@@ -316,7 +316,7 @@ def create_client(exchange_config: Dict[str, Any], *, market_type: str = "swap")
             base_url = default_gate if is_demo else (_get(exchange_config, "base_url", "baseUrl") or default_gate)
             if str(exchange_config.get("api_family") or "").strip().lower() == "stock":
                 if is_demo:
-                    raise LiveTradingError("GATE_STOCK_TESTNET_NOT_SUPPORTED")
+                    raise LiveTradingError("strategyV2.gateStockTestnetUnsupported")
                 return GateStockClient(
                     api_key=api_key,
                     secret_key=secret_key,
 
@@ -66,6 +66,22 @@ def _json_object(value: Any) -> dict[str, Any]:
     return {}
 
 
+def validate_product_account_environment(
+    products: list[dict[str, Any]] | None,
+    exchange_config: dict[str, Any],
+) -> None:
+    from app.services.live_trading.factory import exchange_trading_environment
+
+    has_gate_stock = any(
+        isinstance(product, dict)
+        and str(product.get("exchange_id") or exchange_config.get("exchange_id") or "").lower() == "gate"
+        and str(product.get("api_family") or "").lower() == "stock"
+        for product in products or []
+    )
+    if has_gate_stock and exchange_trading_environment(exchange_config) != "live":
+        raise ValueError("strategyV2.gateStockTestnetUnsupported")
+
+
 def validate_runtime_products(
     products: list[dict[str, Any]] | None,
     *,
 
@@ -62,6 +62,21 @@ def save(self, *, user_id: int, payload: dict[str, Any], strategy_id: int | None
             manifest.metadata(), exchange_id, execution_mode,
             instruments=live_instruments,
         )
+        if execution_mode == "live" and any(
+            item.get("exchange_id") == "gate" and item.get("api_family") == "stock"
+            for item in instrument_products
+        ):
+            from app.services.exchange_execution import resolve_exchange_config
+            from app.services.market.product_catalog import validate_product_account_environment
+
+            account_config = resolve_exchange_config(
+                {"credential_id": credential_id, "exchange_id": exchange_id},
+                user_id=user_id,
+            )
+            try:
+                validate_product_account_environment(instrument_products, account_config)
+            except ValueError as exc:
+                raise StrategyV2ContractError(str(exc)) from exc
         quote_currency = self._validate_live_quote_currency(
             markets=manifest.markets,
             instruments=live_instruments or (
 
@@ -122,13 +122,17 @@ def _preflight_live_strategy(self, strategy_id: int) -> None:
 
         trading_config = _json_object(strategy.get("trading_config"))
         from app.services.exchange_execution import resolve_exchange_config
-        from app.services.market.product_catalog import validate_runtime_products
+        from app.services.market.product_catalog import (
+            validate_product_account_environment,
+            validate_runtime_products,
+        )
 
         exchange_config = resolve_exchange_config(
             _json_object(strategy.get("exchange_config")),
             user_id=user_id,
         )
         exchange_id = str(exchange_config.get("exchange_id") or "").strip().lower()
+        validate_product_account_environment(trading_config.get("instrument_products"), exchange_config)
         validate_runtime_products(
             trading_config.get("instrument_products")
             if isinstance(trading_config.get("instrument_products"), list)
@@ -382,6 +386,9 @@ def _run_strategy_loop(self, strategy_id: int) -> None:
                     trading_config,
                     exchange_id=account_exchange,
                 )
+                from app.services.market.product_catalog import validate_product_account_environment
+
+                validate_product_account_environment(candidates, exchange_config)
 
             frequency = program.manifest.driving_frequency
 
@@ -520,7 +527,6 @@ def runtime_prices() -> dict[str, float]:
                     rest_fallback=runtime_prices,
                 )
                 market_price_feed.start()
-                rest_runtime_prices = runtime_prices
 
                 def runtime_prices() -> dict[str, float]:
                     snapshot = market_price_feed.snapshot(
@@ -533,7 +539,7 @@ def runtime_prices() -> dict[str, float]:
                         "age_ms": snapshot.age_ms,
                         "connected": snapshot.connected,
                     })
-                    return snapshot.prices or rest_runtime_prices()
+                    return snapshot.prices
             state_store = RuntimeStateStore(
                 strategy_id=strategy_id,
                 strategy_run_id=run_id,
 
@@ -6,6 +6,33 @@
 from app.services.market import product_catalog
 
 
+@pytest.mark.parametrize("config", [
+    {"environment": "testnet"}, {"environment": "demo"}, {"sandbox": True},
+    {"use_testnet": True}, {"enableDemoTrading": "true"},
+])
+def test_gate_stock_environment_validation_preserves_account_configuration(config):
+    account = {"exchange_id": "gate", **config}
+    snapshot = dict(account)
+    with pytest.raises(ValueError, match="gateStockTestnetUnsupported"):
+        product_catalog.validate_product_account_environment(
+            [{"exchange_id": "gate", "api_family": "stock"}], account,
+        )
+    assert account == snapshot
+
+
+@pytest.mark.parametrize("exchange,api_family,environment", [
+    ("gate", "stock", "live"), ("gate", "spot", "testnet"),
+    ("gate", "swap", "testnet"), ("binance", "spot", "demo"),
+    ("okx", "swap", "demo"), ("bitget", "spot", "demo"),
+    ("bybit", "swap", "demo"), ("htx", "spot", "live"),
+])
+def test_gate_stock_guard_does_not_change_other_product_environments(exchange, api_family, environment):
+    product_catalog.validate_product_account_environment(
+        [{"exchange_id": exchange, "api_family": api_family}],
+        {"exchange_id": exchange, "environment": environment},
+    )
+
+
 def _manifest(exchange_id="bybit", market_type="spot"):
     return {
         "universe": {
 
@@ -0,0 +1,131 @@
+from types import SimpleNamespace
+from unittest.mock import Mock
+import time
+
+import pandas as pd
+import pytest
+
+from app.services import trading_executor as runtime
+from app.services.live_trading.gate import GateStockClient
+
+
+SYMBOL = "Crypto:NVDA/USD@gate:spot"
+CODE = '''
+def initialize(context):
+    g.symbol = "Crypto:NVDA/USD@gate:spot"
+    context.set_universe([g.symbol])
+    context.subscribe(frequency="1m", fields=["close"])
+    context.set_warmup(50)
+    context.set_benchmark(g.symbol)
+    context.set_metadata(direction_mode="long_only", strategy_family="ema_crossover")
+
+def handle_data(context, data):
+    bars = data.history(g.symbol, count=500, fields=["close"])
+    if len(bars) >= 32:
+        fast = bars.close.ewm(span=10, adjust=False).mean()
+        slow = bars.close.ewm(span=30, adjust=False).mean()
+        if fast.iloc[-1] > slow.iloc[-1] and fast.iloc[-2] <= slow.iloc[-2]:
+            order_target_percent(g.symbol, 0.95)
+'''
+
+
+@pytest.mark.parametrize("account_options", [{}, {"environment": "testnet"}, {"enable_demo_trading": True}])
+def test_gate_stock_complete_live_loop_uses_exchange_quotes(monkeypatch, account_options):
+    product = {
+        "symbol": "NVDA/USD", "exchange_id": "gate", "market_type": "spot",
+        "instrument_id": "NVDA", "product_type": "direct_equity", "api_family": "stock",
+        "underlying_market": "USStock", "underlying_symbol": "NVDA",
+    }
+    strategy = {
+        "id": 1, "user_id": 1, "execution_mode": "live", "initial_capital": 1000,
+        "trading_config": {"instrument_products": [product], "risk_tick_seconds": 0.25},
+        "exchange_config": {"exchange_id": "gate", "api_key": "test", "secret_key": "test", **(account_options or {})},
+    }
+    executor = runtime.TradingExecutor()
+    monkeypatch.setattr(executor, "_load_strategy", lambda _: strategy)
+    monkeypatch.setattr(executor, "_load_source", lambda _: (1, CODE))
+    monkeypatch.setattr(executor, "_load_schedule_timezone", lambda _: "UTC")
+    monkeypatch.setattr(executor, "_positions_by_symbol", lambda *a, **kw: {})
+    monkeypatch.setattr(executor, "_calculate_current_equity", lambda *a, **kw: 1000)
+    submit = Mock(return_value=True)
+    monkeypatch.setattr(executor, "_execute_strategy_v2_intent", submit)
+    cycles = iter([True, True, True, False])
+    monkeypatch.setattr(executor, "_is_strategy_running", lambda *a: next(cycles))
+    heartbeats = []
+    monkeypatch.setattr(executor, "_heartbeat", lambda *a, **kw: heartbeats.append((dict(a[3]), kw)))
+    monkeypatch.setattr(executor, "_mark_stopped", lambda *a: None)
+    logs = []
+    monkeypatch.setattr(runtime, "append_strategy_log", lambda *a: logs.append(a))
+    monkeypatch.setattr(runtime, "ensure_strategy_run", lambda **kw: SimpleNamespace(strategy_run_id=1))
+    monkeypatch.setattr(runtime, "finish_strategy_run", lambda *a, **kw: None)
+    store = Mock()
+    store.load.return_value = {}
+    monkeypatch.setattr(runtime, "RuntimeStateStore", lambda **kw: store)
+    monkeypatch.setattr(runtime, "persist_cancellations", lambda *a: None)
+    monkeypatch.setattr(runtime, "time", SimpleNamespace(monotonic=time.monotonic, sleep=lambda _: None, time=time.time))
+    frame = pd.DataFrame(
+        {"open": 200., "high": 201., "low": 199., "close": 200., "volume": 1.},
+        index=pd.date_range("2026-09-14 14:00", periods=60, freq="min", tz="UTC"),
+    )
+    monkeypatch.setattr(runtime.StrategyV2BacktestService, "fetch_frequency_frames", lambda *a, **kw: ({"1m": {SYMBOL: frame}}, []))
+    request = Mock(return_value=(200, {"data": {"bids": [{"p": "210.1"}], "asks": [{"p": "210.3"}]}}, ""))
+    monkeypatch.setattr(GateStockClient, "_request", request)
+
+    executor._run_strategy_loop(1)
+
+    if account_options:
+        assert executor._last_exit_reason == {1: "strategyV2.gateStockTestnetUnsupported"}
+        assert not heartbeats
+        request.assert_not_called()
+        submit.assert_not_called()
+        assert logs == [(1, "error", "strategyV2.gateStockTestnetUnsupported")]
+        return
+    assert executor._last_exit_reason == {}, logs
+    assert len(heartbeats) == 4, logs
+    assert all(prices.get(SYMBOL) == 210.2 for prices, _ in heartbeats[1:]), logs
+    assert all(meta["status"] == "healthy" for _, meta in heartbeats[1:]), logs
+    assert request.call_count == 3
+
+
+def test_gate_stock_testnet_rejected_before_deployment_is_saved(monkeypatch):
+    from app.services import exchange_execution
+    from app.services.strategy_v2 import deployment
+
+    monkeypatch.setattr(deployment, "get_script_source_service", lambda: SimpleNamespace(
+        get_source=lambda *a, **kw: {"name": "Gate NVDA", "code": CODE},
+    ))
+    monkeypatch.setattr(deployment.StrategyV2DeploymentService, "_credential_exchange", lambda *a: "gate")
+    monkeypatch.setattr(deployment, "get_catalog_product", lambda **kw: {
+        "instrument_id": "NVDA", "api_family": "stock", "product_type": "direct_equity",
+    })
+    resolve = Mock(return_value={"exchange_id": "gate", "environment": "testnet"})
+    monkeypatch.setattr(exchange_execution, "resolve_exchange_config", resolve)
+    database = Mock(side_effect=AssertionError("No deployment should be persisted"))
+    monkeypatch.setattr(deployment, "get_db_connection", database)
+
+    with pytest.raises(deployment.StrategyV2ContractError, match="gateStockTestnetUnsupported"):
+        deployment.StrategyV2DeploymentService().save(user_id=7, payload={
+            "sourceId": 1, "initialCapital": 1000, "credentialId": 23, "executionMode": "live",
+        })
+
+    resolve.assert_called_once_with({"credential_id": 23, "exchange_id": "gate"}, user_id=7)
+    database.assert_not_called()
+
+
+def test_gate_stock_testnet_rejected_before_starting_thread(monkeypatch):
+    from app.services import exchange_execution
+
+    executor = runtime.TradingExecutor()
+    strategy = {
+        "id": 1, "user_id": 7, "execution_mode": "live", "market_type": "spot",
+        "trading_config": {"instrument_products": [{"exchange_id": "gate", "api_family": "stock"}]},
+        "exchange_config": {"credential_id": 23},
+    }
+    monkeypatch.setattr(executor, "_load_strategy", lambda _: strategy)
+    monkeypatch.setattr(exchange_execution, "resolve_exchange_config", lambda *a, **kw: {
+        "exchange_id": "gate", "use_testnet": True,
+    })
+
+    assert executor.start_strategy(1) is False
+    assert executor._last_start_failure == "strategyV2.gateStockTestnetUnsupported"
+    assert not executor.running_strategies