Skip to main content

nautilus_deribit/websocket/
handler.rs

1// -------------------------------------------------------------------------------------------------
2//  Copyright (C) 2015-2026 Nautech Systems Pty Ltd. All rights reserved.
3//  https://nautechsystems.io
4//
5//  Licensed under the GNU Lesser General Public License Version 3.0 (the "License");
6//  You may not use this file except in compliance with the License.
7//  You may obtain a copy of the License at https://www.gnu.org/licenses/lgpl-3.0.en.html
8//
9//  Unless required by applicable law or agreed to in writing, software
10//  distributed under the License is distributed on an "AS IS" BASIS,
11//  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12//  See the License for the specific language governing permissions and
13//  limitations under the License.
14// -------------------------------------------------------------------------------------------------
15
16//! WebSocket message handler for Deribit.
17//!
18//! The handler runs in a dedicated Tokio task as the I/O boundary between the client
19//! orchestrator and the network layer. It exclusively owns the `WebSocketClient` and
20//! processes commands from the client via an unbounded channel.
21
22use 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
109// Deribit documents a 32 kB frame limit: https://docs.deribit.com/articles/errors
110const SUBSCRIPTION_REQUEST_MAX_BYTES: usize = 32_000;
111
112// Bounds replay and terminal tombstone caches only, never pending or active ownership
113const REPLAY_CACHE_CAPACITY: usize = 10_000;
114
115/// Type of pending request for request ID correlation.
116#[derive(Debug, Clone)]
117pub enum PendingRequestType {
118    /// Authentication request.
119    Authenticate,
120    /// Subscribe request with requested channels.
121    Subscribe { channels: Vec<String> },
122    /// Unsubscribe request with requested channels.
123    Unsubscribe { channels: Vec<String> },
124    /// Set heartbeat request.
125    SetHeartbeat,
126    /// Test/ping request (heartbeat response).
127    Test,
128    /// Buy order request.
129    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 order request.
138    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 order request.
147    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 order request.
156    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    /// Cancel all orders by instrument request.
165    CancelAllByInstrument { instrument_id: InstrumentId },
166    /// Get order state request.
167    GetOrderState {
168        client_order_id: ClientOrderId,
169        trader_id: TraderId,
170        strategy_id: StrategyId,
171        instrument_id: InstrumentId,
172    },
173}
174
175/// Commands sent from the client to the handler.
176#[allow(missing_debug_implementations)]
177pub enum HandlerCommand {
178    /// Set the active WebSocket client.
179    SetClient(WebSocketClient),
180    /// Disconnect the WebSocket.
181    Disconnect,
182    /// Authenticate with credentials.
183    Authenticate { auth_params: SecretString },
184    /// Enable heartbeat with interval.
185    SetHeartbeat { interval: u64 },
186    /// Initialize the instrument cache.
187    InitializeInstruments(Vec<InstrumentAny>),
188    /// Update a single instrument in the cache.
189    UpdateInstrument(Box<InstrumentAny>),
190    /// Subscribe to channels.
191    Subscribe { channels: Vec<String> },
192    /// Unsubscribe from channels.
193    Unsubscribe { channels: Vec<String> },
194    /// Submit a buy order.
195    Buy {
196        params: DeribitOrderParams,
197        client_order_id: ClientOrderId,
198        trader_id: TraderId,
199        strategy_id: StrategyId,
200        instrument_id: InstrumentId,
201    },
202    /// Submit a sell order.
203    Sell {
204        params: DeribitOrderParams,
205        client_order_id: ClientOrderId,
206        trader_id: TraderId,
207        strategy_id: StrategyId,
208        instrument_id: InstrumentId,
209    },
210    /// Edit an existing order.
211    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 an existing order.
220    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    /// Cancel all orders by instrument.
229    CancelAllByInstrument {
230        params: DeribitCancelAllByInstrumentParams,
231        instrument_id: InstrumentId,
232    },
233    /// Get order state.
234    GetOrderState {
235        order_id: String,
236        client_order_id: ClientOrderId,
237        trader_id: TraderId,
238        strategy_id: StrategyId,
239        instrument_id: InstrumentId,
240    },
241    /// Replace a book subscription for one recovery attempt.
242    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/// Context for an order submitted via this handler.
253///
254/// Stores the submitted order identity for routing live order and trade updates.
255#[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
273/// Order fields used to identify a venue amendment.
274pub type OrderSignature = (Decimal, Option<Decimal>, Option<Decimal>);
275
276/// Deribit WebSocket feed handler.
277///
278/// Runs in a dedicated Tokio task, processing commands and raw WebSocket messages.
279#[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    // Pending submits stay owned until venue binding or a definitive terminal outcome
303    submitted_order_contexts: AHashMap<ClientOrderId, OrderContext>,
304
305    // Retain terminal ownership and whether later fills require report recovery
306    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    /// Creates a new feed handler.
325    #[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    /// Wires book recovery to the handler command channel with the configured timers.
381    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    /// Sets the account ID for order/fill reports.
393    pub fn set_account_id(&mut self, account_id: AccountId) {
394        self.account_id = Some(account_id);
395    }
396
397    /// Returns the account ID.
398    #[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    /// Generates a unique request ID.
431    fn next_request_id(&self) -> u64 {
432        self.request_id_counter.fetch_add(1, Ordering::Relaxed)
433    }
434
435    /// Returns the current timestamp.
436    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    /// Sends a message over the WebSocket with retry logic.
458    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    /// Sends one order command on the current connection.
502    ///
503    /// The returned future does not borrow the handler. A failure before the write starts is a
504    /// typed not-sent error. A write that may have started stays a transport error whose delivery
505    /// is unknown.
506    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    /// Handles a subscribe command.
865    ///
866    /// Note: The client has already called `mark_subscribe` before sending this command.
867    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    /// Handles an unsubscribe command.
887    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    /// Handles enabling heartbeat.
965    async fn handle_set_heartbeat(&mut self, interval: u64) -> Result<(), DeribitWsError> {
966        let request_id = self.next_request_id();
967
968        // Track this request for response correlation
969        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    /// Responds to a heartbeat test_request.
988    async fn handle_heartbeat_test_request(&mut self) -> Result<(), DeribitWsError> {
989        let request_id = self.next_request_id();
990
991        // Track this request for response correlation
992        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    /// Handles an order submission command.
1009    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(&params.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    /// Handles an edit order command.
1053    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    /// Handles a cancel order command.
1090    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    /// Handles cancel all orders by instrument command.
1127    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    /// Handles get order state command.
1158    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        // Track this request for response correlation
1169        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    /// Processes a command from the client.
1202    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    /// Processes a raw WebSocket message.
1431    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        // Parse the JSON-RPC message
1442        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                // Look up the request type by ID for explicit correlation
1455                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                                        // Emit OrderCanceled from the response path so we
1585                                        // do not lose the event during a reconnection gap.
1586                                        // Both paths check terminal context to suppress
1587                                        // duplicates regardless of which arrives first.
1588                                        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                                        // Individual order status updates come via user.orders subscription
1682                                    }
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                                        // Convert to OrderStatusReport
1882                                        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                    // Response with ID but no matching pending request
1933                    if let Some(error) = &response.error {
1934                        // Log orphaned error response with all available context
1935                        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                        // Success response but no pending request - likely already processed
1948                        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                    // Error response with no ID (shouldn't happen in JSON-RPC 2.0, but handle it)
1956                    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 = &notification.params.channel;
1971                let data = &notification.params.data;
1972
1973                // Determine channel type and parse accordingly
1974                if let Some(channel_type) = DeribitWsChannel::from_channel_string(channel) {
1975                    match channel_type {
1976                        DeribitWsChannel::Trades => {
1977                            // Parse trade messages
1978                            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                                        // Emit OptionGreeks only if subscribed
2029                                        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                                        // Emit MarkPriceUpdate only if subscribed
2046                                        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                                        // Emit IndexPriceUpdate only if subscribed
2062                                        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                            // Parse perpetual channel for funding rate updates
2097                            // This channel is dedicated to perpetual instruments and provides
2098                            // the interest (funding) rate
2099                            match serde_json::from_str::<DeribitPerpetualMsg>(data.get()) {
2100                                Ok(perpetual_msg) => {
2101                                    // Extract instrument name from channel: perpetual.{instrument}.{interval}
2102                                    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                            // Parse quote messages
2135                            match serde_json::from_str::<DeribitQuoteMsg>(data.get()) {
2136                                Ok(quote_msg) => {
2137                                    if let Some(instrument) =
2138                                        self.instruments_cache.get(&quote_msg.instrument_name)
2139                                    {
2140                                        match parse_quote_msg(&quote_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                            // Parse chart.trades messages into Bar objects using emit-on-next pattern.
2248                            // Deribit sends updates for the current bar as it builds. We only emit
2249                            // a bar when we receive a bar with a different timestamp, confirming
2250                            // the previous bar is closed.
2251                            if let Ok(chart_msg) =
2252                                serde_json::from_str::<DeribitChartMsg>(data.get())
2253                            {
2254                                // Extract instrument and resolution from channel
2255                                // Channel format: chart.trades.{instrument}.{resolution}
2256                                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                                                        // Check if we have a pending bar for this channel
2284                                                        let channel_key = channel.clone();
2285
2286                                                        if let Some(pending_bar) =
2287                                                            self.pending_bars.get(&channel_key)
2288                                                        {
2289                                                            // If new bar has different timestamp, the pending bar is closed
2290                                                            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                                                            // Same timestamp - update pending bar with latest values
2306                                                            self.pending_bars
2307                                                                .insert(channel_key, new_bar);
2308                                                        } else {
2309                                                            // First bar for this channel - store as pending
2310                                                            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                            // Handle both array and single object responses
2337                            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                                    // Require account_id for parsing
2350                                    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                                    // Process each order and emit appropriate events
2358                                    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                                        // Determine event type based on order state
2403                                        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                                                // Skip if order already reached terminal state (race condition)
2440                                                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                                                // Skip if already emitted from the cancel
2471                                                // response path
2472                                                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                                                // Fills handled via user.trades, track terminal state
2568                                                // for race condition prevention
2569                                                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                            // Handle both array and single object responses
2620                            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                                    // Skip zero-balance currencies (common with cross-collateral)
2648                                    // Only check equity and balance - initial_margin can be non-zero
2649                                    // for all currencies when cross-collateral is enabled
2650                                    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                                    // Require account_id for parsing
2659                                    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                                            // Check for duplicate per currency
2669                                            let currency_key = portfolio.currency.clone();
2670
2671                                            if let Some(last) =
2672                                                self.last_account_states.get(&currency_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                            // Unhandled channel - return raw
2702                            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 error to signal connection may be unhealthy
2723                            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        // Parse snapshots before accepting so a corrupt frame never completes an episode
2872        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        // Grouped legs stream snapshots, but a contiguous change still advances them
2950        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        // Parse snapshots before accepting so a corrupt frame never completes an episode
2970        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        // Check what the replacement needs before claiming, so an early return leaves the
3033        // book unowned and its next frame requests recovery again
3034        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    // Channels a replacement resubscribes for a book: every desired raw channel of a raw
3079    // book, or the grouped channel itself while desired
3080    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    // Whether another desired channel still feeds a book after `removed` goes away
3101    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    // Recovery replacements unsubscribe without touching refcounts, so an unsubscribe
3113    // command means the last consumer released the channel; drop tracking unless another
3114    // desired channel still feeds the same book
3115    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        // A new attempt supersedes prior attempts: drop their unacknowledged
3154        // requests so late acks cannot drive this transition
3155        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        // Ownership by request id: only this book's recovery-created requests are
3169        // recorded, so user, initial, and other books' requests always survive
3170        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        // A rejected initial subscribe never resolves its wait; recover those books
3193        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    // Validate an incremental frame; a gap starts recovery and fails validation
3248    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    // Parse both legs of a grouped snapshot, requesting recovery when either fails conversion
3269    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        // Preserve order-context updates before suppressing duplicate trade output
3547        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    /// Main message processing loop.
3663    ///
3664    /// Returns `None` when the handler should stop.
3665    /// Messages that need client-side handling (e.g., Reconnected) are returned.
3666    /// Data messages are sent directly to `out_tx` for the user stream.
3667    pub async fn next(&mut self) -> Option<NautilusWsMessage> {
3668        // A persistent interval: recreating a sleep each pass would starve under traffic
3669        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                    // Recovery ends once a snapshot is accepted or the episode is cancelled
3724                }
3725                // Keep later commands behind all queued subscription batches
3726                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                // Process raw WebSocket messages
3742                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                                // Send data messages to user stream
3747                                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                                    // Return messages that need client-side handling
3781                                    NautilusWsMessage::Reconnected
3782                                    | NautilusWsMessage::Authenticated(_)
3783                                    | NautilusWsMessage::AuthenticationFailed(_) => {
3784                                        return Some(nautilus_msg);
3785                                    }
3786                                }
3787                            }
3788                        }
3789                        Message::Ping(data) => {
3790                            // Respond to ping with pong
3791                            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                // Check for stop signal, and poll book health on its own cadence
3802                _ = 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
3866// Grouped channels have the form `book.{instrument}.{group}.{depth}.{interval}`
3867fn 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            // Replayed terminal evidence stays suppressed
5296            handler.process_raw_message(&terminal_update).await;
5297            events.extend(handler.pending_outgoing.drain(..));
5298
5299            // New trade evidence uses terminal report recovery
5300            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        // The delayed open acknowledgement arrives after the fast fill terminalized the order
5403        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        // Fast-fill acceptance ordering is preserved when the trade arrives
5438        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    // Exceeds the Price range, so a level at this price fails domain conversion
6101    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    // The other instrument's book and this instrument's trades must survive a book resync
6124    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        // The armed snapshot deadline owns the book; recovery starts at expiry
6307        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        // The corrupt frame never completes the episode: the same recovery keeps
6621        // ownership and its replacement still runs
6622        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        // Drive the replacement to its resubscribe acknowledgement, so the attempt
6690        // waits for the fresh snapshot with the gate open
6691        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        // The corrupt snapshot fails the waiting attempt, which must retry in about
6725        // a second rather than skipping to the 60s ceiling
6726        let corrupt = handler
6727            .process_raw_message(&book_message("snapshot", 200, None, UNCONVERTIBLE_PRICE))
6728            .await;
6729
6730        assert!(corrupt.is_none());
6731
6732        // Poll the recovery like the handler loop so the failed attempt retries
6733        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        // The first attempt sends its unsubscribe, then times out
6758        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        // The retry supersedes the first attempt and retires its request
6775        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        // The late acknowledgement to the first attempt is ignored
6784        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        // The current attempt's acknowledgement resubscribes, and a duplicate
6794        // response to the same request is ignored by request-id removal
6795        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            // Only the current attempt holds requests: earlier resubscribes retired
6836            assert!(pending_subscribe_channels(&handler).is_empty());
6837            assert_eq!(pending_unsubscribe_channels(&handler).len(), 1);
6838
6839            // The unsubscribe is acknowledged but the resubscribe is not
6840            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        // The initial subscribe is sent but never acknowledged
6869        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        // A delta before any snapshot starts recovery while still unacked
6886        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        // One more attempt retires the withheld resubscribes but keeps the
6917        // initial subscribe for the identical channel
6918        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        // The late initial acknowledgement still confirms the subscription
6928        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        // Both replacements hold their own requests: neither begin retires the
6977        // other book's entries
6978        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        // Both acknowledgements still drive their own resubscribe
6989        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        // The user unsubscribes while the replacement is queued
7030        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        // Recorded ids alone decide ownership: 901 is this book's recovery residue
7076        // while the user's subscribe and the other book's recovery request survive
7077        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        // The gate stays closed until the subscribe acknowledgement; the snapshot
7107        // timer owns the wait, so a corrupt frame is dropped, not rejected
7108        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        // The episode survives the reconnect instead of restarting
7208        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        // A snapshot deadline is armed for the replayed subscription
7214        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        // Dropping the episode completes its work without resubscribing
7249        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        // The rejected wait retires into a running recovery that resubscribes
7291        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        // Keep the socket busy with pings the handler answers without book work
7317        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        // The silent books must still reach stale recovery under traffic
7329        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        // `serde_json/arbitrary_precision` keeps a number's text, so the amount serializes
7417        // and the missing client proves the command was not sent.
7418        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}