1use std::{future::Future, sync::Arc, time::Duration};
19
20use ahash::{AHashMap, AHashSet};
21use anyhow::Context;
22use async_trait::async_trait;
23use indexmap::IndexMap;
24use jiff::Timestamp;
25use nautilus_common::{
26 cache::fifo::FifoCache,
27 clients::ExecutionClient,
28 enums::LogLevel,
29 live::runner::get_exec_event_sender,
30 messages::execution::{
31 BatchCancelOrders, CancelAllOrders, CancelOrder, GenerateFillReports,
32 GenerateFillReportsBuilder, GenerateOrderStatusReport, GenerateOrderStatusReports,
33 GenerateOrderStatusReportsBuilder, GeneratePositionStatusReports,
34 GeneratePositionStatusReportsBuilder, ModifyOrder, QueryAccount, QueryOrder, SubmitOrder,
35 SubmitOrderList,
36 },
37};
38use nautilus_core::{
39 DurationNanos, Params, UUID4, UnixNanos,
40 datetime::NANOSECONDS_IN_MILLISECOND,
41 string::secret::SecretString,
42 time::{AtomicTime, get_atomic_clock_realtime},
43};
44use nautilus_live::{
45 ExecutionClientCore, ExecutionEventEmitter, SocketControlFactory,
46 execution::failure::CommandFailure,
47 task::{TaskGroup, TaskGroupGuard, TaskRef, TaskSpawner},
48};
49use nautilus_model::{
50 accounts::AccountAny,
51 enums::{ContingencyType, LiquiditySide, OmsType, OrderStatus, OrderType},
52 events::{
53 AccountState, OrderAccepted, OrderCancelDenied, OrderCancelRejected, OrderCanceled,
54 OrderDeniedReason, OrderEventAny, OrderExpired, OrderFilled, OrderModifyDenied,
55 OrderModifyRejected, OrderRejected, OrderUpdated,
56 },
57 identifiers::{
58 AccountId, ClientId, ClientOrderId, InstrumentId, StrategyId, TradeId, Venue, VenueOrderId,
59 },
60 instruments::{Instrument, InstrumentAny},
61 orders::{Order, OrderAny},
62 reports::{ExecutionMassStatus, FillReport, OrderStatusReport, PositionStatusReport},
63 types::{AccountBalance, Currency, MarginBalance, Money, Price, Quantity},
64};
65use parking_lot::Mutex;
66use rust_decimal::Decimal;
67use ustr::Ustr;
68
69use super::websocket::trading::{
70 client::BinanceSpotWsTradingClient,
71 messages::BinanceSpotWsTradingMessage,
72 parse::{
73 parse_spot_account_position, parse_spot_exec_report_to_fill,
74 parse_spot_exec_report_to_order_status,
75 },
76 user_data::{BinanceSpotExecutionReport, BinanceSpotExecutionType, BinanceSpotListStatus},
77};
78use crate::{
79 common::{
80 consts::{
81 BINANCE_GTX_ORDER_REJECT_CODE, BINANCE_NAUTILUS_SPOT_BROKER_ID,
82 BINANCE_NEW_ORDER_REJECTED_CODE, BINANCE_SPOT_POST_ONLY_REJECT_MSG,
83 BINANCE_SPOT_SBE_WS_API_DEMO_URL, BINANCE_SPOT_SBE_WS_API_TESTNET_URL,
84 BINANCE_SPOT_SBE_WS_API_URL, BINANCE_VENUE, BINANCE_WS_HEARTBEAT_SECS,
85 },
86 credential::resolve_credentials,
87 dispatch::{
88 DEDUP_CAPACITY, OrderIdentity, OrderListIdentity, PendingOperation, PendingRequest,
89 WsDispatchState, ensure_accepted_emitted,
90 },
91 encoder::{decode_client_order_id, encode_broker_id},
92 enums::{BinanceEnvironment, BinanceOrderStatus, BinanceSide, BinanceTimeInForce},
93 error::{
94 BINANCE_ORDER_RATE_LIMIT_CODE, BINANCE_RATE_LIMIT_STATUS, is_retryable_http_status,
95 },
96 failure::{classify_spot_http_failure, classify_venue_failure, sanitize_reason},
97 instruments::BinanceInstrumentSelector,
98 parse::{
99 parse_micros, parse_micros_or_init, parse_millis_or_init, parse_required_decimal,
100 parse_required_price_at_precision, parse_required_quantity_at_precision,
101 },
102 urls::{get_http_base_url_with_us, get_spot_user_stream_url},
103 },
104 config::BinanceExecutionClientConfig,
105 spot::{
106 enums::{
107 BinanceCancelReplaceMode, BinanceOrderResponseType, BinanceSpotOrderType,
108 order_type_to_binance_spot, time_in_force_to_binance_spot,
109 },
110 http::{
111 client::BinanceSpotHttpClient,
112 error::BinanceSpotHttpError,
113 models::{
114 BinanceCancelOpenOrdersResponse, BinanceCancelOrderListResponse,
115 BinanceCancelOrderResponse,
116 },
117 query::{
118 CancelOrderParams, CancelReplaceOrderParams, NewOcoOrderListParams, NewOrderParams,
119 },
120 },
121 sbe::spot::{
122 list_order_status::ListOrderStatus as SbeListOrderStatus,
123 list_status_type::ListStatusType as SbeListStatusType,
124 order_status::OrderStatus as SbeOrderStatus,
125 },
126 },
127};
128
129const ACCOUNT_TRADES_MAX_INTERVAL_MS: i64 = 24 * 60 * 60 * 1_000;
130
131const ACCOUNT_TRADES_PAGE_LIMIT: u32 = 1_000;
132
133const WS_RECONNECT_SETUP_RETRY_DELAY: Duration = Duration::from_secs(1);
134
135#[derive(Debug)]
141pub struct BinanceSpotExecutionClient {
142 core: ExecutionClientCore,
143 clock: &'static AtomicTime,
144 config: BinanceExecutionClientConfig,
145 emitter: ExecutionEventEmitter,
146 dispatch_state: Arc<WsDispatchState>,
147 lifecycle_lock: Arc<Mutex<()>>,
148 http_client: BinanceSpotHttpClient,
149 socket_factory: SocketControlFactory,
150 ws_trading_client: Option<BinanceSpotWsTradingClient>,
151 ws_trading_dispatch: Option<TaskRef>,
152 ws_user_data_client: Arc<Mutex<Option<BinanceSpotWsTradingClient>>>,
153 ws_user_data_dispatch: Option<TaskRef>,
154 listen_key: Option<SecretString>,
155 us_credentials: Option<(SecretString, SecretString)>,
156 ws_authenticated: Arc<tokio::sync::Notify>,
157 ws_user_data_subscribed: Arc<tokio::sync::Notify>,
158 session_tasks: TaskGroup,
159 pending_tasks: TaskGroup,
160 shutdown_errors: Vec<String>,
161}
162
163impl BinanceSpotExecutionClient {
164 pub fn new(
170 core: ExecutionClientCore,
171 config: BinanceExecutionClientConfig,
172 ) -> anyhow::Result<Self> {
173 config.validate()?;
174 let (api_key, api_secret) = resolve_credentials(
175 config
176 .api_key
177 .as_ref()
178 .map(|value| value.expose_secret().to_owned()),
179 config
180 .api_secret
181 .as_ref()
182 .map(|value| value.expose_secret().to_owned()),
183 config.environment,
184 config.product_type,
185 )?;
186
187 let clock = get_atomic_clock_realtime();
188 let socket_factory = SocketControlFactory::new(core.client_id, Some(*BINANCE_VENUE));
189 let base_url_http = config.base_url_http.clone().or_else(|| {
190 config.us.then(|| {
191 get_http_base_url_with_us(config.product_type, config.environment, true).to_string()
192 })
193 });
194 let proxy_url = config
195 .proxy_url
196 .as_ref()
197 .map(|value| value.expose_secret().to_owned());
198
199 let http_client = BinanceSpotHttpClient::new_with_json_responses(
200 config.environment,
201 clock,
202 Some(api_key.clone()),
203 Some(api_secret.clone()),
204 base_url_http,
205 Some(config.recv_window_ms),
206 None, proxy_url.clone(),
208 config.us,
209 )
210 .context("failed to construct Binance Spot HTTP client")?
211 .with_retry_config(config.retry_config());
212 let emitter = ExecutionEventEmitter::new(
213 clock,
214 core.trader_id,
215 core.account_id,
216 core.account_type,
217 core.base_currency,
218 );
219
220 let ws_trading_client = if config.us {
221 None
222 } else {
223 let url = Some(Self::resolve_ws_trading_url(
224 config.base_url_ws_trading.clone(),
225 config.environment,
226 ));
227 Some(
228 BinanceSpotWsTradingClient::new(
229 url,
230 api_key.clone(),
231 api_secret.clone(),
232 Some(BINANCE_WS_HEARTBEAT_SECS),
233 config.transport_backend,
234 )
235 .with_proxy(proxy_url)
236 .with_recv_window(Some(config.recv_window_ms))
237 .with_socket_control(socket_factory.control("binance-spot-trading")),
238 )
239 };
240 let us_credentials = config
241 .us
242 .then_some((SecretString::from(api_key), SecretString::from(api_secret)));
243
244 let session_tasks = TaskGroup::new();
245 let pending_tasks = TaskGroup::new();
246
247 Ok(Self {
248 core,
249 clock,
250 config,
251 emitter,
252 dispatch_state: Arc::new(WsDispatchState::default()),
253 lifecycle_lock: Arc::new(Mutex::new(())),
254 http_client,
255 socket_factory,
256 ws_trading_client,
257 ws_trading_dispatch: None,
258 ws_user_data_client: Arc::new(Mutex::new(None)),
259 ws_user_data_dispatch: None,
260 listen_key: None,
261 us_credentials,
262 ws_authenticated: Arc::new(tokio::sync::Notify::new()),
263 ws_user_data_subscribed: Arc::new(tokio::sync::Notify::new()),
264 session_tasks,
265 pending_tasks,
266 shutdown_errors: Vec::new(),
267 })
268 }
269
270 fn restore_active_orders(&self) {
271 for order in crate::common::execution::active_orders(&self.core) {
272 let Some(instrument) = self
273 .http_client
274 .get_instrument(&order.instrument_id().symbol.inner())
275 else {
276 continue;
277 };
278
279 if instrument.id() != order.instrument_id() {
280 continue;
281 }
282
283 self.dispatch_state
284 .restore_order(&order, None, instrument.price_precision());
285 }
286 }
287
288 fn resolve_ws_trading_url(base_url: Option<String>, environment: BinanceEnvironment) -> String {
289 base_url.unwrap_or_else(|| {
290 match environment {
291 BinanceEnvironment::Live => BINANCE_SPOT_SBE_WS_API_URL,
292 BinanceEnvironment::Testnet => BINANCE_SPOT_SBE_WS_API_TESTNET_URL,
293 BinanceEnvironment::Demo => BINANCE_SPOT_SBE_WS_API_DEMO_URL,
294 }
295 .to_string()
296 })
297 }
298
299 async fn refresh_account_state(&self) -> anyhow::Result<AccountState> {
300 self.http_client
301 .request_account_state(self.core.account_id)
302 .await
303 }
304
305 fn update_account_state(&self) {
306 let http_client = self.http_client.clone();
307 let account_id = self.core.account_id;
308 let emitter = self.emitter.clone();
309 let clock = self.clock;
310
311 self.spawn_task("query_account", async move {
312 let account_state = http_client.request_account_state(account_id).await?;
313 let ts_now = clock.get_time_ns();
314 emitter.emit_account_state(
315 account_state.balances.clone(),
316 account_state.margins.clone(),
317 account_state.is_reported,
318 ts_now,
319 account_state.info,
320 );
321 Ok(())
322 });
323 }
324
325 fn ws_user_data_active(&self) -> bool {
326 let dispatch_running = if self.config.us {
327 self.ws_user_data_dispatch
328 .as_ref()
329 .is_some_and(TaskRef::is_active)
330 } else {
331 self.ws_trading_dispatch
332 .as_ref()
333 .is_some_and(TaskRef::is_active)
334 };
335 let user_data_active = if self.config.us {
336 self.ws_user_data_client
337 .lock()
338 .as_ref()
339 .is_some_and(BinanceSpotWsTradingClient::is_user_data_active)
340 } else {
341 self.ws_trading_client
342 .as_ref()
343 .is_some_and(BinanceSpotWsTradingClient::is_user_data_active)
344 };
345
346 user_data_active && dispatch_running
347 }
348
349 fn ensure_ws_user_data_active(&self) -> anyhow::Result<()> {
350 anyhow::ensure!(
351 self.ws_user_data_active(),
352 "Binance Spot user data stream is not active",
353 );
354 Ok(())
355 }
356
357 fn ws_order_transport_active(&self) -> bool {
358 self.config.use_ws_trading && self.ws_trading_client.is_some() && self.ws_user_data_active()
359 }
360
361 fn submit_order_internal(
362 &self,
363 cmd: &SubmitOrder,
364 params: Option<NewOrderParams>,
365 ) -> anyhow::Result<()> {
366 let order = self.core.cache().try_order_owned(&cmd.client_order_id)?;
367
368 let event_emitter = self.emitter.clone();
369 let trader_id = self.core.trader_id;
370 let account_id = self.core.account_id;
371 let client_order_id = order.client_order_id();
372 let strategy_id = order.strategy_id();
373 let instrument_id = order.instrument_id();
374 let order_side = order.order_side();
375 let order_type = order.order_type();
376 let quantity = order.quantity();
377 let time_in_force = order.time_in_force();
378 let price = order.price();
379 let trigger_price = order.trigger_price();
380 let is_post_only = order.is_post_only();
381 let is_quote_quantity = order.is_quote_quantity();
382 let display_qty = order.display_qty();
383 let use_gtd = self.config.use_gtd;
384 let clock = self.clock;
385 let ts_init = self.clock.get_time_ns();
386
387 self.dispatch_state.order_identities.insert(
389 client_order_id,
390 OrderIdentity {
391 instrument_id,
392 strategy_id,
393 order_side,
394 order_type,
395 price,
396 quantity,
397 is_quote_quantity,
398 venue_position_id: None,
399 },
400 );
401
402 if let Some(params) = params {
403 let ws_client = self.ws_trading_client.as_ref().unwrap().clone();
404 let dispatch_state = self.dispatch_state.clone();
405
406 let request_id = ws_client.next_request_id();
408 dispatch_state.pending_requests.insert(
409 request_id.clone(),
410 PendingRequest {
411 command_id: None,
412 client_order_id,
413 venue_order_id: None,
414 operation: PendingOperation::Place,
415 },
416 );
417
418 self.spawn_task("submit_order_ws", async move {
419 if let Err(e) = ws_client
420 .place_order_with_id(request_id.clone(), params)
421 .await
422 {
423 dispatch_state.pending_requests.remove(&request_id);
424 log::warn!(
425 "WS submit request failed for {client_order_id}, awaiting reconciliation: {e}"
426 );
427 anyhow::bail!("WS submit order failed: {e}");
428 }
429 Ok(())
430 });
431 } else {
432 let http_client = self.http_client.clone();
433 let dispatch_state = self.dispatch_state.clone();
434 log::debug!("WS trading not active, falling back to HTTP for submit_order");
435
436 self.spawn_task("submit_order_http", async move {
437 let result = http_client
438 .submit_order(
439 account_id,
440 instrument_id,
441 client_order_id,
442 order_side,
443 order_type,
444 quantity,
445 time_in_force,
446 price,
447 trigger_price,
448 is_post_only,
449 is_quote_quantity,
450 display_qty,
451 use_gtd,
452 )
453 .await;
454
455 match result {
456 Ok(report) => handle_spot_order_submit_success(
457 client_order_id,
458 report.venue_order_id,
459 ),
460 Err(e) => {
461 let http_error = e.downcast_ref::<BinanceSpotHttpError>();
462 let failure = http_error.map_or_else(
463 || CommandFailure::Ambiguous(e.to_string()),
464 classify_spot_http_submit_failure,
465 );
466
467 match failure {
468 CommandFailure::Ambiguous(reason) => {
469 log::warn!(
470 "Ambiguous submit failure for {client_order_id}, awaiting reconciliation: {reason}"
471 );
472 }
473 CommandFailure::NotSent(reason)
474 | CommandFailure::VenueRejected(reason) => {
475 let due_post_only =
476 http_error.is_some_and(is_spot_post_only_rejection);
477 dispatch_state.cleanup_terminal(client_order_id);
478 let rejected = OrderRejected::new(
479 trader_id,
480 strategy_id,
481 instrument_id,
482 client_order_id,
483 account_id,
484 format!("submit-order-error: {}", sanitize_reason(&reason))
485 .into(),
486 UUID4::new(),
487 ts_init,
488 clock.get_time_ns(),
489 false,
490 due_post_only,
491 );
492 event_emitter.send_order_event(OrderEventAny::Rejected(rejected));
493 }
494 }
495 return Err(e);
496 }
497 }
498 Ok(())
499 });
500 }
501
502 Ok(())
503 }
504
505 fn cancel_order_internal(&self, cmd: &CancelOrder) {
506 let event_emitter = self.emitter.clone();
507 let trader_id = self.core.trader_id;
508 let account_id = self.core.account_id;
509 let clock = self.clock;
510 let command = cmd.clone();
511 let prefer_client_order_id = self
512 .dispatch_state
513 .order_identities
514 .contains_key(&cmd.client_order_id);
515
516 if self.ws_order_transport_active() {
517 let ws_client = self.ws_trading_client.as_ref().unwrap().clone();
518 let dispatch_state = self.dispatch_state.clone();
519 let params = build_cancel_order_params(&command, prefer_client_order_id);
520
521 let request_id = ws_client.next_request_id();
523 dispatch_state.pending_requests.insert(
524 request_id.clone(),
525 PendingRequest {
526 command_id: Some(command.command_id),
527 client_order_id: command.client_order_id,
528 venue_order_id: command.venue_order_id,
529 operation: PendingOperation::Cancel,
530 },
531 );
532
533 let http_client = self.http_client.clone();
534 self.spawn_task("cancel_order_ws", async move {
535 let mut params = params;
536 http_client
537 .inner()
538 .resolve_cancel_order(&mut params)
539 .await
540 .inspect_err(|e| {
541 dispatch_state.pending_requests.remove(&request_id);
542 let ts_now = clock.get_time_ns();
543
544 let mut rejected = OrderCancelDenied::new(
545 trader_id,
546 command.strategy_id,
547 command.instrument_id,
548 command.client_order_id,
549 format!(
550 "cancel identity lookup failed before submission: {}",
551 sanitize_reason(&e.to_string())
552 )
553 .into(),
554 UUID4::new(),
555 ts_now,
556 ts_now,
557 command.venue_order_id,
558 Some(account_id),
559 );
560 rejected.causation_id = Some(command.command_id);
561 event_emitter.send_order_event(OrderEventAny::CancelDenied(rejected));
562 })?;
563
564 let result = ws_client
565 .cancel_order_with_id(request_id.clone(), params)
566 .await;
567
568 if let Err(e) = result {
569 dispatch_state.pending_requests.remove(&request_id);
570 log::warn!(
571 "WS cancel request failed for {}, awaiting reconciliation: {e}",
572 command.client_order_id
573 );
574 anyhow::bail!("WS cancel order failed: {e}");
575 }
576 Ok(())
577 });
578 } else {
579 let http_client = self.http_client.clone();
580 let dispatch_state = self.dispatch_state.clone();
581 log::debug!("WS trading not active, falling back to HTTP for cancel_order");
582
583 self.spawn_task("cancel_order_http", async move {
584 let result = http_client
585 .cancel_order(
586 command.instrument_id,
587 if prefer_client_order_id { None } else { command.venue_order_id },
588 Some(command.client_order_id),
589 )
590 .await;
591
592 match result {
593 Ok(venue_order_id) => {
594 dispatch_state.cleanup_terminal(command.client_order_id);
595 let ts_now = clock.get_time_ns();
596 let canceled_event = OrderCanceled::new(
597 trader_id,
598 command.strategy_id,
599 command.instrument_id,
600 command.client_order_id,
601 UUID4::new(),
602 ts_now,
603 ts_now,
604 false,
605 Some(venue_order_id),
606 Some(account_id),
607 None,
608 );
609 event_emitter.send_order_event(OrderEventAny::Canceled(canceled_event));
610 }
611 Err(e) => {
612 let failure = e.downcast_ref::<BinanceSpotHttpError>().map_or_else(
613 || CommandFailure::Ambiguous(e.to_string()),
614 classify_spot_http_failure,
615 );
616
617 match failure {
618 CommandFailure::Ambiguous(reason) => {
619 log::warn!(
620 "Ambiguous cancel failure for {}, awaiting reconciliation: {reason}",
621 command.client_order_id
622 );
623 }
624 CommandFailure::NotSent(reason) => {
625 let ts_now = clock.get_time_ns();
626
627 let mut rejected_event = OrderCancelDenied::new(
628 trader_id,
629 command.strategy_id,
630 command.instrument_id,
631 command.client_order_id,
632 format!("cancel-order-error: {}", sanitize_reason(&reason))
633 .into(),
634 UUID4::new(),
635 ts_now,
636 ts_now,
637 command.venue_order_id,
638 Some(account_id),
639 );
640 rejected_event.causation_id = Some(command.command_id);
641 event_emitter
642 .send_order_event(OrderEventAny::CancelDenied(rejected_event));
643 }
644 CommandFailure::VenueRejected(reason) => {
645 let ts_now = clock.get_time_ns();
646
647 let mut rejected_event = OrderCancelRejected::new(
648 trader_id,
649 command.strategy_id,
650 command.instrument_id,
651 command.client_order_id,
652 format!("cancel-order-error: {}", sanitize_reason(&reason))
653 .into(),
654 UUID4::new(),
655 ts_now,
656 ts_now,
657 false,
658 command.venue_order_id,
659 Some(account_id),
660 );
661 rejected_event.causation_id = Some(command.command_id);
662 event_emitter
663 .send_order_event(OrderEventAny::CancelRejected(rejected_event));
664 }
665 }
666 return Err(e);
667 }
668 }
669 Ok(())
670 });
671 }
672 }
673
674 fn spawn_task<F>(&self, description: &'static str, fut: F)
675 where
676 F: Future<Output = anyhow::Result<()>> + Send + 'static,
677 {
678 crate::common::execution::spawn_task(&self.pending_tasks, description, fut);
679 }
680
681 fn begin_generation_shutdown(&self) {
682 if let Some(client) = self.ws_trading_client.as_ref() {
683 client.mark_user_data_inactive();
684 client.begin_shutdown();
685 }
686
687 if let Some(client) = self.ws_user_data_client.lock().as_ref() {
688 client.mark_user_data_inactive();
689 client.begin_shutdown();
690 }
691
692 self.core.set_disconnected();
693 self.abort_session_tasks();
694 self.abort_pending_tasks();
695 }
696
697 fn abort_pending_tasks(&self) {
698 crate::common::execution::abort_pending_tasks(&self.pending_tasks);
699 }
700
701 fn abort_session_tasks(&self) {
702 self.session_tasks.begin_shutdown();
703 }
704
705 async fn await_pending_tasks(&self) -> anyhow::Result<()> {
706 crate::common::execution::await_pending_tasks(&self.pending_tasks).await
707 }
708
709 async fn await_session_tasks(&self) -> anyhow::Result<()> {
710 self.session_tasks.begin_shutdown();
711 self.session_tasks
712 .finish_shutdown(Duration::from_secs(1), Duration::from_secs(2))
713 .await
714 .map_err(|e| anyhow::anyhow!("Failed to terminate Binance Spot session tasks: {e}"))?;
715 Ok(())
716 }
717
718 async fn ws_setup_failure(
719 &mut self,
720 mut ws_trading: BinanceSpotWsTradingClient,
721 reason: String,
722 ) -> anyhow::Error {
723 ws_trading.mark_user_data_inactive();
724 log::debug!("{reason}; Binance Spot private user data is required for execution");
725
726 self.abort_session_tasks();
727
728 if let Err(e) = ws_trading.disconnect().await {
729 log::warn!("Failed to stop Binance Spot trading WebSocket after setup failure: {e}");
730 }
731 self.disconnect_us_user_data().await;
732
733 if let Err(e) = self.await_session_tasks().await {
734 log::warn!("Failed to drain Binance Spot session tasks after setup failure: {e}");
735 }
736 self.ws_trading_client = Some(ws_trading);
737 anyhow::anyhow!(reason)
738 }
739
740 async fn connect_us_user_data(&mut self) -> anyhow::Result<()> {
741 let (api_key, api_secret) = self
742 .us_credentials
743 .clone()
744 .context("Binance US user data credentials are unavailable")?;
745 let response = self
746 .http_client
747 .inner()
748 .create_listen_key()
749 .await
750 .context("failed to create Binance US listen key")?;
751 let listen_key = response.into_listen_key();
752 self.listen_key = Some(listen_key.clone());
753 let url = get_spot_user_stream_url(
754 self.config.base_url_ws.as_deref(),
755 listen_key.expose_secret(),
756 );
757 let mut ws_user_data = BinanceSpotWsTradingClient::new(
758 Some(url),
759 api_key.expose_secret().to_owned(),
760 api_secret.expose_secret().to_owned(),
761 Some(BINANCE_WS_HEARTBEAT_SECS),
762 self.config.transport_backend,
763 )
764 .with_proxy(
765 self.config
766 .proxy_url
767 .as_ref()
768 .map(|value| value.expose_secret().to_owned()),
769 )
770 .with_socket_control(self.socket_factory.control("binance-spot-user-streams"));
771 *self.ws_user_data_client.lock() = Some(ws_user_data.clone());
772 ws_user_data
773 .connect()
774 .await
775 .context("failed to connect Binance US user data stream")?;
776
777 let ws_clone = ws_user_data.clone();
778 let emitter = self.emitter.clone();
779 let account_id = self.core.account_id;
780 let clock = self.clock;
781 let http_client = self.http_client.clone();
782 let dispatch_state = self.dispatch_state.clone();
783 let lifecycle_lock = self.lifecycle_lock.clone();
784 let treat_expired_as_canceled = self.config.treat_expired_as_canceled;
785 let ws_authenticated = self.ws_authenticated.clone();
786 let ws_user_data_subscribed = self.ws_user_data_subscribed.clone();
787 let (setup_error_tx, _setup_error_rx) = tokio::sync::mpsc::unbounded_channel();
788 let seen_trade_ids = self.dispatch_state.seen_trade_ids();
789 let task_spawner = self
790 .session_tasks
791 .spawner()
792 .context("Binance Spot session task admission is closed")?;
793
794 let future = async move {
795 while let Some(message) = ws_clone.recv().await {
796 if matches!(&message, BinanceSpotWsTradingMessage::Reconnected) {
797 ws_clone.mark_user_data_active();
798 }
799 let _lifecycle_guard = lifecycle_lock.lock();
800 dispatch_ws_trading_message(
801 message,
802 &emitter,
803 &http_client,
804 account_id,
805 treat_expired_as_canceled,
806 clock,
807 &dispatch_state,
808 &ws_authenticated,
809 &ws_user_data_subscribed,
810 &setup_error_tx,
811 &seen_trade_ids,
812 &task_spawner,
813 );
814 }
815
816 log::debug!("Data dispatch loop ended");
817 };
818 let dispatch = self
819 .session_tasks
820 .spawn_named("binance-spot-user-data-dispatch", future)?;
821 self.ws_user_data_dispatch = Some(dispatch);
822
823 let keepalive_http = self.http_client.clone();
824 let keepalive_key = listen_key.clone();
825
826 if let Err(e) = self.session_tasks.spawn(async move {
827 let mut interval = tokio::time::interval(Duration::from_secs(30 * 60));
828 interval.tick().await;
829
830 loop {
831 interval.tick().await;
832
833 if let Err(e) = keepalive_http
834 .inner()
835 .extend_listen_key(keepalive_key.expose_secret())
836 .await
837 {
838 log::warn!("Binance US listen key keepalive failed: {e}");
839 }
840 }
841 }) {
842 return Err(e.into());
843 }
844
845 ws_user_data.mark_user_data_active();
846 *self.ws_user_data_client.lock() = Some(ws_user_data);
847 Ok(())
848 }
849
850 async fn disconnect_us_user_data(&mut self) {
851 let mut client_drained = true;
852 let client = self.ws_user_data_client.lock().clone();
853
854 if let Some(mut client) = client {
855 client.mark_user_data_inactive();
856 if let Err(e) = client.disconnect().await {
857 client_drained = false;
858 self.shutdown_errors.push(format!(
859 "failed to stop Binance US user data WebSocket: {e}"
860 ));
861 }
862 }
863
864 if client_drained {
865 *self.ws_user_data_client.lock() = None;
866 }
867
868 if let Some(listen_key) = self.listen_key.clone() {
869 match self
870 .http_client
871 .inner()
872 .close_listen_key(listen_key.expose_secret())
873 .await
874 {
875 Ok(())
876 if self.listen_key.as_ref().map(SecretString::expose_secret)
877 == Some(listen_key.expose_secret()) =>
878 {
879 self.listen_key = None;
880 }
881 Ok(()) => {}
882 Err(e) => self
883 .shutdown_errors
884 .push(format!("failed to close Binance US listen key: {e}")),
885 }
886 }
887 }
888
889 async fn teardown_partial_connect(&mut self) -> anyhow::Result<()> {
890 if let Some(client) = self.ws_trading_client.as_ref() {
891 client.mark_user_data_inactive();
892 client.begin_shutdown();
893 }
894
895 if let Some(client) = self.ws_user_data_client.lock().as_ref() {
896 client.mark_user_data_inactive();
897 client.begin_shutdown();
898 }
899
900 self.abort_session_tasks();
901 self.abort_pending_tasks();
902
903 if let Some(ref mut ws_trading) = self.ws_trading_client
904 && let Err(e) = ws_trading.disconnect().await
905 {
906 self.shutdown_errors
907 .push(format!("trading WebSocket shutdown failed: {e}"));
908 }
909 self.disconnect_us_user_data().await;
910
911 let (session_result, pending_result) =
912 tokio::join!(self.await_session_tasks(), self.await_pending_tasks());
913 self.core.set_disconnected();
914
915 if let Err(e) = session_result {
916 self.shutdown_errors.push(e.to_string());
917 }
918
919 if let Err(e) = pending_result {
920 self.shutdown_errors.push(e.to_string());
921 }
922
923 if !self.shutdown_errors.is_empty() {
924 let errors = std::mem::take(&mut self.shutdown_errors);
925 anyhow::bail!("Binance Spot shutdown failed: {}", errors.join("; "));
926 }
927 Ok(())
928 }
929}
930
931#[async_trait(?Send)]
932impl ExecutionClient for BinanceSpotExecutionClient {
933 fn is_connected(&self) -> bool {
934 self.core.is_connected()
935 }
936
937 fn client_id(&self) -> ClientId {
938 self.core.client_id
939 }
940
941 fn account_id(&self) -> AccountId {
942 self.core.account_id
943 }
944
945 fn venue(&self) -> Venue {
946 *BINANCE_VENUE
947 }
948
949 fn oms_type(&self) -> OmsType {
950 self.core.oms_type
951 }
952
953 fn provides_bulk_position_coverage(&self, _instrument_id: InstrumentId) -> bool {
955 false
956 }
957
958 fn get_account(&self) -> Option<AccountAny> {
959 self.core.cache().account_owned(&self.core.account_id)
960 }
961
962 async fn connect(&mut self) -> anyhow::Result<()> {
963 if self.core.is_connected() && self.session_tasks.is_open() && self.pending_tasks.is_open()
964 {
965 return Ok(());
966 }
967
968 if !self.pending_tasks.is_open() || !self.session_tasks.is_open() {
969 self.teardown_partial_connect().await?;
970 }
971
972 if !self.pending_tasks.is_open() {
973 self.await_pending_tasks().await?;
974 self.pending_tasks.start_generation().map_err(|e| {
975 anyhow::anyhow!("Failed to start Binance Spot task generation: {e}")
976 })?;
977 }
978
979 if !self.session_tasks.is_open() {
980 self.await_session_tasks().await?;
981 self.session_tasks.start_generation().map_err(|e| {
982 anyhow::anyhow!("Failed to start Binance Spot session generation: {e}")
983 })?;
984 }
985 let ws_trading_client = self.ws_trading_client.clone();
986 let ws_user_data_client = Arc::clone(&self.ws_user_data_client);
987 let setup_guard =
988 TaskGroupGuard::new(&[&self.session_tasks, &self.pending_tasks], move || {
989 if let Some(client) = ws_trading_client {
990 client.begin_shutdown();
991 }
992
993 if let Some(client) = ws_user_data_client.lock().as_ref() {
994 client.begin_shutdown();
995 }
996 });
997
998 let ws_setup_timeout = Duration::from_millis(self.config.ws_trading_setup_timeout_ms);
999
1000 if !self.core.instruments_initialized() {
1002 let instruments = self
1003 .http_client
1004 .request_instruments_with_config(&self.config.instrument_provider, self.config.us)
1005 .await
1006 .context("failed to request Binance Spot instruments")?;
1007
1008 if instruments.is_empty() {
1009 log::warn!("No instruments returned for Binance Spot");
1010 } else {
1011 log::debug!("Loaded {} Spot instruments", instruments.len());
1012 self.http_client.cache_instruments(instruments);
1013 }
1014
1015 self.core.set_instruments_initialized();
1016 }
1017
1018 self.restore_active_orders();
1019
1020 let account_state = self
1022 .refresh_account_state()
1023 .await
1024 .context("failed to request Binance account state")?;
1025
1026 if !account_state.balances.is_empty() {
1027 log::debug!(
1028 "Received account state with {} balance(s)",
1029 account_state.balances.len()
1030 );
1031 }
1032
1033 self.emitter.send_account_state(account_state);
1034
1035 crate::common::execution::await_account_registered(&self.core, self.core.account_id, 30.0)
1037 .await?;
1038
1039 let session_result = async {
1040 if self.config.us {
1041 self.connect_us_user_data().await?;
1042 }
1043
1044 if let Some(mut ws_trading) = self.ws_trading_client.clone() {
1045 match ws_trading.connect().await {
1046 Ok(()) => {
1047 log::debug!("Connected to Binance Spot WS trading API");
1048
1049 let ws_trading_clone = ws_trading.clone();
1050 let emitter = self.emitter.clone();
1051 let account_id = self.core.account_id;
1052 let clock = self.clock;
1053 let http_client = self.http_client.clone();
1054 let dispatch_state = self.dispatch_state.clone();
1055 let lifecycle_lock = self.lifecycle_lock.clone();
1056 let treat_expired_as_canceled = self.config.treat_expired_as_canceled;
1057 let ws_authenticated = self.ws_authenticated.clone();
1058 let ws_user_data_subscribed = self.ws_user_data_subscribed.clone();
1059 let (ws_setup_error_tx, mut ws_setup_error_rx) =
1060 tokio::sync::mpsc::unbounded_channel();
1061 let seen_trade_ids = self.dispatch_state.seen_trade_ids();
1062 let task_spawner = self
1063 .session_tasks
1064 .spawner()
1065 .context("Binance Spot session task admission is closed")?;
1066
1067 let future = async move {
1068 let mut resubscribing = false;
1069
1070 loop {
1071 match ws_trading_clone.recv().await {
1072 Some(msg) => {
1073 match &msg {
1074 BinanceSpotWsTradingMessage::Reconnected => {
1075 ws_trading_clone.mark_user_data_inactive();
1076 resubscribing = true;
1077 if let Err(e) = ws_trading_clone.session_logon().await {
1078 resubscribing = false;
1079 log::error!(
1080 "Failed to re-authenticate Binance Spot user data stream: {e}"
1081 );
1082 }
1083 }
1084 BinanceSpotWsTradingMessage::Authenticated if resubscribing => {
1085 if let Err(e) =
1086 ws_trading_clone.subscribe_user_data().await
1087 {
1088 resubscribing = false;
1089 log::error!(
1090 "Failed to resubscribe Binance Spot user data stream: {e}"
1091 );
1092 }
1093 continue;
1094 }
1095 BinanceSpotWsTradingMessage::UserDataSubscribed { .. } => {
1096 let was_resubscribing = resubscribing;
1097 resubscribing = false;
1098 ws_trading_clone.mark_user_data_active();
1099
1100 if was_resubscribing {
1101 continue;
1102 }
1103 }
1104 BinanceSpotWsTradingMessage::AuthenticationRejected(reason)
1105 if resubscribing =>
1106 {
1107 log::warn!(
1108 "Binance Spot reconnect authentication failed; retrying: {reason}"
1109 );
1110 tokio::time::sleep(WS_RECONNECT_SETUP_RETRY_DELAY).await;
1111
1112 if let Err(e) = ws_trading_clone.session_logon().await {
1113 resubscribing = false;
1114 log::error!(
1115 "Failed to retry Binance Spot reconnect authentication: {e}"
1116 );
1117 }
1118 continue;
1119 }
1120 BinanceSpotWsTradingMessage::UserDataSubscriptionRejected(reason)
1121 if resubscribing =>
1122 {
1123 log::warn!(
1124 "Binance Spot reconnect user data subscription failed; retrying: {reason}"
1125 );
1126 tokio::time::sleep(WS_RECONNECT_SETUP_RETRY_DELAY).await;
1127
1128 if let Err(e) =
1129 ws_trading_clone.subscribe_user_data().await
1130 {
1131 resubscribing = false;
1132 log::error!(
1133 "Failed to retry Binance Spot user data subscription: {e}"
1134 );
1135 }
1136 continue;
1137 }
1138 _ => {}
1139 }
1140
1141 let _lifecycle_guard = lifecycle_lock.lock();
1142 dispatch_ws_trading_message(
1143 msg,
1144 &emitter,
1145 &http_client,
1146 account_id,
1147 treat_expired_as_canceled,
1148 clock,
1149 &dispatch_state,
1150 &ws_authenticated,
1151 &ws_user_data_subscribed,
1152 &ws_setup_error_tx,
1153 &seen_trade_ids,
1154 &task_spawner,
1155 );
1156 }
1157 None => {
1158 log::debug!("WS trading dispatch loop ended");
1159 break;
1160 }
1161 }
1162 }
1163 };
1164 let dispatch = self
1165 .session_tasks
1166 .spawn_named("binance-spot-trading-dispatch", future)?;
1167 self.ws_trading_dispatch = Some(dispatch);
1168
1169 if let Err(e) = ws_trading.session_logon().await {
1170 let reason = format!("WS session logon failed: {e}");
1171 return Err(self.ws_setup_failure(ws_trading, reason).await);
1172 } else {
1173 let auth_result = wait_for_ws_setup_response(
1174 ws_setup_timeout,
1175 self.ws_authenticated.notified(),
1176 &mut ws_setup_error_rx,
1177 "WS session authentication timed out",
1178 )
1179 .await;
1180
1181 if let Err(e) = auth_result {
1182 return Err(self.ws_setup_failure(ws_trading, e.to_string()).await);
1183 } else if let Err(e) = ws_trading.subscribe_user_data().await {
1184 let reason = format!("WS user data subscribe failed: {e}");
1185 return Err(self.ws_setup_failure(ws_trading, reason).await);
1186 } else {
1187 let subscribe_result = wait_for_ws_setup_response(
1188 ws_setup_timeout,
1189 self.ws_user_data_subscribed.notified(),
1190 &mut ws_setup_error_rx,
1191 "WS user data subscription timed out",
1192 )
1193 .await;
1194
1195 if let Err(e) = subscribe_result {
1196 return Err(self.ws_setup_failure(ws_trading, e.to_string()).await);
1197 } else {
1198 self.ws_trading_client = Some(ws_trading);
1199 }
1200 }
1201 }
1202 }
1203 Err(e) => {
1204 let reason = format!("Failed to connect WS trading API: {e}");
1205 return Err(self.ws_setup_failure(ws_trading, reason).await);
1206 }
1207 }
1208 }
1209
1210 let refresh_secs = self.config.instrument_refresh_interval_secs;
1211 if refresh_secs > 0 {
1212 let http_client = self.http_client.clone();
1213 let provider = self.config.instrument_provider.clone();
1214 let us = self.config.us;
1215
1216 self.session_tasks.spawn(async move {
1217 let mut interval = tokio::time::interval(Duration::from_secs(refresh_secs));
1218 interval.tick().await;
1219
1220 loop {
1221 interval.tick().await;
1222
1223 match http_client
1224 .request_instruments_with_config(&provider, us)
1225 .await
1226 {
1227 Ok(instruments) => log::debug!(
1228 "Refreshed Binance Spot execution instruments: count={}",
1229 instruments.len()
1230 ),
1231 Err(e) => {
1232 log::warn!("Binance Spot execution instrument refresh failed: {e}");
1233 }
1234 }
1235 }
1236 })?;
1237 }
1238
1239 Ok::<(), anyhow::Error>(())
1240 }
1241 .await;
1242
1243 if let Err(e) = session_result {
1244 if let Err(teardown_error) = self.teardown_partial_connect().await {
1245 return Err(e.context(format!(
1246 "Binance Spot startup teardown failed: {teardown_error}"
1247 )));
1248 }
1249 return Err(e);
1250 }
1251
1252 setup_guard.disarm();
1253 self.core.set_connected();
1254 log::info!("Connected: client_id={}", self.core.client_id);
1255 Ok(())
1256 }
1257
1258 async fn disconnect(&mut self) -> anyhow::Result<()> {
1259 self.teardown_partial_connect().await?;
1260 log::info!("Disconnected: client_id={}", self.core.client_id);
1261 Ok(())
1262 }
1263
1264 fn query_account(&self, _cmd: QueryAccount) -> anyhow::Result<()> {
1265 self.update_account_state();
1266 Ok(())
1267 }
1268
1269 fn query_order(&self, cmd: QueryOrder) -> anyhow::Result<()> {
1270 log::debug!("query_order: client_order_id={}", cmd.client_order_id);
1271
1272 let http_client = self.http_client.clone();
1273 let command = cmd;
1274 let event_emitter = self.emitter.clone();
1275 let account_id = self.core.account_id;
1276 let treat_expired_as_canceled = self.config.treat_expired_as_canceled;
1277
1278 self.spawn_task("query_order", async move {
1279 let result = http_client
1280 .request_order_status_report(
1281 account_id,
1282 command.instrument_id,
1283 command.venue_order_id,
1284 Some(command.client_order_id),
1285 )
1286 .await;
1287
1288 match result {
1289 Ok(Some(mut report)) => {
1290 normalize_spot_order_status_report(&mut report, treat_expired_as_canceled);
1291 event_emitter.send_order_status_report(report);
1292 }
1293 Ok(None) => log::debug!(
1294 "No order status report returned: client_order_id={}",
1295 command.client_order_id
1296 ),
1297 Err(e) => log::warn!("Failed to query order status: {e}"),
1298 }
1299
1300 Ok(())
1301 });
1302
1303 Ok(())
1304 }
1305
1306 fn generate_account_state(
1307 &self,
1308 balances: Vec<AccountBalance>,
1309 margins: Vec<MarginBalance>,
1310 reported: bool,
1311 ts_event: UnixNanos,
1312 info: Option<Params>,
1313 ) -> anyhow::Result<()> {
1314 self.emitter
1315 .emit_account_state(balances, margins, reported, ts_event, info);
1316 Ok(())
1317 }
1318
1319 fn start(&mut self) -> anyhow::Result<()> {
1320 if self.core.is_started() {
1321 return Ok(());
1322 }
1323
1324 self.emitter.set_sender(get_exec_event_sender());
1325 self.core.set_started();
1326
1327 let http_client = self.http_client.clone();
1329 let provider = self.config.instrument_provider.clone();
1330 let us = self.config.us;
1331
1332 self.session_tasks.spawn(async move {
1333 match http_client
1334 .request_instruments_with_config(&provider, us)
1335 .await
1336 {
1337 Ok(instruments) => {
1338 if instruments.is_empty() {
1339 log::warn!("No instruments returned for Binance Spot");
1340 } else {
1341 http_client.cache_instruments(instruments);
1342 log::debug!("Instruments initialized");
1343 }
1344 }
1345 Err(e) => {
1346 log::warn!("Failed to request Binance Spot instruments: {e}");
1347 }
1348 }
1349 })?;
1350
1351 log::info!(
1352 "Started: client_id={}, account_id={}, account_type={:?}, environment={:?}, product_type={:?}",
1353 self.core.client_id,
1354 self.core.account_id,
1355 self.core.account_type,
1356 self.config.environment,
1357 self.config.product_type,
1358 );
1359 Ok(())
1360 }
1361
1362 fn stop(&mut self) -> anyhow::Result<()> {
1363 let was_started = self.core.is_started();
1364 self.core.set_stopped();
1365 self.begin_generation_shutdown();
1366
1367 if was_started {
1368 log::info!("Stopped: client_id={}", self.core.client_id);
1369 }
1370 Ok(())
1371 }
1372
1373 fn reset(&mut self) -> anyhow::Result<()> {
1374 self.begin_generation_shutdown();
1375 Ok(())
1376 }
1377
1378 fn dispose(&mut self) -> anyhow::Result<()> {
1379 self.begin_generation_shutdown();
1380 Ok(())
1381 }
1382
1383 async fn generate_order_status_report(
1384 &self,
1385 cmd: &GenerateOrderStatusReport,
1386 ) -> anyhow::Result<Option<OrderStatusReport>> {
1387 let Some(instrument_id) = cmd.instrument_id else {
1388 log::warn!("generate_order_status_report requires instrument_id: {cmd}");
1389 return Ok(None);
1390 };
1391
1392 anyhow::ensure!(
1393 !self.config.instrument_provider.excludes(instrument_id),
1394 "Cannot query Binance Spot order for excluded instrument {instrument_id}"
1395 );
1396
1397 let venue_order_id = cmd
1399 .venue_order_id
1400 .as_ref()
1401 .map(|id| VenueOrderId::new(id.inner()));
1402
1403 let report = self
1404 .http_client
1405 .request_order_status_report(
1406 self.core.account_id,
1407 instrument_id,
1408 venue_order_id,
1409 cmd.client_order_id,
1410 )
1411 .await?;
1412
1413 Ok(report.map(|mut report| {
1414 normalize_spot_order_status_report(&mut report, self.config.treat_expired_as_canceled);
1415 report
1416 }))
1417 }
1418
1419 async fn generate_order_status_reports(
1420 &self,
1421 cmd: &GenerateOrderStatusReports,
1422 ) -> anyhow::Result<Vec<OrderStatusReport>> {
1423 let start_dt = cmd.start.map(|nanos| nanos.to_datetime_utc());
1424 let end_dt = cmd.end.map(|nanos| nanos.to_datetime_utc());
1425
1426 let mut reports = self
1427 .http_client
1428 .request_order_status_reports_scoped(
1429 self.core.account_id,
1430 cmd.instrument_id,
1431 start_dt,
1432 end_dt,
1433 cmd.open_only,
1434 None, Some(&self.config.instrument_provider),
1436 )
1437 .await?;
1438
1439 normalize_spot_order_status_reports(&mut reports, self.config.treat_expired_as_canceled);
1440
1441 crate::common::execution::log_report_receipt(
1442 reports.len(),
1443 "OrderStatusReport",
1444 cmd.log_receipt_level,
1445 );
1446 Ok(reports)
1447 }
1448
1449 async fn generate_fill_reports(
1450 &self,
1451 cmd: GenerateFillReports,
1452 ) -> anyhow::Result<Vec<FillReport>> {
1453 let Some(instrument_id) = cmd.instrument_id else {
1454 log::warn!("generate_fill_reports requires instrument_id for Binance Spot");
1455 return Ok(Vec::new());
1456 };
1457
1458 if self.config.instrument_provider.excludes(instrument_id) {
1459 log::debug!("Dropping out-of-scope Binance Spot report request for {instrument_id}");
1460 return Ok(Vec::new());
1461 }
1462
1463 let venue_order_id = cmd
1465 .venue_order_id
1466 .as_ref()
1467 .map(|id| VenueOrderId::new(id.inner()));
1468 let requested_start_time = cmd
1469 .start
1470 .map(|start| start.as_i64() / NANOSECONDS_IN_MILLISECOND as i64);
1471 let requested_end_time = cmd
1472 .end
1473 .map(|end| end.as_i64() / NANOSECONDS_IN_MILLISECOND as i64);
1474 if let (Some(start), Some(end)) = (requested_start_time, requested_end_time) {
1475 anyhow::ensure!(
1476 start <= end,
1477 "fill report start time must not exceed end time"
1478 );
1479 }
1480
1481 let mut reports = Vec::new();
1482 let mut seen_trade_ids = AHashSet::new();
1483
1484 if venue_order_id.is_some() {
1485 let mut from_id = 0;
1486
1487 loop {
1488 let page = self
1489 .http_client
1490 .request_fill_reports_with_cursor(
1491 self.core.account_id,
1492 instrument_id,
1493 venue_order_id,
1494 None,
1495 None,
1496 Some(from_id),
1497 Some(ACCOUNT_TRADES_PAGE_LIMIT),
1498 )
1499 .await?;
1500
1501 if page.is_empty() {
1502 break;
1503 }
1504
1505 let page_len = page.len();
1506 let max_trade_id = max_trade_id(&page)?;
1507 let passed_end = requested_end_time.is_some_and(|end_time| {
1508 page.iter().any(|report| report_time_ms(report) > end_time)
1509 });
1510
1511 reports.extend(page.into_iter().filter(|report| {
1512 requested_start_time
1513 .is_none_or(|start_time| report_time_ms(report) >= start_time)
1514 && requested_end_time
1515 .is_none_or(|end_time| report_time_ms(report) <= end_time)
1516 && seen_trade_ids.insert(report.trade_id)
1517 }));
1518
1519 if page_len < ACCOUNT_TRADES_PAGE_LIMIT as usize || passed_end {
1520 break;
1521 }
1522
1523 let next_from_id = max_trade_id
1524 .checked_add(1)
1525 .context("Binance Spot trade ID overflow during pagination")?;
1526 anyhow::ensure!(
1527 next_from_id > from_id,
1528 "Binance Spot account-trades pagination made no progress"
1529 );
1530 from_id = next_from_id;
1531 }
1532 } else if let Some(query_start_time) = requested_start_time {
1533 let query_end_time = requested_end_time.unwrap_or_else(|| {
1534 self.clock.get_time_ns().as_i64() / NANOSECONDS_IN_MILLISECOND as i64
1535 });
1536 anyhow::ensure!(
1537 query_start_time <= query_end_time,
1538 "fill report start time must not exceed end time"
1539 );
1540 let mut window_start = query_start_time;
1541
1542 loop {
1543 let window_end = window_start
1544 .saturating_add(ACCOUNT_TRADES_MAX_INTERVAL_MS)
1545 .min(query_end_time);
1546 let mut from_id = None;
1547
1548 loop {
1549 let start = if from_id.is_none() {
1550 Some(
1551 Timestamp::from_millisecond(window_start)
1552 .context("invalid Binance Spot account-trades start time")?,
1553 )
1554 } else {
1555 None
1556 };
1557 let end = if from_id.is_none() {
1558 Some(
1559 Timestamp::from_millisecond(window_end)
1560 .context("invalid Binance Spot account-trades end time")?,
1561 )
1562 } else {
1563 None
1564 };
1565 let page = self
1566 .http_client
1567 .request_fill_reports_with_cursor(
1568 self.core.account_id,
1569 instrument_id,
1570 None,
1571 start,
1572 end,
1573 from_id,
1574 Some(ACCOUNT_TRADES_PAGE_LIMIT),
1575 )
1576 .await?;
1577
1578 if page.is_empty() {
1579 break;
1580 }
1581
1582 let page_len = page.len();
1583 let max_trade_id = max_trade_id(&page)?;
1584 let passed_window_end = page
1585 .iter()
1586 .any(|report| report_time_ms(report) > window_end);
1587
1588 reports.extend(page.into_iter().filter(|report| {
1589 let report_time = report_time_ms(report);
1590 report_time >= window_start
1591 && report_time <= window_end
1592 && seen_trade_ids.insert(report.trade_id)
1593 }));
1594
1595 if page_len < ACCOUNT_TRADES_PAGE_LIMIT as usize || passed_window_end {
1596 break;
1597 }
1598
1599 let next_from_id = max_trade_id
1600 .checked_add(1)
1601 .context("Binance Spot trade ID overflow during pagination")?;
1602 anyhow::ensure!(
1603 from_id.is_none_or(|cursor| next_from_id > cursor),
1604 "Binance Spot account-trades pagination made no progress"
1605 );
1606 from_id = Some(next_from_id);
1607 }
1608
1609 if window_end >= query_end_time {
1610 break;
1611 }
1612 window_start = window_end.saturating_add(1);
1613 }
1614 } else {
1615 let mut from_id = 0;
1616
1617 loop {
1618 let page = self
1619 .http_client
1620 .request_fill_reports_with_cursor(
1621 self.core.account_id,
1622 instrument_id,
1623 None,
1624 None,
1625 None,
1626 Some(from_id),
1627 Some(ACCOUNT_TRADES_PAGE_LIMIT),
1628 )
1629 .await?;
1630
1631 if page.is_empty() {
1632 break;
1633 }
1634
1635 let page_len = page.len();
1636 let max_trade_id = max_trade_id(&page)?;
1637 let passed_end = requested_end_time.is_some_and(|end_time| {
1638 page.iter().any(|report| report_time_ms(report) > end_time)
1639 });
1640
1641 reports.extend(page.into_iter().filter(|report| {
1642 requested_end_time.is_none_or(|end_time| report_time_ms(report) <= end_time)
1643 && seen_trade_ids.insert(report.trade_id)
1644 }));
1645
1646 if page_len < ACCOUNT_TRADES_PAGE_LIMIT as usize || passed_end {
1647 break;
1648 }
1649
1650 let next_from_id = max_trade_id
1651 .checked_add(1)
1652 .context("Binance Spot trade ID overflow during pagination")?;
1653 anyhow::ensure!(
1654 next_from_id > from_id,
1655 "Binance Spot account-trades pagination made no progress"
1656 );
1657 from_id = next_from_id;
1658 }
1659 }
1660
1661 let mut reports_with_trade_ids = reports
1662 .into_iter()
1663 .map(|report| parse_trade_id(&report).map(|trade_id| (report, trade_id)))
1664 .collect::<anyhow::Result<Vec<_>>>()?;
1665 reports_with_trade_ids
1666 .sort_unstable_by_key(|(report, trade_id)| (report.ts_event, *trade_id));
1667 crate::common::execution::log_report_receipt(
1668 reports_with_trade_ids.len(),
1669 "FillReport",
1670 cmd.log_receipt_level,
1671 );
1672 Ok(reports_with_trade_ids
1673 .into_iter()
1674 .map(|(report, _)| report)
1675 .collect())
1676 }
1677
1678 async fn generate_position_status_reports(
1679 &self,
1680 cmd: &GeneratePositionStatusReports,
1681 ) -> anyhow::Result<Vec<PositionStatusReport>> {
1682 crate::common::execution::log_report_receipt(
1685 0,
1686 "PositionStatusReport",
1687 cmd.log_receipt_level,
1688 );
1689 Ok(Vec::new())
1690 }
1691
1692 async fn generate_mass_status(
1693 &self,
1694 lookback_mins: Option<u64>,
1695 ) -> anyhow::Result<Option<ExecutionMassStatus>> {
1696 log::info!("Generating ExecutionMassStatus (lookback_mins={lookback_mins:?})");
1697
1698 let ts_now = self.clock.get_time_ns();
1699
1700 let start = lookback_mins
1701 .map(DurationNanos::try_from_mins)
1702 .transpose()?
1703 .map(|lookback| ts_now.saturating_sub(lookback));
1704
1705 let order_cmd = GenerateOrderStatusReportsBuilder::default()
1706 .log_receipt_level(LogLevel::Off)
1707 .ts_init(ts_now)
1708 .open_only(true)
1709 .start(start)
1710 .build()
1711 .map_err(|e| anyhow::anyhow!("{e}"))?;
1712
1713 let position_cmd = GeneratePositionStatusReportsBuilder::default()
1714 .log_receipt_level(LogLevel::Off)
1715 .ts_init(ts_now)
1716 .start(start)
1717 .build()
1718 .map_err(|e| anyhow::anyhow!("{e}"))?;
1719
1720 let (order_reports, position_reports) = tokio::try_join!(
1721 self.generate_order_status_reports(&order_cmd),
1722 self.generate_position_status_reports(&position_cmd),
1723 )?;
1724
1725 let mut instrument_ids: Vec<_> = order_reports
1726 .iter()
1727 .map(|report| report.instrument_id)
1728 .collect();
1729 {
1730 let cache = self.core.cache();
1731 instrument_ids.extend(cache.external_order_claim_instrument_ids(None));
1732 instrument_ids.extend(
1733 cache
1734 .positions_open(
1735 Some(&BINANCE_VENUE),
1736 None,
1737 None,
1738 Some(&self.core.account_id),
1739 None,
1740 )
1741 .into_iter()
1742 .map(|position| position.instrument_id),
1743 );
1744 instrument_ids.extend(
1745 cache
1746 .orders_open(
1747 Some(&BINANCE_VENUE),
1748 None,
1749 None,
1750 Some(&self.core.account_id),
1751 None,
1752 )
1753 .into_iter()
1754 .chain(cache.orders_inflight(
1755 Some(&BINANCE_VENUE),
1756 None,
1757 None,
1758 Some(&self.core.account_id),
1759 None,
1760 ))
1761 .map(|order| order.instrument_id())
1762 .filter(|instrument_id| {
1763 self.http_client
1764 .get_instrument(&instrument_id.symbol.inner())
1765 .is_some_and(|instrument| instrument.id() == *instrument_id)
1766 }),
1767 );
1768 }
1769
1770 let selector = BinanceInstrumentSelector::new(
1771 &self.config.instrument_provider,
1772 self.config.product_type,
1773 )?;
1774 instrument_ids.extend(
1775 self.http_client
1776 .instrument_ids_reconciliation()
1777 .into_iter()
1778 .filter(|id| selector.is_explicit(*id, id.symbol.as_str())),
1779 );
1780
1781 {
1782 let cache = self.core.cache();
1783 instrument_ids.retain(|id| {
1784 id.venue == *BINANCE_VENUE
1785 && !self.config.instrument_provider.excludes(*id)
1786 && cache.instrument(id).is_none_or(|instrument| {
1787 matches!(instrument, InstrumentAny::CurrencyPair(_))
1788 })
1789 });
1790 }
1791
1792 instrument_ids.sort_unstable();
1793 instrument_ids.dedup();
1794
1795 let mut order_reports: IndexMap<_, _> = order_reports
1796 .into_iter()
1797 .map(|report| (report.venue_order_id, report))
1798 .collect();
1799 let mut reports_complete = true;
1800 let mut fill_reports = Vec::new();
1801
1802 for instrument_id in instrument_ids {
1803 if self
1804 .http_client
1805 .get_instrument(&instrument_id.symbol.inner())
1806 .is_none_or(|instrument| instrument.id() != instrument_id)
1807 {
1808 log::warn!("Cannot recover Binance Spot history for unresolved {instrument_id}");
1809 reports_complete = false;
1810 continue;
1811 }
1812
1813 match self
1814 .http_client
1815 .request_order_history(self.core.account_id, instrument_id, start, ts_now)
1816 .await
1817 {
1818 Ok(mut history) => {
1819 normalize_spot_order_status_reports(
1820 &mut history,
1821 self.config.treat_expired_as_canceled,
1822 );
1823 crate::common::execution::merge_order_history(
1824 &mut order_reports,
1825 history,
1826 start,
1827 ts_now,
1828 );
1829 }
1830 Err(e) => {
1831 log::warn!("Failed to recover Binance Spot history for {instrument_id}: {e}");
1832 reports_complete = false;
1833 }
1834 }
1835
1836 let fill_cmd = GenerateFillReportsBuilder::default()
1837 .log_receipt_level(LogLevel::Off)
1838 .ts_init(ts_now)
1839 .instrument_id(Some(instrument_id))
1840 .start(start)
1841 .end(start.map(|_| ts_now))
1842 .build()
1843 .map_err(|e| anyhow::anyhow!("{e}"))?;
1844 fill_reports.extend(self.generate_fill_reports(fill_cmd).await?);
1845 }
1846
1847 log::info!("Received {} OrderStatusReports", order_reports.len());
1848 log::info!("Received {} FillReports", fill_reports.len());
1849 log::info!("Received {} PositionReports", position_reports.len());
1850
1851 let mut mass_status = ExecutionMassStatus::new(
1852 self.core.client_id,
1853 self.core.account_id,
1854 *BINANCE_VENUE,
1855 ts_now,
1856 None,
1857 );
1858
1859 let cache = self.core.cache();
1860
1861 let reports_complete = reports_complete
1862 && fill_reports.iter().all(|fill| {
1863 order_reports.contains_key(&fill.venue_order_id)
1864 || cache
1865 .client_order_id(&fill.venue_order_id)
1866 .and_then(|client_order_id| cache.order(client_order_id))
1867 .is_some_and(|order| {
1868 order.instrument_id() == fill.instrument_id
1869 && order.account_id() == Some(fill.account_id)
1870 && order.order_side() == fill.order_side
1871 })
1872 });
1873
1874 mass_status.set_report_window(Some(start.unwrap_or_default()), reports_complete);
1875 self.dispatch_state
1876 .restore_terminal_fills(&order_reports, &fill_reports);
1877 mass_status.add_order_reports(order_reports.into_values().collect());
1878 mass_status.add_fill_reports(fill_reports);
1879 mass_status.add_position_reports(position_reports);
1880
1881 Ok(Some(mass_status))
1882 }
1883
1884 fn submit_order(&self, cmd: SubmitOrder) -> anyhow::Result<()> {
1885 let order = self.core.cache().try_order_owned(&cmd.client_order_id)?;
1886
1887 if order.is_closed() {
1888 let client_order_id = order.client_order_id();
1889 log::warn!("Cannot submit closed order {client_order_id}");
1890 return Ok(());
1891 }
1892
1893 if let Err(reason) = validate_order(&order, self.config.use_gtd) {
1894 self.emitter.emit_order_denied(&order, &reason.to_string());
1895 return Ok(());
1896 }
1897
1898 self.ensure_ws_user_data_active()?;
1899
1900 let params = if self.ws_order_transport_active() {
1901 match build_new_order_params(
1902 &order,
1903 order.client_order_id(),
1904 order.is_post_only(),
1905 order.is_quote_quantity(),
1906 self.config.use_gtd,
1907 ) {
1908 Ok(params) => Some(params),
1909 Err(e) => {
1910 let reason = OrderDeniedReason::ValidationFailed {
1911 detail: e.to_string(),
1912 };
1913 self.emitter.emit_order_denied(&order, &reason.to_string());
1914 return Ok(());
1915 }
1916 }
1917 } else {
1918 None
1919 };
1920
1921 log::debug!("OrderSubmitted client_order_id={}", order.client_order_id());
1922 self.emitter.emit_order_submitted(&order);
1923
1924 self.submit_order_internal(&cmd, params)
1925 }
1926
1927 fn submit_order_list(&self, cmd: SubmitOrderList) -> anyhow::Result<()> {
1928 if cmd.order_list.client_order_ids.is_empty() {
1929 log::debug!("submit_order_list called with empty order list");
1930 return Ok(());
1931 }
1932
1933 self.ensure_ws_user_data_active()?;
1934
1935 let orders = self.core.get_orders_for_list(&cmd.order_list)?;
1936
1937 if let Some(reason) = orders
1938 .iter()
1939 .find_map(|order| validate_order(order, self.config.use_gtd).err())
1940 {
1941 let reason = reason.to_string();
1942
1943 for order in &orders {
1944 self.emitter.emit_order_denied(order, &reason);
1945 }
1946 return Ok(());
1947 }
1948
1949 if let Some(order) = orders.iter().find(|order| order.is_closed()) {
1950 let reason = format!("Cannot submit closed order {}", order.client_order_id());
1951 for order in &orders {
1952 self.emitter.emit_order_denied(order, &reason);
1953 }
1954 return Ok(());
1955 }
1956
1957 let params = match build_spot_order_list_params(
1958 cmd.order_list.id.as_ref(),
1959 &orders,
1960 self.config.use_gtd,
1961 ) {
1962 Ok(request) => request,
1963 Err(reason) => {
1964 for order in &orders {
1965 self.emitter.emit_order_denied(order, &reason);
1966 }
1967 return Ok(());
1968 }
1969 };
1970
1971 for order in &orders {
1972 self.dispatch_state.order_identities.insert(
1973 order.client_order_id(),
1974 OrderIdentity {
1975 instrument_id: order.instrument_id(),
1976 strategy_id: order.strategy_id(),
1977 order_side: order.order_side(),
1978 order_type: order.order_type(),
1979 price: order.price(),
1980 quantity: order.quantity(),
1981 is_quote_quantity: order.is_quote_quantity(),
1982 venue_position_id: None,
1983 },
1984 );
1985 self.emitter.emit_order_submitted(order);
1986 }
1987
1988 let event_emitter = self.emitter.clone();
1989 let account_id = self.core.account_id;
1990 let clock = self.clock;
1991 let http_client = self.http_client.clone();
1992 let dispatch_state = self.dispatch_state.clone();
1993
1994 let lifecycle_lock = self.lifecycle_lock.clone();
1995 self.spawn_task("submit_order_list_http", async move {
1996 if let Err(e) = submit_spot_order_list(&http_client, ¶ms).await {
1997 let _lifecycle_guard = lifecycle_lock.lock();
1998 handle_spot_order_list_submit_error(
1999 &event_emitter,
2000 &dispatch_state,
2001 account_id,
2002 clock,
2003 &orders,
2004 e,
2005 )?;
2006 }
2007
2008 Ok(())
2009 });
2010
2011 Ok(())
2012 }
2013
2014 fn modify_order(&self, cmd: ModifyOrder) -> anyhow::Result<()> {
2015 let order = self
2019 .core
2020 .cache()
2021 .order(&cmd.client_order_id)
2022 .map(|o| o.clone());
2023
2024 let Some(order) = order else {
2025 log::warn!(
2026 "Cannot modify order {}: not found in cache",
2027 cmd.client_order_id
2028 );
2029 let ts_init = self.clock.get_time_ns();
2030
2031 let mut rejected_event = OrderModifyDenied::new(
2032 self.core.trader_id,
2033 cmd.strategy_id,
2034 cmd.instrument_id,
2035 cmd.client_order_id,
2036 "Order not found in cache for modify".into(),
2037 UUID4::new(),
2038 ts_init, ts_init,
2040 cmd.venue_order_id,
2041 Some(self.core.account_id),
2042 );
2043 rejected_event.causation_id = Some(cmd.command_id);
2044
2045 self.emitter
2046 .send_order_event(OrderEventAny::ModifyDenied(rejected_event));
2047 return Ok(());
2048 };
2049
2050 let event_emitter = self.emitter.clone();
2051 let trader_id = self.core.trader_id;
2052 let account_id = self.core.account_id;
2053 let clock = self.clock;
2054
2055 let order_side = order.order_side();
2056 let order_type = order.order_type();
2057 let time_in_force = order.time_in_force();
2058 let quantity = cmd.quantity.unwrap_or_else(|| order.quantity());
2059 let use_gtd = self.config.use_gtd;
2060 let dispatch_state = self.dispatch_state.clone();
2061
2062 if self.ws_order_transport_active() {
2063 let command = cmd;
2064 let ws_client = self.ws_trading_client.as_ref().unwrap().clone();
2065 let cancel_id = cancel_replace_cancel_id();
2066 dispatch_state.insert_cancel_replace(cancel_id.clone());
2067 let params = build_cancel_replace_params(
2068 &command,
2069 &order,
2070 quantity,
2071 use_gtd,
2072 cancel_id.clone(),
2073 )?;
2074
2075 if let Some(venue_order_id) = command.venue_order_id {
2076 dispatch_state.begin_replace(command.client_order_id, venue_order_id);
2077 }
2078
2079 let request_id = ws_client.next_request_id();
2081 dispatch_state.pending_requests.insert(
2082 request_id.clone(),
2083 PendingRequest {
2084 command_id: Some(command.command_id),
2085 client_order_id: command.client_order_id,
2086 venue_order_id: command.venue_order_id,
2087 operation: PendingOperation::Modify,
2088 },
2089 );
2090 dispatch_state
2091 .cancel_replace_request_ids
2092 .insert(request_id.clone(), cancel_id.clone());
2093
2094 let http_client = self.http_client.clone();
2095 self.spawn_task("modify_order_ws", async move {
2096 let mut params = params;
2097 http_client
2098 .inner()
2099 .resolve_cancel_replace(&mut params)
2100 .await
2101 .inspect_err(|e| {
2102 dispatch_state.pending_requests.remove(&request_id);
2103 dispatch_state
2104 .cancel_replace_request_ids
2105 .remove(&request_id);
2106 handle_http_modify_failure(
2107 &anyhow::anyhow!(BinanceSpotHttpError::ValidationError(e.to_string())),
2108 &command,
2109 &cancel_id,
2110 &event_emitter,
2111 &dispatch_state,
2112 account_id,
2113 clock.get_time_ns(),
2114 );
2115 })?;
2116
2117 let result = ws_client
2118 .cancel_replace_order_with_id(request_id.clone(), params)
2119 .await;
2120
2121 if let Err(e) = result {
2122 dispatch_state.pending_requests.remove(&request_id);
2123 dispatch_state
2124 .cancel_replace_request_ids
2125 .remove(&request_id);
2126 log::warn!(
2127 "WS modify request failed for {}, awaiting reconciliation: {e}",
2128 command.client_order_id
2129 );
2130 anyhow::bail!("WS modify order failed: {e}");
2131 }
2132 Ok(())
2133 });
2134 } else {
2135 let command = cmd;
2136 let http_client = self.http_client.clone();
2137 log::debug!("WS trading not active, falling back to HTTP for modify_order");
2138 let dispatch_state = self.dispatch_state.clone();
2139 let cancel_id = cancel_replace_cancel_id();
2140 dispatch_state.insert_cancel_replace(cancel_id.clone());
2141
2142 if let Some(venue_order_id) = command.venue_order_id {
2143 dispatch_state.begin_replace(command.client_order_id, venue_order_id);
2144 }
2145
2146 self.spawn_task("modify_order_http", async move {
2147 let result = match command.venue_order_id {
2148 Some(venue_order_id) => {
2149 http_client
2150 .modify_order(
2151 account_id,
2152 command.instrument_id,
2153 venue_order_id,
2154 command.client_order_id,
2155 order_side,
2156 order_type,
2157 quantity,
2158 time_in_force,
2159 command.price,
2160 use_gtd,
2161 &cancel_id,
2162 )
2163 .await
2164 }
2165 None => Err(anyhow::anyhow!(BinanceSpotHttpError::ValidationError(
2166 "venue_order_id required for modify".to_string()
2167 ))),
2168 };
2169
2170 match result {
2171 Ok(report) => {
2172 let Some(price) = report.price else {
2173 anyhow::bail!("Spot replacement response has no price");
2174 };
2175
2176 if dispatch_state.record_order_update(
2177 command.client_order_id,
2178 report.venue_order_id,
2179 report.quantity,
2180 price,
2181 report.trigger_price,
2182 ) != Some(true)
2183 {
2184 return Ok(());
2185 }
2186 let ts_now = clock.get_time_ns();
2187 let updated_event = OrderUpdated::new(
2188 trader_id,
2189 command.strategy_id,
2190 command.instrument_id,
2191 command.client_order_id,
2192 report.quantity,
2193 UUID4::new(),
2194 ts_now,
2195 ts_now,
2196 false,
2197 Some(report.venue_order_id),
2198 Some(account_id),
2199 report.price,
2200 None, None, false, );
2204 event_emitter.send_order_event(OrderEventAny::Updated(updated_event));
2205 }
2206 Err(e) => {
2207 handle_http_modify_failure(
2208 &e,
2209 &command,
2210 &cancel_id,
2211 &event_emitter,
2212 &dispatch_state,
2213 account_id,
2214 clock.get_time_ns(),
2215 );
2216 return Err(e);
2217 }
2218 }
2219 Ok(())
2220 });
2221 }
2222
2223 Ok(())
2224 }
2225
2226 fn cancel_order(&self, cmd: CancelOrder) -> anyhow::Result<()> {
2227 self.cancel_order_internal(&cmd);
2228 Ok(())
2229 }
2230
2231 fn cancel_all_orders(&self, cmd: CancelAllOrders) -> anyhow::Result<()> {
2232 if cmd.order_side.is_some() {
2233 let cancels: Vec<CancelOrder> = {
2235 let cache = self.core.cache();
2236 cache
2237 .orders_open(None, Some(&cmd.instrument_id), None, None, cmd.order_side)
2238 .into_iter()
2239 .map(|order| CancelOrder {
2240 trader_id: order.trader_id(),
2241 client_id: cmd.client_id,
2242 strategy_id: order.strategy_id(),
2243 instrument_id: order.instrument_id(),
2244 client_order_id: order.client_order_id(),
2245 venue_order_id: order.venue_order_id(),
2246 command_id: cmd.command_id,
2247 ts_init: cmd.ts_init,
2248 params: cmd.params.clone(),
2249 correlation_id: cmd.correlation_id,
2250 causation_id: cmd.causation_id,
2251 })
2252 .collect()
2253 };
2254
2255 if cancels.is_empty() {
2256 log::debug!("No open orders to cancel for {}", cmd.instrument_id);
2257 return Ok(());
2258 }
2259
2260 return self.batch_cancel_orders(BatchCancelOrders {
2261 trader_id: cmd.trader_id,
2262 client_id: cmd.client_id,
2263 strategy_id: cmd.strategy_id,
2264 instrument_id: cmd.instrument_id,
2265 cancels,
2266 command_id: cmd.command_id,
2267 ts_init: cmd.ts_init,
2268 params: cmd.params,
2269 correlation_id: cmd.correlation_id,
2270 causation_id: cmd.causation_id,
2271 });
2272 }
2273
2274 let event_emitter = self.emitter.clone();
2275 let trader_id = self.core.trader_id;
2276 let account_id = self.core.account_id;
2277 let clock = self.clock;
2278
2279 if self.ws_order_transport_active() {
2280 let ws_client = self.ws_trading_client.as_ref().unwrap().clone();
2281 let symbol = cmd.instrument_id.symbol.to_string();
2282
2283 self.spawn_task("cancel_all_orders_ws", async move {
2284 if let Err(e) = ws_client.cancel_all_orders(symbol).await {
2285 log::error!("WS cancel_all_orders failed: {e}");
2286 }
2287 Ok(())
2289 });
2290
2291 return Ok(());
2292 }
2293
2294 log::debug!("WS trading not active, falling back to HTTP for cancel_all_orders");
2295 let http_client = self.http_client.clone();
2296 let dispatch_state = self.dispatch_state.clone();
2297 let lifecycle_lock = self.lifecycle_lock.clone();
2298
2299 let strategy_lookup: AHashMap<ClientOrderId, StrategyId> = {
2301 let cache = self.core.cache();
2302 cache
2303 .orders_open(None, Some(&cmd.instrument_id), None, None, None)
2304 .into_iter()
2305 .map(|order| (order.client_order_id(), order.strategy_id()))
2306 .collect()
2307 };
2308
2309 let command = cmd;
2310 self.spawn_task("cancel_all_orders_http", async move {
2311 let responses = http_client
2312 .cancel_all_order_responses(command.instrument_id)
2313 .await?;
2314 let canceled_orders = prepare_cancel_all_orders(responses)?;
2315 anyhow::ensure!(
2316 canceled_orders
2317 .iter()
2318 .all(|order| order.instrument_id == command.instrument_id),
2319 "cancel-all response contains an order for a different instrument",
2320 );
2321 let _lifecycle_guard = lifecycle_lock.lock();
2322
2323 for canceled_order in canceled_orders {
2324 let client_order_id = canceled_order.client_order_id;
2325 if canceled_order.order_list {
2326 dispatch_order_list_canceled(
2327 &canceled_order,
2328 &event_emitter,
2329 account_id,
2330 &dispatch_state,
2331 clock.get_time_ns(),
2332 );
2333 continue;
2334 }
2335 let strategy_id = strategy_lookup
2336 .get(&client_order_id)
2337 .copied()
2338 .unwrap_or(command.strategy_id);
2339
2340 if dispatch_state.is_terminal(&client_order_id) {
2341 continue;
2342 }
2343
2344 dispatch_state.cleanup_terminal(client_order_id);
2345
2346 let canceled_event = OrderCanceled::new(
2347 trader_id,
2348 strategy_id,
2349 command.instrument_id,
2350 client_order_id,
2351 UUID4::new(),
2352 command.ts_init,
2353 clock.get_time_ns(),
2354 false,
2355 Some(canceled_order.venue_order_id),
2356 Some(account_id),
2357 None,
2358 );
2359
2360 event_emitter.send_order_event(OrderEventAny::Canceled(canceled_event));
2361 }
2362
2363 Ok(())
2364 });
2365
2366 Ok(())
2367 }
2368
2369 fn batch_cancel_orders(&self, cmd: BatchCancelOrders) -> anyhow::Result<()> {
2370 if cmd.cancels.is_empty() {
2371 return Ok(());
2372 }
2373
2374 for cancel in &cmd.cancels {
2376 self.cancel_order_internal(cancel);
2377 }
2378
2379 Ok(())
2380 }
2381}
2382
2383fn validate_order(order: &impl Order, use_gtd: bool) -> Result<(), OrderDeniedReason> {
2384 if order.is_reduce_only() {
2385 return Err(OrderDeniedReason::UnsupportedReduceOnly);
2386 }
2387
2388 let order_type = order.order_type();
2389 let venue_type = order_type_to_binance_spot(order_type, order.is_post_only())
2390 .map_err(|_| OrderDeniedReason::UnsupportedOrderType { order_type })?;
2391
2392 if matches!(
2393 venue_type,
2394 BinanceSpotOrderType::Limit
2395 | BinanceSpotOrderType::StopLossLimit
2396 | BinanceSpotOrderType::TakeProfitLimit
2397 ) {
2398 time_in_force_to_binance_spot(order.time_in_force(), use_gtd)
2399 .map_err(|_| OrderDeniedReason::UnsupportedTimeInForce(order.time_in_force()))?;
2400 }
2401
2402 if matches!(
2403 order_type,
2404 OrderType::StopMarket
2405 | OrderType::StopLimit
2406 | OrderType::MarketIfTouched
2407 | OrderType::LimitIfTouched
2408 ) && order.trigger_price().is_none()
2409 {
2410 return Err(OrderDeniedReason::ValidationFailed {
2411 detail: "Conditional orders require a trigger price".to_string(),
2412 });
2413 }
2414
2415 if order.is_quote_quantity() && order_type != OrderType::Market {
2416 return Err(OrderDeniedReason::unsupported_quote_quantity());
2417 }
2418
2419 Ok(())
2420}
2421
2422fn max_trade_id(reports: &[FillReport]) -> anyhow::Result<i64> {
2423 let mut max_trade_id = None;
2424
2425 for report in reports {
2426 let trade_id = parse_trade_id(report)?;
2427 max_trade_id = Some(max_trade_id.map_or(trade_id, |current: i64| current.max(trade_id)));
2428 }
2429
2430 max_trade_id.context("Binance Spot account-trades page was empty")
2431}
2432
2433fn parse_trade_id(report: &FillReport) -> anyhow::Result<i64> {
2434 report
2435 .trade_id
2436 .to_string()
2437 .parse::<i64>()
2438 .with_context(|| format!("invalid Binance Spot trade ID {}", report.trade_id))
2439}
2440
2441fn report_time_ms(report: &FillReport) -> i64 {
2442 report.ts_event.as_i64() / NANOSECONDS_IN_MILLISECOND as i64
2443}
2444
2445fn normalize_spot_order_status_report(
2446 report: &mut OrderStatusReport,
2447 treat_expired_as_canceled: bool,
2448) {
2449 if treat_expired_as_canceled && report.order_status == OrderStatus::Expired {
2450 report.order_status = OrderStatus::Canceled;
2451 }
2452}
2453
2454fn normalize_spot_order_status_reports(
2455 reports: &mut [OrderStatusReport],
2456 treat_expired_as_canceled: bool,
2457) {
2458 for report in reports {
2459 normalize_spot_order_status_report(report, treat_expired_as_canceled);
2460 }
2461}
2462
2463async fn wait_for_ws_setup_response(
2464 timeout: Duration,
2465 success: impl Future<Output = ()>,
2466 setup_errors: &mut tokio::sync::mpsc::UnboundedReceiver<String>,
2467 timeout_message: &'static str,
2468) -> anyhow::Result<()> {
2469 tokio::pin!(success);
2470
2471 let result = tokio::time::timeout(timeout, async {
2472 tokio::select! {
2473 () = &mut success => Ok(()),
2474 err = setup_errors.recv() => {
2475 anyhow::bail!(
2476 "{}",
2477 err.unwrap_or_else(|| "WS setup error channel closed".to_string()),
2478 )
2479 }
2480 }
2481 })
2482 .await;
2483
2484 result.map_err(|_| anyhow::anyhow!(timeout_message))?
2485}
2486
2487#[expect(clippy::too_many_arguments)]
2488fn dispatch_ws_trading_message(
2489 msg: BinanceSpotWsTradingMessage,
2490 emitter: &ExecutionEventEmitter,
2491 http_client: &BinanceSpotHttpClient,
2492 account_id: AccountId,
2493 treat_expired_as_canceled: bool,
2494 clock: &'static AtomicTime,
2495 dispatch_state: &WsDispatchState,
2496 ws_authenticated: &tokio::sync::Notify,
2497 ws_user_data_subscribed: &tokio::sync::Notify,
2498 ws_setup_error_tx: &tokio::sync::mpsc::UnboundedSender<String>,
2499 seen_trade_ids: &std::sync::Arc<Mutex<FifoCache<(Ustr, i64), DEDUP_CAPACITY>>>,
2500 task_spawner: &TaskSpawner,
2501) {
2502 match msg {
2503 BinanceSpotWsTradingMessage::OrderAccepted {
2504 request_id,
2505 response,
2506 } => {
2507 dispatch_state.pending_requests.remove(&request_id);
2508 log::debug!(
2509 "WS order accepted: request_id={request_id}, order_id={}",
2510 response.order_id
2511 );
2512 }
2514 BinanceSpotWsTradingMessage::OrderRejected {
2515 request_id,
2516 status,
2517 code,
2518 msg,
2519 } => {
2520 log::debug!(
2521 "WS order rejected: request_id={request_id}, status={status}, code={code}, msg={msg}"
2522 );
2523
2524 if let Some((_, pending)) = dispatch_state.pending_requests.remove(&request_id) {
2525 let code_i64 = i64::from(code);
2526 let reason = format!("code={code}: {msg}");
2527 match classify_spot_submit_failure(code_i64, Some(status), &reason) {
2528 CommandFailure::Ambiguous(reason) => {
2529 log::warn!(
2530 "Ambiguous WS submit failure for {}, awaiting reconciliation: {reason}",
2531 pending.client_order_id,
2532 );
2533
2534 return;
2535 }
2536 CommandFailure::NotSent(_) | CommandFailure::VenueRejected(_) => {}
2537 }
2538
2539 let identity = dispatch_state
2541 .order_identities
2542 .get(&pending.client_order_id)
2543 .map(|r| r.clone());
2544
2545 if let Some(identity) = identity {
2546 let due_post_only = code_i64 == BINANCE_GTX_ORDER_REJECT_CODE
2547 || (code_i64 == BINANCE_NEW_ORDER_REJECTED_CODE
2548 && msg == BINANCE_SPOT_POST_ONLY_REJECT_MSG);
2549 let ts_now = clock.get_time_ns();
2550 let rejected = OrderRejected::new(
2551 emitter.trader_id(),
2552 identity.strategy_id,
2553 identity.instrument_id,
2554 pending.client_order_id,
2555 account_id,
2556 Ustr::from(&sanitize_reason(&reason)),
2557 UUID4::new(),
2558 ts_now,
2559 ts_now,
2560 false,
2561 due_post_only,
2562 );
2563 dispatch_state.cleanup_terminal(pending.client_order_id);
2564 emitter.send_order_event(OrderEventAny::Rejected(rejected));
2565 } else {
2566 log::warn!(
2567 "No order identity for {}, cannot emit OrderRejected",
2568 pending.client_order_id
2569 );
2570 }
2571 } else {
2572 log::warn!("No pending request for {request_id}, cannot emit OrderRejected");
2573 }
2574 }
2575 BinanceSpotWsTradingMessage::OrderCanceled {
2576 request_id,
2577 response,
2578 } => {
2579 dispatch_state.pending_requests.remove(&request_id);
2580 log::debug!(
2581 "WS order canceled: request_id={request_id}, order_id={}",
2582 response.order_id
2583 );
2584 }
2586 BinanceSpotWsTradingMessage::CancelRejected {
2587 request_id,
2588 status,
2589 code,
2590 msg,
2591 } => {
2592 log::debug!(
2593 "WS cancel rejected: request_id={request_id}, status={status}, code={code}, msg={msg}"
2594 );
2595
2596 if let Some((_, pending)) = dispatch_state.pending_requests.remove(&request_id) {
2597 let reason = format!("code={code}: {msg}");
2598
2599 match classify_venue_failure(Some(i64::from(code)), Some(status), &reason) {
2600 CommandFailure::Ambiguous(_) => {
2601 log::warn!(
2602 "Ambiguous WS cancel failure for {}, awaiting reconciliation: {reason}",
2603 pending.client_order_id,
2604 );
2605 return;
2606 }
2607 CommandFailure::NotSent(_) | CommandFailure::VenueRejected(_) => {}
2608 }
2609
2610 if let Some(identity) = dispatch_state
2611 .order_identities
2612 .get(&pending.client_order_id)
2613 {
2614 let ts_now = clock.get_time_ns();
2615
2616 let mut rejected = OrderCancelRejected::new(
2617 emitter.trader_id(),
2618 identity.strategy_id,
2619 identity.instrument_id,
2620 pending.client_order_id,
2621 Ustr::from(&sanitize_reason(&reason)),
2622 UUID4::new(),
2623 ts_now,
2624 ts_now,
2625 false,
2626 pending.venue_order_id,
2627 Some(account_id),
2628 );
2629 rejected.causation_id = pending.command_id;
2630 emitter.send_order_event(OrderEventAny::CancelRejected(rejected));
2631 }
2632 }
2633 }
2634 BinanceSpotWsTradingMessage::CancelReplaceAccepted {
2635 request_id,
2636 cancel_response,
2637 new_order_response,
2638 } => {
2639 dispatch_state.pending_requests.remove(&request_id);
2640 dispatch_state
2641 .cancel_replace_request_ids
2642 .remove(&request_id);
2643 log::debug!(
2644 "WS cancel-replace accepted: request_id={request_id}, \
2645 canceled_id={}, new_id={}",
2646 cancel_response.order_id,
2647 new_order_response.order_id,
2648 );
2649 }
2651 BinanceSpotWsTradingMessage::CancelReplaceRejected {
2652 request_id,
2653 status,
2654 code,
2655 msg,
2656 } => {
2657 log::debug!(
2658 "WS cancel-replace rejected: request_id={request_id}, status={status}, code={code}, msg={msg}"
2659 );
2660
2661 let reason = format!("code={code}: {msg}");
2662 let is_ambiguous = matches!(
2663 classify_venue_failure(Some(i64::from(code)), Some(status), &reason),
2664 CommandFailure::Ambiguous(_)
2665 );
2666 let confirmed_cancel = dispatch_state
2667 .cancel_replace_request_ids
2668 .remove(&request_id)
2669 .filter(|_| !is_ambiguous)
2670 .and_then(|(_, cancel_id)| dispatch_state.on_cancel_replace_rejected(&cancel_id));
2671 let pending = dispatch_state
2672 .pending_requests
2673 .remove(&request_id)
2674 .map(|(_, pending)| pending);
2675
2676 if is_ambiguous {
2677 log::warn!("Ambiguous WS modify failure, awaiting reconciliation: {reason}");
2678 return;
2679 }
2680
2681 if let Some(pending) = &pending {
2682 if let Some(canceled) = dispatch_state.reject_replace(pending.client_order_id) {
2683 dispatch_state.cleanup_terminal(pending.client_order_id);
2684 emitter.send_order_event(OrderEventAny::Canceled(canceled));
2685 return;
2686 }
2687
2688 if let Some(identity) = dispatch_state
2689 .order_identities
2690 .get(&pending.client_order_id)
2691 {
2692 let ts_now = clock.get_time_ns();
2693
2694 let mut rejected = OrderModifyRejected::new(
2695 emitter.trader_id(),
2696 identity.strategy_id,
2697 identity.instrument_id,
2698 pending.client_order_id,
2699 Ustr::from(&sanitize_reason(&reason)),
2700 UUID4::new(),
2701 ts_now,
2702 ts_now,
2703 false,
2704 pending.venue_order_id,
2705 Some(account_id),
2706 );
2707 rejected.causation_id = pending.command_id;
2708 emitter.send_order_event(OrderEventAny::ModifyRejected(rejected));
2709 }
2710 }
2711
2712 if let Some(report) = confirmed_cancel {
2713 emit_canceled_after_rejected_replace(
2714 emitter,
2715 dispatch_state,
2716 account_id,
2717 report,
2718 clock.get_time_ns(),
2719 );
2720 }
2721 }
2722 BinanceSpotWsTradingMessage::RequestFailed { request_id, msg } => {
2723 dispatch_state.pending_requests.remove(&request_id);
2724 dispatch_state
2725 .cancel_replace_request_ids
2726 .remove(&request_id);
2727 log::warn!(
2728 "WS trading request failed without structured venue response: request_id={request_id}, {msg}"
2729 );
2730 }
2731 BinanceSpotWsTradingMessage::AllOrdersCanceled {
2732 request_id,
2733 responses,
2734 } => {
2735 dispatch_state.pending_requests.remove(&request_id);
2736 log::debug!(
2737 "WS all orders canceled: request_id={request_id}, count={}",
2738 responses.len()
2739 );
2740
2741 match prepare_cancel_all_orders(responses) {
2742 Ok(canceled_orders) => {
2743 let ts_init = clock.get_time_ns();
2744
2745 for canceled_order in canceled_orders
2746 .iter()
2747 .filter(|canceled_order| canceled_order.order_list)
2748 {
2749 dispatch_order_list_canceled(
2750 canceled_order,
2751 emitter,
2752 account_id,
2753 dispatch_state,
2754 ts_init,
2755 );
2756 }
2757 }
2758 Err(e) => log::error!(
2759 "Ignoring invalid WS cancel-all response {request_id} to avoid false terminal events: {e}"
2760 ),
2761 }
2762 }
2763 BinanceSpotWsTradingMessage::UserDataSubscribed { subscription_id } => {
2764 log::debug!("User data stream subscribed: id={subscription_id}");
2765 ws_user_data_subscribed.notify_one();
2766 }
2767 BinanceSpotWsTradingMessage::ExecutionReport(report) => {
2768 let ts_init = clock.get_time_ns();
2769 dispatch_execution_report(
2770 &report,
2771 emitter,
2772 http_client,
2773 account_id,
2774 treat_expired_as_canceled,
2775 dispatch_state,
2776 seen_trade_ids,
2777 ts_init,
2778 );
2779 }
2780 BinanceSpotWsTradingMessage::ListStatus(status) => {
2781 dispatch_list_status(
2782 &status,
2783 emitter,
2784 account_id,
2785 dispatch_state,
2786 clock.get_time_ns(),
2787 );
2788 }
2789 BinanceSpotWsTradingMessage::AccountPosition(position) => {
2790 let ts_init = clock.get_time_ns();
2791 match parse_spot_account_position(&position, account_id, ts_init) {
2792 Ok(state) => emitter.send_account_state(state),
2793 Err(e) => log::error!(
2794 "Ignoring invalid spot account position to avoid partial account state: {e:#}"
2795 ),
2796 }
2797 }
2798 BinanceSpotWsTradingMessage::BalanceUpdate(update) => {
2799 log::debug!(
2800 "Balance update: asset={}, delta={}",
2801 update.asset,
2802 update.delta,
2803 );
2804 let http_client = http_client.clone();
2805 let emitter = emitter.clone();
2806
2807 if let Err(e) = task_spawner.spawn(async move {
2808 match http_client.request_account_state(account_id).await {
2809 Ok(state) => emitter.send_account_state(state),
2810 Err(e) => {
2811 log::warn!("Failed to refresh account state after balance update: {e}");
2812 }
2813 }
2814 }) {
2815 log::warn!("Skipping Binance Spot balance refresh after shutdown began: {e}");
2816 }
2817 }
2818 BinanceSpotWsTradingMessage::Connected => {
2819 log::debug!("WS trading API connected");
2820 }
2821 BinanceSpotWsTradingMessage::Authenticated => {
2822 log::debug!("WS trading API authenticated");
2823 ws_authenticated.notify_one();
2824 }
2825 BinanceSpotWsTradingMessage::AuthenticationRejected(reason) => {
2826 log::error!("WS trading API authentication failed: {reason}");
2827 let _ = ws_setup_error_tx.send(reason);
2828 }
2829 BinanceSpotWsTradingMessage::Reconnected => {
2830 log::info!("WS trading API reconnected");
2831 }
2832 BinanceSpotWsTradingMessage::ServerShutdown { event_time } => {
2833 log::warn!(
2834 "WS trading API server shutdown notice (event_time={event_time}); reconnect expected within ~10 minutes"
2835 );
2836 }
2837 BinanceSpotWsTradingMessage::Error(err) => {
2838 log::error!("WS trading API error: {err}");
2839 let _ = ws_setup_error_tx.send(err);
2840 }
2841 BinanceSpotWsTradingMessage::UserDataSubscriptionRejected(reason) => {
2842 log::error!("WS trading API user data subscription failed: {reason}");
2843 let _ = ws_setup_error_tx.send(reason);
2844 }
2845 }
2846}
2847
2848#[derive(Debug)]
2849struct PreparedCancelOrder {
2850 venue_order_id: VenueOrderId,
2851 transaction_time: i64,
2852 client_order_id: ClientOrderId,
2853 instrument_id: InstrumentId,
2854 order_list: bool,
2855}
2856
2857fn prepare_cancel_all_orders(
2858 responses: Vec<BinanceCancelOpenOrdersResponse>,
2859) -> anyhow::Result<Vec<PreparedCancelOrder>> {
2860 let mut prepared = Vec::new();
2861 let mut order_ids = AHashSet::new();
2862 let mut client_order_ids = AHashSet::new();
2863
2864 for response in responses {
2865 match response {
2866 BinanceCancelOpenOrdersResponse::Order(response) => prepare_cancel_order(
2867 &response,
2868 false,
2869 &mut order_ids,
2870 &mut client_order_ids,
2871 &mut prepared,
2872 )?,
2873 BinanceCancelOpenOrdersResponse::OrderList(response) => {
2874 prepare_cancel_order_list(
2875 response,
2876 &mut order_ids,
2877 &mut client_order_ids,
2878 &mut prepared,
2879 )?;
2880 }
2881 }
2882 }
2883
2884 Ok(prepared)
2885}
2886
2887fn prepare_cancel_order_list(
2888 response: BinanceCancelOrderListResponse,
2889 order_ids: &mut AHashSet<(InstrumentId, i64)>,
2890 client_order_ids: &mut AHashSet<ClientOrderId>,
2891 prepared: &mut Vec<PreparedCancelOrder>,
2892) -> anyhow::Result<()> {
2893 anyhow::ensure!(
2894 response.order_list_id >= 0 && !response.symbol.is_empty(),
2895 "order list has an invalid list ID or empty symbol",
2896 );
2897 anyhow::ensure!(
2898 response.list_status_type == SbeListStatusType::AllDone
2899 && response.list_order_status == SbeListOrderStatus::AllDone,
2900 "order list {} was not fully canceled: status={:?}, order_status={:?}",
2901 response.order_list_id,
2902 response.list_status_type,
2903 response.list_order_status,
2904 );
2905 anyhow::ensure!(
2906 !response.orders.is_empty() && response.orders.len() == response.order_reports.len(),
2907 "order list {} has {} orders and {} reports",
2908 response.order_list_id,
2909 response.orders.len(),
2910 response.order_reports.len(),
2911 );
2912
2913 let mut list_orders = AHashMap::with_capacity(response.orders.len());
2914 for order in response.orders {
2915 anyhow::ensure!(
2916 order.symbol == response.symbol,
2917 "order list {} contains order {} for symbol {}, expected {}",
2918 response.order_list_id,
2919 order.order_id,
2920 order.symbol,
2921 response.symbol,
2922 );
2923 anyhow::ensure!(
2924 list_orders.insert(order.order_id, order).is_none(),
2925 "order list {} contains a duplicate order ID",
2926 response.order_list_id,
2927 );
2928 }
2929
2930 for report in response.order_reports {
2931 anyhow::ensure!(
2932 report.order_list_id == Some(response.order_list_id),
2933 "order {} reports order-list ID {:?}, expected {}",
2934 report.order_id,
2935 report.order_list_id,
2936 response.order_list_id,
2937 );
2938 let order = list_orders.remove(&report.order_id).with_context(|| {
2939 format!(
2940 "order-list report {} is absent from list {}",
2941 report.order_id, response.order_list_id
2942 )
2943 })?;
2944 anyhow::ensure!(
2945 report.symbol == response.symbol
2946 && report.symbol == order.symbol
2947 && report.orig_client_order_id == order.client_order_id,
2948 "order-list report {} does not match its order identity",
2949 report.order_id,
2950 );
2951 prepare_cancel_order(&report, true, order_ids, client_order_ids, prepared)?;
2952 }
2953
2954 anyhow::ensure!(
2955 list_orders.is_empty(),
2956 "order list {} is missing {} child reports",
2957 response.order_list_id,
2958 list_orders.len(),
2959 );
2960 Ok(())
2961}
2962
2963fn prepare_cancel_order(
2964 response: &BinanceCancelOrderResponse,
2965 order_list: bool,
2966 order_ids: &mut AHashSet<(InstrumentId, i64)>,
2967 client_order_ids: &mut AHashSet<ClientOrderId>,
2968 prepared: &mut Vec<PreparedCancelOrder>,
2969) -> anyhow::Result<()> {
2970 anyhow::ensure!(
2971 response.order_id >= 0
2972 && !response.symbol.is_empty()
2973 && !response.orig_client_order_id.is_empty(),
2974 "cancel-all response has an invalid order ID, symbol, or original client order ID",
2975 );
2976 anyhow::ensure!(
2977 response.status == SbeOrderStatus::Canceled,
2978 "order {} reports status {:?}, expected Canceled",
2979 response.order_id,
2980 response.status,
2981 );
2982 let client_order_id = decode_client_order_id(
2983 &response.orig_client_order_id,
2984 BINANCE_NAUTILUS_SPOT_BROKER_ID,
2985 )?;
2986 let instrument_id = InstrumentId::new(response.symbol.as_str().into(), *BINANCE_VENUE);
2987 anyhow::ensure!(
2988 order_ids.insert((instrument_id, response.order_id)),
2989 "cancel-all response contains duplicate order ID {} for {}",
2990 response.order_id,
2991 instrument_id,
2992 );
2993 anyhow::ensure!(
2994 client_order_ids.insert(client_order_id),
2995 "cancel-all response contains duplicate client order ID {client_order_id}",
2996 );
2997 prepared.push(PreparedCancelOrder {
2998 venue_order_id: VenueOrderId::new(response.order_id.to_string()),
2999 transaction_time: response.transact_time,
3000 client_order_id,
3001 instrument_id,
3002 order_list,
3003 });
3004 Ok(())
3005}
3006
3007fn dispatch_list_status(
3008 status: &BinanceSpotListStatus,
3009 emitter: &ExecutionEventEmitter,
3010 account_id: AccountId,
3011 state: &WsDispatchState,
3012 ts_init: UnixNanos,
3013) {
3014 let Ok(ts_event) = parse_micros(status.transaction_time_us, "list transaction time") else {
3015 return;
3016 };
3017
3018 let executing = status.list_status_type == SbeListStatusType::ExecStarted
3019 && status.list_order_status == SbeListOrderStatus::Executing;
3020 let rejected = status.list_status_type == SbeListStatusType::Response
3021 && status.list_order_status == SbeListOrderStatus::Reject
3022 && !status.reject_reason.trim().is_empty()
3023 && status.reject_reason != "NONE";
3024
3025 if !executing && !rejected {
3026 return;
3027 }
3028
3029 for child in &status.orders {
3030 let Ok(client_order_id) =
3031 decode_client_order_id(&child.client_order_id, BINANCE_NAUTILUS_SPOT_BROKER_ID)
3032 else {
3033 continue;
3034 };
3035
3036 let identity = state
3037 .order_identities
3038 .get(&client_order_id)
3039 .map(|entry| entry.clone());
3040
3041 let Some(identity) = identity else {
3042 continue;
3043 };
3044
3045 if identity.instrument_id.symbol.as_str() != child.symbol.as_str() {
3046 log::warn!(
3047 "Ignoring list {} child {client_order_id} with mismatched instrument",
3048 status.order_list_id
3049 );
3050 continue;
3051 }
3052
3053 if rejected {
3054 reject_spot_list_child(
3055 emitter,
3056 state,
3057 account_id,
3058 client_order_id,
3059 &status.reject_reason,
3060 ts_event,
3061 ts_init,
3062 );
3063 continue;
3064 }
3065
3066 let venue_order_id = VenueOrderId::new(child.order_id.to_string());
3067 if let Some(list) = state.order_lists.get(&client_order_id) {
3068 if list.order_list_id != status.order_list_id || list.venue_order_id != venue_order_id {
3069 log::warn!("Ignoring conflicting list identity for {client_order_id}");
3070 }
3071
3072 continue;
3073 }
3074
3075 let execution_report_seen =
3076 state.has_emitted_accepted(&client_order_id) || state.has_filled(&client_order_id);
3077 if !state.has_emitted_accepted(&client_order_id) {
3078 state.insert_accepted(client_order_id);
3079
3080 let accepted = OrderAccepted::new(
3081 emitter.trader_id(),
3082 identity.strategy_id,
3083 identity.instrument_id,
3084 client_order_id,
3085 venue_order_id,
3086 account_id,
3087 UUID4::new(),
3088 ts_event,
3089 ts_init,
3090 false,
3091 );
3092 emitter.send_order_event(OrderEventAny::Accepted(accepted));
3093 }
3094
3095 state.order_lists.insert(
3096 client_order_id,
3097 OrderListIdentity {
3098 order_list_id: status.order_list_id,
3099 venue_order_id,
3100 execution_report_seen,
3101 },
3102 );
3103 }
3104}
3105
3106fn reject_spot_list_child(
3107 emitter: &ExecutionEventEmitter,
3108 state: &WsDispatchState,
3109 account_id: AccountId,
3110 client_order_id: ClientOrderId,
3111 reason: &str,
3112 ts_event: UnixNanos,
3113 ts_init: UnixNanos,
3114) {
3115 if state.has_emitted_accepted(&client_order_id) || state.has_filled(&client_order_id) {
3116 return;
3117 }
3118
3119 let Some((_, identity)) = state.order_identities.remove(&client_order_id) else {
3120 return;
3121 };
3122
3123 state
3124 .pending_requests
3125 .retain(|_, request| request.client_order_id != client_order_id);
3126 state.mark_terminal(client_order_id);
3127 state.cleanup_terminal(client_order_id);
3128
3129 let rejected = OrderRejected::new(
3130 emitter.trader_id(),
3131 identity.strategy_id,
3132 identity.instrument_id,
3133 client_order_id,
3134 account_id,
3135 Ustr::from(reason),
3136 UUID4::new(),
3137 ts_event,
3138 ts_init,
3139 false,
3140 false,
3141 );
3142 emitter.send_order_event(OrderEventAny::Rejected(rejected));
3143}
3144
3145fn dispatch_order_list_canceled(
3146 canceled_order: &PreparedCancelOrder,
3147 emitter: &ExecutionEventEmitter,
3148 account_id: AccountId,
3149 state: &WsDispatchState,
3150 ts_init: UnixNanos,
3151) {
3152 let client_order_id = canceled_order.client_order_id;
3153 let identity = state
3154 .order_identities
3155 .remove_if(&client_order_id, |_, identity| {
3156 identity.instrument_id == canceled_order.instrument_id
3157 });
3158
3159 let Some((_, identity)) = identity else {
3160 if state.order_identities.contains_key(&client_order_id) {
3161 log::error!(
3162 "Ignoring cancel-all result for {client_order_id}: tracked instrument does not match {}",
3163 canceled_order.instrument_id,
3164 );
3165 } else {
3166 state
3167 .pending_requests
3168 .retain(|_, pending| pending.client_order_id != client_order_id);
3169 log::debug!("Skipping duplicate cancel-all result for {client_order_id}");
3170 }
3171 return;
3172 };
3173
3174 state
3175 .pending_requests
3176 .retain(|_, pending| pending.client_order_id != client_order_id);
3177 let ts_event = parse_micros_or_init(
3178 canceled_order.transaction_time,
3179 "Spot cancel-all transaction time",
3180 ts_init,
3181 );
3182 ensure_accepted_emitted(
3183 client_order_id,
3184 account_id,
3185 canceled_order.venue_order_id,
3186 &identity,
3187 emitter,
3188 state,
3189 ts_event,
3190 );
3191 state.mark_terminal(client_order_id);
3192 state.cleanup_terminal(client_order_id);
3193 let canceled = OrderCanceled::new(
3194 emitter.trader_id(),
3195 identity.strategy_id,
3196 identity.instrument_id,
3197 client_order_id,
3198 UUID4::new(),
3199 ts_event,
3200 ts_init,
3201 false,
3202 Some(canceled_order.venue_order_id),
3203 Some(account_id),
3204 None,
3205 );
3206 emitter.send_order_event(OrderEventAny::Canceled(canceled));
3207}
3208
3209fn build_new_order_params(
3210 order: &impl Order,
3211 client_order_id: ClientOrderId,
3212 is_post_only: bool,
3213 is_quote_quantity: bool,
3214 use_gtd: bool,
3215) -> anyhow::Result<NewOrderParams> {
3216 let binance_side = BinanceSide::try_from(order.order_side())?;
3217 let binance_order_type = order_type_to_binance_spot(order.order_type(), is_post_only)?;
3218
3219 let requires_trigger = matches!(
3220 order.order_type(),
3221 OrderType::StopMarket
3222 | OrderType::StopLimit
3223 | OrderType::MarketIfTouched
3224 | OrderType::LimitIfTouched
3225 );
3226
3227 if requires_trigger && order.trigger_price().is_none() {
3228 anyhow::bail!("Conditional orders require a trigger price");
3229 }
3230
3231 let supports_tif = matches!(
3232 binance_order_type,
3233 BinanceSpotOrderType::Limit
3234 | BinanceSpotOrderType::StopLossLimit
3235 | BinanceSpotOrderType::TakeProfitLimit
3236 );
3237 let binance_tif = if supports_tif {
3238 Some(time_in_force_to_binance_spot(
3239 order.time_in_force(),
3240 use_gtd,
3241 )?)
3242 } else {
3243 None
3244 };
3245
3246 let qty_str = order.quantity().to_string();
3247 let (base_qty, quote_qty) = if is_quote_quantity {
3248 (None, Some(qty_str))
3249 } else {
3250 (Some(qty_str), None)
3251 };
3252
3253 let client_id_str = encode_broker_id(&client_order_id, BINANCE_NAUTILUS_SPOT_BROKER_ID);
3254
3255 Ok(NewOrderParams {
3256 symbol: order.instrument_id().symbol.to_string(),
3257 side: binance_side,
3258 order_type: binance_order_type,
3259 time_in_force: binance_tif,
3260 quantity: base_qty,
3261 quote_order_qty: quote_qty,
3262 price: order.price().map(|p| p.to_string()),
3263 new_client_order_id: Some(client_id_str),
3264 stop_price: order.trigger_price().map(|p| p.to_string()),
3265 trailing_delta: None,
3266 iceberg_qty: order.display_qty().map(|q| q.to_string()),
3267 new_order_resp_type: Some(BinanceOrderResponseType::Full),
3268 self_trade_prevention_mode: None,
3269 strategy_id: None,
3270 strategy_type: None,
3271 })
3272}
3273
3274fn build_spot_order_list_params(
3275 order_list_id: &str,
3276 orders: &[OrderAny],
3277 use_gtd: bool,
3278) -> Result<NewOcoOrderListParams, String> {
3279 let has_grouped_order = orders.iter().any(is_grouped_order);
3280
3281 if has_grouped_order {
3282 return build_spot_oco_order_list_params(order_list_id, orders, use_gtd);
3283 }
3284
3285 Err("Binance Spot order-list submission currently supports only OCO lists".to_string())
3286}
3287
3288fn build_spot_oco_order_list_params(
3289 order_list_id: &str,
3290 orders: &[OrderAny],
3291 use_gtd: bool,
3292) -> Result<NewOcoOrderListParams, String> {
3293 if orders.len() != 2 {
3294 return Err(format!(
3295 "Binance Spot OCO order-list submission requires exactly 2 orders, was {}",
3296 orders.len()
3297 ));
3298 }
3299
3300 if orders
3301 .iter()
3302 .any(|order| order.contingency_type() != Some(ContingencyType::Oco))
3303 {
3304 return Err(
3305 "Binance Spot grouped order-list submission currently supports only OCO lists"
3306 .to_string(),
3307 );
3308 }
3309
3310 let first = &orders[0];
3311 let second = &orders[1];
3312 if first.instrument_id() != second.instrument_id() {
3313 return Err("Binance Spot OCO order-list legs must use the same instrument".to_string());
3314 }
3315
3316 if first.order_side() != second.order_side() {
3317 return Err("Binance Spot OCO order-list legs must use the same side".to_string());
3318 }
3319
3320 if first.quantity() != second.quantity() {
3321 return Err("Binance Spot OCO order-list legs must use the same quantity".to_string());
3322 }
3323
3324 if first.is_quote_quantity() || second.is_quote_quantity() {
3325 return Err(OrderDeniedReason::unsupported_quote_quantity().to_string());
3326 }
3327
3328 let mut above = None;
3329 let mut below = None;
3330
3331 for order in orders {
3332 let params = build_new_order_params(
3333 order,
3334 order.client_order_id(),
3335 order.is_post_only(),
3336 false,
3337 use_gtd,
3338 )
3339 .map_err(|e| e.to_string())?;
3340
3341 match spot_oco_leg_position(params.side, params.order_type)? {
3342 SpotOcoLegPosition::Above => {
3343 if above.replace(params).is_some() {
3344 return Err(
3345 "Binance Spot OCO order-list resolved more than one above leg".to_string(),
3346 );
3347 }
3348 }
3349 SpotOcoLegPosition::Below => {
3350 if below.replace(params).is_some() {
3351 return Err(
3352 "Binance Spot OCO order-list resolved more than one below leg".to_string(),
3353 );
3354 }
3355 }
3356 }
3357 }
3358
3359 let above = above.ok_or_else(|| "Binance Spot OCO order-list missing above leg".to_string())?;
3360 let below = below.ok_or_else(|| "Binance Spot OCO order-list missing below leg".to_string())?;
3361 let quantity = above
3362 .quantity
3363 .clone()
3364 .ok_or_else(|| "Binance Spot OCO order-list requires base quantity".to_string())?;
3365
3366 Ok(NewOcoOrderListParams {
3367 symbol: first.instrument_id().symbol.to_string(),
3368 list_client_order_id: Some(order_list_id.to_string()),
3369 side: above.side,
3370 quantity,
3371 above_type: above.order_type,
3372 above_client_order_id: above.new_client_order_id,
3373 above_iceberg_qty: above.iceberg_qty,
3374 above_price: above.price,
3375 above_stop_price: above.stop_price,
3376 above_time_in_force: above.time_in_force,
3377 below_type: below.order_type,
3378 below_client_order_id: below.new_client_order_id,
3379 below_iceberg_qty: below.iceberg_qty,
3380 below_price: below.price,
3381 below_stop_price: below.stop_price,
3382 below_time_in_force: below.time_in_force,
3383 new_order_resp_type: Some(BinanceOrderResponseType::Full),
3384 self_trade_prevention_mode: None,
3385 })
3386}
3387
3388enum SpotOcoLegPosition {
3389 Above,
3390 Below,
3391}
3392
3393fn spot_oco_leg_position(
3394 side: BinanceSide,
3395 order_type: BinanceSpotOrderType,
3396) -> Result<SpotOcoLegPosition, String> {
3397 match (side, order_type) {
3398 (
3399 BinanceSide::Sell,
3400 BinanceSpotOrderType::LimitMaker
3401 | BinanceSpotOrderType::TakeProfit
3402 | BinanceSpotOrderType::TakeProfitLimit,
3403 )
3404 | (
3405 BinanceSide::Buy,
3406 BinanceSpotOrderType::StopLoss | BinanceSpotOrderType::StopLossLimit,
3407 ) => Ok(SpotOcoLegPosition::Above),
3408 (
3409 BinanceSide::Sell,
3410 BinanceSpotOrderType::StopLoss | BinanceSpotOrderType::StopLossLimit,
3411 )
3412 | (
3413 BinanceSide::Buy,
3414 BinanceSpotOrderType::LimitMaker
3415 | BinanceSpotOrderType::TakeProfit
3416 | BinanceSpotOrderType::TakeProfitLimit,
3417 ) => Ok(SpotOcoLegPosition::Below),
3418 (_, unsupported) => Err(format!(
3419 "Unsupported Binance Spot OCO leg order type: {unsupported:?}"
3420 )),
3421 }
3422}
3423
3424fn is_grouped_order(order: &OrderAny) -> bool {
3425 order.contingency_type().is_some()
3426 || order
3427 .linked_order_ids()
3428 .is_some_and(|linked_order_ids| !linked_order_ids.is_empty())
3429}
3430
3431fn classify_spot_http_submit_failure(error: &BinanceSpotHttpError) -> CommandFailure {
3432 match error {
3433 BinanceSpotHttpError::BinanceError { code, status, .. } => {
3434 classify_spot_submit_failure(*code, Some(*status), &error.to_string())
3435 }
3436 _ => classify_spot_http_failure(error),
3437 }
3438}
3439
3440fn classify_spot_submit_failure(code: i64, status: Option<u16>, reason: &str) -> CommandFailure {
3441 if code == BINANCE_ORDER_RATE_LIMIT_CODE
3443 && !status.is_some_and(|status| {
3444 status != BINANCE_RATE_LIMIT_STATUS && is_retryable_http_status(status)
3445 })
3446 {
3447 CommandFailure::venue_rejected(reason)
3448 } else {
3449 classify_venue_failure(Some(code), status, reason)
3450 }
3451}
3452
3453fn handle_spot_order_submit_success(client_order_id: ClientOrderId, venue_order_id: VenueOrderId) {
3454 log::debug!(
3455 "Order submit succeeded: client_order_id={client_order_id}, venue_order_id={venue_order_id}",
3456 );
3457}
3458
3459async fn submit_spot_order_list(
3460 http_client: &BinanceSpotHttpClient,
3461 params: &NewOcoOrderListParams,
3462) -> Result<(), BinanceSpotHttpError> {
3463 let response = http_client.submit_oco_order_list(params).await?;
3464 log::debug!(
3465 "Order list submit succeeded: order_list_id={}, order_count={}",
3466 response.order_list_id,
3467 response.orders.len(),
3468 );
3469 Ok(())
3470}
3471
3472fn handle_spot_order_list_submit_error(
3473 event_emitter: &ExecutionEventEmitter,
3474 dispatch_state: &WsDispatchState,
3475 account_id: AccountId,
3476 clock: &'static AtomicTime,
3477 orders: &[OrderAny],
3478 error: BinanceSpotHttpError,
3479) -> anyhow::Result<()> {
3480 match classify_spot_http_submit_failure(&error) {
3481 CommandFailure::Ambiguous(reason) => {
3482 log::warn!("Ambiguous order-list submit failure, awaiting reconciliation: {reason}");
3483 }
3484 CommandFailure::NotSent(reason) | CommandFailure::VenueRejected(reason) => {
3485 let ts_now = clock.get_time_ns();
3488 let reason = format!("submit-order-list-error: {}", sanitize_reason(&reason));
3489
3490 for order in orders {
3491 reject_spot_list_child(
3492 event_emitter,
3493 dispatch_state,
3494 account_id,
3495 order.client_order_id(),
3496 &reason,
3497 ts_now,
3498 ts_now,
3499 );
3500 }
3501 }
3502 }
3503
3504 Err(error.into())
3505}
3506
3507fn build_cancel_order_params(cmd: &CancelOrder, prefer_client_order_id: bool) -> CancelOrderParams {
3508 let order_id = cmd
3509 .venue_order_id
3510 .and_then(|id| id.inner().parse::<i64>().ok());
3511
3512 if let Some(order_id) = order_id
3513 && !prefer_client_order_id
3514 {
3515 CancelOrderParams::by_order_id(cmd.instrument_id.symbol.to_string(), order_id)
3516 } else {
3517 let client_id_str = encode_broker_id(&cmd.client_order_id, BINANCE_NAUTILUS_SPOT_BROKER_ID);
3518 CancelOrderParams::by_client_order_id(cmd.instrument_id.symbol.to_string(), client_id_str)
3519 }
3520}
3521
3522fn cancel_replace_cancel_id() -> String {
3527 format!("CR-{}", UUID4::new().as_str().replace('-', ""))
3528}
3529
3530fn emit_canceled_after_rejected_replace(
3535 emitter: &ExecutionEventEmitter,
3536 state: &WsDispatchState,
3537 account_id: AccountId,
3538 report: OrderStatusReport,
3539 ts_init: UnixNanos,
3540) {
3541 let identity = report
3542 .client_order_id
3543 .and_then(|cid| state.order_identities.get(&cid).map(|r| r.clone()));
3544 if let Some(client_order_id) = report.client_order_id {
3545 state.cleanup_terminal(client_order_id);
3546 }
3547 let (Some(client_order_id), Some(identity)) = (report.client_order_id, identity) else {
3548 emitter.send_order_status_report(report);
3549 return;
3550 };
3551
3552 let canceled = OrderCanceled::new(
3553 emitter.trader_id(),
3554 identity.strategy_id,
3555 identity.instrument_id,
3556 client_order_id,
3557 UUID4::new(),
3558 report.ts_last,
3559 ts_init,
3560 false,
3561 Some(report.venue_order_id),
3562 Some(account_id),
3563 None,
3564 );
3565 emitter.send_order_event(OrderEventAny::Canceled(canceled));
3566}
3567
3568fn handle_http_modify_failure(
3570 error: &anyhow::Error,
3571 command: &ModifyOrder,
3572 cancel_id: &str,
3573 emitter: &ExecutionEventEmitter,
3574 state: &WsDispatchState,
3575 account_id: AccountId,
3576 ts_now: UnixNanos,
3577) {
3578 let failure = error.downcast_ref::<BinanceSpotHttpError>().map_or_else(
3579 || CommandFailure::Ambiguous(error.to_string()),
3580 classify_spot_http_failure,
3581 );
3582
3583 match failure {
3584 CommandFailure::Ambiguous(reason) => {
3585 log::warn!(
3586 "Ambiguous modify failure for {}, awaiting reconciliation: {reason}",
3587 command.client_order_id
3588 );
3589 }
3590 CommandFailure::NotSent(reason) => {
3591 if let Some(canceled) = state.reject_replace(command.client_order_id) {
3592 state.cleanup_terminal(command.client_order_id);
3593 emitter.send_order_event(OrderEventAny::Canceled(canceled));
3594 }
3595
3596 let mut rejected_event = OrderModifyDenied::new(
3597 emitter.trader_id(),
3598 command.strategy_id,
3599 command.instrument_id,
3600 command.client_order_id,
3601 format!("modify-order-error: {}", sanitize_reason(&reason)).into(),
3602 UUID4::new(),
3603 ts_now,
3604 ts_now,
3605 command.venue_order_id,
3606 Some(account_id),
3607 );
3608 rejected_event.causation_id = Some(command.command_id);
3609 emitter.send_order_event(OrderEventAny::ModifyDenied(rejected_event));
3610 if let Some(report) = state.on_cancel_replace_rejected(cancel_id) {
3611 emit_canceled_after_rejected_replace(emitter, state, account_id, report, ts_now);
3612 }
3613 }
3614 CommandFailure::VenueRejected(reason) => {
3615 if let Some(canceled) = state.reject_replace(command.client_order_id) {
3616 state.cleanup_terminal(command.client_order_id);
3617 emitter.send_order_event(OrderEventAny::Canceled(canceled));
3618 return;
3619 }
3620
3621 let mut rejected_event = OrderModifyRejected::new(
3622 emitter.trader_id(),
3623 command.strategy_id,
3624 command.instrument_id,
3625 command.client_order_id,
3626 format!("modify-order-error: {}", sanitize_reason(&reason)).into(),
3627 UUID4::new(),
3628 ts_now,
3629 ts_now,
3630 false,
3631 command.venue_order_id,
3632 Some(account_id),
3633 );
3634 rejected_event.causation_id = Some(command.command_id);
3635 emitter.send_order_event(OrderEventAny::ModifyRejected(rejected_event));
3636
3637 if let Some(report) = state.on_cancel_replace_rejected(cancel_id) {
3638 emit_canceled_after_rejected_replace(emitter, state, account_id, report, ts_now);
3639 }
3640 }
3641 }
3642}
3643
3644fn build_cancel_replace_params(
3645 cmd: &ModifyOrder,
3646 order: &impl Order,
3647 quantity: Quantity,
3648 use_gtd: bool,
3649 cancel_new_client_order_id: String,
3650) -> anyhow::Result<CancelReplaceOrderParams> {
3651 let binance_side = BinanceSide::try_from(order.order_side())?;
3652 let binance_order_type = order_type_to_binance_spot(order.order_type(), false)?;
3653 let binance_tif = time_in_force_to_binance_spot(order.time_in_force(), use_gtd)?;
3654
3655 let cancel_order_id: Option<i64> = cmd
3656 .venue_order_id
3657 .map(|id| {
3658 id.inner()
3659 .parse::<i64>()
3660 .map_err(|_| anyhow::anyhow!("Invalid venue order ID: {id}"))
3661 })
3662 .transpose()?;
3663
3664 let client_id_str = encode_broker_id(&cmd.client_order_id, BINANCE_NAUTILUS_SPOT_BROKER_ID);
3665
3666 Ok(CancelReplaceOrderParams {
3667 symbol: cmd.instrument_id.symbol.to_string(),
3668 side: binance_side,
3669 order_type: binance_order_type,
3670 cancel_replace_mode: BinanceCancelReplaceMode::StopOnFailure,
3671 time_in_force: Some(binance_tif),
3672 quantity: Some(quantity.to_string()),
3673 quote_order_qty: None,
3674 price: cmd.price.map(|p| p.to_string()),
3675 cancel_order_id,
3676 cancel_orig_client_order_id: if cancel_order_id.is_none() {
3677 Some(client_id_str.clone())
3678 } else {
3679 None
3680 },
3681 cancel_new_client_order_id: Some(cancel_new_client_order_id),
3682 new_client_order_id: Some(client_id_str),
3683 stop_price: None,
3684 trailing_delta: None,
3685 iceberg_qty: None,
3686 new_order_resp_type: Some(BinanceOrderResponseType::Full),
3687 self_trade_prevention_mode: None,
3688 })
3689}
3690
3691#[expect(clippy::too_many_arguments)]
3696fn dispatch_execution_report(
3697 report: &BinanceSpotExecutionReport,
3698 emitter: &ExecutionEventEmitter,
3699 http_client: &BinanceSpotHttpClient,
3700 account_id: AccountId,
3701 treat_expired_as_canceled: bool,
3702 dispatch_state: &WsDispatchState,
3703 seen_trade_ids: &std::sync::Arc<Mutex<FifoCache<(Ustr, i64), DEDUP_CAPACITY>>>,
3704 ts_init: UnixNanos,
3705) {
3706 let symbol = report.symbol;
3707 let instrument_id = InstrumentId::new(symbol.into(), *BINANCE_VENUE);
3708 let Some(instrument) = http_client.get_instrument(&symbol) else {
3709 log::warn!("Cannot dispatch Spot execution report for uncached instrument {instrument_id}");
3710 return;
3711 };
3712 let (price_precision, size_precision) =
3713 (instrument.price_precision(), instrument.size_precision());
3714
3715 if report.execution_type == BinanceSpotExecutionType::Canceled
3716 && dispatch_state.has_cancel_replace(&report.client_order_id)
3717 {
3718 match parse_spot_exec_report_to_order_status(
3719 report,
3720 instrument_id,
3721 price_precision,
3722 size_precision,
3723 account_id,
3724 treat_expired_as_canceled,
3725 ts_init,
3726 ) {
3727 Ok(status) => {
3728 if dispatch_state.on_cancel_replace_canceled(&report.client_order_id, status) {
3729 log::debug!(
3731 "Withholding cancel-replace cancel report: client_order_id={}, venue_order_id={}",
3732 report.order_client_order_id(),
3733 report.order_id
3734 );
3735 return;
3736 }
3737 }
3738 Err(e) => log::warn!(
3739 "Cannot withhold cancel-replace cancel report, dispatching normally: {e}"
3740 ),
3741 }
3742 }
3743
3744 let client_order_id = match decode_client_order_id(
3745 report.order_client_order_id(),
3746 BINANCE_NAUTILUS_SPOT_BROKER_ID,
3747 ) {
3748 Ok(client_order_id) => client_order_id,
3749 Err(e) => {
3750 log::warn!("Skipping Spot execution report with invalid client order ID: {e}");
3751 return;
3752 }
3753 };
3754
3755 let identity = dispatch_state
3756 .order_identities
3757 .get(&client_order_id)
3758 .map(|r| r.clone());
3759
3760 if let Some(identity) = identity {
3761 dispatch_tracked_execution_report(
3762 report,
3763 emitter,
3764 account_id,
3765 treat_expired_as_canceled,
3766 dispatch_state,
3767 seen_trade_ids,
3768 client_order_id,
3769 &identity,
3770 instrument_id,
3771 price_precision,
3772 size_precision,
3773 instrument.quote_currency(),
3774 ts_init,
3775 );
3776 } else {
3777 dispatch_untracked_execution_report(
3778 report,
3779 emitter,
3780 account_id,
3781 treat_expired_as_canceled,
3782 dispatch_state,
3783 client_order_id,
3784 seen_trade_ids,
3785 instrument_id,
3786 price_precision,
3787 size_precision,
3788 ts_init,
3789 );
3790 }
3791}
3792
3793#[expect(clippy::too_many_arguments)]
3795fn dispatch_tracked_execution_report(
3796 report: &BinanceSpotExecutionReport,
3797 emitter: &ExecutionEventEmitter,
3798 account_id: AccountId,
3799 treat_expired_as_canceled: bool,
3800 state: &WsDispatchState,
3801 seen_trade_ids: &std::sync::Arc<Mutex<FifoCache<(Ustr, i64), DEDUP_CAPACITY>>>,
3802 client_order_id: ClientOrderId,
3803 identity: &OrderIdentity,
3804 instrument_id: InstrumentId,
3805 price_precision: u8,
3806 size_precision: u8,
3807 quote_currency: Currency,
3808 ts_init: UnixNanos,
3809) {
3810 let venue_order_id = VenueOrderId::new(report.order_id.to_string());
3811 let ts_event = parse_millis_or_init(report.event_time, "Spot execution event time", ts_init);
3812
3813 match report.execution_type {
3814 BinanceSpotExecutionType::Unknown => {
3815 log::warn!("Skipping unknown Spot execution type for {}", report.symbol);
3816 }
3817 BinanceSpotExecutionType::New => {
3818 if state.is_order_new_stale(&client_order_id, venue_order_id) {
3819 log::debug!("Skipping New for already-filled {client_order_id}");
3820 return;
3821 }
3822
3823 let Some(price) =
3824 parse_spot_execution_report_price(report, &report.price, price_precision, "price")
3825 else {
3826 return;
3827 };
3828 let Some(quantity) = parse_spot_execution_report_quantity(
3829 report,
3830 &report.original_qty,
3831 size_precision,
3832 "original_qty",
3833 ) else {
3834 return;
3835 };
3836 let Some(stop_price) =
3837 parse_spot_execution_report_decimal(report, &report.stop_price, "stop_price")
3838 else {
3839 return;
3840 };
3841 let trigger = if stop_price > Decimal::ZERO {
3842 let Some(trigger_price) = parse_spot_execution_report_price(
3843 report,
3844 &report.stop_price,
3845 price_precision,
3846 "stop_price",
3847 ) else {
3848 return;
3849 };
3850 Some(trigger_price)
3851 } else {
3852 None
3853 };
3854
3855 let Some(changed) = identity.is_quote_quantity.then_some(false).or_else(|| {
3856 state.record_order_update(client_order_id, venue_order_id, quantity, price, trigger)
3857 }) else {
3858 return;
3859 };
3860
3861 let first_list_report =
3862 state
3863 .order_lists
3864 .get_mut(&client_order_id)
3865 .is_some_and(|mut list| {
3866 let first =
3867 !list.execution_report_seen && list.venue_order_id == venue_order_id;
3868 list.execution_report_seen = true;
3869 first
3870 });
3871
3872 if state.has_emitted_accepted(&client_order_id) {
3873 if !changed || first_list_report {
3874 return;
3875 }
3876 let updated = OrderUpdated::new(
3877 emitter.trader_id(),
3878 identity.strategy_id,
3879 identity.instrument_id,
3880 client_order_id,
3881 quantity,
3882 UUID4::new(),
3883 ts_event,
3884 ts_init,
3885 false,
3886 Some(venue_order_id),
3887 Some(account_id),
3888 Some(price),
3889 trigger,
3890 None, false, );
3893 emitter.send_order_event(OrderEventAny::Updated(updated));
3894 return;
3895 }
3896 state.insert_accepted(client_order_id);
3897 let accepted = OrderAccepted::new(
3898 emitter.trader_id(),
3899 identity.strategy_id,
3900 identity.instrument_id,
3901 client_order_id,
3902 venue_order_id,
3903 account_id,
3904 UUID4::new(),
3905 ts_event,
3906 ts_init,
3907 false,
3908 );
3909 emitter.send_order_event(OrderEventAny::Accepted(accepted));
3910 }
3911 BinanceSpotExecutionType::Trade => {
3912 let dedup_key = (report.symbol, report.trade_id);
3913 let is_duplicate = state.has_trade(&client_order_id, &dedup_key, seen_trade_ids);
3914
3915 if is_duplicate {
3916 log::debug!(
3917 "Duplicate trade_id={} for {}, skipping",
3918 report.trade_id,
3919 report.symbol
3920 );
3921 return;
3922 }
3923
3924 let Some(last_qty) = parse_spot_execution_report_quantity(
3925 report,
3926 &report.last_filled_qty,
3927 size_precision,
3928 "last_filled_qty",
3929 ) else {
3930 return;
3931 };
3932 let Some(last_px) = parse_spot_execution_report_price(
3933 report,
3934 &report.last_filled_price,
3935 price_precision,
3936 "last_filled_price",
3937 ) else {
3938 return;
3939 };
3940 let Some(commission) =
3941 parse_spot_execution_report_decimal(report, &report.commission, "commission")
3942 else {
3943 return;
3944 };
3945 let commission_currency = report
3946 .commission_asset
3947 .as_ref()
3948 .map_or_else(Currency::USDT, |a| {
3949 Currency::get_or_create_crypto(a.as_str())
3950 });
3951 let commission_money = match Money::from_decimal(commission, commission_currency) {
3952 Ok(money) => money,
3953 Err(e) => {
3954 log::warn!(
3955 "Failed to build Spot commission money for symbol={}, order_id={}, \
3956 trade_id={}: {e}",
3957 report.symbol,
3958 report.order_id,
3959 report.trade_id,
3960 );
3961 return;
3962 }
3963 };
3964
3965 ensure_accepted_emitted(
3966 client_order_id,
3967 account_id,
3968 venue_order_id,
3969 identity,
3970 emitter,
3971 state,
3972 ts_init,
3973 );
3974
3975 let liquidity_side = if report.is_maker {
3976 LiquiditySide::Maker
3977 } else {
3978 LiquiditySide::Taker
3979 };
3980
3981 let Some(()) = emit_order_update_from_fill(
3982 report,
3983 identity,
3984 client_order_id,
3985 venue_order_id,
3986 account_id,
3987 price_precision,
3988 size_precision,
3989 ts_event,
3990 ts_init,
3991 emitter,
3992 state,
3993 ) else {
3994 return;
3995 };
3996
3997 let filled = OrderFilled::new(
3998 emitter.trader_id(),
3999 identity.strategy_id,
4000 instrument_id,
4001 client_order_id,
4002 venue_order_id,
4003 account_id,
4004 TradeId::new(report.trade_id.to_string()),
4005 identity.order_side,
4006 identity.order_type,
4007 last_qty,
4008 last_px,
4009 quote_currency,
4010 liquidity_side,
4011 UUID4::new(),
4012 ts_event,
4013 ts_init,
4014 false,
4015 None,
4016 Some(commission_money),
4017 None,
4018 );
4019
4020 state.insert_filled(client_order_id);
4021 emitter.send_order_event(OrderEventAny::Filled(filled));
4022 seen_trade_ids.lock().add(dedup_key);
4023
4024 let cumulative_qty = parse_spot_execution_report_decimal(
4025 report,
4026 &report.cumulative_filled_qty,
4027 "cumulative_filled_qty",
4028 );
4029 let original_qty =
4030 parse_spot_execution_report_decimal(report, &report.original_qty, "original_qty");
4031
4032 if let (Some(original_qty), Some(cumulative_qty)) = (original_qty, cumulative_qty)
4033 && original_qty <= cumulative_qty
4034 && (!identity.is_quote_quantity
4035 || report.order_status == BinanceOrderStatus::Filled)
4036 {
4037 state.cleanup_terminal(client_order_id);
4038 }
4039 }
4040 BinanceSpotExecutionType::Replaced => {
4041 log::debug!(
4044 "Order replaced: client_order_id={client_order_id}, venue_order_id={venue_order_id}"
4045 );
4046 }
4047 BinanceSpotExecutionType::Canceled | BinanceSpotExecutionType::TradePrevention => {
4048 ensure_accepted_emitted(
4049 client_order_id,
4050 account_id,
4051 venue_order_id,
4052 identity,
4053 emitter,
4054 state,
4055 ts_init,
4056 );
4057 let canceled = OrderCanceled::new(
4058 emitter.trader_id(),
4059 identity.strategy_id,
4060 identity.instrument_id,
4061 client_order_id,
4062 UUID4::new(),
4063 ts_event,
4064 ts_init,
4065 false,
4066 Some(venue_order_id),
4067 Some(account_id),
4068 None,
4069 );
4070
4071 if state.defer_replace_cancel(canceled) {
4072 return;
4073 }
4074 state.cleanup_terminal(client_order_id);
4075 emitter.send_order_event(OrderEventAny::Canceled(canceled));
4076 }
4077 BinanceSpotExecutionType::Expired => {
4078 ensure_accepted_emitted(
4079 client_order_id,
4080 account_id,
4081 venue_order_id,
4082 identity,
4083 emitter,
4084 state,
4085 ts_init,
4086 );
4087 state.cleanup_terminal(client_order_id);
4088
4089 if treat_expired_as_canceled {
4090 let canceled = OrderCanceled::new(
4091 emitter.trader_id(),
4092 identity.strategy_id,
4093 identity.instrument_id,
4094 client_order_id,
4095 UUID4::new(),
4096 ts_event,
4097 ts_init,
4098 false,
4099 Some(venue_order_id),
4100 Some(account_id),
4101 None,
4102 );
4103 emitter.send_order_event(OrderEventAny::Canceled(canceled));
4104 } else {
4105 let expired = OrderExpired::new(
4106 emitter.trader_id(),
4107 identity.strategy_id,
4108 identity.instrument_id,
4109 client_order_id,
4110 UUID4::new(),
4111 ts_event,
4112 ts_init,
4113 false,
4114 Some(venue_order_id),
4115 Some(account_id),
4116 );
4117 emitter.send_order_event(OrderEventAny::Expired(expired));
4118 }
4119 }
4120 BinanceSpotExecutionType::Rejected => {
4121 let reason = if report.reject_reason.is_empty() {
4122 Ustr::from("Order rejected by venue")
4123 } else {
4124 Ustr::from(&report.reject_reason)
4125 };
4126 let due_post_only = report.time_in_force == BinanceTimeInForce::Gtx
4127 || (report.order_type == "LIMIT_MAKER"
4128 && (report.reject_reason.is_empty() || report.reject_reason == "NONE"));
4129 state.cleanup_terminal(client_order_id);
4130 emitter.emit_order_rejected_event(
4131 identity.strategy_id,
4132 identity.instrument_id,
4133 client_order_id,
4134 reason.as_str(),
4135 ts_init,
4136 due_post_only,
4137 );
4138 }
4139 }
4140}
4141
4142#[expect(clippy::too_many_arguments)]
4143fn emit_order_update_from_fill(
4144 report: &BinanceSpotExecutionReport,
4145 identity: &OrderIdentity,
4146 client_order_id: ClientOrderId,
4147 venue_order_id: VenueOrderId,
4148 account_id: AccountId,
4149 price_precision: u8,
4150 size_precision: u8,
4151 ts_event: UnixNanos,
4152 ts_init: UnixNanos,
4153 emitter: &ExecutionEventEmitter,
4154 state: &WsDispatchState,
4155) -> Option<()> {
4156 let quantity = parse_spot_execution_report_quantity(
4157 report,
4158 &report.original_qty,
4159 size_precision,
4160 "original_qty",
4161 )?;
4162 let cumulative_qty = parse_spot_execution_report_decimal(
4163 report,
4164 &report.cumulative_filled_qty,
4165 "cumulative_filled_qty",
4166 )?;
4167
4168 if quantity.is_zero() || quantity.as_decimal() < cumulative_qty {
4169 log::warn!(
4170 "Invalid Spot order quantity for {client_order_id}: \
4171 original_qty={}, cumulative_filled_qty={cumulative_qty}",
4172 report.original_qty,
4173 );
4174 return None;
4175 }
4176
4177 let (price, trigger_price) = if identity.is_quote_quantity {
4178 (Price::zero(price_precision), None)
4179 } else {
4180 let price =
4181 parse_spot_execution_report_price(report, &report.price, price_precision, "price")?;
4182 let stop_price =
4183 parse_spot_execution_report_decimal(report, &report.stop_price, "stop_price")?;
4184
4185 let trigger_price = if stop_price > Decimal::ZERO {
4186 Some(parse_spot_execution_report_price(
4187 report,
4188 &report.stop_price,
4189 price_precision,
4190 "stop_price",
4191 )?)
4192 } else {
4193 None
4194 };
4195
4196 (price, trigger_price)
4197 };
4198
4199 if state.record_order_update_from_fill(
4200 client_order_id,
4201 venue_order_id,
4202 quantity,
4203 price,
4204 trigger_price,
4205 identity,
4206 ) != Some(true)
4207 {
4208 return Some(());
4209 }
4210
4211 let updated = OrderUpdated::new(
4212 emitter.trader_id(),
4213 identity.strategy_id,
4214 identity.instrument_id,
4215 client_order_id,
4216 quantity,
4217 UUID4::new(),
4218 ts_event,
4219 ts_init,
4220 false,
4221 Some(venue_order_id),
4222 Some(account_id),
4223 identity.price.map(|_| price),
4224 trigger_price,
4225 None,
4226 false,
4227 );
4228 emitter.send_order_event(OrderEventAny::Updated(updated));
4229 Some(())
4230}
4231
4232fn parse_spot_execution_report_quantity(
4233 report: &BinanceSpotExecutionReport,
4234 raw: &str,
4235 precision: u8,
4236 field: &str,
4237) -> Option<Quantity> {
4238 match parse_required_quantity_at_precision(raw, precision, field) {
4239 Ok(value) => Some(value),
4240 Err(e) => {
4241 warn_invalid_spot_execution_report_field(report, field, &e);
4242 None
4243 }
4244 }
4245}
4246
4247fn parse_spot_execution_report_price(
4248 report: &BinanceSpotExecutionReport,
4249 raw: &str,
4250 precision: u8,
4251 field: &str,
4252) -> Option<Price> {
4253 match parse_required_price_at_precision(raw, precision, field) {
4254 Ok(value) => Some(value),
4255 Err(e) => {
4256 warn_invalid_spot_execution_report_field(report, field, &e);
4257 None
4258 }
4259 }
4260}
4261
4262fn parse_spot_execution_report_decimal(
4263 report: &BinanceSpotExecutionReport,
4264 raw: &str,
4265 field: &str,
4266) -> Option<Decimal> {
4267 match parse_required_decimal(raw, field) {
4268 Ok(value) => Some(value),
4269 Err(e) => {
4270 warn_invalid_spot_execution_report_field(report, field, &e);
4271 None
4272 }
4273 }
4274}
4275
4276fn warn_invalid_spot_execution_report_field(
4277 report: &BinanceSpotExecutionReport,
4278 field: &str,
4279 error: &anyhow::Error,
4280) {
4281 log::warn!(
4282 "Failed to parse Spot execution report {field} for symbol={}, order_id={}, \
4283 trade_id={}, client_order_id={}: {error}",
4284 report.symbol,
4285 report.order_id,
4286 report.trade_id,
4287 report.client_order_id,
4288 );
4289}
4290
4291#[expect(clippy::too_many_arguments)]
4293fn dispatch_untracked_execution_report(
4294 report: &BinanceSpotExecutionReport,
4295 emitter: &ExecutionEventEmitter,
4296 account_id: AccountId,
4297 treat_expired_as_canceled: bool,
4298 state: &WsDispatchState,
4299 client_order_id: ClientOrderId,
4300 seen_trade_ids: &std::sync::Arc<Mutex<FifoCache<(Ustr, i64), DEDUP_CAPACITY>>>,
4301 instrument_id: InstrumentId,
4302 price_precision: u8,
4303 size_precision: u8,
4304 ts_init: UnixNanos,
4305) {
4306 let terminal = state.is_terminal(&client_order_id);
4307 if terminal && report.execution_type != BinanceSpotExecutionType::Trade {
4308 return;
4309 }
4310
4311 match report.execution_type {
4312 BinanceSpotExecutionType::Unknown => {
4313 log::warn!("Skipping unknown Spot execution type for {}", report.symbol);
4314 }
4315 BinanceSpotExecutionType::Trade => {
4316 let dedup_key = (report.symbol, report.trade_id);
4317 let is_duplicate = state.has_trade(&client_order_id, &dedup_key, seen_trade_ids);
4318
4319 if is_duplicate {
4320 log::debug!(
4321 "Duplicate trade_id={} for {}, skipping",
4322 report.trade_id,
4323 report.symbol
4324 );
4325 return;
4326 }
4327
4328 if !terminal {
4329 match parse_spot_exec_report_to_order_status(
4330 report,
4331 instrument_id,
4332 price_precision,
4333 size_precision,
4334 account_id,
4335 treat_expired_as_canceled,
4336 ts_init,
4337 ) {
4338 Ok(status) => emitter.send_order_status_report(status),
4339 Err(e) => log::error!("Failed to parse order status report: {e}"),
4340 }
4341 }
4342
4343 match parse_spot_exec_report_to_fill(
4344 report,
4345 instrument_id,
4346 price_precision,
4347 size_precision,
4348 account_id,
4349 ts_init,
4350 ) {
4351 Ok(fill) => {
4352 emitter.send_fill_report(fill);
4353 seen_trade_ids.lock().add(dedup_key);
4354 }
4355 Err(e) => log::error!("Failed to parse fill report: {e}"),
4356 }
4357 }
4358 BinanceSpotExecutionType::New
4359 | BinanceSpotExecutionType::Canceled
4360 | BinanceSpotExecutionType::Replaced
4361 | BinanceSpotExecutionType::Rejected
4362 | BinanceSpotExecutionType::Expired
4363 | BinanceSpotExecutionType::TradePrevention => {
4364 match parse_spot_exec_report_to_order_status(
4365 report,
4366 instrument_id,
4367 price_precision,
4368 size_precision,
4369 account_id,
4370 treat_expired_as_canceled,
4371 ts_init,
4372 ) {
4373 Ok(status) => emitter.send_order_status_report(status),
4374 Err(e) => log::error!("Failed to parse order status report: {e}"),
4375 }
4376 }
4377 }
4378}
4379
4380fn is_spot_post_only_rejection(error: &BinanceSpotHttpError) -> bool {
4382 match error {
4383 BinanceSpotHttpError::BinanceError { code, message, .. } => {
4384 *code == BINANCE_GTX_ORDER_REJECT_CODE
4385 || (*code == BINANCE_NEW_ORDER_REJECTED_CODE
4386 && message == BINANCE_SPOT_POST_ONLY_REJECT_MSG)
4387 }
4388 _ => false,
4389 }
4390}
4391
4392#[cfg(test)]
4393mod tests {
4394 use std::{
4395 cell::RefCell,
4396 rc::Rc,
4397 sync::{
4398 Arc,
4399 atomic::{AtomicUsize, Ordering},
4400 },
4401 };
4402
4403 use nautilus_common::{
4404 cache::Cache,
4405 clients::ExecutionClient,
4406 messages::{
4407 ExecutionEvent,
4408 execution::{CancelAllOrders, ExecutionReport},
4409 },
4410 };
4411 use nautilus_core::{UUID4, UnixNanos, time::get_atomic_clock_realtime};
4412 use nautilus_execution::reconciliation::{
4413 generate_reconciliation_order_pre_fill_events, reconcile_fill_report,
4414 };
4415 use nautilus_live::ExecutionClientCore;
4416 use nautilus_model::{
4417 enums::{
4418 AccountType, LiquiditySide, OmsType, OrderSide, OrderStatus, OrderType, TimeInForce,
4419 },
4420 events::{OrderEventAny, order::spec::OrderFilledSpec},
4421 identifiers::{AccountId, ClientOrderId, InstrumentId, StrategyId, TraderId, VenueOrderId},
4422 instruments::{InstrumentAny, stubs::currency_pair_ethusdt},
4423 orders::{Order, OrderTestBuilder, stubs::TestOrderEventStubs},
4424 types::{Price, Quantity},
4425 };
4426 use rstest::rstest;
4427
4428 use super::*;
4429 use crate::{
4430 common::{
4431 consts::{
4432 BINANCE_CLIENT_ID, BINANCE_STATUS_UNKNOWN_CODE, BINANCE_UNEXPECTED_RESPONSE_CODE,
4433 BINANCE_VENUE,
4434 },
4435 enums::BinanceEnvironment,
4436 },
4437 config::BinanceExecutionClientConfig,
4438 spot::{
4439 http::models::BinanceCancelOrderListOrder,
4440 sbe::spot::{
4441 contingency_type::ContingencyType as SbeContingencyType,
4442 order_side::OrderSide as SbeOrderSide, order_type::OrderType as SbeOrderType,
4443 self_trade_prevention_mode::SelfTradePreventionMode as SbeStp,
4444 time_in_force::TimeInForce as SbeTimeInForce,
4445 },
4446 websocket::trading::user_data::{
4447 BinanceSpotAccountPositionMsg, BinanceSpotBalanceEntry,
4448 },
4449 },
4450 };
4451
4452 #[rstest]
4453 #[case::unsupported_type(OrderType::MarketToLimit, false, false, Some(OrderDeniedReason::UnsupportedOrderType { order_type: OrderType::MarketToLimit }))]
4454 #[case::reduce_only(
4455 OrderType::Market,
4456 true,
4457 false,
4458 Some(OrderDeniedReason::UnsupportedReduceOnly)
4459 )]
4460 #[case::limit_quote_quantity(
4461 OrderType::Limit,
4462 false,
4463 true,
4464 Some(OrderDeniedReason::unsupported_quote_quantity())
4465 )]
4466 #[case::market_quote_quantity(OrderType::Market, false, true, None)]
4467 fn test_validate_order_fields(
4468 #[case] order_type: OrderType,
4469 #[case] reduce_only: bool,
4470 #[case] quote_quantity: bool,
4471 #[case] expected: Option<OrderDeniedReason>,
4472 ) {
4473 let order = OrderTestBuilder::new(order_type)
4474 .instrument_id(InstrumentId::from("BTCUSDT.BINANCE"))
4475 .quantity(Quantity::from("1"))
4476 .price(Price::from("100"))
4477 .reduce_only(reduce_only)
4478 .quote_quantity(quote_quantity)
4479 .build();
4480 assert_eq!(validate_order(&order, false).err(), expected);
4481 }
4482
4483 #[rstest]
4484 #[case::limit(
4485 false,
4486 Some(OrderDeniedReason::UnsupportedTimeInForce(TimeInForce::Day))
4487 )]
4488 #[case::maker(true, None)]
4489 fn test_validate_order_time_in_force_only_when_sent(
4490 #[case] post_only: bool,
4491 #[case] expected: Option<OrderDeniedReason>,
4492 ) {
4493 let order = OrderTestBuilder::new(OrderType::Limit)
4494 .instrument_id(InstrumentId::from("BTCUSDT.BINANCE"))
4495 .quantity(Quantity::from("1"))
4496 .price(Price::from("100"))
4497 .post_only(post_only)
4498 .time_in_force(TimeInForce::Day)
4499 .build();
4500 assert_eq!(validate_order(&order, false).err(), expected);
4501
4502 if post_only {
4503 let params =
4504 build_new_order_params(&order, order.client_order_id(), true, false, false)
4505 .unwrap();
4506 assert_eq!(params.time_in_force, None);
4507 }
4508 }
4509
4510 #[rstest]
4511 #[case::live(BinanceEnvironment::Live, BINANCE_SPOT_SBE_WS_API_URL)]
4512 #[case::testnet(BinanceEnvironment::Testnet, BINANCE_SPOT_SBE_WS_API_TESTNET_URL)]
4513 #[case::demo(BinanceEnvironment::Demo, BINANCE_SPOT_SBE_WS_API_DEMO_URL)]
4514 fn test_resolve_ws_trading_url_uses_environment_default(
4515 #[case] environment: BinanceEnvironment,
4516 #[case] expected: &str,
4517 ) {
4518 assert_eq!(
4519 BinanceSpotExecutionClient::resolve_ws_trading_url(None, environment),
4520 expected
4521 );
4522 }
4523
4524 #[rstest]
4525 fn test_resolve_ws_trading_url_preserves_override() {
4526 let expected = "wss://example.com/ws-api/v3";
4527
4528 assert_eq!(
4529 BinanceSpotExecutionClient::resolve_ws_trading_url(
4530 Some(expected.to_string()),
4531 BinanceEnvironment::Testnet,
4532 ),
4533 expected
4534 );
4535 }
4536
4537 #[rstest]
4538 fn test_dispatch_ws_trading_message_emits_cancel_rejected_and_clears_pending_request() {
4539 let tasks = TaskGroup::new();
4540 let task_spawner = tasks.spawner().expect("task spawner");
4541 let clock = get_atomic_clock_realtime();
4542 let (emitter, mut rx) = create_test_emitter(clock);
4543 let http_client = create_test_http_client(clock);
4544 let dispatch_state = create_tracked_dispatch_state(
4545 ClientOrderId::from("TEST"),
4546 InstrumentId::from("BTCUSDT.BINANCE"),
4547 );
4548 let ws_authenticated = tokio::sync::Notify::new();
4549 let ws_user_data_subscribed = tokio::sync::Notify::new();
4550 let (ws_setup_error_tx, _ws_setup_error_rx) = tokio::sync::mpsc::unbounded_channel();
4551 let seen_trade_ids = Arc::new(Mutex::new(FifoCache::new()));
4552
4553 dispatch_state.pending_requests.insert(
4554 "req-cancel".to_string(),
4555 PendingRequest {
4556 command_id: None,
4557 client_order_id: ClientOrderId::from("TEST"),
4558 venue_order_id: Some(VenueOrderId::from("12345")),
4559 operation: PendingOperation::Cancel,
4560 },
4561 );
4562
4563 dispatch_ws_trading_message(
4564 BinanceSpotWsTradingMessage::CancelRejected {
4565 request_id: "req-cancel".to_string(),
4566 status: 400,
4567 code: -2011,
4568 msg: "Unknown order sent".to_string(),
4569 },
4570 &emitter,
4571 &http_client,
4572 AccountId::from("BINANCE-001"),
4573 false,
4574 clock,
4575 &dispatch_state,
4576 &ws_authenticated,
4577 &ws_user_data_subscribed,
4578 &ws_setup_error_tx,
4579 &seen_trade_ids,
4580 &task_spawner,
4581 );
4582
4583 assert!(dispatch_state.pending_requests.get("req-cancel").is_none());
4584
4585 match rx
4586 .try_recv()
4587 .expect("Cancel rejection event should be emitted")
4588 {
4589 ExecutionEvent::Order(OrderEventAny::CancelRejected(event)) => {
4590 assert_eq!(event.client_order_id, ClientOrderId::from("TEST"));
4591 assert_eq!(event.account_id, Some(AccountId::from("BINANCE-001")));
4592 assert!(event.reason.contains("code=-2011"));
4593 }
4594 other => panic!("Expected CancelRejected event, was {other:?}"),
4595 }
4596 }
4597
4598 #[rstest]
4599 #[case::unexpected_response(
4600 400,
4601 BINANCE_UNEXPECTED_RESPONSE_CODE,
4602 "An unexpected response was received from the message bus"
4603 )]
4604 #[case::status_unknown(
4605 400,
4606 BINANCE_STATUS_UNKNOWN_CODE,
4607 "Timeout waiting for response from backend server"
4608 )]
4609 #[case::order_rate_limit_ip_ban(
4610 418,
4611 BINANCE_ORDER_RATE_LIMIT_CODE,
4612 "Too many new orders; current limit is 100 orders per 10 SECOND."
4613 )]
4614 #[case::order_rate_limit_server_error(
4615 500,
4616 BINANCE_ORDER_RATE_LIMIT_CODE,
4617 "Too many new orders; current limit is 100 orders per 10 SECOND."
4618 )]
4619 fn test_dispatch_ws_trading_message_unknown_status_keeps_order_registered(
4620 #[case] status: u16,
4621 #[case] code: i64,
4622 #[case] msg: &str,
4623 ) {
4624 let tasks = TaskGroup::new();
4625 let task_spawner = tasks.spawner().expect("task spawner");
4626 let clock = get_atomic_clock_realtime();
4627 let (emitter, mut rx) = create_test_emitter(clock);
4628 let http_client = create_test_http_client(clock);
4629 let client_order_id = ClientOrderId::from("TEST");
4630 let dispatch_state =
4631 create_tracked_dispatch_state(client_order_id, InstrumentId::from("BTCUSDT.BINANCE"));
4632 let ws_authenticated = tokio::sync::Notify::new();
4633 let ws_user_data_subscribed = tokio::sync::Notify::new();
4634 let (ws_setup_error_tx, _ws_setup_error_rx) = tokio::sync::mpsc::unbounded_channel();
4635 let seen_trade_ids = Arc::new(Mutex::new(FifoCache::new()));
4636
4637 dispatch_state.pending_requests.insert(
4638 "req-submit".to_string(),
4639 PendingRequest {
4640 command_id: None,
4641 client_order_id,
4642 venue_order_id: None,
4643 operation: PendingOperation::Place,
4644 },
4645 );
4646
4647 dispatch_ws_trading_message(
4648 BinanceSpotWsTradingMessage::OrderRejected {
4649 request_id: "req-submit".to_string(),
4650 status,
4651 code: code as i32,
4652 msg: msg.to_string(),
4653 },
4654 &emitter,
4655 &http_client,
4656 AccountId::from("BINANCE-001"),
4657 false,
4658 clock,
4659 &dispatch_state,
4660 &ws_authenticated,
4661 &ws_user_data_subscribed,
4662 &ws_setup_error_tx,
4663 &seen_trade_ids,
4664 &task_spawner,
4665 );
4666
4667 assert!(dispatch_state.pending_requests.get("req-submit").is_none());
4668 assert!(
4669 dispatch_state
4670 .order_identities
4671 .get(&client_order_id)
4672 .is_some()
4673 );
4674 assert!(rx.try_recv().is_err());
4675 }
4676
4677 #[rstest]
4678 #[case::post_only(
4679 400,
4680 BINANCE_NEW_ORDER_REJECTED_CODE as i32,
4681 BINANCE_SPOT_POST_ONLY_REJECT_MSG,
4682 true
4683 )]
4684 #[case::order_rate_limit(
4685 429,
4686 BINANCE_ORDER_RATE_LIMIT_CODE as i32,
4687 "Too many new orders; current limit is 100 orders per 10 SECOND.",
4688 false
4689 )]
4690 fn test_dispatch_ws_trading_message_definite_submit_rejection_emits_order_rejected(
4691 #[case] status: u16,
4692 #[case] code: i32,
4693 #[case] msg: &str,
4694 #[case] due_post_only: bool,
4695 ) {
4696 let tasks = TaskGroup::new();
4697 let task_spawner = tasks.spawner().expect("task spawner");
4698 let clock = get_atomic_clock_realtime();
4699 let (emitter, mut rx) = create_test_emitter(clock);
4700 let http_client = create_test_http_client(clock);
4701 let client_order_id = ClientOrderId::from("TEST");
4702 let dispatch_state =
4703 create_tracked_dispatch_state(client_order_id, InstrumentId::from("BTCUSDT.BINANCE"));
4704 let ws_authenticated = tokio::sync::Notify::new();
4705 let ws_user_data_subscribed = tokio::sync::Notify::new();
4706 let (ws_setup_error_tx, _ws_setup_error_rx) = tokio::sync::mpsc::unbounded_channel();
4707 let seen_trade_ids = Arc::new(Mutex::new(FifoCache::new()));
4708
4709 dispatch_state.pending_requests.insert(
4710 "req-submit".to_string(),
4711 PendingRequest {
4712 command_id: None,
4713 client_order_id,
4714 venue_order_id: None,
4715 operation: PendingOperation::Place,
4716 },
4717 );
4718
4719 dispatch_ws_trading_message(
4720 BinanceSpotWsTradingMessage::OrderRejected {
4721 request_id: "req-submit".to_string(),
4722 status,
4723 code,
4724 msg: msg.to_string(),
4725 },
4726 &emitter,
4727 &http_client,
4728 AccountId::from("BINANCE-001"),
4729 false,
4730 clock,
4731 &dispatch_state,
4732 &ws_authenticated,
4733 &ws_user_data_subscribed,
4734 &ws_setup_error_tx,
4735 &seen_trade_ids,
4736 &task_spawner,
4737 );
4738
4739 assert!(dispatch_state.pending_requests.get("req-submit").is_none());
4740 assert!(
4741 dispatch_state
4742 .order_identities
4743 .get(&client_order_id)
4744 .is_none()
4745 );
4746
4747 let expected_reason = format!("code={code}: {msg}");
4748
4749 match rx
4750 .try_recv()
4751 .expect("OrderRejected event should be emitted")
4752 {
4753 ExecutionEvent::Order(OrderEventAny::Rejected(event)) => {
4754 assert_eq!(event.client_order_id, client_order_id);
4755 assert_eq!(event.account_id, AccountId::from("BINANCE-001"));
4756 assert_eq!(event.reason.as_str(), expected_reason);
4757 assert_eq!(event.due_post_only, due_post_only);
4758 }
4759 other => panic!("Expected OrderRejected event, was {other:?}"),
4760 }
4761 }
4762
4763 #[rstest]
4764 fn test_dispatch_ws_trading_message_emits_modify_rejected_and_clears_pending_request() {
4765 let tasks = TaskGroup::new();
4766 let task_spawner = tasks.spawner().expect("task spawner");
4767 let clock = get_atomic_clock_realtime();
4768 let (emitter, mut rx) = create_test_emitter(clock);
4769 let http_client = create_test_http_client(clock);
4770 let dispatch_state = create_tracked_dispatch_state(
4771 ClientOrderId::from("TEST"),
4772 InstrumentId::from("BTCUSDT.BINANCE"),
4773 );
4774 let ws_authenticated = tokio::sync::Notify::new();
4775 let ws_user_data_subscribed = tokio::sync::Notify::new();
4776 let (ws_setup_error_tx, _ws_setup_error_rx) = tokio::sync::mpsc::unbounded_channel();
4777 let seen_trade_ids = Arc::new(Mutex::new(FifoCache::new()));
4778
4779 dispatch_state.pending_requests.insert(
4780 "req-modify".to_string(),
4781 PendingRequest {
4782 command_id: None,
4783 client_order_id: ClientOrderId::from("TEST"),
4784 venue_order_id: Some(VenueOrderId::from("12345")),
4785 operation: PendingOperation::Modify,
4786 },
4787 );
4788
4789 dispatch_ws_trading_message(
4790 BinanceSpotWsTradingMessage::CancelReplaceRejected {
4791 request_id: "req-modify".to_string(),
4792 status: 400,
4793 code: -2021,
4794 msg: "Order cancel-replace partially failed".to_string(),
4795 },
4796 &emitter,
4797 &http_client,
4798 AccountId::from("BINANCE-001"),
4799 false,
4800 clock,
4801 &dispatch_state,
4802 &ws_authenticated,
4803 &ws_user_data_subscribed,
4804 &ws_setup_error_tx,
4805 &seen_trade_ids,
4806 &task_spawner,
4807 );
4808
4809 assert!(dispatch_state.pending_requests.get("req-modify").is_none());
4810
4811 match rx
4812 .try_recv()
4813 .expect("Modify rejection event should be emitted")
4814 {
4815 ExecutionEvent::Order(OrderEventAny::ModifyRejected(event)) => {
4816 assert_eq!(event.client_order_id, ClientOrderId::from("TEST"));
4817 assert_eq!(event.account_id, Some(AccountId::from("BINANCE-001")));
4818 assert!(event.reason.contains("code=-2021"));
4819 }
4820 other => panic!("Expected ModifyRejected event, was {other:?}"),
4821 }
4822 }
4823
4824 fn dispatch_account_position(
4825 position: BinanceSpotAccountPositionMsg,
4826 ) -> tokio::sync::mpsc::UnboundedReceiver<ExecutionEvent> {
4827 let tasks = TaskGroup::new();
4828 let task_spawner = tasks.spawner().expect("task spawner");
4829 let clock = get_atomic_clock_realtime();
4830 let (emitter, rx) = create_test_emitter(clock);
4831 let http_client = create_test_http_client(clock);
4832 let dispatch_state = WsDispatchState::default();
4833 let ws_authenticated = tokio::sync::Notify::new();
4834 let ws_user_data_subscribed = tokio::sync::Notify::new();
4835 let (ws_setup_error_tx, _ws_setup_error_rx) = tokio::sync::mpsc::unbounded_channel();
4836 let seen_trade_ids = Arc::new(Mutex::new(FifoCache::new()));
4837
4838 dispatch_ws_trading_message(
4839 BinanceSpotWsTradingMessage::AccountPosition(position),
4840 &emitter,
4841 &http_client,
4842 AccountId::from("BINANCE-001"),
4843 false,
4844 clock,
4845 &dispatch_state,
4846 &ws_authenticated,
4847 &ws_user_data_subscribed,
4848 &ws_setup_error_tx,
4849 &seen_trade_ids,
4850 &task_spawner,
4851 );
4852
4853 rx
4854 }
4855
4856 fn account_position(balances: Vec<BinanceSpotBalanceEntry>) -> BinanceSpotAccountPositionMsg {
4857 BinanceSpotAccountPositionMsg {
4858 event_type: "outboundAccountPosition".to_string(),
4859 event_time: 1_700_000_000_000,
4860 last_update_time: 1_700_000_000_000,
4861 balances,
4862 }
4863 }
4864
4865 #[rstest]
4866 fn test_dispatch_account_position_emits_exact_balance() {
4867 let position = account_position(vec![BinanceSpotBalanceEntry {
4868 asset: Ustr::from("BTC"),
4869 free: Decimal::from(1),
4870 locked: Decimal::from(2),
4871 }]);
4872
4873 let mut rx = dispatch_account_position(position);
4874
4875 match rx.try_recv().expect("account state should be emitted") {
4876 ExecutionEvent::Account(state) => {
4877 assert_eq!(state.balances.len(), 1);
4878 assert_eq!(state.balances[0].total.as_decimal(), Decimal::from(3));
4879 assert_eq!(state.balances[0].locked.as_decimal(), Decimal::from(2));
4880 }
4881 other => panic!("Expected account state, was {other:?}"),
4882 }
4883
4884 assert!(rx.try_recv().is_err());
4885 }
4886
4887 #[rstest]
4888 fn test_dispatch_account_position_does_not_emit_partial_state() {
4889 let position = account_position(vec![
4890 BinanceSpotBalanceEntry {
4891 asset: Ustr::from("BTC"),
4892 free: Decimal::from(1),
4893 locked: Decimal::ZERO,
4894 },
4895 BinanceSpotBalanceEntry {
4896 asset: Ustr::from("ETH"),
4897 free: Decimal::from(i64::MAX),
4898 locked: Decimal::ZERO,
4899 },
4900 ]);
4901
4902 let mut rx = dispatch_account_position(position);
4903
4904 assert!(rx.try_recv().is_err());
4905 }
4906
4907 fn create_test_emitter(
4908 clock: &'static AtomicTime,
4909 ) -> (
4910 ExecutionEventEmitter,
4911 tokio::sync::mpsc::UnboundedReceiver<ExecutionEvent>,
4912 ) {
4913 let mut emitter = ExecutionEventEmitter::new(
4914 clock,
4915 TraderId::from("TESTER-001"),
4916 AccountId::from("BINANCE-001"),
4917 AccountType::Cash,
4918 None,
4919 );
4920 let (tx, rx) = tokio::sync::mpsc::unbounded_channel();
4921 emitter.set_sender(tx);
4922 (emitter, rx)
4923 }
4924
4925 fn create_test_http_client(clock: &'static AtomicTime) -> BinanceSpotHttpClient {
4926 let client = BinanceSpotHttpClient::new(
4927 BinanceEnvironment::Live,
4928 clock,
4929 None,
4930 None,
4931 None,
4932 None,
4933 None,
4934 None,
4935 )
4936 .expect("Test HTTP client should be created");
4937 client.cache_instruments(vec![
4938 nautilus_model::instruments::stubs::currency_pair_ethusdt().into(),
4939 nautilus_model::instruments::stubs::currency_pair_btcusdt().into(),
4940 ]);
4941 client
4942 }
4943
4944 fn create_tracked_dispatch_state(
4945 client_order_id: ClientOrderId,
4946 instrument_id: InstrumentId,
4947 ) -> WsDispatchState {
4948 let dispatch_state = WsDispatchState::default();
4949 dispatch_state.order_identities.insert(
4950 client_order_id,
4951 OrderIdentity {
4952 instrument_id,
4953 strategy_id: StrategyId::from("TEST-STRATEGY"),
4954 order_side: OrderSide::Buy,
4955 order_type: OrderType::Limit,
4956 price: None,
4957 quantity: Quantity::from("1"),
4958 is_quote_quantity: false,
4959 venue_position_id: None,
4960 },
4961 );
4962 dispatch_state
4963 }
4964
4965 fn create_list_status_state(status: &BinanceSpotListStatus) -> (Cache, WsDispatchState) {
4966 let mut cache = Cache::default();
4967 let state = WsDispatchState::default();
4968
4969 for child in &status.orders {
4970 let client_order_id = ClientOrderId::from(child.client_order_id.as_str());
4971 let mut order = OrderTestBuilder::new(OrderType::Limit)
4972 .trader_id(TraderId::from("TESTER-001"))
4973 .strategy_id(StrategyId::from("TEST-STRATEGY"))
4974 .client_order_id(client_order_id)
4975 .instrument_id(InstrumentId::from("BTCUSDT.BINANCE"))
4976 .side(OrderSide::Buy)
4977 .quantity(Quantity::from("0.001000"))
4978 .price(Price::from("50000.00"))
4979 .build();
4980 order
4981 .apply(TestOrderEventStubs::submitted(
4982 &order,
4983 AccountId::from("BINANCE-001"),
4984 ))
4985 .unwrap();
4986 state.order_identities.insert(
4987 client_order_id,
4988 OrderIdentity {
4989 instrument_id: order.instrument_id(),
4990 strategy_id: order.strategy_id(),
4991 order_side: order.order_side(),
4992 order_type: order.order_type(),
4993 price: order.price(),
4994 quantity: order.quantity(),
4995 is_quote_quantity: false,
4996 venue_position_id: None,
4997 },
4998 );
4999
5000 cache.add_order(order, None, None, false).unwrap();
5001 }
5002
5003 (cache, state)
5004 }
5005
5006 fn list_status_fixture(rejected: bool) -> BinanceSpotListStatus {
5007 let name = if rejected { "rejected" } else { "executing" };
5008 let bytes = crate::common::testing::load_fixture_bytes(&format!(
5009 "spot/user_data_sbe/list_status_{name}.sbe"
5010 ));
5011 crate::spot::websocket::trading::decode_sbe::decode_list_status(&bytes).unwrap()
5012 }
5013
5014 #[rstest]
5015 #[case::list_before_report(false)]
5016 #[case::report_before_list(true)]
5017 fn test_dispatch_list_status_acceptance_ordering(
5018 #[case] report_first: bool,
5019 #[values(false, true)] filled: bool,
5020 ) {
5021 let status = list_status_fixture(false);
5022 let (mut cache, state) = create_list_status_state(&status);
5023 let clock = get_atomic_clock_realtime();
5024 let (emitter, mut rx) = create_test_emitter(clock);
5025 let client = create_test_http_client(clock);
5026 let account_id = AccountId::from("BINANCE-001");
5027 let ts_init = UnixNanos::from(1_734_300_000_999_888_000u64);
5028 let seen = Arc::new(Mutex::new(FifoCache::new()));
5029 let json = crate::common::testing::load_fixture_string(
5030 "spot/user_data_json/execution_report_new.json",
5031 );
5032
5033 let reports: Vec<_> = status
5034 .orders
5035 .iter()
5036 .map(|child| {
5037 let mut report: BinanceSpotExecutionReport = serde_json::from_str(&json).unwrap();
5038 report.symbol = child.symbol;
5039 report.order_id = child.order_id;
5040 report.client_order_id = child.client_order_id.clone();
5041 report.original_qty = "0.001000".to_owned();
5042 report.price = "50000.00".to_owned();
5043 report.stop_price = "0".to_owned();
5044 report
5045 })
5046 .collect();
5047
5048 let dispatch = |report: &BinanceSpotExecutionReport| {
5049 dispatch_execution_report(
5050 report, &emitter, &client, account_id, false, &state, &seen, ts_init,
5051 );
5052 };
5053
5054 if report_first {
5055 dispatch(&reports[0]);
5056 }
5057
5058 dispatch_list_status(&status, &emitter, account_id, &state, ts_init);
5059 dispatch_list_status(&status, &emitter, account_id, &state, ts_init);
5060
5061 for report in &reports {
5062 dispatch(report);
5063 dispatch(report);
5064 }
5065
5066 for (index, report) in reports.iter().enumerate() {
5067 let mut terminal = report.clone();
5068
5069 terminal.execution_type = if filled {
5070 BinanceSpotExecutionType::Trade
5071 } else {
5072 BinanceSpotExecutionType::Canceled
5073 };
5074
5075 terminal.order_status = if filled {
5076 BinanceOrderStatus::Filled
5077 } else {
5078 BinanceOrderStatus::Canceled
5079 };
5080
5081 terminal.last_filled_qty = "0.001000".to_owned();
5082 terminal.cumulative_filled_qty = "0.001000".to_owned();
5083 terminal.last_filled_price = "50000.00".to_owned();
5084 terminal.trade_id = 9000 + index as i64;
5085 terminal.commission = "0.00000100".to_owned();
5086 terminal.commission_asset = Some(Ustr::from("BTC"));
5087 dispatch(&terminal);
5088 }
5089
5090 dispatch_list_status(&status, &emitter, account_id, &state, ts_init);
5091 let events: Vec<_> = std::iter::from_fn(|| rx.try_recv().ok()).collect();
5092 assert_eq!(events.len(), 4);
5093
5094 for (index, event) in events.iter().enumerate() {
5095 let ExecutionEvent::Order(event) = event else {
5096 panic!("Expected order event");
5097 };
5098
5099 if index < 2 {
5100 let OrderEventAny::Accepted(accepted) = event else {
5101 panic!("Expected acceptance");
5102 };
5103
5104 assert_eq!(
5105 accepted.client_order_id.as_str(),
5106 status.orders[index].client_order_id
5107 );
5108 assert_eq!(
5109 accepted.venue_order_id.as_str(),
5110 status.orders[index].order_id.to_string()
5111 );
5112 assert_eq!(accepted.account_id, account_id);
5113 assert_eq!(accepted.trader_id, TraderId::from("TESTER-001"));
5114 assert_eq!(accepted.ts_init, ts_init);
5115 assert_eq!(
5116 accepted.ts_event,
5117 if report_first && index == 0 {
5118 UnixNanos::from_millis_checked(reports[0].event_time).unwrap()
5119 } else {
5120 UnixNanos::from_micros_checked(status.transaction_time_us).unwrap()
5121 }
5122 );
5123 assert_eq!(accepted.strategy_id, StrategyId::from("TEST-STRATEGY"));
5124 assert_eq!(
5125 accepted.instrument_id,
5126 InstrumentId::from("BTCUSDT.BINANCE")
5127 );
5128 assert!(!accepted.reconciliation);
5129 } else {
5130 assert_eq!(
5131 event.client_order_id().as_str(),
5132 status.orders[index - 2].client_order_id
5133 );
5134 assert!(matches!(event, OrderEventAny::Filled(_)) == filled);
5135 }
5136
5137 cache.update_order(event).unwrap();
5138 }
5139
5140 for child in &status.orders {
5141 let cid = ClientOrderId::from(child.client_order_id.as_str());
5142 let venue_id = VenueOrderId::from(child.order_id.to_string());
5143 let order = cache.order(&cid).unwrap();
5144 assert_eq!(
5145 order.status(),
5146 if filled {
5147 OrderStatus::Filled
5148 } else {
5149 OrderStatus::Canceled
5150 }
5151 );
5152 assert_eq!(order.venue_order_id(), Some(venue_id));
5153 assert_eq!(order.account_id(), Some(account_id));
5154 assert_eq!(cache.client_order_id(&venue_id), Some(&cid));
5155 assert!(!state.has_emitted_accepted(&cid));
5156 assert!(!state.has_filled(&cid));
5157 }
5158
5159 assert!(state.order_identities.is_empty());
5160 assert!(state.order_lists.is_empty());
5161 assert!(state.pending_requests.is_empty());
5162 }
5163
5164 #[rstest]
5165 #[case::list_first(false)]
5166 #[case::http_first(true)]
5167 fn test_dispatch_list_status_rejection_once(#[case] http_first: bool) {
5168 let status = list_status_fixture(true);
5169 let (mut cache, state) = create_list_status_state(&status);
5170 let clock = get_atomic_clock_realtime();
5171 let (emitter, mut rx) = create_test_emitter(clock);
5172
5173 let orders: Vec<_> = status
5174 .orders
5175 .iter()
5176 .map(|child| {
5177 cache
5178 .order(&ClientOrderId::from(child.client_order_id.as_str()))
5179 .unwrap()
5180 .clone()
5181 })
5182 .collect();
5183
5184 for child in &status.orders {
5185 state.pending_requests.insert(
5186 child.client_order_id.clone(),
5187 PendingRequest {
5188 command_id: None,
5189 client_order_id: ClientOrderId::from(child.client_order_id.as_str()),
5190 venue_order_id: None,
5191 operation: PendingOperation::Place,
5192 },
5193 );
5194 }
5195
5196 let http_reject = || {
5197 let error = BinanceSpotHttpError::BinanceError {
5198 code: -2010,
5199 message: "INSUFFICIENT_BALANCES".to_owned(),
5200 status: 400,
5201 retry_after: None,
5202 };
5203
5204 assert!(
5205 handle_spot_order_list_submit_error(
5206 &emitter,
5207 &state,
5208 AccountId::from("BINANCE-001"),
5209 clock,
5210 &orders,
5211 error
5212 )
5213 .is_err()
5214 );
5215 };
5216
5217 if http_first {
5218 http_reject();
5219 }
5220
5221 for _ in 0..2 {
5222 dispatch_list_status(
5223 &status,
5224 &emitter,
5225 AccountId::from("BINANCE-001"),
5226 &state,
5227 clock.get_time_ns(),
5228 );
5229 }
5230
5231 if !http_first {
5232 http_reject();
5233 }
5234
5235 let events: Vec<_> = std::iter::from_fn(|| rx.try_recv().ok()).collect();
5236 assert_eq!(events.len(), 2);
5237
5238 for (index, event) in events.iter().enumerate() {
5239 let ExecutionEvent::Order(OrderEventAny::Rejected(rejected)) = event else {
5240 panic!("Expected rejection");
5241 };
5242
5243 assert_eq!(
5244 rejected.client_order_id.as_str(),
5245 status.orders[index].client_order_id
5246 );
5247 assert_eq!(
5248 rejected.reason.as_str(),
5249 if http_first {
5250 "submit-order-list-error: Binance error -2010 (HTTP 400): INSUFFICIENT_BALANCES"
5251 } else {
5252 "INSUFFICIENT_BALANCES"
5253 }
5254 );
5255 assert_eq!(rejected.trader_id, TraderId::from("TESTER-001"));
5256 assert_eq!(rejected.strategy_id, StrategyId::from("TEST-STRATEGY"));
5257 assert_eq!(
5258 rejected.instrument_id,
5259 InstrumentId::from("BTCUSDT.BINANCE")
5260 );
5261 assert_eq!(rejected.account_id, AccountId::from("BINANCE-001"));
5262 assert!(!rejected.reconciliation);
5263 assert!(!rejected.due_post_only);
5264 cache
5265 .update_order(&OrderEventAny::Rejected(rejected.clone()))
5266 .unwrap();
5267 }
5268
5269 for child in &status.orders {
5270 assert_eq!(
5271 cache
5272 .order(&ClientOrderId::from(child.client_order_id.as_str()))
5273 .unwrap()
5274 .status(),
5275 OrderStatus::Rejected
5276 );
5277 }
5278
5279 assert!(state.order_identities.is_empty());
5280 assert!(state.pending_requests.is_empty());
5281 assert!(state.order_lists.is_empty());
5282 }
5283
5284 #[rstest]
5285 fn test_dispatch_list_status_untracked_and_aggregate_terminal() {
5286 let mut status = list_status_fixture(false);
5287 let (_cache, state) = create_list_status_state(&status);
5288 let first = ClientOrderId::from(status.orders[0].client_order_id.as_str());
5289 let second = ClientOrderId::from(status.orders[1].client_order_id.as_str());
5290 state.order_identities.remove(&second);
5291 let clock = get_atomic_clock_realtime();
5292 let (emitter, mut rx) = create_test_emitter(clock);
5293 dispatch_list_status(
5294 &status,
5295 &emitter,
5296 AccountId::from("BINANCE-001"),
5297 &state,
5298 clock.get_time_ns(),
5299 );
5300 status.list_status_type = SbeListStatusType::AllDone;
5301 status.list_order_status = SbeListOrderStatus::AllDone;
5302 dispatch_list_status(
5303 &status,
5304 &emitter,
5305 AccountId::from("BINANCE-001"),
5306 &state,
5307 clock.get_time_ns(),
5308 );
5309 status.list_status_type = SbeListStatusType::Response;
5310 status.list_order_status = SbeListOrderStatus::Reject;
5311 status.reject_reason = "INSUFFICIENT_BALANCES".to_owned();
5312 dispatch_list_status(
5313 &status,
5314 &emitter,
5315 AccountId::from("BINANCE-001"),
5316 &state,
5317 clock.get_time_ns(),
5318 );
5319 let events: Vec<_> = std::iter::from_fn(|| rx.try_recv().ok()).collect();
5320 assert_eq!(events.len(), 1);
5321 assert!(
5322 matches!(&events[0], ExecutionEvent::Order(OrderEventAny::Accepted(event)) if event.client_order_id == first)
5323 );
5324 assert!(state.order_identities.contains_key(&first));
5325 assert!(!state.order_identities.contains_key(&second));
5326 assert_eq!(state.order_lists.len(), 1);
5327 }
5328
5329 #[rstest]
5330 fn test_dispatch_list_status_rejection_after_execution_report() {
5331 let status = list_status_fixture(true);
5332 let (mut cache, state) = create_list_status_state(&status);
5333 let clock = get_atomic_clock_realtime();
5334 let (emitter, mut rx) = create_test_emitter(clock);
5335 let client = create_test_http_client(clock);
5336 let seen = Arc::new(Mutex::new(FifoCache::new()));
5337 let json = crate::common::testing::load_fixture_string(
5338 "spot/user_data_json/execution_report_new.json",
5339 );
5340 let first = &status.orders[0];
5341 let mut report: BinanceSpotExecutionReport = serde_json::from_str(&json).unwrap();
5342 report.symbol = first.symbol;
5343 report.order_id = first.order_id;
5344 report.client_order_id = first.client_order_id.clone();
5345 report.execution_type = BinanceSpotExecutionType::Rejected;
5346 report.order_status = BinanceOrderStatus::Rejected;
5347 report.reject_reason = "INSUFFICIENT_BALANCES".to_owned();
5348 dispatch_execution_report(
5349 &report,
5350 &emitter,
5351 &client,
5352 AccountId::from("BINANCE-001"),
5353 false,
5354 &state,
5355 &seen,
5356 clock.get_time_ns(),
5357 );
5358 dispatch_list_status(
5359 &status,
5360 &emitter,
5361 AccountId::from("BINANCE-001"),
5362 &state,
5363 clock.get_time_ns(),
5364 );
5365 dispatch_list_status(
5366 &status,
5367 &emitter,
5368 AccountId::from("BINANCE-001"),
5369 &state,
5370 clock.get_time_ns(),
5371 );
5372 let events: Vec<_> = std::iter::from_fn(|| rx.try_recv().ok()).collect();
5373 assert_eq!(events.len(), 2);
5374
5375 for (index, event) in events.iter().enumerate() {
5376 let ExecutionEvent::Order(OrderEventAny::Rejected(rejected)) = event else {
5377 panic!("Expected rejection");
5378 };
5379
5380 assert_eq!(
5381 rejected.client_order_id.as_str(),
5382 status.orders[index].client_order_id
5383 );
5384 assert_eq!(rejected.reason.as_str(), "INSUFFICIENT_BALANCES");
5385 cache
5386 .update_order(&OrderEventAny::Rejected(rejected.clone()))
5387 .unwrap();
5388 }
5389
5390 assert!(state.order_identities.is_empty());
5391 assert!(state.order_lists.is_empty());
5392 assert!(state.pending_requests.is_empty());
5393
5394 for child in &status.orders {
5395 assert_eq!(
5396 cache
5397 .order(&ClientOrderId::from(child.client_order_id.as_str()))
5398 .unwrap()
5399 .status(),
5400 OrderStatus::Rejected
5401 );
5402 }
5403 }
5404
5405 #[rstest]
5406 fn test_dispatch_list_status_acceptance_survives_fifo_turnover() {
5407 let status = list_status_fixture(false);
5408 let (_cache, state) = create_list_status_state(&status);
5409 let clock = get_atomic_clock_realtime();
5410 let (emitter, mut rx) = create_test_emitter(clock);
5411 dispatch_list_status(
5412 &status,
5413 &emitter,
5414 AccountId::from("BINANCE-001"),
5415 &state,
5416 clock.get_time_ns(),
5417 );
5418
5419 for index in 0..10_001 {
5420 state.insert_accepted(ClientOrderId::from(format!("unrelated-{index}")));
5421 }
5422
5423 for child in &status.orders {
5424 let cid = ClientOrderId::from(child.client_order_id.as_str());
5425 let identity = state.order_identities.get(&cid).unwrap().clone();
5426 ensure_accepted_emitted(
5427 cid,
5428 AccountId::from("BINANCE-001"),
5429 VenueOrderId::from(child.order_id.to_string()),
5430 &identity,
5431 &emitter,
5432 &state,
5433 clock.get_time_ns(),
5434 );
5435 }
5436
5437 dispatch_list_status(
5438 &status,
5439 &emitter,
5440 AccountId::from("BINANCE-001"),
5441 &state,
5442 clock.get_time_ns(),
5443 );
5444
5445 for child in &status.orders {
5446 let cid = ClientOrderId::from(child.client_order_id.as_str());
5447 assert!(state.has_emitted_accepted(&cid));
5448 let list = state.order_lists.get(&cid).unwrap();
5449 assert_eq!(list.order_list_id, status.order_list_id);
5450 assert_eq!(list.venue_order_id.as_str(), child.order_id.to_string());
5451 assert!(!list.execution_report_seen);
5452 }
5453
5454 let events: Vec<_> = std::iter::from_fn(|| rx.try_recv().ok()).collect();
5455 assert_eq!(events.len(), 2);
5456
5457 for (index, event) in events.iter().enumerate() {
5458 assert!(
5459 matches!(event, ExecutionEvent::Order(OrderEventAny::Accepted(event)) if event.client_order_id.as_str() == status.orders[index].client_order_id)
5460 );
5461 }
5462 }
5463
5464 #[rstest]
5465 fn test_dispatch_list_status_preserves_replacement_update() {
5466 let status = list_status_fixture(false);
5467 let (mut cache, state) = create_list_status_state(&status);
5468 let clock = get_atomic_clock_realtime();
5469 let (emitter, mut rx) = create_test_emitter(clock);
5470 let client = create_test_http_client(clock);
5471 let seen = Arc::new(Mutex::new(FifoCache::new()));
5472 dispatch_list_status(
5473 &status,
5474 &emitter,
5475 AccountId::from("BINANCE-001"),
5476 &state,
5477 clock.get_time_ns(),
5478 );
5479 let json = crate::common::testing::load_fixture_string(
5480 "spot/user_data_json/execution_report_new.json",
5481 );
5482 let child = &status.orders[0];
5483 let mut report: BinanceSpotExecutionReport = serde_json::from_str(&json).unwrap();
5484 report.client_order_id = child.client_order_id.clone();
5485 report.symbol = child.symbol;
5486 report.order_id = child.order_id + 1;
5487 report.original_qty = "0.002000".to_owned();
5488 report.price = "49999.00".to_owned();
5489 report.stop_price = "0".to_owned();
5490 dispatch_execution_report(
5491 &report,
5492 &emitter,
5493 &client,
5494 AccountId::from("BINANCE-001"),
5495 false,
5496 &state,
5497 &seen,
5498 clock.get_time_ns(),
5499 );
5500 let events: Vec<_> = std::iter::from_fn(|| rx.try_recv().ok()).collect();
5501 assert_eq!(events.len(), 3);
5502
5503 for event in &events {
5504 let ExecutionEvent::Order(event) = event else {
5505 panic!("Expected order event");
5506 };
5507
5508 cache.update_order(event).unwrap();
5509 }
5510
5511 let ExecutionEvent::Order(OrderEventAny::Updated(updated)) = &events[2] else {
5512 panic!("Expected replacement update");
5513 };
5514
5515 assert_eq!(updated.client_order_id.as_str(), child.client_order_id);
5516 assert_eq!(updated.quantity, Quantity::from("0.002000"));
5517 assert_eq!(updated.price, Some(Price::from("49999.00")));
5518 assert_eq!(
5519 updated.venue_order_id,
5520 Some(VenueOrderId::from(report.order_id.to_string()))
5521 );
5522 let order = cache.order(&updated.client_order_id).unwrap();
5523 assert_eq!(order.status(), OrderStatus::Accepted);
5524 assert_eq!(order.quantity(), updated.quantity);
5525 assert_eq!(order.price(), updated.price);
5526 assert_eq!(order.venue_order_id(), updated.venue_order_id);
5527 }
5528
5529 fn create_cancel_order_list_response(
5530 children: &[(ClientOrderId, i64)],
5531 ) -> BinanceCancelOpenOrdersResponse {
5532 let symbol = "BTCUSDT";
5533 let order_list_id = 44;
5534 let orders = children
5535 .iter()
5536 .map(|(client_order_id, order_id)| BinanceCancelOrderListOrder {
5537 symbol: symbol.to_string(),
5538 order_id: *order_id,
5539 client_order_id: encode_broker_id(client_order_id, BINANCE_NAUTILUS_SPOT_BROKER_ID),
5540 })
5541 .collect();
5542 let order_reports = children
5543 .iter()
5544 .map(|(client_order_id, order_id)| BinanceCancelOrderResponse {
5545 price_exponent: -8,
5546 qty_exponent: -8,
5547 order_id: *order_id,
5548 order_list_id: Some(order_list_id),
5549 transact_time: 1_734_300_000_000_000,
5550 price_mantissa: 100_000_000_000,
5551 orig_qty_mantissa: 10_000_000,
5552 executed_qty_mantissa: 0,
5553 cummulative_quote_qty_mantissa: 0,
5554 status: SbeOrderStatus::Canceled,
5555 time_in_force: SbeTimeInForce::Gtc,
5556 order_type: SbeOrderType::Limit,
5557 side: SbeOrderSide::Sell,
5558 self_trade_prevention_mode: SbeStp::None,
5559 client_order_id: "cancel-list".to_string(),
5560 orig_client_order_id: encode_broker_id(
5561 client_order_id,
5562 BINANCE_NAUTILUS_SPOT_BROKER_ID,
5563 ),
5564 symbol: symbol.to_string(),
5565 })
5566 .collect();
5567 BinanceCancelOpenOrdersResponse::OrderList(BinanceCancelOrderListResponse {
5568 order_list_id,
5569 contingency_type: SbeContingencyType::Oco,
5570 list_status_type: SbeListStatusType::AllDone,
5571 list_order_status: SbeListOrderStatus::AllDone,
5572 transaction_time: 1_734_300_000_000_000,
5573 list_client_order_id: "list-44".to_string(),
5574 symbol: symbol.to_string(),
5575 orders,
5576 order_reports,
5577 })
5578 }
5579
5580 #[rstest]
5581 fn test_dispatch_order_list_canceled_emits_ordered_events_once_and_cleans_state() {
5582 let clock = get_atomic_clock_realtime();
5583 let (emitter, mut rx) = create_test_emitter(clock);
5584 let account_id = AccountId::from("BINANCE-001");
5585 let instrument_id = InstrumentId::from("BTCUSDT.BINANCE");
5586 let first = ClientOrderId::from("O-20200101-000000-001-001-1");
5587 let second = ClientOrderId::from("O-20200101-000000-002-002-2");
5588 let state = create_tracked_dispatch_state(first, instrument_id);
5589 state.order_identities.insert(
5590 second,
5591 OrderIdentity {
5592 instrument_id,
5593 strategy_id: StrategyId::from("TEST-STRATEGY"),
5594 order_side: OrderSide::Sell,
5595 order_type: OrderType::Limit,
5596 price: None,
5597 quantity: Quantity::from("1"),
5598 is_quote_quantity: false,
5599 venue_position_id: None,
5600 },
5601 );
5602
5603 for (request_id, client_order_id) in [("cancel-1", first), ("cancel-2", second)] {
5604 state.pending_requests.insert(
5605 request_id.to_string(),
5606 PendingRequest {
5607 command_id: None,
5608 client_order_id,
5609 venue_order_id: None,
5610 operation: PendingOperation::Cancel,
5611 },
5612 );
5613 }
5614
5615 let prepared = prepare_cancel_all_orders(vec![create_cancel_order_list_response(&[
5616 (first, 111),
5617 (second, 222),
5618 ])])
5619 .unwrap();
5620
5621 for canceled_order in &prepared {
5622 dispatch_order_list_canceled(
5623 canceled_order,
5624 &emitter,
5625 account_id,
5626 &state,
5627 clock.get_time_ns(),
5628 );
5629 }
5630
5631 for canceled_order in &prepared {
5632 dispatch_order_list_canceled(
5633 canceled_order,
5634 &emitter,
5635 account_id,
5636 &state,
5637 clock.get_time_ns(),
5638 );
5639 }
5640
5641 let events: Vec<_> = std::iter::from_fn(|| rx.try_recv().ok()).collect();
5642 assert_eq!(events.len(), 4);
5643
5644 for (accepted_index, canceled_index, client_order_id) in [(0, 1, first), (2, 3, second)] {
5645 assert!(matches!(
5646 &events[accepted_index],
5647 ExecutionEvent::Order(OrderEventAny::Accepted(event))
5648 if event.client_order_id == client_order_id
5649 ));
5650 assert!(matches!(
5651 &events[canceled_index],
5652 ExecutionEvent::Order(OrderEventAny::Canceled(event))
5653 if event.client_order_id == client_order_id
5654 ));
5655 }
5656 assert!(state.order_identities.is_empty());
5657 assert!(state.pending_requests.is_empty());
5658 assert!(!state.has_emitted_accepted(&first));
5659 assert!(!state.has_emitted_accepted(&second));
5660 assert!(state.is_terminal(&first));
5661 assert!(state.is_terminal(&second));
5662 }
5663
5664 #[rstest]
5665 fn test_prepare_cancel_order_list_rejects_mismatched_child_without_events() {
5666 let clock = get_atomic_clock_realtime();
5667 let (_emitter, mut rx) = create_test_emitter(clock);
5668 let client_order_id = ClientOrderId::from("O-20200101-000000-001-001-1");
5669 let mut response = create_cancel_order_list_response(&[(client_order_id, 111)]);
5670 let BinanceCancelOpenOrdersResponse::OrderList(order_list) = &mut response else {
5671 unreachable!();
5672 };
5673 order_list.order_reports[0].orig_client_order_id = encode_broker_id(
5674 &ClientOrderId::from("OTHER"),
5675 BINANCE_NAUTILUS_SPOT_BROKER_ID,
5676 );
5677
5678 let error = prepare_cancel_all_orders(vec![response]).unwrap_err();
5679
5680 assert!(
5681 error
5682 .to_string()
5683 .contains("does not match its order identity")
5684 );
5685 assert!(rx.try_recv().is_err());
5686 }
5687
5688 #[rstest]
5689 fn test_prepare_cancel_order_list_rejects_non_canceled_child_without_state_change() {
5690 let clock = get_atomic_clock_realtime();
5691 let (_emitter, mut rx) = create_test_emitter(clock);
5692 let client_order_id = ClientOrderId::from("O-20200101-000000-001-001-1");
5693 let instrument_id = InstrumentId::from("BTCUSDT.BINANCE");
5694 let state = create_tracked_dispatch_state(client_order_id, instrument_id);
5695 let mut response = create_cancel_order_list_response(&[(client_order_id, 111)]);
5696 let BinanceCancelOpenOrdersResponse::OrderList(order_list) = &mut response else {
5697 unreachable!();
5698 };
5699 order_list.order_reports[0].status = SbeOrderStatus::Filled;
5700
5701 let error = prepare_cancel_all_orders(vec![response]).unwrap_err();
5702
5703 assert!(error.to_string().contains("reports status Filled"));
5704 assert!(state.order_identities.contains_key(&client_order_id));
5705 assert!(rx.try_recv().is_err());
5706 }
5707
5708 #[rstest]
5709 fn test_dispatch_order_list_canceled_concurrent_duplicate_emits_once() {
5710 let clock = get_atomic_clock_realtime();
5711 let (emitter, mut rx) = create_test_emitter(clock);
5712 let account_id = AccountId::from("BINANCE-001");
5713 let client_order_id = ClientOrderId::from("O-20200101-000000-001-001-1");
5714 let instrument_id = InstrumentId::from("BTCUSDT.BINANCE");
5715 let state = create_tracked_dispatch_state(client_order_id, instrument_id);
5716 let prepared = prepare_cancel_all_orders(vec![create_cancel_order_list_response(&[(
5717 client_order_id,
5718 111,
5719 )])])
5720 .unwrap();
5721
5722 std::thread::scope(|scope| {
5723 for _ in 0..2 {
5724 scope.spawn(|| {
5725 dispatch_order_list_canceled(
5726 &prepared[0],
5727 &emitter,
5728 account_id,
5729 &state,
5730 clock.get_time_ns(),
5731 );
5732 });
5733 }
5734 });
5735
5736 let events: Vec<_> = std::iter::from_fn(|| rx.try_recv().ok()).collect();
5737 assert_eq!(events.len(), 2);
5738 assert!(matches!(
5739 &events[0],
5740 ExecutionEvent::Order(OrderEventAny::Accepted(event))
5741 if event.client_order_id == client_order_id
5742 ));
5743 assert!(matches!(
5744 &events[1],
5745 ExecutionEvent::Order(OrderEventAny::Canceled(event))
5746 if event.client_order_id == client_order_id
5747 ));
5748 assert!(state.order_identities.is_empty());
5749 }
5750
5751 #[rstest]
5752 fn test_http_submit_success_defers_acceptance_to_user_stream() {
5753 let clock = get_atomic_clock_realtime();
5754 let (emitter, mut rx) = create_test_emitter(clock);
5755 let client_order_id = ClientOrderId::from("O-20200101-000000-000-000-0");
5756 let instrument_id = InstrumentId::from("ETHUSDT.BINANCE");
5757 let dispatch_state = Arc::new(create_tracked_dispatch_state(
5758 client_order_id,
5759 instrument_id,
5760 ));
5761 handle_spot_order_submit_success(client_order_id, VenueOrderId::from("12345678"));
5762
5763 assert!(!dispatch_state.has_emitted_accepted(&client_order_id));
5764 assert!(rx.try_recv().is_err());
5765 let new_json = crate::common::testing::load_fixture_string(
5766 "spot/user_data_json/execution_report_new.json",
5767 );
5768 let report: BinanceSpotExecutionReport = serde_json::from_str(&new_json).unwrap();
5769 let identity = dispatch_state
5770 .order_identities
5771 .get(&client_order_id)
5772 .unwrap()
5773 .clone();
5774 dispatch_tracked_execution_report(
5775 &report,
5776 &emitter,
5777 AccountId::from("BINANCE-001"),
5778 false,
5779 &dispatch_state,
5780 &Arc::new(Mutex::new(FifoCache::new())),
5781 client_order_id,
5782 &identity,
5783 instrument_id,
5784 2,
5785 8,
5786 Currency::USDT(),
5787 clock.get_time_ns(),
5788 );
5789
5790 assert!(matches!(
5791 rx.try_recv(),
5792 Ok(ExecutionEvent::Order(OrderEventAny::Accepted(event)))
5793 if event.client_order_id == client_order_id
5794 && event.venue_order_id == VenueOrderId::from("12345678")
5795 ));
5796 assert!(rx.try_recv().is_err());
5797 }
5798
5799 #[rstest]
5800 #[case::gtx(
5801 BinanceSpotHttpError::BinanceError {
5802 code: BINANCE_GTX_ORDER_REJECT_CODE,
5803 message: "Order would immediately trigger.".to_string(),
5804 status: 400,
5805 retry_after: None,
5806 },
5807 true,
5808 )]
5809 #[case::spot_post_only(
5810 BinanceSpotHttpError::BinanceError {
5811 code: BINANCE_NEW_ORDER_REJECTED_CODE,
5812 message: BINANCE_SPOT_POST_ONLY_REJECT_MSG.to_string(),
5813 status: 400,
5814 retry_after: None,
5815 },
5816 true,
5817 )]
5818 #[case::new_order_rejected_other_message(
5819 BinanceSpotHttpError::BinanceError {
5820 code: BINANCE_NEW_ORDER_REJECTED_CODE,
5821 message: "Insufficient balance.".to_string(),
5822 status: 400,
5823 retry_after: None,
5824 },
5825 false,
5826 )]
5827 #[case::unrelated_code(
5828 BinanceSpotHttpError::BinanceError {
5829 code: -2011,
5830 message: "Unknown order sent.".to_string(),
5831 status: 400,
5832 retry_after: None,
5833 },
5834 false,
5835 )]
5836 #[case::non_binance_error(
5837 BinanceSpotHttpError::NetworkError("connection reset".to_string()),
5838 false,
5839 )]
5840 fn test_is_spot_post_only_rejection(
5841 #[case] error: BinanceSpotHttpError,
5842 #[case] expected: bool,
5843 ) {
5844 assert_eq!(is_spot_post_only_rejection(&error), expected);
5845 }
5846
5847 #[rstest]
5848 #[case::filled(BinanceSpotExecutionType::Trade)]
5849 #[case::canceled(BinanceSpotExecutionType::Canceled)]
5850 #[case::expired(BinanceSpotExecutionType::Expired)]
5851 #[case::rejected(BinanceSpotExecutionType::Rejected)]
5852 #[case::prevented(BinanceSpotExecutionType::TradePrevention)]
5853 fn test_terminal_execution_report_replay(#[case] terminal_type: BinanceSpotExecutionType) {
5854 let clock = get_atomic_clock_realtime();
5855 let (emitter, mut rx) = create_test_emitter(clock);
5856 let client = create_test_http_client(clock);
5857 let cid = ClientOrderId::from("O-20200101-000000-000-000-0");
5858 let instrument_id = InstrumentId::from("ETHUSDT.BINANCE");
5859 let state = create_tracked_dispatch_state(cid, instrument_id);
5860 let seen = state.seen_trade_ids();
5861 let json = crate::common::testing::load_fixture_string(
5862 "spot/user_data_json/execution_report_trade.json",
5863 );
5864 let mut report: BinanceSpotExecutionReport = serde_json::from_str(&json).unwrap();
5865 report.execution_type = terminal_type;
5866 let ts_init = UnixNanos::from(1_734_300_000_999_888_000u64);
5867
5868 let dispatch = |report: &BinanceSpotExecutionReport| {
5869 dispatch_execution_report(
5870 report,
5871 &emitter,
5872 &client,
5873 AccountId::from("BINANCE-001"),
5874 false,
5875 &state,
5876 &seen,
5877 ts_init,
5878 );
5879 };
5880
5881 dispatch(&report);
5882 let initial: Vec<_> = std::iter::from_fn(|| rx.try_recv().ok()).collect();
5883 assert_eq!(
5884 initial.len(),
5885 if terminal_type == BinanceSpotExecutionType::Rejected {
5886 1
5887 } else {
5888 2
5889 }
5890 );
5891 assert!(!state.order_identities.contains_key(&cid));
5892 assert!(state.is_terminal(&cid));
5893
5894 dispatch(&report);
5895 let mut stale = report.clone();
5896 stale.execution_type = BinanceSpotExecutionType::New;
5897 dispatch(&stale);
5898 assert!(rx.try_recv().is_err());
5899
5900 let mut late = report;
5901 late.execution_type = BinanceSpotExecutionType::Trade;
5902 late.trade_id += 1;
5903 late.last_filled_qty = "0.12345".to_owned();
5904 late.last_filled_price = "2501.23".to_owned();
5905 let mut malformed = late.clone();
5906 malformed.last_filled_price = "invalid".to_owned();
5907 dispatch(&malformed);
5908 assert!(rx.try_recv().is_err());
5909 dispatch(&late);
5910 dispatch(&late);
5911 let events: Vec<_> = std::iter::from_fn(|| rx.try_recv().ok()).collect();
5912 assert_eq!(events.len(), 1);
5913
5914 let ExecutionEvent::Report(ExecutionReport::Fill(fill)) = &events[0] else {
5915 panic!("Expected only a late fill report");
5916 };
5917
5918 let expected = FillReport::new(
5919 AccountId::from("BINANCE-001"),
5920 instrument_id,
5921 VenueOrderId::from("12345678"),
5922 TradeId::from("98765433"),
5923 OrderSide::Buy,
5924 Quantity::from("0.12345"),
5925 Price::from("2501.23"),
5926 Money::from("0.001 ETH"),
5927 LiquiditySide::Maker,
5928 Some(cid),
5929 None,
5930 UnixNanos::from(1_709_654_401_000_000_000u64),
5931 ts_init,
5932 Some(fill.report_id),
5933 );
5934 assert_eq!(fill.as_ref(), &expected);
5935 }
5936
5937 #[rstest]
5938 fn test_execution_report_skips_restored_mass_status_trade() {
5939 let clock = get_atomic_clock_realtime();
5940 let (emitter, mut rx) = create_test_emitter(clock);
5941 let client = create_test_http_client(clock);
5942 let state = WsDispatchState::default();
5943 let instrument_id = InstrumentId::from("ETHUSDT.BINANCE");
5944 let account_id = AccountId::from("BINANCE-001");
5945 let json = crate::common::testing::load_fixture_string(
5946 "spot/user_data_json/execution_report_trade.json",
5947 );
5948 let mut msg: BinanceSpotExecutionReport = serde_json::from_str(&json).unwrap();
5949 let ts_init = clock.get_time_ns();
5950 let report = parse_spot_exec_report_to_order_status(
5951 &msg,
5952 instrument_id,
5953 2,
5954 5,
5955 account_id,
5956 false,
5957 ts_init,
5958 )
5959 .unwrap();
5960 let fill =
5961 parse_spot_exec_report_to_fill(&msg, instrument_id, 2, 5, account_id, ts_init).unwrap();
5962 let orders = indexmap::IndexMap::from([(report.venue_order_id, report)]);
5963 state.restore_terminal_fills(&orders, &[fill]);
5964 let seen = state.seen_trade_ids();
5965
5966 let dispatch = |msg: &BinanceSpotExecutionReport| {
5967 dispatch_execution_report(
5968 msg, &emitter, &client, account_id, false, &state, &seen, ts_init,
5969 );
5970 };
5971
5972 dispatch(&msg);
5973 assert!(rx.try_recv().is_err());
5974 msg.trade_id += 1;
5975 dispatch(&msg);
5976 let status = rx.try_recv().unwrap();
5977
5978 let ExecutionEvent::Report(ExecutionReport::Order(status)) = status else {
5979 panic!("Expected a genuinely new untracked order status report");
5980 };
5981
5982 assert_eq!(status.venue_order_id, VenueOrderId::from("12345678"));
5983 assert_eq!(status.filled_qty, Quantity::from("1"));
5984 let event = rx.try_recv().unwrap();
5985
5986 let ExecutionEvent::Report(ExecutionReport::Fill(fill)) = event else {
5987 panic!("Expected a genuinely new untracked fill report");
5988 };
5989
5990 assert_eq!(fill.trade_id, TradeId::from("98765433"));
5991 assert!(rx.try_recv().is_err());
5992 }
5993
5994 #[rstest]
5995 fn test_closed_mass_status_retires_restored_order(#[values(false, true)] accepted: bool) {
5996 let clock = get_atomic_clock_realtime();
5997 let (emitter, mut rx) = create_test_emitter(clock);
5998 let client = create_test_http_client(clock);
5999 let state = WsDispatchState::default();
6000 let instrument_id = InstrumentId::from("ETHUSDT.BINANCE");
6001 let account_id = AccountId::from("BINANCE-001");
6002 let json = crate::common::testing::load_fixture_string(
6003 "spot/user_data_json/execution_report_trade.json",
6004 );
6005 let mut msg: BinanceSpotExecutionReport = serde_json::from_str(&json).unwrap();
6006 let ts_init = clock.get_time_ns();
6007 let report = parse_spot_exec_report_to_order_status(
6008 &msg,
6009 instrument_id,
6010 2,
6011 5,
6012 account_id,
6013 false,
6014 ts_init,
6015 )
6016 .unwrap();
6017 let fill =
6018 parse_spot_exec_report_to_fill(&msg, instrument_id, 2, 5, account_id, ts_init).unwrap();
6019 let cid = report.client_order_id.unwrap();
6020 let mut order = OrderTestBuilder::new(OrderType::Limit)
6021 .client_order_id(cid)
6022 .instrument_id(instrument_id)
6023 .quantity(report.quantity)
6024 .price(report.price.unwrap())
6025 .build();
6026 order
6027 .apply(TestOrderEventStubs::submitted(&order, account_id))
6028 .unwrap();
6029
6030 if accepted {
6031 order
6032 .apply(TestOrderEventStubs::accepted(
6033 &order,
6034 account_id,
6035 report.venue_order_id,
6036 ))
6037 .unwrap();
6038 }
6039
6040 state.restore_order(&order, None, 2);
6041 state.restore_terminal_fills(
6042 &indexmap::IndexMap::from([(report.venue_order_id, report.clone())]),
6043 std::slice::from_ref(&fill),
6044 );
6045
6046 for event in generate_reconciliation_order_pre_fill_events(&order, &report, ts_init) {
6047 order.apply(event).unwrap();
6048 }
6049
6050 let instrument = InstrumentAny::CurrencyPair(currency_pair_ethusdt());
6051 order
6052 .apply(reconcile_fill_report(&order, &fill, &instrument, ts_init, false).unwrap())
6053 .unwrap();
6054 dispatch_execution_report(
6055 &msg,
6056 &emitter,
6057 &client,
6058 account_id,
6059 false,
6060 &state,
6061 &state.seen_trade_ids(),
6062 ts_init,
6063 );
6064 msg.execution_type = BinanceSpotExecutionType::New;
6065 dispatch_execution_report(
6066 &msg,
6067 &emitter,
6068 &client,
6069 account_id,
6070 false,
6071 &state,
6072 &state.seen_trade_ids(),
6073 ts_init,
6074 );
6075 assert_eq!(order.status(), OrderStatus::Filled);
6076 assert_eq!(order.filled_qty(), Quantity::from("1"));
6077 assert!(state.is_terminal(&cid));
6078 assert!(!state.order_identities.contains_key(&cid));
6079 assert!(!state.has_emitted_accepted(&cid));
6080 assert!(!state.has_filled(&cid));
6081 assert!(rx.try_recv().is_err());
6082 }
6083
6084 #[rstest]
6085 fn test_terminal_execution_report_restored_trade_replay() {
6086 let clock = get_atomic_clock_realtime();
6087 let (emitter, mut rx) = create_test_emitter(clock);
6088 let client = create_test_http_client(clock);
6089 let cid = ClientOrderId::from("O-20200101-000000-000-000-0");
6090 let instrument_id = InstrumentId::from("ETHUSDT.BINANCE");
6091 let account_id = AccountId::from("BINANCE-001");
6092 let mut order = OrderTestBuilder::new(OrderType::Limit)
6093 .client_order_id(cid)
6094 .instrument_id(instrument_id)
6095 .quantity(Quantity::from("2"))
6096 .price(Price::from("2500.00"))
6097 .build();
6098 let accepted =
6099 TestOrderEventStubs::accepted(&order, account_id, VenueOrderId::from("12345678"));
6100 order.apply(accepted).unwrap();
6101 let fill = OrderFilledSpec::builder()
6102 .trader_id(order.trader_id())
6103 .strategy_id(order.strategy_id())
6104 .instrument_id(instrument_id)
6105 .client_order_id(cid)
6106 .account_id(account_id)
6107 .venue_order_id(VenueOrderId::from("12345678"))
6108 .trade_id(TradeId::from("98765432"))
6109 .last_qty(Quantity::from("1"))
6110 .last_px(Price::from("2500.00"))
6111 .build();
6112 order.apply(OrderEventAny::Filled(fill)).unwrap();
6113 let state = WsDispatchState::default();
6114 state.restore_order(&order, None, 2);
6115 state.cleanup_terminal(cid);
6116 let json = crate::common::testing::load_fixture_string(
6117 "spot/user_data_json/execution_report_trade.json",
6118 );
6119 let report: BinanceSpotExecutionReport = serde_json::from_str(&json).unwrap();
6120 dispatch_execution_report(
6121 &report,
6122 &emitter,
6123 &client,
6124 account_id,
6125 false,
6126 &state,
6127 &state.seen_trade_ids(),
6128 clock.get_time_ns(),
6129 );
6130 assert!(state.is_terminal(&cid));
6131 assert!(state.seen_trade_ids().lock().is_empty());
6132 assert!(rx.try_recv().is_err());
6133 }
6134
6135 #[rstest]
6136 fn test_dispatch_tracked_execution_report_trade_dedup() {
6137 let tasks = TaskGroup::new();
6138 let task_spawner = tasks.spawner().expect("task spawner");
6139 let clock = get_atomic_clock_realtime();
6140 let (emitter, mut rx) = create_test_emitter(clock);
6141 let http_client = create_test_http_client(clock);
6142 let client_order_id = ClientOrderId::from("x-TD67BGP9-T0000000000000");
6143 let local_client_order_id = ClientOrderId::from("O-20200101-000000-000-000-0");
6144 let dispatch_state = create_tracked_dispatch_state(
6145 local_client_order_id,
6146 InstrumentId::from("ETHUSDT.BINANCE"),
6147 );
6148 dispatch_state
6149 .order_identities
6150 .get_mut(&local_client_order_id)
6151 .unwrap()
6152 .price = Some(Price::from("2500.00"));
6153 let ws_authenticated = tokio::sync::Notify::new();
6154 let ws_user_data_subscribed = tokio::sync::Notify::new();
6155 let (ws_setup_error_tx, _ws_setup_error_rx) = tokio::sync::mpsc::unbounded_channel();
6156 let seen_trade_ids = Arc::new(Mutex::new(FifoCache::new()));
6157
6158 let trade_json = crate::common::testing::load_fixture_string(
6159 "spot/user_data_json/execution_report_trade.json",
6160 );
6161 let report: BinanceSpotExecutionReport = serde_json::from_str(&trade_json).unwrap();
6162
6163 dispatch_ws_trading_message(
6164 BinanceSpotWsTradingMessage::ExecutionReport(Box::new(report.clone())),
6165 &emitter,
6166 &http_client,
6167 AccountId::from("BINANCE-001"),
6168 false,
6169 clock,
6170 &dispatch_state,
6171 &ws_authenticated,
6172 &ws_user_data_subscribed,
6173 &ws_setup_error_tx,
6174 &seen_trade_ids,
6175 &task_spawner,
6176 );
6177 dispatch_ws_trading_message(
6178 BinanceSpotWsTradingMessage::ExecutionReport(Box::new(report)),
6179 &emitter,
6180 &http_client,
6181 AccountId::from("BINANCE-001"),
6182 false,
6183 clock,
6184 &dispatch_state,
6185 &ws_authenticated,
6186 &ws_user_data_subscribed,
6187 &ws_setup_error_tx,
6188 &seen_trade_ids,
6189 &task_spawner,
6190 );
6191
6192 let mut events = Vec::new();
6193 while let Ok(event) = rx.try_recv() {
6194 events.push(event);
6195 }
6196
6197 assert_eq!(events.len(), 2);
6198
6199 let ExecutionEvent::Order(OrderEventAny::Accepted(accepted)) = &events[0] else {
6200 panic!("Expected acceptance before the first fill")
6201 };
6202
6203 let expected = OrderAccepted::new(
6204 TraderId::from("TESTER-001"),
6205 StrategyId::from("TEST-STRATEGY"),
6206 InstrumentId::from("ETHUSDT.BINANCE"),
6207 local_client_order_id,
6208 VenueOrderId::from("12345678"),
6209 AccountId::from("BINANCE-001"),
6210 accepted.event_id,
6211 accepted.ts_init,
6212 accepted.ts_init,
6213 false,
6214 );
6215 assert_eq!(*accepted, expected);
6216
6217 let fills: Vec<_> = events
6218 .iter()
6219 .filter(|e| matches!(e, ExecutionEvent::Order(OrderEventAny::Filled(_))))
6220 .collect();
6221 assert_eq!(fills.len(), 1, "duplicate trade should be deduped");
6222
6223 match fills[0] {
6224 ExecutionEvent::Order(OrderEventAny::Filled(fill)) => {
6225 assert_eq!(
6226 fill.client_order_id,
6227 ClientOrderId::from("O-20200101-000000-000-000-0"),
6228 );
6229 assert_eq!(fill.trade_id, TradeId::new("98765432"));
6230 assert_eq!(fill.liquidity_side, LiquiditySide::Maker);
6231 assert_eq!(fill.currency, Currency::USDT());
6232 assert_eq!(fill.last_px, Price::from("2500.00"));
6233 assert_eq!(fill.last_qty, Quantity::from("1.00000"));
6234 assert_eq!(
6235 fill.commission,
6236 Some(Money::from_decimal(Decimal::new(1, 3), Currency::ETH()).unwrap()),
6237 );
6238 }
6239 _ => unreachable!(),
6240 }
6241 let _ = client_order_id;
6242 }
6243
6244 #[rstest]
6245 #[case::single(false, false)]
6246 #[case::multiple_stable(true, false)]
6247 #[case::multiple_changed(true, true)]
6248 fn test_dispatch_quote_quantity_market_order(
6249 #[values(false, true)] new_before_trade: bool,
6250 #[values(false, true)] http_before_trade: bool,
6251 #[case] multiple_fills: bool,
6252 #[case] quantity_changes: bool,
6253 #[values(false, true)] quote_quantity: bool,
6254 ) {
6255 let clock = get_atomic_clock_realtime();
6256 let (emitter, mut rx) = create_test_emitter(clock);
6257 let http_client = create_test_http_client(clock);
6258 let client_order_id = ClientOrderId::from("O-20200101-000000-000-000-0");
6259 let instrument_id = InstrumentId::from("ETHUSDT.BINANCE");
6260 let account_id = AccountId::from("BINANCE-001");
6261 let venue_order_id = VenueOrderId::from("12345678");
6262 let base_qty = Quantity::from("0.00300");
6263
6264 let mut order = OrderTestBuilder::new(OrderType::Market)
6265 .trader_id(TraderId::from("TESTER-001"))
6266 .strategy_id(StrategyId::from("TEST-STRATEGY"))
6267 .client_order_id(client_order_id)
6268 .instrument_id(instrument_id)
6269 .side(OrderSide::Buy)
6270 .quantity(if quote_quantity {
6271 Quantity::from("13.00000")
6272 } else {
6273 base_qty
6274 })
6275 .quote_quantity(quote_quantity)
6276 .build();
6277
6278 order
6279 .apply(TestOrderEventStubs::submitted(&order, account_id))
6280 .unwrap();
6281 let state = create_tracked_dispatch_state(client_order_id, instrument_id);
6282 {
6283 let mut identity = state.order_identities.get_mut(&client_order_id).unwrap();
6284 identity.order_type = OrderType::Market;
6285 identity.quantity = order.quantity();
6286 identity.is_quote_quantity = quote_quantity;
6287 }
6288
6289 let seen_trade_ids = Arc::new(Mutex::new(FifoCache::new()));
6290 let json = crate::common::testing::load_fixture_string(
6291 "spot/user_data_json/execution_report_new.json",
6292 );
6293 let mut new: BinanceSpotExecutionReport = serde_json::from_str(&json).unwrap();
6294 new.order_type = "MARKET".to_string();
6295 new.original_qty = "0.00300000".to_string();
6296 new.price = "0.00000000".to_string();
6297
6298 let dispatch = |report: &BinanceSpotExecutionReport| {
6299 dispatch_execution_report(
6300 report,
6301 &emitter,
6302 &http_client,
6303 account_id,
6304 false,
6305 &state,
6306 &seen_trade_ids,
6307 UnixNanos::from(1709654402000000000),
6308 );
6309 };
6310
6311 if http_before_trade {
6312 handle_spot_order_submit_success(client_order_id, venue_order_id);
6313 }
6314
6315 if new_before_trade {
6316 dispatch(&new);
6317 dispatch(&new);
6318 }
6319
6320 let json = crate::common::testing::load_fixture_string(
6321 "spot/user_data_json/execution_report_trade.json",
6322 );
6323 let mut trade: BinanceSpotExecutionReport = serde_json::from_str(&json).unwrap();
6324 trade.order_type = "MARKET".to_string();
6325 trade.price = new.price.clone();
6326
6327 trade.original_qty = if quote_quantity && quantity_changes {
6328 "0.00400000".to_string()
6329 } else {
6330 new.original_qty.clone()
6331 };
6332
6333 trade.is_maker = false;
6334 trade.last_filled_price = "4000.00".to_string();
6335 trade.last_filled_qty = if multiple_fills {
6336 "0.00100000"
6337 } else {
6338 "0.00300000"
6339 }
6340 .to_string();
6341
6342 trade.cumulative_filled_qty = trade.last_filled_qty.clone();
6343
6344 trade.order_status = if multiple_fills {
6345 BinanceOrderStatus::PartiallyFilled
6346 } else {
6347 BinanceOrderStatus::Filled
6348 };
6349
6350 trade.commission = "0.01200000".to_string();
6351 trade.commission_asset = Some(Ustr::from("USDT"));
6352 dispatch(&trade);
6353 dispatch(&trade);
6354
6355 if !http_before_trade {
6356 handle_spot_order_submit_success(client_order_id, venue_order_id);
6357 }
6358
6359 if !new_before_trade && multiple_fills {
6360 dispatch(&new);
6361 }
6362
6363 if multiple_fills {
6364 trade.original_qty = new.original_qty.clone();
6365 trade.trade_id += 1;
6366 trade.event_time += 1;
6367 trade.last_filled_qty = "0.00200000".to_string();
6368 trade.cumulative_filled_qty = "0.00300000".to_string();
6369 trade.last_filled_price = "4500.00".to_string();
6370 trade.commission = "0.00000200".to_string();
6371 trade.commission_asset = Some(Ustr::from("ETH"));
6372 trade.order_status = BinanceOrderStatus::Filled;
6373 dispatch(&trade);
6374 dispatch(&trade);
6375 }
6376
6377 let events: Vec<_> = std::iter::from_fn(|| rx.try_recv().ok()).collect();
6378 for event in &events {
6379 let ExecutionEvent::Order(event) = event else {
6380 panic!("Expected typed order event, was {event:?}")
6381 };
6382
6383 order.apply(event.clone()).unwrap();
6384 if let OrderEventAny::Filled(fill) = event {
6385 assert_eq!(
6386 order.status(),
6387 if multiple_fills && fill.trade_id == TradeId::from("98765432") {
6388 OrderStatus::PartiallyFilled
6389 } else {
6390 OrderStatus::Filled
6391 },
6392 );
6393 }
6394 }
6395
6396 let fills: Vec<_> = events
6397 .iter()
6398 .filter_map(|event| match event {
6399 ExecutionEvent::Order(OrderEventAny::Filled(fill)) => Some(fill),
6400 _ => None,
6401 })
6402 .collect();
6403
6404 assert_eq!(
6405 events.len(),
6406 2 + usize::from(quote_quantity)
6407 + usize::from(multiple_fills)
6408 + usize::from(quote_quantity && quantity_changes)
6409 );
6410 assert!(matches!(
6411 events[0],
6412 ExecutionEvent::Order(OrderEventAny::Accepted(_))
6413 ));
6414
6415 if quote_quantity {
6416 let ExecutionEvent::Order(OrderEventAny::Updated(update)) = &events[1] else {
6417 panic!("Expected quantity update")
6418 };
6419
6420 assert_eq!(
6421 update.quantity,
6422 if quantity_changes {
6423 Quantity::from("0.00400")
6424 } else {
6425 base_qty
6426 },
6427 );
6428 assert!(!update.is_quote_quantity);
6429 assert_eq!(update.price, None);
6430 assert_eq!(update.trigger_price, None);
6431 assert_eq!(update.account_id, Some(account_id));
6432 assert_eq!(update.venue_order_id, Some(venue_order_id));
6433 }
6434
6435 assert_eq!(fills.len(), 1 + usize::from(multiple_fills));
6436 assert_eq!(
6437 fills[0].last_qty,
6438 Quantity::from(if multiple_fills { "0.00100" } else { "0.00300" })
6439 );
6440 assert_eq!(fills[0].last_px, Price::from("4000.00"));
6441 assert_eq!(fills[0].commission, Some(Money::from("0.012 USDT")));
6442 assert_eq!(fills[0].trade_id, TradeId::from("98765432"));
6443
6444 if multiple_fills {
6445 assert_eq!(fills[1].last_qty, Quantity::from("0.00200"));
6446 assert_eq!(fills[1].last_px, Price::from("4500.00"));
6447 assert_eq!(fills[1].commission, Some(Money::from("0.000002 ETH")));
6448 assert_eq!(fills[1].trade_id, TradeId::from("98765433"));
6449 }
6450
6451 for fill in fills {
6452 assert_eq!(fill.client_order_id, client_order_id);
6453 assert_eq!(fill.venue_order_id, venue_order_id);
6454 assert_eq!(fill.account_id, account_id);
6455 assert_eq!(fill.instrument_id, instrument_id);
6456 assert_eq!(fill.strategy_id, order.strategy_id());
6457 assert_eq!(fill.trader_id, order.trader_id());
6458 assert_eq!(fill.order_side, OrderSide::Buy);
6459 assert_eq!(fill.order_type, OrderType::Market);
6460 assert_eq!(fill.currency, Currency::USDT());
6461 assert_eq!(fill.liquidity_side, LiquiditySide::Taker);
6462 assert_eq!(fill.position_id, None);
6463 assert!(!fill.reconciliation);
6464 }
6465
6466 assert_eq!(order.status(), OrderStatus::Filled);
6467 assert_eq!(order.quantity(), base_qty);
6468 assert_eq!(order.filled_qty(), base_qty);
6469 assert_eq!(order.leaves_qty(), Quantity::zero(5));
6470 assert!(!order.is_quote_quantity());
6471 assert_eq!(order.venue_order_id(), Some(venue_order_id));
6472 assert_eq!(
6473 order.commissions().get(&Currency::USDT()),
6474 Some(&Money::from("0.012 USDT"))
6475 );
6476 assert_eq!(
6477 order.commissions().get(&Currency::ETH()),
6478 multiple_fills.then_some(&Money::from("0.000002 ETH"))
6479 );
6480 assert!(state.order_identities.is_empty());
6481
6482 dispatch(&new);
6483 assert!(rx.try_recv().is_err());
6484 }
6485
6486 #[rstest]
6487 #[case::malformed("invalid")]
6488 #[case::zero("0")]
6489 #[case::below_filled("0.001")]
6490 fn test_dispatch_quote_quantity_invalid_base_quantity_recovers(#[case] original_qty: &str) {
6491 let clock = get_atomic_clock_realtime();
6492 let (emitter, mut rx) = create_test_emitter(clock);
6493 let http_client = create_test_http_client(clock);
6494 let client_order_id = ClientOrderId::from("O-20200101-000000-000-000-0");
6495 let instrument_id = InstrumentId::from("ETHUSDT.BINANCE");
6496 let state = create_tracked_dispatch_state(client_order_id, instrument_id);
6497 {
6498 let mut identity = state.order_identities.get_mut(&client_order_id).unwrap();
6499 identity.order_type = OrderType::Market;
6500 identity.is_quote_quantity = true;
6501 identity.quantity = Quantity::from("13.00000");
6502 }
6503
6504 let seen_trade_ids = Arc::new(Mutex::new(FifoCache::new()));
6505 let json = crate::common::testing::load_fixture_string(
6506 "spot/user_data_json/execution_report_trade.json",
6507 );
6508 let mut trade: BinanceSpotExecutionReport = serde_json::from_str(&json).unwrap();
6509 trade.original_qty = original_qty.to_string();
6510 trade.last_filled_qty = "0.003".to_string();
6511 trade.cumulative_filled_qty = "0.003".to_string();
6512
6513 let dispatch = |report: &BinanceSpotExecutionReport| {
6514 dispatch_execution_report(
6515 report,
6516 &emitter,
6517 &http_client,
6518 AccountId::from("BINANCE-001"),
6519 false,
6520 &state,
6521 &seen_trade_ids,
6522 clock.get_time_ns(),
6523 );
6524 };
6525
6526 dispatch(&trade);
6527 let rejected_events: Vec<_> = std::iter::from_fn(|| rx.try_recv().ok()).collect();
6528 let tracked_after_error = state.order_identities.contains_key(&client_order_id);
6529 let consumed_after_error = seen_trade_ids
6530 .lock()
6531 .contains(&(trade.symbol, trade.trade_id));
6532 trade.original_qty = "0.003".to_string();
6533 dispatch(&trade);
6534 let recovered_events: Vec<_> = std::iter::from_fn(|| rx.try_recv().ok()).collect();
6535
6536 assert_eq!(rejected_events.len(), 1);
6537 assert!(matches!(
6538 rejected_events[0],
6539 ExecutionEvent::Order(OrderEventAny::Accepted(_))
6540 ));
6541 assert!(tracked_after_error);
6542 assert!(!consumed_after_error);
6543 assert_eq!(recovered_events.len(), 2);
6544 assert!(
6545 matches!(&recovered_events[0], ExecutionEvent::Order(OrderEventAny::Updated(event)) if event.quantity == Quantity::from("0.00300") && !event.is_quote_quantity)
6546 );
6547 assert!(
6548 matches!(&recovered_events[1], ExecutionEvent::Order(OrderEventAny::Filled(event)) if event.last_qty == Quantity::from("0.00300"))
6549 );
6550 assert!(state.order_identities.is_empty());
6551 }
6552
6553 #[rstest]
6554 #[case::quantity("last_filled_qty", "not-a-number")]
6555 #[case::commission_malformed("commission", "not-a-number")]
6556 #[case::commission_out_of_range("commission", "100000000000000000000")]
6557 fn test_dispatch_tracked_execution_report_invalid_fill_emits_nothing(
6558 #[case] field: &str,
6559 #[case] value: &str,
6560 ) {
6561 let tasks = TaskGroup::new();
6562 let task_spawner = tasks.spawner().expect("task spawner");
6563 let clock = get_atomic_clock_realtime();
6564 let (emitter, mut rx) = create_test_emitter(clock);
6565 let http_client = create_test_http_client(clock);
6566 let dispatch_state = create_tracked_dispatch_state(
6567 ClientOrderId::from("O-20200101-000000-000-000-0"),
6568 InstrumentId::from("ETHUSDT.BINANCE"),
6569 );
6570 let ws_authenticated = tokio::sync::Notify::new();
6571 let ws_user_data_subscribed = tokio::sync::Notify::new();
6572 let (ws_setup_error_tx, _ws_setup_error_rx) = tokio::sync::mpsc::unbounded_channel();
6573 let seen_trade_ids = Arc::new(Mutex::new(FifoCache::new()));
6574
6575 let trade_json = crate::common::testing::load_fixture_string(
6576 "spot/user_data_json/execution_report_trade.json",
6577 );
6578 let mut report: BinanceSpotExecutionReport = serde_json::from_str(&trade_json).unwrap();
6579 match field {
6580 "last_filled_qty" => report.last_filled_qty = value.to_owned(),
6581 "commission" => report.commission = value.to_owned(),
6582 _ => panic!("Unexpected field {field}"),
6583 }
6584
6585 dispatch_ws_trading_message(
6586 BinanceSpotWsTradingMessage::ExecutionReport(Box::new(report)),
6587 &emitter,
6588 &http_client,
6589 AccountId::from("BINANCE-001"),
6590 false,
6591 clock,
6592 &dispatch_state,
6593 &ws_authenticated,
6594 &ws_user_data_subscribed,
6595 &ws_setup_error_tx,
6596 &seen_trade_ids,
6597 &task_spawner,
6598 );
6599
6600 let mut events = Vec::new();
6601 while let Ok(event) = rx.try_recv() {
6602 events.push(event);
6603 }
6604
6605 assert!(events.is_empty());
6606 assert!(
6607 !dispatch_state
6608 .has_emitted_accepted(&ClientOrderId::from("O-20200101-000000-000-000-0"),)
6609 );
6610 }
6611
6612 #[rstest]
6613 fn test_dispatch_execution_report_invalid_client_order_id_emits_nothing() {
6614 let clock = get_atomic_clock_realtime();
6615 let (emitter, mut rx) = create_test_emitter(clock);
6616 let http_client = create_test_http_client(clock);
6617 let dispatch_state = WsDispatchState::default();
6618 let seen_trade_ids = Arc::new(Mutex::new(FifoCache::new()));
6619 let json = crate::common::testing::load_fixture_string(
6620 "spot/user_data_json/execution_report_new.json",
6621 );
6622 let mut report: BinanceSpotExecutionReport = serde_json::from_str(&json).unwrap();
6623 report.client_order_id = "x-TD67BGP9-R".to_string();
6624
6625 dispatch_execution_report(
6626 &report,
6627 &emitter,
6628 &http_client,
6629 AccountId::from("BINANCE-001"),
6630 false,
6631 &dispatch_state,
6632 &seen_trade_ids,
6633 clock.get_time_ns(),
6634 );
6635
6636 assert!(rx.try_recv().is_err());
6637 assert!(dispatch_state.order_identities.is_empty());
6638 }
6639
6640 #[rstest]
6641 fn test_dispatch_execution_report_canceled_resolves_order_by_orig_client_order_id() {
6642 let clock = get_atomic_clock_realtime();
6643 let (emitter, mut rx) = create_test_emitter(clock);
6644 let http_client = create_test_http_client(clock);
6645 let client_order_id = ClientOrderId::from("O-20200101-000000-000-000-0");
6646 let instrument_id = InstrumentId::from("ETHUSDT.BINANCE");
6647 let dispatch_state = WsDispatchState::default();
6648 dispatch_state.insert_accepted(client_order_id);
6649 dispatch_state.order_identities.insert(
6650 client_order_id,
6651 OrderIdentity {
6652 instrument_id,
6653 strategy_id: StrategyId::from("TEST-STRATEGY"),
6654 order_side: OrderSide::Buy,
6655 order_type: OrderType::Limit,
6656 price: None,
6657 quantity: Quantity::from("1"),
6658 is_quote_quantity: false,
6659 venue_position_id: None,
6660 },
6661 );
6662 let seen_trade_ids = Arc::new(Mutex::new(FifoCache::new()));
6663 let json = crate::common::testing::load_fixture_string(
6664 "spot/user_data_json/execution_report_canceled.json",
6665 );
6666 let mut report: BinanceSpotExecutionReport = serde_json::from_str(&json).unwrap();
6667 report.original_client_order_id = Some(report.client_order_id.clone());
6668 report.client_order_id = "web_9f8e7d6c5b4a".to_string();
6669
6670 dispatch_execution_report(
6671 &report,
6672 &emitter,
6673 &http_client,
6674 AccountId::from("BINANCE-001"),
6675 false,
6676 &dispatch_state,
6677 &seen_trade_ids,
6678 clock.get_time_ns(),
6679 );
6680
6681 match rx.try_recv().expect("OrderCanceled expected") {
6682 ExecutionEvent::Order(OrderEventAny::Canceled(event)) => {
6683 assert_eq!(event.client_order_id, client_order_id);
6684 }
6685 other => panic!("Expected OrderCanceled, was {other:?}"),
6686 }
6687 assert!(rx.try_recv().is_err());
6688 assert!(dispatch_state.order_identities.is_empty());
6689 }
6690
6691 #[rstest]
6692 fn test_build_cancel_replace_params_sends_cancel_new_client_order_id() {
6693 let client_order_id = ClientOrderId::from("O-20200101-000000-000-000-0");
6694 let instrument_id = InstrumentId::from("ETHUSDT.BINANCE");
6695 let mut builder = OrderTestBuilder::new(OrderType::Limit);
6696 let order = builder
6697 .instrument_id(instrument_id)
6698 .client_order_id(client_order_id)
6699 .side(OrderSide::Buy)
6700 .quantity(Quantity::from("1"))
6701 .price(Price::from("2500.00"))
6702 .build();
6703 let cmd = ModifyOrder::new(
6704 TraderId::from("TESTER-001"),
6705 None,
6706 StrategyId::from("TEST-STRATEGY"),
6707 instrument_id,
6708 client_order_id,
6709 Some(VenueOrderId::from("12345678")),
6710 Some(Quantity::from("2")),
6711 Some(Price::from("2400.00")),
6712 None,
6713 UUID4::new(),
6714 UnixNanos::default(),
6715 None,
6716 None,
6717 );
6718 let cancel_id = cancel_replace_cancel_id();
6719
6720 let params = build_cancel_replace_params(
6721 &cmd,
6722 &order,
6723 Quantity::from("2"),
6724 false,
6725 cancel_id.clone(),
6726 )
6727 .unwrap();
6728
6729 assert!(cancel_id.len() <= 36);
6730 assert_eq!(params.cancel_order_id, Some(12345678));
6731 assert_eq!(
6732 params.cancel_new_client_order_id.as_deref(),
6733 Some(cancel_id.as_str())
6734 );
6735 let json = serde_json::to_value(¶ms).unwrap();
6736 assert_eq!(json["cancelNewClientOrderId"], cancel_id);
6737 }
6738
6739 #[rstest]
6740 fn test_dispatch_execution_report_cancel_replace_skips_cancel_then_updates_on_new() {
6741 let clock = get_atomic_clock_realtime();
6742 let (emitter, mut rx) = create_test_emitter(clock);
6743 let http_client = create_test_http_client(clock);
6744 let client_order_id = ClientOrderId::from("O-20200101-000000-000-000-0");
6745 let instrument_id = InstrumentId::from("ETHUSDT.BINANCE");
6746 let dispatch_state = WsDispatchState::default();
6747 dispatch_state.insert_accepted(client_order_id);
6748 dispatch_state.order_identities.insert(
6749 client_order_id,
6750 OrderIdentity {
6751 instrument_id,
6752 strategy_id: StrategyId::from("TEST-STRATEGY"),
6753 order_side: OrderSide::Buy,
6754 order_type: OrderType::Limit,
6755 price: None,
6756 quantity: Quantity::from("1"),
6757 is_quote_quantity: false,
6758 venue_position_id: None,
6759 },
6760 );
6761 let seen_trade_ids = Arc::new(Mutex::new(FifoCache::new()));
6762 let account_id = AccountId::from("BINANCE-001");
6763
6764 let json = crate::common::testing::load_fixture_string(
6765 "spot/user_data_json/execution_report_canceled.json",
6766 );
6767 let mut canceled: BinanceSpotExecutionReport = serde_json::from_str(&json).unwrap();
6768 canceled.original_client_order_id = Some(canceled.client_order_id.clone());
6769 let cancel_id = cancel_replace_cancel_id();
6770 dispatch_state.insert_cancel_replace(cancel_id.clone());
6771 canceled.client_order_id = cancel_id;
6772
6773 dispatch_execution_report(
6774 &canceled,
6775 &emitter,
6776 &http_client,
6777 account_id,
6778 false,
6779 &dispatch_state,
6780 &seen_trade_ids,
6781 clock.get_time_ns(),
6782 );
6783
6784 assert!(rx.try_recv().is_err(), "cancel half must not emit");
6785 assert!(
6786 dispatch_state
6787 .order_identities
6788 .contains_key(&client_order_id)
6789 );
6790
6791 let json = crate::common::testing::load_fixture_string(
6792 "spot/user_data_json/execution_report_new.json",
6793 );
6794 let mut new: BinanceSpotExecutionReport = serde_json::from_str(&json).unwrap();
6795 new.order_id = canceled.order_id + 1;
6796
6797 dispatch_execution_report(
6798 &new,
6799 &emitter,
6800 &http_client,
6801 account_id,
6802 false,
6803 &dispatch_state,
6804 &seen_trade_ids,
6805 clock.get_time_ns(),
6806 );
6807
6808 match rx.try_recv().expect("OrderUpdated expected") {
6809 ExecutionEvent::Order(OrderEventAny::Updated(event)) => {
6810 assert_eq!(event.client_order_id, client_order_id);
6811 assert_eq!(
6812 event.venue_order_id,
6813 Some(VenueOrderId::new(new.order_id.to_string()))
6814 );
6815 }
6816 other => panic!("Expected OrderUpdated, was {other:?}"),
6817 }
6818 assert!(rx.try_recv().is_err());
6819 }
6820
6821 fn cancel_replace_cancel_report(cancel_id: &str) -> BinanceSpotExecutionReport {
6822 let json = crate::common::testing::load_fixture_string(
6823 "spot/user_data_json/execution_report_canceled.json",
6824 );
6825 let mut report: BinanceSpotExecutionReport = serde_json::from_str(&json).unwrap();
6826 report.original_client_order_id = Some(report.client_order_id.clone());
6827 report.client_order_id = cancel_id.to_string();
6828 report
6829 }
6830
6831 fn reject_cancel_replace(
6832 request_id: &str,
6833 code: i32,
6834 emitter: &ExecutionEventEmitter,
6835 http_client: &BinanceSpotHttpClient,
6836 dispatch_state: &WsDispatchState,
6837 task_spawner: &TaskSpawner,
6838 clock: &'static AtomicTime,
6839 ) {
6840 let seen_trade_ids = Arc::new(Mutex::new(FifoCache::new()));
6841 let ws_authenticated = tokio::sync::Notify::new();
6842 let ws_user_data_subscribed = tokio::sync::Notify::new();
6843 let (ws_setup_error_tx, _ws_setup_error_rx) = tokio::sync::mpsc::unbounded_channel();
6844
6845 dispatch_ws_trading_message(
6846 BinanceSpotWsTradingMessage::CancelReplaceRejected {
6847 request_id: request_id.to_string(),
6848 status: 400,
6849 code,
6850 msg: "Order cancel-replace partially failed".to_string(),
6851 },
6852 emitter,
6853 http_client,
6854 AccountId::from("BINANCE-001"),
6855 false,
6856 clock,
6857 dispatch_state,
6858 &ws_authenticated,
6859 &ws_user_data_subscribed,
6860 &ws_setup_error_tx,
6861 &seen_trade_ids,
6862 task_spawner,
6863 );
6864 }
6865
6866 #[rstest]
6867 #[case::cancel_report_first(true)]
6868 #[case::rejection_first(false)]
6869 fn test_cancel_replace_rejected_after_confirmed_cancel_emits_canceled(
6870 #[case] cancel_report_first: bool,
6871 ) {
6872 let tasks = TaskGroup::new();
6873 let task_spawner = tasks.spawner().expect("task spawner");
6874 let clock = get_atomic_clock_realtime();
6875 let (emitter, mut rx) = create_test_emitter(clock);
6876 let http_client = create_test_http_client(clock);
6877 let client_order_id = ClientOrderId::from("O-20200101-000000-000-000-0");
6878 let instrument_id = InstrumentId::from("ETHUSDT.BINANCE");
6879 let dispatch_state = create_tracked_dispatch_state(client_order_id, instrument_id);
6880 dispatch_state.insert_accepted(client_order_id);
6881 let seen_trade_ids = Arc::new(Mutex::new(FifoCache::new()));
6882 let account_id = AccountId::from("BINANCE-001");
6883
6884 let cancel_id = cancel_replace_cancel_id();
6885 dispatch_state.insert_cancel_replace(cancel_id.clone());
6886 dispatch_state.pending_requests.insert(
6887 "req-modify".to_string(),
6888 PendingRequest {
6889 command_id: None,
6890 client_order_id,
6891 venue_order_id: Some(VenueOrderId::from("12345678")),
6892 operation: PendingOperation::Modify,
6893 },
6894 );
6895 dispatch_state
6896 .cancel_replace_request_ids
6897 .insert("req-modify".to_string(), cancel_id.clone());
6898 dispatch_state.begin_replace(client_order_id, VenueOrderId::from("12345678"));
6899 let canceled = cancel_replace_cancel_report(&cancel_id);
6900
6901 if cancel_report_first {
6902 dispatch_execution_report(
6903 &canceled,
6904 &emitter,
6905 &http_client,
6906 account_id,
6907 false,
6908 &dispatch_state,
6909 &seen_trade_ids,
6910 clock.get_time_ns(),
6911 );
6912 assert!(rx.try_recv().is_err(), "cancel report must be withheld");
6913 }
6914
6915 reject_cancel_replace(
6916 "req-modify",
6917 -2021,
6918 &emitter,
6919 &http_client,
6920 &dispatch_state,
6921 &task_spawner,
6922 clock,
6923 );
6924
6925 match rx.try_recv().expect("OrderModifyRejected expected") {
6926 ExecutionEvent::Order(OrderEventAny::ModifyRejected(event)) => {
6927 assert_eq!(event.client_order_id, client_order_id);
6928 }
6929 other => panic!("Expected OrderModifyRejected, was {other:?}"),
6930 }
6931
6932 if !cancel_report_first {
6933 assert!(rx.try_recv().is_err(), "no cancel confirmed yet");
6934 dispatch_execution_report(
6935 &canceled,
6936 &emitter,
6937 &http_client,
6938 account_id,
6939 false,
6940 &dispatch_state,
6941 &seen_trade_ids,
6942 clock.get_time_ns(),
6943 );
6944 }
6945
6946 match rx.try_recv().expect("OrderCanceled expected") {
6947 ExecutionEvent::Order(OrderEventAny::Canceled(event)) => {
6948 assert_eq!(event.client_order_id, client_order_id);
6949 assert_eq!(event.venue_order_id, Some(VenueOrderId::from("12345678")));
6950 assert_eq!(
6951 event.ts_event,
6952 UnixNanos::from(1_709_654_402_000_000_000u64)
6953 );
6954 }
6955 other => panic!("Expected OrderCanceled, was {other:?}"),
6956 }
6957 assert!(rx.try_recv().is_err());
6958 assert!(dispatch_state.order_identities.is_empty());
6959 assert!(dispatch_state.pending_requests.is_empty());
6960 assert!(dispatch_state.cancel_replace_request_ids.is_empty());
6961 }
6962
6963 #[rstest]
6964 #[case::partial_failure(-2021, 409, true)]
6965 #[case::ambiguous(BINANCE_STATUS_UNKNOWN_CODE, 500, false)]
6966 fn test_http_modify_failure_replays_withheld_cancel_without_identity(
6967 #[case] code: i64,
6968 #[case] status: u16,
6969 #[case] definitive: bool,
6970 ) {
6971 let clock = get_atomic_clock_realtime();
6972 let (emitter, mut rx) = create_test_emitter(clock);
6973 let http_client = create_test_http_client(clock);
6974 let dispatch_state = WsDispatchState::default();
6975 let seen_trade_ids = Arc::new(Mutex::new(FifoCache::new()));
6976 let account_id = AccountId::from("BINANCE-001");
6977 let client_order_id = ClientOrderId::from("O-20200101-000000-000-000-0");
6978 let instrument_id = InstrumentId::from("ETHUSDT.BINANCE");
6979
6980 let cancel_id = cancel_replace_cancel_id();
6981 dispatch_state.insert_cancel_replace(cancel_id.clone());
6982 let canceled = cancel_replace_cancel_report(&cancel_id);
6983
6984 dispatch_execution_report(
6985 &canceled,
6986 &emitter,
6987 &http_client,
6988 account_id,
6989 false,
6990 &dispatch_state,
6991 &seen_trade_ids,
6992 clock.get_time_ns(),
6993 );
6994 assert!(rx.try_recv().is_err(), "cancel report must be withheld");
6995
6996 let command = ModifyOrder::new(
6997 TraderId::from("TESTER-001"),
6998 None,
6999 StrategyId::from("TEST-STRATEGY"),
7000 instrument_id,
7001 client_order_id,
7002 Some(VenueOrderId::from("12345678")),
7003 Some(Quantity::from("2")),
7004 Some(Price::from("2400.00")),
7005 None,
7006 UUID4::new(),
7007 UnixNanos::default(),
7008 None,
7009 None,
7010 );
7011 let error = anyhow::anyhow!(BinanceSpotHttpError::BinanceError {
7012 code,
7013 message: "Order cancel-replace partially failed.".to_string(),
7014 status,
7015 retry_after: None,
7016 });
7017
7018 handle_http_modify_failure(
7019 &error,
7020 &command,
7021 &cancel_id,
7022 &emitter,
7023 &dispatch_state,
7024 account_id,
7025 clock.get_time_ns(),
7026 );
7027
7028 if !definitive {
7029 assert!(
7030 rx.try_recv().is_err(),
7031 "ambiguous outcome must remain pending"
7032 );
7033 return;
7034 }
7035
7036 match rx.try_recv().expect("OrderModifyRejected expected") {
7037 ExecutionEvent::Order(OrderEventAny::ModifyRejected(event)) => {
7038 assert_eq!(event.client_order_id, client_order_id);
7039 }
7040 other => panic!("Expected OrderModifyRejected, was {other:?}"),
7041 }
7042
7043 match rx.try_recv().expect("cancel status report expected") {
7044 ExecutionEvent::Report(ExecutionReport::Order(report)) => {
7045 assert_eq!(report.client_order_id, Some(client_order_id));
7046 assert_eq!(report.venue_order_id, VenueOrderId::from("12345678"));
7047 assert_eq!(report.order_status, OrderStatus::Canceled);
7048 assert_eq!(
7049 report.ts_last,
7050 UnixNanos::from(1_709_654_402_000_000_000u64)
7051 );
7052 }
7053 other => panic!("Expected order status report, was {other:?}"),
7054 }
7055 assert!(rx.try_recv().is_err());
7056 }
7057
7058 #[rstest]
7059 #[case::unexpected_response(BINANCE_UNEXPECTED_RESPONSE_CODE)]
7060 #[case::status_unknown(BINANCE_STATUS_UNKNOWN_CODE)]
7061 fn test_cancel_replace_ambiguous_rejection_keeps_withholding_cancel(#[case] code: i64) {
7062 let tasks = TaskGroup::new();
7063 let task_spawner = tasks.spawner().expect("task spawner");
7064 let clock = get_atomic_clock_realtime();
7065 let (emitter, mut rx) = create_test_emitter(clock);
7066 let http_client = create_test_http_client(clock);
7067 let client_order_id = ClientOrderId::from("O-20200101-000000-000-000-0");
7068 let instrument_id = InstrumentId::from("ETHUSDT.BINANCE");
7069 let dispatch_state = create_tracked_dispatch_state(client_order_id, instrument_id);
7070 dispatch_state.insert_accepted(client_order_id);
7071 let seen_trade_ids = Arc::new(Mutex::new(FifoCache::new()));
7072 let account_id = AccountId::from("BINANCE-001");
7073
7074 let cancel_id = cancel_replace_cancel_id();
7075 dispatch_state.insert_cancel_replace(cancel_id.clone());
7076 dispatch_state.pending_requests.insert(
7077 "req-modify".to_string(),
7078 PendingRequest {
7079 command_id: None,
7080 client_order_id,
7081 venue_order_id: Some(VenueOrderId::from("12345678")),
7082 operation: PendingOperation::Modify,
7083 },
7084 );
7085 dispatch_state
7086 .cancel_replace_request_ids
7087 .insert("req-modify".to_string(), cancel_id.clone());
7088 dispatch_state.begin_replace(client_order_id, VenueOrderId::from("12345678"));
7089 let canceled = cancel_replace_cancel_report(&cancel_id);
7090
7091 dispatch_execution_report(
7092 &canceled,
7093 &emitter,
7094 &http_client,
7095 account_id,
7096 false,
7097 &dispatch_state,
7098 &seen_trade_ids,
7099 clock.get_time_ns(),
7100 );
7101 reject_cancel_replace(
7102 "req-modify",
7103 i32::try_from(code).unwrap(),
7104 &emitter,
7105 &http_client,
7106 &dispatch_state,
7107 &task_spawner,
7108 clock,
7109 );
7110
7111 assert!(
7112 rx.try_recv().is_err(),
7113 "ambiguous outcome must remain pending"
7114 );
7115
7116 let json = crate::common::testing::load_fixture_string(
7118 "spot/user_data_json/execution_report_new.json",
7119 );
7120 let mut new: BinanceSpotExecutionReport = serde_json::from_str(&json).unwrap();
7121 new.order_id = canceled.order_id + 1;
7122
7123 dispatch_execution_report(
7124 &new,
7125 &emitter,
7126 &http_client,
7127 account_id,
7128 false,
7129 &dispatch_state,
7130 &seen_trade_ids,
7131 clock.get_time_ns(),
7132 );
7133
7134 match rx.try_recv().expect("OrderUpdated expected") {
7135 ExecutionEvent::Order(OrderEventAny::Updated(event)) => {
7136 assert_eq!(event.client_order_id, client_order_id);
7137 assert_eq!(
7138 event.venue_order_id,
7139 Some(VenueOrderId::new(new.order_id.to_string()))
7140 );
7141 }
7142 other => panic!("Expected OrderUpdated, was {other:?}"),
7143 }
7144 assert!(rx.try_recv().is_err());
7145 }
7146
7147 #[rstest]
7148 #[case::as_expired(false, OrderStatus::Expired)]
7149 #[case::as_canceled(true, OrderStatus::Canceled)]
7150 fn test_normalize_spot_order_status_report_expired_respects_config(
7151 #[case] treat_expired_as_canceled: bool,
7152 #[case] expected: OrderStatus,
7153 ) {
7154 let clock = get_atomic_clock_realtime();
7155 let json = crate::common::testing::load_fixture_string(
7156 "spot/user_data_json/execution_report_expired.json",
7157 );
7158 let msg: BinanceSpotExecutionReport = serde_json::from_str(&json).unwrap();
7159 let mut report = parse_spot_exec_report_to_order_status(
7160 &msg,
7161 InstrumentId::from("ETHUSDT.BINANCE"),
7162 2,
7163 5,
7164 AccountId::from("BINANCE-001"),
7165 false,
7166 clock.get_time_ns(),
7167 )
7168 .unwrap();
7169 let mut reports = vec![report.clone()];
7170
7171 normalize_spot_order_status_report(&mut report, treat_expired_as_canceled);
7172 normalize_spot_order_status_reports(&mut reports, treat_expired_as_canceled);
7173
7174 assert_eq!(report.order_status, expected);
7175 assert_eq!(reports[0].order_status, expected);
7176 }
7177
7178 #[rstest]
7179 #[case::tracked(true)]
7180 #[case::external(false)]
7181 fn test_cancel_identifier_preserves_external_orders(#[case] tracked: bool) {
7182 let client_order_id = ClientOrderId::from("cancel-target");
7183 let cmd = CancelOrder::new(
7184 TraderId::from("TESTER-001"),
7185 None,
7186 StrategyId::from("TEST-STRATEGY"),
7187 InstrumentId::from("ETHUSDT.BINANCE"),
7188 client_order_id,
7189 Some(VenueOrderId::from("12345")),
7190 UUID4::new(),
7191 UnixNanos::default(),
7192 None,
7193 None,
7194 );
7195
7196 let params = build_cancel_order_params(&cmd, tracked);
7197
7198 assert_eq!(params.symbol, "ETHUSDT");
7199 assert_eq!(params.order_id, (!tracked).then_some(12345));
7200 assert_eq!(
7201 params.orig_client_order_id,
7202 tracked.then(|| encode_broker_id(&client_order_id, BINANCE_NAUTILUS_SPOT_BROKER_ID))
7203 );
7204 assert_eq!(params.new_client_order_id, None);
7205 }
7206
7207 #[rstest]
7208 #[case::stream_first(false, false)]
7209 #[case::http_first(true, false)]
7210 #[case::replacement_rejected(false, true)]
7211 fn test_cancel_replace_preserves_logical_order(
7212 #[case] http_first: bool,
7213 #[case] rejected: bool,
7214 ) {
7215 let clock = get_atomic_clock_realtime();
7216 let (emitter, mut rx) = create_test_emitter(clock);
7217 let client = create_test_http_client(clock);
7218 let client_order_id = ClientOrderId::from("O-20200101-000000-000-000-0");
7219 let state =
7220 create_tracked_dispatch_state(client_order_id, InstrumentId::from("ETHUSDT.BINANCE"));
7221 let seen = Arc::new(Mutex::new(FifoCache::new()));
7222 let json = crate::common::testing::load_fixture_string(
7223 "spot/user_data_json/execution_report_new.json",
7224 );
7225 let mut original: BinanceSpotExecutionReport = serde_json::from_str(&json).unwrap();
7226 original.client_order_id =
7227 encode_broker_id(&client_order_id, BINANCE_NAUTILUS_SPOT_BROKER_ID);
7228 let dispatch = |report: &BinanceSpotExecutionReport| {
7229 dispatch_execution_report(
7230 report,
7231 &emitter,
7232 &client,
7233 AccountId::from("BINANCE-001"),
7234 false,
7235 &state,
7236 &seen,
7237 clock.get_time_ns(),
7238 );
7239 };
7240 dispatch(&original);
7241 let old_id = VenueOrderId::from(original.order_id.to_string());
7242 let new_id = VenueOrderId::from((original.order_id + 1).to_string());
7243 state.begin_replace(client_order_id, old_id);
7244 let mut replacement = original.clone();
7245 replacement.order_id += 1;
7246 replacement.price = "2501.00".to_string();
7247 replacement.original_qty = "2.00000".to_string();
7248
7249 if http_first {
7250 assert_eq!(
7251 state.record_order_update(
7252 client_order_id,
7253 new_id,
7254 Quantity::from("2.00000"),
7255 Price::from("2501.00"),
7256 None
7257 ),
7258 Some(true)
7259 );
7260 }
7261 let mut canceled = original.clone();
7262 canceled.execution_type = BinanceSpotExecutionType::Canceled;
7263 canceled.original_client_order_id = Some(original.client_order_id);
7264 canceled.client_order_id = "venue-cancel-request".to_string();
7265 dispatch(&canceled);
7266
7267 if rejected {
7268 let event = state
7269 .reject_replace(client_order_id)
7270 .expect("Cancellation must be retained");
7271 assert_eq!(event.venue_order_id, Some(old_id));
7272 state.cleanup_terminal(client_order_id);
7273 emitter.send_order_event(OrderEventAny::Canceled(event));
7274 } else {
7275 dispatch(&replacement);
7276 dispatch(&replacement);
7277 dispatch(&canceled);
7278 assert!(state.order_identities.contains_key(&client_order_id));
7279 assert_eq!(
7280 state.record_order_update(
7281 client_order_id,
7282 new_id,
7283 Quantity::from("2.00000"),
7284 Price::from("2501.00"),
7285 None
7286 ),
7287 Some(false)
7288 );
7289 }
7290 assert!(matches!(
7291 rx.try_recv().unwrap(),
7292 ExecutionEvent::Order(OrderEventAny::Accepted(_))
7293 ));
7294
7295 if rejected {
7296 assert!(matches!(
7297 rx.try_recv().unwrap(),
7298 ExecutionEvent::Order(OrderEventAny::Canceled(_))
7299 ));
7300 } else if !http_first {
7301 let ExecutionEvent::Order(OrderEventAny::Updated(event)) = rx.try_recv().unwrap()
7302 else {
7303 panic!("Expected replacement update");
7304 };
7305 assert_eq!(event.client_order_id, client_order_id);
7306 assert_eq!(event.venue_order_id, Some(new_id));
7307 assert_eq!(event.quantity, Quantity::from("2.00000"));
7308 assert_eq!(event.price, Some(Price::from("2501.00")));
7309 }
7310 assert!(rx.try_recv().is_err());
7311 }
7312
7313 #[rstest]
7314 #[case::duplicate("duplicate")]
7315 #[case::quantity("quantity")]
7316 #[case::price("price")]
7317 #[case::trigger("trigger")]
7318 #[case::replacement("replacement")]
7319 fn test_dispatch_new_emits_only_changed_order_terms(#[case] change: &str) {
7320 let clock = get_atomic_clock_realtime();
7321 let (emitter, mut rx) = create_test_emitter(clock);
7322 let client_order_id = ClientOrderId::from("O-20200101-000000-000-000-0");
7323 let instrument_id = InstrumentId::from("ETHUSDT.BINANCE");
7324 let state = create_tracked_dispatch_state(client_order_id, instrument_id);
7325 let identity = state
7326 .order_identities
7327 .get(&client_order_id)
7328 .unwrap()
7329 .clone();
7330 let seen_trade_ids = Arc::new(Mutex::new(FifoCache::new()));
7331 let json = crate::common::testing::load_fixture_string(
7332 "spot/user_data_json/execution_report_new.json",
7333 );
7334 let mut report: BinanceSpotExecutionReport = serde_json::from_str(&json).unwrap();
7335 let dispatch = |report: &BinanceSpotExecutionReport| {
7336 dispatch_tracked_execution_report(
7337 report,
7338 &emitter,
7339 AccountId::from("BINANCE-001"),
7340 false,
7341 &state,
7342 &seen_trade_ids,
7343 client_order_id,
7344 &identity,
7345 instrument_id,
7346 2,
7347 5,
7348 Currency::USDT(),
7349 clock.get_time_ns(),
7350 );
7351 };
7352 dispatch(&report);
7353 match change {
7354 "quantity" => report.original_qty = "2.00000".to_string(),
7355 "price" => report.price = "2501.00".to_string(),
7356 "trigger" => report.stop_price = "2499.00".to_string(),
7357 "replacement" => report.order_id += 1,
7358 "duplicate" => {}
7359 _ => unreachable!(),
7360 }
7361 dispatch(&report);
7362 dispatch(&report);
7363
7364 assert!(matches!(
7365 rx.try_recv().unwrap(),
7366 ExecutionEvent::Order(OrderEventAny::Accepted(_))
7367 ));
7368
7369 if change != "duplicate" {
7370 let ExecutionEvent::Order(OrderEventAny::Updated(updated)) = rx.try_recv().unwrap()
7371 else {
7372 panic!("expected changed order update");
7373 };
7374 assert_eq!(updated.client_order_id, client_order_id);
7375 assert_eq!(
7376 updated.venue_order_id,
7377 Some(VenueOrderId::from(report.order_id.to_string()))
7378 );
7379 assert_eq!(
7380 updated.quantity,
7381 Quantity::from(report.original_qty.as_str())
7382 );
7383 assert_eq!(updated.price, Some(Price::from(report.price.as_str())));
7384 assert_eq!(
7385 updated.trigger_price,
7386 (change == "trigger").then(|| Price::from("2499.00"))
7387 );
7388 }
7389 assert!(rx.try_recv().is_err());
7390 }
7391
7392 #[rstest]
7393 #[case::as_expired(false)]
7394 #[case::as_canceled(true)]
7395 fn test_dispatch_tracked_execution_report_expired_respects_config(
7396 #[case] treat_expired_as_canceled: bool,
7397 ) {
7398 let clock = get_atomic_clock_realtime();
7399 let (emitter, mut rx) = create_test_emitter(clock);
7400 let client_order_id = ClientOrderId::from("O-20200101-000000-000-000-0");
7401 let instrument_id = InstrumentId::from("ETHUSDT.BINANCE");
7402 let dispatch_state = WsDispatchState::default();
7403 dispatch_state.insert_accepted(client_order_id);
7404 let seen_trade_ids = Arc::new(Mutex::new(FifoCache::new()));
7405 let identity = OrderIdentity {
7406 instrument_id,
7407 strategy_id: StrategyId::from("TEST-STRATEGY"),
7408 order_side: OrderSide::Buy,
7409 order_type: OrderType::Limit,
7410 price: None,
7411 quantity: Quantity::from("1"),
7412 is_quote_quantity: false,
7413 venue_position_id: None,
7414 };
7415
7416 let json = crate::common::testing::load_fixture_string(
7417 "spot/user_data_json/execution_report_expired.json",
7418 );
7419 let report: BinanceSpotExecutionReport = serde_json::from_str(&json).unwrap();
7420
7421 dispatch_tracked_execution_report(
7422 &report,
7423 &emitter,
7424 AccountId::from("BINANCE-001"),
7425 treat_expired_as_canceled,
7426 &dispatch_state,
7427 &seen_trade_ids,
7428 client_order_id,
7429 &identity,
7430 instrument_id,
7431 2,
7432 5,
7433 Currency::USDT(),
7434 clock.get_time_ns(),
7435 );
7436
7437 let event = rx.try_recv().expect("terminal order event expected");
7438 match (treat_expired_as_canceled, event) {
7439 (true, ExecutionEvent::Order(OrderEventAny::Canceled(event))) => {
7440 assert_eq!(event.client_order_id, client_order_id);
7441 }
7442 (false, ExecutionEvent::Order(OrderEventAny::Expired(event))) => {
7443 assert_eq!(event.client_order_id, client_order_id);
7444 }
7445 (_, other) => panic!("Expected terminal expired/canceled event, was {other:?}"),
7446 }
7447 assert!(rx.try_recv().is_err());
7448 }
7449
7450 #[rstest]
7451 fn test_dispatch_tracked_execution_report_rejected_gtx_sets_post_only() {
7452 let tasks = TaskGroup::new();
7453 let task_spawner = tasks.spawner().expect("task spawner");
7454 let clock = get_atomic_clock_realtime();
7455 let (emitter, mut rx) = create_test_emitter(clock);
7456 let http_client = create_test_http_client(clock);
7457 let client_order_id = ClientOrderId::from("O-20200101-000000-000-000-1");
7458 let dispatch_state =
7459 create_tracked_dispatch_state(client_order_id, InstrumentId::from("ETHUSDT.BINANCE"));
7460 let ws_authenticated = tokio::sync::Notify::new();
7461 let ws_user_data_subscribed = tokio::sync::Notify::new();
7462 let (ws_setup_error_tx, _ws_setup_error_rx) = tokio::sync::mpsc::unbounded_channel();
7463 let seen_trade_ids = Arc::new(Mutex::new(FifoCache::new()));
7464
7465 let encoded = encode_broker_id(&client_order_id, BINANCE_NAUTILUS_SPOT_BROKER_ID);
7466 let report_json = format!(
7467 r#"{{
7468 "e":"executionReport","E":1709654400000,"s":"ETHUSDT",
7469 "c":"{encoded}","S":"BUY","o":"LIMIT","f":"GTX",
7470 "q":"1.00000000","p":"2500.00000000","P":"0.00000000",
7471 "x":"REJECTED","X":"REJECTED","r":"NONE","i":12345678,
7472 "l":"0.00000000","z":"0.00000000","L":"0.00000000",
7473 "n":"0","N":null,"T":1709654400000,"t":-1,"w":false,"m":false,
7474 "O":1709654400000,"Z":"0.00000000","C":""
7475 }}"#,
7476 );
7477 let report: BinanceSpotExecutionReport = serde_json::from_str(&report_json).unwrap();
7478
7479 dispatch_ws_trading_message(
7480 BinanceSpotWsTradingMessage::ExecutionReport(Box::new(report)),
7481 &emitter,
7482 &http_client,
7483 AccountId::from("BINANCE-001"),
7484 false,
7485 clock,
7486 &dispatch_state,
7487 &ws_authenticated,
7488 &ws_user_data_subscribed,
7489 &ws_setup_error_tx,
7490 &seen_trade_ids,
7491 &task_spawner,
7492 );
7493
7494 match rx.try_recv().expect("OrderRejected event expected") {
7495 ExecutionEvent::Order(OrderEventAny::Rejected(event)) => {
7496 assert_eq!(event.client_order_id, client_order_id);
7497 assert_eq!(event.account_id, AccountId::from("BINANCE-001"));
7498 assert!(event.due_post_only);
7499 }
7500 other => panic!("Expected OrderRejected event, was {other:?}"),
7501 }
7502 }
7503
7504 fn test_execution_client(
7505 base_url_http: String,
7506 ) -> (BinanceSpotExecutionClient, Rc<RefCell<Cache>>) {
7507 let cache = Rc::new(RefCell::new(Cache::default()));
7508 let core = ExecutionClientCore::new(
7509 TraderId::from("TESTER-001"),
7510 *BINANCE_CLIENT_ID,
7511 *BINANCE_VENUE,
7512 OmsType::Hedging,
7513 AccountId::from("BINANCE-001"),
7514 AccountType::Cash,
7515 None,
7516 cache.clone(),
7517 );
7518 let config = BinanceExecutionClientConfig {
7519 base_url_http: Some(base_url_http),
7520 use_ws_trading: false,
7521 api_key: Some("test_api_key".into()),
7522 api_secret: Some("test_api_secret".into()),
7523 ..Default::default()
7524 };
7525
7526 (
7527 BinanceSpotExecutionClient::new(core, config).unwrap(),
7528 cache,
7529 )
7530 }
7531
7532 async fn wait_for_spawned_tasks(client: &BinanceSpotExecutionClient) {
7533 for _ in 0..40 {
7534 if client.pending_tasks.all_finished() {
7535 return;
7536 }
7537
7538 tokio::time::sleep(Duration::from_millis(25)).await;
7539 }
7540
7541 panic!("timed out waiting for spawned Binance Spot execution tasks");
7542 }
7543
7544 struct MockVenueHits {
7545 single_cancel: Arc<AtomicUsize>,
7546 batch: Arc<AtomicUsize>,
7547 cancel_all: Arc<AtomicUsize>,
7548 }
7549
7550 async fn start_cancel_reject_server() -> (String, MockVenueHits) {
7551 let single_hits = Arc::new(AtomicUsize::new(0));
7552 let single_hits_clone = single_hits.clone();
7553 let batch_hits = Arc::new(AtomicUsize::new(0));
7554 let batch_hits_clone = batch_hits.clone();
7555 let cancel_all_hits = Arc::new(AtomicUsize::new(0));
7556 let cancel_all_hits_clone = cancel_all_hits.clone();
7557 let app = axum::Router::new()
7558 .route(
7559 "/api/v3/order",
7560 axum::routing::delete(move || {
7561 let hits = single_hits_clone.clone();
7562 async move {
7563 hits.fetch_add(1, Ordering::Relaxed);
7564
7565 (
7566 axum::http::StatusCode::BAD_REQUEST,
7567 axum::Json(
7568 serde_json::json!({"code": -2011, "msg": "Unknown order sent"}),
7569 ),
7570 )
7571 }
7572 }),
7573 )
7574 .route(
7575 "/api/v3/batchOrders",
7576 axum::routing::delete(move || {
7577 let hits = batch_hits_clone.clone();
7578 async move {
7579 hits.fetch_add(1, Ordering::Relaxed);
7580
7581 axum::Json(serde_json::json!([]))
7582 }
7583 }),
7584 )
7585 .route(
7586 "/api/v3/openOrders",
7587 axum::routing::delete(move || {
7588 let hits = cancel_all_hits_clone.clone();
7589 async move {
7590 hits.fetch_add(1, Ordering::Relaxed);
7591
7592 axum::Json(serde_json::json!([]))
7593 }
7594 }),
7595 );
7596 let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
7597 let addr = listener.local_addr().unwrap();
7598
7599 tokio::spawn(async move {
7600 axum::serve(listener, app.into_make_service())
7601 .await
7602 .unwrap();
7603 });
7604
7605 (
7606 format!("http://{addr}"),
7607 MockVenueHits {
7608 single_cancel: single_hits,
7609 batch: batch_hits,
7610 cancel_all: cancel_all_hits,
7611 },
7612 )
7613 }
7614
7615 #[rstest]
7616 #[case::buy(Some(OrderSide::Buy), vec![0, 2])]
7617 #[case::sell(Some(OrderSide::Sell), vec![1, 3])]
7618 #[tokio::test]
7619 async fn test_cancel_all_orders_filters_by_side_and_preserves_owners(
7620 #[case] order_side: Option<OrderSide>,
7621 #[case] expected_indices: Vec<usize>,
7622 ) {
7623 let (base_url, hits) = start_cancel_reject_server().await;
7624 let (mut client, cache) = test_execution_client(base_url);
7625 let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel();
7626 client.emitter.set_sender(tx);
7627
7628 let instrument_id = InstrumentId::from("BTCUSDT.BINANCE");
7629 let other_instrument_id = InstrumentId::from("ETHUSDT.BINANCE");
7630 let account_id = client.core.account_id;
7631 let mut orders = Vec::new();
7632
7633 for (index, (instrument, owner, side, open)) in [
7634 (instrument_id, "S-001", OrderSide::Buy, true),
7635 (instrument_id, "S-001", OrderSide::Sell, true),
7636 (instrument_id, "S-002", OrderSide::Buy, true),
7637 (instrument_id, "S-002", OrderSide::Sell, true),
7638 (other_instrument_id, "S-001", OrderSide::Buy, true),
7639 (other_instrument_id, "S-002", OrderSide::Sell, true),
7640 (instrument_id, "S-001", OrderSide::Buy, false),
7641 (instrument_id, "S-002", OrderSide::Sell, false),
7642 ]
7643 .into_iter()
7644 .enumerate()
7645 {
7646 let client_order_id = ClientOrderId::from(format!("O-CANCEL-ALL-{index}"));
7647 let mut builder = OrderTestBuilder::new(OrderType::Limit);
7648 let order = builder
7649 .instrument_id(instrument)
7650 .client_order_id(client_order_id)
7651 .strategy_id(StrategyId::from(owner))
7652 .side(side)
7653 .quantity(Quantity::from("1"))
7654 .price(Price::from("10000.00"))
7655 .build();
7656 let venue_order_id = VenueOrderId::from(format!("{}", 1000 + index));
7657 let accepted = TestOrderEventStubs::accepted(&order, account_id, venue_order_id);
7658 cache
7659 .borrow_mut()
7660 .add_order(order, None, Some(*BINANCE_CLIENT_ID), false)
7661 .unwrap();
7662 let order = cache.borrow_mut().update_order(&accepted).unwrap();
7663
7664 if !open {
7665 let canceled =
7666 TestOrderEventStubs::canceled(&order, account_id, Some(venue_order_id));
7667 cache.borrow_mut().update_order(&canceled).unwrap();
7668 }
7669
7670 orders.push(order);
7671 }
7672
7673 client
7674 .cancel_all_orders(CancelAllOrders::new(
7675 TraderId::from("TESTER-001"),
7676 Some(*BINANCE_CLIENT_ID),
7677 StrategyId::from("S-001"),
7678 instrument_id,
7679 order_side,
7680 UUID4::new(),
7681 UnixNanos::default(),
7682 None,
7683 None,
7684 ))
7685 .unwrap();
7686 wait_for_spawned_tasks(&client).await;
7687
7688 assert_eq!(hits.single_cancel.load(Ordering::Relaxed), 2);
7690 assert_eq!(hits.batch.load(Ordering::Relaxed), 0);
7691 assert_eq!(hits.cancel_all.load(Ordering::Relaxed), 0);
7692
7693 let mut actual = Vec::new();
7694
7695 for _ in &expected_indices {
7696 let event = rx.try_recv().expect("expected OrderCancelRejected event");
7697 match event {
7698 ExecutionEvent::Order(OrderEventAny::CancelRejected(rejected)) => {
7699 actual.push((rejected.client_order_id, rejected.strategy_id));
7700 }
7701 event => panic!("expected OrderCancelRejected, was {event:?}"),
7702 }
7703 }
7704
7705 let mut expected: Vec<_> = expected_indices
7706 .iter()
7707 .map(|&index| {
7708 let order = &orders[index];
7709 (order.client_order_id(), order.strategy_id())
7710 })
7711 .collect();
7712
7713 actual.sort();
7714 expected.sort();
7715
7716 assert_eq!(actual, expected);
7717 assert!(rx.try_recv().is_err());
7718 }
7719
7720 #[rstest]
7721 #[tokio::test]
7722 async fn test_cancel_all_orders_with_side_and_empty_cache_sends_nothing() {
7723 let (base_url, hits) = start_cancel_reject_server().await;
7724 let (mut client, _cache) = test_execution_client(base_url);
7725 let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel();
7726 client.emitter.set_sender(tx);
7727
7728 client
7729 .cancel_all_orders(CancelAllOrders::new(
7730 TraderId::from("TESTER-001"),
7731 Some(*BINANCE_CLIENT_ID),
7732 StrategyId::from("S-001"),
7733 InstrumentId::from("BTCUSDT.BINANCE"),
7734 Some(OrderSide::Buy),
7735 UUID4::new(),
7736 UnixNanos::default(),
7737 None,
7738 None,
7739 ))
7740 .unwrap();
7741 wait_for_spawned_tasks(&client).await;
7742
7743 assert_eq!(hits.single_cancel.load(Ordering::Relaxed), 0);
7744 assert_eq!(hits.batch.load(Ordering::Relaxed), 0);
7745 assert_eq!(hits.cancel_all.load(Ordering::Relaxed), 0);
7746 assert!(rx.try_recv().is_err());
7747 assert!(client.dispatch_state.pending_requests.is_empty());
7748 }
7749}