fix: complete stock trading and backtest contracts

Author: tianhe

backend_api_python/app/services/ai_generation_contracts.py

@@ -4,7 +4,7 @@
 ## Exchange-routed equity product contract
 - Preserve the complete canonical instrument returned by product discovery, including leading zeros, quote or settlement currency, exchange, and market type. Examples are `Crypto:00700/HKD@gate:spot`, `Crypto:AAPL/USD@gate:spot`, and a catalog-confirmed Binance Hong Kong equity perpetual such as `Crypto:HK0700/USDT@binance:swap`.
 - The `Crypto` prefix is the exchange-routing namespace; it does not assert that the underlying asset is cryptocurrency. The catalog distinguishes `direct_equity`, `tokenized_equity`, `stock_perpetual`, and ordinary `crypto` products and records an API family for execution.
-- Current venue families are exact: Binance supports `stock_perpetual/swap/swap`; OKX and Bybit support `tokenized_equity/spot/spot` plus `stock_perpetual/swap/swap`; Bitget supports `tokenized_equity/spot/reality` plus `stock_perpetual/swap/swap`; Gate supports `direct_equity/spot/stock` plus `stock_perpetual/swap/swap`; HTX equity products remain disabled until authoritative product metadata and an execution contract are verified.
+- Current venue families are exact: Binance, OKX, and Bybit support `tokenized_equity/spot/spot` plus `stock_perpetual/swap/swap`; Bitget supports `tokenized_equity/spot/reality` plus `stock_perpetual/swap/swap`; Gate supports `direct_equity/spot/stock` plus `stock_perpetual/swap/swap`; HTX equity products remain disabled until authoritative product metadata and an execution contract are verified.
 - Product identity and execution eligibility come from the active exchange product catalog. Do not infer a direct equity, tokenized equity, stock perpetual, venue, region, currency, or native instrument ID from ticker spelling alone, and do not manufacture catalog metadata in strategy source. When a venue does not expose authoritative equity metadata, keep the product unsupported rather than guessing.
 - Gate Tencent uses `Crypto:00700/HKD@gate:spot` with `direct_equity/spot/stock` and maps to `HKStock:00700`; Gate Apple uses `Crypto:AAPL/USD@gate:spot` and maps to `USStock:AAPL`. Find them with exchange Gate, market type Spot, and product type Direct Equity, then select the exact returned product.
 - A catalog-confirmed Binance Hong Kong equity perpetual such as `Crypto:HK0700/USDT@binance:swap` uses `stock_perpetual/swap/swap` and may map to `HKStock:00700`. It is a derivative settled under the venue contract, not direct ownership of the Hong Kong share. Do not rewrite it as Gate spot, `HKStock:00700.HK`, or a differently named Binance contract.

backend_api_python/app/services/live_trading/capabilities.py

