Skip to main content

nautilus_bybit/
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 Bybit adapter.
17
18use std::{
19    future::Future,
20    str::FromStr,
21    sync::Arc,
22    time::{Duration, Instant},
23};
24
25use ahash::AHashMap;
26use anyhow::Context;
27use async_trait::async_trait;
28use futures_util::{StreamExt, pin_mut};
29use nautilus_common::{
30    clients::{ExecutionClient, ExecutionReportTask},
31    live::runner::get_exec_event_sender,
32    messages::execution::{
33        BatchCancelOrders, BatchModifyOrders, CancelAllOrders, CancelOrder, GenerateFillReports,
34        GenerateFillReportsBuilder, GenerateOrderStatusReport, GenerateOrderStatusReports,
35        GenerateOrderStatusReportsBuilder, GeneratePositionStatusReports, ModifyOrder,
36        QueryAccount, QueryOrder, SubmitOrder, SubmitOrderList,
37    },
38};
39use nautilus_core::{
40    DurationNanos, Params, UUID4, UnixNanos,
41    datetime::unix_nanos_to_iso8601,
42    env::get_or_env_var,
43    string::secret::SecretString,
44    time::{AtomicTime, get_atomic_clock_realtime},
45};
46use nautilus_live::{
47    ExecutionClientCore, ExecutionEventEmitter, SocketControl,
48    execution::failure::CommandFailure,
49    task::{TaskGroup, TaskGroupGuard},
50};
51use nautilus_model::{
52    accounts::AccountAny,
53    data::CustomData,
54    enums::{OmsType, OrderStatus, OrderType},
55    events::{OrderCanceled, OrderDeniedReason, OrderEventAny},
56    identifiers::{AccountId, ClientId, ClientOrderId, InstrumentId, StrategyId, Venue},
57    instruments::{Instrument, InstrumentAny},
58    orders::{Order, OrderAny},
59    reports::{ExecutionMassStatus, FillReport, OrderStatusReport, PositionStatusReport},
60    types::{AccountBalance, MarginBalance, Price, Quantity},
61};
62use ustr::Ustr;
63
64use crate::{
65    common::{
66        consts::BYBIT_VENUE,
67        credential::credential_env_vars,
68        enums::{
69            BybitAccountType, BybitEnvironment, BybitMarginAction, BybitOrderSide,
70            BybitOrderSmpType, BybitOrderType, BybitPositionIdx, BybitPositionMode,
71            BybitProductType, BybitTpSlMode, resolve_trigger_type,
72        },
73        parse::{
74            BybitTpSlParams, bybit_rejection_due_post_only, extract_raw_symbol, get_price_str,
75            make_hedge_venue_position_id, map_time_in_force, nanos_to_millis,
76            parse_bybit_tp_sl_params, parse_margin_action,
77            resolve_position_idx as resolve_bybit_position_idx, spot_leverage, spot_market_unit,
78            trigger_direction,
79        },
80        rate_limit::batch_send_limit,
81        symbol::BybitSymbol,
82    },
83    config::BybitExecutionClientConfig,
84    data_types::{
85        BybitMarginBorrowResult, BybitMarginRepayResult, BybitMarginStatusResult,
86        register_bybit_custom_data,
87    },
88    http::{
89        client::BybitHttpClient,
90        error::{
91            BybitCancelOrderError, BybitHttpError, BybitModifyOrderError, BybitSubmitOrderError,
92            is_bybit_ambiguous_order_error_code,
93        },
94    },
95    repay::repay_blackout_delay,
96    websocket::{
97        client::BybitWebSocketClient,
98        dispatch::{
99            OrderIdentity, OrderStateSnapshot, PendingOperation, WsDispatchState,
100            cache_execution_fee_rates, cleanup_terminal, cleanup_terminal_when_ready,
101            dispatch_ws_message, drain_pending_fast_executions, flush_pending_fast_executions,
102            has_pending_fast_execution, record_venue_order_id,
103        },
104        messages::{BybitWsAmendOrderParams, BybitWsCancelOrderParams, BybitWsPlaceOrderParams},
105    },
106};
107
108/// Live execution client for Bybit.
109#[derive(Debug)]
110pub struct BybitExecutionClient {
111    core: ExecutionClientCore,
112    clock: &'static AtomicTime,
113    config: BybitExecutionClientConfig,
114    emitter: ExecutionEventEmitter,
115    http_client: BybitHttpClient,
116    ws_private: BybitWebSocketClient,
117    ws_trade: BybitWebSocketClient,
118    session_tasks: TaskGroup,
119    pending_tasks: TaskGroup,
120    shutdown_errors: Vec<String>,
121    instruments_cache: Arc<AHashMap<Ustr, InstrumentAny>>,
122    dispatch_state: Arc<WsDispatchState>,
123}
124
125impl BybitExecutionClient {
126    /// Creates a new [`BybitExecutionClient`].
127    ///
128    /// # Errors
129    ///
130    /// Returns an error if the client fails to initialize.
131    pub fn new(
132        core: ExecutionClientCore,
133        config: BybitExecutionClientConfig,
134    ) -> anyhow::Result<Self> {
135        config.validate()?;
136
137        let (key_var, secret_var) = credential_env_vars(config.environment);
138        let api_key = get_or_env_var(
139            config.api_key.clone().map(SecretString::into_inner),
140            key_var,
141        )?;
142        let api_secret = get_or_env_var(
143            config.api_secret.clone().map(SecretString::into_inner),
144            secret_var,
145        )?;
146        let proxy_url = config
147            .proxy_url
148            .as_ref()
149            .map(|value| value.expose_secret().to_owned());
150
151        let http_client = BybitHttpClient::with_credentials(
152            api_key.clone(),
153            api_secret.clone(),
154            Some(config.http_base_url()),
155            config.http_timeout_secs,
156            config.max_retries,
157            config.retry_delay_initial_ms,
158            config.retry_delay_max_ms,
159            config.recv_window_ms,
160            proxy_url.clone(),
161        )?;
162        http_client.set_use_spot_position_reports(config.use_spot_position_reports);
163
164        let mut ws_private = BybitWebSocketClient::new_private(
165            config.environment,
166            Some(api_key),
167            Some(api_secret),
168            Some(config.ws_private_url()),
169            config.heartbeat_interval_secs,
170            config.transport_backend,
171            proxy_url.clone(),
172        )
173        .with_socket_control(SocketControl::new(
174            core.client_id,
175            Some(*BYBIT_VENUE),
176            "bybit-user-streams",
177        ));
178
179        if let Some(secs) = config.auth_timeout_secs {
180            ws_private.set_auth_wait_timeout(Duration::from_secs(secs));
181        }
182
183        let mut ws_trade = BybitWebSocketClient::new_trade(
184            config.environment,
185            http_client.clone(),
186            Some(config.ws_trade_url()),
187            config.heartbeat_interval_secs,
188            config.transport_backend,
189            proxy_url,
190        )
191        .with_socket_control(SocketControl::new(
192            core.client_id,
193            Some(*BYBIT_VENUE),
194            "bybit-trading",
195        ));
196
197        if let Some(secs) = config.auth_timeout_secs {
198            ws_trade.set_auth_wait_timeout(Duration::from_secs(secs));
199        }
200        ws_trade.set_recv_window_ms(config.recv_window_ms);
201
202        let clock = get_atomic_clock_realtime();
203        let emitter = ExecutionEventEmitter::new(
204            clock,
205            core.trader_id,
206            core.account_id,
207            core.account_type,
208            None,
209        );
210
211        let session_tasks = TaskGroup::new();
212        let pending_tasks = TaskGroup::new();
213        let dispatch_state = WsDispatchState::new(config.use_ws_execution_fast);
214
215        Ok(Self {
216            core,
217            clock,
218            config,
219            emitter,
220            http_client,
221            ws_private,
222            ws_trade,
223            session_tasks,
224            pending_tasks,
225            shutdown_errors: Vec::new(),
226            instruments_cache: Arc::new(AHashMap::new()),
227            dispatch_state: Arc::new(dispatch_state),
228        })
229    }
230
231    fn product_types(&self) -> Vec<BybitProductType> {
232        if self.config.product_types.is_empty() {
233            vec![BybitProductType::Linear]
234        } else {
235            self.config.product_types.clone()
236        }
237    }
238
239    async fn refresh_execution_fee_rates(
240        http_client: BybitHttpClient,
241        product_types: Vec<BybitProductType>,
242        instruments: Arc<AHashMap<Ustr, InstrumentAny>>,
243        state: Arc<WsDispatchState>,
244    ) {
245        for product_type in product_types {
246            match http_client
247                .request_fee_rates(product_type, None, None)
248                .await
249            {
250                Ok(fee_rates) => {
251                    state.fee_rates.retain(|instrument_id, _| {
252                        BybitProductType::from_suffix(instrument_id.symbol.as_str())
253                            != Some(product_type)
254                    });
255
256                    let cached =
257                        cache_execution_fee_rates(&state, &instruments, product_type, fee_rates);
258                    log::debug!("Cached {cached} {product_type:?} execution fee rates");
259                }
260                Err(e) => log::warn!(
261                    "Failed to refresh {product_type:?} execution fee rates, retaining previous rates when available: {e}"
262                ),
263            }
264        }
265    }
266
267    async fn initialize_instruments(
268        &mut self,
269        product_types: Vec<BybitProductType>,
270    ) -> anyhow::Result<()> {
271        if !self.core.instruments_initialized() {
272            let mut all_instruments = Vec::new();
273
274            for product_type in &product_types {
275                let instruments = self
276                    .http_client
277                    .request_instruments(*product_type, None, None)
278                    .await
279                    .with_context(|| {
280                        format!("failed to request Bybit instruments for {product_type:?}")
281                    })?;
282
283                if instruments.is_empty() {
284                    log::warn!("No instruments returned for {product_type:?}");
285                    continue;
286                }
287
288                log::debug!("Loaded {} {product_type:?} instruments", instruments.len());
289
290                self.http_client.cache_instruments(&instruments);
291                all_instruments.extend(instruments);
292            }
293
294            if !all_instruments.is_empty() {
295                let mut instruments_map = AHashMap::new();
296                for instrument in &all_instruments {
297                    instruments_map.insert(instrument.id().symbol.inner(), instrument.clone());
298                }
299
300                self.instruments_cache = Arc::new(instruments_map);
301            }
302
303            self.core.set_instruments_initialized();
304        }
305
306        if self.config.use_ws_execution_fast {
307            let http_client = self.http_client.clone();
308            let instruments = Arc::clone(&self.instruments_cache);
309            let state = Arc::clone(&self.dispatch_state);
310            self.spawn_task("refresh Bybit execution fee rates", async move {
311                Self::refresh_execution_fee_rates(http_client, product_types, instruments, state)
312                    .await;
313                Ok(())
314            });
315        }
316
317        Ok(())
318    }
319
320    async fn connect_private_websocket(&mut self) -> anyhow::Result<()> {
321        self.ws_private.connect().await?;
322        self.ws_private.wait_until_active(10.0).await?;
323        log::debug!("Connected to private WebSocket");
324
325        let account_id = self.core.account_id;
326        let instruments = Arc::clone(&self.instruments_cache);
327        let state = Arc::clone(&self.dispatch_state);
328        let clock = self.clock;
329        let stream = self.ws_private.stream();
330        let emitter = self.emitter.clone();
331
332        self.session_tasks.spawn(async move {
333            pin_mut!(stream);
334
335            while let Some(message) = stream.next().await {
336                dispatch_ws_message(&message, account_id, &instruments, clock, &state, &emitter);
337            }
338        })?;
339
340        self.ws_private.subscribe_orders().await?;
341
342        if self.config.use_ws_execution_fast {
343            self.ws_private.subscribe_executions_fast().await?;
344        } else {
345            self.ws_private.subscribe_executions().await?;
346        }
347
348        self.ws_private.subscribe_positions().await?;
349        self.ws_private.subscribe_wallet().await?;
350        Ok(())
351    }
352
353    async fn connect_trade_websocket(&mut self) -> anyhow::Result<()> {
354        if self.config.environment == BybitEnvironment::Demo {
355            log::info!("Demo mode: Trade WebSocket not available, orders use HTTP REST API");
356            return Ok(());
357        }
358
359        self.ws_trade.connect().await?;
360        self.ws_trade.wait_until_active(10.0).await?;
361        log::debug!("Connected to trade WebSocket");
362
363        let account_id = self.core.account_id;
364        let instruments = Arc::clone(&self.instruments_cache);
365        let state = Arc::clone(&self.dispatch_state);
366        let clock = self.clock;
367        let stream = self.ws_trade.stream();
368        let emitter = self.emitter.clone();
369
370        self.session_tasks.spawn(async move {
371            pin_mut!(stream);
372
373            while let Some(message) = stream.next().await {
374                dispatch_ws_message(&message, account_id, &instruments, clock, &state, &emitter);
375            }
376        })?;
377
378        Ok(())
379    }
380
381    fn update_account_state(&self) {
382        let http_client = self.http_client.clone();
383        let account_id = self.core.account_id;
384        let emitter = self.emitter.clone();
385
386        self.spawn_task("query_account", async move {
387            let account_state = http_client
388                .request_account_state(BybitAccountType::Unified, account_id)
389                .await
390                .context("failed to request Bybit account state")?;
391            emitter.send_account_state(account_state);
392            Ok(())
393        });
394    }
395
396    fn borrow_spot_margin(&self, coin: Option<String>, amount: Option<String>, amount_given: bool) {
397        let Some(coin) = coin else {
398            log::error!("Borrow action requires 'coin' param");
399            return;
400        };
401
402        let quantity = match Self::margin_quantity(&coin, amount.as_deref(), amount_given) {
403            Ok(quantity) => quantity,
404            Err(message) => {
405                log::error!("{message}");
406                let ts_now = self.clock.get_time_ns();
407
408                let result = BybitMarginBorrowResult::new(
409                    coin,
410                    amount.unwrap_or_default(),
411                    false,
412                    message.to_string(),
413                    ts_now,
414                    ts_now,
415                );
416                self.emitter
417                    .send_custom_data(CustomData::from_arc(Arc::new(result)));
418                return;
419            }
420        };
421
422        let amount_str = quantity.to_string();
423
424        let http_client = self.http_client.clone();
425        let emitter = self.emitter.clone();
426        let clock = self.clock;
427        self.spawn_task("borrow_spot", async move {
428            let ts_now = clock.get_time_ns();
429
430            let (success, message) = match http_client.borrow_spot(&coin, quantity).await {
431                Ok(_) => {
432                    log::info!("Borrowed {quantity} {coin}");
433                    (true, String::new())
434                }
435                Err(e) => {
436                    let message = format!("{e}");
437                    log::error!("Borrow failed: {message}");
438                    (false, message)
439                }
440            };
441
442            let result =
443                BybitMarginBorrowResult::new(coin, amount_str, success, message, ts_now, ts_now);
444            emitter.send_custom_data(CustomData::from_arc(Arc::new(result)));
445            Ok(())
446        });
447    }
448
449    fn repay_spot_margin(&self, coin: Option<String>, amount: Option<String>, amount_given: bool) {
450        let Some(coin) = coin else {
451            log::error!("Repay action requires 'coin' param");
452            return;
453        };
454
455        // A missing amount repays the whole outstanding borrow; a present amount that is
456        // not a string or number must fail instead of becoming a repay-all.
457        let quantity = match amount.as_deref() {
458            Some(amount_str) => match Self::margin_quantity(&coin, Some(amount_str), true) {
459                Ok(quantity) => Some(quantity),
460                Err(message) => {
461                    log::error!("{message}");
462                    let ts_now = self.clock.get_time_ns();
463
464                    let result = BybitMarginRepayResult::new(
465                        coin,
466                        amount,
467                        false,
468                        "FAIL".to_string(),
469                        message.to_string(),
470                        ts_now,
471                        ts_now,
472                    );
473                    self.emitter
474                        .send_custom_data(CustomData::from_arc(Arc::new(result)));
475                    return;
476                }
477            },
478            None if amount_given => {
479                let message = format!("invalid 'amount' for {coin}, was not a string or number");
480                log::error!("{message}");
481                let ts_now = self.clock.get_time_ns();
482
483                let result = BybitMarginRepayResult::new(
484                    coin,
485                    None,
486                    false,
487                    "FAIL".to_string(),
488                    message,
489                    ts_now,
490                    ts_now,
491                );
492                self.emitter
493                    .send_custom_data(CustomData::from_arc(Arc::new(result)));
494                return;
495            }
496            None => None,
497        };
498
499        let amount_str = quantity.map(|quantity| quantity.to_string());
500
501        let http_client = self.http_client.clone();
502        let emitter = self.emitter.clone();
503        let clock = self.clock;
504        self.spawn_task("repay_spot", async move {
505            // Manual repayment uses no-convert repayment, so a balance shortfall fails
506            // instead of spending other assets, and only the repay endpoints are blocked
507            // by the hourly interest-calculation window. The check runs in the task
508            // directly before the request; throttling after the check can still
509            // carry a request into the window, which the docs disclose as a venue error.
510            let now_ns = clock.get_time_ns();
511
512            if let Some(result) =
513                Self::repay_blackout_rejection(&coin, amount_str.as_deref(), now_ns)
514            {
515                log::warn!("Deferring manual repay: {}", result.message);
516                emitter.send_custom_data(CustomData::from_arc(Arc::new(result)));
517                return Ok(());
518            }
519
520            let ts_now = clock.get_time_ns();
521
522            let (success, result_status, message) =
523                match http_client.repay_spot_borrow(&coin, quantity).await {
524                    Ok(response) => {
525                        let status = response.result.result_status;
526                        log::info!(
527                            "Repaid {} {coin} (result status {status})",
528                            amount_str.as_deref().unwrap_or("all"),
529                        );
530                        (true, status.to_string(), String::new())
531                    }
532                    Err(e) => {
533                        let message = format!("{e}");
534                        log::error!("Repay failed: {message}");
535                        (false, "FAIL".to_string(), message)
536                    }
537                };
538
539            let result = BybitMarginRepayResult::new(
540                coin,
541                amount_str,
542                success,
543                result_status,
544                message,
545                ts_now,
546                ts_now,
547            );
548            emitter.send_custom_data(CustomData::from_arc(Arc::new(result)));
549            Ok(())
550        });
551    }
552
553    fn query_spot_borrow_amount(&self, coin: Option<String>) {
554        let Some(coin) = coin else {
555            log::error!("Get borrow amount action requires 'coin' param");
556            return;
557        };
558
559        let http_client = self.http_client.clone();
560        let emitter = self.emitter.clone();
561        let clock = self.clock;
562
563        self.spawn_task("get_spot_borrow_amount", async move {
564            let borrow_amount = http_client
565                .get_spot_borrow_amount(&coin)
566                .await
567                .with_context(|| format!("failed to query borrow amount for {coin}"))?;
568            let ts_now = clock.get_time_ns();
569            log::info!("Borrow amount for {coin}: {borrow_amount}");
570            let result =
571                BybitMarginStatusResult::new(coin, borrow_amount.to_string(), ts_now, ts_now);
572            emitter.send_custom_data(CustomData::from_arc(Arc::new(result)));
573            Ok(())
574        });
575    }
576
577    fn margin_quantity(
578        coin: &str,
579        amount: Option<&str>,
580        amount_given: bool,
581    ) -> anyhow::Result<Quantity> {
582        let Some(amount) = amount else {
583            if amount_given {
584                anyhow::bail!("invalid 'amount' for {coin}, was not a string or number");
585            }
586
587            anyhow::bail!("Borrow action requires an 'amount' param for {coin}");
588        };
589
590        let quantity = Quantity::from_str(amount)
591            .map_err(|e| anyhow::anyhow!("invalid 'amount' for {coin}: '{amount}', was {e}"))?;
592        anyhow::ensure!(
593            quantity.as_decimal() > rust_decimal::Decimal::ZERO,
594            "invalid 'amount' for {coin}: '{amount}', was not a positive value",
595        );
596        Ok(quantity)
597    }
598
599    /// Builds the failed result for a manual repay inside Bybit's hourly blackout,
600    /// or `None` when repayment is allowed.
601    #[must_use]
602    fn repay_blackout_rejection(
603        coin: &str,
604        amount: Option<&str>,
605        now_ns: UnixNanos,
606    ) -> Option<BybitMarginRepayResult> {
607        let wait = repay_blackout_delay(now_ns)?;
608        let retry_ns = now_ns + DurationNanos::new(wait.as_nanos() as u64);
609        let message = format!(
610            "Bybit repay blackout window (mm:04:00-mm:05:30 UTC); retry after {}",
611            unix_nanos_to_iso8601(retry_ns),
612        );
613        Some(BybitMarginRepayResult::new(
614            coin.to_string(),
615            amount.map(str::to_string),
616            false,
617            "FAIL".to_string(),
618            message,
619            now_ns,
620            now_ns,
621        ))
622    }
623
624    fn spawn_task<F>(&self, description: &'static str, fut: F)
625    where
626        F: Future<Output = anyhow::Result<()>> + Send + 'static,
627    {
628        let future = async move {
629            if let Err(e) = fut.await {
630                log::warn!("{description} failed: {e:?}");
631            }
632        };
633
634        if let Err(e) = self.pending_tasks.spawn(future) {
635            log::warn!("Skipping Bybit {description} after shutdown began: {e}");
636        }
637    }
638
639    fn abort_pending_tasks(&self) {
640        self.pending_tasks.begin_shutdown();
641    }
642
643    fn abort_session_tasks(&self) {
644        self.session_tasks.begin_shutdown();
645    }
646
647    async fn await_pending_tasks(&self) -> anyhow::Result<()> {
648        self.pending_tasks.begin_shutdown();
649        self.pending_tasks
650            .finish_shutdown(Duration::from_secs(1), Duration::from_secs(2))
651            .await
652            .map_err(|e| anyhow::anyhow!("Failed to terminate Bybit execution tasks: {e}"))?;
653        Ok(())
654    }
655
656    async fn await_session_tasks(&self) -> anyhow::Result<()> {
657        self.session_tasks.begin_shutdown();
658        self.session_tasks
659            .finish_shutdown(Duration::from_secs(1), Duration::from_secs(2))
660            .await
661            .map_err(|e| {
662                anyhow::anyhow!("Failed to terminate Bybit execution session tasks: {e}")
663            })?;
664        Ok(())
665    }
666
667    async fn teardown_partial_connect(&mut self) -> anyhow::Result<()> {
668        self.abort_session_tasks();
669        self.abort_pending_tasks();
670        self.http_client.cancel_all_requests();
671        self.ws_private.begin_shutdown();
672        self.ws_trade.begin_shutdown();
673
674        if let Err(e) = self.ws_private.close().await {
675            self.shutdown_errors
676                .push(format!("private WebSocket shutdown failed: {e}"));
677        }
678
679        if let Err(e) = self.ws_trade.close().await {
680            self.shutdown_errors
681                .push(format!("trade WebSocket shutdown failed: {e}"));
682        }
683        self.dispatch_state.clear_repay_sender();
684
685        if let Err(e) = self.await_session_tasks().await {
686            self.shutdown_errors.push(e.to_string());
687        }
688
689        if let Err(e) = self.await_pending_tasks().await {
690            self.shutdown_errors.push(e.to_string());
691        }
692
693        if self.dispatch_state.fast_execution {
694            flush_pending_fast_executions(
695                &self.instruments_cache,
696                self.core.account_id,
697                self.clock.get_time_ns(),
698                &self.dispatch_state,
699                &self.emitter,
700            );
701        }
702
703        self.core.set_disconnected();
704
705        if self.shutdown_errors.is_empty() {
706            Ok(())
707        } else {
708            let errors = std::mem::take(&mut self.shutdown_errors);
709            anyhow::bail!("Bybit execution shutdown failed: {}", errors.join("; "))
710        }
711    }
712
713    /// Polls the cache until the account is registered or timeout is reached.
714    async fn await_account_registered(&self, timeout_secs: f64) -> anyhow::Result<()> {
715        let account_id = self.core.account_id;
716
717        if self.core.cache().account(&account_id).is_some() {
718            log::info!("Account {account_id} registered");
719            return Ok(());
720        }
721
722        let start = Instant::now();
723        let timeout = Duration::from_secs_f64(timeout_secs);
724        let interval = Duration::from_millis(10);
725
726        loop {
727            tokio::time::sleep(interval).await;
728
729            if self.core.cache().account(&account_id).is_some() {
730                log::info!("Account {account_id} registered");
731                return Ok(());
732            }
733
734            if start.elapsed() >= timeout {
735                anyhow::bail!(
736                    "Timeout waiting for account {account_id} to be registered after {timeout_secs}s"
737                );
738            }
739        }
740    }
741
742    fn get_product_type_for_instrument(&self, instrument_id: InstrumentId) -> BybitProductType {
743        BybitProductType::from_suffix(instrument_id.symbol.as_str()).unwrap_or_else(|| {
744            log::warn!("No product-type suffix on {instrument_id}, defaulting to Linear");
745            BybitProductType::Linear
746        })
747    }
748
749    const fn provides_bulk_position_coverage_for_product_type(
750        product_type: BybitProductType,
751    ) -> bool {
752        !matches!(product_type, BybitProductType::Spot)
753    }
754
755    async fn generate_bulk_position_status_reports(
756        &self,
757        product_types: Vec<BybitProductType>,
758    ) -> anyhow::Result<Vec<PositionStatusReport>> {
759        let mut reports = Vec::new();
760
761        for product_type in product_types {
762            if !Self::provides_bulk_position_coverage_for_product_type(product_type) {
763                continue;
764            }
765
766            let mut fetched = self
767                .http_client
768                .request_position_status_reports(self.core.account_id, product_type, None)
769                .await?;
770            reports.append(&mut fetched);
771        }
772
773        Ok(reports)
774    }
775
776    fn resolve_position_idx(
777        &self,
778        instrument_id: InstrumentId,
779        order_side: BybitOrderSide,
780        is_reduce_only: bool,
781        manual_override: Option<BybitPositionIdx>,
782    ) -> Option<BybitPositionIdx> {
783        let product_type = self.get_product_type_for_instrument(instrument_id);
784        if !matches!(
785            product_type,
786            BybitProductType::Linear | BybitProductType::Inverse
787        ) {
788            return None;
789        }
790        let mode = self
791            .config
792            .position_mode
793            .as_ref()
794            .and_then(|map| map.get(instrument_id.symbol.as_str()).copied());
795        resolve_bybit_position_idx(mode, order_side, is_reduce_only, manual_override)
796    }
797
798    fn resolve_smp_type(
799        &self,
800        manual_override: Option<BybitOrderSmpType>,
801    ) -> Option<BybitOrderSmpType> {
802        manual_override.or(self.config.smp_type)
803    }
804
805    async fn apply_account_configuration(&self) -> anyhow::Result<()> {
806        self.apply_leverages_setting().await;
807        self.apply_position_modes_setting().await;
808        self.apply_margin_mode_setting().await
809    }
810
811    async fn apply_leverages_setting(&self) {
812        let Some(leverages) = &self.config.futures_leverages else {
813            return;
814        };
815
816        for (symbol_str, leverage) in leverages {
817            self.apply_leverage_entry(symbol_str, *leverage).await;
818        }
819    }
820
821    async fn apply_leverage_entry(&self, symbol_str: &str, leverage: u32) {
822        let Some(symbol) = Self::parse_derivative_symbol(symbol_str) else {
823            return;
824        };
825        let lev = leverage.to_string();
826        let result = self
827            .http_client
828            .set_leverage(symbol.product_type(), symbol.raw_symbol(), &lev, &lev)
829            .await;
830
831        match result {
832            Ok(_) => log::info!("Set leverage for {symbol_str} to {leverage}"),
833            Err(e) if Self::is_unchanged_error(&e, "110043") => {
834                log::debug!("Leverage already set for {symbol_str} to {leverage}");
835            }
836            Err(e) => log::error!("Failed to set leverage for {symbol_str}: {e}"),
837        }
838    }
839
840    async fn apply_position_modes_setting(&self) {
841        let Some(modes) = &self.config.position_mode else {
842            return;
843        };
844
845        for (symbol_str, mode) in modes {
846            self.apply_position_mode_entry(symbol_str, *mode).await;
847        }
848    }
849
850    async fn apply_position_mode_entry(&self, symbol_str: &str, mode: BybitPositionMode) {
851        let Some(symbol) = Self::parse_derivative_symbol(symbol_str) else {
852            return;
853        };
854        let result = self
855            .http_client
856            .switch_mode(
857                symbol.product_type(),
858                mode,
859                Some(symbol.raw_symbol().to_string()),
860                None,
861            )
862            .await;
863
864        match result {
865            Ok(_) => log::info!("Set symbol `{symbol_str}` position mode to `{mode:?}`"),
866            Err(e) if Self::is_unchanged_error(&e, "110025") => {
867                log::debug!("Symbol `{symbol_str}` position mode already set to `{mode:?}`");
868            }
869            Err(e) => log::error!("Failed to set position mode for {symbol_str}: {e}"),
870        }
871    }
872
873    async fn apply_margin_mode_setting(&self) -> anyhow::Result<()> {
874        let Some(margin_mode) = self.config.margin_mode else {
875            return Ok(());
876        };
877
878        let result = self.http_client.set_margin_mode(margin_mode).await;
879
880        match result {
881            Ok(_) => {
882                log::info!("Set account margin mode to {margin_mode:?}");
883                Ok(())
884            }
885            Err(e) if Self::is_unchanged_error(&e, "") => {
886                log::debug!("Margin mode already set to {margin_mode:?}");
887                Ok(())
888            }
889            Err(e) if Self::is_low_margin_error(&e) => {
890                log::warn!("Cannot set margin mode: {e}");
891                Ok(())
892            }
893            Err(e) => Err(anyhow::Error::from(e).context("failed to set margin mode")),
894        }
895    }
896
897    fn parse_derivative_symbol(symbol_str: &str) -> Option<BybitSymbol> {
898        let symbol = match BybitSymbol::new(symbol_str) {
899            Ok(s) => s,
900            Err(e) => {
901                log::warn!("Failed to parse symbol {symbol_str}: {e}");
902                return None;
903            }
904        };
905        matches!(
906            symbol.product_type(),
907            BybitProductType::Linear | BybitProductType::Inverse
908        )
909        .then_some(symbol)
910    }
911
912    fn is_unchanged_error<E: std::fmt::Display>(err: &E, code: &str) -> bool {
913        let msg = err.to_string().to_lowercase();
914        if msg.contains("not been modified") {
915            return true;
916        }
917        !code.is_empty() && msg.contains(code)
918    }
919
920    fn is_low_margin_error<E: std::fmt::Display>(err: &E) -> bool {
921        err.to_string()
922            .contains("needs to be equal to or greater than")
923    }
924
925    fn map_order_type(order_type: OrderType) -> anyhow::Result<(BybitOrderType, bool)> {
926        match order_type {
927            OrderType::Market => Ok((BybitOrderType::Market, false)),
928            OrderType::Limit => Ok((BybitOrderType::Limit, false)),
929            OrderType::StopMarket | OrderType::MarketIfTouched => {
930                Ok((BybitOrderType::Market, true))
931            }
932            OrderType::StopLimit | OrderType::LimitIfTouched => Ok((BybitOrderType::Limit, true)),
933            _ => anyhow::bail!("unsupported order type for Bybit: {order_type}"),
934        }
935    }
936
937    fn validate_bbo_params(
938        order: &OrderAny,
939        product_type: BybitProductType,
940        tp_sl: &BybitTpSlParams,
941    ) -> anyhow::Result<()> {
942        if !tp_sl.has_bbo() {
943            return Ok(());
944        }
945
946        anyhow::ensure!(
947            matches!(
948                product_type,
949                BybitProductType::Linear | BybitProductType::Inverse
950            ),
951            "`bbo_side_type` and `bbo_level` are only supported for Bybit linear and inverse products"
952        );
953
954        let order_type = order.order_type();
955        anyhow::ensure!(
956            matches!(
957                order_type,
958                OrderType::Limit | OrderType::StopLimit | OrderType::LimitIfTouched
959            ),
960            "`bbo_side_type` and `bbo_level` are not supported for order type {order_type:?}"
961        );
962
963        Ok(())
964    }
965
966    fn build_ws_place_params(
967        order: &OrderAny,
968        product_type: BybitProductType,
969        raw_symbol: &str,
970        tp_sl: &BybitTpSlParams,
971        position_idx: Option<BybitPositionIdx>,
972        smp_type: Option<BybitOrderSmpType>,
973    ) -> anyhow::Result<BybitWsPlaceOrderParams> {
974        let bybit_side = BybitOrderSide::from(order.order_side());
975        let (bybit_order_type, is_conditional) = Self::map_order_type(order.order_type())?;
976        let time_in_force = map_time_in_force(
977            bybit_order_type,
978            Some(order.time_in_force()),
979            Some(order.is_post_only()),
980        )
981        .map_err(OrderDeniedReason::UnsupportedTimeInForce)?;
982        let has_tp_sl = tp_sl.has_tp_sl();
983        let trigger_dir = trigger_direction(order.order_type(), order.order_side(), is_conditional);
984
985        Ok(BybitWsPlaceOrderParams {
986            category: product_type,
987            symbol: Ustr::from(raw_symbol),
988            side: bybit_side,
989            order_type: bybit_order_type,
990            qty: order.quantity().to_string(),
991            is_leverage: spot_leverage(product_type, tp_sl.is_leverage),
992            market_unit: spot_market_unit(
993                product_type,
994                bybit_order_type,
995                order.is_quote_quantity(),
996            ),
997            price: if tp_sl.has_bbo() {
998                None
999            } else {
1000                order.price().map(|p: Price| p.to_string())
1001            },
1002            time_in_force,
1003            order_link_id: Some(order.client_order_id().to_string()),
1004            reduce_only: if order.is_reduce_only() {
1005                Some(true)
1006            } else {
1007                None
1008            },
1009            close_on_trigger: tp_sl.close_on_trigger,
1010            trigger_price: order.trigger_price().map(|p: Price| p.to_string()),
1011            trigger_by: if is_conditional {
1012                Some(resolve_trigger_type(order.trigger_type()))
1013            } else {
1014                None
1015            },
1016            trigger_direction: trigger_dir.map(|d| d as i32),
1017            tpsl_mode: tp_sl.tpsl_mode.or(has_tp_sl.then_some(BybitTpSlMode::Full)),
1018            take_profit: tp_sl.take_profit.map(|p| p.to_string()),
1019            stop_loss: tp_sl.stop_loss.map(|p| p.to_string()),
1020            tp_trigger_by: tp_sl.tp_trigger_by.or(tp_sl
1021                .take_profit
1022                .map(|_| resolve_trigger_type(order.trigger_type()))),
1023            sl_trigger_by: tp_sl.sl_trigger_by.or(tp_sl
1024                .stop_loss
1025                .map(|_| resolve_trigger_type(order.trigger_type()))),
1026            sl_trigger_price: tp_sl.sl_trigger_price.clone(),
1027            tp_trigger_price: tp_sl.tp_trigger_price.clone(),
1028            sl_order_type: tp_sl.sl_order_type,
1029            tp_order_type: tp_sl.tp_order_type,
1030            sl_limit_price: tp_sl.sl_limit_price.clone(),
1031            tp_limit_price: tp_sl.tp_limit_price.clone(),
1032            order_iv: tp_sl.order_iv.clone(),
1033            smp_type,
1034            mmp: tp_sl.mmp,
1035            position_idx,
1036            bbo_side_type: tp_sl.bbo_side_type,
1037            bbo_level: tp_sl.bbo_level.clone(),
1038        })
1039    }
1040
1041    fn build_ws_amend_params(
1042        cmd: &ModifyOrder,
1043        product_type: BybitProductType,
1044        raw_symbol: &str,
1045    ) -> Result<BybitWsAmendOrderParams, String> {
1046        let order_iv = if let Some(params) = cmd.params.as_ref()
1047            && let Some(value) = params.get("order_iv")
1048        {
1049            Some(get_price_str(params, "order_iv").ok_or_else(|| {
1050                format!("invalid type for 'order_iv': {value}, expected string or number")
1051            })?)
1052        } else {
1053            None
1054        };
1055
1056        Ok(BybitWsAmendOrderParams {
1057            category: product_type,
1058            symbol: Ustr::from(raw_symbol),
1059            order_id: cmd.venue_order_id.map(|v| v.to_string()),
1060            order_link_id: Some(cmd.client_order_id.to_string()),
1061            qty: cmd.quantity.map(|q| q.to_string()),
1062            price: cmd.price.map(|p| p.to_string()),
1063            trigger_price: cmd.trigger_price.map(|p| p.to_string()),
1064            take_profit: None,
1065            stop_loss: None,
1066            tp_trigger_by: None,
1067            sl_trigger_by: None,
1068            order_iv,
1069        })
1070    }
1071}
1072
1073fn submit_rejection_reason(error: &anyhow::Error) -> Option<&str> {
1074    for cause in error.chain() {
1075        if let Some(submit_error) = cause.downcast_ref::<BybitSubmitOrderError>() {
1076            return match submit_error {
1077                BybitSubmitOrderError::Rejected { reason } => Some(reason.as_str()),
1078                BybitSubmitOrderError::MissingOrderId
1079                | BybitSubmitOrderError::PostSubmitLookup { .. } => None,
1080            };
1081        }
1082
1083        if let Some(BybitHttpError::BybitError {
1084            error_code,
1085            message,
1086        }) = cause.downcast_ref()
1087            && !http_order_error_is_ambiguous(*error_code)
1088        {
1089            return Some(message.as_str());
1090        }
1091    }
1092    None
1093}
1094
1095#[async_trait(?Send)]
1096impl ExecutionClient for BybitExecutionClient {
1097    fn is_connected(&self) -> bool {
1098        self.core.is_connected()
1099    }
1100
1101    fn client_id(&self) -> ClientId {
1102        self.core.client_id
1103    }
1104
1105    fn account_id(&self) -> AccountId {
1106        self.core.account_id
1107    }
1108
1109    fn venue(&self) -> Venue {
1110        *BYBIT_VENUE
1111    }
1112
1113    fn oms_type(&self) -> OmsType {
1114        self.core.oms_type
1115    }
1116
1117    fn get_account(&self) -> Option<AccountAny> {
1118        self.core.cache().account_owned(&self.core.account_id)
1119    }
1120
1121    fn provides_bulk_position_coverage(&self, instrument_id: InstrumentId) -> bool {
1122        // Resolve the suffix directly rather than through `get_product_type_for_instrument`, whose
1123        // Linear fallback would claim coverage for an identifier this adapter cannot classify. A
1124        // recognized derivative suffix is still uncovered when its product type is unconfigured,
1125        // since the bulk loop only queries `product_types()`.
1126        let Some(product_type) = BybitProductType::from_suffix(instrument_id.symbol.as_str())
1127        else {
1128            return false;
1129        };
1130
1131        self.product_types().contains(&product_type)
1132            && Self::provides_bulk_position_coverage_for_product_type(product_type)
1133    }
1134
1135    async fn connect(&mut self) -> anyhow::Result<()> {
1136        if self.core.is_connected() && self.pending_tasks.is_open() && self.session_tasks.is_open()
1137        {
1138            return Ok(());
1139        }
1140
1141        // Margin results publish as custom data, which streaming and catalog writers
1142        // can only serialize once the types are registered.
1143        register_bybit_custom_data();
1144
1145        if !self.pending_tasks.is_open() || !self.session_tasks.is_open() {
1146            self.teardown_partial_connect().await?;
1147        }
1148
1149        if !self.pending_tasks.is_open() {
1150            self.await_pending_tasks().await?;
1151            self.pending_tasks
1152                .start_generation()
1153                .map_err(|e| anyhow::anyhow!("Failed to start Bybit task generation: {e}"))?;
1154        }
1155
1156        if !self.session_tasks.is_open() {
1157            self.await_session_tasks().await?;
1158            self.session_tasks
1159                .start_generation()
1160                .map_err(|e| anyhow::anyhow!("Failed to start Bybit session generation: {e}"))?;
1161        }
1162        let http_client = self.http_client.clone();
1163        let ws_private = self.ws_private.clone();
1164        let ws_trade = self.ws_trade.clone();
1165        let setup_guard =
1166            TaskGroupGuard::new(&[&self.session_tasks, &self.pending_tasks], move || {
1167                http_client.cancel_all_requests();
1168                ws_private.begin_shutdown();
1169                ws_trade.begin_shutdown();
1170            });
1171
1172        let connect_result: anyhow::Result<()> = async {
1173            // Reset after a prior disconnect so REST calls are not short-circuited
1174            self.http_client.reset_cancellation_token();
1175
1176            let product_types = self.product_types();
1177            self.initialize_instruments(product_types).await?;
1178
1179            self.ws_private.set_account_id(self.core.account_id);
1180            self.ws_trade.set_account_id(self.core.account_id);
1181
1182            if self.config.auto_repay_spot_borrows {
1183                let (tx, rx) = tokio::sync::mpsc::unbounded_channel();
1184                self.dispatch_state.set_repay_sender(tx);
1185
1186                let http_client = self.http_client.clone();
1187                let clock = self.clock;
1188                self.session_tasks.spawn(async move {
1189                    crate::repay::run_spot_repay_consumer(rx, http_client, clock).await;
1190                })?;
1191            }
1192
1193            self.connect_private_websocket().await?;
1194            self.connect_trade_websocket().await?;
1195
1196            self.apply_account_configuration().await?;
1197
1198            let account_state = self
1199                .http_client
1200                .request_account_state(BybitAccountType::Unified, self.core.account_id)
1201                .await
1202                .context("failed to request Bybit account state")?;
1203
1204            if !account_state.balances.is_empty() {
1205                log::debug!(
1206                    "Received account state with {} balance(s)",
1207                    account_state.balances.len()
1208                );
1209            }
1210            self.emitter.send_account_state(account_state);
1211
1212            self.await_account_registered(30.0).await?;
1213
1214            Ok(())
1215        }
1216        .await;
1217
1218        if let Err(e) = connect_result {
1219            if let Err(teardown_error) = self.teardown_partial_connect().await {
1220                return Err(e.context(format!("Bybit startup teardown failed: {teardown_error}")));
1221            }
1222            return Err(e);
1223        }
1224
1225        setup_guard.disarm();
1226        self.core.set_connected();
1227        log::info!("Connected: client_id={}", self.core.client_id);
1228        Ok(())
1229    }
1230
1231    async fn disconnect(&mut self) -> anyhow::Result<()> {
1232        self.teardown_partial_connect().await?;
1233        log::info!("Disconnected: client_id={}", self.core.client_id);
1234        Ok(())
1235    }
1236
1237    fn query_account(&self, cmd: QueryAccount) -> anyhow::Result<()> {
1238        let params = cmd.params.as_ref();
1239
1240        let action = params
1241            .and_then(|params| params.get_str("action"))
1242            .and_then(parse_margin_action);
1243
1244        let Some(action) = action else {
1245            if let Some(action_str) = params.and_then(|params| params.get_str("action")) {
1246                log::warn!("Unknown query_account action: {action_str}");
1247            }
1248
1249            self.update_account_state();
1250            return Ok(());
1251        };
1252
1253        let coin = params
1254            .and_then(|params| params.get_str("coin"))
1255            .map(String::from);
1256        let amount_given = params.is_some_and(|params| params.contains_key("amount"));
1257        let amount = params.and_then(|params| get_price_str(params, "amount"));
1258        match action {
1259            BybitMarginAction::Borrow => self.borrow_spot_margin(coin, amount, amount_given),
1260            BybitMarginAction::Repay => self.repay_spot_margin(coin, amount, amount_given),
1261            BybitMarginAction::GetBorrowAmount => self.query_spot_borrow_amount(coin),
1262        }
1263
1264        Ok(())
1265    }
1266
1267    fn query_order(&self, cmd: QueryOrder) -> anyhow::Result<()> {
1268        let instrument_id = cmd.instrument_id;
1269        let product_type = self.get_product_type_for_instrument(instrument_id);
1270        let client_order_id = cmd.client_order_id;
1271        let venue_order_id = cmd.venue_order_id;
1272        let account_id = self.core.account_id;
1273        let strategy_id = cmd.strategy_id;
1274        let state = Arc::clone(&self.dispatch_state);
1275        let instruments = Arc::clone(&self.instruments_cache);
1276        let http_client = self.http_client.clone();
1277        let emitter = self.emitter.clone();
1278
1279        self.spawn_task("query_order", async move {
1280            match http_client
1281                .query_order(
1282                    account_id,
1283                    product_type,
1284                    instrument_id,
1285                    Some(client_order_id),
1286                    venue_order_id,
1287                )
1288                .await
1289            {
1290                Ok(Some(report)) => {
1291                    if state.fast_execution {
1292                        let recoverable = !report.order_status.is_closed()
1293                            || has_pending_fast_execution(report.venue_order_id, &state);
1294                        if recoverable
1295                            && let Some(client_order_id) = report.client_order_id
1296                            && !state.order_identities.contains_key(&client_order_id)
1297                            && let Some(order_side) = report.order_side
1298                        {
1299                            state.order_identities.insert(
1300                                client_order_id,
1301                                OrderIdentity {
1302                                    instrument_id: report.instrument_id,
1303                                    strategy_id,
1304                                    order_side,
1305                                    order_type: report.order_type,
1306                                    venue_position_id: report.venue_position_id,
1307                                },
1308                            );
1309                        }
1310
1311                        cache_reconciliation_order_identity(
1312                            account_id,
1313                            None,
1314                            &state,
1315                            &report,
1316                            &instruments,
1317                            &emitter,
1318                        );
1319                    }
1320
1321                    emitter.send_order_status_report(report);
1322                }
1323                Ok(None) => {
1324                    log::warn!("Order not found: client_order_id={client_order_id}, venue_order_id={venue_order_id:?}");
1325                }
1326                Err(e) => {
1327                    log::warn!("Failed to query order: {e}");
1328                }
1329            }
1330            Ok(())
1331        });
1332
1333        Ok(())
1334    }
1335
1336    fn generate_account_state(
1337        &self,
1338        balances: Vec<AccountBalance>,
1339        margins: Vec<MarginBalance>,
1340        reported: bool,
1341        ts_event: UnixNanos,
1342        info: Option<Params>,
1343    ) -> anyhow::Result<()> {
1344        self.emitter
1345            .emit_account_state(balances, margins, reported, ts_event, info);
1346        Ok(())
1347    }
1348
1349    fn start(&mut self) -> anyhow::Result<()> {
1350        if self.core.is_started() {
1351            return Ok(());
1352        }
1353
1354        let sender = get_exec_event_sender();
1355        self.emitter.set_sender(sender);
1356        self.core.set_started();
1357
1358        let http_client = self.http_client.clone();
1359        let product_types = self.config.product_types.clone();
1360
1361        self.session_tasks.spawn(async move {
1362            let mut all_instruments = Vec::new();
1363
1364            for product_type in product_types {
1365                match http_client
1366                    .request_instruments(product_type, None, None)
1367                    .await
1368                {
1369                    Ok(instruments) => {
1370                        if instruments.is_empty() {
1371                            log::warn!("No instruments returned for {product_type:?}");
1372                            continue;
1373                        }
1374                        http_client.cache_instruments(&instruments);
1375                        all_instruments.extend(instruments);
1376                    }
1377                    Err(e) => {
1378                        log::error!("Failed to request instruments for {product_type:?}: {e}");
1379                    }
1380                }
1381            }
1382
1383            if all_instruments.is_empty() {
1384                log::warn!(
1385                    "Instrument bootstrap yielded no instruments; WebSocket submissions may fail"
1386                );
1387            } else {
1388                log::debug!("Instruments initialized: count={}", all_instruments.len());
1389            }
1390        })?;
1391
1392        log::info!(
1393            "Started: client_id={}, account_id={}, account_type={:?}, product_types={:?}, environment={:?}, proxy_url={:?}",
1394            self.core.client_id,
1395            self.core.account_id,
1396            self.core.account_type,
1397            self.config.product_types,
1398            self.config.environment,
1399            self.config.proxy_url,
1400        );
1401        Ok(())
1402    }
1403
1404    fn stop(&mut self) -> anyhow::Result<()> {
1405        if self.core.is_stopped() {
1406            return Ok(());
1407        }
1408
1409        self.core.set_stopped();
1410        self.core.set_disconnected();
1411
1412        self.abort_session_tasks();
1413        self.abort_pending_tasks();
1414        self.http_client.cancel_all_requests();
1415        self.ws_private.begin_shutdown();
1416        self.ws_trade.begin_shutdown();
1417        log::info!("Stopped: client_id={}", self.core.client_id);
1418        Ok(())
1419    }
1420
1421    fn generate_order_status_report_task(
1422        &self,
1423        cmd: &GenerateOrderStatusReport,
1424    ) -> Option<ExecutionReportTask<Option<OrderStatusReport>>> {
1425        let http_client = self.http_client.clone();
1426        let core = self.core.clone();
1427        let account_id = core.account_id;
1428        let state = Arc::clone(&self.dispatch_state);
1429        let instruments = Arc::clone(&self.instruments_cache);
1430        let emitter = self.emitter.clone();
1431
1432        let instrument = cmd.instrument_id.map(|instrument_id| {
1433            (
1434                instrument_id,
1435                self.get_product_type_for_instrument(instrument_id),
1436            )
1437        });
1438
1439        let command = cmd.clone();
1440        Some(ExecutionReportTask::new(
1441            async move {
1442                let Some((instrument_id, product_type)) = instrument else {
1443                    log::warn!("generate_order_status_report requires instrument_id: {command}");
1444                    return Ok(None);
1445                };
1446
1447                let reports = http_client
1448                    .request_order_status_reports(
1449                        account_id,
1450                        product_type,
1451                        Some(instrument_id),
1452                        false,
1453                        None,
1454                        None,
1455                        None,
1456                    )
1457                    .await?;
1458
1459                Ok(reports.into_iter().find(|report| {
1460                    command
1461                        .client_order_id
1462                        .is_none_or(|id| report.client_order_id == Some(id))
1463                        && command
1464                            .venue_order_id
1465                            .is_none_or(|id| report.venue_order_id.as_str() == id.as_str())
1466                }))
1467            },
1468            move |report| {
1469                if let Some(report) = &report {
1470                    cache_reconciliation_order_identity(
1471                        account_id,
1472                        Some(&core),
1473                        &state,
1474                        report,
1475                        &instruments,
1476                        &emitter,
1477                    );
1478                }
1479
1480                Ok(report)
1481            },
1482        ))
1483    }
1484
1485    fn generate_order_status_reports_task(
1486        &self,
1487        cmd: &GenerateOrderStatusReports,
1488    ) -> Option<ExecutionReportTask<Vec<OrderStatusReport>>> {
1489        let http_client = self.http_client.clone();
1490        let core = self.core.clone();
1491        let account_id = core.account_id;
1492        let state = Arc::clone(&self.dispatch_state);
1493        let instruments = Arc::clone(&self.instruments_cache);
1494        let emitter = self.emitter.clone();
1495        let product_types = cmd.instrument_id.map_or_else(
1496            || self.product_types(),
1497            |instrument_id| vec![self.get_product_type_for_instrument(instrument_id)],
1498        );
1499
1500        let command = cmd.clone();
1501        Some(ExecutionReportTask::new(
1502            async move {
1503                let mut reports = Vec::new();
1504
1505                for product_type in product_types {
1506                    let mut fetched = http_client
1507                        .request_order_status_reports(
1508                            account_id,
1509                            product_type,
1510                            command.instrument_id,
1511                            command.open_only,
1512                            None,
1513                            None,
1514                            None,
1515                        )
1516                        .await?;
1517                    reports.append(&mut fetched);
1518                }
1519
1520                if let Some(start) = command.start {
1521                    reports.retain(|report| report.ts_last >= start);
1522                }
1523
1524                if let Some(end) = command.end {
1525                    reports.retain(|report| report.ts_last <= end);
1526                }
1527
1528                Ok(reports)
1529            },
1530            move |reports| {
1531                for report in &reports {
1532                    cache_reconciliation_order_identity(
1533                        account_id,
1534                        Some(&core),
1535                        &state,
1536                        report,
1537                        &instruments,
1538                        &emitter,
1539                    );
1540                }
1541
1542                Ok(reports)
1543            },
1544        ))
1545    }
1546
1547    async fn generate_order_status_report(
1548        &self,
1549        cmd: &GenerateOrderStatusReport,
1550    ) -> anyhow::Result<Option<OrderStatusReport>> {
1551        let task = self
1552            .generate_order_status_report_task(cmd)
1553            .expect("Bybit single-order report task");
1554        task.collection.await;
1555        (task.finish)()
1556    }
1557
1558    async fn generate_order_status_reports(
1559        &self,
1560        cmd: &GenerateOrderStatusReports,
1561    ) -> anyhow::Result<Vec<OrderStatusReport>> {
1562        let task = self
1563            .generate_order_status_reports_task(cmd)
1564            .expect("Bybit bulk order report task");
1565        task.collection.await;
1566        (task.finish)()
1567    }
1568
1569    async fn generate_fill_reports(
1570        &self,
1571        cmd: GenerateFillReports,
1572    ) -> anyhow::Result<Vec<FillReport>> {
1573        let start_ms = nanos_to_millis(cmd.start);
1574        let end_ms = nanos_to_millis(cmd.end);
1575        let product_types = cmd.instrument_id.map_or_else(
1576            || self.product_types(),
1577            |instrument_id| vec![self.get_product_type_for_instrument(instrument_id)],
1578        );
1579        let mut reports = Vec::new();
1580
1581        for product_type in product_types {
1582            let mut fetched = self
1583                .http_client
1584                .request_fill_reports(
1585                    self.core.account_id,
1586                    product_type,
1587                    cmd.instrument_id,
1588                    start_ms,
1589                    end_ms,
1590                    None,
1591                )
1592                .await?;
1593            reports.append(&mut fetched);
1594        }
1595
1596        if let Some(venue_order_id) = cmd.venue_order_id {
1597            reports.retain(|report| report.venue_order_id.as_str() == venue_order_id.as_str());
1598        }
1599
1600        Ok(reports)
1601    }
1602
1603    async fn generate_position_status_reports(
1604        &self,
1605        cmd: &GeneratePositionStatusReports,
1606    ) -> anyhow::Result<Vec<PositionStatusReport>> {
1607        if let Some(instrument_id) = cmd.instrument_id {
1608            let product_type = self.get_product_type_for_instrument(instrument_id);
1609            self.http_client
1610                .request_position_status_reports(
1611                    self.core.account_id,
1612                    product_type,
1613                    Some(instrument_id),
1614                )
1615                .await
1616        } else {
1617            self.generate_bulk_position_status_reports(self.product_types())
1618                .await
1619        }
1620    }
1621
1622    async fn generate_mass_status(
1623        &self,
1624        lookback_mins: Option<u64>,
1625    ) -> anyhow::Result<Option<ExecutionMassStatus>> {
1626        log::info!("Generating ExecutionMassStatus (lookback_mins={lookback_mins:?})");
1627
1628        let ts_now = self.clock.get_time_ns();
1629
1630        let start = lookback_mins
1631            .map(DurationNanos::try_from_mins)
1632            .transpose()?
1633            .map(|lookback| ts_now.saturating_sub(lookback));
1634
1635        let order_cmd = GenerateOrderStatusReportsBuilder::default()
1636            .ts_init(ts_now)
1637            .open_only(false)
1638            .start(start)
1639            .build()
1640            .map_err(|e| anyhow::anyhow!("{e}"))?;
1641
1642        let fill_cmd = GenerateFillReportsBuilder::default()
1643            .ts_init(ts_now)
1644            .start(start)
1645            .build()
1646            .map_err(|e| anyhow::anyhow!("{e}"))?;
1647
1648        let position_reports_fut = async {
1649            let product_types = self.product_types();
1650            let skip_spot = product_types.iter().any(|product_type| {
1651                !Self::provides_bulk_position_coverage_for_product_type(*product_type)
1652            });
1653
1654            if skip_spot {
1655                log::info!(
1656                    "SPOT mass-status position coverage is unavailable because wallet balances cannot be attributed to pairs"
1657                );
1658            }
1659
1660            self.generate_bulk_position_status_reports(product_types)
1661                .await
1662        };
1663
1664        let (order_reports, fill_reports, position_reports) = tokio::try_join!(
1665            self.generate_order_status_reports(&order_cmd),
1666            self.generate_fill_reports(fill_cmd),
1667            position_reports_fut,
1668        )?;
1669
1670        log::info!("Received {} OrderStatusReports", order_reports.len());
1671        log::info!("Received {} FillReports", fill_reports.len());
1672        log::info!("Received {} PositionReports", position_reports.len());
1673
1674        let mut mass_status = ExecutionMassStatus::new(
1675            self.core.client_id,
1676            self.core.account_id,
1677            *BYBIT_VENUE,
1678            ts_now,
1679            None,
1680        );
1681
1682        mass_status.add_order_reports(order_reports);
1683        mass_status.add_fill_reports(fill_reports);
1684        mass_status.add_position_reports(position_reports);
1685
1686        Ok(Some(mass_status))
1687    }
1688
1689    fn submit_order(&self, cmd: SubmitOrder) -> anyhow::Result<()> {
1690        let order = self.core.cache().try_order_owned(&cmd.client_order_id)?;
1691        if order.is_closed() {
1692            log::warn!("Cannot submit closed order {}", order.client_order_id());
1693            return Ok(());
1694        }
1695
1696        let instrument_id = order.instrument_id();
1697        let product_type = self.get_product_type_for_instrument(instrument_id);
1698
1699        // Validate order params before emitting submitted event
1700        if let Err(denied) = validate_order(&order, product_type) {
1701            self.emitter.emit_order_denied(&order, &denied.to_string());
1702            return Ok(());
1703        }
1704
1705        let tp_sl = match parse_bybit_tp_sl_params(cmd.params.as_ref()) {
1706            Ok(p) => p,
1707            Err(e) => {
1708                let denied = OrderDeniedReason::ValidationFailed {
1709                    detail: e.to_string(),
1710                };
1711                self.emitter.emit_order_denied(&order, &denied.to_string());
1712                return Ok(());
1713            }
1714        };
1715
1716        if let Err(e) = Self::validate_bbo_params(&order, product_type, &tp_sl) {
1717            let denied = OrderDeniedReason::ValidationFailed {
1718                detail: e.to_string(),
1719            };
1720            self.emitter.emit_order_denied(&order, &denied.to_string());
1721            return Ok(());
1722        }
1723
1724        // The demo HTTP create-order entry cannot carry TP/SL trigger prices (only the mainnet
1725        // WS path can), so deny rather than submit an order missing the user's trigger prices.
1726        if self.config.environment == BybitEnvironment::Demo
1727            && (tp_sl.tp_trigger_price.is_some() || tp_sl.sl_trigger_price.is_some())
1728        {
1729            let denied = OrderDeniedReason::UnsupportedTpSl {
1730                detail: "TP/SL trigger prices are not supported in demo mode".to_string(),
1731            };
1732            self.emitter.emit_order_denied(&order, &denied.to_string());
1733            return Ok(());
1734        }
1735
1736        log::debug!("OrderSubmitted client_order_id={}", order.client_order_id());
1737        self.emitter.emit_order_submitted(&order);
1738
1739        let client_order_id = order.client_order_id();
1740        let strategy_id = order.strategy_id();
1741        let emitter = self.emitter.clone();
1742        let clock = self.clock;
1743
1744        let bybit_side = BybitOrderSide::from(order.order_side());
1745        let position_idx = self.resolve_position_idx(
1746            instrument_id,
1747            bybit_side,
1748            order.is_reduce_only(),
1749            tp_sl.position_idx,
1750        );
1751        let venue_position_id =
1752            position_idx.and_then(|idx| make_hedge_venue_position_id(instrument_id, idx as i32));
1753
1754        self.dispatch_state.order_identities.insert(
1755            client_order_id,
1756            OrderIdentity {
1757                instrument_id,
1758                strategy_id,
1759                order_side: order.order_side(),
1760                order_type: order.order_type(),
1761                venue_position_id,
1762            },
1763        );
1764
1765        // Seed for BBO reconciliation: venue may replace the submitted price
1766        self.dispatch_state.order_snapshots.insert(
1767            client_order_id,
1768            OrderStateSnapshot {
1769                quantity: order.quantity(),
1770                price: order.price(),
1771                trigger_price: order.trigger_price(),
1772            },
1773        );
1774
1775        let smp_type = self.resolve_smp_type(tp_sl.smp_type);
1776
1777        if self.config.environment == BybitEnvironment::Demo {
1778            let http_client = self.http_client.clone();
1779            let account_id = self.core.account_id;
1780            let order_side = order.order_side();
1781            let order_type = order.order_type();
1782            let quantity = order.quantity();
1783            let time_in_force = order.time_in_force();
1784            let price = order.price();
1785            let trigger_price = order.trigger_price();
1786            let post_only = order.is_post_only();
1787            let reduce_only = order.is_reduce_only();
1788            let is_quote_quantity = order.is_quote_quantity();
1789            let is_leverage = tp_sl.is_leverage;
1790            let bbo_side_type = tp_sl.bbo_side_type;
1791            let bbo_level = tp_sl.bbo_level.clone();
1792            let native_tp_sl = tp_sl.to_native_tp_sl();
1793            let dispatch_state = Arc::clone(&self.dispatch_state);
1794
1795            self.spawn_task("submit_order_http", async move {
1796                let native_tp_sl_ref = (!native_tp_sl.is_empty()).then_some(&native_tp_sl);
1797                let result = http_client
1798                    .submit_order(
1799                        account_id,
1800                        product_type,
1801                        instrument_id,
1802                        client_order_id,
1803                        order_side,
1804                        order_type,
1805                        quantity,
1806                        Some(time_in_force),
1807                        price,
1808                        trigger_price,
1809                        Some(post_only),
1810                        reduce_only,
1811                        is_quote_quantity,
1812                        is_leverage,
1813                        position_idx,
1814                        bbo_side_type,
1815                        bbo_level,
1816                        smp_type,
1817                        native_tp_sl_ref,
1818                    )
1819                    .await;
1820
1821                if let Err(e) = result {
1822                    if let Some(reason) = submit_rejection_reason(&e) {
1823                        dispatch_state.order_identities.remove(&client_order_id);
1824                        dispatch_state.order_snapshots.remove(&client_order_id);
1825                        let ts_event = clock.get_time_ns();
1826                        emitter.emit_order_rejected_event(
1827                            strategy_id,
1828                            instrument_id,
1829                            client_order_id,
1830                            reason,
1831                            ts_event,
1832                            bybit_rejection_due_post_only(reason),
1833                        );
1834                        anyhow::bail!("submit order rejected: {reason}");
1835                    }
1836
1837                    log::warn!(
1838                        "Submit failure without confirmed venue rejection for {client_order_id}: \
1839                         {e}; awaiting reconciliation",
1840                    );
1841                    return Ok(());
1842                }
1843
1844                Ok(())
1845            });
1846
1847            return Ok(());
1848        }
1849
1850        let raw_symbol = extract_raw_symbol(instrument_id.symbol.as_str());
1851        let params = Self::build_ws_place_params(
1852            &order,
1853            product_type,
1854            raw_symbol,
1855            &tp_sl,
1856            position_idx,
1857            smp_type,
1858        )?;
1859
1860        let ws_trade = self.ws_trade.clone();
1861        let dispatch_state = Arc::clone(&self.dispatch_state);
1862
1863        self.spawn_task("submit_order", async move {
1864            let req_id = UUID4::new().to_string();
1865            dispatch_state.pending_requests.insert(
1866                req_id.clone(),
1867                (
1868                    vec![client_order_id],
1869                    vec![None],
1870                    PendingOperation::Place,
1871                    Vec::new(),
1872                ),
1873            );
1874
1875            if let Err(e) = ws_trade.place_order_with_id(params, req_id.clone()).await {
1876                dispatch_state.pending_requests.remove(&req_id);
1877                dispatch_state.order_identities.remove(&client_order_id);
1878                dispatch_state.order_snapshots.remove(&client_order_id);
1879                let reason = e.to_string();
1880                emitter.emit_order_rejected_event(
1881                    strategy_id,
1882                    instrument_id,
1883                    client_order_id,
1884                    &reason,
1885                    clock.get_time_ns(),
1886                    false,
1887                );
1888            }
1889
1890            Ok(())
1891        });
1892
1893        Ok(())
1894    }
1895
1896    fn submit_order_list(&self, cmd: SubmitOrderList) -> anyhow::Result<()> {
1897        if cmd.order_list.client_order_ids.is_empty() {
1898            return Ok(());
1899        }
1900
1901        let tp_sl = match parse_bybit_tp_sl_params(cmd.params.as_ref()) {
1902            Ok(p) => p,
1903            Err(e) => {
1904                let cache = self.core.cache();
1905                let denied = OrderDeniedReason::ValidationFailed {
1906                    detail: e.to_string(),
1907                }
1908                .to_string();
1909
1910                for cid in &cmd.order_list.client_order_ids {
1911                    if let Some(order) = cache.order(cid) {
1912                        self.emitter.emit_order_denied(&order, &denied);
1913                    }
1914                }
1915                return Ok(());
1916            }
1917        };
1918
1919        let instrument_id = cmd.instrument_id;
1920        let product_type = self.get_product_type_for_instrument(instrument_id);
1921
1922        // The demo HTTP create-order entry cannot carry TP/SL trigger prices (only the mainnet
1923        // WS path can), so deny rather than submit orders missing the user's trigger prices.
1924        if self.config.environment == BybitEnvironment::Demo
1925            && (tp_sl.tp_trigger_price.is_some() || tp_sl.sl_trigger_price.is_some())
1926        {
1927            let cache = self.core.cache();
1928            let denied = OrderDeniedReason::UnsupportedTpSl {
1929                detail: "TP/SL trigger prices are not supported in demo mode".to_string(),
1930            }
1931            .to_string();
1932
1933            for cid in &cmd.order_list.client_order_ids {
1934                if let Some(order) = cache.order(cid) {
1935                    self.emitter.emit_order_denied(&order, &denied);
1936                }
1937            }
1938            return Ok(());
1939        }
1940
1941        let strategy_id = cmd.strategy_id;
1942
1943        let mut valid_orders = Vec::with_capacity(cmd.order_list.client_order_ids.len());
1944        {
1945            let cache = self.core.cache();
1946            let order_list_id = cmd.order_list.id;
1947            let list_denied = OrderDeniedReason::OrderListDenied { order_list_id };
1948            // (offending leg, reason for the offending leg, reason for the remaining legs). A
1949            // single offending leg carries its specific reason and the rest render
1950            // `ORDER_LIST_DENIED`; a list-level failure renders the same reason for every leg.
1951            let mut denial: Option<(ClientOrderId, OrderDeniedReason, OrderDeniedReason)> = None;
1952
1953            for cid in &cmd.order_list.client_order_ids {
1954                let Some(order) = cache.order(cid) else {
1955                    let reason = OrderDeniedReason::OrderListIncomplete { order_list_id };
1956                    denial = Some((*cid, reason.clone(), reason));
1957                    break;
1958                };
1959
1960                if order.is_closed() {
1961                    denial = Some((
1962                        *cid,
1963                        OrderDeniedReason::ValidationFailed {
1964                            detail: format!("cannot submit closed order {cid}"),
1965                        },
1966                        list_denied,
1967                    ));
1968                    break;
1969                }
1970
1971                if let Err(reason) = validate_order(&order, product_type) {
1972                    denial = Some((*cid, reason, list_denied));
1973                    break;
1974                }
1975
1976                if let Err(e) = Self::validate_bbo_params(&order, product_type, &tp_sl) {
1977                    denial = Some((
1978                        *cid,
1979                        OrderDeniedReason::ValidationFailed {
1980                            detail: e.to_string(),
1981                        },
1982                        list_denied,
1983                    ));
1984                    break;
1985                }
1986
1987                valid_orders.push(order.clone());
1988            }
1989
1990            // Deny the entire list if any leg fails validation
1991            if let Some((offender, offender_reason, rest_reason)) = denial {
1992                let offender_reason = offender_reason.to_string();
1993                let rest_reason = rest_reason.to_string();
1994
1995                for cid in &cmd.order_list.client_order_ids {
1996                    if let Some(order) = cache.order(cid) {
1997                        let reason = if *cid == offender {
1998                            offender_reason.as_str()
1999                        } else {
2000                            rest_reason.as_str()
2001                        };
2002                        self.emitter.emit_order_denied(&order, reason);
2003                    }
2004                }
2005                return Ok(());
2006            }
2007        }
2008
2009        if valid_orders.is_empty() {
2010            return Ok(());
2011        }
2012
2013        for order in &valid_orders {
2014            self.emitter.emit_order_submitted(order);
2015            let bybit_side = BybitOrderSide::from(order.order_side());
2016            let position_idx = self.resolve_position_idx(
2017                instrument_id,
2018                bybit_side,
2019                order.is_reduce_only(),
2020                tp_sl.position_idx,
2021            );
2022            let venue_position_id = position_idx
2023                .and_then(|idx| make_hedge_venue_position_id(instrument_id, idx as i32));
2024            self.dispatch_state.order_identities.insert(
2025                order.client_order_id(),
2026                OrderIdentity {
2027                    instrument_id,
2028                    strategy_id,
2029                    order_side: order.order_side(),
2030                    order_type: order.order_type(),
2031                    venue_position_id,
2032                },
2033            );
2034            self.dispatch_state.order_snapshots.insert(
2035                order.client_order_id(),
2036                OrderStateSnapshot {
2037                    quantity: order.quantity(),
2038                    price: order.price(),
2039                    trigger_price: order.trigger_price(),
2040                },
2041            );
2042        }
2043
2044        let emitter = self.emitter.clone();
2045        let clock = self.clock;
2046
2047        let smp_type = self.resolve_smp_type(tp_sl.smp_type);
2048
2049        // Demo mode: submit individually via HTTP
2050        if self.config.environment == BybitEnvironment::Demo {
2051            let http_client = self.http_client.clone();
2052            let account_id = self.core.account_id;
2053            let is_leverage = tp_sl.is_leverage;
2054            let bbo_side_type = tp_sl.bbo_side_type;
2055            let bbo_level = tp_sl.bbo_level.clone();
2056            let native_tp_sl = tp_sl.to_native_tp_sl();
2057            let dispatch_state = Arc::clone(&self.dispatch_state);
2058
2059            let order_data: Vec<_> = valid_orders
2060                .iter()
2061                .map(|o| {
2062                    let bybit_side = BybitOrderSide::from(o.order_side());
2063                    let position_idx = self.resolve_position_idx(
2064                        instrument_id,
2065                        bybit_side,
2066                        o.is_reduce_only(),
2067                        tp_sl.position_idx,
2068                    );
2069                    (
2070                        o.client_order_id(),
2071                        o.order_side(),
2072                        o.order_type(),
2073                        o.quantity(),
2074                        o.time_in_force(),
2075                        o.price(),
2076                        o.trigger_price(),
2077                        o.is_post_only(),
2078                        o.is_reduce_only(),
2079                        o.is_quote_quantity(),
2080                        position_idx,
2081                    )
2082                })
2083                .collect();
2084
2085            self.spawn_task("submit_order_list_http", async move {
2086                let native_tp_sl_ref = (!native_tp_sl.is_empty()).then_some(&native_tp_sl);
2087
2088                for (
2089                    cid,
2090                    side,
2091                    otype,
2092                    qty,
2093                    tif,
2094                    price,
2095                    trigger,
2096                    post_only,
2097                    reduce,
2098                    quote_qty,
2099                    position_idx,
2100                ) in order_data
2101                {
2102                    if let Err(e) = http_client
2103                        .submit_order(
2104                            account_id,
2105                            product_type,
2106                            instrument_id,
2107                            cid,
2108                            side,
2109                            otype,
2110                            qty,
2111                            Some(tif),
2112                            price,
2113                            trigger,
2114                            Some(post_only),
2115                            reduce,
2116                            quote_qty,
2117                            is_leverage,
2118                            position_idx,
2119                            bbo_side_type,
2120                            bbo_level.clone(),
2121                            smp_type,
2122                            native_tp_sl_ref,
2123                        )
2124                        .await
2125                    {
2126                        if let Some(reason) = submit_rejection_reason(&e) {
2127                            dispatch_state.order_identities.remove(&cid);
2128                            dispatch_state.order_snapshots.remove(&cid);
2129                            let ts_event = clock.get_time_ns();
2130                            emitter.emit_order_rejected_event(
2131                                strategy_id,
2132                                instrument_id,
2133                                cid,
2134                                reason,
2135                                ts_event,
2136                                bybit_rejection_due_post_only(reason),
2137                            );
2138                            continue;
2139                        }
2140
2141                        log::warn!(
2142                            "Submit failure without confirmed venue rejection for {cid}: {e}; \
2143                             awaiting reconciliation",
2144                        );
2145                    }
2146                }
2147                Ok(())
2148            });
2149
2150            return Ok(());
2151        }
2152
2153        // Live mode: batch submit via WebSocket
2154        let raw_symbol = extract_raw_symbol(instrument_id.symbol.as_str());
2155
2156        let mut order_params = Vec::with_capacity(valid_orders.len());
2157        let mut client_order_ids = Vec::with_capacity(valid_orders.len());
2158
2159        for order in &valid_orders {
2160            let bybit_side = BybitOrderSide::from(order.order_side());
2161            let position_idx = self.resolve_position_idx(
2162                instrument_id,
2163                bybit_side,
2164                order.is_reduce_only(),
2165                tp_sl.position_idx,
2166            );
2167            let params = Self::build_ws_place_params(
2168                order,
2169                product_type,
2170                raw_symbol,
2171                &tp_sl,
2172                position_idx,
2173                smp_type,
2174            )
2175            .expect("validated above");
2176            order_params.push(params);
2177            client_order_ids.push(order.client_order_id());
2178        }
2179
2180        let ws_trade = self.ws_trade.clone();
2181        let dispatch_state = Arc::clone(&self.dispatch_state);
2182
2183        self.spawn_task("submit_order_list", async move {
2184            let req_ids = BybitWebSocketClient::batch_request_ids(product_type, order_params.len());
2185            for (req_id, chunk_cids) in req_ids.iter().zip(
2186                client_order_ids
2187                    .chunks(batch_send_limit(product_type))
2188                    .map(|chunk| chunk.to_vec()),
2189            ) {
2190                let chunk_voids = vec![None; chunk_cids.len()];
2191                dispatch_state.pending_requests.insert(
2192                    req_id.clone(),
2193                    (chunk_cids, chunk_voids, PendingOperation::Place, Vec::new()),
2194                );
2195            }
2196
2197            if let Err(e) = ws_trade
2198                .batch_place_orders_with_ids(order_params, req_ids.clone())
2199                .await
2200            {
2201                for req_id in req_ids {
2202                    dispatch_state.pending_requests.remove(&req_id);
2203                }
2204                let reason = e.to_string();
2205                let ts_event = clock.get_time_ns();
2206
2207                for client_order_id in client_order_ids {
2208                    dispatch_state.order_identities.remove(&client_order_id);
2209                    dispatch_state.order_snapshots.remove(&client_order_id);
2210                    emitter.emit_order_rejected_event(
2211                        strategy_id,
2212                        instrument_id,
2213                        client_order_id,
2214                        &reason,
2215                        ts_event,
2216                        false,
2217                    );
2218                }
2219            }
2220            Ok(())
2221        });
2222
2223        Ok(())
2224    }
2225
2226    fn modify_order(&self, cmd: ModifyOrder) -> anyhow::Result<()> {
2227        let instrument_id = cmd.instrument_id;
2228        let product_type = self.get_product_type_for_instrument(instrument_id);
2229        let client_order_id = cmd.client_order_id;
2230        let strategy_id = cmd.strategy_id;
2231        let venue_order_id = cmd.venue_order_id;
2232        let emitter = self.emitter.clone();
2233        let clock = self.clock;
2234
2235        let has_order_iv = cmd
2236            .params
2237            .as_ref()
2238            .and_then(|p| p.get("order_iv"))
2239            .is_some();
2240
2241        if self.config.environment == BybitEnvironment::Demo && has_order_iv {
2242            log::warn!(
2243                "Modify command failed local validation for {client_order_id}: {}",
2244                "Option params (order_iv) are not supported in demo mode",
2245            );
2246            emitter.emit_order_modify_denied_event(
2247                strategy_id,
2248                instrument_id,
2249                client_order_id,
2250                venue_order_id,
2251                "Option params (order_iv) are not supported in demo mode",
2252                clock.get_time_ns(),
2253                Some(cmd.command_id),
2254            );
2255            return Ok(());
2256        }
2257
2258        if self.config.environment == BybitEnvironment::Demo {
2259            let http_client = self.http_client.clone();
2260            let account_id = self.core.account_id;
2261            let quantity = cmd.quantity;
2262            let price = cmd.price;
2263            let trigger_price = cmd.trigger_price;
2264
2265            self.spawn_task("modify_order_http", async move {
2266                let result = http_client
2267                    .modify_order(
2268                        account_id,
2269                        product_type,
2270                        instrument_id,
2271                        Some(client_order_id),
2272                        venue_order_id,
2273                        quantity,
2274                        price,
2275                        trigger_price,
2276                    )
2277                    .await;
2278
2279                if let Err(e) = result {
2280                    match classify_modify_http_failure(&e) {
2281                        CommandFailure::VenueRejected(reason) => {
2282                            let ts_event = clock.get_time_ns();
2283                            emitter.emit_order_modify_rejected_event(
2284                                strategy_id,
2285                                instrument_id,
2286                                client_order_id,
2287                                venue_order_id,
2288                                &format!("modify-order-error: {reason}"),
2289                                ts_event,
2290                                Some(cmd.command_id),
2291                            );
2292                            anyhow::bail!("modify order rejected: {reason}");
2293                        }
2294                        CommandFailure::NotSent(reason) => {
2295                            emitter.emit_order_modify_denied_event(
2296                                strategy_id,
2297                                instrument_id,
2298                                client_order_id,
2299                                venue_order_id,
2300                                &reason,
2301                                clock.get_time_ns(),
2302                                Some(cmd.command_id),
2303                            );
2304                        }
2305                        CommandFailure::Ambiguous(reason) => {
2306                            log::warn!(
2307                                "Ambiguous HTTP modify failure for {client_order_id}, awaiting reconciliation: {reason}"
2308                            );
2309                        }
2310                    }
2311                }
2312
2313                Ok(())
2314            });
2315
2316            return Ok(());
2317        }
2318
2319        let raw_symbol = extract_raw_symbol(instrument_id.symbol.as_str());
2320
2321        let params = match Self::build_ws_amend_params(&cmd, product_type, raw_symbol) {
2322            Ok(params) => params,
2323            Err(reason) => {
2324                log::warn!(
2325                    "Modify command failed local validation for {client_order_id}: {reason}",
2326                );
2327                emitter.emit_order_modify_denied_event(
2328                    strategy_id,
2329                    instrument_id,
2330                    client_order_id,
2331                    venue_order_id,
2332                    &reason,
2333                    clock.get_time_ns(),
2334                    Some(cmd.command_id),
2335                );
2336                return Ok(());
2337            }
2338        };
2339
2340        let ws_trade = self.ws_trade.clone();
2341        let dispatch_state = Arc::clone(&self.dispatch_state);
2342
2343        self.spawn_task("modify_order", async move {
2344            let req_id = UUID4::new().to_string();
2345            dispatch_state.pending_requests.insert(
2346                req_id.clone(),
2347                (
2348                    vec![client_order_id],
2349                    vec![venue_order_id],
2350                    PendingOperation::Amend,
2351                    vec![Some(cmd.command_id)],
2352                ),
2353            );
2354
2355            if let Err(e) = ws_trade.amend_order_with_id(params, req_id.clone()).await {
2356                dispatch_state.pending_requests.remove(&req_id);
2357                emitter.emit_order_modify_denied_event(
2358                    strategy_id,
2359                    instrument_id,
2360                    client_order_id,
2361                    venue_order_id,
2362                    &e.to_string(),
2363                    clock.get_time_ns(),
2364                    Some(cmd.command_id),
2365                );
2366            }
2367
2368            Ok(())
2369        });
2370
2371        Ok(())
2372    }
2373
2374    fn batch_modify_orders(&self, cmd: BatchModifyOrders) -> anyhow::Result<()> {
2375        if cmd.modifies.is_empty() {
2376            return Ok(());
2377        }
2378
2379        if self.config.environment == BybitEnvironment::Demo {
2380            for modify in cmd.modifies {
2381                self.modify_order(modify)?;
2382            }
2383
2384            return Ok(());
2385        }
2386
2387        let instrument_id = cmd.instrument_id;
2388        let product_type = self.get_product_type_for_instrument(instrument_id);
2389        let raw_symbol = extract_raw_symbol(instrument_id.symbol.as_str());
2390        let emitter = self.emitter.clone();
2391        let clock = self.clock;
2392
2393        let mut amend_params = Vec::with_capacity(cmd.modifies.len());
2394        let mut strategy_ids = Vec::with_capacity(cmd.modifies.len());
2395        let mut client_order_ids = Vec::with_capacity(cmd.modifies.len());
2396        let mut venue_order_ids = Vec::with_capacity(cmd.modifies.len());
2397        let mut command_ids = Vec::with_capacity(cmd.modifies.len());
2398
2399        for modify in &cmd.modifies {
2400            match Self::build_ws_amend_params(modify, product_type, raw_symbol) {
2401                Ok(params) => {
2402                    amend_params.push(params);
2403                    strategy_ids.push(modify.strategy_id);
2404                    client_order_ids.push(modify.client_order_id);
2405                    venue_order_ids.push(modify.venue_order_id);
2406                    command_ids.push(modify.command_id);
2407                }
2408                Err(reason) => {
2409                    log::warn!(
2410                        "Modify command failed local validation for {}: {reason}",
2411                        modify.client_order_id,
2412                    );
2413                    emitter.emit_order_modify_denied_event(
2414                        modify.strategy_id,
2415                        instrument_id,
2416                        modify.client_order_id,
2417                        modify.venue_order_id,
2418                        &reason,
2419                        clock.get_time_ns(),
2420                        Some(modify.command_id),
2421                    );
2422                }
2423            }
2424        }
2425
2426        if amend_params.is_empty() {
2427            return Ok(());
2428        }
2429
2430        let ws_trade = self.ws_trade.clone();
2431        let dispatch_state = Arc::clone(&self.dispatch_state);
2432
2433        self.spawn_task("batch_modify_orders", async move {
2434            let req_ids = BybitWebSocketClient::batch_request_ids(product_type, amend_params.len());
2435            let chunk_limit = batch_send_limit(product_type);
2436
2437            for (req_id, ((chunk_cids, chunk_voids), chunk_commands)) in req_ids.iter().zip(
2438                client_order_ids
2439                    .chunks(chunk_limit)
2440                    .map(|chunk| chunk.to_vec())
2441                    .zip(
2442                        venue_order_ids
2443                            .chunks(chunk_limit)
2444                            .map(|chunk| chunk.to_vec()),
2445                    )
2446                    .zip(command_ids.chunks(chunk_limit)),
2447            ) {
2448                dispatch_state.pending_requests.insert(
2449                    req_id.clone(),
2450                    (
2451                        chunk_cids,
2452                        chunk_voids,
2453                        PendingOperation::Amend,
2454                        chunk_commands.iter().copied().map(Some).collect(),
2455                    ),
2456                );
2457            }
2458
2459            if let Err(e) = ws_trade
2460                .batch_amend_orders_with_ids(amend_params, req_ids.clone())
2461                .await
2462            {
2463                for req_id in req_ids {
2464                    dispatch_state.pending_requests.remove(&req_id);
2465                }
2466
2467                let reason = e.to_string();
2468                let ts_event = clock.get_time_ns();
2469
2470                for (((strategy_id, client_order_id), venue_order_id), command_id) in strategy_ids
2471                    .into_iter()
2472                    .zip(client_order_ids)
2473                    .zip(venue_order_ids)
2474                    .zip(command_ids)
2475                {
2476                    emitter.emit_order_modify_denied_event(
2477                        strategy_id,
2478                        instrument_id,
2479                        client_order_id,
2480                        venue_order_id,
2481                        &reason,
2482                        ts_event,
2483                        Some(command_id),
2484                    );
2485                }
2486            }
2487
2488            Ok(())
2489        });
2490
2491        Ok(())
2492    }
2493
2494    fn cancel_order(&self, cmd: CancelOrder) -> anyhow::Result<()> {
2495        let instrument_id = cmd.instrument_id;
2496        let product_type = self.get_product_type_for_instrument(instrument_id);
2497        let client_order_id = cmd.client_order_id;
2498        let strategy_id = cmd.strategy_id;
2499        let venue_order_id = cmd.venue_order_id;
2500        let emitter = self.emitter.clone();
2501        let clock = self.clock;
2502
2503        if self.config.environment == BybitEnvironment::Demo {
2504            let http_client = self.http_client.clone();
2505            let account_id = self.core.account_id;
2506
2507            self.spawn_task("cancel_order_http", async move {
2508                let result = http_client
2509                    .cancel_order(
2510                        account_id,
2511                        product_type,
2512                        instrument_id,
2513                        Some(client_order_id),
2514                        venue_order_id,
2515                    )
2516                    .await;
2517
2518                if let Ok(ref report) = result {
2519                    emit_cancel_confirmation(&emitter, strategy_id, client_order_id, report);
2520                }
2521
2522                if let Err(e) = result {
2523                    match classify_cancel_http_failure(&e) {
2524                        CommandFailure::VenueRejected(reason) => {
2525                            let ts_event = clock.get_time_ns();
2526                            emitter.emit_order_cancel_rejected_event(
2527                                strategy_id,
2528                                instrument_id,
2529                                client_order_id,
2530                                venue_order_id,
2531                                &format!("cancel-order-error: {reason}"),
2532                                ts_event,
2533                                Some(cmd.command_id),
2534                            );
2535                            anyhow::bail!("cancel order rejected: {reason}");
2536                        }
2537                        CommandFailure::NotSent(reason) => {
2538                            emitter.emit_order_cancel_denied_event(
2539                                strategy_id,
2540                                instrument_id,
2541                                client_order_id,
2542                                venue_order_id,
2543                                &reason,
2544                                clock.get_time_ns(),
2545                                Some(cmd.command_id),
2546                            );
2547                        }
2548                        CommandFailure::Ambiguous(reason) => {
2549                            log::warn!(
2550                                "Ambiguous HTTP cancel failure for {client_order_id}, awaiting reconciliation: {reason}"
2551                            );
2552                        }
2553                    }
2554                }
2555
2556                Ok(())
2557            });
2558
2559            return Ok(());
2560        }
2561
2562        let raw_symbol = extract_raw_symbol(instrument_id.symbol.as_str());
2563
2564        let params = BybitWsCancelOrderParams {
2565            category: product_type,
2566            symbol: Ustr::from(raw_symbol),
2567            order_id: cmd.venue_order_id.map(|v| v.to_string()),
2568            order_link_id: Some(cmd.client_order_id.to_string()),
2569        };
2570
2571        let ws_trade = self.ws_trade.clone();
2572        let dispatch_state = Arc::clone(&self.dispatch_state);
2573
2574        self.spawn_task("cancel_order", async move {
2575            let req_id = UUID4::new().to_string();
2576            dispatch_state.pending_requests.insert(
2577                req_id.clone(),
2578                (
2579                    vec![client_order_id],
2580                    vec![venue_order_id],
2581                    PendingOperation::Cancel,
2582                    vec![Some(cmd.command_id)],
2583                ),
2584            );
2585
2586            if let Err(e) = ws_trade.cancel_order_with_id(params, req_id.clone()).await {
2587                dispatch_state.pending_requests.remove(&req_id);
2588                emitter.emit_order_cancel_denied_event(
2589                    strategy_id,
2590                    instrument_id,
2591                    client_order_id,
2592                    venue_order_id,
2593                    &e.to_string(),
2594                    clock.get_time_ns(),
2595                    Some(cmd.command_id),
2596                );
2597            }
2598
2599            Ok(())
2600        });
2601
2602        Ok(())
2603    }
2604
2605    fn cancel_all_orders(&self, cmd: CancelAllOrders) -> anyhow::Result<()> {
2606        if cmd.order_side.is_some() {
2607            // Bybit cancel-all has no side parameter, so select matching open
2608            // orders and cancel their explicit IDs through the batch path.
2609            let cancels: Vec<CancelOrder> = {
2610                let cache = self.core.cache();
2611                cache
2612                    .orders_open(None, Some(&cmd.instrument_id), None, None, cmd.order_side)
2613                    .iter()
2614                    .map(|order| CancelOrder {
2615                        trader_id: order.trader_id(),
2616                        client_id: cmd.client_id,
2617                        strategy_id: order.strategy_id(),
2618                        instrument_id: order.instrument_id(),
2619                        client_order_id: order.client_order_id(),
2620                        venue_order_id: order.venue_order_id(),
2621                        command_id: cmd.command_id,
2622                        ts_init: cmd.ts_init,
2623                        params: cmd.params.clone(),
2624                        correlation_id: cmd.correlation_id,
2625                        causation_id: cmd.causation_id,
2626                    })
2627                    .collect()
2628            };
2629
2630            if cancels.is_empty() {
2631                log::debug!("No open orders to cancel for {}", cmd.instrument_id);
2632                return Ok(());
2633            }
2634
2635            return self.batch_cancel_orders(BatchCancelOrders {
2636                trader_id: cmd.trader_id,
2637                client_id: cmd.client_id,
2638                strategy_id: cmd.strategy_id,
2639                instrument_id: cmd.instrument_id,
2640                cancels,
2641                command_id: cmd.command_id,
2642                ts_init: cmd.ts_init,
2643                params: cmd.params,
2644                correlation_id: cmd.correlation_id,
2645                causation_id: cmd.causation_id,
2646            });
2647        }
2648
2649        let instrument_id = cmd.instrument_id;
2650        let product_type = self.get_product_type_for_instrument(instrument_id);
2651        let account_id = self.core.account_id;
2652        let http_client = self.http_client.clone();
2653        let emitter = self.emitter.clone();
2654
2655        let mut orders: Vec<_> = self
2656            .core
2657            .cache()
2658            .orders_open(None, Some(&instrument_id), None, Some(&account_id), None)
2659            .into_iter()
2660            .map(|order| {
2661                (
2662                    order.client_order_id(),
2663                    order.venue_order_id(),
2664                    order.strategy_id(),
2665                )
2666            })
2667            .collect();
2668
2669        let timeout = Duration::from_secs(self.config.http_timeout_secs);
2670        let interval = Duration::from_millis(self.config.retry_delay_initial_ms.max(1));
2671
2672        self.spawn_task("cancel_all_orders", async move {
2673            let confirmation = async {
2674                let reports = http_client
2675                    .cancel_all_orders(account_id, product_type, instrument_id)
2676                    .await
2677                    .with_context(|| {
2678                        format!("failed to cancel Bybit orders for {instrument_id}")
2679                    })?;
2680
2681                for report in reports {
2682                    if !report.order_status.is_closed() {
2683                        continue;
2684                    }
2685
2686                    if let Some(index) =
2687                        orders
2688                            .iter()
2689                            .position(|(client_order_id, venue_order_id, _)| {
2690                                venue_order_id.map_or(
2691                                    report.client_order_id == Some(*client_order_id),
2692                                    |id| id == report.venue_order_id,
2693                                )
2694                            })
2695                    {
2696                        let (client_order_id, _, strategy_id) = orders.swap_remove(index);
2697                        emit_cancel_confirmation(&emitter, strategy_id, client_order_id, &report);
2698                    }
2699                }
2700
2701                while !orders.is_empty() {
2702                    for index in (0..orders.len()).rev() {
2703                        let (client_order_id, venue_order_id, strategy_id) = orders[index];
2704                        if let Some(report) = http_client
2705                            .query_order(
2706                                account_id,
2707                                product_type,
2708                                instrument_id,
2709                                Some(client_order_id),
2710                                venue_order_id,
2711                            )
2712                            .await?
2713                            && report.order_status.is_closed()
2714                        {
2715                            orders.swap_remove(index);
2716                            emit_cancel_confirmation(
2717                                &emitter,
2718                                strategy_id,
2719                                client_order_id,
2720                                &report,
2721                            );
2722                        }
2723                    }
2724
2725                    if !orders.is_empty() {
2726                        tokio::time::sleep(interval).await;
2727                    }
2728                }
2729
2730                Ok(())
2731            };
2732
2733            tokio::time::timeout(timeout, confirmation)
2734                .await
2735                .context("timed out confirming Bybit cancel-all orders")?
2736        });
2737
2738        Ok(())
2739    }
2740
2741    fn batch_cancel_orders(&self, cmd: BatchCancelOrders) -> anyhow::Result<()> {
2742        if cmd.cancels.is_empty() {
2743            return Ok(());
2744        }
2745
2746        if self.config.environment == BybitEnvironment::Demo {
2747            for cancel in cmd.cancels {
2748                self.cancel_order(cancel)?;
2749            }
2750
2751            return Ok(());
2752        }
2753
2754        let instrument_id = cmd.instrument_id;
2755        let product_type = self.get_product_type_for_instrument(instrument_id);
2756        let emitter = self.emitter.clone();
2757        let clock = self.clock;
2758
2759        let raw_symbol = Ustr::from(extract_raw_symbol(instrument_id.symbol.as_str()));
2760
2761        let mut cancel_params = Vec::with_capacity(cmd.cancels.len());
2762        let strategy_ids: Vec<_> = cmd.cancels.iter().map(|c| c.strategy_id).collect();
2763        let client_order_ids: Vec<_> = cmd.cancels.iter().map(|c| c.client_order_id).collect();
2764        let command_ids: Vec<_> = cmd.cancels.iter().map(|c| c.command_id).collect();
2765        let venue_order_ids: Vec<_> = cmd.cancels.iter().map(|c| c.venue_order_id).collect();
2766
2767        for cancel in &cmd.cancels {
2768            cancel_params.push(BybitWsCancelOrderParams {
2769                category: product_type,
2770                symbol: raw_symbol,
2771                order_id: cancel.venue_order_id.map(|v| v.to_string()),
2772                order_link_id: Some(cancel.client_order_id.to_string()),
2773            });
2774        }
2775
2776        let ws_trade = self.ws_trade.clone();
2777        let dispatch_state = Arc::clone(&self.dispatch_state);
2778
2779        self.spawn_task("batch_cancel_orders", async move {
2780            let req_ids =
2781                BybitWebSocketClient::batch_request_ids(product_type, cancel_params.len());
2782            let chunk_limit = batch_send_limit(product_type);
2783
2784            for (req_id, ((chunk_cids, chunk_voids), chunk_commands)) in req_ids.iter().zip(
2785                client_order_ids
2786                    .chunks(chunk_limit)
2787                    .map(|chunk| chunk.to_vec())
2788                    .zip(
2789                        venue_order_ids
2790                            .chunks(chunk_limit)
2791                            .map(|chunk| chunk.to_vec()),
2792                    )
2793                    .zip(command_ids.chunks(chunk_limit)),
2794            ) {
2795                dispatch_state.pending_requests.insert(
2796                    req_id.clone(),
2797                    (
2798                        chunk_cids,
2799                        chunk_voids,
2800                        PendingOperation::Cancel,
2801                        chunk_commands.iter().copied().map(Some).collect(),
2802                    ),
2803                );
2804            }
2805
2806            if let Err(e) = ws_trade
2807                .batch_cancel_orders_with_ids(cancel_params, req_ids.clone())
2808                .await
2809            {
2810                for req_id in req_ids {
2811                    dispatch_state.pending_requests.remove(&req_id);
2812                }
2813                let reason = e.to_string();
2814                let ts_event = clock.get_time_ns();
2815
2816                for (((strategy_id, client_order_id), venue_order_id), command_id) in strategy_ids
2817                    .into_iter()
2818                    .zip(client_order_ids)
2819                    .zip(venue_order_ids)
2820                    .zip(command_ids)
2821                {
2822                    emitter.emit_order_cancel_denied_event(
2823                        strategy_id,
2824                        instrument_id,
2825                        client_order_id,
2826                        venue_order_id,
2827                        &reason,
2828                        ts_event,
2829                        Some(command_id),
2830                    );
2831                }
2832            }
2833            Ok(())
2834        });
2835
2836        Ok(())
2837    }
2838}
2839
2840fn validate_order(
2841    order: &OrderAny,
2842    product_type: BybitProductType,
2843) -> Result<(), OrderDeniedReason> {
2844    let (bybit_order_type, is_conditional) =
2845        BybitExecutionClient::map_order_type(order.order_type()).map_err(|_| {
2846            OrderDeniedReason::UnsupportedOrderType {
2847                order_type: order.order_type(),
2848            }
2849        })?;
2850
2851    map_time_in_force(
2852        bybit_order_type,
2853        Some(order.time_in_force()),
2854        Some(order.is_post_only()),
2855    )
2856    .map_err(OrderDeniedReason::UnsupportedTimeInForce)?;
2857
2858    if product_type == BybitProductType::Option && is_conditional {
2859        return Err(OrderDeniedReason::UnsupportedOrderType {
2860            order_type: order.order_type(),
2861        });
2862    }
2863
2864    Ok(())
2865}
2866
2867fn emit_cancel_confirmation(
2868    emitter: &ExecutionEventEmitter,
2869    strategy_id: StrategyId,
2870    client_order_id: ClientOrderId,
2871    report: &OrderStatusReport,
2872) {
2873    // Status reports can infer fills before the execution stream delivers them
2874    if report.order_status != OrderStatus::Canceled {
2875        return;
2876    }
2877
2878    let canceled = OrderCanceled::new(
2879        emitter.trader_id(),
2880        strategy_id,
2881        report.instrument_id,
2882        client_order_id,
2883        UUID4::new(),
2884        report.ts_last,
2885        report.ts_init,
2886        false,
2887        Some(report.venue_order_id),
2888        Some(report.account_id),
2889        None,
2890    );
2891    emitter.send_order_event(OrderEventAny::Canceled(canceled));
2892}
2893
2894fn classify_cancel_http_failure(error: &anyhow::Error) -> CommandFailure {
2895    if error
2896        .chain()
2897        .any(|cause| cause.downcast_ref::<BybitCancelOrderError>().is_some())
2898    {
2899        return CommandFailure::ambiguous(error.to_string());
2900    }
2901
2902    classify_http_failure(error)
2903}
2904
2905fn classify_modify_http_failure(error: &anyhow::Error) -> CommandFailure {
2906    if error
2907        .chain()
2908        .any(|cause| cause.downcast_ref::<BybitModifyOrderError>().is_some())
2909    {
2910        return CommandFailure::ambiguous(error.to_string());
2911    }
2912
2913    classify_http_failure(error)
2914}
2915
2916fn http_order_error_is_ambiguous(code: i32) -> bool {
2917    is_bybit_ambiguous_order_error_code(i64::from(code))
2918}
2919
2920fn classify_http_failure(error: &anyhow::Error) -> CommandFailure {
2921    let reason = error.to_string();
2922
2923    for cause in error.chain() {
2924        let Some(http_error) = cause.downcast_ref::<BybitHttpError>() else {
2925            continue;
2926        };
2927
2928        return match http_error {
2929            BybitHttpError::BybitError { error_code, .. }
2930                if http_order_error_is_ambiguous(*error_code) =>
2931            {
2932                CommandFailure::Ambiguous(reason)
2933            }
2934            BybitHttpError::BybitError { .. } => CommandFailure::VenueRejected(reason),
2935            BybitHttpError::MissingCredentials
2936            | BybitHttpError::ValidationError(_)
2937            | BybitHttpError::BuildError(_) => CommandFailure::NotSent(reason),
2938            BybitHttpError::JsonError(_)
2939            | BybitHttpError::Canceled(_)
2940            | BybitHttpError::NetworkError(_)
2941            | BybitHttpError::UnexpectedStatus { .. } => CommandFailure::Ambiguous(reason),
2942        };
2943    }
2944
2945    CommandFailure::NotSent(reason)
2946}
2947
2948fn cache_reconciliation_order_identity(
2949    account_id: AccountId,
2950    core: Option<&ExecutionClientCore>,
2951    state: &WsDispatchState,
2952    report: &OrderStatusReport,
2953    instruments: &AHashMap<Ustr, InstrumentAny>,
2954    emitter: &ExecutionEventEmitter,
2955) {
2956    let Some(client_order_id) = report.client_order_id else {
2957        if state.fast_execution
2958            && has_pending_fast_execution(report.venue_order_id, state)
2959            && let Some(instrument) = instruments.get(&report.instrument_id.symbol.inner())
2960        {
2961            drain_pending_fast_executions(
2962                report.venue_order_id,
2963                instrument,
2964                account_id,
2965                report.ts_init,
2966                state,
2967                emitter,
2968            );
2969        }
2970
2971        return;
2972    };
2973
2974    if !state.fast_execution {
2975        if report.order_status.is_closed() {
2976            cleanup_terminal_when_ready(client_order_id, report.filled_qty, state);
2977        } else if let Some(identity) = cached_order_identity(core, client_order_id, report) {
2978            state.order_identities.insert(client_order_id, identity);
2979        }
2980
2981        return;
2982    }
2983
2984    reconcile_fast_order_report(
2985        account_id,
2986        client_order_id,
2987        core,
2988        report,
2989        instruments,
2990        state,
2991        emitter,
2992    );
2993}
2994
2995fn reconcile_fast_order_report(
2996    account_id: AccountId,
2997    client_order_id: ClientOrderId,
2998    core: Option<&ExecutionClientCore>,
2999    report: &OrderStatusReport,
3000    instruments: &AHashMap<Ustr, InstrumentAny>,
3001    state: &WsDispatchState,
3002    emitter: &ExecutionEventEmitter,
3003) {
3004    let closed = report.order_status.is_closed();
3005    let has_pending = has_pending_fast_execution(report.venue_order_id, state);
3006    if !state.order_identities.contains_key(&client_order_id)
3007        && (!closed || has_pending)
3008        && let Some(identity) = cached_order_identity(core, client_order_id, report)
3009    {
3010        state.order_identities.insert(client_order_id, identity);
3011    }
3012
3013    let tracked = state.order_identities.contains_key(&client_order_id);
3014    if tracked {
3015        record_venue_order_id(client_order_id, report.venue_order_id, state);
3016    }
3017
3018    if let Some(instrument) = instruments.get(&report.instrument_id.symbol.inner()) {
3019        drain_pending_fast_executions(
3020            report.venue_order_id,
3021            instrument,
3022            account_id,
3023            report.ts_init,
3024            state,
3025            emitter,
3026        );
3027    }
3028
3029    if closed && cached_order_has_terminal_quantity(core, client_order_id, report.filled_qty) {
3030        cleanup_terminal(client_order_id, state);
3031        return;
3032    }
3033
3034    if tracked && closed {
3035        cleanup_terminal_when_ready(client_order_id, report.filled_qty, state);
3036    }
3037}
3038
3039fn cached_order_identity(
3040    core: Option<&ExecutionClientCore>,
3041    client_order_id: ClientOrderId,
3042    report: &OrderStatusReport,
3043) -> Option<OrderIdentity> {
3044    core.and_then(|core| {
3045        core.cache()
3046            .order(&client_order_id)
3047            .map(|order| OrderIdentity {
3048                instrument_id: report.instrument_id,
3049                strategy_id: order.strategy_id(),
3050                order_side: order.order_side(),
3051                order_type: order.order_type(),
3052                venue_position_id: report.venue_position_id,
3053            })
3054    })
3055}
3056
3057fn cached_order_has_terminal_quantity(
3058    core: Option<&ExecutionClientCore>,
3059    client_order_id: ClientOrderId,
3060    terminal_qty: Quantity,
3061) -> bool {
3062    let Some(core) = core else {
3063        return false;
3064    };
3065
3066    core.cache()
3067        .order(&client_order_id)
3068        .is_some_and(|order| order.is_closed() && order.filled_qty() >= terminal_qty)
3069}
3070
3071#[cfg(test)]
3072#[path = "../tests/integration/exec_client.rs"]
3073mod exec_client_tests;
3074
3075#[cfg(test)]
3076mod tests {
3077    use std::{
3078        cell::RefCell,
3079        rc::Rc,
3080        sync::atomic::{AtomicBool, Ordering},
3081        time::Duration,
3082    };
3083
3084    use axum::{
3085        Json, Router,
3086        routing::{get, post},
3087    };
3088    use nautilus_common::{
3089        cache::Cache,
3090        clients::ExecutionClient,
3091        messages::{
3092            ExecutionEvent,
3093            execution::{
3094                BatchCancelOrders, BatchModifyOrders, CancelAllOrders, CancelOrder,
3095                ExecutionReport, ModifyOrder, SubmitOrder, SubmitOrderList,
3096            },
3097        },
3098        testing::wait_until_async,
3099    };
3100    use nautilus_core::{Params, UUID4};
3101    use nautilus_live::ExecutionClientCore;
3102    use nautilus_model::{
3103        enums::{AccountType, OrderSide, OrderStatus, TimeInForce},
3104        events::OrderEventAny,
3105        identifiers::{
3106            ClientOrderId, OrderListId, PositionId, StrategyId, TradeId, TraderId, VenueOrderId,
3107        },
3108        instruments::stubs::crypto_perpetual_ethusdt,
3109        orders::{OrderList, builder::OrderTestBuilder, stubs::TestOrderEventStubs},
3110        types::Quantity,
3111    };
3112    use rstest::rstest;
3113
3114    use super::*;
3115    use crate::{
3116        common::{
3117            consts::{BYBIT_CLIENT_ID, BYBIT_VENUE},
3118            enums::{BybitMarketUnit, BybitTimeInForce},
3119            parse::parse_linear_instrument,
3120        },
3121        http::models::BybitInstrumentLinearResponse,
3122    };
3123
3124    fn test_execution_client() -> (BybitExecutionClient, Rc<RefCell<Cache>>) {
3125        let cache = Rc::new(RefCell::new(Cache::default()));
3126        let core = ExecutionClientCore::new(
3127            TraderId::from("TESTER-001"),
3128            *BYBIT_CLIENT_ID,
3129            *BYBIT_VENUE,
3130            OmsType::Netting,
3131            AccountId::from("BYBIT-001"),
3132            AccountType::Margin,
3133            None,
3134            cache.clone(),
3135        );
3136        let config = BybitExecutionClientConfig {
3137            api_key: Some("test_key".into()),
3138            api_secret: Some("test_secret".into()),
3139            ..Default::default()
3140        };
3141
3142        (BybitExecutionClient::new(core, config).unwrap(), cache)
3143    }
3144
3145    async fn wait_for_spawned_tasks(client: &BybitExecutionClient) {
3146        for _ in 0..20 {
3147            if client.pending_tasks.all_finished() {
3148                return;
3149            }
3150
3151            tokio::time::sleep(Duration::from_millis(25)).await;
3152        }
3153
3154        panic!("timed out waiting for spawned Bybit execution tasks");
3155    }
3156
3157    fn assert_next_submitted(
3158        rx: &mut tokio::sync::mpsc::UnboundedReceiver<ExecutionEvent>,
3159        client_order_id: ClientOrderId,
3160    ) {
3161        let event = rx.try_recv().expect("expected OrderSubmitted event");
3162        assert!(
3163            matches!(event, ExecutionEvent::Order(OrderEventAny::Submitted(ref submitted)) if submitted.client_order_id == client_order_id),
3164            "expected OrderSubmitted for {client_order_id}, was {event:?}",
3165        );
3166    }
3167
3168    fn assert_next_rejected(
3169        rx: &mut tokio::sync::mpsc::UnboundedReceiver<ExecutionEvent>,
3170        client_order_id: ClientOrderId,
3171    ) {
3172        let event = rx.try_recv().expect("expected OrderRejected event");
3173        assert!(
3174            matches!(event, ExecutionEvent::Order(OrderEventAny::Rejected(ref rejected))
3175                if rejected.client_order_id == client_order_id),
3176            "expected OrderRejected for {client_order_id}, was {event:?}",
3177        );
3178    }
3179
3180    fn assert_next_cancel_denied(
3181        rx: &mut tokio::sync::mpsc::UnboundedReceiver<ExecutionEvent>,
3182        client_order_id: ClientOrderId,
3183    ) {
3184        let event = rx.try_recv().expect("expected OrderCancelDenied event");
3185        assert!(
3186            matches!(event, ExecutionEvent::Order(OrderEventAny::CancelDenied(ref rejected))
3187                if rejected.client_order_id == client_order_id),
3188            "expected OrderCancelDenied for {client_order_id}, was {event:?}",
3189        );
3190    }
3191
3192    fn assert_next_modify_denied(
3193        rx: &mut tokio::sync::mpsc::UnboundedReceiver<ExecutionEvent>,
3194        client_order_id: ClientOrderId,
3195    ) {
3196        let event = rx.try_recv().expect("expected OrderModifyDenied event");
3197        assert!(
3198            matches!(event, ExecutionEvent::Order(OrderEventAny::ModifyDenied(ref rejected))
3199                if rejected.client_order_id == client_order_id),
3200            "expected OrderModifyDenied for {client_order_id}, was {event:?}",
3201        );
3202    }
3203
3204    fn cancel_command(client_order_id: ClientOrderId) -> CancelOrder {
3205        CancelOrder::new(
3206            TraderId::from("TESTER-001"),
3207            Some(*BYBIT_CLIENT_ID),
3208            StrategyId::from("S-001"),
3209            InstrumentId::from("BTCUSDT-LINEAR.BYBIT"),
3210            client_order_id,
3211            Some(VenueOrderId::from("venue-cancel-1")),
3212            UUID4::new(),
3213            UnixNanos::default(),
3214            None,
3215            None,
3216        )
3217    }
3218
3219    fn modify_command(client_order_id: ClientOrderId, params: Option<Params>) -> ModifyOrder {
3220        ModifyOrder::new(
3221            TraderId::from("TESTER-001"),
3222            Some(*BYBIT_CLIENT_ID),
3223            StrategyId::from("S-001"),
3224            InstrumentId::from("BTCUSDT-LINEAR.BYBIT"),
3225            client_order_id,
3226            Some(VenueOrderId::from("venue-modify-1")),
3227            Some(Quantity::from("1")),
3228            Some(Price::from("10001.00")),
3229            None,
3230            UUID4::new(),
3231            UnixNanos::default(),
3232            params,
3233            None,
3234        )
3235    }
3236
3237    #[rstest]
3238    fn test_cancel_http_failure_classification_matches_policy() {
3239        let venue_reject = anyhow::Error::from(BybitHttpError::BybitError {
3240            error_code: 110001,
3241            message: "Order does not exist".to_string(),
3242        });
3243        assert_eq!(
3244            classify_cancel_http_failure(&venue_reject),
3245            CommandFailure::VenueRejected(venue_reject.to_string()),
3246        );
3247
3248        let rate_limit = anyhow::Error::from(BybitHttpError::BybitError {
3249            error_code: 10006,
3250            message: "Too many visits".to_string(),
3251        });
3252        assert_eq!(
3253            classify_cancel_http_failure(&rate_limit),
3254            CommandFailure::Ambiguous(rate_limit.to_string()),
3255        );
3256        assert!(submit_rejection_reason(&rate_limit).is_none());
3257
3258        let post_lookup = anyhow::Error::from(BybitCancelOrderError::PostCancelLookup {
3259            source: anyhow::anyhow!("history lookup failed"),
3260        });
3261        assert_eq!(
3262            classify_cancel_http_failure(&post_lookup),
3263            CommandFailure::Ambiguous(post_lookup.to_string()),
3264        );
3265
3266        let transport = anyhow::Error::from(BybitHttpError::NetworkError(
3267            "connection closed".to_string(),
3268        ));
3269        assert_eq!(
3270            classify_cancel_http_failure(&transport),
3271            CommandFailure::Ambiguous(transport.to_string()),
3272        );
3273    }
3274
3275    #[rstest]
3276    #[case::window_start(4, 0)]
3277    #[case::window_end(5, 30)]
3278    fn test_repay_blackout_rejection_publishes_failed_result_inside_window(
3279        #[case] minute: u64,
3280        #[case] second: u64,
3281    ) {
3282        let now_ns = UnixNanos::from((100 * 3600 + minute * 60 + second) * 1_000_000_000);
3283
3284        let result = BybitExecutionClient::repay_blackout_rejection("ETH", Some("0.500"), now_ns)
3285            .expect("expected a rejection inside the blackout window");
3286
3287        assert_eq!(result.coin, "ETH");
3288        assert_eq!(result.amount.as_deref(), Some("0.500"));
3289        assert!(!result.success);
3290        assert_eq!(result.result_status, "FAIL");
3291        assert!(
3292            result
3293                .message
3294                .starts_with("Bybit repay blackout window (mm:04:00-mm:05:30 UTC); retry after ")
3295        );
3296        assert!(result.message.contains(":05:31"), "was {}", result.message);
3297        assert_eq!(result.ts_event, now_ns);
3298        assert_eq!(result.ts_init, now_ns);
3299    }
3300
3301    #[rstest]
3302    #[case::before_window(3, 59)]
3303    #[case::after_window(5, 31)]
3304    #[case::mid_hour(30, 0)]
3305    fn test_repay_blackout_rejection_allows_repayment_outside_window(
3306        #[case] minute: u64,
3307        #[case] second: u64,
3308    ) {
3309        let now_ns = UnixNanos::from((100 * 3600 + minute * 60 + second) * 1_000_000_000);
3310
3311        let result = BybitExecutionClient::repay_blackout_rejection("ETH", None, now_ns);
3312
3313        assert!(result.is_none());
3314    }
3315
3316    #[rstest]
3317    fn test_modify_http_failure_classification_matches_policy() {
3318        let venue_reject = anyhow::Error::from(BybitHttpError::BybitError {
3319            error_code: 110003,
3320            message: "Order price exceeds allowable range".to_string(),
3321        });
3322        assert_eq!(
3323            classify_modify_http_failure(&venue_reject),
3324            CommandFailure::VenueRejected(venue_reject.to_string()),
3325        );
3326
3327        let server_error = anyhow::Error::from(BybitHttpError::BybitError {
3328            error_code: 10016,
3329            message: "Server error".to_string(),
3330        });
3331        assert_eq!(
3332            classify_modify_http_failure(&server_error),
3333            CommandFailure::Ambiguous(server_error.to_string()),
3334        );
3335
3336        let post_lookup = anyhow::Error::from(BybitModifyOrderError::PostModifyLookup {
3337            source: anyhow::anyhow!("realtime lookup failed"),
3338        });
3339        assert_eq!(
3340            classify_modify_http_failure(&post_lookup),
3341            CommandFailure::Ambiguous(post_lookup.to_string()),
3342        );
3343
3344        let status = anyhow::Error::from(BybitHttpError::UnexpectedStatus {
3345            status: 503,
3346            body: "service unavailable".to_string(),
3347        });
3348        assert_eq!(
3349            classify_modify_http_failure(&status),
3350            CommandFailure::Ambiguous(status.to_string()),
3351        );
3352    }
3353
3354    #[rstest]
3355    #[case::visits(10006)]
3356    #[case::frequency_protection(10429)]
3357    fn test_rate_limit_http_order_failures_stay_ambiguous(#[case] code: i32) {
3358        let error = anyhow::Error::from(BybitHttpError::BybitError {
3359            error_code: code,
3360            message: "Too many visits".to_string(),
3361        });
3362
3363        let expected = CommandFailure::Ambiguous(error.to_string());
3364
3365        assert_eq!(classify_cancel_http_failure(&error), expected);
3366        assert_eq!(classify_modify_http_failure(&error), expected);
3367        assert!(submit_rejection_reason(&error).is_none());
3368    }
3369
3370    #[rstest]
3371    #[tokio::test]
3372    async fn test_ws_cancel_queue_failure_emits_cancel_denied() {
3373        let (mut client, _cache) = test_execution_client();
3374        let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel();
3375        client.emitter.set_sender(tx);
3376        client.ws_trade.close().await.unwrap();
3377        let client_order_id = ClientOrderId::from("O-CANCEL-WS-FAIL");
3378
3379        client
3380            .cancel_order(cancel_command(client_order_id))
3381            .unwrap();
3382        wait_for_spawned_tasks(&client).await;
3383
3384        assert_next_cancel_denied(&mut rx, client_order_id);
3385    }
3386
3387    #[rstest]
3388    #[tokio::test]
3389    async fn test_ws_modify_queue_failure_emits_modify_denied() {
3390        let (mut client, _cache) = test_execution_client();
3391        let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel();
3392        client.emitter.set_sender(tx);
3393        client.ws_trade.close().await.unwrap();
3394        let client_order_id = ClientOrderId::from("O-MODIFY-WS-FAIL");
3395
3396        client
3397            .modify_order(modify_command(client_order_id, None))
3398            .unwrap();
3399        wait_for_spawned_tasks(&client).await;
3400
3401        assert_next_modify_denied(&mut rx, client_order_id);
3402    }
3403
3404    #[rstest]
3405    #[tokio::test]
3406    async fn test_http_cancel_local_validation_failure_emits_cancel_denied() {
3407        let (mut client, _cache) = test_execution_client();
3408        let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel();
3409        client.emitter.set_sender(tx);
3410        client.config.environment = BybitEnvironment::Demo;
3411
3412        client
3413            .cancel_order(cancel_command(ClientOrderId::from(
3414                "O-CANCEL-LOCAL-VALIDATION",
3415            )))
3416            .unwrap();
3417        wait_for_spawned_tasks(&client).await;
3418
3419        assert_next_cancel_denied(&mut rx, ClientOrderId::from("O-CANCEL-LOCAL-VALIDATION"));
3420    }
3421
3422    #[rstest]
3423    #[tokio::test]
3424    async fn test_modify_local_validation_failure_emits_modify_denied() {
3425        let (mut client, _cache) = test_execution_client();
3426        let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel();
3427        client.emitter.set_sender(tx);
3428
3429        let params =
3430            Params::new([("order_iv".to_string(), serde_json::json!({ "bad": true }))].into());
3431
3432        client
3433            .modify_order(modify_command(
3434                ClientOrderId::from("O-MODIFY-LOCAL-VALIDATION"),
3435                Some(params),
3436            ))
3437            .unwrap();
3438
3439        assert_next_modify_denied(&mut rx, ClientOrderId::from("O-MODIFY-LOCAL-VALIDATION"));
3440    }
3441
3442    #[rstest]
3443    #[case(OrderType::Limit, false)]
3444    #[case(OrderType::Limit, true)]
3445    #[case(OrderType::Market, false)]
3446    #[case(OrderType::StopLimit, false)]
3447    #[case(OrderType::StopMarket, false)]
3448    #[case(OrderType::LimitIfTouched, false)]
3449    #[case(OrderType::MarketIfTouched, false)]
3450    #[tokio::test]
3451    async fn test_submit_order_unsupported_time_in_force_denied(
3452        #[case] order_type: OrderType,
3453        #[case] post_only: bool,
3454        #[values(
3455            BybitEnvironment::Demo,
3456            BybitEnvironment::Mainnet,
3457            BybitEnvironment::Testnet
3458        )]
3459        environment: BybitEnvironment,
3460        #[values(TimeInForce::Day, TimeInForce::AtTheOpen, TimeInForce::AtTheClose)]
3461        time_in_force: TimeInForce,
3462    ) {
3463        let (mut client, cache) = test_execution_client();
3464        let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel();
3465        client.emitter.set_sender(tx);
3466        client.config.environment = environment;
3467        let client_order_id = ClientOrderId::from("O-TIF-DENIED");
3468        let instrument_id = InstrumentId::from("BTCUSDT-LINEAR.BYBIT");
3469        let order = OrderTestBuilder::new(order_type)
3470            .instrument_id(instrument_id)
3471            .client_order_id(client_order_id)
3472            .side(OrderSide::Buy)
3473            .quantity(Quantity::from("0.02"))
3474            .price(Price::from("10000.00"))
3475            .trigger_price(Price::from("10000.00"))
3476            .time_in_force(time_in_force)
3477            .post_only(post_only)
3478            .build();
3479
3480        let command = SubmitOrder::new(
3481            order.trader_id(),
3482            Some(*BYBIT_CLIENT_ID),
3483            order.strategy_id(),
3484            instrument_id,
3485            client_order_id,
3486            order.init_event().clone(),
3487            None,
3488            None,
3489            None,
3490            UUID4::new(),
3491            UnixNanos::default(),
3492            None,
3493        );
3494        cache
3495            .borrow_mut()
3496            .add_order(order, None, None, false)
3497            .unwrap();
3498        let ts_before = client.clock.get_time_ns();
3499
3500        client.submit_order(command).unwrap();
3501
3502        let ts_after = client.clock.get_time_ns();
3503
3504        let ExecutionEvent::Order(OrderEventAny::Denied(event)) = rx.try_recv().unwrap() else {
3505            panic!("Expected OrderDenied before submission");
3506        };
3507
3508        assert_eq!(event.trader_id, TraderId::from("TESTER-001"));
3509        assert_eq!(event.strategy_id, StrategyId::from("S-001"));
3510        assert_eq!(event.instrument_id, instrument_id);
3511        assert_eq!(event.client_order_id, client_order_id);
3512        assert_eq!(
3513            event.reason.as_str(),
3514            format!("UNSUPPORTED_TIME_IN_FORCE: {time_in_force}")
3515        );
3516        assert!(event.ts_event >= ts_before && event.ts_event <= ts_after);
3517        assert_eq!(event.ts_init, event.ts_event);
3518        assert_eq!(event.causation_id, None);
3519        assert_eq!(
3520            rx.try_recv().unwrap_err(),
3521            tokio::sync::mpsc::error::TryRecvError::Empty
3522        );
3523        assert!(client.pending_tasks.is_empty());
3524        assert!(client.dispatch_state.order_identities.is_empty());
3525        assert!(client.dispatch_state.order_snapshots.is_empty());
3526        assert!(client.dispatch_state.pending_requests.is_empty());
3527    }
3528
3529    #[rstest]
3530    #[case(OrderType::Limit, false)]
3531    #[case(OrderType::Limit, true)]
3532    #[case(OrderType::Market, false)]
3533    #[tokio::test]
3534    async fn test_submit_order_list_unsupported_time_in_force_denied(
3535        #[case] order_type: OrderType,
3536        #[case] post_only: bool,
3537        #[values(
3538            BybitEnvironment::Demo,
3539            BybitEnvironment::Mainnet,
3540            BybitEnvironment::Testnet
3541        )]
3542        environment: BybitEnvironment,
3543        #[values(TimeInForce::Day, TimeInForce::AtTheOpen, TimeInForce::AtTheClose)]
3544        time_in_force: TimeInForce,
3545    ) {
3546        let (mut client, cache) = test_execution_client();
3547        let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel();
3548        client.emitter.set_sender(tx);
3549        client.config.environment = environment;
3550        let instrument_id = InstrumentId::from("BTCUSDT-LINEAR.BYBIT");
3551        let client_order_ids = [
3552            ClientOrderId::from("O-TIF-VALID"),
3553            ClientOrderId::from("O-TIF-DENIED"),
3554        ];
3555        let mut inits = Vec::new();
3556
3557        for (cid, tif) in client_order_ids
3558            .into_iter()
3559            .zip([TimeInForce::Gtc, time_in_force])
3560        {
3561            let order = OrderTestBuilder::new(order_type)
3562                .instrument_id(instrument_id)
3563                .client_order_id(cid)
3564                .side(OrderSide::Sell)
3565                .quantity(Quantity::from("0.03"))
3566                .price(Price::from("12000.00"))
3567                .time_in_force(tif)
3568                .post_only(post_only)
3569                .build();
3570            inits.push(order.init_event().clone());
3571            cache
3572                .borrow_mut()
3573                .add_order(order, None, None, false)
3574                .unwrap();
3575        }
3576
3577        let list_id = OrderListId::from("OL-TIF-DENIED");
3578
3579        let order_list = OrderList::new(
3580            list_id,
3581            instrument_id,
3582            StrategyId::from("S-001"),
3583            client_order_ids.to_vec(),
3584            UnixNanos::default(),
3585        );
3586
3587        let command = SubmitOrderList::new(
3588            TraderId::from("TESTER-001"),
3589            Some(*BYBIT_CLIENT_ID),
3590            StrategyId::from("S-001"),
3591            order_list,
3592            inits,
3593            None,
3594            None,
3595            None,
3596            UUID4::new(),
3597            UnixNanos::default(),
3598            None,
3599        );
3600        let ts_before = client.clock.get_time_ns();
3601
3602        client.submit_order_list(command).unwrap();
3603
3604        let ts_after = client.clock.get_time_ns();
3605
3606        for (cid, reason) in client_order_ids.into_iter().zip([
3607            format!("ORDER_LIST_DENIED: {list_id}"),
3608            format!("UNSUPPORTED_TIME_IN_FORCE: {time_in_force}"),
3609        ]) {
3610            let ExecutionEvent::Order(OrderEventAny::Denied(event)) = rx.try_recv().unwrap() else {
3611                panic!("Expected OrderDenied before any list leg submission");
3612            };
3613
3614            assert_eq!(event.trader_id, TraderId::from("TESTER-001"));
3615            assert_eq!(event.strategy_id, StrategyId::from("S-001"));
3616            assert_eq!(event.instrument_id, instrument_id);
3617            assert_eq!(event.client_order_id, cid);
3618            assert_eq!(event.reason.as_str(), reason);
3619            assert!(event.ts_event >= ts_before && event.ts_event <= ts_after);
3620            assert_eq!(event.ts_init, event.ts_event);
3621            assert_eq!(event.causation_id, None);
3622        }
3623
3624        assert_eq!(
3625            rx.try_recv().unwrap_err(),
3626            tokio::sync::mpsc::error::TryRecvError::Empty
3627        );
3628        assert!(client.pending_tasks.is_empty());
3629        assert!(client.dispatch_state.order_identities.is_empty());
3630        assert!(client.dispatch_state.order_snapshots.is_empty());
3631        assert!(client.dispatch_state.pending_requests.is_empty());
3632    }
3633
3634    #[rstest]
3635    #[tokio::test]
3636    async fn test_ws_submit_queue_failure_emits_order_rejected() {
3637        let (mut client, cache) = test_execution_client();
3638        let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel();
3639        client.emitter.set_sender(tx);
3640
3641        let client_order_id = ClientOrderId::from("O-WS-SEND-FAIL");
3642        let instrument_id = InstrumentId::from("BTCUSDT-LINEAR.BYBIT");
3643        let mut builder = OrderTestBuilder::new(OrderType::Limit);
3644        let order = builder
3645            .instrument_id(instrument_id)
3646            .client_order_id(client_order_id)
3647            .side(OrderSide::Buy)
3648            .quantity(Quantity::from("1"))
3649            .price(Price::from("10000.00"))
3650            .build();
3651        let init = order.init_event().clone();
3652        let trader_id = order.trader_id();
3653        let strategy_id = order.strategy_id();
3654
3655        cache
3656            .borrow_mut()
3657            .add_order(order, None, Some(*BYBIT_CLIENT_ID), false)
3658            .unwrap();
3659
3660        let command = SubmitOrder::new(
3661            trader_id,
3662            Some(*BYBIT_CLIENT_ID),
3663            strategy_id,
3664            instrument_id,
3665            client_order_id,
3666            init,
3667            None,
3668            None,
3669            None,
3670            UUID4::new(),
3671            UnixNanos::default(),
3672            None, // correlation_id
3673        );
3674
3675        client.submit_order(command).unwrap();
3676
3677        assert_next_submitted(&mut rx, client_order_id);
3678        wait_for_spawned_tasks(&client).await;
3679
3680        assert!(
3681            !client
3682                .dispatch_state
3683                .order_identities
3684                .contains_key(&client_order_id)
3685        );
3686        assert!(
3687            !client
3688                .dispatch_state
3689                .order_snapshots
3690                .contains_key(&client_order_id)
3691        );
3692        assert_next_rejected(&mut rx, client_order_id);
3693    }
3694
3695    #[rstest]
3696    #[tokio::test]
3697    async fn test_ws_submit_order_list_queue_failure_emits_order_rejected() {
3698        let (mut client, cache) = test_execution_client();
3699        let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel();
3700        client.emitter.set_sender(tx);
3701
3702        let instrument_id = InstrumentId::from("BTCUSDT-LINEAR.BYBIT");
3703        let strategy_id = StrategyId::from("S-001");
3704        let client_order_id_1 = ClientOrderId::from("O-WS-LIST-SEND-FAIL-1");
3705        let client_order_id_2 = ClientOrderId::from("O-WS-LIST-SEND-FAIL-2");
3706
3707        let mut builder_1 = OrderTestBuilder::new(OrderType::Limit);
3708        let order_1 = builder_1
3709            .strategy_id(strategy_id)
3710            .instrument_id(instrument_id)
3711            .client_order_id(client_order_id_1)
3712            .side(OrderSide::Buy)
3713            .quantity(Quantity::from("1"))
3714            .price(Price::from("10000.00"))
3715            .build();
3716        let init_1 = order_1.init_event().clone();
3717        let trader_id = order_1.trader_id();
3718
3719        let mut builder_2 = OrderTestBuilder::new(OrderType::Limit);
3720        let order_2 = builder_2
3721            .strategy_id(strategy_id)
3722            .instrument_id(instrument_id)
3723            .client_order_id(client_order_id_2)
3724            .side(OrderSide::Sell)
3725            .quantity(Quantity::from("1"))
3726            .price(Price::from("10001.00"))
3727            .build();
3728        let init_2 = order_2.init_event().clone();
3729
3730        cache
3731            .borrow_mut()
3732            .add_order(order_1, None, Some(*BYBIT_CLIENT_ID), false)
3733            .unwrap();
3734        cache
3735            .borrow_mut()
3736            .add_order(order_2, None, Some(*BYBIT_CLIENT_ID), false)
3737            .unwrap();
3738
3739        let order_list = OrderList::new(
3740            OrderListId::from("OL-WS-SEND-FAIL"),
3741            instrument_id,
3742            strategy_id,
3743            vec![client_order_id_1, client_order_id_2],
3744            UnixNanos::default(),
3745        );
3746        let command = SubmitOrderList::new(
3747            trader_id,
3748            Some(*BYBIT_CLIENT_ID),
3749            strategy_id,
3750            order_list,
3751            vec![init_1, init_2],
3752            None,
3753            None,
3754            None,
3755            UUID4::new(),
3756            UnixNanos::default(),
3757            None, // correlation_id
3758        );
3759
3760        client.submit_order_list(command).unwrap();
3761
3762        assert_next_submitted(&mut rx, client_order_id_1);
3763        assert_next_submitted(&mut rx, client_order_id_2);
3764        wait_for_spawned_tasks(&client).await;
3765
3766        for client_order_id in [client_order_id_1, client_order_id_2] {
3767            assert!(
3768                !client
3769                    .dispatch_state
3770                    .order_identities
3771                    .contains_key(&client_order_id)
3772            );
3773            assert!(
3774                !client
3775                    .dispatch_state
3776                    .order_snapshots
3777                    .contains_key(&client_order_id)
3778            );
3779            assert_next_rejected(&mut rx, client_order_id);
3780        }
3781    }
3782
3783    fn sample_order_status_report(
3784        client_order_id: ClientOrderId,
3785        instrument_id: InstrumentId,
3786        order_status: OrderStatus,
3787        venue_position_id: Option<PositionId>,
3788    ) -> OrderStatusReport {
3789        let mut report = OrderStatusReport::new(
3790            AccountId::from("BYBIT-001"),
3791            instrument_id,
3792            Some(client_order_id),
3793            VenueOrderId::from("BYBIT-ORDER-001"),
3794            OrderSide::Buy.into(),
3795            OrderType::Limit,
3796            TimeInForce::Gtc,
3797            order_status,
3798            Quantity::from("1"),
3799            Quantity::from("0"),
3800            UnixNanos::default(),
3801            UnixNanos::default(),
3802            UnixNanos::default(),
3803            None,
3804        );
3805        report.venue_position_id = venue_position_id;
3806        report
3807    }
3808
3809    #[rstest]
3810    fn test_cache_reconciliation_order_identity_caches_and_clears_hedge_report() {
3811        let (client, cache) = test_execution_client();
3812        let client_order_id = ClientOrderId::from("O-HEDGE-RECON");
3813        let instrument_id = InstrumentId::from("BTCUSDT-LINEAR.BYBIT");
3814        let venue_position_id = PositionId::from("BTCUSDT-LINEAR.BYBIT-LONG");
3815        let mut builder = OrderTestBuilder::new(OrderType::Limit);
3816        let order = builder
3817            .instrument_id(instrument_id)
3818            .client_order_id(client_order_id)
3819            .side(OrderSide::Buy)
3820            .quantity(Quantity::from("1"))
3821            .price(Price::from("10000.00"))
3822            .build();
3823        cache
3824            .borrow_mut()
3825            .add_order(order.clone(), None, None, false)
3826            .unwrap();
3827
3828        let report = sample_order_status_report(
3829            client_order_id,
3830            instrument_id,
3831            OrderStatus::Accepted,
3832            Some(venue_position_id),
3833        );
3834        cache_reconciliation_order_identity(
3835            client.core.account_id,
3836            Some(&client.core),
3837            &client.dispatch_state,
3838            &report,
3839            &client.instruments_cache,
3840            &client.emitter,
3841        );
3842
3843        {
3844            let identity = client
3845                .dispatch_state
3846                .order_identities
3847                .get(&client_order_id)
3848                .unwrap();
3849            assert_eq!(identity.instrument_id, instrument_id);
3850            assert_eq!(identity.strategy_id, order.strategy_id());
3851            assert_eq!(identity.order_side, order.order_side());
3852            assert_eq!(identity.order_type, order.order_type());
3853            assert_eq!(identity.venue_position_id, Some(venue_position_id));
3854        }
3855
3856        let terminal_report = sample_order_status_report(
3857            client_order_id,
3858            instrument_id,
3859            OrderStatus::Filled,
3860            Some(venue_position_id),
3861        );
3862        cache_reconciliation_order_identity(
3863            client.core.account_id,
3864            Some(&client.core),
3865            &client.dispatch_state,
3866            &terminal_report,
3867            &client.instruments_cache,
3868            &client.emitter,
3869        );
3870
3871        assert!(
3872            client
3873                .dispatch_state
3874                .order_identities
3875                .get(&client_order_id)
3876                .is_none()
3877        );
3878    }
3879
3880    #[rstest]
3881    fn test_cache_reconciliation_order_identity_defers_fast_terminal_cleanup() {
3882        let (mut client, cache) = test_execution_client();
3883        Arc::get_mut(&mut client.dispatch_state)
3884            .unwrap()
3885            .fast_execution = true;
3886        let client_order_id = ClientOrderId::from("O-FAST-RECON");
3887        let instrument_id = InstrumentId::from("BTCUSDT-LINEAR.BYBIT");
3888        let order = OrderTestBuilder::new(OrderType::Limit)
3889            .instrument_id(instrument_id)
3890            .client_order_id(client_order_id)
3891            .side(OrderSide::Buy)
3892            .quantity(Quantity::from("0.5"))
3893            .price(Price::from("10000.00"))
3894            .build();
3895        cache
3896            .borrow_mut()
3897            .add_order(order, None, None, false)
3898            .unwrap();
3899        let accepted =
3900            sample_order_status_report(client_order_id, instrument_id, OrderStatus::Accepted, None);
3901        cache_reconciliation_order_identity(
3902            client.core.account_id,
3903            Some(&client.core),
3904            &client.dispatch_state,
3905            &accepted,
3906            &client.instruments_cache,
3907            &client.emitter,
3908        );
3909        let mut terminal =
3910            sample_order_status_report(client_order_id, instrument_id, OrderStatus::Filled, None);
3911        terminal.filled_qty = Quantity::from("0.5");
3912
3913        cache_reconciliation_order_identity(
3914            client.core.account_id,
3915            Some(&client.core),
3916            &client.dispatch_state,
3917            &terminal,
3918            &client.instruments_cache,
3919            &client.emitter,
3920        );
3921
3922        assert!(
3923            client
3924                .dispatch_state
3925                .order_identities
3926                .contains_key(&client_order_id)
3927        );
3928        assert_eq!(
3929            *client
3930                .dispatch_state
3931                .terminal_order_quantities
3932                .get(&client_order_id)
3933                .unwrap(),
3934            Quantity::from("0.5")
3935        );
3936        assert_eq!(
3937            client
3938                .dispatch_state
3939                .order_venue_ids
3940                .get(&client_order_id)
3941                .map(|id| *id),
3942            Some(terminal.venue_order_id)
3943        );
3944    }
3945
3946    #[rstest]
3947    #[case::nonterminal(true)]
3948    #[case::terminal_cached_order(false)]
3949    fn test_cache_reconciliation_recovers_fast_fill_without_recreating_state(
3950        #[case] recover_open: bool,
3951    ) {
3952        let (mut client, cache) = test_execution_client();
3953        Arc::get_mut(&mut client.dispatch_state)
3954            .unwrap()
3955            .fast_execution = true;
3956        let json = crate::common::testing::load_test_json("http_get_instruments_linear.json");
3957        let response: BybitInstrumentLinearResponse = serde_json::from_str(&json).unwrap();
3958        let instrument = parse_linear_instrument(
3959            &response.result.list[1],
3960            UnixNanos::default(),
3961            UnixNanos::default(),
3962        )
3963        .unwrap();
3964        let instrument_id = instrument.id();
3965        let mut instruments = AHashMap::new();
3966        instruments.insert(instrument_id.symbol.inner(), instrument.clone());
3967        client.instruments_cache = Arc::new(instruments);
3968        let client_order_id = ClientOrderId::from("O-FAST-DRAIN");
3969        let order = OrderTestBuilder::new(OrderType::Limit)
3970            .instrument_id(instrument_id)
3971            .client_order_id(client_order_id)
3972            .side(OrderSide::Buy)
3973            .quantity(Quantity::from("0.5"))
3974            .price(Price::from("3000.00"))
3975            .build();
3976        cache
3977            .borrow_mut()
3978            .add_order(order, None, None, false)
3979            .unwrap();
3980        let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel();
3981        client.emitter.set_sender(tx);
3982        let accepted =
3983            sample_order_status_report(client_order_id, instrument_id, OrderStatus::Accepted, None);
3984        let json = crate::common::testing::load_test_json("ws_account_execution_fast.json");
3985        let mut fast: crate::websocket::messages::BybitWsAccountExecutionFastMsg =
3986            serde_json::from_str(&json).unwrap();
3987        fast.data[0].category = BybitProductType::Linear;
3988        fast.data[0].symbol = Ustr::from("ETHUSDT");
3989        fast.data[0].order_id = accepted.venue_order_id.as_str().into();
3990        fast.data[0].order_link_id = Ustr::from("");
3991        fast.data[0].exec_price = "3000.00".to_string();
3992        fast.data[0].exec_qty = "0.5".to_string();
3993        dispatch_ws_message(
3994            &crate::websocket::messages::BybitWsMessage::AccountExecutionFast(fast),
3995            client.core.account_id,
3996            &client.instruments_cache,
3997            client.clock,
3998            &client.dispatch_state,
3999            &client.emitter,
4000        );
4001        assert!(rx.try_recv().is_err());
4002        assert!(
4003            !client
4004                .dispatch_state
4005                .order_identities
4006                .contains_key(&client_order_id)
4007        );
4008        assert!(
4009            client
4010                .instruments_cache
4011                .contains_key(&instrument_id.symbol.inner())
4012        );
4013
4014        if recover_open {
4015            cache_reconciliation_order_identity(
4016                client.core.account_id,
4017                Some(&client.core),
4018                &client.dispatch_state,
4019                &accepted,
4020                &client.instruments_cache,
4021                &client.emitter,
4022            );
4023
4024            assert!(matches!(
4025                rx.try_recv().unwrap(),
4026                ExecutionEvent::Order(OrderEventAny::Accepted(_))
4027            ));
4028
4029            match rx.try_recv().unwrap() {
4030                ExecutionEvent::Report(ExecutionReport::Fill(report)) => {
4031                    assert_eq!(report.client_order_id, Some(client_order_id));
4032                    assert_eq!(report.last_qty, Quantity::from("0.5"));
4033                }
4034                other => panic!("Expected FillReport, found {other:?}"),
4035            }
4036
4037            assert!(rx.try_recv().is_err());
4038        }
4039
4040        let order = cache.borrow().order(&client_order_id).unwrap().clone();
4041        let accepted_event =
4042            TestOrderEventStubs::accepted(&order, client.core.account_id, accepted.venue_order_id);
4043        cache.borrow_mut().update_order(&accepted_event).unwrap();
4044        let order = cache.borrow().order(&client_order_id).unwrap().clone();
4045        let filled = TestOrderEventStubs::filled(
4046            &order,
4047            &instrument,
4048            Some(TradeId::from("rest-fill-1")),
4049            None,
4050            Some(Price::from("3000.00")),
4051            Some(Quantity::from("0.5")),
4052            None,
4053            None,
4054            None,
4055            Some(client.core.account_id),
4056        );
4057        cache.borrow_mut().update_order(&filled).unwrap();
4058        let mut terminal = accepted;
4059        terminal.order_status = OrderStatus::Filled;
4060        terminal.filled_qty = Quantity::from("0.5");
4061
4062        for _ in 0..2 {
4063            cache_reconciliation_order_identity(
4064                client.core.account_id,
4065                Some(&client.core),
4066                &client.dispatch_state,
4067                &terminal,
4068                &client.instruments_cache,
4069                &client.emitter,
4070            );
4071        }
4072
4073        if !recover_open {
4074            assert!(matches!(
4075                rx.try_recv().unwrap(),
4076                ExecutionEvent::Order(OrderEventAny::Accepted(_))
4077            ));
4078
4079            match rx.try_recv().unwrap() {
4080                ExecutionEvent::Report(ExecutionReport::Fill(report)) => {
4081                    assert_eq!(report.client_order_id, Some(client_order_id));
4082                    assert_eq!(report.last_qty, Quantity::from("0.5"));
4083                }
4084                other => panic!("Expected FillReport, found {other:?}"),
4085            }
4086        }
4087
4088        assert!(rx.try_recv().is_err());
4089        assert!(
4090            !client
4091                .dispatch_state
4092                .order_identities
4093                .contains_key(&client_order_id)
4094        );
4095        assert!(
4096            !client
4097                .dispatch_state
4098                .order_venue_ids
4099                .contains_key(&client_order_id)
4100        );
4101        assert!(
4102            !client
4103                .dispatch_state
4104                .venue_order_ids
4105                .contains_key(&terminal.venue_order_id)
4106        );
4107        assert!(
4108            !client
4109                .dispatch_state
4110                .terminal_order_quantities
4111                .contains_key(&client_order_id)
4112        );
4113    }
4114
4115    #[rstest]
4116    #[tokio::test]
4117    async fn test_teardown_flushes_pending_fast_execution() {
4118        let (mut client, _cache) = test_execution_client();
4119        Arc::get_mut(&mut client.dispatch_state)
4120            .unwrap()
4121            .fast_execution = true;
4122        let json = crate::common::testing::load_test_json("http_get_instruments_linear.json");
4123        let response: BybitInstrumentLinearResponse = serde_json::from_str(&json).unwrap();
4124        let instrument = parse_linear_instrument(
4125            &response.result.list[1],
4126            UnixNanos::default(),
4127            UnixNanos::default(),
4128        )
4129        .unwrap();
4130        let instrument_id = instrument.id();
4131        let mut instruments = AHashMap::new();
4132        instruments.insert(instrument_id.symbol.inner(), instrument);
4133        client.instruments_cache = Arc::new(instruments);
4134        let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel();
4135        client.emitter.set_sender(tx);
4136        let json = crate::common::testing::load_test_json("ws_account_execution_fast.json");
4137        let mut fast: crate::websocket::messages::BybitWsAccountExecutionFastMsg =
4138            serde_json::from_str(&json).unwrap();
4139        fast.data[0].category = BybitProductType::Linear;
4140        fast.data[0].symbol = Ustr::from("ETHUSDT");
4141        fast.data[0].order_id = Ustr::from("BYBIT-ORDER-001");
4142        fast.data[0].order_link_id = Ustr::from("");
4143        fast.data[0].exec_price = "3000.00".to_string();
4144        fast.data[0].exec_qty = "0.5".to_string();
4145        dispatch_ws_message(
4146            &crate::websocket::messages::BybitWsMessage::AccountExecutionFast(fast),
4147            client.core.account_id,
4148            &client.instruments_cache,
4149            client.clock,
4150            &client.dispatch_state,
4151            &client.emitter,
4152        );
4153        assert!(rx.try_recv().is_err());
4154
4155        client.teardown_partial_connect().await.unwrap();
4156
4157        match rx.try_recv().unwrap() {
4158            ExecutionEvent::Report(ExecutionReport::Fill(report)) => {
4159                assert_eq!(report.client_order_id, None);
4160                assert_eq!(report.last_qty, Quantity::from("0.5"));
4161            }
4162            other => panic!("Expected FillReport, found {other:?}"),
4163        }
4164
4165        assert!(rx.try_recv().is_err());
4166    }
4167
4168    #[rstest]
4169    #[tokio::test]
4170    async fn test_refresh_execution_fee_rates_retains_previous_on_failure() {
4171        let fee_response: serde_json::Value = serde_json::from_str(
4172            &crate::common::testing::load_test_json("http_get_fee_rate.json"),
4173        )
4174        .unwrap();
4175        let failing = Arc::new(AtomicBool::new(false));
4176        let response = fee_response.clone();
4177        let failure_flag = Arc::clone(&failing);
4178
4179        let router = Router::new().route(
4180            "/v5/account/fee-rate",
4181            get(move || {
4182                let response = response.clone();
4183                let failing = Arc::clone(&failure_flag);
4184                async move {
4185                    if failing.load(Ordering::Relaxed) {
4186                        Json(serde_json::json!({
4187                            "retCode": 10001,
4188                            "retMsg": "fee rate request failed",
4189                            "result": {},
4190                            "retExtInfo": {},
4191                            "time": 1697673900000i64
4192                        }))
4193                    } else {
4194                        Json(response)
4195                    }
4196                }
4197            }),
4198        );
4199
4200        let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
4201        let addr = listener.local_addr().unwrap();
4202        let server = tokio::spawn(async move { axum::serve(listener, router).await.unwrap() });
4203        let (mut client, _cache) = test_execution_client();
4204        client.http_client = BybitHttpClient::with_credentials(
4205            "test_key".to_string(),
4206            "test_secret".to_string(),
4207            Some(format!("http://{addr}")),
4208            1,
4209            0,
4210            10,
4211            10,
4212            5_000,
4213            None,
4214        )
4215        .unwrap();
4216        let json = crate::common::testing::load_test_json("http_get_instruments_linear.json");
4217        let response: BybitInstrumentLinearResponse = serde_json::from_str(&json).unwrap();
4218        let instrument = parse_linear_instrument(
4219            &response.result.list[1],
4220            UnixNanos::default(),
4221            UnixNanos::default(),
4222        )
4223        .unwrap();
4224        let instrument_id = instrument.id();
4225        let mut instruments = AHashMap::new();
4226        instruments.insert(instrument_id.symbol.inner(), instrument);
4227        let instruments = Arc::new(instruments);
4228
4229        BybitExecutionClient::refresh_execution_fee_rates(
4230            client.http_client.clone(),
4231            vec![BybitProductType::Linear],
4232            Arc::clone(&instruments),
4233            Arc::clone(&client.dispatch_state),
4234        )
4235        .await;
4236        let previous = *client.dispatch_state.fee_rates.get(&instrument_id).unwrap();
4237        failing.store(true, Ordering::Relaxed);
4238        BybitExecutionClient::refresh_execution_fee_rates(
4239            client.http_client.clone(),
4240            vec![BybitProductType::Linear],
4241            instruments,
4242            Arc::clone(&client.dispatch_state),
4243        )
4244        .await;
4245
4246        assert_eq!(
4247            *client.dispatch_state.fee_rates.get(&instrument_id).unwrap(),
4248            previous
4249        );
4250        server.abort();
4251    }
4252
4253    #[rstest]
4254    fn test_rest_recovery_cleans_after_core_applies_terminal_report() {
4255        let (mut client, cache) = test_execution_client();
4256        Arc::get_mut(&mut client.dispatch_state)
4257            .unwrap()
4258            .fast_execution = true;
4259        let json = crate::common::testing::load_test_json("http_get_instruments_linear.json");
4260        let response: BybitInstrumentLinearResponse = serde_json::from_str(&json).unwrap();
4261        let instrument = parse_linear_instrument(
4262            &response.result.list[1],
4263            UnixNanos::default(),
4264            UnixNanos::default(),
4265        )
4266        .unwrap();
4267        let instrument_id = instrument.id();
4268        let mut instruments = AHashMap::new();
4269        instruments.insert(instrument_id.symbol.inner(), instrument.clone());
4270        client.instruments_cache = Arc::new(instruments);
4271        let client_order_id = ClientOrderId::from("O-REST-ONLY");
4272        let venue_order_id = VenueOrderId::from("BYBIT-ORDER-001");
4273        let account_id = client.core.account_id;
4274        client.dispatch_state.order_identities.insert(
4275            client_order_id,
4276            OrderIdentity {
4277                instrument_id,
4278                strategy_id: StrategyId::from("S-001"),
4279                order_side: OrderSide::Buy,
4280                order_type: OrderType::Limit,
4281                venue_position_id: None,
4282            },
4283        );
4284
4285        let mut order = OrderTestBuilder::new(OrderType::Limit)
4286            .instrument_id(instrument_id)
4287            .client_order_id(client_order_id)
4288            .side(OrderSide::Buy)
4289            .quantity(Quantity::from("0.5"))
4290            .price(Price::from("3000.00"))
4291            .build();
4292        order
4293            .apply(TestOrderEventStubs::accepted(
4294                &order,
4295                account_id,
4296                venue_order_id,
4297            ))
4298            .unwrap();
4299        cache
4300            .borrow_mut()
4301            .add_order(order, None, None, false)
4302            .unwrap();
4303        let mut terminal =
4304            sample_order_status_report(client_order_id, instrument_id, OrderStatus::Filled, None);
4305        terminal.filled_qty = Quantity::from("0.5");
4306
4307        cache_reconciliation_order_identity(
4308            client.core.account_id,
4309            Some(&client.core),
4310            &client.dispatch_state,
4311            &terminal,
4312            &client.instruments_cache,
4313            &client.emitter,
4314        );
4315
4316        assert!(
4317            client
4318                .dispatch_state
4319                .order_identities
4320                .contains_key(&client_order_id)
4321        );
4322
4323        let order = cache.borrow().order(&client_order_id).unwrap().clone();
4324        let filled = TestOrderEventStubs::filled(
4325            &order,
4326            &instrument,
4327            Some(TradeId::from("rest-fill-1")),
4328            None,
4329            Some(Price::from("3000.00")),
4330            Some(Quantity::from("0.5")),
4331            None,
4332            None,
4333            None,
4334            Some(account_id),
4335        );
4336        cache.borrow_mut().update_order(&filled).unwrap();
4337        cache_reconciliation_order_identity(
4338            client.core.account_id,
4339            Some(&client.core),
4340            &client.dispatch_state,
4341            &terminal,
4342            &client.instruments_cache,
4343            &client.emitter,
4344        );
4345
4346        assert!(client.dispatch_state.order_identities.is_empty());
4347        assert!(client.dispatch_state.order_venue_ids.is_empty());
4348        assert!(client.dispatch_state.venue_order_ids.is_empty());
4349        assert!(client.dispatch_state.terminal_order_quantities.is_empty());
4350    }
4351
4352    #[rstest]
4353    fn test_cache_reconciliation_external_order_drains_pending_fill() {
4354        let (mut client, _cache) = test_execution_client();
4355        Arc::get_mut(&mut client.dispatch_state)
4356            .unwrap()
4357            .fast_execution = true;
4358        let json = crate::common::testing::load_test_json("http_get_instruments_linear.json");
4359        let response: BybitInstrumentLinearResponse = serde_json::from_str(&json).unwrap();
4360        let instrument = parse_linear_instrument(
4361            &response.result.list[1],
4362            UnixNanos::default(),
4363            UnixNanos::default(),
4364        )
4365        .unwrap();
4366        let instrument_id = instrument.id();
4367        let mut instruments = AHashMap::new();
4368        instruments.insert(instrument_id.symbol.inner(), instrument);
4369        client.instruments_cache = Arc::new(instruments);
4370        let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel();
4371        client.emitter.set_sender(tx);
4372        let mut report = sample_order_status_report(
4373            ClientOrderId::from("unused"),
4374            instrument_id,
4375            OrderStatus::Accepted,
4376            None,
4377        );
4378        report.client_order_id = None;
4379        let json = crate::common::testing::load_test_json("ws_account_execution_fast.json");
4380        let mut fast: crate::websocket::messages::BybitWsAccountExecutionFastMsg =
4381            serde_json::from_str(&json).unwrap();
4382        fast.data[0].category = BybitProductType::Linear;
4383        fast.data[0].symbol = Ustr::from("ETHUSDT");
4384        fast.data[0].order_id = report.venue_order_id.as_str().into();
4385        fast.data[0].order_link_id = Ustr::from("");
4386        fast.data[0].exec_price = "3000.00".to_string();
4387        fast.data[0].exec_qty = "0.5".to_string();
4388        dispatch_ws_message(
4389            &crate::websocket::messages::BybitWsMessage::AccountExecutionFast(fast),
4390            client.core.account_id,
4391            &client.instruments_cache,
4392            client.clock,
4393            &client.dispatch_state,
4394            &client.emitter,
4395        );
4396        assert!(rx.try_recv().is_err());
4397
4398        cache_reconciliation_order_identity(
4399            client.core.account_id,
4400            Some(&client.core),
4401            &client.dispatch_state,
4402            &report,
4403            &client.instruments_cache,
4404            &client.emitter,
4405        );
4406
4407        match rx.try_recv().unwrap() {
4408            ExecutionEvent::Report(ExecutionReport::Fill(fill)) => {
4409                assert_eq!(fill.client_order_id, None);
4410                assert_eq!(fill.last_qty, Quantity::from("0.5"));
4411            }
4412            other => panic!("Expected FillReport, found {other:?}"),
4413        }
4414
4415        assert!(rx.try_recv().is_err());
4416        assert!(client.dispatch_state.order_identities.is_empty());
4417        assert!(client.dispatch_state.order_venue_ids.is_empty());
4418        assert!(client.dispatch_state.venue_order_ids.is_empty());
4419    }
4420
4421    #[rstest]
4422    fn test_cache_reconciliation_order_identity_keeps_one_way_local_report() {
4423        let (client, cache) = test_execution_client();
4424        let client_order_id = ClientOrderId::from("O-ONEWAY-RECON");
4425        let instrument_id = InstrumentId::from("BTCUSDT-LINEAR.BYBIT");
4426        let mut builder = OrderTestBuilder::new(OrderType::Limit);
4427        let order = builder
4428            .instrument_id(instrument_id)
4429            .client_order_id(client_order_id)
4430            .side(OrderSide::Buy)
4431            .quantity(Quantity::from("1"))
4432            .price(Price::from("10000.00"))
4433            .build();
4434        cache
4435            .borrow_mut()
4436            .add_order(order, None, None, false)
4437            .unwrap();
4438
4439        let report =
4440            sample_order_status_report(client_order_id, instrument_id, OrderStatus::Accepted, None);
4441        cache_reconciliation_order_identity(
4442            client.core.account_id,
4443            Some(&client.core),
4444            &client.dispatch_state,
4445            &report,
4446            &client.instruments_cache,
4447            &client.emitter,
4448        );
4449
4450        let identity = client
4451            .dispatch_state
4452            .order_identities
4453            .get(&client_order_id)
4454            .unwrap();
4455        assert_eq!(identity.instrument_id, instrument_id);
4456        assert_eq!(identity.venue_position_id, None);
4457    }
4458
4459    #[rstest]
4460    #[case::single_discard(true, false)]
4461    #[case::bulk_discard(false, false)]
4462    #[case::single_finish(true, true)]
4463    #[case::bulk_finish(false, true)]
4464    #[tokio::test]
4465    async fn test_closed_report_collection_preserves_pending_command_identity(
4466        #[case] single: bool,
4467        #[case] accepted: bool,
4468        #[values(PendingOperation::Cancel, PendingOperation::Amend)] operation: PendingOperation,
4469    ) {
4470        let client_order_id = ClientOrderId::from("client-open-1");
4471        let instrument_id = InstrumentId::from("ETHUSDT-LINEAR.BYBIT");
4472        let report =
4473            sample_order_status_report(client_order_id, instrument_id, OrderStatus::Accepted, None);
4474        let json = crate::common::testing::load_test_json("http_get_orders_realtime.json");
4475        let mut orders: serde_json::Value = serde_json::from_str(&json).unwrap();
4476        orders["result"]["list"].as_array_mut().unwrap().truncate(1);
4477        orders["result"]["list"][0]["orderStatus"] = serde_json::json!("Cancelled");
4478        orders["result"]["list"][0]["orderId"] = serde_json::json!(report.venue_order_id.as_str());
4479        let (mut client, cache, server) = order_report_client(orders).await;
4480        let mut order = OrderTestBuilder::new(OrderType::Limit)
4481            .client_order_id(client_order_id)
4482            .instrument_id(instrument_id)
4483            .side(OrderSide::Buy)
4484            .quantity(Quantity::from("0.010"))
4485            .price(Price::from("3930.41"))
4486            .build();
4487        let event =
4488            TestOrderEventStubs::accepted(&order, client.core.account_id, report.venue_order_id);
4489        order.apply(event).unwrap();
4490        cache
4491            .borrow_mut()
4492            .add_order(order.clone(), None, None, false)
4493            .unwrap();
4494        cache_reconciliation_order_identity(
4495            client.core.account_id,
4496            Some(&client.core),
4497            &client.dispatch_state,
4498            &report,
4499            &client.instruments_cache,
4500            &client.emitter,
4501        );
4502        client.dispatch_state.pending_requests.insert(
4503            "late-command".to_string(),
4504            (
4505                vec![client_order_id],
4506                vec![Some(report.venue_order_id)],
4507                operation,
4508                Vec::new(),
4509            ),
4510        );
4511        let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel();
4512        client.emitter.set_sender(tx);
4513
4514        let task = if single {
4515            let command = GenerateOrderStatusReport::new(
4516                UUID4::new(),
4517                UnixNanos::default(),
4518                Some(instrument_id),
4519                Some(client_order_id),
4520                Some(report.venue_order_id),
4521                None,
4522                None,
4523            );
4524            let task = client.generate_order_status_report_task(&command).unwrap();
4525            ExecutionReportTask {
4526                collection: task.collection,
4527                finish: Box::new(move || Ok((task.finish)()?.into_iter().collect::<Vec<_>>())),
4528            }
4529        } else {
4530            let command = GenerateOrderStatusReports::new(
4531                UUID4::new(),
4532                UnixNanos::default(),
4533                false,
4534                Some(instrument_id),
4535                None,
4536                None,
4537                None,
4538                None,
4539            );
4540            client.generate_order_status_reports_task(&command).unwrap()
4541        };
4542
4543        tokio::spawn(task.collection).await.unwrap();
4544        assert!(
4545            client
4546                .dispatch_state
4547                .order_identities
4548                .contains_key(&client_order_id)
4549        );
4550
4551        if accepted {
4552            let reports = (task.finish)().unwrap();
4553            assert_eq!(reports.len(), 1);
4554            assert_eq!(reports[0].order_status, OrderStatus::Canceled);
4555        } else {
4556            drop(task.finish);
4557        }
4558
4559        let json = crate::common::testing::load_test_json("ws_order_response.json");
4560        let mut response: serde_json::Value = serde_json::from_str(&json).unwrap();
4561        response["op"] = serde_json::json!(match operation {
4562            PendingOperation::Cancel => "order.cancel",
4563            PendingOperation::Amend => "order.amend",
4564            PendingOperation::Place => unreachable!(),
4565        });
4566        response["retCode"] = serde_json::json!(110001);
4567        response["retMsg"] = serde_json::json!("Order does not exist.");
4568        response["reqId"] = serde_json::json!("late-command");
4569        response["data"]["orderLinkId"] = serde_json::json!(client_order_id.as_str());
4570        response["data"]["orderId"] = serde_json::json!(report.venue_order_id.as_str());
4571        let response = serde_json::from_value(response).unwrap();
4572        let message = crate::websocket::messages::BybitWsMessage::OrderResponse(response);
4573        dispatch_ws_message(
4574            &message,
4575            client.core.account_id,
4576            &client.instruments_cache,
4577            client.clock,
4578            &client.dispatch_state,
4579            &client.emitter,
4580        );
4581        assert_eq!(
4582            client
4583                .dispatch_state
4584                .order_identities
4585                .contains_key(&client_order_id),
4586            !accepted
4587        );
4588        assert!(client.dispatch_state.pending_requests.is_empty());
4589
4590        if accepted {
4591            assert!(rx.try_recv().is_err());
4592        } else {
4593            let ExecutionEvent::Order(event) = rx.try_recv().unwrap() else {
4594                panic!("expected delayed command rejection");
4595            };
4596
4597            let (reason, reconciliation) = match (operation, &event) {
4598                (PendingOperation::Cancel, OrderEventAny::CancelRejected(event)) => {
4599                    (event.reason, event.reconciliation)
4600                }
4601                (PendingOperation::Amend, OrderEventAny::ModifyRejected(event)) => {
4602                    (event.reason, event.reconciliation)
4603                }
4604                _ => panic!("unexpected rejection event: {event:?}"),
4605            };
4606
4607            assert_eq!(event.trader_id(), client.core.trader_id);
4608            assert_eq!(event.account_id(), Some(client.core.account_id));
4609            assert_eq!(event.client_order_id(), client_order_id);
4610            assert_eq!(event.venue_order_id(), Some(report.venue_order_id));
4611            assert_eq!(event.instrument_id(), instrument_id);
4612            assert_eq!(event.strategy_id(), order.strategy_id());
4613            assert_eq!(reason.as_str(), "Order does not exist.");
4614            assert!(!reconciliation);
4615            assert!(rx.try_recv().is_err());
4616        }
4617
4618        server.abort();
4619    }
4620
4621    #[rstest]
4622    #[case::single(true)]
4623    #[case::bulk(false)]
4624    #[tokio::test]
4625    async fn test_open_report_finalization_uses_current_core(#[case] single: bool) {
4626        let orders = serde_json::from_str(&crate::common::testing::load_test_json(
4627            "http_get_orders_realtime.json",
4628        ))
4629        .unwrap();
4630        let (client, cache, server) = order_report_client(orders).await;
4631        let client_order_id = ClientOrderId::from("client-open-1");
4632        let instrument_id = InstrumentId::from("ETHUSDT-LINEAR.BYBIT");
4633
4634        let task = if single {
4635            let command = GenerateOrderStatusReport::new(
4636                UUID4::new(),
4637                UnixNanos::default(),
4638                Some(instrument_id),
4639                Some(client_order_id),
4640                Some(VenueOrderId::from("open-order-1")),
4641                None,
4642                None,
4643            );
4644            let task = client.generate_order_status_report_task(&command).unwrap();
4645            ExecutionReportTask {
4646                collection: task.collection,
4647                finish: Box::new(move || Ok((task.finish)()?.into_iter().collect::<Vec<_>>())),
4648            }
4649        } else {
4650            let command = GenerateOrderStatusReports::new(
4651                UUID4::new(),
4652                UnixNanos::default(),
4653                false,
4654                Some(instrument_id),
4655                None,
4656                None,
4657                None,
4658                None,
4659            );
4660            client.generate_order_status_reports_task(&command).unwrap()
4661        };
4662
4663        tokio::spawn(task.collection).await.unwrap();
4664        assert!(client.dispatch_state.order_identities.is_empty());
4665        let strategy_id = StrategyId::from("LATE_OWNER-007");
4666        let order = OrderTestBuilder::new(OrderType::Market)
4667            .strategy_id(strategy_id)
4668            .client_order_id(client_order_id)
4669            .instrument_id(instrument_id)
4670            .side(OrderSide::Sell)
4671            .quantity(Quantity::from("0.027"))
4672            .build();
4673        cache
4674            .borrow_mut()
4675            .add_order(order, None, None, false)
4676            .unwrap();
4677
4678        let reports = (task.finish)().unwrap();
4679
4680        assert_eq!(reports[0].client_order_id, Some(client_order_id));
4681        let identity = client
4682            .dispatch_state
4683            .order_identities
4684            .get(&client_order_id)
4685            .unwrap();
4686        assert_eq!(
4687            (
4688                identity.instrument_id,
4689                identity.strategy_id,
4690                identity.order_side,
4691                identity.order_type,
4692                identity.venue_position_id
4693            ),
4694            (
4695                instrument_id,
4696                strategy_id,
4697                OrderSide::Sell,
4698                OrderType::Market,
4699                None
4700            ),
4701        );
4702        server.abort();
4703    }
4704
4705    #[rstest]
4706    #[case::single(true)]
4707    #[case::bulk(false)]
4708    #[tokio::test]
4709    async fn test_order_report_collection_error_preserves_identity(#[case] single: bool) {
4710        let response = serde_json::json!({
4711            "retCode": 10001, "retMsg": "report collection failure", "result": {"list": []},
4712            "retExtInfo": {}, "time": 1761355905610u64,
4713        });
4714        let (client, _, server) = order_report_client(response).await;
4715        let client_order_id = ClientOrderId::from("client-open-1");
4716        let instrument_id = InstrumentId::from("ETHUSDT-LINEAR.BYBIT");
4717        let strategy_id = StrategyId::from("ERROR_OWNER-009");
4718        client.dispatch_state.order_identities.insert(
4719            client_order_id,
4720            OrderIdentity {
4721                instrument_id,
4722                strategy_id,
4723                order_side: OrderSide::Sell,
4724                order_type: OrderType::Market,
4725                venue_position_id: Some(PositionId::from("ERROR-POSITION")),
4726            },
4727        );
4728
4729        let single_command = GenerateOrderStatusReport::new(
4730            UUID4::new(),
4731            UnixNanos::default(),
4732            Some(instrument_id),
4733            Some(client_order_id),
4734            Some(VenueOrderId::from("open-order-1")),
4735            None,
4736            None,
4737        );
4738
4739        let bulk_command = GenerateOrderStatusReports::new(
4740            UUID4::new(),
4741            UnixNanos::default(),
4742            false,
4743            Some(instrument_id),
4744            None,
4745            None,
4746            None,
4747            None,
4748        );
4749
4750        for fused in [false, true] {
4751            let error = if fused {
4752                if single {
4753                    client
4754                        .generate_order_status_report(&single_command)
4755                        .await
4756                        .unwrap_err()
4757                } else {
4758                    client
4759                        .generate_order_status_reports(&bulk_command)
4760                        .await
4761                        .unwrap_err()
4762                }
4763            } else if single {
4764                let task = client
4765                    .generate_order_status_report_task(&single_command)
4766                    .unwrap();
4767
4768                tokio::spawn(task.collection).await.unwrap();
4769                (task.finish)().unwrap_err()
4770            } else {
4771                let task = client
4772                    .generate_order_status_reports_task(&bulk_command)
4773                    .unwrap();
4774
4775                tokio::spawn(task.collection).await.unwrap();
4776                (task.finish)().unwrap_err()
4777            };
4778
4779            let error = error.downcast_ref::<BybitHttpError>().unwrap();
4780            assert!(
4781                matches!(error, BybitHttpError::BybitError { error_code: 10001, message } if message == "report collection failure")
4782            );
4783            let identity = client
4784                .dispatch_state
4785                .order_identities
4786                .get(&client_order_id)
4787                .unwrap();
4788            assert_eq!(
4789                (
4790                    identity.instrument_id,
4791                    identity.strategy_id,
4792                    identity.order_side,
4793                    identity.order_type,
4794                    identity.venue_position_id
4795                ),
4796                (
4797                    instrument_id,
4798                    strategy_id,
4799                    OrderSide::Sell,
4800                    OrderType::Market,
4801                    Some(PositionId::from("ERROR-POSITION"))
4802                ),
4803            );
4804        }
4805
4806        server.abort();
4807    }
4808
4809    #[rstest]
4810    #[case::both_match(Some("ETHUSDT-LINEAR.BYBIT"), Some("client-open-1"), Some("open-order-1"), Some(("client-open-1", "open-order-1")))]
4811    #[case::crossed_identifiers(
4812        Some("ETHUSDT-LINEAR.BYBIT"),
4813        Some("client-open-1"),
4814        Some("open-order-2"),
4815        None
4816    )]
4817    #[case::client_only(Some("ETHUSDT-LINEAR.BYBIT"), Some("client-open-2"), None, Some(("client-open-2", "open-order-2")))]
4818    #[case::venue_only(Some("ETHUSDT-LINEAR.BYBIT"), None, Some("open-order-2"), Some(("client-open-2", "open-order-2")))]
4819    #[case::missing_instrument(None, Some("client-open-1"), Some("open-order-1"), None)]
4820    #[tokio::test]
4821    async fn test_single_report_task_preserves_lookup_filters(
4822        #[case] instrument: Option<&str>,
4823        #[case] client_order_id: Option<&str>,
4824        #[case] venue_order_id: Option<&str>,
4825        #[case] expected: Option<(&str, &str)>,
4826    ) {
4827        let orders = serde_json::from_str(&crate::common::testing::load_test_json(
4828            "http_get_orders_realtime.json",
4829        ))
4830        .unwrap();
4831        let (client, _, server) = order_report_client(orders).await;
4832
4833        let command = GenerateOrderStatusReport::new(
4834            UUID4::new(),
4835            UnixNanos::default(),
4836            instrument.map(InstrumentId::from),
4837            client_order_id.map(ClientOrderId::from),
4838            venue_order_id.map(VenueOrderId::from),
4839            None,
4840            None,
4841        );
4842        let task = client.generate_order_status_report_task(&command).unwrap();
4843        tokio::spawn(task.collection).await.unwrap();
4844
4845        let report = (task.finish)().unwrap();
4846
4847        assert_eq!(
4848            report.map(|report| (report.client_order_id, report.venue_order_id)),
4849            expected.map(|(client, venue)| (
4850                Some(ClientOrderId::from(client)),
4851                VenueOrderId::from(venue)
4852            )),
4853        );
4854        server.abort();
4855    }
4856
4857    #[rstest]
4858    #[case::unbounded(None, None, vec!["open-order-1", "open-order-2"])]
4859    #[case::after_first(Some(1761355905607), None, vec!["open-order-2"])]
4860    #[case::before_second(None, Some(1761355905608), vec!["open-order-1"])]
4861    #[case::inclusive_bounds(Some(1761355905606), Some(1761355905606), vec!["open-order-1"])]
4862    #[tokio::test]
4863    async fn test_bulk_report_task_preserves_window_and_fused_parity(
4864        #[case] start_ms: Option<u64>,
4865        #[case] end_ms: Option<u64>,
4866        #[case] expected: Vec<&str>,
4867    ) {
4868        let orders = serde_json::from_str(&crate::common::testing::load_test_json(
4869            "http_get_orders_realtime.json",
4870        ))
4871        .unwrap();
4872        let (client, _, server) = order_report_client(orders).await;
4873
4874        let command = GenerateOrderStatusReports::new(
4875            UUID4::new(),
4876            UnixNanos::default(),
4877            false,
4878            Some(InstrumentId::from("ETHUSDT-LINEAR.BYBIT")),
4879            start_ms.map(|ms| UnixNanos::from(ms * 1_000_000)),
4880            end_ms.map(|ms| UnixNanos::from(ms * 1_000_000)),
4881            None,
4882            None,
4883        );
4884        let task = client.generate_order_status_reports_task(&command).unwrap();
4885        tokio::spawn(task.collection).await.unwrap();
4886
4887        let collected = (task.finish)().unwrap();
4888        let fused = client
4889            .generate_order_status_reports(&command)
4890            .await
4891            .unwrap();
4892
4893        let expected: Vec<_> = expected.into_iter().map(VenueOrderId::from).collect();
4894        assert_eq!(
4895            collected
4896                .iter()
4897                .map(|report| report.venue_order_id)
4898                .collect::<Vec<_>>(),
4899            expected
4900        );
4901        assert_eq!(
4902            fused
4903                .iter()
4904                .map(|report| report.venue_order_id)
4905                .collect::<Vec<_>>(),
4906            expected
4907        );
4908        server.abort();
4909    }
4910
4911    async fn order_report_client(
4912        response: serde_json::Value,
4913    ) -> (
4914        BybitExecutionClient,
4915        Rc<RefCell<Cache>>,
4916        tokio::task::JoinHandle<()>,
4917    ) {
4918        let history = response.clone();
4919        let router = Router::new()
4920            .route(
4921                "/v5/order/realtime",
4922                get(move || std::future::ready(Json(response.clone()))),
4923            )
4924            .route(
4925                "/v5/order/history",
4926                get(move || std::future::ready(Json(history.clone()))),
4927            );
4928        let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
4929        let addr = listener.local_addr().unwrap();
4930        let server = tokio::spawn(async move { axum::serve(listener, router).await.unwrap() });
4931        let (mut client, cache) = test_execution_client();
4932        client.http_client = BybitHttpClient::with_credentials(
4933            "test_key".to_string(),
4934            "test_secret".to_string(),
4935            Some(format!("http://{addr}")),
4936            1,
4937            0,
4938            10,
4939            10,
4940            5_000,
4941            None,
4942        )
4943        .unwrap();
4944        let mut instrument = crypto_perpetual_ethusdt();
4945        instrument.id = InstrumentId::from("ETHUSDT-LINEAR.BYBIT");
4946        client.http_client.cache_instrument(instrument.into());
4947        (client, cache, server)
4948    }
4949
4950    #[rstest]
4951    #[tokio::test]
4952    async fn test_bulk_report_finalization_emits_fill_before_status_result() {
4953        let client_order_id = ClientOrderId::from("O-FAST-DRAIN");
4954        let instrument_id = InstrumentId::from("ETHUSDT-LINEAR.BYBIT");
4955        let mut report =
4956            sample_order_status_report(client_order_id, instrument_id, OrderStatus::Filled, None);
4957        report.filled_qty = Quantity::from("0.5");
4958        let mut orders: serde_json::Value = serde_json::from_str(
4959            &crate::common::testing::load_test_json("http_get_orders_realtime.json"),
4960        )
4961        .unwrap();
4962        orders["result"]["nextPageCursor"] = serde_json::json!("");
4963        orders["result"]["list"].as_array_mut().unwrap().truncate(1);
4964        orders["result"]["list"][0]["orderStatus"] = serde_json::json!("Filled");
4965        orders["result"]["list"][0]["orderId"] = serde_json::json!(report.venue_order_id.as_str());
4966        orders["result"]["list"][0]["orderLinkId"] = serde_json::json!(client_order_id.as_str());
4967        orders["result"]["list"][0]["cumExecQty"] = serde_json::json!("0.5");
4968        let (mut client, _cache, server) = order_report_client(orders).await;
4969        Arc::get_mut(&mut client.dispatch_state)
4970            .unwrap()
4971            .fast_execution = true;
4972        let json = crate::common::testing::load_test_json("http_get_instruments_linear.json");
4973        let response: BybitInstrumentLinearResponse = serde_json::from_str(&json).unwrap();
4974        let instrument = parse_linear_instrument(
4975            &response.result.list[1],
4976            UnixNanos::default(),
4977            UnixNanos::default(),
4978        )
4979        .unwrap();
4980        let mut instruments = AHashMap::new();
4981        instruments.insert(instrument_id.symbol.inner(), instrument);
4982        client.instruments_cache = Arc::new(instruments);
4983        client.dispatch_state.order_identities.insert(
4984            client_order_id,
4985            OrderIdentity {
4986                instrument_id,
4987                strategy_id: StrategyId::from("S-001"),
4988                order_side: OrderSide::Buy,
4989                order_type: OrderType::Limit,
4990                venue_position_id: None,
4991            },
4992        );
4993
4994        let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel();
4995        client.emitter.set_sender(tx);
4996        let json = crate::common::testing::load_test_json("ws_account_execution_fast.json");
4997        let mut fast: crate::websocket::messages::BybitWsAccountExecutionFastMsg =
4998            serde_json::from_str(&json).unwrap();
4999        fast.data[0].category = BybitProductType::Linear;
5000        fast.data[0].symbol = Ustr::from("ETHUSDT");
5001        fast.data[0].order_id = report.venue_order_id.as_str().into();
5002        fast.data[0].order_link_id = Ustr::from("");
5003        fast.data[0].exec_price = "3000.00".to_string();
5004        fast.data[0].exec_qty = "0.5".to_string();
5005        dispatch_ws_message(
5006            &crate::websocket::messages::BybitWsMessage::AccountExecutionFast(fast),
5007            client.core.account_id,
5008            &client.instruments_cache,
5009            client.clock,
5010            &client.dispatch_state,
5011            &client.emitter,
5012        );
5013        assert!(rx.try_recv().is_err());
5014
5015        let command = GenerateOrderStatusReports::new(
5016            UUID4::new(),
5017            UnixNanos::default(),
5018            false,
5019            Some(instrument_id),
5020            None,
5021            None,
5022            None,
5023            None,
5024        );
5025
5026        let task = client.generate_order_status_reports_task(&command).unwrap();
5027        task.collection.await;
5028        let reports = (task.finish)().unwrap();
5029        assert_eq!(reports.len(), 1);
5030        assert_eq!(reports[0].filled_qty, Quantity::from("0.5"));
5031        assert_eq!(reports[0].venue_order_id, report.venue_order_id);
5032        assert!(matches!(
5033            rx.try_recv().unwrap(),
5034            ExecutionEvent::Order(OrderEventAny::Accepted(_))
5035        ));
5036
5037        match rx.try_recv().unwrap() {
5038            ExecutionEvent::Report(ExecutionReport::Fill(fill)) => {
5039                assert_eq!(fill.last_qty, Quantity::from("0.5"));
5040                assert_eq!(
5041                    fill.trade_id.as_str(),
5042                    "3510f361-0add-5c7b-a2e7-9679810944fc"
5043                );
5044            }
5045            other => panic!("Expected FillReport after finalization, found {other:?}"),
5046        }
5047
5048        assert!(rx.try_recv().is_err());
5049        server.abort();
5050    }
5051
5052    #[rstest]
5053    #[case::pending(true)]
5054    #[case::late_closed(false)]
5055    #[tokio::test]
5056    async fn test_query_order_restores_pending_fill_without_recreating_completed_state(
5057        #[case] recover_pending: bool,
5058    ) {
5059        let client_order_id = ClientOrderId::from("O-FAST-DRAIN");
5060        let instrument_id = InstrumentId::from("ETHUSDT-LINEAR.BYBIT");
5061        let mut report =
5062            sample_order_status_report(client_order_id, instrument_id, OrderStatus::Filled, None);
5063        report.filled_qty = Quantity::from("0.5");
5064        let mut orders: serde_json::Value = serde_json::from_str(
5065            &crate::common::testing::load_test_json("http_get_orders_realtime.json"),
5066        )
5067        .unwrap();
5068        orders["result"]["nextPageCursor"] = serde_json::json!("");
5069        orders["result"]["list"].as_array_mut().unwrap().truncate(1);
5070        orders["result"]["list"][0]["orderStatus"] = serde_json::json!("Filled");
5071        orders["result"]["list"][0]["orderId"] = serde_json::json!(report.venue_order_id.as_str());
5072        orders["result"]["list"][0]["orderLinkId"] = serde_json::json!(client_order_id.as_str());
5073        orders["result"]["list"][0]["cumExecQty"] = serde_json::json!("0.5");
5074        let (mut client, _cache, server) = order_report_client(orders).await;
5075        Arc::get_mut(&mut client.dispatch_state)
5076            .unwrap()
5077            .fast_execution = true;
5078        let json = crate::common::testing::load_test_json("http_get_instruments_linear.json");
5079        let response: BybitInstrumentLinearResponse = serde_json::from_str(&json).unwrap();
5080        let instrument = parse_linear_instrument(
5081            &response.result.list[1],
5082            UnixNanos::default(),
5083            UnixNanos::default(),
5084        )
5085        .unwrap();
5086        let mut instruments = AHashMap::new();
5087        instruments.insert(instrument_id.symbol.inner(), instrument);
5088        client.instruments_cache = Arc::new(instruments);
5089        if recover_pending {
5090            client.dispatch_state.order_identities.insert(
5091                client_order_id,
5092                OrderIdentity {
5093                    instrument_id,
5094                    strategy_id: StrategyId::from("S-001"),
5095                    order_side: OrderSide::Buy,
5096                    order_type: OrderType::Limit,
5097                    venue_position_id: None,
5098                },
5099            );
5100        }
5101
5102        let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel();
5103        client.emitter.set_sender(tx);
5104
5105        if recover_pending {
5106            let json = crate::common::testing::load_test_json("ws_account_execution_fast.json");
5107            let mut fast: crate::websocket::messages::BybitWsAccountExecutionFastMsg =
5108                serde_json::from_str(&json).unwrap();
5109            fast.data[0].category = BybitProductType::Linear;
5110            fast.data[0].symbol = Ustr::from("ETHUSDT");
5111            fast.data[0].order_id = report.venue_order_id.as_str().into();
5112            fast.data[0].order_link_id = Ustr::from("");
5113            fast.data[0].exec_price = "3000.00".to_string();
5114            fast.data[0].exec_qty = "0.5".to_string();
5115            dispatch_ws_message(
5116                &crate::websocket::messages::BybitWsMessage::AccountExecutionFast(fast),
5117                client.core.account_id,
5118                &client.instruments_cache,
5119                client.clock,
5120                &client.dispatch_state,
5121                &client.emitter,
5122            );
5123        }
5124
5125        assert!(rx.try_recv().is_err());
5126
5127        client
5128            .query_order(QueryOrder::new(
5129                TraderId::from("TESTER-001"),
5130                Some(*BYBIT_CLIENT_ID),
5131                StrategyId::from("S-001"),
5132                instrument_id,
5133                client_order_id,
5134                Some(report.venue_order_id),
5135                UUID4::new(),
5136                UnixNanos::default(),
5137                None,
5138                None,
5139            ))
5140            .unwrap();
5141        wait_for_spawned_tasks(&client).await;
5142
5143        if recover_pending {
5144            assert!(matches!(
5145                rx.try_recv().unwrap(),
5146                ExecutionEvent::Order(OrderEventAny::Accepted(_))
5147            ));
5148            assert!(matches!(
5149                rx.try_recv().unwrap(),
5150                ExecutionEvent::Report(ExecutionReport::Fill(_))
5151            ));
5152        }
5153
5154        assert!(matches!(
5155            rx.try_recv().unwrap(),
5156            ExecutionEvent::Report(ExecutionReport::Order(_))
5157        ));
5158        assert!(rx.try_recv().is_err());
5159
5160        if !recover_pending {
5161            assert!(client.dispatch_state.order_identities.is_empty());
5162            assert!(client.dispatch_state.order_venue_ids.is_empty());
5163            assert!(client.dispatch_state.venue_order_ids.is_empty());
5164        }
5165
5166        server.abort();
5167    }
5168
5169    async fn fill_report_client(
5170        response: serde_json::Value,
5171    ) -> (
5172        BybitExecutionClient,
5173        Rc<RefCell<Cache>>,
5174        tokio::task::JoinHandle<()>,
5175    ) {
5176        let router = Router::new().route(
5177            "/v5/execution/list",
5178            get(move || std::future::ready(Json(response.clone()))),
5179        );
5180        let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
5181        let addr = listener.local_addr().unwrap();
5182        let server = tokio::spawn(async move { axum::serve(listener, router).await.unwrap() });
5183        let (mut client, cache) = test_execution_client();
5184        client.http_client = BybitHttpClient::with_credentials(
5185            "test_key".to_string(),
5186            "test_secret".to_string(),
5187            Some(format!("http://{addr}")),
5188            1,
5189            0,
5190            10,
5191            10,
5192            5_000,
5193            None,
5194        )
5195        .unwrap();
5196        let mut instrument = crypto_perpetual_ethusdt();
5197        instrument.id = InstrumentId::from("ETHUSDT-LINEAR.BYBIT");
5198        client.http_client.cache_instrument(instrument.into());
5199        (client, cache, server)
5200    }
5201
5202    async fn mass_status_client(
5203        execution_response: serde_json::Value,
5204        position_fails: bool,
5205    ) -> (
5206        BybitExecutionClient,
5207        Rc<RefCell<Cache>>,
5208        tokio::task::JoinHandle<()>,
5209    ) {
5210        let empty = serde_json::json!({
5211            "retCode": 0,
5212            "retMsg": "OK",
5213            "result": {"list": [], "nextPageCursor": ""},
5214            "retExtInfo": {},
5215            "time": 1761355906606i64
5216        });
5217
5218        let position_response = if position_fails {
5219            serde_json::json!({
5220                "retCode": 10001,
5221                "retMsg": "position request failed",
5222                "result": {},
5223                "retExtInfo": {},
5224                "time": 1761355906606i64
5225            })
5226        } else {
5227            empty.clone()
5228        };
5229
5230        let realtime = empty.clone();
5231        let history = empty;
5232        let router = Router::new()
5233            .route(
5234                "/v5/order/realtime",
5235                get(move || std::future::ready(Json(realtime.clone()))),
5236            )
5237            .route(
5238                "/v5/order/history",
5239                get(move || std::future::ready(Json(history.clone()))),
5240            )
5241            .route(
5242                "/v5/execution/list",
5243                get(move || std::future::ready(Json(execution_response.clone()))),
5244            )
5245            .route(
5246                "/v5/position/list",
5247                get(move || std::future::ready(Json(position_response.clone()))),
5248            );
5249        let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
5250        let addr = listener.local_addr().unwrap();
5251        let server = tokio::spawn(async move { axum::serve(listener, router).await.unwrap() });
5252        let (mut client, cache) = test_execution_client();
5253        client.http_client = BybitHttpClient::with_credentials(
5254            "test_key".to_string(),
5255            "test_secret".to_string(),
5256            Some(format!("http://{addr}")),
5257            1,
5258            0,
5259            10,
5260            10,
5261            5_000,
5262            None,
5263        )
5264        .unwrap();
5265        let mut instrument = crypto_perpetual_ethusdt();
5266        instrument.id = InstrumentId::from("ETHUSDT-LINEAR.BYBIT");
5267        client.http_client.cache_instrument(instrument.into());
5268        (client, cache, server)
5269    }
5270
5271    fn assert_websocket_fill_after_rest(
5272        client: &mut BybitExecutionClient,
5273        rx: &mut tokio::sync::mpsc::UnboundedReceiver<ExecutionEvent>,
5274        client_order_id: ClientOrderId,
5275        instrument_id: InstrumentId,
5276        venue_order_id: VenueOrderId,
5277    ) {
5278        let mut instrument = crypto_perpetual_ethusdt();
5279        instrument.id = instrument_id;
5280        let instrument: InstrumentAny = instrument.into();
5281
5282        client.instruments_cache = Arc::new(AHashMap::from_iter([(
5283            instrument_id.symbol.inner(),
5284            instrument,
5285        )]));
5286        let json = crate::common::testing::load_test_json("ws_account_execution_fast.json");
5287        let mut fast: crate::websocket::messages::BybitWsAccountExecutionFastMsg =
5288            serde_json::from_str(&json).unwrap();
5289        fast.data[0].category = BybitProductType::Linear;
5290        fast.data[0].symbol = Ustr::from("ETHUSDT");
5291        fast.data[0].exec_id = "f1dce92e-1g29-6977-a526-dg420c6ecb4c".to_string();
5292        fast.data[0].exec_price = "3000.00".to_string();
5293        fast.data[0].exec_qty = "0.5".to_string();
5294        fast.data[0].order_id = venue_order_id.as_str().into();
5295        fast.data[0].order_link_id = client_order_id.as_str().into();
5296        fast.data[0].side = BybitOrderSide::Sell;
5297        fast.data[0].is_maker = false;
5298
5299        dispatch_ws_message(
5300            &crate::websocket::messages::BybitWsMessage::AccountExecutionFast(fast),
5301            client.core.account_id,
5302            &client.instruments_cache,
5303            client.clock,
5304            &client.dispatch_state,
5305            &client.emitter,
5306        );
5307
5308        assert!(matches!(
5309            rx.try_recv().unwrap(),
5310            ExecutionEvent::Order(OrderEventAny::Accepted(_))
5311        ));
5312
5313        match rx.try_recv().unwrap() {
5314            ExecutionEvent::Report(ExecutionReport::Fill(report)) => {
5315                assert_eq!(report.client_order_id, Some(client_order_id));
5316                assert_eq!(report.last_qty, Quantity::from("0.5"));
5317                assert_eq!(
5318                    report.trade_id.as_str(),
5319                    "f1dce92e-1g29-6977-a526-dg420c6ecb4c"
5320                );
5321            }
5322            other => panic!("Expected FillReport, found {other:?}"),
5323        }
5324
5325        assert!(rx.try_recv().is_err());
5326        assert!(
5327            !client
5328                .dispatch_state
5329                .order_identities
5330                .contains_key(&client_order_id)
5331        );
5332        assert!(
5333            !client
5334                .dispatch_state
5335                .order_venue_ids
5336                .contains_key(&client_order_id)
5337        );
5338        assert!(
5339            !client
5340                .dispatch_state
5341                .terminal_order_quantities
5342                .contains_key(&client_order_id)
5343        );
5344    }
5345
5346    #[rstest]
5347    #[case::success(false)]
5348    #[case::position_failure(true)]
5349    #[tokio::test]
5350    async fn test_mass_status_does_not_suppress_websocket_fill(#[case] position_fails: bool) {
5351        let mut response: serde_json::Value = serde_json::from_str(
5352            &crate::common::testing::load_test_json("http_get_executions.json"),
5353        )
5354        .unwrap();
5355        response["result"]["nextPageCursor"] = serde_json::json!("");
5356        let (mut client, _cache, server) = mass_status_client(response, position_fails).await;
5357        Arc::get_mut(&mut client.dispatch_state)
5358            .unwrap()
5359            .fast_execution = true;
5360        let client_order_id = ClientOrderId::from("test-order-002");
5361        let instrument_id = InstrumentId::from("ETHUSDT-LINEAR.BYBIT");
5362        let venue_order_id = VenueOrderId::from("7b954230-6a41-3ba8-bc20-26d20ab44b83");
5363        client.dispatch_state.order_identities.insert(
5364            client_order_id,
5365            OrderIdentity {
5366                instrument_id,
5367                strategy_id: StrategyId::from("S-001"),
5368                order_side: OrderSide::Sell,
5369                order_type: OrderType::Limit,
5370                venue_position_id: None,
5371            },
5372        );
5373
5374        record_venue_order_id(client_order_id, venue_order_id, &client.dispatch_state);
5375        client
5376            .dispatch_state
5377            .terminal_order_quantities
5378            .insert(client_order_id, Quantity::from("0.5"));
5379        let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel();
5380        client.emitter.set_sender(tx);
5381
5382        let result = client.generate_mass_status(None).await;
5383
5384        if position_fails {
5385            assert!(result.is_err());
5386        } else {
5387            assert!(result.unwrap().is_some());
5388        }
5389
5390        assert!(
5391            client
5392                .dispatch_state
5393                .order_identities
5394                .contains_key(&client_order_id)
5395        );
5396        assert_websocket_fill_after_rest(
5397            &mut client,
5398            &mut rx,
5399            client_order_id,
5400            instrument_id,
5401            venue_order_id,
5402        );
5403        server.abort();
5404    }
5405
5406    #[rstest]
5407    #[tokio::test]
5408    async fn test_generate_fill_reports_does_not_suppress_websocket_fill() {
5409        let mut response: serde_json::Value = serde_json::from_str(
5410            &crate::common::testing::load_test_json("http_get_executions.json"),
5411        )
5412        .unwrap();
5413        response["result"]["nextPageCursor"] = serde_json::json!("");
5414        let (mut client, _cache, server) = fill_report_client(response).await;
5415        Arc::get_mut(&mut client.dispatch_state)
5416            .unwrap()
5417            .fast_execution = true;
5418        let client_order_id = ClientOrderId::from("test-order-002");
5419        let instrument_id = InstrumentId::from("ETHUSDT-LINEAR.BYBIT");
5420        let venue_order_id = VenueOrderId::from("7b954230-6a41-3ba8-bc20-26d20ab44b83");
5421        client.dispatch_state.order_identities.insert(
5422            client_order_id,
5423            OrderIdentity {
5424                instrument_id,
5425                strategy_id: StrategyId::from("S-001"),
5426                order_side: OrderSide::Sell,
5427                order_type: OrderType::Limit,
5428                venue_position_id: None,
5429            },
5430        );
5431
5432        record_venue_order_id(client_order_id, venue_order_id, &client.dispatch_state);
5433        client
5434            .dispatch_state
5435            .terminal_order_quantities
5436            .insert(client_order_id, Quantity::from("0.5"));
5437
5438        let command = GenerateFillReports::new(
5439            UUID4::new(),
5440            UnixNanos::default(),
5441            Some(instrument_id),
5442            Some(venue_order_id),
5443            None,
5444            None,
5445            None,
5446            None,
5447        );
5448        let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel();
5449        client.emitter.set_sender(tx);
5450
5451        let reports = client.generate_fill_reports(command.clone()).await.unwrap();
5452
5453        assert_eq!(reports.len(), 1);
5454        assert!(client.generate_fill_reports_task(&command).is_none());
5455        assert!(
5456            client
5457                .dispatch_state
5458                .order_identities
5459                .contains_key(&client_order_id)
5460        );
5461        assert_websocket_fill_after_rest(
5462            &mut client,
5463            &mut rx,
5464            client_order_id,
5465            instrument_id,
5466            venue_order_id,
5467        );
5468        server.abort();
5469    }
5470
5471    #[rstest]
5472    #[case(TimeInForce::Gtc, Ok(Some(BybitTimeInForce::Gtc)))]
5473    #[case(TimeInForce::Gtd, Ok(Some(BybitTimeInForce::Gtc)))]
5474    #[case(TimeInForce::Ioc, Ok(Some(BybitTimeInForce::Ioc)))]
5475    #[case(TimeInForce::Fok, Ok(Some(BybitTimeInForce::Fok)))]
5476    #[case(
5477        TimeInForce::Day,
5478        Err(OrderDeniedReason::UnsupportedTimeInForce(TimeInForce::Day))
5479    )]
5480    #[case(
5481        TimeInForce::AtTheOpen,
5482        Err(OrderDeniedReason::UnsupportedTimeInForce(TimeInForce::AtTheOpen))
5483    )]
5484    #[case(
5485        TimeInForce::AtTheClose,
5486        Err(OrderDeniedReason::UnsupportedTimeInForce(TimeInForce::AtTheClose))
5487    )]
5488    fn test_ws_params_time_in_force(
5489        #[case] tif: TimeInForce,
5490        #[case] expected: Result<Option<BybitTimeInForce>, OrderDeniedReason>,
5491    ) {
5492        let mut builder = OrderTestBuilder::new(OrderType::Limit);
5493        builder
5494            .instrument_id(InstrumentId::from("BTCUSDT-LINEAR.BYBIT"))
5495            .time_in_force(tif)
5496            .quantity(Quantity::from("0.02"))
5497            .price(Price::from("10000.00"));
5498
5499        if tif == TimeInForce::Gtd {
5500            builder.expire_time(UnixNanos::from(1_900_000_000_000_000_000));
5501        }
5502
5503        let order = builder.build();
5504        let params = BybitExecutionClient::build_ws_place_params(
5505            &order,
5506            BybitProductType::Linear,
5507            "BTCUSDT",
5508            &BybitTpSlParams::default(),
5509            None,
5510            None,
5511        );
5512        assert_eq!(
5513            params
5514                .map(|p| p.time_in_force)
5515                .map_err(|e| e.downcast::<OrderDeniedReason>().unwrap()),
5516            expected,
5517        );
5518    }
5519
5520    #[rstest]
5521    #[case::spot_market_base(
5522        BybitProductType::Spot,
5523        BybitOrderType::Market,
5524        false,
5525        Some(BybitMarketUnit::BaseCoin)
5526    )]
5527    #[case::spot_market_quote(
5528        BybitProductType::Spot,
5529        BybitOrderType::Market,
5530        true,
5531        Some(BybitMarketUnit::QuoteCoin)
5532    )]
5533    #[case::spot_limit(BybitProductType::Spot, BybitOrderType::Limit, true, None)]
5534    #[case::linear_market(BybitProductType::Linear, BybitOrderType::Market, true, None)]
5535    fn test_ws_params_market_unit(
5536        #[case] product_type: BybitProductType,
5537        #[case] order_type: BybitOrderType,
5538        #[case] is_quote_quantity: bool,
5539        #[case] expected: Option<BybitMarketUnit>,
5540    ) {
5541        let params = BybitWsPlaceOrderParams {
5542            category: product_type,
5543            symbol: ustr::Ustr::from("BTCUSDT"),
5544            side: BybitOrderSide::Buy,
5545            order_type,
5546            qty: "1.0".to_string(),
5547            is_leverage: None,
5548            market_unit: spot_market_unit(product_type, order_type, is_quote_quantity),
5549            price: None,
5550            time_in_force: None,
5551            order_link_id: None,
5552            reduce_only: None,
5553            close_on_trigger: None,
5554            trigger_price: None,
5555            trigger_by: None,
5556            trigger_direction: None,
5557            tpsl_mode: None,
5558            take_profit: None,
5559            stop_loss: None,
5560            tp_trigger_by: None,
5561            sl_trigger_by: None,
5562            sl_trigger_price: None,
5563            tp_trigger_price: None,
5564            sl_order_type: None,
5565            tp_order_type: None,
5566            sl_limit_price: None,
5567            tp_limit_price: None,
5568            order_iv: None,
5569            smp_type: None,
5570            mmp: None,
5571            position_idx: None,
5572            bbo_side_type: None,
5573            bbo_level: None,
5574        };
5575
5576        assert_eq!(params.market_unit, expected);
5577    }
5578
5579    #[rstest]
5580    #[case::market(OrderType::Market, BybitOrderType::Market, false)]
5581    #[case::limit(OrderType::Limit, BybitOrderType::Limit, false)]
5582    #[case::stop_market(OrderType::StopMarket, BybitOrderType::Market, true)]
5583    #[case::stop_limit(OrderType::StopLimit, BybitOrderType::Limit, true)]
5584    #[case::market_if_touched(OrderType::MarketIfTouched, BybitOrderType::Market, true)]
5585    #[case::limit_if_touched(OrderType::LimitIfTouched, BybitOrderType::Limit, true)]
5586    fn test_map_order_type(
5587        #[case] input: OrderType,
5588        #[case] expected_type: BybitOrderType,
5589        #[case] expected_conditional: bool,
5590    ) {
5591        let (bybit_type, is_conditional) = BybitExecutionClient::map_order_type(input).unwrap();
5592        assert_eq!(bybit_type, expected_type);
5593        assert_eq!(is_conditional, expected_conditional);
5594    }
5595
5596    #[rstest]
5597    fn test_map_order_type_rejects_trailing_stop() {
5598        BybitExecutionClient::map_order_type(OrderType::TrailingStopMarket).unwrap_err();
5599    }
5600
5601    #[rstest]
5602    #[case::linear("BTCUSDT-LINEAR", true)]
5603    #[case::inverse("BTCUSD-INVERSE", true)]
5604    #[case::spot("BTCUSDT-SPOT", false)]
5605    #[case::option("BTC-30JUN25-100000-C-OPTION", false)]
5606    fn test_parse_derivative_symbol_filters_product_type(
5607        #[case] symbol_str: &str,
5608        #[case] keeps: bool,
5609    ) {
5610        let result = BybitExecutionClient::parse_derivative_symbol(symbol_str);
5611        assert_eq!(result.is_some(), keeps);
5612    }
5613
5614    #[rstest]
5615    fn test_parse_derivative_symbol_rejects_malformed() {
5616        assert!(BybitExecutionClient::parse_derivative_symbol("not-a-real-symbol").is_none());
5617    }
5618
5619    #[rstest]
5620    #[case::matches_msg("Position mode has not been modified", "110025", true)]
5621    #[case::matches_code("retCode 110025: noop", "110025", true)]
5622    #[case::matches_msg_only("Already not been modified", "", true)]
5623    #[case::wrong_code("retCode 99999: other", "110025", false)]
5624    #[case::empty_no_modified_msg("retCode 99999", "", false)]
5625    fn test_is_unchanged_error(#[case] msg: &str, #[case] code: &str, #[case] expected: bool) {
5626        let err = anyhow::anyhow!("{msg}");
5627        assert_eq!(
5628            BybitExecutionClient::is_unchanged_error(&err, code),
5629            expected
5630        );
5631    }
5632
5633    #[rstest]
5634    #[case::matches("Margin needs to be equal to or greater than 0.5", true)]
5635    #[case::no_match("Some other error", false)]
5636    fn test_is_low_margin_error(#[case] msg: &str, #[case] expected: bool) {
5637        let err = anyhow::anyhow!("{msg}");
5638        assert_eq!(BybitExecutionClient::is_low_margin_error(&err), expected);
5639    }
5640
5641    #[rstest]
5642    fn test_submit_rejection_reason_matches_confirmed_rejection() {
5643        let err = anyhow::Error::from(BybitSubmitOrderError::Rejected {
5644            reason: "EC_PostOnlyWillTakeLiquidity".to_string(),
5645        });
5646
5647        assert_eq!(
5648            submit_rejection_reason(&err),
5649            Some("EC_PostOnlyWillTakeLiquidity"),
5650        );
5651    }
5652
5653    #[rstest]
5654    fn test_submit_rejection_reason_ignores_post_submit_lookup_failure() {
5655        let err = anyhow::Error::from(BybitSubmitOrderError::PostSubmitLookup {
5656            source: anyhow::Error::from(BybitHttpError::BybitError {
5657                error_code: 110017,
5658                message: "current position is zero, cannot fix reduce-only order qty".to_string(),
5659            }),
5660        })
5661        .context("Submit order failed");
5662
5663        assert_eq!(submit_rejection_reason(&err), None);
5664    }
5665
5666    #[rstest]
5667    fn test_submit_rejection_reason_ignores_missing_order_id() {
5668        let err = anyhow::Error::from(BybitSubmitOrderError::MissingOrderId);
5669
5670        assert_eq!(submit_rejection_reason(&err), None);
5671    }
5672
5673    #[rstest]
5674    fn test_submit_rejection_reason_matches_venue_http_error() {
5675        let err = anyhow::Error::from(BybitHttpError::BybitError {
5676            error_code: 110017,
5677            message: "current position is zero, cannot fix reduce-only order qty".to_string(),
5678        });
5679
5680        assert_eq!(
5681            submit_rejection_reason(&err),
5682            Some("current position is zero, cannot fix reduce-only order qty"),
5683        );
5684    }
5685
5686    #[rstest]
5687    fn test_submit_rejection_reason_ignores_ambiguous_http_error() {
5688        let err = anyhow::Error::from(BybitHttpError::BybitError {
5689            error_code: 10016,
5690            message: "rate limit exceeded".to_string(),
5691        });
5692
5693        assert_eq!(submit_rejection_reason(&err), None);
5694    }
5695
5696    #[rstest]
5697    #[case::buy(Some(OrderSide::Buy), vec![0, 2])]
5698    #[case::sell(Some(OrderSide::Sell), vec![1, 3])]
5699    #[tokio::test]
5700    async fn test_cancel_all_orders_filters_by_side_and_preserves_owners(
5701        #[case] order_side: Option<OrderSide>,
5702        #[case] expected_indices: Vec<usize>,
5703    ) {
5704        let (mut client, cache) = test_execution_client();
5705        let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel();
5706        client.emitter.set_sender(tx);
5707        client.ws_trade.close().await.unwrap();
5708
5709        let instrument_id = InstrumentId::from("BTCUSDT-LINEAR.BYBIT");
5710        let other_instrument_id = InstrumentId::from("ETHUSDT-LINEAR.BYBIT");
5711        let account_id = client.core.account_id;
5712        let mut orders = Vec::new();
5713
5714        for (index, (instrument, owner, side, open)) in [
5715            (instrument_id, "S-001", OrderSide::Buy, true),
5716            (instrument_id, "S-001", OrderSide::Sell, true),
5717            (instrument_id, "S-002", OrderSide::Buy, true),
5718            (instrument_id, "S-002", OrderSide::Sell, true),
5719            (other_instrument_id, "S-001", OrderSide::Buy, true),
5720            (other_instrument_id, "S-002", OrderSide::Sell, true),
5721            (instrument_id, "S-001", OrderSide::Buy, false),
5722            (instrument_id, "S-002", OrderSide::Sell, false),
5723        ]
5724        .into_iter()
5725        .enumerate()
5726        {
5727            let client_order_id = ClientOrderId::from(format!("O-CANCEL-ALL-{index}"));
5728            let mut builder = OrderTestBuilder::new(OrderType::Limit);
5729            let order = builder
5730                .instrument_id(instrument)
5731                .client_order_id(client_order_id)
5732                .strategy_id(StrategyId::from(owner))
5733                .side(side)
5734                .quantity(Quantity::from("1"))
5735                .price(Price::from("10000.00"))
5736                .build();
5737            let venue_order_id = VenueOrderId::from(format!("BYBIT-{index}"));
5738            let accepted = TestOrderEventStubs::accepted(&order, account_id, venue_order_id);
5739            cache
5740                .borrow_mut()
5741                .add_order(order.clone(), None, Some(*BYBIT_CLIENT_ID), false)
5742                .unwrap();
5743            let order = cache.borrow_mut().update_order(&accepted).unwrap();
5744
5745            if !open {
5746                let canceled =
5747                    TestOrderEventStubs::canceled(&order, account_id, Some(venue_order_id));
5748                cache.borrow_mut().update_order(&canceled).unwrap();
5749            }
5750
5751            orders.push((order, venue_order_id));
5752        }
5753
5754        client
5755            .cancel_all_orders(CancelAllOrders::new(
5756                TraderId::from("TESTER-001"),
5757                Some(*BYBIT_CLIENT_ID),
5758                StrategyId::from("S-001"),
5759                instrument_id,
5760                order_side,
5761                UUID4::new(),
5762                UnixNanos::default(),
5763                None,
5764                None,
5765            ))
5766            .unwrap();
5767        wait_for_spawned_tasks(&client).await;
5768
5769        // The closed transport rejects the batch, exposing selection and
5770        // event ownership through the existing failure path.
5771        let mut actual = Vec::new();
5772
5773        for _ in &expected_indices {
5774            let event = rx.try_recv().expect("expected OrderCancelDenied event");
5775            match event {
5776                ExecutionEvent::Order(OrderEventAny::CancelDenied(rejected)) => {
5777                    actual.push((rejected.client_order_id, rejected.strategy_id));
5778                }
5779                event => panic!("expected OrderCancelDenied, was {event:?}"),
5780            }
5781        }
5782
5783        let mut expected: Vec<_> = expected_indices
5784            .iter()
5785            .map(|&index| {
5786                let (order, _) = &orders[index];
5787                (order.client_order_id(), order.strategy_id())
5788            })
5789            .collect();
5790
5791        actual.sort();
5792        expected.sort();
5793
5794        assert_eq!(actual, expected);
5795        assert!(rx.try_recv().is_err());
5796    }
5797
5798    #[rstest]
5799    #[tokio::test]
5800    async fn test_cancel_all_orders_with_side_and_empty_cache_sends_nothing() {
5801        let (mut client, _cache) = test_execution_client();
5802        let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel();
5803        client.emitter.set_sender(tx);
5804        client.ws_trade.close().await.unwrap();
5805
5806        client
5807            .cancel_all_orders(CancelAllOrders::new(
5808                TraderId::from("TESTER-001"),
5809                Some(*BYBIT_CLIENT_ID),
5810                StrategyId::from("S-001"),
5811                InstrumentId::from("BTCUSDT-LINEAR.BYBIT"),
5812                Some(OrderSide::Buy),
5813                UUID4::new(),
5814                UnixNanos::default(),
5815                None,
5816                None,
5817            ))
5818            .unwrap();
5819        wait_for_spawned_tasks(&client).await;
5820
5821        assert!(rx.try_recv().is_err());
5822        assert!(client.dispatch_state.pending_requests.is_empty());
5823    }
5824
5825    #[rstest]
5826    #[case::working("New", "0")]
5827    #[case::filled("Filled", "0.010")]
5828    #[tokio::test]
5829    async fn test_cancel_all_orders_leaves_unconfirmed_cancellation_open(
5830        #[case] status: &str,
5831        #[case] filled_qty: &str,
5832    ) {
5833        let json = crate::common::testing::load_test_json("http_get_orders_realtime.json");
5834        let mut orders: serde_json::Value = serde_json::from_str(&json).unwrap();
5835        orders["result"]["list"][0]["orderStatus"] = serde_json::json!(status);
5836        orders["result"]["list"][0]["cumExecQty"] = serde_json::json!(filled_qty);
5837        orders["result"]["list"][0]["avgPrice"] = serde_json::json!("3930.41");
5838        let mut empty = orders.clone();
5839        empty["result"]["list"] = serde_json::json!([]);
5840        let history = empty.clone();
5841        let queried = Arc::new(AtomicBool::new(false));
5842        let query_observed = Arc::clone(&queried);
5843
5844        let router = Router::new()
5845            .route(
5846                "/v5/order/cancel-all",
5847                post(move || std::future::ready(Json(empty.clone()))),
5848            )
5849            .route(
5850                "/v5/order/history",
5851                get(move || std::future::ready(Json(history.clone()))),
5852            )
5853            .route(
5854                "/v5/order/realtime",
5855                get(move || {
5856                    query_observed.store(true, Ordering::Relaxed);
5857                    std::future::ready(Json(orders.clone()))
5858                }),
5859            );
5860
5861        let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
5862        let addr = listener.local_addr().unwrap();
5863        let server = tokio::spawn(async move { axum::serve(listener, router).await.unwrap() });
5864
5865        let (mut client, cache) = test_execution_client();
5866        let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel();
5867        client.emitter.set_sender(tx);
5868        client.config.http_timeout_secs = 1;
5869        client.config.retry_delay_initial_ms = 10;
5870        client.http_client = BybitHttpClient::with_credentials(
5871            "test_key".to_string(),
5872            "test_secret".to_string(),
5873            Some(format!("http://{addr}")),
5874            1,
5875            0,
5876            10,
5877            10,
5878            5_000,
5879            None,
5880        )
5881        .unwrap();
5882        let instrument_id = InstrumentId::from("ETHUSDT-LINEAR.BYBIT");
5883        let mut instrument = crypto_perpetual_ethusdt();
5884        instrument.id = instrument_id;
5885        client.http_client.cache_instrument(instrument.into());
5886        let mut builder = OrderTestBuilder::new(OrderType::Limit);
5887        let order = builder
5888            .instrument_id(instrument_id)
5889            .client_order_id(ClientOrderId::from("client-open-1"))
5890            .side(OrderSide::Buy)
5891            .quantity(Quantity::from("0.01"))
5892            .price(Price::from("3930.41"))
5893            .build();
5894        let accepted = TestOrderEventStubs::accepted(
5895            &order,
5896            client.core.account_id,
5897            VenueOrderId::from("open-order-1"),
5898        );
5899        cache
5900            .borrow_mut()
5901            .add_order(order.clone(), None, Some(*BYBIT_CLIENT_ID), false)
5902            .unwrap();
5903        cache.borrow_mut().update_order(&accepted).unwrap();
5904        client
5905            .cancel_all_orders(CancelAllOrders::new(
5906                TraderId::from("TESTER-001"),
5907                Some(*BYBIT_CLIENT_ID),
5908                order.strategy_id(),
5909                instrument_id,
5910                None,
5911                UUID4::new(),
5912                UnixNanos::default(),
5913                None,
5914                None,
5915            ))
5916            .unwrap();
5917        wait_until_async(
5918            || async { client.pending_tasks.all_finished() },
5919            Duration::from_secs(5),
5920        )
5921        .await;
5922
5923        assert!(queried.load(Ordering::Relaxed));
5924        assert_eq!(
5925            cache
5926                .borrow()
5927                .order(&order.client_order_id())
5928                .unwrap()
5929                .status(),
5930            OrderStatus::Accepted
5931        );
5932        assert!(rx.try_recv().is_err());
5933        server.abort();
5934    }
5935
5936    #[rstest]
5937    #[tokio::test]
5938    async fn test_batch_cancel_orders_failure_preserves_owning_strategies() {
5939        let (mut client, _cache) = test_execution_client();
5940        let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel();
5941        client.emitter.set_sender(tx);
5942        client.ws_trade.close().await.unwrap();
5943
5944        let instrument_id = InstrumentId::from("BTCUSDT-LINEAR.BYBIT");
5945
5946        let cancels = ["S-001", "S-002"]
5947            .into_iter()
5948            .enumerate()
5949            .map(|(index, owner)| {
5950                CancelOrder::new(
5951                    TraderId::from("TESTER-001"),
5952                    Some(*BYBIT_CLIENT_ID),
5953                    StrategyId::from(owner),
5954                    instrument_id,
5955                    ClientOrderId::from(format!("O-BATCH-OWNER-{index}")),
5956                    Some(VenueOrderId::from(format!("BYBIT-BATCH-{index}"))),
5957                    UUID4::new(),
5958                    UnixNanos::default(),
5959                    None,
5960                    None,
5961                )
5962            })
5963            .collect::<Vec<_>>();
5964
5965        client
5966            .batch_cancel_orders(BatchCancelOrders::new(
5967                TraderId::from("TESTER-001"),
5968                Some(*BYBIT_CLIENT_ID),
5969                StrategyId::from("S-001"),
5970                instrument_id,
5971                cancels.clone(),
5972                UUID4::new(),
5973                UnixNanos::default(),
5974                None,
5975                None,
5976            ))
5977            .unwrap();
5978        wait_for_spawned_tasks(&client).await;
5979
5980        let mut actual = Vec::new();
5981
5982        for _ in &cancels {
5983            let event = rx.try_recv().expect("expected OrderCancelDenied event");
5984            match event {
5985                ExecutionEvent::Order(OrderEventAny::CancelDenied(rejected)) => {
5986                    actual.push((
5987                        rejected.client_order_id,
5988                        rejected.strategy_id,
5989                        rejected.causation_id,
5990                    ));
5991                }
5992                event => panic!("expected OrderCancelDenied, was {event:?}"),
5993            }
5994        }
5995
5996        let mut expected: Vec<_> = cancels
5997            .iter()
5998            .map(|cancel| {
5999                (
6000                    cancel.client_order_id,
6001                    cancel.strategy_id,
6002                    Some(cancel.command_id),
6003                )
6004            })
6005            .collect();
6006
6007        actual.sort_by_key(|entry| entry.0);
6008        expected.sort_by_key(|entry| entry.0);
6009
6010        assert_eq!(actual, expected);
6011        assert!(rx.try_recv().is_err());
6012    }
6013
6014    #[rstest]
6015    #[tokio::test]
6016    async fn test_batch_modify_orders_failure_preserves_owning_strategies() {
6017        let (mut client, _cache) = test_execution_client();
6018        let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel();
6019        client.emitter.set_sender(tx);
6020        client.ws_trade.close().await.unwrap();
6021
6022        let instrument_id = InstrumentId::from("BTCUSDT-LINEAR.BYBIT");
6023
6024        let modifies = ["S-001", "S-002"]
6025            .into_iter()
6026            .enumerate()
6027            .map(|(index, owner)| {
6028                ModifyOrder::new(
6029                    TraderId::from("TESTER-001"),
6030                    Some(*BYBIT_CLIENT_ID),
6031                    StrategyId::from(owner),
6032                    instrument_id,
6033                    ClientOrderId::from(format!("O-BATCH-MODIFY-{index}")),
6034                    Some(VenueOrderId::from(format!("BYBIT-BATCH-MODIFY-{index}"))),
6035                    Some(Quantity::from("1")),
6036                    Some(Price::from("10001.00")),
6037                    None,
6038                    UUID4::new(),
6039                    UnixNanos::default(),
6040                    None,
6041                    None,
6042                )
6043            })
6044            .collect::<Vec<_>>();
6045
6046        client
6047            .batch_modify_orders(BatchModifyOrders::new(
6048                TraderId::from("TESTER-001"),
6049                Some(*BYBIT_CLIENT_ID),
6050                StrategyId::from("S-001"),
6051                instrument_id,
6052                modifies.clone(),
6053                UUID4::new(),
6054                UnixNanos::default(),
6055                None,
6056                None,
6057            ))
6058            .unwrap();
6059        wait_for_spawned_tasks(&client).await;
6060
6061        let mut actual = Vec::new();
6062
6063        for _ in &modifies {
6064            let event = rx.try_recv().expect("expected OrderModifyDenied event");
6065            match event {
6066                ExecutionEvent::Order(OrderEventAny::ModifyDenied(denied)) => {
6067                    actual.push((
6068                        denied.client_order_id,
6069                        denied.strategy_id,
6070                        denied.venue_order_id,
6071                        denied.causation_id,
6072                    ));
6073                }
6074                event => panic!("expected OrderModifyDenied, was {event:?}"),
6075            }
6076        }
6077
6078        let mut expected: Vec<_> = modifies
6079            .iter()
6080            .map(|modify| {
6081                (
6082                    modify.client_order_id,
6083                    modify.strategy_id,
6084                    modify.venue_order_id,
6085                    Some(modify.command_id),
6086                )
6087            })
6088            .collect();
6089
6090        actual.sort_by_key(|entry| entry.0);
6091        expected.sort_by_key(|entry| entry.0);
6092
6093        assert_eq!(actual, expected);
6094        assert!(rx.try_recv().is_err());
6095    }
6096
6097    #[rstest]
6098    #[tokio::test]
6099    async fn test_batch_modify_orders_denies_invalid_order_iv_and_unsent_valid_sibling() {
6100        let (mut client, _cache) = test_execution_client();
6101        let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel();
6102        client.emitter.set_sender(tx);
6103        client.ws_trade.close().await.unwrap();
6104
6105        let instrument_id = InstrumentId::from("BTCUSDT-LINEAR.BYBIT");
6106        let invalid_params =
6107            Params::new([("order_iv".to_string(), serde_json::json!({ "bad": true }))].into());
6108
6109        let invalid = ModifyOrder::new(
6110            TraderId::from("TESTER-001"),
6111            Some(*BYBIT_CLIENT_ID),
6112            StrategyId::from("S-INVALID"),
6113            instrument_id,
6114            ClientOrderId::from("O-BATCH-IV-INVALID"),
6115            Some(VenueOrderId::from("BYBIT-IV-INVALID")),
6116            Some(Quantity::from("1")),
6117            Some(Price::from("10001.00")),
6118            None,
6119            UUID4::new(),
6120            UnixNanos::default(),
6121            Some(invalid_params),
6122            None,
6123        );
6124
6125        let valid = ModifyOrder::new(
6126            TraderId::from("TESTER-001"),
6127            Some(*BYBIT_CLIENT_ID),
6128            StrategyId::from("S-VALID"),
6129            instrument_id,
6130            ClientOrderId::from("O-BATCH-IV-VALID"),
6131            Some(VenueOrderId::from("BYBIT-IV-VALID")),
6132            Some(Quantity::from("2")),
6133            Some(Price::from("10002.00")),
6134            None,
6135            UUID4::new(),
6136            UnixNanos::default(),
6137            None,
6138            None,
6139        );
6140
6141        client
6142            .batch_modify_orders(BatchModifyOrders::new(
6143                TraderId::from("TESTER-001"),
6144                Some(*BYBIT_CLIENT_ID),
6145                StrategyId::from("S-BATCH"),
6146                instrument_id,
6147                vec![invalid.clone(), valid.clone()],
6148                UUID4::new(),
6149                UnixNanos::default(),
6150                None,
6151                None,
6152            ))
6153            .unwrap();
6154        wait_for_spawned_tasks(&client).await;
6155
6156        for modify in [&invalid, &valid] {
6157            let event = rx.try_recv().expect("expected OrderModifyDenied event");
6158
6159            let ExecutionEvent::Order(OrderEventAny::ModifyDenied(denied)) = event else {
6160                panic!("expected OrderModifyDenied, was {event:?}");
6161            };
6162
6163            assert_eq!(denied.client_order_id, modify.client_order_id);
6164            assert_eq!(denied.strategy_id, modify.strategy_id);
6165            assert_eq!(denied.venue_order_id, modify.venue_order_id);
6166            assert_eq!(denied.causation_id, Some(modify.command_id));
6167        }
6168
6169        assert!(rx.try_recv().is_err());
6170    }
6171}