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