1use 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#[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 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 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 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 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 #[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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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, );
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, );
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 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}