1use 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
72pub enum HandlerCommand {
74 SetClient(Arc<WebSocketClient>),
76 Disconnect,
78 Subscribe { args: Vec<OKXSubscriptionArg> },
80 SubscribeBook {
82 subscription: OKXSubscriptionArg,
83 cancel: CancellationToken,
84 gate: SnapshotGate,
85 completion: tokio::sync::oneshot::Sender<Result<(), OKXWsError>>,
86 },
87 Unsubscribe { args: Vec<OKXSubscriptionArg> },
89 Resubscribe {
91 subscription: OKXSubscriptionArg,
92 cancel: CancellationToken,
93 gate: SnapshotGate,
94 completion: tokio::sync::oneshot::Sender<Result<(), OKXWsError>>,
95 },
96 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 #[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 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 () = time::sleep(time::Duration::from_millis(100)) => {
501 }
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 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
939fn 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
979pub 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
1006pub 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
1016fn 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 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 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 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_timeout(OKXWsOperation::Order, "50004", false)]
3033 #[case::cancel_timeout(OKXWsOperation::CancelOrder, "50004", false)]
3034 #[case::amend_timeout(OKXWsOperation::AmendOrder, "50004", false)]
3035 #[case::system_busy(OKXWsOperation::Order, "50013", false)]
3036 #[case::success(OKXWsOperation::Order, "0", false)]
3037 #[case::all_failed_without_details(OKXWsOperation::BatchOrders, "1", false)]
3038 #[case::partially_succeeded_without_details(OKXWsOperation::BatchOrders, "2", false)]
3039 #[tokio::test]
3040 async fn empty_order_response_preserves_command_outcome(
3041 #[case] op: OKXWsOperation,
3042 #[case] code: &str,
3043 #[case] rejected: bool,
3044 #[values(false, true)] omit_data: bool,
3045 ) {
3046 let mut peer = handler_peer().await;
3047 let (raw_tx, raw_rx) = tokio::sync::mpsc::unbounded_channel();
3048 peer.handler.raw_rx = raw_rx;
3049 let mut pending = order_send("request-17".to_string(), 17);
3050 pending.op = Some(op.clone());
3051 if matches!(
3052 op,
3053 OKXWsOperation::BatchOrders
3054 | OKXWsOperation::BatchCancelOrders
3055 | OKXWsOperation::BatchAmendOrders
3056 ) {
3057 pending
3058 .client_order_ids
3059 .push(ClientOrderId::from("OQUEUED18"));
3060 }
3061 let client_order_ids = pending.client_order_ids.clone();
3062 peer.handler.pending_sends.push_back(pending);
3063 peer.handler.send_pending().await;
3064 assert_eq!(peer.frames.recv().await.unwrap(), "request-17");
3065
3066 let mut response =
3067 json!({"id":"17", "op":op, "code":code, "msg":"Venue reason", "data":[]});
3068 if omit_data {
3069 response.as_object_mut().unwrap().remove("data");
3070 }
3071 raw_tx
3072 .send(Message::Text(response.to_string().into()))
3073 .unwrap();
3074 let response = peer.handler.next().await.unwrap();
3075 let unrelated = ClientOrderId::from("OUNRELATED");
3076 let mut tracked_ids = client_order_ids.clone();
3077 tracked_ids.push(unrelated);
3078 let (events, state) = dispatch_response(response, &tracked_ids);
3079
3080 assert_eq!(
3081 events.len(),
3082 if rejected { client_order_ids.len() } else { 0 }
3083 );
3084 assert!(state.order_identity(unrelated).is_some());
3085 assert!(state.pending_orders.contains_key(unrelated.as_str()));
3086 assert!(state.pending_cancels.contains_key(unrelated.as_str()));
3087 assert!(state.pending_amends.contains_key(unrelated.as_str()));
3088 let submit = matches!(op, OKXWsOperation::Order | OKXWsOperation::BatchOrders);
3089
3090 for (index, client_order_id) in client_order_ids.into_iter().enumerate() {
3091 assert_eq!(
3092 state.order_identity(client_order_id).is_some(),
3093 !(submit && rejected)
3094 );
3095 assert_eq!(
3096 state.pending_orders.contains_key(client_order_id.as_str()),
3097 !(submit && rejected)
3098 );
3099 assert_eq!(
3100 state.pending_cancels.contains_key(client_order_id.as_str()),
3101 !(!submit
3102 && rejected
3103 && matches!(
3104 op,
3105 OKXWsOperation::CancelOrder | OKXWsOperation::BatchCancelOrders
3106 ))
3107 );
3108 assert_eq!(
3109 state.pending_amends.contains_key(client_order_id.as_str()),
3110 !(!submit
3111 && rejected
3112 && matches!(
3113 op,
3114 OKXWsOperation::AmendOrder | OKXWsOperation::BatchAmendOrders
3115 ))
3116 );
3117
3118 if rejected {
3119 let reason = "OKX error 50124: Venue reason";
3120
3121 match &events[index] {
3122 ExecutionEvent::Order(OrderEventAny::Rejected(event)) if submit => {
3123 assert_eq!(event.client_order_id, client_order_id);
3124 assert_eq!(event.reason.as_str(), reason);
3125 }
3126 ExecutionEvent::Order(OrderEventAny::CancelRejected(event))
3127 if matches!(
3128 op,
3129 OKXWsOperation::CancelOrder | OKXWsOperation::BatchCancelOrders
3130 ) =>
3131 {
3132 assert_eq!(event.client_order_id, client_order_id);
3133 assert_eq!(event.reason.as_str(), reason);
3134 }
3135 ExecutionEvent::Order(OrderEventAny::ModifyRejected(event))
3136 if matches!(
3137 op,
3138 OKXWsOperation::AmendOrder | OKXWsOperation::BatchAmendOrders
3139 ) =>
3140 {
3141 assert_eq!(event.client_order_id, client_order_id);
3142 assert_eq!(event.reason.as_str(), reason);
3143 }
3144 event => panic!("Unexpected event: {event:?}"),
3145 }
3146 }
3147 }
3148 peer.handler.inner.as_ref().unwrap().disconnect().await;
3149 peer.server.abort();
3150 }
3151
3152 #[tokio::test]
3153 async fn order_response_correlates_only_once_with_matching_request() {
3154 let mut peer = handler_peer().await;
3155 let (raw_tx, raw_rx) = tokio::sync::mpsc::unbounded_channel();
3156 peer.handler.raw_rx = raw_rx;
3157 for index in [17, 29] {
3158 peer.handler
3159 .pending_sends
3160 .push_back(order_send(format!("request-{index}"), index));
3161 peer.handler.send_pending().await;
3162 peer.frames.recv().await.unwrap();
3163 }
3164
3165 let mut correlated = Vec::new();
3166
3167 for (id, op) in [
3168 (Some("unknown"), OKXWsOperation::CancelOrder),
3169 (None, OKXWsOperation::CancelOrder),
3170 (Some("17"), OKXWsOperation::Order),
3171 (Some("29"), OKXWsOperation::CancelOrder),
3172 (Some("29"), OKXWsOperation::CancelOrder),
3173 (Some("17"), OKXWsOperation::CancelOrder),
3174 ] {
3175 raw_tx
3176 .send(Message::Text(
3177 json!({"id":id, "op":op, "code":"50124", "msg":"Refused", "data":[]})
3178 .to_string()
3179 .into(),
3180 ))
3181 .unwrap();
3182 let response = peer.handler.next().await.unwrap();
3183 let OKXWsMessage::OrderResponse {
3184 client_order_ids, ..
3185 } = &response
3186 else {
3187 panic!("Expected order response");
3188 };
3189 correlated.push(client_order_ids.clone());
3190 }
3191
3192 assert_eq!(
3193 correlated,
3194 vec![
3195 vec![],
3196 vec![],
3197 vec![],
3198 vec![ClientOrderId::from("OQUEUED29")],
3199 vec![],
3200 vec![ClientOrderId::from("OQUEUED17")]
3201 ]
3202 );
3203 assert!(peer.handler.sent_requests.is_empty());
3204 peer.handler.inner.as_ref().unwrap().disconnect().await;
3205 peer.server.abort();
3206 }
3207
3208 #[rstest]
3209 #[case(false)]
3210 #[case(true)]
3211 #[tokio::test]
3212 async fn nonempty_batch_response_keeps_per_item_outcomes(#[case] reverse: bool) {
3213 let mut peer = handler_peer().await;
3214 let (raw_tx, raw_rx) = tokio::sync::mpsc::unbounded_channel();
3215 peer.handler.raw_rx = raw_rx;
3216 let ids = [
3217 ClientOrderId::from("OSUCCESS"),
3218 ClientOrderId::from("OREJECTED"),
3219 ClientOrderId::from("OTIMEOUT"),
3220 ];
3221 let mut pending = order_send("request-17".to_string(), 17);
3222 pending.op = Some(OKXWsOperation::BatchOrders);
3223 pending.client_order_ids = ids.to_vec();
3224 peer.handler.pending_sends.push_back(pending);
3225 peer.handler.send_pending().await;
3226 peer.frames.recv().await.unwrap();
3227 let mut data = vec![
3228 json!({"clOrdId":"OSUCCESS", "sCode":"0", "sMsg":"", "ordId":"771"}),
3229 json!({"clOrdId":"OREJECTED", "sCode":"51000", "sMsg":"Invalid size"}),
3230 json!({"clOrdId":"OTIMEOUT", "sCode":"50004", "sMsg":"Timeout"}),
3231 ];
3232
3233 if reverse {
3234 data.reverse();
3235 }
3236 raw_tx.send(Message::Text(json!({"id":"17", "op":"batch-orders", "code":"2", "msg":"Partial failure", "data":data}).to_string().into())).unwrap();
3237 let response = peer.handler.next().await.unwrap();
3238 let (events, state) = dispatch_response(response, &ids);
3239 raw_tx.send(Message::Text(json!({"id":"17", "op":"batch-orders", "code":"50124", "msg":"Late reply", "data":[]}).to_string().into())).unwrap();
3240 let duplicate = peer.handler.next().await.unwrap();
3241 let OKXWsMessage::OrderResponse {
3242 client_order_ids, ..
3243 } = duplicate
3244 else {
3245 panic!("Expected order response");
3246 };
3247
3248 assert_eq!(events.len(), 1);
3249 assert!(
3250 matches!(&events[0], ExecutionEvent::Order(OrderEventAny::Rejected(event)) if event.client_order_id == ids[1] && event.reason.as_str() == "OKX error 51000: Invalid size")
3251 );
3252 assert!(state.order_identity(ids[0]).is_some());
3253 assert!(!state.pending_orders.contains_key(ids[0].as_str()));
3254 assert!(state.order_identity(ids[1]).is_none());
3255 assert!(state.order_identity(ids[2]).is_some());
3256 assert!(state.pending_orders.contains_key(ids[2].as_str()));
3257 assert!(client_order_ids.is_empty());
3258 assert!(peer.handler.sent_requests.is_empty());
3259 peer.handler.inner.as_ref().unwrap().disconnect().await;
3260 peer.server.abort();
3261 }
3262
3263 #[tokio::test]
3264 async fn order_response_correlation_is_bounded_and_expires() {
3265 let mut peer = handler_peer().await;
3266 let (raw_tx, raw_rx) = tokio::sync::mpsc::unbounded_channel();
3267 peer.handler.raw_rx = raw_rx;
3268 for index in 0..=PENDING_SENDS_CAPACITY {
3269 peer.handler
3270 .pending_sends
3271 .push_back(order_send(format!("request-{index}"), index));
3272 peer.handler.send_pending().await;
3273 peer.frames.recv().await.unwrap();
3274 }
3275 assert_eq!(peer.handler.sent_requests.len(), PENDING_SENDS_CAPACITY);
3276 assert!(!peer.handler.sent_requests.contains_key(&"0".to_string()));
3277
3278 tokio::time::pause();
3279 tokio::time::advance(ORDER_RESPONSE_TTL).await;
3280 raw_tx
3281 .send(Message::Text(
3282 json!({"id":"1", "op":"cancel-order", "code":"50124", "msg":"Too late", "data":[]})
3283 .to_string()
3284 .into(),
3285 ))
3286 .unwrap();
3287 let response = peer.handler.next().await.unwrap();
3288 tokio::time::resume();
3289 let OKXWsMessage::OrderResponse {
3290 client_order_ids, ..
3291 } = response
3292 else {
3293 panic!("Expected order response");
3294 };
3295
3296 assert!(client_order_ids.is_empty());
3297 assert!(!peer.handler.sent_requests.contains_key(&"1".to_string()));
3298 peer.commands.send(HandlerCommand::Disconnect).unwrap();
3299 assert!(peer.handler.next().await.is_none());
3300 assert!(peer.handler.sent_requests.is_empty());
3301 peer.server.abort();
3302 }
3303
3304 fn dispatch_response(
3305 response: OKXWsMessage,
3306 client_order_ids: &[ClientOrderId],
3307 ) -> (Vec<ExecutionEvent>, WsDispatchState) {
3308 let state = WsDispatchState::default();
3309 let strategy_id = StrategyId::from("PROBE-007");
3310 let instrument_id = InstrumentId::from("BTC-USDT-SWAP.OKX");
3311
3312 for &client_order_id in client_order_ids {
3313 state.order_identities.insert(
3314 client_order_id,
3315 OrderIdentity {
3316 client_order_id,
3317 strategy_id,
3318 instrument_id,
3319 order_side: OrderSide::Buy,
3320 order_type: OrderType::Limit,
3321 },
3322 );
3323
3324 for pending in [
3325 &state.pending_orders,
3326 &state.pending_cancels,
3327 &state.pending_amends,
3328 ] {
3329 pending.insert(
3330 client_order_id.to_string(),
3331 PendingOrderInfo {
3332 trader_id: TraderId::from("TRADER-009"),
3333 strategy_id,
3334 instrument_id,
3335 },
3336 );
3337 }
3338 }
3339 let clock = get_atomic_clock_realtime();
3340 let account_id = AccountId::from("OKX-009");
3341 let mut emitter = ExecutionEventEmitter::new(
3342 clock,
3343 TraderId::from("TRADER-009"),
3344 account_id,
3345 AccountType::Margin,
3346 None,
3347 );
3348 let (sender, mut receiver) = tokio::sync::mpsc::unbounded_channel();
3349 emitter.set_sender(sender);
3350 dispatch_ws_message(
3351 response,
3352 &emitter,
3353 &state,
3354 account_id,
3355 AccountType::Margin,
3356 &AtomicMap::new(),
3357 &mut FeeCache::new(),
3358 &mut FilledQtyCache::new(),
3359 &mut AHashMap::new(),
3360 clock,
3361 );
3362 let mut events = Vec::new();
3363 while let Ok(event) = receiver.try_recv() {
3364 events.push(event);
3365 }
3366 (events, state)
3367 }
3368}