1use std::{
23 collections::{HashSet, VecDeque},
24 sync::{
25 Arc,
26 atomic::{AtomicBool, AtomicU64, Ordering},
27 },
28};
29
30use ahash::{AHashMap, AHashSet};
31use futures_util::{StreamExt, future::BoxFuture};
32use indexmap::IndexMap;
33use nautilus_common::{
34 cache::fifo::{FifoCache, FifoCacheMap},
35 live::dst::time::{Duration, Instant},
36};
37use nautilus_core::{
38 AtomicSet, AtomicTime, UUID4, UnixNanos,
39 string::secret::{SecretString, zeroize_json_value},
40 time::get_atomic_clock_realtime,
41};
42use nautilus_live::book::{
43 BookSequenceOutcome, DEFAULT_BOOK_SNAPSHOT_TIMEOUT_SECS, snapshot::SnapshotGate,
44};
45use nautilus_model::{
46 data::{Bar, CustomData, Data, DataType, InstrumentStatus},
47 enums::{MarketStatusAction, OrderSide, OrderType},
48 events::{
49 AccountState, OrderAccepted, OrderCancelDenied, OrderCancelRejected, OrderFilled,
50 OrderModifyDenied, OrderModifyRejected, OrderRejected,
51 },
52 identifiers::{
53 AccountId, ClientOrderId, InstrumentId, StrategyId, Symbol, TradeId, TraderId, VenueOrderId,
54 },
55 instruments::{Instrument, InstrumentAny},
56 reports::FillReport,
57 types::Currency,
58};
59use nautilus_network::{
60 RECONNECTED,
61 error::SendError,
62 retry::{RetryManager, create_websocket_retry_manager},
63 websocket::{AuthTracker, SubscriptionState, WebSocketClient},
64};
65use parking_lot::Mutex;
66use rust_decimal::Decimal;
67use serde_json::value::RawValue;
68use tokio_tungstenite::tungstenite::Message;
69use tokio_util::sync::CancellationToken;
70use ustr::Ustr;
71
72use super::{
73 enums::{DeribitBookMsgType, DeribitHeartbeatType, DeribitWsChannel, DeribitWsMethod},
74 error::DeribitWsError,
75 failure::{
76 REASON_CANCELED, classify_deribit_command_failure, classify_deribit_venue_error,
77 sanitize_strategy_reason, terminal_reason,
78 },
79 messages::{
80 DeribitAuthResult, DeribitBookMsg, DeribitCancelAllByInstrumentParams, DeribitCancelParams,
81 DeribitChartMsg, DeribitEditParams, DeribitHeartbeatParams, DeribitInstrumentStateMsg,
82 DeribitJsonRpcRequest, DeribitJsonRpcResponse, DeribitOrderMsg, DeribitOrderParams,
83 DeribitOrderResponse, DeribitPerpetualMsg, DeribitPortfolioMsg, DeribitQuoteMsg,
84 DeribitSubscribeParams, DeribitTickerMsg, DeribitTradeMsg, DeribitUserTradeMsg,
85 DeribitVolatilityIndexMsg, DeribitWsMessage, NautilusWsMessage, parse_raw_message,
86 },
87 parse::{
88 OrderEventType, determine_order_event_type, parse_book_depth, parse_book_msg,
89 parse_chart_msg, parse_deribit_order_type, parse_order_accepted_with_client_order_id,
90 parse_order_canceled_with_client_order_id, parse_order_expired_with_client_order_id,
91 parse_order_updated_with_client_order_id, parse_perpetual_to_funding_rate, parse_quote_msg,
92 parse_ticker_to_index_price, parse_ticker_to_mark_price, parse_ticker_to_option_greeks,
93 parse_trades_data, parse_user_order_msg, parse_user_trade_msg, resolution_to_bar_type,
94 },
95};
96use crate::{
97 book::{
98 recovery::{BookRecovery, recover},
99 sync::{BookKey, BookSyncTracker, UnsubscribedOutcome},
100 },
101 common::{
102 consts::{DERIBIT_RATE_LIMIT_KEY_ORDER, DERIBIT_VENUE, DERIBIT_WS_SUBSCRIPTION_KEY},
103 enums::DeribitInstrumentState,
104 parse::{parse_portfolio_to_account_state, use_cost_for_bar_volume},
105 },
106 data_types::DeribitVolatilityIndex,
107};
108
109const SUBSCRIPTION_REQUEST_MAX_BYTES: usize = 32_000;
111
112const REPLAY_CACHE_CAPACITY: usize = 10_000;
114
115#[derive(Debug, Clone)]
117pub enum PendingRequestType {
118 Authenticate,
120 Subscribe { channels: Vec<String> },
122 Unsubscribe { channels: Vec<String> },
124 SetHeartbeat,
126 Test,
128 Buy {
130 client_order_id: ClientOrderId,
131 trader_id: TraderId,
132 strategy_id: StrategyId,
133 instrument_id: InstrumentId,
134 order_side: OrderSide,
135 order_type: OrderType,
136 },
137 Sell {
139 client_order_id: ClientOrderId,
140 trader_id: TraderId,
141 strategy_id: StrategyId,
142 instrument_id: InstrumentId,
143 order_side: OrderSide,
144 order_type: OrderType,
145 },
146 Edit {
148 causation_id: Option<UUID4>,
149 venue_order_id: Option<VenueOrderId>,
150 client_order_id: ClientOrderId,
151 trader_id: TraderId,
152 strategy_id: StrategyId,
153 instrument_id: InstrumentId,
154 },
155 Cancel {
157 causation_id: Option<UUID4>,
158 venue_order_id: Option<VenueOrderId>,
159 client_order_id: ClientOrderId,
160 trader_id: TraderId,
161 strategy_id: StrategyId,
162 instrument_id: InstrumentId,
163 },
164 CancelAllByInstrument { instrument_id: InstrumentId },
166 GetOrderState {
168 client_order_id: ClientOrderId,
169 trader_id: TraderId,
170 strategy_id: StrategyId,
171 instrument_id: InstrumentId,
172 },
173}
174
175#[allow(missing_debug_implementations)]
177pub enum HandlerCommand {
178 SetClient(WebSocketClient),
180 Disconnect,
182 Authenticate { auth_params: SecretString },
184 SetHeartbeat { interval: u64 },
186 InitializeInstruments(Vec<InstrumentAny>),
188 UpdateInstrument(Box<InstrumentAny>),
190 Subscribe { channels: Vec<String> },
192 Unsubscribe { channels: Vec<String> },
194 Buy {
196 params: DeribitOrderParams,
197 client_order_id: ClientOrderId,
198 trader_id: TraderId,
199 strategy_id: StrategyId,
200 instrument_id: InstrumentId,
201 },
202 Sell {
204 params: DeribitOrderParams,
205 client_order_id: ClientOrderId,
206 trader_id: TraderId,
207 strategy_id: StrategyId,
208 instrument_id: InstrumentId,
209 },
210 Edit {
212 causation_id: Option<UUID4>,
213 params: DeribitEditParams,
214 client_order_id: ClientOrderId,
215 trader_id: TraderId,
216 strategy_id: StrategyId,
217 instrument_id: InstrumentId,
218 },
219 Cancel {
221 causation_id: Option<UUID4>,
222 params: DeribitCancelParams,
223 client_order_id: ClientOrderId,
224 trader_id: TraderId,
225 strategy_id: StrategyId,
226 instrument_id: InstrumentId,
227 },
228 CancelAllByInstrument {
230 params: DeribitCancelAllByInstrumentParams,
231 instrument_id: InstrumentId,
232 },
233 GetOrderState {
235 order_id: String,
236 client_order_id: ClientOrderId,
237 trader_id: TraderId,
238 strategy_id: StrategyId,
239 instrument_id: InstrumentId,
240 },
241 RecoverBook {
243 instrument: Ustr,
244 channel: Option<String>,
245 cancel: CancellationToken,
246 gate: SnapshotGate,
247 completion: tokio::sync::oneshot::Sender<Result<(), DeribitWsError>>,
248 recovery: Arc<BookRecovery>,
249 },
250}
251
252#[derive(Debug, Clone)]
256pub struct OrderContext {
257 pub client_order_id: ClientOrderId,
258 pub trader_id: TraderId,
259 pub strategy_id: StrategyId,
260 pub instrument_id: InstrumentId,
261 pub order_side: OrderSide,
262 pub order_type: OrderType,
263 pub accepted: bool,
264 pub last_order_signature: Option<OrderSignature>,
265}
266
267#[derive(Debug, Clone)]
268struct TerminalOrderContext {
269 context: OrderContext,
270 late_fills_as_reports: bool,
271}
272
273pub type OrderSignature = (Decimal, Option<Decimal>, Option<Decimal>);
275
276#[allow(missing_debug_implementations)]
280pub struct DeribitWsFeedHandler {
281 clock: &'static AtomicTime,
282 signal: Arc<AtomicBool>,
283 inner: Option<Arc<WebSocketClient>>,
284 cmd_rx: tokio::sync::mpsc::UnboundedReceiver<HandlerCommand>,
285 pending_command: Option<HandlerCommand>,
286 subscription_requests: VecDeque<(u64, String)>,
287 subscription_send: Option<SubscriptionSend>,
288 raw_rx: tokio::sync::mpsc::UnboundedReceiver<Message>,
289 out_tx: tokio::sync::mpsc::UnboundedSender<NautilusWsMessage>,
290 auth_tracker: AuthTracker,
291 subscriptions_state: SubscriptionState,
292 retry_manager: RetryManager<DeribitWsError>,
293 instruments_cache: AHashMap<Ustr, InstrumentAny>,
294 option_greeks_subs: Arc<AtomicSet<InstrumentId>>,
295 mark_price_subs: Arc<AtomicSet<InstrumentId>>,
296 index_price_subs: Arc<AtomicSet<InstrumentId>>,
297 request_id_counter: AtomicU64,
298 pending_requests: AHashMap<u64, PendingRequestType>,
299 book_recovery_requests: AHashMap<BookKey, AHashSet<u64>>,
300 account_id: Option<AccountId>,
301 order_contexts: AHashMap<VenueOrderId, OrderContext>,
302 submitted_order_contexts: AHashMap<ClientOrderId, OrderContext>,
304
305 terminal_order_contexts:
307 FifoCacheMap<VenueOrderId, TerminalOrderContext, REPLAY_CACHE_CAPACITY>,
308
309 emitted_trades: FifoCache<(VenueOrderId, TradeId), REPLAY_CACHE_CAPACITY>,
310 pending_bars: AHashMap<String, Bar>,
311 bars_timestamp_on_close: bool,
312 last_account_states: AHashMap<String, AccountState>,
313 book_depth_subs: Arc<tokio::sync::Mutex<SubscriptionState>>,
314 book_sync: BookSyncTracker,
315 book_cmd_tx: Option<tokio::sync::mpsc::UnboundedSender<HandlerCommand>>,
316 book_snapshot_timeout: Duration,
317 book_stale_threshold: Duration,
318 book_monitor_last: Instant,
319 pending_outgoing: VecDeque<NautilusWsMessage>,
320 subscribe_errors: Arc<Mutex<Vec<String>>>,
321}
322
323impl DeribitWsFeedHandler {
324 #[expect(clippy::too_many_arguments)]
326 #[must_use]
327 pub fn new(
328 signal: Arc<AtomicBool>,
329 cmd_rx: tokio::sync::mpsc::UnboundedReceiver<HandlerCommand>,
330 raw_rx: tokio::sync::mpsc::UnboundedReceiver<Message>,
331 out_tx: tokio::sync::mpsc::UnboundedSender<NautilusWsMessage>,
332 auth_tracker: AuthTracker,
333 subscriptions_state: SubscriptionState,
334 option_greeks_subs: Arc<AtomicSet<InstrumentId>>,
335 mark_price_subs: Arc<AtomicSet<InstrumentId>>,
336 index_price_subs: Arc<AtomicSet<InstrumentId>>,
337 account_id: Option<AccountId>,
338 bars_timestamp_on_close: bool,
339 subscribe_errors: Arc<Mutex<Vec<String>>>,
340 ) -> Self {
341 Self {
342 clock: get_atomic_clock_realtime(),
343 signal,
344 inner: None,
345 cmd_rx,
346 pending_command: None,
347 subscription_requests: VecDeque::new(),
348 subscription_send: None,
349 raw_rx,
350 out_tx,
351 auth_tracker,
352 subscriptions_state,
353 retry_manager: create_websocket_retry_manager(),
354 instruments_cache: AHashMap::new(),
355 option_greeks_subs,
356 mark_price_subs,
357 index_price_subs,
358 request_id_counter: AtomicU64::new(1),
359 pending_requests: AHashMap::new(),
360 book_recovery_requests: AHashMap::new(),
361 account_id,
362 order_contexts: AHashMap::new(),
363 submitted_order_contexts: AHashMap::new(),
364 terminal_order_contexts: FifoCacheMap::new(),
365 emitted_trades: FifoCache::new(),
366 pending_bars: AHashMap::new(),
367 bars_timestamp_on_close,
368 last_account_states: AHashMap::new(),
369 book_depth_subs: Arc::new(tokio::sync::Mutex::new(SubscriptionState::new('.'))),
370 book_sync: BookSyncTracker::default(),
371 book_cmd_tx: None,
372 book_snapshot_timeout: Duration::from_secs(DEFAULT_BOOK_SNAPSHOT_TIMEOUT_SECS),
373 book_stale_threshold: Duration::from_secs(120),
374 book_monitor_last: Instant::now(),
375 pending_outgoing: VecDeque::new(),
376 subscribe_errors,
377 }
378 }
379
380 pub(crate) fn set_book_sync(
382 &mut self,
383 cmd_tx: tokio::sync::mpsc::UnboundedSender<HandlerCommand>,
384 snapshot_timeout: Duration,
385 stale_threshold: Duration,
386 ) {
387 self.book_cmd_tx = Some(cmd_tx);
388 self.book_snapshot_timeout = snapshot_timeout;
389 self.book_stale_threshold = stale_threshold;
390 }
391
392 pub fn set_account_id(&mut self, account_id: AccountId) {
394 self.account_id = Some(account_id);
395 }
396
397 #[must_use]
399 pub fn account_id(&self) -> Option<AccountId> {
400 self.account_id
401 }
402
403 fn clear_state(&mut self) {
404 let pending_count = self.pending_requests.len();
405 let bars_count = self.pending_bars.len();
406 let account_count = self.last_account_states.len();
407 let book_count = self.book_sync.len();
408 let outgoing_count = self.pending_outgoing.len();
409
410 self.pending_requests.clear();
411 self.book_recovery_requests.clear();
412 self.subscription_requests.clear();
413 self.subscription_send = None;
414 self.pending_bars.clear();
415 self.last_account_states.clear();
416 self.book_sync.reset_on_reconnect();
417 self.pending_outgoing.clear();
418
419 log::debug!(
420 "Reset state: pending_requests={pending_count}, pending_bars={bars_count}, \
421 account_states={account_count}, book_sync={book_count}, \
422 pending_outgoing={outgoing_count}"
423 );
424 }
425
426 pub(crate) fn set_book_depth_subs(&mut self, subs: Arc<tokio::sync::Mutex<SubscriptionState>>) {
427 self.book_depth_subs = subs;
428 }
429
430 fn next_request_id(&self) -> u64 {
432 self.request_id_counter.fetch_add(1, Ordering::Relaxed)
433 }
434
435 fn ts_init(&self) -> UnixNanos {
437 self.clock.get_time_ns()
438 }
439
440 async fn send_tracked_request(
441 &mut self,
442 request_id: u64,
443 payload: Result<String, DeribitWsError>,
444 rate_limit_keys: Option<&[Ustr]>,
445 ) -> Result<(), DeribitWsError> {
446 let payload = match payload {
447 Ok(payload) => payload,
448 Err(e) => {
449 self.pending_requests.remove(&request_id);
450 return Err(e);
451 }
452 };
453
454 self.send_with_retry(payload, rate_limit_keys).await
455 }
456
457 fn send_with_retry(
459 &self,
460 payload: String,
461 rate_limit_keys: Option<&[Ustr]>,
462 ) -> BoxFuture<'static, Result<(), DeribitWsError>> {
463 self.send_secret_with_retry(payload.into(), rate_limit_keys)
464 }
465
466 fn send_secret_with_retry(
467 &self,
468 payload: SecretString,
469 rate_limit_keys: Option<&[Ustr]>,
470 ) -> BoxFuture<'static, Result<(), DeribitWsError>> {
471 let client = self.inner.clone();
472 let retry_manager = self.retry_manager.clone();
473 let keys_owned: Option<Vec<Ustr>> = rate_limit_keys.map(<[Ustr]>::to_vec);
474 Box::pin(async move {
475 let Some(client) = client else {
476 return Err(DeribitWsError::NotConnected);
477 };
478
479 retry_manager
480 .invocation(
481 "websocket_send",
482 || {
483 let payload = payload.clone();
484 let keys = keys_owned.clone();
485 let client = client.clone();
486 async move {
487 client
488 .send_text(payload.expose_secret().to_owned(), keys.as_deref())
489 .await
490 .map_err(|e| DeribitWsError::Send(e.to_string()))
491 }
492 },
493 |e| matches!(e, DeribitWsError::Send(_)),
494 |e| DeribitWsError::Timeout(e.to_string()),
495 )
496 .execute()
497 .await
498 })
499 }
500
501 fn send_order_once(&self, payload: String) -> BoxFuture<'static, Result<(), DeribitWsError>> {
507 if self.signal.load(Ordering::Acquire) {
508 return Box::pin(async { Err(DeribitWsError::CanceledBeforeSend) });
509 }
510
511 let Some(client) = self.inner.clone() else {
512 return Box::pin(async { Err(DeribitWsError::NotConnected) });
513 };
514
515 if client.is_reconnecting() {
516 return Box::pin(async {
517 Err(DeribitWsError::TransportSend(SendError::ConnectionChanged))
518 });
519 }
520
521 let connection_epoch = client.connection_epoch();
522 let keys = *DERIBIT_RATE_LIMIT_KEY_ORDER;
523 Box::pin(async move {
524 client
525 .send_text_on_connection(payload, Some(keys.as_slice()), connection_epoch)
526 .await
527 .map_err(DeribitWsError::TransportSend)
528 })
529 }
530
531 fn terminal_command_reason(&self, error: &DeribitWsError) -> Option<String> {
532 let failure = classify_deribit_command_failure(error);
533
534 let Some(reason) = terminal_reason(&failure) else {
535 log::warn!("Ambiguous order command outcome, awaiting reconciliation: {error}");
536 return None;
537 };
538
539 log::warn!("Order command was not sent: {error}");
540 Some(reason.to_string())
541 }
542
543 fn venue_command_reason(
544 code: i64,
545 message: &str,
546 data: Option<&serde_json::Value>,
547 ) -> Option<(String, bool)> {
548 log::warn!("Venue order command result: code={code}, message={message}, data={data:?}");
549 let (failure, due_post_only) = classify_deribit_venue_error(code, message);
550
551 let Some(reason) = terminal_reason(&failure) else {
552 log::warn!(
553 "Ambiguous venue order command outcome, awaiting reconciliation: code={code}, message={message}, data={data:?}"
554 );
555 return None;
556 };
557
558 Some((reason.to_string(), due_post_only))
559 }
560
561 fn should_track_command(&self, sent: &Result<(), DeribitWsError>) -> bool {
562 match sent {
563 Ok(()) => true,
564 Err(e) => terminal_reason(&classify_deribit_command_failure(e)).is_none(),
565 }
566 }
567
568 fn track_submit(&mut self, request_id: u64, context: OrderContext) {
569 let pending = match context.order_side {
570 OrderSide::Buy => PendingRequestType::Buy {
571 client_order_id: context.client_order_id,
572 trader_id: context.trader_id,
573 strategy_id: context.strategy_id,
574 instrument_id: context.instrument_id,
575 order_side: context.order_side,
576 order_type: context.order_type,
577 },
578 OrderSide::Sell => PendingRequestType::Sell {
579 client_order_id: context.client_order_id,
580 trader_id: context.trader_id,
581 strategy_id: context.strategy_id,
582 instrument_id: context.instrument_id,
583 order_side: context.order_side,
584 order_type: context.order_type,
585 },
586 };
587
588 self.submitted_order_contexts
589 .insert(context.client_order_id, context);
590 self.pending_requests.insert(request_id, pending);
591 }
592
593 fn order_rejected(
594 &self,
595 trader_id: TraderId,
596 strategy_id: StrategyId,
597 instrument_id: InstrumentId,
598 client_order_id: ClientOrderId,
599 reason: &str,
600 due_post_only: bool,
601 ) -> OrderRejected {
602 let ts_init = self.ts_init();
603
604 OrderRejected::new(
605 trader_id,
606 strategy_id,
607 instrument_id,
608 client_order_id,
609 self.account_id.unwrap_or(AccountId::new("DERIBIT-UNKNOWN")),
610 ustr::ustr(reason),
611 UUID4::new(),
612 ts_init,
613 ts_init,
614 false,
615 due_post_only,
616 )
617 }
618
619 #[expect(
620 clippy::too_many_arguments,
621 reason = "event construction preserves order identity and command correlation"
622 )]
623 fn order_modify_denied(
624 &self,
625 trader_id: TraderId,
626 strategy_id: StrategyId,
627 instrument_id: InstrumentId,
628 client_order_id: ClientOrderId,
629 venue_order_id: Option<VenueOrderId>,
630 causation_id: Option<UUID4>,
631 reason: &str,
632 ) -> OrderModifyDenied {
633 let ts_init = self.ts_init();
634
635 let mut event = OrderModifyDenied::new(
636 trader_id,
637 strategy_id,
638 instrument_id,
639 client_order_id,
640 reason.into(),
641 UUID4::new(),
642 ts_init,
643 ts_init,
644 venue_order_id,
645 self.account_id,
646 );
647 event.causation_id = causation_id;
648 event
649 }
650
651 #[expect(
652 clippy::too_many_arguments,
653 reason = "event construction preserves order identity and command correlation"
654 )]
655 fn order_cancel_denied(
656 &self,
657 trader_id: TraderId,
658 strategy_id: StrategyId,
659 instrument_id: InstrumentId,
660 client_order_id: ClientOrderId,
661 venue_order_id: Option<VenueOrderId>,
662 causation_id: Option<UUID4>,
663 reason: &str,
664 ) -> OrderCancelDenied {
665 let ts_init = self.ts_init();
666
667 let mut event = OrderCancelDenied::new(
668 trader_id,
669 strategy_id,
670 instrument_id,
671 client_order_id,
672 reason.into(),
673 UUID4::new(),
674 ts_init,
675 ts_init,
676 venue_order_id,
677 self.account_id,
678 );
679 event.causation_id = causation_id;
680 event
681 }
682
683 fn order_modify_rejected(
684 &self,
685 trader_id: TraderId,
686 strategy_id: StrategyId,
687 instrument_id: InstrumentId,
688 client_order_id: ClientOrderId,
689 venue_order_id: Option<VenueOrderId>,
690 reason: &str,
691 ) -> OrderModifyRejected {
692 let ts_init = self.ts_init();
693
694 OrderModifyRejected::new(
695 trader_id,
696 strategy_id,
697 instrument_id,
698 client_order_id,
699 ustr::ustr(reason),
700 UUID4::new(),
701 ts_init,
702 ts_init,
703 false,
704 venue_order_id,
705 self.account_id,
706 )
707 }
708
709 fn fail_unsent_order_commands(&mut self) {
710 self.cmd_rx.close();
711 let mut commands = Vec::new();
712 if let Some(command) = self.pending_command.take() {
713 commands.push(command);
714 }
715
716 while let Ok(command) = self.cmd_rx.try_recv() {
717 commands.push(command);
718 }
719
720 for command in commands {
721 match command {
722 HandlerCommand::Buy {
723 client_order_id,
724 trader_id,
725 strategy_id,
726 instrument_id,
727 ..
728 }
729 | HandlerCommand::Sell {
730 client_order_id,
731 trader_id,
732 strategy_id,
733 instrument_id,
734 ..
735 } => {
736 let _ =
737 self.out_tx
738 .send(NautilusWsMessage::OrderRejected(self.order_rejected(
739 trader_id,
740 strategy_id,
741 instrument_id,
742 client_order_id,
743 REASON_CANCELED,
744 false,
745 )));
746 }
747 HandlerCommand::Edit {
748 causation_id,
749 params,
750 client_order_id,
751 trader_id,
752 strategy_id,
753 instrument_id,
754 } => {
755 let _ = self.out_tx.send(NautilusWsMessage::OrderModifyDenied(
756 self.order_modify_denied(
757 trader_id,
758 strategy_id,
759 instrument_id,
760 client_order_id,
761 VenueOrderId::new_checked(params.order_id).ok(),
762 causation_id,
763 REASON_CANCELED,
764 ),
765 ));
766 }
767 HandlerCommand::Cancel {
768 causation_id,
769 params,
770 client_order_id,
771 trader_id,
772 strategy_id,
773 instrument_id,
774 } => {
775 let _ = self.out_tx.send(NautilusWsMessage::OrderCancelDenied(
776 self.order_cancel_denied(
777 trader_id,
778 strategy_id,
779 instrument_id,
780 client_order_id,
781 VenueOrderId::new_checked(params.order_id).ok(),
782 causation_id,
783 REASON_CANCELED,
784 ),
785 ));
786 }
787 HandlerCommand::CancelAllByInstrument { instrument_id, .. } => {
788 log::warn!(
789 "Cancel all by instrument canceled before transmission for {instrument_id}"
790 );
791 }
792 _ => {}
793 }
794 }
795 }
796
797 fn order_cancel_rejected(
798 &self,
799 trader_id: TraderId,
800 strategy_id: StrategyId,
801 instrument_id: InstrumentId,
802 client_order_id: ClientOrderId,
803 venue_order_id: Option<VenueOrderId>,
804 reason: &str,
805 ) -> OrderCancelRejected {
806 let ts_init = self.ts_init();
807
808 OrderCancelRejected::new(
809 trader_id,
810 strategy_id,
811 instrument_id,
812 client_order_id,
813 ustr::ustr(reason),
814 UUID4::new(),
815 ts_init,
816 ts_init,
817 false,
818 venue_order_id,
819 self.account_id,
820 )
821 }
822
823 async fn handle_authenticate(&mut self, auth_params: SecretString) {
824 let request_id = self.next_request_id();
825 log::debug!("Authenticating: request_id={request_id}");
826
827 let auth_params: serde_json::Value = match serde_json::from_str(auth_params.expose_secret())
828 {
829 Ok(auth_params) => auth_params,
830 Err(e) => {
831 log::error!("Failed to deserialize auth params: {e}");
832 self.auth_tracker.fail(format!("Serialization failed: {e}"));
833 return;
834 }
835 };
836 self.pending_requests
837 .insert(request_id, PendingRequestType::Authenticate);
838
839 let mut request = DeribitJsonRpcRequest::new(
840 request_id,
841 DeribitWsMethod::PublicAuth.as_method_str(),
842 auth_params,
843 );
844 let serialized = serde_json::to_string(&request).map(SecretString::from);
845 zeroize_json_value(&mut request.params);
846 drop(request);
847
848 match serialized {
849 Ok(payload) => {
850 if let Err(e) = self.send_secret_with_retry(payload, None).await {
851 self.pending_requests.remove(&request_id);
852 log::error!("Authentication send failed: {e}");
853 self.auth_tracker.fail(format!("Send failed: {e}"));
854 }
855 }
856 Err(e) => {
857 self.pending_requests.remove(&request_id);
858 log::error!("Failed to serialize auth request: {e}");
859 self.auth_tracker.fail(format!("Serialization failed: {e}"));
860 }
861 }
862 }
863
864 fn handle_subscribe(&mut self, channels: &[String]) -> Result<Vec<u64>, DeribitWsError> {
868 let result = self.queue_subscription_requests(channels.to_vec(), true);
869 if result.is_ok() {
870 for channel in channels {
871 if let Some(key) = BookKey::for_channel(channel)
872 && let Some(instrument_id) = book_instrument_id(channel)
873 {
874 self.book_sync.record_subscription(key, instrument_id);
875 }
876 }
877 }
878
879 if let Err(e) = &result {
880 self.subscribe_errors.lock().push(e.to_string());
881 }
882
883 result
884 }
885
886 fn handle_unsubscribe(&mut self, channels: Vec<String>) -> Result<Vec<u64>, DeribitWsError> {
888 self.queue_subscription_requests(channels, false)
889 }
890
891 fn queue_subscription_requests(
892 &mut self,
893 channels: Vec<String>,
894 subscribe: bool,
895 ) -> Result<Vec<u64>, DeribitWsError> {
896 let private = channels
897 .iter()
898 .any(|ch| DeribitWsChannel::requires_auth(ch));
899
900 let method = match (subscribe, private) {
901 (true, true) => DeribitWsMethod::PrivateSubscribe,
902 (true, false) => DeribitWsMethod::PublicSubscribe,
903 (false, true) => DeribitWsMethod::PrivateUnsubscribe,
904 (false, false) => DeribitWsMethod::PublicUnsubscribe,
905 };
906
907 let batches = subscription_batches(channels, &method)?;
908 let mut request_ids = Vec::with_capacity(batches.len());
909 for channels in batches {
910 let request_id = self.next_request_id();
911 request_ids.push(request_id);
912
913 let request = DeribitJsonRpcRequest::new(
914 request_id,
915 method.as_method_str(),
916 DeribitSubscribeParams { channels },
917 );
918 let payload =
919 serde_json::to_string(&request).map_err(|e| DeribitWsError::Json(e.to_string()))?;
920 let channels = request.params.channels;
921 let pending = if subscribe {
922 PendingRequestType::Subscribe { channels }
923 } else {
924 PendingRequestType::Unsubscribe { channels }
925 };
926
927 self.pending_requests.insert(request_id, pending);
928 self.subscription_requests.push_back((request_id, payload));
929 }
930
931 Ok(request_ids)
932 }
933
934 fn coalesce_subscriptions(&mut self, mut channels: Vec<String>) -> Vec<String> {
935 let private = channels
936 .iter()
937 .any(|ch| DeribitWsChannel::requires_auth(ch));
938 let mut bytes = channels.iter().map(|ch| ch.len() + 3).sum::<usize>();
939 while bytes < SUBSCRIPTION_REQUEST_MAX_BYTES {
940 let Ok(cmd) = self.cmd_rx.try_recv() else {
941 break;
942 };
943
944 match cmd {
945 HandlerCommand::Subscribe { channels: adjacent }
946 if adjacent
947 .iter()
948 .any(|ch| DeribitWsChannel::requires_auth(ch))
949 == private =>
950 {
951 bytes += adjacent.iter().map(|ch| ch.len() + 3).sum::<usize>() + 1;
952 channels.extend(adjacent);
953 }
954 cmd => {
955 self.pending_command = Some(cmd);
956 break;
957 }
958 }
959 }
960
961 channels
962 }
963
964 async fn handle_set_heartbeat(&mut self, interval: u64) -> Result<(), DeribitWsError> {
966 let request_id = self.next_request_id();
967
968 self.pending_requests
970 .insert(request_id, PendingRequestType::SetHeartbeat);
971
972 let request = DeribitJsonRpcRequest::new(
973 request_id,
974 DeribitWsMethod::SetHeartbeat.as_method_str(),
975 DeribitHeartbeatParams { interval },
976 );
977
978 let payload =
979 serde_json::to_string(&request).map_err(|e| DeribitWsError::Json(e.to_string()));
980
981 log::debug!(
982 "Enabling heartbeat with interval: request_id={request_id}, interval={interval} seconds"
983 );
984 self.send_tracked_request(request_id, payload, None).await
985 }
986
987 async fn handle_heartbeat_test_request(&mut self) -> Result<(), DeribitWsError> {
989 let request_id = self.next_request_id();
990
991 self.pending_requests
993 .insert(request_id, PendingRequestType::Test);
994
995 let request = DeribitJsonRpcRequest::new(
996 request_id,
997 DeribitWsMethod::Test.as_method_str(),
998 serde_json::json!({}),
999 );
1000
1001 let payload =
1002 serde_json::to_string(&request).map_err(|e| DeribitWsError::Json(e.to_string()));
1003
1004 log::trace!("Responding to heartbeat test_request: request_id={request_id}");
1005 self.send_tracked_request(request_id, payload, None).await
1006 }
1007
1008 async fn handle_submit(
1010 &mut self,
1011 order_side: OrderSide,
1012 params: DeribitOrderParams,
1013 client_order_id: ClientOrderId,
1014 trader_id: TraderId,
1015 strategy_id: StrategyId,
1016 instrument_id: InstrumentId,
1017 ) -> Result<(), DeribitWsError> {
1018 let request_id = self.next_request_id();
1019 let order_type = parse_deribit_order_type(¶ms.order_type);
1020 let order_signature = (params.amount, params.price, params.trigger_price);
1021
1022 let (method, side) = match order_side {
1023 OrderSide::Buy => (DeribitWsMethod::Buy, "buy"),
1024 OrderSide::Sell => (DeribitWsMethod::Sell, "sell"),
1025 };
1026
1027 let request = DeribitJsonRpcRequest::new(request_id, method.as_method_str(), params);
1028 let payload =
1029 serde_json::to_string(&request).map_err(|e| DeribitWsError::Encode(e.to_string()))?;
1030
1031 log::debug!("Sending {side} order: request_id={request_id}");
1032 let sent = self.send_order_once(payload).await;
1033 if self.should_track_command(&sent) {
1034 self.track_submit(
1035 request_id,
1036 OrderContext {
1037 client_order_id,
1038 trader_id,
1039 strategy_id,
1040 instrument_id,
1041 order_side,
1042 order_type,
1043 accepted: false,
1044 last_order_signature: Some(order_signature),
1045 },
1046 );
1047 }
1048
1049 sent
1050 }
1051
1052 async fn handle_edit(
1054 &mut self,
1055 params: DeribitEditParams,
1056 client_order_id: ClientOrderId,
1057 trader_id: TraderId,
1058 strategy_id: StrategyId,
1059 instrument_id: InstrumentId,
1060 causation_id: Option<UUID4>,
1061 ) -> Result<(), DeribitWsError> {
1062 let request_id = self.next_request_id();
1063 let order_id = params.order_id.clone();
1064 let venue_order_id = VenueOrderId::new_checked(order_id.clone()).ok();
1065 let request =
1066 DeribitJsonRpcRequest::new(request_id, DeribitWsMethod::Edit.as_method_str(), params);
1067 let payload =
1068 serde_json::to_string(&request).map_err(|e| DeribitWsError::Encode(e.to_string()))?;
1069
1070 log::debug!("Sending edit order: request_id={request_id}, order_id={order_id}");
1071 let sent = self.send_order_once(payload).await;
1072 if self.should_track_command(&sent) {
1073 self.pending_requests.insert(
1074 request_id,
1075 PendingRequestType::Edit {
1076 causation_id,
1077 venue_order_id,
1078 client_order_id,
1079 trader_id,
1080 strategy_id,
1081 instrument_id,
1082 },
1083 );
1084 }
1085
1086 sent
1087 }
1088
1089 async fn handle_cancel(
1091 &mut self,
1092 params: DeribitCancelParams,
1093 client_order_id: ClientOrderId,
1094 trader_id: TraderId,
1095 strategy_id: StrategyId,
1096 instrument_id: InstrumentId,
1097 causation_id: Option<UUID4>,
1098 ) -> Result<(), DeribitWsError> {
1099 let request_id = self.next_request_id();
1100 let order_id = params.order_id.clone();
1101 let venue_order_id = VenueOrderId::new_checked(order_id.clone()).ok();
1102 let request =
1103 DeribitJsonRpcRequest::new(request_id, DeribitWsMethod::Cancel.as_method_str(), params);
1104 let payload =
1105 serde_json::to_string(&request).map_err(|e| DeribitWsError::Encode(e.to_string()))?;
1106
1107 log::debug!("Sending cancel order: request_id={request_id}, order_id={order_id}");
1108 let sent = self.send_order_once(payload).await;
1109 if self.should_track_command(&sent) {
1110 self.pending_requests.insert(
1111 request_id,
1112 PendingRequestType::Cancel {
1113 causation_id,
1114 venue_order_id,
1115 client_order_id,
1116 trader_id,
1117 strategy_id,
1118 instrument_id,
1119 },
1120 );
1121 }
1122
1123 sent
1124 }
1125
1126 async fn handle_cancel_all_by_instrument(
1128 &mut self,
1129 params: DeribitCancelAllByInstrumentParams,
1130 instrument_id: InstrumentId,
1131 ) -> Result<(), DeribitWsError> {
1132 let request_id = self.next_request_id();
1133 let instrument_name = params.instrument_name.clone();
1134
1135 let request = DeribitJsonRpcRequest::new(
1136 request_id,
1137 DeribitWsMethod::CancelAllByInstrument.as_method_str(),
1138 params,
1139 );
1140 let payload =
1141 serde_json::to_string(&request).map_err(|e| DeribitWsError::Encode(e.to_string()))?;
1142
1143 log::debug!(
1144 "Sending cancel_all_by_instrument: request_id={request_id}, instrument={instrument_name}"
1145 );
1146 let sent = self.send_order_once(payload).await;
1147 if self.should_track_command(&sent) {
1148 self.pending_requests.insert(
1149 request_id,
1150 PendingRequestType::CancelAllByInstrument { instrument_id },
1151 );
1152 }
1153
1154 sent
1155 }
1156
1157 async fn handle_get_order_state(
1159 &mut self,
1160 order_id: String,
1161 client_order_id: ClientOrderId,
1162 trader_id: TraderId,
1163 strategy_id: StrategyId,
1164 instrument_id: InstrumentId,
1165 ) -> Result<(), DeribitWsError> {
1166 let request_id = self.next_request_id();
1167
1168 self.pending_requests.insert(
1170 request_id,
1171 PendingRequestType::GetOrderState {
1172 client_order_id,
1173 trader_id,
1174 strategy_id,
1175 instrument_id,
1176 },
1177 );
1178
1179 let params = serde_json::json!({
1180 "order_id": order_id
1181 });
1182
1183 let request = DeribitJsonRpcRequest::new(
1184 request_id,
1185 DeribitWsMethod::GetOrderState.as_method_str(),
1186 params,
1187 );
1188
1189 let payload =
1190 serde_json::to_string(&request).map_err(|e| DeribitWsError::Json(e.to_string()));
1191
1192 log::debug!("Sending get_order_state: request_id={request_id}, order_id={order_id}");
1193 self.send_tracked_request(
1194 request_id,
1195 payload,
1196 Some(DERIBIT_RATE_LIMIT_KEY_ORDER.as_slice()),
1197 )
1198 .await
1199 }
1200
1201 async fn process_command(&mut self, cmd: HandlerCommand) {
1203 match cmd {
1204 HandlerCommand::SetClient(client) => {
1205 log::debug!("Setting WebSocket client");
1206 self.inner = Some(Arc::new(client));
1207 }
1208 HandlerCommand::Disconnect => {
1209 log::debug!("Disconnecting WebSocket");
1210
1211 if let Some(client) = self.inner.take() {
1212 client.disconnect().await;
1213 }
1214 }
1215 HandlerCommand::Authenticate { auth_params } => {
1216 self.handle_authenticate(auth_params).await;
1217 }
1218 HandlerCommand::SetHeartbeat { interval } => {
1219 if let Err(e) = self.handle_set_heartbeat(interval).await {
1220 log::error!("Set heartbeat failed: {e}");
1221 }
1222 }
1223 HandlerCommand::InitializeInstruments(instruments) => {
1224 log::debug!("Handler received {} instruments", instruments.len());
1225 self.instruments_cache.clear();
1226 for inst in instruments {
1227 self.instruments_cache
1228 .insert(inst.raw_symbol().inner(), inst);
1229 }
1230 }
1231 HandlerCommand::UpdateInstrument(instrument) => {
1232 log::trace!("Updating instrument: {}", instrument.raw_symbol());
1233 self.instruments_cache
1234 .insert(instrument.raw_symbol().inner(), *instrument);
1235 }
1236 HandlerCommand::Subscribe { channels } => {
1237 if let Err(e) = self.handle_subscribe(&channels) {
1238 log::error!("Subscribe failed: {e}");
1239 }
1240 }
1241 HandlerCommand::Unsubscribe { channels } => {
1242 self.drop_released_book_tracking(&channels);
1243
1244 if let Err(e) = self.handle_unsubscribe(channels) {
1245 log::error!("Unsubscribe failed: {e}");
1246 }
1247 }
1248 HandlerCommand::RecoverBook {
1249 instrument,
1250 channel,
1251 cancel,
1252 gate,
1253 completion,
1254 recovery,
1255 } => {
1256 self.replace_book_subscription(
1257 instrument, channel, &cancel, gate, completion, &recovery,
1258 );
1259 }
1260 HandlerCommand::Buy {
1261 params,
1262 client_order_id,
1263 trader_id,
1264 strategy_id,
1265 instrument_id,
1266 } => {
1267 if let Err(e) = self
1268 .handle_submit(
1269 OrderSide::Buy,
1270 params,
1271 client_order_id,
1272 trader_id,
1273 strategy_id,
1274 instrument_id,
1275 )
1276 .await
1277 && let Some(reason) = self.terminal_command_reason(&e)
1278 {
1279 let _ =
1280 self.out_tx
1281 .send(NautilusWsMessage::OrderRejected(self.order_rejected(
1282 trader_id,
1283 strategy_id,
1284 instrument_id,
1285 client_order_id,
1286 &reason,
1287 false,
1288 )));
1289 }
1290 }
1291 HandlerCommand::Sell {
1292 params,
1293 client_order_id,
1294 trader_id,
1295 strategy_id,
1296 instrument_id,
1297 } => {
1298 if let Err(e) = self
1299 .handle_submit(
1300 OrderSide::Sell,
1301 params,
1302 client_order_id,
1303 trader_id,
1304 strategy_id,
1305 instrument_id,
1306 )
1307 .await
1308 && let Some(reason) = self.terminal_command_reason(&e)
1309 {
1310 let _ =
1311 self.out_tx
1312 .send(NautilusWsMessage::OrderRejected(self.order_rejected(
1313 trader_id,
1314 strategy_id,
1315 instrument_id,
1316 client_order_id,
1317 &reason,
1318 false,
1319 )));
1320 }
1321 }
1322 HandlerCommand::Edit {
1323 causation_id,
1324 params,
1325 client_order_id,
1326 trader_id,
1327 strategy_id,
1328 instrument_id,
1329 } => {
1330 let venue_order_id = VenueOrderId::new_checked(params.order_id.clone()).ok();
1331
1332 if let Err(e) = self
1333 .handle_edit(
1334 params,
1335 client_order_id,
1336 trader_id,
1337 strategy_id,
1338 instrument_id,
1339 causation_id,
1340 )
1341 .await
1342 && let Some(reason) = self.terminal_command_reason(&e)
1343 {
1344 self.pending_outgoing
1345 .push_back(NautilusWsMessage::OrderModifyDenied(
1346 self.order_modify_denied(
1347 trader_id,
1348 strategy_id,
1349 instrument_id,
1350 client_order_id,
1351 venue_order_id,
1352 causation_id,
1353 &reason,
1354 ),
1355 ));
1356 }
1357 }
1358 HandlerCommand::Cancel {
1359 causation_id,
1360 params,
1361 client_order_id,
1362 trader_id,
1363 strategy_id,
1364 instrument_id,
1365 } => {
1366 let venue_order_id = VenueOrderId::new_checked(params.order_id.clone()).ok();
1367
1368 if let Err(e) = self
1369 .handle_cancel(
1370 params,
1371 client_order_id,
1372 trader_id,
1373 strategy_id,
1374 instrument_id,
1375 causation_id,
1376 )
1377 .await
1378 && let Some(reason) = self.terminal_command_reason(&e)
1379 {
1380 self.pending_outgoing
1381 .push_back(NautilusWsMessage::OrderCancelDenied(
1382 self.order_cancel_denied(
1383 trader_id,
1384 strategy_id,
1385 instrument_id,
1386 client_order_id,
1387 venue_order_id,
1388 causation_id,
1389 &reason,
1390 ),
1391 ));
1392 }
1393 }
1394 HandlerCommand::CancelAllByInstrument {
1395 params,
1396 instrument_id,
1397 } => {
1398 if let Err(e) = self
1399 .handle_cancel_all_by_instrument(params, instrument_id)
1400 .await
1401 {
1402 log::warn!(
1403 "Cancel all by instrument failed for {instrument_id}, awaiting reconciliation: {e}"
1404 );
1405 }
1406 }
1407 HandlerCommand::GetOrderState {
1408 order_id,
1409 client_order_id,
1410 trader_id,
1411 strategy_id,
1412 instrument_id,
1413 } => {
1414 if let Err(e) = self
1415 .handle_get_order_state(
1416 order_id,
1417 client_order_id,
1418 trader_id,
1419 strategy_id,
1420 instrument_id,
1421 )
1422 .await
1423 {
1424 log::error!("Get order state failed: {e}");
1425 }
1426 }
1427 }
1428 }
1429
1430 async fn process_raw_message(&mut self, text: &str) -> Option<NautilusWsMessage> {
1432 if text == RECONNECTED {
1433 log::info!("Received reconnection signal");
1434
1435 self.auth_tracker.invalidate();
1436 self.clear_state();
1437
1438 return Some(NautilusWsMessage::Reconnected);
1439 }
1440
1441 let ws_msg = match parse_raw_message(text) {
1443 Ok(msg) => msg,
1444 Err(e) => {
1445 log::warn!("Failed to parse message: {e}");
1446 return None;
1447 }
1448 };
1449
1450 let ts_init = self.ts_init();
1451
1452 match ws_msg {
1453 DeribitWsMessage::Response(response) => {
1454 if let Some(request_id) = response.id
1456 && let Some(request_type) = self.pending_requests.remove(&request_id)
1457 {
1458 for ids in self.book_recovery_requests.values_mut() {
1459 ids.remove(&request_id);
1460 }
1461
1462 match request_type {
1463 PendingRequestType::Authenticate => {
1464 if let Some(error) = &response.error {
1465 let reason = format!(
1466 "Authentication error code={}: {}",
1467 error.code, error.message
1468 );
1469 log::error!(
1470 "Authentication failed: code={}, message={}, request_id={}",
1471 error.code,
1472 error.message,
1473 request_id
1474 );
1475 self.auth_tracker.fail(reason.clone());
1476 return Some(NautilusWsMessage::AuthenticationFailed(reason));
1477 } else if let Some(result) = &response.result {
1478 match serde_json::from_str::<DeribitAuthResult>(result.get()) {
1479 Ok(auth_result) => {
1480 self.auth_tracker.succeed();
1481 log::debug!(
1482 "WebSocket authenticated successfully (request_id={}, scope={}, expires_in={}s)",
1483 request_id,
1484 auth_result.scope,
1485 auth_result.expires_in
1486 );
1487 return Some(NautilusWsMessage::Authenticated(Box::new(
1488 auth_result,
1489 )));
1490 }
1491 Err(e) => {
1492 let reason = format!("Failed to parse auth result: {e}");
1493 log::error!("{reason}: request_id={request_id}");
1494 self.auth_tracker.fail(reason.clone());
1495 return Some(NautilusWsMessage::AuthenticationFailed(
1496 reason,
1497 ));
1498 }
1499 }
1500 }
1501 }
1502 PendingRequestType::Subscribe { channels } => {
1503 if let Some(error) = &response.error {
1504 log::error!(
1505 "Subscribe failed: code={}, message={}, channels={:?}, request_id={}",
1506 error.code,
1507 error.message,
1508 channels,
1509 request_id
1510 );
1511
1512 self.subscribe_errors.lock().push(format!(
1513 "Subscribe rejected: code={}, message={}",
1514 error.code, error.message,
1515 ));
1516
1517 self.abort_book_replacements(&channels, error.code, &error.message);
1518 self.recover_rejected_book_subscriptions(&channels);
1519 } else {
1520 let acknowledged = self.subscription_acknowledgements(
1521 request_id,
1522 &channels,
1523 response.result.as_deref(),
1524 true,
1525 );
1526
1527 for ch in acknowledged {
1528 self.subscriptions_state.confirm_subscribe(&ch);
1529 log::debug!("Subscription confirmed: {ch}");
1530 self.confirm_book_subscription(&ch);
1531 }
1532 }
1533 }
1534 PendingRequestType::Unsubscribe { channels } => {
1535 self.handle_unsubscribe_acknowledgement(
1536 request_id, &channels, &response,
1537 );
1538 }
1539 PendingRequestType::SetHeartbeat => {
1540 if let Some(error) = &response.error {
1541 log::error!(
1542 "Set heartbeat failed: code={}, message={}, request_id={}",
1543 error.code,
1544 error.message,
1545 request_id
1546 );
1547 } else {
1548 log::debug!("Heartbeat enabled (request_id={request_id})");
1549 }
1550 }
1551 PendingRequestType::Test => {
1552 if let Some(error) = &response.error {
1553 log::warn!(
1554 "Heartbeat test failed: code={}, message={}, request_id={}",
1555 error.code,
1556 error.message,
1557 request_id
1558 );
1559 } else {
1560 log::trace!(
1561 "Heartbeat test acknowledged (request_id={request_id})"
1562 );
1563 }
1564 }
1565 PendingRequestType::Cancel {
1566 venue_order_id,
1567 causation_id,
1568 client_order_id,
1569 trader_id,
1570 strategy_id,
1571 instrument_id,
1572 } => {
1573 if let Some(result) = &response.result {
1574 match serde_json::from_str::<DeribitOrderMsg>(result.get()) {
1575 Ok(order_msg) => {
1576 let venue_order_id =
1577 VenueOrderId::new(order_msg.order_id.as_str());
1578 log::debug!(
1579 "Cancel confirmed: venue_order_id={venue_order_id}, \
1580 client_order_id={client_order_id}, state={}",
1581 order_msg.order_state
1582 );
1583
1584 if order_msg.order_state == "cancelled"
1589 && !self
1590 .terminal_order_contexts
1591 .contains_key(&venue_order_id)
1592 {
1593 let instrument_name_ustr = order_msg.instrument_name;
1594
1595 if let Some(instrument) =
1596 self.instruments_cache.get(&instrument_name_ustr)
1597 && let Some(account_id) = self.account_id
1598 {
1599 let event =
1600 parse_order_canceled_with_client_order_id(
1601 &order_msg,
1602 instrument,
1603 account_id,
1604 trader_id,
1605 strategy_id,
1606 client_order_id,
1607 ts_init,
1608 );
1609 let context = self
1610 .find_order_context(
1611 venue_order_id,
1612 Some(client_order_id),
1613 )
1614 .or_else(|| {
1615 let order_side =
1616 match order_msg.direction.as_str() {
1617 "buy" => OrderSide::Buy,
1618 "sell" => OrderSide::Sell,
1619 _ => return None,
1620 };
1621 Some(OrderContext {
1622 client_order_id,
1623 trader_id,
1624 strategy_id,
1625 instrument_id,
1626 order_side,
1627 order_type: parse_deribit_order_type(
1628 &order_msg.order_type,
1629 ),
1630 accepted: true,
1631 last_order_signature: Some(
1632 Self::order_signature(&order_msg),
1633 ),
1634 })
1635 });
1636
1637 if let Some(context) = context {
1638 self.finish_order_context(
1639 venue_order_id,
1640 &context,
1641 true,
1642 );
1643 }
1644 return Some(NautilusWsMessage::OrderCanceled(
1645 event,
1646 ));
1647 }
1648 }
1649 }
1650 Err(e) => {
1651 log::error!(
1652 "Failed to parse cancel response: request_id={request_id}, error={e}"
1653 );
1654 }
1655 }
1656 } else if let Some(error) = &response.error {
1657 let (reason, _) = Self::venue_command_reason(
1658 error.code,
1659 &error.message,
1660 error.data.as_ref(),
1661 )?;
1662 let mut event = self.order_cancel_rejected(
1663 trader_id,
1664 strategy_id,
1665 instrument_id,
1666 client_order_id,
1667 venue_order_id,
1668 &reason,
1669 );
1670 event.causation_id = causation_id;
1671 return Some(NautilusWsMessage::OrderCancelRejected(event));
1672 }
1673 }
1674 PendingRequestType::CancelAllByInstrument { instrument_id } => {
1675 if let Some(result) = &response.result {
1676 match serde_json::from_str::<u64>(result.get()) {
1677 Ok(count) => {
1678 log::debug!(
1679 "Cancelled {count} orders for instrument {instrument_id}"
1680 );
1681 }
1683 Err(e) => {
1684 log::warn!("Failed to parse cancel_all response: {e}");
1685 }
1686 }
1687 } else if let Some(error) = &response.error {
1688 log::warn!(
1689 "Cancel all by instrument left in flight for {instrument_id}: code={}, message={}, data={:?}, class={:?}",
1690 error.code,
1691 error.message,
1692 error.data,
1693 classify_deribit_venue_error(error.code, &error.message).0
1694 );
1695 }
1696 }
1697 PendingRequestType::Buy {
1698 client_order_id,
1699 trader_id,
1700 strategy_id,
1701 instrument_id,
1702 order_side,
1703 order_type,
1704 }
1705 | PendingRequestType::Sell {
1706 client_order_id,
1707 trader_id,
1708 strategy_id,
1709 instrument_id,
1710 order_side,
1711 order_type,
1712 } => {
1713 let submit_context = OrderContext {
1714 client_order_id,
1715 trader_id,
1716 strategy_id,
1717 instrument_id,
1718 order_side,
1719 order_type,
1720 accepted: false,
1721 last_order_signature: None,
1722 };
1723
1724 return self.handle_order_submit_response(
1725 &submit_context,
1726 request_id,
1727 &response,
1728 ts_init,
1729 );
1730 }
1731 PendingRequestType::Edit {
1732 venue_order_id,
1733 causation_id,
1734 client_order_id,
1735 trader_id,
1736 strategy_id,
1737 instrument_id,
1738 } => {
1739 if let Some(result) = &response.result {
1740 match serde_json::from_str::<DeribitOrderResponse>(result.get()) {
1741 Ok(order_response) => {
1742 let venue_order_id =
1743 VenueOrderId::new(&order_response.order.order_id);
1744 log::debug!(
1745 "Order updated: venue_order_id={}, client_order_id={}, state={}",
1746 venue_order_id,
1747 client_order_id,
1748 order_response.order.order_state
1749 );
1750
1751 let instrument_name_ustr = Ustr::from(
1752 order_response.order.instrument_name.as_str(),
1753 );
1754
1755 if let Some(instrument) =
1756 self.instruments_cache.get(&instrument_name_ustr)
1757 {
1758 if let Some(account_id) = self.account_id {
1759 let Some(mut context) = self.find_order_context(
1760 venue_order_id,
1761 Some(client_order_id),
1762 ) else {
1763 let report = parse_user_order_msg(
1764 &order_response.order,
1765 instrument,
1766 account_id,
1767 ts_init,
1768 );
1769 let outgoing = self.route_user_trades(
1770 &order_response.trades,
1771 ts_init,
1772 );
1773 self.pending_outgoing.extend(outgoing);
1774 return report
1775 .map(|report| {
1776 NautilusWsMessage::OrderStatusReports(vec![
1777 report,
1778 ])
1779 })
1780 .map_err(|e| {
1781 log::warn!(
1782 "Failed to parse external edit response: {e}"
1783 );
1784 })
1785 .ok();
1786 };
1787 let was_terminal = self
1788 .terminal_order_contexts
1789 .contains_key(&venue_order_id);
1790 let signature =
1791 Self::order_signature(&order_response.order);
1792 let duplicate_update = was_terminal
1793 || context.last_order_signature
1794 == Some(signature);
1795 let event = (!duplicate_update).then(|| {
1796 parse_order_updated_with_client_order_id(
1797 &order_response.order,
1798 instrument,
1799 account_id,
1800 context.trader_id,
1801 context.strategy_id,
1802 context.client_order_id,
1803 ts_init,
1804 )
1805 });
1806 context.accepted = true;
1807 context.last_order_signature = Some(signature);
1808
1809 if was_terminal {
1810 self.finish_order_context(
1811 venue_order_id,
1812 &context,
1813 false,
1814 );
1815 } else {
1816 self.bind_order_context(
1817 venue_order_id,
1818 context,
1819 );
1820 }
1821 let outgoing = self.route_user_trades(
1822 &order_response.trades,
1823 ts_init,
1824 );
1825 self.pending_outgoing.extend(outgoing);
1826 return event.map(|mut event| {
1827 event.causation_id = causation_id;
1828 NautilusWsMessage::OrderUpdated(event)
1829 });
1830 } else {
1831 log::warn!(
1832 "Cannot create OrderUpdated: account_id not set"
1833 );
1834 }
1835 } else {
1836 log::warn!(
1837 "Instrument {instrument_name_ustr} not found in cache for edit response"
1838 );
1839 }
1840 }
1841 Err(e) => {
1842 log::error!(
1843 "Failed to parse edit response: request_id={request_id}, error={e}"
1844 );
1845 }
1846 }
1847 } else if let Some(error) = &response.error {
1848 let (reason, _) = Self::venue_command_reason(
1849 error.code,
1850 &error.message,
1851 error.data.as_ref(),
1852 )?;
1853 let mut event = self.order_modify_rejected(
1854 trader_id,
1855 strategy_id,
1856 instrument_id,
1857 client_order_id,
1858 venue_order_id,
1859 &reason,
1860 );
1861 event.causation_id = causation_id;
1862 return Some(NautilusWsMessage::OrderModifyRejected(event));
1863 }
1864 }
1865 PendingRequestType::GetOrderState {
1866 client_order_id,
1867 trader_id: _,
1868 strategy_id: _,
1869 instrument_id: _,
1870 } => {
1871 if let Some(result) = &response.result {
1872 match serde_json::from_str::<DeribitOrderMsg>(result.get()) {
1873 Ok(order_msg) => {
1874 log::debug!(
1875 "Order state received: venue_order_id={}, client_order_id={}, state={}",
1876 order_msg.order_id,
1877 client_order_id,
1878 order_msg.order_state
1879 );
1880
1881 let instrument_name_ustr = order_msg.instrument_name;
1883
1884 if let Some(instrument) =
1885 self.instruments_cache.get(&instrument_name_ustr)
1886 {
1887 if let Some(account_id) = self.account_id {
1888 match parse_user_order_msg(
1889 &order_msg, instrument, account_id, ts_init,
1890 ) {
1891 Ok(report) => {
1892 return Some(
1893 NautilusWsMessage::OrderStatusReports(
1894 vec![report],
1895 ),
1896 );
1897 }
1898 Err(e) => {
1899 log::warn!(
1900 "Failed to parse get_order_state response to report: {e}"
1901 );
1902 }
1903 }
1904 } else {
1905 log::warn!(
1906 "Cannot create OrderStatusReport: account_id not set"
1907 );
1908 }
1909 } else {
1910 log::warn!(
1911 "Instrument {instrument_name_ustr} not found in cache for get_order_state response"
1912 );
1913 }
1914 }
1915 Err(e) => {
1916 log::error!(
1917 "Failed to parse get_order_state response: request_id={request_id}, error={e}"
1918 );
1919 }
1920 }
1921 } else if let Some(error) = &response.error {
1922 log::error!(
1923 "Get order state failed: code={}, message={}, client_order_id={}",
1924 error.code,
1925 error.message,
1926 client_order_id
1927 );
1928 }
1929 }
1930 }
1931 } else if let Some(request_id) = response.id {
1932 if let Some(error) = &response.error {
1934 log::error!(
1936 "Deribit error for unknown request: code={}, message={}, request_id={}, data={:?}",
1937 error.code,
1938 error.message,
1939 request_id,
1940 error.data
1941 );
1942 return Some(NautilusWsMessage::Error(DeribitWsError::DeribitError {
1943 code: error.code,
1944 message: error.message.clone(),
1945 }));
1946 } else {
1947 log::debug!(
1949 "Received response for unknown request_id={}, result present: {}",
1950 request_id,
1951 response.result.is_some()
1952 );
1953 }
1954 } else if let Some(error) = &response.error {
1955 log::error!(
1957 "Deribit error with no request_id: code={}, message={}, data={:?}",
1958 error.code,
1959 error.message,
1960 error.data
1961 );
1962 return Some(NautilusWsMessage::Error(DeribitWsError::DeribitError {
1963 code: error.code,
1964 message: error.message.clone(),
1965 }));
1966 }
1967 None
1968 }
1969 DeribitWsMessage::Notification(notification) => {
1970 let channel = ¬ification.params.channel;
1971 let data = ¬ification.params.data;
1972
1973 if let Some(channel_type) = DeribitWsChannel::from_channel_string(channel) {
1975 match channel_type {
1976 DeribitWsChannel::Trades => {
1977 match serde_json::from_str::<Vec<DeribitTradeMsg>>(data.get()) {
1979 Ok(trades) => {
1980 log::debug!("Received {} trades", trades.len());
1981 let data_vec = parse_trades_data(
1982 &trades,
1983 &self.instruments_cache,
1984 ts_init,
1985 );
1986
1987 if data_vec.is_empty() && !trades.is_empty() {
1988 let missing: Vec<&Ustr> = trades
1989 .iter()
1990 .map(|t| &t.instrument_name)
1991 .filter(|name| {
1992 !self.instruments_cache.contains_key(name)
1993 })
1994 .collect();
1995
1996 if missing.is_empty() {
1997 log::warn!(
1998 "Received {} trades but parsed 0 (parse failures); cache size: {}",
1999 trades.len(),
2000 self.instruments_cache.len()
2001 );
2002 } else {
2003 log::warn!(
2004 "Trade message received but instrument(s) not found in cache: {:?} (cache size: {})",
2005 missing,
2006 self.instruments_cache.len()
2007 );
2008 }
2009 } else if !data_vec.is_empty() {
2010 log::debug!("Parsed {} trade ticks", data_vec.len());
2011 return Some(NautilusWsMessage::Data(data_vec));
2012 }
2013 }
2014 Err(e) => {
2015 log::warn!("Failed to deserialize trades: {e}");
2016 }
2017 }
2018 }
2019 DeribitWsChannel::Book => {
2020 return self.handle_book_message(channel, data.get(), ts_init).await;
2021 }
2022 DeribitWsChannel::Ticker => {
2023 match serde_json::from_str::<DeribitTickerMsg>(data.get()) {
2024 Ok(ticker_msg) => {
2025 if let Some(instrument) =
2026 self.instruments_cache.get(&ticker_msg.instrument_name)
2027 {
2028 if self.option_greeks_subs.contains(&instrument.id())
2030 && let Some(option_greeks) =
2031 parse_ticker_to_option_greeks(
2032 &ticker_msg,
2033 instrument,
2034 ts_init,
2035 )
2036 {
2037 let _ = self.out_tx.send(
2038 NautilusWsMessage::OptionGreeks(option_greeks),
2039 );
2040 }
2041
2042 let instrument_id = instrument.id();
2043 let mut data_vec = Vec::new();
2044
2045 if self.mark_price_subs.contains(&instrument_id) {
2047 match parse_ticker_to_mark_price(
2048 &ticker_msg,
2049 instrument,
2050 ts_init,
2051 ) {
2052 Ok(mark_price) => {
2053 data_vec.push(Data::MarkPrice(mark_price));
2054 }
2055 Err(e) => {
2056 log::warn!("Failed to parse mark price: {e}");
2057 }
2058 }
2059 }
2060
2061 if self.index_price_subs.contains(&instrument_id) {
2063 match parse_ticker_to_index_price(
2064 &ticker_msg,
2065 instrument,
2066 ts_init,
2067 ) {
2068 Ok(index_price) => {
2069 data_vec.push(Data::IndexPrice(index_price));
2070 }
2071 Err(e) => {
2072 log::warn!("Failed to parse index price: {e}");
2073 }
2074 }
2075 }
2076
2077 if !data_vec.is_empty() {
2078 return Some(NautilusWsMessage::Data(data_vec));
2079 }
2080 } else {
2081 log::warn!(
2082 "Ticker message received but instrument '{}' not found in cache (cache size: {})",
2083 ticker_msg.instrument_name,
2084 self.instruments_cache.len()
2085 );
2086 }
2087 }
2088 Err(e) => {
2089 log::warn!(
2090 "Failed to deserialize ticker message: {e}, channel: {channel}"
2091 );
2092 }
2093 }
2094 }
2095 DeribitWsChannel::Perpetual => {
2096 match serde_json::from_str::<DeribitPerpetualMsg>(data.get()) {
2100 Ok(perpetual_msg) => {
2101 let parts: Vec<&str> = channel.split('.').collect();
2103 if parts.len() >= 2 {
2104 let instrument_name = Ustr::from(parts[1]);
2105
2106 if let Some(instrument) =
2107 self.instruments_cache.get(&instrument_name)
2108 {
2109 let funding_rate = parse_perpetual_to_funding_rate(
2110 &perpetual_msg,
2111 instrument,
2112 ts_init,
2113 );
2114 return Some(NautilusWsMessage::FundingRates(vec![
2115 funding_rate,
2116 ]));
2117 } else {
2118 log::warn!(
2119 "Instrument {} not found in cache (cache size: {})",
2120 instrument_name,
2121 self.instruments_cache.len()
2122 );
2123 }
2124 }
2125 }
2126 Err(e) => {
2127 log::warn!(
2128 "Failed to deserialize perpetual message: {e}, data: {data}"
2129 );
2130 }
2131 }
2132 }
2133 DeribitWsChannel::Quote => {
2134 match serde_json::from_str::<DeribitQuoteMsg>(data.get()) {
2136 Ok(quote_msg) => {
2137 if let Some(instrument) =
2138 self.instruments_cache.get("e_msg.instrument_name)
2139 {
2140 match parse_quote_msg("e_msg, instrument, ts_init) {
2141 Ok(quote) => {
2142 return Some(NautilusWsMessage::Data(vec![
2143 Data::Quote(quote),
2144 ]));
2145 }
2146 Err(e) => {
2147 log::warn!("Failed to parse quote message: {e}");
2148 }
2149 }
2150 } else {
2151 log::warn!(
2152 "Quote message received but instrument '{}' not found in cache (cache size: {})",
2153 quote_msg.instrument_name,
2154 self.instruments_cache.len()
2155 );
2156 }
2157 }
2158 Err(e) => {
2159 log::warn!(
2160 "Failed to deserialize quote message: {e}, channel: {channel}"
2161 );
2162 }
2163 }
2164 }
2165 DeribitWsChannel::VolatilityIndex => {
2166 match serde_json::from_str::<DeribitVolatilityIndexMsg>(data.get()) {
2167 Ok(msg) => {
2168 let ts_event = UnixNanos::from(msg.timestamp * 1_000_000);
2169
2170 let metadata = nautilus_core::Params::new(
2171 [(
2172 "index_name".to_string(),
2173 serde_json::Value::String(msg.index_name.clone()),
2174 )]
2175 .into(),
2176 );
2177 let data_type = DataType::new(
2178 "DeribitVolatilityIndex",
2179 Some(metadata),
2180 None,
2181 );
2182
2183 let dvol = DeribitVolatilityIndex::new(
2184 msg.index_name,
2185 msg.volatility,
2186 ts_event,
2187 ts_init,
2188 );
2189
2190 return Some(NautilusWsMessage::Data(vec![Data::Custom(
2191 CustomData::new(Arc::new(dvol), data_type),
2192 )]));
2193 }
2194 Err(e) => {
2195 log::warn!("Failed to deserialize volatility index: {e}");
2196 }
2197 }
2198 }
2199 DeribitWsChannel::InstrumentState => {
2200 match serde_json::from_str::<DeribitInstrumentStateMsg>(data.get()) {
2201 Ok(state_msg) => {
2202 log::debug!(
2203 "Instrument state change: {} -> {} (timestamp: {})",
2204 state_msg.instrument_name,
2205 state_msg.state,
2206 state_msg.timestamp
2207 );
2208
2209 let instrument_id = if let Some(instrument) =
2210 self.instruments_cache.get(&state_msg.instrument_name)
2211 {
2212 instrument.id()
2213 } else {
2214 log::debug!(
2215 "Instrument '{}' not in cache, constructing ID",
2216 state_msg.instrument_name
2217 );
2218 InstrumentId::new(
2219 Symbol::new(state_msg.instrument_name),
2220 *DERIBIT_VENUE,
2221 )
2222 };
2223
2224 let action = MarketStatusAction::from(state_msg.state);
2225 let is_trading =
2226 Some(state_msg.state == DeribitInstrumentState::Started);
2227 let ts_event = UnixNanos::from(state_msg.timestamp * 1_000_000);
2228 let status = InstrumentStatus::new(
2229 instrument_id,
2230 action,
2231 ts_event,
2232 ts_init,
2233 None,
2234 None,
2235 is_trading,
2236 None,
2237 None,
2238 );
2239 return Some(NautilusWsMessage::InstrumentStatus(status));
2240 }
2241 Err(e) => {
2242 log::warn!("Failed to parse instrument status message: {e}");
2243 }
2244 }
2245 }
2246 DeribitWsChannel::ChartTrades => {
2247 if let Ok(chart_msg) =
2252 serde_json::from_str::<DeribitChartMsg>(data.get())
2253 {
2254 let parts: Vec<&str> = channel.split('.').collect();
2257 if parts.len() >= 4 {
2258 let instrument_name = Ustr::from(parts[2]);
2259 let resolution = parts[3];
2260
2261 if let Some(instrument) =
2262 self.instruments_cache.get(&instrument_name)
2263 {
2264 let instrument_id = instrument.id();
2265
2266 match resolution_to_bar_type(instrument_id, resolution) {
2267 Ok(bar_type) => {
2268 let price_precision = instrument.price_precision();
2269 let size_precision = instrument.size_precision();
2270 let use_cost_for_volume =
2271 use_cost_for_bar_volume(instrument);
2272
2273 match parse_chart_msg(
2274 &chart_msg,
2275 bar_type,
2276 price_precision,
2277 size_precision,
2278 use_cost_for_volume,
2279 self.bars_timestamp_on_close,
2280 ts_init,
2281 ) {
2282 Ok(new_bar) => {
2283 let channel_key = channel.clone();
2285
2286 if let Some(pending_bar) =
2287 self.pending_bars.get(&channel_key)
2288 {
2289 if new_bar.ts_event
2291 != pending_bar.ts_event
2292 {
2293 let closed_bar = *pending_bar;
2294 self.pending_bars
2295 .insert(channel_key, new_bar);
2296 log::debug!(
2297 "Emitting closed bar: {closed_bar:?}"
2298 );
2299 return Some(
2300 NautilusWsMessage::Data(vec![
2301 Data::Bar(closed_bar),
2302 ]),
2303 );
2304 }
2305 self.pending_bars
2307 .insert(channel_key, new_bar);
2308 } else {
2309 self.pending_bars
2311 .insert(channel_key, new_bar);
2312 }
2313 }
2314 Err(e) => {
2315 log::warn!(
2316 "Failed to parse chart message to bar: {e}"
2317 );
2318 }
2319 }
2320 }
2321 Err(e) => {
2322 log::warn!(
2323 "Failed to create BarType from resolution {resolution}: {e}"
2324 );
2325 }
2326 }
2327 } else {
2328 log::warn!(
2329 "Instrument {instrument_name} not found in cache for chart data"
2330 );
2331 }
2332 }
2333 }
2334 }
2335 DeribitWsChannel::UserOrders => {
2336 let orders_result = serde_json::from_str::<Vec<DeribitOrderMsg>>(
2338 data.get(),
2339 )
2340 .or_else(|_| {
2341 serde_json::from_str::<DeribitOrderMsg>(data.get())
2342 .map(|order| vec![order])
2343 });
2344
2345 match orders_result {
2346 Ok(orders) => {
2347 log::debug!("Received {} user order updates", orders.len());
2348
2349 let Some(account_id) = self.account_id else {
2351 log::warn!("Cannot parse user orders: account_id not set");
2352 return Some(NautilusWsMessage::Raw(data.clone()));
2353 };
2354
2355 let mut outgoing = Vec::new();
2356
2357 for order in &orders {
2359 let venue_order_id_str = &order.order_id;
2360 let venue_order_id =
2361 VenueOrderId::new(venue_order_id_str.as_str());
2362 let instrument_name = order.instrument_name;
2363
2364 let Some(instrument) =
2365 self.instruments_cache.get(&instrument_name)
2366 else {
2367 log::warn!(
2368 "Instrument {instrument_name} not found in cache"
2369 );
2370 continue;
2371 };
2372
2373 let label_client_order_id = order
2374 .label
2375 .as_ref()
2376 .filter(|l| !l.is_empty())
2377 .map(ClientOrderId::new);
2378 let was_terminal = self
2379 .terminal_order_contexts
2380 .contains_key(&venue_order_id);
2381 let Some(mut context) = self.find_order_context(
2382 venue_order_id,
2383 label_client_order_id,
2384 ) else {
2385 match parse_user_order_msg(
2386 order, instrument, account_id, ts_init,
2387 ) {
2388 Ok(report) => outgoing.push(
2389 NautilusWsMessage::OrderStatusReports(vec![
2390 report,
2391 ]),
2392 ),
2393 Err(e) => log::warn!(
2394 "Failed to parse external order update: {e}"
2395 ),
2396 }
2397 continue;
2398 };
2399
2400 let signature = Self::order_signature(order);
2401
2402 let event_type = determine_order_event_type(
2404 &order.order_state,
2405 !context.accepted,
2406 order.replaced
2407 && context.last_order_signature != Some(signature),
2408 );
2409 context.last_order_signature = Some(signature);
2410
2411 let trader_id = context.trader_id;
2412 let strategy_id = context.strategy_id;
2413 let client_order_id = context.client_order_id;
2414
2415 let push_accepted = |
2416 context: &mut OrderContext,
2417 outgoing: &mut Vec<NautilusWsMessage>,
2418 | {
2419 if context.accepted {
2420 return;
2421 }
2422
2423 outgoing.push(NautilusWsMessage::OrderAccepted(
2424 parse_order_accepted_with_client_order_id(
2425 order,
2426 instrument,
2427 account_id,
2428 trader_id,
2429 strategy_id,
2430 client_order_id,
2431 ts_init,
2432 ),
2433 ));
2434 context.accepted = true;
2435 };
2436
2437 match event_type {
2438 OrderEventType::Accepted => {
2439 if self
2441 .terminal_order_contexts
2442 .contains_key(&venue_order_id)
2443 {
2444 log::debug!(
2445 "Skipping OrderAccepted for terminal order: client_order_id={client_order_id}"
2446 );
2447 continue;
2448 }
2449
2450 let event =
2451 parse_order_accepted_with_client_order_id(
2452 order,
2453 instrument,
2454 account_id,
2455 trader_id,
2456 strategy_id,
2457 client_order_id,
2458 ts_init,
2459 );
2460 context.accepted = true;
2461 self.bind_order_context(venue_order_id, context);
2462
2463 log::debug!(
2464 "Emitting OrderAccepted: venue_order_id={venue_order_id}"
2465 );
2466 outgoing
2467 .push(NautilusWsMessage::OrderAccepted(event));
2468 }
2469 OrderEventType::Canceled => {
2470 if self
2473 .terminal_order_contexts
2474 .contains_key(&venue_order_id)
2475 {
2476 log::trace!(
2477 "Skipping duplicate OrderCanceled: client_order_id={client_order_id}"
2478 );
2479 continue;
2480 }
2481
2482 push_accepted(&mut context, &mut outgoing);
2483
2484 let event =
2485 parse_order_canceled_with_client_order_id(
2486 order,
2487 instrument,
2488 account_id,
2489 trader_id,
2490 strategy_id,
2491 client_order_id,
2492 ts_init,
2493 );
2494 log::debug!(
2495 "Emitting OrderCanceled: venue_order_id={venue_order_id}"
2496 );
2497 self.finish_order_context(
2498 venue_order_id,
2499 &context,
2500 true,
2501 );
2502 outgoing
2503 .push(NautilusWsMessage::OrderCanceled(event));
2504 }
2505 OrderEventType::Expired => {
2506 if self
2507 .terminal_order_contexts
2508 .contains_key(&venue_order_id)
2509 {
2510 log::trace!(
2511 "Skipping duplicate OrderExpired: client_order_id={client_order_id}"
2512 );
2513 continue;
2514 }
2515
2516 push_accepted(&mut context, &mut outgoing);
2517
2518 let event =
2519 parse_order_expired_with_client_order_id(
2520 order,
2521 instrument,
2522 account_id,
2523 trader_id,
2524 strategy_id,
2525 client_order_id,
2526 ts_init,
2527 );
2528 log::debug!(
2529 "Emitting OrderExpired: venue_order_id={venue_order_id}"
2530 );
2531 self.finish_order_context(
2532 venue_order_id,
2533 &context,
2534 true,
2535 );
2536 outgoing
2537 .push(NautilusWsMessage::OrderExpired(event));
2538 }
2539 OrderEventType::Updated => {
2540 if was_terminal {
2541 log::trace!(
2542 "Skipping amendment for terminal order: venue_order_id={venue_order_id}"
2543 );
2544 continue;
2545 }
2546
2547 push_accepted(&mut context, &mut outgoing);
2548
2549 let event =
2550 parse_order_updated_with_client_order_id(
2551 order,
2552 instrument,
2553 account_id,
2554 trader_id,
2555 strategy_id,
2556 client_order_id,
2557 ts_init,
2558 );
2559 self.bind_order_context(venue_order_id, context);
2560 log::debug!(
2561 "Emitting OrderUpdated: venue_order_id={venue_order_id}"
2562 );
2563 outgoing
2564 .push(NautilusWsMessage::OrderUpdated(event));
2565 }
2566 OrderEventType::None => {
2567 if order.order_state == "filled" {
2570 log::debug!(
2571 "Recording terminal order: venue_order_id={venue_order_id}, state={}",
2572 order.order_state
2573 );
2574 self.finish_order_context(
2575 venue_order_id,
2576 &context,
2577 false,
2578 );
2579 } else if order.order_state == "rejected" {
2580 log::debug!(
2581 "Recording rejected order: venue_order_id={venue_order_id}"
2582 );
2583 self.finish_order_context(
2584 venue_order_id,
2585 &context,
2586 true,
2587 );
2588 } else if was_terminal {
2589 self.finish_order_context(
2590 venue_order_id,
2591 &context,
2592 false,
2593 );
2594 } else {
2595 log::trace!(
2596 "No event to emit for order {}, state={}",
2597 venue_order_id,
2598 order.order_state
2599 );
2600 self.bind_order_context(
2601 venue_order_id,
2602 context,
2603 );
2604 }
2605 }
2606 }
2607 }
2608
2609 if !outgoing.is_empty() {
2610 self.pending_outgoing.extend(outgoing);
2611 }
2612 }
2613 Err(e) => {
2614 log::warn!("Failed to deserialize user orders: {e}");
2615 }
2616 }
2617 }
2618 DeribitWsChannel::UserTrades => {
2619 let trades_result =
2621 serde_json::from_str::<Vec<DeribitUserTradeMsg>>(data.get())
2622 .or_else(|_| {
2623 serde_json::from_str::<DeribitUserTradeMsg>(data.get())
2624 .map(|trade| vec![trade])
2625 });
2626
2627 match trades_result {
2628 Ok(trades) => {
2629 log::debug!("Received {} user trade updates", trades.len());
2630 if self.account_id.is_none() {
2631 log::warn!("Cannot parse user trades: account_id not set");
2632 return Some(NautilusWsMessage::Raw(data.clone()));
2633 }
2634 let outgoing = self.route_user_trades(&trades, ts_init);
2635 if !outgoing.is_empty() {
2636 self.pending_outgoing.extend(outgoing);
2637 }
2638 }
2639 Err(e) => {
2640 log::warn!("Failed to deserialize user trades: {e}");
2641 }
2642 }
2643 }
2644 DeribitWsChannel::UserPortfolio => {
2645 match serde_json::from_str::<DeribitPortfolioMsg>(data.get()) {
2646 Ok(portfolio) => {
2647 if portfolio.equity.is_zero() && portfolio.balance.is_zero() {
2651 log::trace!(
2652 "Skipping zero-balance portfolio for {}",
2653 portfolio.currency
2654 );
2655 return None;
2656 }
2657
2658 let Some(account_id) = self.account_id else {
2660 log::warn!("Cannot parse portfolio: account_id not set");
2661 return None;
2662 };
2663
2664 match parse_portfolio_to_account_state(
2665 &portfolio, account_id, ts_init,
2666 ) {
2667 Ok(account_state) => {
2668 let currency_key = portfolio.currency.clone();
2670
2671 if let Some(last) =
2672 self.last_account_states.get(¤cy_key)
2673 && account_state.has_same_balances_and_margins(last)
2674 {
2675 log::trace!(
2676 "Skipping duplicate portfolio update for {}",
2677 portfolio.currency
2678 );
2679 return None;
2680 }
2681
2682 self.last_account_states
2683 .insert(currency_key, account_state.clone());
2684 return Some(NautilusWsMessage::AccountState(
2685 account_state,
2686 ));
2687 }
2688 Err(e) => {
2689 log::warn!(
2690 "Failed to parse portfolio to AccountState: {e}"
2691 );
2692 }
2693 }
2694 }
2695 Err(e) => {
2696 log::warn!("Failed to deserialize portfolio: {e}");
2697 }
2698 }
2699 }
2700 _ => {
2701 log::trace!("Unhandled channel: {channel}");
2703 return Some(NautilusWsMessage::Raw(data.clone()));
2704 }
2705 }
2706 } else {
2707 log::trace!("Unknown channel: {channel}");
2708 return Some(NautilusWsMessage::Raw(data.clone()));
2709 }
2710 None
2711 }
2712 DeribitWsMessage::Heartbeat(heartbeat) => {
2713 match heartbeat.heartbeat_type {
2714 DeribitHeartbeatType::TestRequest => {
2715 log::trace!(
2716 "Received heartbeat test_request - responding with public/test"
2717 );
2718
2719 if let Err(e) = self.handle_heartbeat_test_request().await {
2720 log::error!("Failed to respond to heartbeat test_request: {e}");
2721
2722 return Some(NautilusWsMessage::Error(DeribitWsError::Send(format!(
2724 "Heartbeat response failed: {e}"
2725 ))));
2726 }
2727 }
2728 DeribitHeartbeatType::Heartbeat => {
2729 log::trace!("Received heartbeat acknowledgment");
2730 }
2731 }
2732 None
2733 }
2734 DeribitWsMessage::Error(err) => {
2735 log::error!("Deribit error {}: {}", err.code, err.message);
2736 Some(NautilusWsMessage::Error(DeribitWsError::DeribitError {
2737 code: err.code,
2738 message: err.message,
2739 }))
2740 }
2741 DeribitWsMessage::Reconnected => Some(NautilusWsMessage::Reconnected),
2742 }
2743 }
2744
2745 fn handle_unsubscribe_acknowledgement(
2746 &mut self,
2747 request_id: u64,
2748 channels: &[String],
2749 response: &DeribitJsonRpcResponse<Box<RawValue>>,
2750 ) {
2751 if let Some(error) = &response.error {
2752 log::error!(
2753 "Unsubscribe failed: code={}, message={}, channels={:?}, request_id={}",
2754 error.code,
2755 error.message,
2756 channels,
2757 request_id
2758 );
2759
2760 self.abort_book_replacements(channels, error.code, &error.message);
2761
2762 return;
2763 }
2764
2765 let acknowledged = self.subscription_acknowledgements(
2766 request_id,
2767 channels,
2768 response.result.as_deref(),
2769 false,
2770 );
2771
2772 for ch in &acknowledged {
2773 self.subscriptions_state.confirm_unsubscribe(ch);
2774 log::debug!("Unsubscription confirmed: {ch}");
2775 self.handle_book_unsubscribe_ack(ch);
2776 }
2777 }
2778
2779 fn subscription_acknowledgements(
2780 &self,
2781 request_id: u64,
2782 requested: &[String],
2783 result: Option<&RawValue>,
2784 subscribe: bool,
2785 ) -> Vec<String> {
2786 let operation = if subscribe {
2787 "Subscribe"
2788 } else {
2789 "Unsubscribe"
2790 };
2791
2792 let parsed = result
2793 .ok_or_else(|| "missing result".to_string())
2794 .and_then(|result| {
2795 serde_json::from_str::<Vec<String>>(result.get()).map_err(|e| e.to_string())
2796 });
2797
2798 let returned = match parsed {
2799 Ok(channels) => channels,
2800 Err(e) => {
2801 let reason =
2802 format!("{operation} acknowledgement invalid: {e}, request_id={request_id}");
2803 log::error!("{reason}");
2804
2805 if subscribe {
2806 self.subscribe_errors.lock().push(reason);
2807 }
2808
2809 return Vec::new();
2810 }
2811 };
2812
2813 let mut returned: HashSet<String> = returned.into_iter().collect();
2814 let mut requested_unique = HashSet::new();
2815 let acknowledged: Vec<String> = requested
2816 .iter()
2817 .filter(|ch| requested_unique.insert(ch.as_str()) && returned.remove(ch.as_str()))
2818 .cloned()
2819 .collect();
2820
2821 if acknowledged.len() != requested_unique.len() || !returned.is_empty() {
2822 let reason = format!(
2823 "{operation} acknowledgement incomplete or unrelated: confirmed={} requested={} unrelated={}, request_id={request_id}",
2824 acknowledged.len(),
2825 requested_unique.len(),
2826 returned.len(),
2827 );
2828 log::error!("{reason}");
2829
2830 if subscribe {
2831 self.subscribe_errors.lock().push(reason);
2832 }
2833 }
2834
2835 acknowledged
2836 }
2837
2838 async fn handle_book_message(
2839 &mut self,
2840 channel: &str,
2841 data: &str,
2842 ts_init: UnixNanos,
2843 ) -> Option<NautilusWsMessage> {
2844 let book_msg = match serde_json::from_str::<DeribitBookMsg>(data) {
2845 Ok(msg) => msg,
2846 Err(e) => {
2847 log::warn!("Failed to deserialize book message: {e}, channel: {channel}");
2848 return None;
2849 }
2850 };
2851
2852 if is_grouped_book_channel(channel) {
2853 return self.handle_grouped_book(channel, &book_msg, ts_init).await;
2854 }
2855
2856 let key = BookKey::for_channel(channel)?;
2857
2858 if !self.book_sync.is_tracked(&key) {
2859 return None;
2860 }
2861
2862 let Some(instrument) = self.instruments_cache.get(&book_msg.instrument_name) else {
2863 log::warn!(
2864 "Book message received but instrument '{}' not found in cache (cache size: {})",
2865 book_msg.instrument_name,
2866 self.instruments_cache.len()
2867 );
2868 return None;
2869 };
2870
2871 if book_msg.msg_type == DeribitBookMsgType::Snapshot {
2873 let deltas = match parse_book_msg(&book_msg, instrument, ts_init) {
2874 Ok(deltas) => deltas,
2875 Err(e) => {
2876 log::error!(
2877 "Failed to parse book snapshot for {}: {e}, requesting recovery",
2878 book_msg.instrument_name
2879 );
2880 self.reject_book_frame(&key, DeribitWsError::ParsingError(e.to_string()));
2881 return None;
2882 }
2883 };
2884
2885 return match self.book_sync.validate(
2886 &key,
2887 book_msg.msg_type,
2888 book_msg.change_id,
2889 book_msg.prev_change_id,
2890 Instant::now(),
2891 ) {
2892 BookSequenceOutcome::Accept => Some(NautilusWsMessage::Deltas(deltas)),
2893 BookSequenceOutcome::Suppress | BookSequenceOutcome::Recover => None,
2894 };
2895 }
2896
2897 match self.book_sync.validate(
2898 &key,
2899 book_msg.msg_type,
2900 book_msg.change_id,
2901 book_msg.prev_change_id,
2902 Instant::now(),
2903 ) {
2904 BookSequenceOutcome::Accept => {}
2905 BookSequenceOutcome::Suppress => return None,
2906 BookSequenceOutcome::Recover => {
2907 self.start_book_recovery(&key);
2908 return None;
2909 }
2910 }
2911
2912 match parse_book_msg(&book_msg, instrument, ts_init) {
2913 Ok(deltas) => Some(NautilusWsMessage::Deltas(deltas)),
2914 Err(e) => {
2915 log::error!(
2916 "Failed to parse book message for {}: {e}, requesting recovery",
2917 book_msg.instrument_name
2918 );
2919 self.reject_book_delta(&key, DeribitWsError::ParsingError(e.to_string()));
2920 None
2921 }
2922 }
2923 }
2924
2925 async fn handle_grouped_book(
2926 &mut self,
2927 channel: &str,
2928 book_msg: &DeribitBookMsg<'_>,
2929 ts_init: UnixNanos,
2930 ) -> Option<NautilusWsMessage> {
2931 let (depth_refs, deltas_subscribed) = {
2932 let depth_subs = self.book_depth_subs.lock().await;
2933 let depth_refs = depth_subs.get_reference_count(channel);
2934 let deltas_subscribed =
2935 self.subscriptions_state.get_reference_count(channel) > depth_refs;
2936 (depth_refs, deltas_subscribed)
2937 };
2938
2939 if depth_refs == 0 && !deltas_subscribed {
2940 return None;
2941 }
2942
2943 let key = BookKey::for_channel(channel)?;
2944
2945 if !self.book_sync.is_tracked(&key) {
2946 return None;
2947 }
2948
2949 if book_msg.msg_type == DeribitBookMsgType::Change
2951 && !self.validate_book_frame(
2952 &key,
2953 book_msg.msg_type,
2954 book_msg.change_id,
2955 book_msg.prev_change_id,
2956 )
2957 {
2958 return None;
2959 }
2960
2961 let Some(instrument) = self.instruments_cache.get(&book_msg.instrument_name) else {
2962 log::warn!(
2963 "Book snapshot instrument '{}' not found in cache",
2964 book_msg.instrument_name
2965 );
2966 return None;
2967 };
2968
2969 let depth = if depth_refs > 0 {
2971 Some(parse_book_depth(book_msg, instrument, ts_init))
2972 } else {
2973 None
2974 };
2975
2976 let deltas = if deltas_subscribed {
2977 Some(parse_book_msg(book_msg, instrument, ts_init))
2978 } else {
2979 None
2980 };
2981
2982 let (depth, deltas) = self.parse_grouped_snapshot(
2983 &key,
2984 channel,
2985 book_msg.instrument_name.as_str(),
2986 depth,
2987 deltas,
2988 )?;
2989
2990 if book_msg.msg_type == DeribitBookMsgType::Snapshot
2991 && !matches!(
2992 self.book_sync.validate(
2993 &key,
2994 book_msg.msg_type,
2995 book_msg.change_id,
2996 book_msg.prev_change_id,
2997 Instant::now(),
2998 ),
2999 BookSequenceOutcome::Accept
3000 )
3001 {
3002 return None;
3003 }
3004
3005 if let Some(depth) = depth {
3006 if let Some(deltas) = deltas {
3007 self.pending_outgoing
3008 .push_back(NautilusWsMessage::Deltas(deltas));
3009 }
3010
3011 return Some(NautilusWsMessage::Data(vec![Data::BookDepth(Box::new(
3012 depth,
3013 ))]));
3014 }
3015
3016 deltas.map(NautilusWsMessage::Deltas)
3017 }
3018
3019 fn reject_book_frame(&mut self, key: &BookKey, error: DeribitWsError) {
3020 if self.book_sync.reject_snapshot(key, error) == BookSequenceOutcome::Recover {
3021 self.start_book_recovery(key);
3022 }
3023 }
3024
3025 fn reject_book_delta(&mut self, key: &BookKey, error: DeribitWsError) {
3026 if self.book_sync.reject_delta(key, error) == BookSequenceOutcome::Recover {
3027 self.start_book_recovery(key);
3028 }
3029 }
3030
3031 fn start_book_recovery(&mut self, key: &BookKey) {
3032 if self.book_replacement_channels(key).is_empty() {
3035 return;
3036 }
3037
3038 let Some(cmd_tx) = self.book_cmd_tx.clone() else {
3039 return;
3040 };
3041
3042 let Some(recovery) = self.book_sync.claim(key) else {
3043 return;
3044 };
3045
3046 log::debug!("Starting book recovery for {key}");
3047 let timeout = self.book_snapshot_timeout;
3048 self.book_sync
3049 .work
3050 .push(recover(key.clone(), recovery, cmd_tx, timeout));
3051 }
3052
3053 fn poll_book_recoveries(&mut self) {
3054 if self.book_sync.is_empty() {
3055 return;
3056 }
3057
3058 let now = Instant::now();
3059 let elapsed = now
3060 .checked_duration_since(self.book_monitor_last)
3061 .unwrap_or_default();
3062
3063 if elapsed < Duration::from_secs(1) {
3064 return;
3065 }
3066
3067 self.book_monitor_last = now;
3068
3069 for (key, signal) in
3070 self.book_sync
3071 .recoveries(self.book_stale_threshold, self.book_snapshot_timeout, now)
3072 {
3073 signal.log();
3074 self.start_book_recovery(&key);
3075 }
3076 }
3077
3078 fn book_replacement_channels(&self, key: &BookKey) -> Vec<String> {
3081 match key {
3082 BookKey::Raw(instrument) => self
3083 .subscriptions_state
3084 .all_topics()
3085 .into_iter()
3086 .filter(|t| {
3087 is_instrument_book_channel(t, instrument) && !is_grouped_book_channel(t)
3088 })
3089 .collect(),
3090 BookKey::Grouped(channel) => {
3091 if self.subscriptions_state.get_reference_count(channel) > 0 {
3092 vec![channel.clone()]
3093 } else {
3094 Vec::new()
3095 }
3096 }
3097 }
3098 }
3099
3100 fn book_key_still_desired(&self, key: &BookKey, removed: &str) -> bool {
3102 match key {
3103 BookKey::Raw(instrument) => self.subscriptions_state.all_topics().iter().any(|t| {
3104 t != removed
3105 && is_instrument_book_channel(t, instrument)
3106 && !is_grouped_book_channel(t)
3107 }),
3108 BookKey::Grouped(_) => false,
3109 }
3110 }
3111
3112 fn drop_released_book_tracking(&mut self, channels: &[String]) {
3116 for channel in channels {
3117 if let Some(key) = BookKey::for_channel(channel)
3118 && !self.book_key_still_desired(&key, channel)
3119 {
3120 self.book_sync.remove(&key);
3121 self.book_recovery_requests.remove(&key);
3122 }
3123 }
3124 }
3125
3126 fn replace_book_subscription(
3127 &mut self,
3128 instrument: Ustr,
3129 channel: Option<String>,
3130 cancel: &CancellationToken,
3131 gate: SnapshotGate,
3132 completion: tokio::sync::oneshot::Sender<Result<(), DeribitWsError>>,
3133 recovery: &Arc<BookRecovery>,
3134 ) {
3135 let key = match channel {
3136 Some(channel) => BookKey::Grouped(channel),
3137 None => BookKey::Raw(instrument),
3138 };
3139
3140 let channels = self.book_replacement_channels(&key);
3141
3142 if channels.is_empty() || cancel.is_cancelled() {
3143 return;
3144 }
3145
3146 if !self
3147 .book_sync
3148 .begin_recovery_write(&key, recovery, gate, completion, channels.clone())
3149 {
3150 return;
3151 }
3152
3153 self.retire_superseded_recovery_requests(&key);
3156
3157 match self.handle_unsubscribe(channels) {
3158 Ok(ids) => self
3159 .book_recovery_requests
3160 .entry(key)
3161 .or_default()
3162 .extend(ids),
3163 Err(e) => self.book_sync.abort_recovery_write(&key, e),
3164 }
3165 }
3166
3167 fn retire_superseded_recovery_requests(&mut self, key: &BookKey) {
3168 if let Some(ids) = self.book_recovery_requests.remove(key) {
3171 for id in ids {
3172 self.pending_requests.remove(&id);
3173 }
3174 }
3175 }
3176
3177 fn abort_book_replacements(&mut self, channels: &[String], code: i64, message: &str) {
3178 for channel in channels {
3179 if let Some(key) = BookKey::for_channel(channel) {
3180 self.book_sync.abort_recovery_write(
3181 &key,
3182 DeribitWsError::DeribitError {
3183 code,
3184 message: message.to_owned(),
3185 },
3186 );
3187 }
3188 }
3189 }
3190
3191 fn recover_rejected_book_subscriptions(&mut self, channels: &[String]) {
3192 for channel in channels {
3194 if let Some(key) = BookKey::for_channel(channel)
3195 && self.book_sync.has_unacked_subscription(&key)
3196 {
3197 self.start_book_recovery(&key);
3198 }
3199 }
3200 }
3201
3202 fn confirm_book_subscription(&mut self, channel: &str) {
3203 if let Some(key) = BookKey::for_channel(channel) {
3204 let timeout = self.book_snapshot_timeout;
3205 self.book_sync.subscribed(&key, timeout, Instant::now());
3206 }
3207 }
3208
3209 fn handle_book_unsubscribe_ack(&mut self, channel: &str) {
3210 let Some(key) = BookKey::for_channel(channel) else {
3211 return;
3212 };
3213
3214 let lost = DeribitWsError::Transport("book replacement lost before resubscribe".to_owned());
3215
3216 match self.book_sync.unsubscribed(&key, channel, lost) {
3217 UnsubscribedOutcome::Resubscribe(pending) => {
3218 let desired: Vec<String> = pending
3219 .into_iter()
3220 .filter(|channel| self.subscriptions_state.get_reference_count(channel) > 0)
3221 .collect();
3222
3223 if desired.is_empty() {
3224 self.book_sync.abort_recovery_write(
3225 &key,
3226 DeribitWsError::ClientError("book replacement cancelled".to_owned()),
3227 );
3228 self.book_sync.remove(&key);
3229 } else {
3230 match self.handle_subscribe(&desired) {
3231 Ok(ids) => self
3232 .book_recovery_requests
3233 .entry(key.clone())
3234 .or_default()
3235 .extend(ids),
3236 Err(e) => self.book_sync.abort_recovery_write(&key, e),
3237 }
3238 }
3239 }
3240 UnsubscribedOutcome::RejectRecovery => {
3241 log::debug!("Book replacement lost for {key}, failing its attempt");
3242 }
3243 UnsubscribedOutcome::Ignored => {}
3244 }
3245 }
3246
3247 fn validate_book_frame(
3249 &mut self,
3250 key: &BookKey,
3251 msg_type: DeribitBookMsgType,
3252 change_id: u64,
3253 prev_change_id: Option<u64>,
3254 ) -> bool {
3255 match self
3256 .book_sync
3257 .validate(key, msg_type, change_id, prev_change_id, Instant::now())
3258 {
3259 BookSequenceOutcome::Accept => true,
3260 BookSequenceOutcome::Suppress => false,
3261 BookSequenceOutcome::Recover => {
3262 self.start_book_recovery(key);
3263 false
3264 }
3265 }
3266 }
3267
3268 fn parse_grouped_snapshot<T, U>(
3270 &mut self,
3271 key: &BookKey,
3272 channel: &str,
3273 instrument_name: &str,
3274 depth: Option<anyhow::Result<T>>,
3275 deltas: Option<anyhow::Result<U>>,
3276 ) -> Option<(Option<T>, Option<U>)> {
3277 let depth = match depth.transpose() {
3278 Ok(depth) => depth,
3279 Err(e) => {
3280 log::error!(
3281 "Failed to parse grouped book snapshot for {instrument_name} on {channel}: {e}, requesting recovery",
3282 );
3283 self.reject_book_frame(key, DeribitWsError::ParsingError(e.to_string()));
3284 return None;
3285 }
3286 };
3287
3288 let deltas = match deltas.transpose() {
3289 Ok(deltas) => deltas,
3290 Err(e) => {
3291 log::error!(
3292 "Failed to parse grouped book snapshot for {instrument_name} on {channel}: {e}, requesting recovery",
3293 );
3294 self.reject_book_frame(key, DeribitWsError::ParsingError(e.to_string()));
3295 return None;
3296 }
3297 };
3298
3299 Some((depth, deltas))
3300 }
3301
3302 fn handle_order_submit_response(
3303 &mut self,
3304 submit_context: &OrderContext,
3305 request_id: u64,
3306 response: &DeribitJsonRpcResponse<Box<RawValue>>,
3307 ts_init: UnixNanos,
3308 ) -> Option<NautilusWsMessage> {
3309 let client_order_id = submit_context.client_order_id;
3310 let trader_id = submit_context.trader_id;
3311 let strategy_id = submit_context.strategy_id;
3312 let instrument_id = submit_context.instrument_id;
3313
3314 let Some(result) = &response.result else {
3315 let error = response.error.as_ref()?;
3316 let (reason, due_post_only) =
3317 Self::venue_command_reason(error.code, &error.message, error.data.as_ref())?;
3318 self.submitted_order_contexts.remove(&client_order_id);
3319 return Some(NautilusWsMessage::OrderRejected(self.order_rejected(
3320 trader_id,
3321 strategy_id,
3322 instrument_id,
3323 client_order_id,
3324 &reason,
3325 due_post_only,
3326 )));
3327 };
3328
3329 let order_response = match serde_json::from_str::<DeribitOrderResponse>(result.get()) {
3330 Ok(order_response) => order_response,
3331 Err(e) => {
3332 log::error!("Failed to parse order response: request_id={request_id}, error={e}");
3333 return None;
3334 }
3335 };
3336
3337 let venue_order_id_str = &order_response.order.order_id;
3338 let venue_order_id = VenueOrderId::new(venue_order_id_str.as_str());
3339 let order_state = &order_response.order.order_state;
3340 log::debug!(
3341 "Order response: venue_order_id={venue_order_id}, client_order_id={client_order_id}, state={order_state}"
3342 );
3343
3344 let was_terminal = self.terminal_order_contexts.contains_key(&venue_order_id);
3345
3346 let mut context = self
3347 .find_order_context(venue_order_id, Some(client_order_id))
3348 .unwrap_or_else(|| OrderContext {
3349 last_order_signature: Some(Self::order_signature(&order_response.order)),
3350 ..submit_context.clone()
3351 });
3352
3353 context.last_order_signature = Some(Self::order_signature(&order_response.order));
3354 if was_terminal {
3355 self.finish_order_context(venue_order_id, &context, false);
3356 } else {
3357 self.bind_order_context(venue_order_id, context.clone());
3358 }
3359
3360 if order_state == "rejected" {
3361 self.submitted_order_contexts.remove(&client_order_id);
3362 self.finish_order_context(venue_order_id, &context, true);
3363 let due_post_only =
3364 order_response.order.reject_reason.as_deref() == Some("post_only_reject");
3365 let reason = sanitize_strategy_reason(
3366 order_response.order.reject_reason.as_deref().unwrap_or(""),
3367 );
3368 log::warn!(
3369 "Venue rejected order in result: client_order_id={client_order_id}, reason={reason}"
3370 );
3371 return Some(NautilusWsMessage::OrderRejected(self.order_rejected(
3372 trader_id,
3373 strategy_id,
3374 instrument_id,
3375 client_order_id,
3376 &reason,
3377 due_post_only,
3378 )));
3379 }
3380
3381 if !order_response.trades.is_empty() {
3382 let outgoing = self.route_user_trades(&order_response.trades, ts_init);
3383 self.pending_outgoing.extend(outgoing);
3384 return None;
3385 }
3386
3387 if order_state == "filled" {
3388 log::debug!(
3389 "Deferring acceptance for fast-filled order until its trade arrives: venue_order_id={venue_order_id}, client_order_id={client_order_id}"
3390 );
3391 self.finish_order_context(venue_order_id, &context, false);
3392 return None;
3393 }
3394
3395 if was_terminal {
3396 log::debug!(
3397 "Skipping OrderAccepted for terminal order: client_order_id={client_order_id}"
3398 );
3399 return None;
3400 }
3401
3402 if context.accepted {
3403 log::trace!(
3404 "Skipping duplicate OrderAccepted response: venue_order_id={venue_order_id}"
3405 );
3406 return None;
3407 }
3408
3409 let instrument_name_ustr = order_response.order.instrument_name;
3410
3411 let Some(instrument) = self.instruments_cache.get(&instrument_name_ustr) else {
3412 log::warn!("Instrument {instrument_name_ustr} not found in cache for order response");
3413 return None;
3414 };
3415
3416 let Some(account_id) = self.account_id else {
3417 log::warn!("Cannot create OrderAccepted: account_id not set");
3418 return None;
3419 };
3420
3421 let event = parse_order_accepted_with_client_order_id(
3422 &order_response.order,
3423 instrument,
3424 account_id,
3425 trader_id,
3426 strategy_id,
3427 client_order_id,
3428 ts_init,
3429 );
3430 context.accepted = true;
3431 self.bind_order_context(venue_order_id, context);
3432 Some(NautilusWsMessage::OrderAccepted(event))
3433 }
3434
3435 fn order_signature(order: &DeribitOrderMsg) -> OrderSignature {
3436 (order.amount, order.price, order.trigger_price)
3437 }
3438
3439 fn find_order_context(
3440 &self,
3441 venue_order_id: VenueOrderId,
3442 client_order_id: Option<ClientOrderId>,
3443 ) -> Option<OrderContext> {
3444 self.order_contexts
3445 .get(&venue_order_id)
3446 .or_else(|| {
3447 self.terminal_order_contexts
3448 .get(&venue_order_id)
3449 .map(|terminal| &terminal.context)
3450 })
3451 .cloned()
3452 .or_else(|| {
3453 client_order_id.and_then(|client_order_id| {
3454 self.submitted_order_contexts.get(&client_order_id).cloned()
3455 })
3456 })
3457 }
3458
3459 fn bind_order_context(&mut self, venue_order_id: VenueOrderId, context: OrderContext) {
3460 self.submitted_order_contexts
3461 .remove(&context.client_order_id);
3462 self.terminal_order_contexts.remove(&venue_order_id);
3463 self.order_contexts.insert(venue_order_id, context);
3464 }
3465
3466 fn finish_order_context(
3467 &mut self,
3468 venue_order_id: VenueOrderId,
3469 context: &OrderContext,
3470 late_fills_as_reports: bool,
3471 ) {
3472 self.order_contexts.remove(&venue_order_id);
3473 self.submitted_order_contexts
3474 .remove(&context.client_order_id);
3475 let late_fills_as_reports = late_fills_as_reports
3476 || self
3477 .terminal_order_contexts
3478 .get(&venue_order_id)
3479 .is_some_and(|terminal| terminal.late_fills_as_reports);
3480
3481 let terminal = TerminalOrderContext {
3482 context: context.clone(),
3483 late_fills_as_reports,
3484 };
3485
3486 self.terminal_order_contexts
3487 .insert(venue_order_id, terminal);
3488 }
3489
3490 fn route_user_trades(
3491 &mut self,
3492 trades: &[DeribitUserTradeMsg],
3493 ts_init: UnixNanos,
3494 ) -> Vec<NautilusWsMessage> {
3495 let Some(account_id) = self.account_id else {
3496 log::warn!("Cannot parse user trades: account_id not set");
3497 return Vec::new();
3498 };
3499
3500 let mut outgoing = Vec::with_capacity(trades.len() + 1);
3501 let mut reports = Vec::new();
3502 let mut completed_contexts = IndexMap::new();
3503
3504 for trade in trades {
3505 let instrument_name = trade.instrument_name;
3506 let Some((report, quote_currency)) =
3507 self.instruments_cache
3508 .get(&instrument_name)
3509 .map(|instrument| {
3510 (
3511 parse_user_trade_msg(trade, instrument, account_id, ts_init),
3512 instrument.quote_currency(),
3513 )
3514 })
3515 else {
3516 log::warn!("Instrument {instrument_name} not found in cache");
3517 continue;
3518 };
3519
3520 let report = match report {
3521 Ok(report) => report,
3522 Err(e) => {
3523 log::warn!("Failed to parse trade {}: {e}", trade.trade_id);
3524 continue;
3525 }
3526 };
3527
3528 self.route_user_trade(
3529 trade,
3530 report,
3531 quote_currency,
3532 &mut outgoing,
3533 &mut reports,
3534 &mut completed_contexts,
3535 );
3536 }
3537
3538 for (venue_order_id, context) in completed_contexts {
3539 self.finish_order_context(venue_order_id, &context, true);
3540 }
3541
3542 if !reports.is_empty() {
3543 outgoing.push(NautilusWsMessage::FillReports(reports));
3544 }
3545
3546 outgoing.retain_mut(|message| match message {
3548 NautilusWsMessage::OrderFilled(fill) => self
3549 .emitted_trades
3550 .insert((fill.venue_order_id, fill.trade_id)),
3551 NautilusWsMessage::FillReports(reports) => {
3552 reports.retain(|report| {
3553 self.emitted_trades
3554 .insert((report.venue_order_id, report.trade_id))
3555 });
3556
3557 !reports.is_empty()
3558 }
3559 _ => true,
3560 });
3561
3562 outgoing
3563 }
3564
3565 fn route_user_trade(
3566 &mut self,
3567 trade: &DeribitUserTradeMsg,
3568 mut report: FillReport,
3569 quote_currency: Currency,
3570 outgoing: &mut Vec<NautilusWsMessage>,
3571 reports: &mut Vec<FillReport>,
3572 completed_contexts: &mut IndexMap<VenueOrderId, OrderContext>,
3573 ) {
3574 let venue_order_id = report.venue_order_id;
3575 let terminal = self.terminal_order_contexts.get(&venue_order_id);
3576 let was_terminal = terminal.is_some();
3577 let late_fills_as_reports = terminal.is_some_and(|terminal| terminal.late_fills_as_reports);
3578
3579 let Some(mut context) = self.find_order_context(venue_order_id, report.client_order_id)
3580 else {
3581 log::debug!(
3582 "Parsed external fill report: {} @ {}",
3583 report.trade_id,
3584 report.last_px
3585 );
3586 reports.push(report);
3587 return;
3588 };
3589
3590 if late_fills_as_reports {
3591 report.client_order_id = Some(context.client_order_id);
3592 log::debug!(
3593 "Parsed post-terminal fill report: {} @ {}",
3594 report.trade_id,
3595 report.last_px
3596 );
3597 reports.push(report);
3598 return;
3599 }
3600
3601 if !reports.is_empty() {
3602 outgoing.push(NautilusWsMessage::FillReports(std::mem::take(reports)));
3603 }
3604
3605 let account_id = report.account_id;
3606
3607 if !context.accepted {
3608 outgoing.push(NautilusWsMessage::OrderAccepted(OrderAccepted::new(
3609 context.trader_id,
3610 context.strategy_id,
3611 context.instrument_id,
3612 context.client_order_id,
3613 venue_order_id,
3614 account_id,
3615 UUID4::new(),
3616 report.ts_event,
3617 report.ts_init,
3618 false,
3619 )));
3620 context.accepted = true;
3621 }
3622
3623 log::debug!(
3624 "Parsed tracked fill event: {} @ {}",
3625 report.trade_id,
3626 report.last_px
3627 );
3628 outgoing.push(NautilusWsMessage::OrderFilled(OrderFilled::new(
3629 context.trader_id,
3630 context.strategy_id,
3631 context.instrument_id,
3632 context.client_order_id,
3633 venue_order_id,
3634 account_id,
3635 report.trade_id,
3636 context.order_side,
3637 context.order_type,
3638 report.last_qty,
3639 report.last_px,
3640 quote_currency,
3641 report.liquidity_side,
3642 UUID4::new(),
3643 report.ts_event,
3644 report.ts_init,
3645 false,
3646 report.venue_position_id,
3647 Some(report.commission),
3648 None,
3649 )));
3650
3651 if trade.state == "filled" {
3652 completed_contexts.insert(venue_order_id, context.clone());
3653 }
3654
3655 if was_terminal {
3656 self.finish_order_context(venue_order_id, &context, false);
3657 } else {
3658 self.bind_order_context(venue_order_id, context);
3659 }
3660 }
3661
3662 pub async fn next(&mut self) -> Option<NautilusWsMessage> {
3668 let mut book_monitor = tokio::time::interval(tokio::time::Duration::from_millis(100));
3670
3671 loop {
3672 if let Some(msg) = self.pending_outgoing.pop_front() {
3673 match msg {
3674 NautilusWsMessage::Reconnected
3675 | NautilusWsMessage::Authenticated(_)
3676 | NautilusWsMessage::AuthenticationFailed(_) => {
3677 return Some(msg);
3678 }
3679 _ => {
3680 let _ = self.out_tx.send(msg);
3681 continue;
3682 }
3683 }
3684 }
3685
3686 if self.signal.load(Ordering::Relaxed) {
3687 self.subscription_send = None;
3688 self.fail_unsent_order_commands();
3689 self.process_command(HandlerCommand::Disconnect).await;
3690 return None;
3691 }
3692
3693 if self.subscription_send.is_none()
3694 && let Some((request_id, payload)) = self.subscription_requests.pop_front()
3695 {
3696 let send = self.send_secret_with_retry(
3697 payload.into(),
3698 Some(&[Ustr::from(DERIBIT_WS_SUBSCRIPTION_KEY)]),
3699 );
3700 self.subscription_send = Some(Box::pin(async move { (request_id, send.await) }));
3701 }
3702
3703 tokio::select! {
3704 (request_id, result) = async {
3705 match &mut self.subscription_send {
3706 Some(send) => send.await,
3707 None => std::future::pending().await,
3708 }
3709 } => {
3710 self.subscription_send = None;
3711
3712 if let Err(e) = result {
3713 if matches!(
3714 self.pending_requests.remove(&request_id),
3715 Some(PendingRequestType::Subscribe { .. })
3716 ) {
3717 self.subscribe_errors.lock().push(e.to_string());
3718 }
3719 log::error!("Subscription request send failed: request_id={request_id}, {e}");
3720 }
3721 }
3722 Some(_) = self.book_sync.work.next(), if !self.book_sync.work.is_empty() => {
3723 }
3725 Some(cmd) = async {
3727 match self.pending_command.take() {
3728 Some(cmd) => Some(cmd),
3729 None => self.cmd_rx.recv().await,
3730 }
3731 }, if self.subscription_send.is_none() && self.subscription_requests.is_empty() => {
3732 let cmd = match cmd {
3733 HandlerCommand::Subscribe { channels } => {
3734 let channels = self.coalesce_subscriptions(channels);
3735 HandlerCommand::Subscribe { channels }
3736 }
3737 cmd => cmd,
3738 };
3739 self.process_command(cmd).await;
3740 }
3741 Some(msg) = self.raw_rx.recv() => {
3743 match msg {
3744 Message::Text(text) => {
3745 if let Some(nautilus_msg) = self.process_raw_message(&text).await {
3746 match &nautilus_msg {
3748 NautilusWsMessage::Data(_)
3749 | NautilusWsMessage::Deltas(_)
3750 | NautilusWsMessage::Instrument(_)
3751 | NautilusWsMessage::InstrumentStatus(_)
3752 | NautilusWsMessage::OptionGreeks(_)
3753 | NautilusWsMessage::Raw(_)
3754 | NautilusWsMessage::Error(_) => {
3755 let _ = self.out_tx.send(nautilus_msg);
3756 }
3757 NautilusWsMessage::FundingRates(rates) => {
3758 let msg_to_send =
3759 NautilusWsMessage::FundingRates(rates.clone());
3760
3761 if let Err(e) = self.out_tx.send(msg_to_send) {
3762 log::error!("Failed to send funding rates: {e}");
3763 }
3764 }
3765 NautilusWsMessage::OrderStatusReports(_)
3766 | NautilusWsMessage::FillReports(_)
3767 | NautilusWsMessage::OrderFilled(_)
3768 | NautilusWsMessage::OrderAccepted(_)
3769 | NautilusWsMessage::OrderCanceled(_)
3770 | NautilusWsMessage::OrderExpired(_)
3771 | NautilusWsMessage::OrderUpdated(_)
3772 | NautilusWsMessage::OrderRejected(_)
3773 | NautilusWsMessage::OrderCancelRejected(_)
3774 | NautilusWsMessage::OrderModifyDenied(_)
3775 | NautilusWsMessage::OrderModifyRejected(_)
3776 | NautilusWsMessage::OrderCancelDenied(_)
3777 | NautilusWsMessage::AccountState(_) => {
3778 let _ = self.out_tx.send(nautilus_msg);
3779 }
3780 NautilusWsMessage::Reconnected
3782 | NautilusWsMessage::Authenticated(_)
3783 | NautilusWsMessage::AuthenticationFailed(_) => {
3784 return Some(nautilus_msg);
3785 }
3786 }
3787 }
3788 }
3789 Message::Ping(data) => {
3790 if let Some(client) = &self.inner {
3792 let _ = client.send_pong(data.to_vec()).await;
3793 }
3794 }
3795 Message::Close(_) => {
3796 log::debug!("Received close frame");
3797 }
3798 _ => {}
3799 }
3800 }
3801 _ = book_monitor.tick() => {
3803 self.poll_book_recoveries();
3804 }
3805 }
3806 }
3807 }
3808}
3809
3810type SubscriptionSend = BoxFuture<'static, (u64, Result<(), DeribitWsError>)>;
3811
3812fn subscription_batches(
3813 channels: Vec<String>,
3814 method: &DeribitWsMethod,
3815) -> Result<Vec<Vec<String>>, DeribitWsError> {
3816 let envelope = DeribitJsonRpcRequest::new(
3817 u64::MAX,
3818 method.as_method_str(),
3819 DeribitSubscribeParams {
3820 channels: Vec::new(),
3821 },
3822 );
3823
3824 let overhead = serde_json::to_string(&envelope)
3825 .map_err(|e| DeribitWsError::Json(e.to_string()))?
3826 .len();
3827 let mut batches = Vec::new();
3828 let mut batch = Vec::new();
3829 let mut bytes = overhead;
3830
3831 for channel in channels {
3832 let encoded =
3833 serde_json::to_string(&channel).map_err(|e| DeribitWsError::Json(e.to_string()))?;
3834
3835 if overhead + encoded.len() > SUBSCRIPTION_REQUEST_MAX_BYTES {
3836 return Err(DeribitWsError::Subscribe(
3837 "Channel exceeds the WebSocket request byte limit".to_string(),
3838 ));
3839 }
3840
3841 let separator = usize::from(!batch.is_empty());
3842 if bytes + separator + encoded.len() > SUBSCRIPTION_REQUEST_MAX_BYTES {
3843 batches.push(std::mem::take(&mut batch));
3844 bytes = overhead;
3845 }
3846
3847 bytes += usize::from(!batch.is_empty()) + encoded.len();
3848 batch.push(channel);
3849 }
3850
3851 if !batch.is_empty() {
3852 batches.push(batch);
3853 }
3854
3855 Ok(batches)
3856}
3857
3858fn is_instrument_book_channel(channel: &str, instrument_name: &str) -> bool {
3859 channel.starts_with("book.")
3860 && channel
3861 .split('.')
3862 .nth(1)
3863 .is_some_and(|s| s == instrument_name)
3864}
3865
3866fn is_grouped_book_channel(channel: &str) -> bool {
3868 channel.starts_with("book.") && channel.split('.').count() == 5
3869}
3870
3871fn book_instrument_id(channel: &str) -> Option<InstrumentId> {
3872 let symbol = channel.split('.').nth(1)?;
3873 Some(InstrumentId::new(
3874 Symbol::from(Ustr::from(symbol)),
3875 *DERIBIT_VENUE,
3876 ))
3877}
3878
3879#[cfg(test)]
3880mod tests {
3881 use std::time::Duration;
3882
3883 use futures_util::{SinkExt, StreamExt};
3884 use nautilus_live::book::BookSyncSignalKind;
3885 use nautilus_model::{
3886 enums::{BookType, LiquiditySide},
3887 events::OrderEventAny,
3888 instruments::Instrument,
3889 orderbook::OrderBook,
3890 types::{Currency, Money, Price, Quantity},
3891 };
3892 use nautilus_network::{
3893 ratelimiter::quota::Quota,
3894 websocket::{WebSocketConfig, channel_message_handler},
3895 };
3896 use rstest::rstest;
3897
3898 use super::*;
3899 use crate::{
3900 common::{
3901 parse::parse_deribit_instrument_any,
3902 testing::{load_test_json, routed_spot_instrument},
3903 },
3904 http::models::{DeribitInstrument, DeribitJsonRpcResponse},
3905 };
3906
3907 fn routing_test_handler() -> DeribitWsFeedHandler {
3908 let signal = Arc::new(AtomicBool::new(false));
3909 let (_cmd_tx, cmd_rx) = tokio::sync::mpsc::unbounded_channel();
3910 let (_raw_tx, raw_rx) = tokio::sync::mpsc::unbounded_channel();
3911 let (out_tx, _out_rx) = tokio::sync::mpsc::unbounded_channel();
3912 let mut handler = DeribitWsFeedHandler::new(
3913 signal,
3914 cmd_rx,
3915 raw_rx,
3916 out_tx,
3917 AuthTracker::new(),
3918 SubscriptionState::new('.'),
3919 Arc::new(AtomicSet::new()),
3920 Arc::new(AtomicSet::new()),
3921 Arc::new(AtomicSet::new()),
3922 Some(AccountId::from("DERIBIT-001")),
3923 true,
3924 Arc::new(Mutex::new(Vec::new())),
3925 );
3926 let json = load_test_json("http_get_instruments.json");
3927 let response: DeribitJsonRpcResponse<Vec<DeribitInstrument>> =
3928 serde_json::from_str(&json).unwrap();
3929 let instrument = parse_deribit_instrument_any(
3930 &response.result.unwrap()[0],
3931 UnixNanos::default(),
3932 UnixNanos::default(),
3933 )
3934 .unwrap()
3935 .unwrap();
3936 handler
3937 .instruments_cache
3938 .insert(instrument.raw_symbol().inner(), instrument);
3939 handler
3940 }
3941
3942 fn order_data(order_state: &str, replaced: bool) -> serde_json::Value {
3943 serde_json::json!({
3944 "order_id": "ETH-584830574",
3945 "label": "O-19700101-000000-001-001-1",
3946 "instrument_name": "BTC-PERPETUAL",
3947 "direction": "buy",
3948 "order_type": "market",
3949 "order_state": order_state,
3950 "replaced": replaced,
3951 "price": 203.8,
3952 "amount": 2.0,
3953 "filled_amount": if order_state == "filled" { 2.0 } else { 0.0 },
3954 "average_price": 203.8,
3955 "creation_timestamp": 1_590_480_712_700_u64,
3956 "last_update_timestamp": 1_590_480_712_800_u64,
3957 "time_in_force": "good_til_cancelled",
3958 "commission": 0.00073602,
3959 "post_only": false,
3960 "reduce_only": false,
3961 "trigger_price": null,
3962 "trigger": null,
3963 "max_show": null,
3964 "api": true,
3965 "reject_reason": null,
3966 "cancel_reason": null
3967 })
3968 }
3969
3970 fn trade_data() -> serde_json::Value {
3971 serde_json::json!({
3972 "trade_id": "ETH-2696068",
3973 "order_id": "ETH-584830574",
3974 "instrument_name": "BTC-PERPETUAL",
3975 "direction": "buy",
3976 "price": 203.8,
3977 "amount": 2.0,
3978 "fee": 0.00073602,
3979 "fee_currency": "USDT",
3980 "timestamp": 1_590_480_712_800_u64,
3981 "trade_seq": 1_966_042_u64,
3982 "liquidity": "T",
3983 "order_type": "market",
3984 "index_price": 203.89,
3985 "mark_price": 203.78,
3986 "tick_direction": 3,
3987 "state": "filled",
3988 "label": "O-19700101-000000-001-001-1",
3989 "reduce_only": false,
3990 "post_only": false,
3991 "liquidation": null,
3992 "profit_loss": null
3993 })
3994 }
3995
3996 fn subscription(channel: &str, data: &serde_json::Value) -> String {
3997 serde_json::json!({
3998 "jsonrpc": "2.0",
3999 "method": "subscription",
4000 "params": { "channel": channel, "data": data }
4001 })
4002 .to_string()
4003 }
4004
4005 #[rstest]
4006 #[case([0, 1, 2])]
4007 #[case([0, 2, 1])]
4008 #[case([1, 0, 2])]
4009 #[case([1, 2, 0])]
4010 #[case([2, 0, 1])]
4011 #[case([2, 1, 0])]
4012 #[tokio::test]
4013 async fn routed_spot_async_fills_emit_once(
4014 #[case] sequence: [usize; 3],
4015 #[values("open", "filled")] ack_state: &str,
4016 ) {
4017 let mut handler = routing_test_handler();
4018 let instrument = routed_spot_instrument();
4019 let instrument_id = instrument.id();
4020 handler
4021 .instruments_cache
4022 .insert(instrument.raw_symbol().inner(), instrument);
4023 let client_order_id = ClientOrderId::from("routed-904");
4024 handler.submitted_order_contexts.insert(
4025 client_order_id,
4026 OrderContext {
4027 client_order_id,
4028 trader_id: TraderId::from("TRADER-001"),
4029 strategy_id: StrategyId::from("S-001"),
4030 instrument_id,
4031 order_side: OrderSide::Buy,
4032 order_type: OrderType::Limit,
4033 accepted: false,
4034 last_order_signature: None,
4035 },
4036 );
4037
4038 handler.pending_requests.insert(
4039 42,
4040 PendingRequestType::Buy {
4041 client_order_id,
4042 trader_id: TraderId::from("TRADER-001"),
4043 strategy_id: StrategyId::from("S-001"),
4044 instrument_id,
4045 order_side: OrderSide::Buy,
4046 order_type: OrderType::Limit,
4047 },
4048 );
4049
4050 let mut messages: Vec<serde_json::Value> = serde_json::from_str(include_str!(
4051 "../../test_data/ws_routed_spot_execution.json"
4052 ))
4053 .unwrap();
4054 messages[0]["result"]["order"]["order_state"] = ack_state.into();
4055 let mut events = Vec::new();
4056
4057 for _ in 0..2 {
4058 for index in sequence {
4059 if let Some(event) = handler
4060 .process_raw_message(&messages[index].to_string())
4061 .await
4062 {
4063 events.push(event);
4064 }
4065
4066 events.extend(handler.pending_outgoing.drain(..));
4067 }
4068 }
4069
4070 assert_eq!(events.len(), 2);
4071
4072 let accepted = match &events[0] {
4073 NautilusWsMessage::OrderAccepted(event) => event,
4074 other => panic!("Expected acceptance, received {other:?}"),
4075 };
4076
4077 let filled = match &events[1] {
4078 NautilusWsMessage::OrderFilled(event) => event,
4079 other => panic!("Expected fill, received {other:?}"),
4080 };
4081
4082 assert_eq!(accepted.trader_id, TraderId::from("TRADER-001"));
4083 assert_eq!(accepted.strategy_id, StrategyId::from("S-001"));
4084 assert_eq!(accepted.instrument_id, instrument_id);
4085 assert_eq!(accepted.client_order_id, client_order_id);
4086 assert_eq!(accepted.venue_order_id, VenueOrderId::from("CSR-ORDER-904"));
4087 assert_eq!(accepted.account_id, AccountId::from("DERIBIT-001"));
4088 assert_eq!(filled.trader_id, accepted.trader_id);
4089 assert_eq!(filled.strategy_id, accepted.strategy_id);
4090 assert_eq!(filled.instrument_id, instrument_id);
4091 assert_eq!(filled.client_order_id, client_order_id);
4092 assert_eq!(filled.venue_order_id, accepted.venue_order_id);
4093 assert_eq!(filled.account_id, accepted.account_id);
4094 assert_eq!(filled.trade_id, TradeId::from("CSR-TRADE-904"));
4095 assert_eq!(filled.order_side, OrderSide::Buy);
4096 assert_eq!(filled.order_type, OrderType::Limit);
4097 assert_eq!(filled.last_qty, Quantity::from("0.0042"));
4098 assert_eq!(filled.last_px, Price::from("45000.25"));
4099 assert_eq!(filled.currency, Currency::USDC());
4100 assert_eq!(filled.liquidity_side, LiquiditySide::Taker);
4101 assert_eq!(filled.commission, Some(Money::from("0.01911000 USDC")));
4102 assert_eq!(filled.ts_event, UnixNanos::from(1_787_011_200_500_000_000));
4103 assert_eq!(filled.position_id, None);
4104 assert!(!filled.reconciliation);
4105 }
4106
4107 #[rstest]
4108 #[tokio::test]
4109 async fn tracked_fast_fill_synthesizes_accepted_before_filled() {
4110 let mut handler = routing_test_handler();
4111 let client_order_id = ClientOrderId::from("O-19700101-000000-001-001-1");
4112 let instrument_id = InstrumentId::from("BTC-PERPETUAL.DERIBIT");
4113 handler.submitted_order_contexts.insert(
4114 client_order_id,
4115 OrderContext {
4116 client_order_id,
4117 trader_id: TraderId::from("TRADER-001"),
4118 strategy_id: StrategyId::from("S-001"),
4119 instrument_id,
4120 order_side: OrderSide::Buy,
4121 order_type: OrderType::Market,
4122 accepted: false,
4123 last_order_signature: None,
4124 },
4125 );
4126 handler.pending_requests.insert(
4127 42,
4128 PendingRequestType::Buy {
4129 client_order_id,
4130 trader_id: TraderId::from("TRADER-001"),
4131 strategy_id: StrategyId::from("S-001"),
4132 instrument_id,
4133 order_side: OrderSide::Buy,
4134 order_type: OrderType::Market,
4135 },
4136 );
4137 let response = serde_json::json!({
4138 "jsonrpc": "2.0",
4139 "id": 42,
4140 "result": { "order": order_data("filled", false), "trades": [] }
4141 });
4142
4143 handler.process_raw_message(&response.to_string()).await;
4144 assert!(handler.pending_outgoing.is_empty());
4145 assert!(
4146 !handler
4147 .terminal_order_contexts
4148 .get(&VenueOrderId::from("ETH-584830574"))
4149 .unwrap()
4150 .context
4151 .accepted
4152 );
4153
4154 handler
4155 .process_raw_message(&subscription(
4156 "user.trades.any.any.raw",
4157 &serde_json::json!([trade_data()]),
4158 ))
4159 .await;
4160
4161 assert!(matches!(
4162 handler.pending_outgoing.pop_front().unwrap(),
4163 NautilusWsMessage::OrderAccepted(event)
4164 if event.client_order_id == client_order_id
4165 ));
4166 assert!(matches!(
4167 handler.pending_outgoing.pop_front().unwrap(),
4168 NautilusWsMessage::OrderFilled(event)
4169 if event.client_order_id == client_order_id
4170 && event.trade_id.to_string() == "ETH-2696068"
4171 && event.order_side == OrderSide::Buy
4172 && event.order_type == OrderType::Market
4173 && event.last_qty.to_string() == "2"
4174 && event.last_px.to_string() == "203.8"
4175 && event.liquidity_side == LiquiditySide::Taker
4176 && event.commission == Some(Money::from("0.00073602 USDT"))
4177 ));
4178 assert!(handler.pending_outgoing.is_empty());
4179
4180 handler
4181 .process_raw_message(&subscription(
4182 "user.trades.any.any.raw",
4183 &serde_json::json!([trade_data()]),
4184 ))
4185 .await;
4186
4187 assert!(handler.pending_outgoing.is_empty());
4188 }
4189
4190 #[rstest]
4191 #[case::response_first(false)]
4192 #[case::subscription_first(true)]
4193 #[tokio::test]
4194 async fn submit_response_trades_use_tracked_event_path(
4195 #[case] subscription_first: bool,
4196 #[values("filled", "open")] trade_state: &str,
4197 ) {
4198 let mut handler = routing_test_handler();
4199 let client_order_id = ClientOrderId::from("O-19700101-000000-001-001-1");
4200 let context = OrderContext {
4201 client_order_id,
4202 trader_id: TraderId::from("TRADER-001"),
4203 strategy_id: StrategyId::from("S-001"),
4204 instrument_id: InstrumentId::from("BTC-PERPETUAL.DERIBIT"),
4205 order_side: OrderSide::Buy,
4206 order_type: OrderType::Market,
4207 accepted: false,
4208 last_order_signature: None,
4209 };
4210 handler
4211 .submitted_order_contexts
4212 .insert(client_order_id, context.clone());
4213 handler.pending_requests.insert(
4214 42,
4215 PendingRequestType::Buy {
4216 client_order_id,
4217 trader_id: context.trader_id,
4218 strategy_id: context.strategy_id,
4219 instrument_id: context.instrument_id,
4220 order_side: context.order_side,
4221 order_type: context.order_type,
4222 },
4223 );
4224
4225 let mut trade = trade_data();
4226 trade["state"] = serde_json::json!(trade_state);
4227 trade["amount"] = serde_json::json!(if trade_state == "filled" { 2 } else { 1 });
4228 let mut order = order_data(trade_state, false);
4229 order["filled_amount"] = trade["amount"].clone();
4230 let response = serde_json::json!({
4231 "jsonrpc": "2.0",
4232 "id": 42,
4233 "result": { "order": order, "trades": [trade.clone()] }
4234 });
4235 let trade_update = subscription("user.trades.any.any.raw", &serde_json::json!([trade]));
4236
4237 let (raw_tx, raw_rx) = tokio::sync::mpsc::unbounded_channel();
4238 let (out_tx, mut out_rx) = tokio::sync::mpsc::unbounded_channel();
4239 handler.raw_rx = raw_rx;
4240 handler.out_tx = out_tx;
4241 let response = response.to_string();
4242 let messages = if subscription_first {
4243 [trade_update, response]
4244 } else {
4245 [response, trade_update]
4246 };
4247
4248 for message in messages {
4249 raw_tx.send(Message::Text(message.into())).unwrap();
4250 }
4251
4252 raw_tx.send(Message::Text(RECONNECTED.into())).unwrap();
4253 let reconnected = tokio::time::timeout(std::time::Duration::from_secs(2), handler.next())
4254 .await
4255 .unwrap();
4256
4257 assert!(matches!(reconnected, Some(NautilusWsMessage::Reconnected)));
4258 assert!(matches!(
4259 out_rx.try_recv().unwrap(),
4260 NautilusWsMessage::OrderAccepted(event)
4261 if event.client_order_id == client_order_id
4262 ));
4263 assert!(matches!(
4264 out_rx.try_recv().unwrap(),
4265 NautilusWsMessage::OrderFilled(event)
4266 if event.client_order_id == client_order_id
4267 && event.trade_id.to_string() == "ETH-2696068"
4268 && event.last_qty.to_string() == if trade_state == "filled" { "2" } else { "1" }
4269 ));
4270 assert!(out_rx.try_recv().is_err());
4271 assert!(handler.pending_outgoing.is_empty());
4272 let venue_order_id = VenueOrderId::from("ETH-584830574");
4273 assert_eq!(
4274 handler
4275 .terminal_order_contexts
4276 .contains_key(&venue_order_id),
4277 trade_state == "filled",
4278 );
4279 assert_eq!(
4280 handler.order_contexts.contains_key(&venue_order_id),
4281 trade_state == "open",
4282 );
4283 assert!(
4284 !handler
4285 .submitted_order_contexts
4286 .contains_key(&client_order_id)
4287 );
4288 }
4289
4290 #[rstest]
4291 #[case::tracked(true)]
4292 #[case::external(false)]
4293 #[tokio::test]
4294 async fn trade_replays_after_reconnect_preserve_new_fills(#[case] tracked: bool) {
4295 let mut handler = routing_test_handler();
4296 let client_order_id = ClientOrderId::from("O-19700101-000000-001-001-1");
4297 let venue_order_id = VenueOrderId::from("ETH-584830574");
4298
4299 if tracked {
4300 handler.order_contexts.insert(
4301 venue_order_id,
4302 OrderContext {
4303 client_order_id,
4304 trader_id: TraderId::from("TRADER-001"),
4305 strategy_id: StrategyId::from("S-001"),
4306 instrument_id: InstrumentId::from("BTC-PERPETUAL.DERIBIT"),
4307 order_side: OrderSide::Buy,
4308 order_type: OrderType::Market,
4309 accepted: true,
4310 last_order_signature: None,
4311 },
4312 );
4313 }
4314
4315 let mut first_trade = trade_data();
4316 first_trade["amount"] = serde_json::json!(1);
4317 let mut second_trade = first_trade.clone();
4318 second_trade["trade_id"] = serde_json::json!("ETH-2696069");
4319 second_trade["price"] = serde_json::json!(204.1);
4320 second_trade["fee"] = serde_json::json!(0.00083602);
4321 let first_update = subscription(
4322 "user.trades.any.any.raw",
4323 &serde_json::json!([first_trade.clone(), first_trade.clone()]),
4324 );
4325 let replay_update = subscription(
4326 "user.trades.any.any.raw",
4327 &serde_json::json!([first_trade, second_trade.clone(), second_trade]),
4328 );
4329
4330 handler.process_raw_message(&first_update).await;
4331 let first = handler.pending_outgoing.pop_front().unwrap();
4332 assert!(handler.pending_outgoing.is_empty());
4333 let reconnected = handler.process_raw_message(RECONNECTED).await;
4334 handler.process_raw_message(&replay_update).await;
4335 let second = handler.pending_outgoing.pop_front().unwrap();
4336
4337 let fills: Vec<_> = [first, second]
4338 .into_iter()
4339 .enumerate()
4340 .map(|(index, message)| match message {
4341 NautilusWsMessage::OrderFilled(fill) => {
4342 assert!(tracked && index == 0);
4343 assert_eq!(fill.client_order_id, client_order_id);
4344 (
4345 fill.trade_id,
4346 fill.last_qty,
4347 fill.last_px,
4348 fill.commission.unwrap(),
4349 )
4350 }
4351 NautilusWsMessage::FillReports(mut reports) => {
4352 assert!(!tracked || index == 1);
4353 assert_eq!(reports.len(), 1);
4354 let report = reports.pop().unwrap();
4355 assert_eq!(report.client_order_id, Some(client_order_id));
4356 (
4357 report.trade_id,
4358 report.last_qty,
4359 report.last_px,
4360 report.commission,
4361 )
4362 }
4363 message => panic!("unexpected fill message: {message:?}"),
4364 })
4365 .collect();
4366
4367 assert!(matches!(reconnected, Some(NautilusWsMessage::Reconnected)));
4368 assert!(handler.pending_outgoing.is_empty());
4369 assert_eq!(
4370 fills,
4371 vec![
4372 (
4373 TradeId::from("ETH-2696068"),
4374 Quantity::from(1),
4375 Price::from("203.8"),
4376 Money::from("0.00073602 USDT")
4377 ),
4378 (
4379 TradeId::from("ETH-2696069"),
4380 Quantity::from(1),
4381 Price::from("204.1"),
4382 Money::from("0.00083602 USDT")
4383 ),
4384 ],
4385 );
4386 assert_eq!(
4387 handler
4388 .terminal_order_contexts
4389 .contains_key(&venue_order_id),
4390 tracked
4391 );
4392 assert!(!handler.order_contexts.contains_key(&venue_order_id));
4393 }
4394
4395 #[rstest]
4396 fn trade_dedup_is_scoped_to_venue_order() {
4397 let mut handler = routing_test_handler();
4398 let first_trade = trade_data();
4399 let mut second_trade = first_trade.clone();
4400 second_trade["order_id"] = serde_json::json!("ETH-584830575");
4401 let trades: Vec<DeribitUserTradeMsg> = serde_json::from_str(
4402 &serde_json::json!([first_trade.clone(), first_trade, second_trade]).to_string(),
4403 )
4404 .unwrap();
4405
4406 let messages = handler.route_user_trades(&trades, UnixNanos::default());
4407
4408 assert_eq!(messages.len(), 1);
4409
4410 let NautilusWsMessage::FillReports(reports) = &messages[0] else {
4411 panic!("expected external fill reports");
4412 };
4413
4414 assert_eq!(
4415 reports
4416 .iter()
4417 .map(|report| (report.venue_order_id, report.trade_id))
4418 .collect::<Vec<_>>(),
4419 vec![
4420 (
4421 VenueOrderId::from("ETH-584830574"),
4422 TradeId::from("ETH-2696068")
4423 ),
4424 (
4425 VenueOrderId::from("ETH-584830575"),
4426 TradeId::from("ETH-2696068")
4427 ),
4428 ],
4429 );
4430 }
4431
4432 #[rstest]
4433 #[tokio::test]
4434 async fn reconnect_preserves_submit_identity_before_response() {
4435 let mut handler = routing_test_handler();
4436 let client_order_id = ClientOrderId::from("O-19700101-000000-001-001-1");
4437 handler.submitted_order_contexts.insert(
4438 client_order_id,
4439 OrderContext {
4440 client_order_id,
4441 trader_id: TraderId::from("TRADER-001"),
4442 strategy_id: StrategyId::from("S-001"),
4443 instrument_id: InstrumentId::from("BTC-PERPETUAL.DERIBIT"),
4444 order_side: OrderSide::Buy,
4445 order_type: OrderType::Market,
4446 accepted: false,
4447 last_order_signature: None,
4448 },
4449 );
4450 handler
4451 .pending_requests
4452 .insert(42, PendingRequestType::Test);
4453
4454 handler.clear_state();
4455 handler
4456 .process_raw_message(&subscription(
4457 "user.orders.any.any.raw",
4458 &serde_json::json!([order_data("open", false)]),
4459 ))
4460 .await;
4461
4462 assert!(handler.pending_requests.is_empty());
4463 assert!(matches!(
4464 handler.pending_outgoing.pop_front().unwrap(),
4465 NautilusWsMessage::OrderAccepted(event)
4466 if event.client_order_id == client_order_id
4467 ));
4468 assert!(
4469 handler
4470 .order_contexts
4471 .get(&VenueOrderId::from("ETH-584830574"))
4472 .unwrap()
4473 .accepted
4474 );
4475 assert!(
4476 !handler
4477 .submitted_order_contexts
4478 .contains_key(&client_order_id)
4479 );
4480 }
4481
4482 #[tokio::test]
4483 async fn pending_submit_survives_replay_cache_eviction_pressure() {
4484 let mut handler = routing_test_handler();
4485 let client_order_id = ClientOrderId::from("O-19700101-000000-001-001-1");
4486 let instrument_id = InstrumentId::from("BTC-PERPETUAL.DERIBIT");
4487 handler.track_submit(
4488 1,
4489 OrderContext {
4490 client_order_id,
4491 trader_id: TraderId::from("TRADER-001"),
4492 strategy_id: StrategyId::from("S-001"),
4493 instrument_id,
4494 order_side: OrderSide::Buy,
4495 order_type: OrderType::Market,
4496 accepted: false,
4497 last_order_signature: None,
4498 },
4499 );
4500
4501 for seq in 2..=(REPLAY_CACHE_CAPACITY as u64 + 1) {
4502 let filler_id = ClientOrderId::from(format!("O-FILLER-{seq:05}"));
4503 handler.track_submit(
4504 seq,
4505 OrderContext {
4506 client_order_id: filler_id,
4507 trader_id: TraderId::from("TRADER-001"),
4508 strategy_id: StrategyId::from("S-001"),
4509 instrument_id,
4510 order_side: OrderSide::Buy,
4511 order_type: OrderType::Market,
4512 accepted: false,
4513 last_order_signature: None,
4514 },
4515 );
4516 }
4517
4518 assert!(
4519 handler
4520 .submitted_order_contexts
4521 .contains_key(&client_order_id)
4522 );
4523
4524 handler
4525 .process_raw_message(&subscription(
4526 "user.orders.any.any.raw",
4527 &serde_json::json!([order_data("open", false)]),
4528 ))
4529 .await;
4530
4531 assert!(matches!(
4532 handler.pending_outgoing.pop_front().unwrap(),
4533 NautilusWsMessage::OrderAccepted(event)
4534 if event.client_order_id == client_order_id
4535 ));
4536 assert!(
4537 handler
4538 .order_contexts
4539 .get(&VenueOrderId::from("ETH-584830574"))
4540 .unwrap()
4541 .accepted
4542 );
4543 assert!(
4544 !handler
4545 .submitted_order_contexts
4546 .contains_key(&client_order_id)
4547 );
4548 }
4549
4550 #[tokio::test]
4551 async fn active_order_survives_terminal_cache_eviction_pressure() {
4552 let mut handler = routing_test_handler();
4553 let venue_order_id = VenueOrderId::from("ETH-584830574");
4554 let client_order_id = ClientOrderId::from("O-19700101-000000-001-001-1");
4555 let instrument_id = InstrumentId::from("BTC-PERPETUAL.DERIBIT");
4556 handler.order_contexts.insert(
4557 venue_order_id,
4558 OrderContext {
4559 client_order_id,
4560 trader_id: TraderId::from("TRADER-001"),
4561 strategy_id: StrategyId::from("S-001"),
4562 instrument_id,
4563 order_side: OrderSide::Buy,
4564 order_type: OrderType::Market,
4565 accepted: false,
4566 last_order_signature: None,
4567 },
4568 );
4569
4570 for seq in 0..=REPLAY_CACHE_CAPACITY {
4571 let filler_id = VenueOrderId::from(format!("ETH-FILLER-{seq:05}"));
4572 let filler_client_id = ClientOrderId::from(format!("O-FILLER-{seq:05}"));
4573 handler.terminal_order_contexts.insert(
4574 filler_id,
4575 TerminalOrderContext {
4576 context: OrderContext {
4577 client_order_id: filler_client_id,
4578 trader_id: TraderId::from("TRADER-001"),
4579 strategy_id: StrategyId::from("S-001"),
4580 instrument_id,
4581 order_side: OrderSide::Buy,
4582 order_type: OrderType::Market,
4583 accepted: true,
4584 last_order_signature: None,
4585 },
4586 late_fills_as_reports: true,
4587 },
4588 );
4589 }
4590
4591 handler
4592 .process_raw_message(&subscription(
4593 "user.orders.any.any.raw",
4594 &serde_json::json!([order_data("open", false)]),
4595 ))
4596 .await;
4597
4598 assert!(matches!(
4599 handler.pending_outgoing.pop_front().unwrap(),
4600 NautilusWsMessage::OrderAccepted(event)
4601 if event.client_order_id == client_order_id
4602 ));
4603 assert!(
4604 handler
4605 .order_contexts
4606 .get(&venue_order_id)
4607 .unwrap()
4608 .accepted
4609 );
4610 }
4611
4612 #[tokio::test]
4613 async fn submitted_order_cancelled_before_bind_releases_pending_context() {
4614 let mut handler = routing_test_handler();
4615 let venue_order_id = VenueOrderId::from("ETH-584830574");
4616 let client_order_id = ClientOrderId::from("O-19700101-000000-001-001-1");
4617 handler.submitted_order_contexts.insert(
4618 client_order_id,
4619 OrderContext {
4620 client_order_id,
4621 trader_id: TraderId::from("TRADER-001"),
4622 strategy_id: StrategyId::from("S-001"),
4623 instrument_id: InstrumentId::from("BTC-PERPETUAL.DERIBIT"),
4624 order_side: OrderSide::Buy,
4625 order_type: OrderType::Market,
4626 accepted: false,
4627 last_order_signature: None,
4628 },
4629 );
4630
4631 handler
4632 .process_raw_message(&subscription(
4633 "user.orders.any.any.raw",
4634 &serde_json::json!([order_data("cancelled", false)]),
4635 ))
4636 .await;
4637
4638 assert!(matches!(
4639 handler.pending_outgoing.pop_front().unwrap(),
4640 NautilusWsMessage::OrderAccepted(event)
4641 if event.client_order_id == client_order_id
4642 ));
4643 assert!(matches!(
4644 handler.pending_outgoing.pop_front().unwrap(),
4645 NautilusWsMessage::OrderCanceled(event)
4646 if event.client_order_id == client_order_id
4647 ));
4648 assert!(
4649 !handler
4650 .submitted_order_contexts
4651 .contains_key(&client_order_id)
4652 );
4653 assert!(
4654 handler
4655 .terminal_order_contexts
4656 .contains_key(&venue_order_id)
4657 );
4658 }
4659
4660 #[rstest]
4661 #[case("cancelled")]
4662 #[case("expired")]
4663 #[tokio::test]
4664 async fn tracked_terminal_order_synthesizes_accepted_first(#[case] order_state: &str) {
4665 let mut handler = routing_test_handler();
4666 let venue_order_id = VenueOrderId::from("ETH-584830574");
4667 let client_order_id = ClientOrderId::from("O-19700101-000000-001-001-1");
4668 handler.order_contexts.insert(
4669 venue_order_id,
4670 OrderContext {
4671 client_order_id,
4672 trader_id: TraderId::from("TRADER-001"),
4673 strategy_id: StrategyId::from("S-001"),
4674 instrument_id: InstrumentId::from("BTC-PERPETUAL.DERIBIT"),
4675 order_side: OrderSide::Buy,
4676 order_type: OrderType::Market,
4677 accepted: false,
4678 last_order_signature: None,
4679 },
4680 );
4681
4682 handler
4683 .process_raw_message(&subscription(
4684 "user.orders.any.any.raw",
4685 &serde_json::json!([order_data(order_state, false)]),
4686 ))
4687 .await;
4688
4689 let accepted = handler.pending_outgoing.pop_front().unwrap();
4690 let terminal = handler.pending_outgoing.pop_front().unwrap();
4691 assert!(matches!(
4692 accepted,
4693 NautilusWsMessage::OrderAccepted(event)
4694 if event.client_order_id == client_order_id
4695 ));
4696 assert!(
4697 matches!(
4698 (order_state, terminal),
4699 ("cancelled", NautilusWsMessage::OrderCanceled(_))
4700 | ("expired", NautilusWsMessage::OrderExpired(_))
4701 ),
4702 "unexpected terminal message for {order_state}",
4703 );
4704 assert!(handler.pending_outgoing.is_empty());
4705 assert!(!handler.order_contexts.contains_key(&venue_order_id));
4706 }
4707
4708 #[rstest]
4709 #[case("filled")]
4710 #[case("open")]
4711 #[tokio::test]
4712 async fn late_fill_after_terminal_status_uses_report_recovery(
4713 #[case] trade_state: &str,
4714 #[values("cancelled", "expired", "rejected")] terminal_state: &str,
4715 #[values(None, Some("STALE-CLIENT-ID"))] label: Option<&str>,
4716 ) {
4717 let mut handler = routing_test_handler();
4718 let venue_order_id = VenueOrderId::from("ETH-584830574");
4719 let client_order_id = ClientOrderId::from("O-19700101-000000-001-001-1");
4720 handler.order_contexts.insert(
4721 venue_order_id,
4722 OrderContext {
4723 client_order_id,
4724 trader_id: TraderId::from("TRADER-001"),
4725 strategy_id: StrategyId::from("S-001"),
4726 instrument_id: InstrumentId::from("BTC-PERPETUAL.DERIBIT"),
4727 order_side: OrderSide::Buy,
4728 order_type: OrderType::Market,
4729 accepted: true,
4730 last_order_signature: None,
4731 },
4732 );
4733
4734 handler
4735 .process_raw_message(&subscription(
4736 "user.orders.any.any.raw",
4737 &serde_json::json!([order_data(terminal_state, false)]),
4738 ))
4739 .await;
4740 let mut trade = trade_data();
4741 trade["state"] = serde_json::Value::String(trade_state.to_string());
4742
4743 trade["label"] = match label {
4744 Some(label) => serde_json::json!(label),
4745 None => serde_json::Value::Null,
4746 };
4747
4748 handler
4749 .process_raw_message(&subscription(
4750 "user.trades.any.any.raw",
4751 &serde_json::json!([trade.clone(), trade.clone()]),
4752 ))
4753 .await;
4754
4755 match terminal_state {
4756 "cancelled" | "expired" => {
4757 let terminal = handler.pending_outgoing.pop_front().unwrap();
4758 assert!(
4759 matches!(
4760 (terminal_state, terminal),
4761 ("cancelled", NautilusWsMessage::OrderCanceled(_))
4762 | ("expired", NautilusWsMessage::OrderExpired(_))
4763 ),
4764 "unexpected terminal message for {terminal_state}",
4765 );
4766 }
4767 "rejected" => {}
4768 _ => unreachable!(),
4769 }
4770
4771 let message = handler.pending_outgoing.pop_front().unwrap();
4772
4773 let NautilusWsMessage::FillReports(reports) = message else {
4774 panic!("expected late fill reports, was {message:?}");
4775 };
4776
4777 assert_eq!(reports.len(), 1);
4778 let report = &reports[0];
4779 assert_eq!(report.account_id, AccountId::from("DERIBIT-001"));
4780 assert_eq!(
4781 report.instrument_id,
4782 InstrumentId::from("BTC-PERPETUAL.DERIBIT")
4783 );
4784 assert_eq!(report.venue_order_id, venue_order_id);
4785 assert_eq!(report.trade_id, TradeId::from("ETH-2696068"));
4786 assert_eq!(report.order_side, OrderSide::Buy);
4787 assert_eq!(report.last_qty, Quantity::from(2));
4788 assert_eq!(report.last_px, Price::from("203.8"));
4789 assert_eq!(report.commission, Money::from("0.00073602 USDT"));
4790 assert_eq!(report.liquidity_side, LiquiditySide::Taker);
4791 assert_eq!(report.client_order_id, Some(client_order_id));
4792 assert_eq!(report.venue_position_id, None);
4793 assert_eq!(report.avg_px, None);
4794 assert_eq!(report.ts_event, UnixNanos::from(1_590_480_712_800_000_000));
4795
4796 handler
4797 .process_raw_message(&subscription(
4798 "user.trades.any.any.raw",
4799 &serde_json::json!([trade]),
4800 ))
4801 .await;
4802
4803 assert!(handler.pending_outgoing.is_empty());
4804 assert!(!handler.order_contexts.contains_key(&venue_order_id));
4805 assert!(
4806 handler
4807 .terminal_order_contexts
4808 .get(&venue_order_id)
4809 .unwrap()
4810 .late_fills_as_reports
4811 );
4812 }
4813
4814 #[rstest]
4815 #[case("cancelled")]
4816 #[case("rejected")]
4817 #[tokio::test]
4818 async fn late_fill_after_command_response_uses_report_recovery(#[case] terminal_state: &str) {
4819 let mut handler = routing_test_handler();
4820 let venue_order_id = VenueOrderId::from("ETH-584830574");
4821 let client_order_id = ClientOrderId::from("O-19700101-000000-001-001-1");
4822 let trader_id = TraderId::from("TRADER-001");
4823 let strategy_id = StrategyId::from("S-001");
4824 let instrument_id = InstrumentId::from("BTC-PERPETUAL.DERIBIT");
4825 handler.order_contexts.insert(
4826 venue_order_id,
4827 OrderContext {
4828 client_order_id,
4829 trader_id,
4830 strategy_id,
4831 instrument_id,
4832 order_side: OrderSide::Buy,
4833 order_type: OrderType::Market,
4834 accepted: true,
4835 last_order_signature: None,
4836 },
4837 );
4838
4839 let pending = if terminal_state == "cancelled" {
4840 PendingRequestType::Cancel {
4841 venue_order_id: Some(venue_order_id),
4842 causation_id: None,
4843 client_order_id,
4844 trader_id,
4845 strategy_id,
4846 instrument_id,
4847 }
4848 } else {
4849 PendingRequestType::Buy {
4850 client_order_id,
4851 trader_id,
4852 strategy_id,
4853 instrument_id,
4854 order_side: OrderSide::Buy,
4855 order_type: OrderType::Market,
4856 }
4857 };
4858
4859 handler.pending_requests.insert(42, pending);
4860
4861 let result = if terminal_state == "cancelled" {
4862 order_data(terminal_state, false)
4863 } else {
4864 serde_json::json!({
4865 "order": order_data(terminal_state, false),
4866 "trades": []
4867 })
4868 };
4869
4870 let response = serde_json::json!({
4871 "jsonrpc": "2.0",
4872 "id": 42,
4873 "result": result,
4874 });
4875
4876 let terminal = handler.process_raw_message(&response.to_string()).await;
4877
4878 assert!(
4879 matches!(
4880 (terminal_state, terminal),
4881 ("cancelled", Some(NautilusWsMessage::OrderCanceled(_)))
4882 | ("rejected", Some(NautilusWsMessage::OrderRejected(_)))
4883 ),
4884 "unexpected terminal response for {terminal_state}",
4885 );
4886
4887 handler
4888 .process_raw_message(&subscription(
4889 "user.trades.any.any.raw",
4890 &serde_json::json!([trade_data()]),
4891 ))
4892 .await;
4893
4894 let message = handler.pending_outgoing.pop_front().unwrap();
4895
4896 let NautilusWsMessage::FillReports(reports) = message else {
4897 panic!("expected late fill reports, was {message:?}");
4898 };
4899
4900 assert_eq!(reports.len(), 1);
4901 assert_eq!(reports[0].venue_order_id, venue_order_id);
4902 assert_eq!(reports[0].client_order_id, Some(client_order_id));
4903 assert_eq!(reports[0].trade_id, TradeId::from("ETH-2696068"));
4904 assert!(handler.pending_outgoing.is_empty());
4905 assert!(!handler.order_contexts.contains_key(&venue_order_id));
4906 assert!(
4907 handler
4908 .terminal_order_contexts
4909 .get(&venue_order_id)
4910 .unwrap()
4911 .late_fills_as_reports
4912 );
4913 }
4914
4915 #[rstest]
4916 #[case::direct_stream("direct_stream")]
4917 #[case::venue_status("venue_status")]
4918 #[case::submit_response("submit_response")]
4919 #[tokio::test]
4920 async fn final_trade_routing_handles_batches_and_split_delivery(#[case] delivery: &str) {
4921 let mut handler = routing_test_handler();
4922 let venue_order_id = VenueOrderId::from("ETH-584830574");
4923 let client_order_id = ClientOrderId::from("O-19700101-000000-001-001-1");
4924 handler.order_contexts.insert(
4925 venue_order_id,
4926 OrderContext {
4927 client_order_id,
4928 trader_id: TraderId::from("TRADER-001"),
4929 strategy_id: StrategyId::from("S-001"),
4930 instrument_id: InstrumentId::from("BTC-PERPETUAL.DERIBIT"),
4931 order_side: OrderSide::Buy,
4932 order_type: OrderType::Market,
4933 accepted: true,
4934 last_order_signature: None,
4935 },
4936 );
4937
4938 let mut first_trade = trade_data();
4939 first_trade["amount"] = serde_json::json!(1);
4940 let mut second_trade = trade_data();
4941 second_trade["trade_id"] = serde_json::json!("ETH-2696069");
4942 second_trade["amount"] = serde_json::json!(1);
4943 second_trade["price"] = serde_json::json!(204.1);
4944 second_trade["fee"] = serde_json::json!(0.00083602);
4945
4946 match delivery {
4947 "direct_stream" => {
4948 handler
4949 .process_raw_message(&subscription(
4950 "user.trades.any.any.raw",
4951 &serde_json::json!([first_trade.clone(), second_trade.clone()]),
4952 ))
4953 .await;
4954 }
4955 "venue_status" => {
4956 handler
4957 .process_raw_message(&subscription(
4958 "user.orders.any.any.raw",
4959 &serde_json::json!([order_data("filled", false)]),
4960 ))
4961 .await;
4962 assert!(handler.pending_outgoing.is_empty());
4963 handler
4964 .process_raw_message(&subscription(
4965 "user.trades.any.any.raw",
4966 &serde_json::json!([first_trade.clone(), second_trade.clone()]),
4967 ))
4968 .await;
4969 }
4970 "submit_response" => {
4971 handler.pending_requests.insert(
4972 42,
4973 PendingRequestType::Buy {
4974 client_order_id,
4975 trader_id: TraderId::from("TRADER-001"),
4976 strategy_id: StrategyId::from("S-001"),
4977 instrument_id: InstrumentId::from("BTC-PERPETUAL.DERIBIT"),
4978 order_side: OrderSide::Buy,
4979 order_type: OrderType::Market,
4980 },
4981 );
4982
4983 let response = serde_json::json!({
4984 "jsonrpc": "2.0",
4985 "id": 42,
4986 "result": {
4987 "order": order_data("filled", false),
4988 "trades": [first_trade.clone()],
4989 }
4990 });
4991 handler.process_raw_message(&response.to_string()).await;
4992 handler
4993 .process_raw_message(&subscription(
4994 "user.trades.any.any.raw",
4995 &serde_json::json!([second_trade.clone()]),
4996 ))
4997 .await;
4998 }
4999 _ => unreachable!(),
5000 }
5001
5002 assert!(matches!(
5003 handler.pending_outgoing.pop_front().unwrap(),
5004 NautilusWsMessage::OrderFilled(event)
5005 if event.client_order_id == client_order_id
5006 && event.trade_id == TradeId::from("ETH-2696068")
5007 && event.last_qty == Quantity::from(1)
5008 && event.last_px == Price::from("203.8")
5009 && event.commission == Some(Money::from("0.00073602 USDT"))
5010 ));
5011 let second_message = handler.pending_outgoing.pop_front().unwrap();
5012
5013 match delivery {
5014 "direct_stream" | "venue_status" => {
5015 assert!(matches!(
5016 second_message,
5017 NautilusWsMessage::OrderFilled(event)
5018 if event.client_order_id == client_order_id
5019 && event.trade_id == TradeId::from("ETH-2696069")
5020 && event.last_qty == Quantity::from(1)
5021 && event.last_px == Price::from("204.1")
5022 && event.commission == Some(Money::from("0.00083602 USDT"))
5023 ));
5024 }
5025 "submit_response" => {
5026 let NautilusWsMessage::FillReports(reports) = second_message else {
5027 panic!("expected split-delivery fill report, was {second_message:?}");
5028 };
5029
5030 assert_eq!(reports.len(), 1);
5031 assert_eq!(reports[0].client_order_id, Some(client_order_id));
5032 assert_eq!(reports[0].trade_id, TradeId::from("ETH-2696069"));
5033 assert_eq!(reports[0].last_qty, Quantity::from(1));
5034 assert_eq!(reports[0].last_px, Price::from("204.1"));
5035 assert_eq!(reports[0].commission, Money::from("0.00083602 USDT"));
5036 }
5037 _ => unreachable!(),
5038 }
5039
5040 assert!(handler.pending_outgoing.is_empty());
5041 assert!(!handler.order_contexts.contains_key(&venue_order_id));
5042 assert!(
5043 handler
5044 .terminal_order_contexts
5045 .get(&venue_order_id)
5046 .unwrap()
5047 .late_fills_as_reports
5048 );
5049
5050 let mut late_trade = trade_data();
5051 late_trade["trade_id"] = serde_json::json!("ETH-2696070");
5052 handler
5053 .process_raw_message(&subscription(
5054 "user.trades.any.any.raw",
5055 &serde_json::json!([first_trade, late_trade]),
5056 ))
5057 .await;
5058
5059 let message = handler.pending_outgoing.pop_front().unwrap();
5060
5061 let NautilusWsMessage::FillReports(reports) = message else {
5062 panic!("expected post-terminal fill reports, was {message:?}");
5063 };
5064
5065 assert_eq!(reports.len(), 1);
5066 assert_eq!(reports[0].client_order_id, Some(client_order_id));
5067 assert_eq!(reports[0].trade_id, TradeId::from("ETH-2696070"));
5068 assert!(handler.pending_outgoing.is_empty());
5069 }
5070
5071 #[rstest]
5072 #[tokio::test]
5073 async fn venue_filled_status_before_trade_keeps_first_fill_typed() {
5074 let mut handler = routing_test_handler();
5075 let venue_order_id = VenueOrderId::from("ETH-584830574");
5076 let client_order_id = ClientOrderId::from("O-19700101-000000-001-001-1");
5077 handler.order_contexts.insert(
5078 venue_order_id,
5079 OrderContext {
5080 client_order_id,
5081 trader_id: TraderId::from("TRADER-001"),
5082 strategy_id: StrategyId::from("S-001"),
5083 instrument_id: InstrumentId::from("BTC-PERPETUAL.DERIBIT"),
5084 order_side: OrderSide::Buy,
5085 order_type: OrderType::Market,
5086 accepted: true,
5087 last_order_signature: None,
5088 },
5089 );
5090
5091 handler
5092 .process_raw_message(&subscription(
5093 "user.orders.any.any.raw",
5094 &serde_json::json!([order_data("filled", false)]),
5095 ))
5096 .await;
5097
5098 assert!(handler.pending_outgoing.is_empty());
5099 assert!(
5100 !handler
5101 .terminal_order_contexts
5102 .get(&venue_order_id)
5103 .unwrap()
5104 .late_fills_as_reports
5105 );
5106
5107 handler
5108 .process_raw_message(&subscription(
5109 "user.trades.any.any.raw",
5110 &serde_json::json!([trade_data()]),
5111 ))
5112 .await;
5113
5114 assert!(matches!(
5115 handler.pending_outgoing.pop_front().unwrap(),
5116 NautilusWsMessage::OrderFilled(event)
5117 if event.client_order_id == client_order_id
5118 && event.trade_id == TradeId::from("ETH-2696068")
5119 ));
5120 assert!(handler.pending_outgoing.is_empty());
5121 assert!(!handler.order_contexts.contains_key(&venue_order_id));
5122 assert!(
5123 handler
5124 .terminal_order_contexts
5125 .get(&venue_order_id)
5126 .unwrap()
5127 .late_fills_as_reports
5128 );
5129 }
5130
5131 #[rstest]
5132 #[tokio::test]
5133 async fn mixed_late_report_and_tracked_fill_preserve_trade_order() {
5134 let mut handler = routing_test_handler();
5135 let terminal_venue_order_id = VenueOrderId::from("ETH-584830574");
5136 let terminal_client_order_id = ClientOrderId::from("O-19700101-000000-001-001-1");
5137 handler.order_contexts.insert(
5138 terminal_venue_order_id,
5139 OrderContext {
5140 client_order_id: terminal_client_order_id,
5141 trader_id: TraderId::from("TRADER-001"),
5142 strategy_id: StrategyId::from("S-001"),
5143 instrument_id: InstrumentId::from("BTC-PERPETUAL.DERIBIT"),
5144 order_side: OrderSide::Buy,
5145 order_type: OrderType::Market,
5146 accepted: true,
5147 last_order_signature: None,
5148 },
5149 );
5150
5151 handler
5152 .process_raw_message(&subscription(
5153 "user.orders.any.any.raw",
5154 &serde_json::json!([order_data("cancelled", false)]),
5155 ))
5156 .await;
5157 assert!(matches!(
5158 handler.pending_outgoing.pop_front().unwrap(),
5159 NautilusWsMessage::OrderCanceled(_)
5160 ));
5161
5162 let active_venue_order_id = VenueOrderId::from("ETH-584830575");
5163 let active_client_order_id = ClientOrderId::from("O-19700101-000000-001-001-2");
5164 handler.order_contexts.insert(
5165 active_venue_order_id,
5166 OrderContext {
5167 client_order_id: active_client_order_id,
5168 trader_id: TraderId::from("TRADER-001"),
5169 strategy_id: StrategyId::from("S-001"),
5170 instrument_id: InstrumentId::from("BTC-PERPETUAL.DERIBIT"),
5171 order_side: OrderSide::Buy,
5172 order_type: OrderType::Market,
5173 accepted: true,
5174 last_order_signature: None,
5175 },
5176 );
5177
5178 let mut late_trade = trade_data();
5179 late_trade["state"] = serde_json::json!("open");
5180 let mut active_trade = trade_data();
5181 active_trade["order_id"] = serde_json::json!(active_venue_order_id.to_string());
5182 active_trade["trade_id"] = serde_json::json!("ETH-2696069");
5183 active_trade["label"] = serde_json::json!(active_client_order_id.to_string());
5184
5185 handler
5186 .process_raw_message(&subscription(
5187 "user.trades.any.any.raw",
5188 &serde_json::json!([late_trade, active_trade]),
5189 ))
5190 .await;
5191
5192 let late_message = handler.pending_outgoing.pop_front().unwrap();
5193
5194 let NautilusWsMessage::FillReports(reports) = late_message else {
5195 panic!("expected late report first, was {late_message:?}");
5196 };
5197
5198 assert_eq!(reports.len(), 1);
5199 assert_eq!(reports[0].venue_order_id, terminal_venue_order_id);
5200 assert_eq!(reports[0].client_order_id, Some(terminal_client_order_id));
5201 assert!(matches!(
5202 handler.pending_outgoing.pop_front().unwrap(),
5203 NautilusWsMessage::OrderFilled(event)
5204 if event.venue_order_id == active_venue_order_id
5205 && event.client_order_id == active_client_order_id
5206 && event.trade_id == TradeId::from("ETH-2696069")
5207 ));
5208 assert!(handler.pending_outgoing.is_empty());
5209 }
5210
5211 #[rstest]
5212 #[case::filled_terminal_first("filled", true)]
5213 #[case::cancelled_terminal_first("cancelled", true)]
5214 #[case::filled_response_first("filled", false)]
5215 #[case::cancelled_response_first("cancelled", false)]
5216 #[tokio::test]
5217 async fn delayed_open_submit_response_preserves_terminal_context(
5218 #[case] terminal_state: &str,
5219 #[case] terminal_first: bool,
5220 ) {
5221 let mut handler = routing_test_handler();
5222 let venue_order_id = VenueOrderId::from("ETH-584830574");
5223 let client_order_id = ClientOrderId::from("O-19700101-000000-001-001-1");
5224 handler.order_contexts.insert(
5225 venue_order_id,
5226 OrderContext {
5227 client_order_id,
5228 trader_id: TraderId::from("TRADER-001"),
5229 strategy_id: StrategyId::from("S-001"),
5230 instrument_id: InstrumentId::from("BTC-PERPETUAL.DERIBIT"),
5231 order_side: OrderSide::Buy,
5232 order_type: OrderType::Market,
5233 accepted: false,
5234 last_order_signature: None,
5235 },
5236 );
5237
5238 handler.pending_requests.insert(
5239 42,
5240 PendingRequestType::Buy {
5241 client_order_id,
5242 trader_id: TraderId::from("TRADER-001"),
5243 strategy_id: StrategyId::from("S-001"),
5244 instrument_id: InstrumentId::from("BTC-PERPETUAL.DERIBIT"),
5245 order_side: OrderSide::Buy,
5246 order_type: OrderType::Market,
5247 },
5248 );
5249
5250 let response = serde_json::json!({
5251 "jsonrpc": "2.0",
5252 "id": 42,
5253 "result": { "order": order_data("open", false), "trades": [] }
5254 })
5255 .to_string();
5256
5257 let terminal_update = if terminal_state == "filled" {
5258 subscription(
5259 "user.trades.any.any.raw",
5260 &serde_json::json!([trade_data()]),
5261 )
5262 } else {
5263 subscription(
5264 "user.orders.any.any.raw",
5265 &serde_json::json!([order_data("cancelled", false)]),
5266 )
5267 };
5268
5269 let mut new_trade = trade_data();
5270 new_trade["trade_id"] = serde_json::json!("ETH-2696069");
5271 let new_trade_update =
5272 subscription("user.trades.any.any.raw", &serde_json::json!([new_trade]));
5273 let mut events = Vec::new();
5274
5275 if terminal_first {
5276 handler.process_raw_message(&terminal_update).await;
5277 events.extend(handler.pending_outgoing.drain(..));
5278 assert!(
5279 handler
5280 .terminal_order_contexts
5281 .contains_key(&venue_order_id)
5282 );
5283
5284 let result = handler.process_raw_message(&response).await;
5285
5286 assert!(result.is_none());
5287 events.extend(handler.pending_outgoing.drain(..));
5288 assert!(!handler.order_contexts.contains_key(&venue_order_id));
5289 assert!(
5290 handler
5291 .terminal_order_contexts
5292 .contains_key(&venue_order_id)
5293 );
5294
5295 handler.process_raw_message(&terminal_update).await;
5297 events.extend(handler.pending_outgoing.drain(..));
5298
5299 handler.process_raw_message(&new_trade_update).await;
5301 events.extend(handler.pending_outgoing.drain(..));
5302 } else {
5303 let result = handler.process_raw_message(&response).await;
5304 events.extend(result);
5305 events.extend(handler.pending_outgoing.drain(..));
5306 handler.process_raw_message(&terminal_update).await;
5307 events.extend(handler.pending_outgoing.drain(..));
5308 }
5309
5310 assert!(!handler.order_contexts.contains_key(&venue_order_id));
5311 assert!(
5312 handler
5313 .terminal_order_contexts
5314 .get(&venue_order_id)
5315 .unwrap()
5316 .context
5317 .accepted
5318 );
5319
5320 let kinds: Vec<&str> = events
5321 .iter()
5322 .map(|event| match event {
5323 NautilusWsMessage::OrderAccepted(_) => "accepted",
5324 NautilusWsMessage::OrderFilled(_) => "filled",
5325 NautilusWsMessage::FillReports(_) => "fill_report",
5326 NautilusWsMessage::OrderCanceled(_) => "canceled",
5327 other => panic!("unexpected message: {other:?}"),
5328 })
5329 .collect();
5330
5331 let expected: &[&str] = match (terminal_state, terminal_first) {
5332 ("filled", true) => &["accepted", "filled", "fill_report"],
5333 ("cancelled", true) => &["accepted", "canceled", "fill_report"],
5334 ("filled", false) => &["accepted", "filled"],
5335 ("cancelled", false) => &["accepted", "canceled"],
5336 _ => unreachable!(),
5337 };
5338
5339 assert_eq!(kinds, expected);
5340
5341 if terminal_first {
5342 assert!(matches!(
5343 events.last(),
5344 Some(NautilusWsMessage::FillReports(reports))
5345 if reports.len() == 1
5346 && reports[0].trade_id == TradeId::from("ETH-2696069")
5347 && reports[0].client_order_id == Some(client_order_id)
5348 ));
5349 }
5350 }
5351
5352 #[rstest]
5353 #[tokio::test]
5354 async fn delayed_open_submit_response_after_fast_fill_keeps_terminal() {
5355 let mut handler = routing_test_handler();
5356 let venue_order_id = VenueOrderId::from("ETH-584830574");
5357 let client_order_id = ClientOrderId::from("O-19700101-000000-001-001-1");
5358
5359 let context = OrderContext {
5360 client_order_id,
5361 trader_id: TraderId::from("TRADER-001"),
5362 strategy_id: StrategyId::from("S-001"),
5363 instrument_id: InstrumentId::from("BTC-PERPETUAL.DERIBIT"),
5364 order_side: OrderSide::Buy,
5365 order_type: OrderType::Market,
5366 accepted: false,
5367 last_order_signature: None,
5368 };
5369
5370 handler
5371 .submitted_order_contexts
5372 .insert(client_order_id, context.clone());
5373 handler.pending_requests.insert(
5374 42,
5375 PendingRequestType::Buy {
5376 client_order_id,
5377 trader_id: context.trader_id,
5378 strategy_id: context.strategy_id,
5379 instrument_id: context.instrument_id,
5380 order_side: context.order_side,
5381 order_type: context.order_type,
5382 },
5383 );
5384
5385 let filled_response = serde_json::json!({
5386 "jsonrpc": "2.0",
5387 "id": 42,
5388 "result": { "order": order_data("filled", false), "trades": [] }
5389 });
5390 handler
5391 .process_raw_message(&filled_response.to_string())
5392 .await;
5393 assert!(
5394 !handler
5395 .terminal_order_contexts
5396 .get(&venue_order_id)
5397 .unwrap()
5398 .context
5399 .accepted
5400 );
5401
5402 handler.pending_requests.insert(
5404 43,
5405 PendingRequestType::Buy {
5406 client_order_id,
5407 trader_id: context.trader_id,
5408 strategy_id: context.strategy_id,
5409 instrument_id: context.instrument_id,
5410 order_side: context.order_side,
5411 order_type: context.order_type,
5412 },
5413 );
5414
5415 let open_response = serde_json::json!({
5416 "jsonrpc": "2.0",
5417 "id": 43,
5418 "result": { "order": order_data("open", false), "trades": [] }
5419 });
5420
5421 let result = handler
5422 .process_raw_message(&open_response.to_string())
5423 .await;
5424
5425 assert!(result.is_none());
5426 assert!(handler.pending_outgoing.is_empty());
5427 assert!(!handler.order_contexts.contains_key(&venue_order_id));
5428 assert!(
5429 !handler
5430 .terminal_order_contexts
5431 .get(&venue_order_id)
5432 .unwrap()
5433 .context
5434 .accepted
5435 );
5436
5437 handler
5439 .process_raw_message(&subscription(
5440 "user.trades.any.any.raw",
5441 &serde_json::json!([trade_data()]),
5442 ))
5443 .await;
5444
5445 assert!(matches!(
5446 handler.pending_outgoing.pop_front().unwrap(),
5447 NautilusWsMessage::OrderAccepted(event)
5448 if event.client_order_id == client_order_id
5449 ));
5450 assert!(matches!(
5451 handler.pending_outgoing.pop_front().unwrap(),
5452 NautilusWsMessage::OrderFilled(event)
5453 if event.client_order_id == client_order_id
5454 && event.trade_id == TradeId::from("ETH-2696068")
5455 ));
5456 assert!(handler.pending_outgoing.is_empty());
5457 assert!(!handler.order_contexts.contains_key(&venue_order_id));
5458 assert!(
5459 handler
5460 .terminal_order_contexts
5461 .get(&venue_order_id)
5462 .unwrap()
5463 .context
5464 .accepted
5465 );
5466 }
5467
5468 #[rstest]
5469 #[tokio::test]
5470 async fn tracked_order_uses_stored_client_id_when_label_changes() {
5471 let mut handler = routing_test_handler();
5472 let venue_order_id = VenueOrderId::from("ETH-584830574");
5473 let client_order_id = ClientOrderId::from("ORIGINAL-CLIENT-ID");
5474 handler.order_contexts.insert(
5475 venue_order_id,
5476 OrderContext {
5477 client_order_id,
5478 trader_id: TraderId::from("TRADER-001"),
5479 strategy_id: StrategyId::from("S-001"),
5480 instrument_id: InstrumentId::from("BTC-PERPETUAL.DERIBIT"),
5481 order_side: OrderSide::Buy,
5482 order_type: OrderType::Market,
5483 accepted: false,
5484 last_order_signature: None,
5485 },
5486 );
5487 let mut order = order_data("open", false);
5488 order["label"] = serde_json::Value::Null;
5489
5490 handler
5491 .process_raw_message(&subscription(
5492 "user.orders.any.any.raw",
5493 &serde_json::json!([order]),
5494 ))
5495 .await;
5496
5497 assert!(matches!(
5498 handler.pending_outgoing.pop_front().unwrap(),
5499 NautilusWsMessage::OrderAccepted(event)
5500 if event.client_order_id == client_order_id
5501 ));
5502 assert!(handler.pending_outgoing.is_empty());
5503 }
5504
5505 #[rstest]
5506 #[tokio::test]
5507 async fn subscription_accept_before_submit_response_is_not_duplicated() {
5508 let mut handler = routing_test_handler();
5509 let client_order_id = ClientOrderId::from("O-19700101-000000-001-001-1");
5510 handler.submitted_order_contexts.insert(
5511 client_order_id,
5512 OrderContext {
5513 client_order_id,
5514 trader_id: TraderId::from("TRADER-001"),
5515 strategy_id: StrategyId::from("S-001"),
5516 instrument_id: InstrumentId::from("BTC-PERPETUAL.DERIBIT"),
5517 order_side: OrderSide::Buy,
5518 order_type: OrderType::Market,
5519 accepted: false,
5520 last_order_signature: None,
5521 },
5522 );
5523 handler.pending_requests.insert(
5524 42,
5525 PendingRequestType::Buy {
5526 client_order_id,
5527 trader_id: TraderId::from("TRADER-001"),
5528 strategy_id: StrategyId::from("S-001"),
5529 instrument_id: InstrumentId::from("BTC-PERPETUAL.DERIBIT"),
5530 order_side: OrderSide::Buy,
5531 order_type: OrderType::Market,
5532 },
5533 );
5534
5535 handler
5536 .process_raw_message(&subscription(
5537 "user.orders.any.any.raw",
5538 &serde_json::json!([order_data("open", false)]),
5539 ))
5540 .await;
5541 let accepted = handler.pending_outgoing.pop_front().unwrap();
5542 let response = serde_json::json!({
5543 "jsonrpc": "2.0",
5544 "id": 42,
5545 "result": { "order": order_data("open", false), "trades": [] }
5546 });
5547 let duplicate = handler.process_raw_message(&response.to_string()).await;
5548 handler.clear_state();
5549 handler
5550 .process_raw_message(&subscription(
5551 "user.orders.any.any.raw",
5552 &serde_json::json!([order_data("open", false)]),
5553 ))
5554 .await;
5555
5556 assert!(matches!(accepted, NautilusWsMessage::OrderAccepted(_)));
5557 assert!(duplicate.is_none());
5558 assert!(handler.pending_outgoing.is_empty());
5559 assert!(
5560 handler
5561 .order_contexts
5562 .get(&VenueOrderId::from("ETH-584830574"))
5563 .unwrap()
5564 .accepted
5565 );
5566 }
5567
5568 #[rstest]
5569 #[tokio::test]
5570 async fn untracked_live_order_and_fill_use_report_paths() {
5571 let mut handler = routing_test_handler();
5572
5573 handler
5574 .process_raw_message(&subscription(
5575 "user.orders.any.any.raw",
5576 &serde_json::json!([order_data("open", false)]),
5577 ))
5578 .await;
5579 handler
5580 .process_raw_message(&subscription(
5581 "user.trades.any.any.raw",
5582 &serde_json::json!([trade_data()]),
5583 ))
5584 .await;
5585
5586 assert!(matches!(
5587 handler.pending_outgoing.pop_front().unwrap(),
5588 NautilusWsMessage::OrderStatusReports(reports) if reports.len() == 1
5589 ));
5590 assert!(matches!(
5591 handler.pending_outgoing.pop_front().unwrap(),
5592 NautilusWsMessage::FillReports(reports) if reports.len() == 1
5593 ));
5594 assert!(handler.pending_outgoing.is_empty());
5595 }
5596
5597 #[rstest]
5598 #[case::modify(false)]
5599 #[case::cancel(true)]
5600 #[tokio::test]
5601 async fn command_failure_preserves_causation_and_venue_identity(
5602 #[case] cancel: bool,
5603 #[values(false, true)] not_sent: bool,
5604 ) {
5605 let mut handler = routing_test_handler();
5606 handler.clock = Box::leak(Box::new(AtomicTime::new(false, UnixNanos::from(17))));
5607 let client_order_id = ClientOrderId::from("O-COMMAND-FAILURE");
5608 let trader_id = TraderId::from("TRADER-001");
5609 let strategy_id = StrategyId::from("S-001");
5610 let instrument_id = InstrumentId::from("BTC-PERPETUAL.DERIBIT");
5611 let venue_order_id = VenueOrderId::from("ETH-584830574");
5612 let causation_id = UUID4::new();
5613
5614 let message = if not_sent {
5615 let command = if cancel {
5616 HandlerCommand::Cancel {
5617 causation_id: Some(causation_id),
5618 params: DeribitCancelParams {
5619 order_id: venue_order_id.to_string(),
5620 },
5621 client_order_id,
5622 trader_id,
5623 strategy_id,
5624 instrument_id,
5625 }
5626 } else {
5627 HandlerCommand::Edit {
5628 causation_id: Some(causation_id),
5629 params: DeribitEditParams {
5630 order_id: venue_order_id.to_string(),
5631 amount: Decimal::from(2),
5632 price: Some(Decimal::from(205)),
5633 post_only: None,
5634 reject_post_only: None,
5635 reduce_only: None,
5636 trigger_price: None,
5637 },
5638 client_order_id,
5639 trader_id,
5640 strategy_id,
5641 instrument_id,
5642 }
5643 };
5644
5645 handler.process_command(command).await;
5646 handler
5647 .pending_outgoing
5648 .pop_front()
5649 .expect("pre-send failure publishes a denial")
5650 } else {
5651 let pending = if cancel {
5652 PendingRequestType::Cancel {
5653 venue_order_id: Some(venue_order_id),
5654 causation_id: Some(causation_id),
5655 client_order_id,
5656 trader_id,
5657 strategy_id,
5658 instrument_id,
5659 }
5660 } else {
5661 PendingRequestType::Edit {
5662 venue_order_id: Some(venue_order_id),
5663 causation_id: Some(causation_id),
5664 client_order_id,
5665 trader_id,
5666 strategy_id,
5667 instrument_id,
5668 }
5669 };
5670
5671 handler.pending_requests.insert(1, pending);
5672 let response = serde_json::json!({
5673 "jsonrpc": "2.0",
5674 "id": 1,
5675 "error": {"code": 10004, "message": "order_not_found", "data": null}
5676 });
5677 handler
5678 .process_raw_message(&response.to_string())
5679 .await
5680 .expect("venue refusal produces a rejection")
5681 };
5682
5683 let (event, cause, reason, ts_init) = match message {
5684 NautilusWsMessage::OrderModifyDenied(event) if not_sent && !cancel => (
5685 OrderEventAny::ModifyDenied(event),
5686 event.causation_id,
5687 event.reason,
5688 event.ts_init,
5689 ),
5690 NautilusWsMessage::OrderCancelDenied(event) if not_sent && cancel => (
5691 OrderEventAny::CancelDenied(event),
5692 event.causation_id,
5693 event.reason,
5694 event.ts_init,
5695 ),
5696 NautilusWsMessage::OrderModifyRejected(event) if !not_sent && !cancel => (
5697 OrderEventAny::ModifyRejected(event),
5698 event.causation_id,
5699 event.reason,
5700 event.ts_init,
5701 ),
5702 NautilusWsMessage::OrderCancelRejected(event) if !not_sent && cancel => (
5703 OrderEventAny::CancelRejected(event),
5704 event.causation_id,
5705 event.reason,
5706 event.ts_init,
5707 ),
5708 other => panic!("unexpected command outcome {other:?}"),
5709 };
5710
5711 assert_eq!(event.trader_id(), trader_id);
5712 assert_eq!(event.strategy_id(), strategy_id);
5713 assert_eq!(event.instrument_id(), instrument_id);
5714 assert_eq!(event.client_order_id(), client_order_id);
5715 assert_eq!(event.venue_order_id(), Some(venue_order_id));
5716 assert_eq!(event.account_id(), Some(AccountId::from("DERIBIT-001")));
5717 assert_eq!(event.ts_event(), UnixNanos::from(17));
5718 assert_eq!(ts_init, UnixNanos::from(17));
5719 assert_eq!(cause, Some(causation_id));
5720 assert_eq!(
5721 reason.as_str(),
5722 if not_sent {
5723 "not connected"
5724 } else {
5725 "order_not_found"
5726 }
5727 );
5728 assert!(handler.pending_requests.is_empty());
5729 assert!(handler.pending_outgoing.is_empty());
5730 }
5731
5732 #[rstest]
5733 #[case::modify(false)]
5734 #[case::cancel(true)]
5735 #[tokio::test]
5736 async fn ambiguous_venue_code_emits_no_command_event(#[case] cancel: bool) {
5737 let mut handler = routing_test_handler();
5738 let client_order_id = ClientOrderId::from("O-AMBIGUOUS");
5739
5740 let pending = if cancel {
5741 PendingRequestType::Cancel {
5742 venue_order_id: Some(VenueOrderId::from("ETH-584830574")),
5743 causation_id: Some(UUID4::new()),
5744 client_order_id,
5745 trader_id: TraderId::from("TRADER-001"),
5746 strategy_id: StrategyId::from("S-001"),
5747 instrument_id: InstrumentId::from("BTC-PERPETUAL.DERIBIT"),
5748 }
5749 } else {
5750 PendingRequestType::Edit {
5751 venue_order_id: Some(VenueOrderId::from("ETH-584830574")),
5752 causation_id: Some(UUID4::new()),
5753 client_order_id,
5754 trader_id: TraderId::from("TRADER-001"),
5755 strategy_id: StrategyId::from("S-001"),
5756 instrument_id: InstrumentId::from("BTC-PERPETUAL.DERIBIT"),
5757 }
5758 };
5759
5760 handler.pending_requests.insert(1, pending);
5761 let message = handler
5762 .process_raw_message(&load_test_json("ws_error.json"))
5763 .await;
5764
5765 assert!(message.is_none());
5766 assert!(handler.pending_requests.is_empty());
5767 assert!(handler.pending_outgoing.is_empty());
5768 }
5769
5770 #[rstest]
5771 #[tokio::test]
5772 async fn edit_response_without_tracked_context_uses_report_path() {
5773 let mut handler = routing_test_handler();
5774 handler.pending_requests.insert(
5775 42,
5776 PendingRequestType::Edit {
5777 venue_order_id: None,
5778 causation_id: None,
5779 client_order_id: ClientOrderId::from("UNKNOWN-CLIENT-ID"),
5780 trader_id: TraderId::from("TRADER-001"),
5781 strategy_id: StrategyId::from("S-001"),
5782 instrument_id: InstrumentId::from("BTC-PERPETUAL.DERIBIT"),
5783 },
5784 );
5785 let response = serde_json::json!({
5786 "jsonrpc": "2.0",
5787 "id": 42,
5788 "result": { "order": order_data("open", true), "trades": [trade_data()] }
5789 });
5790
5791 let message = handler.process_raw_message(&response.to_string()).await;
5792 let fill = handler.pending_outgoing.pop_front().unwrap();
5793
5794 assert!(matches!(
5795 message,
5796 Some(NautilusWsMessage::OrderStatusReports(reports)) if reports.len() == 1
5797 ));
5798 assert!(matches!(
5799 fill,
5800 NautilusWsMessage::FillReports(reports) if reports.len() == 1
5801 ));
5802 assert!(handler.order_contexts.is_empty());
5803 assert!(handler.pending_outgoing.is_empty());
5804 }
5805
5806 #[rstest]
5807 #[tokio::test]
5808 async fn tracked_edit_response_routes_fill_and_deduplicates_subscription_echo() {
5809 let mut handler = routing_test_handler();
5810 let venue_order_id = VenueOrderId::from("ETH-584830574");
5811 let client_order_id = ClientOrderId::from("O-19700101-000000-001-001-1");
5812 handler.order_contexts.insert(
5813 venue_order_id,
5814 OrderContext {
5815 client_order_id,
5816 trader_id: TraderId::from("TRADER-001"),
5817 strategy_id: StrategyId::from("S-001"),
5818 instrument_id: InstrumentId::from("BTC-PERPETUAL.DERIBIT"),
5819 order_side: OrderSide::Buy,
5820 order_type: OrderType::Market,
5821 accepted: true,
5822 last_order_signature: None,
5823 },
5824 );
5825 handler.pending_requests.insert(
5826 42,
5827 PendingRequestType::Edit {
5828 venue_order_id: None,
5829 causation_id: None,
5830 client_order_id,
5831 trader_id: TraderId::from("TRADER-001"),
5832 strategy_id: StrategyId::from("S-001"),
5833 instrument_id: InstrumentId::from("BTC-PERPETUAL.DERIBIT"),
5834 },
5835 );
5836 let response = serde_json::json!({
5837 "jsonrpc": "2.0",
5838 "id": 42,
5839 "result": { "order": order_data("open", true), "trades": [trade_data()] }
5840 });
5841
5842 let updated = handler.process_raw_message(&response.to_string()).await;
5843 let filled = handler.pending_outgoing.pop_front().unwrap();
5844 handler
5845 .process_raw_message(&subscription(
5846 "user.orders.any.any.raw",
5847 &serde_json::json!([order_data("open", true)]),
5848 ))
5849 .await;
5850
5851 assert!(matches!(
5852 updated,
5853 Some(NautilusWsMessage::OrderUpdated(event))
5854 if event.client_order_id == client_order_id
5855 ));
5856 assert!(matches!(
5857 filled,
5858 NautilusWsMessage::OrderFilled(event)
5859 if event.client_order_id == client_order_id
5860 ));
5861 assert!(handler.pending_outgoing.is_empty());
5862 assert!(!handler.order_contexts.contains_key(&venue_order_id));
5863 assert!(
5864 handler
5865 .terminal_order_contexts
5866 .get(&venue_order_id)
5867 .unwrap()
5868 .context
5869 .last_order_signature
5870 .is_some(),
5871 );
5872 }
5873
5874 #[rstest]
5875 #[tokio::test]
5876 async fn subscription_edit_echo_before_response_is_not_duplicated() {
5877 let mut handler = routing_test_handler();
5878 let venue_order_id = VenueOrderId::from("ETH-584830574");
5879 let client_order_id = ClientOrderId::from("O-19700101-000000-001-001-1");
5880 handler.order_contexts.insert(
5881 venue_order_id,
5882 OrderContext {
5883 client_order_id,
5884 trader_id: TraderId::from("TRADER-001"),
5885 strategy_id: StrategyId::from("S-001"),
5886 instrument_id: InstrumentId::from("BTC-PERPETUAL.DERIBIT"),
5887 order_side: OrderSide::Buy,
5888 order_type: OrderType::Market,
5889 accepted: true,
5890 last_order_signature: None,
5891 },
5892 );
5893 handler.pending_requests.insert(
5894 42,
5895 PendingRequestType::Edit {
5896 venue_order_id: None,
5897 causation_id: None,
5898 client_order_id,
5899 trader_id: TraderId::from("TRADER-001"),
5900 strategy_id: StrategyId::from("S-001"),
5901 instrument_id: InstrumentId::from("BTC-PERPETUAL.DERIBIT"),
5902 },
5903 );
5904 handler
5905 .process_raw_message(&subscription(
5906 "user.orders.any.any.raw",
5907 &serde_json::json!([order_data("open", true)]),
5908 ))
5909 .await;
5910 let updated = handler.pending_outgoing.pop_front().unwrap();
5911 let response = serde_json::json!({
5912 "jsonrpc": "2.0",
5913 "id": 42,
5914 "result": { "order": order_data("open", true), "trades": [trade_data()] }
5915 });
5916
5917 let duplicate = handler.process_raw_message(&response.to_string()).await;
5918 let filled = handler.pending_outgoing.pop_front().unwrap();
5919
5920 assert!(matches!(
5921 updated,
5922 NautilusWsMessage::OrderUpdated(event)
5923 if event.client_order_id == client_order_id
5924 ));
5925 assert!(duplicate.is_none());
5926 assert!(matches!(
5927 filled,
5928 NautilusWsMessage::OrderFilled(event)
5929 if event.client_order_id == client_order_id
5930 ));
5931 assert!(handler.pending_outgoing.is_empty());
5932 }
5933
5934 #[rstest]
5935 #[case::new_trade(true)]
5936 #[case::repeated_trade(false)]
5937 #[tokio::test]
5938 async fn delayed_edit_response_keeps_partial_fill_terminal(#[case] new_trade: bool) {
5939 let mut handler = routing_test_handler();
5940 let venue_order_id = VenueOrderId::from("ETH-584830574");
5941 let client_order_id = ClientOrderId::from("O-19700101-000000-001-001-1");
5942 handler.order_contexts.insert(
5943 venue_order_id,
5944 OrderContext {
5945 client_order_id,
5946 trader_id: TraderId::from("TRADER-001"),
5947 strategy_id: StrategyId::from("S-001"),
5948 instrument_id: InstrumentId::from("BTC-PERPETUAL.DERIBIT"),
5949 order_side: OrderSide::Buy,
5950 order_type: OrderType::Market,
5951 accepted: true,
5952 last_order_signature: None,
5953 },
5954 );
5955 handler
5956 .process_raw_message(&subscription(
5957 "user.trades.any.any.raw",
5958 &serde_json::json!([trade_data()]),
5959 ))
5960 .await;
5961 handler.pending_outgoing.clear();
5962 handler.pending_requests.insert(
5963 42,
5964 PendingRequestType::Edit {
5965 venue_order_id: None,
5966 causation_id: None,
5967 client_order_id,
5968 trader_id: TraderId::from("TRADER-001"),
5969 strategy_id: StrategyId::from("S-001"),
5970 instrument_id: InstrumentId::from("BTC-PERPETUAL.DERIBIT"),
5971 },
5972 );
5973 let mut partial_trade = trade_data();
5974 partial_trade["state"] = serde_json::Value::String("open".to_string());
5975 if new_trade {
5976 partial_trade["trade_id"] = serde_json::json!("ETH-2696069");
5977 }
5978
5979 let response = serde_json::json!({
5980 "jsonrpc": "2.0",
5981 "id": 42,
5982 "result": { "order": order_data("open", true), "trades": [partial_trade] }
5983 });
5984
5985 let updated = handler.process_raw_message(&response.to_string()).await;
5986 let filled = handler.pending_outgoing.pop_front();
5987
5988 assert!(updated.is_none());
5989
5990 match filled {
5991 Some(NautilusWsMessage::FillReports(reports)) => {
5992 assert!(new_trade);
5993 assert_eq!(reports.len(), 1);
5994 assert_eq!(reports[0].client_order_id, Some(client_order_id));
5995 assert_eq!(reports[0].trade_id, TradeId::from("ETH-2696069"));
5996 }
5997 None => assert!(!new_trade),
5998 message => panic!("unexpected fill message: {message:?}"),
5999 }
6000
6001 assert!(!handler.order_contexts.contains_key(&venue_order_id));
6002 assert!(
6003 handler
6004 .terminal_order_contexts
6005 .contains_key(&venue_order_id)
6006 );
6007 assert!(handler.pending_outgoing.is_empty());
6008 }
6009
6010 #[rstest]
6011 #[tokio::test]
6012 async fn tracked_replaced_order_emits_updated_event() {
6013 let mut handler = routing_test_handler();
6014 let venue_order_id = VenueOrderId::from("ETH-584830574");
6015 let client_order_id = ClientOrderId::from("O-19700101-000000-001-001-1");
6016 handler.order_contexts.insert(
6017 venue_order_id,
6018 OrderContext {
6019 client_order_id,
6020 trader_id: TraderId::from("TRADER-001"),
6021 strategy_id: StrategyId::from("S-001"),
6022 instrument_id: InstrumentId::from("BTC-PERPETUAL.DERIBIT"),
6023 order_side: OrderSide::Buy,
6024 order_type: OrderType::Market,
6025 accepted: true,
6026 last_order_signature: None,
6027 },
6028 );
6029
6030 handler
6031 .process_raw_message(&subscription(
6032 "user.orders.any.any.raw",
6033 &serde_json::json!([order_data("open", true)]),
6034 ))
6035 .await;
6036
6037 assert!(matches!(
6038 handler.pending_outgoing.pop_front().unwrap(),
6039 NautilusWsMessage::OrderUpdated(event)
6040 if event.client_order_id == client_order_id
6041 ));
6042
6043 let mut partial_fill = order_data("open", true);
6044 partial_fill["filled_amount"] = serde_json::json!(1.0);
6045 partial_fill["last_update_timestamp"] = serde_json::json!(1_590_480_712_900_u64);
6046 handler
6047 .process_raw_message(&subscription(
6048 "user.orders.any.any.raw",
6049 &serde_json::json!([partial_fill]),
6050 ))
6051 .await;
6052
6053 assert!(handler.pending_outgoing.is_empty());
6054 }
6055
6056 #[rstest]
6057 #[tokio::test]
6058 async fn unaccepted_amendment_synthesizes_accepted_first() {
6059 let mut handler = routing_test_handler();
6060 let venue_order_id = VenueOrderId::from("ETH-584830574");
6061 let client_order_id = ClientOrderId::from("O-19700101-000000-001-001-1");
6062 handler.order_contexts.insert(
6063 venue_order_id,
6064 OrderContext {
6065 client_order_id,
6066 trader_id: TraderId::from("TRADER-001"),
6067 strategy_id: StrategyId::from("S-001"),
6068 instrument_id: InstrumentId::from("BTC-PERPETUAL.DERIBIT"),
6069 order_side: OrderSide::Buy,
6070 order_type: OrderType::Market,
6071 accepted: false,
6072 last_order_signature: None,
6073 },
6074 );
6075
6076 handler
6077 .process_raw_message(&subscription(
6078 "user.orders.any.any.raw",
6079 &serde_json::json!([order_data("open", true)]),
6080 ))
6081 .await;
6082
6083 assert!(matches!(
6084 handler.pending_outgoing.pop_front().unwrap(),
6085 NautilusWsMessage::OrderAccepted(event)
6086 if event.client_order_id == client_order_id
6087 ));
6088 assert!(matches!(
6089 handler.pending_outgoing.pop_front().unwrap(),
6090 NautilusWsMessage::OrderUpdated(event)
6091 if event.client_order_id == client_order_id
6092 ));
6093 assert!(handler.order_contexts[&venue_order_id].accepted);
6094 assert!(handler.pending_outgoing.is_empty());
6095 }
6096
6097 const BOOK_CHANNEL: &str = "book.BTC-PERPETUAL.100ms";
6098 const GROUPED_CHANNEL: &str = "book.BTC-PERPETUAL.none.10.100ms";
6099
6100 const UNCONVERTIBLE_PRICE: f64 = 1e20;
6102
6103 fn book_message(
6104 msg_type: &str,
6105 change_id: u64,
6106 prev_change_id: Option<u64>,
6107 bid_price: f64,
6108 ) -> String {
6109 subscription(
6110 BOOK_CHANNEL,
6111 &serde_json::json!({
6112 "type": msg_type,
6113 "instrument_name": "BTC-PERPETUAL",
6114 "timestamp": 1_700_000_000_000_u64,
6115 "change_id": change_id,
6116 "prev_change_id": prev_change_id,
6117 "bids": [["new", bid_price, 10.0]],
6118 "asks": [],
6119 }),
6120 )
6121 }
6122
6123 fn grouped_book_message(change_id: u64, bid_price: f64) -> String {
6125 subscription(
6126 GROUPED_CHANNEL,
6127 &serde_json::json!({
6128 "instrument_name": "BTC-PERPETUAL",
6129 "timestamp": 1_700_000_000_000_u64,
6130 "change_id": change_id,
6131 "bids": [[bid_price, 10.0]],
6132 "asks": [],
6133 }),
6134 )
6135 }
6136
6137 async fn book_test_handler() -> (
6138 DeribitWsFeedHandler,
6139 tokio::sync::mpsc::UnboundedReceiver<HandlerCommand>,
6140 ) {
6141 let mut handler = routing_test_handler();
6142 let (cmd_tx, cmd_rx) = tokio::sync::mpsc::unbounded_channel();
6143 handler.set_book_sync(cmd_tx, Duration::from_secs(10), Duration::from_secs(120));
6144 for channel in [
6145 BOOK_CHANNEL,
6146 "book.ETH-PERPETUAL.100ms",
6147 "trades.BTC-PERPETUAL.100ms",
6148 ] {
6149 subscribe_channel(&mut handler, channel).await;
6150 }
6151
6152 (handler, cmd_rx)
6153 }
6154
6155 async fn subscribe_channel(handler: &mut DeribitWsFeedHandler, channel: &str) {
6156 handler.subscriptions_state.mark_subscribe(channel);
6157 handler.subscriptions_state.add_reference(channel);
6158 handler
6159 .process_command(HandlerCommand::Subscribe {
6160 channels: vec![channel.to_owned()],
6161 })
6162 .await;
6163
6164 let requests: Vec<(u64, Vec<String>)> = handler
6165 .pending_requests
6166 .iter()
6167 .filter_map(|(id, request)| match request {
6168 PendingRequestType::Subscribe { channels } => Some((*id, channels.clone())),
6169 _ => None,
6170 })
6171 .collect();
6172
6173 for (id, channels) in requests {
6174 let ack = serde_json::json!({"jsonrpc": "2.0", "id": id, "result": channels});
6175 handler.process_raw_message(&ack.to_string()).await;
6176 }
6177 }
6178
6179 async fn next_recover_command(
6180 handler: &mut DeribitWsFeedHandler,
6181 cmd_rx: &mut tokio::sync::mpsc::UnboundedReceiver<HandlerCommand>,
6182 ) -> HandlerCommand {
6183 let work = handler.book_sync.work.next();
6184 tokio::pin!(work);
6185
6186 tokio::select! {
6187 cmd = cmd_rx.recv() => cmd.expect("recovery sends its replacement command"),
6188 _ = &mut work => panic!("recovery ended without replacement"),
6189 }
6190 }
6191
6192 fn pending_unsubscribe_channels(handler: &DeribitWsFeedHandler) -> Vec<Vec<String>> {
6193 handler
6194 .pending_requests
6195 .values()
6196 .filter_map(|request| match request {
6197 PendingRequestType::Unsubscribe { channels } => Some(channels.clone()),
6198 _ => None,
6199 })
6200 .collect()
6201 }
6202
6203 fn pending_subscribe_channels(handler: &DeribitWsFeedHandler) -> Vec<Vec<String>> {
6204 handler
6205 .pending_requests
6206 .values()
6207 .filter_map(|request| match request {
6208 PendingRequestType::Subscribe { channels } => Some(channels.clone()),
6209 _ => None,
6210 })
6211 .collect()
6212 }
6213
6214 #[rstest]
6215 #[tokio::test]
6216 async fn book_sequence_gap_starts_recovery_and_resubscribes() {
6217 let (mut handler, mut cmd_rx) = book_test_handler().await;
6218
6219 let snapshot = handler
6220 .process_raw_message(&book_message("snapshot", 100, None, 42500.0))
6221 .await;
6222 let contiguous = handler
6223 .process_raw_message(&book_message("change", 101, Some(100), 42499.5))
6224 .await;
6225
6226 assert!(matches!(
6227 snapshot,
6228 Some(NautilusWsMessage::Deltas(deltas)) if deltas.sequence == 100
6229 ));
6230 assert!(matches!(
6231 contiguous,
6232 Some(NautilusWsMessage::Deltas(deltas)) if deltas.sequence == 101
6233 ));
6234 assert!(handler.book_sync.work.is_empty());
6235
6236 let gap = handler
6237 .process_raw_message(&book_message("change", 103, Some(102), 42499.0))
6238 .await;
6239
6240 assert!(gap.is_none());
6241 assert_eq!(handler.book_sync.work.len(), 1);
6242
6243 let command = next_recover_command(&mut handler, &mut cmd_rx).await;
6244 handler.process_command(command).await;
6245
6246 assert_eq!(
6247 pending_unsubscribe_channels(&handler),
6248 vec![vec![BOOK_CHANNEL.to_string()]]
6249 );
6250
6251 let unsubscribe_id = handler
6252 .pending_requests
6253 .iter()
6254 .find_map(|(id, request)| {
6255 matches!(request, PendingRequestType::Unsubscribe { .. }).then_some(*id)
6256 })
6257 .unwrap();
6258
6259 let ack = serde_json::json!({
6260 "jsonrpc": "2.0",
6261 "id": unsubscribe_id,
6262 "result": [BOOK_CHANNEL],
6263 });
6264 handler.process_raw_message(&ack.to_string()).await;
6265
6266 assert_eq!(
6267 pending_subscribe_channels(&handler),
6268 vec![vec![BOOK_CHANNEL.to_string()]]
6269 );
6270
6271 let subscribe_id = handler
6272 .pending_requests
6273 .iter()
6274 .find_map(|(id, request)| {
6275 matches!(request, PendingRequestType::Subscribe { .. }).then_some(*id)
6276 })
6277 .unwrap();
6278
6279 let ack = serde_json::json!({
6280 "jsonrpc": "2.0",
6281 "id": subscribe_id,
6282 "result": [BOOK_CHANNEL],
6283 });
6284 handler.process_raw_message(&ack.to_string()).await;
6285
6286 let recovered = handler
6287 .process_raw_message(&book_message("snapshot", 200, None, 42500.0))
6288 .await;
6289
6290 assert!(matches!(
6291 recovered,
6292 Some(NautilusWsMessage::Deltas(deltas)) if deltas.sequence == 200
6293 ));
6294 }
6295
6296 #[rstest]
6297 #[tokio::test]
6298 async fn first_delta_without_snapshot_is_suppressed() {
6299 let (mut handler, _cmd_rx) = book_test_handler().await;
6300
6301 let delta = handler
6302 .process_raw_message(&book_message("change", 101, Some(100), 42499.5))
6303 .await;
6304
6305 assert!(delta.is_none());
6306 assert!(handler.book_sync.work.is_empty());
6308 }
6309
6310 #[tokio::test]
6311 async fn grouped_book_waits_for_depth_subscription_update() {
6312 let (mut handler, _cmd_rx) = book_test_handler().await;
6313 subscribe_channel(&mut handler, GROUPED_CHANNEL).await;
6314 handler
6315 .book_depth_subs
6316 .lock()
6317 .await
6318 .add_reference(GROUPED_CHANNEL);
6319 handler
6320 .process_raw_message(&book_message("snapshot", 100, None, 42500.0))
6321 .await;
6322 let depth_subs = Arc::clone(&handler.book_depth_subs);
6323 let subscriptions = handler.subscriptions_state.clone();
6324 let depth_guard = depth_subs.lock().await;
6325 depth_guard.add_reference(GROUPED_CHANNEL);
6326 let message = grouped_book_message(999, 89532.5);
6327 let mut processing = Box::pin(handler.process_raw_message(&message));
6328
6329 assert!(futures_util::poll!(processing.as_mut()).is_pending());
6330
6331 subscriptions.add_reference(GROUPED_CHANNEL);
6332 drop(depth_guard);
6333 let output = processing.await.unwrap();
6334
6335 let NautilusWsMessage::Data(data) = output else {
6336 panic!("expected grouped depth");
6337 };
6338
6339 let [Data::BookDepth(depth)] = data.as_slice() else {
6340 panic!("expected only depth data");
6341 };
6342
6343 assert_eq!(depth.sequence, 999);
6344 assert!(handler.pending_outgoing.is_empty());
6345 assert!(handler.book_sync.work.is_empty());
6346
6347 let contiguous = handler
6348 .process_raw_message(&book_message("change", 101, Some(100), 42499.5))
6349 .await;
6350
6351 assert!(matches!(
6352 contiguous,
6353 Some(NautilusWsMessage::Deltas(deltas)) if deltas.sequence == 101
6354 ));
6355 }
6356
6357 #[rstest]
6358 #[case::depth_only(false)]
6359 #[case::shared_grouped_channel(true)]
6360 #[tokio::test]
6361 async fn grouped_depth_does_not_change_raw_book_sequence(#[case] grouped_deltas: bool) {
6362 let (mut handler, _cmd_rx) = book_test_handler().await;
6363 subscribe_channel(&mut handler, GROUPED_CHANNEL).await;
6364 handler
6365 .book_depth_subs
6366 .lock()
6367 .await
6368 .add_reference(GROUPED_CHANNEL);
6369
6370 if grouped_deltas {
6371 handler.subscriptions_state.add_reference(GROUPED_CHANNEL);
6372 }
6373
6374 let snapshot = handler
6375 .process_raw_message(&book_message("snapshot", 100, None, 42500.0))
6376 .await
6377 .unwrap();
6378 let grouped = handler
6379 .process_raw_message(&grouped_book_message(999, 89532.5))
6380 .await
6381 .unwrap();
6382 let contiguous = handler
6383 .process_raw_message(&book_message("change", 101, Some(100), 42499.5))
6384 .await
6385 .unwrap();
6386
6387 let mut book = OrderBook::new(
6388 InstrumentId::from("BTC-PERPETUAL.DERIBIT"),
6389 BookType::L2_MBP,
6390 );
6391
6392 let NautilusWsMessage::Deltas(snapshot) = snapshot else {
6393 panic!("expected raw snapshot");
6394 };
6395
6396 book.apply_deltas(&snapshot).unwrap();
6397
6398 let NautilusWsMessage::Data(data) = grouped else {
6399 panic!("expected grouped depth");
6400 };
6401
6402 let [Data::BookDepth(depth)] = data.as_slice() else {
6403 panic!("expected only depth data");
6404 };
6405
6406 let NautilusWsMessage::Deltas(contiguous) = contiguous else {
6407 panic!("expected raw delta");
6408 };
6409
6410 book.apply_deltas(&contiguous).unwrap();
6411
6412 assert_eq!(depth.sequence, 999);
6413 assert_eq!(depth.bids[0].price, Price::from("89532.5"));
6414 assert_eq!(
6415 book.bids_as_map(None).into_iter().collect::<Vec<_>>(),
6416 vec![
6417 (Decimal::from(42500), Decimal::from(10)),
6418 (Decimal::new(424995, 1), Decimal::from(10)),
6419 ]
6420 );
6421 assert!(handler.book_sync.work.is_empty());
6422 assert!(pending_unsubscribe_channels(&handler).is_empty());
6423 assert_eq!(handler.pending_outgoing.len(), usize::from(grouped_deltas));
6424
6425 if grouped_deltas {
6426 let Some(NautilusWsMessage::Deltas(deltas)) = handler.pending_outgoing.pop_front()
6427 else {
6428 panic!("expected requested grouped deltas");
6429 };
6430
6431 assert_eq!(deltas.sequence, 999);
6432 }
6433 }
6434
6435 #[rstest]
6436 #[case::deltas(false)]
6437 #[case::depth(true)]
6438 #[tokio::test]
6439 async fn rejected_grouped_book_snapshot_requests_recovery(#[case] depth: bool) {
6440 let (mut handler, _cmd_rx) = book_test_handler().await;
6441 subscribe_channel(&mut handler, GROUPED_CHANNEL).await;
6442 if depth {
6443 handler
6444 .book_depth_subs
6445 .lock()
6446 .await
6447 .add_reference(GROUPED_CHANNEL);
6448 }
6449
6450 let first = handler
6451 .process_raw_message(&grouped_book_message(100, 42500.0))
6452 .await;
6453
6454 match first.unwrap() {
6455 NautilusWsMessage::Deltas(deltas) if !depth => assert_eq!(deltas.sequence, 100),
6456 NautilusWsMessage::Data(data) if depth => {
6457 let [Data::BookDepth(snapshot)] = data.as_slice() else {
6458 panic!("expected depth");
6459 };
6460
6461 assert_eq!(snapshot.sequence, 100);
6462 }
6463 message => panic!("unexpected message: {message:?}"),
6464 }
6465
6466 let rejected = handler
6467 .process_raw_message(&grouped_book_message(101, UNCONVERTIBLE_PRICE))
6468 .await;
6469
6470 assert!(rejected.is_none());
6471 assert_eq!(handler.book_sync.work.len(), 1);
6472 assert!(pending_unsubscribe_channels(&handler).is_empty());
6473
6474 let next = handler
6475 .process_raw_message(&grouped_book_message(102, 42500.0))
6476 .await;
6477
6478 match next.unwrap() {
6479 NautilusWsMessage::Deltas(deltas) if !depth => assert_eq!(deltas.sequence, 102),
6480 NautilusWsMessage::Data(data) if depth => {
6481 let [Data::BookDepth(snapshot)] = data.as_slice() else {
6482 panic!("expected depth");
6483 };
6484
6485 assert_eq!(snapshot.sequence, 102);
6486 }
6487 message => panic!("unexpected message: {message:?}"),
6488 }
6489 }
6490
6491 #[rstest]
6492 #[case::deltas(false)]
6493 #[case::depth(true)]
6494 #[tokio::test]
6495 async fn delta_channel_recovery_survives_grouped_snapshot_before_unsubscribe_ack(
6496 #[case] depth: bool,
6497 ) {
6498 let (mut handler, mut cmd_rx) = book_test_handler().await;
6499 subscribe_channel(&mut handler, GROUPED_CHANNEL).await;
6500 if depth {
6501 handler
6502 .book_depth_subs
6503 .lock()
6504 .await
6505 .add_reference(GROUPED_CHANNEL);
6506 }
6507
6508 handler
6509 .process_raw_message(&book_message("snapshot", 100, None, 42500.0))
6510 .await;
6511 let rejected = handler
6512 .process_raw_message(&book_message("change", 101, Some(100), UNCONVERTIBLE_PRICE))
6513 .await;
6514 let grouped = handler
6515 .process_raw_message(&grouped_book_message(102, 42500.0))
6516 .await;
6517
6518 assert!(rejected.is_none());
6519 assert_eq!(handler.book_sync.work.len(), 1);
6520
6521 match grouped.unwrap() {
6522 NautilusWsMessage::Deltas(deltas) if !depth => assert_eq!(deltas.sequence, 102),
6523 NautilusWsMessage::Data(data) if depth => {
6524 let [Data::BookDepth(snapshot)] = data.as_slice() else {
6525 panic!("expected depth");
6526 };
6527
6528 assert_eq!(snapshot.sequence, 102);
6529 }
6530 message => panic!("unexpected message: {message:?}"),
6531 }
6532
6533 let command = next_recover_command(&mut handler, &mut cmd_rx).await;
6534 handler.process_command(command).await;
6535
6536 assert_eq!(
6537 pending_unsubscribe_channels(&handler),
6538 vec![vec![BOOK_CHANNEL.to_string()]]
6539 );
6540
6541 let unsubscribe_id = handler
6542 .pending_requests
6543 .iter()
6544 .find_map(|(id, request)| {
6545 matches!(request, PendingRequestType::Unsubscribe { .. }).then_some(*id)
6546 })
6547 .unwrap();
6548
6549 let ack = serde_json::json!({
6550 "jsonrpc": "2.0",
6551 "id": unsubscribe_id,
6552 "result": [BOOK_CHANNEL],
6553 });
6554 handler.process_raw_message(&ack.to_string()).await;
6555
6556 assert_eq!(
6557 pending_subscribe_channels(&handler),
6558 vec![vec![BOOK_CHANNEL.to_string()]]
6559 );
6560 }
6561
6562 #[rstest]
6563 #[tokio::test]
6564 async fn rejected_book_delta_forces_recovery_and_drops_successor() {
6565 let (mut handler, _cmd_rx) = book_test_handler().await;
6566
6567 let snapshot = handler
6568 .process_raw_message(&book_message("snapshot", 100, None, 42500.0))
6569 .await;
6570 let rejected = handler
6571 .process_raw_message(&book_message("change", 101, Some(100), UNCONVERTIBLE_PRICE))
6572 .await;
6573 let successor = handler
6574 .process_raw_message(&book_message("change", 102, Some(101), 42499.5))
6575 .await;
6576
6577 assert!(matches!(
6578 snapshot,
6579 Some(NautilusWsMessage::Deltas(deltas)) if deltas.sequence == 100
6580 ));
6581 assert!(rejected.is_none());
6582 assert!(successor.is_none());
6583 assert_eq!(handler.book_sync.work.len(), 1);
6584 assert!(pending_unsubscribe_channels(&handler).is_empty());
6585
6586 let recovered = handler
6587 .process_raw_message(&book_message("snapshot", 200, None, 42500.0))
6588 .await;
6589
6590 assert!(matches!(
6591 recovered,
6592 Some(NautilusWsMessage::Deltas(deltas)) if deltas.sequence == 200
6593 ));
6594
6595 let contiguous = handler
6596 .process_raw_message(&book_message("change", 201, Some(200), 42499.5))
6597 .await;
6598
6599 assert!(matches!(
6600 contiguous,
6601 Some(NautilusWsMessage::Deltas(deltas)) if deltas.sequence == 201
6602 ));
6603 }
6604
6605 #[rstest]
6606 #[tokio::test]
6607 async fn rejected_snapshot_during_recovery_keeps_episode() {
6608 let (mut handler, mut cmd_rx) = book_test_handler().await;
6609
6610 handler
6611 .process_raw_message(&book_message("snapshot", 100, None, 42500.0))
6612 .await;
6613 let gap = handler
6614 .process_raw_message(&book_message("change", 105, Some(104), 42499.0))
6615 .await;
6616
6617 assert!(gap.is_none());
6618 assert_eq!(handler.book_sync.work.len(), 1);
6619
6620 let rejected = handler
6623 .process_raw_message(&book_message("snapshot", 200, None, UNCONVERTIBLE_PRICE))
6624 .await;
6625
6626 assert!(rejected.is_none());
6627 assert_eq!(handler.book_sync.work.len(), 1);
6628
6629 let command = next_recover_command(&mut handler, &mut cmd_rx).await;
6630 handler.process_command(command).await;
6631
6632 assert_eq!(
6633 pending_unsubscribe_channels(&handler),
6634 vec![vec![BOOK_CHANNEL.to_string()]]
6635 );
6636
6637 let unsubscribe_id = handler
6638 .pending_requests
6639 .iter()
6640 .find_map(|(id, request)| {
6641 matches!(request, PendingRequestType::Unsubscribe { .. }).then_some(*id)
6642 })
6643 .unwrap();
6644
6645 let ack = serde_json::json!({
6646 "jsonrpc": "2.0",
6647 "id": unsubscribe_id,
6648 "result": [BOOK_CHANNEL],
6649 });
6650 handler.process_raw_message(&ack.to_string()).await;
6651
6652 let subscribe_id = handler
6653 .pending_requests
6654 .iter()
6655 .find_map(|(id, request)| {
6656 matches!(request, PendingRequestType::Subscribe { .. }).then_some(*id)
6657 })
6658 .unwrap();
6659
6660 let ack = serde_json::json!({
6661 "jsonrpc": "2.0",
6662 "id": subscribe_id,
6663 "result": [BOOK_CHANNEL],
6664 });
6665 handler.process_raw_message(&ack.to_string()).await;
6666
6667 let recovered = handler
6668 .process_raw_message(&book_message("snapshot", 300, None, 42500.0))
6669 .await;
6670
6671 assert!(matches!(
6672 recovered,
6673 Some(NautilusWsMessage::Deltas(deltas)) if deltas.sequence == 300
6674 ));
6675 }
6676
6677 #[rstest]
6678 #[tokio::test]
6679 async fn corrupt_snapshot_awaiting_replacement_retries_fast() {
6680 let (mut handler, mut cmd_rx) = book_test_handler().await;
6681
6682 handler
6683 .process_raw_message(&book_message("snapshot", 100, None, 42500.0))
6684 .await;
6685 handler
6686 .process_raw_message(&book_message("change", 105, Some(104), 42499.0))
6687 .await;
6688
6689 let command = next_recover_command(&mut handler, &mut cmd_rx).await;
6692 handler.process_command(command).await;
6693
6694 let unsubscribe_id = handler
6695 .pending_requests
6696 .iter()
6697 .find_map(|(id, request)| {
6698 matches!(request, PendingRequestType::Unsubscribe { .. }).then_some(*id)
6699 })
6700 .unwrap();
6701
6702 let ack = serde_json::json!({
6703 "jsonrpc": "2.0",
6704 "id": unsubscribe_id,
6705 "result": [BOOK_CHANNEL],
6706 });
6707 handler.process_raw_message(&ack.to_string()).await;
6708
6709 let subscribe_id = handler
6710 .pending_requests
6711 .iter()
6712 .find_map(|(id, request)| {
6713 matches!(request, PendingRequestType::Subscribe { .. }).then_some(*id)
6714 })
6715 .unwrap();
6716
6717 let ack = serde_json::json!({
6718 "jsonrpc": "2.0",
6719 "id": subscribe_id,
6720 "result": [BOOK_CHANNEL],
6721 });
6722 handler.process_raw_message(&ack.to_string()).await;
6723
6724 let corrupt = handler
6727 .process_raw_message(&book_message("snapshot", 200, None, UNCONVERTIBLE_PRICE))
6728 .await;
6729
6730 assert!(corrupt.is_none());
6731
6732 let next = handler.book_sync.work.next();
6734 tokio::pin!(next);
6735 let retried = tokio::select! {
6736 cmd = cmd_rx.recv() => cmd,
6737 _ = &mut next => panic!("recovery ended without retry"),
6738 () = tokio::time::sleep(Duration::from_secs(10)) => {
6739 panic!("replacement did not retry fast")
6740 }
6741 };
6742 retried.expect("recovery sends its next replacement");
6743 }
6744
6745 #[rstest]
6746 #[tokio::test]
6747 async fn superseded_attempt_ack_is_ignored() {
6748 let (mut handler, mut cmd_rx) = book_test_handler().await;
6749
6750 handler
6751 .process_raw_message(&book_message("snapshot", 100, None, 42500.0))
6752 .await;
6753 handler
6754 .process_raw_message(&book_message("change", 105, Some(104), 42499.0))
6755 .await;
6756
6757 let command = next_recover_command(&mut handler, &mut cmd_rx).await;
6759 handler.process_command(command).await;
6760
6761 let first_id = handler
6762 .pending_requests
6763 .iter()
6764 .find_map(|(id, request)| {
6765 matches!(request, PendingRequestType::Unsubscribe { .. }).then_some(*id)
6766 })
6767 .unwrap();
6768
6769 let key = BookKey::for_channel(BOOK_CHANNEL).expect("book key");
6770 handler
6771 .book_sync
6772 .abort_recovery_write(&key, DeribitWsError::Timeout("book replacement".to_owned()));
6773
6774 let command = next_recover_command(&mut handler, &mut cmd_rx).await;
6776 handler.process_command(command).await;
6777
6778 assert_eq!(
6779 pending_unsubscribe_channels(&handler),
6780 vec![vec![BOOK_CHANNEL.to_string()]]
6781 );
6782
6783 let ack = serde_json::json!({
6785 "jsonrpc": "2.0",
6786 "id": first_id,
6787 "result": [BOOK_CHANNEL],
6788 });
6789 handler.process_raw_message(&ack.to_string()).await;
6790
6791 assert!(pending_subscribe_channels(&handler).is_empty());
6792
6793 let second_id = handler
6796 .pending_requests
6797 .iter()
6798 .find_map(|(id, request)| {
6799 matches!(request, PendingRequestType::Unsubscribe { .. }).then_some(*id)
6800 })
6801 .unwrap();
6802
6803 let ack = serde_json::json!({
6804 "jsonrpc": "2.0",
6805 "id": second_id,
6806 "result": [BOOK_CHANNEL],
6807 });
6808 handler.process_raw_message(&ack.to_string()).await;
6809 handler.process_raw_message(&ack.to_string()).await;
6810
6811 assert_eq!(
6812 pending_subscribe_channels(&handler),
6813 vec![vec![BOOK_CHANNEL.to_string()]]
6814 );
6815 }
6816
6817 #[rstest]
6818 #[tokio::test]
6819 async fn withheld_subscribe_acks_stay_bounded_across_attempts() {
6820 let (mut handler, mut cmd_rx) = book_test_handler().await;
6821
6822 handler
6823 .process_raw_message(&book_message("snapshot", 100, None, 42500.0))
6824 .await;
6825 handler
6826 .process_raw_message(&book_message("change", 105, Some(104), 42499.0))
6827 .await;
6828
6829 let key = BookKey::for_channel(BOOK_CHANNEL).expect("book key");
6830
6831 for _ in 0..3 {
6832 let command = next_recover_command(&mut handler, &mut cmd_rx).await;
6833 handler.process_command(command).await;
6834
6835 assert!(pending_subscribe_channels(&handler).is_empty());
6837 assert_eq!(pending_unsubscribe_channels(&handler).len(), 1);
6838
6839 let id = handler
6841 .pending_requests
6842 .iter()
6843 .find_map(|(id, request)| {
6844 matches!(request, PendingRequestType::Unsubscribe { .. }).then_some(*id)
6845 })
6846 .unwrap();
6847
6848 let ack = serde_json::json!({
6849 "jsonrpc": "2.0",
6850 "id": id,
6851 "result": [BOOK_CHANNEL],
6852 });
6853 handler.process_raw_message(&ack.to_string()).await;
6854
6855 handler
6856 .book_sync
6857 .abort_recovery_write(&key, DeribitWsError::Timeout("book replacement".to_owned()));
6858 }
6859 }
6860
6861 #[rstest]
6862 #[tokio::test]
6863 async fn recovery_retirement_preserves_unacked_initial_subscribe() {
6864 let mut handler = routing_test_handler();
6865 let (cmd_tx, mut cmd_rx) = tokio::sync::mpsc::unbounded_channel();
6866 handler.set_book_sync(cmd_tx, Duration::from_secs(10), Duration::from_secs(120));
6867
6868 handler.subscriptions_state.mark_subscribe(BOOK_CHANNEL);
6870 handler.subscriptions_state.add_reference(BOOK_CHANNEL);
6871 handler
6872 .process_command(HandlerCommand::Subscribe {
6873 channels: vec![BOOK_CHANNEL.to_owned()],
6874 })
6875 .await;
6876
6877 let initial_id = handler
6878 .pending_requests
6879 .iter()
6880 .find_map(|(id, request)| {
6881 matches!(request, PendingRequestType::Subscribe { .. }).then_some(*id)
6882 })
6883 .unwrap();
6884
6885 handler
6887 .process_raw_message(&book_message("change", 101, Some(100), 42499.5))
6888 .await;
6889
6890 let key = BookKey::for_channel(BOOK_CHANNEL).expect("book key");
6891
6892 for _ in 0..2 {
6893 let command = next_recover_command(&mut handler, &mut cmd_rx).await;
6894 handler.process_command(command).await;
6895
6896 let id = handler
6897 .pending_requests
6898 .iter()
6899 .find_map(|(id, request)| {
6900 matches!(request, PendingRequestType::Unsubscribe { .. }).then_some(*id)
6901 })
6902 .unwrap();
6903
6904 let ack = serde_json::json!({
6905 "jsonrpc": "2.0",
6906 "id": id,
6907 "result": [BOOK_CHANNEL],
6908 });
6909 handler.process_raw_message(&ack.to_string()).await;
6910
6911 handler
6912 .book_sync
6913 .abort_recovery_write(&key, DeribitWsError::Timeout("book replacement".to_owned()));
6914 }
6915
6916 let command = next_recover_command(&mut handler, &mut cmd_rx).await;
6919 handler.process_command(command).await;
6920
6921 assert_eq!(
6922 pending_subscribe_channels(&handler),
6923 vec![vec![BOOK_CHANNEL.to_string()]]
6924 );
6925 assert!(handler.pending_requests.contains_key(&initial_id));
6926
6927 let ack = serde_json::json!({
6929 "jsonrpc": "2.0",
6930 "id": initial_id,
6931 "result": [BOOK_CHANNEL],
6932 });
6933 handler.process_raw_message(&ack.to_string()).await;
6934
6935 assert!(!handler.pending_requests.contains_key(&initial_id));
6936 assert!(
6937 handler
6938 .subscriptions_state
6939 .pending_subscribe_topics()
6940 .is_empty()
6941 );
6942 }
6943
6944 #[rstest]
6945 #[tokio::test]
6946 async fn concurrent_book_recoveries_keep_their_own_requests() {
6947 let (mut handler, mut cmd_rx) = book_test_handler().await;
6948 subscribe_channel(&mut handler, GROUPED_CHANNEL).await;
6949
6950 handler
6951 .process_raw_message(&book_message("snapshot", 100, None, 42500.0))
6952 .await;
6953 handler
6954 .process_raw_message(&grouped_book_message(500, 42500.0))
6955 .await;
6956 handler
6957 .process_raw_message(&book_message("change", 105, Some(104), 42499.0))
6958 .await;
6959
6960 let grouped_gap = subscription(
6961 GROUPED_CHANNEL,
6962 &serde_json::json!({
6963 "type": "change",
6964 "instrument_name": "BTC-PERPETUAL",
6965 "timestamp": 1_700_000_000_000_u64,
6966 "change_id": 505,
6967 "prev_change_id": 504,
6968 "bids": [],
6969 "asks": [],
6970 }),
6971 );
6972 handler.process_raw_message(&grouped_gap).await;
6973
6974 assert_eq!(handler.book_sync.work.len(), 2);
6975
6976 for _ in 0..2 {
6979 let command = next_recover_command(&mut handler, &mut cmd_rx).await;
6980 handler.process_command(command).await;
6981 }
6982
6983 let unsubs = pending_unsubscribe_channels(&handler);
6984 assert_eq!(unsubs.len(), 2);
6985 assert!(unsubs.contains(&vec![BOOK_CHANNEL.to_string()]));
6986 assert!(unsubs.contains(&vec![GROUPED_CHANNEL.to_owned()]));
6987
6988 for (id, request) in handler.pending_requests.clone() {
6990 if let PendingRequestType::Unsubscribe { channels } = request {
6991 let ack = serde_json::json!({
6992 "jsonrpc": "2.0",
6993 "id": id,
6994 "result": channels,
6995 });
6996 handler.process_raw_message(&ack.to_string()).await;
6997 }
6998 }
6999
7000 let subs = pending_subscribe_channels(&handler);
7001 assert_eq!(subs.len(), 2);
7002 assert!(subs.contains(&vec![BOOK_CHANNEL.to_string()]));
7003 assert!(subs.contains(&vec![GROUPED_CHANNEL.to_owned()]));
7004 }
7005
7006 #[rstest]
7007 #[tokio::test]
7008 async fn unsubscribe_ack_after_cancel_is_ignored() {
7009 let (mut handler, mut cmd_rx) = book_test_handler().await;
7010
7011 handler
7012 .process_raw_message(&book_message("snapshot", 100, None, 42500.0))
7013 .await;
7014 handler
7015 .process_raw_message(&book_message("change", 105, Some(104), 42499.0))
7016 .await;
7017
7018 let command = next_recover_command(&mut handler, &mut cmd_rx).await;
7019 handler.process_command(command).await;
7020
7021 let request_id = handler
7022 .pending_requests
7023 .iter()
7024 .find_map(|(id, request)| {
7025 matches!(request, PendingRequestType::Unsubscribe { .. }).then_some(*id)
7026 })
7027 .unwrap();
7028
7029 handler.subscriptions_state.remove_reference(BOOK_CHANNEL);
7031 handler
7032 .process_command(HandlerCommand::Unsubscribe {
7033 channels: vec![BOOK_CHANNEL.to_string()],
7034 })
7035 .await;
7036
7037 assert_eq!(handler.book_sync.len(), 1);
7038
7039 let ack = serde_json::json!({
7040 "jsonrpc": "2.0",
7041 "id": request_id,
7042 "result": [BOOK_CHANNEL],
7043 });
7044 handler.process_raw_message(&ack.to_string()).await;
7045
7046 assert!(pending_subscribe_channels(&handler).is_empty());
7047 assert_eq!(handler.book_sync.len(), 1);
7048 }
7049
7050 #[rstest]
7051 fn retire_superseded_recovery_requests_keeps_user_requests() {
7052 let mut handler = routing_test_handler();
7053
7054 handler.pending_requests.insert(
7055 901,
7056 PendingRequestType::Unsubscribe {
7057 channels: vec![BOOK_CHANNEL.to_owned()],
7058 },
7059 );
7060
7061 handler.pending_requests.insert(
7062 902,
7063 PendingRequestType::Subscribe {
7064 channels: vec![BOOK_CHANNEL.to_owned()],
7065 },
7066 );
7067
7068 handler.pending_requests.insert(
7069 903,
7070 PendingRequestType::Unsubscribe {
7071 channels: vec!["book.ETH-PERPETUAL.100ms".to_owned()],
7072 },
7073 );
7074
7075 let btc = BookKey::for_channel(BOOK_CHANNEL).expect("book key");
7078 let eth = BookKey::for_channel("book.ETH-PERPETUAL.100ms").expect("book key");
7079 handler
7080 .book_recovery_requests
7081 .insert(btc.clone(), AHashSet::from([901]));
7082 handler
7083 .book_recovery_requests
7084 .insert(eth, AHashSet::from([903]));
7085
7086 handler.retire_superseded_recovery_requests(&btc);
7087
7088 assert!(!handler.pending_requests.contains_key(&901));
7089 assert!(handler.pending_requests.contains_key(&902));
7090 assert!(handler.pending_requests.contains_key(&903));
7091 }
7092
7093 #[rstest]
7094 #[tokio::test]
7095 async fn corrupt_snapshot_before_ack_starts_no_recovery() {
7096 let mut handler = routing_test_handler();
7097 let (cmd_tx, _cmd_rx) = tokio::sync::mpsc::unbounded_channel();
7098 handler.set_book_sync(cmd_tx, Duration::from_secs(10), Duration::from_secs(120));
7099 handler.subscriptions_state.mark_subscribe(BOOK_CHANNEL);
7100 handler.subscriptions_state.add_reference(BOOK_CHANNEL);
7101 let key = BookKey::for_channel(BOOK_CHANNEL).expect("book key");
7102 handler
7103 .book_sync
7104 .record_subscription(key, InstrumentId::from("BTC-PERPETUAL.DERIBIT"));
7105
7106 let corrupt = handler
7109 .process_raw_message(&book_message("snapshot", 100, None, UNCONVERTIBLE_PRICE))
7110 .await;
7111
7112 assert!(corrupt.is_none());
7113 assert!(handler.book_sync.work.is_empty());
7114 }
7115
7116 #[rstest]
7117 #[case::deltas(false)]
7118 #[case::depth(true)]
7119 #[tokio::test]
7120 async fn corrupt_grouped_snapshot_before_ack_starts_no_recovery(#[case] depth: bool) {
7121 let mut handler = routing_test_handler();
7122 let (cmd_tx, _cmd_rx) = tokio::sync::mpsc::unbounded_channel();
7123 handler.set_book_sync(cmd_tx, Duration::from_secs(10), Duration::from_secs(120));
7124 handler.subscriptions_state.mark_subscribe(GROUPED_CHANNEL);
7125 handler.subscriptions_state.add_reference(GROUPED_CHANNEL);
7126 if depth {
7127 handler
7128 .book_depth_subs
7129 .lock()
7130 .await
7131 .add_reference(GROUPED_CHANNEL);
7132 }
7133
7134 let key = BookKey::for_channel(GROUPED_CHANNEL).expect("book key");
7135 handler
7136 .book_sync
7137 .record_subscription(key, InstrumentId::from("BTC-PERPETUAL.DERIBIT"));
7138
7139 let corrupt = handler
7140 .process_raw_message(&grouped_book_message(100, UNCONVERTIBLE_PRICE))
7141 .await;
7142
7143 assert!(corrupt.is_none());
7144 assert!(handler.book_sync.work.is_empty());
7145 }
7146
7147 #[rstest]
7148 #[tokio::test]
7149 async fn corrupt_snapshot_after_ack_requests_recovery() {
7150 let (mut handler, _cmd_rx) = book_test_handler().await;
7151
7152 handler
7153 .process_raw_message(&book_message("snapshot", 100, None, 42500.0))
7154 .await;
7155
7156 let corrupt = handler
7157 .process_raw_message(&book_message("snapshot", 101, None, UNCONVERTIBLE_PRICE))
7158 .await;
7159
7160 assert!(corrupt.is_none());
7161 assert_eq!(handler.book_sync.work.len(), 1);
7162 }
7163
7164 #[rstest]
7165 #[tokio::test]
7166 async fn user_unsubscribe_removes_book_tracking() {
7167 let (mut handler, _cmd_rx) = book_test_handler().await;
7168
7169 handler
7170 .process_raw_message(&book_message("snapshot", 100, None, 42500.0))
7171 .await;
7172 assert_eq!(handler.book_sync.len(), 2);
7173
7174 handler.subscriptions_state.remove_reference(BOOK_CHANNEL);
7175 handler
7176 .process_command(HandlerCommand::Unsubscribe {
7177 channels: vec![BOOK_CHANNEL.to_string()],
7178 })
7179 .await;
7180
7181 assert_eq!(handler.book_sync.len(), 1);
7182
7183 let delta = handler
7184 .process_raw_message(&book_message("change", 101, Some(100), 42499.5))
7185 .await;
7186
7187 assert!(delta.is_none());
7188 assert!(handler.book_sync.work.is_empty());
7189 }
7190
7191 #[rstest]
7192 #[tokio::test]
7193 async fn reconnect_during_recovery_keeps_episode_and_arms_deadline() {
7194 let (mut handler, _cmd_rx) = book_test_handler().await;
7195
7196 handler
7197 .process_raw_message(&book_message("snapshot", 100, None, 42500.0))
7198 .await;
7199 handler
7200 .process_raw_message(&book_message("change", 105, Some(104), 42499.0))
7201 .await;
7202
7203 assert_eq!(handler.book_sync.work.len(), 1);
7204
7205 handler.process_raw_message(RECONNECTED).await;
7206
7207 assert_eq!(handler.book_sync.len(), 2);
7209 assert_eq!(handler.book_sync.work.len(), 1);
7210 let key = BookKey::Raw(Ustr::from("BTC-PERPETUAL"));
7211 assert!(handler.book_sync.claim(&key).is_none());
7212
7213 let now = Instant::now() + Duration::from_secs(11);
7215 let recoveries =
7216 handler
7217 .book_sync
7218 .recoveries(Duration::from_secs(120), Duration::from_secs(10), now);
7219 let btc = recoveries
7220 .iter()
7221 .find(|(k, _)| *k == key)
7222 .expect("btc recovery signal");
7223 assert_eq!(btc.1.kind, BookSyncSignalKind::SnapshotMissing);
7224 }
7225
7226 #[rstest]
7227 #[tokio::test]
7228 async fn user_unsubscribe_during_recovery_cancels_episode() {
7229 let (mut handler, _cmd_rx) = book_test_handler().await;
7230
7231 handler
7232 .process_raw_message(&book_message("snapshot", 100, None, 42500.0))
7233 .await;
7234 handler
7235 .process_raw_message(&book_message("change", 105, Some(104), 42499.0))
7236 .await;
7237
7238 assert_eq!(handler.book_sync.work.len(), 1);
7239
7240 handler.subscriptions_state.remove_reference(BOOK_CHANNEL);
7241 handler
7242 .process_command(HandlerCommand::Unsubscribe {
7243 channels: vec![BOOK_CHANNEL.to_string()],
7244 })
7245 .await;
7246
7247 assert_eq!(handler.book_sync.len(), 1);
7248 assert!(handler.book_sync.work.next().await.is_some());
7250 assert!(handler.book_sync.work.is_empty());
7251 assert!(pending_subscribe_channels(&handler).is_empty());
7252
7253 let delta = handler
7254 .process_raw_message(&book_message("change", 106, Some(105), 42499.5))
7255 .await;
7256
7257 assert!(delta.is_none());
7258 assert!(handler.book_sync.work.is_empty());
7259 }
7260
7261 #[rstest]
7262 #[tokio::test]
7263 async fn rejected_initial_subscribe_starts_recovery() {
7264 let (mut handler, mut cmd_rx) = book_test_handler().await;
7265
7266 handler.subscriptions_state.mark_subscribe(GROUPED_CHANNEL);
7267 handler.subscriptions_state.add_reference(GROUPED_CHANNEL);
7268 handler
7269 .process_command(HandlerCommand::Subscribe {
7270 channels: vec![GROUPED_CHANNEL.to_owned()],
7271 })
7272 .await;
7273
7274 let id = handler
7275 .pending_requests
7276 .iter()
7277 .find_map(|(id, request)| match request {
7278 PendingRequestType::Subscribe { .. } => Some(*id),
7279 _ => None,
7280 })
7281 .expect("subscribe request");
7282
7283 let rejection = serde_json::json!({
7284 "jsonrpc": "2.0",
7285 "id": id,
7286 "error": {"code": 10028, "message": "too many requests"},
7287 });
7288 handler.process_raw_message(&rejection.to_string()).await;
7289
7290 assert_eq!(handler.book_sync.work.len(), 1);
7292 let key = BookKey::Grouped(GROUPED_CHANNEL.to_owned());
7293 assert!(!handler.book_sync.has_unacked_subscription(&key));
7294
7295 let HandlerCommand::RecoverBook { .. } =
7296 next_recover_command(&mut handler, &mut cmd_rx).await
7297 else {
7298 panic!("expected a recovery command");
7299 };
7300 }
7301
7302 #[rstest]
7303 #[tokio::test]
7304 async fn book_monitor_runs_while_socket_stays_busy() {
7305 let (mut handler, _cmd_rx) = book_test_handler().await;
7306
7307 handler
7308 .process_raw_message(&book_message("snapshot", 100, None, 42500.0))
7309 .await;
7310 handler.book_stale_threshold = Duration::from_secs(1);
7311
7312 let (raw_tx, raw_rx) = tokio::sync::mpsc::unbounded_channel();
7313 handler.raw_rx = raw_rx;
7314 let signal = handler.signal.clone();
7315
7316 let busy = tokio::spawn(async move {
7318 while raw_tx.send(Message::Ping(vec![].into())).is_ok() {
7319 tokio::time::sleep(Duration::from_millis(5)).await;
7320 }
7321 });
7322
7323 let looping = tokio::spawn(async move {
7324 while handler.next().await.is_some() {}
7325 handler
7326 });
7327
7328 tokio::time::sleep(Duration::from_secs(4)).await;
7330 signal.store(true, Ordering::SeqCst);
7331 let handler = looping.await.expect("loop task");
7332 busy.abort();
7333
7334 assert_eq!(handler.book_sync.work.len(), 2);
7335 }
7336
7337 #[rstest]
7338 #[tokio::test]
7339 async fn cancelled_recovery_command_sends_nothing() {
7340 let (mut handler, mut cmd_rx) = book_test_handler().await;
7341
7342 handler
7343 .process_raw_message(&book_message("snapshot", 100, None, 42500.0))
7344 .await;
7345 handler
7346 .process_raw_message(&book_message("change", 105, Some(104), 42499.0))
7347 .await;
7348
7349 let command = next_recover_command(&mut handler, &mut cmd_rx).await;
7350
7351 let HandlerCommand::RecoverBook { cancel, .. } = &command else {
7352 panic!("expected a recovery command");
7353 };
7354
7355 cancel.cancel();
7356 handler.process_command(command).await;
7357
7358 assert!(pending_unsubscribe_channels(&handler).is_empty());
7359 assert_eq!(handler.book_sync.work.len(), 1);
7360 }
7361
7362 #[rstest]
7363 #[case(OrderSide::Buy)]
7364 #[case(OrderSide::Sell)]
7365 #[tokio::test]
7366 async fn order_serialization_failure_leaves_no_order_context(#[case] side: OrderSide) {
7367 let mut handler = routing_test_handler();
7368 let client_order_id = ClientOrderId::from("O-19700101-000000-001-001-1");
7369 let trader_id = TraderId::from("TRADER-001");
7370 let strategy_id = StrategyId::from("S-001");
7371 let instrument_id = InstrumentId::from("BTC-PERPETUAL.DERIBIT");
7372
7373 let params = DeribitOrderParams {
7374 instrument_name: "BTC-PERPETUAL".to_string(),
7375 amount: Decimal::from_str_exact("100000000.005000001").unwrap(),
7376 order_type: "limit".to_string(),
7377 label: Some(client_order_id.to_string()),
7378 price: Some(Decimal::from_str_exact("65000.5").unwrap()),
7379 time_in_force: Some("good_til_cancelled".to_string()),
7380 post_only: None,
7381 reject_post_only: None,
7382 reduce_only: None,
7383 trigger_price: None,
7384 trigger: None,
7385 max_show: None,
7386 valid_until: None,
7387 };
7388
7389 let result = match side {
7390 OrderSide::Buy => {
7391 handler
7392 .handle_submit(
7393 OrderSide::Buy,
7394 params,
7395 client_order_id,
7396 trader_id,
7397 strategy_id,
7398 instrument_id,
7399 )
7400 .await
7401 }
7402 OrderSide::Sell => {
7403 handler
7404 .handle_submit(
7405 OrderSide::Sell,
7406 params,
7407 client_order_id,
7408 trader_id,
7409 strategy_id,
7410 instrument_id,
7411 )
7412 .await
7413 }
7414 };
7415
7416 if "0.10".parse::<serde_json::Number>().unwrap().to_string() == "0.10" {
7419 assert!(matches!(result, Err(DeribitWsError::NotConnected)));
7420 } else {
7421 assert!(matches!(
7422 result,
7423 Err(DeribitWsError::Encode(message))
7424 if message == "exact decimal number serialization requires serde_json/arbitrary_precision"
7425 ));
7426 }
7427
7428 assert!(
7429 handler
7430 .submitted_order_contexts
7431 .get(&client_order_id)
7432 .is_none()
7433 );
7434 assert!(handler.pending_requests.is_empty());
7435 }
7436
7437 #[tokio::test]
7438 async fn stop_before_write_rejects_queued_submit() {
7439 let signal = Arc::new(AtomicBool::new(true));
7440 let (cmd_tx, cmd_rx) = tokio::sync::mpsc::unbounded_channel();
7441 let (_raw_tx, raw_rx) = tokio::sync::mpsc::unbounded_channel();
7442 let (out_tx, mut out_rx) = tokio::sync::mpsc::unbounded_channel();
7443
7444 let mut handler = DeribitWsFeedHandler::new(
7445 signal,
7446 cmd_rx,
7447 raw_rx,
7448 out_tx,
7449 AuthTracker::new(),
7450 SubscriptionState::new('.'),
7451 Arc::new(AtomicSet::new()),
7452 Arc::new(AtomicSet::new()),
7453 Arc::new(AtomicSet::new()),
7454 Some(AccountId::from("DERIBIT-001")),
7455 true,
7456 Arc::new(Mutex::new(Vec::new())),
7457 );
7458 let client_order_id = ClientOrderId::new("stop-before-write-001");
7459 cmd_tx
7460 .send(HandlerCommand::Buy {
7461 params: DeribitOrderParams {
7462 instrument_name: "BTC-PERPETUAL".to_string(),
7463 amount: Decimal::new(1, 0),
7464 order_type: "limit".to_string(),
7465 label: Some(client_order_id.to_string()),
7466 price: Some(Decimal::new(50_000, 0)),
7467 time_in_force: Some("good_til_cancelled".to_string()),
7468 post_only: None,
7469 reject_post_only: None,
7470 reduce_only: None,
7471 trigger_price: None,
7472 trigger: None,
7473 max_show: None,
7474 valid_until: None,
7475 },
7476 client_order_id,
7477 trader_id: TraderId::from("TESTER-001"),
7478 strategy_id: StrategyId::from("S-001"),
7479 instrument_id: InstrumentId::from("BTC-PERPETUAL.DERIBIT"),
7480 })
7481 .unwrap();
7482
7483 assert!(handler.next().await.is_none());
7484 let message = out_rx.try_recv().expect("queued submit rejection");
7485
7486 let NautilusWsMessage::OrderRejected(rejected) = message else {
7487 panic!("expected OrderRejected, was {message:?}");
7488 };
7489
7490 assert_eq!(rejected.client_order_id, client_order_id);
7491 assert_eq!(rejected.reason.as_str(), "canceled before transmission");
7492 assert!(!rejected.due_post_only);
7493 assert!(out_rx.try_recv().is_err());
7494 assert!(cmd_tx.send(HandlerCommand::Disconnect).is_err());
7495 }
7496
7497 #[rstest]
7498 #[case(true)]
7499 #[case(false)]
7500 #[tokio::test]
7501 async fn stop_before_write_denies_queued_modify_or_cancel(#[case] cancel: bool) {
7502 let signal = Arc::new(AtomicBool::new(true));
7503 let (cmd_tx, cmd_rx) = tokio::sync::mpsc::unbounded_channel();
7504 let (_raw_tx, raw_rx) = tokio::sync::mpsc::unbounded_channel();
7505 let (out_tx, mut out_rx) = tokio::sync::mpsc::unbounded_channel();
7506
7507 let mut handler = DeribitWsFeedHandler::new(
7508 signal,
7509 cmd_rx,
7510 raw_rx,
7511 out_tx,
7512 AuthTracker::new(),
7513 SubscriptionState::new('.'),
7514 Arc::new(AtomicSet::new()),
7515 Arc::new(AtomicSet::new()),
7516 Arc::new(AtomicSet::new()),
7517 Some(AccountId::from("DERIBIT-001")),
7518 true,
7519 Arc::new(Mutex::new(Vec::new())),
7520 );
7521 let client_order_id = ClientOrderId::new("stop-before-write-002");
7522 let venue_order_id = VenueOrderId::from("DERIBIT-ORDER-1");
7523 let causation_id = UUID4::new();
7524
7525 let command = if cancel {
7526 HandlerCommand::Cancel {
7527 causation_id: Some(causation_id),
7528 params: DeribitCancelParams {
7529 order_id: venue_order_id.to_string(),
7530 },
7531 client_order_id,
7532 trader_id: TraderId::from("TESTER-001"),
7533 strategy_id: StrategyId::from("S-001"),
7534 instrument_id: InstrumentId::from("BTC-PERPETUAL.DERIBIT"),
7535 }
7536 } else {
7537 HandlerCommand::Edit {
7538 causation_id: Some(causation_id),
7539 params: DeribitEditParams {
7540 order_id: venue_order_id.to_string(),
7541 amount: Decimal::new(1, 0),
7542 price: Some(Decimal::new(50_000, 0)),
7543 post_only: None,
7544 reject_post_only: None,
7545 reduce_only: None,
7546 trigger_price: None,
7547 },
7548 client_order_id,
7549 trader_id: TraderId::from("TESTER-001"),
7550 strategy_id: StrategyId::from("S-001"),
7551 instrument_id: InstrumentId::from("BTC-PERPETUAL.DERIBIT"),
7552 }
7553 };
7554
7555 cmd_tx.send(command).unwrap();
7556 assert!(handler.next().await.is_none());
7557 let message = out_rx.try_recv().expect("queued command denial");
7558
7559 let (id, reason, venue, cause) = match message {
7560 NautilusWsMessage::OrderCancelDenied(event) if cancel => (
7561 event.client_order_id,
7562 event.reason,
7563 event.venue_order_id,
7564 event.causation_id,
7565 ),
7566 NautilusWsMessage::OrderModifyDenied(event) if !cancel => (
7567 event.client_order_id,
7568 event.reason,
7569 event.venue_order_id,
7570 event.causation_id,
7571 ),
7572 other => panic!("expected one denial, was {other:?}"),
7573 };
7574
7575 assert_eq!(id, client_order_id);
7576 assert_eq!(reason.as_str(), "canceled before transmission");
7577 assert_eq!(venue, Some(venue_order_id));
7578 assert_eq!(cause, Some(causation_id));
7579 assert!(out_rx.try_recv().is_err());
7580 assert!(cmd_tx.send(HandlerCommand::Disconnect).is_err());
7581 }
7582
7583 #[rstest]
7584 #[case(true)]
7585 #[case(false)]
7586 #[tokio::test]
7587 async fn stopping_handler_flushes_queued_modify_or_cancel_denial(#[case] cancel: bool) {
7588 let signal = Arc::new(AtomicBool::new(false));
7589 let (_cmd_tx, cmd_rx) = tokio::sync::mpsc::unbounded_channel();
7590 let (_raw_tx, raw_rx) = tokio::sync::mpsc::unbounded_channel();
7591 let (out_tx, mut out_rx) = tokio::sync::mpsc::unbounded_channel();
7592
7593 let mut handler = DeribitWsFeedHandler::new(
7594 signal.clone(),
7595 cmd_rx,
7596 raw_rx,
7597 out_tx,
7598 AuthTracker::new(),
7599 SubscriptionState::new('.'),
7600 Arc::new(AtomicSet::new()),
7601 Arc::new(AtomicSet::new()),
7602 Arc::new(AtomicSet::new()),
7603 Some(AccountId::from("DERIBIT-001")),
7604 true,
7605 Arc::new(Mutex::new(Vec::new())),
7606 );
7607 let client_order_id = ClientOrderId::new("flush-denial-001");
7608 let venue_order_id = VenueOrderId::from("DERIBIT-ORDER-1");
7609 let causation_id = UUID4::new();
7610
7611 let command = if cancel {
7612 HandlerCommand::Cancel {
7613 causation_id: Some(causation_id),
7614 params: DeribitCancelParams {
7615 order_id: venue_order_id.to_string(),
7616 },
7617 client_order_id,
7618 trader_id: TraderId::from("TESTER-001"),
7619 strategy_id: StrategyId::from("S-001"),
7620 instrument_id: InstrumentId::from("BTC-PERPETUAL.DERIBIT"),
7621 }
7622 } else {
7623 HandlerCommand::Edit {
7624 causation_id: Some(causation_id),
7625 params: DeribitEditParams {
7626 order_id: venue_order_id.to_string(),
7627 amount: Decimal::new(1, 0),
7628 price: Some(Decimal::new(50_000, 0)),
7629 post_only: None,
7630 reject_post_only: None,
7631 reduce_only: None,
7632 trigger_price: None,
7633 },
7634 client_order_id,
7635 trader_id: TraderId::from("TESTER-001"),
7636 strategy_id: StrategyId::from("S-001"),
7637 instrument_id: InstrumentId::from("BTC-PERPETUAL.DERIBIT"),
7638 }
7639 };
7640
7641 signal.store(true, Ordering::Relaxed);
7642 handler.process_command(command).await;
7643 assert!(handler.next().await.is_none());
7644
7645 let message = out_rx.try_recv().expect("shutdown should flush the denial");
7646
7647 let id = match message {
7648 NautilusWsMessage::OrderCancelDenied(event) if cancel => event.client_order_id,
7649 NautilusWsMessage::OrderModifyDenied(event) if !cancel => event.client_order_id,
7650 other => panic!("expected one denial, was {other:?}"),
7651 };
7652
7653 assert_eq!(id, client_order_id);
7654 assert!(out_rx.try_recv().is_err());
7655 }
7656
7657 #[tokio::test]
7658 async fn ambiguous_submit_error_keeps_order_context() {
7659 let mut handler = routing_test_handler();
7660 let client_order_id = ClientOrderId::from("O-AMBIGUOUS-SUBMIT");
7661 handler.submitted_order_contexts.insert(
7662 client_order_id,
7663 OrderContext {
7664 client_order_id,
7665 trader_id: TraderId::from("TRADER-001"),
7666 strategy_id: StrategyId::from("S-001"),
7667 instrument_id: InstrumentId::from("BTC-PERPETUAL.DERIBIT"),
7668 order_side: OrderSide::Buy,
7669 order_type: OrderType::Limit,
7670 accepted: false,
7671 last_order_signature: None,
7672 },
7673 );
7674
7675 handler.pending_requests.insert(
7676 1,
7677 PendingRequestType::Buy {
7678 client_order_id,
7679 trader_id: TraderId::from("TRADER-001"),
7680 strategy_id: StrategyId::from("S-001"),
7681 instrument_id: InstrumentId::from("BTC-PERPETUAL.DERIBIT"),
7682 order_side: OrderSide::Buy,
7683 order_type: OrderType::Limit,
7684 },
7685 );
7686
7687 let message = handler
7688 .process_raw_message(&load_test_json("ws_error.json"))
7689 .await;
7690
7691 assert!(message.is_none());
7692 assert!(
7693 handler
7694 .submitted_order_contexts
7695 .contains_key(&client_order_id)
7696 );
7697 assert!(handler.pending_requests.is_empty());
7698 }
7699
7700 #[tokio::test]
7701 async fn submit_error_response_emits_order_rejected() {
7702 let mut handler = routing_test_handler();
7703 let client_order_id = ClientOrderId::from("O-19700101-000000-001-001-1");
7704 handler.submitted_order_contexts.insert(
7705 client_order_id,
7706 OrderContext {
7707 client_order_id,
7708 trader_id: TraderId::from("TRADER-001"),
7709 strategy_id: StrategyId::from("S-001"),
7710 instrument_id: InstrumentId::from("BTC-PERPETUAL.DERIBIT"),
7711 order_side: OrderSide::Buy,
7712 order_type: OrderType::Market,
7713 accepted: false,
7714 last_order_signature: None,
7715 },
7716 );
7717
7718 handler.pending_requests.insert(
7719 42,
7720 PendingRequestType::Buy {
7721 client_order_id,
7722 trader_id: TraderId::from("TRADER-001"),
7723 strategy_id: StrategyId::from("S-001"),
7724 instrument_id: InstrumentId::from("BTC-PERPETUAL.DERIBIT"),
7725 order_side: OrderSide::Buy,
7726 order_type: OrderType::Market,
7727 },
7728 );
7729
7730 let response = serde_json::json!({
7731 "jsonrpc": "2.0",
7732 "id": 42,
7733 "error": { "code": 11050, "message": "bad_request" }
7734 });
7735
7736 let event = handler.process_raw_message(&response.to_string()).await;
7737
7738 let Some(NautilusWsMessage::OrderRejected(rejected)) = event else {
7739 panic!("expected OrderRejected, was {event:?}");
7740 };
7741
7742 assert_eq!(rejected.client_order_id, client_order_id);
7743 assert_eq!(rejected.reason.as_str(), "bad_request");
7744 assert!(!rejected.due_post_only);
7745 assert!(handler.pending_outgoing.is_empty());
7746 assert!(
7747 !handler
7748 .submitted_order_contexts
7749 .contains_key(&client_order_id)
7750 );
7751 }
7752
7753 #[tokio::test]
7754 async fn submit_result_rejected_sets_due_post_only() {
7755 let mut handler = routing_test_handler();
7756 let client_order_id = ClientOrderId::from("routed-904");
7757 let trader_id = TraderId::from("TRADER-001");
7758 let strategy_id = StrategyId::from("S-001");
7759 let instrument_id = InstrumentId::from("BTC_USDC.DERIBIT");
7760 handler.submitted_order_contexts.insert(
7761 client_order_id,
7762 OrderContext {
7763 client_order_id,
7764 trader_id,
7765 strategy_id,
7766 instrument_id,
7767 order_side: OrderSide::Buy,
7768 order_type: OrderType::Limit,
7769 accepted: false,
7770 last_order_signature: None,
7771 },
7772 );
7773
7774 handler.pending_requests.insert(
7775 42,
7776 PendingRequestType::Buy {
7777 client_order_id,
7778 trader_id,
7779 strategy_id,
7780 instrument_id,
7781 order_side: OrderSide::Buy,
7782 order_type: OrderType::Limit,
7783 },
7784 );
7785
7786 let mut messages: Vec<serde_json::Value> = serde_json::from_str(include_str!(
7787 "../../test_data/ws_routed_spot_execution.json"
7788 ))
7789 .unwrap();
7790 messages[0]["id"] = 42.into();
7791 messages[0]["result"]["order"]["order_state"] = "rejected".into();
7792 messages[0]["result"]["order"]["reject_reason"] = "post_only_reject".into();
7793
7794 let event = handler
7795 .process_raw_message(&messages[0].to_string())
7796 .await
7797 .expect("rejected result should emit");
7798
7799 let NautilusWsMessage::OrderRejected(rejected) = event else {
7800 panic!("expected OrderRejected, was {event:?}");
7801 };
7802
7803 assert_eq!(rejected.client_order_id, client_order_id);
7804 assert_eq!(rejected.reason.as_str(), "post_only_reject");
7805 assert!(rejected.due_post_only);
7806 assert!(
7807 !handler
7808 .submitted_order_contexts
7809 .contains_key(&client_order_id)
7810 );
7811 }
7812
7813 #[rstest]
7814 #[case(DeribitWsMethod::PublicSubscribe)]
7815 #[case(DeribitWsMethod::PrivateSubscribe)]
7816 #[case(DeribitWsMethod::PublicUnsubscribe)]
7817 #[case(DeribitWsMethod::PrivateUnsubscribe)]
7818 fn subscription_batches_bound_serialized_bytes(#[case] method: DeribitWsMethod) {
7819 let mut channels: Vec<String> = (0..1500)
7820 .map(|i| format!("book.BTC-27DEC30-{}-C.none.20.100ms", 100000 + i))
7821 .collect();
7822 channels.push("quoted.\"\\\n.é".repeat(100));
7823 let batches = subscription_batches(channels.clone(), &method).unwrap();
7824 assert_eq!(batches.len(), 3);
7825 let mut actual = Vec::new();
7826
7827 for channels in batches {
7828 let request = DeribitJsonRpcRequest::new(
7829 u64::MAX,
7830 method.as_method_str(),
7831 DeribitSubscribeParams { channels },
7832 );
7833 let payload = serde_json::to_string(&request).unwrap();
7834 assert!(payload.len() <= SUBSCRIPTION_REQUEST_MAX_BYTES);
7835 actual.extend(request.params.channels);
7836 }
7837
7838 assert_eq!(actual, channels);
7839 }
7840
7841 #[rstest]
7842 fn subscription_batches_exact_boundary_and_oversized_channel() {
7843 let method = DeribitWsMethod::PrivateSubscribe;
7844
7845 let request = DeribitJsonRpcRequest::new(
7846 u64::MAX,
7847 method.as_method_str(),
7848 DeribitSubscribeParams {
7849 channels: vec![String::new()],
7850 },
7851 );
7852
7853 let overhead = serde_json::to_string(&request).unwrap().len();
7854 let channel = "a".repeat(SUBSCRIPTION_REQUEST_MAX_BYTES - overhead);
7855 assert_eq!(
7856 subscription_batches(vec![channel.clone()], &method).unwrap(),
7857 vec![vec![channel.clone()]],
7858 );
7859 assert!(matches!(
7860 subscription_batches(vec![format!("{channel}a")], &method),
7861 Err(DeribitWsError::Subscribe(_)),
7862 ));
7863 assert!(
7864 subscription_batches(Vec::new(), &method)
7865 .unwrap()
7866 .is_empty()
7867 );
7868 }
7869
7870 #[tokio::test]
7871 async fn subscription_batches_correlate_rejections_and_reconnect() {
7872 let mut handler = routing_test_handler();
7873 let channels: Vec<String> = (0..1500)
7874 .map(|i| format!("book.BTC-27DEC30-{}-C.none.20.100ms", 100000 + i))
7875 .collect();
7876
7877 for channel in &channels {
7878 handler.subscriptions_state.add_reference(channel);
7879 handler.subscriptions_state.mark_subscribe(channel);
7880 }
7881
7882 handler.handle_subscribe(&channels).unwrap();
7883 assert_eq!(handler.subscription_requests.len(), 2);
7884 let requests: Vec<_> = handler.subscription_requests.iter().cloned().collect();
7885 for (index, (request_id, payload)) in requests.iter().enumerate() {
7886 let request: serde_json::Value = serde_json::from_str(payload).unwrap();
7887
7888 let result = if index == 0 {
7889 serde_json::json!({"jsonrpc": "2.0", "id": request_id, "result": request["params"]["channels"]})
7890 } else {
7891 serde_json::json!({"jsonrpc": "2.0", "id": request_id, "error": {"code": 10028, "message": "too_many_requests"}})
7892 };
7893
7894 handler.process_raw_message(&result.to_string()).await;
7895 }
7896
7897 let rejected: serde_json::Value = serde_json::from_str(&requests[1].1).unwrap();
7898 let rejected: Vec<String> =
7899 serde_json::from_value(rejected["params"]["channels"].clone()).unwrap();
7900 let mut pending = handler.subscriptions_state.pending_subscribe_topics();
7901 pending.sort();
7902 assert_eq!(pending, rejected);
7903 assert!(handler.pending_requests.is_empty());
7904 assert_eq!(handler.subscribe_errors.lock().len(), 1);
7905 let mut restored = handler.subscriptions_state.reset_after_reconnect();
7906 restored.sort();
7907 assert_eq!(restored, channels);
7908 handler.process_raw_message(RECONNECTED).await;
7909 assert!(handler.subscription_requests.is_empty());
7910 assert!(handler.subscription_send.is_none());
7911 assert_eq!(
7912 handler
7913 .subscriptions_state
7914 .get_reference_count(&channels[0]),
7915 1
7916 );
7917 }
7918
7919 #[rstest]
7920 #[case::full("full")]
7921 #[case::partial("partial")]
7922 #[case::empty("empty")]
7923 #[case::missing("missing")]
7924 #[case::null("null")]
7925 #[case::object("object")]
7926 #[case::scalar("scalar")]
7927 #[case::mixed_types("mixed_types")]
7928 #[case::unrelated("unrelated")]
7929 #[case::mixed_unrelated("mixed_unrelated")]
7930 #[case::duplicates("duplicates")]
7931 #[case::full_duplicates("full_duplicates")]
7932 #[tokio::test]
7933 async fn subscription_acknowledgements_correlate_batches(
7934 #[case] response_kind: &str,
7935 #[values(true, false)] subscribe: bool,
7936 ) {
7937 let mut handler = routing_test_handler();
7938 let channels: Vec<String> = (0..1500)
7939 .map(|i| format!("book.BTC-27DEC30-{}-C.none.20.100ms", 100000 + i))
7940 .collect();
7941
7942 for channel in &channels {
7943 handler.subscriptions_state.add_reference(channel);
7944 handler.subscriptions_state.add_reference(channel);
7945 handler.subscriptions_state.mark_subscribe(channel);
7946 if !subscribe {
7947 handler.subscriptions_state.confirm_subscribe(channel);
7948 handler.subscriptions_state.remove_reference(channel);
7949 handler.subscriptions_state.remove_reference(channel);
7950 handler.subscriptions_state.mark_unsubscribe(channel);
7951 }
7952 }
7953
7954 handler
7955 .queue_subscription_requests(channels.clone(), subscribe)
7956 .unwrap();
7957 let requests: Vec<_> = handler.subscription_requests.drain(..).collect();
7958 assert_eq!(requests.len(), 2);
7959 let mut acknowledged = Vec::new();
7960
7961 for (index, (request_id, payload)) in requests.iter().enumerate().rev() {
7962 let request: serde_json::Value = serde_json::from_str(payload).unwrap();
7963 let batch: Vec<String> =
7964 serde_json::from_value(request["params"]["channels"].clone()).unwrap();
7965 let other: serde_json::Value = serde_json::from_str(&requests[1 - index].1).unwrap();
7966 let unrelated = other["params"]["channels"][0].as_str().unwrap();
7967 let mut full = batch.clone();
7968 full.reverse();
7969
7970 let result = match response_kind {
7971 "full" => serde_json::json!(full),
7972 "partial" => serde_json::json!([batch[0]]),
7973 "empty" | "missing" => serde_json::json!([]),
7974 "null" => serde_json::Value::Null,
7975 "object" => serde_json::json!({"channels": batch}),
7976 "scalar" => serde_json::json!("ok"),
7977 "mixed_types" => serde_json::json!([batch[0], 17]),
7978 "unrelated" => serde_json::json!([unrelated]),
7979 "mixed_unrelated" => serde_json::json!([batch[0], unrelated]),
7980 "duplicates" => serde_json::json!([batch[0], batch[0]]),
7981 "full_duplicates" => {
7982 full.push(batch[0].clone());
7983 serde_json::json!(full)
7984 }
7985 _ => unreachable!(),
7986 };
7987
7988 let mut response = serde_json::json!({
7989 "jsonrpc": "2.0", "id": request_id, "result": result,
7990 });
7991
7992 if response_kind == "missing" {
7993 response.as_object_mut().unwrap().remove("result");
7994 }
7995
7996 match response_kind {
7997 "full" | "full_duplicates" => acknowledged.extend(batch),
7998 "partial" | "mixed_unrelated" | "duplicates" => {
7999 acknowledged.push(batch[0].clone());
8000 }
8001 _ => {}
8002 }
8003
8004 handler.process_raw_message(&response.to_string()).await;
8005 }
8006
8007 let mut expected_pending: Vec<_> = channels
8008 .iter()
8009 .filter(|ch| !acknowledged.contains(ch))
8010 .cloned()
8011 .collect();
8012 expected_pending.sort();
8013
8014 let mut pending = if subscribe {
8015 handler.subscriptions_state.pending_subscribe_topics()
8016 } else {
8017 handler.subscriptions_state.pending_unsubscribe_topics()
8018 };
8019
8020 pending.sort();
8021
8022 assert_eq!(pending, expected_pending);
8023 assert_eq!(
8024 handler.subscriptions_state.len(),
8025 if subscribe { acknowledged.len() } else { 0 }
8026 );
8027 assert!(handler.pending_requests.is_empty());
8028 let expected_errors =
8029 usize::from(subscribe && !matches!(response_kind, "full" | "full_duplicates"))
8030 * requests.len();
8031 assert_eq!(handler.subscribe_errors.lock().len(), expected_errors);
8032
8033 for (error, (request_id, _)) in handler
8034 .subscribe_errors
8035 .lock()
8036 .iter()
8037 .zip(requests.iter().rev())
8038 {
8039 assert!(error.starts_with("Subscribe acknowledgement "));
8040 assert!(error.ends_with(&format!("request_id={request_id}")));
8041 }
8042
8043 for channel in &channels {
8044 assert_eq!(
8045 handler.subscriptions_state.get_reference_count(channel),
8046 if subscribe { 2 } else { 0 }
8047 );
8048 }
8049
8050 let mut replay = handler.subscriptions_state.reset_after_reconnect();
8051 replay.sort();
8052 assert_eq!(replay, if subscribe { channels } else { Vec::new() });
8053 }
8054
8055 #[tokio::test]
8056 async fn subscription_acknowledgements_accept_duplicate_requests() {
8057 let mut handler = routing_test_handler();
8058 let first = "ticker.BTC-PERPETUAL.100ms".to_string();
8059 let last = "ticker.ETH-PERPETUAL.100ms".to_string();
8060 for channel in [&first, &last] {
8061 handler.subscriptions_state.add_reference(channel);
8062 handler.subscriptions_state.add_reference(channel);
8063 handler.subscriptions_state.mark_subscribe(channel);
8064 }
8065
8066 let (cmd_tx, cmd_rx) = tokio::sync::mpsc::unbounded_channel();
8067 handler.cmd_rx = cmd_rx;
8068 cmd_tx
8069 .send(HandlerCommand::Subscribe {
8070 channels: vec![first.clone(), last.clone()],
8071 })
8072 .unwrap();
8073
8074 let coalesced = handler.coalesce_subscriptions(vec![first.clone()]);
8075 assert_eq!(coalesced, [first.clone(), first.clone(), last.clone()]);
8076 handler.handle_subscribe(&coalesced).unwrap();
8077 let (request_id, _) = handler.subscription_requests.pop_front().unwrap();
8078 let ack =
8079 serde_json::json!({"jsonrpc": "2.0", "id": request_id, "result": [last, first, first]});
8080 handler.process_raw_message(&ack.to_string()).await;
8081
8082 assert_eq!(handler.subscriptions_state.len(), 2);
8083 assert!(
8084 handler
8085 .subscriptions_state
8086 .pending_subscribe_topics()
8087 .is_empty()
8088 );
8089 assert!(handler.subscribe_errors.lock().is_empty());
8090 assert_eq!(handler.subscriptions_state.get_reference_count(&first), 2);
8091 assert_eq!(handler.subscriptions_state.get_reference_count(&last), 2);
8092
8093 let book_first = "book.BTC-PERPETUAL.100ms".to_string();
8094 let book_last = "book.BTC-PERPETUAL.raw".to_string();
8095 for channel in [&book_first, &book_last] {
8096 handler.subscriptions_state.add_reference(channel);
8097 handler.subscriptions_state.mark_subscribe(channel);
8098 handler.subscriptions_state.confirm_subscribe(channel);
8099 }
8100
8101 let key = BookKey::Raw(Ustr::from("BTC-PERPETUAL"));
8102 handler
8103 .book_sync
8104 .record_subscription(key.clone(), InstrumentId::from("BTC-PERPETUAL.DERIBIT"));
8105 let recovery = handler.book_sync.claim(&key).unwrap();
8106 let (completion, _rx) = tokio::sync::oneshot::channel();
8107 assert!(handler.book_sync.begin_recovery_write(
8108 &key,
8109 &recovery,
8110 recovery.gate.clone(),
8111 completion,
8112 vec![book_first.clone(), book_last.clone()],
8113 ));
8114 handler
8115 .handle_unsubscribe(vec![
8116 book_first.clone(),
8117 book_first.clone(),
8118 book_last.clone(),
8119 ])
8120 .unwrap();
8121 let (request_id, _) = handler.subscription_requests.pop_front().unwrap();
8122 let ack = serde_json::json!({"jsonrpc": "2.0", "id": request_id, "result": [book_last, book_first]});
8123 handler.process_raw_message(&ack.to_string()).await;
8124 let (_, payload) = handler.subscription_requests.pop_front().unwrap();
8125 let replay: serde_json::Value = serde_json::from_str(&payload).unwrap();
8126
8127 assert_eq!(
8128 replay["params"]["channels"],
8129 serde_json::json!([book_first, book_last])
8130 );
8131 assert_eq!(handler.subscription_requests.len(), 0);
8132 assert_eq!(handler.subscriptions_state.get_reference_count(&first), 2);
8133 assert_eq!(handler.subscriptions_state.get_reference_count(&last), 2);
8134 }
8135
8136 #[tokio::test]
8137 async fn subscription_acknowledgements_preserve_cancellation_and_replay() {
8138 let mut handler = routing_test_handler();
8139 let retained = "ticker.BTC-PERPETUAL.100ms".to_string();
8140 let canceled = "ticker.ETH-PERPETUAL.100ms".to_string();
8141 for channel in [&retained, &canceled] {
8142 handler.subscriptions_state.add_reference(channel);
8143 handler.subscriptions_state.add_reference(channel);
8144 handler.subscriptions_state.mark_subscribe(channel);
8145 }
8146
8147 handler
8148 .handle_subscribe(&[retained.clone(), canceled.clone()])
8149 .unwrap();
8150 let (request_id, _) = handler.subscription_requests.pop_front().unwrap();
8151 let ack = serde_json::json!({"jsonrpc": "2.0", "id": request_id, "result": []});
8152 handler.process_raw_message(&ack.to_string()).await;
8153
8154 assert!(!handler.subscriptions_state.remove_reference(&retained));
8155 assert!(!handler.subscriptions_state.remove_reference(&canceled));
8156 assert!(handler.subscriptions_state.remove_reference(&canceled));
8157 handler.subscriptions_state.mark_unsubscribe(&canceled);
8158 handler.process_raw_message(RECONNECTED).await;
8159 let replay = handler.subscriptions_state.reset_after_reconnect();
8160 handler.handle_subscribe(&replay).unwrap();
8161 let (request_id, _) = handler.subscription_requests.pop_front().unwrap();
8162 let ack = serde_json::json!({"jsonrpc": "2.0", "id": request_id, "result": [retained]});
8163 handler.process_raw_message(&ack.to_string()).await;
8164
8165 assert_eq!(replay, [retained.as_str()]);
8166 assert_eq!(
8167 handler.subscriptions_state.all_topics(),
8168 [retained.as_str()]
8169 );
8170 assert_eq!(handler.subscriptions_state.len(), 1);
8171 assert_eq!(
8172 handler.subscriptions_state.get_reference_count(&retained),
8173 1
8174 );
8175 assert_eq!(
8176 handler.subscriptions_state.get_reference_count(&canceled),
8177 0
8178 );
8179 assert!(
8180 handler
8181 .subscriptions_state
8182 .pending_subscribe_topics()
8183 .is_empty()
8184 );
8185 assert!(
8186 handler
8187 .subscriptions_state
8188 .pending_unsubscribe_topics()
8189 .is_empty()
8190 );
8191 }
8192
8193 #[rstest]
8194 #[case::full("full")]
8195 #[case::partial("partial")]
8196 #[case::empty("empty")]
8197 #[case::malformed("malformed")]
8198 #[case::error("error")]
8199 #[tokio::test]
8200 async fn subscription_acknowledgements_gate_book_recovery(
8201 #[case] response_kind: &str,
8202 #[values(false, true)] cancel: bool,
8203 ) {
8204 let mut handler = routing_test_handler();
8205 let channels = [
8206 BOOK_CHANNEL.to_string(),
8207 "book.BTC-PERPETUAL.raw".to_string(),
8208 ];
8209
8210 for channel in &channels {
8211 handler.subscriptions_state.add_reference(channel);
8212 handler.subscriptions_state.add_reference(channel);
8213 handler.subscriptions_state.mark_subscribe(channel);
8214 handler.subscriptions_state.confirm_subscribe(channel);
8215 }
8216
8217 let key = BookKey::Raw(Ustr::from("BTC-PERPETUAL"));
8218 handler
8219 .book_sync
8220 .record_subscription(key.clone(), InstrumentId::from("BTC-PERPETUAL.DERIBIT"));
8221 let recovery = handler.book_sync.claim(&key).unwrap();
8222 let (completion, _rx) = tokio::sync::oneshot::channel();
8223 assert!(handler.book_sync.begin_recovery_write(
8224 &key,
8225 &recovery,
8226 recovery.gate.clone(),
8227 completion,
8228 channels.to_vec(),
8229 ));
8230 handler.handle_unsubscribe(channels.to_vec()).unwrap();
8231 let (request_id, _) = handler.subscription_requests.pop_front().unwrap();
8232 if cancel {
8233 handler.subscriptions_state.remove_reference(&channels[0]);
8234 handler.subscriptions_state.remove_reference(&channels[0]);
8235 handler.subscriptions_state.mark_unsubscribe(&channels[0]);
8236 }
8237
8238 let response = match response_kind {
8239 "full" => serde_json::json!({"jsonrpc": "2.0", "id": request_id, "result": channels}),
8240 "partial" => {
8241 serde_json::json!({"jsonrpc": "2.0", "id": request_id, "result": [channels[0]]})
8242 }
8243 "empty" => serde_json::json!({"jsonrpc": "2.0", "id": request_id, "result": []}),
8244 "malformed" => serde_json::json!({"jsonrpc": "2.0", "id": request_id, "result": "ok"}),
8245 "error" => {
8246 serde_json::json!({"jsonrpc": "2.0", "id": request_id, "error": {"code": 10028, "message": "too_many_requests"}})
8247 }
8248 _ => unreachable!(),
8249 };
8250
8251 handler.process_raw_message(&response.to_string()).await;
8252
8253 let mut resubscribed: Vec<String> = handler
8254 .pending_requests
8255 .values()
8256 .flat_map(|request| match request {
8257 PendingRequestType::Subscribe { channels } => channels.clone(),
8258 _ => panic!("unexpected request: {request:?}"),
8259 })
8260 .collect();
8261
8262 resubscribed.sort();
8263
8264 let mut expected = match (response_kind, cancel) {
8265 ("full", false) => channels.to_vec(),
8266 ("full", true) => vec![channels[1].clone()],
8267 _ => Vec::new(),
8268 };
8269
8270 expected.sort();
8271
8272 assert_eq!(resubscribed, expected);
8273 assert!(
8274 handler
8275 .subscriptions_state
8276 .pending_subscribe_topics()
8277 .is_empty()
8278 );
8279 assert_eq!(
8280 handler.subscriptions_state.len(),
8281 if cancel { 1 } else { 2 }
8282 );
8283 assert_eq!(
8284 handler
8285 .subscriptions_state
8286 .get_reference_count(&channels[0]),
8287 if cancel { 0 } else { 2 }
8288 );
8289 assert_eq!(
8290 handler
8291 .subscriptions_state
8292 .get_reference_count(&channels[1]),
8293 2
8294 );
8295 }
8296
8297 #[rstest]
8298 fn subscription_coalescing_preserves_barriers_and_authentication() {
8299 let mut handler = routing_test_handler();
8300 let (cmd_tx, cmd_rx) = tokio::sync::mpsc::unbounded_channel();
8301 handler.cmd_rx = cmd_rx;
8302 cmd_tx
8303 .send(HandlerCommand::Subscribe {
8304 channels: vec!["ticker.ETH-PERPETUAL.100ms".into()],
8305 })
8306 .unwrap();
8307
8308 cmd_tx
8309 .send(HandlerCommand::Unsubscribe {
8310 channels: vec!["ticker.BTC-PERPETUAL.100ms".into()],
8311 })
8312 .unwrap();
8313
8314 cmd_tx
8315 .send(HandlerCommand::Subscribe {
8316 channels: vec!["ticker.SOL_USDC-PERPETUAL.100ms".into()],
8317 })
8318 .unwrap();
8319
8320 let combined = handler.coalesce_subscriptions(vec!["ticker.BTC-PERPETUAL.100ms".into()]);
8321 assert_eq!(
8322 combined,
8323 vec!["ticker.BTC-PERPETUAL.100ms", "ticker.ETH-PERPETUAL.100ms"]
8324 );
8325 assert!(matches!(
8326 handler.pending_command.take(),
8327 Some(HandlerCommand::Unsubscribe { .. })
8328 ));
8329 assert!(matches!(
8330 handler.cmd_rx.try_recv(),
8331 Ok(HandlerCommand::Subscribe { .. })
8332 ));
8333 cmd_tx
8334 .send(HandlerCommand::Subscribe {
8335 channels: vec!["user.orders.any.any.raw".into()],
8336 })
8337 .unwrap();
8338
8339 let combined = handler.coalesce_subscriptions(vec!["ticker.BTC-PERPETUAL.100ms".into()]);
8340 assert_eq!(combined, vec!["ticker.BTC-PERPETUAL.100ms"]);
8341 assert!(matches!(
8342 handler.pending_command,
8343 Some(HandlerCommand::Subscribe { .. })
8344 ));
8345 }
8346
8347 #[rstest]
8348 #[case::reconnect(true)]
8349 #[case::shutdown(false)]
8350 #[tokio::test]
8351 async fn subscription_quota_wait_keeps_messages_and_lifecycle_responsive(
8352 #[case] reconnect: bool,
8353 ) {
8354 let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
8355 let addr = listener.local_addr().unwrap();
8356 let server = tokio::spawn(async move {
8357 let (stream, _) = listener.accept().await.unwrap();
8358 tokio_tungstenite::accept_async(stream).await.unwrap()
8359 });
8360
8361 let (message_handler, raw_rx) = channel_message_handler();
8362 let config = WebSocketConfig::builder()
8363 .url(format!("ws://{addr}"))
8364 .build()
8365 .unwrap();
8366 let quota = Quota::with_period(Duration::from_secs(60)).unwrap();
8367 let ws_client = WebSocketClient::builder()
8368 .config(config)
8369 .message_handler(message_handler)
8370 .keyed_quotas(vec![(DERIBIT_WS_SUBSCRIPTION_KEY.to_string(), quota)])
8371 .connect()
8372 .await
8373 .unwrap();
8374 let mut socket = server.await.unwrap();
8375 ws_client
8376 .send_text(
8377 "reserve".to_string(),
8378 Some(&[Ustr::from(DERIBIT_WS_SUBSCRIPTION_KEY)]),
8379 )
8380 .await
8381 .unwrap();
8382 assert_eq!(
8383 socket.next().await.unwrap().unwrap(),
8384 Message::Text("reserve".into())
8385 );
8386
8387 let mut handler = routing_test_handler();
8388 handler.inner = Some(Arc::new(ws_client));
8389 handler.raw_rx = raw_rx;
8390 let (out_tx, mut out_rx) = tokio::sync::mpsc::unbounded_channel();
8391 handler.out_tx = out_tx;
8392 handler
8393 .handle_authenticate(
8394 serde_json::json!({"grant_type":"client_credentials"})
8395 .to_string()
8396 .into(),
8397 )
8398 .await;
8399 let auth: serde_json::Value =
8400 serde_json::from_str(socket.next().await.unwrap().unwrap().to_text().unwrap()).unwrap();
8401 assert_eq!(auth["method"], "public/auth");
8402 assert_eq!(auth["id"], 1);
8403 let channels = vec![
8404 "ticker.BTC-PERPETUAL.100ms".to_string(),
8405 "ticker.ETH-PERPETUAL.100ms".to_string(),
8406 ];
8407
8408 for channel in &channels {
8409 handler.subscriptions_state.add_reference(channel);
8410 handler.subscriptions_state.mark_subscribe(channel);
8411 handler
8412 .handle_subscribe(std::slice::from_ref(channel))
8413 .unwrap();
8414 }
8415
8416 handler.subscriptions_state.add_reference(&channels[0]);
8417 assert!(futures_util::poll!(Box::pin(handler.next())).is_pending());
8418 assert!(handler.subscription_send.is_some());
8419 assert_eq!(handler.subscription_requests.len(), 1);
8420
8421 let incoming = serde_json::json!({"value":17});
8422 socket
8423 .send(Message::Text(
8424 subscription("unknown.channel", &incoming).into(),
8425 ))
8426 .await
8427 .unwrap();
8428 socket.send(Message::Text(serde_json::json!({"jsonrpc":"2.0","method":"heartbeat","params":{"type":"test_request"}}).to_string().into())).await.unwrap();
8429 socket
8430 .send(Message::Ping(vec![7, 11].into()))
8431 .await
8432 .unwrap();
8433 socket
8434 .send(Message::Text(
8435 serde_json::json!({
8436 "jsonrpc":"2.0", "id":1, "result":{
8437 "access_token":"access", "refresh_token":"refresh", "expires_in":901,
8438 "scope":"session:test", "token_type":"bearer", "enabled_features":[]
8439 }
8440 })
8441 .to_string()
8442 .into(),
8443 ))
8444 .await
8445 .unwrap();
8446 let authenticated = tokio::time::timeout(Duration::from_millis(500), handler.next())
8447 .await
8448 .unwrap();
8449
8450 let Some(NautilusWsMessage::Authenticated(auth)) = authenticated else {
8451 panic!("Expected authentication response during quota wait");
8452 };
8453
8454 assert_eq!(auth.access_token.expose_secret(), "access");
8455 assert_eq!(auth.refresh_token.expose_secret(), "refresh");
8456 assert_eq!(auth.expires_in, 901);
8457 assert_eq!(auth.scope, "session:test");
8458 assert_eq!(auth.token_type, "bearer");
8459 assert_eq!(auth.enabled_features, Vec::<String>::new());
8460 assert!(
8461 matches!(out_rx.try_recv().unwrap(), NautilusWsMessage::Raw(data) if serde_json::from_str::<serde_json::Value>(data.get()).unwrap() == incoming)
8462 );
8463 let mut heartbeat = None;
8464 let mut pong = None;
8465
8466 for _ in 0..2 {
8467 let message = tokio::time::timeout(Duration::from_millis(500), socket.next())
8468 .await
8469 .unwrap()
8470 .unwrap()
8471 .unwrap();
8472
8473 match message {
8474 Message::Text(text) => {
8475 heartbeat = Some(serde_json::from_str::<serde_json::Value>(&text).unwrap());
8476 }
8477 Message::Pong(data) => pong = Some(data.to_vec()),
8478 message => panic!("Unexpected response: {message:?}"),
8479 }
8480 }
8481
8482 assert_eq!(
8483 heartbeat,
8484 Some(serde_json::json!({"jsonrpc":"2.0", "id":4, "method":"public/test", "params":{}}))
8485 );
8486 assert_eq!(pong, Some(vec![7, 11]));
8487 assert!(handler.subscription_send.is_some());
8488 assert_eq!(handler.subscription_requests.len(), 1);
8489
8490 if reconnect {
8491 socket
8492 .send(Message::Text(RECONNECTED.into()))
8493 .await
8494 .unwrap();
8495 let result = tokio::time::timeout(Duration::from_millis(500), handler.next())
8496 .await
8497 .unwrap();
8498 assert!(matches!(result, Some(NautilusWsMessage::Reconnected)));
8499 assert!(handler.subscription_send.is_none());
8500 assert!(handler.subscription_requests.is_empty());
8501 assert!(handler.pending_requests.is_empty());
8502 let mut restored = handler.subscriptions_state.reset_after_reconnect();
8503 restored.sort();
8504 assert_eq!(restored, channels);
8505 assert_eq!(
8506 handler
8507 .subscriptions_state
8508 .get_reference_count(&channels[0]),
8509 2
8510 );
8511 assert_eq!(
8512 handler
8513 .subscriptions_state
8514 .get_reference_count(&channels[1]),
8515 1
8516 );
8517 }
8518
8519 handler.signal.store(true, Ordering::Relaxed);
8520 let result = tokio::time::timeout(Duration::from_millis(500), handler.next())
8521 .await
8522 .unwrap();
8523 assert!(result.is_none());
8524 assert!(handler.subscription_send.is_none());
8525 let close = tokio::time::timeout(Duration::from_millis(500), socket.next())
8526 .await
8527 .unwrap()
8528 .unwrap()
8529 .unwrap();
8530 assert!(matches!(close, Message::Close(_)));
8531 }
8532
8533 #[rstest]
8534 #[case(true, "private/subscribe")]
8535 #[case(false, "private/unsubscribe")]
8536 fn mixed_subscription_batches_keep_original_private_method(
8537 #[case] subscribe: bool,
8538 #[case] method: &str,
8539 ) {
8540 let mut handler = routing_test_handler();
8541 let mut channels: Vec<String> = (0..1500)
8542 .map(|i| format!("ticker.BTC-27DEC30-{}-C.100ms", 100000 + i))
8543 .collect();
8544 channels.push("user.orders.any.any.raw".into());
8545 handler
8546 .queue_subscription_requests(channels.clone(), subscribe)
8547 .unwrap();
8548 assert_eq!(handler.subscription_requests.len(), 2);
8549 let mut actual = Vec::new();
8550
8551 for (_, payload) in &handler.subscription_requests {
8552 let request: serde_json::Value = serde_json::from_str(payload).unwrap();
8553 assert_eq!(request["method"], method);
8554 actual.extend(
8555 serde_json::from_value::<Vec<String>>(request["params"]["channels"].clone())
8556 .unwrap(),
8557 );
8558 }
8559
8560 assert_eq!(actual, channels);
8561 }
8562
8563 #[tokio::test]
8564 async fn subscription_send_wait_processes_heartbeat_and_authentication() {
8565 let mut handler = routing_test_handler();
8566 let (raw_tx, raw_rx) = tokio::sync::mpsc::unbounded_channel();
8567 handler.raw_rx = raw_rx;
8568 handler.subscription_send = Some(Box::pin(std::future::pending()));
8569 handler
8570 .pending_requests
8571 .insert(42, PendingRequestType::Authenticate);
8572 raw_tx
8573 .send(Message::Text(load_test_json("ws_test_request.json").into()))
8574 .unwrap();
8575 let response = serde_json::json!({
8576 "jsonrpc": "2.0", "id": 42,
8577 "result": {
8578 "access_token": "test-access", "refresh_token": "test-refresh", "expires_in": 900,
8579 "scope": "connection", "token_type": "bearer"
8580 }
8581 });
8582 raw_tx
8583 .send(Message::Text(response.to_string().into()))
8584 .unwrap();
8585 let result = tokio::time::timeout(std::time::Duration::from_millis(500), handler.next())
8586 .await
8587 .unwrap();
8588 assert!(matches!(result, Some(NautilusWsMessage::Authenticated(_))));
8589 assert!(handler.subscription_send.is_some());
8590 assert!(!handler.pending_requests.contains_key(&42));
8591 assert!(matches!(
8592 handler.pending_requests.get(&1),
8593 Some(PendingRequestType::Test)
8594 ));
8595 }
8596
8597 #[tokio::test]
8598 async fn subscription_send_wait_preserves_command_order() {
8599 let mut handler = routing_test_handler();
8600 let (cmd_tx, cmd_rx) = tokio::sync::mpsc::unbounded_channel();
8601 handler.cmd_rx = cmd_rx;
8602 handler.subscription_send = Some(Box::pin(std::future::pending()));
8603 cmd_tx
8604 .send(HandlerCommand::SetHeartbeat { interval: 37 })
8605 .unwrap();
8606 {
8607 let next = handler.next();
8608 tokio::pin!(next);
8609 assert!(futures_util::poll!(next).is_pending());
8610 }
8611
8612 assert!(handler.pending_requests.is_empty());
8613 assert_eq!(handler.cmd_rx.len(), 1);
8614 handler.subscription_send = None;
8615 {
8616 let next = handler.next();
8617 tokio::pin!(next);
8618 assert!(futures_util::poll!(next).is_pending());
8619 }
8620
8621 assert_eq!(handler.cmd_rx.len(), 0);
8622 assert_eq!(handler.pending_requests.len(), 1);
8623 assert!(matches!(
8624 handler.pending_requests.get(&1),
8625 Some(PendingRequestType::SetHeartbeat)
8626 ));
8627 }
8628
8629 #[rstest]
8630 #[case(true)]
8631 #[case(false)]
8632 #[tokio::test]
8633 async fn subscription_send_failure_removes_request_correlation(#[case] subscribe: bool) {
8634 let mut handler = routing_test_handler();
8635 let channels = vec!["ticker.BTC-PERPETUAL.100ms".into()];
8636 let request = if subscribe {
8637 PendingRequestType::Subscribe { channels }
8638 } else {
8639 PendingRequestType::Unsubscribe { channels }
8640 };
8641
8642 handler.pending_requests.insert(73, request);
8643
8644 handler.subscription_send =
8645 Some(Box::pin(async { (73, Err(DeribitWsError::NotConnected)) }));
8646 {
8647 let next = handler.next();
8648 tokio::pin!(next);
8649 assert!(futures_util::poll!(next).is_pending());
8650 }
8651
8652 assert!(handler.pending_requests.is_empty());
8653 assert!(handler.subscription_send.is_none());
8654
8655 let expected_errors = if subscribe {
8656 vec![DeribitWsError::NotConnected.to_string()]
8657 } else {
8658 Vec::new()
8659 };
8660
8661 assert_eq!(*handler.subscribe_errors.lock(), expected_errors);
8662 }
8663}