1use std::{
42 sync::{
43 Arc,
44 atomic::{AtomicU64, Ordering},
45 },
46 time::{Duration, Instant},
47};
48
49use ahash::AHashMap;
50use anyhow::Context;
51use async_trait::async_trait;
52use dashmap::DashMap;
53use futures_util::{Stream, StreamExt, pin_mut};
54use nautilus_common::{
55 clients::ExecutionClient,
56 live::runner::get_exec_event_sender,
57 messages::execution::{
58 BatchCancelOrders, CancelAllOrders, CancelOrder, GenerateFillReports,
59 GenerateOrderStatusReport, GenerateOrderStatusReports, GeneratePositionStatusReports,
60 ModifyOrder, QueryAccount, QueryOrder, SubmitOrder, SubmitOrderList,
61 },
62};
63use nautilus_core::{
64 DurationNanos, Params, UUID4, UnixNanos,
65 time::{AtomicTime, get_atomic_clock_realtime},
66};
67use nautilus_live::{
68 ExecutionClientCore, ExecutionEventEmitter, SocketControlFactory,
69 execution::{failure::CommandFailure, reports::retain_order_status_reports},
70 task::{TaskGroup, TaskGroupGuard},
71};
72use nautilus_model::{
73 accounts::AccountAny,
74 enums::{AccountType, OmsType, OrderStatus, OrderType, TimeInForce},
75 events::{
76 AccountState, OrderAccepted, OrderCanceled, OrderDeniedReason, OrderEventAny, OrderExpired,
77 },
78 identifiers::{
79 AccountId, ClientId, ClientOrderId, InstrumentId, StrategyId, Symbol, Venue, VenueOrderId,
80 },
81 instruments::{Instrument, InstrumentAny},
82 orders::{Order, OrderAny},
83 reports::{ExecutionMassStatus, FillReport, OrderStatusReport, PositionStatusReport},
84 types::{AccountBalance, Currency, MarginBalance, Money},
85};
86use nautilus_network::retry::RetryConfig;
87use parking_lot::Mutex;
88use rust_decimal::Decimal;
89
90use crate::{
91 common::{
92 consts::DYDX_VENUE,
93 credential::{DydxCredential, credential_env_vars},
94 instrument_cache::InstrumentCache,
95 parse::nanos_to_secs_i64,
96 },
97 config::DydxAdapterConfig,
98 error::DydxError,
99 execution::{
100 broadcaster::TxBroadcaster,
101 encoder::ClientOrderIdEncoder,
102 order_builder::OrderMessageBuilder,
103 tx_manager::TransactionManager,
104 types::{LimitOrderParams, OrderContext},
105 },
106 grpc::{DydxGrpcClient, SHORT_TERM_ORDER_MAXIMUM_LIFETIME, types::ChainId},
107 http::{
108 client::DydxHttpClient,
109 parse::{
110 parse_account_state, parse_fill_report, parse_order_status_report,
111 parse_position_status_report,
112 },
113 },
114 websocket::{
115 DydxWsDispatchState, OrderIdentity,
116 client::DydxWebSocketClient,
117 enums::DydxWsOutputMessage,
118 fill_report_to_order_filled,
119 parse::{parse_ws_fill_report, parse_ws_order_report, parse_ws_position_report},
120 },
121};
122
123pub mod block_time;
124pub mod broadcaster;
125pub mod encoder;
126pub mod order_builder;
127pub mod submitter;
128pub mod tx_manager;
129pub mod types;
130pub mod wallet;
131
132use block_time::BlockTimeMonitor;
133
134const DYDX_INDEXER_REPORT_LIMIT: u32 = 1_000;
135
136#[derive(Debug)]
148pub struct DydxExecutionClient {
149 core: ExecutionClientCore,
150 clock: &'static AtomicTime,
151 config: DydxAdapterConfig,
152 emitter: ExecutionEventEmitter,
153 http_client: DydxHttpClient,
154 ws_client: DydxWebSocketClient,
155 grpc_client: Arc<tokio::sync::RwLock<Option<DydxGrpcClient>>>,
156 instrument_cache: Arc<InstrumentCache>,
157 block_time_monitor: Arc<BlockTimeMonitor>,
158 oracle_prices: Arc<DashMap<InstrumentId, Decimal>>,
159 encoder: Arc<ClientOrderIdEncoder>,
160 dispatch_state: Arc<DydxWsDispatchState>,
161 order_contexts: Arc<DashMap<u32, OrderContext>>,
162 order_id_map: Arc<DashMap<String, (u32, u32)>>,
163 wallet_address: String,
164 subaccount_number: u32,
165 tx_manager: Option<Arc<TransactionManager>>,
166 broadcaster: Option<Arc<TxBroadcaster>>,
167 order_builder: Option<Arc<OrderMessageBuilder>>,
168 session_tasks: TaskGroup,
169 pending_tasks: TaskGroup,
170 shutdown_errors: Vec<String>,
171 pending_task_labels: Arc<Mutex<AHashMap<u64, &'static str>>>,
172 next_pending_task_id: AtomicU64,
173}
174
175impl DydxExecutionClient {
176 pub fn new(
182 core: ExecutionClientCore,
183 config: DydxAdapterConfig,
184 wallet_address: String,
185 subaccount_number: u32,
186 ) -> anyhow::Result<Self> {
187 config.validate()?;
188
189 let trader_id = core.trader_id;
190 let account_id = core.account_id;
191 let clock = get_atomic_clock_realtime();
192 let emitter =
193 ExecutionEventEmitter::new(clock, trader_id, account_id, AccountType::Margin, None);
194
195 let retry_config = RetryConfig {
196 max_retries: config.max_retries,
197 initial_delay_ms: config.retry_delay_initial_ms,
198 max_delay_ms: config.retry_delay_max_ms,
199 ..Default::default()
200 };
201 let http_client = DydxHttpClient::new(
202 Some(config.base_url.clone()),
203 config.timeout_secs,
204 config
205 .proxy_url
206 .as_ref()
207 .map(|value| value.expose_secret().to_owned()),
208 config.network,
209 Some(retry_config),
210 )?;
211
212 let instrument_cache = http_client.instrument_cache().clone();
213
214 let credential = DydxCredential::resolve(
215 config
216 .private_key
217 .as_ref()
218 .map(|value| value.expose_secret()),
219 config.network,
220 config.authenticator_ids.clone(),
221 )?
222 .ok_or_else(|| anyhow::anyhow!("Credentials required for execution client"))?;
223
224 let ws_client = DydxWebSocketClient::new_private_with_cache(
225 config.ws_url.clone(),
226 credential,
227 core.account_id,
228 instrument_cache.clone(),
229 Some(20),
230 config.transport_backend,
231 config
232 .proxy_url
233 .as_ref()
234 .map(|value| value.expose_secret().to_owned()),
235 )
236 .with_socket_factory(SocketControlFactory::new(core.client_id, Some(*DYDX_VENUE)));
237
238 let grpc_client = Arc::new(tokio::sync::RwLock::new(None));
239
240 let session_tasks = TaskGroup::new();
241 let pending_tasks = TaskGroup::new();
242
243 Ok(Self {
244 core,
245 clock,
246 config,
247 emitter,
248 http_client,
249 ws_client,
250 grpc_client,
251 instrument_cache,
252 block_time_monitor: Arc::new(BlockTimeMonitor::new()),
253 oracle_prices: Arc::new(DashMap::new()),
254 encoder: Arc::new(ClientOrderIdEncoder::new()),
255 dispatch_state: Arc::new(DydxWsDispatchState::default()),
256 order_contexts: Arc::new(DashMap::new()),
257 order_id_map: Arc::new(DashMap::new()),
258 wallet_address,
259 subaccount_number,
260 tx_manager: None,
261 broadcaster: None,
262 order_builder: None,
263 session_tasks,
264 pending_tasks,
265 shutdown_errors: Vec::new(),
266 pending_task_labels: Arc::new(Mutex::new(AHashMap::new())),
267 next_pending_task_id: AtomicU64::new(0),
268 })
269 }
270
271 fn resolve_private_key(config: &DydxAdapterConfig) -> anyhow::Result<String> {
272 let (private_key_env, _) = credential_env_vars(config.network);
273
274 if let Some(ref pk) = config.private_key
275 && !pk.expose_secret().trim().is_empty()
276 {
277 return Ok(pk.expose_secret().to_owned());
278 }
279
280 if let Some(pk) = std::env::var(private_key_env)
281 .ok()
282 .filter(|s| !s.trim().is_empty())
283 {
284 return Ok(pk);
285 }
286
287 anyhow::bail!("{private_key_env} not found in config or environment")
288 }
289
290 fn register_order_context(&self, client_id_u32: u32, context: OrderContext) {
291 self.order_contexts.insert(client_id_u32, context);
292 }
293
294 fn get_order_context(&self, client_id_u32: u32) -> Option<OrderContext> {
295 self.order_contexts
296 .get(&client_id_u32)
297 .map(|r| r.value().clone())
298 }
299
300 fn get_chain_id(&self) -> ChainId {
301 self.config.get_chain_id()
302 }
303
304 fn spawn_ws_stream_handler(
305 &self,
306 stream: impl Stream<Item = DydxWsOutputMessage> + Send + 'static,
307 ) -> anyhow::Result<()> {
308 if !self.session_tasks.is_empty() {
309 anyhow::bail!("dYdX WebSocket stream task is already registered");
310 }
311
312 log::debug!("Starting execution WebSocket message processing task");
313
314 let trader_id = self.core.trader_id;
315 let account_id = self.core.account_id;
316 let instrument_cache = self.instrument_cache.clone();
317 let oracle_prices = self.oracle_prices.clone();
318 let encoder = self.encoder.clone();
319 let order_contexts = self.order_contexts.clone();
320 let order_id_map = self.order_id_map.clone();
321 let dispatch_state = self.dispatch_state.clone();
322 let block_time_monitor = self.block_time_monitor.clone();
323 let emitter = self.emitter.clone();
324 let clock = self.clock;
325
326 let future = async move {
327 log::debug!("Execution WebSocket message loop started");
328
329 let mut cum_fill_totals: AHashMap<VenueOrderId, (Decimal, Decimal)> = AHashMap::new();
330
331 pin_mut!(stream);
332 while let Some(msg) = stream.next().await {
333 match msg {
334 DydxWsOutputMessage::SubaccountSubscribed(msg) => {
335 log::debug!("Parsing subaccount subscription with full context");
336
337 let inst_map = instrument_cache.to_instrument_id_map();
338
339 let oracle_map: std::collections::HashMap<_, _> = oracle_prices
340 .iter()
341 .map(|entry| (*entry.key(), *entry.value()))
342 .collect();
343
344 let ts_init = clock.get_time_ns();
345 let ts_event = ts_init;
346
347 if let Some(ref subaccount) = msg.contents.subaccount {
348 match parse_account_state(
349 subaccount,
350 account_id,
351 &inst_map,
352 &oracle_map,
353 ts_event,
354 ts_init,
355 ) {
356 Ok(account_state) => {
357 log::debug!(
358 "Parsed account state: {} balance(s), {} margin(s)",
359 account_state.balances.len(),
360 account_state.margins.len()
361 );
362 emitter.send_account_state(account_state);
363 }
364 Err(e) => {
365 log::error!("Failed to parse account state: {e}");
366 }
367 }
368
369 if let Some(ref positions) = subaccount.open_perpetual_positions {
370 log::debug!(
371 "Parsing {} position(s) from subscription",
372 positions.len()
373 );
374
375 for (market, ws_position) in positions {
376 match parse_ws_position_report(
377 ws_position,
378 &instrument_cache,
379 account_id,
380 ts_init,
381 ) {
382 Ok(report) => {
383 log::debug!(
384 "Parsed position report: {} {} {} {}",
385 report.instrument_id,
386 report.position_side,
387 report.quantity,
388 market
389 );
390 emitter.send_position_report(report);
391 }
392 Err(e) => {
393 log::error!(
394 "Failed to parse WebSocket position for {market}: {e}"
395 );
396 }
397 }
398 }
399 }
400 } else {
401 log::warn!(
402 "Subaccount subscription without initial state (new/empty subaccount)"
403 );
404
405 let currency =
406 Currency::get_or_create_crypto_with_context("USDC", None);
407 let zero = Money::zero(currency);
408 let balance = AccountBalance::new_checked(zero, zero, zero)
409 .expect("zero balance should always be valid");
410 let account_state = AccountState::new(
411 account_id,
412 AccountType::Margin,
413 vec![balance],
414 vec![],
415 true,
416 UUID4::new(),
417 ts_init,
418 ts_init,
419 None,
420 );
421 emitter.send_account_state(account_state);
422 }
423 }
424 DydxWsOutputMessage::SubaccountsChannelData(data) => {
425 log::debug!(
426 "Processing subaccounts channel data (orders={:?}, fills={:?})",
427 data.contents.orders.as_ref().map(|o| o.len()),
428 data.contents.fills.as_ref().map(|f| f.len())
429 );
430 let ts_init = clock.get_time_ns();
431
432 let mut terminal_orders: Vec<(u32, u32, String)> = Vec::new();
433 let mut pending_order_reports = Vec::new();
434
435 if let Some(ref orders) = data.contents.orders {
436 for ws_order in orders {
437 log::debug!(
438 "Parsing WS order: clob_pair_id={}, status={:?}, client_id={}",
439 ws_order.clob_pair_id,
440 ws_order.status,
441 ws_order.client_id
442 );
443
444 if let Ok(client_id_u32) = ws_order.client_id.parse::<u32>() {
445 let client_meta = ws_order
446 .client_metadata
447 .as_ref()
448 .and_then(|s| s.parse::<u32>().ok())
449 .unwrap_or(crate::grpc::DEFAULT_RUST_CLIENT_METADATA);
450 order_id_map
451 .insert(ws_order.id.clone(), (client_id_u32, client_meta));
452 }
453
454 match parse_ws_order_report(
455 ws_order,
456 &instrument_cache,
457 &order_contexts,
458 &encoder,
459 account_id,
460 ts_init,
461 ) {
462 Ok(report) => {
463 if report.order_status.is_closed()
464 && let Ok(cid) = ws_order.client_id.parse::<u32>()
465 {
466 let meta = ws_order
467 .client_metadata
468 .as_ref()
469 .and_then(|s| s.parse::<u32>().ok())
470 .unwrap_or(
471 crate::grpc::DEFAULT_RUST_CLIENT_METADATA,
472 );
473 terminal_orders.push((cid, meta, ws_order.id.clone()));
474 }
475 let order_side = report
476 .order_side
477 .as_ref()
478 .map_or("NO_ORDER_SIDE", AsRef::as_ref);
479 log::debug!(
480 "Parsed order report: {} {} {:?} qty={} client_order_id={:?}",
481 report.instrument_id,
482 order_side,
483 report.order_status,
484 report.quantity,
485 report.client_order_id
486 );
487 pending_order_reports.push(report);
488 }
489 Err(e) => {
490 log::error!("Failed to parse WebSocket order: {e}");
491 }
492 }
493 }
494 }
495
496 if let Some(ref fills) = data.contents.fills {
498 for ws_fill in fills {
499 match parse_ws_fill_report(
500 ws_fill,
501 &instrument_cache,
502 &order_id_map,
503 &order_contexts,
504 &encoder,
505 account_id,
506 ts_init,
507 ) {
508 Ok(report) => {
509 log::debug!(
510 "Parsed fill report: {} {} {} @ {} client_order_id={:?}",
511 report.instrument_id,
512 report.venue_order_id,
513 report.last_qty,
514 report.last_px,
515 report.client_order_id
516 );
517
518 let identity = report.client_order_id.and_then(|cid| {
519 dispatch_state
520 .order_identities
521 .get(&cid)
522 .map(|r| (cid, r.clone()))
523 });
524
525 if let Some((cid, ident)) = identity {
526 if !dispatch_state.emitted_accepted.contains(&cid) {
527 dispatch_state.insert_accepted(cid);
528 let accepted = OrderAccepted::new(
529 trader_id,
530 ident.strategy_id,
531 ident.instrument_id,
532 cid,
533 report.venue_order_id,
534 account_id,
535 UUID4::new(),
536 ts_init,
537 ts_init,
538 false,
539 );
540 emitter.send_order_event(OrderEventAny::Accepted(
541 accepted,
542 ));
543 }
544
545 dispatch_state.insert_filled(cid);
546 let instrument =
547 instrument_cache.get(&report.instrument_id);
548 let quote_currency = instrument
549 .map_or_else(Currency::USD, |i: InstrumentAny| {
550 i.quote_currency()
551 });
552 let filled = fill_report_to_order_filled(
553 &report,
554 trader_id,
555 &ident,
556 quote_currency,
557 );
558 emitter.send_order_event(OrderEventAny::Filled(filled));
559 } else {
560 let entry = cum_fill_totals
561 .entry(report.venue_order_id)
562 .or_default();
563 let qty = report.last_qty.as_decimal();
564 entry.0 += report.last_px.as_decimal() * qty;
565 entry.1 += qty;
566 emitter.send_fill_report(report);
567 }
568 }
569 Err(e) => {
570 log::error!("Failed to parse WebSocket fill: {e}");
571 }
572 }
573 }
574 }
575
576 for report in &mut pending_order_reports {
577 if let Some((notional, total_qty)) =
578 cum_fill_totals.get(&report.venue_order_id)
579 && !total_qty.is_zero()
580 {
581 report.avg_px = Some(notional / total_qty);
582 }
583 }
584
585 for report in pending_order_reports {
586 let identity = report.client_order_id.and_then(|cid| {
587 dispatch_state
588 .order_identities
589 .get(&cid)
590 .map(|r| (cid, r.clone()))
591 });
592
593 if let Some((cid, ident)) = identity {
594 match report.order_status {
595 OrderStatus::Accepted => {
596 if dispatch_state.emitted_accepted.contains(&cid)
597 || dispatch_state.filled_orders.contains(&cid)
598 {
599 log::debug!("Skipping duplicate Accepted for {cid}");
600 continue;
601 }
602 dispatch_state.insert_accepted(cid);
603 let accepted = OrderAccepted::new(
604 trader_id,
605 ident.strategy_id,
606 ident.instrument_id,
607 cid,
608 report.venue_order_id,
609 account_id,
610 UUID4::new(),
611 report.ts_last,
612 ts_init,
613 false,
614 );
615 emitter.send_order_event(OrderEventAny::Accepted(accepted));
616 }
617 OrderStatus::Canceled => {
618 if !dispatch_state.emitted_accepted.contains(&cid) {
619 dispatch_state.insert_accepted(cid);
620 let accepted = OrderAccepted::new(
621 trader_id,
622 ident.strategy_id,
623 ident.instrument_id,
624 cid,
625 report.venue_order_id,
626 account_id,
627 UUID4::new(),
628 ts_init,
629 ts_init,
630 false,
631 );
632 emitter.send_order_event(OrderEventAny::Accepted(
633 accepted,
634 ));
635 }
636 let is_expiry = report
639 .expire_time
640 .is_some_and(|exp| report.ts_last >= exp);
641
642 if is_expiry {
643 let expired = OrderExpired::new(
644 trader_id,
645 ident.strategy_id,
646 ident.instrument_id,
647 cid,
648 UUID4::new(),
649 report.ts_last,
650 ts_init,
651 false,
652 Some(report.venue_order_id),
653 Some(account_id),
654 );
655 emitter
656 .send_order_event(OrderEventAny::Expired(expired));
657 } else {
658 let canceled = OrderCanceled::new(
659 trader_id,
660 ident.strategy_id,
661 ident.instrument_id,
662 cid,
663 UUID4::new(),
664 report.ts_last,
665 ts_init,
666 false,
667 Some(report.venue_order_id),
668 Some(account_id),
669 None,
670 );
671 emitter.send_order_event(OrderEventAny::Canceled(
672 canceled,
673 ));
674 }
675 dispatch_state.cleanup_terminal(&cid);
676 }
677 OrderStatus::Filled => {
678 dispatch_state.cleanup_terminal(&cid);
680 }
681 OrderStatus::Expired => {
682 if !dispatch_state.emitted_accepted.contains(&cid) {
688 dispatch_state.insert_accepted(cid);
689 let accepted = OrderAccepted::new(
690 trader_id,
691 ident.strategy_id,
692 ident.instrument_id,
693 cid,
694 report.venue_order_id,
695 account_id,
696 UUID4::new(),
697 ts_init,
698 ts_init,
699 false,
700 );
701 emitter.send_order_event(OrderEventAny::Accepted(
702 accepted,
703 ));
704 }
705 let expired = OrderExpired::new(
706 trader_id,
707 ident.strategy_id,
708 ident.instrument_id,
709 cid,
710 UUID4::new(),
711 report.ts_last,
712 ts_init,
713 false,
714 Some(report.venue_order_id),
715 Some(account_id),
716 );
717 emitter.send_order_event(OrderEventAny::Expired(expired));
718 dispatch_state.cleanup_terminal(&cid);
719 }
720 _ => {
721 emitter.send_order_status_report(report);
722 }
723 }
724 } else {
725 emitter.send_order_status_report(report);
726 }
727 }
728
729 for (client_id, client_metadata, order_id) in terminal_orders {
730 order_contexts.remove(&client_id);
731 encoder.remove(client_id, client_metadata);
732 order_id_map.remove(&order_id);
733 cum_fill_totals.remove(&VenueOrderId::new(&order_id));
734 }
735 }
736 DydxWsOutputMessage::Markets(contents) => {
737 if let Some(ref oracle_map) = contents.oracle_prices {
738 for (symbol_str, oracle_market) in oracle_map {
739 let instrument_id = {
740 let symbol = format!("{symbol_str}-PERP");
741 InstrumentId::new(
742 Symbol::new(&symbol),
743 *crate::common::consts::DYDX_VENUE,
744 )
745 };
746
747 if instrument_cache.get(&instrument_id).is_some()
748 && let Ok(price_dec) =
749 oracle_market.oracle_price.parse::<Decimal>()
750 {
751 oracle_prices.insert(instrument_id, price_dec);
752 log::trace!(
753 "Updated oracle price for {instrument_id}: {price_dec}"
754 );
755 }
756 }
757 }
758
759 if let Some(ref markets) = contents.markets {
760 for (symbol_str, market_data) in markets {
761 if let Some(oracle_price_str) = &market_data.oracle_price {
762 let instrument_id = {
763 let symbol = format!("{symbol_str}-PERP");
764 InstrumentId::new(
765 Symbol::new(&symbol),
766 *crate::common::consts::DYDX_VENUE,
767 )
768 };
769
770 if instrument_cache.get(&instrument_id).is_some()
771 && let Ok(price_dec) = oracle_price_str.parse::<Decimal>()
772 {
773 oracle_prices.insert(instrument_id, price_dec);
774 }
775 }
776 }
777 }
778 }
779 DydxWsOutputMessage::BlockHeight { height, time } => {
780 log::debug!("Block height update: {height} at {time}");
781 block_time_monitor.record_block(height, time);
782 }
783 DydxWsOutputMessage::Error(err) => {
784 log::warn!("WebSocket error: {err:?}");
785 }
786 DydxWsOutputMessage::Reconnected { .. } => {
787 log::info!("WebSocket reconnected");
788 }
789 _ => {}
790 }
791 }
792 log::debug!("WebSocket message processing task ended");
793 };
794
795 self.session_tasks
796 .spawn(future)
797 .context("failed to register dYdX execution WebSocket stream task")?;
798 log::debug!("WebSocket stream handler started");
799 Ok(())
800 }
801
802 fn mark_instruments_initialized(&self) {
803 let count = self.instrument_cache.len();
804 self.core.set_instruments_initialized();
805 log::debug!("Instruments initialized: {count} instruments in shared cache");
806 }
807
808 fn get_instrument_by_market(&self, market: &str) -> Option<InstrumentAny> {
809 self.instrument_cache.get_by_market(market)
810 }
811
812 fn get_instrument_by_clob_pair_id(&self, clob_pair_id: u32) -> Option<InstrumentAny> {
813 let instrument = self.instrument_cache.get_by_clob_id(clob_pair_id);
814
815 if instrument.is_none() {
816 self.instrument_cache.log_missing_clob_pair_id(clob_pair_id);
817 }
818
819 instrument
820 }
821
822 fn get_execution_components(
823 &self,
824 ) -> anyhow::Result<(
825 Arc<TransactionManager>,
826 Arc<TxBroadcaster>,
827 Arc<OrderMessageBuilder>,
828 )> {
829 let tx_manager = self
830 .tx_manager
831 .as_ref()
832 .ok_or_else(|| {
833 anyhow::anyhow!("TransactionManager not initialized - call connect() first")
834 })?
835 .clone();
836 let broadcaster = self
837 .broadcaster
838 .as_ref()
839 .ok_or_else(|| anyhow::anyhow!("TxBroadcaster not initialized - call connect() first"))?
840 .clone();
841 let order_builder = self
842 .order_builder
843 .as_ref()
844 .ok_or_else(|| {
845 anyhow::anyhow!("OrderMessageBuilder not initialized - call connect() first")
846 })?
847 .clone();
848 Ok((tx_manager, broadcaster, order_builder))
849 }
850
851 fn spawn_task<F>(&self, label: &'static str, fut: F)
852 where
853 F: Future<Output = anyhow::Result<()>> + Send + 'static,
854 {
855 let future = async move {
856 if let Err(e) = fut.await {
857 log::error!("{label}: {e:?}");
858 }
859 };
860
861 self.spawn_labeled(label, future);
862 }
863
864 fn spawn_order_task<F>(
867 &self,
868 label: &'static str,
869 strategy_id: StrategyId,
870 instrument_id: InstrumentId,
871 client_order_id: ClientOrderId,
872 fut: F,
873 ) where
874 F: Future<Output = anyhow::Result<()>> + Send + 'static,
875 {
876 let emitter = self.emitter.clone();
877 let clock = self.clock;
878
879 let future = async move {
880 if let Err(e) = fut.await {
881 if is_definitive_broadcast_rejection(&e) {
882 let error_msg = format!("{label} failed: {e:?}");
883 log::warn!("{error_msg}");
884
885 let ts_event = clock.get_time_ns();
886 emitter.emit_order_rejected_event(
887 strategy_id,
888 instrument_id,
889 client_order_id,
890 &error_msg,
891 ts_event,
892 false,
893 );
894 } else {
895 log::warn!(
896 "Ambiguous dYdX {label} failure for {client_order_id}, awaiting reconciliation: {e:?}"
897 );
898 }
899 }
900 };
901
902 self.spawn_labeled(label, future);
903 }
904
905 fn spawn_labeled<F>(&self, label: &'static str, future: F)
906 where
907 F: Future<Output = ()> + Send + 'static,
908 {
909 let id = self.next_pending_task_id.fetch_add(1, Ordering::Relaxed);
910 self.pending_task_labels.lock().insert(id, label);
911
912 let label_guard = PendingTaskLabel {
913 id,
914 labels: Arc::clone(&self.pending_task_labels),
915 };
916 let wrapped = async move {
917 let _label = label_guard;
918 future.await;
919 };
920
921 if let Err(e) = self.pending_tasks.spawn(wrapped) {
922 self.pending_task_labels.lock().remove(&id);
923 log::warn!("Skipping dYdX {label} after shutdown began: {e}");
924 }
925 }
926
927 fn begin_pending_shutdown(&self) {
928 let labels = self.pending_task_labels.lock();
929 let pending_cancels = labels
930 .values()
931 .filter(|label| label.contains("cancel"))
932 .count();
933 let pending_other = labels.len() - pending_cancels;
934
935 if pending_cancels > 0 {
936 log::warn!(
937 "Waiting for {pending_cancels} in-flight cancel task(s) before disconnect; orders may still be open on the venue"
938 );
939 }
940
941 if pending_other > 0 {
942 log::debug!("Waiting for {pending_other} other in-flight task(s) before disconnect");
943 }
944 drop(labels);
945
946 self.pending_tasks.begin_shutdown();
947 }
948
949 async fn finish_tasks(&self) -> anyhow::Result<()> {
950 let (session_result, pending_result) = tokio::join!(
951 self.session_tasks
952 .finish_shutdown(Duration::from_secs(1), Duration::from_secs(2)),
953 self.pending_tasks
954 .finish_shutdown(Duration::from_secs(2), Duration::from_secs(2)),
955 );
956 session_result.context("failed to finish dYdX execution session tasks")?;
957 pending_result.context("failed to finish dYdX execution command tasks")?;
958 Ok(())
959 }
960
961 async fn prepare_task_groups(&mut self) -> anyhow::Result<()> {
962 if !self.session_tasks.is_open() || !self.pending_tasks.is_open() {
963 self.session_tasks.begin_shutdown();
964 self.begin_pending_shutdown();
965 self.ws_client.begin_shutdown();
966 self.finish_shutdown().await?;
967 self.session_tasks
968 .start_generation()
969 .context("failed to start dYdX execution session task generation")?;
970 self.pending_tasks
971 .start_generation()
972 .context("failed to start dYdX execution command task generation")?;
973 }
974 Ok(())
975 }
976
977 async fn finish_shutdown(&mut self) -> anyhow::Result<()> {
978 if let Err(e) = self
979 .ws_client
980 .disconnect()
981 .await
982 .context("failed to disconnect dYdX websocket")
983 {
984 self.shutdown_errors.push(e.to_string());
985 }
986
987 if let Err(e) = self.finish_tasks().await {
988 self.shutdown_errors.push(e.to_string());
989 }
990
991 if !self.shutdown_errors.is_empty() {
992 anyhow::bail!(std::mem::take(&mut self.shutdown_errors).join("; "));
993 }
994 Ok(())
995 }
996
997 async fn teardown_partial_connect(&mut self) -> anyhow::Result<()> {
998 self.begin_pending_shutdown();
999 self.session_tasks.begin_shutdown();
1000 self.ws_client.begin_shutdown();
1001 let shutdown_result = self.finish_shutdown().await;
1002 self.core.set_disconnected();
1003 shutdown_result
1004 }
1005
1006 fn send_modify_denied(
1007 &self,
1008 strategy_id: StrategyId,
1009 instrument_id: InstrumentId,
1010 client_order_id: ClientOrderId,
1011 venue_order_id: Option<VenueOrderId>,
1012 reason: &str,
1013 causation_id: UUID4,
1014 ) {
1015 let ts_event = self.clock.get_time_ns();
1016 self.emitter.emit_order_modify_denied_event(
1017 strategy_id,
1018 instrument_id,
1019 client_order_id,
1020 venue_order_id,
1021 reason,
1022 ts_event,
1023 Some(causation_id),
1024 );
1025 }
1026
1027 async fn await_account_registered(&self, timeout_secs: f64) -> anyhow::Result<()> {
1028 let account_id = self.core.account_id;
1029
1030 if self.core.cache().account(&account_id).is_some() {
1031 log::info!("Account {account_id} registered");
1032 return Ok(());
1033 }
1034
1035 let start = Instant::now();
1036 let timeout = Duration::from_secs_f64(timeout_secs);
1037 let interval = Duration::from_millis(10);
1038
1039 loop {
1040 tokio::time::sleep(interval).await;
1041
1042 if self.core.cache().account(&account_id).is_some() {
1043 log::info!("Account {account_id} registered");
1044 return Ok(());
1045 }
1046
1047 if start.elapsed() >= timeout {
1048 anyhow::bail!(
1049 "Timeout waiting for account {account_id} to be registered after {timeout_secs}s"
1050 );
1051 }
1052 }
1053 }
1054}
1055
1056async fn broadcast_partitioned_cancels(
1064 orders: Vec<DydxCancelOrderRequest>,
1065 block_height: u32,
1066 tx_manager: Arc<TransactionManager>,
1067 broadcaster: Arc<TxBroadcaster>,
1068 order_builder: Arc<OrderMessageBuilder>,
1069 emitter: ExecutionEventEmitter,
1070 clock: &'static AtomicTime,
1071) -> anyhow::Result<()> {
1072 if orders.is_empty() {
1073 return Ok(());
1074 }
1075
1076 let (short_term_orders, long_term_orders): (Vec<_>, Vec<_>) = orders
1077 .into_iter()
1078 .partition(|order| order.order_flags == types::ORDER_FLAG_SHORT_TERM);
1079
1080 let mut errors = Vec::new();
1081
1082 if !short_term_orders.is_empty() {
1083 let st_pairs: Vec<_> = short_term_orders
1084 .iter()
1085 .map(|order| (order.instrument_id, order.client_id))
1086 .collect();
1087
1088 log::debug!(
1089 "Batch cancelling {} short-term orders with MsgBatchCancel",
1090 st_pairs.len()
1091 );
1092
1093 match order_builder.build_batch_cancel_short_term(&st_pairs, block_height) {
1094 Ok(msg) => {
1095 let operation = format!("BatchCancel {} short-term orders", st_pairs.len());
1096 match broadcaster
1097 .broadcast_short_term(&tx_manager, vec![msg], &operation)
1098 .await
1099 {
1100 Ok(tx_hash) => {
1101 log::debug!(
1102 "Successfully batch cancelled {} short-term orders, tx_hash: {}",
1103 st_pairs.len(),
1104 tx_hash
1105 );
1106 }
1107 Err(e) => {
1108 let msg = format!("Short-term batch cancel failed: {e:?}");
1109 log::warn!("{msg}");
1110
1111 if e.is_definitive_broadcast_rejection() {
1114 emit_partitioned_cancel_failure(
1115 &short_term_orders,
1116 &emitter,
1117 clock,
1118 &CommandFailure::venue_rejected(&msg),
1119 );
1120 }
1121 errors.push(msg);
1122 }
1123 }
1124 }
1125 Err(e) => {
1126 let msg = format!("Failed to build MsgBatchCancel: {e:?}");
1127 log::error!("{msg}");
1128 emit_partitioned_cancel_failure(
1129 &short_term_orders,
1130 &emitter,
1131 clock,
1132 &CommandFailure::not_sent(&msg),
1133 );
1134 errors.push(msg);
1135 }
1136 }
1137 }
1138
1139 if !long_term_orders.is_empty() {
1140 let lt_tuples: Vec<_> = long_term_orders
1141 .iter()
1142 .map(|order| (order.instrument_id, order.client_id, order.order_flags))
1143 .collect();
1144
1145 log::debug!(
1146 "Batch cancelling {} long-term orders",
1147 long_term_orders.len(),
1148 );
1149
1150 match order_builder.build_cancel_orders_batch_with_flags(<_tuples, block_height) {
1151 Ok(cancel_msgs) => {
1152 let operation = format!("BatchCancel {} long-term orders", long_term_orders.len());
1153 match broadcaster
1154 .broadcast_with_retry(&tx_manager, cancel_msgs, &operation)
1155 .await
1156 {
1157 Ok(tx_hash) => {
1158 log::debug!(
1159 "Successfully batch cancelled {} long-term orders, tx_hash: {}",
1160 long_term_orders.len(),
1161 tx_hash
1162 );
1163 }
1164 Err(e) => {
1165 let msg = format!("Long-term batch cancel failed: {e:?}");
1166 log::warn!("{msg}");
1167
1168 if e.is_definitive_broadcast_rejection() {
1169 emit_partitioned_cancel_failure(
1170 &long_term_orders,
1171 &emitter,
1172 clock,
1173 &CommandFailure::venue_rejected(&msg),
1174 );
1175 }
1176 errors.push(msg);
1177 }
1178 }
1179 }
1180 Err(e) => {
1181 let msg = format!("Failed to build long-term cancel messages: {e:?}");
1182 log::error!("{msg}");
1183 emit_partitioned_cancel_failure(
1184 &long_term_orders,
1185 &emitter,
1186 clock,
1187 &CommandFailure::not_sent(&msg),
1188 );
1189 errors.push(msg);
1190 }
1191 }
1192 }
1193
1194 if !errors.is_empty() {
1195 anyhow::bail!("partitioned cancel failed: {}", errors.join("; "));
1196 }
1197
1198 Ok(())
1199}
1200
1201fn emit_partitioned_cancel_failure(
1202 orders: &[DydxCancelOrderRequest],
1203 emitter: &ExecutionEventEmitter,
1204 clock: &AtomicTime,
1205 failure: &CommandFailure,
1206) {
1207 for order in orders {
1208 match failure {
1209 CommandFailure::NotSent(reason) => emitter.emit_order_cancel_denied_event(
1210 order.strategy_id,
1211 order.instrument_id,
1212 order.client_order_id,
1213 order.venue_order_id,
1214 reason,
1215 clock.get_time_ns(),
1216 Some(order.command_id),
1217 ),
1218 CommandFailure::VenueRejected(reason) => emitter.emit_order_cancel_rejected_event(
1219 order.strategy_id,
1220 order.instrument_id,
1221 order.client_order_id,
1222 order.venue_order_id,
1223 reason,
1224 clock.get_time_ns(),
1225 Some(order.command_id),
1226 ),
1227 CommandFailure::Ambiguous(_) => {}
1228 }
1229 }
1230}
1231
1232fn is_definitive_broadcast_rejection(err: &anyhow::Error) -> bool {
1233 err.downcast_ref::<DydxError>()
1234 .is_some_and(DydxError::is_definitive_broadcast_rejection)
1235}
1236
1237#[async_trait(?Send)]
1238impl ExecutionClient for DydxExecutionClient {
1239 fn is_connected(&self) -> bool {
1240 self.core.is_connected()
1241 }
1242
1243 fn client_id(&self) -> ClientId {
1244 self.core.client_id
1245 }
1246
1247 fn account_id(&self) -> AccountId {
1248 self.core.account_id
1249 }
1250
1251 fn venue(&self) -> Venue {
1252 *DYDX_VENUE
1253 }
1254
1255 fn oms_type(&self) -> OmsType {
1256 self.core.oms_type
1257 }
1258
1259 fn get_account(&self) -> Option<AccountAny> {
1260 self.core.cache().account_owned(&self.core.account_id)
1261 }
1262
1263 fn generate_account_state(
1264 &self,
1265 balances: Vec<AccountBalance>,
1266 margins: Vec<MarginBalance>,
1267 reported: bool,
1268 ts_event: UnixNanos,
1269 info: Option<Params>,
1270 ) -> anyhow::Result<()> {
1271 self.emitter
1272 .emit_account_state(balances, margins, reported, ts_event, info);
1273 Ok(())
1274 }
1275
1276 fn start(&mut self) -> anyhow::Result<()> {
1277 if self.core.is_started() {
1278 log::warn!("dYdX execution client already started");
1279 return Ok(());
1280 }
1281
1282 let sender = get_exec_event_sender();
1283 self.emitter.set_sender(sender);
1284 log::info!("Starting dYdX execution client");
1285 self.core.set_started();
1286 Ok(())
1287 }
1288
1289 fn stop(&mut self) -> anyhow::Result<()> {
1290 if self.core.is_stopped() {
1291 log::warn!("dYdX execution client not started");
1292 return Ok(());
1293 }
1294
1295 log::info!("Stopping dYdX execution client");
1296 self.session_tasks.begin_shutdown();
1297 self.begin_pending_shutdown();
1298 self.ws_client.begin_shutdown();
1299 self.core.set_stopped();
1300 self.core.set_disconnected();
1301 Ok(())
1302 }
1303
1304 fn submit_order(&self, cmd: SubmitOrder) -> anyhow::Result<()> {
1305 if !self.is_connected() {
1306 let reason = "Cannot submit order: execution client not connected";
1307 log::error!("{reason}");
1308 anyhow::bail!(reason);
1309 }
1310
1311 let current_block = self.block_time_monitor.current_block_height();
1312 let order = self.core.cache().try_order_owned(&cmd.client_order_id)?;
1313
1314 let client_order_id = order.client_order_id();
1315 let instrument_id = order.instrument_id();
1316 let strategy_id = order.strategy_id();
1317
1318 if current_block == 0 {
1319 let reason = "Block height not initialized";
1320 log::warn!("Cannot submit order {client_order_id}: {reason}");
1321 self.emitter.emit_order_denied(&order, reason);
1322 return Ok(());
1323 }
1324
1325 if order.is_closed() {
1326 log::warn!("Cannot submit closed order {client_order_id}");
1327 return Ok(());
1328 }
1329
1330 if order.is_quote_quantity() {
1331 let reason = OrderDeniedReason::unsupported_quote_quantity().to_string();
1332 log::warn!("{reason}");
1333 self.emitter.emit_order_denied(&order, &reason);
1334 return Ok(());
1335 }
1336
1337 let unsupported_tif_reason = match order.time_in_force() {
1341 TimeInForce::Fok => Some(
1342 "Fill-or-kill (FOK) orders are deprecated by dYdX v4 (chain rejects with code=48)",
1343 ),
1344 TimeInForce::Day => Some("DAY time-in-force is not supported by dYdX v4"),
1345 _ => None,
1346 };
1347
1348 if let Some(reason) = unsupported_tif_reason {
1349 log::warn!("{reason}");
1350 self.emitter.emit_order_denied(&order, reason);
1351 return Ok(());
1352 }
1353
1354 match order.order_type() {
1355 OrderType::Market
1356 | OrderType::Limit
1357 | OrderType::StopMarket
1358 | OrderType::StopLimit
1359 | OrderType::MarketIfTouched
1360 | OrderType::LimitIfTouched => {}
1361 OrderType::TrailingStopMarket | OrderType::TrailingStopLimit => {
1362 let reason = "Trailing stop orders not supported by dYdX v4 protocol";
1363 log::warn!("{reason}");
1364 self.emitter.emit_order_denied(&order, reason);
1365 return Ok(());
1366 }
1367 order_type => {
1368 let reason = format!("Order type {order_type:?} not supported by dYdX");
1369 log::warn!("{reason}");
1370 self.emitter.emit_order_denied(&order, &reason);
1371 return Ok(());
1372 }
1373 }
1374
1375 let (tx_manager, broadcaster, order_builder) = match self.get_execution_components() {
1376 Ok(components) => components,
1377 Err(e) => {
1378 log::error!("Failed to get execution components: {e}");
1379 self.emitter.emit_order_denied(&order, &e.to_string());
1380 return Ok(());
1381 }
1382 };
1383
1384 let block_height = self.block_time_monitor.current_block_height() as u32;
1385
1386 let encoded = match self.encoder.encode(client_order_id) {
1387 Ok(enc) => enc,
1388 Err(e) => {
1389 log::error!("Failed to generate client order ID: {e}");
1390 self.emitter.emit_order_denied(&order, &e.to_string());
1391 return Ok(());
1392 }
1393 };
1394
1395 self.emitter.emit_order_submitted(&order);
1396 let client_id_u32 = encoded.client_id;
1397 let client_metadata = encoded.client_metadata;
1398
1399 log::debug!(
1400 "[SUBMIT_ORDER] Nautilus '{}' -> dYdX u32={} meta={:#x} | instrument={} side={:?} qty={} type={:?}",
1401 client_order_id,
1402 client_id_u32,
1403 client_metadata,
1404 instrument_id,
1405 order.order_side(),
1406 order.quantity(),
1407 order.order_type()
1408 );
1409
1410 let expire_time = order.expire_time().map(nanos_to_secs_i64);
1411
1412 let order_flags = match order.order_type() {
1413 OrderType::StopMarket
1414 | OrderType::StopLimit
1415 | OrderType::MarketIfTouched
1416 | OrderType::LimitIfTouched => types::ORDER_FLAG_CONDITIONAL,
1417 OrderType::Market => types::ORDER_FLAG_SHORT_TERM,
1418 OrderType::Limit => {
1419 let lifetime = types::OrderLifetime::from_time_in_force(
1420 order.time_in_force(),
1421 expire_time,
1422 false,
1423 order_builder.max_short_term_secs(),
1424 );
1425 lifetime.order_flags()
1426 }
1427 _ => types::ORDER_FLAG_LONG_TERM,
1428 };
1429
1430 let ts_submitted = self.clock.get_time_ns();
1431 let trader_id = order.trader_id();
1432 self.register_order_context(
1433 client_id_u32,
1434 OrderContext {
1435 client_order_id,
1436 trader_id,
1437 strategy_id,
1438 instrument_id,
1439 submitted_at: ts_submitted,
1440 order_flags,
1441 },
1442 );
1443
1444 self.dispatch_state.order_identities.insert(
1447 client_order_id,
1448 OrderIdentity {
1449 instrument_id,
1450 strategy_id,
1451 order_side: order.order_side(),
1452 order_type: order.order_type(),
1453 },
1454 );
1455
1456 self.spawn_order_task(
1457 "submit_order",
1458 strategy_id,
1459 instrument_id,
1460 client_order_id,
1461 async move {
1462 let (msg, order_type_str) = match order.order_type() {
1463 OrderType::Market => {
1464 let msg = order_builder.build_market_order_with_reduce_only(
1465 instrument_id,
1466 client_id_u32,
1467 client_metadata,
1468 order.order_side(),
1469 order.quantity(),
1470 order.is_reduce_only(),
1471 block_height,
1472 )?;
1473 (msg, "market")
1474 }
1475 OrderType::Limit => {
1476 let msg = order_builder.build_limit_order(
1477 instrument_id,
1478 client_id_u32,
1479 client_metadata,
1480 order.order_side(),
1481 order
1482 .price()
1483 .ok_or_else(|| anyhow::anyhow!("Limit order missing price"))?,
1484 order.quantity(),
1485 order.time_in_force(),
1486 order.is_post_only(),
1487 order.is_reduce_only(),
1488 block_height,
1489 expire_time, )?;
1491 (msg, "limit")
1492 }
1493 OrderType::StopMarket => {
1496 let trigger_price = order.trigger_price().ok_or_else(|| {
1497 anyhow::anyhow!("Stop market order missing trigger_price")
1498 })?;
1499 let cond_expire = order.expire_time().map(nanos_to_secs_i64);
1500 let msg = order_builder.build_stop_market_order(
1501 instrument_id,
1502 client_id_u32,
1503 client_metadata,
1504 order.order_side(),
1505 trigger_price,
1506 order.quantity(),
1507 order.is_reduce_only(),
1508 cond_expire,
1509 )?;
1510 (msg, "stop_market")
1511 }
1512 OrderType::StopLimit => {
1513 let trigger_price = order.trigger_price().ok_or_else(|| {
1514 anyhow::anyhow!("Stop limit order missing trigger_price")
1515 })?;
1516 let limit_price = order.price().ok_or_else(|| {
1517 anyhow::anyhow!("Stop limit order missing limit price")
1518 })?;
1519 let cond_expire = order.expire_time().map(nanos_to_secs_i64);
1520 let msg = order_builder.build_stop_limit_order(
1521 instrument_id,
1522 client_id_u32,
1523 client_metadata,
1524 order.order_side(),
1525 trigger_price,
1526 limit_price,
1527 order.quantity(),
1528 order.time_in_force(),
1529 order.is_post_only(),
1530 order.is_reduce_only(),
1531 cond_expire,
1532 )?;
1533 (msg, "stop_limit")
1534 }
1535 OrderType::MarketIfTouched => {
1537 let trigger_price = order.trigger_price().ok_or_else(|| {
1538 anyhow::anyhow!("Take profit market order missing trigger_price")
1539 })?;
1540 let cond_expire = order.expire_time().map(nanos_to_secs_i64);
1541 let msg = order_builder.build_take_profit_market_order(
1542 instrument_id,
1543 client_id_u32,
1544 client_metadata,
1545 order.order_side(),
1546 trigger_price,
1547 order.quantity(),
1548 order.is_reduce_only(),
1549 cond_expire,
1550 )?;
1551 (msg, "take_profit_market")
1552 }
1553 OrderType::LimitIfTouched => {
1555 let trigger_price = order.trigger_price().ok_or_else(|| {
1556 anyhow::anyhow!("Take profit limit order missing trigger_price")
1557 })?;
1558 let limit_price = order.price().ok_or_else(|| {
1559 anyhow::anyhow!("Take profit limit order missing limit price")
1560 })?;
1561 let cond_expire = order.expire_time().map(nanos_to_secs_i64);
1562 let msg = order_builder.build_take_profit_limit_order(
1563 instrument_id,
1564 client_id_u32,
1565 client_metadata,
1566 order.order_side(),
1567 trigger_price,
1568 limit_price,
1569 order.quantity(),
1570 order.time_in_force(),
1571 order.is_post_only(),
1572 order.is_reduce_only(),
1573 cond_expire,
1574 )?;
1575 (msg, "take_profit_limit")
1576 }
1577 _ => unreachable!("Order type already validated"),
1578 };
1579
1580 let operation = format!("Submit {order_type_str} order {client_order_id}");
1583
1584 if order_flags == types::ORDER_FLAG_SHORT_TERM {
1585 broadcaster
1586 .broadcast_short_term(&tx_manager, vec![msg], &operation)
1587 .await?;
1588 } else {
1589 broadcaster
1590 .broadcast_with_retry(&tx_manager, vec![msg], &operation)
1591 .await?;
1592 }
1593 log::debug!("Successfully submitted {order_type_str} order: {client_order_id}");
1594
1595 Ok(())
1596 },
1597 );
1598
1599 Ok(())
1600 }
1601
1602 fn submit_order_list(&self, cmd: SubmitOrderList) -> anyhow::Result<()> {
1603 let orders = self.core.get_orders_for_list(&cmd.order_list)?;
1604 let order_count = orders.len();
1605
1606 if !self.is_connected() {
1607 let reason = "Cannot submit order list: execution client not connected";
1608 log::error!("{reason}");
1609 anyhow::bail!(reason);
1610 }
1611
1612 let unsupported_tif_reason = |order: &OrderAny| match order.time_in_force() {
1617 TimeInForce::Fok => Some(
1618 "Fill-or-kill (FOK) orders are deprecated by dYdX v4 (chain rejects with code=48)",
1619 ),
1620 TimeInForce::Day => Some("DAY time-in-force is not supported by dYdX v4"),
1621 _ => None,
1622 };
1623
1624 if orders
1625 .iter()
1626 .any(|order| unsupported_tif_reason(order).is_some())
1627 {
1628 for order in &orders {
1631 let reason = unsupported_tif_reason(order)
1632 .unwrap_or("Order list denied: sibling order has unsupported time in force");
1633 self.emitter.emit_order_denied(order, reason);
1634 }
1635 return Ok(());
1636 }
1637
1638 let current_block = self.block_time_monitor.current_block_height();
1639 if current_block == 0 {
1640 let reason = "Block height not initialized";
1641 log::warn!("Cannot submit order list: {reason}");
1642 for order in &orders {
1643 self.emitter.emit_order_denied(order, reason);
1644 }
1645 return Ok(());
1646 }
1647
1648 let (tx_manager, broadcaster, order_builder) = match self.get_execution_components() {
1649 Ok(components) => components,
1650 Err(e) => {
1651 log::error!("Failed to get execution components for batch: {e}");
1652 for order in &orders {
1653 self.emitter.emit_order_denied(order, &e.to_string());
1654 }
1655 return Ok(());
1656 }
1657 };
1658
1659 let mut order_params: Vec<LimitOrderParams> = Vec::with_capacity(order_count);
1660 let mut order_info: Vec<(ClientOrderId, InstrumentId, StrategyId)> =
1661 Vec::with_capacity(order_count);
1662
1663 for order in &orders {
1664 if order.order_type() != OrderType::Limit {
1665 log::debug!(
1666 "Order {} has type {:?}, falling back to individual submission",
1667 order.client_order_id(),
1668 order.order_type()
1669 );
1670 let submit_cmd = SubmitOrder::new(
1671 cmd.trader_id,
1672 cmd.client_id,
1673 cmd.strategy_id,
1674 order.instrument_id(),
1675 order.client_order_id(),
1676 order.init_event().clone(),
1677 cmd.exec_algorithm_id,
1678 cmd.position_id,
1679 cmd.params.clone(),
1680 UUID4::new(),
1681 cmd.ts_init,
1682 cmd.correlation_id,
1683 );
1684
1685 if let Err(e) = self.submit_order(submit_cmd) {
1686 log::error!(
1687 "Failed to submit order {} from order list: {e}",
1688 order.client_order_id()
1689 );
1690 }
1691 continue;
1692 }
1693
1694 if order.is_quote_quantity() {
1695 self.emitter.emit_order_denied(
1696 order,
1697 &OrderDeniedReason::unsupported_quote_quantity().to_string(),
1698 );
1699 continue;
1700 }
1701
1702 let Some(price) = order.price() else {
1703 self.emitter
1704 .emit_order_denied(order, "Limit order missing price");
1705 continue;
1706 };
1707
1708 let encoded = match self.encoder.encode(order.client_order_id()) {
1709 Ok(enc) => enc,
1710 Err(e) => {
1711 log::error!("Failed to generate client order ID: {e}");
1712 self.emitter.emit_order_denied(order, &e.to_string());
1713 continue;
1714 }
1715 };
1716 let client_id_u32 = encoded.client_id;
1717 let client_metadata = encoded.client_metadata;
1718
1719 self.emitter.emit_order_submitted(order);
1720
1721 let expire_time_secs = order.expire_time().map(nanos_to_secs_i64);
1722 let lifetime = types::OrderLifetime::from_time_in_force(
1723 order.time_in_force(),
1724 expire_time_secs,
1725 false,
1726 order_builder.max_short_term_secs(),
1727 );
1728
1729 let ts_submitted = self.clock.get_time_ns();
1730 self.register_order_context(
1731 client_id_u32,
1732 OrderContext {
1733 client_order_id: order.client_order_id(),
1734 trader_id: order.trader_id(),
1735 strategy_id: order.strategy_id(),
1736 instrument_id: order.instrument_id(),
1737 submitted_at: ts_submitted,
1738 order_flags: lifetime.order_flags(),
1739 },
1740 );
1741
1742 self.dispatch_state.order_identities.insert(
1743 order.client_order_id(),
1744 OrderIdentity {
1745 instrument_id: order.instrument_id(),
1746 strategy_id: order.strategy_id(),
1747 order_side: order.order_side(),
1748 order_type: order.order_type(),
1749 },
1750 );
1751
1752 order_params.push(LimitOrderParams {
1753 instrument_id: order.instrument_id(),
1754 client_order_id: client_id_u32,
1755 client_metadata,
1756 side: order.order_side(),
1757 price,
1758 quantity: order.quantity(),
1759 time_in_force: order.time_in_force(),
1760 post_only: order.is_post_only(),
1761 reduce_only: order.is_reduce_only(),
1762 expire_time_ns: order.expire_time(),
1763 });
1764 order_info.push((
1765 order.client_order_id(),
1766 order.instrument_id(),
1767 order.strategy_id(),
1768 ));
1769 }
1770
1771 if order_params.is_empty() {
1772 return Ok(());
1773 }
1774
1775 let has_short_term = order_params
1777 .iter()
1778 .any(|params| order_builder.is_short_term_order(params));
1779
1780 let block_height = current_block as u32;
1781 let emitter = self.emitter.clone();
1782 let clock = self.clock;
1783
1784 if has_short_term {
1785 log::debug!(
1786 "Submitting {} short-term limit orders concurrently (sequence not consumed)",
1787 order_params.len()
1788 );
1789
1790 self.spawn_labeled("batch_submit_short_term", async move {
1791 let mut handles = tokio::task::JoinSet::new();
1794
1795 for (params, (client_order_id, instrument_id, strategy_id)) in
1796 order_params.into_iter().zip(order_info)
1797 {
1798 let tx_manager = tx_manager.clone();
1799 let broadcaster = broadcaster.clone();
1800 let order_builder = order_builder.clone();
1801 let emitter = emitter.clone();
1802
1803 handles.spawn(async move {
1804 let msg = match order_builder
1805 .build_limit_order_from_params(¶ms, block_height)
1806 {
1807 Ok(m) => m,
1808 Err(e) => {
1809 log::error!(
1812 "Failed to build order message for {client_order_id}: {e:?}"
1813 );
1814 return;
1815 }
1816 };
1817
1818 let operation = format!("Submit short-term order {client_order_id}");
1820
1821 if let Err(e) = broadcaster
1822 .broadcast_short_term(&tx_manager, vec![msg], &operation)
1823 .await
1824 {
1825 if e.is_definitive_broadcast_rejection() {
1826 let error_msg = format!("Order submission failed: {e:?}");
1827 log::warn!("{error_msg}");
1828 let ts_event = clock.get_time_ns();
1829 emitter.emit_order_rejected_event(
1830 strategy_id,
1831 instrument_id,
1832 client_order_id,
1833 &error_msg,
1834 ts_event,
1835 false,
1836 );
1837 } else {
1838 log::warn!(
1839 "Ambiguous dYdX submit failure for {client_order_id}, awaiting reconciliation: {e:?}"
1840 );
1841 }
1842 }
1843 });
1844 }
1845
1846 while let Some(result) = handles.join_next().await {
1847 if let Err(e) = result
1848 && !e.is_cancelled()
1849 {
1850 log::warn!("dYdX short-term order task failed: {e}");
1851 }
1852 }
1853 });
1854 } else {
1855 log::debug!(
1856 "Batch submitting {} long-term limit orders in single transaction",
1857 order_params.len()
1858 );
1859
1860 self.spawn_labeled("batch_submit_long_term", async move {
1861 let msgs: Result<Vec<_>, _> = order_params
1862 .iter()
1863 .map(|params| order_builder.build_limit_order_from_params(params, block_height))
1864 .collect();
1865
1866 let msgs = match msgs {
1867 Ok(m) => m,
1868 Err(e) => {
1869 log::error!("Failed to build batch order messages: {e:?}");
1872 return;
1873 }
1874 };
1875
1876 let operation = format!("Submit batch of {} limit orders", msgs.len());
1877
1878 if let Err(e) = broadcaster
1879 .broadcast_with_retry(&tx_manager, msgs, &operation)
1880 .await
1881 {
1882 if e.is_definitive_broadcast_rejection() {
1883 let error_msg = format!("Batch order submission failed: {e:?}");
1886 log::warn!("{error_msg}");
1887 let ts_event = clock.get_time_ns();
1888
1889 for (client_order_id, instrument_id, strategy_id) in order_info {
1890 emitter.emit_order_rejected_event(
1891 strategy_id,
1892 instrument_id,
1893 client_order_id,
1894 &error_msg,
1895 ts_event,
1896 false,
1897 );
1898 }
1899 } else {
1900 log::warn!(
1901 "Ambiguous dYdX batch submit failure, awaiting reconciliation: {e:?}"
1902 );
1903 }
1904 }
1905 });
1906 }
1907
1908 Ok(())
1909 }
1910
1911 fn modify_order(&self, cmd: ModifyOrder) -> anyhow::Result<()> {
1915 let reason = "dYdX does not support order modification. Use cancel and resubmit instead.";
1916 log::warn!("{reason}");
1917
1918 self.send_modify_denied(
1919 cmd.strategy_id,
1920 cmd.instrument_id,
1921 cmd.client_order_id,
1922 cmd.venue_order_id,
1923 reason,
1924 cmd.command_id,
1925 );
1926 Ok(())
1927 }
1928
1929 fn cancel_order(&self, cmd: CancelOrder) -> anyhow::Result<()> {
1930 let deny = |reason: &str| {
1931 self.emitter.emit_order_cancel_denied_event(
1932 cmd.strategy_id,
1933 cmd.instrument_id,
1934 cmd.client_order_id,
1935 cmd.venue_order_id,
1936 reason,
1937 self.clock.get_time_ns(),
1938 Some(cmd.command_id),
1939 );
1940 };
1941
1942 if !self.is_connected() {
1943 deny("Cannot cancel order: not connected");
1944 return Ok(());
1945 }
1946
1947 let client_order_id = cmd.client_order_id;
1948 let instrument_id = cmd.instrument_id;
1949 let strategy_id = cmd.strategy_id;
1950 let venue_order_id = cmd.venue_order_id;
1951
1952 let (order_time_in_force, order_expire_time) = {
1953 let cache = self.core.cache();
1954
1955 let order = match cache.order(&client_order_id) {
1956 Some(order) => order,
1957 None => {
1958 deny("Order not found in cache for cancel");
1959 return Ok(());
1960 }
1961 };
1962
1963 if order.is_closed() {
1964 log::warn!(
1965 "CancelOrder command for {} when order already {} (will not send to exchange)",
1966 client_order_id,
1967 order.status()
1968 );
1969 deny("Cannot cancel a closed order");
1970 return Ok(());
1971 }
1972
1973 if cache.instrument(&instrument_id).is_none() {
1974 log::error!(
1975 "Cannot cancel order {client_order_id}: instrument {instrument_id} not found in cache"
1976 );
1977 deny("Instrument not found in cache for cancel");
1978 return Ok(());
1979 }
1980
1981 (
1982 order.time_in_force(),
1983 order.expire_time().map(nanos_to_secs_i64),
1984 )
1985 }; log::debug!("Cancelling order {client_order_id} for instrument {instrument_id}");
1988
1989 let (tx_manager, broadcaster, order_builder) = match self.get_execution_components() {
1990 Ok(components) => components,
1991 Err(e) => {
1992 deny(&format!(
1993 "Failed to get execution components for cancel: {e}"
1994 ));
1995 return Ok(());
1996 }
1997 };
1998
1999 let block_height = self.block_time_monitor.current_block_height() as u32;
2000
2001 let encoded = match self.encoder.get(&client_order_id) {
2002 Some(enc) => enc,
2003 None => {
2004 deny("Client order ID not found in encoder for cancel");
2005 return Ok(());
2006 }
2007 };
2008 let client_id_u32 = encoded.client_id;
2009
2010 log::debug!(
2011 "[CANCEL_ORDER] Nautilus '{client_order_id}' -> dYdX u32={client_id_u32} | instrument={instrument_id}"
2012 );
2013
2014 let order_flags = self.get_order_context(client_id_u32).map_or_else(
2016 || {
2017 log::debug!(
2018 "Order context not found for {client_order_id}, deriving flags from order"
2019 );
2020 types::OrderLifetime::from_time_in_force(
2021 order_time_in_force, order_expire_time, false,
2024 order_builder.max_short_term_secs(),
2025 )
2026 .order_flags()
2027 },
2028 |ctx| ctx.order_flags,
2029 );
2030
2031 let clock = self.clock;
2032 let emitter = self.emitter.clone();
2033
2034 self.spawn_task("cancel_order", async move {
2035 let cancel_msg = match order_builder.build_cancel_order_with_flags(
2036 instrument_id,
2037 client_id_u32,
2038 order_flags,
2039 block_height,
2040 ) {
2041 Ok(msg) => msg,
2042 Err(e) => {
2043 emitter.emit_order_cancel_denied_event(
2044 strategy_id,
2045 instrument_id,
2046 client_order_id,
2047 venue_order_id,
2048 &format!("Cancel command failed local validation: {e:?}"),
2049 clock.get_time_ns(),
2050 Some(cmd.command_id),
2051 );
2052 return Ok(());
2053 }
2054 };
2055
2056 let cancel_op = format!("Cancel order {client_order_id}");
2058 let result = if order_flags == types::ORDER_FLAG_SHORT_TERM {
2059 broadcaster
2060 .broadcast_short_term(&tx_manager, vec![cancel_msg], &cancel_op)
2061 .await
2062 } else {
2063 broadcaster
2064 .broadcast_with_retry(&tx_manager, vec![cancel_msg], &cancel_op)
2065 .await
2066 };
2067
2068 match result {
2069 Ok(_) => {
2070 log::debug!("Successfully cancelled order: {client_order_id}");
2071 }
2072 Err(e) if e.is_definitive_broadcast_rejection() => {
2073 log::warn!("Failed to cancel order {client_order_id}: {e:?}");
2074
2075 let ts_event = clock.get_time_ns();
2076 emitter.emit_order_cancel_rejected_event(
2077 strategy_id,
2078 instrument_id,
2079 client_order_id,
2080 venue_order_id,
2081 &format!("Cancel order failed: {e:?}"),
2082 ts_event,
2083 Some(cmd.command_id),
2084 );
2085 }
2086 Err(e) => {
2087 log::warn!(
2088 "Ambiguous dYdX cancel failure for {client_order_id}, awaiting reconciliation: {e:?}"
2089 );
2090 }
2091 }
2092
2093 Ok(())
2094 });
2095
2096 Ok(())
2097 }
2098
2099 fn cancel_all_orders(&self, cmd: CancelAllOrders) -> anyhow::Result<()> {
2100 if !self.is_connected() {
2101 anyhow::bail!("Cannot cancel orders: not connected");
2102 }
2103
2104 let instrument_id = cmd.instrument_id;
2105 let order_side_filter = cmd.order_side;
2106
2107 let order_data: Vec<CancelAllOrderData> = {
2108 let cache = self.core.cache();
2109 let side_filter = order_side_filter;
2110 cache
2111 .orders_open(None, Some(&instrument_id), None, None, side_filter)
2112 .into_iter()
2113 .map(|order| {
2114 (
2115 order.strategy_id(),
2116 order.client_order_id(),
2117 order.venue_order_id(),
2118 order.time_in_force(),
2119 order.expire_time(),
2120 )
2121 })
2122 .collect()
2123 }; let short_term_count = order_data
2126 .iter()
2127 .filter(|(_, _, _, tif, _)| matches!(tif, TimeInForce::Ioc | TimeInForce::Fok))
2128 .count();
2129 let long_term_count = order_data.len() - short_term_count;
2130
2131 log::debug!(
2132 "Cancel all orders: total={}, short_term={}, long_term={}, instrument_id={instrument_id}, order_side={order_side_filter:?}",
2133 order_data.len(),
2134 short_term_count,
2135 long_term_count
2136 );
2137
2138 let (tx_manager, broadcaster, order_builder) = match self.get_execution_components() {
2139 Ok(components) => components,
2140 Err(e) => {
2141 log::error!("Failed to get execution components for cancel_all: {e}");
2142 return Ok(());
2143 }
2144 };
2145
2146 let block_height = self.block_time_monitor.current_block_height() as u32;
2147
2148 let mut orders_to_cancel = Vec::new();
2149
2150 for (strategy_id, client_order_id, venue_order_id, _time_in_force, _expire_time) in
2151 &order_data
2152 {
2153 let Some(encoded) = self.encoder.get(client_order_id) else {
2154 log::warn!("Cannot cancel order {client_order_id}: not found in encoder");
2155 continue;
2156 };
2157 let client_id_u32 = encoded.client_id;
2158
2159 let Some(ctx) = self.get_order_context(client_id_u32) else {
2160 log::debug!(
2161 "Skipping cancel for {client_order_id}: order context already cleaned up (terminal)"
2162 );
2163 continue;
2164 };
2165 orders_to_cancel.push(DydxCancelOrderRequest {
2166 command_id: cmd.command_id,
2167 instrument_id,
2168 client_id: client_id_u32,
2169 order_flags: ctx.order_flags,
2170 strategy_id: *strategy_id,
2171 client_order_id: *client_order_id,
2172 venue_order_id: *venue_order_id,
2173 });
2174 }
2175
2176 if orders_to_cancel.is_empty() {
2177 return Ok(());
2178 }
2179
2180 log::debug!(
2181 "Cancel all: {} orders (short_term={}, long_term={}), instrument_id={instrument_id}, order_side={order_side_filter:?}",
2182 orders_to_cancel.len(),
2183 orders_to_cancel
2184 .iter()
2185 .filter(|order| order.order_flags == types::ORDER_FLAG_SHORT_TERM)
2186 .count(),
2187 orders_to_cancel
2188 .iter()
2189 .filter(|order| order.order_flags != types::ORDER_FLAG_SHORT_TERM)
2190 .count(),
2191 );
2192
2193 let clock = self.clock;
2194 let emitter = self.emitter.clone();
2195
2196 self.spawn_task("cancel_all_orders", async move {
2197 broadcast_partitioned_cancels(
2198 orders_to_cancel,
2199 block_height,
2200 tx_manager,
2201 broadcaster,
2202 order_builder,
2203 emitter,
2204 clock,
2205 )
2206 .await
2207 });
2208
2209 Ok(())
2210 }
2211
2212 fn batch_cancel_orders(&self, cmd: BatchCancelOrders) -> anyhow::Result<()> {
2213 if cmd.cancels.is_empty() {
2214 return Ok(());
2215 }
2216
2217 if !self.is_connected() {
2218 for cancel in &cmd.cancels {
2219 self.emitter.emit_order_cancel_denied_event(
2220 cancel.strategy_id,
2221 cancel.instrument_id,
2222 cancel.client_order_id,
2223 cancel.venue_order_id,
2224 "Cannot cancel orders: not connected",
2225 self.clock.get_time_ns(),
2226 Some(cancel.command_id),
2227 );
2228 }
2229
2230 return Ok(());
2231 }
2232
2233 let (tx_manager, broadcaster, order_builder) = match self.get_execution_components() {
2234 Ok(components) => components,
2235 Err(e) => {
2236 for cancel in &cmd.cancels {
2237 self.emitter.emit_order_cancel_denied_event(
2238 cancel.strategy_id,
2239 cancel.instrument_id,
2240 cancel.client_order_id,
2241 cancel.venue_order_id,
2242 &format!("Failed to get execution components for batch cancel: {e}"),
2243 self.clock.get_time_ns(),
2244 Some(cancel.command_id),
2245 );
2246 }
2247
2248 return Ok(());
2249 }
2250 };
2251
2252 let mut orders_to_cancel = Vec::with_capacity(cmd.cancels.len());
2253 for cancel in &cmd.cancels {
2254 let client_order_id = cancel.client_order_id;
2255 let encoded = match self.encoder.get(&client_order_id) {
2256 Some(enc) => enc,
2257 None => {
2258 self.emitter.emit_order_cancel_denied_event(
2259 cancel.strategy_id,
2260 cancel.instrument_id,
2261 client_order_id,
2262 cancel.venue_order_id,
2263 "Client order ID not found in encoder for cancel",
2264 self.clock.get_time_ns(),
2265 Some(cancel.command_id),
2266 );
2267 continue;
2268 }
2269 };
2270 let client_id_u32 = encoded.client_id;
2271
2272 let Some(ctx) = self.get_order_context(client_id_u32) else {
2273 self.emitter.emit_order_cancel_denied_event(
2274 cancel.strategy_id,
2275 cancel.instrument_id,
2276 client_order_id,
2277 cancel.venue_order_id,
2278 "Order context not found for cancel",
2279 self.clock.get_time_ns(),
2280 Some(cancel.command_id),
2281 );
2282 continue;
2283 };
2284
2285 orders_to_cancel.push(DydxCancelOrderRequest {
2286 command_id: cancel.command_id,
2287 instrument_id: cancel.instrument_id,
2288 client_id: client_id_u32,
2289 order_flags: ctx.order_flags,
2290 strategy_id: cancel.strategy_id,
2291 client_order_id,
2292 venue_order_id: cancel.venue_order_id,
2293 });
2294 }
2295
2296 if orders_to_cancel.is_empty() {
2297 log::warn!("No valid orders to cancel in batch");
2298 return Ok(());
2299 }
2300
2301 let block_height = self.block_time_monitor.current_block_height() as u32;
2302 let clock = self.clock;
2303 let emitter = self.emitter.clone();
2304
2305 log::debug!(
2306 "Batch cancelling {} orders via partitioned strategy",
2307 orders_to_cancel.len(),
2308 );
2309
2310 self.spawn_task("batch_cancel_orders", async move {
2311 broadcast_partitioned_cancels(
2312 orders_to_cancel,
2313 block_height,
2314 tx_manager,
2315 broadcaster,
2316 order_builder,
2317 emitter,
2318 clock,
2319 )
2320 .await
2321 });
2322
2323 Ok(())
2324 }
2325
2326 fn query_account(&self, _cmd: QueryAccount) -> anyhow::Result<()> {
2327 let http_client = self.http_client.clone();
2328 let wallet_address = self.wallet_address.clone();
2329 let subaccount_number = self.subaccount_number;
2330 let account_id = self.core.account_id;
2331 let emitter = self.emitter.clone();
2332
2333 self.spawn_task("query_account", async move {
2334 let account_state = http_client
2335 .request_account_state(&wallet_address, subaccount_number, account_id)
2336 .await
2337 .context("failed to query account state")?;
2338
2339 emitter.emit_account_state(
2340 account_state.balances.clone(),
2341 account_state.margins.clone(),
2342 account_state.is_reported,
2343 account_state.ts_event,
2344 account_state.info,
2345 );
2346 Ok(())
2347 });
2348
2349 Ok(())
2350 }
2351
2352 fn query_order(&self, cmd: QueryOrder) -> anyhow::Result<()> {
2353 log::debug!("Querying order: client_order_id={}", cmd.client_order_id);
2354
2355 let http_client = self.http_client.clone();
2356 let wallet_address = self.wallet_address.clone();
2357 let subaccount_number = self.subaccount_number;
2358 let account_id = self.core.account_id;
2359 let emitter = self.emitter.clone();
2360 let client_order_id = cmd.client_order_id;
2361 let venue_order_id = cmd.venue_order_id;
2362 let instrument_id = cmd.instrument_id;
2363
2364 self.spawn_task("query_order", async move {
2365 let reports = http_client
2366 .request_order_status_reports(
2367 &wallet_address,
2368 subaccount_number,
2369 account_id,
2370 Some(instrument_id),
2371 )
2372 .await
2373 .context("failed to query order status")?;
2374
2375 let report = reports.into_iter().find(|r| {
2376 if venue_order_id.is_some_and(|vid| r.venue_order_id == vid) {
2377 return true;
2378 }
2379 r.client_order_id.is_some_and(|cid| cid == client_order_id)
2380 });
2381
2382 if let Some(report) = report {
2383 emitter.send_order_status_report(report);
2384 } else {
2385 log::warn!(
2386 "No order found for client_order_id={client_order_id}, venue_order_id={venue_order_id:?}"
2387 );
2388 }
2389
2390 Ok(())
2391 });
2392
2393 Ok(())
2394 }
2395
2396 async fn connect(&mut self) -> anyhow::Result<()> {
2397 if self.core.is_connected() && self.session_tasks.is_open() && self.pending_tasks.is_open()
2398 {
2399 log::warn!("dYdX execution client already connected");
2400 return Ok(());
2401 }
2402
2403 log::info!("Connecting to dYdX");
2404
2405 self.prepare_task_groups().await?;
2406 let ws_client = self.ws_client.clone();
2407 let setup_guard =
2408 TaskGroupGuard::new(&[&self.session_tasks, &self.pending_tasks], move || {
2409 ws_client.begin_shutdown();
2410 });
2411
2412 log::debug!("Loading instruments from HTTP API");
2413 self.http_client.fetch_and_cache_instruments().await?;
2414 log::debug!(
2415 "Loaded {} instruments from HTTP into shared cache",
2416 self.http_client.cached_instruments_count()
2417 );
2418 self.mark_instruments_initialized();
2419
2420 let grpc_urls = self.config.get_grpc_urls();
2422 let mut grpc_client = DydxGrpcClient::new_with_fallback(&grpc_urls)
2423 .await
2424 .context("failed to construct dYdX gRPC client")?;
2425 log::debug!("gRPC client initialized");
2426
2427 let initial_height = grpc_client
2429 .latest_block_height()
2430 .await
2431 .context("failed to fetch initial block height")?;
2432 self.block_time_monitor
2434 .record_block(initial_height.0 as u64, jiff::Timestamp::now());
2435 log::debug!("Initial block height: {}", initial_height.0);
2436
2437 *self.grpc_client.write().await = Some(grpc_client.clone());
2438
2439 let private_key =
2440 Self::resolve_private_key(&self.config).context("failed to resolve private key")?;
2441 let tx_manager = Arc::new(
2442 TransactionManager::new(
2443 grpc_client.clone(),
2444 &private_key,
2445 self.wallet_address.clone(),
2446 self.get_chain_id(),
2447 )
2448 .context("failed to create TransactionManager")?,
2449 );
2450
2451 tx_manager
2452 .resolve_authenticators()
2453 .await
2454 .context("failed to resolve authenticators")?;
2455
2456 tx_manager
2459 .initialize_sequence()
2460 .await
2461 .context("failed to initialize sequence")?;
2462
2463 self.tx_manager = Some(tx_manager);
2464 self.broadcaster = Some(Arc::new(TxBroadcaster::new(
2465 grpc_client,
2466 self.config.grpc_quota(),
2467 )));
2468 self.order_builder = Some(Arc::new(OrderMessageBuilder::new(
2469 self.http_client.clone(),
2470 self.wallet_address.clone(),
2471 self.subaccount_number,
2472 self.block_time_monitor.clone(),
2473 )));
2474 log::debug!(
2475 "OrderMessageBuilder initialized (block_time_monitor ready: {}, max_short_term: {:.1}s)",
2476 self.block_time_monitor.is_ready(),
2477 SHORT_TERM_ORDER_MAXIMUM_LIFETIME as f64
2478 * self.block_time_monitor.seconds_per_block_or_default()
2479 );
2480
2481 let session_result = async {
2482 self.ws_client.connect().await?;
2483 log::debug!("WebSocket connected");
2484
2485 self.ws_client.subscribe_block_height().await?;
2486 log::debug!("Subscribed to block height updates");
2487
2488 self.ws_client.subscribe_markets().await?;
2489 log::debug!("Subscribed to markets");
2490
2491 log::debug!(
2492 "Using wallet address for queries: {} (subaccount {})",
2493 self.wallet_address,
2494 self.subaccount_number
2495 );
2496 self.ws_client
2497 .subscribe_subaccount(&self.wallet_address, self.subaccount_number)
2498 .await?;
2499 log::debug!(
2500 "Subscribed to subaccount updates: {}/{}",
2501 self.wallet_address,
2502 self.subaccount_number
2503 );
2504
2505 let stream = self.ws_client.stream();
2506 self.spawn_ws_stream_handler(stream)?;
2507
2508 self.await_account_registered(30.0).await?;
2510
2511 Ok::<(), anyhow::Error>(())
2512 }
2513 .await;
2514
2515 if let Err(e) = session_result {
2516 if let Err(teardown_error) = self.teardown_partial_connect().await {
2517 return Err(e.context(format!(
2518 "dYdX execution startup teardown failed: {teardown_error}"
2519 )));
2520 }
2521 return Err(e);
2522 }
2523
2524 self.core.set_connected();
2525 setup_guard.disarm();
2526 log::info!("Connected: client_id={}", self.core.client_id);
2527 Ok(())
2528 }
2529
2530 async fn disconnect(&mut self) -> anyhow::Result<()> {
2531 log::info!("Disconnecting from dYdX");
2532
2533 self.begin_pending_shutdown();
2534 let ws_client = self.ws_client.clone();
2535 let disconnect_guard = TaskGroupGuard::new(&[&self.session_tasks], move || {
2536 ws_client.begin_shutdown();
2537 });
2538
2539 let _ = self
2540 .ws_client
2541 .unsubscribe_subaccount(&self.wallet_address, self.subaccount_number)
2542 .await
2543 .map_err(|e| log::warn!("Failed to unsubscribe from subaccount: {e}"));
2544
2545 let _ = self
2546 .ws_client
2547 .unsubscribe_markets()
2548 .await
2549 .map_err(|e| log::warn!("Failed to unsubscribe from markets: {e}"));
2550
2551 let _ = self
2552 .ws_client
2553 .unsubscribe_block_height()
2554 .await
2555 .map_err(|e| log::warn!("Failed to unsubscribe from block height: {e}"));
2556
2557 let shutdown_result = self.teardown_partial_connect().await;
2558 disconnect_guard.disarm();
2559 shutdown_result?;
2560 log::info!("Disconnected: client_id={}", self.core.client_id);
2561 Ok(())
2562 }
2563
2564 async fn generate_order_status_report(
2565 &self,
2566 cmd: &GenerateOrderStatusReport,
2567 ) -> anyhow::Result<Option<OrderStatusReport>> {
2568 let market = cmd
2573 .instrument_id
2574 .map(|id| id.symbol.as_str().trim_end_matches("-PERP").to_string());
2575
2576 let response = self
2577 .http_client
2578 .inner
2579 .get_orders(
2580 &self.wallet_address,
2581 self.subaccount_number,
2582 market.as_deref(),
2583 Some(DYDX_INDEXER_REPORT_LIMIT),
2584 )
2585 .await
2586 .context("failed to fetch order from dYdX API")?;
2587
2588 if response.is_empty() {
2589 log::debug!(
2590 "No orders returned for {}/subaccount={} (market_filter={:?})",
2591 self.wallet_address,
2592 self.subaccount_number,
2593 market,
2594 );
2595 return Ok(None);
2596 }
2597
2598 let ts_init = UnixNanos::default();
2599 let scanned_count = response.len();
2600
2601 let report = find_matching_order_report(
2602 &response,
2603 cmd.instrument_id,
2604 cmd.client_order_id,
2605 cmd.venue_order_id,
2606 |clob_pair_id| self.get_instrument_by_clob_pair_id(clob_pair_id),
2607 &self.encoder,
2608 self.core.account_id,
2609 ts_init,
2610 )?;
2611
2612 if report.is_none() {
2613 let page_full = scanned_count == DYDX_INDEXER_REPORT_LIMIT as usize;
2617 log::debug!(
2618 "No order matched filters for {}/subaccount={} \
2619 (client_order_id={:?}, venue_order_id={:?}, instrument_id={:?}, \
2620 scanned={scanned_count}, page_full={page_full}, limit={DYDX_INDEXER_REPORT_LIMIT})",
2621 self.wallet_address,
2622 self.subaccount_number,
2623 cmd.client_order_id,
2624 cmd.venue_order_id,
2625 cmd.instrument_id,
2626 );
2627 }
2628
2629 Ok(report)
2630 }
2631
2632 async fn generate_order_status_reports(
2633 &self,
2634 cmd: &GenerateOrderStatusReports,
2635 ) -> anyhow::Result<Vec<OrderStatusReport>> {
2636 let response = self
2637 .http_client
2638 .inner
2639 .get_orders(
2640 &self.wallet_address,
2641 self.subaccount_number,
2642 None, Some(DYDX_INDEXER_REPORT_LIMIT),
2644 )
2645 .await
2646 .context("failed to fetch orders from dYdX API")?;
2647
2648 let mut reports = Vec::new();
2649 let ts_init = UnixNanos::default();
2650
2651 for order in response {
2652 let instrument = match self.get_instrument_by_clob_pair_id(order.clob_pair_id) {
2653 Some(inst) => inst,
2654 None => continue,
2655 };
2656
2657 if let Some(filter_id) = cmd.instrument_id
2658 && instrument.id() != filter_id
2659 {
2660 continue;
2661 }
2662
2663 match parse_order_status_report(&order, &instrument, self.core.account_id, ts_init) {
2664 Ok(mut r) => {
2665 if !order.client_id.is_empty()
2666 && let Ok(client_id_u32) = order.client_id.parse::<u32>()
2667 {
2668 self.encoder.register_known_client_id(client_id_u32);
2669
2670 if let Some(decoded) = self
2671 .encoder
2672 .decode_if_known(client_id_u32, order.client_metadata)
2673 {
2674 log::debug!(
2675 "Decoded order: dYdX client_id={} meta={:#x} -> '{}'",
2676 client_id_u32,
2677 order.client_metadata,
2678 decoded,
2679 );
2680 r.client_order_id = Some(decoded);
2681 }
2682 }
2683 reports.push(r);
2684 }
2685 Err(e) => {
2686 log::warn!("Failed to parse order status report: {e}");
2687 }
2688 }
2689 }
2690
2691 retain_order_status_reports(&mut reports, cmd);
2692
2693 {
2700 let cache = self.core.cache();
2701 reports.retain(|r| {
2702 let Some(cid) = r.client_order_id else {
2703 return true;
2704 };
2705
2706 match cache.order(&cid) {
2707 Some(order) if order.status().is_closed() => {
2708 log::debug!(
2709 "Skipping reconciliation report for terminal order {cid} \
2710 (cache status={:?}, venue status={:?})",
2711 order.status(),
2712 r.order_status,
2713 );
2714 false
2715 }
2716 _ => true,
2717 }
2718 });
2719 }
2720
2721 Ok(reports)
2722 }
2723
2724 async fn generate_fill_reports(
2725 &self,
2726 cmd: GenerateFillReports,
2727 ) -> anyhow::Result<Vec<FillReport>> {
2728 let response = self
2729 .http_client
2730 .inner
2731 .get_fills(
2732 &self.wallet_address,
2733 self.subaccount_number,
2734 None, Some(DYDX_INDEXER_REPORT_LIMIT),
2736 )
2737 .await
2738 .context("failed to fetch fills from dYdX API")?;
2739
2740 let mut reports = Vec::new();
2741 let ts_init = UnixNanos::default();
2742
2743 for fill in response.fills {
2744 let instrument = match self.get_instrument_by_market(&fill.market) {
2745 Some(inst) => inst,
2746 None => {
2747 log::warn!("Unknown market in fill: {}", fill.market);
2748 continue;
2749 }
2750 };
2751
2752 if let Some(filter_id) = cmd.instrument_id
2753 && instrument.id() != filter_id
2754 {
2755 continue;
2756 }
2757
2758 let report = match parse_fill_report(&fill, &instrument, self.core.account_id, ts_init)
2759 {
2760 Ok(r) => r,
2761 Err(e) => {
2762 log::warn!("Failed to parse fill report: {e}");
2763 continue;
2764 }
2765 };
2766
2767 reports.push(report);
2768 }
2769
2770 if let Some(venue_order_id) = cmd.venue_order_id {
2771 reports.retain(|r| r.venue_order_id.as_str() == venue_order_id.as_str());
2772 }
2773
2774 Ok(reports)
2775 }
2776
2777 async fn generate_position_status_reports(
2778 &self,
2779 cmd: &GeneratePositionStatusReports,
2780 ) -> anyhow::Result<Vec<PositionStatusReport>> {
2781 let response = self
2782 .http_client
2783 .inner
2784 .get_subaccount(&self.wallet_address, self.subaccount_number)
2785 .await
2786 .context("failed to fetch subaccount from dYdX API")?;
2787
2788 let mut reports = Vec::new();
2789 let ts_init = UnixNanos::default();
2790
2791 for (market_ticker, perp_position) in &response.subaccount.open_perpetual_positions {
2792 let instrument = match self.get_instrument_by_market(market_ticker) {
2793 Some(inst) => inst,
2794 None => {
2795 log::warn!("Unknown market in position: {market_ticker}");
2796 continue;
2797 }
2798 };
2799
2800 if let Some(filter_id) = cmd.instrument_id
2801 && instrument.id() != filter_id
2802 {
2803 continue;
2804 }
2805
2806 let report = match parse_position_status_report(
2807 perp_position,
2808 &instrument,
2809 self.core.account_id,
2810 ts_init,
2811 ) {
2812 Ok(r) => r,
2813 Err(e) => {
2814 log::warn!("Failed to parse position status report: {e}");
2815 continue;
2816 }
2817 };
2818
2819 reports.push(report);
2820 }
2821
2822 Ok(reports)
2823 }
2824
2825 async fn generate_mass_status(
2826 &self,
2827 lookback_mins: Option<u64>,
2828 ) -> anyhow::Result<Option<ExecutionMassStatus>> {
2829 let ts_init = self.clock.get_time_ns();
2830
2831 let orders_response = self
2832 .http_client
2833 .inner
2834 .get_orders(
2835 &self.wallet_address,
2836 self.subaccount_number,
2837 None,
2838 Some(DYDX_INDEXER_REPORT_LIMIT),
2839 )
2840 .await
2841 .context("failed to fetch orders for mass status")?;
2842
2843 let subaccount_response = self
2844 .http_client
2845 .inner
2846 .get_subaccount(&self.wallet_address, self.subaccount_number)
2847 .await
2848 .context("failed to fetch subaccount for mass status")?;
2849
2850 let fills_response = self
2851 .http_client
2852 .inner
2853 .get_fills(
2854 &self.wallet_address,
2855 self.subaccount_number,
2856 None,
2857 Some(DYDX_INDEXER_REPORT_LIMIT),
2858 )
2859 .await
2860 .context("failed to fetch fills for mass status")?;
2861
2862 let mut order_reports = Vec::new();
2863 let mut orders_filtered = 0usize;
2864
2865 for order in orders_response {
2866 let instrument = match self.get_instrument_by_clob_pair_id(order.clob_pair_id) {
2867 Some(inst) => inst,
2868 None => {
2869 orders_filtered += 1;
2870 continue;
2871 }
2872 };
2873
2874 match parse_order_status_report(&order, &instrument, self.core.account_id, ts_init) {
2875 Ok(mut r) => {
2876 if !order.client_id.is_empty()
2877 && let Ok(client_id_u32) = order.client_id.parse::<u32>()
2878 {
2879 self.encoder.register_known_client_id(client_id_u32);
2880
2881 if let Some(decoded) = self
2882 .encoder
2883 .decode_if_known(client_id_u32, order.client_metadata)
2884 {
2885 log::debug!(
2886 "Decoded reconciliation order: dYdX client_id={} meta={:#x} -> '{}'",
2887 client_id_u32,
2888 order.client_metadata,
2889 decoded,
2890 );
2891 r.client_order_id = Some(decoded);
2892 }
2893 }
2894 order_reports.push(r);
2895 }
2896 Err(e) => {
2897 log::warn!("Failed to parse order status report: {e}");
2898 orders_filtered += 1;
2899 }
2900 }
2901 }
2902
2903 let mut position_reports = Vec::new();
2904
2905 for (market_ticker, perp_position) in
2906 &subaccount_response.subaccount.open_perpetual_positions
2907 {
2908 let instrument = match self.get_instrument_by_market(market_ticker) {
2909 Some(inst) => inst,
2910 None => continue,
2911 };
2912
2913 match parse_position_status_report(
2914 perp_position,
2915 &instrument,
2916 self.core.account_id,
2917 ts_init,
2918 ) {
2919 Ok(r) => position_reports.push(r),
2920 Err(e) => {
2921 log::warn!("Failed to parse position status report: {e}");
2922 }
2923 }
2924 }
2925
2926 let mut fill_reports = Vec::new();
2927 let mut fills_filtered = 0usize;
2928
2929 for fill in fills_response.fills {
2930 let instrument = match self.get_instrument_by_market(&fill.market) {
2931 Some(inst) => inst,
2932 None => {
2933 fills_filtered += 1;
2934 continue;
2935 }
2936 };
2937
2938 match parse_fill_report(&fill, &instrument, self.core.account_id, ts_init) {
2939 Ok(r) => fill_reports.push(r),
2940 Err(e) => {
2941 log::warn!("Failed to parse fill report: {e}");
2942 fills_filtered += 1;
2943 }
2944 }
2945 }
2946
2947 apply_avg_px_from_fills(&mut order_reports, &fill_reports);
2948
2949 {
2954 let cache = self.core.cache();
2955 order_reports.retain(|r| {
2956 let Some(cid) = r.client_order_id else {
2957 return true;
2958 };
2959
2960 match cache.order(&cid) {
2961 Some(order) if order.status().is_closed() => {
2962 log::debug!(
2963 "Skipping reconciliation report for terminal order {cid} \
2964 (cache status={:?}, venue status={:?})",
2965 order.status(),
2966 r.order_status,
2967 );
2968 false
2969 }
2970 _ => true,
2971 }
2972 });
2973 }
2974
2975 if let Some(mins) = lookback_mins {
2976 let now_ns = self.clock.get_time_ns();
2977 let cutoff = now_ns.saturating_sub(DurationNanos::try_from_mins(mins)?);
2978
2979 let orders_before = order_reports.len();
2980 order_reports.retain(|r| r.ts_last >= cutoff);
2981 let orders_removed = orders_before - order_reports.len();
2982
2983 let fills_before = fill_reports.len();
2984 fill_reports.retain(|r| r.ts_event >= cutoff);
2985 let fills_removed = fills_before - fill_reports.len();
2986
2987 log::debug!(
2988 "Lookback filter ({}min): orders {}->{} (removed {}), fills {}->{} (removed {}), positions {} (unfiltered)",
2989 mins,
2990 orders_before,
2991 order_reports.len(),
2992 orders_removed,
2993 fills_before,
2994 fill_reports.len(),
2995 fills_removed,
2996 position_reports.len(),
2997 );
2998 } else {
2999 log::debug!(
3000 "Generated mass status: {} orders ({} filtered), {} positions, {} fills ({} filtered)",
3001 order_reports.len(),
3002 orders_filtered,
3003 position_reports.len(),
3004 fill_reports.len(),
3005 fills_filtered,
3006 );
3007 }
3008
3009 let mut mass_status = ExecutionMassStatus::new(
3010 self.core.client_id,
3011 self.core.account_id,
3012 self.core.venue,
3013 ts_init,
3014 None, );
3016
3017 mass_status.add_order_reports(order_reports);
3018 mass_status.add_position_reports(position_reports);
3019 mass_status.add_fill_reports(fill_reports);
3020
3021 Ok(Some(mass_status))
3022 }
3023}
3024
3025type CancelAllOrderData = (
3026 StrategyId,
3027 ClientOrderId,
3028 Option<VenueOrderId>,
3029 TimeInForce,
3030 Option<UnixNanos>,
3031);
3032
3033#[derive(Clone, Copy)]
3034struct DydxCancelOrderRequest {
3035 command_id: UUID4,
3036 instrument_id: InstrumentId,
3037 client_id: u32,
3038 order_flags: u32,
3039 strategy_id: StrategyId,
3040 client_order_id: ClientOrderId,
3041 venue_order_id: Option<VenueOrderId>,
3042}
3043
3044fn apply_avg_px_from_fills(order_reports: &mut [OrderStatusReport], fill_reports: &[FillReport]) {
3045 let mut totals: AHashMap<VenueOrderId, (Decimal, Decimal)> = AHashMap::new();
3046 for fill in fill_reports {
3047 let entry = totals.entry(fill.venue_order_id).or_default();
3048 let qty = fill.last_qty.as_decimal();
3049 entry.0 += fill.last_px.as_decimal() * qty;
3050 entry.1 += qty;
3051 }
3052
3053 for report in order_reports {
3054 if let Some((notional, total_qty)) = totals.get(&report.venue_order_id)
3055 && !total_qty.is_zero()
3056 {
3057 report.avg_px = Some(notional / total_qty);
3058 }
3059 }
3060}
3061
3062struct PendingTaskLabel {
3063 id: u64,
3064 labels: Arc<Mutex<AHashMap<u64, &'static str>>>,
3065}
3066
3067impl Drop for PendingTaskLabel {
3068 fn drop(&mut self) {
3069 self.labels.lock().remove(&self.id);
3070 }
3071}
3072
3073#[allow(clippy::too_many_arguments)]
3074fn find_matching_order_report<F>(
3075 orders: &[crate::http::models::Order],
3076 instrument_filter: Option<InstrumentId>,
3077 client_order_id_filter: Option<ClientOrderId>,
3078 venue_order_id_filter: Option<VenueOrderId>,
3079 lookup_instrument: F,
3080 encoder: &ClientOrderIdEncoder,
3081 account_id: AccountId,
3082 ts_init: UnixNanos,
3083) -> anyhow::Result<Option<OrderStatusReport>>
3084where
3085 F: Fn(u32) -> Option<InstrumentAny>,
3086{
3087 for order in orders {
3088 let instrument = match lookup_instrument(order.clob_pair_id) {
3089 Some(inst) => inst,
3090 None => continue,
3091 };
3092
3093 if let Some(filter_id) = instrument_filter
3094 && instrument.id() != filter_id
3095 {
3096 continue;
3097 }
3098
3099 let mut report = parse_order_status_report(order, &instrument, account_id, ts_init)
3100 .context("failed to parse order status report")?;
3101
3102 if !order.client_id.is_empty()
3103 && let Ok(client_id_u32) = order.client_id.parse::<u32>()
3104 {
3105 encoder.register_known_client_id(client_id_u32);
3106
3107 if let Some(decoded) = encoder.decode_if_known(client_id_u32, order.client_metadata) {
3108 log::debug!(
3109 "Decoded order: dYdX client_id={} meta={:#x} -> '{}'",
3110 client_id_u32,
3111 order.client_metadata,
3112 decoded,
3113 );
3114 report.client_order_id = Some(decoded);
3115 }
3116 }
3117
3118 if let Some(client_order_id) = client_order_id_filter
3119 && report.client_order_id != Some(client_order_id)
3120 {
3121 continue;
3122 }
3123
3124 if let Some(venue_order_id) = venue_order_id_filter
3125 && report.venue_order_id.as_str() != venue_order_id.as_str()
3126 {
3127 continue;
3128 }
3129
3130 return Ok(Some(report));
3131 }
3132
3133 Ok(None)
3134}
3135
3136#[cfg(test)]
3137mod tests {
3138 use std::{cell::RefCell, rc::Rc};
3139
3140 use axum::{Json, Router, http::Uri, routing::get};
3141 use jiff::Timestamp;
3142 use nautilus_common::{
3143 cache::Cache, clock::VirtualClock, factories::OrderFactory, messages::ExecutionEvent,
3144 };
3145 use nautilus_model::{
3146 enums::OrderSide,
3147 identifiers::{Symbol, TraderId},
3148 instruments::{CryptoPerpetual, InstrumentAny},
3149 orders::{Order as _, OrderAny},
3150 types::{Currency, Price, Quantity},
3151 };
3152 use rstest::rstest;
3153 use rust_decimal_macros::dec;
3154 use serde_json::Value;
3155
3156 use super::*;
3157 use crate::{
3158 common::{
3159 consts::DYDX_CLIENT_ID,
3160 enums::{DydxOrderStatus, DydxOrderType, DydxTimeInForce},
3161 },
3162 http::models::Order,
3163 };
3164
3165 fn test_instrument(symbol: &str, venue: &str) -> InstrumentAny {
3166 let instrument_id = InstrumentId::new(Symbol::new(symbol), Venue::new(venue));
3167 InstrumentAny::CryptoPerpetual(
3168 CryptoPerpetual::builder()
3169 .instrument_id(instrument_id)
3170 .raw_symbol(instrument_id.symbol)
3171 .base_currency(Currency::BTC())
3172 .quote_currency(Currency::USD())
3173 .settlement_currency(Currency::USD())
3174 .is_inverse(false)
3175 .price_precision(2)
3176 .size_precision(3)
3177 .price_increment(Price::new(0.01, 2))
3178 .size_increment(Quantity::new(0.001, 3))
3179 .ts_event(UnixNanos::default())
3180 .ts_init(UnixNanos::default())
3181 .build()
3182 .unwrap(),
3183 )
3184 }
3185
3186 fn test_order(id: &str, clob_pair_id: u32, client_id: &str) -> Order {
3187 Order {
3188 id: id.to_string(),
3189 subaccount_id: "sub-1".to_string(),
3190 client_id: client_id.to_string(),
3191 clob_pair_id,
3192 side: OrderSide::Buy,
3193 size: dec!(1.0),
3194 total_filled: dec!(0),
3195 price: dec!(50000),
3196 status: DydxOrderStatus::Open,
3197 order_type: DydxOrderType::Limit,
3198 time_in_force: DydxTimeInForce::Gtt,
3199 reduce_only: false,
3200 post_only: false,
3201 order_flags: 64,
3202 good_til_block: None,
3203 good_til_block_time: None,
3204 created_at_height: Some(100),
3205 client_metadata: 4,
3206 trigger_price: None,
3207 condition_type: None,
3208 conditional_order_trigger_subticks: None,
3209 execution: None,
3210 updated_at: None,
3211 updated_at_height: None,
3212 ticker: None,
3213 subaccount_number: 0,
3214 order_router_address: None,
3215 }
3216 }
3217
3218 fn test_order_factory() -> OrderFactory {
3219 let clock = Rc::new(RefCell::new(VirtualClock::new()));
3220 OrderFactory::new(
3221 TraderId::from("TRADER-001"),
3222 StrategyId::from("S-001"),
3223 Some(0),
3224 Some(0),
3225 clock,
3226 false,
3227 false,
3228 )
3229 }
3230
3231 fn create_execution_client() -> (
3232 DydxExecutionClient,
3233 Rc<RefCell<Cache>>,
3234 tokio::sync::mpsc::UnboundedReceiver<ExecutionEvent>,
3235 ) {
3236 const TEST_PRIVATE_KEY: &str =
3237 "0000000000000000000000000000000000000000000000000000000000000001";
3238
3239 let cache = Rc::new(RefCell::new(Cache::default()));
3240 let core = ExecutionClientCore::new(
3241 TraderId::from("TRADER-001"),
3242 *DYDX_CLIENT_ID,
3243 *DYDX_VENUE,
3244 OmsType::Netting,
3245 AccountId::from("DYDX-001"),
3246 AccountType::Margin,
3247 None,
3248 cache.clone(),
3249 );
3250 core.set_connected();
3251
3252 let config = DydxAdapterConfig {
3253 base_url: "http://127.0.0.1:1".to_string(),
3254 ws_url: "ws://127.0.0.1:1".to_string(),
3255 grpc_url: "http://127.0.0.1:1".to_string(),
3256 grpc_urls: vec!["http://127.0.0.1:1".to_string()],
3257 wallet_address: Some("dydx1test".to_string()),
3258 private_key: Some(TEST_PRIVATE_KEY.into()),
3259 ..Default::default()
3260 };
3261
3262 let mut client =
3263 DydxExecutionClient::new(core, config, "dydx1test".to_string(), 0).unwrap();
3264 client
3265 .block_time_monitor
3266 .record_block(100, Timestamp::now());
3267
3268 let (sender, receiver) = tokio::sync::mpsc::unbounded_channel::<ExecutionEvent>();
3269 client.emitter.set_sender(sender);
3270
3271 (client, cache, receiver)
3272 }
3273
3274 #[rstest]
3275 #[tokio::test]
3276 async fn test_mass_status_captures_collection_start() {
3277 let clock: &'static AtomicTime =
3278 Box::leak(Box::new(AtomicTime::new(false, UnixNanos::from(100))));
3279
3280 let router = Router::new().fallback(get(move |uri: Uri| async move {
3281 clock.set_time(UnixNanos::from(200));
3282
3283 let fixture = if uri.path() == "/v4/orders" {
3284 include_str!("../../test_data/http_get_orders.json")
3285 } else if uri.path() == "/v4/fills" {
3286 include_str!("../../test_data/http_get_fills.json")
3287 } else {
3288 include_str!("../../test_data/http_get_subaccount.json")
3289 };
3290
3291 let value: Value = serde_json::from_str(fixture).unwrap();
3292 Json(value["result"].clone())
3293 }));
3294
3295 let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
3296 let addr = listener.local_addr().unwrap();
3297
3298 let server = tokio::spawn(async move {
3299 axum::serve(listener, router).await.unwrap();
3300 });
3301
3302 let (mut client, _cache, _rx) = create_execution_client();
3303 client.clock = clock;
3304 client.http_client = DydxHttpClient::new(
3305 Some(format!("http://{addr}")),
3306 5,
3307 None,
3308 client.config.network,
3309 None,
3310 )
3311 .unwrap();
3312
3313 let snapshot = client.generate_mass_status(None).await.unwrap().unwrap();
3314 server.abort();
3315
3316 assert_eq!(snapshot.ts_init, UnixNanos::from(100));
3317 assert_eq!(clock.get_time_ns(), UnixNanos::from(200));
3318 }
3319
3320 fn cache_order(cache: &Rc<RefCell<Cache>>, order: OrderAny) {
3321 cache
3322 .borrow_mut()
3323 .add_order(order, None, Some(*DYDX_CLIENT_ID), false)
3324 .unwrap();
3325 }
3326
3327 fn recv_order_event(
3328 rx: &mut tokio::sync::mpsc::UnboundedReceiver<ExecutionEvent>,
3329 ) -> OrderEventAny {
3330 match rx.try_recv().expect("expected execution event") {
3331 ExecutionEvent::Order(event) => event,
3332 event => panic!("Expected order event, was {event:?}"),
3333 }
3334 }
3335
3336 #[rstest]
3337 fn test_submit_order_denies_quote_quantity() {
3338 let (client, cache, mut rx) = create_execution_client();
3339 let mut factory = test_order_factory();
3340 let instrument_id = InstrumentId::from("BTC-USD-PERP.DYDX");
3341 let order = factory.market(
3342 instrument_id,
3343 OrderSide::Buy,
3344 Quantity::from("100"),
3345 Some(TimeInForce::Ioc),
3346 None,
3347 Some(true),
3348 None,
3349 None,
3350 None,
3351 Some(ClientOrderId::from("O-QUOTE-QTY")),
3352 );
3353 cache_order(&cache, order.clone());
3354
3355 let command = SubmitOrder::from_order(
3356 &order,
3357 order.trader_id(),
3358 Some(*DYDX_CLIENT_ID),
3359 None,
3360 UUID4::new(),
3361 UnixNanos::default(),
3362 );
3363 client.submit_order(command).unwrap();
3364
3365 match recv_order_event(&mut rx) {
3366 OrderEventAny::Denied(event) => {
3367 assert_eq!(event.client_order_id, order.client_order_id());
3368 assert_eq!(event.instrument_id, instrument_id);
3369 assert_eq!(event.reason, "UNSUPPORTED_QUOTE_QUANTITY");
3370 }
3371 event => panic!("Expected order denied event, was {event:?}"),
3372 }
3373 }
3374
3375 #[rstest]
3376 fn test_submit_order_denies_market_fok() {
3377 let (client, cache, mut rx) = create_execution_client();
3378 let mut factory = test_order_factory();
3379 let instrument_id = InstrumentId::from("BTC-USD-PERP.DYDX");
3380 let order = factory.market(
3381 instrument_id,
3382 OrderSide::Buy,
3383 Quantity::from("0.1"),
3384 Some(TimeInForce::Fok),
3385 None,
3386 Some(false),
3387 None,
3388 None,
3389 None,
3390 Some(ClientOrderId::from("O-MARKET-FOK")),
3391 );
3392 cache_order(&cache, order.clone());
3393
3394 let command = SubmitOrder::from_order(
3395 &order,
3396 order.trader_id(),
3397 Some(*DYDX_CLIENT_ID),
3398 None,
3399 UUID4::new(),
3400 UnixNanos::default(),
3401 );
3402 client.submit_order(command).unwrap();
3403
3404 match recv_order_event(&mut rx) {
3405 OrderEventAny::Denied(event) => {
3406 assert_eq!(event.client_order_id, order.client_order_id());
3407 assert_eq!(event.instrument_id, instrument_id);
3408 assert!(
3409 event.reason.contains("Fill-or-kill") && event.reason.contains("deprecated"),
3410 "expected FOK-deprecation reason, was: {}",
3411 event.reason,
3412 );
3413 }
3414 event => panic!("Expected order denied event, was {event:?}"),
3415 }
3416 }
3417
3418 #[rstest]
3419 fn test_submit_order_denies_limit_fok() {
3420 let (client, cache, mut rx) = create_execution_client();
3424 let mut factory = test_order_factory();
3425 let instrument_id = InstrumentId::from("BTC-USD-PERP.DYDX");
3426 let order = factory.limit(
3427 instrument_id,
3428 OrderSide::Buy,
3429 Quantity::from("0.1"),
3430 Price::from("50000.0"),
3431 Some(TimeInForce::Fok),
3432 None,
3433 Some(false),
3434 None,
3435 Some(false),
3436 None,
3437 None,
3438 None,
3439 None,
3440 None,
3441 None,
3442 Some(ClientOrderId::from("O-LIMIT-FOK")),
3443 );
3444 cache_order(&cache, order.clone());
3445
3446 let command = SubmitOrder::from_order(
3447 &order,
3448 order.trader_id(),
3449 Some(*DYDX_CLIENT_ID),
3450 None,
3451 UUID4::new(),
3452 UnixNanos::default(),
3453 );
3454 client.submit_order(command).unwrap();
3455
3456 match recv_order_event(&mut rx) {
3457 OrderEventAny::Denied(event) => {
3458 assert_eq!(event.client_order_id, order.client_order_id());
3459 assert!(
3460 event.reason.contains("Fill-or-kill") && event.reason.contains("deprecated"),
3461 "expected FOK-deprecation reason, was: {}",
3462 event.reason,
3463 );
3464 }
3465 event => panic!("Expected order denied event, was {event:?}"),
3466 }
3467 }
3468
3469 #[rstest]
3470 fn test_submit_order_denies_day_tif() {
3471 let (client, cache, mut rx) = create_execution_client();
3474 let mut factory = test_order_factory();
3475 let instrument_id = InstrumentId::from("BTC-USD-PERP.DYDX");
3476 let order = factory.limit(
3477 instrument_id,
3478 OrderSide::Buy,
3479 Quantity::from("0.1"),
3480 Price::from("50000.0"),
3481 Some(TimeInForce::Day),
3482 None,
3483 Some(false),
3484 None,
3485 Some(false),
3486 None,
3487 None,
3488 None,
3489 None,
3490 None,
3491 None,
3492 Some(ClientOrderId::from("O-LIMIT-DAY")),
3493 );
3494 cache_order(&cache, order.clone());
3495
3496 let command = SubmitOrder::from_order(
3497 &order,
3498 order.trader_id(),
3499 Some(*DYDX_CLIENT_ID),
3500 None,
3501 UUID4::new(),
3502 UnixNanos::default(),
3503 );
3504 client.submit_order(command).unwrap();
3505
3506 match recv_order_event(&mut rx) {
3507 OrderEventAny::Denied(event) => {
3508 assert_eq!(event.client_order_id, order.client_order_id());
3509 assert!(
3510 event.reason.contains("DAY"),
3511 "expected DAY-unsupported reason, was: {}",
3512 event.reason,
3513 );
3514 }
3515 event => panic!("Expected order denied event, was {event:?}"),
3516 }
3517 }
3518
3519 #[rstest]
3520 #[tokio::test]
3521 async fn test_submit_order_list_denies_quote_quantity() {
3522 use nautilus_model::{
3523 identifiers::OrderListId,
3524 orders::{OrderList, builder::OrderTestBuilder},
3525 };
3526
3527 let requests = Arc::new(std::sync::atomic::AtomicUsize::new(0));
3528 let observed_requests = Arc::clone(&requests);
3529 let router = Router::new().fallback(move || {
3530 observed_requests.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
3531 async { axum::http::StatusCode::NOT_FOUND }
3532 });
3533
3534 let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
3535 let addr = listener.local_addr().unwrap();
3536 let server = tokio::spawn(async move { axum::serve(listener, router).await.unwrap() });
3537 let grpc = DydxGrpcClient::new(format!("http://{addr}")).await.unwrap();
3538 let (mut client, cache, mut rx) = create_execution_client();
3539 client.tx_manager = Some(Arc::new(
3540 TransactionManager::new(
3541 grpc.clone(),
3542 &DydxExecutionClient::resolve_private_key(&client.config).unwrap(),
3543 client.wallet_address.clone(),
3544 client.get_chain_id(),
3545 )
3546 .unwrap(),
3547 ));
3548 client.broadcaster = Some(Arc::new(TxBroadcaster::new(
3549 grpc,
3550 client.config.grpc_quota(),
3551 )));
3552 client.order_builder = Some(Arc::new(OrderMessageBuilder::new(
3553 client.http_client.clone(),
3554 client.wallet_address.clone(),
3555 client.subaccount_number,
3556 client.block_time_monitor.clone(),
3557 )));
3558 let order = OrderTestBuilder::new(OrderType::Limit)
3559 .instrument_id(InstrumentId::from("BTC-USD-PERP.DYDX"))
3560 .quantity(Quantity::from("100"))
3561 .price(Price::from("50000"))
3562 .quote_quantity(true)
3563 .build();
3564 cache_order(&cache, order.clone());
3565
3566 let order_list = OrderList::new(
3567 OrderListId::from("OL-QUOTE"),
3568 order.instrument_id(),
3569 order.strategy_id(),
3570 vec![order.client_order_id()],
3571 UnixNanos::default(),
3572 );
3573
3574 let command = SubmitOrderList::new(
3575 order.trader_id(),
3576 Some(*DYDX_CLIENT_ID),
3577 order.strategy_id(),
3578 order_list,
3579 vec![order.init_event().clone()],
3580 None,
3581 None,
3582 None,
3583 UUID4::new(),
3584 UnixNanos::default(),
3585 None,
3586 );
3587
3588 client.submit_order_list(command).unwrap();
3589
3590 let OrderEventAny::Denied(denied) = recv_order_event(&mut rx) else {
3591 panic!("Expected order denial");
3592 };
3593
3594 assert_eq!(denied.client_order_id, order.client_order_id());
3595 assert_eq!(denied.instrument_id, order.instrument_id());
3596 assert_eq!(denied.reason.as_str(), "UNSUPPORTED_QUOTE_QUANTITY");
3597 assert_eq!(
3598 rx.try_recv().unwrap_err(),
3599 tokio::sync::mpsc::error::TryRecvError::Empty
3600 );
3601 assert_eq!(requests.load(std::sync::atomic::Ordering::Relaxed), 0);
3602 server.abort();
3603 }
3604
3605 #[rstest]
3609 #[case(TimeInForce::Fok, "Fill-or-kill")]
3610 #[case(TimeInForce::Day, "DAY")]
3611 fn test_submit_order_list_denies_unsupported_tif(
3612 #[case] tif: TimeInForce,
3613 #[case] reason_substring: &str,
3614 ) {
3615 use nautilus_common::messages::execution::SubmitOrderList;
3616 use nautilus_model::{identifiers::OrderListId, orders::OrderList};
3617
3618 let (client, cache, mut rx) = create_execution_client();
3619 let mut factory = test_order_factory();
3620 let instrument_id = InstrumentId::from("BTC-USD-PERP.DYDX");
3621 let order = factory.limit(
3622 instrument_id,
3623 OrderSide::Buy,
3624 Quantity::from("0.1"),
3625 Price::from("50000.0"),
3626 Some(tif),
3627 None,
3628 Some(false),
3629 None,
3630 Some(false),
3631 None,
3632 None,
3633 None,
3634 None,
3635 None,
3636 None,
3637 Some(ClientOrderId::from("O-LIST-1")),
3638 );
3639 cache_order(&cache, order.clone());
3640
3641 let order_list = OrderList::new(
3642 OrderListId::from("OL-1"),
3643 instrument_id,
3644 order.strategy_id(),
3645 vec![order.client_order_id()],
3646 UnixNanos::default(),
3647 );
3648 let init = order.init_event().clone();
3649
3650 let cmd = SubmitOrderList::new(
3651 order.trader_id(),
3652 Some(*DYDX_CLIENT_ID),
3653 order.strategy_id(),
3654 order_list,
3655 vec![init],
3656 None,
3657 None,
3658 None,
3659 UUID4::new(),
3660 UnixNanos::default(),
3661 None, );
3663 client.submit_order_list(cmd).unwrap();
3664
3665 match recv_order_event(&mut rx) {
3666 OrderEventAny::Denied(event) => {
3667 assert_eq!(event.client_order_id, order.client_order_id());
3668 assert!(
3669 event.reason.contains(reason_substring),
3670 "expected reason containing {reason_substring:?}, was: {}",
3671 event.reason,
3672 );
3673 }
3674 event => panic!("Expected order denied event, was {event:?}"),
3675 }
3676 }
3677
3678 #[rstest]
3681 fn test_submit_order_list_denies_supported_siblings_on_abort() {
3682 use nautilus_common::messages::execution::SubmitOrderList;
3683 use nautilus_model::{identifiers::OrderListId, orders::OrderList};
3684
3685 let (client, cache, mut rx) = create_execution_client();
3686 let mut factory = test_order_factory();
3687 let instrument_id = InstrumentId::from("BTC-USD-PERP.DYDX");
3688 let order_gtc = factory.limit(
3689 instrument_id,
3690 OrderSide::Buy,
3691 Quantity::from("0.1"),
3692 Price::from("50000.0"),
3693 Some(TimeInForce::Gtc),
3694 None,
3695 Some(false),
3696 None,
3697 Some(false),
3698 None,
3699 None,
3700 None,
3701 None,
3702 None,
3703 None,
3704 Some(ClientOrderId::from("O-MIXED-GTC")),
3705 );
3706 let order_fok = factory.limit(
3707 instrument_id,
3708 OrderSide::Sell,
3709 Quantity::from("0.1"),
3710 Price::from("51000.0"),
3711 Some(TimeInForce::Fok),
3712 None,
3713 Some(false),
3714 None,
3715 Some(false),
3716 None,
3717 None,
3718 None,
3719 None,
3720 None,
3721 None,
3722 Some(ClientOrderId::from("O-MIXED-FOK")),
3723 );
3724 cache_order(&cache, order_gtc.clone());
3725 cache_order(&cache, order_fok.clone());
3726
3727 let order_list = OrderList::new(
3728 OrderListId::from("OL-MIXED"),
3729 instrument_id,
3730 order_gtc.strategy_id(),
3731 vec![order_gtc.client_order_id(), order_fok.client_order_id()],
3732 UnixNanos::default(),
3733 );
3734
3735 let cmd = SubmitOrderList::new(
3736 order_gtc.trader_id(),
3737 Some(*DYDX_CLIENT_ID),
3738 order_gtc.strategy_id(),
3739 order_list,
3740 vec![
3741 order_gtc.init_event().clone(),
3742 order_fok.init_event().clone(),
3743 ],
3744 None,
3745 None,
3746 None,
3747 UUID4::new(),
3748 UnixNanos::default(),
3749 None, );
3751 client.submit_order_list(cmd).unwrap();
3752
3753 let mut denied_reasons = std::collections::HashMap::new();
3754
3755 for _ in 0..2 {
3756 match recv_order_event(&mut rx) {
3757 OrderEventAny::Denied(event) => {
3758 denied_reasons.insert(event.client_order_id, event.reason);
3759 }
3760 event => panic!("Expected order denied event, was {event:?}"),
3761 }
3762 }
3763
3764 assert!(
3765 denied_reasons[&order_gtc.client_order_id()].contains("sibling order"),
3766 "GTC sibling should be denied with list-abort reason",
3767 );
3768 assert!(
3769 denied_reasons[&order_fok.client_order_id()].contains("Fill-or-kill"),
3770 "FOK order should be denied with TIF reason",
3771 );
3772 }
3773
3774 #[tokio::test]
3777 async fn test_pending_task_labels_drain_with_scope() {
3778 let (client, _cache, _rx) = create_execution_client();
3779
3780 client.spawn_labeled("cancel_all_orders", async {
3781 tokio::time::sleep(std::time::Duration::from_secs(60)).await;
3782 });
3783 client.spawn_labeled("submit_order", async {
3784 tokio::time::sleep(std::time::Duration::from_secs(60)).await;
3785 });
3786
3787 {
3788 let labels = client.pending_task_labels.lock();
3789 assert_eq!(labels.len(), 2);
3790 }
3791
3792 client.begin_pending_shutdown();
3793 client
3794 .pending_tasks
3795 .finish_shutdown(Duration::ZERO, Duration::from_secs(1))
3796 .await
3797 .unwrap();
3798
3799 assert!(client.pending_tasks.is_empty());
3800 assert!(client.pending_task_labels.lock().is_empty());
3801 }
3802
3803 #[rstest]
3807 #[case("cancel_all_orders", true)]
3808 #[case("batch_cancel_orders", true)]
3809 #[case("Submit order", false)]
3810 #[case("batch_submit_short_term", false)]
3811 #[case("batch_submit_long_term", false)]
3812 fn test_pending_task_label_classification(
3813 #[case] label: &'static str,
3814 #[case] is_cancel: bool,
3815 ) {
3816 assert_eq!(label.contains("cancel"), is_cancel);
3820 }
3821
3822 #[rstest]
3823 #[case(false)]
3824 #[case(true)]
3825 fn test_emit_partitioned_cancel_failure_emits_each_cancel(#[case] not_sent: bool) {
3826 let clock = get_atomic_clock_realtime();
3827 let mut emitter = ExecutionEventEmitter::new(
3828 clock,
3829 TraderId::from("TRADER-001"),
3830 AccountId::from("DYDX-001"),
3831 AccountType::Margin,
3832 None,
3833 );
3834 let (sender, mut rx) = tokio::sync::mpsc::unbounded_channel::<ExecutionEvent>();
3835 emitter.set_sender(sender);
3836
3837 let instrument_id = InstrumentId::from("BTC-USD-PERP.DYDX");
3838 let orders = vec![
3839 DydxCancelOrderRequest {
3840 command_id: UUID4::new(),
3841 instrument_id,
3842 client_id: 1,
3843 order_flags: types::ORDER_FLAG_SHORT_TERM,
3844 strategy_id: StrategyId::from("S-001"),
3845 client_order_id: ClientOrderId::from("O-CANCEL-1"),
3846 venue_order_id: Some(VenueOrderId::from("V-1")),
3847 },
3848 DydxCancelOrderRequest {
3849 command_id: UUID4::new(),
3850 instrument_id,
3851 client_id: 2,
3852 order_flags: types::ORDER_FLAG_LONG_TERM,
3853 strategy_id: StrategyId::from("S-001"),
3854 client_order_id: ClientOrderId::from("O-CANCEL-2"),
3855 venue_order_id: Some(VenueOrderId::from("V-2")),
3856 },
3857 ];
3858
3859 let failure = if not_sent {
3860 CommandFailure::not_sent("broadcast failed")
3861 } else {
3862 CommandFailure::venue_rejected("broadcast failed")
3863 };
3864
3865 emit_partitioned_cancel_failure(&orders, &emitter, clock, &failure);
3866
3867 for order in &orders {
3868 match recv_order_event(&mut rx) {
3869 OrderEventAny::CancelDenied(event) if not_sent => {
3870 assert_eq!(event.client_order_id, order.client_order_id);
3871 assert_eq!(event.instrument_id, order.instrument_id);
3872 assert_eq!(event.venue_order_id, order.venue_order_id);
3873 assert_eq!(event.reason, "broadcast failed");
3874 assert_eq!(event.causation_id, Some(order.command_id));
3875 }
3876 OrderEventAny::CancelRejected(event) if !not_sent => {
3877 assert_eq!(event.causation_id, Some(order.command_id));
3878 assert_eq!(event.client_order_id, order.client_order_id);
3879 assert_eq!(event.instrument_id, order.instrument_id);
3880 assert_eq!(event.venue_order_id, order.venue_order_id);
3881 assert_eq!(event.reason, "broadcast failed");
3882 }
3883 event => panic!("Expected order cancel rejected event, was {event:?}"),
3884 }
3885 }
3886 assert!(rx.try_recv().is_err());
3887 }
3888
3889 #[rstest]
3890 fn test_find_matching_order_report_returns_later_match() {
3891 let btc_inst = test_instrument("BTC-USD-PERP", "DYDX");
3895 let eth_inst = test_instrument("ETH-USD-PERP", "DYDX");
3896
3897 let orders = vec![
3898 test_order("order-eth", 1, "22222"),
3899 test_order("order-btc", 0, "11111"),
3900 ];
3901
3902 let encoder = ClientOrderIdEncoder::new();
3903 let report = find_matching_order_report(
3904 &orders,
3905 Some(btc_inst.id()),
3906 None,
3907 None,
3908 |clob_pair_id| match clob_pair_id {
3909 0 => Some(btc_inst.clone()),
3910 1 => Some(eth_inst.clone()),
3911 _ => None,
3912 },
3913 &encoder,
3914 AccountId::new("DYDX-001"),
3915 UnixNanos::default(),
3916 )
3917 .expect("lookup should succeed");
3918
3919 let report = report.expect("matching order should be found");
3920 assert_eq!(report.instrument_id, btc_inst.id());
3921 assert_eq!(report.venue_order_id.as_str(), "order-btc");
3922 }
3923
3924 #[rstest]
3925 fn test_find_matching_order_report_returns_none_when_no_match() {
3926 let btc_inst = test_instrument("BTC-USD-PERP", "DYDX");
3927 let eth_inst = test_instrument("ETH-USD-PERP", "DYDX");
3928
3929 let orders = vec![
3930 test_order("order-eth-1", 1, "22222"),
3931 test_order("order-eth-2", 1, "33333"),
3932 ];
3933
3934 let encoder = ClientOrderIdEncoder::new();
3935 let report = find_matching_order_report(
3936 &orders,
3937 Some(btc_inst.id()),
3938 None,
3939 None,
3940 |clob_pair_id| match clob_pair_id {
3941 0 => Some(btc_inst.clone()),
3942 1 => Some(eth_inst.clone()),
3943 _ => None,
3944 },
3945 &encoder,
3946 AccountId::new("DYDX-001"),
3947 UnixNanos::default(),
3948 )
3949 .expect("lookup should succeed");
3950
3951 assert!(report.is_none());
3952 }
3953
3954 #[rstest]
3955 fn test_find_matching_order_report_filters_by_venue_order_id() {
3956 let btc_inst = test_instrument("BTC-USD-PERP", "DYDX");
3957
3958 let orders = vec![
3959 test_order("order-a", 0, "11111"),
3960 test_order("order-b", 0, "22222"),
3961 test_order("order-c", 0, "33333"),
3962 ];
3963
3964 let encoder = ClientOrderIdEncoder::new();
3965 let target = VenueOrderId::new("order-b");
3966 let report = find_matching_order_report(
3967 &orders,
3968 None,
3969 None,
3970 Some(target),
3971 |_| Some(btc_inst.clone()),
3972 &encoder,
3973 AccountId::new("DYDX-001"),
3974 UnixNanos::default(),
3975 )
3976 .expect("lookup should succeed")
3977 .expect("matching order should be found");
3978
3979 assert_eq!(report.venue_order_id.as_str(), "order-b");
3980 }
3981
3982 #[rstest]
3983 fn test_find_matching_order_report_skips_orders_without_cached_instrument() {
3984 let btc_inst = test_instrument("BTC-USD-PERP", "DYDX");
3985
3986 let orders = vec![
3987 test_order("order-unknown", 99, "11111"),
3988 test_order("order-btc", 0, "22222"),
3989 ];
3990
3991 let encoder = ClientOrderIdEncoder::new();
3992 let report = find_matching_order_report(
3993 &orders,
3994 Some(btc_inst.id()),
3995 None,
3996 None,
3997 |clob_pair_id| (clob_pair_id == 0).then(|| btc_inst.clone()),
3998 &encoder,
3999 AccountId::new("DYDX-001"),
4000 UnixNanos::default(),
4001 )
4002 .expect("lookup should succeed")
4003 .expect("matching order should be found");
4004
4005 assert_eq!(report.venue_order_id.as_str(), "order-btc");
4006 }
4007}