PINK: S1 leverage cache, S2 background refresh, Gap 1/2/3 fee+slippage logging
S1 — Leverage cache (bingx_direct.py):
_ensure_leverage(): per-symbol asyncio.Lock + cached value check; skips ~350ms
POST when exchange already has the requested leverage. Saves ~350ms/trade.
Cache updated ONLY on success; failed POST leaves cache stale → correct retry.
Persist: JSON sidecar /tmp/.bingx_leverage_cache_{env}.json; survives restarts.
connect(): _verify_leverage_drift() detects when another process changed leverage
at the exchange and updates cache to exchange truth (logs WARNING on drift).
Multi-runner contract: leverage is account-level on BingX; documented that
concurrent runners with different leverage desires for same symbol conflict.
20 mock tests: same-lev skip, change-triggers-POST, failure-no-cache-update,
concurrent-same-symbol (lock prevents race), drift-detect, persist/restore,
multi-runner known-limitation documentation test.
S2 — Background state refresh (bingx_direct.py):
MARKET fills: asyncio.create_task(_refresh_state_background) — does not block
submit path. WS FILL_SETTLED + ACCOUNT_UPDATE deliver capital truth anyway.
LIMIT fills: synchronous refresh retained (include_history=False, not True) —
needed to detect resting order state for next pump cycle.
Saves ~600–900ms/trade on MARKET exits. ENTER similarly improved.
Gap 1 — VenueEvent friction fields (contracts.py):
Added: fee, fee_asset, fee_source, is_maker, exchange_ts, slippage_bps,
mark_at_submit — all with defaults so existing callers are unaffected.
Detailed inline docs for sign conventions and provenance codes.
Gap 2 — Fee estimation + WS_SETTLED provenance (bingx_direct.py, pink_clickhouse.py):
submit_intent: estimates fee from fill_price × fill_qty × taker/maker rate;
annotates ack_row with _fee_estimated, _fee_source, _is_maker_est.
persist_fee_settled(): new method writes fee_settled_events row when WS
ORDER_TRADE_UPDATE delivers actual commission ("n" field); fee_source="WS_SETTLED".
pink_direct._run_account_stream: calls persist_fee_settled on FILL_SETTLED.
Gap 3 — Slippage measurement (bingx_direct.py, bingx_venue.py, pink_clickhouse.py):
Captures mark_at_submit before the order POST; computes slippage_bps signed
by side: positive = adverse (taker overpaid / maker undersold), negative =
price improvement. Measured for BOTH taker and maker fills for symmetry.
Flows through VenueEvent → trade_events.slippage_bps + trade_exit_legs.slippage_bps.
S3 / SOR — Maker order placement: comprehensive TODO block in submit_intent with:
SHORT/LONG-aware price offset design, OBF integration requirements,
TODO_ADD_PARAMSET_VIBRISS for spread_bps threshold, intelligent timeout_s
calibration requirements, price-impact awareness gap, SOR abstraction CRITICAL TODO.
REST/WS split: documented why BingX (and all retail venues) separate these
and why a unified VenueAdapter protocol is the long-term solution.
151/151 existing tests green + 20 new leverage cache tests = 171 total.
Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
This commit is contained in:
Codex
@@ -10,11 +10,13 @@ import asyncio
|
||||
import json
|
||||
import logging
|
||||
import math
|
||||
import time
|
||||
import uuid
|
||||
from dataclasses import dataclass
|
||||
from dataclasses import dataclass, field
|
||||
from datetime import datetime, timezone
|
||||
from decimal import Decimal, ROUND_DOWN
|
||||
from typing import Any, Optional
|
||||
from pathlib import Path
|
||||
from typing import Any, Dict, Optional, Tuple
|
||||
|
||||
from nautilus_trader.model.identifiers import InstrumentId
|
||||
|
||||
@@ -194,6 +196,37 @@ class BingxDirectExecutionAdapter(ExecutionPort):
|
||||
self._state: ExchangeStateSnapshot | None = None
|
||||
self._connected = False
|
||||
|
||||
# ── S1: Leverage cache ────────────────────────────────────────────────
|
||||
# Maps symbol → last successfully set leverage (int).
|
||||
# Avoids a ~350ms leverage POST before every order when leverage is unchanged.
|
||||
#
|
||||
# Cache key is symbol only (not runner_id) because leverage is an
|
||||
# ACCOUNT-LEVEL setting on BingX — one value per symbol per account.
|
||||
# IMPORTANT CONTRACT: if multiple runners share this account and request
|
||||
# DIFFERENT leverages for the same symbol concurrently, the last writer
|
||||
# wins at the exchange and the other runner's order executes at wrong
|
||||
# leverage. Callers MUST ensure leverage is uniform across runners for
|
||||
# any given symbol when sharing an account, or use separate accounts.
|
||||
# This cache only eliminates the redundant round-trip; it cannot resolve
|
||||
# the underlying multi-runner semantic conflict.
|
||||
#
|
||||
# Per-symbol asyncio.Lock: prevents concurrent submit_intent calls for the
|
||||
# same symbol from interleaving leverage POST + cache update, which would
|
||||
# create a window where the cache says "leverage set" but the POST hasn't
|
||||
# completed yet. Lock scope is deliberately tight (only the POST + cache
|
||||
# write), not the entire submit_intent, to avoid head-of-line blocking.
|
||||
self._leverage_cache: Dict[str, int] = {}
|
||||
self._leverage_locks: Dict[str, asyncio.Lock] = {}
|
||||
# Persist path: survives process restarts within a session, not across
|
||||
# reboots (leverage should be re-verified from exchange on cold start).
|
||||
env_tag = "live" if getattr(self._config, "environment", None) and \
|
||||
str(getattr(self._config, "environment", "")).upper() == "LIVE" else "vst"
|
||||
self._leverage_cache_path = Path(f"/tmp/.bingx_leverage_cache_{env_tag}.json")
|
||||
self._load_leverage_cache()
|
||||
|
||||
# ── S2: Background state refresh tracking ─────────────────────────────
|
||||
self._state_refreshed_at: float = 0.0 # monotonic seconds
|
||||
|
||||
@property
|
||||
def state(self) -> ExchangeStateSnapshot | None:
|
||||
return self._state
|
||||
@@ -202,12 +235,122 @@ class BingxDirectExecutionAdapter(ExecutionPort):
|
||||
await self._provider.initialize()
|
||||
self._connected = True
|
||||
self._state = await self.refresh_state()
|
||||
# S4/S1: on reconnect, verify cached leverage matches exchange truth.
|
||||
# Drift happens when another process/runner changed leverage on the same account.
|
||||
await self._verify_leverage_drift()
|
||||
return True
|
||||
|
||||
async def disconnect(self) -> None:
|
||||
self._connected = False
|
||||
await self._client.close()
|
||||
|
||||
# ── S1: Leverage cache helpers ────────────────────────────────────────────
|
||||
|
||||
def _load_leverage_cache(self) -> None:
|
||||
"""Load persisted leverage cache from JSON sidecar. Ignores errors."""
|
||||
try:
|
||||
raw = json.loads(self._leverage_cache_path.read_text())
|
||||
self._leverage_cache = {
|
||||
str(k): int(v)
|
||||
for k, v in raw.items()
|
||||
if isinstance(v, (int, float)) and math.isfinite(float(v)) and float(v) >= 1
|
||||
}
|
||||
LOGGER.debug("leverage cache loaded: %s", self._leverage_cache)
|
||||
except Exception:
|
||||
self._leverage_cache = {}
|
||||
|
||||
def _persist_leverage_cache(self) -> None:
|
||||
"""Flush leverage cache to JSON sidecar. Non-fatal on failure."""
|
||||
try:
|
||||
self._leverage_cache_path.write_text(
|
||||
json.dumps(self._leverage_cache, indent=2)
|
||||
)
|
||||
except Exception as exc:
|
||||
LOGGER.warning("leverage cache persist failed: %s", exc)
|
||||
|
||||
async def _ensure_leverage(self, symbol: str, leverage: int) -> bool:
|
||||
"""Set leverage for symbol only if the cached value differs.
|
||||
|
||||
Returns True if a POST was made (leverage was changed), False if skipped.
|
||||
The asyncio.Lock per symbol ensures concurrent submit_intent calls for the
|
||||
same symbol never interleave leverage POST and cache update — preventing
|
||||
the heisenbug where two orders both think they set leverage but one runs
|
||||
at the wrong value because the other's POST arrived last.
|
||||
|
||||
Cache is updated ONLY on successful POST. A failed POST leaves the cache
|
||||
stale, so the next submit retries — correct conservative behaviour.
|
||||
"""
|
||||
lock = self._leverage_locks.setdefault(symbol, asyncio.Lock())
|
||||
async with lock:
|
||||
cached = self._leverage_cache.get(symbol)
|
||||
if cached == leverage:
|
||||
return False # exchange already at requested value — skip POST
|
||||
|
||||
try:
|
||||
await self._client.signed_post(
|
||||
"/openApi/swap/v2/trade/leverage",
|
||||
{"symbol": symbol, "side": "BOTH", "leverage": leverage},
|
||||
)
|
||||
prev = self._leverage_cache.get(symbol)
|
||||
self._leverage_cache[symbol] = leverage
|
||||
self._persist_leverage_cache()
|
||||
LOGGER.info(
|
||||
"leverage SET symbol=%s %s→%d",
|
||||
symbol, f"{prev}→" if prev is not None else "", leverage,
|
||||
)
|
||||
return True
|
||||
except Exception as exc:
|
||||
LOGGER.warning(
|
||||
"leverage POST failed symbol=%s lev=%d: %s — "
|
||||
"cache NOT updated, will retry on next submit",
|
||||
symbol, leverage, exc,
|
||||
)
|
||||
return False # do NOT cache — retry guarantees correctness
|
||||
|
||||
async def _verify_leverage_drift(self) -> None:
|
||||
"""On connect/reconnect, compare cached leverage with exchange reality.
|
||||
|
||||
Drift occurs when another process or runner changed leverage on the same
|
||||
account while this adapter was offline. Log it loudly; update cache to
|
||||
exchange truth so next submit does not re-set to the wrong value.
|
||||
"""
|
||||
for symbol, cached_lev in list(self._leverage_cache.items()):
|
||||
try:
|
||||
resp = await self._client.signed_get(
|
||||
"/openApi/swap/v2/trade/leverage", {"symbol": symbol}
|
||||
)
|
||||
exchange_lev = int(
|
||||
float(resp.get("longLeverage") or resp.get("leverage") or 0)
|
||||
)
|
||||
if exchange_lev > 0 and exchange_lev != cached_lev:
|
||||
LOGGER.warning(
|
||||
"LEVERAGE DRIFT symbol=%s cached=%d exchange=%d — "
|
||||
"another process may have changed it; cache updated to exchange truth",
|
||||
symbol, cached_lev, exchange_lev,
|
||||
)
|
||||
self._leverage_cache[symbol] = exchange_lev
|
||||
except Exception as exc:
|
||||
LOGGER.debug("leverage drift check failed symbol=%s: %s", symbol, exc)
|
||||
self._persist_leverage_cache()
|
||||
|
||||
# ── S2: Background state refresh ─────────────────────────────────────────
|
||||
|
||||
async def _refresh_state_background(self, symbol: str) -> None:
|
||||
"""Background task: refresh internal state after a synchronous MARKET fill.
|
||||
|
||||
MARKET fills deliver fill_price / executedQty in the ACK; capital and
|
||||
position truth arrive via WS FILL_SETTLED + ACCOUNT_UPDATE. This REST
|
||||
poll is belt-and-suspenders — catches edge cases such as unexpected
|
||||
concurrent fills or exchange position ledger lag. It does not block the
|
||||
submit path.
|
||||
"""
|
||||
try:
|
||||
self._state = await self._refresh_exchange_state(symbol, include_history=False)
|
||||
self._state_refreshed_at = time.monotonic()
|
||||
LOGGER.debug("background state refresh complete symbol=%s", symbol)
|
||||
except Exception as exc:
|
||||
LOGGER.warning("background state refresh failed symbol=%s: %s", symbol, exc)
|
||||
|
||||
def _resolve_instrument(self, asset: str):
|
||||
normalized = _normalize_symbol(asset)
|
||||
candidates = [
|
||||
@@ -354,13 +497,65 @@ class BingxDirectExecutionAdapter(ExecutionPort):
|
||||
async def refresh_state(self, symbol: str | None = None, *, include_history: bool = False) -> ExchangeStateSnapshot:
|
||||
return await self._refresh_exchange_state(symbol, include_history=include_history)
|
||||
|
||||
# ── S3 — Maker order placement (CRITICAL TODO) ────────────────────────────
|
||||
# Currently all orders are MARKET (taker, 0.04% fee). For exits especially,
|
||||
# a LIMIT order at bid+1tick (SHORT close) or ask-1tick (LONG close) with
|
||||
# reduceOnly=true can fill as maker (0.02% fee) — 50% fee saving per trade.
|
||||
#
|
||||
# Design requirements before this is safe to enable:
|
||||
#
|
||||
# 1. SHORT/LONG awareness (CRITICAL):
|
||||
# SHORT close → BUY side → LIMIT at bid+1tick (slightly above bid to rest on book)
|
||||
# LONG close → SELL side → LIMIT at ask-1tick
|
||||
# SHORT enter → SELL side → LIMIT at ask-1tick (only if signal allows waiting)
|
||||
# LONG enter → BUY side → LIMIT at bid+1tick
|
||||
#
|
||||
# 2. OBF integration: the OBF subsystem tracks order book depth and emits
|
||||
# spread guidance. Use OBF.spread_bps and OBF.bid_depth / ask_depth to
|
||||
# decide whether a maker order is viable (tight spread = fast fill,
|
||||
# thin book = price impact of own order too large).
|
||||
#
|
||||
# 3. TODO_ADD_PARAMSET_VIBRISS: The "calm market" threshold (currently
|
||||
# hardcoded as spread_bps < 5) MUST be VIBRISS-calibrated. VIBRISS
|
||||
# governs our own assessment of market microstructure quality. Some
|
||||
# invariants may remain hardcoded (e.g. "never use maker if spread > 50bps")
|
||||
# but the normal operating range should be a VIBRISS metaparameter.
|
||||
# See: prod/vibriss/ for the param-set schema.
|
||||
#
|
||||
# 4. Timeout calibration: timeout_s cannot be a fixed constant. It must
|
||||
# reflect: (a) the strategy's max adverse excursion budget for the position,
|
||||
# (b) the expected fill velocity from OBF order-flow data, (c) the remaining
|
||||
# time before the signal's max_hold threshold. A resting limit that misses
|
||||
# its cancel window creates an orphaned order — a hard risk control failure.
|
||||
#
|
||||
# 5. Price impact awareness (future, not yet operational):
|
||||
# For large notionals, our own LIMIT order changes the book. At some notional
|
||||
# threshold, the maker price improvement is eaten by the impact of our own
|
||||
# resting order. The OBF subsystem must estimate this before we switch from
|
||||
# MARKET to LIMIT. This is the "price impact of our own order" problem.
|
||||
#
|
||||
# CRITICAL TODO: Abstraction. The entire order placement logic (MARKET/LIMIT/
|
||||
# TWAP/VWAP/Iceberg, maker/taker selection, price impact estimation, timeout/
|
||||
# fallback, cancel-replace) MUST eventually be a dedicated "Smart Order Router"
|
||||
# (SOR) subsystem. submit_intent() should be a thin dispatcher into the SOR,
|
||||
# not a monolith. This is a pre-condition for multi-venue support, co-location
|
||||
# optimisation, and regulatory reporting.
|
||||
#
|
||||
# GAP in characterisation: why does BingX separate REST (order placement) from
|
||||
# WS (fill events)? Almost certainly historical: REST came first for audit-
|
||||
# trail reasons (HMAC-signed requests → deterministic replay), WS push came
|
||||
# later for low-latency fills. The FIX protocol unifies these under one
|
||||
# connection — that is the right long-term model and the reason venue-agnostic
|
||||
# abstraction via the VenueAdapter protocol is critical. Any future venue
|
||||
# (Bybit, OKX, Binance) will have the same REST/WS split.
|
||||
# ─────────────────────────────────────────────────────────────────────────
|
||||
|
||||
async def submit_intent(self, intent: Intent) -> ExecutionReceipt:
|
||||
symbol = self._instrument_venue_symbol(intent.asset)
|
||||
if intent.action == DecisionAction.EXIT:
|
||||
side = "SELL" if intent.side == TradeSide.LONG else "BUY"
|
||||
else:
|
||||
side = "BUY" if intent.side == TradeSide.LONG else "SELL"
|
||||
# Entries must be free to open the slot; only exits are reduce-only.
|
||||
reduce_only = bool(intent.action == DecisionAction.EXIT)
|
||||
if reduce_only:
|
||||
self._exit_client_order_seq += 1
|
||||
@@ -372,25 +567,28 @@ class BingxDirectExecutionAdapter(ExecutionPort):
|
||||
int(round(float(intent.leverage or self._config.default_leverage))),
|
||||
exchange_max=self._config.exchange_leverage_cap,
|
||||
)
|
||||
try:
|
||||
await self._client.signed_post(
|
||||
"/openApi/swap/v2/trade/leverage",
|
||||
{"symbol": symbol, "side": "BOTH", "leverage": leverage},
|
||||
)
|
||||
except Exception as _lev_exc:
|
||||
# W: leverage POST failed — order will execute at whatever leverage the
|
||||
# exchange currently has for this symbol. Log prominently; do NOT abort
|
||||
# the submit because the order may still succeed at the right leverage.
|
||||
import logging as _logging
|
||||
_logging.getLogger(__name__).warning(
|
||||
"BingX leverage set failed (symbol=%s lev=%s): %s — proceeding with submit",
|
||||
symbol, leverage, _lev_exc,
|
||||
)
|
||||
|
||||
# S1: leverage cache — skip POST when exchange already has the right value.
|
||||
await self._ensure_leverage(symbol, leverage)
|
||||
|
||||
# Capture mark price BEFORE the order POST for slippage measurement (Gap 3).
|
||||
# This is the most honest reference: the market state at decision time.
|
||||
mark_at_submit = 0.0
|
||||
submit_ts_ms = int(time.time() * 1000)
|
||||
if self._state is not None:
|
||||
for _sym_key, _pos in self._state.open_positions.items():
|
||||
_mark = float(_pos.get("markPrice") or _pos.get("avgPrice") or 0.0)
|
||||
if _mark > 0:
|
||||
mark_at_submit = _mark
|
||||
break
|
||||
if mark_at_submit <= 0:
|
||||
# No open position for mark — use the last known mark from any symbol
|
||||
# as a rough reference (e.g. for fresh ENTER with no position yet)
|
||||
pass # remains 0.0; slippage will be 0
|
||||
|
||||
try:
|
||||
# Honor the order type forwarded by the venue adapter
|
||||
# (bingx_venue._legacy_intent sets _order_type/_limit_price). MARKET
|
||||
# is the default; a LIMIT carries a resting price + GTC and will not
|
||||
# fill synchronously — the async-fill pump settles it later.
|
||||
# (bingx_venue._legacy_intent encodes _order_type/_limit_price).
|
||||
order_type = str((intent.metadata or {}).get("_order_type", "MARKET") or "MARKET").upper()
|
||||
limit_price = float((intent.metadata or {}).get("_limit_price", 0.0) or 0.0)
|
||||
is_limit = order_type == "LIMIT" and limit_price > 0.0
|
||||
@@ -422,8 +620,12 @@ class BingxDirectExecutionAdapter(ExecutionPort):
|
||||
fill_price = value
|
||||
break
|
||||
if fill_price <= 0 and self._state is not None:
|
||||
# Use the last known exchange mark as a fallback for projected accounting.
|
||||
fill_price = next((float(row.get("markPrice") or row.get("avgPrice") or 0.0) for row in self._state.open_positions.values() if float(row.get("markPrice") or row.get("avgPrice") or 0.0) > 0), 0.0)
|
||||
fill_price = next(
|
||||
(float(row.get("markPrice") or row.get("avgPrice") or 0.0)
|
||||
for row in self._state.open_positions.values()
|
||||
if float(row.get("markPrice") or row.get("avgPrice") or 0.0) > 0),
|
||||
0.0,
|
||||
)
|
||||
except BingxHttpError as exc:
|
||||
status = "RATE_LIMITED" if _is_rate_limited_error(exc) else "REJECTED"
|
||||
ack_row = {
|
||||
@@ -434,6 +636,52 @@ class BingxDirectExecutionAdapter(ExecutionPort):
|
||||
}
|
||||
fill_price = 0.0
|
||||
ack = None
|
||||
is_limit = False
|
||||
|
||||
# ── Gap 2: fee estimation (ESTIMATED_TAKER / ESTIMATED_MAKER) ────────
|
||||
# BingX REST ACK does not include commission. WS FILL_SETTLED will deliver
|
||||
# the actual fee later and update the fee_source to "WS_SETTLED".
|
||||
# Until then, log an estimate so CH rows are never blank on this field.
|
||||
fill_qty = float(ack_row.get("executedQty") or ack_row.get("filledQty") or
|
||||
getattr(intent, "target_size", 0.0) or 0.0)
|
||||
if is_limit:
|
||||
# LIMIT orders *may* rest and fill as maker — optimistic estimate.
|
||||
fee_rate = 0.0002 # BingX perpetuals maker fee 0.02%
|
||||
fee_source = "ESTIMATED_MAKER"
|
||||
is_maker_est = True
|
||||
else:
|
||||
fee_rate = 0.0004 # BingX perpetuals taker fee 0.04%
|
||||
fee_source = "ESTIMATED_TAKER"
|
||||
is_maker_est = False
|
||||
estimated_fee = fill_price * fill_qty * fee_rate if fill_price > 0 and fill_qty > 0 else 0.0
|
||||
|
||||
# ── Gap 3: slippage (signed, vs mark_at_submit) ───────────────────────
|
||||
# Positive = worse than mark (taker overpays), negative = better (maker/price improvement).
|
||||
# Measured for BOTH taker and maker fills so post-trade analytics can compare.
|
||||
slippage_bps = 0.0
|
||||
if mark_at_submit > 0 and fill_price > 0:
|
||||
raw_diff = (fill_price - mark_at_submit) / mark_at_submit * 10_000
|
||||
# Sign convention: adverse = positive regardless of direction.
|
||||
# For BUY (LONG enter / SHORT close): higher fill price = worse → positive
|
||||
# For SELL (SHORT enter / LONG close): lower fill price = worse → positive
|
||||
if side == "BUY":
|
||||
slippage_bps = raw_diff # positive if fill > mark (paid up)
|
||||
else:
|
||||
slippage_bps = -raw_diff # positive if fill < mark (sold down)
|
||||
|
||||
# Exchange-assigned fill time from ACK (field "updateTime" or "time"); 0 if absent.
|
||||
exchange_ts = int(ack_row.get("updateTime") or ack_row.get("time") or
|
||||
ack_row.get("transactTime") or 0)
|
||||
|
||||
# Annotate ack_row with computed friction so _events_from_submit can read them.
|
||||
ack_row["_fee_estimated"] = estimated_fee
|
||||
ack_row["_fee_source"] = fee_source
|
||||
ack_row["_is_maker_est"] = is_maker_est
|
||||
ack_row["_mark_at_submit"] = mark_at_submit
|
||||
ack_row["_slippage_bps"] = slippage_bps
|
||||
ack_row["_submit_ts_ms"] = submit_ts_ms
|
||||
ack_row["_exchange_ts"] = exchange_ts
|
||||
|
||||
receipt = ExecutionReceipt(
|
||||
timestamp=datetime.now(timezone.utc),
|
||||
status=status,
|
||||
@@ -443,12 +691,28 @@ class BingxDirectExecutionAdapter(ExecutionPort):
|
||||
quantity=float(intent.target_size or 0.0),
|
||||
price=fill_price,
|
||||
client_order_id=client_order_id,
|
||||
order_id=str((ack.order_id if 'ack' in locals() and ack is not None else '') or ack_row.get("orderId") or ""),
|
||||
order_id=str(
|
||||
(ack.order_id if "ack" in locals() and ack is not None else "")
|
||||
or ack_row.get("orderId") or ""
|
||||
),
|
||||
raw_ack=ack_row,
|
||||
raw_state=dict(self._state.account if self._state is not None else {}),
|
||||
)
|
||||
# Refresh from the venue so the direct runtime can use exchange-led state.
|
||||
self._state = await self._refresh_exchange_state(intent.asset, include_history=True)
|
||||
|
||||
# S2: background state refresh — do not block the submit path for MARKET fills.
|
||||
# For MARKET orders that returned FILLED in the ACK, all fill data is already
|
||||
# in the receipt. The WS stream (FILL_SETTLED + ACCOUNT_UPDATE) delivers
|
||||
# capital truth. The background REST poll is belt-and-suspenders.
|
||||
# For LIMIT / non-FILLED orders: must refresh synchronously to detect resting order.
|
||||
market_filled = (status == "FILLED" and not is_limit)
|
||||
if market_filled:
|
||||
asyncio.create_task(
|
||||
self._refresh_state_background(intent.asset),
|
||||
name=f"state_refresh_{symbol}",
|
||||
)
|
||||
else:
|
||||
self._state = await self._refresh_exchange_state(intent.asset, include_history=False)
|
||||
|
||||
return receipt
|
||||
|
||||
async def cancel(self, order: Any, *, reason: str = "") -> dict[str, Any]:
|
||||
|
||||
Reference in New Issue
Block a user