@@ -30,8 +30,11 @@ def supports_swap(self) -> bool:
 CRYPTO_VENUE_CAPABILITIES: Dict[str, VenueCapability] = {
     "binance": VenueCapability(
         "binance", frozenset({"spot", "swap"}),
-        equity_product_types=frozenset({"stock_perpetual"}),
-        equity_api_families=frozenset({("stock_perpetual", "swap", "swap")}),
+        equity_product_types=frozenset({"tokenized_equity", "stock_perpetual"}),
+        equity_api_families=frozenset({
+            ("tokenized_equity", "spot", "spot"),
+            ("stock_perpetual", "swap", "swap"),
+        }),
     ),
     "okx": VenueCapability(
         "okx", frozenset({"spot", "swap"}),

backend_api_python/app/services/market/instrument_products.py

@@ -4,7 +4,7 @@
 
 import re
 from dataclasses import asdict, dataclass
-from typing import Any, Mapping
+from typing import Any, Collection, Mapping
 
 
 PRODUCT_CRYPTO = "crypto"
@@ -35,15 +35,15 @@ def classify_instrument_product(
     market_type: str = "spot",
     symbol: str = "",
     instrument_id: str = "",
+    known_equity_symbols: Collection[str] | None = None,
 ) -> InstrumentProductProfile:
     """Build a conservative product profile from exchange instrument metadata.
 
     The classifier only promotes a symbol to an equity product when the venue
-    returns an explicit product flag. Bitget Reality is the sole fallback: its
-    public catalog currently omits ``isReality`` in some CCXT versions, while
-    the venue-defined ``R<TICKER>`` convention and ``areaSymbol=yes`` remain
-    available. Unknown instruments stay ordinary crypto and therefore remain
-    outside equity-product live feature gates.
+    returns an explicit product flag. Bitget Reality also accepts its venue
+    marker, while Binance bStocks require both the venue suffix and a matching
+    reference equity symbol. Unknown instruments stay ordinary crypto and
+    therefore remain outside equity-product live feature gates.
     """
 
     unified = dict(info or {})
@@ -63,7 +63,18 @@ def classify_instrument_product(
             and _looks_like_bitget_reality_base(base)
         )
     )
-    is_equity_product = explicit_equity or bitget_reality
+    known_equities = {
+        str(value or "").strip().upper()
+        for value in (known_equity_symbols or ())
+        if str(value or "").strip()
+    }
+    binance_bstock = (
+        exchange == "binance"
+        and mt == "spot"
+        and base.endswith("B")
+        and base[:-1] in known_equities
+    )
+    is_equity_product = explicit_equity or bitget_reality or binance_bstock
 
     if is_equity_product and mt == "swap":
         product_type = PRODUCT_STOCK_PERPETUAL

backend_api_python/app/services/market/product_catalog.py

@@ -27,7 +27,7 @@ def get_catalog_product(
         clauses.append("market_type = ?")
         params.append(str(market_type).strip().lower())
     if instrument_id:
-        clauses.append("instrument_id = ?")
+        clauses.append("UPPER(instrument_id) = UPPER(?)")
         params.append(str(instrument_id).strip())
 
     with get_db_connection() as db:

backend_api_python/app/services/market_catalog_sync.py

@@ -8,6 +8,7 @@
 
 from app.services.symbol_master_sync import (
     fetch_crypto_symbols_with_diagnostics,
+    reclassify_stored_equity_products,
     upsert_symbol_master,
 )
 from app.utils.db import get_db_connection
@@ -17,7 +18,7 @@
 logger = get_logger(__name__)
 _thread_lock = threading.Lock()
 _worker = None
-MARKET_CATALOG_SCHEMA_VERSION = 2
+MARKET_CATALOG_SCHEMA_VERSION = 3
 
 
 def _json_value(value):
@@ -81,13 +82,15 @@ def _run_sync(run_id: int) -> None:
     try:
         rows, contexts = fetch_crypto_symbols_with_diagnostics()
         written = upsert_symbol_master(rows) if rows else 0
+        reclassified = reclassify_stored_equity_products()
         succeeded = sum(1 for item in contexts if item.get("ok"))
         failed = len(contexts) - succeeded
         status = "success" if failed == 0 else ("partial" if succeeded else "failed")
         _finish_run(run_id, status, {
             "catalog_schema_version": MARKET_CATALOG_SCHEMA_VERSION,
             "rows": len(rows),
             "upserted": written,
+            "reclassified": reclassified,
             "contexts_total": len(contexts),
             "contexts_succeeded": succeeded,
             "contexts_failed": failed,
@@ -198,7 +201,20 @@ def get_market_catalog_overview() -> dict:
                        COUNT(*) FILTER (WHERE is_active = 1) AS active,
                        COUNT(DISTINCT symbol) FILTER (WHERE is_active = 1) AS symbols,
                        COUNT(*) FILTER (WHERE is_active = 1 AND asset_class = 'equity') AS equities,
-                       COUNT(*) FILTER (WHERE is_active = 1 AND asset_class = 'rwa') AS rwa
+                       COUNT(*) FILTER (WHERE is_active = 1 AND asset_class = 'rwa') AS rwa,
+                       COUNT(*) FILTER (
+                           WHERE is_active = 1 AND market_type = 'spot'
+                             AND COALESCE(product_type, 'crypto') = 'crypto'
+                       ) AS ordinary_spot,
+                       COUNT(*) FILTER (
+                           WHERE is_active = 1 AND product_type = 'tokenized_equity'
+                       ) AS tokenized_equity,
+                       COUNT(*) FILTER (
+                           WHERE is_active = 1 AND product_type = 'direct_equity'
+                       ) AS direct_equity,
+                       COUNT(*) FILTER (
+                           WHERE is_active = 1 AND product_type = 'stock_perpetual'
+                       ) AS stock_perpetual
                   FROM qd_market_symbols
                  WHERE market = 'Crypto' AND exchange <> ''
                  GROUP BY LOWER(exchange), market_type
@@ -211,7 +227,20 @@ def get_market_catalog_overview() -> dict:
                 SELECT COUNT(*) FILTER (WHERE is_active = 1) AS active,
                        COUNT(DISTINCT symbol) FILTER (WHERE is_active = 1) AS symbols,
                        COUNT(*) FILTER (WHERE is_active = 1 AND asset_class = 'equity') AS equities,
-                       COUNT(*) FILTER (WHERE is_active = 1 AND asset_class = 'rwa') AS rwa
+                       COUNT(*) FILTER (WHERE is_active = 1 AND asset_class = 'rwa') AS rwa,
+                       COUNT(*) FILTER (
+                           WHERE is_active = 1 AND market_type = 'spot'
+                             AND COALESCE(product_type, 'crypto') = 'crypto'
+                       ) AS ordinary_spot,
+                       COUNT(*) FILTER (
+                           WHERE is_active = 1 AND product_type = 'tokenized_equity'
+                       ) AS tokenized_equity,
+                       COUNT(*) FILTER (
+                           WHERE is_active = 1 AND product_type = 'direct_equity'
+                       ) AS direct_equity,
+                       COUNT(*) FILTER (
+                           WHERE is_active = 1 AND product_type = 'stock_perpetual'
+                       ) AS stock_perpetual
                   FROM qd_market_symbols
                  WHERE market = 'Crypto'
                 """

backend_api_python/app/services/script_source.py

@@ -12,6 +12,7 @@
 import time
 from typing import Any, Dict, List, Optional
 
+from app.services.strategy_params import canonical_strategy_param_schema
 from app.utils.db import get_db_connection
 from app.utils.logger import get_logger
 
@@ -249,7 +250,10 @@ def create_source(self, payload: Dict[str, Any]) -> int:
         code = str(payload.get("code") or "")
         description = str(payload.get("description") or "")
         template_key = str(payload.get("template_key") or payload.get("templateKey") or "")
-        param_schema = payload.get("param_schema") or payload.get("paramSchema") or {}
+        param_schema = canonical_strategy_param_schema(
+            code,
+            payload.get("param_schema") or payload.get("paramSchema") or {},
+        )
         metadata = payload.get("metadata") or {}
         asset_type = _source_asset_type(payload.get("asset_type") or payload.get("assetType"))
         source_marketplace_indicator_id = payload.get("source_marketplace_indicator_id") or payload.get("sourceMarketplaceIndicatorId")
@@ -304,7 +308,12 @@ def update_source(self, source_id: int, user_id: int, payload: Dict[str, Any]) -
         code = str(payload.get("code") if payload.get("code") is not None else existing.get("code") or "")
         description = str(payload.get("description") if payload.get("description") is not None else existing.get("description") or "")
         template_key = str(payload.get("template_key") or payload.get("templateKey") or existing.get("template_key") or "")
-        param_schema = payload.get("param_schema") if "param_schema" in payload else payload.get("paramSchema", existing.get("param_schema") or {})
+        param_schema = canonical_strategy_param_schema(
+            code,
+            payload.get("param_schema")
+            if "param_schema" in payload
+            else payload.get("paramSchema", existing.get("param_schema") or {}),
+        )
         metadata = payload.get("metadata") if "metadata" in payload else existing.get("metadata") or {}
         asset_type = _source_asset_type(
             payload.get("asset_type") if "asset_type" in payload

backend_api_python/app/services/strategy_authoring.py

@@ -138,6 +138,19 @@ def get_strategy_authoring_contract() -> dict[str, Any]:
                 "underlying_symbol": "00700",
                 "catalog_validation_required": True,
                 "direct_share_ownership": False,
+            }, {
+                "instrument": "Crypto:NVDAB/USDT@binance:spot",
+                "market": "Crypto",
+                "symbol": "NVDAB/USDT",
+                "exchange_id": "binance",
+                "market_type": "spot",
+                "asset_class": "equity",
+                "product_type": "tokenized_equity",
+                "api_family": "spot",
+                "underlying_market": "USStock",
+                "underlying_symbol": "NVDA",
+                "catalog_validation_required": True,
+                "direct_share_ownership": False,
             }],
             "discovery_filters": {
                 "required": ["exchange_id", "market_type", "product_type"],
@@ -153,6 +166,12 @@ def get_strategy_authoring_contract() -> dict[str, Any]:
                     "product_type": "stock_perpetual",
                     "search_examples": ["HK0700", "TENCENT"],
                 },
+                "binance_bstock": {
+                    "exchange_id": "binance",
+                    "market_type": "spot",
+                    "product_type": "tokenized_equity",
+                    "search_examples": ["NVDAB", "AAPLB"],
+                },
             },
             "venue_capabilities": {
                 exchange_id: [

backend_api_python/app/services/strategy_params.py

@@ -0,0 +1,69 @@
+"""Canonical parameter schema for Strategy API V2 source code."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from app.services.indicator_params import IndicatorParamsParser
+
+
+_TYPE_MAP = {
+    "int": "integer",
+    "float": "number",
+    "bool": "boolean",
+    "str": "text",
+    "string": "text",
+}
+
+
+def canonical_strategy_param_schema(
+    code: str,
+    schema: dict[str, Any] | None = None,
+) -> dict[str, Any]:
+    """Make declared ``# @param`` defaults authoritative for saved sources."""
+    existing = dict(schema or {})
+    declared = IndicatorParamsParser.parse_params(code or "")
+    if not declared:
+        return existing
+
+    existing_rows = existing.get("params")
+    previous_by_name = {
+        str(item.get("name") or ""): dict(item)
+        for item in (existing_rows if isinstance(existing_rows, list) else [])
+        if isinstance(item, dict) and str(item.get("name") or "")
+    }
+    params: list[dict[str, Any]] = []
+    for declaration in declared:
+        name = str(declaration.get("name") or "")
+        row = previous_by_name.get(name, {})
+        declared_type = str(declaration.get("type") or "").lower()
+        previous_type = str(row.get("type") or "").lower()
+        compatible_types = {
+            "int": {"int", "integer"},
+            "float": {"float", "number", "percent"},
+            "bool": {"bool", "boolean"},
+            "str": {"str", "string", "text"},
+        }
+        row.update({
+            "name": name,
+            "type": (
+                previous_type
+                if previous_type in compatible_types.get(declared_type, set())
+                else _TYPE_MAP.get(declared_type, declared_type or "text")
+            ),
+            "default": declaration.get("default"),
+            "source": "code_param",
+        })
+        description = str(declaration.get("description") or "").strip()
+        if description:
+            row["description"] = description
+        if row["type"] == "integer":
+            row.setdefault("step", 1)
+        elif row["type"] == "number":
+            row.setdefault("step", 0.1)
+        values = declaration.get("values")
+        if isinstance(values, list) and values:
+            row["values"] = list(values)
+        params.append(row)
+
+    return {**existing, "params": params}

backend_api_python/app/services/strategy_runtime/timeframes.py

@@ -19,11 +19,27 @@
 from app.services.strategy_v2.service import StrategyV2BacktestService
 
 
-def live_history_days(frequency: str, warmup_bars: int) -> int:
+def live_history_days(
+    frequency: str,
+    warmup_bars: int,
+    candidates: list[dict[str, object]] | tuple = (),
+) -> int:
     """Return a frequency-aware live lookback with a startup buffer."""
     bars = max(10, max(1, int(warmup_bars or 0)) * 3)
     seconds = frequency_seconds(frequency) * bars
-    return max(1, int(math.ceil(seconds / 86_400)))
+    days = max(1, int(math.ceil(seconds / 86_400)))
+    normalized = str(frequency or "").strip().lower()
+    stock_session = any(
+        str(item.get("market") or "") in {"USStock", "HKStock", "CNStock", "AStock"}
+        or str(item.get("underlying_market") or "") in {"USStock", "HKStock", "CNStock", "AStock"}
+        or str(item.get("api_family") or "").strip().lower() == "stock"
+        for item in candidates
+    )
+    if stock_session and normalized.endswith(("m", "h")):
+        hours = float(normalized[:-1]) / (60 if normalized.endswith("m") else 1)
+        session_days = math.ceil(max(1, warmup_bars) * 3 * hours / 4 * 7 / 5 * 1.5)
+        days = max(days, 7, session_days)
+    return days
 
 
 def completed_bar_token(frequency: str, now: datetime | None = None) -> int:
@@ -46,7 +62,7 @@ def load_live_frequency_frames(
     """Load a complete live frame bundle for all declared strategy timeframes."""
     start_dates = {
         frequency: end_date
-        - timedelta(days=live_history_days(frequency, manifest.warmup_bars))
+        - timedelta(days=live_history_days(frequency, manifest.warmup_bars, candidates))
         for frequency in manifest.frequencies
     }
     bundles, skipped = service.fetch_frequency_frames(