fix: enforce exchange grid quantity rules

Author: Henry

backend_api_python/app/services/grid/engine.py

@@ -1162,6 +1162,7 @@ def _normalize_grid_base_qty(self, qty: float, price: float) -> float:
                 quantity=float(qty),
                 market_type=self.cfg.market_type,
                 exchange_config=self.exchange_config,
+                price=float(price),
             )
         except Exception as e:
             logger.debug("grid normalize qty sid=%s: %s", self.strategy_id, e)

backend_api_python/app/services/grid/exchange_orders.py

@@ -44,7 +44,7 @@ def __iter__(self):
         yield self.avg_price
 
 
-def normalize_grid_order_quantity(
+def _normalize_grid_order_quantity_for_client(
     client: BaseRestClient,
     *,
     symbol: str,
@@ -174,6 +174,94 @@ def normalize_grid_order_quantity(
     return qty
 
 
+def _grid_exchange_id(client: BaseRestClient, exchange_config: Dict[str, Any]) -> str:
+    configured = str(
+        exchange_config.get("exchange_id")
+        or exchange_config.get("exchange")
+        or exchange_config.get("exchangeId")
+        or ""
+    ).strip().lower()
+    aliases = {
+        "gateio": "gate",
+        "gate.io": "gate",
+        "huobi": "htx",
+    }
+    if configured:
+        return aliases.get(configured, configured)
+    if isinstance(client, (BinanceFuturesClient, BinanceSpotClient)):
+        return "binance"
+    if isinstance(client, (BitgetMixClient, BitgetSpotClient)):
+        return "bitget"
+    if isinstance(client, BybitClient):
+        return "bybit"
+    if isinstance(client, (GateUsdtFuturesClient, GateSpotClient)):
+        return "gate"
+    if isinstance(client, HtxClient):
+        return "htx"
+    if isinstance(client, OkxClient):
+        return "okx"
+    return ""
+
+
+def normalize_grid_order_quantity(
+    client: BaseRestClient,
+    *,
+    symbol: str,
+    quantity: float,
+    market_type: str,
+    exchange_config: Optional[Dict[str, Any]] = None,
+    price: float = 0.0,
+) -> float:
+    """Normalize a grid order against both client and native exchange rules.
+
+    The client-specific pass converts contracts to base units where needed.
+    The common rules pass then floors amount precision and rejects quantities
+    below either the exchange minimum amount or minimum order notional.
+    """
+    cfg = exchange_config if isinstance(exchange_config, dict) else {}
+    normalized = _normalize_grid_order_quantity_for_client(
+        client,
+        symbol=symbol,
+        quantity=quantity,
+        market_type=market_type,
+        exchange_config=cfg,
+    )
+    if normalized <= 0:
+        return 0.0
+
+    exchange_id = _grid_exchange_id(client, cfg)
+    if not exchange_id:
+        return normalized
+    try:
+        from app.services.instrument_rules import get_instrument_rules_provider
+
+        rules = get_instrument_rules_provider().get_rules(
+            symbol,
+            exchange_id=exchange_id,
+            market_type=market_type,
+            client=client,
+        )
+        normalized = rules.normalize_amount(normalized, enforce_minimum=True)
+        px = max(0.0, float(price or 0.0))
+        min_notional = max(0.0, float(rules.min_notional or 0.0))
+        if normalized <= 0:
+            return 0.0
+        if px > 0 and min_notional > 0 and normalized * px < min_notional:
+            return 0.0
+        return normalized
+    except Exception as exc:
+        # If native rules cannot be verified, skipping the grid order is safer
+        # than passing an unrounded float to an exchange. The next sync cycle
+        # retries after the provider cache/endpoint recovers.
+        logger.warning(
+            "grid native quantity rules unavailable exchange=%s symbol=%s: %s",
+            exchange_id,
+            symbol,
+            exc,
+        )
+        return 0.0
+
+
 def make_grid_initial_client_order_id(strategy_id: int, leg: str = "") -> str:
     """Stable client oid for grid initial market leg (one per strategy/leg, avoids duplicate opens)."""
     suffix = str(leg or "").strip().lower()[:1]

backend_api_python/tests/test_grid_exchange_requirements.py

@@ -201,6 +201,14 @@ class FakeBitgetClient:
         def get_account_pos_mode(self, **kwargs):
             return "hedge_mode"
 
+        def get_contract(self, **kwargs):
+            return {
+                "sizeMultiplier": "0.0001",
+                "minTradeNum": "0.0001",
+                "contractSize": "1",
+                "priceStep": "0.01",
+            }
+
     placed = []
     monkeypatch.setattr(
         "app.services.live_trading.position_query.query_exchange_position_size",

backend_api_python/tests/test_grid_quantity_normalization.py

@@ -1,5 +1,10 @@
+import pytest
+
+from app.services import instrument_rules
 from app.services.grid.exchange_orders import normalize_grid_order_quantity
-from app.services.live_trading.gate import GateUsdtFuturesClient
+from app.services.instrument_rules import InstrumentRules
+from app.services.live_trading.base import BaseRestClient
+from app.services.live_trading.gate import GateSpotClient, GateUsdtFuturesClient
 from app.services.live_trading.htx import HtxClient
 
 
@@ -47,3 +52,103 @@ def test_htx_futures_never_rounds_sub_contract_quantity_up():
     client.get_contract_info = lambda **_kwargs: {"contract_size": "0.001"}
 
     assert client._base_to_contracts(symbol="BTC/USDT", qty=0.0005) == 0
+
+
+def test_gate_spot_grid_rejects_float_dust_and_floors_native_precision():
+    client = GateSpotClient.__new__(GateSpotClient)
+    client.get_currency_pair = lambda **_kwargs: {
+        "amount_precision": 6,
+        "precision": 2,
+        "min_base_amount": "0.0001",
+        "min_quote_amount": "1",
+    }
+
+    assert normalize_grid_order_quantity(
+        client,
+        symbol="BTC/USDT",
+        quantity=3.3532799999999997e-07,
+        market_type="spot",
+        price=100_000,
+    ) == 0.0
+    assert normalize_grid_order_quantity(
+        client,
+        symbol="BTC/USDT",
+        quantity=0.0001239,
+        market_type="spot",
+        price=100_000,
+    ) == pytest.approx(0.000123)
+
+
+def test_htx_spot_grid_rejects_float_dust_and_minimum_notional():
+    client = HtxClient.__new__(HtxClient)
+    client.get_spot_symbol_info = lambda **_kwargs: {
+        "amount-precision": 6,
+        "price-precision": 2,
+        "min-order-amt": "0.0001",
+        "min-order-value": "1",
+    }
+
+    assert normalize_grid_order_quantity(
+        client,
+        symbol="BTC/USDT",
+        quantity=3.3532799999999997e-07,
+        market_type="spot",
+        price=100_000,
+    ) == 0.0
+    assert normalize_grid_order_quantity(
+        client,
+        symbol="BTC/USDT",
+        quantity=0.0001,
+        market_type="spot",
+        price=5_000,
+    ) == 0.0
+
+
+@pytest.mark.parametrize("exchange_id", ["binance", "okx", "bitget", "bybit", "gate", "htx"])
+@pytest.mark.parametrize("market_type", ["spot", "swap"])
+def test_all_grid_exchanges_apply_common_minimum_rules(
+    monkeypatch,
+    exchange_id,
+    market_type,
+):
+    rules = InstrumentRules(
+        key=f"Crypto:BTC/USDT@{exchange_id}:{market_type}",
+        exchange_id=exchange_id,
+        market_type=market_type,
+        symbol="BTC/USDT",
+        amount_step=0.001,
+        min_amount=0.01,
+        min_notional=5.0,
+    )
+
+    class FakeProvider:
+        def get_rules(self, *_args, **_kwargs):
+            return rules
+
+    monkeypatch.setattr(instrument_rules, "get_instrument_rules_provider", lambda: FakeProvider())
+    client = BaseRestClient("https://example.invalid")
+
+    assert normalize_grid_order_quantity(
+        client,
+        symbol="BTC/USDT",
+        quantity=0.0099,
+        market_type=market_type,
+        exchange_config={"exchange_id": exchange_id},
+        price=1_000,
+    ) == 0.0
+    assert normalize_grid_order_quantity(
+        client,
+        symbol="BTC/USDT",
+        quantity=0.0129,
+        market_type=market_type,
+        exchange_config={"exchange_id": exchange_id},
+        price=100,
+    ) == 0.0
+    assert normalize_grid_order_quantity(
+        client,
+        symbol="BTC/USDT",
+        quantity=0.1239,
+        market_type=market_type,
+        exchange_config={"exchange_id": exchange_id},
+        price=100,
+    ) == pytest.approx(0.123)