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