Skip to main content

nautilus_binance/spot/
execution.rs

1// -------------------------------------------------------------------------------------------------
2//  Copyright (C) 2015-2026 Nautech Systems Pty Ltd. All rights reserved.
3//  https://nautechsystems.io
4//
5//  Licensed under the GNU Lesser General Public License Version 3.0 (the "License");
6//  You may not use this file except in compliance with the License.
7//  You may obtain a copy of the License at https://www.gnu.org/licenses/lgpl-3.0.en.html
8//
9//  Unless required by applicable law or agreed to in writing, software
10//  distributed under the License is distributed on an "AS IS" BASIS,
11//  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12//  See the License for the specific language governing permissions and
13//  limitations under the License.
14// -------------------------------------------------------------------------------------------------
15
16//! Live execution client implementation for the Binance Spot adapter.
17
18use 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/// Live execution client for Binance Spot trading.
136///
137/// Implements the [`ExecutionClient`] trait for order management on Binance Spot
138/// and Spot Margin markets. Uses WebSocket or HTTP for order commands. The WebSocket
139/// User Data Stream is required for successful execution lifecycle events.
140#[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    /// Creates a new [`BinanceSpotExecutionClient`].
165    ///
166    /// # Errors
167    ///
168    /// Returns an error if the HTTP client fails to initialize or credentials are missing.
169    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, // timeout_secs
207            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        // Register identity for tracked/external dispatch routing
388        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            // Pre-register before sending to avoid response racing the insert
407            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            // Pre-register before sending to avoid response racing the insert
522            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    // Spot position reports are empty, so an absent report is not evidence of a flat position
954    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        // Load instruments if not already done
1001        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        // Request initial account state
1021        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        // Wait for account to be registered in cache before completing connect
1036        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        // Spawn instrument bootstrap task
1328        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        // Convert ClientOrderId to VenueOrderId if provided (API naming quirk)
1398        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, // limit
1435                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        // Convert ClientOrderId to VenueOrderId if provided (API naming quirk)
1464        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        // Spot trading doesn't have positions in the traditional sense
1683        // Returns empty for spot, could be extended for margin positions
1684        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, &params).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        // Binance Spot uses cancel-replace for order modification, which requires
2016        // the full order specification (side, type, time_in_force). Since ModifyOrder
2017        // doesn't include these fields, we need to look up the original order from cache.
2018        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, // no venue timestamp, rejected locally
2039                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            // Pre-register before sending to avoid response racing the insert
2080            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,  // trigger_price
2201                            None,  // protection_price
2202                            false, // is_quote_quantity
2203                        );
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            // Cancel-all has no side parameter
2234            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                // Individual cancel confirmations dispatched via WS trading message loop
2288                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        // Build strategy lookup from cache before spawning (cache is not Send)
2300        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        // No batch cancel endpoint; fan-out preserves owning-strategy attribution
2375        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            // OrderAccepted event is synthesized from UDS executionReport (New)
2513        }
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                // Clone to drop the DashMap read guard before cleanup_terminal
2540                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            // OrderCanceled event is synthesized from UDS executionReport (Canceled)
2585        }
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            // OrderUpdated event is synthesized from UDS executionReport (Replaced)
2650        }
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    // Spot -1015 confirms rejection, but ambiguous HTTP statuses other than 429 take precedence
3442    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            // An order list is validated and placed atomically by the venue, so a
3486            // request-scoped rejection or a proven unsent request applies to every child
3487            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
3522/// Returns a unique `cancelNewClientOrderId` for a cancel-replace request.
3523///
3524/// Registered in [`WsDispatchState`] so the cancel half's `CANCELED` report can
3525/// be matched to the request that produced it.
3526fn cancel_replace_cancel_id() -> String {
3527    format!("CR-{}", UUID4::new().as_str().replace('-', ""))
3528}
3529
3530/// Emits the confirmed cancellation of a cancel-replace whose replacement the
3531/// venue rejected: `OrderCanceled` for a tracked order, or the withheld status
3532/// report for an order without a dispatch identity (recovered after restart or
3533/// claimed through reconciliation) so reconciliation applies it.
3534fn 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
3568// Replay a withheld cancel report only after the modify outcome is definitive
3569fn 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/// Dispatches a Spot execution report with tracked/untracked routing.
3692///
3693/// Tracked orders (with registered identity) produce proper order events.
3694/// Untracked orders fall back to execution reports for reconciliation.
3695#[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                    // Cancel half of a cancel-replace: the replacement `NEW` drives `OrderUpdated`
3730                    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/// Dispatches a tracked execution report as proper order events.
3794#[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,  // protection_price
3891                    false, // is_quote_quantity
3892                );
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            // Cancel-replace succeeded: the old order is being replaced.
4042            // The replacement NEW event follows with the new price/qty.
4043            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/// Dispatches an untracked execution report as execution reports for reconciliation.
4292#[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
4380// Checks for GTX (-5022) and spot LIMIT_MAKER (-2010 + specific message)
4381fn 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(&params).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        // The replacement did go through: its NEW still drives OrderUpdated
7117        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        // Rejections expose per-order ownership in the outcomes
7689        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}