1use std::{collections::VecDeque, fmt::Debug, hash::Hash, sync::Arc};
24
25use ahash::AHashMap;
26use dashmap::DashMap;
27use nautilus_common::cache::fifo::{FifoCache, FifoCacheMap};
28use nautilus_core::{AtomicMap, UUID4, UnixNanos, time::AtomicTime};
29use nautilus_live::{
30 ExecutionEventEmitter,
31 execution::{
32 context::{OrderContext, OrderIdentity},
33 failure::CommandFailure,
34 },
35};
36use nautilus_model::{
37 enums::{AccountType, OrderStatus, OrderType},
38 events::{
39 OrderAccepted, OrderCanceled, OrderEventAny, OrderFilled, OrderRejected, OrderTriggered,
40 OrderUpdated,
41 },
42 identifiers::{
43 AccountId, ClientOrderId, InstrumentId, StrategyId, TradeId, TraderId, VenueOrderId,
44 },
45 instruments::{Instrument, InstrumentAny},
46 orders::TRIGGERABLE_ORDER_TYPES,
47 reports::{FillReport, OrderStatusReport},
48 types::Currency,
49};
50use parking_lot::Mutex;
51use ustr::Ustr;
52
53use crate::{
54 common::{
55 consts::{
56 OKX_CONDITIONAL_ORDER_TYPES, OKX_FIELD_CLORDID, OKX_FIELD_SCODE, OKX_FIELD_SMSG,
57 OKX_FIELD_SUBCODE, OKX_POST_ONLY_CANCEL_REASON, OKX_POST_ONLY_CANCEL_SOURCE,
58 OKX_SUCCESS_CODE,
59 },
60 enums::{OKXAlgoOrderStatus, OKXAlgoOrderType, OKXOrderStatus, OKXOrderType},
61 failure::{classify_okx_venue_code, classify_okx_ws_failure},
62 parse::{
63 is_market_price, parse_client_order_id, parse_millisecond_timestamp, parse_price,
64 parse_quantity,
65 },
66 },
67 http::models::{OKXAccount, OKXCancelAlgoOrderResponse, OKXPosition, OKXSpreadOrder},
68 websocket::{
69 client::PendingOrderInfo,
70 enums::OKXWsOperation,
71 handler::{is_post_only_auto_cancel, is_unfilled_rpi_cancel},
72 messages::{ExecutionReport, OKXAlgoOrderMsg, OKXOrderMsg, OKXWsMessage},
73 parse::{
74 FeeCache, FilledQtyCache, OrderStateSnapshot, ParsedOrderEvent,
75 is_terminal_order_state, parse_algo_order_msg, parse_algo_order_status_report,
76 parse_order_event, parse_order_msg, parse_order_status_report,
77 parse_spread_order_event, parse_spread_order_msg, update_fee_fill_caches,
78 },
79 },
80};
81
82const DEDUP_CAPACITY: usize = 10_000;
84
85#[derive(Clone, Copy, Debug, PartialEq, Eq)]
86struct OrderVenueBinding {
87 parent: VenueOrderId,
88 child: Option<VenueOrderId>,
89}
90
91#[derive(Debug)]
92struct OrderLifecycleBindings {
93 client_by_parent: AHashMap<VenueOrderId, ClientOrderId>,
94 venue_by_client: AHashMap<ClientOrderId, OrderVenueBinding>,
95 terminal_client_by_parent: FifoCacheMap<VenueOrderId, ClientOrderId, DEDUP_CAPACITY>,
96}
97
98impl Default for OrderLifecycleBindings {
99 fn default() -> Self {
100 Self {
101 client_by_parent: AHashMap::new(),
102 venue_by_client: AHashMap::new(),
103 terminal_client_by_parent: FifoCacheMap::new(),
104 }
105 }
106}
107
108impl OrderLifecycleBindings {
109 fn client_order_id(&self, parent: &VenueOrderId) -> Option<ClientOrderId> {
110 self.client_by_parent
111 .get(parent)
112 .or_else(|| self.terminal_client_by_parent.get(parent))
113 .copied()
114 }
115
116 fn finish(&mut self, client_order_id: ClientOrderId, binding: OrderVenueBinding) {
117 self.client_by_parent.remove(&binding.parent);
118 self.venue_by_client.remove(&client_order_id);
119 self.terminal_client_by_parent
120 .insert(binding.parent, client_order_id);
121 }
122}
123
124#[derive(Clone, Copy, Debug, PartialEq, Eq)]
125enum ExecutionUpdateRoute {
126 Tracked(ClientOrderId, OrderContext),
127 External,
128 Suppressed,
129}
130
131#[derive(Clone, Copy, Debug, PartialEq, Eq)]
132enum LinkedChildResolution {
133 Bound(ClientOrderId),
134 Held,
135 External,
136}
137
138#[derive(Debug)]
139struct PendingLinkedChild {
140 parent_venue_order_id: VenueOrderId,
141 candidate_client_order_ids: Vec<ClientOrderId>,
142 message: OKXOrderMsg,
143}
144
145#[derive(Debug)]
146struct DedupCache<K>
147where
148 K: Clone + Debug + Eq + Hash,
149{
150 inner: Mutex<FifoCache<K, DEDUP_CAPACITY>>,
151}
152
153impl<K> DedupCache<K>
154where
155 K: Clone + Debug + Eq + Hash,
156{
157 fn new() -> Self {
158 Self {
159 inner: Mutex::new(FifoCache::new()),
160 }
161 }
162
163 fn contains(&self, key: &K) -> bool {
164 self.inner.lock().contains(key)
165 }
166
167 fn insert(&self, key: K) -> bool {
168 self.inner.lock().insert(key)
169 }
170
171 fn remove(&self, key: &K) {
172 self.inner.lock().remove(key);
173 }
174}
175
176#[derive(Debug)]
179pub struct WsDispatchState {
180 pub order_identities: DashMap<ClientOrderId, OrderIdentity>,
181 order_contexts: DashMap<ClientOrderId, OrderContext>,
182 pub(crate) algo_order_states: DashMap<ClientOrderId, AlgoOrderState>,
183 pub(crate) pending_orders: Arc<DashMap<String, PendingOrderInfo>>,
184 pub(crate) pending_cancels: Arc<DashMap<String, PendingOrderInfo>>,
185 pub(crate) pending_amends: Arc<DashMap<String, PendingOrderInfo>>,
186 pub(crate) pending_command_ids: Arc<DashMap<String, Vec<(ClientOrderId, UUID4)>>>,
187 accepted_venue_order_ids: Mutex<FifoCacheMap<ClientOrderId, VenueOrderId, DEDUP_CAPACITY>>,
188 triggered_orders: DedupCache<ClientOrderId>,
189 filled_orders: DedupCache<ClientOrderId>,
190 terminal_orders: DedupCache<ClientOrderId>,
191 emitted_trades: DedupCache<TradeId>,
192 post_only_rejections: DedupCache<Ustr>,
193 lifecycle_bindings: Mutex<OrderLifecycleBindings>,
194 pending_linked_children: Mutex<VecDeque<PendingLinkedChild>>,
195 linked_child_notify: tokio::sync::Notify,
196}
197
198#[derive(Clone, Copy, Debug)]
199pub(crate) struct AlgoOrderState {
200 pub(crate) order_type: OKXAlgoOrderType,
201 pub(crate) ts_last: UnixNanos,
202}
203
204impl Default for WsDispatchState {
205 fn default() -> Self {
206 Self {
207 order_identities: DashMap::new(),
208 order_contexts: DashMap::new(),
209 algo_order_states: DashMap::new(),
210 pending_orders: Arc::new(DashMap::new()),
211 pending_cancels: Arc::new(DashMap::new()),
212 pending_amends: Arc::new(DashMap::new()),
213 pending_command_ids: Arc::new(DashMap::new()),
214 accepted_venue_order_ids: Mutex::new(FifoCacheMap::new()),
215 triggered_orders: DedupCache::new(),
216 filled_orders: DedupCache::new(),
217 terminal_orders: DedupCache::new(),
218 emitted_trades: DedupCache::new(),
219 post_only_rejections: DedupCache::new(),
220 lifecycle_bindings: Mutex::new(OrderLifecycleBindings::default()),
221 pending_linked_children: Mutex::new(VecDeque::new()),
222 linked_child_notify: tokio::sync::Notify::new(),
223 }
224 }
225}
226
227impl WsDispatchState {
228 pub(crate) fn with_pending_maps(
231 pending_orders: Arc<DashMap<String, PendingOrderInfo>>,
232 pending_cancels: Arc<DashMap<String, PendingOrderInfo>>,
233 pending_amends: Arc<DashMap<String, PendingOrderInfo>>,
234 pending_command_ids: Arc<DashMap<String, Vec<(ClientOrderId, UUID4)>>>,
235 ) -> Self {
236 Self {
237 pending_orders,
238 pending_cancels,
239 pending_amends,
240 pending_command_ids,
241 ..Default::default()
242 }
243 }
244
245 pub(crate) fn track_order_context(&self, context: OrderContext) {
246 self.order_contexts
247 .insert(context.identity.client_order_id, context);
248 }
249
250 pub(crate) fn register_external_order(
251 &self,
252 context: OrderContext,
253 venue_order_id: VenueOrderId,
254 ) {
255 let client_order_id = context.identity.client_order_id;
256 self.track_order_context(context);
257 self.bind_order(client_order_id, venue_order_id);
258 self.insert_accepted(client_order_id, venue_order_id);
259 }
260
261 pub(crate) fn bind_order(&self, client_order_id: ClientOrderId, venue_order_id: VenueOrderId) {
262 let mut bindings = self.lifecycle_bindings.lock();
263 let binding = bindings.venue_by_client.get(&client_order_id).copied();
264 if binding.is_some_and(|binding| binding.parent != venue_order_id) {
265 log::error!(
266 "Ignoring conflicting order binding for {client_order_id}: expected={:?} received={venue_order_id}",
267 binding.map(|binding| binding.parent),
268 );
269 return;
270 }
271
272 bindings
273 .client_by_parent
274 .insert(venue_order_id, client_order_id);
275 bindings.venue_by_client.insert(
276 client_order_id,
277 binding.unwrap_or(OrderVenueBinding {
278 parent: venue_order_id,
279 child: None,
280 }),
281 );
282 self.linked_child_notify.notify_one();
283 }
284
285 pub(crate) fn order_venue_binding(
286 &self,
287 client_order_id: ClientOrderId,
288 ) -> Option<(VenueOrderId, bool)> {
289 let bindings = self.lifecycle_bindings.lock();
290 bindings
291 .venue_by_client
292 .get(&client_order_id)
293 .map(|binding| {
294 (
295 binding.child.unwrap_or(binding.parent),
296 binding.child.is_some(),
297 )
298 })
299 }
300
301 pub(crate) fn order_identity(&self, client_order_id: ClientOrderId) -> Option<OrderIdentity> {
302 self.order_context(client_order_id)
303 .map(|context| context.identity)
304 .or_else(|| {
305 self.order_identities
306 .get(&client_order_id)
307 .map(|entry| *entry)
308 })
309 }
310
311 pub(crate) fn order_context(&self, client_order_id: ClientOrderId) -> Option<OrderContext> {
312 self.order_contexts
313 .get(&client_order_id)
314 .map(|entry| *entry)
315 }
316
317 pub(crate) fn remove_order_tracking(&self, client_order_id: ClientOrderId) {
318 self.pending_command_ids.retain(|_, commands| {
319 commands.retain(|(id, _)| *id != client_order_id);
320 !commands.is_empty()
321 });
322
323 let pending = self.pending_linked_children.lock();
324 let removed_context = self.order_contexts.remove(&client_order_id);
325 self.order_identities.remove(&client_order_id);
326 self.algo_order_states.remove(&client_order_id);
327 drop(pending);
328
329 let Some((_, context)) = removed_context else {
330 return;
331 };
332
333 if context.identity.order_type != OrderType::Limit {
334 self.linked_child_notify.notify_one();
335 return;
336 }
337
338 let mut bindings = self.lifecycle_bindings.lock();
339 if let Some(binding) = bindings.venue_by_client.remove(&client_order_id) {
340 bindings.client_by_parent.remove(&binding.parent);
341 }
342 }
343
344 pub(crate) fn resolve_algo_submit_failure(
345 &self,
346 client_order_id: ClientOrderId,
347 failure: &CommandFailure,
348 ) {
349 let bindings = self.lifecycle_bindings.lock();
350 if matches!(failure, CommandFailure::Ambiguous(_))
351 && bindings.venue_by_client.contains_key(&client_order_id)
352 {
353 return;
354 }
355
356 self.remove_order_tracking(client_order_id);
357 }
358
359 pub(crate) async fn wait_for_linked_child_route(&self) {
360 self.linked_child_notify.notified().await;
361 }
362
363 fn resolve_or_hold_linked_child(
364 &self,
365 parent_venue_order_id: VenueOrderId,
366 instrument_id: InstrumentId,
367 message: &OKXOrderMsg,
368 ) -> LinkedChildResolution {
369 let candidate_client_order_ids = self
370 .order_contexts
371 .iter()
372 .filter_map(|entry| {
373 (entry.identity.instrument_id == instrument_id
374 && OKX_CONDITIONAL_ORDER_TYPES.contains(&entry.identity.order_type))
375 .then_some(entry.identity.client_order_id)
376 })
377 .collect::<Vec<_>>();
378 let bindings = self.lifecycle_bindings.lock();
379 if let Some(client_order_id) = bindings.client_order_id(&parent_venue_order_id) {
380 return LinkedChildResolution::Bound(client_order_id);
381 }
382
383 let mut pending = self.pending_linked_children.lock();
384 let candidate_client_order_ids = candidate_client_order_ids
385 .iter()
386 .filter(|client_order_id| {
387 self.order_contexts.contains_key(client_order_id)
388 && !bindings.venue_by_client.contains_key(client_order_id)
389 })
390 .copied()
391 .collect::<Vec<_>>();
392
393 if candidate_client_order_ids.is_empty() {
394 return LinkedChildResolution::External;
395 }
396
397 pending.push_back(PendingLinkedChild {
398 parent_venue_order_id,
399 candidate_client_order_ids,
400 message: message.clone(),
401 });
402 LinkedChildResolution::Held
403 }
404
405 fn take_routable_linked_children(&self) -> Vec<OKXOrderMsg> {
406 if self.pending_linked_children.lock().is_empty() {
407 return Vec::new();
408 }
409
410 let bindings = self.lifecycle_bindings.lock();
411 let mut pending = self.pending_linked_children.lock();
412 let mut held = VecDeque::with_capacity(pending.len());
413 let mut routable = Vec::new();
414
415 while let Some(child) = pending.pop_front() {
416 let is_bound = bindings
417 .client_order_id(&child.parent_venue_order_id)
418 .is_some();
419 let is_pending = child
420 .candidate_client_order_ids
421 .iter()
422 .any(|client_order_id| {
423 self.order_contexts.contains_key(client_order_id)
424 && !bindings.venue_by_client.contains_key(client_order_id)
425 });
426
427 if is_bound || !is_pending {
428 routable.push(child.message);
429 } else {
430 held.push_back(child);
431 }
432 }
433
434 *pending = held;
435 routable
436 }
437}
438
439impl WsDispatchState {
440 #[must_use]
442 pub fn contains_accepted(&self, cid: &ClientOrderId) -> bool {
443 self.accepted_venue_order_ids.lock().contains_key(cid)
444 }
445
446 pub fn insert_accepted(&self, cid: ClientOrderId, venue_order_id: VenueOrderId) {
448 self.accepted_venue_order_ids
449 .lock()
450 .insert(cid, venue_order_id);
451 }
452
453 fn accepted_venue_order_id(&self, cid: &ClientOrderId) -> Option<VenueOrderId> {
454 self.accepted_venue_order_ids.lock().get(cid).copied()
455 }
456
457 #[must_use]
459 pub fn contains_triggered(&self, cid: &ClientOrderId) -> bool {
460 self.triggered_orders.contains(cid)
461 }
462
463 pub fn insert_triggered(&self, cid: ClientOrderId) {
465 let _ = self.triggered_orders.insert(cid);
466 }
467
468 #[must_use]
470 pub fn contains_filled(&self, cid: &ClientOrderId) -> bool {
471 self.filled_orders.contains(cid)
472 }
473
474 pub fn insert_filled(&self, cid: ClientOrderId) {
476 let _ = self.filled_orders.insert(cid);
477 }
478
479 #[must_use]
481 pub fn contains_terminal(&self, cid: &ClientOrderId) -> bool {
482 self.terminal_orders.contains(cid)
483 }
484
485 pub fn insert_terminal(&self, cid: ClientOrderId) {
487 let _ = self.terminal_orders.insert(cid);
488 }
489
490 pub fn check_and_insert_trade(&self, trade_id: TradeId) -> bool {
493 !self.emitted_trades.insert(trade_id)
494 }
495
496 #[must_use]
497 pub fn contains_trade(&self, trade_id: &TradeId) -> bool {
498 self.emitted_trades.contains(trade_id)
499 }
500
501 fn remove_accepted(&self, cid: &ClientOrderId) {
502 self.accepted_venue_order_ids.lock().remove(cid);
503 }
504
505 fn remove_triggered(&self, cid: &ClientOrderId) {
506 self.triggered_orders.remove(cid);
507 }
508
509 fn remove_filled(&self, cid: &ClientOrderId) {
510 self.filled_orders.remove(cid);
511 }
512
513 fn insert_post_only_rejection(&self, order_id: Ustr) {
514 let _ = self.post_only_rejections.insert(order_id);
515 }
516
517 fn contains_post_only_rejection(&self, order_id: &Ustr) -> bool {
518 self.post_only_rejections.contains(order_id)
519 }
520}
521
522#[expect(clippy::too_many_arguments)]
529pub fn dispatch_ws_message(
530 message: OKXWsMessage,
531 emitter: &ExecutionEventEmitter,
532 state: &WsDispatchState,
533 account_id: AccountId,
534 account_type: AccountType,
535 instruments: &AtomicMap<Ustr, InstrumentAny>,
536 fee_cache: &mut FeeCache,
537 filled_qty_cache: &mut FilledQtyCache,
538 order_state_cache: &mut AHashMap<ClientOrderId, OrderStateSnapshot>,
539 clock: &AtomicTime,
540) {
541 let guard = instruments.load();
542 let instruments: &AHashMap<Ustr, InstrumentAny> = &guard;
543
544 match message {
545 OKXWsMessage::Orders(order_msgs) => {
546 let ts_init = clock.get_time_ns();
547 let pending_order_msgs = state.take_routable_linked_children();
548 if !pending_order_msgs.is_empty() {
549 dispatch_order_messages(
550 &pending_order_msgs,
551 emitter,
552 state,
553 account_id,
554 instruments,
555 fee_cache,
556 filled_qty_cache,
557 order_state_cache,
558 ts_init,
559 );
560 }
561 dispatch_order_messages(
562 &order_msgs,
563 emitter,
564 state,
565 account_id,
566 instruments,
567 fee_cache,
568 filled_qty_cache,
569 order_state_cache,
570 ts_init,
571 );
572 }
573 OKXWsMessage::SpreadOrders(order_msgs) => {
574 let ts_init = clock.get_time_ns();
575 dispatch_spread_order_messages(
576 &order_msgs,
577 emitter,
578 state,
579 account_id,
580 instruments,
581 filled_qty_cache,
582 order_state_cache,
583 ts_init,
584 );
585 }
586 OKXWsMessage::AlgoOrders(algo_msgs) => {
587 let ts_init = clock.get_time_ns();
588 for msg in &algo_msgs {
589 dispatch_algo_order_message(msg, emitter, state, account_id, instruments, ts_init);
590 }
591 }
592 OKXWsMessage::Account(data) => {
593 let ts_init = clock.get_time_ns();
594
595 match serde_json::from_value::<Vec<OKXAccount>>(data) {
596 Ok(accounts) => {
597 for account in &accounts {
598 match crate::common::parse::parse_account_state(
599 account,
600 account_id,
601 account_type,
602 ts_init,
603 ) {
604 Ok(account_state) => emitter.send_account_state(account_state),
605 Err(e) => log::error!("Failed to parse account state: {e}"),
606 }
607 }
608 }
609 Err(e) => log::error!("Failed to deserialize account data: {e}"),
610 }
611 }
612 OKXWsMessage::Positions(data) => {
613 let ts_init = clock.get_time_ns();
614
615 match serde_json::from_value::<Vec<OKXPosition>>(data) {
616 Ok(positions) => {
617 for position in positions {
618 let Some(instrument) = instruments.get(&position.inst_id) else {
619 log::warn!("No cached instrument for position: {}", position.inst_id);
620 continue;
621 };
622 let instrument_id = instrument.id();
623 let size_precision = instrument.size_precision();
624
625 match crate::common::parse::parse_position_status_report(
626 &position,
627 account_id,
628 instrument_id,
629 size_precision,
630 ts_init,
631 ) {
632 Ok(report) => emitter.send_position_report(report),
633 Err(e) => log::error!("Failed to parse position report: {e}"),
634 }
635 }
636 }
637 Err(e) => log::error!("Failed to deserialize positions data: {e}"),
638 }
639 }
640 OKXWsMessage::OrderResponse {
641 id,
642 op,
643 code,
644 msg,
645 mut data,
646 client_order_ids,
647 } => {
648 let command_ids = id
649 .as_ref()
650 .and_then(|id| state.pending_command_ids.remove(id))
651 .map_or_default(|(_, ids)| ids);
652 let ts_init = clock.get_time_ns();
653
654 if code != OKX_SUCCESS_CODE && data.is_empty() {
655 log::warn!(
656 "Order response error (no data): id={id:?} op={op:?} code={code} msg={msg}"
657 );
658
659 if code != "1" && code != "2" {
661 data = client_order_ids
662 .into_iter()
663 .map(|client_order_id| {
664 serde_json::json!({
665 "clOrdId": client_order_id.as_str(),
666 "sCode": code,
667 "sMsg": msg,
668 })
669 })
670 .collect();
671 }
672 }
673
674 for item in &data {
675 let s_code = item
676 .get(OKX_FIELD_SCODE)
677 .and_then(|v| v.as_str())
678 .unwrap_or("");
679 let s_msg = item
680 .get(OKX_FIELD_SMSG)
681 .and_then(|v| v.as_str())
682 .unwrap_or("");
683 let sub_code = item
684 .get(OKX_FIELD_SUBCODE)
685 .and_then(|v| v.as_str())
686 .unwrap_or("");
687 let reason = format_order_response_reason(s_code, s_msg, sub_code);
688 let cl_ord_id = item
689 .get(OKX_FIELD_CLORDID)
690 .and_then(|v| v.as_str())
691 .unwrap_or("");
692
693 if s_code == OKX_SUCCESS_CODE {
694 log::debug!("Order response ok: op={op:?} cl_ord_id={cl_ord_id}");
695 match op {
696 OKXWsOperation::Order
697 | OKXWsOperation::BatchOrders
698 | OKXWsOperation::OrderAlgo => {
699 state.pending_orders.remove(cl_ord_id);
700 }
701 OKXWsOperation::CancelOrder
702 | OKXWsOperation::BatchCancelOrders
703 | OKXWsOperation::MassCancel
704 | OKXWsOperation::CancelAlgos => {
705 state.pending_cancels.remove(cl_ord_id);
706 }
707 OKXWsOperation::AmendOrder | OKXWsOperation::BatchAmendOrders => {
708 state.pending_amends.remove(cl_ord_id);
709 }
710 _ => {}
711 }
712 continue;
713 }
714
715 let Some(client_order_id) = parse_client_order_id(cl_ord_id) else {
716 log::warn!(
717 "Order response error without client_order_id: \
718 op={op:?} s_code={s_code} s_msg={s_msg}"
719 );
720 continue;
721 };
722
723 let Some(ident) = state.order_identity(client_order_id) else {
724 log::warn!(
725 "Order response error for untracked order: \
726 op={op:?} cl_ord_id={cl_ord_id} s_code={s_code} s_msg={s_msg}"
727 );
728 continue;
729 };
730
731 let venue_order_id = item
732 .get("ordId")
733 .and_then(|v| v.as_str())
734 .filter(|s| !s.is_empty())
735 .map(VenueOrderId::new);
736
737 match classify_okx_venue_code(s_code, reason.clone()) {
738 CommandFailure::Ambiguous(reason) => {
739 log::warn!(
740 "Ambiguous order response for {client_order_id}, awaiting reconciliation: \
741 op={op:?} s_code={s_code} {reason}"
742 );
743 continue;
744 }
745 CommandFailure::NotSent(_) => {
746 log::warn!(
747 "Unexpected NotSent classification for venue order response: \
748 op={op:?} cl_ord_id={cl_ord_id} s_code={s_code}"
749 );
750 continue;
751 }
752 CommandFailure::VenueRejected(_) => {}
753 }
754
755 match op {
756 OKXWsOperation::Order | OKXWsOperation::BatchOrders => {
757 state.remove_order_tracking(client_order_id);
758 state.pending_orders.remove(cl_ord_id);
759 emitter.emit_order_rejected_event(
760 ident.strategy_id,
761 ident.instrument_id,
762 client_order_id,
763 &reason,
764 ts_init,
765 false,
766 );
767 }
768 OKXWsOperation::CancelOrder
769 | OKXWsOperation::BatchCancelOrders
770 | OKXWsOperation::MassCancel => {
771 state.pending_cancels.remove(cl_ord_id);
772 emitter.emit_order_cancel_rejected_event(
773 ident.strategy_id,
774 ident.instrument_id,
775 client_order_id,
776 venue_order_id,
777 &reason,
778 ts_init,
779 command_ids
780 .iter()
781 .find(|(id, _)| *id == client_order_id)
782 .map(|(_, cause)| *cause),
783 );
784 }
785 OKXWsOperation::AmendOrder | OKXWsOperation::BatchAmendOrders => {
786 state.pending_amends.remove(cl_ord_id);
787 emitter.emit_order_modify_rejected_event(
788 ident.strategy_id,
789 ident.instrument_id,
790 client_order_id,
791 venue_order_id,
792 &reason,
793 ts_init,
794 command_ids
795 .iter()
796 .find(|(id, _)| *id == client_order_id)
797 .map(|(_, cause)| *cause),
798 );
799 }
800 _ => {
801 log::warn!(
802 "Order response error for unhandled op: \
803 op={op:?} cl_ord_id={cl_ord_id} s_code={s_code} s_msg={s_msg}"
804 );
805 }
806 }
807 }
808 }
809 OKXWsMessage::SendFailed {
810 request_id,
811 client_order_ids,
812 op,
813 error,
814 } => {
815 dispatch_send_failure(
816 &request_id,
817 client_order_ids,
818 op.as_ref(),
819 &error,
820 emitter,
821 state,
822 clock,
823 );
824 }
825 OKXWsMessage::ChannelData { channel, .. } => {
826 log::debug!("Ignoring data channel message on execution client: {channel:?}");
827 }
828 OKXWsMessage::SubscriptionFailed {
829 channel,
830 inst_id,
831 code,
832 msg,
833 } => {
834 log::error!(
835 "OKX rejected {channel:?} subscription for {inst_id:?} \
836 (code={code}, msg={msg}); execution updates for it will not flow"
837 );
838 }
839 OKXWsMessage::LiquidationWarnings(warnings) => {
840 for warning in warnings {
841 log::warn!(
842 "Liquidation warning: inst_id={}, pos_side={:?}, pos={}, mgn_ratio={}, mark_px={}, mgn_mode={:?}",
843 warning.inst_id,
844 warning.pos_side,
845 warning.pos,
846 warning.mgn_ratio,
847 warning.mark_px,
848 warning.mgn_mode,
849 );
850 }
851 }
852 OKXWsMessage::BookData { .. }
853 | OKXWsMessage::RpiBookData { .. }
854 | OKXWsMessage::Instruments(_) => {
855 log::debug!("Ignoring data message on execution client");
856 }
857 OKXWsMessage::Error(_) => {}
858 OKXWsMessage::Reconnected => {
859 log::info!("Websocket reconnected");
860 }
861 OKXWsMessage::Authenticated => {
862 log::debug!("Websocket authenticated");
863 }
864 }
865}
866
867fn dispatch_send_failure(
868 request_id: &str,
869 client_order_ids: Vec<ClientOrderId>,
870 op: Option<&OKXWsOperation>,
871 error: &crate::websocket::error::OKXWsError,
872 emitter: &ExecutionEventEmitter,
873 state: &WsDispatchState,
874 clock: &AtomicTime,
875) {
876 let failure = classify_okx_ws_failure(error);
877 let is_ambiguous = matches!(failure, CommandFailure::Ambiguous(_));
878
879 let command_ids = if is_ambiguous {
880 state
881 .pending_command_ids
882 .get(request_id)
883 .map_or_default(|entry| entry.clone())
884 } else {
885 state
886 .pending_command_ids
887 .remove(request_id)
888 .map_or_default(|(_, ids)| ids)
889 };
890
891 log::warn!(
892 "WebSocket send failed without structured venue response: \
893 request_id={request_id}, client_order_ids={client_order_ids:?}, \
894 op={op:?}, {failure:?}"
895 );
896
897 for client_order_id in client_order_ids {
898 let key = client_order_id.as_str();
899 let causation_id = command_ids
900 .iter()
901 .find(|(id, _)| *id == client_order_id)
902 .map(|(_, cause)| *cause);
903
904 match op {
905 Some(
906 OKXWsOperation::Order | OKXWsOperation::BatchOrders | OKXWsOperation::OrderAlgo,
907 ) => {
908 if !is_ambiguous {
909 state.pending_orders.remove(key);
910 }
911
912 emit_send_failed_submit(&failure, state, emitter, clock, client_order_id);
913 }
914 Some(
915 OKXWsOperation::CancelOrder
916 | OKXWsOperation::BatchCancelOrders
917 | OKXWsOperation::MassCancel
918 | OKXWsOperation::CancelAlgos,
919 ) => {
920 if !is_ambiguous {
921 state.pending_cancels.remove(key);
922 }
923
924 emit_send_failed_cancel(
925 &failure,
926 state,
927 emitter,
928 clock,
929 client_order_id,
930 None,
931 causation_id,
932 );
933 }
934 Some(OKXWsOperation::AmendOrder | OKXWsOperation::BatchAmendOrders) => {
935 if !is_ambiguous {
936 state.pending_amends.remove(key);
937 }
938
939 emit_send_failed_modify(
940 &failure,
941 state,
942 emitter,
943 clock,
944 client_order_id,
945 causation_id,
946 );
947 }
948 _ => {}
949 }
950 }
951}
952
953fn route_algo_order_message(
954 msg: &OKXAlgoOrderMsg,
955 state: &WsDispatchState,
956) -> ExecutionUpdateRoute {
957 if matches!(
958 msg.ord_type,
959 OKXAlgoOrderType::Iceberg
960 | OKXAlgoOrderType::SmartIceberg
961 | OKXAlgoOrderType::Twap
962 | OKXAlgoOrderType::Chase
963 | OKXAlgoOrderType::Other
964 ) || msg.state == OKXAlgoOrderStatus::Unknown
965 {
966 return ExecutionUpdateRoute::Suppressed;
967 }
968
969 let direct_client_order_id = parse_client_order_id(&msg.algo_cl_ord_id)
970 .or_else(|| parse_client_order_id(&msg.cl_ord_id));
971
972 if let Some(client_order_id) = direct_client_order_id {
973 if state.contains_terminal(&client_order_id) {
974 return ExecutionUpdateRoute::Suppressed;
975 }
976
977 if let Some(context) = state
978 .order_contexts
979 .get(&client_order_id)
980 .filter(|entry| OKX_CONDITIONAL_ORDER_TYPES.contains(&entry.identity.order_type))
981 .map(|entry| *entry)
982 {
983 return ExecutionUpdateRoute::Tracked(client_order_id, context);
984 }
985
986 if state.order_identity(client_order_id).is_some() {
987 return ExecutionUpdateRoute::Suppressed;
988 }
989 }
990
991 let parent_venue_order_id = VenueOrderId::new(msg.algo_id.as_str());
992 let client_order_id = {
993 let bindings = state.lifecycle_bindings.lock();
994 bindings.client_order_id(&parent_venue_order_id)
995 };
996
997 let Some(client_order_id) = client_order_id else {
998 return ExecutionUpdateRoute::External;
999 };
1000
1001 if state.contains_terminal(&client_order_id) {
1002 return ExecutionUpdateRoute::Suppressed;
1003 }
1004
1005 state
1006 .order_contexts
1007 .get(&client_order_id)
1008 .filter(|entry| OKX_CONDITIONAL_ORDER_TYPES.contains(&entry.identity.order_type))
1009 .map_or(ExecutionUpdateRoute::Suppressed, |entry| {
1010 ExecutionUpdateRoute::Tracked(client_order_id, *entry)
1011 })
1012}
1013
1014fn dispatch_algo_order_message(
1015 msg: &OKXAlgoOrderMsg,
1016 emitter: &ExecutionEventEmitter,
1017 state: &WsDispatchState,
1018 account_id: AccountId,
1019 instruments: &AHashMap<Ustr, InstrumentAny>,
1020 ts_init: UnixNanos,
1021) {
1022 let route = route_algo_order_message(msg, state);
1023
1024 match route {
1025 ExecutionUpdateRoute::External => {
1026 match parse_algo_order_msg(msg, account_id, instruments, ts_init) {
1027 Ok(Some(report)) => dispatch_execution_reports(vec![report], emitter, state),
1028 Ok(None) => {}
1029 Err(e) => log::error!("Failed to parse external algo order message: {e}"),
1030 }
1031 }
1032 ExecutionUpdateRoute::Suppressed => {
1033 log::debug!(
1034 "Suppressing algo order update: algo_id={} state={:?}",
1035 msg.algo_id,
1036 msg.state,
1037 );
1038 }
1039 ExecutionUpdateRoute::Tracked(client_order_id, context) => {
1040 let Some(instrument) = instruments.get(&msg.inst_id) else {
1041 log::warn!(
1042 "No instrument for {}, skipping algo order message",
1043 msg.inst_id
1044 );
1045 return;
1046 };
1047 dispatch_tracked_algo_order_message(
1048 msg,
1049 client_order_id,
1050 context,
1051 instrument,
1052 emitter,
1053 state,
1054 account_id,
1055 ts_init,
1056 );
1057 }
1058 }
1059}
1060
1061#[expect(
1062 clippy::too_many_arguments,
1063 reason = "tracked routing requires the resolved context, venue state, and event timestamps"
1064)]
1065fn dispatch_tracked_algo_order_message(
1066 msg: &OKXAlgoOrderMsg,
1067 client_order_id: ClientOrderId,
1068 mut context: OrderContext,
1069 instrument: &InstrumentAny,
1070 emitter: &ExecutionEventEmitter,
1071 state: &WsDispatchState,
1072 account_id: AccountId,
1073 ts_init: UnixNanos,
1074) {
1075 let parent_venue_order_id = VenueOrderId::new(msg.algo_id.as_str());
1076 let ts_event = parse_millisecond_timestamp(msg.u_time);
1077 let mut bindings = state.lifecycle_bindings.lock();
1078 let mut is_terminal = false;
1079 let mut binding = bindings
1080 .venue_by_client
1081 .get(&client_order_id)
1082 .copied()
1083 .unwrap_or(OrderVenueBinding {
1084 parent: parent_venue_order_id,
1085 child: None,
1086 });
1087
1088 if binding.parent != parent_venue_order_id {
1089 log::error!(
1090 "Suppressing conflicting algo parent binding for {client_order_id}: expected={} received={parent_venue_order_id}",
1091 binding.parent,
1092 );
1093 return;
1094 }
1095
1096 if binding.child.is_none() {
1097 let Some(refreshed) = dispatch_pending_algo_order(
1098 msg, context, instrument, account_id, ts_event, ts_init, emitter, state,
1099 ) else {
1100 return;
1101 };
1102
1103 context = refreshed;
1104 }
1105
1106 bindings
1107 .client_by_parent
1108 .insert(parent_venue_order_id, client_order_id);
1109
1110 match msg.state {
1111 OKXAlgoOrderStatus::Live | OKXAlgoOrderStatus::Pause => {}
1112 OKXAlgoOrderStatus::Effective
1113 | OKXAlgoOrderStatus::OrderPlaced
1114 | OKXAlgoOrderStatus::PartiallyEffective
1115 | OKXAlgoOrderStatus::Filled
1116 | OKXAlgoOrderStatus::PartiallyFailed => {
1117 let child_venue_order_id = algo_child_venue_order_id(msg);
1118 if let Some(child_venue_order_id) = child_venue_order_id {
1119 bind_algo_child_and_emit_transition(
1120 client_order_id,
1121 parent_venue_order_id,
1122 child_venue_order_id,
1123 &mut binding,
1124 context,
1125 account_id,
1126 ts_event,
1127 ts_init,
1128 emitter,
1129 state,
1130 );
1131 } else {
1132 ensure_accepted_emitted(
1133 client_order_id,
1134 account_id,
1135 parent_venue_order_id,
1136 &context.identity,
1137 emitter,
1138 state,
1139 ts_event,
1140 ts_init,
1141 );
1142 }
1143
1144 if matches!(
1145 msg.state,
1146 OKXAlgoOrderStatus::Filled | OKXAlgoOrderStatus::PartiallyFailed
1147 ) {
1148 log::debug!(
1149 "Deferring tracked algo {:?} update for {client_order_id} to regular child execution updates",
1150 msg.state,
1151 );
1152 }
1153 }
1154 OKXAlgoOrderStatus::Canceled => {
1155 if binding.child.is_some() {
1156 log::debug!(
1157 "Suppressing stale canceled algo parent for triggered order {client_order_id}"
1158 );
1159 } else {
1160 ensure_accepted_emitted(
1161 client_order_id,
1162 account_id,
1163 parent_venue_order_id,
1164 &context.identity,
1165 emitter,
1166 state,
1167 ts_event,
1168 ts_init,
1169 );
1170 let canceled = OrderCanceled::new(
1171 emitter.trader_id(),
1172 context.identity.strategy_id,
1173 context.identity.instrument_id,
1174 client_order_id,
1175 UUID4::new(),
1176 ts_event,
1177 ts_init,
1178 false,
1179 Some(parent_venue_order_id),
1180 Some(account_id),
1181 None,
1182 );
1183 state.insert_terminal(client_order_id);
1184 state.remove_accepted(&client_order_id);
1185 state.remove_order_tracking(client_order_id);
1186 is_terminal = true;
1187 emitter.send_order_event(OrderEventAny::Canceled(canceled));
1188 }
1189 }
1190 OKXAlgoOrderStatus::OrderFailed => {
1191 if binding.child.is_some() {
1192 log::debug!(
1193 "Suppressing stale failed algo parent for triggered order {client_order_id}"
1194 );
1195 } else {
1196 let reason = if msg.fail_code.is_empty() {
1197 "OKX algo order failed".to_string()
1198 } else {
1199 format_order_response_reason(&msg.fail_code, "", "")
1200 };
1201 let rejected = OrderRejected::new(
1202 emitter.trader_id(),
1203 context.identity.strategy_id,
1204 context.identity.instrument_id,
1205 client_order_id,
1206 account_id,
1207 Ustr::from(reason.as_str()),
1208 UUID4::new(),
1209 ts_event,
1210 ts_init,
1211 false,
1212 false,
1213 );
1214 state.insert_terminal(client_order_id);
1215 state.remove_accepted(&client_order_id);
1216 state.remove_order_tracking(client_order_id);
1217 is_terminal = true;
1218 emitter.send_order_event(OrderEventAny::Rejected(rejected));
1219 }
1220 }
1221 OKXAlgoOrderStatus::Unknown => {}
1222 }
1223
1224 if is_terminal {
1225 bindings.finish(client_order_id, binding);
1226 } else {
1227 bindings.venue_by_client.insert(client_order_id, binding);
1228 }
1229
1230 drop(bindings);
1231 state.linked_child_notify.notify_one();
1232}
1233
1234fn algo_child_venue_order_id(msg: &OKXAlgoOrderMsg) -> Option<VenueOrderId> {
1235 if !msg.ord_id.is_empty() {
1236 return Some(VenueOrderId::new(msg.ord_id.as_str()));
1237 }
1238
1239 match msg.ord_id_list.as_slice() {
1240 [order_id] if !order_id.is_empty() => Some(VenueOrderId::new(order_id.as_str())),
1241 [] => None,
1242 order_ids => {
1243 log::warn!(
1244 "Cannot bind algo order {} to {} triggered child IDs",
1245 msg.algo_id,
1246 order_ids.len(),
1247 );
1248 None
1249 }
1250 }
1251}
1252
1253#[expect(clippy::too_many_arguments)]
1254fn dispatch_pending_algo_order(
1255 msg: &OKXAlgoOrderMsg,
1256 mut context: OrderContext,
1257 instrument: &InstrumentAny,
1258 account_id: AccountId,
1259 ts_event: UnixNanos,
1260 ts_init: UnixNanos,
1261 emitter: &ExecutionEventEmitter,
1262 state: &WsDispatchState,
1263) -> Option<OrderContext> {
1264 if state
1265 .algo_order_states
1266 .get(&context.identity.client_order_id)
1267 .is_some_and(|previous| ts_event < previous.ts_last)
1268 {
1269 return None;
1270 }
1271
1272 let client_order_id = context.identity.client_order_id;
1273 let pending = matches!(
1274 msg.state,
1275 OKXAlgoOrderStatus::Live | OKXAlgoOrderStatus::Pause
1276 );
1277 let parent_venue_order_id = VenueOrderId::new(msg.algo_id.as_str());
1278
1279 if pending {
1280 ensure_accepted_emitted(
1281 client_order_id,
1282 account_id,
1283 parent_venue_order_id,
1284 &context.identity,
1285 emitter,
1286 state,
1287 ts_event,
1288 ts_init,
1289 );
1290 }
1291
1292 let previous = context;
1293
1294 match parse_algo_order_status_report(msg, instrument, account_id, ts_init) {
1295 Ok(report) => {
1296 if !msg.sz.is_empty() {
1297 context.quantity = report.quantity;
1298 }
1299
1300 context.price = report.price;
1301 context.trigger_price = report.trigger_price;
1302 context.trigger_type = report.trigger_type;
1303 }
1304 Err(e) => {
1305 log::error!(
1306 "Failed to refresh tracked algo order context for {}: {e}",
1307 context.identity.client_order_id,
1308 );
1309 return Some(context);
1310 }
1311 }
1312
1313 if !msg.actual_sz.is_empty() && msg.actual_sz != "0" {
1314 match parse_quantity(msg.actual_sz.as_str(), instrument.size_precision()) {
1315 Ok(quantity) => context.quantity = quantity,
1316 Err(e) => log::error!(
1317 "Failed to refresh tracked algo actual quantity for {}: {e}",
1318 context.identity.client_order_id,
1319 ),
1320 }
1321 }
1322
1323 state.track_order_context(context);
1324 state.algo_order_states.insert(
1325 client_order_id,
1326 AlgoOrderState {
1327 order_type: msg.ord_type,
1328 ts_last: ts_event,
1329 },
1330 );
1331
1332 if pending
1333 && msg.ord_type != OKXAlgoOrderType::MoveOrderStop
1334 && (previous.quantity != context.quantity
1335 || previous.price != context.price
1336 || previous.trigger_price != context.trigger_price)
1337 {
1338 emit_order_update(
1339 parent_venue_order_id,
1340 context,
1341 account_id,
1342 ts_event,
1343 ts_init,
1344 false,
1345 emitter,
1346 );
1347 }
1348
1349 Some(context)
1350}
1351
1352fn refresh_regular_child_context(
1353 msg: &OKXOrderMsg,
1354 mut context: OrderContext,
1355 instrument: &InstrumentAny,
1356) -> OrderContext {
1357 match parse_quantity(&msg.sz, instrument.size_precision()) {
1358 Ok(quantity) => context.quantity = quantity,
1359 Err(e) => log::error!(
1360 "Failed to refresh tracked child quantity for {}: {e}",
1361 context.identity.client_order_id,
1362 ),
1363 }
1364
1365 context.price = if is_market_price(&msg.px) {
1366 None
1367 } else {
1368 match parse_price(&msg.px, instrument.price_precision()) {
1369 Ok(price) => Some(price),
1370 Err(e) => {
1371 log::error!(
1372 "Failed to refresh tracked child price for {}: {e}",
1373 context.identity.client_order_id,
1374 );
1375 context.price
1376 }
1377 }
1378 };
1379 context
1380}
1381
1382#[expect(clippy::too_many_arguments)]
1383fn bind_algo_child_and_emit_transition(
1384 client_order_id: ClientOrderId,
1385 parent_venue_order_id: VenueOrderId,
1386 child_venue_order_id: VenueOrderId,
1387 binding: &mut OrderVenueBinding,
1388 context: OrderContext,
1389 account_id: AccountId,
1390 ts_event: UnixNanos,
1391 ts_init: UnixNanos,
1392 emitter: &ExecutionEventEmitter,
1393 state: &WsDispatchState,
1394) {
1395 if let Some(bound_child) = binding.child {
1396 if bound_child != child_venue_order_id {
1397 log::error!(
1398 "Suppressing conflicting algo child binding for {client_order_id}: expected={bound_child} received={child_venue_order_id}"
1399 );
1400 }
1401 return;
1402 }
1403
1404 binding.child = Some(child_venue_order_id);
1405 state.track_order_context(context);
1406 ensure_accepted_emitted(
1407 client_order_id,
1408 account_id,
1409 parent_venue_order_id,
1410 &context.identity,
1411 emitter,
1412 state,
1413 ts_event,
1414 ts_init,
1415 );
1416
1417 if state.accepted_venue_order_id(&client_order_id) != Some(child_venue_order_id) {
1418 state.insert_accepted(client_order_id, child_venue_order_id);
1419 emit_order_update(
1420 child_venue_order_id,
1421 context,
1422 account_id,
1423 ts_event,
1424 ts_init,
1425 false,
1426 emitter,
1427 );
1428 }
1429
1430 if !state.contains_triggered(&client_order_id) {
1431 state.insert_triggered(client_order_id);
1432
1433 if TRIGGERABLE_ORDER_TYPES.contains(&context.identity.order_type) {
1434 let triggered = OrderTriggered::new(
1435 emitter.trader_id(),
1436 context.identity.strategy_id,
1437 context.identity.instrument_id,
1438 client_order_id,
1439 UUID4::new(),
1440 ts_event,
1441 ts_init,
1442 false,
1443 Some(child_venue_order_id),
1444 Some(account_id),
1445 );
1446 emitter.send_order_event(OrderEventAny::Triggered(triggered));
1447 }
1448 }
1449}
1450
1451#[expect(clippy::too_many_arguments)]
1452fn refresh_bound_child_and_emit_update(
1453 client_order_id: ClientOrderId,
1454 child_venue_order_id: VenueOrderId,
1455 context: OrderContext,
1456 account_id: AccountId,
1457 ts_event: UnixNanos,
1458 ts_init: UnixNanos,
1459 emitter: &ExecutionEventEmitter,
1460 state: &WsDispatchState,
1461 emit_update: bool,
1462) {
1463 let terms_changed = state
1464 .order_contexts
1465 .get(&client_order_id)
1466 .is_some_and(|previous| {
1467 previous.quantity != context.quantity
1468 || previous.price != context.price
1469 || previous.trigger_price != context.trigger_price
1470 });
1471 state.track_order_context(context);
1472
1473 if !terms_changed || !emit_update {
1474 return;
1475 }
1476
1477 state.insert_accepted(client_order_id, child_venue_order_id);
1478 emit_order_update(
1479 child_venue_order_id,
1480 context,
1481 account_id,
1482 ts_event,
1483 ts_init,
1484 false,
1485 emitter,
1486 );
1487}
1488
1489fn emit_order_update(
1490 child_venue_order_id: VenueOrderId,
1491 context: OrderContext,
1492 account_id: AccountId,
1493 ts_event: UnixNanos,
1494 ts_init: UnixNanos,
1495 reconciliation: bool,
1496 emitter: &ExecutionEventEmitter,
1497) {
1498 let updated = OrderUpdated::new(
1499 emitter.trader_id(),
1500 context.identity.strategy_id,
1501 context.identity.instrument_id,
1502 context.identity.client_order_id,
1503 context.quantity,
1504 UUID4::new(),
1505 ts_event,
1506 ts_init,
1507 reconciliation,
1508 Some(child_venue_order_id),
1509 Some(account_id),
1510 context.price,
1511 context.trigger_price,
1512 None,
1513 context.is_quote_quantity,
1514 );
1515 emitter.send_order_event(OrderEventAny::Updated(updated));
1516}
1517
1518#[expect(clippy::too_many_arguments)]
1521fn dispatch_order_messages(
1522 order_msgs: &[OKXOrderMsg],
1523 emitter: &ExecutionEventEmitter,
1524 state: &WsDispatchState,
1525 account_id: AccountId,
1526 instruments: &AHashMap<Ustr, InstrumentAny>,
1527 fee_cache: &mut FeeCache,
1528 filled_qty_cache: &mut FilledQtyCache,
1529 order_state_cache: &mut AHashMap<ClientOrderId, OrderStateSnapshot>,
1530 ts_init: UnixNanos,
1531) {
1532 for msg in order_msgs {
1533 let Some(instrument) = instruments.get(&msg.inst_id) else {
1534 log::warn!("No instrument for {}, skipping order message", msg.inst_id);
1535 continue;
1536 };
1537
1538 let direct_client_order_id = state
1539 .lifecycle_bindings
1540 .lock()
1541 .client_by_parent
1542 .get(&VenueOrderId::new(msg.ord_id))
1543 .copied()
1544 .or_else(|| parse_client_order_id(&msg.cl_ord_id));
1545 let parent_client_order_id = msg
1546 .algo_cl_ord_id
1547 .as_deref()
1548 .and_then(parse_client_order_id);
1549 let linked_parent_venue_order_id = msg
1550 .algo_id
1551 .as_deref()
1552 .filter(|value| !value.is_empty())
1553 .or_else(|| {
1554 msg.linked_algo_ord
1555 .as_ref()
1556 .map(|linked| linked.algo_id.as_str())
1557 .filter(|value| !value.is_empty())
1558 })
1559 .map(VenueOrderId::new);
1560
1561 let direct_resolution = [direct_client_order_id, parent_client_order_id]
1564 .into_iter()
1565 .flatten()
1566 .find_map(|client_order_id| {
1567 state
1568 .order_identity(client_order_id)
1569 .map(|identity| (client_order_id, Some(identity)))
1570 });
1571
1572 let bound_client_order_id = if direct_resolution.is_none()
1573 && let Some(parent_venue_order_id) = linked_parent_venue_order_id
1574 {
1575 match state.resolve_or_hold_linked_child(parent_venue_order_id, instrument.id(), msg) {
1576 LinkedChildResolution::Bound(client_order_id) => Some(client_order_id),
1577 LinkedChildResolution::Held => {
1578 log::debug!(
1579 "Holding linked child update during algo parent binding: ord_id={} parent_id={parent_venue_order_id}",
1580 msg.ord_id,
1581 );
1582 continue;
1583 }
1584 LinkedChildResolution::External => None,
1585 }
1586 } else {
1587 None
1588 };
1589
1590 let resolved = direct_resolution
1591 .or_else(|| {
1592 bound_client_order_id.and_then(|client_order_id| {
1593 state
1594 .order_identity(client_order_id)
1595 .map(|identity| (client_order_id, Some(identity)))
1596 })
1597 })
1598 .or_else(|| {
1599 bound_client_order_id
1600 .or(parent_client_order_id)
1601 .or(direct_client_order_id)
1602 .map(|client_order_id| (client_order_id, None))
1603 });
1604
1605 let Some((client_order_id, identity)) = resolved else {
1606 log::debug!(
1607 "Order without client or algo client order ID (ord_id={}), sending as report",
1608 msg.ord_id
1609 );
1610 dispatch_order_msg_as_report(
1611 msg,
1612 account_id,
1613 instruments,
1614 fee_cache,
1615 filled_qty_cache,
1616 emitter,
1617 state,
1618 ts_init,
1619 );
1620 continue;
1621 };
1622
1623 if let Some(ident) = identity {
1624 let context = state
1625 .order_contexts
1626 .get(&client_order_id)
1627 .filter(|entry| OKX_CONDITIONAL_ORDER_TYPES.contains(&entry.identity.order_type))
1628 .map(|entry| refresh_regular_child_context(msg, *entry, instrument));
1629 let mut lifecycle_bindings = context.map(|_| state.lifecycle_bindings.lock());
1630
1631 if let (Some(context), Some(bindings)) = (context, lifecycle_bindings.as_mut()) {
1632 let parent_venue_order_id = linked_parent_venue_order_id.or_else(|| {
1633 bindings
1634 .venue_by_client
1635 .get(&client_order_id)
1636 .map(|binding| binding.parent)
1637 });
1638
1639 let child_venue_order_id = VenueOrderId::new(msg.ord_id);
1640 let parent_venue_order_id = parent_venue_order_id.unwrap_or(child_venue_order_id);
1641 let mut binding = bindings
1642 .venue_by_client
1643 .get(&client_order_id)
1644 .copied()
1645 .unwrap_or(OrderVenueBinding {
1646 parent: parent_venue_order_id,
1647 child: None,
1648 });
1649
1650 if binding.parent != parent_venue_order_id {
1651 log::error!(
1652 "Suppressing conflicting child parent binding for {client_order_id}: expected={} received={parent_venue_order_id}",
1653 binding.parent,
1654 );
1655 continue;
1656 }
1657
1658 bindings
1659 .client_by_parent
1660 .insert(parent_venue_order_id, client_order_id);
1661 let ts_event = parse_millisecond_timestamp(msg.u_time);
1662
1663 if binding.child == Some(child_venue_order_id) {
1664 refresh_bound_child_and_emit_update(
1665 client_order_id,
1666 child_venue_order_id,
1667 context,
1668 account_id,
1669 ts_event,
1670 ts_init,
1671 emitter,
1672 state,
1673 !order_state_cache.contains_key(&client_order_id),
1674 );
1675 } else {
1676 bind_algo_child_and_emit_transition(
1677 client_order_id,
1678 parent_venue_order_id,
1679 child_venue_order_id,
1680 &mut binding,
1681 context,
1682 account_id,
1683 ts_event,
1684 ts_init,
1685 emitter,
1686 state,
1687 );
1688 }
1689
1690 bindings.venue_by_client.insert(client_order_id, binding);
1691 }
1692
1693 let is_post_only_cancel = is_post_only_auto_cancel(msg);
1694
1695 if is_post_only_cancel
1696 || (!state.contains_accepted(&client_order_id) && is_unfilled_rpi_cancel(msg))
1697 {
1698 if is_post_only_cancel {
1699 state.insert_post_only_rejection(msg.ord_id);
1700 }
1701
1702 let ts_event = parse_millisecond_timestamp(msg.u_time);
1703 let reason = if msg.ord_type == OKXOrderType::Rpi {
1704 msg.cancel_source_reason
1705 .as_deref()
1706 .filter(|reason| !reason.is_empty())
1707 .unwrap_or("RPI order canceled before acceptance")
1708 } else {
1709 "Post-only order would have taken liquidity"
1710 };
1711 let rejected = OrderRejected::new(
1712 emitter.trader_id(),
1713 ident.strategy_id,
1714 instrument.id(),
1715 client_order_id,
1716 account_id,
1717 Ustr::from(reason),
1718 UUID4::new(),
1719 ts_event,
1720 ts_init,
1721 false,
1722 true, );
1724 state.remove_order_tracking(client_order_id);
1725 if let Some(bindings) = lifecycle_bindings.as_mut() {
1726 state.insert_terminal(client_order_id);
1727 if let Some(binding) = bindings.venue_by_client.get(&client_order_id).copied() {
1728 bindings.finish(client_order_id, binding);
1729 }
1730 }
1731
1732 order_state_cache.remove(&client_order_id);
1733 fee_cache.remove(&msg.ord_id);
1734 filled_qty_cache.remove(&msg.ord_id);
1735 emitter.send_order_event(OrderEventAny::Rejected(rejected));
1736 continue;
1737 }
1738
1739 let previous_fee = fee_cache.get(&msg.ord_id).copied();
1740 let previous_filled_qty = filled_qty_cache.get(&msg.ord_id).copied();
1741 let previous_state = order_state_cache.get(&client_order_id);
1742
1743 match parse_order_event(
1744 msg,
1745 client_order_id,
1746 account_id,
1747 emitter.trader_id(),
1748 ident.strategy_id,
1749 instrument,
1750 previous_fee,
1751 previous_filled_qty,
1752 previous_state,
1753 ts_init,
1754 ) {
1755 Ok(event) => {
1756 let needs_status =
1757 matches!(event, ParsedOrderEvent::Fill(_) | ParsedOrderEvent::Skipped);
1758 update_order_state_cache(msg, instrument, client_order_id, order_state_cache);
1759 dispatch_imported_order_update(
1760 client_order_id,
1761 msg.state,
1762 parse_millisecond_timestamp(msg.u_time),
1763 ts_init,
1764 emitter,
1765 state,
1766 order_state_cache,
1767 &event,
1768 );
1769 dispatch_parsed_order_event(
1770 event,
1771 client_order_id,
1772 account_id,
1773 VenueOrderId::new(msg.ord_id),
1774 &ident,
1775 instrument,
1776 msg.state,
1777 emitter,
1778 state,
1779 order_state_cache,
1780 ts_init,
1781 );
1782
1783 dispatch_filled_order_status(
1784 msg,
1785 Some(client_order_id),
1786 instrument,
1787 emitter,
1788 state,
1789 ts_init,
1790 needs_status,
1791 );
1792
1793 if state.contains_terminal(&client_order_id)
1794 && let Some(bindings) = lifecycle_bindings.as_mut()
1795 && let Some(binding) =
1796 bindings.venue_by_client.get(&client_order_id).copied()
1797 {
1798 bindings.finish(client_order_id, binding);
1799 }
1800
1801 update_fee_fill_caches(msg, instrument, fee_cache, filled_qty_cache);
1802 }
1803 Err(e) => log::error!("Failed to parse order event for {client_order_id}: {e}"),
1804 }
1805 } else if state.contains_terminal(&client_order_id) {
1806 dispatch_terminal_order_fill_as_report(
1807 msg,
1808 client_order_id,
1809 account_id,
1810 instruments,
1811 fee_cache,
1812 filled_qty_cache,
1813 emitter,
1814 state,
1815 ts_init,
1816 );
1817 } else if is_post_only_auto_cancel(msg) && state.contains_post_only_rejection(&msg.ord_id) {
1818 log::debug!(
1819 "Skipping replayed post-only rejection for {client_order_id}: ord_id={}",
1820 msg.ord_id
1821 );
1822 } else {
1823 log::debug!(
1824 "Untracked order {client_order_id} (ord_id={}), sending as report for reconciliation",
1825 msg.ord_id
1826 );
1827 dispatch_order_msg_as_report(
1828 msg,
1829 account_id,
1830 instruments,
1831 fee_cache,
1832 filled_qty_cache,
1833 emitter,
1834 state,
1835 ts_init,
1836 );
1837 }
1838 }
1839}
1840
1841#[expect(clippy::too_many_arguments)]
1842fn dispatch_imported_order_update(
1843 client_order_id: ClientOrderId,
1844 venue_status: OKXOrderStatus,
1845 ts_event: UnixNanos,
1846 ts_init: UnixNanos,
1847 emitter: &ExecutionEventEmitter,
1848 state: &WsDispatchState,
1849 order_state_cache: &AHashMap<ClientOrderId, OrderStateSnapshot>,
1850 event: &ParsedOrderEvent,
1851) {
1852 let Some(mut context) = state
1853 .order_contexts
1854 .get_mut(&client_order_id)
1855 .filter(|entry| entry.identity.order_type == OrderType::Limit)
1856 else {
1857 return;
1858 };
1859
1860 let Some(snapshot) = order_state_cache.get(&client_order_id) else {
1861 return;
1862 };
1863
1864 let terms_changed = snapshot.quantity != context.quantity || snapshot.price != context.price;
1865 context.quantity = snapshot.quantity;
1866 context.price = snapshot.price;
1867
1868 if terms_changed
1869 && !matches!(event, ParsedOrderEvent::Updated(_))
1870 && matches!(
1871 venue_status,
1872 OKXOrderStatus::Live | OKXOrderStatus::PartiallyFilled | OKXOrderStatus::Filled
1873 )
1874 {
1875 emit_order_update(
1876 snapshot.venue_order_id,
1877 *context,
1878 emitter.account_id(),
1879 ts_event,
1880 ts_init,
1881 venue_status == OKXOrderStatus::Filled,
1882 emitter,
1883 );
1884 }
1885}
1886
1887#[expect(clippy::too_many_arguments)]
1888fn dispatch_spread_order_messages(
1889 order_msgs: &[OKXSpreadOrder],
1890 emitter: &ExecutionEventEmitter,
1891 state: &WsDispatchState,
1892 account_id: AccountId,
1893 instruments: &AHashMap<Ustr, InstrumentAny>,
1894 filled_qty_cache: &mut FilledQtyCache,
1895 order_state_cache: &mut AHashMap<ClientOrderId, OrderStateSnapshot>,
1896 ts_init: UnixNanos,
1897) {
1898 for msg in order_msgs {
1899 let Some(instrument) = instruments.get(&msg.sprd_id) else {
1900 log::warn!(
1901 "No instrument for {}, skipping spread order message",
1902 msg.sprd_id
1903 );
1904 continue;
1905 };
1906
1907 let client_order_id = state
1908 .lifecycle_bindings
1909 .lock()
1910 .client_by_parent
1911 .get(&VenueOrderId::new(msg.ord_id.as_str()))
1912 .copied()
1913 .or_else(|| parse_client_order_id(msg.cl_ord_id.as_str()));
1914
1915 let Some(client_order_id) = client_order_id else {
1916 log::debug!(
1917 "Spread order without client_order_id (ord_id={}), sending as report",
1918 msg.ord_id
1919 );
1920 dispatch_spread_order_msg_as_report(
1921 msg,
1922 account_id,
1923 instruments,
1924 filled_qty_cache,
1925 emitter,
1926 state,
1927 ts_init,
1928 );
1929 continue;
1930 };
1931
1932 let identity = state.order_identity(client_order_id);
1933
1934 if let Some(ident) = identity {
1935 if is_spread_post_only_auto_cancel(msg) {
1936 let ts_event = msg
1937 .u_time
1938 .or(msg.c_time)
1939 .map_or(ts_init, parse_millisecond_timestamp);
1940 let rejected = OrderRejected::new(
1941 emitter.trader_id(),
1942 ident.strategy_id,
1943 instrument.id(),
1944 client_order_id,
1945 account_id,
1946 Ustr::from(OKX_POST_ONLY_CANCEL_REASON),
1947 UUID4::new(),
1948 ts_event,
1949 ts_init,
1950 false,
1951 true,
1952 );
1953 state.remove_order_tracking(client_order_id);
1954 order_state_cache.remove(&client_order_id);
1955 filled_qty_cache.remove(&msg.ord_id);
1956 emitter.send_order_event(OrderEventAny::Rejected(rejected));
1957 continue;
1958 }
1959
1960 let previous_filled_qty = filled_qty_cache.get(&msg.ord_id).copied();
1961 let previous_state = order_state_cache.get(&client_order_id);
1962
1963 match parse_spread_order_event(
1964 msg,
1965 client_order_id,
1966 account_id,
1967 emitter.trader_id(),
1968 ident.strategy_id,
1969 instrument,
1970 previous_filled_qty,
1971 previous_state,
1972 ts_init,
1973 ) {
1974 Ok(event) => {
1975 update_spread_order_state_cache(
1976 msg,
1977 instrument,
1978 client_order_id,
1979 order_state_cache,
1980 );
1981 let ts_event = msg
1982 .u_time
1983 .or(msg.c_time)
1984 .map_or(ts_init, parse_millisecond_timestamp);
1985 dispatch_imported_order_update(
1986 client_order_id,
1987 msg.state,
1988 ts_event,
1989 ts_init,
1990 emitter,
1991 state,
1992 order_state_cache,
1993 &event,
1994 );
1995 dispatch_parsed_order_event(
1996 event,
1997 client_order_id,
1998 account_id,
1999 VenueOrderId::new(msg.ord_id.as_str()),
2000 &ident,
2001 instrument,
2002 msg.state,
2003 emitter,
2004 state,
2005 order_state_cache,
2006 ts_init,
2007 );
2008 update_spread_fill_cache(msg, instrument, filled_qty_cache);
2009 }
2010 Err(e) => {
2011 log::error!("Failed to parse spread order event for {client_order_id}: {e}");
2012 }
2013 }
2014 } else {
2015 log::debug!(
2016 "Untracked spread order {client_order_id} (ord_id={}), sending as report for reconciliation",
2017 msg.ord_id
2018 );
2019 dispatch_spread_order_msg_as_report(
2020 msg,
2021 account_id,
2022 instruments,
2023 filled_qty_cache,
2024 emitter,
2025 state,
2026 ts_init,
2027 );
2028 }
2029 }
2030}
2031
2032#[expect(clippy::too_many_arguments)]
2038fn dispatch_parsed_order_event(
2039 event: ParsedOrderEvent,
2040 client_order_id: ClientOrderId,
2041 account_id: AccountId,
2042 venue_order_id: VenueOrderId,
2043 identity: &OrderIdentity,
2044 instrument: &InstrumentAny,
2045 venue_status: OKXOrderStatus,
2046 emitter: &ExecutionEventEmitter,
2047 state: &WsDispatchState,
2048 order_state_cache: &mut AHashMap<ClientOrderId, OrderStateSnapshot>,
2049 ts_init: UnixNanos,
2050) {
2051 let is_terminal;
2052
2053 match event {
2054 ParsedOrderEvent::Accepted(e) => {
2055 if state.contains_filled(&client_order_id) || state.contains_terminal(&client_order_id)
2056 {
2057 log::debug!("Skipping duplicate Accepted for {client_order_id}");
2058 return;
2059 }
2060
2061 if state.contains_accepted(&client_order_id) {
2062 emit_venue_order_id_update_if_changed(
2063 client_order_id,
2064 account_id,
2065 venue_order_id,
2066 identity,
2067 e.ts_event,
2068 emitter,
2069 state,
2070 order_state_cache,
2071 ts_init,
2072 );
2073 return;
2074 }
2075
2076 if state.contains_triggered(&client_order_id) {
2077 log::debug!("Skipping duplicate Accepted for {client_order_id}");
2078 return;
2079 }
2080
2081 state.insert_accepted(client_order_id, venue_order_id);
2082 is_terminal = false;
2083 emitter.send_order_event(OrderEventAny::Accepted(e));
2084 }
2085 ParsedOrderEvent::Triggered(e) => {
2086 if state.contains_filled(&client_order_id) {
2087 log::debug!("Skipping stale Triggered for {client_order_id} (already filled)");
2088 return;
2089 }
2090
2091 if !TRIGGERABLE_ORDER_TYPES.contains(&identity.order_type) {
2092 log::debug!(
2093 "Skipping OrderTriggered for {} order {client_order_id}: market-style stops have no TRIGGERED state",
2094 identity.order_type,
2095 );
2096 state.insert_triggered(client_order_id);
2097 return;
2098 }
2099
2100 ensure_accepted_emitted(
2101 client_order_id,
2102 account_id,
2103 venue_order_id,
2104 identity,
2105 emitter,
2106 state,
2107 ts_init,
2108 ts_init,
2109 );
2110 state.insert_triggered(client_order_id);
2111 is_terminal = false;
2112 emitter.send_order_event(OrderEventAny::Triggered(e));
2113 }
2114 ParsedOrderEvent::Canceled(e) => {
2115 ensure_accepted_emitted(
2116 client_order_id,
2117 account_id,
2118 venue_order_id,
2119 identity,
2120 emitter,
2121 state,
2122 ts_init,
2123 ts_init,
2124 );
2125 state.remove_triggered(&client_order_id);
2126 state.remove_filled(&client_order_id);
2127 is_terminal = true;
2128 emitter.send_order_event(OrderEventAny::Canceled(e));
2129 }
2130 ParsedOrderEvent::Expired(e) => {
2131 ensure_accepted_emitted(
2132 client_order_id,
2133 account_id,
2134 venue_order_id,
2135 identity,
2136 emitter,
2137 state,
2138 ts_init,
2139 ts_init,
2140 );
2141 state.remove_triggered(&client_order_id);
2142 state.remove_filled(&client_order_id);
2143 is_terminal = true;
2144 emitter.send_order_event(OrderEventAny::Expired(e));
2145 }
2146 ParsedOrderEvent::Updated(e) => {
2147 ensure_accepted_emitted(
2148 client_order_id,
2149 account_id,
2150 venue_order_id,
2151 identity,
2152 emitter,
2153 state,
2154 ts_init,
2155 ts_init,
2156 );
2157 is_terminal = false;
2158 emitter.send_order_event(OrderEventAny::Updated(e));
2159 }
2160 ParsedOrderEvent::Fill(fill_report) => {
2161 is_terminal = venue_status == OKXOrderStatus::Filled;
2162
2163 if state.check_and_insert_trade(fill_report.trade_id) {
2164 log::debug!(
2165 "Skipping duplicate fill for {client_order_id}: trade_id={}",
2166 fill_report.trade_id
2167 );
2168 } else {
2169 emit_venue_order_id_update_if_changed(
2170 client_order_id,
2171 account_id,
2172 venue_order_id,
2173 identity,
2174 fill_report.ts_event,
2175 emitter,
2176 state,
2177 order_state_cache,
2178 ts_init,
2179 );
2180 ensure_accepted_emitted(
2181 client_order_id,
2182 account_id,
2183 venue_order_id,
2184 identity,
2185 emitter,
2186 state,
2187 ts_init,
2188 ts_init,
2189 );
2190 state.insert_filled(client_order_id);
2191 state.remove_triggered(&client_order_id);
2192 let filled = fill_report_to_order_filled(
2193 &fill_report,
2194 emitter.trader_id(),
2195 identity,
2196 instrument.quote_currency(),
2197 );
2198 emitter.send_order_event(OrderEventAny::Filled(filled));
2199 }
2200 }
2201 ParsedOrderEvent::StatusOnly(report) => {
2202 is_terminal = matches!(
2203 report.order_status,
2204 OrderStatus::Filled | OrderStatus::Canceled | OrderStatus::Expired
2205 );
2206 emitter.send_order_status_report(*report);
2207 }
2208 ParsedOrderEvent::Skipped => {
2209 is_terminal = venue_status == OKXOrderStatus::Filled;
2210 }
2211 }
2212
2213 if is_terminal {
2214 state.insert_terminal(client_order_id);
2215 state.remove_order_tracking(client_order_id);
2216 state.remove_accepted(&client_order_id);
2217 order_state_cache.remove(&client_order_id);
2218 }
2222}
2223
2224#[expect(
2227 clippy::too_many_arguments,
2228 reason = "acceptance reconstruction requires identity, venue state, and event timestamps"
2229)]
2230fn ensure_accepted_emitted(
2231 client_order_id: ClientOrderId,
2232 account_id: AccountId,
2233 venue_order_id: VenueOrderId,
2234 identity: &OrderIdentity,
2235 emitter: &ExecutionEventEmitter,
2236 state: &WsDispatchState,
2237 ts_event: UnixNanos,
2238 ts_init: UnixNanos,
2239) {
2240 if state.contains_accepted(&client_order_id)
2241 || state.contains_terminal(&client_order_id)
2242 || state.contains_filled(&client_order_id)
2243 {
2244 return;
2245 }
2246
2247 state.insert_accepted(client_order_id, venue_order_id);
2248 let accepted = OrderAccepted::new(
2249 emitter.trader_id(),
2250 identity.strategy_id,
2251 identity.instrument_id,
2252 client_order_id,
2253 venue_order_id,
2254 account_id,
2255 UUID4::new(),
2256 ts_event,
2257 ts_init,
2258 false,
2259 );
2260 emitter.send_order_event(OrderEventAny::Accepted(accepted));
2261}
2262
2263#[expect(clippy::too_many_arguments)]
2264fn emit_venue_order_id_update_if_changed(
2265 client_order_id: ClientOrderId,
2266 account_id: AccountId,
2267 venue_order_id: VenueOrderId,
2268 identity: &OrderIdentity,
2269 ts_event: UnixNanos,
2270 emitter: &ExecutionEventEmitter,
2271 state: &WsDispatchState,
2272 order_state_cache: &AHashMap<ClientOrderId, OrderStateSnapshot>,
2273 ts_init: UnixNanos,
2274) {
2275 let Some(accepted_venue_order_id) = state.accepted_venue_order_id(&client_order_id) else {
2276 return;
2277 };
2278
2279 if accepted_venue_order_id == venue_order_id {
2280 return;
2281 }
2282
2283 let Some(snapshot) = order_state_cache.get(&client_order_id) else {
2284 return;
2285 };
2286
2287 state.insert_accepted(client_order_id, venue_order_id);
2288 let updated = OrderUpdated::new(
2289 emitter.trader_id(),
2290 identity.strategy_id,
2291 identity.instrument_id,
2292 client_order_id,
2293 snapshot.quantity,
2294 UUID4::new(),
2295 ts_event,
2296 ts_init,
2297 false,
2298 Some(venue_order_id),
2299 Some(account_id),
2300 snapshot.price,
2301 None,
2302 None,
2303 false,
2304 );
2305 emitter.send_order_event(OrderEventAny::Updated(updated));
2306}
2307
2308fn fill_report_to_order_filled(
2310 report: &FillReport,
2311 trader_id: TraderId,
2312 identity: &OrderIdentity,
2313 quote_currency: Currency,
2314) -> OrderFilled {
2315 OrderFilled::new(
2316 trader_id,
2317 identity.strategy_id,
2318 report.instrument_id,
2319 report
2320 .client_order_id
2321 .expect("tracked order has client_order_id"),
2322 report.venue_order_id,
2323 report.account_id,
2324 report.trade_id,
2325 identity.order_side,
2326 identity.order_type,
2327 report.last_qty,
2328 report.last_px,
2329 quote_currency,
2330 report.liquidity_side,
2331 UUID4::new(),
2332 report.ts_event,
2333 report.ts_init,
2334 false,
2335 report.venue_position_id,
2336 Some(report.commission),
2337 None,
2338 )
2339}
2340
2341#[expect(clippy::too_many_arguments)]
2343fn dispatch_order_msg_as_report(
2344 msg: &OKXOrderMsg,
2345 account_id: AccountId,
2346 instruments: &AHashMap<Ustr, InstrumentAny>,
2347 fee_cache: &mut FeeCache,
2348 filled_qty_cache: &mut FilledQtyCache,
2349 emitter: &ExecutionEventEmitter,
2350 state: &WsDispatchState,
2351 ts_init: UnixNanos,
2352) {
2353 match parse_order_msg(
2354 msg,
2355 account_id,
2356 instruments,
2357 fee_cache,
2358 filled_qty_cache,
2359 ts_init,
2360 ) {
2361 Ok(report) => {
2362 let needs_status = matches!(report, ExecutionReport::Fill(_));
2363
2364 match report {
2365 ExecutionReport::Fill(fill_report) => {
2366 let order_report = instruments.get(&msg.inst_id).and_then(|instrument| {
2367 parse_order_status_report(msg, instrument, account_id, ts_init)
2368 .inspect_err(|e| {
2369 log::error!("Failed to parse status for untracked order fill: {e}");
2370 })
2371 .ok()
2372 });
2373
2374 match order_report {
2375 Some(order_report) => dispatch_order_with_fills_report(
2376 order_report,
2377 fill_report,
2378 emitter,
2379 state,
2380 ),
2381 None => dispatch_execution_reports(
2382 vec![ExecutionReport::Fill(fill_report)],
2383 emitter,
2384 state,
2385 ),
2386 }
2387 }
2388 report @ ExecutionReport::Order(_) => {
2389 dispatch_execution_reports(vec![report], emitter, state);
2390 }
2391 }
2392
2393 if let Some(instrument) = instruments.get(&msg.inst_id) {
2394 dispatch_filled_order_status(
2395 msg,
2396 None,
2397 instrument,
2398 emitter,
2399 state,
2400 ts_init,
2401 needs_status,
2402 );
2403 update_fee_fill_caches(msg, instrument, fee_cache, filled_qty_cache);
2404 }
2405 }
2406 Err(e) => log::error!("Failed to parse order message as report: {e}"),
2407 }
2408}
2409
2410fn dispatch_filled_order_status(
2411 msg: &OKXOrderMsg,
2412 client_order_id: Option<ClientOrderId>,
2413 instrument: &InstrumentAny,
2414 emitter: &ExecutionEventEmitter,
2415 state: &WsDispatchState,
2416 ts_init: UnixNanos,
2417 needs_status: bool,
2418) {
2419 if !needs_status || msg.state != OKXOrderStatus::Filled {
2420 return;
2421 }
2422
2423 let report = parse_order_status_report(msg, instrument, emitter.account_id(), ts_init)
2424 .and_then(|report| {
2425 let requested = parse_quantity(&msg.sz, instrument.size_precision())?;
2426 Ok((report, requested))
2427 });
2428
2429 match report {
2430 Ok((mut report, requested)) => {
2431 if report.filled_qty.is_positive() && report.quantity != requested {
2432 report.client_order_id = client_order_id.or(report.client_order_id);
2433
2434 dispatch_execution_reports(vec![ExecutionReport::Order(report)], emitter, state);
2436 }
2437 }
2438 Err(e) => log::error!(
2439 "Failed to parse filled order status for {}: {e}",
2440 msg.ord_id
2441 ),
2442 }
2443}
2444
2445#[expect(clippy::too_many_arguments)]
2446fn dispatch_terminal_order_fill_as_report(
2447 msg: &OKXOrderMsg,
2448 client_order_id: ClientOrderId,
2449 account_id: AccountId,
2450 instruments: &AHashMap<Ustr, InstrumentAny>,
2451 fee_cache: &mut FeeCache,
2452 filled_qty_cache: &mut FilledQtyCache,
2453 emitter: &ExecutionEventEmitter,
2454 state: &WsDispatchState,
2455 ts_init: UnixNanos,
2456) {
2457 match parse_order_msg(
2458 msg,
2459 account_id,
2460 instruments,
2461 fee_cache,
2462 filled_qty_cache,
2463 ts_init,
2464 ) {
2465 Ok(ExecutionReport::Fill(mut report)) => {
2466 report.client_order_id = Some(client_order_id);
2467 dispatch_execution_reports(vec![ExecutionReport::Fill(report)], emitter, state);
2468
2469 if let Some(instrument) = instruments.get(&msg.inst_id) {
2470 update_fee_fill_caches(msg, instrument, fee_cache, filled_qty_cache);
2471 }
2472 }
2473 Ok(ExecutionReport::Order(_)) => {
2474 log::debug!(
2475 "Suppressing stale regular order status for terminal tracked order {client_order_id}: ord_id={}",
2476 msg.ord_id,
2477 );
2478 }
2479 Err(e) => log::error!("Failed to parse terminal order update: {e}"),
2480 }
2481}
2482
2483fn dispatch_spread_order_msg_as_report(
2484 msg: &OKXSpreadOrder,
2485 account_id: AccountId,
2486 instruments: &AHashMap<Ustr, InstrumentAny>,
2487 filled_qty_cache: &mut FilledQtyCache,
2488 emitter: &ExecutionEventEmitter,
2489 state: &WsDispatchState,
2490 ts_init: UnixNanos,
2491) {
2492 match parse_spread_order_msg(msg, account_id, instruments, filled_qty_cache, ts_init) {
2493 Ok(report) => {
2494 dispatch_execution_reports(vec![report], emitter, state);
2495
2496 if let Some(instrument) = instruments.get(&msg.sprd_id) {
2497 update_spread_fill_cache(msg, instrument, filled_qty_cache);
2498 }
2499 }
2500 Err(e) => log::error!("Failed to parse spread order message as report: {e}"),
2501 }
2502}
2503
2504fn update_order_state_cache(
2506 msg: &OKXOrderMsg,
2507 instrument: &InstrumentAny,
2508 client_order_id: ClientOrderId,
2509 order_state_cache: &mut AHashMap<ClientOrderId, OrderStateSnapshot>,
2510) {
2511 let venue_order_id = VenueOrderId::new(msg.ord_id);
2512 let quantity = parse_quantity(&msg.sz, instrument.size_precision()).unwrap_or_default();
2513 let price = if is_market_price(&msg.px) {
2514 None
2515 } else {
2516 parse_price(&msg.px, instrument.price_precision()).ok()
2517 };
2518
2519 order_state_cache.insert(
2520 client_order_id,
2521 OrderStateSnapshot {
2522 venue_order_id,
2523 quantity,
2524 price,
2525 },
2526 );
2527}
2528
2529fn update_spread_order_state_cache(
2530 msg: &OKXSpreadOrder,
2531 instrument: &InstrumentAny,
2532 client_order_id: ClientOrderId,
2533 order_state_cache: &mut AHashMap<ClientOrderId, OrderStateSnapshot>,
2534) {
2535 let venue_order_id = VenueOrderId::new(msg.ord_id.as_str());
2536 let quantity = parse_quantity(&msg.sz, instrument.size_precision()).unwrap_or_default();
2537 let price = if is_market_price(&msg.px) {
2538 None
2539 } else {
2540 parse_price(&msg.px, instrument.price_precision()).ok()
2541 };
2542
2543 order_state_cache.insert(
2544 client_order_id,
2545 OrderStateSnapshot {
2546 venue_order_id,
2547 quantity,
2548 price,
2549 },
2550 );
2551}
2552
2553fn update_spread_fill_cache(
2554 msg: &OKXSpreadOrder,
2555 instrument: &InstrumentAny,
2556 filled_qty_cache: &mut FilledQtyCache,
2557) {
2558 if !msg.acc_fill_sz.is_empty()
2559 && msg.acc_fill_sz != "0"
2560 && let Ok(qty) = parse_quantity(&msg.acc_fill_sz, instrument.size_precision())
2561 {
2562 filled_qty_cache.record(msg.ord_id, qty, is_terminal_order_state(msg.state));
2563 }
2564}
2565
2566fn is_spread_post_only_auto_cancel(msg: &OKXSpreadOrder) -> bool {
2567 msg.state == OKXOrderStatus::Canceled && msg.cancel_source == OKX_POST_ONLY_CANCEL_SOURCE
2568}
2569
2570pub fn dispatch_execution_reports(
2572 reports: Vec<ExecutionReport>,
2573 emitter: &ExecutionEventEmitter,
2574 state: &WsDispatchState,
2575) {
2576 log::debug!("Processing {} execution report(s)", reports.len());
2577
2578 for report in reports {
2579 match report {
2580 ExecutionReport::Order(order_report) => {
2581 if update_order_report_state(&order_report, state) {
2582 emitter.send_order_status_report(order_report);
2583 }
2584 }
2585 ExecutionReport::Fill(fill_report) => {
2586 if update_fill_report_state(&fill_report, state) {
2587 emitter.send_fill_report(fill_report);
2588 }
2589 }
2590 }
2591 }
2592}
2593
2594fn dispatch_order_with_fills_report(
2595 order_report: OrderStatusReport,
2596 fill_report: FillReport,
2597 emitter: &ExecutionEventEmitter,
2598 state: &WsDispatchState,
2599) {
2600 if !update_fill_report_state(&fill_report, state) {
2601 return;
2602 }
2603
2604 if update_order_report_state(&order_report, state) {
2605 let fills = vec![fill_report];
2606 emitter.send_order_with_fills(order_report, fills);
2607 } else {
2608 emitter.send_fill_report(fill_report);
2609 }
2610}
2611
2612fn update_order_report_state(order_report: &OrderStatusReport, state: &WsDispatchState) -> bool {
2613 if let Some(cid) = order_report.client_order_id {
2614 match order_report.order_status {
2615 #[allow(clippy::collapsible_match)]
2617 OrderStatus::Accepted => {
2618 if state.contains_terminal(&cid)
2619 || state.contains_filled(&cid)
2620 || state.contains_triggered(&cid)
2621 {
2622 log::debug!(
2623 "Skipping stale OrderStatusReport(Accepted) \
2624 for {cid} (order already terminal)"
2625 );
2626 return false;
2627 }
2628
2629 if !state.contains_accepted(&cid) {
2630 state.insert_accepted(cid, order_report.venue_order_id);
2631 }
2632 }
2633 OrderStatus::Triggered => {
2634 if state.contains_filled(&cid) {
2635 log::debug!(
2636 "Skipping stale OrderStatusReport(Triggered) for {cid} (already filled)"
2637 );
2638 return false;
2639 }
2640
2641 state.insert_triggered(cid);
2642 }
2643 OrderStatus::Filled => {
2644 state.insert_filled(cid);
2645 state.insert_terminal(cid);
2646 state.remove_triggered(&cid);
2647 }
2648 OrderStatus::Canceled | OrderStatus::Expired | OrderStatus::Rejected => {
2649 state.insert_terminal(cid);
2650 state.remove_triggered(&cid);
2651 state.remove_filled(&cid);
2652 }
2653 _ => {}
2654 }
2655 }
2656
2657 true
2658}
2659
2660fn update_fill_report_state(fill_report: &FillReport, state: &WsDispatchState) -> bool {
2661 if state.check_and_insert_trade(fill_report.trade_id) {
2662 log::debug!(
2663 "Skipping duplicate fill report: trade_id={}",
2664 fill_report.trade_id
2665 );
2666 return false;
2667 }
2668
2669 if let Some(cid) = fill_report.client_order_id {
2670 state.insert_filled(cid);
2671 state.remove_triggered(&cid);
2672 }
2673
2674 true
2675}
2676
2677fn emit_send_failed_submit(
2678 failure: &CommandFailure,
2679 state: &WsDispatchState,
2680 emitter: &ExecutionEventEmitter,
2681 clock: &AtomicTime,
2682 client_order_id: ClientOrderId,
2683) {
2684 let (CommandFailure::NotSent(reason) | CommandFailure::VenueRejected(reason)) = failure else {
2685 return;
2686 };
2687 let Some(ident) = state.order_identity(client_order_id) else {
2688 return;
2689 };
2690
2691 state.remove_order_tracking(client_order_id);
2692 emitter.emit_order_rejected_event(
2693 ident.strategy_id,
2694 ident.instrument_id,
2695 client_order_id,
2696 reason,
2697 clock.get_time_ns(),
2698 false,
2699 );
2700}
2701
2702fn emit_send_failed_modify(
2703 failure: &CommandFailure,
2704 state: &WsDispatchState,
2705 emitter: &ExecutionEventEmitter,
2706 clock: &AtomicTime,
2707 client_order_id: ClientOrderId,
2708 causation_id: Option<UUID4>,
2709) {
2710 let (CommandFailure::NotSent(reason) | CommandFailure::VenueRejected(reason)) = failure else {
2711 return;
2712 };
2713 let Some(ident) = state.order_identity(client_order_id) else {
2714 return;
2715 };
2716
2717 if matches!(failure, CommandFailure::NotSent(_)) {
2718 emitter.emit_order_modify_denied_event(
2719 ident.strategy_id,
2720 ident.instrument_id,
2721 client_order_id,
2722 None,
2723 reason,
2724 clock.get_time_ns(),
2725 causation_id,
2726 );
2727 } else {
2728 emitter.emit_order_modify_rejected_event(
2729 ident.strategy_id,
2730 ident.instrument_id,
2731 client_order_id,
2732 None,
2733 reason,
2734 clock.get_time_ns(),
2735 causation_id,
2736 );
2737 }
2738}
2739
2740pub(crate) fn emit_send_failed_cancel(
2741 failure: &CommandFailure,
2742 state: &WsDispatchState,
2743 emitter: &ExecutionEventEmitter,
2744 clock: &AtomicTime,
2745 client_order_id: ClientOrderId,
2746 venue_order_id: Option<VenueOrderId>,
2747 causation_id: Option<UUID4>,
2748) {
2749 let (CommandFailure::NotSent(reason) | CommandFailure::VenueRejected(reason)) = failure else {
2750 return;
2751 };
2752
2753 let Some(ident) = state.order_identity(client_order_id) else {
2754 return;
2755 };
2756
2757 let venue_order_id = state
2758 .order_venue_binding(client_order_id)
2759 .map(|(venue_order_id, _)| venue_order_id)
2760 .or(venue_order_id);
2761
2762 if matches!(failure, CommandFailure::NotSent(_)) {
2763 emitter.emit_order_cancel_denied_event(
2764 ident.strategy_id,
2765 ident.instrument_id,
2766 client_order_id,
2767 venue_order_id,
2768 reason,
2769 clock.get_time_ns(),
2770 causation_id,
2771 );
2772 } else {
2773 emitter.emit_order_cancel_rejected_event(
2774 ident.strategy_id,
2775 ident.instrument_id,
2776 client_order_id,
2777 venue_order_id,
2778 reason,
2779 clock.get_time_ns(),
2780 causation_id,
2781 );
2782 }
2783}
2784
2785#[derive(Debug, Clone)]
2786pub struct AlgoCancelContext {
2787 pub causation_id: Option<UUID4>,
2788 pub client_order_id: ClientOrderId,
2789 pub instrument_id: InstrumentId,
2790 pub strategy_id: StrategyId,
2791 pub venue_order_id: Option<VenueOrderId>,
2792}
2793
2794pub fn emit_algo_cancel_rejections(
2797 responses: &[OKXCancelAlgoOrderResponse],
2798 contexts: &[AlgoCancelContext],
2799 emitter: &ExecutionEventEmitter,
2800 clock: &'static AtomicTime,
2801) {
2802 for (i, item) in responses.iter().enumerate() {
2803 let code = item.s_code.as_deref().unwrap_or(OKX_SUCCESS_CODE);
2804 if code == OKX_SUCCESS_CODE {
2805 continue;
2806 }
2807
2808 let msg = item.s_msg.as_deref().unwrap_or("");
2809
2810 if matches!(
2811 classify_okx_venue_code(code, msg),
2812 CommandFailure::Ambiguous(_) | CommandFailure::NotSent(_)
2813 ) {
2814 if let Some(ctx) = contexts.get(i) {
2815 log::warn!(
2816 "Ambiguous algo cancel response for {}, awaiting reconciliation: \
2817 algo_id={} sCode={code} sMsg={msg}",
2818 ctx.client_order_id,
2819 item.algo_id
2820 );
2821 } else {
2822 log::warn!(
2823 "Ambiguous algo cancel response without context at index {i}: \
2824 algo_id={} sCode={code} sMsg={msg}",
2825 item.algo_id
2826 );
2827 }
2828 continue;
2829 }
2830
2831 if let Some(ctx) = contexts.get(i) {
2832 let reason = format_order_response_reason(code, msg, "");
2833 let ts = clock.get_time_ns();
2834 emitter.emit_order_cancel_rejected_event(
2835 ctx.strategy_id,
2836 ctx.instrument_id,
2837 ctx.client_order_id,
2838 ctx.venue_order_id,
2839 &reason,
2840 ts,
2841 ctx.causation_id,
2842 );
2843 } else {
2844 log::warn!(
2845 "Algo cancel rejected but no context at index {i}: \
2846 algo_id={} sCode={code} sMsg={msg}",
2847 item.algo_id
2848 );
2849 }
2850 }
2851}
2852
2853pub fn emit_batch_cancel_failure(
2854 contexts: &[AlgoCancelContext],
2855 error: &str,
2856 _emitter: &ExecutionEventEmitter,
2857 _clock: &'static AtomicTime,
2858) {
2859 for ctx in contexts {
2860 log::warn!(
2861 "Ambiguous algo batch cancel failure for {}, awaiting reconciliation: {error}",
2862 ctx.client_order_id
2863 );
2864 }
2865}
2866
2867pub(crate) fn format_order_response_reason(s_code: &str, s_msg: &str, sub_code: &str) -> String {
2868 match (s_code.is_empty(), s_msg.is_empty(), sub_code.is_empty()) {
2869 (false, false, true) => format!("OKX error {s_code}: {s_msg}"),
2870 (false, false, false) => format!("OKX error {s_code}: {s_msg} (subCode={sub_code})"),
2871 (false, true, true) => format!("OKX error {s_code}"),
2872 (false, true, false) => format!("OKX error {s_code} (subCode={sub_code})"),
2873 (true, false, true) => s_msg.to_string(),
2874 (true, false, false) => format!("{s_msg} (subCode={sub_code})"),
2875 (true, true, false) => format!("subCode={sub_code}"),
2876 (true, true, true) => String::new(),
2877 }
2878}
2879
2880#[cfg(test)]
2881mod tests {
2882 use std::time::Duration;
2883
2884 use nautilus_common::messages::{ExecutionEvent, ExecutionReport as CommonExecutionReport};
2885 use nautilus_core::time::get_atomic_clock_realtime;
2886 use nautilus_model::{
2887 enums::{AccountType, OrderSide, OrderType, TimeInForce, TriggerType},
2888 events::order::spec::OrderUpdatedSpec,
2889 identifiers::Symbol,
2890 instruments::CurrencyPair,
2891 orders::{Order, OrderTestBuilder, stubs::TestOrderEventStubs},
2892 types::{Price, Quantity},
2893 };
2894 use nautilus_network::error::SendError;
2895 use rstest::rstest;
2896
2897 use super::*;
2898 use crate::{
2899 common::{
2900 enums::{OKXInstrumentType, OKXSide, OKXTargetCurrency},
2901 parse::parse_spread_instrument,
2902 testing::create_stub_instrument,
2903 },
2904 websocket::{error::OKXWsError, messages::OKXWsFrame},
2905 };
2906
2907 fn load_algo_order_messages(fixture: &str) -> Vec<OKXAlgoOrderMsg> {
2908 let path = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR"))
2909 .join("test_data")
2910 .join(fixture);
2911 let content = std::fs::read_to_string(path).unwrap();
2912 let frame: OKXWsFrame = serde_json::from_str(&content).unwrap();
2913 let OKXWsFrame::Data { data, .. } = frame else {
2914 panic!("Expected algo order data frame");
2915 };
2916 serde_json::from_value(data).unwrap()
2917 }
2918
2919 fn load_regular_order_messages(fixture: &str) -> Vec<OKXOrderMsg> {
2920 let path = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR"))
2921 .join("test_data")
2922 .join(fixture);
2923 let content = std::fs::read_to_string(path).unwrap();
2924 let frame: OKXWsFrame = serde_json::from_str(&content).unwrap();
2925 let OKXWsFrame::Data { data, .. } = frame else {
2926 panic!("Expected regular order data frame");
2927 };
2928 serde_json::from_value(data).unwrap()
2929 }
2930
2931 fn test_algo_context(client_order_id: ClientOrderId) -> OrderContext {
2932 OrderContext {
2933 identity: OrderIdentity {
2934 client_order_id,
2935 strategy_id: StrategyId::from("STRATEGY-001"),
2936 instrument_id: InstrumentId::from("BTC-USDT-SWAP.OKX"),
2937 order_side: OrderSide::Sell,
2938 order_type: OrderType::StopLimit,
2939 },
2940 quantity: Quantity::from("0.01"),
2941 price: Some(Price::from("102900")),
2942 trigger_price: Some(Price::from("95000")),
2943 trigger_type: Some(TriggerType::LastPrice),
2944 time_in_force: TimeInForce::Gtc,
2945 is_post_only: false,
2946 is_reduce_only: true,
2947 is_quote_quantity: false,
2948 }
2949 }
2950
2951 fn test_algo_instruments() -> AtomicMap<Ustr, InstrumentAny> {
2952 let instrument = create_stub_instrument();
2953 let instruments = AtomicMap::new();
2954 instruments.insert(
2955 Ustr::from("BTC-USDT-SWAP"),
2956 InstrumentAny::CryptoPerpetual(instrument),
2957 );
2958 instruments
2959 }
2960
2961 fn test_execution_emitter() -> (
2962 ExecutionEventEmitter,
2963 tokio::sync::mpsc::UnboundedReceiver<ExecutionEvent>,
2964 ) {
2965 let clock = get_atomic_clock_realtime();
2966 let mut emitter = ExecutionEventEmitter::new(
2967 clock,
2968 TraderId::from("TRADER-001"),
2969 AccountId::from("OKX-001"),
2970 AccountType::Margin,
2971 None,
2972 );
2973 let (sender, receiver) = tokio::sync::mpsc::unbounded_channel();
2974 emitter.set_sender(sender);
2975 (emitter, receiver)
2976 }
2977
2978 fn dispatch_test_message(
2979 message: OKXWsMessage,
2980 emitter: &ExecutionEventEmitter,
2981 state: &WsDispatchState,
2982 instruments: &AtomicMap<Ustr, InstrumentAny>,
2983 ) {
2984 dispatch_ws_message(
2985 message,
2986 emitter,
2987 state,
2988 AccountId::from("OKX-001"),
2989 AccountType::Margin,
2990 instruments,
2991 &mut FeeCache::new(),
2992 &mut FilledQtyCache::new(),
2993 &mut AHashMap::new(),
2994 get_atomic_clock_realtime(),
2995 );
2996 }
2997
2998 fn drain_execution_events(
2999 receiver: &mut tokio::sync::mpsc::UnboundedReceiver<ExecutionEvent>,
3000 ) -> Vec<ExecutionEvent> {
3001 let mut events = Vec::new();
3002 while let Ok(event) = receiver.try_recv() {
3003 events.push(event);
3004 }
3005 events
3006 }
3007
3008 #[rstest]
3009 #[case::regular(false)]
3010 #[case::spread(true)]
3011 fn test_imported_order_unchanged_then_amended(#[case] spread: bool) {
3012 let cid = ClientOrderId::from("O-IMPORTED");
3013 let vid = VenueOrderId::from("7001");
3014
3015 let (instrument, mut payload) = imported_order_fixture(spread);
3016
3017 let instrument_id = instrument.id();
3018 let order = OrderTestBuilder::new(OrderType::Limit)
3019 .instrument_id(instrument_id)
3020 .client_order_id(cid)
3021 .side(OrderSide::Buy)
3022 .quantity(Quantity::from("0.01"))
3023 .price(Price::from("1.00"))
3024 .build();
3025 let state = WsDispatchState::default();
3026 state.register_external_order(OrderContext::from(&order), vid);
3027 let instruments = AtomicMap::new();
3028 instruments.insert(instrument_id.symbol.inner(), instrument);
3029 let (emitter, mut rx) = test_execution_emitter();
3030 let mut fee_cache = FeeCache::new();
3031 let mut fills = FilledQtyCache::new();
3032 let mut snapshots = AHashMap::new();
3033 let msg = &mut payload["data"][0];
3034 msg[if spread { "sprdId" } else { "instId" }] =
3035 serde_json::json!(instrument_id.symbol.as_str());
3036 msg["ordId"] = serde_json::json!("7001");
3037 msg["clOrdId"] = serde_json::json!("");
3038 msg["ordType"] = serde_json::json!("limit");
3039 msg["state"] = serde_json::json!("live");
3040 msg["sz"] = serde_json::json!("0.01");
3041 msg["px"] = serde_json::json!("1.00");
3042 msg["accFillSz"] = serde_json::json!("0");
3043 msg["fillSz"] = serde_json::json!("0");
3044 msg["tradeId"] = serde_json::json!("");
3045
3046 for amended in [false, true, true] {
3047 if amended {
3048 payload["data"][0]["sz"] = serde_json::json!("0.02");
3049 payload["data"][0]["px"] = serde_json::json!("1.10");
3050 }
3051
3052 let message = if spread {
3053 OKXWsMessage::SpreadOrders(serde_json::from_value(payload["data"].clone()).unwrap())
3054 } else {
3055 OKXWsMessage::Orders(serde_json::from_value(payload["data"].clone()).unwrap())
3056 };
3057
3058 dispatch_ws_message(
3059 message,
3060 &emitter,
3061 &state,
3062 emitter.account_id(),
3063 AccountType::Margin,
3064 &instruments,
3065 &mut fee_cache,
3066 &mut fills,
3067 &mut snapshots,
3068 get_atomic_clock_realtime(),
3069 );
3070
3071 if !amended {
3072 assert!(drain_execution_events(&mut rx).is_empty());
3073 }
3074 }
3075
3076 let events = drain_execution_events(&mut rx);
3077
3078 let [ExecutionEvent::Order(OrderEventAny::Updated(updated))] = events.as_slice() else {
3079 panic!("expected exactly one imported update, was {events:?}");
3080 };
3081
3082 assert_eq!(updated.client_order_id, cid);
3083 assert_eq!(updated.venue_order_id, Some(vid));
3084 assert_eq!(updated.quantity, Quantity::from("0.02"));
3085 assert_eq!(updated.price, Some(Price::from("1.10")));
3086 assert!(!state.contains_triggered(&cid));
3087 state.remove_order_tracking(cid);
3088 assert_eq!(state.order_context(cid), None);
3089 assert_eq!(state.order_venue_binding(cid), None);
3090 assert!(
3091 !state
3092 .lifecycle_bindings
3093 .lock()
3094 .client_by_parent
3095 .contains_key(&vid)
3096 );
3097 }
3098
3099 #[rstest]
3100 #[case::regular(false)]
3101 #[case::spread(true)]
3102 fn test_imported_order_reduced_to_filled_quantity_closes(#[case] spread: bool) {
3103 let (instrument, mut payload) = imported_order_fixture(spread);
3104 let instrument_id = instrument.id();
3105 let cid = ClientOrderId::from("O-IMPORTED-CLOSE");
3106 let vid = VenueOrderId::from("7001");
3107 let (emitter, mut rx) = test_execution_emitter();
3108 let mut order = OrderTestBuilder::new(OrderType::Limit)
3109 .instrument_id(instrument_id)
3110 .client_order_id(cid)
3111 .side(OrderSide::Buy)
3112 .quantity(Quantity::from("0.03"))
3113 .price(Price::from("1.00"))
3114 .build();
3115 let state = WsDispatchState::default();
3116 state.register_external_order(OrderContext::from(&order), vid);
3117 order
3118 .apply(TestOrderEventStubs::submitted(&order, emitter.account_id()))
3119 .unwrap();
3120 order
3121 .apply(TestOrderEventStubs::accepted(
3122 &order,
3123 emitter.account_id(),
3124 vid,
3125 ))
3126 .unwrap();
3127 let fill = TestOrderEventStubs::filled(
3128 &order,
3129 &instrument,
3130 Some(TradeId::from("7002")),
3131 None,
3132 Some(Price::from("1.00")),
3133 Some(Quantity::from("0.01")),
3134 None,
3135 None,
3136 None,
3137 Some(emitter.account_id()),
3138 );
3139 order.apply(fill).unwrap();
3140 let instruments = AtomicMap::new();
3141 instruments.insert(instrument_id.symbol.inner(), instrument);
3142 let mut fees = FeeCache::new();
3143 let mut fills = FilledQtyCache::new();
3144 fills.record(Ustr::from("7001"), Quantity::from("0.01"), false);
3145 let mut snapshots = AHashMap::new();
3146 let msg = &mut payload["data"][0];
3147 msg[if spread { "sprdId" } else { "instId" }] =
3148 serde_json::json!(instrument_id.symbol.as_str());
3149 msg["ordId"] = serde_json::json!("7001");
3150 msg["clOrdId"] = serde_json::json!("");
3151 msg["ordType"] = serde_json::json!("limit");
3152 msg["state"] = serde_json::json!("partially_filled");
3153 msg["sz"] = serde_json::json!("0.03");
3154 msg["px"] = serde_json::json!("1.00");
3155 msg["accFillSz"] = serde_json::json!("0.01");
3156 msg["fillSz"] = serde_json::json!("0");
3157 msg["fillPx"] = serde_json::json!("1.00");
3158 msg["tradeId"] = serde_json::json!("");
3159 msg["fee"] = serde_json::json!("0");
3160 msg["uTime"] = serde_json::json!("1781827200123");
3161
3162 for terminal in [false, true] {
3163 if terminal {
3164 let msg = &mut payload["data"][0];
3165 msg["state"] = serde_json::json!("filled");
3166 msg["sz"] = serde_json::json!("0.01");
3167 msg["fillSz"] = serde_json::json!("0");
3168 msg["tradeId"] = serde_json::json!("");
3169 }
3170
3171 let message = if spread {
3172 OKXWsMessage::SpreadOrders(serde_json::from_value(payload["data"].clone()).unwrap())
3173 } else {
3174 OKXWsMessage::Orders(serde_json::from_value(payload["data"].clone()).unwrap())
3175 };
3176
3177 dispatch_ws_message(
3178 message,
3179 &emitter,
3180 &state,
3181 emitter.account_id(),
3182 AccountType::Margin,
3183 &instruments,
3184 &mut fees,
3185 &mut fills,
3186 &mut snapshots,
3187 get_atomic_clock_realtime(),
3188 );
3189 let events = drain_execution_events(&mut rx);
3190
3191 if terminal {
3192 let [
3193 ExecutionEvent::Order(OrderEventAny::Updated(updated)),
3194 ExecutionEvent::Report(CommonExecutionReport::Order(report)),
3195 ] = events.as_slice()
3196 else {
3197 panic!("expected terminal amendment and status report, was {events:?}");
3198 };
3199
3200 let expected = OrderUpdatedSpec::builder()
3201 .trader_id(emitter.trader_id())
3202 .strategy_id(order.strategy_id())
3203 .instrument_id(instrument_id)
3204 .client_order_id(cid)
3205 .quantity(Quantity::from("0.01"))
3206 .event_id(updated.event_id)
3207 .ts_event(UnixNanos::from(1_781_827_200_123_000_000))
3208 .ts_init(updated.ts_init)
3209 .reconciliation(true)
3210 .venue_order_id(vid)
3211 .account_id(emitter.account_id())
3212 .price(Price::from("1.00"))
3213 .build();
3214 assert_eq!(*updated, expected);
3215 assert_eq!(report.order_status, OrderStatus::Filled);
3216 assert_eq!(report.quantity, Quantity::from("0.01"));
3217 assert_eq!(report.filled_qty, Quantity::from("0.01"));
3218 order.apply(OrderEventAny::Updated(*updated)).unwrap();
3219 } else {
3220 let [ExecutionEvent::Report(CommonExecutionReport::Order(report))] =
3221 events.as_slice()
3222 else {
3223 panic!("expected unchanged partial status, was {events:?}");
3224 };
3225
3226 assert_eq!(report.order_status, OrderStatus::PartiallyFilled);
3227 assert_eq!(report.quantity, Quantity::from("0.03"));
3228 assert_eq!(report.filled_qty, Quantity::from("0.01"));
3229 assert_eq!(order.status(), OrderStatus::PartiallyFilled);
3230 }
3231 }
3232
3233 assert_eq!(order.status(), OrderStatus::Filled);
3234 assert_eq!(order.quantity(), Quantity::from("0.01"));
3235 assert_eq!(order.filled_qty(), Quantity::from("0.01"));
3236 assert_eq!(order.leaves_qty(), Quantity::from("0.00"));
3237 assert_eq!(order.price(), Some(Price::from("1.00")));
3238 assert_eq!(state.order_identity(cid), None);
3239 assert_eq!(state.order_venue_binding(cid), None);
3240 assert!(
3241 !state
3242 .lifecycle_bindings
3243 .lock()
3244 .client_by_parent
3245 .contains_key(&vid)
3246 );
3247 }
3248
3249 fn imported_order_fixture(spread: bool) -> (InstrumentAny, serde_json::Value) {
3250 if spread {
3251 let definitions: serde_json::Value =
3252 serde_json::from_str(include_str!("../../test_data/http_get_spreads.json"))
3253 .unwrap();
3254 let definition = serde_json::from_value(definitions["data"][1].clone()).unwrap();
3255 let instrument =
3256 parse_spread_instrument(&definition, None, None, UnixNanos::default()).unwrap();
3257 let payload = serde_json::from_str::<serde_json::Value>(include_str!(
3258 "../../test_data/ws_sprd_orders.json"
3259 ))
3260 .unwrap();
3261 (instrument, payload)
3262 } else {
3263 let instruments = test_algo_instruments();
3264 let instrument = instruments
3265 .load()
3266 .get(&Ustr::from("BTC-USDT-SWAP"))
3267 .unwrap()
3268 .clone();
3269 let payload = serde_json::from_str::<serde_json::Value>(include_str!(
3270 "../../test_data/ws_orders.json"
3271 ))
3272 .unwrap();
3273 (instrument, payload)
3274 }
3275 }
3276
3277 #[rstest]
3278 #[case::single_fill(false, false)]
3279 #[case::partial_fill(true, false)]
3280 #[case::status_only(true, true)]
3281 fn short_final_fill_dispatches_terminal_status(
3282 #[values(false, true)] tracked: bool,
3283 #[values(OKXTargetCurrency::BaseCcy, OKXTargetCurrency::QuoteCcy)]
3284 target: OKXTargetCurrency,
3285 #[case] partial_first: bool,
3286 #[case] status_only: bool,
3287 ) {
3288 let mut msg = load_regular_order_messages("ws_orders.json").remove(0);
3289 msg.inst_id = Ustr::from("BTC-USDC");
3290 msg.inst_type = OKXInstrumentType::Spot;
3291 msg.ord_type = OKXOrderType::Market;
3292 msg.side = OKXSide::Buy;
3293 msg.tgt_ccy = Some(target);
3294 msg.sz = match target {
3295 OKXTargetCurrency::BaseCcy => "0.00296487",
3296 OKXTargetCurrency::QuoteCcy => "296.487",
3297 }
3298 .to_string();
3299
3300 msg.acc_fill_sz = Some("0.00296475".to_string());
3301
3302 let last_qty = if partial_first {
3303 "0.00196475"
3304 } else {
3305 "0.00296475"
3306 };
3307
3308 msg.fill_sz = last_qty.to_string();
3309 msg.fill_px = "100000".to_string();
3310 msg.avg_px = "100000".to_string();
3311 msg.px.clear();
3312 msg.state = OKXOrderStatus::Filled;
3313 let client_order_id = ClientOrderId::new(msg.cl_ord_id.as_str());
3314 let instrument_id = InstrumentId::from("BTC-USDC.OKX");
3315 let instrument = CurrencyPair::builder()
3316 .instrument_id(instrument_id)
3317 .raw_symbol(Symbol::from("BTC-USDC"))
3318 .base_currency(Currency::BTC())
3319 .quote_currency(Currency::USDC())
3320 .price_precision(2)
3321 .size_precision(8)
3322 .price_increment(Price::from("0.01"))
3323 .size_increment(Quantity::from("0.00000001"))
3324 .ts_event(UnixNanos::default())
3325 .ts_init(UnixNanos::default())
3326 .build()
3327 .unwrap();
3328 let instruments = AtomicMap::new();
3329 instruments.insert(msg.inst_id, InstrumentAny::CurrencyPair(instrument));
3330 let state = WsDispatchState::default();
3331
3332 if tracked {
3333 state.order_identities.insert(
3334 client_order_id,
3335 OrderIdentity {
3336 client_order_id,
3337 strategy_id: StrategyId::from("STRATEGY-001"),
3338 instrument_id,
3339 order_side: OrderSide::Buy,
3340 order_type: OrderType::Market,
3341 },
3342 );
3343 }
3344
3345 let (emitter, mut receiver) = test_execution_emitter();
3346 let mut fee_cache = FeeCache::new();
3347 let mut filled_qty_cache = FilledQtyCache::new();
3348 let mut order_state_cache = AHashMap::new();
3349 let clock = get_atomic_clock_realtime();
3350
3351 if partial_first {
3352 let mut partial = msg.clone();
3353 partial.state = OKXOrderStatus::PartiallyFilled;
3354
3355 if status_only {
3356 partial.fill_sz = "0.00296475".to_string();
3357 msg.fill_sz = "0".to_string();
3358 } else {
3359 partial.acc_fill_sz = Some("0.001".to_string());
3360 partial.fill_sz = "0.001".to_string();
3361 partial.trade_id = "prior-trade".to_string();
3362 }
3363
3364 dispatch_ws_message(
3365 OKXWsMessage::Orders(vec![partial]),
3366 &emitter,
3367 &state,
3368 emitter.account_id(),
3369 AccountType::Cash,
3370 &instruments,
3371 &mut fee_cache,
3372 &mut filled_qty_cache,
3373 &mut order_state_cache,
3374 clock,
3375 );
3376 let events = drain_execution_events(&mut receiver);
3377 assert_eq!(events.len(), if tracked { 2 } else { 1 });
3378 assert!(!state.contains_terminal(&client_order_id));
3379 }
3380
3381 dispatch_ws_message(
3382 OKXWsMessage::Orders(vec![msg.clone()]),
3383 &emitter,
3384 &state,
3385 emitter.account_id(),
3386 AccountType::Cash,
3387 &instruments,
3388 &mut fee_cache,
3389 &mut filled_qty_cache,
3390 &mut order_state_cache,
3391 clock,
3392 );
3393
3394 let events = drain_execution_events(&mut receiver);
3395 let fill_index = usize::from(tracked && !partial_first);
3396 assert_eq!(events.len(), if status_only { 1 } else { fill_index + 2 });
3397
3398 if !status_only {
3399 match &events[fill_index] {
3400 ExecutionEvent::Order(OrderEventAny::Filled(fill)) => {
3401 assert!(tracked);
3402 assert_eq!(fill.last_qty, Quantity::from(last_qty));
3403 }
3404 ExecutionEvent::Report(CommonExecutionReport::Fill(fill)) => {
3405 assert!(!tracked);
3406 assert_eq!(fill.last_qty, Quantity::from(last_qty));
3407 }
3408 ExecutionEvent::Report(CommonExecutionReport::OrderWithFills(_, fills)) => {
3409 assert!(!tracked);
3410 assert_eq!(fills.len(), 1);
3411 assert_eq!(fills[0].last_qty, Quantity::from(last_qty));
3412 }
3413 other => panic!("Expected fill before terminal status, was {other:?}"),
3414 }
3415 }
3416
3417 let report_index = if status_only { 0 } else { fill_index + 1 };
3418
3419 let ExecutionEvent::Report(CommonExecutionReport::Order(report)) = &events[report_index]
3420 else {
3421 panic!("Expected terminal order status report");
3422 };
3423
3424 assert_eq!(report.client_order_id, Some(client_order_id));
3425 assert_eq!(report.order_status, OrderStatus::Filled);
3426 assert_eq!(report.quantity, Quantity::from("0.00296475"));
3427 assert_eq!(report.filled_qty, Quantity::from("0.00296475"));
3428 assert!(state.contains_terminal(&client_order_id));
3429 assert!(!state.order_identities.contains_key(&client_order_id));
3430 assert!(!state.contains_accepted(&client_order_id));
3431 assert!(!order_state_cache.contains_key(&client_order_id));
3432
3433 dispatch_ws_message(
3434 OKXWsMessage::Orders(vec![msg]),
3435 &emitter,
3436 &state,
3437 emitter.account_id(),
3438 AccountType::Cash,
3439 &instruments,
3440 &mut fee_cache,
3441 &mut filled_qty_cache,
3442 &mut order_state_cache,
3443 clock,
3444 );
3445 assert!(drain_execution_events(&mut receiver).is_empty());
3446 }
3447
3448 #[rstest]
3449 #[case::margin(AccountType::Margin)]
3450 #[case::cash(AccountType::Cash)]
3451 fn account_updates_report_the_configured_account_type(#[case] account_type: AccountType) {
3452 let path = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR"))
3453 .join("test_data")
3454 .join("http_get_account_balance.json");
3455 let content = std::fs::read_to_string(path).unwrap();
3456 let payload: serde_json::Value = serde_json::from_str(&content).unwrap();
3457 let instruments = AtomicMap::new();
3458 let (emitter, mut receiver) = test_execution_emitter();
3459
3460 dispatch_ws_message(
3461 OKXWsMessage::Account(payload["data"].clone()),
3462 &emitter,
3463 &WsDispatchState::default(),
3464 AccountId::from("OKX-001"),
3465 account_type,
3466 &instruments,
3467 &mut FeeCache::new(),
3468 &mut FilledQtyCache::new(),
3469 &mut AHashMap::new(),
3470 get_atomic_clock_realtime(),
3471 );
3472
3473 let events = drain_execution_events(&mut receiver);
3474 assert_eq!(events.len(), 1);
3475
3476 let ExecutionEvent::Account(state) = &events[0] else {
3477 panic!("expected an account state event");
3478 };
3479
3480 assert_eq!(state.account_type, account_type);
3481 assert_eq!(state.account_id, AccountId::from("OKX-001"));
3482 }
3483
3484 #[rstest]
3485 fn tracked_algo_live_and_pause_emit_one_parent_acceptance() {
3486 let mut messages = load_algo_order_messages("ws_orders_algo.json");
3487 let live = messages.remove(0);
3488 let mut pause = live.clone();
3489 pause.state = OKXAlgoOrderStatus::Pause;
3490 pause.u_time += 1;
3491 let client_order_id = ClientOrderId::new(live.algo_cl_ord_id.as_str());
3492 let state = WsDispatchState::default();
3493 let mut context = test_algo_context(client_order_id);
3494 context.identity.order_type = OrderType::StopMarket;
3495 context.price = None;
3496 state.track_order_context(context);
3497 let instruments = test_algo_instruments();
3498 let (emitter, mut receiver) = test_execution_emitter();
3499
3500 dispatch_test_message(
3501 OKXWsMessage::AlgoOrders(vec![live, pause]),
3502 &emitter,
3503 &state,
3504 &instruments,
3505 );
3506
3507 let events = drain_execution_events(&mut receiver);
3508 assert_eq!(events.len(), 1);
3509 match &events[0] {
3510 ExecutionEvent::Order(OrderEventAny::Accepted(accepted)) => {
3511 assert_eq!(accepted.client_order_id, client_order_id);
3512 assert_eq!(
3513 accepted.venue_order_id,
3514 VenueOrderId::new("706620792746729472")
3515 );
3516 }
3517 other => panic!("Expected tracked algo acceptance, was {other:?}"),
3518 }
3519 }
3520
3521 #[rstest]
3522 #[case::after_acceptance(false)]
3523 #[case::first_acceptance(true)]
3524 fn tracked_algo_amend_emits_updated_terms_once(#[case] first_acceptance: bool) {
3525 let live = load_algo_order_messages("ws_orders_algo.json").remove(1);
3526 let client_order_id = ClientOrderId::new(live.algo_cl_ord_id.as_str());
3527 let state = WsDispatchState::default();
3528 let mut context = test_algo_context(client_order_id);
3529 context.identity.order_side = OrderSide::Buy;
3530 context.quantity = Quantity::from("0.02");
3531 context.price = Some(Price::from("106000.00"));
3532 context.trigger_price = Some(Price::from("105000.00"));
3533 context.trigger_type = Some(TriggerType::MarkPrice);
3534 state.track_order_context(context);
3535 let instruments = test_algo_instruments();
3536 let (emitter, mut receiver) = test_execution_emitter();
3537
3538 if !first_acceptance {
3539 dispatch_test_message(
3540 OKXWsMessage::AlgoOrders(vec![live.clone()]),
3541 &emitter,
3542 &state,
3543 &instruments,
3544 );
3545 let events = drain_execution_events(&mut receiver);
3546 assert_eq!(events.len(), 1);
3547 assert!(matches!(
3548 &events[0],
3549 ExecutionEvent::Order(OrderEventAny::Accepted(_))
3550 ));
3551 }
3552
3553 let mut amended = live.clone();
3554 amended.sz = "0.03".into();
3555 amended.trigger_px = "104000".into();
3556 amended.ord_px = "103000".into();
3557 amended.u_time += 2;
3558 dispatch_test_message(
3559 OKXWsMessage::AlgoOrders(vec![amended.clone(), amended, live]),
3560 &emitter,
3561 &state,
3562 &instruments,
3563 );
3564 let events = drain_execution_events(&mut receiver);
3565 assert_eq!(events.len(), if first_acceptance { 2 } else { 1 });
3566
3567 if first_acceptance {
3568 assert!(matches!(
3569 &events[0],
3570 ExecutionEvent::Order(OrderEventAny::Accepted(_))
3571 ));
3572 }
3573
3574 let ExecutionEvent::Order(OrderEventAny::Updated(updated)) = events.last().unwrap() else {
3575 panic!("expected OrderUpdated");
3576 };
3577
3578 assert_eq!(updated.client_order_id, client_order_id);
3579 assert_eq!(
3580 updated.venue_order_id,
3581 Some(VenueOrderId::from("706620792746729473"))
3582 );
3583 assert_eq!(updated.instrument_id, context.identity.instrument_id);
3584 assert_eq!(updated.strategy_id, context.identity.strategy_id);
3585 assert_eq!(updated.account_id, Some(AccountId::from("OKX-001")));
3586 assert_eq!(updated.quantity, Quantity::from("0.03"));
3587 assert_eq!(updated.price, Some(Price::from("103000.00")));
3588 assert_eq!(updated.trigger_price, Some(Price::from("104000.00")));
3589 let final_context = state.order_context(client_order_id).unwrap();
3590 assert_eq!(final_context.quantity, updated.quantity);
3591 assert_eq!(final_context.price, updated.price);
3592 assert_eq!(final_context.trigger_price, updated.trigger_price);
3593 assert_eq!(final_context.trigger_type, Some(TriggerType::MarkPrice));
3594 }
3595
3596 #[rstest]
3597 fn tracked_algo_trailing_acceptance_does_not_emit_update() {
3598 let message = load_algo_order_messages("ws_orders_algo_states.json").remove(2);
3599 let client_order_id = ClientOrderId::new(message.algo_cl_ord_id.as_str());
3600 let state = WsDispatchState::default();
3601 let mut context = test_algo_context(client_order_id);
3602 context.identity.order_type = OrderType::TrailingStopMarket;
3603 context.price = None;
3604 state.track_order_context(context);
3605 let instruments = test_algo_instruments();
3606 let (emitter, mut receiver) = test_execution_emitter();
3607
3608 dispatch_test_message(
3609 OKXWsMessage::AlgoOrders(vec![message]),
3610 &emitter,
3611 &state,
3612 &instruments,
3613 );
3614
3615 let events = drain_execution_events(&mut receiver);
3616 assert_eq!(events.len(), 1);
3617
3618 let ExecutionEvent::Order(OrderEventAny::Accepted(accepted)) = &events[0] else {
3619 panic!("expected OrderAccepted");
3620 };
3621
3622 assert_eq!(accepted.client_order_id, client_order_id);
3623 assert_eq!(
3624 accepted.venue_order_id,
3625 VenueOrderId::from("706620792746729482")
3626 );
3627 assert_eq!(
3628 state.order_context(client_order_id).unwrap().trigger_price,
3629 None
3630 );
3631 }
3632
3633 #[rstest]
3634 #[case::live(OKXAlgoOrderStatus::Live)]
3635 #[case::canceled(OKXAlgoOrderStatus::Canceled)]
3636 #[case::failed(OKXAlgoOrderStatus::OrderFailed)]
3637 fn tracked_algo_malformed_terms_preserve_lifecycle(#[case] status: OKXAlgoOrderStatus) {
3638 let mut message = load_algo_order_messages("ws_orders_algo.json").remove(1);
3639 let client_order_id = ClientOrderId::new(message.algo_cl_ord_id.as_str());
3640 let state = WsDispatchState::default();
3641 let context = test_algo_context(client_order_id);
3642 state.track_order_context(context);
3643 let instruments = test_algo_instruments();
3644 let (emitter, mut receiver) = test_execution_emitter();
3645 message.state = status;
3646 message.trigger_px = "invalid".into();
3647 message.fail_code = "51008".into();
3648
3649 dispatch_test_message(
3650 OKXWsMessage::AlgoOrders(vec![message]),
3651 &emitter,
3652 &state,
3653 &instruments,
3654 );
3655
3656 let events = drain_execution_events(&mut receiver);
3657 assert_eq!(
3658 events.len(),
3659 if status == OKXAlgoOrderStatus::Canceled {
3660 2
3661 } else {
3662 1
3663 }
3664 );
3665
3666 match status {
3667 OKXAlgoOrderStatus::Live => {
3668 assert!(
3669 matches!(&events[0], ExecutionEvent::Order(OrderEventAny::Accepted(event))
3670 if event.client_order_id == client_order_id
3671 && event.venue_order_id == VenueOrderId::from("706620792746729473"))
3672 );
3673 let retained = state.order_context(client_order_id).unwrap();
3674 assert_eq!(retained.quantity, context.quantity);
3675 assert_eq!(retained.price, context.price);
3676 assert_eq!(retained.trigger_price, context.trigger_price);
3677 assert_eq!(retained.trigger_type, context.trigger_type);
3678 assert!(!state.contains_terminal(&client_order_id));
3679 }
3680 OKXAlgoOrderStatus::Canceled => {
3681 assert!(matches!(
3682 &events[0],
3683 ExecutionEvent::Order(OrderEventAny::Accepted(_))
3684 ));
3685 assert!(
3686 matches!(&events[1], ExecutionEvent::Order(OrderEventAny::Canceled(event))
3687 if event.client_order_id == client_order_id
3688 && event.venue_order_id == Some(VenueOrderId::from("706620792746729473")))
3689 );
3690 assert!(state.contains_terminal(&client_order_id));
3691 assert!(state.order_context(client_order_id).is_none());
3692 }
3693 OKXAlgoOrderStatus::OrderFailed => {
3694 assert!(
3695 matches!(&events[0], ExecutionEvent::Order(OrderEventAny::Rejected(event))
3696 if event.client_order_id == client_order_id
3697 && event.reason == Ustr::from("OKX error 51008"))
3698 );
3699 assert!(state.contains_terminal(&client_order_id));
3700 assert!(state.order_context(client_order_id).is_none());
3701 }
3702 _ => unreachable!(),
3703 }
3704 }
3705
3706 #[rstest]
3707 fn algo_update_routes_are_explicit_for_external_tracked_and_suppressed() {
3708 let mut message = load_algo_order_messages("ws_orders_algo.json").remove(0);
3709 let client_order_id = ClientOrderId::new(message.algo_cl_ord_id.as_str());
3710 let state = WsDispatchState::default();
3711
3712 assert_eq!(
3713 route_algo_order_message(&message, &state),
3714 ExecutionUpdateRoute::External
3715 );
3716
3717 let context = test_algo_context(client_order_id);
3718 state.track_order_context(context);
3719 assert_eq!(
3720 route_algo_order_message(&message, &state),
3721 ExecutionUpdateRoute::Tracked(client_order_id, context)
3722 );
3723
3724 message.state = OKXAlgoOrderStatus::Unknown;
3725 assert_eq!(
3726 route_algo_order_message(&message, &state),
3727 ExecutionUpdateRoute::Suppressed
3728 );
3729 }
3730
3731 #[rstest]
3732 #[case::client_id(true)]
3733 #[case::venue_id(false)]
3734 fn imported_limit_context_does_not_route_as_algo(#[case] with_client_id: bool) {
3735 let mut message = load_algo_order_messages("ws_orders_algo.json").remove(0);
3736 let cid = ClientOrderId::new(message.algo_cl_ord_id.as_str());
3737 let vid = VenueOrderId::new(message.algo_id.as_str());
3738 let mut context = test_algo_context(cid);
3739 context.identity.order_type = OrderType::Limit;
3740 context.trigger_price = None;
3741 context.trigger_type = None;
3742 let state = WsDispatchState::default();
3743 state.register_external_order(context, vid);
3744
3745 if !with_client_id {
3746 message.algo_cl_ord_id.clear();
3747 message.cl_ord_id.clear();
3748 }
3749
3750 let route = route_algo_order_message(&message, &state);
3751
3752 assert_eq!(route, ExecutionUpdateRoute::Suppressed);
3753 assert_eq!(state.order_context(cid), Some(context));
3754 assert_eq!(state.order_venue_binding(cid), Some((vid, false)));
3755 assert!(!state.contains_triggered(&cid));
3756 }
3757
3758 #[rstest]
3759 #[case::limit(OrderType::Limit, false)]
3760 #[case::conditional(OrderType::StopLimit, true)]
3761 fn linked_child_waits_only_for_conditional_context(
3762 #[case] order_type: OrderType,
3763 #[case] held: bool,
3764 ) {
3765 let child = load_regular_order_messages("ws_orders_trigger.json").remove(0);
3766 let parent = VenueOrderId::from("7002");
3767 let cid = ClientOrderId::from("O-PENDING-BINDING");
3768 let mut context = test_algo_context(cid);
3769 context.identity.order_type = order_type;
3770 if order_type == OrderType::Limit {
3771 context.trigger_price = None;
3772 context.trigger_type = None;
3773 }
3774
3775 let state = WsDispatchState::default();
3776 state.track_order_context(context);
3777
3778 let resolution =
3779 state.resolve_or_hold_linked_child(parent, context.identity.instrument_id, &child);
3780
3781 assert_eq!(
3782 resolution,
3783 if held {
3784 LinkedChildResolution::Held
3785 } else {
3786 LinkedChildResolution::External
3787 },
3788 );
3789 assert_eq!(
3790 state.pending_linked_children.lock().len(),
3791 usize::from(held)
3792 );
3793 assert_eq!(state.order_context(cid), Some(context));
3794 assert_eq!(state.order_venue_binding(cid), None);
3795 }
3796
3797 #[rstest]
3798 fn rest_parent_binding_routes_linked_child_before_parent_stream_update() {
3799 let mut child = load_regular_order_messages("ws_orders_trigger.json").remove(0);
3800 let client_order_id = ClientOrderId::new("STOP003BTCUSDT20250120");
3801 let parent_venue_order_id = VenueOrderId::new("706620792746729474");
3802 let child_venue_order_id = VenueOrderId::new(child.ord_id);
3803 child.algo_cl_ord_id = None;
3804 let state = WsDispatchState::default();
3805 state.track_order_context(test_algo_context(client_order_id));
3806 state.bind_order(client_order_id, parent_venue_order_id);
3807 let instruments = test_algo_instruments();
3808 let (emitter, mut receiver) = test_execution_emitter();
3809
3810 dispatch_test_message(
3811 OKXWsMessage::Orders(vec![child.clone()]),
3812 &emitter,
3813 &state,
3814 &instruments,
3815 );
3816
3817 let events = drain_execution_events(&mut receiver);
3818 assert_eq!(events.len(), 4);
3819 assert!(matches!(
3820 &events[0],
3821 ExecutionEvent::Order(OrderEventAny::Accepted(accepted))
3822 if accepted.client_order_id == client_order_id
3823 && accepted.venue_order_id == parent_venue_order_id
3824 ));
3825 assert!(matches!(
3826 &events[1],
3827 ExecutionEvent::Order(OrderEventAny::Updated(updated))
3828 if updated.client_order_id == client_order_id
3829 && updated.venue_order_id == Some(child_venue_order_id)
3830 ));
3831 assert!(matches!(
3832 &events[2],
3833 ExecutionEvent::Order(OrderEventAny::Triggered(triggered))
3834 if triggered.client_order_id == client_order_id
3835 && triggered.venue_order_id == Some(child_venue_order_id)
3836 ));
3837 assert!(matches!(
3838 &events[3],
3839 ExecutionEvent::Order(OrderEventAny::Filled(filled))
3840 if filled.client_order_id == client_order_id
3841 && filled.venue_order_id == child_venue_order_id
3842 ));
3843
3844 dispatch_test_message(
3845 OKXWsMessage::Orders(vec![child]),
3846 &emitter,
3847 &state,
3848 &instruments,
3849 );
3850 assert!(drain_execution_events(&mut receiver).is_empty());
3851 }
3852
3853 #[rstest]
3854 #[tokio::test]
3855 async fn pre_binding_child_is_held_until_parent_binding() {
3856 let child = load_regular_order_messages("ws_orders_trigger.json").remove(0);
3857 let parent_venue_order_id = VenueOrderId::new(
3858 child
3859 .linked_algo_ord
3860 .as_ref()
3861 .expect("Expected linked algo order")
3862 .algo_id
3863 .as_str(),
3864 );
3865 let client_order_id = ClientOrderId::new("STOP003BTCUSDT20250120");
3866 let child_venue_order_id = VenueOrderId::new(child.ord_id);
3867 let state = WsDispatchState::default();
3868 state.track_order_context(test_algo_context(client_order_id));
3869 let instruments = test_algo_instruments();
3870 let (emitter, mut receiver) = test_execution_emitter();
3871
3872 dispatch_test_message(
3873 OKXWsMessage::Orders(vec![child.clone()]),
3874 &emitter,
3875 &state,
3876 &instruments,
3877 );
3878 assert!(drain_execution_events(&mut receiver).is_empty());
3879
3880 state.bind_order(client_order_id, parent_venue_order_id);
3881 tokio::time::timeout(
3882 Duration::from_millis(100),
3883 state.wait_for_linked_child_route(),
3884 )
3885 .await
3886 .expect("Expected parent binding to wake the private dispatch loop");
3887 dispatch_test_message(
3888 OKXWsMessage::Orders(Vec::new()),
3889 &emitter,
3890 &state,
3891 &instruments,
3892 );
3893
3894 let events = drain_execution_events(&mut receiver);
3895 assert_eq!(events.len(), 4);
3896 assert!(matches!(
3897 &events[0],
3898 ExecutionEvent::Order(OrderEventAny::Accepted(accepted))
3899 if accepted.client_order_id == client_order_id
3900 && accepted.venue_order_id == parent_venue_order_id
3901 ));
3902 assert!(matches!(
3903 &events[1],
3904 ExecutionEvent::Order(OrderEventAny::Updated(updated))
3905 if updated.client_order_id == client_order_id
3906 && updated.venue_order_id == Some(child_venue_order_id)
3907 ));
3908 assert!(matches!(
3909 &events[2],
3910 ExecutionEvent::Order(OrderEventAny::Triggered(triggered))
3911 if triggered.client_order_id == client_order_id
3912 && triggered.venue_order_id == Some(child_venue_order_id)
3913 ));
3914 assert!(matches!(
3915 &events[3],
3916 ExecutionEvent::Order(OrderEventAny::Filled(filled))
3917 if filled.client_order_id == client_order_id
3918 && filled.venue_order_id == child_venue_order_id
3919 ));
3920
3921 dispatch_test_message(OKXWsMessage::Reconnected, &emitter, &state, &instruments);
3922 dispatch_test_message(
3923 OKXWsMessage::Orders(vec![child]),
3924 &emitter,
3925 &state,
3926 &instruments,
3927 );
3928 assert!(drain_execution_events(&mut receiver).is_empty());
3929 }
3930
3931 #[rstest]
3932 fn held_child_becomes_external_when_candidate_binds_another_parent() {
3933 let child = load_regular_order_messages("ws_orders_trigger.json").remove(0);
3934 let client_order_id = ClientOrderId::new("STOP003BTCUSDT20250120");
3935 let child_venue_order_id = VenueOrderId::new(child.ord_id);
3936 let state = WsDispatchState::default();
3937 state.track_order_context(test_algo_context(client_order_id));
3938 let instruments = test_algo_instruments();
3939 let (emitter, mut receiver) = test_execution_emitter();
3940
3941 dispatch_test_message(
3942 OKXWsMessage::Orders(vec![child]),
3943 &emitter,
3944 &state,
3945 &instruments,
3946 );
3947 assert!(drain_execution_events(&mut receiver).is_empty());
3948
3949 let authoritative_parent = VenueOrderId::new("706620792746729475");
3950 state.bind_order(client_order_id, authoritative_parent);
3951 dispatch_test_message(
3952 OKXWsMessage::Orders(Vec::new()),
3953 &emitter,
3954 &state,
3955 &instruments,
3956 );
3957
3958 let events = drain_execution_events(&mut receiver);
3959 assert_eq!(events.len(), 1);
3960 assert!(matches!(
3961 &events[0],
3962 ExecutionEvent::Report(CommonExecutionReport::OrderWithFills(order, fills))
3963 if order.client_order_id
3964 == Some(ClientOrderId::new("706620792746729474_0"))
3965 && order.venue_order_id == child_venue_order_id
3966 && order.order_status == OrderStatus::Filled
3967 && fills.len() == 1
3968 && fills[0].client_order_id
3969 == Some(ClientOrderId::new("706620792746729474_0"))
3970 && fills[0].venue_order_id == child_venue_order_id
3971 ));
3972 assert_eq!(
3973 state.order_venue_binding(client_order_id),
3974 Some((authoritative_parent, false))
3975 );
3976 }
3977
3978 #[rstest]
3979 #[case::algo(false)]
3980 #[case::imported(true)]
3981 fn active_order_bindings_are_not_evicted_with_replay_state(#[case] imported: bool) {
3982 let state = WsDispatchState::default();
3983 let first_client_order_id = ClientOrderId::new("STOP-ACTIVE-00000");
3984 let first_venue_order_id = VenueOrderId::new("700000000000000000");
3985
3986 for index in 0..=DEDUP_CAPACITY {
3987 let client_order_id = ClientOrderId::new(format!("STOP-ACTIVE-{index:05}").as_str());
3988 let venue_order_id = VenueOrderId::new(
3989 format!("{}", 700_000_000_000_000_000_u64 + index as u64).as_str(),
3990 );
3991
3992 if imported {
3993 let mut context = test_algo_context(client_order_id);
3994 context.identity.order_type = OrderType::Limit;
3995 context.trigger_price = None;
3996 context.trigger_type = None;
3997 state.register_external_order(context, venue_order_id);
3998 } else {
3999 state.bind_order(client_order_id, venue_order_id);
4000 }
4001 }
4002
4003 assert_eq!(
4004 state.order_venue_binding(first_client_order_id),
4005 Some((first_venue_order_id, false))
4006 );
4007 assert_eq!(
4008 state
4009 .lifecycle_bindings
4010 .lock()
4011 .client_by_parent
4012 .get(&first_venue_order_id)
4013 .copied(),
4014 Some(first_client_order_id),
4015 );
4016 }
4017
4018 #[rstest]
4019 fn ambiguous_submit_failure_preserves_only_bound_context() {
4020 let client_order_id = ClientOrderId::new("STOP-AMBIGUOUS-001");
4021 let failure = CommandFailure::Ambiguous("request timed out".to_string());
4022 let unbound_state = WsDispatchState::default();
4023 unbound_state.track_order_context(test_algo_context(client_order_id));
4024
4025 unbound_state.resolve_algo_submit_failure(client_order_id, &failure);
4026 assert_eq!(unbound_state.order_identity(client_order_id), None);
4027
4028 let bound_state = WsDispatchState::default();
4029 let context = test_algo_context(client_order_id);
4030 let parent_venue_order_id = VenueOrderId::new("706620792746729476");
4031 bound_state.track_order_context(context);
4032 bound_state.bind_order(client_order_id, parent_venue_order_id);
4033
4034 bound_state.resolve_algo_submit_failure(client_order_id, &failure);
4035 assert_eq!(
4036 bound_state.order_identity(client_order_id),
4037 Some(context.identity)
4038 );
4039 assert_eq!(
4040 bound_state.order_venue_binding(client_order_id),
4041 Some((parent_venue_order_id, false))
4042 );
4043 }
4044
4045 #[rstest]
4046 #[case::effective(0, false)]
4047 #[case::effective_order_id_list(0, true)]
4048 #[case::partially_effective(1, false)]
4049 #[case::order_placed(2, false)]
4050 fn tracked_algo_trigger_states_bind_child_before_trigger(
4051 #[case] index: usize,
4052 #[case] use_order_id_list: bool,
4053 ) {
4054 let mut messages = if index == 2 {
4055 load_algo_order_messages("ws_orders_algo.json")
4056 } else {
4057 load_algo_order_messages("ws_orders_algo_states.json")
4058 };
4059 let mut message = if index == 2 {
4060 messages.remove(2)
4061 } else {
4062 messages.remove(index)
4063 };
4064 let client_order_id = ClientOrderId::new(message.algo_cl_ord_id.as_str());
4065 let child_venue_order_id = VenueOrderId::new(message.ord_id.as_str());
4066 if use_order_id_list {
4067 message.ord_id_list = vec![message.ord_id.clone()];
4068 message.ord_id.clear();
4069 }
4070
4071 let state = WsDispatchState::default();
4072 state.track_order_context(test_algo_context(client_order_id));
4073 let instruments = test_algo_instruments();
4074 let (emitter, mut receiver) = test_execution_emitter();
4075
4076 dispatch_test_message(
4077 OKXWsMessage::AlgoOrders(vec![message]),
4078 &emitter,
4079 &state,
4080 &instruments,
4081 );
4082
4083 let events = drain_execution_events(&mut receiver);
4084 assert_eq!(events.len(), 3);
4085 assert!(matches!(
4086 &events[0],
4087 ExecutionEvent::Order(OrderEventAny::Accepted(_))
4088 ));
4089 assert!(matches!(
4090 &events[1],
4091 ExecutionEvent::Order(OrderEventAny::Updated(updated))
4092 if updated.venue_order_id == Some(child_venue_order_id)
4093 ));
4094 assert!(matches!(
4095 &events[2],
4096 ExecutionEvent::Order(OrderEventAny::Triggered(triggered))
4097 if triggered.venue_order_id == Some(child_venue_order_id)
4098 ));
4099 assert_eq!(
4100 state.order_venue_binding(client_order_id),
4101 Some((child_venue_order_id, true))
4102 );
4103 }
4104
4105 #[rstest]
4106 fn tracked_algo_transition_uses_venue_actual_quantity() {
4107 let mut message = load_algo_order_messages("ws_orders_algo_states.json").remove(0);
4108 message.sz.clear();
4109 message.close_fraction = "1".to_string();
4110 message.actual_sz = "0.025".to_string();
4111 let client_order_id = ClientOrderId::new(message.algo_cl_ord_id.as_str());
4112 let state = WsDispatchState::default();
4113 state.track_order_context(test_algo_context(client_order_id));
4114 let instruments = test_algo_instruments();
4115 let (emitter, mut receiver) = test_execution_emitter();
4116
4117 dispatch_test_message(
4118 OKXWsMessage::AlgoOrders(vec![message]),
4119 &emitter,
4120 &state,
4121 &instruments,
4122 );
4123
4124 let events = drain_execution_events(&mut receiver);
4125 assert_eq!(events.len(), 3);
4126 assert!(matches!(
4127 &events[1],
4128 ExecutionEvent::Order(OrderEventAny::Updated(updated))
4129 if updated.quantity == Quantity::from("0.025")
4130 && updated.price.is_none()
4131 ));
4132 assert_eq!(
4133 state
4134 .order_contexts
4135 .get(&client_order_id)
4136 .map(|context| context.quantity),
4137 Some(Quantity::from("0.025"))
4138 );
4139 }
4140
4141 #[rstest]
4142 fn regular_child_refreshes_parent_transition_terms() {
4143 let mut parent = load_algo_order_messages("ws_orders_algo_states.json").remove(0);
4144 parent.ord_px = "94950".to_string();
4145 let parent_replay = parent.clone();
4146 let client_order_id = ClientOrderId::new(parent.algo_cl_ord_id.as_str());
4147 let parent_venue_order_id = parent.algo_id.clone();
4148 let child_venue_order_id = parent.ord_id.clone();
4149 let state = WsDispatchState::default();
4150 state.track_order_context(test_algo_context(client_order_id));
4151 let instruments = test_algo_instruments();
4152 let (emitter, mut receiver) = test_execution_emitter();
4153
4154 dispatch_test_message(
4155 OKXWsMessage::AlgoOrders(vec![parent]),
4156 &emitter,
4157 &state,
4158 &instruments,
4159 );
4160 assert_eq!(drain_execution_events(&mut receiver).len(), 3);
4161
4162 let mut child = load_regular_order_messages("ws_orders_trigger.json").remove(0);
4163 child.algo_id = Some(parent_venue_order_id.clone());
4164 child.algo_cl_ord_id = None;
4165 child.linked_algo_ord = Some(crate::websocket::messages::OKXLinkedAlgoOrd {
4166 algo_id: parent_venue_order_id,
4167 });
4168 child.ord_id = Ustr::from(child_venue_order_id.as_str());
4169 child.ord_type = OKXOrderType::Limit;
4170 child.state = OKXOrderStatus::Live;
4171 child.sz = "0.025".to_string();
4172 child.px = "94950".to_string();
4173 child.acc_fill_sz = Some("0".to_string());
4174 child.fill_sz.clear();
4175 child.fill_px.clear();
4176 child.trade_id.clear();
4177
4178 dispatch_test_message(
4179 OKXWsMessage::Orders(vec![child]),
4180 &emitter,
4181 &state,
4182 &instruments,
4183 );
4184
4185 let events = drain_execution_events(&mut receiver);
4186 assert_eq!(events.len(), 1);
4187 assert!(matches!(
4188 &events[0],
4189 ExecutionEvent::Order(OrderEventAny::Updated(updated))
4190 if updated.quantity == Quantity::from("0.025")
4191 && updated.price == Some(Price::from("94950"))
4192 ));
4193 assert_eq!(
4194 state
4195 .order_contexts
4196 .get(&client_order_id)
4197 .map(|context| (context.quantity, context.price)),
4198 Some((Quantity::from("0.025"), Some(Price::from("94950"))))
4199 );
4200
4201 dispatch_test_message(
4202 OKXWsMessage::AlgoOrders(vec![parent_replay]),
4203 &emitter,
4204 &state,
4205 &instruments,
4206 );
4207 assert!(drain_execution_events(&mut receiver).is_empty());
4208 assert_eq!(
4209 state
4210 .order_contexts
4211 .get(&client_order_id)
4212 .map(|context| context.quantity),
4213 Some(Quantity::from("0.025"))
4214 );
4215 }
4216
4217 #[rstest]
4218 fn tracked_algo_holds_trigger_until_linked_child_arrives() {
4219 let mut parent = load_algo_order_messages("ws_orders_algo_states.json").remove(0);
4220 parent.algo_id = "706620792746729474".to_string();
4221 parent.algo_cl_ord_id = "STOP003BTCUSDT20250120".to_string();
4222 parent.ord_id.clear();
4223 parent.ord_id_list.clear();
4224 let client_order_id = ClientOrderId::new(parent.algo_cl_ord_id.as_str());
4225 let state = WsDispatchState::default();
4226 state.track_order_context(test_algo_context(client_order_id));
4227 let instruments = test_algo_instruments();
4228 let (emitter, mut receiver) = test_execution_emitter();
4229
4230 dispatch_test_message(
4231 OKXWsMessage::AlgoOrders(vec![parent]),
4232 &emitter,
4233 &state,
4234 &instruments,
4235 );
4236
4237 let parent_events = drain_execution_events(&mut receiver);
4238 assert_eq!(parent_events.len(), 1);
4239 assert!(matches!(
4240 &parent_events[0],
4241 ExecutionEvent::Order(OrderEventAny::Accepted(_))
4242 ));
4243 assert!(!state.contains_triggered(&client_order_id));
4244
4245 let child = load_regular_order_messages("ws_orders_trigger.json").remove(0);
4246 assert!(child.algo_cl_ord_id.is_none());
4247 assert_eq!(child.cl_ord_id, "706620792746729474_0");
4248 assert_eq!(
4249 child
4250 .linked_algo_ord
4251 .as_ref()
4252 .map(|linked| linked.algo_id.as_str()),
4253 Some("706620792746729474")
4254 );
4255 dispatch_test_message(
4256 OKXWsMessage::Orders(vec![child]),
4257 &emitter,
4258 &state,
4259 &instruments,
4260 );
4261
4262 let child_events = drain_execution_events(&mut receiver);
4263 assert_eq!(child_events.len(), 3);
4264 assert!(matches!(
4265 &child_events[0],
4266 ExecutionEvent::Order(OrderEventAny::Updated(_))
4267 ));
4268 assert!(matches!(
4269 &child_events[1],
4270 ExecutionEvent::Order(OrderEventAny::Triggered(_))
4271 ));
4272
4273 match &child_events[2] {
4274 ExecutionEvent::Order(OrderEventAny::Filled(filled)) => {
4275 assert_eq!(filled.client_order_id, client_order_id);
4276 assert_eq!(
4277 filled.venue_order_id,
4278 VenueOrderId::new("706620792746729999")
4279 );
4280 assert_eq!(filled.trade_id, TradeId::new("1518905530"));
4281 }
4282 other => panic!("Expected tracked child fill, was {other:?}"),
4283 }
4284
4285 assert!(state.contains_terminal(&client_order_id));
4286 }
4287
4288 #[rstest]
4289 fn tracked_algo_child_cancellation_routes_late_fill_report() {
4290 let parent = load_algo_order_messages("ws_orders_algo_states.json").remove(0);
4291 let client_order_id = ClientOrderId::new(parent.algo_cl_ord_id.as_str());
4292 let parent_venue_order_id = parent.algo_id.clone();
4293 let child_venue_order_id = parent.ord_id.clone();
4294 let state = WsDispatchState::default();
4295 state.track_order_context(test_algo_context(client_order_id));
4296 let instruments = test_algo_instruments();
4297 let (emitter, mut receiver) = test_execution_emitter();
4298
4299 dispatch_test_message(
4300 OKXWsMessage::AlgoOrders(vec![parent]),
4301 &emitter,
4302 &state,
4303 &instruments,
4304 );
4305 assert_eq!(drain_execution_events(&mut receiver).len(), 3);
4306
4307 let mut child = load_regular_order_messages("ws_orders_trigger.json").remove(0);
4308 child.algo_id = Some(parent_venue_order_id.clone());
4309 child.linked_algo_ord = Some(crate::websocket::messages::OKXLinkedAlgoOrd {
4310 algo_id: parent_venue_order_id,
4311 });
4312 child.ord_id = Ustr::from(child_venue_order_id.as_str());
4313 let mut canceled = child.clone();
4314 canceled.state = OKXOrderStatus::Canceled;
4315 canceled.acc_fill_sz = Some("0".to_string());
4316 canceled.fill_sz.clear();
4317 canceled.fill_px.clear();
4318 canceled.trade_id.clear();
4319 dispatch_test_message(
4320 OKXWsMessage::Orders(vec![canceled]),
4321 &emitter,
4322 &state,
4323 &instruments,
4324 );
4325
4326 let events = drain_execution_events(&mut receiver);
4327 assert_eq!(events.len(), 1);
4328 assert!(matches!(
4329 &events[0],
4330 ExecutionEvent::Order(OrderEventAny::Canceled(canceled))
4331 if canceled.client_order_id == client_order_id
4332 && canceled.venue_order_id
4333 == Some(VenueOrderId::new(child_venue_order_id.as_str()))
4334 ));
4335 assert!(state.contains_terminal(&client_order_id));
4336
4337 dispatch_test_message(
4338 OKXWsMessage::Orders(vec![child.clone()]),
4339 &emitter,
4340 &state,
4341 &instruments,
4342 );
4343 let events = drain_execution_events(&mut receiver);
4344 assert_eq!(events.len(), 1);
4345 assert!(matches!(
4346 &events[0],
4347 ExecutionEvent::Report(CommonExecutionReport::Fill(report))
4348 if report.client_order_id == Some(client_order_id)
4349 && report.venue_order_id
4350 == VenueOrderId::new(child_venue_order_id.as_str())
4351 && report.trade_id == TradeId::new("1518905530")
4352 ));
4353
4354 dispatch_test_message(
4355 OKXWsMessage::Orders(vec![child]),
4356 &emitter,
4357 &state,
4358 &instruments,
4359 );
4360 assert!(drain_execution_events(&mut receiver).is_empty());
4361 }
4362
4363 #[rstest]
4364 fn reconnect_replay_and_stale_parent_acceptance_are_suppressed() {
4365 let message = load_algo_order_messages("ws_orders_algo_states.json").remove(0);
4366 let client_order_id = ClientOrderId::new(message.algo_cl_ord_id.as_str());
4367 let state = WsDispatchState::default();
4368 state.track_order_context(test_algo_context(client_order_id));
4369 let instruments = test_algo_instruments();
4370 let (emitter, mut receiver) = test_execution_emitter();
4371
4372 dispatch_test_message(
4373 OKXWsMessage::AlgoOrders(vec![message.clone()]),
4374 &emitter,
4375 &state,
4376 &instruments,
4377 );
4378 assert_eq!(drain_execution_events(&mut receiver).len(), 3);
4379
4380 let mut stale_live = message.clone();
4381 stale_live.state = OKXAlgoOrderStatus::Live;
4382 stale_live.ord_id.clear();
4383 dispatch_test_message(OKXWsMessage::Reconnected, &emitter, &state, &instruments);
4384 dispatch_test_message(
4385 OKXWsMessage::AlgoOrders(vec![message, stale_live]),
4386 &emitter,
4387 &state,
4388 &instruments,
4389 );
4390
4391 assert!(drain_execution_events(&mut receiver).is_empty());
4392 assert_eq!(
4393 state
4394 .order_venue_binding(client_order_id)
4395 .map(|(venue_order_id, _)| venue_order_id),
4396 Some(VenueOrderId::new("706620792746730010"))
4397 );
4398 }
4399
4400 #[rstest]
4401 #[case::filled("ws_orders_algo.json", 4, 3)]
4402 #[case::partially_failed("ws_orders_algo_states.json", 4, 1)]
4403 fn tracked_algo_aggregate_state_never_enters_reconciliation(
4404 #[case] fixture: &str,
4405 #[case] index: usize,
4406 #[case] expected_order_events: usize,
4407 ) {
4408 let message = load_algo_order_messages(fixture).remove(index);
4409 let client_order_id = ClientOrderId::new(message.algo_cl_ord_id.as_str());
4410 let state = WsDispatchState::default();
4411 state.track_order_context(test_algo_context(client_order_id));
4412 let instruments = test_algo_instruments();
4413 let (emitter, mut receiver) = test_execution_emitter();
4414
4415 dispatch_test_message(
4416 OKXWsMessage::AlgoOrders(vec![message]),
4417 &emitter,
4418 &state,
4419 &instruments,
4420 );
4421
4422 let events = drain_execution_events(&mut receiver);
4423 assert_eq!(events.len(), expected_order_events);
4424 assert!(
4425 events
4426 .iter()
4427 .all(|event| matches!(event, ExecutionEvent::Order(_)))
4428 );
4429 assert!(state.order_contexts.contains_key(&client_order_id));
4430 assert!(!state.contains_terminal(&client_order_id));
4431 }
4432
4433 #[rstest]
4434 fn tracked_algo_cancel_is_terminal_and_stale_live_is_suppressed() {
4435 let mut message = load_algo_order_messages("ws_orders_algo.json").remove(3);
4436 let client_order_id = ClientOrderId::new(message.algo_cl_ord_id.as_str());
4437 let state = WsDispatchState::default();
4438 state.track_order_context(test_algo_context(client_order_id));
4439 let instruments = test_algo_instruments();
4440 let (emitter, mut receiver) = test_execution_emitter();
4441
4442 dispatch_test_message(
4443 OKXWsMessage::AlgoOrders(vec![message.clone()]),
4444 &emitter,
4445 &state,
4446 &instruments,
4447 );
4448 message.state = OKXAlgoOrderStatus::Live;
4449 message.algo_cl_ord_id.clear();
4450 message.cl_ord_id.clear();
4451 dispatch_test_message(
4452 OKXWsMessage::AlgoOrders(vec![message]),
4453 &emitter,
4454 &state,
4455 &instruments,
4456 );
4457
4458 let events = drain_execution_events(&mut receiver);
4459 assert_eq!(events.len(), 2);
4460 assert!(matches!(
4461 &events[0],
4462 ExecutionEvent::Order(OrderEventAny::Accepted(_))
4463 ));
4464 assert!(matches!(
4465 &events[1],
4466 ExecutionEvent::Order(OrderEventAny::Canceled(canceled))
4467 if canceled.client_order_id == client_order_id
4468 ));
4469 assert!(state.contains_terminal(&client_order_id));
4470 assert!(!state.order_contexts.contains_key(&client_order_id));
4471 assert_eq!(state.order_venue_binding(client_order_id), None);
4472 }
4473
4474 #[rstest]
4475 fn tracked_algo_failure_uses_typed_rejection() {
4476 let mut message = load_algo_order_messages("ws_orders_algo_states.json").remove(3);
4477 message.fail_code = "51008".to_string();
4478 let client_order_id = ClientOrderId::new(message.algo_cl_ord_id.as_str());
4479 let state = WsDispatchState::default();
4480 state.track_order_context(test_algo_context(client_order_id));
4481 let instruments = test_algo_instruments();
4482 let (emitter, mut receiver) = test_execution_emitter();
4483
4484 dispatch_test_message(
4485 OKXWsMessage::AlgoOrders(vec![message]),
4486 &emitter,
4487 &state,
4488 &instruments,
4489 );
4490
4491 let events = drain_execution_events(&mut receiver);
4492 assert_eq!(events.len(), 1);
4493 assert!(matches!(
4494 &events[0],
4495 ExecutionEvent::Order(OrderEventAny::Rejected(rejected))
4496 if rejected.client_order_id == client_order_id
4497 && rejected.reason == Ustr::from("OKX error 51008")
4498 ));
4499 assert!(state.contains_terminal(&client_order_id));
4500 }
4501
4502 #[rstest]
4503 #[case("51000", "Rejected", "", "OKX error 51000: Rejected")]
4504 #[case(
4505 "51000",
4506 "Rejected",
4507 "51004",
4508 "OKX error 51000: Rejected (subCode=51004)"
4509 )]
4510 #[case("51000", "", "", "OKX error 51000")]
4511 #[case("51000", "", "51004", "OKX error 51000 (subCode=51004)")]
4512 #[case("", "Rejected", "", "Rejected")]
4513 #[case("", "Rejected", "51004", "Rejected (subCode=51004)")]
4514 #[case("", "", "51004", "subCode=51004")]
4515 #[case("", "", "", "")]
4516 fn test_format_order_response_reason(
4517 #[case] s_code: &str,
4518 #[case] s_msg: &str,
4519 #[case] sub_code: &str,
4520 #[case] expected: &str,
4521 ) {
4522 assert_eq!(
4523 format_order_response_reason(s_code, s_msg, sub_code),
4524 expected
4525 );
4526 }
4527
4528 #[rstest]
4529 #[case("order", false, false)]
4530 #[case("batch-orders", false, false)]
4531 #[case("batch-orders", false, true)]
4532 #[case("amend-order", true, false)]
4533 #[case("batch-amend-orders", true, false)]
4534 #[case("batch-amend-orders", true, true)]
4535 fn rpi_minimum_notional_rejection_preserves_order_lifecycle(
4536 #[case] case: &str,
4537 #[case] amend: bool,
4538 #[case] reverse: bool,
4539 ) {
4540 let fixtures: serde_json::Value =
4541 serde_json::from_str(include_str!("../../test_data/rpi_minimum_notional.json"))
4542 .unwrap();
4543 let mut response = fixtures[case]["response"].clone();
4544 if reverse {
4545 response["data"].as_array_mut().unwrap().reverse();
4546 }
4547 let frame: OKXWsFrame = serde_json::from_value(response.clone()).unwrap();
4548 let OKXWsFrame::OrderResponse {
4549 id,
4550 op,
4551 code,
4552 msg,
4553 data,
4554 } = frame
4555 else {
4556 panic!("Expected order response");
4557 };
4558 let state = WsDispatchState::default();
4559 let instrument_id = InstrumentId::from("BTC-USDT.OKX");
4560 let strategy_id = StrategyId::from("RPI-003");
4561 let pending = if amend {
4562 &state.pending_amends
4563 } else {
4564 &state.pending_orders
4565 };
4566 let unrelated = "ORPI003";
4567 pending.insert(
4568 unrelated.to_string(),
4569 PendingOrderInfo {
4570 trader_id: TraderId::from("TRADER-001"),
4571 strategy_id,
4572 instrument_id,
4573 },
4574 );
4575 let mut originals = Vec::new();
4576 for item in &data {
4577 let client_order_id = ClientOrderId::new(item["clOrdId"].as_str().unwrap());
4578 let context = OrderContext {
4579 identity: OrderIdentity {
4580 client_order_id,
4581 strategy_id,
4582 instrument_id,
4583 order_side: OrderSide::Sell,
4584 order_type: OrderType::Limit,
4585 },
4586 quantity: Quantity::from("0.2"),
4587 price: Some(Price::from("65123")),
4588 trigger_price: None,
4589 trigger_type: None,
4590 time_in_force: TimeInForce::Gtc,
4591 is_post_only: true,
4592 is_reduce_only: false,
4593 is_quote_quantity: false,
4594 };
4595 state.track_order_context(context);
4596 state
4597 .order_identities
4598 .insert(client_order_id, context.identity);
4599 pending.insert(
4600 client_order_id.to_string(),
4601 PendingOrderInfo {
4602 trader_id: TraderId::from("TRADER-001"),
4603 strategy_id,
4604 instrument_id,
4605 },
4606 );
4607 originals.push(context);
4608 }
4609 let (emitter, mut receiver) = test_execution_emitter();
4610
4611 dispatch_test_message(
4612 OKXWsMessage::OrderResponse {
4613 id,
4614 op,
4615 code,
4616 msg,
4617 data,
4618 client_order_ids: Vec::new(),
4619 },
4620 &emitter,
4621 &state,
4622 &AtomicMap::new(),
4623 );
4624
4625 let events = drain_execution_events(&mut receiver);
4626 assert_eq!(events.len(), 1);
4627 let rejected_id = ClientOrderId::from("ORPI002");
4628 let s_msg = response["data"]
4629 .as_array()
4630 .unwrap()
4631 .iter()
4632 .find(|item| item["sCode"] == "54051")
4633 .unwrap()["sMsg"]
4634 .as_str()
4635 .unwrap();
4636 let reason = format!("OKX error 54051: {s_msg}");
4637
4638 match &events[0] {
4639 ExecutionEvent::Order(OrderEventAny::Rejected(event)) if !amend => {
4640 assert_eq!(event.trader_id, TraderId::from("TRADER-001"));
4641 assert_eq!(event.strategy_id, strategy_id);
4642 assert_eq!(event.instrument_id, instrument_id);
4643 assert_eq!(event.client_order_id, rejected_id);
4644 assert_eq!(event.account_id, AccountId::from("OKX-001"));
4645 assert_eq!(event.reason.as_str(), reason);
4646 assert!(!event.reconciliation);
4647 assert!(!event.due_post_only);
4648 }
4649 ExecutionEvent::Order(OrderEventAny::ModifyRejected(event)) if amend => {
4650 assert_eq!(event.trader_id, TraderId::from("TRADER-001"));
4651 assert_eq!(event.strategy_id, strategy_id);
4652 assert_eq!(event.instrument_id, instrument_id);
4653 assert_eq!(event.client_order_id, rejected_id);
4654 assert_eq!(event.account_id, Some(AccountId::from("OKX-001")));
4655 assert_eq!(
4656 event.venue_order_id,
4657 Some(VenueOrderId::from("2500000000000000002"))
4658 );
4659 assert_eq!(event.reason.as_str(), reason);
4660 assert!(!event.reconciliation);
4661 }
4662 event => panic!("Unexpected event: {event:?}"),
4663 }
4664 assert_eq!(pending.len(), 1);
4665 assert!(pending.contains_key(unrelated));
4666
4667 for original in originals {
4668 let client_order_id = original.identity.client_order_id;
4669 if amend || client_order_id != rejected_id {
4670 assert_eq!(
4671 *state.order_identities.get(&client_order_id).unwrap(),
4672 original.identity
4673 );
4674 assert_eq!(
4675 *state.order_contexts.get(&client_order_id).unwrap(),
4676 original
4677 );
4678 assert!(!state.terminal_orders.contains(&client_order_id));
4679 } else {
4680 assert!(!state.order_identities.contains_key(&client_order_id));
4681 assert!(!state.order_contexts.contains_key(&client_order_id));
4682 }
4683 }
4684 }
4685
4686 #[rstest]
4687 fn cancel_send_failure_prefers_current_venue_binding() {
4688 let cause = UUID4::new();
4689 let state = WsDispatchState::default();
4690 let client_order_id = ClientOrderId::from("O-rebound-cancel");
4691 let identity = test_algo_context(client_order_id).identity;
4692 state.order_identities.insert(client_order_id, identity);
4693 state.bind_order(client_order_id, VenueOrderId::from("current-venue"));
4694 let (emitter, mut receiver) = test_execution_emitter();
4695
4696 emit_send_failed_cancel(
4697 &CommandFailure::NotSent("handler closed".to_string()),
4698 &state,
4699 &emitter,
4700 get_atomic_clock_realtime(),
4701 client_order_id,
4702 Some(VenueOrderId::from("stale-venue")),
4703 Some(cause),
4704 );
4705 let events = drain_execution_events(&mut receiver);
4706
4707 assert_eq!(events.len(), 1);
4708
4709 let ExecutionEvent::Order(OrderEventAny::CancelDenied(event)) = &events[0] else {
4710 panic!("Expected cancel rejection, received {:?}", events[0]);
4711 };
4712
4713 assert_eq!(event.causation_id, Some(cause));
4714 assert_eq!(event.client_order_id, client_order_id);
4715 assert_eq!(
4716 event.venue_order_id,
4717 Some(VenueOrderId::from("current-venue"))
4718 );
4719 assert_eq!(event.instrument_id, identity.instrument_id);
4720 assert_eq!(event.strategy_id, identity.strategy_id);
4721 assert_eq!(event.reason.as_str(), "handler closed");
4722 }
4723
4724 #[rstest]
4725 #[case::no_client(OKXWsError::NoActiveClient, false)]
4726 #[case::connection_changed(OKXWsError::TransportSend(SendError::ConnectionChanged), false)]
4727 #[case::timeout(OKXWsError::TransportSend(SendError::Timeout), false)]
4728 #[case::write_timeout(OKXWsError::TransportSend(SendError::WriteTimeout), true)]
4729 #[case::broken_pipe(OKXWsError::TransportSend(SendError::BrokenPipe("reset".to_string())), true)]
4730 fn cancel_send_failure_resolves_only_definitely_unsent_orders(
4731 #[values(
4732 OKXWsOperation::CancelOrder,
4733 OKXWsOperation::BatchCancelOrders,
4734 OKXWsOperation::MassCancel,
4735 OKXWsOperation::CancelAlgos
4736 )]
4737 op: OKXWsOperation,
4738 #[case] error: OKXWsError,
4739 #[case] ambiguous: bool,
4740 ) {
4741 let state = WsDispatchState::default();
4742 let client_order_ids = [
4743 ClientOrderId::from("O-cancel-first"),
4744 ClientOrderId::from("O-cancel-second"),
4745 ];
4746 let instrument_id = InstrumentId::from("ETH-USDT-SWAP.OKX");
4747 let strategy_id = StrategyId::from("S-CANCEL-FAILURE");
4748 let reason = error.to_string();
4749 let causes = [UUID4::new(), UUID4::new()];
4750 state.pending_command_ids.insert(
4751 "cancel-failure".to_string(),
4752 client_order_ids.into_iter().zip(causes).collect(),
4753 );
4754
4755 for (index, client_order_id) in client_order_ids.into_iter().enumerate() {
4756 state.order_identities.insert(
4757 client_order_id,
4758 OrderIdentity {
4759 client_order_id,
4760 instrument_id,
4761 strategy_id,
4762 order_side: OrderSide::Sell,
4763 order_type: OrderType::Limit,
4764 },
4765 );
4766
4767 state.bind_order(
4768 client_order_id,
4769 VenueOrderId::from(format!("cancel-venue-{index}")),
4770 );
4771 state.pending_cancels.insert(
4772 client_order_id.to_string(),
4773 PendingOrderInfo {
4774 trader_id: TraderId::from("TRADER-001"),
4775 strategy_id,
4776 instrument_id,
4777 },
4778 );
4779 }
4780
4781 let clock = Box::leak(Box::new(AtomicTime::new(false, UnixNanos::from(123_456))));
4782
4783 let mut emitter = ExecutionEventEmitter::new(
4784 clock,
4785 TraderId::from("TRADER-001"),
4786 AccountId::from("OKX-001"),
4787 AccountType::Margin,
4788 None,
4789 );
4790 let (sender, mut receiver) = tokio::sync::mpsc::unbounded_channel();
4791 emitter.set_sender(sender);
4792 dispatch_ws_message(
4793 OKXWsMessage::SendFailed {
4794 request_id: "cancel-failure".to_string(),
4795 client_order_ids: client_order_ids.to_vec(),
4796 op: Some(op),
4797 error,
4798 },
4799 &emitter,
4800 &state,
4801 AccountId::from("OKX-001"),
4802 AccountType::Margin,
4803 &AtomicMap::new(),
4804 &mut FeeCache::new(),
4805 &mut FilledQtyCache::new(),
4806 &mut AHashMap::new(),
4807 clock,
4808 );
4809
4810 let events = drain_execution_events(&mut receiver);
4811 assert_eq!(
4812 state.pending_command_ids.contains_key("cancel-failure"),
4813 ambiguous
4814 );
4815
4816 assert_eq!(events.len(), if ambiguous { 0 } else { 2 });
4817
4818 for (index, client_order_id) in client_order_ids.into_iter().enumerate() {
4819 assert_eq!(
4820 state.pending_cancels.contains_key(client_order_id.as_str()),
4821 ambiguous
4822 );
4823 assert_eq!(
4824 state.order_identity(client_order_id),
4825 Some(OrderIdentity {
4826 client_order_id,
4827 instrument_id,
4828 strategy_id,
4829 order_side: OrderSide::Sell,
4830 order_type: OrderType::Limit,
4831 })
4832 );
4833 assert_eq!(
4834 state.order_venue_binding(client_order_id),
4835 Some((VenueOrderId::from(format!("cancel-venue-{index}")), false))
4836 );
4837
4838 if ambiguous {
4839 continue;
4840 }
4841
4842 let ExecutionEvent::Order(OrderEventAny::CancelDenied(event)) = &events[index] else {
4843 panic!("Expected cancel rejection, received {:?}", events[index]);
4844 };
4845
4846 assert_eq!(event.trader_id, TraderId::from("TRADER-001"));
4847 assert_eq!(event.strategy_id, strategy_id);
4848 assert_eq!(event.instrument_id, instrument_id);
4849 assert_eq!(event.client_order_id, client_order_id);
4850 assert_eq!(
4851 event.venue_order_id,
4852 Some(VenueOrderId::from(format!("cancel-venue-{index}")))
4853 );
4854 assert_eq!(event.account_id, Some(AccountId::from("OKX-001")));
4855 assert_eq!(event.reason.as_str(), reason);
4856 assert_eq!(event.ts_event, UnixNanos::from(123_456));
4857 assert_eq!(event.ts_init, UnixNanos::from(123_456));
4858 assert_eq!(event.causation_id, Some(causes[index]));
4859 }
4860 }
4861
4862 #[rstest]
4863 #[case(false)]
4864 #[case(true)]
4865 fn modify_send_failures_preserve_request_causation(#[case] reverse: bool) {
4866 let state = WsDispatchState::default();
4867 let client_order_id = ClientOrderId::from("O-OVERLAPPING-MODIFY");
4868 let identity = test_algo_context(client_order_id).identity;
4869 state.order_identities.insert(client_order_id, identity);
4870 let first = UUID4::new();
4871 let second = UUID4::new();
4872 state
4873 .pending_command_ids
4874 .insert("modify-first".to_string(), vec![(client_order_id, first)]);
4875 state
4876 .pending_command_ids
4877 .insert("modify-second".to_string(), vec![(client_order_id, second)]);
4878 let (emitter, mut receiver) = test_execution_emitter();
4879 let mut requests = [("modify-first", first), ("modify-second", second)];
4880 if reverse {
4881 requests.reverse();
4882 }
4883
4884 for (index, (request_id, cause)) in requests.into_iter().enumerate() {
4885 dispatch_test_message(
4886 OKXWsMessage::SendFailed {
4887 request_id: request_id.to_string(),
4888 client_order_ids: vec![client_order_id],
4889 op: Some(OKXWsOperation::AmendOrder),
4890 error: OKXWsError::NoActiveClient,
4891 },
4892 &emitter,
4893 &state,
4894 &AtomicMap::new(),
4895 );
4896
4897 let events = drain_execution_events(&mut receiver);
4898
4899 let [ExecutionEvent::Order(OrderEventAny::ModifyDenied(event))] = events.as_slice()
4900 else {
4901 panic!("expected one modify denial: {events:?}")
4902 };
4903
4904 assert_eq!(event.client_order_id, client_order_id);
4905 assert_eq!(event.strategy_id, identity.strategy_id);
4906 assert_eq!(event.instrument_id, identity.instrument_id);
4907 assert_eq!(event.trader_id, TraderId::from("TRADER-001"));
4908 assert_eq!(event.account_id, Some(AccountId::from("OKX-001")));
4909 assert_eq!(event.venue_order_id, None);
4910 assert_eq!(
4911 event.reason.as_str(),
4912 OKXWsError::NoActiveClient.to_string()
4913 );
4914 assert_eq!(event.causation_id, Some(cause));
4915 assert_eq!(state.pending_command_ids.len(), 1 - index);
4916 }
4917 }
4918
4919 #[rstest]
4920 #[case::ambiguous(OKXWsError::SendFailed("connection reset".to_string()), true)]
4921 #[case::not_sent(OKXWsError::NoActiveClient, false)]
4922 fn send_failure_preserves_only_ambiguous_pending_orders(
4923 #[case] error: OKXWsError,
4924 #[case] expected_pending: bool,
4925 ) {
4926 let client_order_ids = [
4927 ClientOrderId::from("O-batch-pending-1"),
4928 ClientOrderId::from("O-batch-pending-2"),
4929 ];
4930 let state = WsDispatchState::default();
4931 let instrument_id = InstrumentId::from("ETH-USDT-SWAP.OKX");
4932 let strategy_id = StrategyId::from("STRATEGY-001");
4933
4934 for client_order_id in client_order_ids {
4935 state.pending_orders.insert(
4936 client_order_id.to_string(),
4937 PendingOrderInfo {
4938 trader_id: TraderId::from("TRADER-001"),
4939 strategy_id,
4940 instrument_id,
4941 },
4942 );
4943 state.order_identities.insert(
4944 client_order_id,
4945 OrderIdentity {
4946 client_order_id,
4947 instrument_id,
4948 strategy_id,
4949 order_side: OrderSide::Buy,
4950 order_type: OrderType::Limit,
4951 },
4952 );
4953 }
4954
4955 let clock = get_atomic_clock_realtime();
4956 let mut emitter = ExecutionEventEmitter::new(
4957 clock,
4958 TraderId::from("TRADER-001"),
4959 AccountId::from("OKX-001"),
4960 AccountType::Margin,
4961 None,
4962 );
4963 let (sender, _receiver) = tokio::sync::mpsc::unbounded_channel();
4964 emitter.set_sender(sender);
4965 let instruments = AtomicMap::new();
4966 let mut fee_cache = FeeCache::new();
4967 let mut filled_qty_cache = FilledQtyCache::new();
4968 let mut order_state_cache = AHashMap::new();
4969
4970 dispatch_ws_message(
4971 OKXWsMessage::SendFailed {
4972 request_id: "req-batch-send-failure".to_string(),
4973 client_order_ids: client_order_ids.to_vec(),
4974 op: Some(OKXWsOperation::BatchOrders),
4975 error,
4976 },
4977 &emitter,
4978 &state,
4979 AccountId::from("OKX-001"),
4980 AccountType::Margin,
4981 &instruments,
4982 &mut fee_cache,
4983 &mut filled_qty_cache,
4984 &mut order_state_cache,
4985 clock,
4986 );
4987
4988 for client_order_id in client_order_ids {
4989 assert_eq!(
4990 state.pending_orders.contains_key(client_order_id.as_str()),
4991 expected_pending,
4992 "pending state mismatch for {client_order_id}"
4993 );
4994 }
4995 }
4996}