Struct BinanceSpot 

pub struct BinanceSpot { /* private fields */ }

BinanceSpot execution client using the official binance-sdk.

• REST API: account snapshot, balance/order/trade queries (startup/cold paths)
• WebSocket API: order placement, order cancellation, user data stream (hot paths)

Rate limits

REST and the WebSocket API share one per-IP request-weight limit per minute. Its value comes from each WebSocket API response, and is Binance’s documented 6000 until the first one. Once a response reports at least 90% of it used, REST queries wait for the next minute, so the rest is left for orders and cancels, which never wait for it. A query, including a fetch_open_orders after a reconnect, can therefore take up to about a minute longer. A reconnect’s fill recovery does not wait for it either, since a pause could outlast the recovery’s 30 s and delay its fills to a retry. After Binance answers with a rate-limit error, REST calls wait out a cooldown, and an order or cancel that would have to open a new WebSocket API session fails with ApiError::RateLimit instead, unsent.

Trait Implementations

impl Clone for BinanceSpot

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for BinanceSpot

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl ExecutionClient for BinanceSpot

fn new(config: Self::Config) -> Self

Panics

Panics if the binance-sdk REST or WebSocket configuration builder fails (e.g. empty or malformed API key/secret).

async fn account_stream( &self, _assets: &[AssetNameExchange], instruments: &[InstrumentNameExchange], ) -> Result<Self::AccountStream, UnindexedClientError>

Returns a live stream of account events (fills, order updates, balance changes).

Startup Race Window

There is a brief window between the initial WS subscribe response and the internal event listener being registered inside the spawned connection manager. TRADE fills arriving in this gap are silently dropped. Callers that require fill completeness at startup MUST call ExecutionClient::fetch_trades with a 1–2 second lookback unconditionally after account_stream returns, before processing any events. Do not use the first event’s arrival as a readiness signal — the first event may be a recovered fill sent before live WS events start. The dedup cache absorbs any duplicates from the overlapping time window. Callers MUST also call ExecutionClient::fetch_open_orders after each reconnect to reconcile open-order state — order lifecycle events (NEW, CANCELED) are not recovered after a WS disconnect, only TRADE fills are.

A recovery that does not finish

Recovery after a reconnect is bounded by a 30 s timeout, and an instrument’s query can fail. Each instrument’s gap, from the disconnect to just after the recovery began, is kept until its fills are forwarded. A gap not read is retried after 1, 2, 4, 8 and 16 minutes, whether the stream stays connected or reconnects in between. A retry reads only the gap, not fills the stream delivered live after it; the few seconds at its end that overlap live delivery are deduplicated. Each failed read is logged at warn with the instrument and the gap. After five failed retries the gap is given up, logged at error, and its fills are not delivered: read them with ExecutionClient::fetch_trades.

A recovered gap counts as read even when a fill in it could not be converted, which is logged, or its order’s cumulative could not be looked up (see below).

A recovered fill advances the order too

A fill that arrives live over the WebSocket carries the order’s cumulative filled quantity in Trade::order_filled_quantity (executionReport’s z), so it advances the order by itself. A fill recovered after a disconnect comes from REST myTrades, which reports executions only, so recovery rebuilds the same figure by reading each recovered order’s executions from its first: one extra request per order (another per further 1,000 executions), up to four orders at a time per instrument.

Those lookups have their own time budget inside the recovery timeout, so they can never cost a fill. A fill whose order was not looked up in time, or whose lookup failed, goes out with order_filled_quantity: None, logged at warn. It then advances the position but not the order, which keeps whatever filled_quantity it held before the gap until the order’s state is learned some other way.

async fn fetch_open_orders( &self, instruments: &[InstrumentNameExchange], ) -> Result<Vec<Order<ExchangeId, InstrumentNameExchange, Open>>, UnindexedClientError>

An empty instruments slice is the ExecutionClient “return all” sentinel: a single no-symbol GET /api/v3/openOrders call returns open orders across every instrument (each order’s instrument is recovered from its own symbol field). A non-empty slice fetches the listed instruments concurrently, per-symbol.

async fn fetch_trades( &self, time_since: DateTime<Utc>, instruments: &[InstrumentNameExchange], ) -> Result<Vec<Trade<AssetNameExchange, InstrumentNameExchange>>, UnindexedClientError>

Documented deviation from the ExecutionClient::fetch_trades “return all” contract: Binance’s myTrades endpoint requires a symbol — there is no no-symbol “all trades” query (unlike open orders). An empty instruments slice therefore has nothing to query and returns an empty Vec; callers wanting all trades must enumerate instruments explicitly.

const EXCHANGE: ExchangeId = ExchangeId::BinanceSpot

const SUPPORTED_KINDS: &'static [InstrumentKindDiscriminant]

The InstrumentKindDiscriminants this client can trade.

type Config = BinanceSpotConfig

type AccountStream = Pin<Box<dyn Stream<Item = AccountEvent<ExchangeId, AssetNameExchange, InstrumentNameExchange>> + Send>>

async fn account_snapshot( &self, assets: &[AssetNameExchange], instruments: &[InstrumentNameExchange], ) -> Result<UnindexedAccountSnapshot, UnindexedClientError>

Reads the account’s balances, and its open orders and positions for instruments, from the venue.

async fn cancel_order( &self, request: OrderRequestCancel<ExchangeId, &InstrumentNameExchange>, ) -> Option<UnindexedOrderResponseCancel>

Cancel an order at the venue.

async fn open_order( &self, request: OrderRequestOpen<ExchangeId, &InstrumentNameExchange>, ) -> Option<Order<ExchangeId, InstrumentNameExchange, UnindexedOrderState>>

Place an order on the exchange.

async fn fetch_balances( &self, assets: &[AssetNameExchange], ) -> Result<Vec<AssetBalance<AssetNameExchange>>, UnindexedClientError>

Fetch current balances for the specified assets.

fn cancel_orders<'a>( &self, requests: impl IntoIterator<Item = OrderRequestCancel<ExchangeId, &'a InstrumentNameExchange>>, ) -> impl Stream<Item = Option<UnindexedOrderResponseCancel>> + Send

fn open_orders<'a>( &self, requests: impl IntoIterator<Item = OrderRequestOpen<ExchangeId, &'a InstrumentNameExchange>>, ) -> impl Stream<Item = Option<Order<ExchangeId, InstrumentNameExchange, UnindexedOrderState>>> + Send