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