Skip to main content

nautilus_okx/websocket/
dispatch.rs

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