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