Skip to main content

nautilus_okx/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 OKX.
17//!
18//! The handler is a thin I/O boundary between the network layer and the client. It owns the
19//! `WebSocketClient`, deserializes raw venue messages into `OKXWsMessage` events, and handles
20//! subscription management, authentication, and retry logic.
21//!
22//! All domain parsing (venue types to Nautilus types) occurs outside the handler:
23//! - Data parsing in `PyOKXWebSocketClient` (uses an instruments cache)
24//! - Execution parsing in `execution.rs` (uses the system Cache)
25
26use std::{
27    collections::VecDeque,
28    fmt::Debug,
29    sync::{
30        Arc,
31        atomic::{AtomicBool, Ordering},
32    },
33};
34
35use dashmap::{DashMap, mapref::entry::Entry};
36use nautilus_common::{cache::fifo::FifoCacheMap, live::dst::time};
37use nautilus_core::{AtomicTime, string::secret::REDACTED};
38pub use nautilus_live::book::snapshot::SnapshotGate;
39use nautilus_model::identifiers::ClientOrderId;
40use nautilus_network::{
41    RECONNECTED,
42    error::SendError,
43    retry::{RetryError, RetryManager, create_websocket_retry_manager},
44    websocket::{AuthTracker, SubscriptionState, TEXT_PING, TEXT_PONG, WebSocketClient},
45};
46use serde_json::{Map, Value};
47use tokio_tungstenite::tungstenite::Message;
48use tokio_util::sync::CancellationToken;
49use ustr::Ustr;
50
51use super::{
52    enums::{OKXSubscriptionEvent, OKXWsChannel, OKXWsOperation},
53    error::OKXWsError,
54    messages::{
55        OKXOrderMsg, OKXSubscription, OKXSubscriptionArg, OKXWebSocketArg, OKXWebSocketError,
56        OKXWsFrame, OKXWsMessage,
57    },
58    subscription::{is_topic_subscribed, topic_from_subscription_arg, topic_from_websocket_arg},
59};
60use crate::{
61    common::{
62        consts::{OKX_FIELD_SMSG, OKX_SUCCESS_CODE, should_retry_error_code},
63        enums::{OKXOrderStatus, OKXOrderType},
64        parse::prefer_rpi_response_fields,
65    },
66    websocket::client::OKX_RATE_LIMIT_KEY_SUBSCRIPTION,
67};
68
69const SUBSCRIBE_ERROR_PREFIX: &str = "Subscribe failed, wrong URL or channel:";
70const UNSUBSCRIBE_ERROR_PREFIX: &str = "Unsubscribe failed, wrong URL or channel:";
71
72/// Commands sent from the outer client to the inner message handler.
73pub enum HandlerCommand {
74    /// Set the `WebSocketClient` for the handler to use.
75    SetClient(Arc<WebSocketClient>),
76    /// Disconnect the WebSocket connection.
77    Disconnect,
78    /// Subscribe to the given channels.
79    Subscribe { args: Vec<OKXSubscriptionArg> },
80    /// Subscribes to a book and reports completion of the transport send.
81    SubscribeBook {
82        subscription: OKXSubscriptionArg,
83        cancel: CancellationToken,
84        gate: SnapshotGate,
85        completion: tokio::sync::oneshot::Sender<Result<(), OKXWsError>>,
86    },
87    /// Unsubscribe from the given channels.
88    Unsubscribe { args: Vec<OKXSubscriptionArg> },
89    /// Replaces a subscription without removing reconnect intent, unless canceled.
90    Resubscribe {
91        subscription: OKXSubscriptionArg,
92        cancel: CancellationToken,
93        gate: SnapshotGate,
94        completion: tokio::sync::oneshot::Sender<Result<(), OKXWsError>>,
95    },
96    /// Send a pre-serialized payload (used for order operations).
97    Send {
98        payload: String,
99        rate_limit_keys: Option<Vec<Ustr>>,
100        request_id: Option<String>,
101        client_order_ids: Vec<ClientOrderId>,
102        op: Option<OKXWsOperation>,
103    },
104}
105
106impl Debug for HandlerCommand {
107    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
108        match self {
109            Self::SetClient(_) => f.write_str("SetClient"),
110            Self::Disconnect => f.write_str("Disconnect"),
111            Self::Subscribe { args } => f
112                .debug_struct(stringify!(Subscribe))
113                .field("args", args)
114                .finish(),
115            Self::SubscribeBook { subscription, .. } => {
116                f.debug_tuple("SubscribeBook").field(subscription).finish()
117            }
118            Self::Unsubscribe { args } => f
119                .debug_struct(stringify!(Unsubscribe))
120                .field("args", args)
121                .finish(),
122            Self::Resubscribe { subscription, .. } => {
123                f.debug_tuple("Resubscribe").field(subscription).finish()
124            }
125            Self::Send {
126                rate_limit_keys,
127                request_id,
128                client_order_ids,
129                op,
130                ..
131            } => f
132                .debug_struct(stringify!(Send))
133                .field("payload", &REDACTED)
134                .field("rate_limit_keys", rate_limit_keys)
135                .field("request_id", request_id)
136                .field("client_order_ids", client_order_ids)
137                .field("op", op)
138                .finish(),
139        }
140    }
141}
142
143pub(super) struct OKXWsFeedHandler {
144    clock: &'static AtomicTime,
145    signal: Arc<AtomicBool>,
146    inner: Option<Arc<WebSocketClient>>,
147    cmd_rx: tokio::sync::mpsc::UnboundedReceiver<HandlerCommand>,
148    raw_rx: tokio::sync::mpsc::UnboundedReceiver<Message>,
149    out_tx: tokio::sync::mpsc::UnboundedSender<OKXWsMessage>,
150    auth_tracker: AuthTracker,
151    requires_auth: bool,
152    subscriptions_state: SubscriptionState,
153    subscriptions: Arc<DashMap<String, OKXSubscriptionArg>>,
154    retry_manager: RetryManager<OKXWsError>,
155    pending_messages: VecDeque<OKXWsMessage>,
156    pending_sends: VecDeque<PendingSend>,
157    sent_requests: FifoCacheMap<String, SentRequest, PENDING_SENDS_CAPACITY>,
158}
159
160impl OKXWsFeedHandler {
161    /// Creates a new [`OKXWsFeedHandler`] instance.
162    #[expect(
163        clippy::too_many_arguments,
164        reason = "the client supplies its authentication requirement alongside the shared tracker"
165    )]
166    pub(super) fn new(
167        signal: Arc<AtomicBool>,
168        cmd_rx: tokio::sync::mpsc::UnboundedReceiver<HandlerCommand>,
169        raw_rx: tokio::sync::mpsc::UnboundedReceiver<Message>,
170        out_tx: tokio::sync::mpsc::UnboundedSender<OKXWsMessage>,
171        auth_tracker: AuthTracker,
172        requires_auth: bool,
173        subscriptions_state: SubscriptionState,
174        subscriptions: Arc<DashMap<String, OKXSubscriptionArg>>,
175        clock: &'static AtomicTime,
176    ) -> Self {
177        Self {
178            clock,
179            signal,
180            inner: None,
181            cmd_rx,
182            raw_rx,
183            out_tx,
184            auth_tracker,
185            requires_auth,
186            subscriptions_state,
187            subscriptions,
188            retry_manager: create_websocket_retry_manager(),
189            pending_messages: VecDeque::new(),
190            pending_sends: VecDeque::new(),
191            sent_requests: FifoCacheMap::new(),
192        }
193    }
194
195    pub(super) fn is_stopped(&self) -> bool {
196        self.signal.load(Ordering::Acquire)
197    }
198
199    pub(super) fn send(&self, msg: OKXWsMessage) -> Result<(), ()> {
200        self.out_tx.send(msg).map_err(|_| ())
201    }
202
203    async fn send_with_retry(
204        &self,
205        payload: String,
206        rate_limit_keys: Option<&[Ustr]>,
207    ) -> Result<(), OKXWsError> {
208        if let Some(client) = &self.inner {
209            let keys_owned: Option<Vec<Ustr>> = rate_limit_keys.map(<[Ustr]>::to_vec);
210            self.retry_manager
211                .invocation(
212                    "websocket_send",
213                    || {
214                        let payload = payload.clone();
215                        let keys = keys_owned.clone();
216                        async move {
217                            client
218                                .send_text(payload, keys.as_deref())
219                                .await
220                                .map_err(OKXWsError::TransportSend)
221                        }
222                    },
223                    should_retry_replay_safe_error,
224                    create_okx_retry_error,
225                )
226                .execute()
227                .await
228        } else {
229            Err(OKXWsError::NoActiveClient)
230        }
231    }
232
233    async fn send_on_connection(
234        &self,
235        payload: String,
236        rate_limit_keys: Option<&[Ustr]>,
237    ) -> Result<(), OKXWsError> {
238        let client = self.inner.as_ref().ok_or(OKXWsError::NoActiveClient)?;
239        // Capture ownership before checking reconnect so recovery cannot select a replacement
240        let connection_epoch = client.connection_epoch();
241        if client.connection_mode().is_reconnect() {
242            return Err(OKXWsError::TransportSend(SendError::ConnectionChanged));
243        }
244
245        client
246            .send_text_on_connection(payload, rate_limit_keys, connection_epoch)
247            .await
248            .map_err(OKXWsError::TransportSend)
249    }
250
251    pub(super) async fn send_pong(&self) -> anyhow::Result<()> {
252        match self.send_on_connection(TEXT_PONG.to_string(), None).await {
253            Ok(()) => {
254                log::trace!("Sent pong response to OKX text ping");
255                Ok(())
256            }
257            Err(e) => Err(anyhow::anyhow!("Failed to send pong: {e}")),
258        }
259    }
260
261    pub(super) async fn next(&mut self) -> Option<OKXWsMessage> {
262        if let Some(message) = self.pending_messages.pop_front() {
263            return Some(message);
264        }
265
266        let mut poll_raw_next = false;
267
268        loop {
269            if self.signal.load(Ordering::Acquire) {
270                log::debug!("Stop signal received");
271                return None;
272            }
273
274            tokio::select! {
275                biased;
276                () = std::future::ready(()), if !poll_raw_next && self.can_send_pending() => {
277                    self.send_pending().await;
278                    poll_raw_next = true;
279                }
280                Some(cmd) = self.cmd_rx.recv(), if !poll_raw_next => {
281                    match cmd {
282                        HandlerCommand::SetClient(client) => {
283                            log::debug!("Handler received WebSocket client");
284                            self.inner = Some(client);
285                        }
286                        HandlerCommand::Disconnect => {
287                            log::debug!("Handler disconnecting WebSocket client");
288                            self.inner = None;
289                            self.sent_requests.clear();
290                            return None;
291                        }
292                        HandlerCommand::Subscribe { args } => {
293                            if let Err(e) = self.handle_subscribe(args).await {
294                                log::error!("Failed to handle subscribe command: error={e}");
295                            }
296                        }
297                        HandlerCommand::SubscribeBook { subscription, cancel, gate, completion } => {
298                            let result = tokio::select! {
299                                biased;
300                                () = cancel.cancelled() => continue,
301                                result = async {
302                                    let client = self.inner.as_ref().ok_or(OKXWsError::NoActiveClient)?;
303                                    self.send_book_subscription(
304                                        OKXWsOperation::Subscribe,
305                                        subscription,
306                                        client.connection_epoch(),
307                                    ).await
308                                } => result,
309                            };
310
311                            if result.is_ok() {
312                                gate.open();
313                            }
314                            let _ = completion.send(result);
315                        }
316                        HandlerCommand::Unsubscribe { args } => {
317                            if let Err(e) = self.handle_unsubscribe(args).await {
318                                log::error!("Failed to handle unsubscribe command: error={e}");
319                            }
320                        }
321                        HandlerCommand::Resubscribe { subscription, cancel, gate, completion } => {
322                            let result = tokio::select! {
323                                biased;
324                                () = cancel.cancelled() => continue,
325                                result = async {
326                                    self.subscriptions_state.mark_failure(&topic_from_subscription_arg(&subscription));
327                                    let client = self.inner.as_ref().ok_or(OKXWsError::NoActiveClient)?;
328                                    let epoch = client.connection_epoch();
329                                    self.send_book_subscription(
330                                        OKXWsOperation::Unsubscribe,
331                                        subscription.clone(),
332                                        epoch,
333                                    ).await?;
334                                    self.send_book_subscription(
335                                        OKXWsOperation::Subscribe,
336                                        subscription,
337                                        epoch,
338                                    ).await
339                                } => result,
340                            };
341
342                            if result.is_ok() {
343                                gate.open();
344                            }
345                            let _ = completion.send(result);
346                        }
347                        HandlerCommand::Send {
348                            payload,
349                            rate_limit_keys,
350                            request_id,
351                            client_order_ids,
352                            op,
353                        } => {
354                            let pending = PendingSend {
355                                payload,
356                                rate_limit_keys,
357                                request_id,
358                                client_order_ids,
359                                op,
360                                attempted: false,
361                            };
362
363                            if self.inner.is_none() {
364                                self.fail_send(pending, OKXWsError::NoActiveClient);
365                            } else if self.pending_sends.len() >= PENDING_SENDS_CAPACITY {
366                                self.fail_send(pending, OKXWsError::TransportSend(SendError::BufferFull));
367                            } else {
368                                log::debug!(
369                                    "Retained WebSocket command: request_id={:?}, op={:?}, mode={:?}",
370                                    pending.request_id,
371                                    pending.op,
372                                    self.inner.as_ref().map(|client| client.connection_mode()),
373                                );
374                                self.pending_sends.push_back(pending);
375                            }
376                        }
377                    }
378
379                    poll_raw_next = true;
380                }
381
382                msg = self.raw_rx.recv() => {
383                    let event = match msg {
384                        Some(msg) => match Self::parse_raw_message(msg) {
385                            Some(event) => event,
386                            None => continue,
387                        },
388                        None => {
389                            log::debug!("WebSocket stream closed");
390                            return None;
391                        }
392                    };
393
394                    match event {
395                        OKXWsFrame::Ping => {
396                            if let Err(e) = self.send_pong().await {
397                                log::warn!("Failed to send pong response: error={e}");
398                            }
399                        }
400                        OKXWsFrame::Login {
401                            code, msg, conn_id, ..
402                        } => {
403                            if code == OKX_SUCCESS_CODE {
404                                self.auth_tracker.succeed();
405                                return Some(OKXWsMessage::Authenticated);
406                            }
407
408                            self.auth_tracker.fail(msg.clone());
409
410                            let error = OKXWebSocketError {
411                                code,
412                                message: msg,
413                                conn_id: Some(conn_id),
414                                timestamp: self.clock.get_time_ns().as_u64(),
415                            };
416                            self.pending_messages.push_back(OKXWsMessage::Error(error));
417                        }
418                        OKXWsFrame::BookData { arg, action, data } => {
419                            return Some(OKXWsMessage::BookData { arg, action, data });
420                        }
421                        OKXWsFrame::RpiBookData { arg, action, data } => {
422                            return Some(OKXWsMessage::RpiBookData { arg, action, data });
423                        }
424                        OKXWsFrame::OrderResponse {
425                            id, op, code, msg, data,
426                        } => {
427                            let client_order_ids = id
428                                .as_ref()
429                                .and_then(|id| {
430                                    let request = self.sent_requests.get(id)?;
431
432                                    if request.op != op {
433                                        return None;
434                                    }
435
436                                    self.sent_requests.remove(id)
437                                })
438                                .filter(|request| request.sent_at.elapsed() < ORDER_RESPONSE_TTL)
439                                .map_or_else(Vec::new, |request| request.client_order_ids);
440
441                            return Some(OKXWsMessage::OrderResponse {
442                                id, op, code, msg, data, client_order_ids,
443                            });
444                        }
445                        OKXWsFrame::Data { arg, data } => {
446                            if let Some(output) = self.route_data_message(arg, data) {
447                                return Some(output);
448                            }
449                        }
450                        OKXWsFrame::Error { arg, code, msg } => {
451                            self.handle_login_error(&code, &msg);
452                            let arg = arg.or_else(|| subscription_arg_from_error_message(&msg));
453                            if let Some(arg) = arg
454                                && self.handle_subscription_error(&arg, &code, &msg)
455                            {
456                                return Some(OKXWsMessage::SubscriptionFailed {
457                                    channel: arg.channel,
458                                    inst_id: arg.inst_id,
459                                    code,
460                                    msg,
461                                });
462                            }
463
464                            let error = OKXWebSocketError {
465                                code,
466                                message: msg,
467                                conn_id: None,
468                                timestamp: self.clock.get_time_ns().as_u64(),
469                            };
470                            return Some(OKXWsMessage::Error(error));
471                        }
472                        OKXWsFrame::Reconnected => {
473                            return Some(OKXWsMessage::Reconnected);
474                        }
475                        OKXWsFrame::Subscription {
476                            event, arg, code, msg,
477                            ..
478                        } => {
479                            let rejected = self
480                                .handle_subscription_ack(&event, &arg, code.as_deref(), msg.as_deref());
481
482                            if rejected {
483                                return Some(OKXWsMessage::SubscriptionFailed {
484                                    channel: arg.channel,
485                                    inst_id: arg.inst_id,
486                                    code: code.unwrap_or_default(),
487                                    msg: msg.unwrap_or_default(),
488                                });
489                            }
490                        }
491                        OKXWsFrame::ChannelConnCount { .. } => {}
492                    }
493                }
494
495                () = std::future::ready(()), if poll_raw_next => {
496                    poll_raw_next = false;
497                }
498
499                // Polled last so a ready message never registers and drops a timer
500                () = time::sleep(time::Duration::from_millis(100)) => {
501                    // Wake the loop to poll the stop signal while both channels are idle
502                }
503
504                else => {
505                    log::debug!("Handler shutting down: stream ended or command channel closed");
506                    return None;
507                }
508            }
509        }
510    }
511
512    fn can_send_pending(&self) -> bool {
513        !self.pending_sends.is_empty()
514            && (!self.requires_auth || self.auth_tracker.is_authenticated())
515            && self.inner.as_ref().is_some_and(|client| client.is_active())
516    }
517
518    async fn send_pending(&mut self) {
519        let client = self.inner.as_ref().expect("pending send requires a client");
520        let epoch = client.connection_epoch();
521
522        if self.requires_auth && !self.auth_tracker.is_authenticated() {
523            return;
524        }
525
526        let pending = self.pending_sends.front_mut().expect("pending send exists");
527        pending.attempted = true;
528        let result = client
529            .send_text_on_connection(
530                pending.payload.clone(),
531                pending.rate_limit_keys.as_deref(),
532                epoch,
533            )
534            .await;
535
536        if matches!(result, Err(SendError::ConnectionChanged)) {
537            pending.attempted = false;
538            self.auth_tracker.invalidate();
539            return;
540        }
541
542        if matches!(result, Err(SendError::Timeout)) {
543            self.auth_tracker.invalidate();
544        }
545
546        let pending = self.pending_sends.pop_front().expect("pending send exists");
547
548        if (result.is_ok()
549            || matches!(
550                result,
551                Err(SendError::WriteTimeout | SendError::BrokenPipe(_))
552            ))
553            && let (Some(request_id), Some(op)) = (&pending.request_id, &pending.op)
554        {
555            // A buffered reply can still arrive after a reconnect or an uncertain write
556            self.sent_requests.insert(
557                request_id.clone(),
558                SentRequest {
559                    op: op.clone(),
560                    client_order_ids: pending.client_order_ids.clone(),
561                    sent_at: time::Instant::now(),
562                },
563            );
564        }
565
566        if let Err(e) = result {
567            self.fail_send(pending, OKXWsError::TransportSend(e));
568        }
569    }
570
571    fn fail_send(&self, pending: PendingSend, error: OKXWsError) {
572        if let Some(request_id) = pending.request_id {
573            let message = OKXWsMessage::SendFailed {
574                request_id,
575                client_order_ids: pending.client_order_ids,
576                op: pending.op,
577                error,
578            };
579
580            if self.send(message).is_err() {
581                if !self.is_stopped() {
582                    log::error!("Failed to forward WebSocket send failure: receiver dropped");
583                }
584
585                self.signal.store(true, Ordering::Release);
586            }
587        }
588    }
589
590    fn route_data_message(&self, arg: OKXWebSocketArg, mut data: Value) -> Option<OKXWsMessage> {
591        let OKXWebSocketArg {
592            channel, inst_id, ..
593        } = arg;
594
595        match channel {
596            OKXWsChannel::Account => Some(OKXWsMessage::Account(data)),
597            OKXWsChannel::Positions => Some(OKXWsMessage::Positions(data)),
598            OKXWsChannel::Orders => {
599                parse_array_items(data, "orders", false).map(OKXWsMessage::Orders)
600            }
601            OKXWsChannel::SprdOrders => {
602                parse_array_items(data, "spread orders", false).map(OKXWsMessage::SpreadOrders)
603            }
604            OKXWsChannel::OrdersAlgo | OKXWsChannel::AlgoAdvance => {
605                parse_array_items(data, "algo orders", false).map(OKXWsMessage::AlgoOrders)
606            }
607            OKXWsChannel::LiquidationWarning => {
608                parse_array_items(data, "liquidation warnings", false)
609                    .map(OKXWsMessage::LiquidationWarnings)
610            }
611            OKXWsChannel::Instruments => {
612                prefer_rpi_response_fields(&mut data);
613                parse_array_items(data, "instruments", true).map(OKXWsMessage::Instruments)
614            }
615            _ => Some(OKXWsMessage::ChannelData {
616                channel,
617                inst_id,
618                data,
619            }),
620        }
621    }
622
623    fn handle_subscription_ack(
624        &self,
625        event: &OKXSubscriptionEvent,
626        arg: &OKXWebSocketArg,
627        code: Option<&str>,
628        msg: Option<&str>,
629    ) -> bool {
630        let topic = topic_from_websocket_arg(arg);
631        let success = code.is_none_or(|c| c == OKX_SUCCESS_CODE);
632
633        match event {
634            OKXSubscriptionEvent::Subscribe => {
635                if success {
636                    self.subscriptions_state.confirm_subscribe(&topic);
637                    false
638                } else {
639                    log::warn!(
640                        "Subscription failed: topic={topic:?}, error={msg:?}, code={code:?}"
641                    );
642                    self.subscriptions_state.mark_failure(&topic);
643                    true
644                }
645            }
646            OKXSubscriptionEvent::Unsubscribe => {
647                if success {
648                    let entry = self.subscriptions.entry(topic.clone());
649                    self.subscriptions_state.confirm_unsubscribe(&topic);
650                    if !is_topic_subscribed(&self.subscriptions_state, &topic)
651                        && let Entry::Occupied(entry) = entry
652                    {
653                        entry.remove();
654                    }
655                } else {
656                    log::warn!(
657                        "Unsubscription failed - restoring subscription: \
658                         topic={topic:?}, error={msg:?}, code={code:?}"
659                    );
660                    self.subscriptions_state.confirm_unsubscribe(&topic);
661                    self.subscriptions_state.mark_subscribe(&topic);
662                    self.subscriptions_state.confirm_subscribe(&topic);
663                }
664                false
665            }
666        }
667    }
668
669    fn handle_login_error(&self, code: &str, msg: &str) {
670        if self.requires_auth
671            && !self.auth_tracker.is_authenticated()
672            && matches!(
673                code,
674                "60004"
675                    | "60005"
676                    | "60006"
677                    | "60007"
678                    | "60009"
679                    | "60023"
680                    | "60024"
681                    | "60026"
682                    | "60031"
683                    | "60032"
684                    | "63999"
685            )
686        {
687            self.auth_tracker
688                .fail(format!("OKX authentication error {code}: {msg}"));
689        }
690    }
691
692    fn handle_subscription_error(&self, arg: &OKXWebSocketArg, code: &str, msg: &str) -> bool {
693        let topic = topic_from_websocket_arg(arg);
694
695        let event = if msg.starts_with(SUBSCRIBE_ERROR_PREFIX) {
696            Some(OKXSubscriptionEvent::Subscribe)
697        } else if msg.starts_with(UNSUBSCRIBE_ERROR_PREFIX) {
698            Some(OKXSubscriptionEvent::Unsubscribe)
699        } else {
700            None
701        };
702
703        if let Some(event) = event {
704            return self.handle_subscription_ack(&event, arg, Some(code), Some(msg));
705        }
706
707        let event = if self
708            .subscriptions_state
709            .pending_unsubscribe_topics()
710            .iter()
711            .any(|pending| pending == &topic)
712        {
713            OKXSubscriptionEvent::Unsubscribe
714        } else if self
715            .subscriptions_state
716            .pending_subscribe_topics()
717            .iter()
718            .any(|pending| pending == &topic)
719            || (arg.channel.is_book()
720                && self
721                    .subscriptions_state
722                    .all_topics()
723                    .iter()
724                    .any(|tracked| tracked == &topic))
725        {
726            OKXSubscriptionEvent::Subscribe
727        } else {
728            return false;
729        };
730
731        self.handle_subscription_ack(&event, arg, Some(code), Some(msg))
732    }
733
734    async fn send_book_subscription(
735        &self,
736        op: OKXWsOperation,
737        subscription: OKXSubscriptionArg,
738        connection_epoch: u64,
739    ) -> Result<(), OKXWsError> {
740        let client = self.inner.as_ref().ok_or(OKXWsError::NoActiveClient)?;
741        let message = OKXSubscription {
742            op,
743            args: vec![subscription],
744        };
745        let payload =
746            serde_json::to_string(&message).map_err(|e| OKXWsError::ClientError(e.to_string()))?;
747
748        client
749            .send_text_on_connection(
750                payload,
751                Some(OKX_RATE_LIMIT_KEY_SUBSCRIPTION.as_slice()),
752                connection_epoch,
753            )
754            .await
755            .map_err(OKXWsError::TransportSend)
756    }
757
758    async fn handle_subscribe(&self, args: Vec<OKXSubscriptionArg>) -> anyhow::Result<()> {
759        for arg in &args {
760            log::debug!(
761                "Subscribing to channel: channel={:?}, inst_id={:?}",
762                arg.channel,
763                arg.inst_id
764            );
765        }
766
767        let message = OKXSubscription {
768            op: OKXWsOperation::Subscribe,
769            args,
770        };
771
772        let json_txt = serde_json::to_string(&message)
773            .map_err(|e| anyhow::anyhow!("Failed to serialize subscription: {e}"))?;
774
775        self.send_with_retry(json_txt, Some(OKX_RATE_LIMIT_KEY_SUBSCRIPTION.as_slice()))
776            .await
777            .map_err(|e| anyhow::anyhow!("Failed to send subscription after retries: {e}"))?;
778        Ok(())
779    }
780
781    async fn handle_unsubscribe(&self, args: Vec<OKXSubscriptionArg>) -> anyhow::Result<()> {
782        for arg in &args {
783            log::debug!(
784                "Unsubscribing from channel: channel={:?}, inst_id={:?}",
785                arg.channel,
786                arg.inst_id
787            );
788        }
789
790        let message = OKXSubscription {
791            op: OKXWsOperation::Unsubscribe,
792            args,
793        };
794
795        let json_txt = serde_json::to_string(&message)
796            .map_err(|e| anyhow::anyhow!("Failed to serialize unsubscription: {e}"))?;
797
798        self.send_with_retry(json_txt, Some(OKX_RATE_LIMIT_KEY_SUBSCRIPTION.as_slice()))
799            .await
800            .map_err(|e| anyhow::anyhow!("Failed to send unsubscription after retries: {e}"))?;
801
802        Ok(())
803    }
804
805    pub(crate) fn parse_raw_message(
806        msg: tokio_tungstenite::tungstenite::Message,
807    ) -> Option<OKXWsFrame> {
808        match msg {
809            tokio_tungstenite::tungstenite::Message::Text(text) => {
810                if text == TEXT_PONG {
811                    log::trace!("Received pong from OKX");
812                    return None;
813                }
814
815                if text == TEXT_PING {
816                    log::trace!("Received ping from OKX (text)");
817                    return Some(OKXWsFrame::Ping);
818                }
819
820                if text == RECONNECTED {
821                    log::debug!("Received WebSocket reconnection signal");
822                    return Some(OKXWsFrame::Reconnected);
823                }
824                log::trace!("Received WebSocket message: {text}");
825
826                match serde_json::from_str(&text) {
827                    Ok(ws_event) => match &ws_event {
828                        OKXWsFrame::Error { arg, code, msg } => {
829                            let level = error_frame_level(arg.as_ref(), code, msg);
830                            log::log!(level, "WebSocket error: {code} - {msg}");
831                            Some(ws_event)
832                        }
833                        OKXWsFrame::Login {
834                            event,
835                            code,
836                            msg,
837                            conn_id,
838                        } => {
839                            if code == OKX_SUCCESS_CODE {
840                                log::debug!("WebSocket authenticated: conn_id={conn_id}");
841                            } else {
842                                log::error!(
843                                    "WebSocket authentication failed: \
844                                     event={event}, code={code}, error={msg}"
845                                );
846                            }
847                            Some(ws_event)
848                        }
849                        OKXWsFrame::Subscription {
850                            event,
851                            arg,
852                            conn_id,
853                            ..
854                        } => {
855                            let channel_str = serde_json::to_string(&arg.channel)
856                                .expect("Invalid OKX websocket channel")
857                                .trim_matches('"')
858                                .to_string();
859                            log::debug!("{event}d: channel={channel_str}, conn_id={conn_id}");
860                            Some(ws_event)
861                        }
862                        OKXWsFrame::ChannelConnCount {
863                            channel,
864                            conn_count,
865                            conn_id,
866                            ..
867                        } => {
868                            let channel_str = serde_json::to_string(channel)
869                                .expect("Invalid OKX websocket channel")
870                                .trim_matches('"')
871                                .to_string();
872                            log::debug!(
873                                "Channel connection status: \
874                                 channel={channel_str}, connections={conn_count}, conn_id={conn_id}",
875                            );
876                            None
877                        }
878                        OKXWsFrame::Ping => {
879                            log::trace!("Ignoring ping event parsed from text payload");
880                            None
881                        }
882                        OKXWsFrame::Data { .. }
883                        | OKXWsFrame::BookData { .. }
884                        | OKXWsFrame::RpiBookData { .. } => Some(ws_event),
885                        OKXWsFrame::OrderResponse {
886                            id, op, code, data, ..
887                        } => {
888                            if code == OKX_SUCCESS_CODE {
889                                log::debug!(
890                                    "Order operation successful: id={id:?}, op={op}, code={code}"
891                                );
892
893                                if let Some(order_data) = data.first() {
894                                    let success_msg = order_data
895                                        .get(OKX_FIELD_SMSG)
896                                        .and_then(|s| s.as_str())
897                                        .unwrap_or("Order operation successful");
898                                    log::debug!("Order success details: {success_msg}");
899                                }
900                            }
901                            Some(ws_event)
902                        }
903                        OKXWsFrame::Reconnected => {
904                            log::warn!("Unexpected Reconnected event from deserialization");
905                            None
906                        }
907                    },
908                    Err(e) => {
909                        log::error!("Failed to parse message: {e}: {text}");
910                        None
911                    }
912                }
913            }
914            Message::Ping(_payload) => {
915                log::trace!("Received binary ping frame from OKX");
916                Some(OKXWsFrame::Ping)
917            }
918            Message::Pong(payload) => {
919                log::trace!("Received pong frame from OKX ({} bytes)", payload.len());
920                None
921            }
922            Message::Binary(msg) => {
923                log::debug!("Raw binary frame ({} bytes)", msg.len());
924                log::trace!("Raw binary: {msg:?}");
925                None
926            }
927            Message::Close(_) => {
928                log::debug!("Received close message");
929                None
930            }
931            msg => {
932                log::warn!("Unexpected message: {msg}");
933                None
934            }
935        }
936    }
937}
938
939// Book recovery retries a rejected book subscription and reports its own failure
940fn error_frame_level(arg: Option<&OKXWebSocketArg>, code: &str, msg: &str) -> log::Level {
941    let book = match arg {
942        Some(arg) => arg.channel.is_book(),
943        None => subscription_arg_from_error_message(msg).is_some_and(|arg| arg.channel.is_book()),
944    };
945
946    if should_retry_error_code(code) || book {
947        log::Level::Warn
948    } else {
949        log::Level::Error
950    }
951}
952
953fn subscription_arg_from_error_message(msg: &str) -> Option<OKXWebSocketArg> {
954    let descriptor = [
955        "Wrong URL or channel:",
956        SUBSCRIBE_ERROR_PREFIX,
957        UNSUBSCRIBE_ERROR_PREFIX,
958    ]
959    .into_iter()
960    .find_map(|prefix| msg.strip_prefix(prefix))?
961    .split_whitespace()
962    .next()?;
963    let mut fields = descriptor.split(',');
964    let channel = fields.next()?;
965    let mut arg = Map::new();
966    arg.insert("channel".to_string(), Value::String(channel.to_string()));
967
968    for field in fields {
969        let (key, value) = field.split_once(':')?;
970        if !matches!(key, "instId" | "sprdId" | "instType" | "instFamily") {
971            return None;
972        }
973        arg.insert(key.to_string(), Value::String(value.to_string()));
974    }
975
976    serde_json::from_value(Value::Object(arg)).ok()
977}
978
979/// Returns `true` when an OKX WebSocket order message represents a post-only auto-cancel.
980pub fn is_post_only_auto_cancel(msg: &OKXOrderMsg) -> bool {
981    use crate::common::{consts::OKX_POST_ONLY_CANCEL_SOURCE, enums::OKXOrderStatus};
982
983    if msg.state != OKXOrderStatus::Canceled {
984        return false;
985    }
986
987    let cancel_source_matches = matches!(
988        msg.cancel_source.as_deref(),
989        Some(source) if source == OKX_POST_ONLY_CANCEL_SOURCE
990    );
991
992    let reason_matches = matches!(
993        msg.cancel_source_reason.as_deref(),
994        Some(reason) if reason.contains("POST_ONLY")
995    );
996
997    if !(cancel_source_matches || reason_matches) {
998        return false;
999    }
1000
1001    msg.acc_fill_sz
1002        .as_ref()
1003        .is_none_or(|filled| filled == "0" || filled.is_empty())
1004}
1005
1006/// Returns `true` when an RPI order update is canceled without any fill.
1007pub fn is_unfilled_rpi_cancel(msg: &OKXOrderMsg) -> bool {
1008    msg.ord_type == OKXOrderType::Rpi
1009        && msg.state == OKXOrderStatus::Canceled
1010        && msg
1011            .acc_fill_sz
1012            .as_ref()
1013            .is_none_or(|filled| filled == "0" || filled.is_empty())
1014}
1015
1016// Per-item deserialization so one malformed entry does not drop the batch.
1017fn parse_array_items<T: serde::de::DeserializeOwned>(
1018    data: Value,
1019    label: &str,
1020    warn_on_parse_error: bool,
1021) -> Option<Vec<T>> {
1022    let Value::Array(items) = data else {
1023        if warn_on_parse_error {
1024            log::warn!("Expected {label} payload to be a JSON array");
1025        } else {
1026            log::error!("Expected {label} payload to be a JSON array");
1027        }
1028        return None;
1029    };
1030
1031    let mut parsed = Vec::with_capacity(items.len());
1032    for (idx, item) in items.into_iter().enumerate() {
1033        match serde_json::from_value::<T>(item) {
1034            Ok(value) => parsed.push(value),
1035            Err(e) => {
1036                if warn_on_parse_error {
1037                    log::warn!("Failed to parse {label} item at index {idx}: {e}");
1038                } else {
1039                    log::error!("Failed to parse {label} item at index {idx}: {e}");
1040                }
1041            }
1042        }
1043    }
1044
1045    if parsed.is_empty() {
1046        None
1047    } else {
1048        Some(parsed)
1049    }
1050}
1051
1052const PENDING_SENDS_CAPACITY: usize = 1_024;
1053const ORDER_RESPONSE_TTL: time::Duration = time::Duration::from_secs(60);
1054
1055struct SentRequest {
1056    op: OKXWsOperation,
1057    client_order_ids: Vec<ClientOrderId>,
1058    sent_at: time::Instant,
1059}
1060
1061struct PendingSend {
1062    payload: String,
1063    rate_limit_keys: Option<Vec<Ustr>>,
1064    request_id: Option<String>,
1065    client_order_ids: Vec<ClientOrderId>,
1066    op: Option<OKXWsOperation>,
1067    attempted: bool,
1068}
1069
1070impl Drop for OKXWsFeedHandler {
1071    fn drop(&mut self) {
1072        self.cmd_rx.close();
1073
1074        while let Some(pending) = self.pending_sends.pop_front() {
1075            let error = if pending.attempted {
1076                OKXWsError::SendFailed(
1077                    "handler stopped before the write outcome was known".to_string(),
1078                )
1079            } else {
1080                OKXWsError::TransportSend(SendError::Closed)
1081            };
1082
1083            self.fail_send(pending, error);
1084        }
1085
1086        while let Ok(command) = self.cmd_rx.try_recv() {
1087            if let HandlerCommand::Send {
1088                payload,
1089                rate_limit_keys,
1090                request_id,
1091                client_order_ids,
1092                op,
1093            } = command
1094            {
1095                self.fail_send(
1096                    PendingSend {
1097                        payload,
1098                        rate_limit_keys,
1099                        request_id,
1100                        client_order_ids,
1101                        op,
1102                        attempted: false,
1103                    },
1104                    OKXWsError::TransportSend(SendError::Closed),
1105                );
1106            }
1107        }
1108    }
1109}
1110
1111fn should_retry_replay_safe_error(error: &OKXWsError) -> bool {
1112    match error {
1113        OKXWsError::OkxError { error_code, .. } => should_retry_error_code(error_code),
1114        OKXWsError::TransportSend(SendError::Timeout | SendError::ConnectionChanged)
1115        | OKXWsError::TungsteniteError(_)
1116        | OKXWsError::OperationTimeout { .. } => true,
1117        OKXWsError::AuthenticationError(_)
1118        | OKXWsError::JsonError(_)
1119        | OKXWsError::ParsingError(_)
1120        | OKXWsError::ClientError(_)
1121        | OKXWsError::NoActiveClient
1122        | OKXWsError::HandlerUnavailable(_)
1123        | OKXWsError::TransportSend(
1124            SendError::InvalidInput(_)
1125            | SendError::BufferFull
1126            | SendError::Closed
1127            | SendError::WriteTimeout
1128            | SendError::BrokenPipe(_),
1129        )
1130        | OKXWsError::SendFailed(_) => false,
1131    }
1132}
1133
1134fn create_okx_retry_error(error: RetryError) -> OKXWsError {
1135    match error {
1136        RetryError::OperationTimeout { timeout_ms } => OKXWsError::OperationTimeout { timeout_ms },
1137        RetryError::InvalidConfiguration { message } => OKXWsError::ClientError(message),
1138        RetryError::Canceled => {
1139            OKXWsError::SendFailed("Adapter disconnecting or shutting down".to_string())
1140        }
1141        error @ RetryError::ElapsedBudgetExceeded { .. } => {
1142            OKXWsError::SendFailed(error.to_string())
1143        }
1144    }
1145}
1146
1147#[cfg(test)]
1148mod tests {
1149    use std::{
1150        num::NonZeroU32,
1151        sync::{Arc, atomic::AtomicBool},
1152        time::Duration,
1153    };
1154
1155    use ahash::AHashMap;
1156    use futures_util::{SinkExt, StreamExt};
1157    use nautilus_common::messages::ExecutionEvent;
1158    use nautilus_core::{collections::AtomicMap, time::get_atomic_clock_realtime};
1159    use nautilus_live::{ExecutionEventEmitter, execution::context::OrderIdentity};
1160    use nautilus_model::{
1161        enums::{AccountType, OrderSide, OrderType},
1162        events::OrderEventAny,
1163        identifiers::{AccountId, InstrumentId, StrategyId, TraderId},
1164    };
1165    use nautilus_network::{
1166        mode::{ConnectionMode, ReconnectRequestOutcome},
1167        ratelimiter::{RateLimiter, quota::Quota},
1168        websocket::{
1169            AuthTracker, SubscriptionState, TransportBackend, WebSocketConfig,
1170            channel_message_handler,
1171        },
1172    };
1173    use rstest::rstest;
1174    use serde_json::json;
1175
1176    use super::*;
1177    use crate::{
1178        book::{BookChannelScope, BookSequenceOutcome, sync::BookSyncTracker},
1179        common::{
1180            consts::OKX_WS_TOPIC_DELIMITER,
1181            enums::{OKXBookAction, OKXBookChannel, OKXRpiPermission},
1182            testing::load_test_json,
1183        },
1184        websocket::{
1185            client::PendingOrderInfo,
1186            dispatch::{WsDispatchState, dispatch_ws_message},
1187            parse::{FeeCache, FilledQtyCache},
1188        },
1189    };
1190
1191    fn create_handler() -> OKXWsFeedHandler {
1192        let signal = Arc::new(AtomicBool::new(false));
1193        let (_cmd_tx, cmd_rx) = tokio::sync::mpsc::unbounded_channel();
1194        let (_raw_tx, raw_rx) = tokio::sync::mpsc::unbounded_channel();
1195        let (out_tx, _out_rx) = tokio::sync::mpsc::unbounded_channel();
1196
1197        OKXWsFeedHandler::new(
1198            signal,
1199            cmd_rx,
1200            raw_rx,
1201            out_tx,
1202            AuthTracker::new(),
1203            false,
1204            SubscriptionState::new(OKX_WS_TOPIC_DELIMITER),
1205            Arc::new(DashMap::new()),
1206            get_atomic_clock_realtime(),
1207        )
1208    }
1209
1210    #[rstest]
1211    fn test_command_debug_redacts_payloads() {
1212        let payload = "authentication-secret";
1213
1214        let send = HandlerCommand::Send {
1215            payload: payload.to_string(),
1216            rate_limit_keys: None,
1217            request_id: None,
1218            client_order_ids: Vec::new(),
1219            op: None,
1220        };
1221
1222        let debug = format!("{send:?}");
1223
1224        assert!(debug.contains(REDACTED));
1225        assert!(!debug.contains(payload));
1226    }
1227
1228    #[rstest]
1229    #[case::submit(OKXWsOperation::Order)]
1230    #[case::cancel(OKXWsOperation::CancelOrder)]
1231    #[case::amend(OKXWsOperation::AmendOrder)]
1232    #[tokio::test]
1233    async fn send_failure_returns_without_inbound_frame(#[case] op: OKXWsOperation) {
1234        let (cmd_tx, cmd_rx) = tokio::sync::mpsc::unbounded_channel();
1235        let (_raw_tx, raw_rx) = tokio::sync::mpsc::unbounded_channel();
1236        let (out_tx, mut out_rx) = tokio::sync::mpsc::unbounded_channel();
1237
1238        let mut handler = OKXWsFeedHandler::new(
1239            Arc::new(AtomicBool::new(false)),
1240            cmd_rx,
1241            raw_rx,
1242            out_tx,
1243            AuthTracker::new(),
1244            false,
1245            SubscriptionState::new(OKX_WS_TOPIC_DELIMITER),
1246            Arc::new(DashMap::new()),
1247            get_atomic_clock_realtime(),
1248        );
1249        let client_order_id = ClientOrderId::from("O-disconnected");
1250        cmd_tx
1251            .send(HandlerCommand::Send {
1252                payload: String::new(),
1253                rate_limit_keys: None,
1254                request_id: Some("disconnected-request".to_string()),
1255                client_order_ids: vec![client_order_id],
1256                op: Some(op.clone()),
1257            })
1258            .unwrap();
1259
1260        let message = tokio::time::timeout(Duration::from_secs(1), async {
1261            tokio::select! {
1262                message = out_rx.recv() => message,
1263                message = handler.next() => panic!("Unexpected handler return: {message:?}"),
1264            }
1265        })
1266        .await
1267        .expect("send failure must not wait for an inbound frame");
1268
1269        let Some(OKXWsMessage::SendFailed {
1270            request_id,
1271            client_order_ids,
1272            op: failed_op,
1273            error,
1274        }) = message
1275        else {
1276            panic!("Expected send failure, received {message:?}");
1277        };
1278
1279        assert_eq!(request_id, "disconnected-request");
1280        assert_eq!(client_order_ids, vec![client_order_id]);
1281        assert_eq!(failed_op, Some(op));
1282        assert!(matches!(error, OKXWsError::NoActiveClient));
1283    }
1284
1285    #[tokio::test]
1286    async fn send_failures_preserve_raw_message_fairness() {
1287        let (cmd_tx, cmd_rx) = tokio::sync::mpsc::unbounded_channel();
1288        let (raw_tx, raw_rx) = tokio::sync::mpsc::unbounded_channel();
1289        let (out_tx, mut out_rx) = tokio::sync::mpsc::unbounded_channel();
1290
1291        let mut handler = OKXWsFeedHandler::new(
1292            Arc::new(AtomicBool::new(false)),
1293            cmd_rx,
1294            raw_rx,
1295            out_tx,
1296            AuthTracker::new(),
1297            false,
1298            SubscriptionState::new(OKX_WS_TOPIC_DELIMITER),
1299            Arc::new(DashMap::new()),
1300            get_atomic_clock_realtime(),
1301        );
1302
1303        for request_id in ["first-cancel", "second-cancel"] {
1304            cmd_tx
1305                .send(HandlerCommand::Send {
1306                    payload: String::new(),
1307                    rate_limit_keys: None,
1308                    request_id: Some(request_id.to_string()),
1309                    client_order_ids: vec![ClientOrderId::from("O-disconnected")],
1310                    op: Some(OKXWsOperation::CancelOrder),
1311                })
1312                .unwrap();
1313        }
1314
1315        raw_tx
1316            .send(Message::Text(RECONNECTED.to_string().into()))
1317            .unwrap();
1318
1319        raw_tx
1320            .send(Message::Text(RECONNECTED.to_string().into()))
1321            .unwrap();
1322
1323        let messages = tokio::time::timeout(Duration::from_secs(1), async {
1324            for _ in 0..2 {
1325                let message = handler.next().await.expect("raw message");
1326                handler.send(message).unwrap();
1327            }
1328
1329            [
1330                out_rx.recv().await,
1331                out_rx.recv().await,
1332                out_rx.recv().await,
1333                out_rx.recv().await,
1334            ]
1335        })
1336        .await
1337        .expect("failures and reconnect must arrive without more input");
1338
1339        assert!(
1340            matches!(&messages[0], Some(OKXWsMessage::SendFailed { request_id, .. })
1341            if request_id == "first-cancel")
1342        );
1343        assert!(matches!(messages[1], Some(OKXWsMessage::Reconnected)));
1344        assert!(
1345            matches!(&messages[2], Some(OKXWsMessage::SendFailed { request_id, .. })
1346            if request_id == "second-cancel")
1347        );
1348        assert!(matches!(messages[3], Some(OKXWsMessage::Reconnected)));
1349        assert!(handler.pending_messages.is_empty());
1350        assert!(handler.cmd_rx.is_empty());
1351    }
1352
1353    #[tokio::test]
1354    async fn test_next_polls_raw_after_one_ready_command() {
1355        let signal = Arc::new(AtomicBool::new(false));
1356        let (cmd_tx, cmd_rx) = tokio::sync::mpsc::unbounded_channel();
1357        let (raw_tx, raw_rx) = tokio::sync::mpsc::unbounded_channel();
1358        let (out_tx, _out_rx) = tokio::sync::mpsc::unbounded_channel();
1359        let mut handler = OKXWsFeedHandler::new(
1360            signal,
1361            cmd_rx,
1362            raw_rx,
1363            out_tx,
1364            AuthTracker::new(),
1365            false,
1366            SubscriptionState::new(OKX_WS_TOPIC_DELIMITER),
1367            Arc::new(DashMap::new()),
1368            get_atomic_clock_realtime(),
1369        );
1370
1371        for _ in 0..3 {
1372            cmd_tx
1373                .send(HandlerCommand::Subscribe { args: Vec::new() })
1374                .unwrap();
1375        }
1376        raw_tx
1377            .send(Message::Text(RECONNECTED.to_string().into()))
1378            .unwrap();
1379
1380        let message = handler.next().await;
1381
1382        assert!(matches!(message, Some(OKXWsMessage::Reconnected)));
1383        assert_eq!(handler.cmd_rx.len(), 2);
1384    }
1385
1386    #[rstest]
1387    #[case::sent(false)]
1388    #[case::canceled(true)]
1389    #[tokio::test]
1390    async fn initial_book_completion_waits_for_send(#[case] canceled: bool) {
1391        let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
1392        let url = format!("ws://{}/", listener.local_addr().unwrap());
1393        let (wire_tx, mut wire_rx) = tokio::sync::mpsc::unbounded_channel();
1394
1395        let server = tokio::spawn(async move {
1396            let (socket, _) = listener.accept().await.unwrap();
1397            let mut socket = tokio_tungstenite::accept_async(socket).await.unwrap();
1398            while let Some(Ok(frame)) = socket.next().await {
1399                wire_tx.send(frame).unwrap();
1400            }
1401        });
1402
1403        let (message_handler, raw_rx) = channel_message_handler();
1404        let client = WebSocketClient::builder()
1405            .config(WebSocketConfig::builder().url(url).build().unwrap())
1406            .message_handler(message_handler)
1407            .default_quota(Quota::with_period(Duration::from_secs(10)).unwrap())
1408            .connect()
1409            .await
1410            .unwrap();
1411        let (cmd_tx, cmd_rx) = tokio::sync::mpsc::unbounded_channel();
1412        let (out_tx, _out_rx) = tokio::sync::mpsc::unbounded_channel();
1413
1414        let mut handler = OKXWsFeedHandler::new(
1415            Arc::new(AtomicBool::new(false)),
1416            cmd_rx,
1417            raw_rx,
1418            out_tx,
1419            AuthTracker::new(),
1420            false,
1421            SubscriptionState::new(OKX_WS_TOPIC_DELIMITER),
1422            Arc::new(DashMap::new()),
1423            get_atomic_clock_realtime(),
1424        );
1425        handler.inner = Some(Arc::new(client));
1426        cmd_tx
1427            .send(HandlerCommand::Subscribe { args: Vec::new() })
1428            .unwrap();
1429        let cancel = CancellationToken::new();
1430        let gate = SnapshotGate::default();
1431        gate.lock().close();
1432        let (completion, mut result) = tokio::sync::oneshot::channel();
1433        cmd_tx
1434            .send(HandlerCommand::SubscribeBook {
1435                subscription: OKXSubscriptionArg {
1436                    channel: OKXWsChannel::Books,
1437                    inst_id: Some(Ustr::from("BTC-USDT")),
1438                    inst_type: None,
1439                    inst_family: None,
1440                },
1441                cancel: cancel.clone(),
1442                gate: gate.clone(),
1443                completion,
1444            })
1445            .unwrap();
1446
1447        let running = tokio::spawn(async move { handler.next().await });
1448        let first = tokio::time::timeout(Duration::from_secs(3), wire_rx.recv())
1449            .await
1450            .unwrap()
1451            .unwrap();
1452        let first: Value = serde_json::from_str(first.to_text().unwrap()).unwrap();
1453        assert_eq!(first, serde_json::json!({"op": "subscribe", "args": []}));
1454        assert!(matches!(
1455            result.try_recv(),
1456            Err(tokio::sync::oneshot::error::TryRecvError::Empty)
1457        ));
1458
1459        if canceled {
1460            cancel.cancel();
1461        }
1462
1463        tokio::time::pause();
1464        tokio::time::advance(Duration::from_secs(10)).await;
1465        tokio::time::resume();
1466        let result = tokio::time::timeout(Duration::from_secs(3), result)
1467            .await
1468            .unwrap();
1469
1470        if canceled {
1471            assert!(gate.lock().is_closed());
1472            assert!(result.is_err());
1473            assert!(
1474                tokio::time::timeout(Duration::from_millis(100), wire_rx.recv())
1475                    .await
1476                    .is_err()
1477            );
1478        } else {
1479            result.unwrap().unwrap();
1480            assert!(!gate.lock().is_closed());
1481            let frame = tokio::time::timeout(Duration::from_secs(3), wire_rx.recv())
1482                .await
1483                .unwrap()
1484                .unwrap();
1485            let frame: Value = serde_json::from_str(frame.to_text().unwrap()).unwrap();
1486            assert_eq!(
1487                frame,
1488                serde_json::json!({"op": "subscribe", "args": [{"channel": "books", "instId": "BTC-USDT"}]})
1489            );
1490        }
1491
1492        running.abort();
1493        server.abort();
1494    }
1495
1496    #[tokio::test]
1497    async fn book_subscription_rejects_changed_connection() {
1498        let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
1499        let url = format!("ws://{}/", listener.local_addr().unwrap());
1500        let (wire_tx, mut wire_rx) = tokio::sync::mpsc::unbounded_channel();
1501
1502        let server = tokio::spawn(async move {
1503            let (socket, _) = listener.accept().await.unwrap();
1504            let mut socket = tokio_tungstenite::accept_async(socket).await.unwrap();
1505            while let Some(Ok(frame)) = socket.next().await {
1506                wire_tx.send(frame).unwrap();
1507            }
1508        });
1509
1510        let (message_handler, raw_rx) = channel_message_handler();
1511        let client = WebSocketClient::builder()
1512            .config(WebSocketConfig::builder().url(url).build().unwrap())
1513            .message_handler(message_handler)
1514            .connect()
1515            .await
1516            .unwrap();
1517        let wrong_epoch = client.connection_epoch() + 1;
1518        let (_cmd_tx, cmd_rx) = tokio::sync::mpsc::unbounded_channel();
1519        let (out_tx, _out_rx) = tokio::sync::mpsc::unbounded_channel();
1520        let mut handler = OKXWsFeedHandler::new(
1521            Arc::new(AtomicBool::new(false)),
1522            cmd_rx,
1523            raw_rx,
1524            out_tx,
1525            AuthTracker::new(),
1526            false,
1527            SubscriptionState::new(OKX_WS_TOPIC_DELIMITER),
1528            Arc::new(DashMap::new()),
1529            get_atomic_clock_realtime(),
1530        );
1531        handler.inner = Some(Arc::new(client));
1532
1533        let result = handler
1534            .send_book_subscription(
1535                OKXWsOperation::Subscribe,
1536                OKXSubscriptionArg {
1537                    channel: OKXWsChannel::Books,
1538                    inst_id: Some(Ustr::from("BTC-USDT")),
1539                    inst_type: None,
1540                    inst_family: None,
1541                },
1542                wrong_epoch,
1543            )
1544            .await;
1545
1546        assert!(matches!(
1547            result,
1548            Err(OKXWsError::TransportSend(SendError::ConnectionChanged))
1549        ));
1550        assert!(matches!(
1551            wire_rx.try_recv(),
1552            Err(tokio::sync::mpsc::error::TryRecvError::Empty)
1553        ));
1554        handler.inner.as_ref().unwrap().disconnect().await;
1555        server.abort();
1556    }
1557
1558    #[tokio::test]
1559    async fn recovery_cancel_between_sends_keeps_snapshot_gate_closed() {
1560        let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
1561        let url = format!("ws://{}/", listener.local_addr().unwrap());
1562        let (received, first_frame) = tokio::sync::oneshot::channel();
1563
1564        let server = tokio::spawn(async move {
1565            let (socket, _) = listener.accept().await.unwrap();
1566            let mut socket = tokio_tungstenite::accept_async(socket).await.unwrap();
1567            let frame = socket.next().await.unwrap().unwrap();
1568            received.send(frame).unwrap();
1569
1570            while socket.next().await.is_some() {}
1571        });
1572
1573        let (message_handler, raw_rx) = channel_message_handler();
1574        let client = WebSocketClient::builder()
1575            .config(WebSocketConfig::builder().url(url).build().unwrap())
1576            .message_handler(message_handler)
1577            .default_quota(Quota::per_hour(NonZeroU32::new(1).unwrap()))
1578            .connect()
1579            .await
1580            .unwrap();
1581        let (cmd_tx, cmd_rx) = tokio::sync::mpsc::unbounded_channel();
1582        let (out_tx, _out_rx) = tokio::sync::mpsc::unbounded_channel();
1583
1584        let mut handler = OKXWsFeedHandler::new(
1585            Arc::new(AtomicBool::new(false)),
1586            cmd_rx,
1587            raw_rx,
1588            out_tx,
1589            AuthTracker::new(),
1590            false,
1591            SubscriptionState::new(OKX_WS_TOPIC_DELIMITER),
1592            Arc::new(DashMap::new()),
1593            get_atomic_clock_realtime(),
1594        );
1595        handler.inner = Some(Arc::new(client));
1596        let tracker = BookSyncTracker::default();
1597        let instrument_id = InstrumentId::from("BTC-USDT.OKX");
1598        tracker.record_subscription(instrument_id, time::Instant::now(), SnapshotGate::default());
1599        let recovery = tracker.claim_recovery(instrument_id).unwrap();
1600        assert!(recovery.begin_replacement());
1601        let cancel = recovery.cancellation.child_token();
1602        let (completion, result) = tokio::sync::oneshot::channel();
1603        cmd_tx
1604            .send(HandlerCommand::Resubscribe {
1605                subscription: OKXSubscriptionArg {
1606                    channel: OKXWsChannel::Books,
1607                    inst_id: Some(Ustr::from("BTC-USDT")),
1608                    inst_type: None,
1609                    inst_family: None,
1610                },
1611                cancel: cancel.clone(),
1612                gate: recovery.gate.clone(),
1613                completion,
1614            })
1615            .unwrap();
1616
1617        let running = tokio::spawn(async move { handler.next().await });
1618        let frame = tokio::time::timeout(Duration::from_secs(3), first_frame)
1619            .await
1620            .unwrap()
1621            .unwrap();
1622        let request: Value = serde_json::from_str(frame.to_text().unwrap()).unwrap();
1623        assert_eq!(request["op"], "unsubscribe");
1624        assert_eq!(
1625            tracker.validate_sequence(instrument_id, true, &[(Some(-1), 42)], time::Instant::now()),
1626            BookSequenceOutcome::Suppress
1627        );
1628        cancel.cancel();
1629        assert!(
1630            tokio::time::timeout(Duration::from_secs(1), result)
1631                .await
1632                .unwrap()
1633                .is_err()
1634        );
1635
1636        assert!(recovery.gate.lock().is_closed());
1637        assert_eq!(
1638            tracker.validate_sequence(instrument_id, true, &[(Some(-1), 43)], time::Instant::now()),
1639            BookSequenceOutcome::Suppress
1640        );
1641        cmd_tx.send(HandlerCommand::Disconnect).unwrap();
1642        tokio::time::timeout(Duration::from_secs(3), running)
1643            .await
1644            .unwrap()
1645            .unwrap();
1646        server.abort();
1647    }
1648
1649    #[rstest]
1650    #[case::disabled_deadline(Duration::ZERO)]
1651    #[case::snapshot_deadline(Duration::from_secs(3))]
1652    #[tokio::test]
1653    async fn reconnect_replay_survives_inflight_recovery(#[case] snapshot_timeout: Duration) {
1654        let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
1655        let url = format!("ws://{}/", listener.local_addr().unwrap());
1656        let (wire_tx, mut wire_rx) = tokio::sync::mpsc::unbounded_channel();
1657
1658        let server = tokio::spawn(async move {
1659            let (socket, _) = listener.accept().await.unwrap();
1660            let mut socket = tokio_tungstenite::accept_async(socket).await.unwrap();
1661
1662            while let Some(Ok(Message::Text(text))) = socket.next().await {
1663                let request: Value = serde_json::from_str(&text).unwrap();
1664                wire_tx
1665                    .send(request["op"].as_str().unwrap().to_owned())
1666                    .unwrap();
1667
1668                if request["op"] == "subscribe" {
1669                    for (fixture, sequence, previous) in [
1670                        ("ws_books_snapshot.json", 100, -1),
1671                        ("ws_books_update.json", 101, 100),
1672                    ] {
1673                        let mut frame: Value =
1674                            serde_json::from_str(&load_test_json(fixture)).unwrap();
1675                        frame["data"][0]["seqId"] = json!(sequence);
1676                        frame["data"][0]["prevSeqId"] = json!(previous);
1677                        socket
1678                            .send(Message::Text(frame.to_string().into()))
1679                            .await
1680                            .unwrap();
1681                    }
1682                }
1683            }
1684        });
1685
1686        // Replay and unsubscribe consume the burst; the replacement subscribe cannot send
1687        let limiter = Arc::new(RateLimiter::new_with_quota(
1688            Some(
1689                Quota::with_period(Duration::from_secs(10))
1690                    .unwrap()
1691                    .allow_burst(NonZeroU32::new(2).unwrap()),
1692            ),
1693            Vec::new(),
1694        ));
1695        let (message_handler, raw_rx) = channel_message_handler();
1696        let client = WebSocketClient::builder()
1697            .config(WebSocketConfig::builder().url(url).build().unwrap())
1698            .message_handler(message_handler)
1699            .rate_limiter(Arc::clone(&limiter))
1700            .connect()
1701            .await
1702            .unwrap();
1703        let (cmd_tx, cmd_rx) = tokio::sync::mpsc::unbounded_channel();
1704        let (out_tx, _out_rx) = tokio::sync::mpsc::unbounded_channel();
1705
1706        let mut handler = OKXWsFeedHandler::new(
1707            Arc::new(AtomicBool::new(false)),
1708            cmd_rx,
1709            raw_rx,
1710            out_tx,
1711            AuthTracker::new(),
1712            false,
1713            SubscriptionState::new(OKX_WS_TOPIC_DELIMITER),
1714            Arc::new(DashMap::new()),
1715            get_atomic_clock_realtime(),
1716        );
1717        handler.inner = Some(Arc::new(client));
1718        let (messages_tx, mut messages_rx) = tokio::sync::mpsc::unbounded_channel();
1719
1720        let running = tokio::spawn(async move {
1721            while let Some(message) = handler.next().await {
1722                messages_tx.send(message).unwrap();
1723            }
1724        });
1725
1726        let instrument_id = InstrumentId::from("BTC-USDT.OKX");
1727        let channels = AtomicMap::new();
1728        channels.insert(instrument_id, OKXBookChannel::Book);
1729        let tracker = BookSyncTracker::default();
1730        tracker.record_subscription(instrument_id, time::Instant::now(), SnapshotGate::default());
1731        let recovery = tracker.claim_recovery(instrument_id).unwrap();
1732        assert!(recovery.begin_replacement());
1733
1734        let arg = OKXSubscriptionArg {
1735            channel: OKXWsChannel::Books,
1736            inst_id: Some(Ustr::from("BTC-USDT")),
1737            inst_type: None,
1738            inst_family: None,
1739        };
1740
1741        cmd_tx
1742            .send(HandlerCommand::Subscribe {
1743                args: vec![arg.clone()],
1744            })
1745            .unwrap();
1746
1747        assert_eq!(
1748            tokio::time::timeout(Duration::from_secs(3), wire_rx.recv())
1749                .await
1750                .unwrap()
1751                .unwrap(),
1752            "subscribe"
1753        );
1754
1755        for action in [OKXBookAction::Snapshot, OKXBookAction::Update] {
1756            let message = tokio::time::timeout(Duration::from_secs(3), messages_rx.recv())
1757                .await
1758                .unwrap()
1759                .unwrap();
1760            assert!(
1761                matches!(message, OKXWsMessage::BookData { action: received, .. } if received == action)
1762            );
1763        }
1764
1765        let (completion, result) = tokio::sync::oneshot::channel();
1766        cmd_tx
1767            .send(HandlerCommand::Resubscribe {
1768                subscription: arg.clone(),
1769                cancel: recovery.cancellation.child_token(),
1770                gate: recovery.gate.clone(),
1771                completion,
1772            })
1773            .unwrap();
1774
1775        assert_eq!(
1776            tokio::time::timeout(Duration::from_secs(3), wire_rx.recv())
1777                .await
1778                .unwrap()
1779                .unwrap(),
1780            "unsubscribe"
1781        );
1782
1783        // Paused time keeps the subscribe blocked until the reset completes
1784        tokio::time::pause();
1785        tracker.reset_sequences(&channels, BookChannelScope::Public);
1786
1787        if !snapshot_timeout.is_zero() {
1788            tracker.seed_pending_snapshots(
1789                &channels,
1790                BookChannelScope::Public,
1791                snapshot_timeout,
1792                time::Instant::now(),
1793            );
1794        }
1795
1796        tokio::time::advance(Duration::from_secs(10)).await;
1797        tokio::time::resume();
1798        let _ = tokio::time::timeout(Duration::from_secs(3), result)
1799            .await
1800            .expect("recovery command completes after reconnect");
1801
1802        let resumed = tokio::time::timeout(Duration::from_secs(3), async {
1803            for (action, sequence) in [(OKXBookAction::Snapshot, 100), (OKXBookAction::Update, 101)]
1804            {
1805                let Some(OKXWsMessage::BookData {
1806                    action: received,
1807                    data,
1808                    ..
1809                }) = messages_rx.recv().await
1810                else {
1811                    panic!("expected book data after reconnect");
1812                };
1813
1814                assert_eq!(received, action);
1815                assert_eq!(data[0].seq_id, sequence);
1816                assert_eq!(
1817                    tracker.validate_sequence(
1818                        instrument_id,
1819                        received == OKXBookAction::Snapshot,
1820                        &[(data[0].prev_seq_id, data[0].seq_id)],
1821                        time::Instant::now(),
1822                    ),
1823                    BookSequenceOutcome::Accept,
1824                );
1825            }
1826        })
1827        .await;
1828
1829        // A successful manual subscribe isolates a failure to automatic replay
1830        if resumed.is_err() {
1831            cmd_tx
1832                .send(HandlerCommand::Subscribe { args: vec![arg] })
1833                .unwrap();
1834
1835            for action in [OKXBookAction::Snapshot, OKXBookAction::Update] {
1836                let message = tokio::time::timeout(Duration::from_secs(3), messages_rx.recv())
1837                    .await
1838                    .unwrap()
1839                    .unwrap();
1840                assert!(
1841                    matches!(message, OKXWsMessage::BookData { action: received, .. } if received == action)
1842                );
1843            }
1844        }
1845
1846        cmd_tx.send(HandlerCommand::Disconnect).unwrap();
1847        tokio::time::timeout(Duration::from_secs(3), running)
1848            .await
1849            .unwrap()
1850            .unwrap();
1851        server.abort();
1852
1853        assert!(
1854            resumed.is_ok(),
1855            "reconnect must preserve an in-flight recovery and resume book output"
1856        );
1857    }
1858
1859    #[rstest]
1860    fn test_should_retry_typed_transport_and_timeout_errors() {
1861        assert!(!should_retry_replay_safe_error(&OKXWsError::TransportSend(
1862            SendError::BufferFull
1863        )));
1864        assert!(should_retry_replay_safe_error(&OKXWsError::TransportSend(
1865            SendError::Timeout
1866        )));
1867        assert!(should_retry_replay_safe_error(&OKXWsError::TransportSend(
1868            SendError::ConnectionChanged
1869        )));
1870        assert!(!should_retry_replay_safe_error(&OKXWsError::TransportSend(
1871            SendError::WriteTimeout
1872        )));
1873        assert!(!should_retry_replay_safe_error(&OKXWsError::TransportSend(
1874            SendError::BrokenPipe("connection reset".to_string())
1875        )));
1876        assert!(should_retry_replay_safe_error(
1877            &OKXWsError::OperationTimeout { timeout_ms: 1_000 }
1878        ));
1879        assert!(!should_retry_replay_safe_error(&OKXWsError::NoActiveClient));
1880        assert!(!should_retry_replay_safe_error(
1881            &OKXWsError::HandlerUnavailable("closed".to_string())
1882        ));
1883    }
1884
1885    #[rstest]
1886    fn test_retryability_uses_websocket_error_type_not_message() {
1887        let message = "connection reset".to_string();
1888        let temporary = OKXWsError::OkxError {
1889            error_code: "50011".to_string(),
1890            message: message.clone(),
1891        };
1892        let permanent = OKXWsError::ClientError(message.clone());
1893        let ambiguous = OKXWsError::SendFailed(message);
1894
1895        assert!(should_retry_replay_safe_error(&temporary));
1896        assert!(!should_retry_replay_safe_error(&permanent));
1897        assert!(!should_retry_replay_safe_error(&ambiguous));
1898    }
1899
1900    #[rstest]
1901    fn test_subscription_error_restores_failed_unsubscribe() {
1902        let handler = create_handler();
1903        let arg = OKXWebSocketArg {
1904            channel: OKXWsChannel::Books,
1905            inst_id: Some(Ustr::from("BTC-USD")),
1906            inst_type: None,
1907            inst_family: None,
1908            bar: None,
1909        };
1910        let topic = topic_from_websocket_arg(&arg);
1911        handler.subscriptions_state.mark_subscribe(&topic);
1912        handler.subscriptions_state.confirm_subscribe(&topic);
1913        handler.subscriptions_state.mark_unsubscribe(&topic);
1914
1915        let rejected_subscription =
1916            handler.handle_subscription_error(&arg, "60019", "Unsubscription failed");
1917
1918        assert!(!rejected_subscription);
1919        assert_eq!(handler.subscriptions_state.all_topics(), vec![topic]);
1920        assert!(
1921            handler
1922                .subscriptions_state
1923                .pending_subscribe_topics()
1924                .is_empty()
1925        );
1926        assert!(
1927            handler
1928                .subscriptions_state
1929                .pending_unsubscribe_topics()
1930                .is_empty()
1931        );
1932    }
1933
1934    #[rstest]
1935    fn stale_unsubscribe_ack_keeps_resubscribed_arguments() {
1936        let handler = create_handler();
1937
1938        let arg = OKXSubscriptionArg {
1939            channel: OKXWsChannel::Trades,
1940            inst_type: None,
1941            inst_family: None,
1942            inst_id: Some(Ustr::from("BTC-USDT")),
1943        };
1944
1945        let topic = topic_from_subscription_arg(&arg);
1946        handler.subscriptions.insert(topic.clone(), arg);
1947        handler.subscriptions_state.mark_subscribe(&topic);
1948        handler.subscriptions_state.confirm_subscribe(&topic);
1949        handler.subscriptions_state.mark_unsubscribe(&topic);
1950        handler.subscriptions_state.mark_subscribe(&topic);
1951
1952        let acknowledgment = OKXWebSocketArg {
1953            channel: OKXWsChannel::Trades,
1954            inst_type: None,
1955            inst_family: None,
1956            inst_id: Some(Ustr::from("BTC-USDT")),
1957            bar: None,
1958        };
1959
1960        let rejected = handler.handle_subscription_ack(
1961            &OKXSubscriptionEvent::Unsubscribe,
1962            &acknowledgment,
1963            Some("0"),
1964            None,
1965        );
1966        let retained = handler
1967            .subscriptions
1968            .get(&topic)
1969            .expect("resubscribed arguments");
1970
1971        assert!(!rejected);
1972        assert_eq!(handler.subscriptions_state.all_topics(), vec![topic]);
1973        assert_eq!(retained.channel, OKXWsChannel::Trades);
1974        assert_eq!(retained.inst_id, Some(Ustr::from("BTC-USDT")));
1975        assert_eq!(retained.inst_type, None);
1976        assert_eq!(retained.inst_family, None);
1977    }
1978
1979    #[rstest]
1980    fn delayed_subscribe_error_does_not_restore_canceled_subscription() {
1981        let handler = create_handler();
1982
1983        let arg = OKXWebSocketArg {
1984            channel: OKXWsChannel::Trades,
1985            inst_type: None,
1986            inst_family: None,
1987            inst_id: Some(Ustr::from("BTC-USDT")),
1988            bar: None,
1989        };
1990
1991        let topic = topic_from_websocket_arg(&arg);
1992        handler.subscriptions.insert(
1993            topic.clone(),
1994            OKXSubscriptionArg {
1995                channel: arg.channel.clone(),
1996                inst_type: None,
1997                inst_family: None,
1998                inst_id: arg.inst_id,
1999            },
2000        );
2001
2002        handler.subscriptions_state.mark_subscribe(&topic);
2003        handler.subscriptions_state.mark_unsubscribe(&topic);
2004
2005        let subscribe_failed = handler.handle_subscription_error(
2006            &arg,
2007            "60018",
2008            "Subscribe failed, wrong URL or channel:trades,instId:BTC-USDT doesn't exist.",
2009        );
2010        let pending = handler.subscriptions_state.pending_unsubscribe_topics();
2011        let active = handler.subscriptions_state.all_topics();
2012        handler.handle_subscription_ack(&OKXSubscriptionEvent::Unsubscribe, &arg, Some("0"), None);
2013
2014        assert!(subscribe_failed);
2015        assert_eq!(pending, vec![topic.clone()]);
2016        assert_eq!(active, Vec::<String>::new());
2017        assert!(handler.subscriptions_state.all_topics().is_empty());
2018        assert!(
2019            handler
2020                .subscriptions_state
2021                .pending_unsubscribe_topics()
2022                .is_empty()
2023        );
2024        assert!(!handler.subscriptions.contains_key(&topic));
2025    }
2026
2027    #[rstest]
2028    fn delayed_unsubscribe_error_does_not_fail_new_subscribe() {
2029        let handler = create_handler();
2030
2031        let arg = OKXWebSocketArg {
2032            channel: OKXWsChannel::Books,
2033            inst_type: None,
2034            inst_family: None,
2035            inst_id: Some(Ustr::from("BTC-USDT")),
2036            bar: None,
2037        };
2038
2039        let topic = topic_from_websocket_arg(&arg);
2040        handler.subscriptions_state.mark_subscribe(&topic);
2041        handler.subscriptions_state.mark_unsubscribe(&topic);
2042        handler.subscriptions_state.mark_subscribe(&topic);
2043
2044        let subscribe_failed = handler.handle_subscription_error(
2045            &arg,
2046            "60035",
2047            "Unsubscribe failed, wrong URL or channel:books,instId:BTC-USDT doesn't exist.",
2048        );
2049
2050        assert!(!subscribe_failed);
2051        assert_eq!(handler.subscriptions_state.all_topics(), vec![topic]);
2052        assert_eq!(handler.subscriptions_state.len(), 1);
2053        assert!(
2054            handler
2055                .subscriptions_state
2056                .pending_subscribe_topics()
2057                .is_empty()
2058        );
2059        assert!(
2060            handler
2061                .subscriptions_state
2062                .pending_unsubscribe_topics()
2063                .is_empty()
2064        );
2065    }
2066
2067    #[rstest]
2068    #[case("Wrong URL or channel:")]
2069    #[case("Subscribe failed, wrong URL or channel:")]
2070    #[case("Unsubscribe failed, wrong URL or channel:")]
2071    fn test_subscription_arg_from_error_message_matches_mainnet_shape(#[case] prefix: &str) {
2072        let msg = format!(
2073            "{prefix}books,instId:BTC-USDT-SWAP doesn't exist. Please use the \
2074                   correct URL, channel and parameters referring to API document."
2075        );
2076
2077        let arg = subscription_arg_from_error_message(&msg).unwrap();
2078
2079        assert_eq!(arg.channel, OKXWsChannel::Books);
2080        assert_eq!(arg.inst_id, Some(Ustr::from("BTC-USDT-SWAP")));
2081        assert_eq!(arg.inst_type, None);
2082        assert_eq!(arg.inst_family, None);
2083        assert_eq!(arg.bar, None);
2084    }
2085
2086    #[rstest]
2087    #[case::book_arg(
2088        Some(OKXWsChannel::Books),
2089        "60018",
2090        "Subscription failed",
2091        log::Level::Warn
2092    )]
2093    #[case::book_from_message(
2094        None,
2095        "60018",
2096        "Wrong URL or channel:books,instId:BTC-USDT-SWAP doesn't exist.",
2097        log::Level::Warn
2098    )]
2099    #[case::retryable(
2100        Some(OKXWsChannel::Tickers),
2101        "50001",
2102        "Service unavailable",
2103        log::Level::Warn
2104    )]
2105    #[case::non_book_arg(
2106        Some(OKXWsChannel::Tickers),
2107        "60018",
2108        "Subscription failed",
2109        log::Level::Error
2110    )]
2111    #[case::non_book_from_message(
2112        None,
2113        "60018",
2114        "Wrong URL or channel:tickers,instId:BTC-USDT-SWAP doesn't exist.",
2115        log::Level::Error
2116    )]
2117    fn test_error_frame_level(
2118        #[case] channel: Option<OKXWsChannel>,
2119        #[case] code: &str,
2120        #[case] msg: &str,
2121        #[case] expected: log::Level,
2122    ) {
2123        let arg = channel.map(|channel| OKXWebSocketArg {
2124            channel,
2125            inst_id: Some(Ustr::from("BTC-USDT-SWAP")),
2126            inst_type: None,
2127            inst_family: None,
2128            bar: None,
2129        });
2130
2131        let level = error_frame_level(arg.as_ref(), code, msg);
2132
2133        assert_eq!(level, expected);
2134    }
2135
2136    #[rstest]
2137    fn test_subscription_error_ignores_non_pending_topic() {
2138        let handler = create_handler();
2139        let arg = OKXWebSocketArg {
2140            channel: OKXWsChannel::Books,
2141            inst_id: Some(Ustr::from("BTC-USDT-SWAP")),
2142            inst_type: None,
2143            inst_family: None,
2144            bar: None,
2145        };
2146
2147        let rejected_subscription =
2148            handler.handle_subscription_error(&arg, "60018", "Subscription failed");
2149
2150        assert!(!rejected_subscription);
2151        assert!(handler.subscriptions_state.all_topics().is_empty());
2152        assert!(
2153            handler
2154                .subscriptions_state
2155                .pending_subscribe_topics()
2156                .is_empty()
2157        );
2158        assert!(
2159            handler
2160                .subscriptions_state
2161                .pending_unsubscribe_topics()
2162                .is_empty()
2163        );
2164    }
2165
2166    #[derive(serde::Deserialize, Debug, PartialEq)]
2167    struct ParseArrayItem {
2168        value: i64,
2169    }
2170
2171    #[rstest]
2172    fn test_parse_array_items_keeps_good_items_when_one_fails() {
2173        let data = json!([
2174            {"value": 1},
2175            {"value": "not a number"},
2176            {"value": 3},
2177        ]);
2178
2179        let parsed: Vec<ParseArrayItem> =
2180            parse_array_items(data, "test", false).expect("non-empty");
2181        assert_eq!(
2182            parsed,
2183            vec![ParseArrayItem { value: 1 }, ParseArrayItem { value: 3 }],
2184        );
2185    }
2186
2187    #[rstest]
2188    fn test_parse_array_items_returns_none_when_payload_not_array() {
2189        let data = json!({"not": "an array"});
2190        let parsed: Option<Vec<ParseArrayItem>> = parse_array_items(data, "test", false);
2191        assert!(parsed.is_none());
2192    }
2193
2194    #[rstest]
2195    fn test_parse_array_items_returns_none_when_all_items_fail() {
2196        let data = json!([{"value": "bad"}]);
2197        let parsed: Option<Vec<ParseArrayItem>> = parse_array_items(data, "test", false);
2198        assert!(parsed.is_none());
2199    }
2200
2201    #[rstest]
2202    fn test_route_instruments_keeps_valid_items_when_one_item_fails() {
2203        let handler = create_handler();
2204        let mut frame: Value =
2205            serde_json::from_str(&load_test_json("ws_instruments.json")).expect("valid fixture");
2206        let data = frame
2207            .get_mut("data")
2208            .and_then(Value::as_array_mut)
2209            .expect("data array");
2210        let mut invalid_item = data[0].clone();
2211        invalid_item["tickSz"] = json!(7);
2212        data.insert(0, invalid_item);
2213
2214        let arg: OKXWebSocketArg = serde_json::from_value(frame["arg"].clone()).expect("valid arg");
2215        let msg = handler
2216            .route_data_message(arg, frame["data"].clone())
2217            .expect("instruments message");
2218
2219        match msg {
2220            OKXWsMessage::Instruments(instruments) => {
2221                assert_eq!(instruments.len(), 1);
2222                assert_eq!(instruments[0].inst_id, "BTC-USDT-SWAP");
2223            }
2224            other => panic!("Expected Instruments, was {other:?}"),
2225        }
2226    }
2227
2228    #[rstest]
2229    fn test_route_instruments_prefers_rpi_over_legacy_alias() {
2230        let handler = create_handler();
2231        let mut frame: Value =
2232            serde_json::from_str(&load_test_json("ws_instruments.json")).expect("valid fixture");
2233        let instrument = &mut frame["data"][0];
2234        instrument["rpi"] = json!("2");
2235        instrument["elp"] = json!("1");
2236
2237        let arg: OKXWebSocketArg = serde_json::from_value(frame["arg"].clone()).expect("valid arg");
2238        let msg = handler
2239            .route_data_message(arg, frame["data"].clone())
2240            .expect("instruments message");
2241
2242        match msg {
2243            OKXWsMessage::Instruments(instruments) => {
2244                assert_eq!(instruments.len(), 1);
2245                assert_eq!(instruments[0].rpi, Some(OKXRpiPermission::Permitted));
2246            }
2247            other => panic!("Expected Instruments, was {other:?}"),
2248        }
2249    }
2250
2251    #[rstest]
2252    fn test_route_liquidation_warnings() {
2253        let handler = create_handler();
2254        let frame: Value = serde_json::from_str(&load_test_json("ws_liquidation_warning.json"))
2255            .expect("valid fixture");
2256
2257        let arg: OKXWebSocketArg = serde_json::from_value(frame["arg"].clone()).expect("valid arg");
2258        let msg = handler
2259            .route_data_message(arg, frame["data"].clone())
2260            .expect("liquidation warning message");
2261
2262        match msg {
2263            OKXWsMessage::LiquidationWarnings(warnings) => {
2264                assert_eq!(warnings.len(), 1);
2265                assert_eq!(warnings[0].inst_id, "BTC-USDT-SWAP");
2266                assert_eq!(warnings[0].mgn_ratio, "0.62");
2267            }
2268            other => panic!("Expected LiquidationWarnings, was {other:?}"),
2269        }
2270    }
2271
2272    #[tokio::test]
2273    async fn bound_send_rejects_reconnecting_epoch_before_waiting() {
2274        let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
2275        let url = format!("ws://{}/", listener.local_addr().unwrap());
2276
2277        let server = tokio::spawn(async move {
2278            let (socket, _) = listener.accept().await.unwrap();
2279            let mut socket = tokio_tungstenite::accept_async(socket).await.unwrap();
2280            let mut frames = Vec::new();
2281            while let Some(Ok(Message::Text(text))) = socket.next().await {
2282                frames.push(text.to_string());
2283            }
2284
2285            frames
2286        });
2287
2288        let (message_handler, raw_rx) = channel_message_handler();
2289        let client = WebSocketClient::builder()
2290            .config(WebSocketConfig::builder().url(url).build().unwrap())
2291            .message_handler(message_handler)
2292            .connect()
2293            .await
2294            .unwrap();
2295        let mode = client.connection_mode_atomic();
2296        let epoch = client.connection_epoch();
2297        let (_cmd_tx, cmd_rx) = tokio::sync::mpsc::unbounded_channel();
2298        let (out_tx, _out_rx) = tokio::sync::mpsc::unbounded_channel();
2299
2300        let mut handler = OKXWsFeedHandler::new(
2301            Arc::new(AtomicBool::new(false)),
2302            cmd_rx,
2303            raw_rx,
2304            out_tx,
2305            AuthTracker::new(),
2306            false,
2307            SubscriptionState::new(OKX_WS_TOPIC_DELIMITER),
2308            Arc::new(DashMap::new()),
2309            get_atomic_clock_realtime(),
2310        );
2311        handler.inner = Some(Arc::new(client));
2312        handler
2313            .send_on_connection("active-control".to_string(), None)
2314            .await
2315            .unwrap();
2316
2317        tokio::time::pause();
2318        mode.store(ConnectionMode::Reconnect.as_u8(), Ordering::SeqCst);
2319
2320        let (ready, result) = {
2321            let mut send =
2322                Box::pin(handler.send_on_connection("cancel-in-reconnect".to_string(), None));
2323
2324            match futures_util::poll!(send.as_mut()) {
2325                std::task::Poll::Ready(result) => (true, result),
2326                std::task::Poll::Pending => {
2327                    mode.store(ConnectionMode::Active.as_u8(), Ordering::SeqCst);
2328                    tokio::time::advance(Duration::from_millis(100)).await;
2329                    (false, send.await)
2330                }
2331            }
2332        };
2333
2334        mode.store(ConnectionMode::Active.as_u8(), Ordering::SeqCst);
2335        tokio::time::resume();
2336        let final_epoch = handler.inner.as_ref().unwrap().connection_epoch();
2337        handler.inner.as_ref().unwrap().disconnect().await;
2338        let frames = tokio::time::timeout(Duration::from_secs(2), server)
2339            .await
2340            .expect("peer did not close")
2341            .unwrap();
2342
2343        assert_eq!(frames, vec!["active-control"]);
2344        assert_eq!(final_epoch, epoch);
2345        assert!(
2346            ready,
2347            "reconnecting send must fail without waiting for recovery"
2348        );
2349        assert!(
2350            matches!(
2351                result,
2352                Err(OKXWsError::TransportSend(SendError::ConnectionChanged))
2353            ),
2354            "expected rejection for a reconnecting epoch, received {result:?}"
2355        );
2356    }
2357
2358    #[tokio::test]
2359    async fn pending_sends_preserve_exact_bytes_and_fifo() {
2360        let mut peer = handler_peer().await;
2361        let payloads = [
2362            serde_json::json!({"id":"17","op":"cancel-order","args":[{"clOrdId":"OQUEUED17","ordId":"70017","instIdCode":1_000_000_101}]}).to_string(),
2363            serde_json::json!({"id":"29","op":"amend-order","args":[{"clOrdId":"OQUEUED29","newSz":"0.013","newPx":"49731.2","instIdCode":1_000_000_102}]}).to_string(),
2364        ];
2365        peer.handler.auth_tracker.invalidate();
2366
2367        for (payload, index, op) in [
2368            (&payloads[0], 17, OKXWsOperation::CancelOrder),
2369            (&payloads[1], 29, OKXWsOperation::AmendOrder),
2370        ] {
2371            let mut pending = order_send(payload.clone(), index);
2372            pending.op = Some(op);
2373            peer.handler.pending_sends.push_back(pending);
2374        }
2375
2376        assert!(!peer.handler.can_send_pending());
2377        assert!(peer.frames.try_recv().is_err());
2378        tokio::time::pause();
2379        let mut next = Box::pin(peer.handler.next());
2380        assert!(futures_util::poll!(next.as_mut()).is_pending());
2381        tokio::time::advance(Duration::from_secs(11)).await;
2382        assert!(futures_util::poll!(next.as_mut()).is_pending());
2383        drop(next);
2384        tokio::time::resume();
2385        assert_eq!(peer.handler.pending_sends.len(), payloads.len());
2386        assert!(peer.messages.try_recv().is_err());
2387
2388        peer.handler.auth_tracker.succeed();
2389        peer.handler.send_pending().await;
2390        peer.handler.send_pending().await;
2391        let frames = [
2392            peer.frames.recv().await.unwrap(),
2393            peer.frames.recv().await.unwrap(),
2394        ];
2395        assert_eq!(frames, payloads);
2396        assert!(peer.handler.pending_sends.is_empty());
2397        assert!(peer.messages.try_recv().is_err());
2398        peer.handler.inner.as_ref().unwrap().disconnect().await;
2399        peer.server.abort();
2400    }
2401
2402    #[tokio::test]
2403    async fn pending_send_preserves_fifo_after_connection_change() {
2404        let mut peer = handler_peer().await;
2405        let keys = [Ustr::from(SEND_RATE_KEY)];
2406        let ws_client = peer.handler.inner.as_ref().unwrap();
2407        let reconnect = ws_client.reconnect_handle();
2408        ws_client
2409            .send_text_on_connection("consume-quota".to_string(), Some(&keys), 0)
2410            .await
2411            .unwrap();
2412        assert_eq!(peer.frames.recv().await.unwrap(), "consume-quota");
2413        let payloads = ["request-17", "request-29"];
2414        for (payload, index) in [(payloads[0], 17), (payloads[1], 29)] {
2415            let mut pending = order_send(payload.to_string(), index);
2416            pending.rate_limit_keys = Some(keys.to_vec());
2417            peer.handler.pending_sends.push_back(pending);
2418        }
2419
2420        let mut send = Box::pin(peer.handler.send_pending());
2421        assert!(futures_util::poll!(send.as_mut()).is_pending());
2422        assert_eq!(
2423            reconnect.request_reconnect(),
2424            ReconnectRequestOutcome::Accepted
2425        );
2426        tokio::time::timeout(Duration::from_secs(5), send)
2427            .await
2428            .unwrap();
2429
2430        assert_eq!(peer.handler.pending_sends.len(), payloads.len());
2431        assert!(!peer.handler.pending_sends.front().unwrap().attempted);
2432        assert!(!peer.handler.auth_tracker.is_authenticated());
2433        assert!(!peer.handler.can_send_pending());
2434        assert!(peer.handler.sent_requests.is_empty());
2435        assert!(peer.frames.try_recv().is_err());
2436        assert!(peer.messages.try_recv().is_err());
2437
2438        peer.handler.auth_tracker.succeed();
2439        peer.handler.send_pending().await;
2440        peer.handler.send_pending().await;
2441        let frames = [
2442            peer.frames.recv().await.unwrap(),
2443            peer.frames.recv().await.unwrap(),
2444        ];
2445        assert_eq!(frames, payloads);
2446        assert!(peer.handler.pending_sends.is_empty());
2447        assert!(peer.messages.try_recv().is_err());
2448        peer.handler.inner.as_ref().unwrap().disconnect().await;
2449        peer.server.abort();
2450    }
2451
2452    #[tokio::test]
2453    async fn pending_send_rechecks_authentication_after_reconnect() {
2454        let mut peer = handler_peer().await;
2455        let payload = "queued-order";
2456        peer.handler
2457            .pending_sends
2458            .push_back(order_send(payload.to_string(), 17));
2459        assert!(peer.handler.can_send_pending());
2460
2461        let client = peer.handler.inner.as_ref().unwrap();
2462        let epoch = client.connection_epoch();
2463        assert_eq!(
2464            client.reconnect_handle().request_reconnect(),
2465            ReconnectRequestOutcome::Accepted
2466        );
2467        tokio::time::timeout(Duration::from_secs(5), async {
2468            while client.connection_epoch() == epoch || !client.is_active() {
2469                tokio::time::sleep(Duration::from_millis(10)).await;
2470            }
2471        })
2472        .await
2473        .unwrap();
2474
2475        assert!(!peer.handler.auth_tracker.is_authenticated());
2476
2477        peer.handler.send_pending().await;
2478
2479        assert_eq!(peer.handler.pending_sends.len(), 1);
2480        assert!(!peer.handler.pending_sends.front().unwrap().attempted);
2481        assert!(peer.frames.try_recv().is_err());
2482        assert!(peer.messages.try_recv().is_err());
2483
2484        peer.handler.auth_tracker.succeed();
2485        peer.handler.send_pending().await;
2486
2487        assert_eq!(peer.frames.recv().await.unwrap(), payload);
2488        assert!(peer.handler.pending_sends.is_empty());
2489        assert!(peer.messages.try_recv().is_err());
2490        peer.handler.inner.as_ref().unwrap().disconnect().await;
2491        peer.server.abort();
2492    }
2493
2494    #[tokio::test]
2495    async fn pending_send_timeout_fails_only_head() {
2496        let mut peer = handler_peer().await;
2497        for index in [17, 29] {
2498            peer.handler
2499                .pending_sends
2500                .push_back(order_send(format!("request-{index}"), index));
2501        }
2502
2503        peer.server.abort();
2504        peer.handler
2505            .inner
2506            .as_ref()
2507            .unwrap()
2508            .connection_mode_atomic()
2509            .store(ConnectionMode::Reconnect.as_u8(), Ordering::SeqCst);
2510        tokio::time::pause();
2511        let mut send = Box::pin(peer.handler.send_pending());
2512        assert!(futures_util::poll!(send.as_mut()).is_pending());
2513        tokio::time::advance(Duration::from_secs(11)).await;
2514        send.await;
2515        tokio::time::resume();
2516
2517        let failure = peer.messages.try_recv().unwrap();
2518        assert!(matches!(failure, OKXWsMessage::SendFailed {
2519            request_id, client_order_ids, op: Some(OKXWsOperation::CancelOrder),
2520            error: OKXWsError::TransportSend(SendError::Timeout),
2521        } if request_id == "17" && client_order_ids == vec![ClientOrderId::from("OQUEUED17")]));
2522        assert_eq!(peer.handler.pending_sends.len(), 1);
2523        assert_eq!(
2524            peer.handler
2525                .pending_sends
2526                .front()
2527                .unwrap()
2528                .request_id
2529                .as_deref(),
2530            Some("29")
2531        );
2532        assert!(!peer.handler.auth_tracker.is_authenticated());
2533        assert!(!peer.handler.can_send_pending());
2534        assert!(peer.handler.sent_requests.is_empty());
2535        assert!(peer.messages.try_recv().is_err());
2536        peer.handler.inner.as_ref().unwrap().disconnect().await;
2537    }
2538
2539    #[tokio::test]
2540    async fn pending_send_capacity_and_drop_report_each_command() {
2541        let mut peer = handler_peer().await;
2542        peer.handler
2543            .pending_sends
2544            .push_back(order_send("sent-request".to_string(), 9_999));
2545        peer.handler.send_pending().await;
2546        peer.frames.recv().await.unwrap();
2547        peer.handler.auth_tracker.invalidate();
2548        for index in 0..PENDING_SENDS_CAPACITY {
2549            peer.handler
2550                .pending_sends
2551                .push_back(order_send(format!("request-{index}"), index));
2552        }
2553
2554        peer.commands
2555            .send(HandlerCommand::Send {
2556                payload: "overflow-request".to_string(),
2557                rate_limit_keys: None,
2558                request_id: Some("overflow".to_string()),
2559                client_order_ids: vec![ClientOrderId::from("OOVERFLOW")],
2560                op: Some(OKXWsOperation::AmendOrder),
2561            })
2562            .unwrap();
2563
2564        let mut next = Box::pin(peer.handler.next());
2565        assert!(futures_util::poll!(next.as_mut()).is_pending());
2566        drop(next);
2567        let overflow = peer.messages.try_recv().unwrap();
2568        assert!(
2569            matches!(overflow, OKXWsMessage::SendFailed { request_id, client_order_ids, op: Some(OKXWsOperation::AmendOrder), error: OKXWsError::TransportSend(SendError::BufferFull) }
2570            if request_id == "overflow" && client_order_ids == vec![ClientOrderId::from("OOVERFLOW")])
2571        );
2572        peer.handler
2573            .inner
2574            .as_ref()
2575            .unwrap()
2576            .connection_mode_atomic()
2577            .store(ConnectionMode::Reconnect.as_u8(), Ordering::SeqCst);
2578        peer.handler.auth_tracker.succeed();
2579        let mut attempted = Box::pin(peer.handler.send_pending());
2580        assert!(futures_util::poll!(attempted.as_mut()).is_pending());
2581        drop(attempted);
2582        peer.commands
2583            .send(HandlerCommand::Send {
2584                payload: "unread-request".to_string(),
2585                rate_limit_keys: None,
2586                request_id: Some("unread".to_string()),
2587                client_order_ids: vec![ClientOrderId::from("OUNREAD")],
2588                op: Some(OKXWsOperation::Order),
2589            })
2590            .unwrap();
2591
2592        peer.handler.inner.as_ref().unwrap().disconnect().await;
2593        drop(peer.handler);
2594        for index in 0..PENDING_SENDS_CAPACITY {
2595            let message = peer.messages.try_recv().unwrap();
2596
2597            let OKXWsMessage::SendFailed {
2598                request_id,
2599                client_order_ids,
2600                op,
2601                error,
2602            } = message
2603            else {
2604                panic!("expected send failure")
2605            };
2606
2607            assert_eq!(request_id, index.to_string());
2608            assert_eq!(
2609                client_order_ids,
2610                vec![ClientOrderId::from(format!("OQUEUED{index}").as_str())]
2611            );
2612            assert_eq!(op, Some(OKXWsOperation::CancelOrder));
2613
2614            if index == 0 {
2615                assert!(matches!(error, OKXWsError::SendFailed(_)));
2616            } else {
2617                assert!(matches!(
2618                    error,
2619                    OKXWsError::TransportSend(SendError::Closed)
2620                ));
2621            }
2622        }
2623
2624        let unread = peer.messages.try_recv().unwrap();
2625        assert!(
2626            matches!(unread, OKXWsMessage::SendFailed { request_id, client_order_ids, op: Some(OKXWsOperation::Order), error: OKXWsError::TransportSend(SendError::Closed) }
2627            if request_id == "unread" && client_order_ids == vec![ClientOrderId::from("OUNREAD")])
2628        );
2629        assert!(peer.messages.try_recv().is_err());
2630        assert!(peer.frames.try_recv().is_err());
2631        peer.server.abort();
2632    }
2633
2634    #[rstest]
2635    #[case(false)]
2636    #[case(true)]
2637    #[tokio::test]
2638    async fn reconnect_preserves_buffered_order_events(#[case] empty_refusal: bool) {
2639        let mut peer = handler_peer().await;
2640        let (raw_tx, raw_rx) = tokio::sync::mpsc::unbounded_channel();
2641        peer.handler.raw_rx = raw_rx;
2642        let mut fixture: Value =
2643            serde_json::from_str(&load_test_json("ws_reconnect_queued_frames.json")).unwrap();
2644        let mut pending = order_send("request-17".to_string(), 17);
2645        pending.request_id = Some("queued-response-17".to_string());
2646        pending.op = Some(OKXWsOperation::Order);
2647        peer.handler.pending_sends.push_back(pending);
2648        peer.handler.send_pending().await;
2649        peer.frames.recv().await.unwrap();
2650
2651        if empty_refusal {
2652            fixture["response"]["code"] = json!("50124");
2653            fixture["response"]["msg"] = json!("Market permission denied");
2654            fixture["response"]["data"] = json!([]);
2655        }
2656        let orders = load_test_json("ws_orders.json");
2657        let orders_frame: Value = serde_json::from_str(&orders).unwrap();
2658        let expected_orders: Vec<OKXOrderMsg> =
2659            serde_json::from_value(orders_frame["data"].clone()).unwrap();
2660
2661        raw_tx.send(Message::Text(orders.into())).unwrap();
2662        raw_tx
2663            .send(Message::Text(fixture["response"].to_string().into()))
2664            .unwrap();
2665
2666        let ws_client = peer.handler.inner.as_ref().unwrap();
2667        assert!(ws_client.request_reconnect());
2668        tokio::time::timeout(Duration::from_secs(5), async {
2669            while ws_client.connection_epoch() != 1 || !ws_client.is_active() {
2670                tokio::time::sleep(Duration::from_millis(10)).await;
2671            }
2672        })
2673        .await
2674        .unwrap();
2675
2676        let orders = tokio::time::timeout(Duration::from_secs(1), peer.handler.next())
2677            .await
2678            .unwrap();
2679
2680        let Some(OKXWsMessage::Orders(orders)) = orders else {
2681            panic!("expected buffered order update, received {orders:?}");
2682        };
2683
2684        let response = tokio::time::timeout(Duration::from_secs(1), peer.handler.next())
2685            .await
2686            .unwrap();
2687
2688        let Some(OKXWsMessage::OrderResponse {
2689            id,
2690            op,
2691            code,
2692            msg,
2693            data,
2694            client_order_ids,
2695        }) = response
2696        else {
2697            panic!("expected buffered order response, received {response:?}");
2698        };
2699
2700        assert_eq!(
2701            serde_json::to_value(orders).unwrap(),
2702            serde_json::to_value(expected_orders).unwrap()
2703        );
2704        assert_eq!(id.as_deref(), Some("queued-response-17"));
2705        assert_eq!(op, OKXWsOperation::Order);
2706        assert_eq!(code, if empty_refusal { "50124" } else { "0" });
2707        assert_eq!(client_order_ids, vec![ClientOrderId::from("OQUEUED17")]);
2708        assert!(peer.handler.sent_requests.is_empty());
2709        assert_eq!(msg, fixture["response"]["msg"].as_str().unwrap());
2710        assert_eq!(data, *fixture["response"]["data"].as_array().unwrap());
2711        assert!(peer.handler.pending_messages.is_empty());
2712        assert!(peer.frames.try_recv().is_err());
2713        peer.handler.inner.as_ref().unwrap().disconnect().await;
2714        peer.server.abort();
2715    }
2716
2717    #[rstest]
2718    #[case::login("login_error", false, true)]
2719    #[case::key("api_key_error", false, true)]
2720    #[case::login_rate_limit("login_rate_limit", false, true)]
2721    #[case::login_method("login_method_error", false, true)]
2722    #[case::subscription("subscription_error", false, false)]
2723    #[case::authenticated("api_key_error", true, false)]
2724    #[tokio::test]
2725    async fn authentication_error_frame_resolves_only_rejected_login(
2726        #[case] fixture_key: &str,
2727        #[case] authenticated: bool,
2728        #[case] rejected: bool,
2729    ) {
2730        let mut peer = handler_peer().await;
2731        peer.handler.requires_auth = true;
2732        let mut pending = peer.handler.auth_tracker.begin();
2733        if authenticated {
2734            peer.handler.auth_tracker.succeed();
2735            assert_eq!(pending.try_recv().unwrap(), Ok(()));
2736        }
2737
2738        let fixture: Value =
2739            serde_json::from_str(&load_test_json("ws_reconnect_queued_frames.json")).unwrap();
2740        let (raw_tx, raw_rx) = tokio::sync::mpsc::unbounded_channel();
2741        peer.handler.raw_rx = raw_rx;
2742        raw_tx
2743            .send(Message::Text(fixture[fixture_key].to_string().into()))
2744            .unwrap();
2745
2746        let message = peer.handler.next().await.unwrap();
2747
2748        let OKXWsMessage::Error(error) = message else {
2749            panic!("expected venue error");
2750        };
2751
2752        assert_eq!(error.code, fixture[fixture_key]["code"].as_str().unwrap());
2753        assert_eq!(error.message, fixture[fixture_key]["msg"].as_str().unwrap());
2754        assert_eq!(peer.handler.auth_tracker.is_authenticated(), authenticated);
2755
2756        if rejected {
2757            assert_eq!(
2758                pending.try_recv().unwrap(),
2759                Err(format!(
2760                    "OKX authentication error {}: {}",
2761                    error.code, error.message
2762                ))
2763            );
2764        } else if !authenticated {
2765            assert!(matches!(
2766                pending.try_recv(),
2767                Err(tokio::sync::oneshot::error::TryRecvError::Empty)
2768            ));
2769        }
2770
2771        peer.handler.inner.as_ref().unwrap().disconnect().await;
2772        peer.server.abort();
2773    }
2774
2775    #[tokio::test]
2776    async fn failed_login_stops_pending_sends() {
2777        let mut peer = handler_peer().await;
2778        let (raw_tx, raw_rx) = tokio::sync::mpsc::unbounded_channel();
2779        peer.handler.raw_rx = raw_rx;
2780        let fixture: Value =
2781            serde_json::from_str(&load_test_json("ws_reconnect_queued_frames.json")).unwrap();
2782        raw_tx
2783            .send(Message::Text(fixture["login_failure"].to_string().into()))
2784            .unwrap();
2785        raw_tx
2786            .send(Message::Text(load_test_json("ws_orders.json").into()))
2787            .unwrap();
2788        assert!(matches!(
2789            peer.handler.next().await,
2790            Some(OKXWsMessage::Orders(_))
2791        ));
2792        peer.handler
2793            .pending_sends
2794            .push_back(order_send("request-17".to_string(), 17));
2795        let error = peer.handler.next().await;
2796
2797        assert!(
2798            matches!(error, Some(OKXWsMessage::Error(error)) if error.code == "60009" && error.message == "Login failed")
2799        );
2800        assert!(!peer.handler.auth_tracker.is_authenticated());
2801        assert!(!peer.handler.can_send_pending());
2802        assert!(peer.frames.try_recv().is_err());
2803        peer.handler.inner.as_ref().unwrap().disconnect().await;
2804        peer.server.abort();
2805    }
2806
2807    #[tokio::test]
2808    async fn uncertain_write_is_not_replayed_after_recovery() {
2809        let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
2810        let url = format!("ws://{}/", listener.local_addr().unwrap());
2811        let (frame_tx, mut frames) = tokio::sync::mpsc::unbounded_channel();
2812
2813        let server = tokio::spawn(async move {
2814            let (socket, _) = listener.accept().await.unwrap();
2815            let mut socket = tokio_tungstenite::accept_async(socket).await.unwrap();
2816            let mut header = [0u8; 1];
2817            tokio::io::AsyncReadExt::read_exact(socket.get_mut(), &mut header)
2818                .await
2819                .unwrap();
2820            assert_eq!(header[0] & 0x0f, 1);
2821            drop(socket);
2822            let (socket, _) = listener.accept().await.unwrap();
2823            let mut socket = tokio_tungstenite::accept_async(socket).await.unwrap();
2824            while let Some(Ok(frame)) = socket.next().await {
2825                if let Message::Text(text) = frame {
2826                    frame_tx.send(text.to_string()).unwrap();
2827                }
2828            }
2829        });
2830
2831        let (message_handler, raw_rx) = channel_message_handler();
2832        let client = WebSocketClient::builder()
2833            .config(
2834                WebSocketConfig::builder()
2835                    .url(url)
2836                    .backend(TransportBackend::Tungstenite)
2837                    .build()
2838                    .unwrap(),
2839            )
2840            .message_handler(message_handler)
2841            .connect()
2842            .await
2843            .unwrap();
2844        let (_commands, cmd_rx) = tokio::sync::mpsc::unbounded_channel();
2845        let (out_tx, mut messages) = tokio::sync::mpsc::unbounded_channel();
2846
2847        let mut handler = OKXWsFeedHandler::new(
2848            Arc::new(AtomicBool::new(false)),
2849            cmd_rx,
2850            raw_rx,
2851            out_tx,
2852            AuthTracker::new(),
2853            false,
2854            SubscriptionState::new(OKX_WS_TOPIC_DELIMITER),
2855            Arc::new(DashMap::new()),
2856            get_atomic_clock_realtime(),
2857        );
2858        handler.inner = Some(Arc::new(client));
2859        handler.auth_tracker.succeed();
2860        handler
2861            .pending_sends
2862            .push_back(order_send("x".repeat(64 * 1024 * 1024), 17));
2863        handler.send_pending().await;
2864        let failure = messages.try_recv().unwrap();
2865
2866        let OKXWsMessage::SendFailed {
2867            request_id,
2868            client_order_ids,
2869            op,
2870            error,
2871        } = failure
2872        else {
2873            panic!("expected send failure");
2874        };
2875
2876        assert_eq!(request_id, "17");
2877        assert_eq!(client_order_ids, vec![ClientOrderId::from("OQUEUED17")]);
2878        assert_eq!(op, Some(OKXWsOperation::CancelOrder));
2879        assert!(matches!(
2880            error,
2881            OKXWsError::TransportSend(SendError::BrokenPipe(_) | SendError::WriteTimeout)
2882        ));
2883        assert!(handler.pending_sends.is_empty());
2884        assert!(handler.sent_requests.contains_key(&"17".to_string()));
2885        let client = Arc::clone(handler.inner.as_ref().unwrap());
2886        tokio::time::timeout(Duration::from_secs(10), async {
2887            while client.connection_epoch() == 0 || !client.is_active() {
2888                tokio::time::sleep(Duration::from_millis(10)).await;
2889            }
2890        })
2891        .await
2892        .unwrap();
2893
2894        handler
2895            .send_on_connection("recovered-control".to_string(), None)
2896            .await
2897            .unwrap();
2898        assert_eq!(frames.recv().await.unwrap(), "recovered-control");
2899        assert!(frames.try_recv().is_err());
2900        let (raw_tx, raw_rx) = tokio::sync::mpsc::unbounded_channel();
2901        handler.raw_rx = raw_rx;
2902        raw_tx
2903            .send(Message::Text(
2904                json!({"id":"17", "op":"cancel-order", "code":"50124", "msg":"Refused", "data":[]})
2905                    .to_string()
2906                    .into(),
2907            ))
2908            .unwrap();
2909        let response = handler.next().await.unwrap();
2910        assert!(matches!(response, OKXWsMessage::OrderResponse {
2911            op: OKXWsOperation::CancelOrder, client_order_ids, ..
2912        } if client_order_ids == vec![ClientOrderId::from("OQUEUED17")]));
2913        assert!(handler.sent_requests.is_empty());
2914        client.disconnect().await;
2915        server.abort();
2916    }
2917
2918    #[tokio::test]
2919    async fn closed_output_stops_handler_without_inbound_frames() {
2920        let mut peer = handler_peer().await;
2921        peer.messages.close();
2922        let client = peer.handler.inner.take().unwrap();
2923        peer.commands
2924            .send(HandlerCommand::Send {
2925                payload: "unwritten-request-17".to_string(),
2926                rate_limit_keys: None,
2927                request_id: Some("17".to_string()),
2928                client_order_ids: vec![ClientOrderId::from("OQUEUED17")],
2929                op: Some(OKXWsOperation::CancelOrder),
2930            })
2931            .unwrap();
2932
2933        let result = tokio::time::timeout(Duration::from_secs(1), peer.handler.next())
2934            .await
2935            .unwrap();
2936        assert!(result.is_none());
2937        assert!(peer.handler.is_stopped());
2938        assert!(peer.frames.try_recv().is_err());
2939        client.disconnect().await;
2940        peer.server.abort();
2941    }
2942
2943    const SEND_RATE_KEY: &str = "owned-send";
2944
2945    struct HandlerPeer {
2946        handler: OKXWsFeedHandler,
2947        commands: tokio::sync::mpsc::UnboundedSender<HandlerCommand>,
2948        frames: tokio::sync::mpsc::UnboundedReceiver<String>,
2949        messages: tokio::sync::mpsc::UnboundedReceiver<OKXWsMessage>,
2950        server: tokio::task::JoinHandle<()>,
2951    }
2952
2953    async fn handler_peer() -> HandlerPeer {
2954        let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
2955        let url = format!("ws://{}/", listener.local_addr().unwrap());
2956        let (frame_tx, frames) = tokio::sync::mpsc::unbounded_channel();
2957
2958        let server = tokio::spawn(async move {
2959            let mut connections = tokio::task::JoinSet::new();
2960
2961            loop {
2962                let (socket, _) = listener.accept().await.unwrap();
2963                let frame_tx = frame_tx.clone();
2964
2965                connections.spawn(async move {
2966                    let mut socket = tokio_tungstenite::accept_async(socket).await.unwrap();
2967                    while let Some(Ok(frame)) = socket.next().await {
2968                        if let Message::Text(text) = frame {
2969                            frame_tx.send(text.to_string()).unwrap();
2970                        }
2971                    }
2972                });
2973            }
2974        });
2975
2976        let (message_handler, raw_rx) = channel_message_handler();
2977        let client = WebSocketClient::builder()
2978            .config(WebSocketConfig::builder().url(url).build().unwrap())
2979            .message_handler(message_handler)
2980            .keyed_quotas(vec![(
2981                SEND_RATE_KEY.to_string(),
2982                Quota::per_second(NonZeroU32::new(1).unwrap()).unwrap(),
2983            )])
2984            .connect()
2985            .await
2986            .unwrap();
2987        let (commands, cmd_rx) = tokio::sync::mpsc::unbounded_channel();
2988        let (out_tx, messages) = tokio::sync::mpsc::unbounded_channel();
2989
2990        let mut handler = OKXWsFeedHandler::new(
2991            Arc::new(AtomicBool::new(false)),
2992            cmd_rx,
2993            raw_rx,
2994            out_tx,
2995            AuthTracker::new(),
2996            true,
2997            SubscriptionState::new(OKX_WS_TOPIC_DELIMITER),
2998            Arc::new(DashMap::new()),
2999            get_atomic_clock_realtime(),
3000        );
3001        client.set_auth_tracker(handler.auth_tracker.clone(), false);
3002        handler.inner = Some(Arc::new(client));
3003        handler.auth_tracker.succeed();
3004
3005        HandlerPeer {
3006            handler,
3007            commands,
3008            frames,
3009            messages,
3010            server,
3011        }
3012    }
3013
3014    fn order_send(payload: String, index: usize) -> PendingSend {
3015        PendingSend {
3016            payload,
3017            rate_limit_keys: None,
3018            request_id: Some(index.to_string()),
3019            client_order_ids: vec![ClientOrderId::from(format!("OQUEUED{index}").as_str())],
3020            op: Some(OKXWsOperation::CancelOrder),
3021            attempted: false,
3022        }
3023    }
3024
3025    #[rstest]
3026    #[case::submit_rejected(OKXWsOperation::Order, "50124", true)]
3027    #[case::batch_submit_rejected(OKXWsOperation::BatchOrders, "50124", true)]
3028    #[case::cancel_rejected(OKXWsOperation::CancelOrder, "50124", true)]
3029    #[case::batch_cancel_rejected(OKXWsOperation::BatchCancelOrders, "50124", true)]
3030    #[case::amend_rejected(OKXWsOperation::AmendOrder, "50124", true)]
3031    #[case::batch_amend_rejected(OKXWsOperation::BatchAmendOrders, "50124", true)]
3032    #[case::submit_expired(OKXWsOperation::Order, "50036", true)]
3033    #[case::batch_submit_expired(OKXWsOperation::BatchOrders, "50036", true)]
3034    #[case::amend_expired(OKXWsOperation::AmendOrder, "50036", true)]
3035    #[case::batch_amend_expired(OKXWsOperation::BatchAmendOrders, "50036", true)]
3036    #[case::submit_timeout(OKXWsOperation::Order, "50004", false)]
3037    #[case::cancel_timeout(OKXWsOperation::CancelOrder, "50004", false)]
3038    #[case::amend_timeout(OKXWsOperation::AmendOrder, "50004", false)]
3039    #[case::system_busy(OKXWsOperation::Order, "50013", false)]
3040    #[case::success(OKXWsOperation::Order, "0", false)]
3041    #[case::all_failed_without_details(OKXWsOperation::BatchOrders, "1", false)]
3042    #[case::partially_succeeded_without_details(OKXWsOperation::BatchOrders, "2", false)]
3043    #[tokio::test]
3044    async fn empty_order_response_preserves_command_outcome(
3045        #[case] op: OKXWsOperation,
3046        #[case] code: &str,
3047        #[case] rejected: bool,
3048        #[values(false, true)] omit_data: bool,
3049    ) {
3050        let mut peer = handler_peer().await;
3051        let (raw_tx, raw_rx) = tokio::sync::mpsc::unbounded_channel();
3052        peer.handler.raw_rx = raw_rx;
3053        let mut pending = order_send("request-17".to_string(), 17);
3054        pending.op = Some(op.clone());
3055        if matches!(
3056            op,
3057            OKXWsOperation::BatchOrders
3058                | OKXWsOperation::BatchCancelOrders
3059                | OKXWsOperation::BatchAmendOrders
3060        ) {
3061            pending
3062                .client_order_ids
3063                .push(ClientOrderId::from("OQUEUED18"));
3064        }
3065        let client_order_ids = pending.client_order_ids.clone();
3066        peer.handler.pending_sends.push_back(pending);
3067        peer.handler.send_pending().await;
3068        assert_eq!(peer.frames.recv().await.unwrap(), "request-17");
3069
3070        let mut response =
3071            json!({"id":"17", "op":op, "code":code, "msg":"Venue reason", "data":[]});
3072        if omit_data {
3073            response.as_object_mut().unwrap().remove("data");
3074        }
3075        raw_tx
3076            .send(Message::Text(response.to_string().into()))
3077            .unwrap();
3078        let response = peer.handler.next().await.unwrap();
3079        let unrelated = ClientOrderId::from("OUNRELATED");
3080        let mut tracked_ids = client_order_ids.clone();
3081        tracked_ids.push(unrelated);
3082        let (events, state) = dispatch_response(response, &tracked_ids);
3083
3084        assert_eq!(
3085            events.len(),
3086            if rejected { client_order_ids.len() } else { 0 }
3087        );
3088        assert!(state.order_identity(unrelated).is_some());
3089        assert!(state.pending_orders.contains_key(unrelated.as_str()));
3090        assert!(state.pending_cancels.contains_key(unrelated.as_str()));
3091        assert!(state.pending_amends.contains_key(unrelated.as_str()));
3092        let submit = matches!(op, OKXWsOperation::Order | OKXWsOperation::BatchOrders);
3093
3094        for (index, client_order_id) in client_order_ids.into_iter().enumerate() {
3095            assert_eq!(
3096                state.order_identity(client_order_id).is_some(),
3097                !(submit && rejected)
3098            );
3099            assert_eq!(
3100                state.pending_orders.contains_key(client_order_id.as_str()),
3101                !(submit && rejected)
3102            );
3103            assert_eq!(
3104                state.pending_cancels.contains_key(client_order_id.as_str()),
3105                !(!submit
3106                    && rejected
3107                    && matches!(
3108                        op,
3109                        OKXWsOperation::CancelOrder | OKXWsOperation::BatchCancelOrders
3110                    ))
3111            );
3112            assert_eq!(
3113                state.pending_amends.contains_key(client_order_id.as_str()),
3114                !(!submit
3115                    && rejected
3116                    && matches!(
3117                        op,
3118                        OKXWsOperation::AmendOrder | OKXWsOperation::BatchAmendOrders
3119                    ))
3120            );
3121
3122            if rejected {
3123                let reason = format!("OKX error {code}: Venue reason");
3124
3125                match &events[index] {
3126                    ExecutionEvent::Order(OrderEventAny::Rejected(event)) if submit => {
3127                        assert_eq!(event.client_order_id, client_order_id);
3128                        assert_eq!(event.reason.as_str(), reason);
3129                    }
3130                    ExecutionEvent::Order(OrderEventAny::CancelRejected(event))
3131                        if matches!(
3132                            op,
3133                            OKXWsOperation::CancelOrder | OKXWsOperation::BatchCancelOrders
3134                        ) =>
3135                    {
3136                        assert_eq!(event.client_order_id, client_order_id);
3137                        assert_eq!(event.reason.as_str(), reason);
3138                    }
3139                    ExecutionEvent::Order(OrderEventAny::ModifyRejected(event))
3140                        if matches!(
3141                            op,
3142                            OKXWsOperation::AmendOrder | OKXWsOperation::BatchAmendOrders
3143                        ) =>
3144                    {
3145                        assert_eq!(event.client_order_id, client_order_id);
3146                        assert_eq!(event.reason.as_str(), reason);
3147                    }
3148                    event => panic!("Unexpected event: {event:?}"),
3149                }
3150            }
3151        }
3152        peer.handler.inner.as_ref().unwrap().disconnect().await;
3153        peer.server.abort();
3154    }
3155
3156    #[tokio::test]
3157    async fn order_response_correlates_only_once_with_matching_request() {
3158        let mut peer = handler_peer().await;
3159        let (raw_tx, raw_rx) = tokio::sync::mpsc::unbounded_channel();
3160        peer.handler.raw_rx = raw_rx;
3161        for index in [17, 29] {
3162            peer.handler
3163                .pending_sends
3164                .push_back(order_send(format!("request-{index}"), index));
3165            peer.handler.send_pending().await;
3166            peer.frames.recv().await.unwrap();
3167        }
3168
3169        let mut correlated = Vec::new();
3170
3171        for (id, op) in [
3172            (Some("unknown"), OKXWsOperation::CancelOrder),
3173            (None, OKXWsOperation::CancelOrder),
3174            (Some("17"), OKXWsOperation::Order),
3175            (Some("29"), OKXWsOperation::CancelOrder),
3176            (Some("29"), OKXWsOperation::CancelOrder),
3177            (Some("17"), OKXWsOperation::CancelOrder),
3178        ] {
3179            raw_tx
3180                .send(Message::Text(
3181                    json!({"id":id, "op":op, "code":"50124", "msg":"Refused", "data":[]})
3182                        .to_string()
3183                        .into(),
3184                ))
3185                .unwrap();
3186            let response = peer.handler.next().await.unwrap();
3187            let OKXWsMessage::OrderResponse {
3188                client_order_ids, ..
3189            } = &response
3190            else {
3191                panic!("Expected order response");
3192            };
3193            correlated.push(client_order_ids.clone());
3194        }
3195
3196        assert_eq!(
3197            correlated,
3198            vec![
3199                vec![],
3200                vec![],
3201                vec![],
3202                vec![ClientOrderId::from("OQUEUED29")],
3203                vec![],
3204                vec![ClientOrderId::from("OQUEUED17")]
3205            ]
3206        );
3207        assert!(peer.handler.sent_requests.is_empty());
3208        peer.handler.inner.as_ref().unwrap().disconnect().await;
3209        peer.server.abort();
3210    }
3211
3212    #[rstest]
3213    #[case(false)]
3214    #[case(true)]
3215    #[tokio::test]
3216    async fn nonempty_batch_response_keeps_per_item_outcomes(#[case] reverse: bool) {
3217        let mut peer = handler_peer().await;
3218        let (raw_tx, raw_rx) = tokio::sync::mpsc::unbounded_channel();
3219        peer.handler.raw_rx = raw_rx;
3220        let ids = [
3221            ClientOrderId::from("OSUCCESS"),
3222            ClientOrderId::from("OREJECTED"),
3223            ClientOrderId::from("OTIMEOUT"),
3224        ];
3225        let mut pending = order_send("request-17".to_string(), 17);
3226        pending.op = Some(OKXWsOperation::BatchOrders);
3227        pending.client_order_ids = ids.to_vec();
3228        peer.handler.pending_sends.push_back(pending);
3229        peer.handler.send_pending().await;
3230        peer.frames.recv().await.unwrap();
3231        let mut data = vec![
3232            json!({"clOrdId":"OSUCCESS", "sCode":"0", "sMsg":"", "ordId":"771"}),
3233            json!({"clOrdId":"OREJECTED", "sCode":"51000", "sMsg":"Invalid size"}),
3234            json!({"clOrdId":"OTIMEOUT", "sCode":"50004", "sMsg":"Timeout"}),
3235        ];
3236
3237        if reverse {
3238            data.reverse();
3239        }
3240        raw_tx.send(Message::Text(json!({"id":"17", "op":"batch-orders", "code":"2", "msg":"Partial failure", "data":data}).to_string().into())).unwrap();
3241        let response = peer.handler.next().await.unwrap();
3242        let (events, state) = dispatch_response(response, &ids);
3243        raw_tx.send(Message::Text(json!({"id":"17", "op":"batch-orders", "code":"50124", "msg":"Late reply", "data":[]}).to_string().into())).unwrap();
3244        let duplicate = peer.handler.next().await.unwrap();
3245        let OKXWsMessage::OrderResponse {
3246            client_order_ids, ..
3247        } = duplicate
3248        else {
3249            panic!("Expected order response");
3250        };
3251
3252        assert_eq!(events.len(), 1);
3253        assert!(
3254            matches!(&events[0], ExecutionEvent::Order(OrderEventAny::Rejected(event)) if event.client_order_id == ids[1] && event.reason.as_str() == "OKX error 51000: Invalid size")
3255        );
3256        assert!(state.order_identity(ids[0]).is_some());
3257        assert!(!state.pending_orders.contains_key(ids[0].as_str()));
3258        assert!(state.order_identity(ids[1]).is_none());
3259        assert!(state.order_identity(ids[2]).is_some());
3260        assert!(state.pending_orders.contains_key(ids[2].as_str()));
3261        assert!(client_order_ids.is_empty());
3262        assert!(peer.handler.sent_requests.is_empty());
3263        peer.handler.inner.as_ref().unwrap().disconnect().await;
3264        peer.server.abort();
3265    }
3266
3267    #[tokio::test]
3268    async fn order_response_correlation_is_bounded_and_expires() {
3269        let mut peer = handler_peer().await;
3270        let (raw_tx, raw_rx) = tokio::sync::mpsc::unbounded_channel();
3271        peer.handler.raw_rx = raw_rx;
3272        for index in 0..=PENDING_SENDS_CAPACITY {
3273            peer.handler
3274                .pending_sends
3275                .push_back(order_send(format!("request-{index}"), index));
3276            peer.handler.send_pending().await;
3277            peer.frames.recv().await.unwrap();
3278        }
3279        assert_eq!(peer.handler.sent_requests.len(), PENDING_SENDS_CAPACITY);
3280        assert!(!peer.handler.sent_requests.contains_key(&"0".to_string()));
3281
3282        tokio::time::pause();
3283        tokio::time::advance(ORDER_RESPONSE_TTL).await;
3284        raw_tx
3285            .send(Message::Text(
3286                json!({"id":"1", "op":"cancel-order", "code":"50124", "msg":"Too late", "data":[]})
3287                    .to_string()
3288                    .into(),
3289            ))
3290            .unwrap();
3291        let response = peer.handler.next().await.unwrap();
3292        tokio::time::resume();
3293        let OKXWsMessage::OrderResponse {
3294            client_order_ids, ..
3295        } = response
3296        else {
3297            panic!("Expected order response");
3298        };
3299
3300        assert!(client_order_ids.is_empty());
3301        assert!(!peer.handler.sent_requests.contains_key(&"1".to_string()));
3302        peer.commands.send(HandlerCommand::Disconnect).unwrap();
3303        assert!(peer.handler.next().await.is_none());
3304        assert!(peer.handler.sent_requests.is_empty());
3305        peer.server.abort();
3306    }
3307
3308    fn dispatch_response(
3309        response: OKXWsMessage,
3310        client_order_ids: &[ClientOrderId],
3311    ) -> (Vec<ExecutionEvent>, WsDispatchState) {
3312        let state = WsDispatchState::default();
3313        let strategy_id = StrategyId::from("PROBE-007");
3314        let instrument_id = InstrumentId::from("BTC-USDT-SWAP.OKX");
3315
3316        for &client_order_id in client_order_ids {
3317            state.order_identities.insert(
3318                client_order_id,
3319                OrderIdentity {
3320                    client_order_id,
3321                    strategy_id,
3322                    instrument_id,
3323                    order_side: OrderSide::Buy,
3324                    order_type: OrderType::Limit,
3325                },
3326            );
3327
3328            for pending in [
3329                &state.pending_orders,
3330                &state.pending_cancels,
3331                &state.pending_amends,
3332            ] {
3333                pending.insert(
3334                    client_order_id.to_string(),
3335                    PendingOrderInfo {
3336                        trader_id: TraderId::from("TRADER-009"),
3337                        strategy_id,
3338                        instrument_id,
3339                    },
3340                );
3341            }
3342        }
3343        let clock = get_atomic_clock_realtime();
3344        let account_id = AccountId::from("OKX-009");
3345        let mut emitter = ExecutionEventEmitter::new(
3346            clock,
3347            TraderId::from("TRADER-009"),
3348            account_id,
3349            AccountType::Margin,
3350            None,
3351        );
3352        let (sender, mut receiver) = tokio::sync::mpsc::unbounded_channel();
3353        emitter.set_sender(sender);
3354        dispatch_ws_message(
3355            response,
3356            &emitter,
3357            &state,
3358            account_id,
3359            AccountType::Margin,
3360            &AtomicMap::new(),
3361            &mut FeeCache::new(),
3362            &mut FilledQtyCache::new(),
3363            &mut AHashMap::new(),
3364            clock,
3365        );
3366        let mut events = Vec::new();
3367        while let Ok(event) = receiver.try_recv() {
3368            events.push(event);
3369        }
3370        (events, state)
3371    }
3372}