Skip to main content

nautilus_okx/
execution.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//! Live execution client implementation for the OKX adapter.
17
18use std::{future::Future, sync::Arc};
19
20use ahash::{AHashMap, AHashSet};
21use anyhow::Context;
22use async_trait::async_trait;
23use nautilus_common::{
24    clients::{ExecutionClient, ExecutionReportTask},
25    live::{
26        dst::time::{self, Duration, Instant},
27        runner::get_exec_event_sender,
28        sender::EventSender,
29    },
30    messages::{
31        ExecutionEvent,
32        execution::{
33            BatchCancelOrders, CancelAllOrders, CancelOrder, GenerateFillReports,
34            GenerateFillReportsBuilder, GenerateOrderStatusReport, GenerateOrderStatusReports,
35            GenerateOrderStatusReportsBuilder, GeneratePositionStatusReports,
36            GeneratePositionStatusReportsBuilder, ModifyOrder, QueryAccount, QueryOrder,
37            SubmitOrder, SubmitOrderList,
38        },
39    },
40    msgbus::{
41        self, TypedHandler,
42        switchboard::{MessagingSwitchboard, get_instruments_pattern},
43    },
44};
45use nautilus_core::{
46    DurationNanos, UUID4, UnixNanos,
47    params::Params,
48    time::{AtomicTime, get_atomic_clock_realtime},
49};
50use nautilus_live::{
51    ExecutionClientCore, ExecutionEventEmitter, SocketControl,
52    execution::{
53        context::{OrderContext, OrderIdentity},
54        failure::CommandFailure,
55        reports::retain_order_status_reports,
56    },
57    task::{TaskGroup, TaskGroupGuard},
58};
59use nautilus_model::{
60    accounts::AccountAny,
61    enums::{
62        AccountType, OmsType, OrderSide, OrderStatus, OrderType, PositionSide, TimeInForce,
63        TrailingOffsetType,
64    },
65    events::{OrderDeniedReason, OrderPriceField},
66    identifiers::{
67        AccountId, ClientId, ClientOrderId, InstrumentId, PositionId, StrategyId, Venue,
68        VenueOrderId,
69    },
70    instruments::{Instrument, InstrumentAny},
71    orders::Order,
72    reports::{ExecutionMassStatus, FillReport, OrderStatusReport, PositionStatusReport},
73    types::{AccountBalance, MarginBalance, Quantity},
74};
75use rust_decimal::Decimal;
76use ustr::Ustr;
77
78mod stream;
79
80use self::stream::{ExecutionStream, StreamState};
81use crate::{
82    common::{
83        consts::{
84            OKX_CONDITIONAL_ORDER_TYPES, OKX_RECONCILIATION_LOOKBACK_DEFAULT_MINS,
85            OKX_RECONCILIATION_LOOKBACK_MAX_MINS, OKX_SUCCESS_CODE, OKX_VENUE,
86            OKX_WS_HEARTBEAT_SECS, contract_filter_with_config_types, okx_algo_target_currency,
87            okx_reduce_only_wire_value, resolve_instrument_families, validate_algo_trigger_type,
88            validate_okx_client_order_id, validate_order_time_in_force,
89            validate_regular_order_params,
90        },
91        enums::{
92            OKXAlgoOrderType, OKXInstrumentType, OKXMarginMode, OKXPositionMode, OKXPositionSide,
93            OKXTradeMode, OKXTriggerType, conditional_order_to_algo_type, is_advance_algo_order,
94        },
95        failure::{classify_okx_http_failure, classify_okx_venue_code, classify_okx_ws_failure},
96        parse::{
97            is_order_status_report_more_advanced, nanos_to_datetime, okx_instrument_type,
98            okx_instrument_type_from_symbol, venue_position_id,
99        },
100        task::{spawn_task, terminate_tasks},
101    },
102    config::OKXExecutionClientConfig,
103    http::{
104        client::{
105            AlgoOrderReportSweep, FillHistory, OKXActiveOrderReportError, OKXHttpClient,
106            ReportInstrumentScope,
107        },
108        models::{OKXAmendAlgoOrderRequest, OKXCancelAlgoOrderRequest},
109        query::GetPositionsParams,
110    },
111    websocket::{
112        client::OKXWebSocketClient,
113        dispatch::{
114            AlgoCancelContext, AlgoOrderState, WsDispatchState, emit_algo_cancel_rejections,
115            emit_send_failed_cancel, format_order_response_reason,
116        },
117        error::OKXWsError,
118    },
119};
120
121#[derive(Debug)]
122pub struct OKXExecutionClient {
123    core: ExecutionClientCore,
124    clock: &'static AtomicTime,
125    config: OKXExecutionClientConfig,
126    emitter: ExecutionEventEmitter,
127    http_client: OKXHttpClient,
128    ws_private: OKXWebSocketClient,
129    ws_business: OKXWebSocketClient,
130    trade_mode: OKXTradeMode,
131    position_mode: OKXPositionMode,
132    ws_dispatch_state: Arc<WsDispatchState>,
133    session_tasks: TaskGroup,
134    pending_tasks: TaskGroup,
135    stream_state: Arc<StreamState>,
136    stream_instruments: Option<TypedHandler<InstrumentAny>>,
137}
138
139impl OKXExecutionClient {
140    /// Creates a new [`OKXExecutionClient`].
141    ///
142    /// # Errors
143    ///
144    /// Returns an error if the configuration is invalid, if `use_spot_position_reports` is set
145    /// without a NETTING OMS, or if the client fails to initialize.
146    pub fn new(
147        core: ExecutionClientCore,
148        config: OKXExecutionClientConfig,
149    ) -> anyhow::Result<Self> {
150        config.validate()?;
151
152        // A wallet holding is one net quantity per pair, a HEDGING correction opens a new
153        // position instead of changing the cached one.
154        anyhow::ensure!(
155            !config.use_spot_position_reports || core.oms_type == OmsType::Netting,
156            "`use_spot_position_reports` requires a NETTING OMS, was {}; set `oms_type` to NETTING",
157            core.oms_type,
158        );
159
160        let api_key = config
161            .api_key
162            .as_ref()
163            .map(|value| value.expose_secret().to_owned());
164        let api_secret = config
165            .api_secret
166            .as_ref()
167            .map(|value| value.expose_secret().to_owned());
168        let api_passphrase = config
169            .api_passphrase
170            .as_ref()
171            .map(|value| value.expose_secret().to_owned());
172        let proxy_url = config
173            .proxy_url
174            .as_ref()
175            .map(|value| value.expose_secret().to_owned());
176        let http_client = OKXHttpClient::with_credentials(
177            api_key.clone(),
178            api_secret.clone(),
179            api_passphrase.clone(),
180            Some(config.http_base_url()),
181            config.http_timeout_secs,
182            config.max_retries,
183            config.retry_delay_initial_ms,
184            config.retry_delay_max_ms,
185            config.environment,
186            proxy_url.clone(),
187        )?;
188
189        let account_id = core.account_id;
190
191        let ws_private = OKXWebSocketClient::with_credentials(
192            Some(config.ws_private_url()),
193            api_key.clone(),
194            api_secret.clone(),
195            api_passphrase.clone(),
196            Some(account_id),
197            Some(OKX_WS_HEARTBEAT_SECS),
198            config.auth_timeout_secs,
199            config.transport_backend,
200            proxy_url.clone(),
201        )
202        .context("failed to construct OKX private websocket client")?
203        .with_socket_control(SocketControl::new(
204            core.client_id,
205            Some(*OKX_VENUE),
206            "okx-private-user-streams",
207        ))
208        .with_order_request_ttl_ms(config.order_request_ttl_ms);
209
210        let ws_business = OKXWebSocketClient::with_credentials(
211            Some(config.ws_business_url()),
212            api_key,
213            api_secret,
214            api_passphrase,
215            Some(account_id),
216            Some(OKX_WS_HEARTBEAT_SECS),
217            config.auth_timeout_secs,
218            config.transport_backend,
219            proxy_url,
220        )
221        .context("failed to construct OKX business websocket client")?
222        .with_socket_control(SocketControl::new(
223            core.client_id,
224            Some(*OKX_VENUE),
225            "okx-business-user-streams",
226        ));
227
228        http_client.set_spot_trade_quote_ccy(config.spot_trade_quote_ccy.clone());
229        ws_private.set_spot_trade_quote_ccy(config.spot_trade_quote_ccy.clone());
230        ws_business.set_spot_trade_quote_ccy(config.spot_trade_quote_ccy.clone());
231
232        let trade_mode = Self::derive_default_trade_mode(core.account_type, &config);
233        let clock = get_atomic_clock_realtime();
234        let emitter = ExecutionEventEmitter::new(
235            clock,
236            core.trader_id,
237            core.account_id,
238            core.account_type,
239            None,
240        );
241
242        let ws_dispatch_state = Arc::new(WsDispatchState::with_pending_maps(
243            ws_private.pending_orders.clone(),
244            ws_private.pending_cancels.clone(),
245            ws_private.pending_amends.clone(),
246            ws_private.pending_command_ids.clone(),
247        ));
248
249        let stream_state = Arc::new(StreamState::new(
250            http_client.clone(),
251            ws_private.clone(),
252            ws_business.clone(),
253            std::iter::empty(),
254        ));
255
256        Ok(Self {
257            core,
258            clock,
259            config,
260            emitter,
261            http_client,
262            ws_private,
263            ws_business,
264            trade_mode,
265            position_mode: OKXPositionMode::NetMode,
266            ws_dispatch_state,
267            session_tasks: TaskGroup::new(),
268            pending_tasks: TaskGroup::new(),
269            stream_state,
270            stream_instruments: None,
271        })
272    }
273
274    pub(crate) fn set_event_sender(&mut self, sender: EventSender<ExecutionEvent>) {
275        self.emitter.set_sender(sender);
276    }
277
278    fn derive_default_trade_mode(
279        account_type: AccountType,
280        config: &OKXExecutionClientConfig,
281    ) -> OKXTradeMode {
282        let is_cross_margin = config.margin_mode == Some(OKXMarginMode::Cross);
283        if account_type == AccountType::Cash {
284            if !config.uses_spot_margin() {
285                return OKXTradeMode::Cash;
286            }
287            return if is_cross_margin {
288                OKXTradeMode::Cross
289            } else {
290                OKXTradeMode::Isolated
291            };
292        }
293
294        if is_cross_margin {
295            OKXTradeMode::Cross
296        } else {
297            OKXTradeMode::Isolated
298        }
299    }
300
301    fn trade_mode_for_order(
302        &self,
303        instrument_id: InstrumentId,
304        params: Option<&Params>,
305    ) -> OKXTradeMode {
306        if let Some(td_mode_str) = get_param_as_string(params, "td_mode") {
307            match td_mode_str.parse::<OKXTradeMode>() {
308                Ok(mode) => return mode,
309                Err(_) => {
310                    log::warn!("Invalid td_mode '{td_mode_str}', using derived trade mode");
311                }
312            }
313        }
314
315        derive_trade_mode_for_instrument(
316            instrument_id,
317            self.config.margin_mode,
318            self.config.uses_spot_margin(),
319        )
320    }
321
322    fn report_context(&self) -> ReportContext {
323        ReportContext {
324            core: self.core.clone(),
325            http_client: self.http_client.clone(),
326            ws_private: self.ws_private.clone(),
327            ws_business: self.ws_business.clone(),
328        }
329    }
330
331    fn report_client(&self) -> OKXReportClient {
332        OKXReportClient {
333            account_id: self.core.account_id,
334            http_client: self.http_client.clone(),
335            instrument_types: self.config.instrument_types.clone(),
336            spot_positions_quote_currency: self.spot_positions_quote_currency(),
337            recover_inst_id_codes: self.config.has_instrument_filters(),
338            load_spreads: self.config.load_spreads,
339            margin_mode: (self.position_mode == OKXPositionMode::LongShortMode).then_some(
340                self.config
341                    .margin_mode
342                    .filter(|mode| *mode != OKXMarginMode::None)
343                    .unwrap_or(OKXMarginMode::Isolated),
344            ),
345        }
346    }
347
348    fn instrument_types(&self) -> Vec<OKXInstrumentType> {
349        OKXReportClient::instrument_types(&self.config.instrument_types)
350    }
351
352    fn spot_positions_quote_currency(&self) -> Option<Ustr> {
353        (self.config.use_spot_position_reports
354            && self.instrument_types().iter().any(|inst_type| {
355                matches!(
356                    inst_type,
357                    OKXInstrumentType::Spot | OKXInstrumentType::Margin
358                )
359            }))
360        .then(|| Ustr::from(self.config.spot_positions_quote_currency.as_str()))
361    }
362
363    async fn collect_order_status_reports(
364        &self,
365        cmd: &GenerateOrderStatusReports,
366        max_history_pages: Option<u32>,
367    ) -> anyhow::Result<OrderReportSweep> {
368        let sweep = self
369            .report_client()
370            .collect_order_status_reports(cmd, max_history_pages)
371            .await?;
372        self.report_context()
373            .register(sweep.reports.iter().map(|report| report.instrument_id));
374        Ok(finish_order_report_sweep(&self.core, sweep, cmd))
375    }
376
377    async fn collect_fill_reports(
378        &self,
379        cmd: GenerateFillReports,
380        history: FillHistory,
381        max_history_pages: Option<u32>,
382    ) -> anyhow::Result<(Vec<FillReport>, bool)> {
383        let result = self
384            .report_client()
385            .collect_fill_reports(cmd, history, max_history_pages)
386            .await?;
387        self.report_context()
388            .register(result.0.iter().map(|report| report.instrument_id));
389        Ok(result)
390    }
391
392    async fn collect_position_status_reports(
393        &self,
394        cmd: &GeneratePositionStatusReports,
395    ) -> anyhow::Result<(Vec<PositionStatusReport>, bool)> {
396        let result = self
397            .report_client()
398            .collect_position_status_reports(cmd)
399            .await?;
400        self.report_context()
401            .register(result.0.iter().map(|report| report.instrument_id));
402        Ok(result)
403    }
404
405    fn query_order_state(&self, cmd: &GenerateOrderStatusReport) -> Option<CachedQueryOrderState> {
406        let cache = self.core.cache();
407        cmd.client_order_id.and_then(|client_order_id| {
408            cache
409                .order(&client_order_id)
410                .map(|order| CachedQueryOrderState {
411                    order_type: order.order_type(),
412                    venue_order_id: order.venue_order_id(),
413                })
414        })
415    }
416
417    fn update_account_state(&self) {
418        let http_client = self.http_client.clone();
419        let account_id = self.core.account_id;
420        let account_type = self.core.account_type;
421        let emitter = self.emitter.clone();
422
423        self.spawn_task("query_account", async move {
424            let account_state = http_client
425                .request_account_state(account_id, account_type)
426                .await
427                .context("failed to request OKX account state")?;
428            emitter.send_account_state(account_state);
429            Ok(())
430        });
431    }
432
433    fn is_conditional_order(&self, order_type: OrderType) -> bool {
434        OKX_CONDITIONAL_ORDER_TYPES.contains(&order_type)
435    }
436
437    fn submit_order_route(
438        &self,
439        instrument_id: InstrumentId,
440        order_type: OrderType,
441    ) -> anyhow::Result<OrderCommandRoute> {
442        if self.is_conditional_order(order_type) {
443            if self.http_client.is_spread(instrument_id) {
444                anyhow::bail!(
445                    "Trigger/conditional orders ({order_type:?}) are not supported for OKX spreads"
446                );
447            }
448
449            let inst_type = okx_instrument_type_from_symbol(instrument_id.symbol.as_str());
450            if inst_type == OKXInstrumentType::Option {
451                anyhow::bail!(
452                    "Trigger/conditional orders ({order_type:?}) are not supported for OKX options"
453                );
454            }
455
456            return Ok(OrderCommandRoute::AlgoHttp);
457        }
458
459        if self.http_client.is_spread(instrument_id) {
460            Ok(OrderCommandRoute::SpreadHttp)
461        } else {
462            Ok(OrderCommandRoute::RegularWs)
463        }
464    }
465
466    fn order_command_route(
467        &self,
468        instrument_id: InstrumentId,
469        order_state: Option<(OrderType, Option<bool>)>,
470        has_bound_child: bool,
471    ) -> OrderCommandRoute {
472        if self.http_client.is_spread(instrument_id) {
473            return OrderCommandRoute::SpreadHttp;
474        }
475
476        if has_bound_child {
477            return OrderCommandRoute::RegularWs;
478        }
479
480        if order_state.is_some_and(|(order_type, is_triggered)| {
481            self.is_conditional_order(order_type) && is_triggered != Some(true)
482        }) {
483            OrderCommandRoute::AlgoHttp
484        } else {
485            OrderCommandRoute::RegularWs
486        }
487    }
488
489    fn cancel_all_orders_route(
490        &self,
491        instrument_id: InstrumentId,
492        order_side: Option<OrderSide>,
493    ) -> CancelAllOrdersRoute {
494        if order_side.is_some() {
495            CancelAllOrdersRoute::Batch
496        } else if self.http_client.is_spread(instrument_id) {
497            CancelAllOrdersRoute::SpreadHttp
498        } else if self.config.use_mm_mass_cancel {
499            CancelAllOrdersRoute::MassCancelHttp
500        } else {
501            CancelAllOrdersRoute::Batch
502        }
503    }
504
505    fn submit_regular_order(
506        &self,
507        cmd: &SubmitOrder,
508        position_side: Option<PositionSide>,
509    ) -> anyhow::Result<()> {
510        let order = {
511            let cache = self.core.cache();
512            cache.try_order_owned(&cmd.client_order_id)?
513        };
514        let ws_private = self.ws_private.clone();
515        let trade_mode = self.trade_mode_for_order(cmd.instrument_id, cmd.params.as_ref());
516
517        let emitter = self.emitter.clone();
518        let clock = self.clock;
519        let trader_id = self.core.trader_id;
520        let context = OrderContext::from(&order);
521
522        self.ws_dispatch_state
523            .order_identities
524            .insert(context.identity.client_order_id, context.identity);
525        let client_order_id = context.identity.client_order_id;
526        let strategy_id = context.identity.strategy_id;
527        let instrument_id = context.identity.instrument_id;
528        let order_side = context.identity.order_side;
529        let order_type = context.identity.order_type;
530        let quantity = context.quantity;
531        let time_in_force = context.time_in_force;
532        let price = context.price;
533        let trigger_price = context.trigger_price;
534        let is_post_only = context.is_post_only;
535        let is_reduce_only = context.is_reduce_only;
536
537        let is_quote_quantity = context.is_quote_quantity;
538
539        let px_usd = get_param_as_string(cmd.params.as_ref(), "px_usd");
540        let px_vol = get_param_as_string(cmd.params.as_ref(), "px_vol");
541        let outcome = get_param_as_string(cmd.params.as_ref(), "outcome");
542        let slippage_pct = get_param_as_string(cmd.params.as_ref(), "slippage_pct");
543        let rpi = get_param_as_bool(cmd.params.as_ref(), "rpi");
544        let rpi_taker_access = get_param_as_bool(cmd.params.as_ref(), "rpi_taker_access");
545        let rpi_px_round = get_param_as_bool(cmd.params.as_ref(), "rpi_px_round");
546
547        self.spawn_task("submit_order", async move {
548            let result = ws_private
549                .submit_order(
550                    trader_id,
551                    strategy_id,
552                    instrument_id,
553                    trade_mode,
554                    client_order_id,
555                    order_side,
556                    order_type,
557                    quantity,
558                    Some(time_in_force),
559                    price,
560                    trigger_price,
561                    Some(is_post_only),
562                    Some(is_reduce_only),
563                    Some(is_quote_quantity),
564                    position_side,
565                    None,
566                    px_usd,
567                    px_vol,
568                    outcome,
569                    slippage_pct,
570                    rpi,
571                    rpi_taker_access,
572                    rpi_px_round,
573                )
574                .await;
575
576            if let Err(e) = result {
577                emit_submit_failure(
578                    classify_okx_ws_failure(&e),
579                    &emitter,
580                    clock,
581                    strategy_id,
582                    instrument_id,
583                    client_order_id,
584                );
585                return Err(anyhow::Error::new(e).context("submit order failed"));
586            }
587
588            Ok(())
589        });
590
591        Ok(())
592    }
593
594    fn submit_order_http(
595        &self,
596        cmd: &SubmitOrder,
597        position_side: Option<PositionSide>,
598    ) -> anyhow::Result<()> {
599        let order = {
600            let cache = self.core.cache();
601            cache.try_order_owned(&cmd.client_order_id)?
602        };
603        let http_client = self.http_client.clone();
604        let trade_mode = self.trade_mode_for_order(cmd.instrument_id, cmd.params.as_ref());
605
606        let emitter = self.emitter.clone();
607        let clock = self.clock;
608        let context = OrderContext::from(&order);
609
610        self.ws_dispatch_state
611            .order_identities
612            .insert(context.identity.client_order_id, context.identity);
613        let client_order_id = context.identity.client_order_id;
614        let strategy_id = context.identity.strategy_id;
615        let instrument_id = context.identity.instrument_id;
616        let order_side = context.identity.order_side;
617        let order_type = context.identity.order_type;
618        let quantity = context.quantity;
619        let time_in_force = context.time_in_force;
620        let price = context.price;
621        let is_post_only = context.is_post_only;
622        let is_reduce_only = context.is_reduce_only;
623        let rpi = get_param_as_bool(cmd.params.as_ref(), "rpi");
624        let rpi_taker_access = get_param_as_bool(cmd.params.as_ref(), "rpi_taker_access");
625        let rpi_px_round = get_param_as_bool(cmd.params.as_ref(), "rpi_px_round");
626
627        self.spawn_task("submit_order_http", async move {
628            let result = http_client
629                .place_order_with_domain_types(
630                    instrument_id,
631                    trade_mode,
632                    client_order_id,
633                    order_side,
634                    order_type,
635                    quantity,
636                    Some(time_in_force),
637                    price,
638                    Some(is_post_only),
639                    Some(is_reduce_only),
640                    None,
641                    position_side,
642                    None,
643                    None,
644                    None,
645                    None,
646                    None,
647                    rpi,
648                    rpi_taker_access,
649                    rpi_px_round,
650                )
651                .await;
652
653            if let Err(e) = result {
654                emit_submit_failure(
655                    classify_okx_http_failure(&e),
656                    &emitter,
657                    clock,
658                    strategy_id,
659                    instrument_id,
660                    client_order_id,
661                );
662                return Err(anyhow::Error::new(e).context("submit order failed"));
663            }
664
665            Ok(())
666        });
667
668        Ok(())
669    }
670
671    fn submit_conditional_order(
672        &self,
673        cmd: &SubmitOrder,
674        position_side: Option<PositionSide>,
675    ) -> anyhow::Result<()> {
676        let order = {
677            let cache = self.core.cache();
678            cache.try_order_owned(&cmd.client_order_id)?
679        };
680        let http_client = self.http_client.clone();
681        let trade_mode = self.trade_mode_for_order(cmd.instrument_id, cmd.params.as_ref());
682
683        let emitter = self.emitter.clone();
684        let clock = self.clock;
685        let context = OrderContext::from(&order);
686
687        let client_order_id = context.identity.client_order_id;
688        let strategy_id = context.identity.strategy_id;
689        let instrument_id = context.identity.instrument_id;
690        let order_side = context.identity.order_side;
691        let order_type = context.identity.order_type;
692        let quantity = context.quantity;
693        let trigger_type = context.trigger_type;
694        let trigger_price = context.trigger_price;
695        let price = context.price;
696        let is_reduce_only = context.is_reduce_only;
697
698        let tgt_ccy = okx_algo_target_currency(
699            okx_instrument_type_from_symbol(instrument_id.symbol.as_str()),
700            trade_mode,
701            order_side,
702            order_type,
703            context.is_quote_quantity,
704        )?;
705
706        let trailing_offset = order.trailing_offset();
707        let trailing_offset_type = order.trailing_offset_type();
708        let activation_price = order.activation_price();
709
710        let close_fraction = get_param_as_string(cmd.params.as_ref(), "close_fraction");
711
712        let reduce_only = if close_fraction.is_some() {
713            Some(true)
714        } else {
715            Some(is_reduce_only)
716        };
717
718        let (callback_ratio, callback_spread) = if order_type == OrderType::TrailingStopMarket {
719            let offset = trailing_offset
720                .ok_or_else(|| anyhow::anyhow!("TrailingStopMarket requires trailing_offset"))?;
721            let offset_type = trailing_offset_type.ok_or_else(|| {
722                anyhow::anyhow!("TrailingStopMarket requires trailing_offset_type")
723            })?;
724
725            match offset_type {
726                TrailingOffsetType::BasisPoints => {
727                    // Convert basis points to ratio (e.g., 100 bps = 0.01)
728                    let ratio = offset / Decimal::from(10000);
729                    (Some(ratio.to_string()), None)
730                }
731                TrailingOffsetType::Price => (None, Some(offset.to_string())),
732                _ => {
733                    anyhow::bail!("Unsupported trailing_offset_type for OKX: {offset_type:?}");
734                }
735            }
736        } else {
737            (None, None)
738        };
739
740        let algo_order_type = if close_fraction.is_some() || tgt_ccy.is_some() {
741            OKXAlgoOrderType::Conditional
742        } else {
743            conditional_order_to_algo_type(order_type)?
744        };
745
746        self.ws_dispatch_state.algo_order_states.insert(
747            client_order_id,
748            AlgoOrderState {
749                order_type: algo_order_type,
750                ts_last: UnixNanos::default(),
751            },
752        );
753
754        self.ws_dispatch_state.track_order_context(context);
755        let dispatch_state = Arc::clone(&self.ws_dispatch_state);
756
757        self.spawn_task("submit_algo_order", async move {
758            let result = http_client
759                .place_algo_order_with_domain_types(
760                    instrument_id,
761                    trade_mode,
762                    client_order_id,
763                    order_side,
764                    order_type,
765                    quantity,
766                    context.is_quote_quantity,
767                    trigger_price,
768                    trigger_type,
769                    price,
770                    reduce_only,
771                    position_side,
772                    close_fraction,
773                    callback_ratio,
774                    callback_spread,
775                    activation_price,
776                )
777                .await;
778
779            match result {
780                Ok(response) => {
781                    dispatch_state.bind_order(
782                        client_order_id,
783                        VenueOrderId::new(response.algo_id.as_str()),
784                    );
785                }
786                Err(e) => {
787                    let failure = classify_okx_http_failure(&e);
788                    dispatch_state.resolve_algo_submit_failure(client_order_id, &failure);
789                    emit_submit_failure(
790                        failure,
791                        &emitter,
792                        clock,
793                        strategy_id,
794                        instrument_id,
795                        client_order_id,
796                    );
797                    return Err(anyhow::Error::new(e).context("submit algo order failed"));
798                }
799            }
800
801            Ok(())
802        });
803
804        Ok(())
805    }
806
807    fn modify_algo_order(&self, cmd: &ModifyOrder) {
808        let algo_type = self
809            .ws_dispatch_state
810            .algo_order_states
811            .get(&cmd.client_order_id)
812            .map(|state| state.order_type);
813        let context = self.ws_dispatch_state.order_context(cmd.client_order_id);
814
815        let request = match algo_amend_request(cmd, algo_type, context) {
816            Ok(request) => request,
817            Err(reason) => {
818                emit_modify_failure(
819                    CommandFailure::NotSent(reason.to_string()),
820                    &self.emitter,
821                    self.clock,
822                    cmd.strategy_id,
823                    cmd.instrument_id,
824                    cmd.client_order_id,
825                    cmd.venue_order_id,
826                    Some(cmd.command_id),
827                );
828                return;
829            }
830        };
831
832        let http_client = self.http_client.clone();
833        let command = cmd.clone();
834        let emitter = self.emitter.clone();
835        let clock = self.clock;
836        self.spawn_task("modify_algo_order", async move {
837            let result = http_client.amend_algo_order(request).await;
838
839            let failure = match result {
840                Err(e) => Some(classify_okx_http_failure(&e)),
841                Ok(response) => response
842                    .s_code
843                    .as_deref()
844                    .filter(|code| *code != OKX_SUCCESS_CODE)
845                    .map(|code| {
846                        classify_okx_venue_code(
847                            code,
848                            format_order_response_reason(
849                                code,
850                                response.s_msg.as_deref().unwrap_or(""),
851                                "",
852                            ),
853                        )
854                    }),
855            };
856
857            if let Some(failure) = failure {
858                emit_modify_failure(
859                    failure,
860                    &emitter,
861                    clock,
862                    command.strategy_id,
863                    command.instrument_id,
864                    command.client_order_id,
865                    command.venue_order_id,
866                    Some(command.command_id),
867                );
868            }
869
870            Ok(())
871        });
872    }
873
874    fn cancel_ws_order(&self, cmd: &CancelOrder) {
875        self.ensure_order_identity(cmd.client_order_id, cmd.strategy_id, cmd.instrument_id);
876
877        let ws_private = self.ws_private.clone();
878        let state = Arc::clone(&self.ws_dispatch_state);
879        let emitter = self.emitter.clone();
880        let clock = self.clock;
881        let mut command = cmd.clone();
882        command.venue_order_id = self
883            .ws_dispatch_state
884            .order_venue_binding(cmd.client_order_id)
885            .map(|(venue_order_id, _)| venue_order_id)
886            .or(cmd.venue_order_id);
887
888        self.spawn_task("cancel_order", async move {
889            let result = ws_private
890                .cancel_order_with_causation(
891                    command.trader_id,
892                    command.strategy_id,
893                    command.instrument_id,
894                    Some(command.client_order_id),
895                    command.venue_order_id,
896                    Some(command.command_id),
897                )
898                .await;
899
900            if let Err(e) = result {
901                let failure = classify_okx_ws_failure(&e);
902
903                if matches!(e, OKXWsError::HandlerUnavailable(_)) {
904                    emit_send_failed_cancel(
905                        &failure,
906                        &state,
907                        &emitter,
908                        clock,
909                        command.client_order_id,
910                        command.venue_order_id,
911                        Some(command.command_id),
912                    );
913                } else {
914                    let emit_local =
915                        matches!(&failure, CommandFailure::NotSent(_)).then_some((&emitter, clock));
916                    emit_cancel_failure(
917                        failure,
918                        emit_local,
919                        command.client_order_id,
920                        command.instrument_id,
921                        command.strategy_id,
922                        command.venue_order_id,
923                        Some(command.command_id),
924                    );
925                }
926
927                return Err(anyhow::Error::new(e).context("cancel order failed"));
928            }
929
930            Ok(())
931        });
932    }
933
934    fn cancel_order_http(&self, cmd: &CancelOrder) {
935        self.ensure_order_identity(cmd.client_order_id, cmd.strategy_id, cmd.instrument_id);
936
937        let http_client = self.http_client.clone();
938        let command = cmd.clone();
939        let emitter = self.emitter.clone();
940        let clock = self.clock;
941
942        self.spawn_task("cancel_order_http", async move {
943            let result = http_client
944                .cancel_order(
945                    command.instrument_id,
946                    Some(command.client_order_id),
947                    command.venue_order_id,
948                )
949                .await;
950
951            if let Err(e) = result {
952                emit_cancel_failure(
953                    classify_okx_http_failure(&e),
954                    Some((&emitter, clock)),
955                    command.client_order_id,
956                    command.instrument_id,
957                    command.strategy_id,
958                    command.venue_order_id,
959                    Some(command.command_id),
960                );
961                return Err(anyhow::Error::new(e).context("cancel order failed"));
962            }
963
964            Ok(())
965        });
966    }
967
968    fn cancel_algo_order(&self, cmd: &CancelOrder) {
969        let http_client = self.http_client.clone();
970        let command = cmd.clone();
971        let emitter = self.emitter.clone();
972        let clock = self.clock;
973
974        let cache = self.core.cache();
975        let is_advance = cache
976            .order(&cmd.client_order_id)
977            .is_some_and(|o| is_advance_algo_order(o.order_type()));
978        drop(cache);
979
980        let request = OKXCancelAlgoOrderRequest {
981            inst_id: cmd.instrument_id.symbol.to_string(),
982            inst_id_code: None,
983            algo_id: cmd.venue_order_id.map(|id| id.to_string()),
984            algo_cl_ord_id: if cmd.venue_order_id.is_none() {
985                Some(cmd.client_order_id.to_string())
986            } else {
987                None
988            },
989        };
990
991        self.spawn_task("cancel_algo_order", async move {
992            let responses = if is_advance {
993                http_client.cancel_advance_algo_orders(vec![request]).await
994            } else {
995                http_client.cancel_algo_orders(vec![request]).await
996            };
997
998            match responses {
999                Err(e) => {
1000                    emit_cancel_failure(
1001                        classify_okx_http_failure(&e),
1002                        Some((&emitter, clock)),
1003                        command.client_order_id,
1004                        command.instrument_id,
1005                        command.strategy_id,
1006                        command.venue_order_id,
1007                        Some(command.command_id),
1008                    );
1009                    return Err(anyhow::Error::new(e).context("cancel algo order failed"));
1010                }
1011                Ok(resps) => {
1012                    if let Some((code, msg)) = resps.first().and_then(|r| {
1013                        r.s_code.as_deref().and_then(|code| {
1014                            (code != OKX_SUCCESS_CODE)
1015                                .then_some((code, r.s_msg.as_deref().unwrap_or("")))
1016                        })
1017                    }) {
1018                        let reason = format_order_response_reason(code, msg, "");
1019                        let failure = classify_okx_venue_code(code, reason.clone());
1020                        let is_rejected = matches!(failure, CommandFailure::VenueRejected(_));
1021                        emit_cancel_failure(
1022                            failure,
1023                            Some((&emitter, clock)),
1024                            command.client_order_id,
1025                            command.instrument_id,
1026                            command.strategy_id,
1027                            command.venue_order_id,
1028                            Some(command.command_id),
1029                        );
1030
1031                        if is_rejected {
1032                            anyhow::bail!("{reason}");
1033                        }
1034                    }
1035                }
1036            }
1037
1038            Ok(())
1039        });
1040    }
1041
1042    fn mass_cancel_instrument(&self, instrument_id: InstrumentId) {
1043        if self.http_client.is_spread(instrument_id) {
1044            let http_client = self.http_client.clone();
1045            self.spawn_task("mass_cancel_orders_http", async move {
1046                if let Err(e) = http_client.cancel_all_orders(instrument_id).await {
1047                    log_mass_cancel_failure(classify_okx_http_failure(&e), instrument_id);
1048                    return Err(anyhow::Error::new(e).context("mass cancel orders failed"));
1049                }
1050                Ok(())
1051            });
1052            return;
1053        }
1054
1055        let ws_private = self.ws_private.clone();
1056
1057        self.spawn_task("mass_cancel_orders", async move {
1058            if let Err(e) = ws_private.mass_cancel_orders(instrument_id).await {
1059                log_mass_cancel_failure(classify_okx_ws_failure(&e), instrument_id);
1060                return Err(anyhow::Error::new(e).context("mass cancel orders failed"));
1061            }
1062            Ok(())
1063        });
1064    }
1065
1066    /// Populates `order_identities` for an order if not already present.
1067    ///
1068    /// Needed for cancel/modify commands on orders loaded via reconciliation
1069    /// (which bypass `submit_order` and therefore have no identity entry).
1070    /// Uses `DashMap::entry().or_insert_with` to keep the check-and-insert
1071    /// atomic; without it, two concurrent reconciliation tasks could race
1072    /// past a `contains_key` check and overwrite each other with stale
1073    /// cache state.
1074    fn ensure_order_identity(
1075        &self,
1076        client_order_id: ClientOrderId,
1077        strategy_id: StrategyId,
1078        instrument_id: InstrumentId,
1079    ) {
1080        if self
1081            .ws_dispatch_state
1082            .order_identity(client_order_id)
1083            .is_some()
1084        {
1085            return;
1086        }
1087
1088        let cache = self.core.cache();
1089
1090        let order_identity = cache
1091            .order(&client_order_id)
1092            .filter(|order| !OKX_CONDITIONAL_ORDER_TYPES.contains(&order.order_type()))
1093            .map(|order| OrderIdentity {
1094                client_order_id,
1095                instrument_id,
1096                strategy_id,
1097                order_side: order.order_side(),
1098                order_type: order.order_type(),
1099            });
1100
1101        drop(cache);
1102
1103        if let Some(order_identity) = order_identity {
1104            self.ws_dispatch_state
1105                .order_identities
1106                .entry(client_order_id)
1107                .or_insert(order_identity);
1108        }
1109    }
1110
1111    fn spawn_task<F>(&self, description: &'static str, fut: F)
1112    where
1113        F: Future<Output = anyhow::Result<()>> + Send + 'static,
1114    {
1115        let fut = async move {
1116            if let Err(e) = fut.await {
1117                log::warn!("{description} failed: {e:?}");
1118            }
1119        };
1120
1121        match self.pending_tasks.spawner() {
1122            Ok(spawner) => spawn_task(&spawner, fut),
1123            Err(e) => log::debug!("Skipping {description} after OKX shutdown began: {e}"),
1124        }
1125    }
1126
1127    // Partitions algo cancel orders into regular and advance, then spawns
1128    // HTTP tasks for each group with per-item and batch-level rejection handling.
1129    fn dispatch_algo_cancels(&self, items: Vec<(OKXCancelAlgoOrderRequest, AlgoCancelContext)>) {
1130        const BATCH_SIZE: usize = 10;
1131
1132        let mut regular_requests = Vec::new();
1133        let mut regular_contexts = Vec::new();
1134        let mut advance_requests = Vec::new();
1135        let mut advance_contexts = Vec::new();
1136
1137        let cache = self.core.cache();
1138
1139        for (request, ctx) in items {
1140            let is_advance = cache
1141                .order(&ctx.client_order_id)
1142                .is_some_and(|o| is_advance_algo_order(o.order_type()));
1143
1144            if is_advance {
1145                advance_requests.push(request);
1146                advance_contexts.push(ctx);
1147            } else {
1148                regular_requests.push(request);
1149                regular_contexts.push(ctx);
1150            }
1151        }
1152
1153        drop(cache);
1154
1155        for (requests, contexts) in regular_requests
1156            .chunks(BATCH_SIZE)
1157            .zip(regular_contexts.chunks(BATCH_SIZE))
1158        {
1159            let regular_requests = requests.to_vec();
1160            let regular_contexts = contexts.to_vec();
1161            let client = self.http_client.clone();
1162            let emitter = self.emitter.clone();
1163            let clock = self.clock;
1164
1165            self.spawn_task("cancel_algo_orders", async move {
1166                match client.cancel_algo_orders(regular_requests).await {
1167                    Ok(responses) => {
1168                        emit_algo_cancel_rejections(&responses, &regular_contexts, &emitter, clock);
1169                    }
1170                    Err(e) => {
1171                        emit_algo_batch_cancel_failure(
1172                            classify_okx_http_failure(&e),
1173                            &regular_contexts,
1174                            &emitter,
1175                            clock,
1176                        );
1177                        return Err(anyhow::Error::new(e).context("cancel algo orders failed"));
1178                    }
1179                }
1180                Ok(())
1181            });
1182        }
1183
1184        for (requests, contexts) in advance_requests
1185            .chunks(BATCH_SIZE)
1186            .zip(advance_contexts.chunks(BATCH_SIZE))
1187        {
1188            let advance_requests = requests.to_vec();
1189            let advance_contexts = contexts.to_vec();
1190            let client = self.http_client.clone();
1191            let emitter = self.emitter.clone();
1192            let clock = self.clock;
1193
1194            self.spawn_task("cancel_advance_algo_orders", async move {
1195                match client.cancel_advance_algo_orders(advance_requests).await {
1196                    Ok(responses) => {
1197                        emit_algo_cancel_rejections(&responses, &advance_contexts, &emitter, clock);
1198                    }
1199                    Err(e) => {
1200                        emit_algo_batch_cancel_failure(
1201                            classify_okx_http_failure(&e),
1202                            &advance_contexts,
1203                            &emitter,
1204                            clock,
1205                        );
1206                        return Err(
1207                            anyhow::Error::new(e).context("cancel advance algo orders failed")
1208                        );
1209                    }
1210                }
1211                Ok(())
1212            });
1213        }
1214    }
1215
1216    fn begin_generation_shutdown(&self) {
1217        self.pending_tasks.begin_shutdown();
1218        self.session_tasks.begin_shutdown();
1219        self.ws_private.begin_shutdown();
1220        self.ws_business.begin_shutdown();
1221        self.core.set_disconnected();
1222    }
1223
1224    /// Polls the cache until the account is registered or timeout is reached.
1225    async fn await_account_registered(&self, timeout_secs: f64) -> anyhow::Result<()> {
1226        let account_id = self.core.account_id;
1227
1228        if self.core.cache().account(&account_id).is_some() {
1229            log::info!("Account {account_id} registered");
1230            return Ok(());
1231        }
1232
1233        let start = Instant::now();
1234        let timeout = Duration::from_secs_f64(timeout_secs);
1235        let interval = Duration::from_millis(10);
1236
1237        loop {
1238            time::sleep(interval).await;
1239
1240            if self.core.cache().account(&account_id).is_some() {
1241                log::info!("Account {account_id} registered");
1242                return Ok(());
1243            }
1244
1245            if start.elapsed() >= timeout {
1246                anyhow::bail!(
1247                    "Timeout waiting for account {account_id} to be registered after {timeout_secs}s"
1248                );
1249            }
1250        }
1251    }
1252
1253    /// Establishes instrument context, both WebSocket transports, private
1254    /// subscriptions, and initial account state.
1255    ///
1256    /// Any failure leaves partially started transports for
1257    /// [`Self::teardown_session`].
1258    async fn establish_session(&mut self) -> anyhow::Result<()> {
1259        // Reset leaves the old generation canceled until this async boundary can drain it
1260        if !self.pending_tasks.is_empty()
1261            || !self.session_tasks.is_empty()
1262            || !self.pending_tasks.is_open()
1263            || !self.session_tasks.is_open()
1264            || self.ws_private.is_active()
1265            || self.ws_business.is_active()
1266            || self.ws_private.has_task()
1267            || self.ws_business.has_task()
1268        {
1269            self.teardown_session().await?;
1270        }
1271
1272        if !self.pending_tasks.is_open() {
1273            self.pending_tasks
1274                .start_generation()
1275                .context("failed to start OKX execution request task generation")?;
1276        }
1277
1278        if !self.session_tasks.is_open() {
1279            self.session_tasks
1280                .start_generation()
1281                .context("failed to start OKX execution stream task generation")?;
1282        }
1283
1284        self.register_stream_instruments();
1285        let instrument_types = self.instrument_types();
1286
1287        self.update_position_mode().await?;
1288
1289        if !self.core.instruments_initialized() {
1290            let mut all_instruments = Vec::new();
1291            let mut all_inst_id_codes = Vec::new();
1292
1293            for instrument_type in &instrument_types {
1294                let Some(families) =
1295                    resolve_instrument_families(&self.config.instrument_families, *instrument_type)
1296                else {
1297                    continue;
1298                };
1299
1300                if families.is_empty() {
1301                    let (mut instruments, inst_id_codes) = self
1302                        .http_client
1303                        .request_instruments(*instrument_type, None)
1304                        .await
1305                        .with_context(|| {
1306                            format!("failed to request OKX instruments for {instrument_type:?}")
1307                        })?;
1308
1309                    instruments.retain(|instrument| {
1310                        contract_filter_with_config_types(
1311                            self.config.contract_types.as_ref(),
1312                            instrument,
1313                        )
1314                    });
1315
1316                    self.check_discovery(&instruments, *instrument_type, None)?;
1317
1318                    log::debug!(
1319                        "Loaded {} {instrument_type:?} instruments",
1320                        instruments.len()
1321                    );
1322
1323                    self.http_client.cache_instruments(&instruments);
1324                    all_instruments.extend(instruments);
1325                    all_inst_id_codes.extend(inst_id_codes);
1326                } else {
1327                    for family in &families {
1328                        let (mut instruments, inst_id_codes) = self
1329                            .http_client
1330                            .request_instruments(*instrument_type, Some(family.clone()))
1331                            .await
1332                            .with_context(|| {
1333                                format!(
1334                                    "failed to request OKX instruments for {instrument_type:?} family {family}"
1335                                )
1336                            })?;
1337
1338                        instruments.retain(|instrument| {
1339                            contract_filter_with_config_types(
1340                                self.config.contract_types.as_ref(),
1341                                instrument,
1342                            )
1343                        });
1344
1345                        self.check_discovery(&instruments, *instrument_type, Some(family))?;
1346
1347                        log::debug!(
1348                            "Loaded {} {instrument_type:?} instruments for family {family}",
1349                            instruments.len()
1350                        );
1351
1352                        self.http_client.cache_instruments(&instruments);
1353                        all_instruments.extend(instruments);
1354                        all_inst_id_codes.extend(inst_id_codes);
1355                    }
1356                }
1357            }
1358
1359            if all_instruments.is_empty() {
1360                anyhow::bail!(
1361                    "No instruments loaded for configured types {instrument_types:?}, \
1362                     cannot initialize execution client"
1363                );
1364            }
1365
1366            if instrument_types.contains(&OKXInstrumentType::Spot)
1367                && let Err(e) = self
1368                    .http_client
1369                    .refresh_account_trade_quote_ccy_lists(OKXInstrumentType::Spot, None)
1370                    .await
1371            {
1372                log::warn!("Failed to refresh account tradeQuoteCcyList: {e}");
1373            }
1374
1375            let trade_quote_ccy_lists = self.http_client.trade_quote_ccy_lists_snapshot();
1376            self.ws_private.cache_instruments(&all_instruments);
1377            self.ws_private
1378                .cache_inst_id_codes(all_inst_id_codes.clone());
1379            self.ws_private
1380                .cache_trade_quote_ccy_lists(trade_quote_ccy_lists.clone());
1381            self.ws_business.cache_instruments(&all_instruments);
1382            self.ws_business.cache_inst_id_codes(all_inst_id_codes);
1383            self.ws_business
1384                .cache_trade_quote_ccy_lists(trade_quote_ccy_lists);
1385            self.core.set_instruments_initialized();
1386        }
1387
1388        Box::pin(self.prepare_active_instruments()).await?;
1389
1390        self.ws_private.connect().await?;
1391        self.ws_private.wait_until_active(10.0).await?;
1392        log::info!("Connected to private WebSocket");
1393
1394        let private_stream = self.ws_private.stream();
1395        self.ws_business.connect().await?;
1396        self.ws_business.wait_until_active(10.0).await?;
1397        log::info!("Connected to business WebSocket");
1398        let business_stream = self.ws_business.stream();
1399        let tasks = self
1400            .session_tasks
1401            .spawner()
1402            .context("OKX execution stream task admission is closed")?;
1403
1404        let worker = ExecutionStream::new(
1405            Arc::clone(&self.stream_state),
1406            Arc::clone(&self.ws_dispatch_state),
1407            self.emitter.clone(),
1408            self.core.account_type,
1409            self.clock,
1410            nautilus_common::live::runner::try_get_data_event_sender(),
1411        );
1412        let cancel = tasks.cancellation_token();
1413        tasks.spawn(worker.run(
1414            futures_util::stream::select(private_stream, business_stream),
1415            cancel,
1416        ))?;
1417
1418        let order_routing_types = order_routing_instrument_types(&instrument_types);
1419
1420        for inst_type in &order_routing_types {
1421            log::debug!("Subscribing to orders channel for {inst_type:?}");
1422            self.ws_private.subscribe_orders(*inst_type).await?;
1423        }
1424
1425        self.ws_private.subscribe_account().await?;
1426
1427        self.subscribe_positions(&instrument_types).await?;
1428
1429        // Liquidation warnings cover margin and derivative positions; SPOT has none
1430        if order_routing_types.iter().any(|t| {
1431            matches!(
1432                t,
1433                OKXInstrumentType::Margin
1434                    | OKXInstrumentType::Swap
1435                    | OKXInstrumentType::Futures
1436                    | OKXInstrumentType::Option
1437            )
1438        }) {
1439            log::debug!("Subscribing to liquidation warning channel");
1440            self.ws_private
1441                .subscribe_liquidation_warning(OKXInstrumentType::Any)
1442                .await?;
1443        }
1444
1445        if self.config.load_spreads {
1446            log::debug!("Subscribing to Nitro spread orders channel");
1447            self.ws_business.subscribe_spread_orders().await?;
1448        }
1449
1450        // Subscribe to algo orders on business WebSocket (OKX requires this endpoint)
1451        for inst_type in &order_routing_types {
1452            if supports_algo_orders(*inst_type) {
1453                self.ws_business.subscribe_orders_algo(*inst_type).await?;
1454                self.ws_business.subscribe_algo_advance(*inst_type).await?;
1455            }
1456        }
1457
1458        let account_state = self
1459            .http_client
1460            .request_account_state(self.core.account_id, self.core.account_type)
1461            .await
1462            .context("failed to request OKX account state")?;
1463
1464        if !account_state.balances.is_empty() {
1465            log::debug!(
1466                "Received account state with {} balance(s)",
1467                account_state.balances.len()
1468            );
1469        }
1470        self.emitter.send_account_state(account_state);
1471
1472        // Wait for account to be registered in cache before completing connect
1473        self.await_account_registered(30.0).await?;
1474
1475        Ok(())
1476    }
1477
1478    async fn subscribe_positions(
1479        &self,
1480        instrument_types: &[OKXInstrumentType],
1481    ) -> anyhow::Result<()> {
1482        for inst_type in [
1483            OKXInstrumentType::Margin,
1484            OKXInstrumentType::Swap,
1485            OKXInstrumentType::Futures,
1486            OKXInstrumentType::Option,
1487        ] {
1488            if instrument_types.contains(&inst_type)
1489                || (inst_type == OKXInstrumentType::Margin
1490                    && instrument_types.contains(&OKXInstrumentType::Spot)
1491                    && self.config.uses_spot_margin())
1492            {
1493                log::debug!("Subscribing to positions channel for {inst_type:?}");
1494                self.ws_private.subscribe_positions(inst_type).await?;
1495            }
1496        }
1497
1498        Ok(())
1499    }
1500
1501    fn register_stream_instruments(&mut self) {
1502        self.unregister_stream_instruments();
1503        let registered = self
1504            .core
1505            .cache()
1506            .instrument_ids(Some(&OKX_VENUE))
1507            .into_iter()
1508            .copied()
1509            .collect::<Vec<_>>();
1510
1511        self.stream_state = Arc::new(StreamState::new(
1512            self.http_client.clone(),
1513            self.ws_private.clone(),
1514            self.ws_business.clone(),
1515            registered,
1516        ));
1517        let state = Arc::downgrade(&self.stream_state);
1518        let core = self.core.clone();
1519
1520        let handler = TypedHandler::from(move |instrument: &InstrumentAny| {
1521            if let Some(state) = state.upgrade() {
1522                let cache = core.cache();
1523                state.observe(instrument, cache.instrument(&instrument.id()));
1524            }
1525        });
1526
1527        msgbus::subscribe_instruments(get_instruments_pattern(*OKX_VENUE), handler.clone(), None);
1528        self.stream_instruments = Some(handler);
1529    }
1530
1531    fn unregister_stream_instruments(&mut self) {
1532        if let Some(handler) = self.stream_instruments.take() {
1533            msgbus::unsubscribe_instruments(get_instruments_pattern(*OKX_VENUE), &handler);
1534        }
1535    }
1536
1537    fn check_discovery(
1538        &self,
1539        instruments: &[InstrumentAny],
1540        instrument_type: OKXInstrumentType,
1541        family: Option<&str>,
1542    ) -> anyhow::Result<()> {
1543        if !instruments.is_empty() {
1544            return Ok(());
1545        }
1546
1547        log::error!(
1548            "OKX execution discovery found no usable instruments: instrument_type={instrument_type:?}, instrument_family={family:?}, contract_types={:?}",
1549            self.config.contract_types,
1550        );
1551        let scope = family.map_or_else(
1552            || format!("{instrument_type:?}"),
1553            |family| format!("{instrument_type:?} family {family}"),
1554        );
1555        anyhow::bail!("No usable instruments for {scope}, cannot initialize execution client")
1556    }
1557
1558    async fn prepare_active_instruments(&self) -> anyhow::Result<()> {
1559        if !self.config.has_instrument_filters() {
1560            return Ok(());
1561        }
1562
1563        let ts_now = self.clock.get_time_ns();
1564
1565        let orders = GenerateOrderStatusReports::new(
1566            UUID4::new(),
1567            ts_now,
1568            true,
1569            None,
1570            None,
1571            None,
1572            None,
1573            None,
1574        );
1575        let positions =
1576            GeneratePositionStatusReports::new(UUID4::new(), ts_now, None, None, None, None, None);
1577        let client = self.report_client();
1578        let (orders, (positions, _)) = tokio::try_join!(
1579            client.collect_order_status_reports(&orders, Some(0)),
1580            client.collect_position_status_reports(&positions),
1581        )?;
1582        // Connect holds the execution-engine borrow, so only adapter caches can be updated here
1583        let context = self.report_context();
1584        for instrument_id in orders
1585            .reports
1586            .iter()
1587            .map(|report| report.instrument_id)
1588            .chain(positions.iter().map(|report| report.instrument_id))
1589        {
1590            context.cache_instrument(instrument_id);
1591        }
1592
1593        Ok(())
1594    }
1595
1596    async fn update_position_mode(&mut self) -> anyhow::Result<()> {
1597        let instrument_types = self.instrument_types();
1598        if instrument_types.iter().any(|instrument_type| {
1599            matches!(
1600                instrument_type,
1601                OKXInstrumentType::Swap | OKXInstrumentType::Futures
1602            )
1603        }) {
1604            let configurations = self
1605                .http_client
1606                .raw_client()
1607                .get_account_configuration()
1608                .await?;
1609            self.position_mode = configurations
1610                .first()
1611                .context("OKX account configuration response is empty")?
1612                .position_mode;
1613
1614            if self.position_mode == OKXPositionMode::LongShortMode {
1615                let report_client = self.report_client();
1616                let scope = report_client.report_scope(&instrument_types);
1617                for inst_type in &instrument_types {
1618                    if !matches!(
1619                        inst_type,
1620                        OKXInstrumentType::Swap | OKXInstrumentType::Futures
1621                    ) {
1622                        continue;
1623                    }
1624
1625                    let positions = self
1626                        .http_client
1627                        .get_positions(GetPositionsParams {
1628                            inst_type: Some(*inst_type),
1629                            ..Default::default()
1630                        })
1631                        .await?;
1632
1633                    for position in positions {
1634                        scope.validate_position_margin(&position)?;
1635                    }
1636                }
1637            }
1638
1639            let expected_oms = match self.position_mode {
1640                OKXPositionMode::NetMode => OmsType::Netting,
1641                OKXPositionMode::LongShortMode => OmsType::Hedging,
1642            };
1643
1644            if self.core.oms_type != expected_oms {
1645                log::warn!(
1646                    "OKX position mode {:?} differs from OMS type {:?}, set oms_type to {expected_oms}",
1647                    self.position_mode,
1648                    self.core.oms_type,
1649                );
1650            }
1651        }
1652
1653        Ok(())
1654    }
1655
1656    /// Drains application tasks before closing transports so task-owned
1657    /// WebSocket clones cannot outlive the session.
1658    async fn teardown_session(&mut self) -> anyhow::Result<()> {
1659        self.begin_generation_shutdown();
1660        self.ws_private.request_close().await;
1661        self.ws_business.request_close().await;
1662        let pending_result = terminate_tasks(&self.pending_tasks, "OKX execution request").await;
1663        let session_result = terminate_tasks(&self.session_tasks, "OKX execution stream").await;
1664
1665        let private_result = self
1666            .ws_private
1667            .close()
1668            .await
1669            .context("failed to close private websocket");
1670        let business_result = self
1671            .ws_business
1672            .close()
1673            .await
1674            .context("failed to close business websocket");
1675
1676        self.core.set_disconnected();
1677
1678        self.unregister_stream_instruments();
1679        let mut errors = Vec::new();
1680        if let Some(failure) = self.stream_state.take_failure() {
1681            errors.push(failure);
1682        }
1683
1684        if let Err(e) = pending_result {
1685            errors.push(e.to_string());
1686        }
1687
1688        if let Err(e) = session_result {
1689            errors.push(e.to_string());
1690        }
1691
1692        if let Err(e) = private_result {
1693            errors.push(e.to_string());
1694        }
1695
1696        if let Err(e) = business_result {
1697            errors.push(e.to_string());
1698        }
1699
1700        if errors.is_empty() {
1701            Ok(())
1702        } else {
1703            anyhow::bail!(errors.join("; "))
1704        }
1705    }
1706}
1707
1708impl Drop for OKXExecutionClient {
1709    fn drop(&mut self) {
1710        self.begin_generation_shutdown();
1711        self.unregister_stream_instruments();
1712    }
1713}
1714
1715fn derive_trade_mode_for_instrument(
1716    instrument_id: InstrumentId,
1717    margin_mode: Option<OKXMarginMode>,
1718    use_spot_margin: bool,
1719) -> OKXTradeMode {
1720    let inst_type = okx_instrument_type_from_symbol(instrument_id.symbol.as_str());
1721    match inst_type {
1722        OKXInstrumentType::Events => OKXTradeMode::Isolated,
1723        OKXInstrumentType::Spot if !use_spot_margin => OKXTradeMode::Cash,
1724        _ if margin_mode == Some(OKXMarginMode::Cross) => OKXTradeMode::Cross,
1725        _ => OKXTradeMode::Isolated,
1726    }
1727}
1728
1729#[async_trait(?Send)]
1730impl ExecutionClient for OKXExecutionClient {
1731    fn is_connected(&self) -> bool {
1732        self.core.is_connected() && self.stream_state.is_healthy()
1733    }
1734
1735    fn client_id(&self) -> ClientId {
1736        self.core.client_id
1737    }
1738
1739    fn account_id(&self) -> AccountId {
1740        self.core.account_id
1741    }
1742
1743    fn venue(&self) -> Venue {
1744        *OKX_VENUE
1745    }
1746
1747    fn oms_type(&self) -> OmsType {
1748        self.core.oms_type
1749    }
1750
1751    fn requires_authoritative_fills(&self) -> bool {
1752        true
1753    }
1754
1755    fn provides_bulk_position_coverage(&self, instrument_id: InstrumentId) -> bool {
1756        if self.http_client.is_spread(instrument_id) {
1757            return false;
1758        }
1759
1760        let instrument_type = okx_instrument_type_from_symbol(instrument_id.symbol.as_str());
1761        !matches!(
1762            instrument_type,
1763            OKXInstrumentType::Spot | OKXInstrumentType::Margin
1764        ) && self.config.instrument_types.contains(&instrument_type)
1765    }
1766
1767    fn get_account(&self) -> Option<AccountAny> {
1768        self.core.cache().account_owned(&self.core.account_id)
1769    }
1770
1771    fn register_external_order(
1772        &self,
1773        client_order_id: ClientOrderId,
1774        venue_order_id: VenueOrderId,
1775        _instrument_id: InstrumentId,
1776        _strategy_id: StrategyId,
1777        _ts_init: UnixNanos,
1778    ) {
1779        let cache = self.core.cache();
1780
1781        let Some(order) = cache.order_ref(&client_order_id) else {
1782            log::warn!("Cannot track imported OKX order {client_order_id}: order not cached");
1783            return;
1784        };
1785
1786        if order.order_type() != OrderType::Limit {
1787            return;
1788        }
1789
1790        let context = OrderContext::from(&*order);
1791        self.ws_dispatch_state
1792            .register_external_order(context, venue_order_id);
1793    }
1794
1795    async fn connect(&mut self) -> anyhow::Result<()> {
1796        if self.is_connected() && self.pending_tasks.is_open() && self.session_tasks.is_open() {
1797            return Ok(());
1798        }
1799        let ws_private = self.ws_private.clone();
1800        let ws_business = self.ws_business.clone();
1801        let setup_guard =
1802            TaskGroupGuard::new(&[&self.session_tasks, &self.pending_tasks], move || {
1803                ws_private.begin_shutdown();
1804                ws_business.begin_shutdown();
1805            });
1806
1807        if let Err(e) = self.establish_session().await {
1808            if let Err(teardown_error) = self.teardown_session().await {
1809                return Err(e.context(format!(
1810                    "OKX execution startup teardown failed: {teardown_error}"
1811                )));
1812            }
1813            return Err(e);
1814        }
1815
1816        if !self.stream_state.is_healthy() {
1817            let failure = self.teardown_session().await;
1818            return failure.and_then(|()| {
1819                Err(anyhow::anyhow!(
1820                    "OKX execution stream recovery failed during connect"
1821                ))
1822            });
1823        }
1824
1825        self.core.set_connected();
1826        setup_guard.disarm();
1827        log::info!("Connected: client_id={}", self.core.client_id);
1828        Ok(())
1829    }
1830
1831    async fn disconnect(&mut self) -> anyhow::Result<()> {
1832        if self.core.is_disconnected()
1833            && self.pending_tasks.is_empty()
1834            && self.session_tasks.is_empty()
1835            && !self.ws_private.has_task()
1836            && !self.ws_business.has_task()
1837            && self.stream_state.is_healthy()
1838        {
1839            return Ok(());
1840        }
1841
1842        self.teardown_session().await?;
1843        log::info!("Disconnected: client_id={}", self.core.client_id);
1844        Ok(())
1845    }
1846
1847    fn query_account(&self, _cmd: QueryAccount) -> anyhow::Result<()> {
1848        self.update_account_state();
1849        Ok(())
1850    }
1851
1852    fn query_order(&self, cmd: QueryOrder) -> anyhow::Result<()> {
1853        let http_client = self.http_client.clone();
1854        let account_id = self.core.account_id;
1855        let emitter = self.emitter.clone();
1856        let instrument_id = cmd.instrument_id;
1857        let client_order_id = cmd.client_order_id;
1858        let venue_order_id = cmd.venue_order_id;
1859        let order_state = {
1860            let cache = self.core.cache();
1861            cache
1862                .order(&client_order_id)
1863                .map(|order| CachedQueryOrderState {
1864                    order_type: order.order_type(),
1865                    venue_order_id: order.venue_order_id(),
1866                })
1867        };
1868
1869        let venue_binding = self.ws_dispatch_state.order_venue_binding(client_order_id);
1870        let authoritative_venue_order_id = venue_binding.map(|(venue_order_id, _)| venue_order_id);
1871        let has_bound_child = venue_binding.is_some_and(|(_, has_bound_child)| has_bound_child);
1872        let cached_venue_order_id = order_state.and_then(|state| state.venue_order_id);
1873        let regular_venue_order_id = if has_bound_child {
1874            authoritative_venue_order_id
1875        } else {
1876            order_state.and_then(|state| {
1877                if OKX_CONDITIONAL_ORDER_TYPES.contains(&state.order_type) {
1878                    state.venue_order_id.or(venue_order_id)
1879                } else {
1880                    state.venue_order_id
1881                }
1882            })
1883        };
1884
1885        let selection_venue_order_id = authoritative_venue_order_id
1886            .or(cached_venue_order_id)
1887            .or(venue_order_id);
1888        let route = query_order_route(
1889            instrument_id,
1890            order_state.map(|state| state.order_type),
1891            regular_venue_order_id.is_some(),
1892            self.http_client.is_spread(instrument_id),
1893        );
1894        self.spawn_task("query_order", async move {
1895            let mut reports = Vec::with_capacity(1);
1896            let mut query_algo = matches!(
1897                route,
1898                QueryOrderRoute::Algo | QueryOrderRoute::RegularAndAlgo
1899            );
1900
1901            match route {
1902                QueryOrderRoute::Spread => {
1903                    match http_client
1904                        .request_order_status_reports(
1905                            account_id,
1906                            None,
1907                            Some(instrument_id),
1908                            None,
1909                            None,
1910                            false,
1911                            None,
1912                        )
1913                        .await
1914                    {
1915                        Ok(spread_reports) => reports.extend(spread_reports),
1916                        Err(e) => {
1917                            log::warn!("OKX query_order failed to fetch spread order: {e}");
1918                        }
1919                    }
1920                }
1921                QueryOrderRoute::Regular | QueryOrderRoute::RegularThenAlgo => {
1922                    let result = if let Some(venue_order_id) = regular_venue_order_id {
1923                        http_client
1924                            .request_order_status_report_by_venue_order_id(
1925                                account_id,
1926                                instrument_id,
1927                                venue_order_id,
1928                            )
1929                            .await
1930                    } else {
1931                        http_client
1932                            .request_order_status_report(
1933                                account_id,
1934                                instrument_id,
1935                                client_order_id,
1936                            )
1937                            .await
1938                    };
1939
1940                    match result {
1941                        Ok(Some(report)) => reports.push(report),
1942                        Ok(None) => {
1943                            query_algo |= route == QueryOrderRoute::RegularThenAlgo;
1944                        }
1945                        Err(e) => {
1946                            log::warn!("OKX query_order failed to fetch regular order: {e}");
1947                        }
1948                    }
1949                }
1950                QueryOrderRoute::Algo | QueryOrderRoute::RegularAndAlgo => {}
1951            }
1952
1953            // Known conditional orders query the algo endpoint by client ID. If
1954            // the parent has triggered, query its single latest regular child so
1955            // a missed child event can supersede the parent state. For an
1956            // uncached order, only fall back after the regular lookup has no match.
1957            if query_algo {
1958                let mut regular_child_venue_order_id = None;
1959
1960                match http_client
1961                    .request_algo_order_status_reports(
1962                        account_id,
1963                        None,
1964                        Some(instrument_id),
1965                        None,
1966                        Some(client_order_id),
1967                        None,
1968                        Some(1),
1969                    )
1970                    .await
1971                {
1972                    Ok(algo_reports) => {
1973                        if matches!(
1974                            route,
1975                            QueryOrderRoute::Algo | QueryOrderRoute::RegularAndAlgo
1976                        ) {
1977                            regular_child_venue_order_id = algo_reports
1978                                .iter()
1979                                .find(|report| {
1980                                    matches!(
1981                                        report.order_status,
1982                                        OrderStatus::Triggered | OrderStatus::Filled
1983                                    )
1984                                })
1985                                .map(|report| report.venue_order_id)
1986                                .or_else(|| {
1987                                    regular_venue_order_id.filter(|venue_order_id| {
1988                                        algo_reports.first().is_none_or(|report| {
1989                                            report.venue_order_id != *venue_order_id
1990                                        })
1991                                    })
1992                                });
1993                        }
1994
1995                        merge_order_status_reports(&mut reports, algo_reports);
1996                    }
1997                    Err(e) => {
1998                        if route == QueryOrderRoute::RegularAndAlgo {
1999                            regular_child_venue_order_id = regular_venue_order_id;
2000                        }
2001
2002                        log::warn!("OKX query_order algo lookup failed for {instrument_id}: {e}");
2003                    }
2004                }
2005
2006                if let Some(child_venue_order_id) = regular_child_venue_order_id {
2007                    match http_client
2008                        .request_order_status_report_by_venue_order_id(
2009                            account_id,
2010                            instrument_id,
2011                            child_venue_order_id,
2012                        )
2013                        .await
2014                    {
2015                        Ok(Some(child_report)) => {
2016                            merge_order_status_reports(&mut reports, vec![child_report]);
2017                        }
2018                        Ok(None) => {}
2019                        Err(e) => {
2020                            log::warn!(
2021                                "OKX query_order failed to fetch regular child order: {e}"
2022                            );
2023                        }
2024                    }
2025                }
2026            }
2027
2028            let Some(report) = select_query_order_report(
2029                reports,
2030                client_order_id,
2031                selection_venue_order_id,
2032            ) else {
2033                log::warn!(
2034                    "OKX query_order found no order for client_order_id={client_order_id}, venue_order_id={selection_venue_order_id:?}",
2035                );
2036                return Ok(());
2037            };
2038
2039            emitter.send_order_status_report(report);
2040            Ok(())
2041        });
2042        Ok(())
2043    }
2044
2045    fn generate_account_state(
2046        &self,
2047        balances: Vec<AccountBalance>,
2048        margins: Vec<MarginBalance>,
2049        reported: bool,
2050        ts_event: UnixNanos,
2051        info: Option<Params>,
2052    ) -> anyhow::Result<()> {
2053        self.emitter
2054            .emit_account_state(balances, margins, reported, ts_event, info);
2055        Ok(())
2056    }
2057
2058    fn on_instrument(&mut self, instrument: InstrumentAny) {
2059        self.http_client.cache_instrument(instrument.clone());
2060        self.ws_private.cache_instrument(instrument.clone());
2061        self.ws_business.cache_instrument(instrument);
2062    }
2063
2064    fn start(&mut self) -> anyhow::Result<()> {
2065        if self.core.is_started() {
2066            return Ok(());
2067        }
2068
2069        let sender = get_exec_event_sender();
2070        self.emitter.set_sender(sender);
2071        self.core.set_started();
2072
2073        log::info!(
2074            "Started: client_id={}, account_id={}, account_type={:?}, trade_mode={:?}, instrument_types={:?}, environment={}, proxy_url={:?}",
2075            self.core.client_id,
2076            self.core.account_id,
2077            self.core.account_type,
2078            self.trade_mode,
2079            self.config.instrument_types,
2080            self.config.environment,
2081            self.config.proxy_url,
2082        );
2083        Ok(())
2084    }
2085
2086    fn stop(&mut self) -> anyhow::Result<()> {
2087        let was_started = self.core.is_started();
2088        self.core.set_stopped();
2089        self.begin_generation_shutdown();
2090
2091        if was_started {
2092            log::info!("Stopped: client_id={}", self.core.client_id);
2093        }
2094        Ok(())
2095    }
2096
2097    fn reset(&mut self) -> anyhow::Result<()> {
2098        self.begin_generation_shutdown();
2099        Ok(())
2100    }
2101
2102    fn dispose(&mut self) -> anyhow::Result<()> {
2103        self.begin_generation_shutdown();
2104        Ok(())
2105    }
2106
2107    fn generate_order_status_report_task(
2108        &self,
2109        cmd: &GenerateOrderStatusReport,
2110    ) -> Option<ExecutionReportTask<Option<OrderStatusReport>>> {
2111        let client = self.report_client();
2112        let context = self.report_context();
2113        let order_state = self.query_order_state(cmd);
2114        let command = cmd.clone();
2115        Some(ExecutionReportTask::new(
2116            async move {
2117                client
2118                    .generate_order_status_report(&command, order_state)
2119                    .await
2120            },
2121            move |report: Option<OrderStatusReport>| {
2122                context.register(report.iter().map(|report| report.instrument_id));
2123                Ok(report)
2124            },
2125        ))
2126    }
2127
2128    fn generate_order_status_reports_task(
2129        &self,
2130        cmd: &GenerateOrderStatusReports,
2131    ) -> Option<ExecutionReportTask<Vec<OrderStatusReport>>> {
2132        let client = self.report_client();
2133        let context = self.report_context();
2134        let core = self.core.clone();
2135        let command = cmd.clone();
2136        let collection_command = command.clone();
2137        Some(ExecutionReportTask::new(
2138            async move {
2139                let mut sweep = client
2140                    .collect_order_status_reports(&collection_command, None)
2141                    .await?;
2142                sweep.regular_by_venue_order_id = AHashMap::new();
2143                sweep.ambiguous_triggered_child_ids = AHashSet::new();
2144                Ok(sweep)
2145            },
2146            move |sweep| {
2147                context.register(sweep.reports.iter().map(|report| report.instrument_id));
2148                Ok(finish_order_report_sweep(&core, sweep, &command).reports)
2149            },
2150        ))
2151    }
2152
2153    fn generate_fill_reports_task(
2154        &self,
2155        cmd: &GenerateFillReports,
2156    ) -> Option<ExecutionReportTask<Vec<FillReport>>> {
2157        let client = self.report_client();
2158        let context = self.report_context();
2159        let command = cmd.clone();
2160        Some(ExecutionReportTask::new(
2161            async move {
2162                client
2163                    .collect_fill_reports(command, FillHistory::Recent, None)
2164                    .await
2165            },
2166            move |(reports, _)| {
2167                context.register(reports.iter().map(|report| report.instrument_id));
2168                Ok(reports)
2169            },
2170        ))
2171    }
2172
2173    fn generate_position_status_reports_task(
2174        &self,
2175        cmd: &GeneratePositionStatusReports,
2176    ) -> Option<ExecutionReportTask<Vec<PositionStatusReport>>> {
2177        let client = self.report_client();
2178        let context = self.report_context();
2179        let command = cmd.clone();
2180        Some(ExecutionReportTask::new(
2181            async move { client.collect_position_status_reports(&command).await },
2182            move |(reports, _)| {
2183                context.register(reports.iter().map(|report| report.instrument_id));
2184                Ok(reports)
2185            },
2186        ))
2187    }
2188
2189    async fn generate_order_status_report(
2190        &self,
2191        cmd: &GenerateOrderStatusReport,
2192    ) -> anyhow::Result<Option<OrderStatusReport>> {
2193        let report = self
2194            .report_client()
2195            .generate_order_status_report(cmd, self.query_order_state(cmd))
2196            .await?;
2197        self.report_context()
2198            .register(report.iter().map(|report| report.instrument_id));
2199        Ok(report)
2200    }
2201
2202    async fn generate_order_status_reports(
2203        &self,
2204        cmd: &GenerateOrderStatusReports,
2205    ) -> anyhow::Result<Vec<OrderStatusReport>> {
2206        Ok(self.collect_order_status_reports(cmd, None).await?.reports)
2207    }
2208
2209    async fn generate_fill_reports(
2210        &self,
2211        cmd: GenerateFillReports,
2212    ) -> anyhow::Result<Vec<FillReport>> {
2213        Ok(self
2214            .collect_fill_reports(cmd, FillHistory::Recent, None)
2215            .await?
2216            .0)
2217    }
2218
2219    async fn generate_position_status_reports(
2220        &self,
2221        cmd: &GeneratePositionStatusReports,
2222    ) -> anyhow::Result<Vec<PositionStatusReport>> {
2223        Ok(self.collect_position_status_reports(cmd).await?.0)
2224    }
2225
2226    async fn generate_mass_status(
2227        &self,
2228        lookback_mins: Option<u64>,
2229    ) -> anyhow::Result<Option<ExecutionMassStatus>> {
2230        log::info!("Generating ExecutionMassStatus (lookback_mins={lookback_mins:?})");
2231
2232        let ts_now = self.clock.get_time_ns();
2233
2234        let lookback_mins = lookback_mins
2235            .unwrap_or(OKX_RECONCILIATION_LOOKBACK_DEFAULT_MINS)
2236            .min(OKX_RECONCILIATION_LOOKBACK_MAX_MINS);
2237        let fill_history = if lookback_mins <= OKX_RECONCILIATION_LOOKBACK_DEFAULT_MINS {
2238            FillHistory::Recent
2239        } else {
2240            FillHistory::Extended
2241        };
2242        let lookback = DurationNanos::try_from_mins(lookback_mins)?;
2243        let start = Some(ts_now.saturating_sub(lookback));
2244
2245        let order_cmd = GenerateOrderStatusReportsBuilder::default()
2246            .ts_init(ts_now)
2247            .open_only(false) // get all orders for mass status
2248            .start(start)
2249            .build()
2250            .map_err(|e| anyhow::anyhow!("{e}"))?;
2251
2252        let fill_cmd = GenerateFillReportsBuilder::default()
2253            .ts_init(ts_now)
2254            .start(start)
2255            .build()
2256            .map_err(|e| anyhow::anyhow!("{e}"))?;
2257
2258        let position_cmd = GeneratePositionStatusReportsBuilder::default()
2259            .ts_init(ts_now)
2260            .start(start)
2261            .build()
2262            .map_err(|e| anyhow::anyhow!("{e}"))?;
2263
2264        let client = self.report_client();
2265        let (
2266            order_sweep,
2267            (fill_reports, fills_complete),
2268            (mut position_reports, positions_complete),
2269        ) = tokio::try_join!(
2270            client.collect_order_status_reports(
2271                &order_cmd,
2272                self.config.max_reconciliation_history_pages,
2273            ),
2274            client.collect_fill_reports(
2275                fill_cmd,
2276                fill_history,
2277                self.config.max_reconciliation_history_pages,
2278            ),
2279            client.collect_position_status_reports(&position_cmd),
2280        )?;
2281        let order_sweep = finish_order_report_sweep(&self.core, order_sweep, &order_cmd);
2282        let OrderReportSweep {
2283            fallback_parents: _,
2284            reports: mut order_reports,
2285            complete: mut orders_complete,
2286            ambiguous_triggered_child_ids,
2287            regular_by_venue_order_id,
2288        } = order_sweep;
2289        orders_complete &= self
2290            .recover_triggered_child_order_reports(
2291                &mut order_reports,
2292                &ambiguous_triggered_child_ids,
2293                &regular_by_venue_order_id,
2294            )
2295            .await?;
2296
2297        if positions_complete {
2298            self.add_flat_derivative_position_reports(
2299                &order_reports,
2300                &fill_reports,
2301                &mut position_reports,
2302                ts_now,
2303            );
2304        }
2305        let reports_complete = orders_complete && fills_complete && positions_complete;
2306
2307        log::info!("Received {} OrderStatusReports", order_reports.len());
2308        log::info!("Received {} FillReports", fill_reports.len());
2309        log::info!("Received {} PositionReports", position_reports.len());
2310
2311        self.report_context().register(
2312            order_reports
2313                .iter()
2314                .map(|report| report.instrument_id)
2315                .chain(fill_reports.iter().map(|report| report.instrument_id))
2316                .chain(position_reports.iter().map(|report| report.instrument_id)),
2317        );
2318
2319        let mut mass_status = ExecutionMassStatus::new(
2320            self.core.client_id,
2321            self.core.account_id,
2322            *OKX_VENUE,
2323            ts_now,
2324            None,
2325        );
2326        mass_status.set_report_window(start, reports_complete);
2327        mass_status.add_order_reports(order_reports);
2328        mass_status.add_fill_reports(fill_reports);
2329        mass_status.add_position_reports(position_reports);
2330
2331        Ok(Some(mass_status))
2332    }
2333
2334    fn submit_order(&self, cmd: SubmitOrder) -> anyhow::Result<()> {
2335        let (route, position_side) = {
2336            let cache = self.core.cache();
2337            let order = cache.try_order(&cmd.client_order_id)?;
2338
2339            if order.is_closed() {
2340                log::warn!("Cannot submit closed order {}", order.client_order_id());
2341                return Ok(());
2342            }
2343
2344            let trade_mode = self.trade_mode_for_order(cmd.instrument_id, cmd.params.as_ref());
2345
2346            if let Err(reason) = self.validate_order(
2347                &*order,
2348                trade_mode,
2349                OrderSubmission::Single,
2350                cmd.params.as_ref(),
2351            ) {
2352                self.emitter.emit_order_denied(&order, &reason.to_string());
2353                return Ok(());
2354            }
2355
2356            let position_side = self.order_position_side(&*order, cmd.params.as_ref());
2357            if let Err(reason) = self
2358                .validate_trade_mode(cmd.instrument_id, position_side, trade_mode)
2359                .and_then(|()| {
2360                    validate_submit_position_id(cmd.instrument_id, position_side, cmd.position_id)
2361                })
2362            {
2363                self.emitter.emit_order_denied(&order, &reason.to_string());
2364                return Ok(());
2365            }
2366
2367            let order_type = order.order_type();
2368            let route = self.submit_order_route(cmd.instrument_id, order_type)?;
2369
2370            log::debug!("OrderSubmitted client_order_id={}", order.client_order_id());
2371            self.emitter.emit_order_submitted(&order);
2372
2373            (route, position_side)
2374        };
2375
2376        match route {
2377            OrderCommandRoute::RegularWs => self.submit_regular_order(&cmd, position_side),
2378            OrderCommandRoute::AlgoHttp => self.submit_conditional_order(&cmd, position_side),
2379            OrderCommandRoute::SpreadHttp => self.submit_order_http(&cmd, position_side),
2380        }
2381    }
2382
2383    fn submit_order_list(&self, cmd: SubmitOrderList) -> anyhow::Result<()> {
2384        if self.http_client.is_spread(cmd.instrument_id) {
2385            let cache = self.core.cache();
2386            let denied = OrderDeniedReason::UnsupportedOrderList {
2387                detail: "spread instruments are not supported in order lists".to_string(),
2388            }
2389            .to_string();
2390
2391            for client_order_id in &cmd.order_list.client_order_ids {
2392                let order = cache.try_order(client_order_id)?;
2393                self.emitter.emit_order_denied(&order, &denied);
2394            }
2395            return Ok(());
2396        }
2397
2398        let inst_type = okx_instrument_type_from_symbol(cmd.instrument_id.symbol.as_str());
2399        let trade_mode = self.trade_mode_for_order(cmd.instrument_id, cmd.params.as_ref());
2400
2401        // Validate all orders before emitting any submitted events
2402        let orders = self.core.get_orders_for_list(&cmd.order_list)?;
2403
2404        // Pre-validate every order so an invalid leg denies the whole list atomically;
2405        // otherwise sibling legs would be left in the cache without a terminal event.
2406        let invalid: Vec<(ClientOrderId, OrderDeniedReason)> = orders
2407            .iter()
2408            .filter_map(|order| {
2409                self.validate_order(
2410                    order,
2411                    trade_mode,
2412                    OrderSubmission::List,
2413                    cmd.params.as_ref(),
2414                )
2415                .and_then(|()| {
2416                    self.validate_trade_mode(
2417                        cmd.instrument_id,
2418                        self.order_position_side(order, cmd.params.as_ref()),
2419                        trade_mode,
2420                    )
2421                })
2422                .and_then(|()| {
2423                    validate_submit_position_id(
2424                        cmd.instrument_id,
2425                        self.order_position_side(order, cmd.params.as_ref()),
2426                        cmd.position_id,
2427                    )
2428                })
2429                .err()
2430                .map(|reason| (order.client_order_id(), reason))
2431            })
2432            .collect();
2433
2434        if !invalid.is_empty() {
2435            let order_list_id = cmd.order_list.id;
2436
2437            for order in &orders {
2438                let denied = invalid
2439                    .iter()
2440                    .find(|(client_order_id, _)| client_order_id == &order.client_order_id())
2441                    .map_or_else(
2442                        || OrderDeniedReason::OrderListDenied { order_list_id },
2443                        |(_, reason)| reason.clone(),
2444                    );
2445                self.emitter.emit_order_denied(order, &denied.to_string());
2446            }
2447            return Ok(());
2448        }
2449
2450        // Build batch payload and emit submitted events
2451        let mut batch_orders = Vec::new();
2452        let outcome = get_param_as_string(cmd.params.as_ref(), "outcome");
2453        let rpi = get_param_as_bool(cmd.params.as_ref(), "rpi");
2454        let rpi_taker_access = get_param_as_bool(cmd.params.as_ref(), "rpi_taker_access");
2455        let rpi_px_round = get_param_as_bool(cmd.params.as_ref(), "rpi_px_round");
2456
2457        for order in &orders {
2458            let context = OrderContext::from(order);
2459
2460            batch_orders.push((
2461                inst_type,
2462                cmd.instrument_id,
2463                trade_mode,
2464                context.identity.client_order_id,
2465                context.identity.order_side,
2466                self.order_position_side(order, cmd.params.as_ref()),
2467                context.identity.order_type,
2468                context.quantity,
2469                context.price,
2470                context.trigger_price,
2471                Some(context.is_post_only),
2472                Some(context.is_reduce_only),
2473                Some(context.is_quote_quantity),
2474                outcome.clone(),
2475                rpi,
2476                rpi_taker_access,
2477                rpi_px_round,
2478            ));
2479
2480            self.ws_dispatch_state
2481                .order_identities
2482                .insert(context.identity.client_order_id, context.identity);
2483
2484            log::debug!("OrderSubmitted client_order_id={}", order.client_order_id());
2485            self.emitter.emit_order_submitted(order);
2486        }
2487
2488        let ws_private = self.ws_private.clone();
2489        let emitter = self.emitter.clone();
2490        let clock = self.clock;
2491        let instrument_id = cmd.instrument_id;
2492        let strategy_id = cmd.strategy_id;
2493        let client_order_ids: Vec<_> = cmd.order_list.client_order_ids;
2494        let dispatch_state = Arc::clone(&self.ws_dispatch_state);
2495
2496        self.spawn_task("batch_submit_orders", async move {
2497            let result = ws_private
2498                .batch_submit_orders(batch_orders)
2499                .await;
2500
2501            if let Err(e) = result {
2502                match classify_okx_ws_failure(&e) {
2503                    CommandFailure::NotSent(reason) => {
2504                        let ts_event = clock.get_time_ns();
2505
2506                        for cid in &client_order_ids {
2507                            dispatch_state.order_identities.remove(cid);
2508                            emitter.emit_order_rejected_event(
2509                                strategy_id,
2510                                instrument_id,
2511                                *cid,
2512                                &reason,
2513                                ts_event,
2514                                false,
2515                            );
2516                        }
2517                    }
2518                    CommandFailure::Ambiguous(reason) | CommandFailure::VenueRejected(reason) => {
2519                        log::warn!(
2520                            "Ambiguous batch submit failure for {} orders on {instrument_id}, awaiting reconciliation: {reason}",
2521                            client_order_ids.len()
2522                        );
2523                    }
2524                }
2525                return Err(anyhow::Error::new(e).context("batch submit orders failed"));
2526            }
2527
2528            Ok(())
2529        });
2530
2531        Ok(())
2532    }
2533
2534    fn modify_order(&self, cmd: ModifyOrder) -> anyhow::Result<()> {
2535        if self.http_client.is_spread(cmd.instrument_id) {
2536            self.emitter.emit_order_modify_denied_event(
2537                cmd.strategy_id,
2538                cmd.instrument_id,
2539                cmd.client_order_id,
2540                cmd.venue_order_id,
2541                "OKX spread orders do not support modify requests",
2542                self.clock.get_time_ns(),
2543                Some(cmd.command_id),
2544            );
2545            return Ok(());
2546        }
2547
2548        let venue_binding = self
2549            .ws_dispatch_state
2550            .order_venue_binding(cmd.client_order_id);
2551
2552        let route = {
2553            let cache = self.core.cache();
2554            let order_state = cache
2555                .order(&cmd.client_order_id)
2556                .map(|order| (order.order_type(), order.is_triggered()));
2557            self.order_command_route(
2558                cmd.instrument_id,
2559                order_state,
2560                venue_binding.is_some_and(|(_, has_bound_child)| has_bound_child),
2561            )
2562        };
2563
2564        let mut command = cmd;
2565        command.venue_order_id = venue_binding
2566            .map(|(venue_order_id, _)| venue_order_id)
2567            .or(command.venue_order_id);
2568        if route == OrderCommandRoute::AlgoHttp {
2569            self.modify_algo_order(&command);
2570            return Ok(());
2571        }
2572
2573        self.ensure_order_identity(
2574            command.client_order_id,
2575            command.strategy_id,
2576            command.instrument_id,
2577        );
2578        let ws_private = self.ws_private.clone();
2579
2580        let new_px_usd = get_param_as_string(command.params.as_ref(), "px_usd");
2581        let new_px_vol = get_param_as_string(command.params.as_ref(), "px_vol");
2582        let rpi_taker_access = get_param_as_bool(command.params.as_ref(), "rpi_taker_access");
2583        let rpi_px_round = get_param_as_bool(command.params.as_ref(), "rpi_px_round");
2584
2585        let emitter = self.emitter.clone();
2586        let clock = self.clock;
2587
2588        self.spawn_task("modify_order", async move {
2589            let result = ws_private
2590                .modify_order_with_causation(
2591                    command.trader_id,
2592                    command.strategy_id,
2593                    command.instrument_id,
2594                    Some(command.client_order_id),
2595                    command.price,
2596                    command.quantity,
2597                    command.venue_order_id,
2598                    new_px_usd,
2599                    new_px_vol,
2600                    rpi_taker_access,
2601                    rpi_px_round,
2602                    Some(command.command_id),
2603                )
2604                .await;
2605
2606            if let Err(e) = result {
2607                emit_modify_failure(
2608                    classify_okx_ws_failure(&e),
2609                    &emitter,
2610                    clock,
2611                    command.strategy_id,
2612                    command.instrument_id,
2613                    command.client_order_id,
2614                    command.venue_order_id,
2615                    Some(command.command_id),
2616                );
2617                return Err(anyhow::Error::new(e).context("modify order failed"));
2618            }
2619
2620            Ok(())
2621        });
2622
2623        Ok(())
2624    }
2625
2626    fn cancel_order(&self, mut cmd: CancelOrder) -> anyhow::Result<()> {
2627        let venue_binding = self
2628            .ws_dispatch_state
2629            .order_venue_binding(cmd.client_order_id);
2630        let route = {
2631            let cache = self.core.cache();
2632            let order_state = cache
2633                .order(&cmd.client_order_id)
2634                .map(|order| (order.order_type(), order.is_triggered()));
2635            self.order_command_route(
2636                cmd.instrument_id,
2637                order_state,
2638                venue_binding.is_some_and(|(_, has_bound_child)| has_bound_child),
2639            )
2640        };
2641
2642        cmd.venue_order_id = venue_binding
2643            .map(|(venue_order_id, _)| venue_order_id)
2644            .or(cmd.venue_order_id);
2645
2646        match route {
2647            OrderCommandRoute::RegularWs => self.cancel_ws_order(&cmd),
2648            OrderCommandRoute::AlgoHttp => self.cancel_algo_order(&cmd),
2649            OrderCommandRoute::SpreadHttp => self.cancel_order_http(&cmd),
2650        }
2651        Ok(())
2652    }
2653
2654    fn cancel_all_orders(&self, cmd: CancelAllOrders) -> anyhow::Result<()> {
2655        match self.cancel_all_orders_route(cmd.instrument_id, cmd.order_side) {
2656            CancelAllOrdersRoute::SpreadHttp | CancelAllOrdersRoute::MassCancelHttp => {
2657                self.mass_cancel_instrument(cmd.instrument_id);
2658                Ok(())
2659            }
2660            CancelAllOrdersRoute::Batch => {
2661                let cancels: Vec<_> = {
2662                    let cache = self.core.cache();
2663                    cache
2664                        .orders_open(None, Some(&cmd.instrument_id), None, None, cmd.order_side)
2665                        .iter()
2666                        .map(|order| CancelOrder {
2667                            trader_id: order.trader_id(),
2668                            client_id: cmd.client_id,
2669                            strategy_id: order.strategy_id(),
2670                            instrument_id: order.instrument_id(),
2671                            client_order_id: order.client_order_id(),
2672                            venue_order_id: order.venue_order_id(),
2673                            command_id: cmd.command_id,
2674                            ts_init: cmd.ts_init,
2675                            params: cmd.params.clone(),
2676                            correlation_id: cmd.correlation_id,
2677                            causation_id: cmd.causation_id,
2678                        })
2679                        .collect()
2680                };
2681
2682                if cancels.is_empty() {
2683                    log::debug!("No open orders to cancel for {}", cmd.instrument_id);
2684                    return Ok(());
2685                }
2686
2687                self.batch_cancel_orders(BatchCancelOrders {
2688                    trader_id: cmd.trader_id,
2689                    client_id: cmd.client_id,
2690                    strategy_id: cmd.strategy_id,
2691                    instrument_id: cmd.instrument_id,
2692                    cancels,
2693                    command_id: cmd.command_id,
2694                    ts_init: cmd.ts_init,
2695                    params: cmd.params,
2696                    correlation_id: cmd.correlation_id,
2697                    causation_id: cmd.causation_id,
2698                })
2699            }
2700        }
2701    }
2702
2703    fn batch_cancel_orders(&self, cmd: BatchCancelOrders) -> anyhow::Result<()> {
2704        let cache = self.core.cache();
2705
2706        let mut regular_payload = Vec::new();
2707        let mut regular_causes = Vec::new();
2708        let mut algo_orders = Vec::new();
2709        let mut http_orders = Vec::new();
2710
2711        for cancel in &cmd.cancels {
2712            let order_state = cache
2713                .order(&cancel.client_order_id)
2714                .map(|order| (order.order_type(), order.is_triggered()));
2715
2716            let venue_binding = self
2717                .ws_dispatch_state
2718                .order_venue_binding(cancel.client_order_id);
2719            let authoritative_venue_order_id = venue_binding
2720                .map(|(venue_order_id, _)| venue_order_id)
2721                .or(cancel.venue_order_id);
2722
2723            match self.order_command_route(
2724                cancel.instrument_id,
2725                order_state,
2726                venue_binding.is_some_and(|(_, has_bound_child)| has_bound_child),
2727            ) {
2728                OrderCommandRoute::RegularWs => {
2729                    self.ensure_order_identity(
2730                        cancel.client_order_id,
2731                        cancel.strategy_id,
2732                        cancel.instrument_id,
2733                    );
2734                    regular_causes.push((cancel.client_order_id, cancel.command_id));
2735                    regular_payload.push((
2736                        cancel.instrument_id,
2737                        Some(cancel.client_order_id),
2738                        authoritative_venue_order_id,
2739                    ));
2740                }
2741                OrderCommandRoute::AlgoHttp => {
2742                    let mut cancel = cancel.clone();
2743                    cancel.venue_order_id = authoritative_venue_order_id;
2744                    algo_orders.push(cancel);
2745                }
2746                OrderCommandRoute::SpreadHttp => {
2747                    self.ensure_order_identity(
2748                        cancel.client_order_id,
2749                        cancel.strategy_id,
2750                        cancel.instrument_id,
2751                    );
2752                    http_orders.push((
2753                        cancel.client_order_id,
2754                        cancel.instrument_id,
2755                        cancel.strategy_id,
2756                        authoritative_venue_order_id,
2757                        cancel.command_id,
2758                    ));
2759                }
2760            }
2761        }
2762        drop(cache);
2763
2764        if !regular_payload.is_empty() {
2765            let ws_private = self.ws_private.clone();
2766            let state = Arc::clone(&self.ws_dispatch_state);
2767            let emitter = self.emitter.clone();
2768            let clock = self.clock;
2769            self.spawn_task("batch_cancel_orders", async move {
2770                let mut offset = 0;
2771                while offset < regular_payload.len() {
2772                    let end = offset + cancel_batch_len(&regular_causes[offset..]);
2773                    let batch = &regular_payload[offset..end];
2774                    let causes = regular_causes[offset..end].to_vec();
2775
2776                    if let Err(e) = ws_private
2777                        .batch_cancel_orders_with_causation(batch.to_vec(), causes)
2778                        .await
2779                    {
2780                        let failure = classify_okx_ws_failure(&e);
2781
2782                        if matches!(failure, CommandFailure::NotSent(_)) {
2783                            for ((_, client_order_id, venue_order_id), (_, command_id)) in
2784                                regular_payload[offset..]
2785                                    .iter()
2786                                    .zip(&regular_causes[offset..])
2787                            {
2788                                let Some(client_order_id) = client_order_id else {
2789                                    continue;
2790                                };
2791
2792                                emit_send_failed_cancel(
2793                                    &failure,
2794                                    &state,
2795                                    &emitter,
2796                                    clock,
2797                                    *client_order_id,
2798                                    *venue_order_id,
2799                                    Some(*command_id),
2800                                );
2801                            }
2802                        } else {
2803                            log_batch_cancel_failure(failure, batch.len());
2804                        }
2805
2806                        return Err(anyhow::Error::new(e).context("batch cancel orders failed"));
2807                    }
2808
2809                    offset = end;
2810                }
2811                Ok(())
2812            });
2813        }
2814
2815        // OKX doesn't support algo cancel via private WebSocket, must use HTTP
2816        if !algo_orders.is_empty() {
2817            let items: Vec<_> = algo_orders
2818                .into_iter()
2819                .map(|cancel| {
2820                    let request = OKXCancelAlgoOrderRequest {
2821                        inst_id: cancel.instrument_id.symbol.to_string(),
2822                        inst_id_code: None,
2823                        algo_id: cancel.venue_order_id.map(|id| id.to_string()),
2824                        algo_cl_ord_id: if cancel.venue_order_id.is_none() {
2825                            Some(cancel.client_order_id.to_string())
2826                        } else {
2827                            None
2828                        },
2829                    };
2830                    let ctx = AlgoCancelContext {
2831                        causation_id: Some(cancel.command_id),
2832                        client_order_id: cancel.client_order_id,
2833                        instrument_id: cancel.instrument_id,
2834                        strategy_id: cancel.strategy_id,
2835                        venue_order_id: cancel.venue_order_id,
2836                    };
2837                    (request, ctx)
2838                })
2839                .collect();
2840            self.dispatch_algo_cancels(items);
2841        }
2842
2843        if !http_orders.is_empty() {
2844            let client = self.http_client.clone();
2845            let emitter = self.emitter.clone();
2846            let clock = self.clock;
2847
2848            self.spawn_task("cancel_http_orders", async move {
2849                for (client_order_id, instrument_id, strategy_id, venue_order_id, command_id) in
2850                    http_orders
2851                {
2852                    if let Err(e) = client
2853                        .cancel_order(instrument_id, Some(client_order_id), venue_order_id)
2854                        .await
2855                    {
2856                        emit_cancel_failure(
2857                            classify_okx_http_failure(&e),
2858                            Some((&emitter, clock)),
2859                            client_order_id,
2860                            instrument_id,
2861                            strategy_id,
2862                            venue_order_id,
2863                            Some(command_id),
2864                        );
2865                    }
2866                }
2867
2868                Ok(())
2869            });
2870        }
2871
2872        Ok(())
2873    }
2874}
2875
2876const MAX_TRIGGERED_CHILD_RECOVERIES: usize = 100;
2877
2878struct OrderReportSweep {
2879    fallback_parents: AHashMap<usize, OrderStatusReport>,
2880    reports: Vec<OrderStatusReport>,
2881    complete: bool,
2882    ambiguous_triggered_child_ids: AHashSet<VenueOrderId>,
2883    regular_by_venue_order_id: AHashMap<VenueOrderId, OrderStatusReport>,
2884}
2885
2886impl OKXExecutionClient {
2887    fn order_position_side(
2888        &self,
2889        order: &impl Order,
2890        params: Option<&Params>,
2891    ) -> Option<PositionSide> {
2892        if self.position_mode != OKXPositionMode::LongShortMode
2893            || !matches!(
2894                okx_instrument_type_from_symbol(order.instrument_id().symbol.as_str()),
2895                OKXInstrumentType::Swap | OKXInstrumentType::Futures
2896            )
2897        {
2898            return None;
2899        }
2900
2901        let is_closing = order.is_reduce_only()
2902            || (self.is_conditional_order(order.order_type())
2903                && get_param_as_string(params, "close_fraction").is_some());
2904
2905        Some(match (order.order_side(), is_closing) {
2906            (OrderSide::Buy, false) | (OrderSide::Sell, true) => PositionSide::Long,
2907            (OrderSide::Sell, false) | (OrderSide::Buy, true) => PositionSide::Short,
2908        })
2909    }
2910
2911    fn validate_order(
2912        &self,
2913        order: &impl Order,
2914        trade_mode: OKXTradeMode,
2915        submission: OrderSubmission,
2916        params: Option<&Params>,
2917    ) -> Result<(), OrderDeniedReason> {
2918        if let Err(detail) = validate_okx_client_order_id(order.client_order_id().as_str()) {
2919            return Err(OrderDeniedReason::InvalidClientOrderId { detail });
2920        }
2921
2922        let is_spread = self.http_client.is_spread(order.instrument_id());
2923        if is_spread && order.is_reduce_only() {
2924            return Err(OrderDeniedReason::UnsupportedReduceOnly);
2925        }
2926
2927        okx_algo_target_currency(
2928            okx_instrument_type_from_symbol(order.instrument_id().symbol.as_str()),
2929            trade_mode,
2930            order.order_side(),
2931            order.order_type(),
2932            order.is_quote_quantity(),
2933        )?;
2934
2935        validate_algo_trigger_type(
2936            okx_instrument_type_from_symbol(order.instrument_id().symbol.as_str()),
2937            trade_mode,
2938            order.order_type(),
2939            order.trigger_type(),
2940        )
2941        .map_err(|detail| OrderDeniedReason::ValidationFailed { detail })?;
2942
2943        if order.is_reduce_only()
2944            && okx_reduce_only_wire_value(
2945                okx_instrument_type_from_symbol(order.instrument_id().symbol.as_str()),
2946                trade_mode,
2947                order.order_side(),
2948                None,
2949                Some(true),
2950            )
2951            .is_err()
2952        {
2953            return Err(OrderDeniedReason::UnsupportedReduceOnly);
2954        }
2955
2956        if matches!(submission, OrderSubmission::List) {
2957            if OKX_CONDITIONAL_ORDER_TYPES.contains(&order.order_type()) {
2958                return Err(OrderDeniedReason::UnsupportedOrderList {
2959                    detail: format!(
2960                        "conditional order {} is not supported",
2961                        order.client_order_id()
2962                    ),
2963                });
2964            }
2965
2966            if order.time_in_force() != TimeInForce::Gtc {
2967                return Err(OrderDeniedReason::UnsupportedOrderList {
2968                    detail: format!(
2969                        "order {} has unsupported time in force {}",
2970                        order.client_order_id(),
2971                        order.time_in_force()
2972                    ),
2973                });
2974            }
2975        }
2976
2977        if !is_spread && !OKX_CONDITIONAL_ORDER_TYPES.contains(&order.order_type()) {
2978            let instrument = self
2979                .http_client
2980                .get_instrument(&order.instrument_id().symbol.inner());
2981
2982            validate_limit_price(order, instrument.as_ref(), submission, params)?;
2983
2984            let instrument_type = instrument
2985                .as_ref()
2986                .map(okx_instrument_type)
2987                .transpose()
2988                .map_err(|e| OrderDeniedReason::ValidationFailed {
2989                    detail: e.to_string(),
2990                })?
2991                .unwrap_or_else(|| {
2992                    okx_instrument_type_from_symbol(order.instrument_id().symbol.as_str())
2993                });
2994
2995            let outcome = get_param_as_string(params, "outcome");
2996            validate_order_time_in_force(Some(order.time_in_force()))
2997                .and_then(|()| {
2998                    validate_regular_order_params(
2999                        instrument_type,
3000                        order.order_type(),
3001                        Some(order.time_in_force()),
3002                        order.is_post_only(),
3003                        get_param_as_bool(params, "rpi").unwrap_or(false),
3004                        outcome.as_deref(),
3005                    )
3006                })
3007                .map_err(|detail| OrderDeniedReason::ValidationFailed { detail })?;
3008        }
3009
3010        Ok(())
3011    }
3012
3013    fn validate_trade_mode(
3014        &self,
3015        instrument_id: InstrumentId,
3016        position_side: Option<PositionSide>,
3017        trade_mode: OKXTradeMode,
3018    ) -> Result<(), OrderDeniedReason> {
3019        if okx_instrument_type_from_symbol(instrument_id.symbol.as_str())
3020            == OKXInstrumentType::Events
3021            && trade_mode != OKXTradeMode::Isolated
3022        {
3023            return Err(OrderDeniedReason::ValidationFailed {
3024                detail: "OKX event contracts require isolated trade mode".to_string(),
3025            });
3026        }
3027
3028        if position_side.is_some() {
3029            let expected = derive_trade_mode_for_instrument(
3030                instrument_id,
3031                self.config.margin_mode,
3032                self.config.uses_spot_margin(),
3033            );
3034
3035            if trade_mode != expected {
3036                return Err(OrderDeniedReason::ValidationFailed {
3037                    detail: format!(
3038                        "OKX long/short mode requires configured trade mode {expected}, received {trade_mode}; mixed margin modes are not supported"
3039                    ),
3040                });
3041            }
3042        }
3043
3044        Ok(())
3045    }
3046
3047    fn add_flat_derivative_position_reports(
3048        &self,
3049        order_reports: &[OrderStatusReport],
3050        fill_reports: &[FillReport],
3051        position_reports: &mut Vec<PositionStatusReport>,
3052        ts_init: UnixNanos,
3053    ) {
3054        let mut instrument_ids: AHashSet<InstrumentId> = order_reports
3055            .iter()
3056            .map(|report| report.instrument_id)
3057            .chain(fill_reports.iter().map(|report| report.instrument_id))
3058            .collect();
3059        let instrument_types = self.instrument_types();
3060        let mut hedging_instrument_ids = AHashSet::new();
3061        let mut hedging_positions = AHashMap::new();
3062
3063        if self.position_mode == OKXPositionMode::LongShortMode {
3064            for (instrument_id, position_id, precision) in order_reports
3065                .iter()
3066                .map(|report| {
3067                    (
3068                        report.instrument_id,
3069                        report.venue_position_id,
3070                        report.quantity.precision,
3071                    )
3072                })
3073                .chain(fill_reports.iter().map(|report| {
3074                    (
3075                        report.instrument_id,
3076                        report.venue_position_id,
3077                        report.last_qty.precision,
3078                    )
3079                }))
3080            {
3081                if let Some(position_id) = position_id {
3082                    hedging_positions.insert((instrument_id, position_id), precision);
3083                }
3084            }
3085        }
3086
3087        {
3088            let cache = self.core.cache();
3089            for position in cache.positions_open(
3090                Some(&OKX_VENUE),
3091                None,
3092                None,
3093                Some(&self.core.account_id),
3094                None,
3095            ) {
3096                instrument_ids.insert(position.instrument_id);
3097                if cache.oms_type(&position.id) == Some(OmsType::Hedging) {
3098                    hedging_instrument_ids.insert(position.instrument_id);
3099                }
3100
3101                if self.position_mode == OKXPositionMode::LongShortMode
3102                    && instrument_types.contains(&okx_instrument_type_from_symbol(
3103                        position.instrument_id.symbol.as_str(),
3104                    ))
3105                    && [OKXPositionSide::Long, OKXPositionSide::Short]
3106                        .iter()
3107                        .any(|side| {
3108                            venue_position_id(position.instrument_id, *side) == Some(position.id)
3109                        })
3110                {
3111                    hedging_positions.insert(
3112                        (position.instrument_id, position.id),
3113                        position.quantity.precision,
3114                    );
3115                }
3116            }
3117        }
3118
3119        for ((instrument_id, position_id), precision) in hedging_positions {
3120            if !position_reports.iter().any(|report| {
3121                report.instrument_id == instrument_id
3122                    && report.venue_position_id == Some(position_id)
3123            }) {
3124                position_reports.push(PositionStatusReport::new(
3125                    self.core.account_id,
3126                    instrument_id,
3127                    PositionSide::Flat,
3128                    Quantity::zero(precision),
3129                    ts_init,
3130                    ts_init,
3131                    None,
3132                    Some(position_id),
3133                    None,
3134                ));
3135            }
3136        }
3137
3138        instrument_ids.retain(|instrument_id| {
3139            if self.http_client.is_spread(*instrument_id)
3140                || hedging_instrument_ids.contains(instrument_id)
3141                || position_reports
3142                    .iter()
3143                    .any(|report| report.instrument_id == *instrument_id)
3144            {
3145                return false;
3146            }
3147
3148            match okx_instrument_type_from_symbol(instrument_id.symbol.as_str()) {
3149                OKXInstrumentType::Swap | OKXInstrumentType::Futures => {
3150                    self.position_mode != OKXPositionMode::LongShortMode
3151                }
3152                OKXInstrumentType::Option => true,
3153                _ => false,
3154            }
3155        });
3156
3157        for instrument_id in instrument_ids {
3158            // A successful OKX positions snapshot omits flat rows
3159            position_reports.push(PositionStatusReport::new(
3160                self.core.account_id,
3161                instrument_id,
3162                PositionSide::Flat,
3163                Quantity::zero(0),
3164                ts_init,
3165                ts_init,
3166                None,
3167                None,
3168                None,
3169            ));
3170        }
3171    }
3172
3173    async fn recover_triggered_child_order_reports(
3174        &self,
3175        reports: &mut Vec<OrderStatusReport>,
3176        ambiguous_triggered_child_ids: &AHashSet<VenueOrderId>,
3177        regular_by_venue_order_id: &AHashMap<VenueOrderId, OrderStatusReport>,
3178    ) -> anyhow::Result<bool> {
3179        let mut fallback_parents = AHashMap::new();
3180        let complete = self
3181            .report_client()
3182            .recover_triggered_child_order_reports(
3183                reports,
3184                ambiguous_triggered_child_ids,
3185                regular_by_venue_order_id,
3186                &mut fallback_parents,
3187            )
3188            .await?;
3189        retain_external_regular_order_fallbacks(&self.core, reports, &fallback_parents);
3190        Ok(complete)
3191    }
3192}
3193
3194struct ReportContext {
3195    core: ExecutionClientCore,
3196    http_client: OKXHttpClient,
3197    ws_private: OKXWebSocketClient,
3198    ws_business: OKXWebSocketClient,
3199}
3200
3201impl ReportContext {
3202    fn register(&self, instrument_ids: impl IntoIterator<Item = InstrumentId>) {
3203        let mut seen = AHashSet::new();
3204        for instrument_id in instrument_ids {
3205            if !seen.insert(instrument_id) {
3206                continue;
3207            }
3208
3209            let Some(instrument) = self.cache_instrument(instrument_id) else {
3210                continue;
3211            };
3212
3213            let cached = self.core.cache().instrument(&instrument_id).is_some();
3214            if !cached {
3215                let endpoint = MessagingSwitchboard::data_engine_process_data();
3216                msgbus::send_data(endpoint, instrument.into());
3217            }
3218        }
3219    }
3220
3221    fn cache_instrument(&self, instrument_id: InstrumentId) -> Option<InstrumentAny> {
3222        let instrument = self
3223            .http_client
3224            .get_instrument(&instrument_id.symbol.inner())?;
3225        let symbol = instrument_id.symbol.inner();
3226        for ws_client in [&self.ws_private, &self.ws_business] {
3227            if !ws_client.instruments_cache_arc().contains_key(&symbol) {
3228                ws_client.cache_instrument(instrument.clone());
3229            }
3230
3231            if let Some(code) = self.http_client.inst_id_code(&symbol)
3232                && ws_client.get_inst_id_code(&symbol) != Some(code)
3233            {
3234                ws_client.cache_inst_id_code(symbol, code);
3235            }
3236        }
3237
3238        Some(instrument)
3239    }
3240}
3241
3242struct OKXReportClient {
3243    account_id: AccountId,
3244    http_client: OKXHttpClient,
3245    instrument_types: Vec<OKXInstrumentType>,
3246    spot_positions_quote_currency: Option<Ustr>,
3247    recover_inst_id_codes: bool,
3248    load_spreads: bool,
3249    margin_mode: Option<OKXMarginMode>,
3250}
3251
3252impl OKXReportClient {
3253    async fn generate_order_status_report(
3254        &self,
3255        cmd: &GenerateOrderStatusReport,
3256        order_state: Option<CachedQueryOrderState>,
3257    ) -> anyhow::Result<Option<OrderStatusReport>> {
3258        let Some(instrument_id) = cmd.instrument_id else {
3259            anyhow::bail!("generate_order_status_report requires instrument_id");
3260        };
3261
3262        if cmd.client_order_id.is_none() && cmd.venue_order_id.is_none() {
3263            anyhow::bail!(
3264                "generate_order_status_report requires client_order_id or venue_order_id"
3265            );
3266        }
3267
3268        self.http_client.resolve_instrument(instrument_id).await?;
3269        self.prepare_inst_id_codes(AHashSet::from_iter([instrument_id]))
3270            .await?;
3271
3272        let cached_venue_order_id = order_state.and_then(|state| state.venue_order_id);
3273
3274        let regular_venue_order_id = order_state.and_then(|state| {
3275            if OKX_CONDITIONAL_ORDER_TYPES.contains(&state.order_type) {
3276                state.venue_order_id.or(cmd.venue_order_id)
3277            } else {
3278                state.venue_order_id
3279            }
3280        });
3281
3282        let selection_venue_order_id = cached_venue_order_id.or(cmd.venue_order_id);
3283        let route = query_order_route(
3284            instrument_id,
3285            order_state.map(|state| state.order_type),
3286            regular_venue_order_id.is_some(),
3287            self.http_client.is_spread(instrument_id),
3288        );
3289
3290        let mut reports = Vec::with_capacity(1);
3291        let mut query_algo = matches!(
3292            route,
3293            QueryOrderRoute::Algo | QueryOrderRoute::RegularAndAlgo
3294        );
3295        let mut lookup_error = None;
3296
3297        match route {
3298            QueryOrderRoute::Spread => {
3299                let targeted_venue_order_id =
3300                    cmd.venue_order_id.filter(|_| cmd.client_order_id.is_none());
3301
3302                match self
3303                    .http_client
3304                    .request_spread_order_status_report(
3305                        self.account_id,
3306                        instrument_id,
3307                        cmd.client_order_id,
3308                        targeted_venue_order_id,
3309                    )
3310                    .await
3311                {
3312                    Ok(Some(report)) => reports.push(report),
3313                    Ok(None) => {}
3314                    Err(e) => lookup_error = Some(e),
3315                }
3316            }
3317            QueryOrderRoute::Regular | QueryOrderRoute::RegularThenAlgo => {
3318                let targeted_venue_order_id = regular_venue_order_id
3319                    .or(cmd.venue_order_id.filter(|_| cmd.client_order_id.is_none()));
3320
3321                let result = if let Some(venue_order_id) = targeted_venue_order_id {
3322                    self.http_client
3323                        .request_order_status_report_by_venue_order_id(
3324                            self.account_id,
3325                            instrument_id,
3326                            venue_order_id,
3327                        )
3328                        .await
3329                } else if let Some(client_order_id) = cmd.client_order_id {
3330                    self.http_client
3331                        .request_order_status_report(
3332                            self.account_id,
3333                            instrument_id,
3334                            client_order_id,
3335                        )
3336                        .await
3337                } else {
3338                    anyhow::bail!(
3339                        "generate_order_status_report requires client_order_id or venue_order_id"
3340                    );
3341                };
3342
3343                match result {
3344                    Ok(Some(report)) => reports.push(report),
3345                    Ok(None) => {
3346                        query_algo |= route == QueryOrderRoute::RegularThenAlgo;
3347                    }
3348                    Err(e) => {
3349                        lookup_error = Some(e);
3350                        query_algo |= route == QueryOrderRoute::RegularThenAlgo;
3351                    }
3352                }
3353            }
3354            QueryOrderRoute::Algo | QueryOrderRoute::RegularAndAlgo => {}
3355        }
3356
3357        if query_algo {
3358            let (algo_id, algo_client_order_id) = match cmd.client_order_id {
3359                Some(client_order_id) => (None, Some(client_order_id)),
3360                None => (cmd.venue_order_id.map(|id| id.as_str().to_string()), None),
3361            };
3362
3363            match self
3364                .http_client
3365                .request_algo_order_status_reports(
3366                    self.account_id,
3367                    None,
3368                    Some(instrument_id),
3369                    algo_id,
3370                    algo_client_order_id,
3371                    None,
3372                    Some(1),
3373                )
3374                .await
3375            {
3376                Ok(algo_reports) => merge_order_status_reports(&mut reports, algo_reports),
3377                Err(e) => {
3378                    if lookup_error.is_none() {
3379                        lookup_error = Some(e);
3380                    }
3381                }
3382            }
3383        }
3384
3385        if reports.is_empty() {
3386            if let Some(e) = lookup_error {
3387                return Err(e);
3388            }
3389
3390            return Ok(None);
3391        }
3392
3393        if let Some(client_order_id) = cmd.client_order_id {
3394            Ok(select_query_order_report(
3395                reports,
3396                client_order_id,
3397                selection_venue_order_id,
3398            ))
3399        } else {
3400            Ok(Some(reports.remove(0)))
3401        }
3402    }
3403
3404    fn instrument_types(instrument_types: &[OKXInstrumentType]) -> Vec<OKXInstrumentType> {
3405        if instrument_types.is_empty() {
3406            vec![OKXInstrumentType::Spot]
3407        } else {
3408            instrument_types.to_vec()
3409        }
3410    }
3411
3412    fn report_scope<'a>(
3413        &'a self,
3414        instrument_types: &'a [OKXInstrumentType],
3415    ) -> ReportInstrumentScope<'a> {
3416        ReportInstrumentScope {
3417            instrument_types,
3418            load_spreads: self.load_spreads,
3419            margin_mode: self.margin_mode,
3420        }
3421    }
3422
3423    async fn collect_order_status_reports(
3424        &self,
3425        cmd: &GenerateOrderStatusReports,
3426        max_history_pages: Option<u32>,
3427    ) -> anyhow::Result<OrderReportSweep> {
3428        let instrument_types = Self::instrument_types(&self.instrument_types);
3429        let routing_types = order_routing_instrument_types(&instrument_types);
3430        let scope = self.report_scope(&routing_types);
3431        let start = nanos_to_datetime(cmd.start);
3432        let end = nanos_to_datetime(cmd.end);
3433        let mut reports = Vec::new();
3434        let mut regular_by_venue_order_id = AHashMap::new();
3435        let mut ambiguous_triggered_child_ids = AHashSet::new();
3436        let mut complete = true;
3437
3438        if let Some(instrument_id) = cmd.instrument_id {
3439            let sweep = self
3440                .http_client
3441                .request_order_status_reports_scoped(
3442                    self.account_id,
3443                    None,
3444                    Some(instrument_id),
3445                    start,
3446                    end,
3447                    cmd.open_only,
3448                    None,
3449                    true,
3450                    Some(scope),
3451                    max_history_pages,
3452                )
3453                .await?;
3454
3455            regular_by_venue_order_id.extend(
3456                sweep
3457                    .reports
3458                    .iter()
3459                    .map(|report| (report.venue_order_id, report.clone())),
3460            );
3461
3462            reports.extend(sweep.reports);
3463            complete &= sweep.complete;
3464
3465            if !self.http_client.is_spread(instrument_id)
3466                && supports_algo_orders(okx_instrument_type_from_symbol(
3467                    instrument_id.symbol.as_str(),
3468                ))
3469            {
3470                let sweep = self
3471                    .http_client
3472                    .request_algo_order_status_reports_sweep(
3473                        self.account_id,
3474                        None,
3475                        Some(instrument_id),
3476                        None,
3477                        None,
3478                        None,
3479                        None,
3480                        start,
3481                        end,
3482                        true,
3483                        max_history_pages,
3484                    )
3485                    .await?;
3486                merge_algo_order_status_reports(
3487                    &mut reports,
3488                    sweep,
3489                    &mut ambiguous_triggered_child_ids,
3490                    &mut complete,
3491                );
3492            }
3493        } else {
3494            for inst_type in &routing_types {
3495                let sweep = self
3496                    .http_client
3497                    .request_order_status_reports_scoped(
3498                        self.account_id,
3499                        Some(*inst_type),
3500                        None,
3501                        start,
3502                        end,
3503                        cmd.open_only,
3504                        None,
3505                        true,
3506                        Some(scope),
3507                        max_history_pages,
3508                    )
3509                    .await?;
3510
3511                regular_by_venue_order_id.extend(
3512                    sweep
3513                        .reports
3514                        .iter()
3515                        .map(|report| (report.venue_order_id, report.clone())),
3516                );
3517
3518                reports.extend(sweep.reports);
3519                complete &= sweep.complete;
3520
3521                if supports_algo_orders(*inst_type) {
3522                    let sweep = self
3523                        .http_client
3524                        .request_algo_order_status_reports_sweep(
3525                            self.account_id,
3526                            Some(*inst_type),
3527                            None,
3528                            None,
3529                            None,
3530                            None,
3531                            None,
3532                            start,
3533                            end,
3534                            true,
3535                            max_history_pages,
3536                        )
3537                        .await?;
3538                    merge_algo_order_status_reports(
3539                        &mut reports,
3540                        sweep,
3541                        &mut ambiguous_triggered_child_ids,
3542                        &mut complete,
3543                    );
3544                }
3545            }
3546        }
3547
3548        if cmd.instrument_id.is_none() && self.load_spreads {
3549            let sweep = self
3550                .http_client
3551                .request_order_status_reports_scoped(
3552                    self.account_id,
3553                    None,
3554                    None,
3555                    start,
3556                    end,
3557                    cmd.open_only,
3558                    None,
3559                    true,
3560                    Some(scope),
3561                    max_history_pages,
3562                )
3563                .await?;
3564            reports.extend(sweep.reports);
3565            complete &= sweep.complete;
3566        }
3567
3568        let mut fallback_parents = AHashMap::new();
3569
3570        if cmd.open_only {
3571            complete &= self
3572                .recover_triggered_child_order_reports(
3573                    &mut reports,
3574                    &ambiguous_triggered_child_ids,
3575                    &regular_by_venue_order_id,
3576                    &mut fallback_parents,
3577                )
3578                .await?;
3579        }
3580
3581        let instrument_ids = reports
3582            .iter()
3583            .filter(|report| report.order_status.is_open())
3584            .map(|report| report.instrument_id)
3585            .collect();
3586        self.prepare_inst_id_codes(instrument_ids).await?;
3587
3588        Ok(OrderReportSweep {
3589            fallback_parents,
3590            reports,
3591            complete,
3592            ambiguous_triggered_child_ids,
3593            regular_by_venue_order_id,
3594        })
3595    }
3596
3597    async fn collect_fill_reports(
3598        &self,
3599        cmd: GenerateFillReports,
3600        history: FillHistory,
3601        max_history_pages: Option<u32>,
3602    ) -> anyhow::Result<(Vec<FillReport>, bool)> {
3603        let instrument_types = Self::instrument_types(&self.instrument_types);
3604        let routing_types = order_routing_instrument_types(&instrument_types);
3605        let scope = self.report_scope(&routing_types);
3606        let start_dt = nanos_to_datetime(cmd.start);
3607        let end_dt = nanos_to_datetime(cmd.end);
3608        let mut reports = Vec::new();
3609        let mut complete = true;
3610
3611        if let Some(instrument_id) = cmd.instrument_id {
3612            let sweep = self
3613                .http_client
3614                .request_fill_reports_scoped(
3615                    self.account_id,
3616                    None,
3617                    Some(instrument_id),
3618                    start_dt,
3619                    end_dt,
3620                    None,
3621                    history,
3622                    Some(scope),
3623                    max_history_pages,
3624                )
3625                .await?;
3626            reports.extend(sweep.reports);
3627            complete &= sweep.complete;
3628        } else {
3629            for inst_type in &routing_types {
3630                let sweep = self
3631                    .http_client
3632                    .request_fill_reports_scoped(
3633                        self.account_id,
3634                        Some(*inst_type),
3635                        None,
3636                        start_dt,
3637                        end_dt,
3638                        None,
3639                        history,
3640                        Some(scope),
3641                        max_history_pages,
3642                    )
3643                    .await?;
3644                reports.extend(sweep.reports);
3645                complete &= sweep.complete;
3646            }
3647
3648            if self.load_spreads {
3649                let sweep = self
3650                    .http_client
3651                    .request_fill_reports_scoped(
3652                        self.account_id,
3653                        None,
3654                        None,
3655                        start_dt,
3656                        end_dt,
3657                        None,
3658                        history,
3659                        Some(scope),
3660                        max_history_pages,
3661                    )
3662                    .await?;
3663                reports.extend(sweep.reports);
3664                complete &= sweep.complete;
3665            }
3666        }
3667
3668        if let Some(venue_order_id) = cmd.venue_order_id {
3669            reports.retain(|report| report.venue_order_id.as_str() == venue_order_id.as_str());
3670        }
3671
3672        Ok((reports, complete))
3673    }
3674
3675    async fn collect_position_status_reports(
3676        &self,
3677        cmd: &GeneratePositionStatusReports,
3678    ) -> anyhow::Result<(Vec<PositionStatusReport>, bool)> {
3679        let instrument_types = Self::instrument_types(&self.instrument_types);
3680        let scope = self.report_scope(&instrument_types);
3681        let mut reports = Vec::new();
3682        let mut complete = true;
3683
3684        if let Some(instrument_id) = cmd.instrument_id {
3685            if self.http_client.is_spread(instrument_id) {
3686                return Ok((reports, complete));
3687            }
3688
3689            let inst_type = okx_instrument_type_from_symbol(instrument_id.symbol.as_str());
3690            if inst_type != OKXInstrumentType::Spot && inst_type != OKXInstrumentType::Margin {
3691                let sweep = self
3692                    .http_client
3693                    .request_position_status_reports_scoped(
3694                        self.account_id,
3695                        None,
3696                        Some(instrument_id),
3697                        Some(scope),
3698                    )
3699                    .await?;
3700                reports.extend(sweep.reports);
3701                complete &= sweep.complete;
3702            }
3703        } else {
3704            for inst_type in &instrument_types {
3705                if *inst_type == OKXInstrumentType::Spot || *inst_type == OKXInstrumentType::Margin
3706                {
3707                    continue;
3708                }
3709
3710                let sweep = self
3711                    .http_client
3712                    .request_position_status_reports_scoped(
3713                        self.account_id,
3714                        Some(*inst_type),
3715                        None,
3716                        Some(scope),
3717                    )
3718                    .await?;
3719                reports.extend(sweep.reports);
3720                complete &= sweep.complete;
3721            }
3722        }
3723
3724        if let Some(quote_currency) = self.spot_positions_quote_currency {
3725            reports.extend(
3726                self.http_client
3727                    .request_spot_position_reports(
3728                        self.account_id,
3729                        cmd.instrument_id,
3730                        quote_currency,
3731                    )
3732                    .await?,
3733            );
3734        }
3735
3736        let instrument_ids = reports.iter().map(|report| report.instrument_id).collect();
3737        self.prepare_inst_id_codes(instrument_ids).await?;
3738
3739        Ok((reports, complete))
3740    }
3741
3742    async fn prepare_inst_id_codes(
3743        &self,
3744        instrument_ids: AHashSet<InstrumentId>,
3745    ) -> anyhow::Result<()> {
3746        if !self.recover_inst_id_codes {
3747            return Ok(());
3748        }
3749
3750        for instrument_id in instrument_ids {
3751            prepare_inst_id_code(&self.http_client, instrument_id).await?;
3752        }
3753
3754        Ok(())
3755    }
3756
3757    async fn recover_triggered_child_order_reports(
3758        &self,
3759        reports: &mut Vec<OrderStatusReport>,
3760        ambiguous_triggered_child_ids: &AHashSet<VenueOrderId>,
3761        regular_by_venue_order_id: &AHashMap<VenueOrderId, OrderStatusReport>,
3762        fallback_parents: &mut AHashMap<usize, OrderStatusReport>,
3763    ) -> anyhow::Result<bool> {
3764        let mut recovered = Vec::with_capacity(reports.len());
3765        let recovery_candidate_count = reports
3766            .iter()
3767            .filter(|report| {
3768                report.order_status == OrderStatus::Triggered
3769                    && !ambiguous_triggered_child_ids.contains(&report.venue_order_id)
3770            })
3771            .count();
3772        let mut complete = true;
3773
3774        if recovery_candidate_count > MAX_TRIGGERED_CHILD_RECOVERIES {
3775            log::warn!(
3776                "Triggered child recovery hit {MAX_TRIGGERED_CHILD_RECOVERIES} request cap; omitting unresolved reports"
3777            );
3778        }
3779
3780        let mut request_count = 0;
3781
3782        for mut parent_report in reports.drain(..) {
3783            if parent_report.order_status != OrderStatus::Triggered {
3784                recovered.push(parent_report);
3785                continue;
3786            }
3787
3788            if ambiguous_triggered_child_ids.contains(&parent_report.venue_order_id) {
3789                log::warn!(
3790                    "Omitting triggered algo order with ambiguous child identifiers: {} {}",
3791                    parent_report.instrument_id,
3792                    parent_report.venue_order_id,
3793                );
3794                self.push_external_regular_order_fallback(
3795                    &parent_report,
3796                    regular_by_venue_order_id,
3797                    &mut recovered,
3798                    fallback_parents,
3799                );
3800                complete = false;
3801                continue;
3802            }
3803
3804            if request_count >= MAX_TRIGGERED_CHILD_RECOVERIES {
3805                self.push_external_regular_order_fallback(
3806                    &parent_report,
3807                    regular_by_venue_order_id,
3808                    &mut recovered,
3809                    fallback_parents,
3810                );
3811                complete = false;
3812                continue;
3813            }
3814            request_count += 1;
3815
3816            match self
3817                .http_client
3818                .request_order_status_report_by_venue_order_id(
3819                    self.account_id,
3820                    parent_report.instrument_id,
3821                    parent_report.venue_order_id,
3822                )
3823                .await
3824            {
3825                Ok(Some(mut child_report)) => {
3826                    if child_report.order_status == OrderStatus::Accepted {
3827                        parent_report.quantity = child_report.quantity;
3828                        parent_report.price = child_report.price.or(parent_report.price);
3829                        parent_report.reduce_only |= child_report.reduce_only;
3830                        parent_report.ts_last = child_report.ts_last;
3831                        recovered.push(parent_report);
3832                    } else {
3833                        child_report.client_order_id = parent_report.client_order_id;
3834                        recovered.push(child_report);
3835                    }
3836                }
3837                Ok(None) => {
3838                    log::warn!(
3839                        "Triggered child order {} {} was not found",
3840                        parent_report.instrument_id,
3841                        parent_report.venue_order_id,
3842                    );
3843                    self.push_external_regular_order_fallback(
3844                        &parent_report,
3845                        regular_by_venue_order_id,
3846                        &mut recovered,
3847                        fallback_parents,
3848                    );
3849                    complete = false;
3850                }
3851                Err(e) if e.downcast_ref::<OKXActiveOrderReportError>().is_some() => {
3852                    return Err(e);
3853                }
3854                Err(e) => {
3855                    log::warn!(
3856                        "Failed to recover triggered child order {} {}: {e}",
3857                        parent_report.instrument_id,
3858                        parent_report.venue_order_id,
3859                    );
3860                    self.push_external_regular_order_fallback(
3861                        &parent_report,
3862                        regular_by_venue_order_id,
3863                        &mut recovered,
3864                        fallback_parents,
3865                    );
3866                    complete = false;
3867                }
3868            }
3869        }
3870
3871        *reports = recovered;
3872        Ok(complete)
3873    }
3874
3875    fn push_external_regular_order_fallback(
3876        &self,
3877        parent_report: &OrderStatusReport,
3878        regular_by_venue_order_id: &AHashMap<VenueOrderId, OrderStatusReport>,
3879        recovered: &mut Vec<OrderStatusReport>,
3880        fallback_parents: &mut AHashMap<usize, OrderStatusReport>,
3881    ) {
3882        if let Some(regular_report) = regular_by_venue_order_id.get(&parent_report.venue_order_id) {
3883            fallback_parents.insert(recovered.len(), parent_report.clone());
3884            recovered.push(regular_report.clone());
3885        }
3886    }
3887}
3888
3889fn finish_order_report_sweep(
3890    core: &ExecutionClientCore,
3891    mut sweep: OrderReportSweep,
3892    command: &GenerateOrderStatusReports,
3893) -> OrderReportSweep {
3894    retain_external_regular_order_fallbacks(core, &mut sweep.reports, &sweep.fallback_parents);
3895    sweep.fallback_parents.clear();
3896    retain_order_status_reports(&mut sweep.reports, command);
3897    sweep
3898}
3899
3900fn retain_external_regular_order_fallbacks(
3901    core: &ExecutionClientCore,
3902    reports: &mut Vec<OrderStatusReport>,
3903    fallback_parents: &AHashMap<usize, OrderStatusReport>,
3904) {
3905    if fallback_parents.is_empty() {
3906        return;
3907    }
3908
3909    let cache = core.cache();
3910    let mut index = 0;
3911    reports.retain(|_| {
3912        let parent = fallback_parents.get(&index);
3913        index += 1;
3914        parent.is_none_or(|parent| {
3915            let cached_by_client = parent
3916                .client_order_id
3917                .is_some_and(|id| cache.order_exists(&id));
3918            let cached_by_venue = cache
3919                .client_order_id(&parent.venue_order_id)
3920                .is_some_and(|id| cache.order_exists(id));
3921            !cached_by_client && !cached_by_venue
3922        })
3923    });
3924}
3925
3926fn validate_limit_price(
3927    order: &impl Order,
3928    instrument: Option<&InstrumentAny>,
3929    submission: OrderSubmission,
3930    params: Option<&Params>,
3931) -> Result<(), OrderDeniedReason> {
3932    if order.order_type() != OrderType::Limit
3933        || (matches!(submission, OrderSubmission::Single)
3934            && (get_param_as_string(params, "px_usd").is_some()
3935                || get_param_as_string(params, "px_vol").is_some()))
3936    {
3937        return Ok(());
3938    }
3939
3940    let Some(price) = order.price() else {
3941        return Ok(());
3942    };
3943
3944    if !price.is_positive() {
3945        return Err(OrderDeniedReason::PriceNotPositive {
3946            field: OrderPriceField::Price,
3947            price,
3948        });
3949    }
3950
3951    if let Some(instrument) = instrument {
3952        instrument
3953            .try_normalize_price(price)
3954            .map_err(|e| OrderDeniedReason::ValidationFailed {
3955                detail: e.to_string(),
3956            })?;
3957    }
3958
3959    Ok(())
3960}
3961
3962fn validate_submit_position_id(
3963    instrument_id: InstrumentId,
3964    position_side: Option<PositionSide>,
3965    position_id: Option<PositionId>,
3966) -> Result<(), OrderDeniedReason> {
3967    if position_id.is_none() {
3968        return Ok(());
3969    }
3970
3971    let expected = position_side.and_then(|side| venue_position_id(instrument_id, side.into()));
3972    if let (Some(position_id), Some(expected)) = (position_id, expected)
3973        && position_id != expected
3974    {
3975        return Err(OrderDeniedReason::InvalidPositionId {
3976            position_id,
3977            detail: format!("expected OKX venue position ID {expected}"),
3978        });
3979    }
3980
3981    Ok(())
3982}
3983
3984#[derive(Debug, Clone, Copy, PartialEq, Eq)]
3985enum OrderCommandRoute {
3986    RegularWs,
3987    AlgoHttp,
3988    SpreadHttp,
3989}
3990
3991#[derive(Debug, Clone, Copy, PartialEq, Eq)]
3992enum QueryOrderRoute {
3993    Regular,
3994    Algo,
3995    RegularThenAlgo,
3996    RegularAndAlgo,
3997    Spread,
3998}
3999
4000#[derive(Debug, Clone, Copy)]
4001struct CachedQueryOrderState {
4002    order_type: OrderType,
4003    venue_order_id: Option<VenueOrderId>,
4004}
4005
4006#[derive(Debug, Clone, Copy, PartialEq, Eq)]
4007enum CancelAllOrdersRoute {
4008    Batch,
4009    MassCancelHttp,
4010    SpreadHttp,
4011}
4012
4013#[derive(Clone, Copy)]
4014enum OrderSubmission {
4015    Single,
4016    List,
4017}
4018
4019fn emit_submit_failure(
4020    failure: CommandFailure,
4021    emitter: &ExecutionEventEmitter,
4022    clock: &'static AtomicTime,
4023    strategy_id: StrategyId,
4024    instrument_id: InstrumentId,
4025    client_order_id: ClientOrderId,
4026) {
4027    match failure {
4028        CommandFailure::NotSent(reason) | CommandFailure::VenueRejected(reason) => {
4029            emitter.emit_order_rejected_event(
4030                strategy_id,
4031                instrument_id,
4032                client_order_id,
4033                &reason,
4034                clock.get_time_ns(),
4035                false,
4036            );
4037        }
4038        CommandFailure::Ambiguous(reason) => {
4039            log::warn!(
4040                "Ambiguous submit failure for {client_order_id}, awaiting reconciliation: {reason}"
4041            );
4042        }
4043    }
4044}
4045
4046#[expect(
4047    clippy::too_many_arguments,
4048    reason = "Failure emission retains order identity and command correlation"
4049)]
4050fn emit_modify_failure(
4051    failure: CommandFailure,
4052    emitter: &ExecutionEventEmitter,
4053    clock: &'static AtomicTime,
4054    strategy_id: StrategyId,
4055    instrument_id: InstrumentId,
4056    client_order_id: ClientOrderId,
4057    venue_order_id: Option<VenueOrderId>,
4058    causation_id: Option<UUID4>,
4059) {
4060    match failure {
4061        CommandFailure::NotSent(reason) => {
4062            emitter.emit_order_modify_denied_event(
4063                strategy_id,
4064                instrument_id,
4065                client_order_id,
4066                venue_order_id,
4067                &reason,
4068                clock.get_time_ns(),
4069                causation_id,
4070            );
4071        }
4072        CommandFailure::VenueRejected(reason) => {
4073            emitter.emit_order_modify_rejected_event(
4074                strategy_id,
4075                instrument_id,
4076                client_order_id,
4077                venue_order_id,
4078                &reason,
4079                clock.get_time_ns(),
4080                causation_id,
4081            );
4082        }
4083        CommandFailure::Ambiguous(reason) => {
4084            log::warn!(
4085                "Ambiguous modify failure for {client_order_id}, awaiting reconciliation: {reason}"
4086            );
4087        }
4088    }
4089}
4090
4091fn algo_amend_request(
4092    cmd: &ModifyOrder,
4093    algo_type: Option<OKXAlgoOrderType>,
4094    context: Option<OrderContext>,
4095) -> Result<OKXAmendAlgoOrderRequest, &'static str> {
4096    let algo_type = algo_type.ok_or("Cannot determine OKX algo order terms for modification")?;
4097    let context = context.ok_or("Cannot determine OKX algo order terms for modification")?;
4098    let algo_id = cmd
4099        .venue_order_id
4100        .ok_or("No algo ID available for pending conditional order")?;
4101    let trigger_price = cmd.trigger_price.map(|price| price.to_string());
4102    let order_price = cmd.price.map(|price| price.to_string());
4103
4104    let trigger_px_type = cmd.trigger_price.map(|_| {
4105        context
4106            .trigger_type
4107            .map_or(OKXTriggerType::Last, Into::into)
4108            .to_string()
4109    });
4110
4111    let mut request = OKXAmendAlgoOrderRequest {
4112        inst_id: cmd.instrument_id.symbol.to_string(),
4113        algo_id: algo_id.to_string(),
4114        algo_cl_ord_id: None,
4115        new_sz: cmd.quantity.map(|quantity| quantity.to_string()),
4116        new_trigger_px: None,
4117        new_trigger_px_type: None,
4118        new_tp_trigger_px: None,
4119        new_tp_ord_px: None,
4120        new_tp_trigger_px_type: None,
4121        new_sl_trigger_px: None,
4122        new_sl_ord_px: None,
4123        new_sl_trigger_px_type: None,
4124        new_order_px: None,
4125        new_callback_ratio: None,
4126        new_callback_spread: None,
4127        new_active_px: None,
4128    };
4129
4130    match (algo_type, context.identity.order_type) {
4131        (OKXAlgoOrderType::Trigger, _) => {
4132            request.new_trigger_px = trigger_price;
4133            request.new_order_px = order_price;
4134            request.new_trigger_px_type = trigger_px_type;
4135        }
4136        (OKXAlgoOrderType::Conditional, OrderType::StopMarket | OrderType::StopLimit) => {
4137            request.new_sl_trigger_px = trigger_price;
4138            request.new_sl_ord_px = order_price;
4139            request.new_sl_trigger_px_type = trigger_px_type;
4140        }
4141        (OKXAlgoOrderType::Conditional, OrderType::MarketIfTouched | OrderType::LimitIfTouched) => {
4142            request.new_tp_trigger_px = trigger_price;
4143            request.new_tp_ord_px = order_price;
4144            request.new_tp_trigger_px_type = trigger_px_type;
4145        }
4146        _ => return Err("OKX does not support modification of this algo order type"),
4147    }
4148
4149    Ok(request)
4150}
4151
4152async fn prepare_inst_id_code(
4153    http: &OKXHttpClient,
4154    instrument_id: InstrumentId,
4155) -> anyhow::Result<()> {
4156    if !http.is_spread(instrument_id) && http.inst_id_code(&instrument_id.symbol.inner()).is_none()
4157    {
4158        http.request_instrument(instrument_id).await?;
4159    }
4160
4161    Ok(())
4162}
4163
4164fn emit_cancel_failure(
4165    failure: CommandFailure,
4166    emit_venue: Option<(&ExecutionEventEmitter, &'static AtomicTime)>,
4167    client_order_id: ClientOrderId,
4168    instrument_id: InstrumentId,
4169    strategy_id: StrategyId,
4170    venue_order_id: Option<VenueOrderId>,
4171    causation_id: Option<UUID4>,
4172) {
4173    match failure {
4174        CommandFailure::VenueRejected(reason) => {
4175            if let Some((emitter, clock)) = emit_venue {
4176                emitter.emit_order_cancel_rejected_event(
4177                    strategy_id,
4178                    instrument_id,
4179                    client_order_id,
4180                    venue_order_id,
4181                    &reason,
4182                    clock.get_time_ns(),
4183                    causation_id,
4184                );
4185            } else {
4186                log::warn!(
4187                    "Ambiguous cancel failure for {client_order_id}, awaiting reconciliation: {reason}"
4188                );
4189            }
4190        }
4191        CommandFailure::NotSent(reason) => {
4192            if let Some((emitter, clock)) = emit_venue {
4193                emitter.emit_order_cancel_denied_event(
4194                    strategy_id,
4195                    instrument_id,
4196                    client_order_id,
4197                    venue_order_id,
4198                    &reason,
4199                    clock.get_time_ns(),
4200                    causation_id,
4201                );
4202            }
4203        }
4204        CommandFailure::Ambiguous(reason) => {
4205            log::warn!(
4206                "Ambiguous cancel failure for {client_order_id}, awaiting reconciliation: {reason}"
4207            );
4208        }
4209    }
4210}
4211
4212// Responses identify children by order ID, so repeated targets need separate requests
4213fn cancel_batch_len(commands: &[(ClientOrderId, UUID4)]) -> usize {
4214    let mut targets = AHashSet::new();
4215    commands
4216        .iter()
4217        .take(20)
4218        .take_while(|(id, _)| targets.insert(*id))
4219        .count()
4220}
4221
4222fn log_batch_cancel_failure(failure: CommandFailure, order_count: usize) {
4223    match failure {
4224        CommandFailure::NotSent(reason) => {
4225            log::warn!(
4226                "Batch cancel command failed local validation for {order_count} orders: {reason}"
4227            );
4228        }
4229        CommandFailure::Ambiguous(reason) | CommandFailure::VenueRejected(reason) => {
4230            log::warn!(
4231                "Ambiguous batch cancel failure for {order_count} orders, awaiting reconciliation: {reason}"
4232            );
4233        }
4234    }
4235}
4236
4237fn log_mass_cancel_failure(failure: CommandFailure, instrument_id: InstrumentId) {
4238    match failure {
4239        CommandFailure::NotSent(reason) => {
4240            log::warn!("Mass cancel command failed local validation for {instrument_id}: {reason}");
4241        }
4242        CommandFailure::Ambiguous(reason) | CommandFailure::VenueRejected(reason) => {
4243            log::warn!(
4244                "Ambiguous mass cancel failure for {instrument_id}, awaiting reconciliation: {reason}"
4245            );
4246        }
4247    }
4248}
4249
4250fn emit_algo_batch_cancel_failure(
4251    failure: CommandFailure,
4252    contexts: &[AlgoCancelContext],
4253    emitter: &ExecutionEventEmitter,
4254    clock: &AtomicTime,
4255) {
4256    match failure {
4257        CommandFailure::NotSent(reason) => {
4258            for ctx in contexts {
4259                emitter.emit_order_cancel_denied_event(
4260                    ctx.strategy_id,
4261                    ctx.instrument_id,
4262                    ctx.client_order_id,
4263                    ctx.venue_order_id,
4264                    &reason,
4265                    clock.get_time_ns(),
4266                    ctx.causation_id,
4267                );
4268            }
4269        }
4270        CommandFailure::Ambiguous(reason) | CommandFailure::VenueRejected(reason) => {
4271            for ctx in contexts {
4272                log::warn!(
4273                    "Ambiguous algo batch cancel failure for {}, awaiting reconciliation: {reason}",
4274                    ctx.client_order_id
4275                );
4276            }
4277        }
4278    }
4279}
4280
4281fn get_param_as_string(params: Option<&Params>, key: &str) -> Option<String> {
4282    params.and_then(|p| {
4283        p.get(key).and_then(|v| {
4284            v.as_str()
4285                .map(ToString::to_string)
4286                .or_else(|| v.as_f64().map(|n| n.to_string()))
4287        })
4288    })
4289}
4290
4291fn get_param_as_bool(params: Option<&Params>, key: &str) -> Option<bool> {
4292    params.and_then(|params| params.get_bool(key))
4293}
4294
4295fn supports_algo_orders(instrument_type: OKXInstrumentType) -> bool {
4296    !matches!(
4297        instrument_type,
4298        OKXInstrumentType::Option | OKXInstrumentType::Events
4299    )
4300}
4301
4302fn order_routing_instrument_types(
4303    instrument_types: &[OKXInstrumentType],
4304) -> Vec<OKXInstrumentType> {
4305    let mut routing_types = instrument_types.to_vec();
4306
4307    // OKX reports cross-margin spot orders as SPOT on order channels and report endpoints
4308    if routing_types.contains(&OKXInstrumentType::Margin)
4309        && !routing_types.contains(&OKXInstrumentType::Spot)
4310        && !routing_types.contains(&OKXInstrumentType::Any)
4311    {
4312        routing_types.push(OKXInstrumentType::Spot);
4313    }
4314
4315    routing_types
4316}
4317
4318fn query_order_route(
4319    instrument_id: InstrumentId,
4320    order_type: Option<OrderType>,
4321    has_cached_venue_order_id: bool,
4322    is_spread: bool,
4323) -> QueryOrderRoute {
4324    if is_spread {
4325        return QueryOrderRoute::Spread;
4326    }
4327
4328    let supports_algo = supports_algo_orders(okx_instrument_type_from_symbol(
4329        instrument_id.symbol.as_str(),
4330    ));
4331
4332    match order_type {
4333        Some(order_type)
4334            if supports_algo
4335                && OKX_CONDITIONAL_ORDER_TYPES.contains(&order_type)
4336                && has_cached_venue_order_id =>
4337        {
4338            QueryOrderRoute::RegularAndAlgo
4339        }
4340        Some(order_type) if supports_algo && OKX_CONDITIONAL_ORDER_TYPES.contains(&order_type) => {
4341            QueryOrderRoute::Algo
4342        }
4343        None if supports_algo => QueryOrderRoute::RegularThenAlgo,
4344        _ => QueryOrderRoute::Regular,
4345    }
4346}
4347
4348fn merge_algo_order_status_reports(
4349    reports: &mut Vec<OrderStatusReport>,
4350    sweep: AlgoOrderReportSweep,
4351    ambiguous_triggered_child_ids: &mut AHashSet<VenueOrderId>,
4352    complete: &mut bool,
4353) {
4354    let AlgoOrderReportSweep {
4355        reports: incoming,
4356        complete: sweep_complete,
4357        ambiguous_triggered_child_ids: ambiguous,
4358    } = sweep;
4359
4360    *complete &= sweep_complete && ambiguous.is_empty();
4361    ambiguous_triggered_child_ids.extend(ambiguous);
4362    merge_order_status_reports(reports, incoming);
4363}
4364
4365fn merge_order_status_reports(
4366    reports: &mut Vec<OrderStatusReport>,
4367    incoming: Vec<OrderStatusReport>,
4368) {
4369    let mut indexes: AHashMap<VenueOrderId, usize> = reports
4370        .iter()
4371        .enumerate()
4372        .map(|(index, report)| (report.venue_order_id, index))
4373        .collect();
4374
4375    for report in incoming {
4376        if let Some(index) = indexes.get(&report.venue_order_id).copied() {
4377            if is_order_status_report_more_advanced(&report, &reports[index]) {
4378                reports[index] = report;
4379            }
4380        } else {
4381            indexes.insert(report.venue_order_id, reports.len());
4382            reports.push(report);
4383        }
4384    }
4385}
4386
4387// Picks the report that best answers the query. Tiered so a strong signal
4388// wins over a weak one regardless of ordering in the merged result set:
4389//   1. Exact `client_order_id` match.
4390//   2. Exact `venue_order_id` match (rare: only when the cached vid is
4391//      still valid; OKX rotates venue_order_id once an algo order triggers).
4392//
4393// Triggered-algo recovery queries the regular child by `ord_id` and the algo
4394// parent by `algo_cl_ord_id`. `linked_order_ids` is deliberately not consulted here
4395// because it is also populated with attached TP/SL child ids on the parent
4396// order, which would otherwise let a query for a child match the parent report.
4397fn select_query_order_report(
4398    reports: Vec<OrderStatusReport>,
4399    client_order_id: ClientOrderId,
4400    venue_order_id: Option<VenueOrderId>,
4401) -> Option<OrderStatusReport> {
4402    let mut by_client_id: Option<OrderStatusReport> = None;
4403    let mut by_vid: Option<OrderStatusReport> = None;
4404
4405    for report in reports {
4406        if report.client_order_id == Some(client_order_id) {
4407            if by_client_id
4408                .as_ref()
4409                .is_none_or(|current| is_order_status_report_more_advanced(&report, current))
4410            {
4411                by_client_id = Some(report);
4412            }
4413
4414            continue;
4415        }
4416
4417        if venue_order_id
4418            .as_ref()
4419            .is_some_and(|vid| report.venue_order_id.as_str() == vid.as_str())
4420            && by_vid
4421                .as_ref()
4422                .is_none_or(|current| is_order_status_report_more_advanced(&report, current))
4423        {
4424            by_vid = Some(report);
4425        }
4426    }
4427
4428    by_client_id.or(by_vid)
4429}
4430
4431#[cfg(test)]
4432mod tests {
4433    use std::{cell::RefCell, rc::Rc, sync::Mutex, time::Duration};
4434
4435    use axum::{
4436        Json, Router,
4437        extract::ws::{Message, WebSocketUpgrade},
4438        routing::{get, post},
4439    };
4440    use futures_util::StreamExt;
4441    use nautilus_common::{
4442        cache::Cache,
4443        live::runner::replace_exec_event_sender,
4444        messages::{ExecutionEvent, ExecutionReport as CommonExecutionReport},
4445        msgbus::TypedIntoHandler,
4446        testing::wait_until_async,
4447    };
4448    use nautilus_core::{AtomicMap, UUID4};
4449    use nautilus_model::{
4450        data::Data,
4451        enums::{LiquiditySide, OrderSide, OrderStatus, TriggerType},
4452        events::{OrderEventAny, OrderInitialized, order::spec::OrderSubmittedSpec},
4453        identifiers::{OrderListId, Symbol, TradeId, TraderId},
4454        instruments::{
4455            CryptoFuture, Instrument,
4456            stubs::{crypto_future_btcusdt, currency_pair_ethusdt},
4457        },
4458        orders::{OrderList, OrderTestBuilder, stubs::TestOrderEventStubs},
4459        position::Position,
4460        types::{Money, Price, Quantity},
4461    };
4462    use rstest::rstest;
4463    use serde_json::Value;
4464    use ustr::Ustr;
4465
4466    use super::*;
4467    use crate::{
4468        common::{
4469            consts::OKX_CLIENT_ID, enums::OKXEnvironment, models::OKXInstrument,
4470            parse::parse_instrument_any, testing::load_test_json,
4471        },
4472        websocket::{
4473            dispatch::dispatch_ws_message,
4474            enums::OKXWsOperation,
4475            messages::OKXWsMessage,
4476            parse::{FeeCache, FilledQtyCache},
4477        },
4478    };
4479
4480    struct DropSignal(Option<tokio::sync::oneshot::Sender<()>>);
4481
4482    impl Drop for DropSignal {
4483        fn drop(&mut self) {
4484            if let Some(sender) = self.0.take() {
4485                let _ = sender.send(());
4486            }
4487        }
4488    }
4489
4490    #[derive(Clone, Copy)]
4491    enum ExecutionTaskBoundary {
4492        Reset,
4493        Dispose,
4494        RepeatedStop,
4495    }
4496
4497    #[rstest]
4498    #[case(OrderType::Market, QueryOrderRoute::Regular)]
4499    #[case(OrderType::Limit, QueryOrderRoute::Regular)]
4500    #[case(OrderType::StopMarket, QueryOrderRoute::Algo)]
4501    #[case(OrderType::TrailingStopMarket, QueryOrderRoute::Algo)]
4502    fn test_query_order_route_for_known_order_type(
4503        #[case] order_type: OrderType,
4504        #[case] expected: QueryOrderRoute,
4505    ) {
4506        assert_eq!(
4507            query_order_route(
4508                InstrumentId::from("BTC-USDT.OKX"),
4509                Some(order_type),
4510                false,
4511                false
4512            ),
4513            expected
4514        );
4515    }
4516
4517    #[rstest]
4518    fn test_query_order_route_for_conditional_order_with_cached_venue_id() {
4519        assert_eq!(
4520            query_order_route(
4521                InstrumentId::from("BTC-USDT.OKX"),
4522                Some(OrderType::StopMarket),
4523                true,
4524                false,
4525            ),
4526            QueryOrderRoute::RegularAndAlgo,
4527        );
4528    }
4529
4530    #[rstest]
4531    fn test_query_order_route_for_unknown_order_type() {
4532        assert_eq!(
4533            query_order_route(InstrumentId::from("BTC-USDT.OKX"), None, false, false),
4534            QueryOrderRoute::RegularThenAlgo,
4535        );
4536    }
4537
4538    #[rstest]
4539    fn test_query_order_route_for_spread() {
4540        assert_eq!(
4541            query_order_route(
4542                InstrumentId::from("ETH-USD-SWAP_ETH-USD-231229.OKX"),
4543                None,
4544                false,
4545                true,
4546            ),
4547            QueryOrderRoute::Spread,
4548        );
4549    }
4550
4551    #[rstest]
4552    #[case("BTC-USD_UM_XPERP-310404.OKX")]
4553    #[case("BTC-USD_UM-261030.OKX")]
4554    fn test_usd_margined_futures_use_regular_routes(
4555        mut crypto_future_btcusdt: CryptoFuture,
4556        #[case] instrument_id: &str,
4557        #[values(false, true)] cached: bool,
4558        #[values(OrderSide::Buy, OrderSide::Sell)] side: OrderSide,
4559    ) {
4560        let client = build_test_exec_client();
4561        let instrument_id = InstrumentId::from(instrument_id);
4562        crypto_future_btcusdt.id = instrument_id;
4563        crypto_future_btcusdt.raw_symbol = instrument_id.symbol;
4564
4565        if cached {
4566            client
4567                .http_client
4568                .cache_instrument(InstrumentAny::CryptoFuture(crypto_future_btcusdt));
4569        }
4570
4571        let order = OrderTestBuilder::new(OrderType::Limit)
4572            .instrument_id(instrument_id)
4573            .client_order_id(ClientOrderId::from("OREDUCEFUTURE"))
4574            .side(side)
4575            .price(Price::from("65000.1"))
4576            .quantity(Quantity::from("3"))
4577            .reduce_only(true)
4578            .build();
4579        let is_spread = client.http_client.is_spread(instrument_id);
4580
4581        assert_eq!(
4582            client
4583                .submit_order_route(instrument_id, OrderType::Limit)
4584                .unwrap(),
4585            OrderCommandRoute::RegularWs
4586        );
4587        assert_eq!(
4588            client
4589                .submit_order_route(instrument_id, OrderType::StopMarket)
4590                .unwrap(),
4591            OrderCommandRoute::AlgoHttp
4592        );
4593        assert_eq!(
4594            client.order_command_route(instrument_id, Some((OrderType::Limit, None)), false),
4595            OrderCommandRoute::RegularWs
4596        );
4597        assert_eq!(
4598            client.cancel_all_orders_route(instrument_id, None),
4599            CancelAllOrdersRoute::Batch
4600        );
4601        assert_eq!(
4602            query_order_route(instrument_id, Some(OrderType::Limit), false, is_spread),
4603            QueryOrderRoute::Regular
4604        );
4605        assert_eq!(
4606            client.validate_order(&order, OKXTradeMode::Cross, OrderSubmission::Single, None),
4607            Ok(())
4608        );
4609    }
4610
4611    #[rstest]
4612    fn test_validate_order_allows_conditional_single_submission() {
4613        let order = OrderTestBuilder::new(OrderType::StopMarket)
4614            .instrument_id(InstrumentId::from("ETH-USDT-SWAP.OKX"))
4615            .client_order_id(ClientOrderId::from("OCONDITIONALSINGLE"))
4616            .side(OrderSide::Sell)
4617            .quantity(Quantity::from("1"))
4618            .trigger_price(Price::from("1000.00"))
4619            .build();
4620
4621        assert_eq!(
4622            build_test_exec_client().validate_order(
4623                &order,
4624                OKXTradeMode::Cross,
4625                OrderSubmission::Single,
4626                None
4627            ),
4628            Ok(())
4629        );
4630    }
4631
4632    #[rstest]
4633    fn test_validate_order_denies_conditional_order_in_list() {
4634        let order = OrderTestBuilder::new(OrderType::StopMarket)
4635            .instrument_id(InstrumentId::from("ETH-USDT-SWAP.OKX"))
4636            .client_order_id(ClientOrderId::from("OCONDITIONALLIST"))
4637            .side(OrderSide::Sell)
4638            .quantity(Quantity::from("2"))
4639            .trigger_price(Price::from("900.00"))
4640            .build();
4641
4642        assert_eq!(
4643            build_test_exec_client().validate_order(
4644                &order,
4645                OKXTradeMode::Cross,
4646                OrderSubmission::List,
4647                None
4648            ),
4649            Err(OrderDeniedReason::UnsupportedOrderList {
4650                detail: "conditional order OCONDITIONALLIST is not supported".to_string(),
4651            })
4652        );
4653    }
4654
4655    #[rstest]
4656    fn test_validate_order_denies_non_gtc_order_in_list() {
4657        let order = OrderTestBuilder::new(OrderType::Limit)
4658            .instrument_id(InstrumentId::from("ETH-USDT-SWAP.OKX"))
4659            .client_order_id(ClientOrderId::from("OIOCLIST"))
4660            .side(OrderSide::Buy)
4661            .price(Price::from("2000.00"))
4662            .quantity(Quantity::from("3"))
4663            .time_in_force(TimeInForce::Ioc)
4664            .build();
4665
4666        assert_eq!(
4667            build_test_exec_client().validate_order(
4668                &order,
4669                OKXTradeMode::Cross,
4670                OrderSubmission::List,
4671                None
4672            ),
4673            Err(OrderDeniedReason::UnsupportedOrderList {
4674                detail: "order OIOCLIST has unsupported time in force IOC".to_string(),
4675            })
4676        );
4677    }
4678
4679    #[rstest]
4680    #[case::cash("BTC-USDT.OKX", OKXTradeMode::Cash)]
4681    #[case::option("BTC-USD-241217-92000-C.OKX", OKXTradeMode::Cross)]
4682    #[case::event("BTC-ABOVE-DAILY-260224-1600-65000.OKX", OKXTradeMode::Cross)]
4683    fn test_validate_order_denies_unsupported_reduce_only(
4684        #[case] instrument_id: &str,
4685        #[case] trade_mode: OKXTradeMode,
4686    ) {
4687        let order = OrderTestBuilder::new(OrderType::Limit)
4688            .instrument_id(InstrumentId::from(instrument_id))
4689            .client_order_id(ClientOrderId::from("OREDUCEUNSUPPORTED"))
4690            .side(OrderSide::Sell)
4691            .price(Price::from("2000.00"))
4692            .quantity(Quantity::from("1"))
4693            .reduce_only(true)
4694            .build();
4695
4696        assert_eq!(
4697            build_test_exec_client().validate_order(
4698                &order,
4699                trade_mode,
4700                OrderSubmission::Single,
4701                None
4702            ),
4703            Err(OrderDeniedReason::UnsupportedReduceOnly)
4704        );
4705    }
4706
4707    fn build_config(
4708        margin_mode: Option<OKXMarginMode>,
4709        use_spot_margin: bool,
4710    ) -> OKXExecutionClientConfig {
4711        OKXExecutionClientConfig {
4712            margin_mode,
4713            use_spot_margin,
4714            ..OKXExecutionClientConfig::default()
4715        }
4716    }
4717
4718    #[rstest]
4719    #[case::spot(OKXInstrumentType::Spot, true)]
4720    #[case::margin(OKXInstrumentType::Margin, true)]
4721    #[case::swap(OKXInstrumentType::Swap, true)]
4722    #[case::futures(OKXInstrumentType::Futures, true)]
4723    #[case::option(OKXInstrumentType::Option, false)]
4724    #[case::events(OKXInstrumentType::Events, false)]
4725    fn test_supports_algo_orders(
4726        #[case] instrument_type: OKXInstrumentType,
4727        #[case] expected: bool,
4728    ) {
4729        assert_eq!(supports_algo_orders(instrument_type), expected);
4730    }
4731
4732    #[rstest]
4733    #[case::margin(
4734        vec![OKXInstrumentType::Margin],
4735        vec![OKXInstrumentType::Margin, OKXInstrumentType::Spot]
4736    )]
4737    #[case::spot_margin(
4738        vec![OKXInstrumentType::Spot, OKXInstrumentType::Margin],
4739        vec![OKXInstrumentType::Spot, OKXInstrumentType::Margin]
4740    )]
4741    #[case::any_margin(
4742        vec![OKXInstrumentType::Any, OKXInstrumentType::Margin],
4743        vec![OKXInstrumentType::Any, OKXInstrumentType::Margin]
4744    )]
4745    #[case::swap(
4746        vec![OKXInstrumentType::Swap],
4747        vec![OKXInstrumentType::Swap]
4748    )]
4749    fn test_order_routing_instrument_types(
4750        #[case] instrument_types: Vec<OKXInstrumentType>,
4751        #[case] expected: Vec<OKXInstrumentType>,
4752    ) {
4753        assert_eq!(order_routing_instrument_types(&instrument_types), expected);
4754    }
4755
4756    #[rstest]
4757    #[case::cash_no_spot_margin(AccountType::Cash, None, false, OKXTradeMode::Cash)]
4758    #[case::cash_spot_margin_cross(
4759        AccountType::Cash,
4760        Some(OKXMarginMode::Cross),
4761        true,
4762        OKXTradeMode::Cross
4763    )]
4764    #[case::cash_spot_margin_isolated(
4765        AccountType::Cash,
4766        Some(OKXMarginMode::Isolated),
4767        true,
4768        OKXTradeMode::Isolated
4769    )]
4770    #[case::cash_spot_margin_none(AccountType::Cash, None, true, OKXTradeMode::Isolated)]
4771    #[case::margin_cross(
4772        AccountType::Margin,
4773        Some(OKXMarginMode::Cross),
4774        false,
4775        OKXTradeMode::Cross
4776    )]
4777    #[case::margin_isolated(
4778        AccountType::Margin,
4779        Some(OKXMarginMode::Isolated),
4780        false,
4781        OKXTradeMode::Isolated
4782    )]
4783    #[case::margin_none(AccountType::Margin, None, false, OKXTradeMode::Isolated)]
4784    fn test_derive_default_trade_mode(
4785        #[case] account_type: AccountType,
4786        #[case] margin_mode: Option<OKXMarginMode>,
4787        #[case] use_spot_margin: bool,
4788        #[case] expected: OKXTradeMode,
4789    ) {
4790        let config = build_config(margin_mode, use_spot_margin);
4791
4792        let result = OKXExecutionClient::derive_default_trade_mode(account_type, &config);
4793
4794        assert_eq!(result, expected);
4795    }
4796
4797    #[rstest]
4798    #[case::spot_no_margin("BTC-USDT", None, false, OKXTradeMode::Cash)]
4799    #[case::spot_cross_margin("BTC-USDT", Some(OKXMarginMode::Cross), true, OKXTradeMode::Cross)]
4800    #[case::spot_isolated_margin(
4801        "ETH-USDT",
4802        Some(OKXMarginMode::Isolated),
4803        true,
4804        OKXTradeMode::Isolated
4805    )]
4806    #[case::spot_margin_no_mode("BTC-USDT", None, true, OKXTradeMode::Isolated)]
4807    #[case::swap_cross(
4808        "BTC-USDT-SWAP",
4809        Some(OKXMarginMode::Cross),
4810        false,
4811        OKXTradeMode::Cross
4812    )]
4813    #[case::swap_isolated(
4814        "BTC-USDT-SWAP",
4815        Some(OKXMarginMode::Isolated),
4816        false,
4817        OKXTradeMode::Isolated
4818    )]
4819    #[case::swap_no_mode("ETH-USDT-SWAP", None, false, OKXTradeMode::Isolated)]
4820    #[case::futures_cross(
4821        "BTC-USDT-250328",
4822        Some(OKXMarginMode::Cross),
4823        false,
4824        OKXTradeMode::Cross
4825    )]
4826    #[case::futures_isolated("BTC-USDT-250328", None, false, OKXTradeMode::Isolated)]
4827    #[case::option_cross(
4828        "BTC-USD-250328-50000-C",
4829        Some(OKXMarginMode::Cross),
4830        false,
4831        OKXTradeMode::Cross
4832    )]
4833    #[case::option_isolated("BTC-USD-250328-50000-C", None, false, OKXTradeMode::Isolated)]
4834    fn test_derive_trade_mode_for_instrument(
4835        #[case] symbol: &str,
4836        #[case] margin_mode: Option<OKXMarginMode>,
4837        #[case] use_spot_margin: bool,
4838        #[case] expected: OKXTradeMode,
4839    ) {
4840        let instrument_id = InstrumentId::from(format!("{symbol}.OKX").as_str());
4841
4842        let result = derive_trade_mode_for_instrument(instrument_id, margin_mode, use_spot_margin);
4843
4844        assert_eq!(result, expected);
4845    }
4846
4847    #[rstest]
4848    #[case::mass_status("mass_status")]
4849    #[case::single_order("single_order")]
4850    #[case::fills("fills")]
4851    #[case::spread_fills("spread_fills")]
4852    #[tokio::test]
4853    async fn test_filtered_reports_register_complete_instrument_context(
4854        #[case] kind: &'static str,
4855    ) {
4856        let empty_response = || async { Json(serde_json::json!({"code":"0","msg":"","data":[]})) };
4857
4858        let router = Router::new()
4859            .route(
4860                "/api/v5/sprd/spreads",
4861                get(|| async {
4862                    let mut response: Value =
4863                        serde_json::from_str(&load_test_json("http_get_spreads.json")).unwrap();
4864                    response["data"].as_array_mut().unwrap().truncate(1);
4865                    Json(response)
4866                }),
4867            )
4868            .route(
4869                "/api/v5/sprd/trades",
4870                get(|| async {
4871                    Json(
4872                        serde_json::from_str::<Value>(&load_test_json(
4873                            "http_get_spread_trades.json",
4874                        ))
4875                        .unwrap(),
4876                    )
4877                }),
4878            )
4879            .route(
4880                "/api/v5/public/instruments",
4881                get(|| async {
4882                    let mut response: Value =
4883                        serde_json::from_str(&load_test_json("http_get_instruments_swap.json"))
4884                            .unwrap();
4885                    response["data"]
4886                        .as_array_mut()
4887                        .unwrap()
4888                        .retain(|row| row["instId"] == "BTC-USDT-SWAP");
4889                    Json(response)
4890                }),
4891            )
4892            .route(
4893                "/api/v5/account/positions",
4894                get(|| async {
4895                    Json(
4896                        serde_json::from_str::<Value>(&load_test_json("http_get_positions.json"))
4897                            .unwrap(),
4898                    )
4899                }),
4900            )
4901            .route(
4902                "/api/v5/account/balance",
4903                get(|| async {
4904                    Json(
4905                        serde_json::from_str::<Value>(&load_test_json(
4906                            "http_get_account_balance.json",
4907                        ))
4908                        .unwrap(),
4909                    )
4910                }),
4911            )
4912            .route("/api/v5/trade/orders-pending", get(empty_response))
4913            .route("/api/v5/trade/orders-history", get(empty_response))
4914            .route("/api/v5/trade/orders-algo-pending", get(empty_response))
4915            .route("/api/v5/trade/orders-algo-history", get(empty_response))
4916            .route(
4917                "/api/v5/trade/order",
4918                get(|| async {
4919                    Json(
4920                        serde_json::from_str::<Value>(&load_test_json(
4921                            "http_get_orders_pending.json",
4922                        ))
4923                        .unwrap(),
4924                    )
4925                }),
4926            )
4927            .route(
4928                "/api/v5/trade/fills",
4929                get(move || async move {
4930                    if kind != "fills" {
4931                        return Json(serde_json::json!({"code":"0","msg":"","data":[]}));
4932                    }
4933
4934                    let mut fill: Value =
4935                        serde_json::from_str(&load_test_json("http_transaction_detail.json"))
4936                            .unwrap();
4937                    fill["instType"] = serde_json::json!("SWAP");
4938                    fill["instId"] = serde_json::json!("BTC-USDT-SWAP");
4939                    fill["fillSz"] = serde_json::json!("1");
4940                    Json(serde_json::json!({"code":"0","msg":"","data":[fill]}))
4941                }),
4942            );
4943
4944        let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
4945        let address = listener.local_addr().unwrap();
4946        let server = tokio::spawn(async move { axum::serve(listener, router).await.unwrap() });
4947        let (mut client, cache) = build_test_exec_client_with_cache();
4948        client.config.instrument_types = vec![OKXInstrumentType::Swap];
4949        client.config.instrument_families = Some(vec!["ETH-USDT".to_string()]);
4950        client.config.max_reconciliation_history_pages = Some(0);
4951        client.core.account_type = AccountType::Margin;
4952        client.http_client = OKXHttpClient::with_credentials(
4953            Some("key".into()),
4954            Some("secret".into()),
4955            Some("passphrase".into()),
4956            Some(format!("http://{address}")),
4957            2,
4958            0,
4959            1,
4960            1,
4961            OKXEnvironment::Demo,
4962            None,
4963        )
4964        .unwrap();
4965        let sink = Rc::clone(&cache);
4966        msgbus::register_data_endpoint(
4967            MessagingSwitchboard::data_engine_process_data(),
4968            TypedIntoHandler::from(move |data: Data| {
4969                let Data::Instrument(instrument) = data else {
4970                    panic!("Expected instrument")
4971                };
4972
4973                sink.borrow_mut().add_instrument(*instrument).unwrap();
4974            }),
4975        );
4976
4977        let instrument_id = if kind == "spread_fills" {
4978            InstrumentId::from("ETH-USD-SWAP_ETH-USD-231229.OKX")
4979        } else {
4980            InstrumentId::from("BTC-USDT-SWAP.OKX")
4981        };
4982
4983        match kind {
4984            "mass_status" => {
4985                let status = client
4986                    .generate_mass_status(Some(60))
4987                    .await
4988                    .unwrap()
4989                    .unwrap();
4990                assert!(status.order_reports().is_empty());
4991                assert!(status.fill_reports().is_empty());
4992                assert_eq!(status.position_reports().len(), 1);
4993                assert_eq!(
4994                    status.position_reports()[&instrument_id][0].quantity,
4995                    Quantity::from("0.5")
4996                );
4997            }
4998            "single_order" => {
4999                let command = GenerateOrderStatusReport::new(
5000                    UUID4::new(),
5001                    UnixNanos::default(),
5002                    Some(instrument_id),
5003                    None,
5004                    Some(VenueOrderId::from("1234567890123456789")),
5005                    None,
5006                    None,
5007                );
5008                let task = client.generate_order_status_report_task(&command).unwrap();
5009                task.collection.await;
5010                assert_eq!(cache.borrow().instrument(&instrument_id), None);
5011                let report = (task.finish)().unwrap().unwrap();
5012                assert_eq!(report.instrument_id, instrument_id);
5013                assert_eq!(
5014                    report.venue_order_id,
5015                    VenueOrderId::from("1234567890123456789")
5016                );
5017            }
5018            "fills" | "spread_fills" => {
5019                let command = GenerateFillReportsBuilder::default()
5020                    .ts_init(UnixNanos::default())
5021                    .instrument_id(Some(instrument_id))
5022                    .build()
5023                    .unwrap();
5024                let task = client.generate_fill_reports_task(&command).unwrap();
5025                task.collection.await;
5026                assert_eq!(cache.borrow().instrument(&instrument_id), None);
5027                let reports = (task.finish)().unwrap();
5028                assert_eq!(reports.len(), 1);
5029                assert_eq!(reports[0].instrument_id, instrument_id);
5030
5031                let (trade_id, quantity) = if kind == "spread_fills" {
5032                    ("9001", "5")
5033                } else {
5034                    ("123456789", "1")
5035                };
5036
5037                assert_eq!(reports[0].trade_id, TradeId::from(trade_id));
5038                assert_eq!(reports[0].last_qty, Quantity::from(quantity));
5039            }
5040            _ => unreachable!(),
5041        }
5042
5043        let expected = client
5044            .http_client
5045            .get_instrument(&instrument_id.symbol.inner())
5046            .unwrap();
5047        assert_eq!(
5048            serde_json::to_value(cache.borrow().instrument(&instrument_id).cloned()).unwrap(),
5049            serde_json::to_value(Some(expected.clone())).unwrap()
5050        );
5051
5052        for ws_client in [&client.ws_private, &client.ws_business] {
5053            assert_eq!(
5054                serde_json::to_value(
5055                    ws_client
5056                        .instruments_cache_arc()
5057                        .get_cloned(&instrument_id.symbol.inner())
5058                )
5059                .unwrap(),
5060                serde_json::to_value(Some(expected.clone())).unwrap()
5061            );
5062            assert_eq!(
5063                ws_client.get_inst_id_code(&instrument_id.symbol.inner()),
5064                if kind == "spread_fills" {
5065                    None
5066                } else {
5067                    Some(10459)
5068                }
5069            );
5070        }
5071
5072        server.abort();
5073    }
5074
5075    #[rstest]
5076    #[tokio::test]
5077    async fn test_report_context_restores_websocket_instrument_and_code() {
5078        let mut response: serde_json::Value =
5079            serde_json::from_str(include_str!("../test_data/http_get_instruments_swap.json"))
5080                .unwrap();
5081        response["data"]
5082            .as_array_mut()
5083            .unwrap()
5084            .retain(|row| row["instId"] == "BTC-USDT-SWAP");
5085
5086        let definition: OKXInstrument =
5087            serde_json::from_value(response["data"][0].clone()).unwrap();
5088        let instrument = parse_instrument_any(&definition, None, None, UnixNanos::default())
5089            .unwrap()
5090            .unwrap();
5091
5092        let router = Router::new().route(
5093            "/api/v5/public/instruments",
5094            get(move || {
5095                let response = response.clone();
5096                async move { Json(response) }
5097            }),
5098        );
5099
5100        let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
5101        let address = listener.local_addr().unwrap();
5102        let server = tokio::spawn(async move {
5103            axum::serve(listener, router).await.unwrap();
5104        });
5105
5106        let mut client = build_test_exec_client();
5107        client.config.instrument_types = vec![OKXInstrumentType::Swap];
5108        client.config.instrument_families = Some(vec!["ETH-USDT".to_string()]);
5109        client.http_client = OKXHttpClient::new(
5110            Some(format!("http://{address}")),
5111            5,
5112            0,
5113            1,
5114            1,
5115            OKXEnvironment::Demo,
5116            None,
5117        )
5118        .unwrap();
5119        let instrument_id = InstrumentId::from("BTC-USDT-SWAP.OKX");
5120        client.http_client.cache_instrument(instrument.clone());
5121        assert_eq!(
5122            client
5123                .http_client
5124                .inst_id_code(&instrument_id.symbol.inner()),
5125            None
5126        );
5127        client
5128            .report_client()
5129            .prepare_inst_id_codes(AHashSet::from_iter([instrument_id]))
5130            .await
5131            .unwrap();
5132        let instrument = client
5133            .http_client
5134            .get_instrument(&instrument_id.symbol.inner())
5135            .unwrap();
5136        client.report_context().register([instrument_id]);
5137        assert_eq!(
5138            client
5139                .ws_private
5140                .instruments_cache_arc()
5141                .get_cloned(&instrument_id.symbol.inner()),
5142            Some(instrument.clone())
5143        );
5144        assert_eq!(
5145            client
5146                .ws_business
5147                .instruments_cache_arc()
5148                .get_cloned(&instrument_id.symbol.inner()),
5149            Some(instrument)
5150        );
5151        assert_eq!(
5152            client
5153                .ws_private
5154                .get_inst_id_code(&instrument_id.symbol.inner()),
5155            Some(10459)
5156        );
5157        assert_eq!(
5158            client
5159                .ws_business
5160                .get_inst_id_code(&instrument_id.symbol.inner()),
5161            Some(10459)
5162        );
5163        server.abort();
5164    }
5165
5166    #[rstest]
5167    #[case::spot(vec![OKXInstrumentType::Spot], "BTC-USDT.OKX", OKXTradeMode::Cash)]
5168    #[case::margin(vec![OKXInstrumentType::Margin], "BTC-USDT.OKX", OKXTradeMode::Cross)]
5169    #[case::events(vec![OKXInstrumentType::Events], "BTC-ABOVE-DAILY-260224-1600-65000.OKX", OKXTradeMode::Isolated)]
5170    fn test_configured_trade_mode(
5171        #[case] instrument_types: Vec<OKXInstrumentType>,
5172        #[case] symbol: &str,
5173        #[case] expected: OKXTradeMode,
5174    ) {
5175        let mut client = build_test_exec_client();
5176        client.config.instrument_types = instrument_types;
5177        client.config.margin_mode = Some(OKXMarginMode::Cross);
5178        let instrument_id = InstrumentId::from(symbol);
5179        assert_eq!(client.trade_mode_for_order(instrument_id, None), expected);
5180    }
5181
5182    #[rstest]
5183    #[case(OKXTradeMode::Cash)]
5184    #[case(OKXTradeMode::Cross)]
5185    fn test_event_trade_mode_rejects_override(#[case] trade_mode: OKXTradeMode) {
5186        let client = build_test_exec_client();
5187        assert_eq!(
5188            client.validate_trade_mode(
5189                InstrumentId::from("BTC-ABOVE-DAILY-260224-1600-65000.OKX"),
5190                None,
5191                trade_mode
5192            ),
5193            Err(OrderDeniedReason::ValidationFailed {
5194                detail: "OKX event contracts require isolated trade mode".to_string()
5195            })
5196        );
5197    }
5198
5199    #[rstest]
5200    #[case::override_to_cross("cross", OKXTradeMode::Cross)]
5201    #[case::override_to_cash("cash", OKXTradeMode::Cash)]
5202    #[case::override_to_isolated("isolated", OKXTradeMode::Isolated)]
5203    #[case::override_to_spot_isolated("spot_isolated", OKXTradeMode::SpotIsolated)]
5204    #[case::case_insensitive("CROSS", OKXTradeMode::Cross)]
5205    fn test_td_mode_param_override(#[case] td_mode_value: &str, #[case] expected: OKXTradeMode) {
5206        let params = Params::new(
5207            [(
5208                "td_mode".to_string(),
5209                Value::String(td_mode_value.to_string()),
5210            )]
5211            .into(),
5212        );
5213
5214        let result = get_param_as_string(Some(&params), "td_mode")
5215            .and_then(|s| s.parse::<OKXTradeMode>().ok());
5216
5217        assert_eq!(result, Some(expected));
5218    }
5219
5220    #[rstest]
5221    fn test_td_mode_param_invalid_falls_through() {
5222        let params =
5223            Params::new([("td_mode".to_string(), Value::String("invalid".to_string()))].into());
5224
5225        let result = get_param_as_string(Some(&params), "td_mode")
5226            .and_then(|s| s.parse::<OKXTradeMode>().ok());
5227
5228        assert_eq!(result, None);
5229    }
5230
5231    #[rstest]
5232    fn test_td_mode_param_absent_falls_through() {
5233        let result = get_param_as_string(None, "td_mode");
5234
5235        assert_eq!(result, None);
5236    }
5237
5238    #[rstest]
5239    fn test_close_fraction_present_sets_reduce_only_true() {
5240        let params =
5241            Params::new([("close_fraction".to_string(), Value::String("1".to_string()))].into());
5242        let params = Some(params);
5243
5244        let close_fraction = get_param_as_string(params.as_ref(), "close_fraction");
5245        let is_reduce_only = false;
5246        let reduce_only = if close_fraction.is_some() {
5247            Some(true)
5248        } else {
5249            Some(is_reduce_only)
5250        };
5251
5252        assert_eq!(close_fraction, Some("1".to_string()));
5253        assert_eq!(reduce_only, Some(true));
5254    }
5255
5256    #[rstest]
5257    fn test_close_fraction_absent_preserves_reduce_only() {
5258        let params: Option<Params> = None;
5259
5260        let close_fraction = get_param_as_string(params.as_ref(), "close_fraction");
5261        let is_reduce_only = false;
5262        let reduce_only = if close_fraction.is_some() {
5263            Some(true)
5264        } else {
5265            Some(is_reduce_only)
5266        };
5267
5268        assert_eq!(close_fraction, None);
5269        assert_eq!(reduce_only, Some(false));
5270    }
5271
5272    #[rstest]
5273    fn test_close_fraction_absent_with_reduce_only_true() {
5274        let params: Option<Params> = None;
5275
5276        let close_fraction = get_param_as_string(params.as_ref(), "close_fraction");
5277        let is_reduce_only = true;
5278        let reduce_only = if close_fraction.is_some() {
5279            Some(true)
5280        } else {
5281            Some(is_reduce_only)
5282        };
5283
5284        assert_eq!(close_fraction, None);
5285        assert_eq!(reduce_only, Some(true));
5286    }
5287
5288    fn make_query_order_report(cid: Option<&str>, vid: &str) -> OrderStatusReport {
5289        OrderStatusReport::new(
5290            AccountId::from("OKX-001"),
5291            InstrumentId::from("BTC-USDT.OKX"),
5292            cid.map(ClientOrderId::from),
5293            VenueOrderId::from(vid),
5294            OrderSide::Buy.into(),
5295            OrderType::Limit,
5296            TimeInForce::Gtc,
5297            OrderStatus::Accepted,
5298            Quantity::new(1.0, 0),
5299            Quantity::zero(0),
5300            UnixNanos::default(),
5301            UnixNanos::default(),
5302            UnixNanos::default(),
5303            None,
5304        )
5305    }
5306
5307    fn with_linked(mut report: OrderStatusReport, linked: &[&str]) -> OrderStatusReport {
5308        report.linked_order_ids = Some(linked.iter().map(|s| ClientOrderId::from(*s)).collect());
5309        report
5310    }
5311
5312    #[rstest]
5313    fn test_merge_order_status_reports_keeps_filled_regular_child() {
5314        let mut filled = make_query_order_report(Some("O-PARENT"), "V-CHILD");
5315        filled.order_status = OrderStatus::Filled;
5316        filled.filled_qty = Quantity::new(1.0, 0);
5317        filled.ts_last = UnixNanos::from(100);
5318
5319        let mut triggered = make_query_order_report(Some("O-PARENT"), "V-CHILD");
5320        triggered.order_status = OrderStatus::Triggered;
5321        triggered.filled_qty = Quantity::new(1.0, 0);
5322        triggered.ts_last = UnixNanos::from(200);
5323
5324        let mut reports = vec![filled];
5325        merge_order_status_reports(&mut reports, vec![triggered]);
5326
5327        assert_eq!(reports.len(), 1);
5328        assert_eq!(reports[0].order_status, OrderStatus::Filled);
5329        assert_eq!(
5330            reports[0].client_order_id,
5331            Some(ClientOrderId::from("O-PARENT"))
5332        );
5333        assert_eq!(reports[0].venue_order_id, VenueOrderId::from("V-CHILD"));
5334    }
5335
5336    #[rstest]
5337    fn test_merge_order_status_reports_replaces_pending_parent_with_triggered_child() {
5338        let mut accepted = make_query_order_report(Some("O-PARENT"), "V-CHILD");
5339        accepted.ts_last = UnixNanos::from(100);
5340
5341        let mut triggered = make_query_order_report(Some("O-PARENT"), "V-CHILD");
5342        triggered.order_status = OrderStatus::Triggered;
5343        triggered.ts_last = UnixNanos::from(200);
5344
5345        let mut reports = vec![accepted];
5346        merge_order_status_reports(&mut reports, vec![triggered]);
5347
5348        assert_eq!(reports.len(), 1);
5349        assert_eq!(reports[0].order_status, OrderStatus::Triggered);
5350        assert_eq!(reports[0].ts_last, UnixNanos::from(200));
5351    }
5352
5353    #[rstest]
5354    fn test_select_query_order_report_matches_client_order_id() {
5355        let reports = vec![make_query_order_report(Some("O-001"), "V-1")];
5356        let selected = select_query_order_report(reports, ClientOrderId::from("O-001"), None);
5357        assert_eq!(
5358            selected.and_then(|r| r.client_order_id),
5359            Some(ClientOrderId::from("O-001"))
5360        );
5361    }
5362
5363    #[rstest]
5364    fn test_select_query_order_report_client_wins_over_venue_mismatch() {
5365        let reports = vec![make_query_order_report(Some("O-001"), "V-1")];
5366        let selected = select_query_order_report(
5367            reports,
5368            ClientOrderId::from("O-001"),
5369            Some(VenueOrderId::from("V-OTHER")),
5370        );
5371        assert_eq!(
5372            selected.and_then(|r| r.client_order_id),
5373            Some(ClientOrderId::from("O-001"))
5374        );
5375    }
5376
5377    #[rstest]
5378    #[case(
5379        OrderStatus::Accepted,
5380        Quantity::zero(0),
5381        OrderStatus::Triggered,
5382        Quantity::zero(0),
5383        OrderStatus::Triggered
5384    )]
5385    #[case(
5386        OrderStatus::Triggered,
5387        Quantity::zero(0),
5388        OrderStatus::PartiallyFilled,
5389        Quantity::new(0.5, 1),
5390        OrderStatus::PartiallyFilled
5391    )]
5392    #[case(
5393        OrderStatus::PartiallyFilled,
5394        Quantity::new(0.5, 1),
5395        OrderStatus::Filled,
5396        Quantity::new(1.0, 0),
5397        OrderStatus::Filled
5398    )]
5399    #[case(
5400        OrderStatus::Triggered,
5401        Quantity::zero(0),
5402        OrderStatus::Canceled,
5403        Quantity::zero(0),
5404        OrderStatus::Canceled
5405    )]
5406    #[case(
5407        OrderStatus::Triggered,
5408        Quantity::zero(0),
5409        OrderStatus::Rejected,
5410        Quantity::zero(0),
5411        OrderStatus::Rejected
5412    )]
5413    fn test_select_query_order_report_chooses_most_advanced_client_match_regardless_of_order(
5414        #[case] first_status: OrderStatus,
5415        #[case] first_filled_qty: Quantity,
5416        #[case] second_status: OrderStatus,
5417        #[case] second_filled_qty: Quantity,
5418        #[case] expected_status: OrderStatus,
5419    ) {
5420        let mut first = make_query_order_report(Some("O-001"), "V-PARENT");
5421        first.order_status = first_status;
5422        first.filled_qty = first_filled_qty;
5423        let mut second = make_query_order_report(Some("O-001"), "V-CHILD");
5424        second.order_status = second_status;
5425        second.filled_qty = second_filled_qty;
5426
5427        for reports in [vec![first.clone(), second.clone()], vec![second, first]] {
5428            let selected = select_query_order_report(
5429                reports,
5430                ClientOrderId::from("O-001"),
5431                Some(VenueOrderId::from("V-PARENT")),
5432            )
5433            .unwrap();
5434
5435            assert_eq!(selected.order_status, expected_status);
5436        }
5437    }
5438
5439    #[rstest]
5440    fn test_select_query_order_report_falls_back_to_venue_order_id() {
5441        // Algo child trigger: report's client_order_id is the child, the
5442        // command still carries the pre-trigger venue_order_id.
5443        let reports = vec![make_query_order_report(Some("O-CHILD"), "V-1")];
5444        let selected = select_query_order_report(
5445            reports,
5446            ClientOrderId::from("O-PARENT"),
5447            Some(VenueOrderId::from("V-1")),
5448        );
5449        assert_eq!(
5450            selected.map(|r| r.venue_order_id.as_str().to_string()),
5451            Some("V-1".to_string()),
5452        );
5453    }
5454
5455    #[rstest]
5456    fn test_select_query_order_report_rejects_when_nothing_matches() {
5457        let reports = vec![make_query_order_report(Some("O-OTHER"), "V-OTHER")];
5458        let selected = select_query_order_report(
5459            reports,
5460            ClientOrderId::from("O-001"),
5461            Some(VenueOrderId::from("V-1")),
5462        );
5463        assert!(selected.is_none());
5464    }
5465
5466    #[rstest]
5467    fn test_select_query_order_report_rejects_when_client_differs_and_no_vid_provided() {
5468        let reports = vec![make_query_order_report(Some("O-OTHER"), "V-1")];
5469        let selected = select_query_order_report(reports, ClientOrderId::from("O-001"), None);
5470        assert!(selected.is_none());
5471    }
5472
5473    #[rstest]
5474    fn test_select_query_order_report_ignores_linked_order_ids_for_parent_with_attached_tp() {
5475        // Parent order has attached TP/SL children listed in its
5476        // linked_order_ids. A query for one of those children must NOT
5477        // resolve to the parent's report via the linked_order_ids.
5478        let child_cid = "O-CHILD-TP";
5479        let reports = vec![with_linked(
5480            make_query_order_report(Some("O-PARENT"), "V-PARENT"),
5481            &[child_cid, "O-CHILD-SL"],
5482        )];
5483        let selected = select_query_order_report(reports, ClientOrderId::from(child_cid), None);
5484        assert!(selected.is_none());
5485    }
5486
5487    #[rstest]
5488    fn test_select_query_order_report_client_match_wins_over_vid_match_elsewhere() {
5489        // Ordering invariant: the client_order_id match beats a vid match on
5490        // a different report regardless of which appears first in the list.
5491        let reports = vec![
5492            make_query_order_report(Some("O-OTHER"), "V-1"),
5493            make_query_order_report(Some("O-001"), "V-2"),
5494        ];
5495        let selected = select_query_order_report(
5496            reports,
5497            ClientOrderId::from("O-001"),
5498            Some(VenueOrderId::from("V-1")),
5499        );
5500        assert_eq!(
5501            selected.and_then(|r| r.client_order_id),
5502            Some(ClientOrderId::from("O-001")),
5503        );
5504    }
5505
5506    fn build_test_exec_client() -> OKXExecutionClient {
5507        build_test_exec_client_with_cache().0
5508    }
5509
5510    #[rstest]
5511    fn test_start_replaces_sender_for_existing_emitter_clone() {
5512        std::thread::spawn(|| {
5513            let mut client = build_test_exec_client();
5514            let emitter = client.emitter.clone();
5515            let (sender, mut receiver) = tokio::sync::mpsc::unbounded_channel();
5516            client.set_event_sender(sender.into());
5517            let event = OrderEventAny::Submitted(
5518                OrderSubmittedSpec::builder()
5519                    .client_order_id(ClientOrderId::from("O-CLONED"))
5520                    .build(),
5521            );
5522            emitter.send_order_event(event.clone());
5523
5524            let ExecutionEvent::Order(received) = receiver.try_recv().unwrap() else {
5525                panic!("Expected order event");
5526            };
5527
5528            assert_eq!(received, event);
5529
5530            let (sender_current, mut receiver_current) = tokio::sync::mpsc::unbounded_channel();
5531            replace_exec_event_sender(sender_current);
5532            client.start().unwrap();
5533            emitter.send_order_event(event.clone());
5534
5535            let ExecutionEvent::Order(received) = receiver_current.try_recv().unwrap() else {
5536                panic!("Expected order event");
5537            };
5538
5539            assert_eq!(received, event);
5540            assert_eq!(
5541                receiver.try_recv().unwrap_err(),
5542                tokio::sync::mpsc::error::TryRecvError::Disconnected
5543            );
5544            assert_eq!(
5545                receiver_current.try_recv().unwrap_err(),
5546                tokio::sync::mpsc::error::TryRecvError::Empty
5547            );
5548        })
5549        .join()
5550        .unwrap();
5551    }
5552
5553    #[rstest]
5554    #[case::stop_limit(OrderType::StopLimit, OKXAlgoOrderType::Trigger)]
5555    #[case::stop_market(OrderType::StopMarket, OKXAlgoOrderType::Trigger)]
5556    #[case::touched_limit(OrderType::LimitIfTouched, OKXAlgoOrderType::Trigger)]
5557    #[case::touched_market(OrderType::MarketIfTouched, OKXAlgoOrderType::Trigger)]
5558    #[case::sl_limit(OrderType::StopLimit, OKXAlgoOrderType::Conditional)]
5559    #[case::sl_market(OrderType::StopMarket, OKXAlgoOrderType::Conditional)]
5560    #[case::tp_limit(OrderType::LimitIfTouched, OKXAlgoOrderType::Conditional)]
5561    #[case::tp_market(OrderType::MarketIfTouched, OKXAlgoOrderType::Conditional)]
5562    #[tokio::test]
5563    async fn test_modify_algo_order_http(
5564        #[case] order_type: OrderType,
5565        #[case] algo_type: OKXAlgoOrderType,
5566        #[values("all", "trigger", "quantity")] amendment: &str,
5567        #[values(("0", "0"), ("0", "51000"), ("0", "50004"), ("1", "51000"), ("1", "50004"))]
5568        response: (&'static str, &'static str),
5569    ) {
5570        let (code, s_code) = response;
5571        let (client, cache) = build_test_exec_client_with_cache();
5572        let (submit_tx, mut submit_rx) = tokio::sync::mpsc::unbounded_channel();
5573        let (request_tx, mut request_rx) = tokio::sync::mpsc::unbounded_channel();
5574
5575        let router = Router::new()
5576            .route(
5577                "/api/v5/trade/order-algo",
5578                post(move |Json(request): Json<Value>| {
5579                    let tx = submit_tx.clone();
5580                    async move {
5581                        tx.send(request).unwrap();
5582                        Json(serde_json::json!({"code": "0", "msg": "", "data": [{
5583                            "algoId": "7003", "sCode": "0", "sMsg": ""
5584                        }]}))
5585                    }
5586                }),
5587            )
5588            .route(
5589                "/api/v5/trade/amend-algos",
5590                post(move |Json(request): Json<Value>| {
5591                    let tx = request_tx.clone();
5592                    async move {
5593                        tx.send(request).unwrap();
5594                        Json(serde_json::json!({"code": code, "msg": "All operations failed", "data": [{
5595                            "algoId": "7003", "sCode": s_code, "sMsg": "test message"
5596                        }]}))
5597                    }
5598                }),
5599            );
5600
5601        let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
5602        let base_url = format!("http://{}", listener.local_addr().unwrap());
5603
5604        let server = tokio::spawn(async move { axum::serve(listener, router).await.unwrap() });
5605        let mut client = client;
5606        let (event_tx, mut event_rx) = tokio::sync::mpsc::unbounded_channel();
5607        client.emitter.set_sender(event_tx);
5608        client.http_client = OKXHttpClient::with_credentials(
5609            Some("test_key".into()),
5610            Some("test_secret".into()),
5611            Some("test_pass".into()),
5612            Some(base_url),
5613            5,
5614            0,
5615            1,
5616            1,
5617            crate::common::enums::OKXEnvironment::Live,
5618            None,
5619        )
5620        .unwrap();
5621        let client_order_id = ClientOrderId::from("OMODIFYALGO");
5622        let instrument_id = InstrumentId::from("BTC-USDT-SWAP.OKX");
5623        let order = OrderTestBuilder::new(order_type)
5624            .instrument_id(instrument_id)
5625            .client_order_id(client_order_id)
5626            .side(OrderSide::Sell)
5627            .quantity(Quantity::from("0.03"))
5628            .price(Price::from("54900.0"))
5629            .trigger_price(Price::from("55000.0"))
5630            .trigger_type(TriggerType::MarkPrice)
5631            .build();
5632        let accepted = TestOrderEventStubs::accepted(
5633            &order,
5634            client.core.account_id,
5635            VenueOrderId::from("7003"),
5636        );
5637        cache
5638            .borrow_mut()
5639            .add_order(order.clone(), None, Some(*OKX_CLIENT_ID), false)
5640            .unwrap();
5641        let mut submit = SubmitOrder::from_order(
5642            &order,
5643            TraderId::from("TESTER-001"),
5644            Some(*OKX_CLIENT_ID),
5645            None,
5646            UUID4::new(),
5647            UnixNanos::default(),
5648        );
5649
5650        if algo_type == OKXAlgoOrderType::Conditional {
5651            let params = Params::new([("close_fraction".into(), Value::String("1".into()))].into());
5652            submit.params = Some(params);
5653        }
5654
5655        client.submit_order(submit).unwrap();
5656        let submitted = tokio::time::timeout(Duration::from_secs(5), submit_rx.recv())
5657            .await
5658            .unwrap()
5659            .unwrap();
5660        assert_eq!(
5661            submitted["ordType"],
5662            serde_json::to_value(algo_type).unwrap()
5663        );
5664        wait_until_async(
5665            || async { client.pending_tasks.is_empty() },
5666            Duration::from_secs(5),
5667        )
5668        .await;
5669        assert!(matches!(
5670            event_rx.try_recv().unwrap(),
5671            ExecutionEvent::Order(OrderEventAny::Submitted(_))
5672        ));
5673        assert!(event_rx.try_recv().is_err());
5674        cache.borrow_mut().update_order(&accepted).unwrap();
5675        let limit = matches!(order_type, OrderType::StopLimit | OrderType::LimitIfTouched);
5676        client
5677            .modify_order(ModifyOrder::new(
5678                TraderId::from("TESTER-001"),
5679                Some(*OKX_CLIENT_ID),
5680                order.strategy_id(),
5681                instrument_id,
5682                client_order_id,
5683                Some(VenueOrderId::from("stale-parent")),
5684                (amendment != "trigger").then(|| Quantity::from("0.04")),
5685                (limit && amendment == "all").then(|| Price::from("53900.0")),
5686                (amendment != "quantity").then(|| Price::from("54000.0")),
5687                UUID4::new(),
5688                UnixNanos::default(),
5689                None,
5690                None,
5691            ))
5692            .unwrap();
5693        let request = tokio::time::timeout(Duration::from_secs(5), request_rx.recv())
5694            .await
5695            .unwrap()
5696            .unwrap();
5697        let mut expected = serde_json::json!({"instId": "BTC-USDT-SWAP", "algoId": "7003"});
5698        if amendment != "trigger" {
5699            expected["newSz"] = Value::String("0.04".into());
5700        }
5701
5702        let (trigger_field, type_field, price_field) = if algo_type == OKXAlgoOrderType::Trigger {
5703            ("newTriggerPx", "newTriggerPxType", "newOrdPx")
5704        } else if matches!(order_type, OrderType::StopLimit | OrderType::StopMarket) {
5705            ("newSlTriggerPx", "newSlTriggerPxType", "newSlOrdPx")
5706        } else {
5707            ("newTpTriggerPx", "newTpTriggerPxType", "newTpOrdPx")
5708        };
5709
5710        if amendment != "quantity" {
5711            expected[trigger_field] = Value::String("54000.0".into());
5712            expected[type_field] = Value::String("mark".into());
5713        }
5714
5715        if limit && amendment == "all" {
5716            expected[price_field] = Value::String("53900.0".into());
5717        }
5718
5719        assert_eq!(request, expected);
5720        wait_until_async(
5721            || async { client.pending_tasks.is_empty() },
5722            Duration::from_secs(5),
5723        )
5724        .await;
5725
5726        if s_code == "51000" {
5727            let ExecutionEvent::Order(OrderEventAny::ModifyRejected(rejected)) =
5728                event_rx.try_recv().unwrap()
5729            else {
5730                panic!("expected OrderModifyRejected");
5731            };
5732
5733            assert_eq!(rejected.client_order_id, client_order_id);
5734            assert_eq!(rejected.venue_order_id, Some(VenueOrderId::from("7003")));
5735            assert_eq!(rejected.instrument_id, instrument_id);
5736            assert_eq!(rejected.strategy_id, order.strategy_id());
5737            assert_eq!(rejected.reason.as_str(), "OKX error 51000: test message");
5738        }
5739
5740        assert!(event_rx.try_recv().is_err());
5741        server.abort();
5742    }
5743
5744    #[rstest]
5745    #[case::trigger(
5746        OrderType::StopLimit,
5747        OKXAlgoOrderType::Trigger,
5748        "newOrdPx",
5749        "newTriggerPx",
5750        "newTriggerPxType"
5751    )]
5752    #[case::sl(
5753        OrderType::StopLimit,
5754        OKXAlgoOrderType::Conditional,
5755        "newSlOrdPx",
5756        "newSlTriggerPx",
5757        "newSlTriggerPxType"
5758    )]
5759    #[case::tp(
5760        OrderType::LimitIfTouched,
5761        OKXAlgoOrderType::Conditional,
5762        "newTpOrdPx",
5763        "newTpTriggerPx",
5764        "newTpTriggerPxType"
5765    )]
5766    fn test_algo_amend_request_preserves_unconfirmed_terms(
5767        #[case] order_type: OrderType,
5768        #[case] algo_type: OKXAlgoOrderType,
5769        #[case] price_field: &str,
5770        #[case] trigger_field: &str,
5771        #[case] type_field: &str,
5772    ) {
5773        let order = OrderTestBuilder::new(order_type)
5774            .instrument_id(InstrumentId::from("BTC-USDT-SWAP.OKX"))
5775            .client_order_id(ClientOrderId::from("OUNCONFIRMED"))
5776            .side(OrderSide::Sell)
5777            .quantity(Quantity::from("0.03"))
5778            .price(Price::from("54900.0"))
5779            .trigger_price(Price::from("55000.0"))
5780            .trigger_type(TriggerType::MarkPrice)
5781            .build();
5782        let context = OrderContext::from(&order);
5783
5784        let mut command = ModifyOrder::new(
5785            TraderId::from("TESTER-001"),
5786            Some(*OKX_CLIENT_ID),
5787            order.strategy_id(),
5788            order.instrument_id(),
5789            order.client_order_id(),
5790            Some(VenueOrderId::from("7003")),
5791            None,
5792            Some(Price::from("53900.0")),
5793            None,
5794            UUID4::new(),
5795            UnixNanos::default(),
5796            None,
5797            None,
5798        );
5799        let first = algo_amend_request(&command, Some(algo_type), Some(context)).unwrap();
5800        command.price = None;
5801        command.trigger_price = Some(Price::from("54000.0"));
5802        let second = algo_amend_request(&command, Some(algo_type), Some(context)).unwrap();
5803        command.trigger_price = None;
5804        command.quantity = Some(Quantity::from("0.04"));
5805        let third = algo_amend_request(&command, Some(algo_type), Some(context)).unwrap();
5806        let mut first_expected = serde_json::json!({"instId": "BTC-USDT-SWAP", "algoId": "7003"});
5807        first_expected[price_field] = Value::String("53900.0".into());
5808        let mut second_expected = serde_json::json!({"instId": "BTC-USDT-SWAP", "algoId": "7003"});
5809        second_expected[trigger_field] = Value::String("54000.0".into());
5810        second_expected[type_field] = Value::String("mark".into());
5811        assert_eq!(serde_json::to_value(first).unwrap(), first_expected);
5812        assert_eq!(serde_json::to_value(second).unwrap(), second_expected);
5813        assert_eq!(
5814            serde_json::to_value(third).unwrap(),
5815            serde_json::json!({
5816                "instId": "BTC-USDT-SWAP", "algoId": "7003", "newSz": "0.04"
5817            })
5818        );
5819    }
5820
5821    #[rstest]
5822    #[case::unknown(
5823        None,
5824        true,
5825        true,
5826        "Cannot determine OKX algo order terms for modification"
5827    )]
5828    #[case::missing_context(
5829        Some(OKXAlgoOrderType::Trigger),
5830        false,
5831        true,
5832        "Cannot determine OKX algo order terms for modification"
5833    )]
5834    #[case::missing_id(
5835        Some(OKXAlgoOrderType::Trigger),
5836        true,
5837        false,
5838        "No algo ID available for pending conditional order"
5839    )]
5840    #[case::trailing(
5841        Some(OKXAlgoOrderType::MoveOrderStop),
5842        true,
5843        true,
5844        "OKX does not support modification of this algo order type"
5845    )]
5846    fn test_modify_algo_order_denies_locally(
5847        #[case] algo_type: Option<OKXAlgoOrderType>,
5848        #[case] has_context: bool,
5849        #[case] has_id: bool,
5850        #[case] reason: &str,
5851    ) {
5852        let mut client = build_test_exec_client();
5853        let (event_tx, mut event_rx) = tokio::sync::mpsc::unbounded_channel();
5854        client.emitter.set_sender(event_tx);
5855        let client_order_id = ClientOrderId::from("OMODIFYINVALID");
5856        let instrument_id = InstrumentId::from("BTC-USDT-SWAP.OKX");
5857        let order = OrderTestBuilder::new(OrderType::StopMarket)
5858            .instrument_id(instrument_id)
5859            .client_order_id(client_order_id)
5860            .side(OrderSide::Sell)
5861            .quantity(Quantity::from("0.03"))
5862            .trigger_price(Price::from("55000.0"))
5863            .build();
5864
5865        if has_context {
5866            client
5867                .ws_dispatch_state
5868                .track_order_context(OrderContext::from(&order));
5869        }
5870
5871        if let Some(order_type) = algo_type {
5872            client.ws_dispatch_state.algo_order_states.insert(
5873                client_order_id,
5874                AlgoOrderState {
5875                    order_type,
5876                    ts_last: UnixNanos::default(),
5877                },
5878            );
5879        }
5880
5881        let cause = UUID4::new();
5882        let venue_order_id = has_id.then(|| VenueOrderId::from("7004"));
5883        client.modify_algo_order(&ModifyOrder::new(
5884            TraderId::from("TESTER-001"),
5885            Some(*OKX_CLIENT_ID),
5886            order.strategy_id(),
5887            instrument_id,
5888            client_order_id,
5889            venue_order_id,
5890            None,
5891            None,
5892            Some(Price::from("54000.0")),
5893            cause,
5894            UnixNanos::default(),
5895            None,
5896            None,
5897        ));
5898
5899        let ExecutionEvent::Order(OrderEventAny::ModifyDenied(rejected)) =
5900            event_rx.try_recv().unwrap()
5901        else {
5902            panic!("expected OrderModifyDenied");
5903        };
5904
5905        assert_eq!(rejected.causation_id, Some(cause));
5906        assert_eq!(rejected.client_order_id, client_order_id);
5907        assert_eq!(rejected.venue_order_id, venue_order_id);
5908        assert_eq!(rejected.instrument_id, instrument_id);
5909        assert_eq!(rejected.strategy_id, order.strategy_id());
5910        assert_eq!(rejected.reason.as_str(), reason);
5911        assert!(event_rx.try_recv().is_err());
5912        assert!(client.pending_tasks.is_empty());
5913    }
5914
5915    #[rstest]
5916    #[case::client_id(true)]
5917    #[case::venue_id(false)]
5918    fn test_report_fallback_uses_current_cache(#[case] match_client_id: bool) {
5919        let (client, cache) = build_test_exec_client_with_cache();
5920        let parent = make_query_order_report(Some("O-PARENT"), "V-PARENT");
5921        let regular = make_query_order_report(Some("O-REGULAR"), "V-REGULAR");
5922        let fallback = make_query_order_report(None, "V-CHILD");
5923        let external = make_query_order_report(None, "V-EXTERNAL");
5924        let fallback_parents = AHashMap::from_iter([
5925            (1, parent.clone()),
5926            (
5927                2,
5928                make_query_order_report(Some("O-EXTERNAL"), "V-EXTERNAL-PARENT"),
5929            ),
5930        ]);
5931        let mut reports = vec![regular.clone(), fallback.clone(), external.clone()];
5932        retain_external_regular_order_fallbacks(&client.core, &mut reports, &fallback_parents);
5933        assert_eq!(reports, [regular.clone(), fallback, external.clone()]);
5934
5935        let order = OrderTestBuilder::new(OrderType::Limit)
5936            .instrument_id(parent.instrument_id)
5937            .side(OrderSide::Buy)
5938            .price(Price::from("100.00"))
5939            .quantity(Quantity::from("1"))
5940            .client_order_id(ClientOrderId::from(if match_client_id {
5941                "O-PARENT"
5942            } else {
5943                "O-OTHER"
5944            }))
5945            .build();
5946
5947        let accepted =
5948            TestOrderEventStubs::accepted(&order, client.core.account_id, parent.venue_order_id);
5949        cache
5950            .borrow_mut()
5951            .add_order(order, None, Some(*OKX_CLIENT_ID), false)
5952            .unwrap();
5953        cache.borrow_mut().update_order(&accepted).unwrap();
5954        retain_external_regular_order_fallbacks(&client.core, &mut reports, &fallback_parents);
5955
5956        assert_eq!(reports, [regular, external]);
5957    }
5958
5959    fn build_test_exec_client_with_cache() -> (OKXExecutionClient, Rc<RefCell<Cache>>) {
5960        let config = OKXExecutionClientConfig {
5961            api_key: Some("test_key".into()),
5962            api_secret: Some("test_secret".into()),
5963            api_passphrase: Some("test_pass".into()),
5964            ..OKXExecutionClientConfig::default()
5965        };
5966
5967        let cache = Rc::new(RefCell::new(Cache::default()));
5968        let core = ExecutionClientCore::new(
5969            TraderId::from("TESTER-001"),
5970            ClientId::from("OKX-TEST"),
5971            *OKX_VENUE,
5972            OmsType::Hedging,
5973            config.account_id,
5974            AccountType::Cash,
5975            None,
5976            Rc::clone(&cache),
5977        );
5978
5979        (
5980            OKXExecutionClient::new(core, config).expect("failed to build test client"),
5981            cache,
5982        )
5983    }
5984
5985    #[rstest]
5986    #[case::reset(ExecutionTaskBoundary::Reset)]
5987    #[case::dispose(ExecutionTaskBoundary::Dispose)]
5988    #[case::repeated_stop(ExecutionTaskBoundary::RepeatedStop)]
5989    #[tokio::test]
5990    async fn lifecycle_boundary_terminates_owned_execution_task(
5991        #[case] boundary: ExecutionTaskBoundary,
5992    ) {
5993        let mut client = build_test_exec_client();
5994
5995        if matches!(boundary, ExecutionTaskBoundary::RepeatedStop) {
5996            client.stop().expect("initial stop");
5997        }
5998
5999        let (drop_tx, drop_rx) = tokio::sync::oneshot::channel();
6000        let signal = DropSignal(Some(drop_tx));
6001        client.spawn_task("pending lifecycle task", async move {
6002            let _signal = signal;
6003            std::future::pending::<anyhow::Result<()>>().await
6004        });
6005
6006        match boundary {
6007            ExecutionTaskBoundary::Reset => client.reset().expect("reset"),
6008            ExecutionTaskBoundary::Dispose => client.dispose().expect("dispose"),
6009            ExecutionTaskBoundary::RepeatedStop => client.stop().expect("repeated stop"),
6010        }
6011
6012        tokio::time::timeout(Duration::from_secs(1), drop_rx)
6013            .await
6014            .expect("lifecycle boundary must drop the owned task")
6015            .expect("drop signal");
6016        terminate_tasks(&client.pending_tasks, "test execution client")
6017            .await
6018            .expect("execution task terminated");
6019        assert!(client.pending_tasks.is_empty());
6020    }
6021
6022    #[rstest]
6023    #[case("BTC-USDT.OKX", false, None, CancelAllOrdersRoute::Batch)]
6024    #[case("BTC-USDT.OKX", true, None, CancelAllOrdersRoute::MassCancelHttp)]
6025    #[case(
6026        "BTC-USDT.OKX",
6027        true,
6028        Some(OrderSide::Buy),
6029        CancelAllOrdersRoute::Batch
6030    )]
6031    #[case(
6032        "BTC-USDT.OKX",
6033        true,
6034        Some(OrderSide::Sell),
6035        CancelAllOrdersRoute::Batch
6036    )]
6037    #[case(
6038        "ETH-USD-SWAP_ETH-USD-231229.OKX",
6039        false,
6040        None,
6041        CancelAllOrdersRoute::SpreadHttp
6042    )]
6043    #[case(
6044        "ETH-USD-SWAP_ETH-USD-231229.OKX",
6045        false,
6046        Some(OrderSide::Buy),
6047        CancelAllOrdersRoute::Batch
6048    )]
6049    #[case(
6050        "ETH-USD-SWAP_ETH-USD-231229.OKX",
6051        true,
6052        Some(OrderSide::Sell),
6053        CancelAllOrdersRoute::Batch
6054    )]
6055    fn test_cancel_all_orders_route(
6056        #[case] instrument_id: &str,
6057        #[case] use_mm_mass_cancel: bool,
6058        #[case] order_side: Option<OrderSide>,
6059        #[case] expected: CancelAllOrdersRoute,
6060    ) {
6061        let mut client = build_test_exec_client();
6062        client.config.use_mm_mass_cancel = use_mm_mass_cancel;
6063
6064        assert_eq!(
6065            client.cancel_all_orders_route(InstrumentId::from(instrument_id), order_side),
6066            expected
6067        );
6068    }
6069
6070    #[rstest]
6071    #[case::buy(Some(OrderSide::Buy), false, &["OCANCEL0", "OCANCEL2"])]
6072    #[case::sell(Some(OrderSide::Sell), false, &["OCANCEL1", "OCANCEL3"])]
6073    #[case::both(None, false, &["OCANCEL0", "OCANCEL1", "OCANCEL2", "OCANCEL3"])]
6074    #[case::mass_buy(Some(OrderSide::Buy), true, &["OCANCEL0", "OCANCEL2"])]
6075    #[case::mass_sell(Some(OrderSide::Sell), true, &["OCANCEL1", "OCANCEL3"])]
6076    #[tokio::test]
6077    async fn test_cancel_all_orders_filters_cached_orders(
6078        #[case] order_side: Option<OrderSide>,
6079        #[case] use_mm_mass_cancel: bool,
6080        #[case] expected_ids: &[&str],
6081        #[values(1, 10, 11)] copies: usize,
6082    ) {
6083        let (mut client, cache) = build_test_exec_client_with_cache();
6084        client.config.use_mm_mass_cancel = use_mm_mass_cancel;
6085        let (server, mut request_rx) = connect_cancel_websocket(&mut client).await;
6086        let instrument_id = InstrumentId::from("BTC-USDT.OKX");
6087
6088        let expected_ids: Vec<_> = (0..copies)
6089            .flat_map(|copy| {
6090                expected_ids.iter().map(move |id| {
6091                    let index: usize = id.strip_prefix("OCANCEL").unwrap().parse().unwrap();
6092                    format!("OCANCEL{}", copy * 8 + index)
6093                })
6094            })
6095            .collect();
6096
6097        let mut expected: Vec<_> = expected_ids
6098            .iter()
6099            .map(|id| ClientOrderId::from(id.as_str()))
6100            .collect();
6101
6102        for copy in 0..copies {
6103            for (index, (symbol, side, strategy, open)) in [
6104                ("BTC-USDT.OKX", OrderSide::Buy, "S-001", true),
6105                ("BTC-USDT.OKX", OrderSide::Sell, "S-001", true),
6106                ("BTC-USDT.OKX", OrderSide::Buy, "S-002", true),
6107                ("BTC-USDT.OKX", OrderSide::Sell, "S-002", true),
6108                ("ETH-USDT.OKX", OrderSide::Buy, "S-001", true),
6109                ("ETH-USDT.OKX", OrderSide::Sell, "S-001", true),
6110                ("BTC-USDT.OKX", OrderSide::Buy, "S-001", false),
6111                ("BTC-USDT.OKX", OrderSide::Sell, "S-001", false),
6112            ]
6113            .into_iter()
6114            .enumerate()
6115            {
6116                let index = copy * 8 + index;
6117                let client_order_id = ClientOrderId::from(format!("OCANCEL{index}"));
6118                let mut order = OrderTestBuilder::new(OrderType::Limit)
6119                    .instrument_id(InstrumentId::from(symbol))
6120                    .client_order_id(client_order_id)
6121                    .strategy_id(StrategyId::from(strategy))
6122                    .side(side)
6123                    .price(Price::from("100.00"))
6124                    .quantity(Quantity::from("1"))
6125                    .build();
6126                let accepted = TestOrderEventStubs::accepted(
6127                    &order,
6128                    client.core.account_id,
6129                    VenueOrderId::from(format!("{index}")),
6130                );
6131                cache
6132                    .borrow_mut()
6133                    .add_order(order.clone(), None, Some(*OKX_CLIENT_ID), false)
6134                    .unwrap();
6135                order = cache.borrow_mut().update_order(&accepted).unwrap();
6136
6137                if !open {
6138                    let canceled = TestOrderEventStubs::canceled(
6139                        &order,
6140                        client.core.account_id,
6141                        order.venue_order_id(),
6142                    );
6143                    cache.borrow_mut().update_order(&canceled).unwrap();
6144                }
6145            }
6146        }
6147
6148        client
6149            .cancel_all_orders(CancelAllOrders::new(
6150                TraderId::from("TESTER-001"),
6151                Some(*OKX_CLIENT_ID),
6152                StrategyId::from("S-001"),
6153                instrument_id,
6154                order_side,
6155                UUID4::new(),
6156                UnixNanos::default(),
6157                None,
6158                None,
6159            ))
6160            .unwrap();
6161        let mut actual: Vec<_> = client
6162            .ws_dispatch_state
6163            .order_identities
6164            .iter()
6165            .map(|entry| *entry.key())
6166            .collect();
6167        actual.sort();
6168
6169        let expected_sizes: &[usize] = match (copies, order_side) {
6170            (1, Some(_)) => &[2],
6171            (1, None) => &[4],
6172            (10, Some(_)) => &[20],
6173            (10, None) => &[20, 20],
6174            (11, Some(_)) => &[20, 2],
6175            (11, None) => &[20, 20, 4],
6176            _ => unreachable!(),
6177        };
6178
6179        let mut payload = Vec::new();
6180        let mut batch_sizes = Vec::new();
6181
6182        for _ in expected_sizes {
6183            let request = tokio::time::timeout(Duration::from_secs(5), request_rx.recv())
6184                .await
6185                .unwrap()
6186                .unwrap();
6187            assert_eq!(request["op"], "batch-cancel-orders");
6188            let args = request["args"].as_array().unwrap();
6189            batch_sizes.push(args.len());
6190            payload.extend(args.iter().cloned());
6191        }
6192
6193        payload.sort_by_key(|item| item["clOrdId"].as_str().unwrap().to_string());
6194
6195        let mut expected_payload: Vec<_> = expected_ids
6196            .iter()
6197            .map(|id| {
6198                serde_json::json!({
6199                    "instIdCode": 10459,
6200                    "clOrdId": id,
6201                    "ordId": id.strip_prefix("OCANCEL").unwrap(),
6202                })
6203            })
6204            .collect();
6205
6206        expected.sort();
6207        expected_payload.sort_by_key(|item| item["clOrdId"].as_str().unwrap().to_string());
6208        client.ws_private.close().await.unwrap();
6209        server.abort();
6210
6211        assert_eq!(batch_sizes, expected_sizes);
6212        assert_eq!(payload, expected_payload);
6213        assert_eq!(actual, expected);
6214        terminate_tasks(&client.pending_tasks, "test execution client")
6215            .await
6216            .unwrap();
6217    }
6218
6219    #[rstest]
6220    #[case::algo_buy("BTC-USDT.OKX", OrderType::StopLimit, Some(OrderSide::Buy), &["0", "2"], false)]
6221    #[case::algo_sell("BTC-USDT.OKX", OrderType::StopLimit, Some(OrderSide::Sell), &["1", "3"], false)]
6222    #[case::algo_both("BTC-USDT.OKX", OrderType::StopLimit, None, &["0", "1", "2", "3"], false)]
6223    #[case::spread_buy("ETH-USD-SWAP_ETH-USD-231229.OKX", OrderType::Limit, Some(OrderSide::Buy), &["0", "2"], false)]
6224    #[case::spread_sell("ETH-USD-SWAP_ETH-USD-231229.OKX", OrderType::Limit, Some(OrderSide::Sell), &["1", "3"], false)]
6225    #[case::advance_buy("BTC-USDT.OKX", OrderType::TrailingStopMarket, Some(OrderSide::Buy), &["0", "2"], false)]
6226    #[case::advance_sell("BTC-USDT.OKX", OrderType::TrailingStopMarket, Some(OrderSide::Sell), &["1", "3"], false)]
6227    #[case::advance_both("BTC-USDT.OKX", OrderType::TrailingStopMarket, None, &["0", "1", "2", "3"], false)]
6228    #[case::mixed_buy("BTC-USDT.OKX", OrderType::StopLimit, Some(OrderSide::Buy), &["0", "2"], true)]
6229    #[case::mixed_sell("BTC-USDT.OKX", OrderType::StopLimit, Some(OrderSide::Sell), &["1", "3"], true)]
6230    #[case::mixed_both("BTC-USDT.OKX", OrderType::StopLimit, None, &["0", "1", "2", "3"], true)]
6231    #[tokio::test]
6232    async fn test_cancel_all_orders_filters_http_requests(
6233        #[case] symbol: &str,
6234        #[case] order_type: OrderType,
6235        #[case] order_side: Option<OrderSide>,
6236        #[case] expected_ids: &[&str],
6237        #[case] mixed_types: bool,
6238        #[values(1, 5, 6)] copies: usize,
6239    ) {
6240        let (request_tx, mut request_rx) = tokio::sync::mpsc::unbounded_channel();
6241
6242        let router = Router::new().fallback(post(
6243            move |uri: axum::http::Uri, Json(request): Json<Value>| {
6244                let tx = request_tx.clone();
6245                async move {
6246                    let mut response = serde_json::from_str::<Value>(include_str!(
6247                        "../test_data/http_cancel_algo_order_response.json"
6248                    ))
6249                    .unwrap();
6250
6251                    if let Some(ord_id) = request.get("ordId") {
6252                        response["data"][0]
6253                            .as_object_mut()
6254                            .unwrap()
6255                            .remove("algoId");
6256                        response["data"][0]["ordId"] = ord_id.clone();
6257                    } else {
6258                        let template = response["data"][0].clone();
6259                        response["data"] = request
6260                            .as_array()
6261                            .unwrap()
6262                            .iter()
6263                            .map(|item| {
6264                                let mut result = template.clone();
6265                                result["algoId"] = item["algoId"].clone();
6266                                result
6267                            })
6268                            .collect();
6269                    }
6270
6271                    tx.send((uri.path().to_string(), request)).unwrap();
6272                    Json(response)
6273                }
6274            },
6275        ));
6276
6277        let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
6278        let base_url = format!("http://{}", listener.local_addr().unwrap());
6279
6280        let server = tokio::spawn(async move { axum::serve(listener, router).await.unwrap() });
6281        let (mut client, cache) = build_test_exec_client_with_cache();
6282        client.http_client = OKXHttpClient::with_credentials(
6283            Some("test_key".into()),
6284            Some("test_secret".into()),
6285            Some("test_pass".into()),
6286            Some(base_url),
6287            5,
6288            0,
6289            1,
6290            1,
6291            client.config.environment,
6292            None,
6293        )
6294        .unwrap();
6295        let instrument_id = InstrumentId::from(symbol);
6296
6297        let mut expected_ids: Vec<_> = (0..copies)
6298            .flat_map(|copy| {
6299                expected_ids.iter().map(move |id| {
6300                    let index: usize = id.parse().unwrap();
6301                    (copy * 4 + index).to_string()
6302                })
6303            })
6304            .collect();
6305
6306        for copy in 0..copies {
6307            for (index, side) in [
6308                OrderSide::Buy,
6309                OrderSide::Sell,
6310                OrderSide::Buy,
6311                OrderSide::Sell,
6312            ]
6313            .into_iter()
6314            .enumerate()
6315            {
6316                let index = copy * 4 + index;
6317
6318                let cached_order_type = if mixed_types && index % 4 >= 2 {
6319                    OrderType::TrailingStopMarket
6320                } else {
6321                    order_type
6322                };
6323
6324                let order = OrderTestBuilder::new(cached_order_type)
6325                    .instrument_id(instrument_id)
6326                    .client_order_id(ClientOrderId::from(format!("OHTTP{index}")))
6327                    .strategy_id(StrategyId::from(if index % 4 < 2 {
6328                        "S-001"
6329                    } else {
6330                        "S-002"
6331                    }))
6332                    .side(side)
6333                    .price(Price::from("100.00"))
6334                    .trigger_price(Price::from("101.00"))
6335                    .trailing_offset(rust_decimal::Decimal::ONE)
6336                    .trailing_offset_type(TrailingOffsetType::Price)
6337                    .quantity(Quantity::from("1"))
6338                    .build();
6339
6340                let accepted = TestOrderEventStubs::accepted(
6341                    &order,
6342                    client.core.account_id,
6343                    VenueOrderId::from(format!("{index}")),
6344                );
6345                cache
6346                    .borrow_mut()
6347                    .add_order(order, None, Some(*OKX_CLIENT_ID), false)
6348                    .unwrap();
6349                cache.borrow_mut().update_order(&accepted).unwrap();
6350            }
6351        }
6352
6353        client
6354            .cancel_all_orders(CancelAllOrders::new(
6355                TraderId::from("TESTER-001"),
6356                Some(*OKX_CLIENT_ID),
6357                StrategyId::from("S-001"),
6358                instrument_id,
6359                order_side,
6360                UUID4::new(),
6361                UnixNanos::default(),
6362                None,
6363                None,
6364            ))
6365            .unwrap();
6366        wait_until_async(
6367            || async { client.pending_tasks.is_empty() },
6368            Duration::from_secs(5),
6369        )
6370        .await;
6371
6372        let mut expected_sizes = if order_type == OrderType::Limit {
6373            vec![1; expected_ids.len()]
6374        } else if mixed_types {
6375            match (copies, order_side) {
6376                (1, Some(_)) => vec![1, 1],
6377                (1, None) => vec![2, 2],
6378                (5, Some(_)) => vec![5, 5],
6379                (5, None) => vec![10, 10],
6380                (6, Some(_)) => vec![6, 6],
6381                (6, None) => vec![10, 2, 10, 2],
6382                _ => unreachable!(),
6383            }
6384        } else {
6385            match (copies, order_side) {
6386                (1, Some(_)) => vec![2],
6387                (1, None) => vec![4],
6388                (5, Some(_)) => vec![10],
6389                (5, None) => vec![10, 10],
6390                (6, Some(_)) => vec![10, 2],
6391                (6, None) => vec![10, 10, 4],
6392                _ => unreachable!(),
6393            }
6394        };
6395
6396        let mut actual = Vec::new();
6397        let mut batch_sizes = Vec::new();
6398
6399        while let Ok((path, request)) = request_rx.try_recv() {
6400            if order_type == OrderType::Limit {
6401                assert_eq!(path, "/api/v5/sprd/cancel-order");
6402                batch_sizes.push(1);
6403                actual.push(request["ordId"].as_str().unwrap().to_string());
6404            } else {
6405                batch_sizes.push(request.as_array().unwrap().len());
6406                for item in request.as_array().unwrap() {
6407                    let index: usize = item["algoId"].as_str().unwrap().parse().unwrap();
6408
6409                    let expected_path = if order_type == OrderType::TrailingStopMarket
6410                        || (mixed_types && index % 4 >= 2)
6411                    {
6412                        "/api/v5/trade/cancel-advance-algos"
6413                    } else {
6414                        "/api/v5/trade/cancel-algos"
6415                    };
6416
6417                    assert_eq!(path, expected_path);
6418                    assert_eq!(item["instId"], "BTC-USDT");
6419                    actual.push(item["algoId"].as_str().unwrap().to_string());
6420                }
6421            }
6422        }
6423
6424        server.abort();
6425        actual.sort();
6426        expected_ids.sort();
6427        batch_sizes.sort_unstable();
6428        expected_sizes.sort_unstable();
6429
6430        assert_eq!(actual, expected_ids);
6431        assert_eq!(batch_sizes, expected_sizes);
6432    }
6433
6434    #[rstest]
6435    #[case("BTC-USDT.OKX", false)]
6436    #[case("BTC-USDT.OKX", true)]
6437    #[case("ETH-USD-SWAP_ETH-USD-231229.OKX", false)]
6438    #[tokio::test]
6439    async fn test_cancel_all_orders_empty_cache_sends_nothing(
6440        #[case] instrument_id: &str,
6441        #[case] use_mm_mass_cancel: bool,
6442    ) {
6443        let mut client = build_test_exec_client();
6444        client.config.use_mm_mass_cancel = use_mm_mass_cancel;
6445        client
6446            .cancel_all_orders(CancelAllOrders::new(
6447                TraderId::from("TESTER-001"),
6448                Some(*OKX_CLIENT_ID),
6449                StrategyId::from("S-001"),
6450                InstrumentId::from(instrument_id),
6451                Some(OrderSide::Buy),
6452                UUID4::new(),
6453                UnixNanos::default(),
6454                None,
6455                None,
6456            ))
6457            .unwrap();
6458
6459        assert!(client.pending_tasks.is_empty());
6460        assert!(client.ws_dispatch_state.order_identities.is_empty());
6461    }
6462
6463    #[rstest]
6464    fn test_order_command_route_uses_bound_child_before_engine_trigger_state_updates() {
6465        let client = build_test_exec_client();
6466        let instrument_id = InstrumentId::from("BTC-USDT-SWAP.OKX");
6467        let pending_trigger = Some((OrderType::StopLimit, Some(false)));
6468
6469        assert_eq!(
6470            client.order_command_route(instrument_id, pending_trigger, false),
6471            OrderCommandRoute::AlgoHttp
6472        );
6473        assert_eq!(
6474            client.order_command_route(instrument_id, pending_trigger, true),
6475            OrderCommandRoute::RegularWs
6476        );
6477        assert_eq!(
6478            client.order_command_route(
6479                instrument_id,
6480                Some((OrderType::StopLimit, Some(true))),
6481                false
6482            ),
6483            OrderCommandRoute::RegularWs
6484        );
6485    }
6486
6487    #[rstest]
6488    #[case(
6489        OrderType::StopMarket,
6490        OrderSide::Sell,
6491        true,
6492        "UNSUPPORTED_QUOTE_QUANTITY"
6493    )]
6494    #[case(
6495        OrderType::MarketIfTouched,
6496        OrderSide::Sell,
6497        true,
6498        "UNSUPPORTED_QUOTE_QUANTITY"
6499    )]
6500    #[case(
6501        OrderType::TrailingStopMarket,
6502        OrderSide::Sell,
6503        true,
6504        "UNSUPPORTED_QUOTE_QUANTITY"
6505    )]
6506    #[case(
6507        OrderType::StopLimit,
6508        OrderSide::Sell,
6509        true,
6510        "UNSUPPORTED_QUOTE_QUANTITY"
6511    )]
6512    #[case(
6513        OrderType::LimitIfTouched,
6514        OrderSide::Sell,
6515        true,
6516        "UNSUPPORTED_QUOTE_QUANTITY"
6517    )]
6518    #[case(
6519        OrderType::StopLimit,
6520        OrderSide::Buy,
6521        true,
6522        "UNSUPPORTED_QUOTE_QUANTITY"
6523    )]
6524    #[case(
6525        OrderType::LimitIfTouched,
6526        OrderSide::Buy,
6527        true,
6528        "UNSUPPORTED_QUOTE_QUANTITY"
6529    )]
6530    #[case(
6531        OrderType::TrailingStopMarket,
6532        OrderSide::Buy,
6533        false,
6534        "OKX Spot TRAILING_STOP_MARKET algo buys require quote quantity"
6535    )]
6536    #[case(
6537        OrderType::StopMarket,
6538        OrderSide::Buy,
6539        false,
6540        "OKX Spot STOP_MARKET algo orders do not support BID_ASK triggers"
6541    )]
6542    fn test_submit_order_denies_unsupported_spot_algo_terms_before_submission(
6543        #[case] order_type: OrderType,
6544        #[case] side: OrderSide,
6545        #[case] quote_quantity: bool,
6546        #[case] expected_reason: &str,
6547        #[values("cash", "cross", "isolated")] mode: &str,
6548    ) {
6549        let (mut client, cache) = build_test_exec_client_with_cache();
6550        let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel();
6551        client.emitter.set_sender(tx);
6552
6553        let order = OrderTestBuilder::new(order_type)
6554            .instrument_id(InstrumentId::from("ETH-USDT.OKX"))
6555            .client_order_id(ClientOrderId::from("OQUOTEDENIED"))
6556            .side(side)
6557            .quantity(Quantity::from("12.34"))
6558            .quote_quantity(quote_quantity)
6559            .price(Price::from(if side == OrderSide::Buy {
6560                "2350.12"
6561            } else {
6562                "2340.12"
6563            }))
6564            .trigger_price(Price::from("2345.67"))
6565            .trigger_type(if expected_reason.ends_with("triggers") {
6566                TriggerType::BidAsk
6567            } else {
6568                TriggerType::LastPrice
6569            })
6570            .trailing_offset(Decimal::new(25, 0))
6571            .trailing_offset_type(TrailingOffsetType::BasisPoints)
6572            .build();
6573
6574        cache
6575            .borrow_mut()
6576            .add_order(order.clone(), None, Some(*OKX_CLIENT_ID), false)
6577            .unwrap();
6578        let mut command = SubmitOrder::from_order(
6579            &order,
6580            client.core.trader_id,
6581            Some(*OKX_CLIENT_ID),
6582            None,
6583            UUID4::new(),
6584            UnixNanos::default(),
6585        );
6586
6587        command.params = Some(Params::new(
6588            [("td_mode".to_string(), Value::String(mode.to_string()))].into(),
6589        ));
6590        let trade_mode = mode.parse::<OKXTradeMode>().unwrap();
6591
6592        client.submit_order(command).unwrap();
6593        let event = rx.try_recv().unwrap();
6594
6595        let ExecutionEvent::Order(OrderEventAny::Denied(denied)) = event else {
6596            panic!("Expected denial, received {event:?}");
6597        };
6598
6599        assert_eq!(denied.client_order_id, order.client_order_id());
6600
6601        let expected = if expected_reason == "UNSUPPORTED_QUOTE_QUANTITY" {
6602            expected_reason.to_string()
6603        } else if expected_reason.ends_with("triggers") {
6604            format!("VALIDATION_FAILED: {expected_reason}")
6605        } else {
6606            format!("VALIDATION_FAILED: {expected_reason} in {trade_mode} mode")
6607        };
6608
6609        assert_eq!(denied.reason.as_str(), expected);
6610        assert_eq!(
6611            rx.try_recv().unwrap_err(),
6612            tokio::sync::mpsc::error::TryRecvError::Empty
6613        );
6614        assert_eq!(
6615            client
6616                .ws_dispatch_state
6617                .order_context(order.client_order_id()),
6618            None
6619        );
6620        assert!(client.ws_dispatch_state.algo_order_states.is_empty());
6621    }
6622
6623    #[rstest]
6624    #[case(OrderType::StopMarket, "slTriggerPx", "newSlTriggerPx")]
6625    #[case(OrderType::MarketIfTouched, "tpTriggerPx", "newTpTriggerPx")]
6626    #[tokio::test]
6627    async fn test_submit_cash_spot_buy_records_conditional_before_stream_update(
6628        #[case] order_type: OrderType,
6629        #[case] trigger_field: &str,
6630        #[case] amend_field: &str,
6631        #[values(false, true)] quote_quantity: bool,
6632    ) {
6633        let (request_tx, mut request_rx) = tokio::sync::mpsc::unbounded_channel();
6634        let router = Router::new().route("/api/v5/trade/order-algo", post(
6635            move |Json(request): Json<Value>| {
6636                let tx = request_tx.clone();
6637                async move {
6638                    tx.send(request).unwrap();
6639                    Json(serde_json::json!({"code": "0", "msg": "", "data": [{
6640                        "algoId": "7003", "algoClOrdId": "OSPOTCONDITIONAL", "sCode": "0", "sMsg": ""
6641                    }]}))
6642                }
6643            },
6644        ));
6645
6646        let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
6647        let base_url = format!("http://{}", listener.local_addr().unwrap());
6648
6649        let server = tokio::spawn(async move { axum::serve(listener, router).await.unwrap() });
6650        let (mut client, cache) = build_test_exec_client_with_cache();
6651        client.http_client = OKXHttpClient::with_credentials(
6652            Some("test_key".into()),
6653            Some("test_secret".into()),
6654            Some("test_pass".into()),
6655            Some(base_url),
6656            5,
6657            0,
6658            1,
6659            1,
6660            OKXEnvironment::Live,
6661            None,
6662        )
6663        .unwrap();
6664        let client_order_id = ClientOrderId::from("OSPOTCONDITIONAL");
6665        let (event_tx, mut event_rx) = tokio::sync::mpsc::unbounded_channel();
6666        client.emitter.set_sender(event_tx);
6667
6668        let quantity = Quantity::from(if quote_quantity {
6669            "12.34500"
6670        } else {
6671            "0.12345"
6672        });
6673
6674        let order = OrderTestBuilder::new(order_type)
6675            .instrument_id(InstrumentId::from("ETH-USDT.OKX"))
6676            .client_order_id(client_order_id)
6677            .side(OrderSide::Buy)
6678            .quantity(quantity)
6679            .quote_quantity(quote_quantity)
6680            .trigger_price(Price::from("2345.67"))
6681            .trigger_type(TriggerType::LastPrice)
6682            .build();
6683        cache
6684            .borrow_mut()
6685            .add_order(order.clone(), None, Some(*OKX_CLIENT_ID), false)
6686            .unwrap();
6687        let submit = SubmitOrder::from_order(
6688            &order,
6689            client.core.trader_id,
6690            Some(*OKX_CLIENT_ID),
6691            None,
6692            UUID4::new(),
6693            UnixNanos::default(),
6694        );
6695        client.submit_order(submit).unwrap();
6696        let request = tokio::time::timeout(Duration::from_secs(5), request_rx.recv())
6697            .await
6698            .unwrap()
6699            .unwrap();
6700        let algo_type = client
6701            .ws_dispatch_state
6702            .algo_order_states
6703            .get(&client_order_id)
6704            .unwrap()
6705            .order_type;
6706        let context = client.ws_dispatch_state.order_context(client_order_id);
6707
6708        let amend = ModifyOrder::new(
6709            client.core.trader_id,
6710            Some(*OKX_CLIENT_ID),
6711            order.strategy_id(),
6712            order.instrument_id(),
6713            client_order_id,
6714            Some(VenueOrderId::from("7003")),
6715            None,
6716            None,
6717            Some(Price::from("2456.78")),
6718            UUID4::new(),
6719            UnixNanos::default(),
6720            None,
6721            None,
6722        );
6723        let amendment = algo_amend_request(&amend, Some(algo_type), context).unwrap();
6724        let amendment = serde_json::to_value(amendment).unwrap();
6725        wait_until_async(
6726            || async { client.pending_tasks.all_finished() },
6727            Duration::from_secs(5),
6728        )
6729        .await;
6730        server.abort();
6731
6732        assert_eq!(request["ordType"], "conditional");
6733        assert_eq!(
6734            request["tgtCcy"],
6735            if quote_quantity {
6736                "quote_ccy"
6737            } else {
6738                "base_ccy"
6739            }
6740        );
6741        assert_eq!(request["sz"], quantity.to_string());
6742        assert_eq!(request[trigger_field], "2345.67");
6743        assert_eq!(algo_type, OKXAlgoOrderType::Conditional);
6744        assert_eq!(context.unwrap().is_quote_quantity, quote_quantity);
6745        assert_eq!(amendment[amend_field], "2456.78");
6746        assert_eq!(amendment.get("newTriggerPx"), None);
6747
6748        let mut instrument = currency_pair_ethusdt();
6749        instrument.id = order.instrument_id();
6750        instrument.raw_symbol = Symbol::from("ETH-USDT");
6751        let instruments = AtomicMap::new();
6752        instruments.insert(
6753            Ustr::from("ETH-USDT"),
6754            InstrumentAny::CurrencyPair(instrument),
6755        );
6756        let mut fee_cache = FeeCache::new();
6757        let mut fills = FilledQtyCache::new();
6758        let mut snapshots = AHashMap::new();
6759        let mut parent: Value =
6760            serde_json::from_str(include_str!("../test_data/ws_orders_algo.json")).unwrap();
6761        let msg = &mut parent["data"][0];
6762        for (key, value) in [
6763            ("algoId", Value::from("7003")),
6764            ("algoClOrdId", Value::from(client_order_id.as_str())),
6765            ("instId", Value::from("ETH-USDT")),
6766            ("instType", Value::from("SPOT")),
6767            ("side", Value::from("buy")),
6768            ("posSide", Value::from("net")),
6769            ("tdMode", Value::from("cash")),
6770            ("reduceOnly", Value::from("false")),
6771            ("ordType", request["ordType"].clone()),
6772            ("sz", request["sz"].clone()),
6773            ("tgtCcy", request["tgtCcy"].clone()),
6774            (trigger_field, request[trigger_field].clone()),
6775            ("triggerPx", Value::from("")),
6776        ] {
6777            msg[key] = value;
6778        }
6779
6780        let (price_field, type_field) = if order_type == OrderType::StopMarket {
6781            ("slOrdPx", "slTriggerPxType")
6782        } else {
6783            ("tpOrdPx", "tpTriggerPxType")
6784        };
6785
6786        msg[price_field] = Value::from("-1");
6787        msg[type_field] = Value::from("last");
6788        let pending = OKXWsMessage::AlgoOrders(
6789            serde_json::from_value(serde_json::json!([msg.clone()])).unwrap(),
6790        );
6791        let pending_replay = OKXWsMessage::AlgoOrders(
6792            serde_json::from_value(serde_json::json!([msg.clone()])).unwrap(),
6793        );
6794        msg[trigger_field] = Value::from("2456.78");
6795        msg["uTime"] = Value::from("1737400000050");
6796        let amended = OKXWsMessage::AlgoOrders(
6797            serde_json::from_value(serde_json::json!([msg.clone()])).unwrap(),
6798        );
6799        let amended_replay = OKXWsMessage::AlgoOrders(
6800            serde_json::from_value(serde_json::json!([msg.clone()])).unwrap(),
6801        );
6802        msg["state"] = Value::from("order_placed");
6803        msg["ordId"] = Value::from("7004");
6804        msg["uTime"] = Value::from("1737400000100");
6805        let triggered = OKXWsMessage::AlgoOrders(
6806            serde_json::from_value(serde_json::json!([msg.clone()])).unwrap(),
6807        );
6808        let mut child: Value = serde_json::from_str(include_str!(
6809            "../test_data/ws_orders_algo_child_filled_empty_cl_ord_id.json"
6810        ))
6811        .unwrap();
6812        let msg = &mut child["data"][0];
6813
6814        let filled_qty = if quote_quantity { "0.00500" } else { "0.12345" };
6815
6816        for (key, value) in [
6817            ("algoId", "7003"),
6818            ("algoClOrdId", client_order_id.as_str()),
6819            ("ordId", "7004"),
6820            ("ordType", "market"),
6821            ("tdMode", "cash"),
6822            (
6823                "tgtCcy",
6824                if quote_quantity {
6825                    "quote_ccy"
6826                } else {
6827                    "base_ccy"
6828                },
6829            ),
6830            (
6831                "sz",
6832                if quote_quantity {
6833                    "12.34500"
6834                } else {
6835                    "0.12345"
6836                },
6837            ),
6838            ("accFillSz", filled_qty),
6839            ("fillSz", filled_qty),
6840            ("avgPx", "2469.00"),
6841            ("fillPx", "2469.00"),
6842            ("px", ""),
6843            ("uTime", "1737400000200"),
6844            ("cTime", "1737400000000"),
6845            ("fillTime", "1737400000200"),
6846        ] {
6847            msg[key] = Value::from(value);
6848        }
6849
6850        let filled = OKXWsMessage::Orders(serde_json::from_value(child["data"].clone()).unwrap());
6851        let filled_replay =
6852            OKXWsMessage::Orders(serde_json::from_value(child["data"].clone()).unwrap());
6853
6854        for message in [
6855            pending,
6856            pending_replay,
6857            amended,
6858            amended_replay,
6859            triggered,
6860            filled,
6861            filled_replay,
6862        ] {
6863            dispatch_ws_message(
6864                message,
6865                &client.emitter,
6866                &client.ws_dispatch_state,
6867                client.core.account_id,
6868                client.core.account_type,
6869                &instruments,
6870                &mut fee_cache,
6871                &mut fills,
6872                &mut snapshots,
6873                client.clock,
6874            );
6875        }
6876
6877        let events: Vec<_> = std::iter::from_fn(|| event_rx.try_recv().ok()).collect();
6878
6879        let [
6880            ExecutionEvent::Order(OrderEventAny::Submitted(submitted)),
6881            ExecutionEvent::Order(OrderEventAny::Accepted(accepted)),
6882            ExecutionEvent::Order(OrderEventAny::Updated(amended)),
6883            ExecutionEvent::Order(OrderEventAny::Updated(bound)),
6884            ExecutionEvent::Order(OrderEventAny::Filled(filled)),
6885            reports @ ..,
6886        ] = events.as_slice()
6887        else {
6888            panic!(
6889                "Expected submitted, accepted, amended, bound, filled, and optional status, was {events:?}"
6890            );
6891        };
6892
6893        let mut applied = order.clone();
6894
6895        for event in &events {
6896            if let ExecutionEvent::Order(event) = event {
6897                applied.apply(event.clone()).unwrap();
6898                assert_eq!(applied.is_quote_quantity(), quote_quantity);
6899            }
6900        }
6901
6902        assert_eq!(submitted.client_order_id, client_order_id);
6903        assert_eq!(accepted.client_order_id, client_order_id);
6904        assert_eq!(accepted.venue_order_id, VenueOrderId::from("7003"));
6905        assert_eq!(amended.client_order_id, client_order_id);
6906        assert_eq!(amended.venue_order_id, Some(VenueOrderId::from("7003")));
6907        assert_eq!(amended.quantity, quantity);
6908        assert_eq!(amended.price, None);
6909        assert_eq!(amended.trigger_price, Some(Price::from("2456.78")));
6910        assert_eq!(amended.is_quote_quantity, quote_quantity);
6911        assert_eq!(bound.client_order_id, client_order_id);
6912        assert_eq!(bound.venue_order_id, Some(VenueOrderId::from("7004")));
6913        assert_eq!(bound.quantity, quantity);
6914        assert_eq!(bound.price, None);
6915        assert_eq!(bound.trigger_price, Some(Price::from("2456.78")));
6916        assert_eq!(bound.is_quote_quantity, quote_quantity);
6917        assert_eq!(filled.client_order_id, client_order_id);
6918        assert_eq!(filled.venue_order_id, VenueOrderId::from("7004"));
6919        assert_eq!(filled.last_qty, Quantity::from(filled_qty));
6920        assert_eq!(filled.last_px, Price::from("2469.00"));
6921
6922        if quote_quantity {
6923            let [ExecutionEvent::Report(CommonExecutionReport::Order(report))] = reports else {
6924                panic!("Expected one terminal quote-sized status report, was {reports:?}");
6925            };
6926
6927            assert_eq!(report.client_order_id, Some(client_order_id));
6928            assert_eq!(report.venue_order_id, VenueOrderId::from("7004"));
6929            assert_eq!(report.order_status, OrderStatus::Filled);
6930            assert_eq!(report.quantity, Quantity::from(filled_qty));
6931            assert_eq!(report.filled_qty, Quantity::from(filled_qty));
6932        } else {
6933            assert!(reports.is_empty(), "{reports:?}");
6934            assert_eq!(applied.status(), OrderStatus::Filled);
6935        }
6936
6937        assert_eq!(
6938            client.ws_dispatch_state.order_identity(client_order_id),
6939            None
6940        );
6941    }
6942
6943    #[rstest]
6944    #[tokio::test]
6945    async fn test_submit_conditional_order_resolves_routing_context() {
6946        let router = Router::new().route(
6947            "/api/v5/trade/order-algo",
6948            post(|Json(request): Json<Value>| async move {
6949                let data = match request["algoClOrdId"].as_str() {
6950                    Some("ORESTBIND001") => serde_json::json!([{
6951                        "algoId": "3796251408639365120",
6952                        "algoClOrdId": "ORESTBIND001",
6953                        "sCode": "0",
6954                        "sMsg": "",
6955                    }]),
6956                    Some("ORESTAMBIGUOUS002") => serde_json::json!([{
6957                        "algoId": "",
6958                        "algoClOrdId": "ORESTAMBIGUOUS002",
6959                        "sCode": "51149",
6960                        "sMsg": "Order timed out. Please try again.",
6961                    }]),
6962                    _ => serde_json::json!([]),
6963                };
6964                Json(serde_json::json!({
6965                    "code": "0",
6966                    "msg": "",
6967                    "data": data,
6968                }))
6969            }),
6970        );
6971        let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
6972        let base_url_http = format!("http://{}", listener.local_addr().unwrap());
6973        tokio::spawn(async move {
6974            axum::serve(listener, router.into_make_service())
6975                .await
6976                .unwrap();
6977        });
6978
6979        let config = OKXExecutionClientConfig {
6980            api_key: Some("test_key".into()),
6981            api_secret: Some("test_secret".into()),
6982            api_passphrase: Some("test_pass".into()),
6983            base_url_http: Some(base_url_http),
6984            ..OKXExecutionClientConfig::default()
6985        };
6986        let cache = Rc::new(RefCell::new(Cache::default()));
6987        let core = ExecutionClientCore::new(
6988            TraderId::from("TESTER-001"),
6989            ClientId::from("OKX-TEST"),
6990            *OKX_VENUE,
6991            OmsType::Hedging,
6992            config.account_id,
6993            AccountType::Cash,
6994            None,
6995            Rc::clone(&cache),
6996        );
6997        let mut client = OKXExecutionClient::new(core, config).unwrap();
6998        let (event_tx, mut event_rx) = tokio::sync::mpsc::unbounded_channel();
6999        client.emitter.set_sender(event_tx);
7000        let client_order_id = ClientOrderId::from("ORESTBIND001");
7001        let order = OrderTestBuilder::new(OrderType::StopLimit)
7002            .client_order_id(client_order_id)
7003            .strategy_id(StrategyId::from("S-REST-BIND-001"))
7004            .instrument_id(InstrumentId::from("BTC-USDT-SWAP.OKX"))
7005            .side(OrderSide::Sell)
7006            .quantity(Quantity::from("0.01"))
7007            .price(Price::from("94900"))
7008            .trigger_price(Price::from("95000"))
7009            .build();
7010        cache
7011            .borrow_mut()
7012            .add_order(order.clone(), None, Some(*OKX_CLIENT_ID), false)
7013            .unwrap();
7014        let command = SubmitOrder::from_order(
7015            &order,
7016            TraderId::from("TESTER-001"),
7017            Some(*OKX_CLIENT_ID),
7018            None,
7019            UUID4::new(),
7020            UnixNanos::default(),
7021        );
7022
7023        client.submit_order(command).unwrap();
7024        wait_until_async(
7025            || async {
7026                client
7027                    .ws_dispatch_state
7028                    .order_venue_binding(client_order_id)
7029                    == Some((VenueOrderId::from("3796251408639365120"), false))
7030            },
7031            Duration::from_secs(5),
7032        )
7033        .await;
7034
7035        assert_eq!(
7036            client.ws_dispatch_state.order_identity(client_order_id),
7037            Some(OrderIdentity {
7038                client_order_id,
7039                strategy_id: StrategyId::from("S-REST-BIND-001"),
7040                instrument_id: InstrumentId::from("BTC-USDT-SWAP.OKX"),
7041                order_side: OrderSide::Sell,
7042                order_type: OrderType::StopLimit,
7043            })
7044        );
7045
7046        let ambiguous_client_order_id = ClientOrderId::from("ORESTAMBIGUOUS002");
7047        let ambiguous_order = OrderTestBuilder::new(OrderType::StopLimit)
7048            .client_order_id(ambiguous_client_order_id)
7049            .strategy_id(StrategyId::from("S-REST-BIND-001"))
7050            .instrument_id(InstrumentId::from("BTC-USDT-SWAP.OKX"))
7051            .side(OrderSide::Sell)
7052            .quantity(Quantity::from("0.02"))
7053            .price(Price::from("94800"))
7054            .trigger_price(Price::from("95100"))
7055            .build();
7056        cache
7057            .borrow_mut()
7058            .add_order(ambiguous_order.clone(), None, Some(*OKX_CLIENT_ID), false)
7059            .unwrap();
7060        let ambiguous_command = SubmitOrder::from_order(
7061            &ambiguous_order,
7062            TraderId::from("TESTER-001"),
7063            Some(*OKX_CLIENT_ID),
7064            None,
7065            UUID4::new(),
7066            UnixNanos::default(),
7067        );
7068
7069        client.submit_order(ambiguous_command).unwrap();
7070        wait_until_async(
7071            || async {
7072                client
7073                    .ws_dispatch_state
7074                    .order_identity(ambiguous_client_order_id)
7075                    .is_none()
7076            },
7077            Duration::from_secs(5),
7078        )
7079        .await;
7080
7081        assert_eq!(
7082            client
7083                .ws_dispatch_state
7084                .order_venue_binding(ambiguous_client_order_id),
7085            None
7086        );
7087
7088        wait_until_async(
7089            || async { client.pending_tasks.all_finished() },
7090            Duration::from_secs(5),
7091        )
7092        .await;
7093        terminate_tasks(&client.pending_tasks, "test execution client")
7094            .await
7095            .expect("execution tasks terminated");
7096
7097        let mut events = Vec::new();
7098        while let Ok(event) = event_rx.try_recv() {
7099            events.push(event);
7100        }
7101
7102        for expected_client_order_id in [client_order_id, ambiguous_client_order_id] {
7103            assert_eq!(
7104                events
7105                    .iter()
7106                    .filter(|event| matches!(
7107                        event,
7108                        ExecutionEvent::Order(OrderEventAny::Submitted(submitted))
7109                            if submitted.client_order_id == expected_client_order_id
7110                    ))
7111                    .count(),
7112                1,
7113            );
7114        }
7115        assert!(
7116            !events.iter().any(|event| matches!(
7117                event,
7118                ExecutionEvent::Order(OrderEventAny::Rejected(rejected))
7119                    if rejected.client_order_id == ambiguous_client_order_id
7120            )),
7121            "ambiguous algo submit failure should not emit OrderRejected: {events:?}",
7122        );
7123    }
7124
7125    #[rstest]
7126    #[tokio::test]
7127    async fn repeated_cancel_targets_use_distinct_request_contexts() {
7128        let (mut client, cache) = build_test_exec_client_with_cache();
7129        let (server, mut request_rx) = connect_cancel_websocket(&mut client).await;
7130        let instrument_id = InstrumentId::from("BTC-USDT.OKX");
7131        let strategy_id = StrategyId::from("S-BATCH-CANCEL");
7132        let target = ClientOrderId::from("OREPEATEDCANCEL");
7133        let venue = VenueOrderId::from("repeat-venue");
7134        let mut order = OrderTestBuilder::new(OrderType::Limit)
7135            .client_order_id(target)
7136            .strategy_id(strategy_id)
7137            .instrument_id(instrument_id)
7138            .quantity(Quantity::from("0.005"))
7139            .price(Price::from("110000"))
7140            .build();
7141        order
7142            .apply(TestOrderEventStubs::accepted(
7143                &order,
7144                client.core.account_id,
7145                venue,
7146            ))
7147            .unwrap();
7148        cache
7149            .borrow_mut()
7150            .add_order(order, None, Some(*OKX_CLIENT_ID), false)
7151            .unwrap();
7152        let causes = [UUID4::new(), UUID4::new()];
7153
7154        let cancels = causes.map(|cause| {
7155            CancelOrder::new(
7156                client.core.trader_id,
7157                Some(*OKX_CLIENT_ID),
7158                strategy_id,
7159                instrument_id,
7160                target,
7161                Some(venue),
7162                cause,
7163                UnixNanos::default(),
7164                None,
7165                None,
7166            )
7167        });
7168
7169        client
7170            .batch_cancel_orders(BatchCancelOrders::new(
7171                client.core.trader_id,
7172                Some(*OKX_CLIENT_ID),
7173                strategy_id,
7174                instrument_id,
7175                cancels.to_vec(),
7176                UUID4::new(),
7177                UnixNanos::default(),
7178                None,
7179                None,
7180            ))
7181            .unwrap();
7182        let mut request_ids = Vec::new();
7183
7184        for cause in causes {
7185            let request = tokio::time::timeout(Duration::from_secs(5), request_rx.recv())
7186                .await
7187                .unwrap()
7188                .unwrap();
7189            let id = request["id"].as_str().unwrap().to_string();
7190            assert_eq!(
7191                request,
7192                serde_json::json!({
7193                    "id": id.as_str(), "op": "batch-cancel-orders",
7194                    "args": [{"instIdCode":10459, "clOrdId":target.as_str(), "ordId":venue.as_str()}],
7195                })
7196            );
7197            assert_eq!(
7198                *client.ws_private.pending_command_ids.get(&id).unwrap(),
7199                vec![(target, cause)]
7200            );
7201            request_ids.push(id);
7202        }
7203
7204        assert_ne!(request_ids[0], request_ids[1]);
7205        wait_until_async(
7206            || async { client.pending_tasks.all_finished() },
7207            Duration::from_secs(5),
7208        )
7209        .await;
7210        client.ws_private.close().await.unwrap();
7211        server.abort();
7212        let _ = server.await;
7213    }
7214
7215    async fn connect_cancel_websocket(
7216        client: &mut OKXExecutionClient,
7217    ) -> (
7218        tokio::task::JoinHandle<()>,
7219        tokio::sync::mpsc::UnboundedReceiver<Value>,
7220    ) {
7221        let (request_tx, request_rx) = tokio::sync::mpsc::unbounded_channel();
7222        let router = Router::new().route(
7223            "/ws",
7224            get(move |ws: WebSocketUpgrade| {
7225                let tx = request_tx.clone();
7226                async move {
7227                    ws.on_upgrade(move |mut socket| async move {
7228                        while let Some(Ok(Message::Text(text))) = socket.next().await {
7229                            let request: Value = serde_json::from_str(&text).unwrap();
7230                            if request["op"] == "login" {
7231                                let response =
7232                                    serde_json::json!({"event": "login", "code": "0", "msg": "", "connId": "test-conn"});
7233                                socket
7234                                    .send(Message::Text(response.to_string().into()))
7235                                    .await
7236                                    .unwrap();
7237                            } else {
7238                                tx.send(request).unwrap();
7239                            }
7240                        }
7241                    })
7242                }
7243            }),
7244        );
7245
7246        let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
7247        let url = format!("ws://{}/ws", listener.local_addr().unwrap());
7248
7249        let server = tokio::spawn(async move { axum::serve(listener, router).await.unwrap() });
7250        client.ws_private = OKXWebSocketClient::with_credentials(
7251            Some(url),
7252            Some("test_key".into()),
7253            Some("test_secret".into()),
7254            Some("test_pass".into()),
7255            Some(client.core.account_id),
7256            None,
7257            None,
7258            client.config.transport_backend,
7259            None,
7260        )
7261        .unwrap();
7262        client
7263            .ws_private
7264            .cache_inst_id_code(ustr::Ustr::from("BTC-USDT"), 10459);
7265        client.ws_private.connect().await.unwrap();
7266        client.ws_private.wait_until_active(5.0).await.unwrap();
7267        (server, request_rx)
7268    }
7269
7270    #[rstest]
7271    #[case::single(1, false, false)]
7272    #[case::batch(23, true, false)]
7273    #[case::repeated(2, true, true)]
7274    #[tokio::test]
7275    async fn closed_handler_denies_every_unsent_cancel(
7276        #[case] count: usize,
7277        #[case] batch: bool,
7278        #[case] repeated: bool,
7279    ) {
7280        let (mut client, cache) = build_test_exec_client_with_cache();
7281        let (event_tx, mut event_rx) = tokio::sync::mpsc::unbounded_channel();
7282        client.emitter.set_sender(event_tx);
7283        let instrument_id = InstrumentId::from("BTC-USDT.OKX");
7284        let strategy_id = StrategyId::from("S-CLOSED-HANDLER");
7285        client
7286            .ws_private
7287            .cache_inst_id_code(Ustr::from("BTC-USDT"), 10459);
7288        let mut cancels = Vec::new();
7289
7290        for index in 0..count {
7291            let client_order_id = ClientOrderId::from(format!("OCLOSED{index}"));
7292            let venue_order_id = VenueOrderId::from(format!("closed-venue-{index}"));
7293            let mut order = OrderTestBuilder::new(OrderType::Limit)
7294                .client_order_id(client_order_id)
7295                .strategy_id(strategy_id)
7296                .instrument_id(instrument_id)
7297                .side(OrderSide::Sell)
7298                .quantity(Quantity::from("0.005"))
7299                .price(Price::from("110000"))
7300                .build();
7301            let accepted =
7302                TestOrderEventStubs::accepted(&order, client.core.account_id, venue_order_id);
7303            order.apply(accepted).unwrap();
7304            cache
7305                .borrow_mut()
7306                .add_order(order, None, Some(*OKX_CLIENT_ID), false)
7307                .unwrap();
7308
7309            if index % 2 == 0 {
7310                client.ws_dispatch_state.bind_order(
7311                    client_order_id,
7312                    VenueOrderId::from(format!("authoritative-venue-{index}")),
7313                );
7314            }
7315
7316            cancels.push(CancelOrder::new(
7317                TraderId::from("TESTER-001"),
7318                Some(*OKX_CLIENT_ID),
7319                strategy_id,
7320                instrument_id,
7321                client_order_id,
7322                Some(venue_order_id),
7323                UUID4::new(),
7324                UnixNanos::default(),
7325                None,
7326                None,
7327            ));
7328        }
7329
7330        let target = cancels[0].client_order_id;
7331        let venue = cancels[0].venue_order_id;
7332        for cancel in cancels.iter_mut().skip(1).filter(|_| repeated) {
7333            cancel.client_order_id = target;
7334            cancel.venue_order_id = venue;
7335        }
7336
7337        if batch {
7338            let command = BatchCancelOrders::new(
7339                TraderId::from("TESTER-001"),
7340                Some(*OKX_CLIENT_ID),
7341                strategy_id,
7342                instrument_id,
7343                cancels.clone(),
7344                UUID4::new(),
7345                UnixNanos::default(),
7346                None,
7347                None,
7348            );
7349            client.batch_cancel_orders(command).unwrap();
7350        } else {
7351            client.cancel_order(cancels[0].clone()).unwrap();
7352        }
7353
7354        wait_until_async(
7355            || async { client.pending_tasks.all_finished() },
7356            Duration::from_secs(5),
7357        )
7358        .await;
7359        terminate_tasks(&client.pending_tasks, "test execution client")
7360            .await
7361            .unwrap();
7362        let events: Vec<_> = std::iter::from_fn(|| event_rx.try_recv().ok()).collect();
7363
7364        assert_eq!(events.len(), count);
7365
7366        for (index, (event, cancel)) in events.iter().zip(cancels).enumerate() {
7367            let ExecutionEvent::Order(OrderEventAny::CancelDenied(rejected)) = event else {
7368                panic!("Expected cancel denial, received {event:?}");
7369            };
7370
7371            assert_eq!(rejected.trader_id, client.core.trader_id);
7372            assert_eq!(rejected.strategy_id, strategy_id);
7373            assert_eq!(rejected.instrument_id, instrument_id);
7374            assert_eq!(rejected.client_order_id, cancel.client_order_id);
7375            assert_eq!(rejected.causation_id, Some(cancel.command_id));
7376
7377            let index = if repeated { 0 } else { index };
7378
7379            let expected_venue_order_id = if index % 2 == 0 {
7380                Some(VenueOrderId::from(format!("authoritative-venue-{index}")))
7381            } else {
7382                cancel.venue_order_id
7383            };
7384
7385            assert_eq!(rejected.venue_order_id, expected_venue_order_id);
7386            assert_eq!(rejected.account_id, Some(client.core.account_id));
7387            assert_eq!(
7388                rejected.reason.as_str(),
7389                "Handler not available: channel closed"
7390            );
7391            assert_eq!(
7392                cache
7393                    .borrow()
7394                    .order(&cancel.client_order_id)
7395                    .unwrap()
7396                    .status(),
7397                OrderStatus::Accepted
7398            );
7399        }
7400
7401        assert!(client.ws_private.pending_cancels.is_empty());
7402    }
7403
7404    #[rstest]
7405    fn test_imported_conditional_order_preserves_report_routing() {
7406        let (mut client, cache) = build_test_exec_client_with_cache();
7407        let cid = ClientOrderId::from("OEEADEMOSTOPLIMIT001");
7408        let iid = InstrumentId::from("ETH-USDT.OKX");
7409        let mut instrument = currency_pair_ethusdt();
7410        instrument.id = iid;
7411        instrument.raw_symbol = Symbol::from("ETH-USDT");
7412        let instruments = AtomicMap::new();
7413        instruments.insert(
7414            Ustr::from("ETH-USDT"),
7415            InstrumentAny::CurrencyPair(instrument),
7416        );
7417        let order = OrderTestBuilder::new(OrderType::StopLimit)
7418            .instrument_id(iid)
7419            .client_order_id(cid)
7420            .side(OrderSide::Buy)
7421            .quantity(Quantity::from("0.003"))
7422            .price(Price::from("1886.00"))
7423            .trigger_price(Price::from("1900.00"))
7424            .build();
7425        cache
7426            .borrow_mut()
7427            .add_order(order.clone(), None, Some(client.core.client_id), false)
7428            .unwrap();
7429        client.register_external_order(
7430            cid,
7431            VenueOrderId::from("7003"),
7432            iid,
7433            order.strategy_id(),
7434            UnixNanos::default(),
7435        );
7436        client.ensure_order_identity(cid, order.strategy_id(), iid);
7437        let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel();
7438        client.emitter.set_sender(tx);
7439        let mut fee_cache = FeeCache::new();
7440        let mut fills = FilledQtyCache::new();
7441        let mut snapshots = AHashMap::new();
7442        let mut parent: Value =
7443            serde_json::from_str(include_str!("../test_data/ws_orders_algo.json")).unwrap();
7444        let msg = &mut parent["data"][0];
7445        msg["algoClOrdId"] = serde_json::json!(cid.as_str());
7446        msg["algoId"] = serde_json::json!("7003");
7447        msg["instId"] = serde_json::json!("ETH-USDT");
7448        msg["ordType"] = serde_json::json!("conditional");
7449        msg["state"] = serde_json::json!("live");
7450        let message =
7451            OKXWsMessage::AlgoOrders(serde_json::from_value(parent["data"].clone()).unwrap());
7452        dispatch_ws_message(
7453            message,
7454            &client.emitter,
7455            &client.ws_dispatch_state,
7456            client.core.account_id,
7457            client.core.account_type,
7458            &instruments,
7459            &mut fee_cache,
7460            &mut fills,
7461            &mut snapshots,
7462            client.clock,
7463        );
7464        let event = rx.try_recv().unwrap();
7465
7466        let ExecutionEvent::Report(CommonExecutionReport::Order(report)) = event else {
7467            panic!("expected imported parent report, was {event:?}");
7468        };
7469
7470        assert_eq!(report.client_order_id, Some(cid));
7471        assert_eq!(report.venue_order_id, VenueOrderId::from("7003"));
7472        assert!(rx.try_recv().is_err());
7473        let child: Value = serde_json::from_str(include_str!(
7474            "../test_data/ws_orders_algo_child_filled_empty_cl_ord_id.json"
7475        ))
7476        .unwrap();
7477        let message = OKXWsMessage::Orders(serde_json::from_value(child["data"].clone()).unwrap());
7478        dispatch_ws_message(
7479            message,
7480            &client.emitter,
7481            &client.ws_dispatch_state,
7482            client.core.account_id,
7483            client.core.account_type,
7484            &instruments,
7485            &mut fee_cache,
7486            &mut fills,
7487            &mut snapshots,
7488            client.clock,
7489        );
7490        let event = rx.try_recv().unwrap();
7491
7492        let ExecutionEvent::Report(CommonExecutionReport::OrderWithFills(order, fills)) = event
7493        else {
7494            panic!("expected imported child order with fills, was {event:?}");
7495        };
7496
7497        assert_eq!(order.client_order_id, Some(cid));
7498        assert_eq!(
7499            order.venue_order_id,
7500            VenueOrderId::from("2497956918703120501")
7501        );
7502        assert_eq!(order.order_status, OrderStatus::Filled);
7503        assert_eq!(fills.len(), 1);
7504        let report = &fills[0];
7505        assert_eq!(report.client_order_id, Some(cid));
7506        assert_eq!(
7507            report.venue_order_id,
7508            VenueOrderId::from("2497956918703120501")
7509        );
7510        assert_eq!(report.last_qty, Quantity::from("0.003"));
7511        assert_eq!(report.last_px, Price::from("1886.00"));
7512        assert!(rx.try_recv().is_err());
7513        assert_eq!(client.ws_dispatch_state.order_identity(cid), None);
7514    }
7515
7516    #[rstest]
7517    fn test_register_external_order_without_cached_order() {
7518        let client = build_test_exec_client();
7519        let cid = ClientOrderId::from("O-MISSING");
7520        client.register_external_order(
7521            cid,
7522            VenueOrderId::from("7002"),
7523            InstrumentId::from("BTC-USDT.OKX"),
7524            StrategyId::from("S-MISSING"),
7525            UnixNanos::default(),
7526        );
7527        assert_eq!(client.ws_dispatch_state.order_identity(cid), None);
7528        assert!(!client.ws_dispatch_state.contains_accepted(&cid));
7529    }
7530
7531    #[rstest]
7532    fn test_register_external_order_tracks_initialized_import() {
7533        let (client, cache) = build_test_exec_client_with_cache();
7534        let order = OrderTestBuilder::new(OrderType::Limit)
7535            .instrument_id(InstrumentId::from("BTC-USDT.OKX"))
7536            .client_order_id(ClientOrderId::from("O-IMPORTED"))
7537            .strategy_id(StrategyId::from("S-IMPORTED"))
7538            .side(OrderSide::Sell)
7539            .quantity(Quantity::from("0.02"))
7540            .price(Price::from("50000.0"))
7541            .build();
7542        let venue_order_id = VenueOrderId::from("7001");
7543        cache
7544            .borrow_mut()
7545            .add_order(order.clone(), None, Some(client.core.client_id), false)
7546            .unwrap();
7547
7548        client.register_external_order(
7549            order.client_order_id(),
7550            venue_order_id,
7551            order.instrument_id(),
7552            order.strategy_id(),
7553            UnixNanos::default(),
7554        );
7555
7556        assert_eq!(
7557            client
7558                .ws_dispatch_state
7559                .order_identity(order.client_order_id()),
7560            Some(OrderIdentity::from(&order))
7561        );
7562        assert!(
7563            client
7564                .ws_dispatch_state
7565                .contains_accepted(&order.client_order_id())
7566        );
7567        assert!(
7568            !client
7569                .ws_dispatch_state
7570                .contains_triggered(&order.client_order_id())
7571        );
7572        assert_eq!(order.status(), OrderStatus::Initialized);
7573        assert_eq!(order.account_id(), None);
7574        assert_eq!(order.venue_order_id(), None);
7575        client
7576            .ws_dispatch_state
7577            .remove_order_tracking(order.client_order_id());
7578        assert_eq!(
7579            client
7580                .ws_dispatch_state
7581                .order_identity(order.client_order_id()),
7582            None
7583        );
7584    }
7585
7586    #[rstest]
7587    fn test_ensure_order_identity_skips_order_without_cached_side() {
7588        let client = build_test_exec_client();
7589        let client_order_id = ClientOrderId::from("O-RESTORED-001");
7590        let strategy_id = StrategyId::from("S-RESTORED-002");
7591        let instrument_id = InstrumentId::from("BTC-USDT.OKX");
7592
7593        client.ensure_order_identity(client_order_id, strategy_id, instrument_id);
7594
7595        assert!(
7596            client
7597                .ws_dispatch_state
7598                .order_identities
7599                .get(&client_order_id)
7600                .is_none()
7601        );
7602    }
7603
7604    #[rstest]
7605    fn test_on_instrument_writes_through_to_client_caches() {
7606        // Bus-delivered instrument updates must land in both the private and
7607        // business WebSocket caches, and in the HTTP cache used by reconciliation.
7608        use nautilus_model::instruments::stubs::crypto_perpetual_ethusdt;
7609
7610        let mut client = build_test_exec_client();
7611        let instrument = InstrumentAny::CryptoPerpetual(crypto_perpetual_ethusdt());
7612        let symbol = instrument.symbol().inner();
7613        let raw_symbol = instrument.raw_symbol().inner();
7614
7615        client.on_instrument(instrument.clone());
7616
7617        let private_cache = client.ws_private.instruments_cache_arc();
7618        let business_cache = client.ws_business.instruments_cache_arc();
7619        assert_eq!(
7620            client
7621                .http_client
7622                .get_instrument(&raw_symbol)
7623                .map(|i| i.id()),
7624            Some(instrument.id()),
7625        );
7626        assert_eq!(
7627            private_cache.load().get(&symbol).map(Instrument::id),
7628            Some(instrument.id()),
7629        );
7630        assert_eq!(
7631            business_cache.load().get(&symbol).map(Instrument::id),
7632            Some(instrument.id()),
7633        );
7634    }
7635
7636    #[rstest]
7637    #[case(OrderSide::Buy, false, PositionSide::Long)]
7638    #[case(OrderSide::Sell, false, PositionSide::Short)]
7639    #[case(OrderSide::Buy, true, PositionSide::Short)]
7640    #[case(OrderSide::Sell, true, PositionSide::Long)]
7641    fn test_order_position_side(
7642        #[case] side: OrderSide,
7643        #[case] reduce_only: bool,
7644        #[case] expected: PositionSide,
7645        #[values("ETH-USDT-SWAP.OKX", "ETH-USDT-271231.OKX")] instrument_id: &str,
7646    ) {
7647        let mut client = build_test_exec_client();
7648        let order = OrderTestBuilder::new(OrderType::Limit)
7649            .instrument_id(InstrumentId::from(instrument_id))
7650            .side(side)
7651            .price(Price::from("123.45"))
7652            .quantity(Quantity::from("2"))
7653            .reduce_only(reduce_only)
7654            .build();
7655        assert_eq!(client.order_position_side(&order, None), None);
7656        client.position_mode = OKXPositionMode::LongShortMode;
7657        assert_eq!(client.order_position_side(&order, None), Some(expected));
7658    }
7659
7660    #[rstest]
7661    #[case(OrderSide::Buy, PositionSide::Short)]
7662    #[case(OrderSide::Sell, PositionSide::Long)]
7663    fn test_order_position_side_close_fraction(
7664        #[case] side: OrderSide,
7665        #[case] expected: PositionSide,
7666    ) {
7667        let mut client = build_test_exec_client();
7668        client.position_mode = OKXPositionMode::LongShortMode;
7669        let order = OrderTestBuilder::new(OrderType::StopMarket)
7670            .instrument_id(InstrumentId::from("ETH-USDT-SWAP.OKX"))
7671            .side(side)
7672            .trigger_price(Price::from("123.45"))
7673            .quantity(Quantity::from("2"))
7674            .build();
7675        let params =
7676            Params::new([("close_fraction".to_string(), Value::String("1".to_string()))].into());
7677        assert_eq!(
7678            client.order_position_side(&order, Some(&params)),
7679            Some(expected)
7680        );
7681    }
7682
7683    #[rstest]
7684    #[case("ETH-USDT.OKX")]
7685    #[case("ETH-USD-271231-2000-C.OKX")]
7686    fn test_order_position_side_other_products(#[case] instrument_id: &str) {
7687        let mut client = build_test_exec_client();
7688        client.position_mode = OKXPositionMode::LongShortMode;
7689        let order = OrderTestBuilder::new(OrderType::Limit)
7690            .instrument_id(InstrumentId::from(instrument_id))
7691            .side(OrderSide::Sell)
7692            .price(Price::from("123.45"))
7693            .quantity(Quantity::from("2"))
7694            .build();
7695        assert_eq!(client.order_position_side(&order, None), None);
7696    }
7697
7698    #[rstest]
7699    #[case(None)]
7700    #[case(Some("ETH-USDT-SWAP.OKX-LONG"))]
7701    fn test_validate_submit_position_id_accepts_leg(#[case] position_id: Option<&str>) {
7702        assert_eq!(
7703            validate_submit_position_id(
7704                InstrumentId::from("ETH-USDT-SWAP.OKX"),
7705                Some(PositionSide::Long),
7706                position_id.map(PositionId::from),
7707            ),
7708            Ok(()),
7709        );
7710    }
7711
7712    #[rstest]
7713    fn test_validate_submit_position_id_rejects_other_leg() {
7714        let position_id = PositionId::from("ETH-USDT-SWAP.OKX-SHORT");
7715        let result = validate_submit_position_id(
7716            InstrumentId::from("ETH-USDT-SWAP.OKX"),
7717            Some(PositionSide::Long),
7718            Some(position_id),
7719        );
7720        assert_eq!(
7721            result,
7722            Err(OrderDeniedReason::InvalidPositionId {
7723                position_id,
7724                detail: "expected OKX venue position ID ETH-USDT-SWAP.OKX-LONG".to_string(),
7725            })
7726        );
7727        assert_eq!(
7728            validate_submit_position_id(
7729                InstrumentId::from("ETH-USDT-SWAP.OKX"),
7730                None,
7731                Some(position_id),
7732            ),
7733            Ok(())
7734        );
7735    }
7736
7737    #[rstest]
7738    #[case(None, OKXTradeMode::Cross, None)]
7739    #[case(Some(PositionSide::Long), OKXTradeMode::Isolated, None)]
7740    #[case(
7741        Some(PositionSide::Short),
7742        OKXTradeMode::Cross,
7743        Some(OKXMarginMode::Cross)
7744    )]
7745    fn test_validate_trade_mode_accepts_configured_or_unrestricted(
7746        #[case] position_side: Option<PositionSide>,
7747        #[case] trade_mode: OKXTradeMode,
7748        #[case] margin_mode: Option<OKXMarginMode>,
7749    ) {
7750        let mut client = build_test_exec_client();
7751        client.config.margin_mode = margin_mode;
7752        assert_eq!(
7753            client.validate_trade_mode(
7754                InstrumentId::from("BTC-USDT-SWAP.OKX"),
7755                position_side,
7756                trade_mode
7757            ),
7758            Ok(())
7759        );
7760    }
7761
7762    #[rstest]
7763    #[case(None)]
7764    #[case(Some(OKXMarginMode::None))]
7765    #[case(Some(OKXMarginMode::Isolated))]
7766    #[tokio::test]
7767    async fn test_update_position_mode_on_reconnect(#[case] margin_mode: Option<OKXMarginMode>) {
7768        let response = Arc::new(Mutex::new(
7769            serde_json::from_str::<Value>(include_str!(
7770                "../test_data/http_get_account_configuration.json"
7771            ))
7772            .unwrap(),
7773        ));
7774
7775        let positions = Arc::new(Mutex::new(
7776            serde_json::json!({"code":"0", "data":[], "msg":""}),
7777        ));
7778        let positions_response = Arc::clone(&positions);
7779        let handler_response = Arc::clone(&response);
7780        let router = Router::new()
7781            .route(
7782                "/api/v5/account/config",
7783                get(move || {
7784                    let response = Arc::clone(&handler_response);
7785                    async move { Json(response.lock().unwrap().clone()) }
7786                }),
7787            )
7788            .route(
7789                "/api/v5/account/positions",
7790                get(move || {
7791                    let response = Arc::clone(&positions_response);
7792                    async move { Json(response.lock().unwrap().clone()) }
7793                }),
7794            )
7795            .route(
7796                "/api/v5/account/balance",
7797                get(|| async { Json(serde_json::json!({"code":"0", "data":[], "msg":""})) }),
7798            );
7799
7800        let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
7801        let address = listener.local_addr().unwrap();
7802        let server = tokio::spawn(async move {
7803            axum::serve(listener, router).await.unwrap();
7804        });
7805
7806        let mut client = build_test_exec_client();
7807        client.config.instrument_types = vec![OKXInstrumentType::Swap];
7808        client.config.margin_mode = margin_mode;
7809        client.http_client = OKXHttpClient::with_credentials(
7810            Some("key".into()),
7811            Some("secret".into()),
7812            Some("pass".into()),
7813            Some(format!("http://{address}")),
7814            5,
7815            0,
7816            1,
7817            1,
7818            OKXEnvironment::Demo,
7819            None,
7820        )
7821        .unwrap();
7822        response.lock().unwrap()["data"][0]["posMode"] = Value::String("long_short_mode".into());
7823        client.update_position_mode().await.unwrap();
7824        assert_eq!(client.position_mode, OKXPositionMode::LongShortMode);
7825        *positions.lock().unwrap() = serde_json::from_str(include_str!(
7826            "../test_data/http_get_positions_long_short.json"
7827        ))
7828        .unwrap();
7829        client.update_position_mode().await.unwrap();
7830        client.config.margin_mode = Some(OKXMarginMode::Cross);
7831        assert_eq!(
7832            client.update_position_mode().await.unwrap_err().to_string(),
7833            "OKX long/short position BTC-USDT-SWAP uses margin mode Isolated, expected Cross; mixed margin modes are not supported"
7834        );
7835        let instruments: Value =
7836            serde_json::from_str(include_str!("../test_data/http_get_instruments_swap.json"))
7837                .unwrap();
7838        let instrument: OKXInstrument = serde_json::from_value(
7839            instruments["data"]
7840                .as_array()
7841                .unwrap()
7842                .iter()
7843                .find(|row| row["instId"] == "BTC-USDT-SWAP")
7844                .unwrap()
7845                .clone(),
7846        )
7847        .unwrap();
7848        client.on_instrument(
7849            parse_instrument_any(&instrument, None, None, UnixNanos::default())
7850                .unwrap()
7851                .unwrap(),
7852        );
7853        let command = GeneratePositionStatusReportsBuilder::default()
7854            .ts_init(UnixNanos::from(98765))
7855            .build()
7856            .unwrap();
7857        assert_eq!(
7858            client
7859                .collect_position_status_reports(&command)
7860                .await
7861                .unwrap_err()
7862                .to_string(),
7863            "OKX long/short position BTC-USDT-SWAP uses margin mode Isolated, expected Cross; mixed margin modes are not supported"
7864        );
7865        client.config.margin_mode = margin_mode;
7866        let (reports, complete) = client
7867            .collect_position_status_reports(&command)
7868            .await
7869            .unwrap();
7870        assert!(complete);
7871        assert_eq!(reports.len(), 2);
7872        assert_eq!(reports[0].quantity, Quantity::from("5.00"));
7873        assert_eq!(
7874            reports[0].venue_position_id,
7875            Some(PositionId::from("BTC-USDT-SWAP.OKX-LONG"))
7876        );
7877        assert_eq!(reports[1].quantity, Quantity::from("2.00"));
7878        assert_eq!(
7879            reports[1].venue_position_id,
7880            Some(PositionId::from("BTC-USDT-SWAP.OKX-SHORT"))
7881        );
7882        client.config.margin_mode = Some(OKXMarginMode::Cross);
7883
7884        for position in positions.lock().unwrap()["data"].as_array_mut().unwrap() {
7885            position["pos"] = Value::String("0".to_string());
7886        }
7887
7888        client.update_position_mode().await.unwrap();
7889        client.config.margin_mode = Some(OKXMarginMode::Isolated);
7890        client.update_position_mode().await.unwrap();
7891        response.lock().unwrap()["data"][0]["posMode"] = Value::String("net_mode".into());
7892        client.update_position_mode().await.unwrap();
7893        assert_eq!(client.position_mode, OKXPositionMode::NetMode);
7894        response.lock().unwrap()["data"] = Value::Array(Vec::new());
7895        assert_eq!(
7896            client.update_position_mode().await.unwrap_err().to_string(),
7897            "OKX account configuration response is empty"
7898        );
7899        assert_eq!(
7900            client.connect().await.unwrap_err().to_string(),
7901            "OKX account configuration response is empty"
7902        );
7903        client.config.instrument_types = vec![OKXInstrumentType::Spot, OKXInstrumentType::Option];
7904        client.update_position_mode().await.unwrap();
7905        server.abort();
7906    }
7907
7908    #[rstest]
7909    #[case(false)]
7910    #[case(true)]
7911    #[tokio::test]
7912    async fn test_submit_spread_preserves_quote_quantity_handling(#[case] quote_quantity: bool) {
7913        let (request_tx, mut request_rx) = tokio::sync::mpsc::unbounded_channel();
7914        let router = Router::new().route(
7915            "/api/v5/sprd/order",
7916            post(move |Json(request): Json<Value>| {
7917                let tx = request_tx.clone();
7918                async move {
7919                    tx.send(request).unwrap();
7920                    let order: Value = serde_json::from_str(include_str!(
7921                        "../test_data/http_place_order_response.json"
7922                    ))
7923                    .unwrap();
7924                    Json(serde_json::json!({"code":"0", "msg":"", "data":[order]}))
7925                }
7926            }),
7927        );
7928
7929        let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
7930        let address = listener.local_addr().unwrap();
7931        let server = tokio::spawn(async move { axum::serve(listener, router).await.unwrap() });
7932        let (mut client, cache) = build_test_exec_client_with_cache();
7933        client.http_client = OKXHttpClient::with_credentials(
7934            Some("key".into()),
7935            Some("secret".into()),
7936            Some("pass".into()),
7937            Some(format!("http://{address}")),
7938            5,
7939            0,
7940            1,
7941            1,
7942            OKXEnvironment::Demo,
7943            None,
7944        )
7945        .unwrap();
7946        let (event_tx, _event_rx) = tokio::sync::mpsc::unbounded_channel();
7947        client.emitter.set_sender(event_tx);
7948        let order = OrderTestBuilder::new(OrderType::Limit)
7949            .instrument_id(InstrumentId::from("BCH-USDT_BCH-USDT-SWAP.OKX"))
7950            .client_order_id(ClientOrderId::from("OSPREADQUOTE"))
7951            .side(OrderSide::Sell)
7952            .quantity(Quantity::from("3"))
7953            .price(Price::from("12.34"))
7954            .quote_quantity(quote_quantity)
7955            .build();
7956        cache
7957            .borrow_mut()
7958            .add_order(order.clone(), None, Some(*OKX_CLIENT_ID), false)
7959            .unwrap();
7960        client
7961            .submit_order(SubmitOrder::from_order(
7962                &order,
7963                client.core.trader_id,
7964                Some(*OKX_CLIENT_ID),
7965                None,
7966                UUID4::new(),
7967                UnixNanos::default(),
7968            ))
7969            .unwrap();
7970        let request = tokio::time::timeout(Duration::from_secs(5), request_rx.recv())
7971            .await
7972            .unwrap()
7973            .unwrap();
7974        client.disconnect().await.unwrap();
7975        server.abort();
7976
7977        assert_eq!(
7978            request,
7979            serde_json::json!({
7980                "sprdId":"BCH-USDT_BCH-USDT-SWAP",
7981                "clOrdId":"OSPREADQUOTE",
7982                "tag":crate::common::consts::OKX_NAUTILUS_BROKER_ID,
7983                "side":"sell",
7984                "ordType":"limit",
7985                "sz":"3",
7986                "px":"12.34"
7987            })
7988        );
7989    }
7990
7991    fn swap_instrument() -> InstrumentAny {
7992        let response: Value =
7993            serde_json::from_str(include_str!("../test_data/http_get_instruments_swap.json"))
7994                .unwrap();
7995        let model: OKXInstrument = serde_json::from_value(response["data"][0].clone()).unwrap();
7996        parse_instrument_any(&model, None, None, UnixNanos::default())
7997            .unwrap()
7998            .unwrap()
7999    }
8000
8001    #[rstest]
8002    #[case(OrderSide::Buy, false, "long")]
8003    #[case(OrderSide::Sell, false, "short")]
8004    #[case(OrderSide::Buy, true, "short")]
8005    #[case(OrderSide::Sell, true, "long")]
8006    #[tokio::test]
8007    async fn test_submit_order_position_side_wire(
8008        #[case] side: OrderSide,
8009        #[case] reduce_only: bool,
8010        #[case] expected_side: &str,
8011        #[values("ws", "batch", "http", "algo", "close_fraction")] transport: &str,
8012    ) {
8013        let (request_tx, mut request_rx) = tokio::sync::mpsc::unbounded_channel();
8014        let ws_tx = request_tx.clone();
8015        let router = Router::new().route("/ws", get(move |ws: WebSocketUpgrade| {
8016            let tx = ws_tx.clone();
8017            async move { ws.on_upgrade(move |mut socket| async move {
8018                while let Some(Ok(Message::Text(text))) = socket.next().await {
8019                    let request: Value = serde_json::from_str(&text).unwrap();
8020                    if request["op"] == "login" {
8021                        let response = serde_json::json!({"event":"login", "code":"0", "msg":"", "connId":"test"});
8022                        socket.send(Message::Text(response.to_string().into())).await.unwrap();
8023                    } else {
8024                        tx.send(request).unwrap();
8025                    }
8026                }
8027            }) }
8028        })).route("/api/v5/trade/order", post({
8029            let tx = request_tx.clone();
8030            move |Json(request): Json<Value>| {
8031                let tx = tx.clone();
8032                async move {
8033                    tx.send(request).unwrap();
8034                    Json(serde_json::from_str::<Value>(include_str!("../test_data/http_place_order_response.json")).unwrap())
8035                }
8036            }
8037        })).route("/api/v5/trade/order-algo", post(move |Json(request): Json<Value>| {
8038            let tx = request_tx.clone();
8039            async move {
8040                tx.send(request).unwrap();
8041                Json(serde_json::from_str::<Value>(include_str!("../test_data/http_place_algo_order_response.json")).unwrap())
8042            }
8043        }));
8044
8045        let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
8046        let address = listener.local_addr().unwrap();
8047        let server = tokio::spawn(async move {
8048            axum::serve(listener, router).await.unwrap();
8049        });
8050
8051        let (mut client, cache) = build_test_exec_client_with_cache();
8052        client.position_mode = OKXPositionMode::LongShortMode;
8053        client.trade_mode = OKXTradeMode::Cross;
8054        client.http_client = OKXHttpClient::with_credentials(
8055            Some("key".into()),
8056            Some("secret".into()),
8057            Some("pass".into()),
8058            Some(format!("http://{address}")),
8059            5,
8060            0,
8061            1,
8062            1,
8063            OKXEnvironment::Demo,
8064            None,
8065        )
8066        .unwrap();
8067        client.ws_private = OKXWebSocketClient::with_credentials(
8068            Some(format!("ws://{address}/ws")),
8069            Some("key".into()),
8070            Some("secret".into()),
8071            Some("pass".into()),
8072            Some(client.core.account_id),
8073            None,
8074            None,
8075            client.config.transport_backend,
8076            None,
8077        )
8078        .unwrap();
8079        let instrument = swap_instrument();
8080        client.on_instrument(instrument.clone());
8081        client
8082            .ws_private
8083            .cache_inst_id_codes([(instrument.raw_symbol().inner(), 10458)]);
8084
8085        if transport == "ws" || transport == "batch" {
8086            client.ws_private.connect().await.unwrap();
8087            client.ws_private.wait_until_active(5.0).await.unwrap();
8088        }
8089
8090        let (event_tx, _event_rx) = tokio::sync::mpsc::unbounded_channel();
8091        client.emitter.set_sender(event_tx);
8092
8093        let order =
8094            OrderTestBuilder::new(if transport == "algo" || transport == "close_fraction" {
8095                OrderType::StopMarket
8096            } else {
8097                OrderType::Limit
8098            })
8099            .instrument_id(instrument.id())
8100            .client_order_id(ClientOrderId::from("OHEDGEWIRE"))
8101            .side(side)
8102            .quantity(Quantity::from("2"))
8103            .price(Price::from("123.4"))
8104            .trigger_price(Price::from("120.00"))
8105            .reduce_only(reduce_only)
8106            .build();
8107
8108        cache
8109            .borrow_mut()
8110            .add_order(order.clone(), None, Some(*OKX_CLIENT_ID), false)
8111            .unwrap();
8112        let mut command = SubmitOrder::from_order(
8113            &order,
8114            client.core.trader_id,
8115            Some(*OKX_CLIENT_ID),
8116            None,
8117            UUID4::new(),
8118            UnixNanos::default(),
8119        );
8120
8121        if transport == "close_fraction" {
8122            let params = Params::new([("close_fraction".into(), Value::String("1".into()))].into());
8123            command.params = Some(params);
8124        }
8125
8126        match transport {
8127            "batch" => {
8128                let order_list = OrderList::new(
8129                    OrderListId::from("OL-HEDGE"),
8130                    instrument.id(),
8131                    order.strategy_id(),
8132                    vec![order.client_order_id()],
8133                    UnixNanos::default(),
8134                );
8135                client
8136                    .submit_order_list(SubmitOrderList::new(
8137                        client.core.trader_id,
8138                        Some(*OKX_CLIENT_ID),
8139                        order.strategy_id(),
8140                        order_list,
8141                        vec![OrderInitialized::from(&order)],
8142                        None,
8143                        None,
8144                        None,
8145                        UUID4::new(),
8146                        UnixNanos::default(),
8147                        None,
8148                    ))
8149                    .unwrap();
8150            }
8151            "http" => client
8152                .submit_order_http(&command, client.order_position_side(&order, None))
8153                .unwrap(),
8154            _ => client.submit_order(command).unwrap(),
8155        }
8156
8157        let request = tokio::time::timeout(Duration::from_secs(5), request_rx.recv())
8158            .await
8159            .unwrap()
8160            .unwrap();
8161
8162        let body = if transport == "ws" || transport == "batch" {
8163            &request["args"][0]
8164        } else {
8165            &request
8166        };
8167
8168        let expected_side = if transport == "close_fraction" {
8169            if side == OrderSide::Buy {
8170                "short"
8171            } else {
8172                "long"
8173            }
8174        } else {
8175            expected_side
8176        };
8177
8178        assert_eq!(body["posSide"], expected_side);
8179        assert_eq!(
8180            body["side"],
8181            if side == OrderSide::Buy {
8182                "buy"
8183            } else {
8184                "sell"
8185            }
8186        );
8187        assert_eq!(body.get("reduceOnly"), None);
8188
8189        if transport == "close_fraction" {
8190            assert_eq!(body.get("sz"), None);
8191            assert_eq!(body["closeFraction"], "1");
8192        } else {
8193            assert_eq!(body["sz"], "2");
8194        }
8195
8196        client.disconnect().await.unwrap();
8197        server.abort();
8198    }
8199
8200    #[rstest]
8201    #[case::accepted("0", OKXTradeMode::Cross, "0")]
8202    #[case::accepted_isolated("0", OKXTradeMode::Isolated, "0")]
8203    #[case::accepted_spot_isolated("0", OKXTradeMode::SpotIsolated, "0")]
8204    #[case::rejected("51000", OKXTradeMode::Cash, "1")]
8205    #[case::ambiguous("50004", OKXTradeMode::Cross, "1")]
8206    #[tokio::test]
8207    async fn test_spot_market_submission_preserves_quantity_intent(
8208        #[case] response_code: &str,
8209        #[case] trade_mode: OKXTradeMode,
8210        #[case] overall_code: &str,
8211        #[values(
8212            (OrderSide::Buy, false, Some("base_ccy"), "0.12345"),
8213            (OrderSide::Buy, true, Some("quote_ccy"), "12.34500"),
8214            (OrderSide::Sell, false, None, "0.12345"),
8215            (OrderSide::Sell, true, Some("quote_ccy"), "12.34500")
8216        )]
8217        sizing: (OrderSide, bool, Option<&str>, &str),
8218        #[values(false, true)] batch: bool,
8219    ) {
8220        let (side, quote_quantity, target, quantity) = sizing;
8221
8222        let (operation, wire_operation) = if batch {
8223            (OKXWsOperation::BatchOrders, "batch-orders")
8224        } else {
8225            (OKXWsOperation::Order, "order")
8226        };
8227
8228        let (request_tx, mut request_rx) = tokio::sync::mpsc::unbounded_channel();
8229        let (barrier_tx, mut barrier_rx) = tokio::sync::mpsc::unbounded_channel();
8230        let ws_tx = request_tx.clone();
8231        let router = Router::new().route("/ws", get(move |ws: WebSocketUpgrade| {
8232            let tx = ws_tx.clone();
8233            let barrier_tx = barrier_tx.clone();
8234            async move { ws.on_upgrade(move |mut socket| async move {
8235                while let Some(Ok(Message::Text(text))) = socket.next().await {
8236                    let request: Value = serde_json::from_str(&text).unwrap();
8237                    match request["op"].as_str() {
8238                        Some("login") => {
8239                            let response = serde_json::json!({"event":"login", "code":"0", "msg":"", "connId":"test"});
8240                            socket.send(Message::Text(response.to_string().into())).await.unwrap();
8241                        }
8242                        Some("subscribe") => {
8243                            let response = serde_json::json!({"event":"subscribe", "arg":request["args"][0], "connId":"test"});
8244                            socket.send(Message::Text(response.to_string().into())).await.unwrap();
8245                            barrier_tx.send(()).unwrap();
8246                        }
8247                        _ => tx.send(request).unwrap(),
8248                    }
8249                }
8250            }) }
8251        })).route("/api/v5/trade/order", post(move |Json(request): Json<Value>| {
8252            let tx = request_tx.clone();
8253            async move {
8254                tx.send(request).unwrap();
8255                let response = serde_json::from_str::<Value>(include_str!("../test_data/http_place_order_response.json")).unwrap();
8256                Json(serde_json::json!({"code":"0", "msg":"", "data":[response]}))
8257            }
8258        }));
8259
8260        let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
8261        let address = listener.local_addr().unwrap();
8262        let server = tokio::spawn(async move { axum::serve(listener, router).await.unwrap() });
8263        let (mut client, cache) = build_test_exec_client_with_cache();
8264
8265        client.http_client = OKXHttpClient::with_credentials(
8266            Some("key".into()),
8267            Some("secret".into()),
8268            Some("pass".into()),
8269            Some(format!("http://{address}")),
8270            5,
8271            0,
8272            1,
8273            1,
8274            OKXEnvironment::Demo,
8275            None,
8276        )
8277        .unwrap();
8278        client.ws_private = OKXWebSocketClient::with_credentials(
8279            Some(format!("ws://{address}/ws")),
8280            Some("key".into()),
8281            Some("secret".into()),
8282            Some("pass".into()),
8283            Some(client.core.account_id),
8284            None,
8285            None,
8286            client.config.transport_backend,
8287            None,
8288        )
8289        .unwrap();
8290        let raw: Value = serde_json::from_str(include_str!(
8291            "../test_data/http_get_instruments_spot_usdc.json"
8292        ))
8293        .unwrap();
8294        let raw: OKXInstrument = serde_json::from_value(raw["data"][0].clone()).unwrap();
8295        let instrument = parse_instrument_any(&raw, None, None, UnixNanos::default())
8296            .unwrap()
8297            .unwrap();
8298        let instrument_id = instrument.id();
8299        client.on_instrument(instrument);
8300        client
8301            .ws_private
8302            .cache_inst_id_code(Ustr::from("BTC-USDC"), 20459);
8303        client.ws_private.connect().await.unwrap();
8304        client.ws_private.wait_until_active(5.0).await.unwrap();
8305        let (event_tx, mut event_rx) = tokio::sync::mpsc::unbounded_channel();
8306        client.emitter.set_sender(event_tx);
8307
8308        let quantity = Quantity::from(quantity);
8309
8310        let order = OrderTestBuilder::new(OrderType::Market)
8311            .instrument_id(instrument_id)
8312            .client_order_id(ClientOrderId::from("OSPOTUNITS"))
8313            .side(side)
8314            .quantity(quantity)
8315            .quote_quantity(quote_quantity)
8316            .build();
8317        cache
8318            .borrow_mut()
8319            .add_order(order.clone(), None, Some(*OKX_CLIENT_ID), false)
8320            .unwrap();
8321
8322        let params = Params::new(
8323            [(
8324                "td_mode".into(),
8325                Value::from(trade_mode.to_string().to_lowercase()),
8326            )]
8327            .into(),
8328        );
8329
8330        if batch {
8331            let list = OrderList::new(
8332                OrderListId::from("OL-UNITS"),
8333                instrument_id,
8334                order.strategy_id(),
8335                vec![order.client_order_id()],
8336                UnixNanos::default(),
8337            );
8338            client
8339                .submit_order_list(SubmitOrderList::new(
8340                    client.core.trader_id,
8341                    Some(*OKX_CLIENT_ID),
8342                    order.strategy_id(),
8343                    list,
8344                    vec![OrderInitialized::from(&order)],
8345                    None,
8346                    None,
8347                    Some(params),
8348                    UUID4::new(),
8349                    UnixNanos::default(),
8350                    None,
8351                ))
8352                .unwrap();
8353        } else {
8354            let mut command = SubmitOrder::from_order(
8355                &order,
8356                client.core.trader_id,
8357                Some(*OKX_CLIENT_ID),
8358                None,
8359                UUID4::new(),
8360                UnixNanos::default(),
8361            );
8362            command.params = Some(params);
8363            client.submit_order(command).unwrap();
8364        }
8365
8366        let request = tokio::time::timeout(Duration::from_secs(5), request_rx.recv())
8367            .await
8368            .unwrap()
8369            .unwrap();
8370        let mut fee_cache = FeeCache::new();
8371        let mut filled_qty_cache = FilledQtyCache::new();
8372        let mut snapshots = AHashMap::new();
8373
8374        let message = OKXWsMessage::OrderResponse {
8375            id: Some("quantity-response".into()),
8376            op: operation,
8377            code: overall_code.into(),
8378            msg: String::new(),
8379            client_order_ids: Vec::new(),
8380            data: vec![serde_json::json!({
8381                "clOrdId": "OSPOTUNITS", "ordId": "98765",
8382                "sCode": response_code, "sMsg": "Parameter tdMode error",
8383            })],
8384        };
8385
8386        dispatch_ws_message(
8387            message,
8388            &client.emitter,
8389            &client.ws_dispatch_state,
8390            client.core.account_id,
8391            client.core.account_type,
8392            &client.ws_private.instruments_cache_arc(),
8393            &mut fee_cache,
8394            &mut filled_qty_cache,
8395            &mut snapshots,
8396            client.clock,
8397        );
8398
8399        let ExecutionEvent::Order(OrderEventAny::Submitted(submitted)) =
8400            event_rx.try_recv().unwrap()
8401        else {
8402            panic!("expected submitted event")
8403        };
8404
8405        assert_eq!(submitted.client_order_id, order.client_order_id());
8406        assert_eq!(submitted.instrument_id, instrument_id);
8407        assert_eq!(submitted.strategy_id, order.strategy_id());
8408        assert_eq!(submitted.account_id, client.core.account_id);
8409        assert_eq!(request["op"], wire_operation);
8410        assert_eq!(
8411            request["args"][0]["tdMode"],
8412            trade_mode.to_string().to_lowercase()
8413        );
8414        assert_eq!(request["args"][0]["sz"], quantity.to_string());
8415        assert_eq!(
8416            request["args"][0].get("tgtCcy").and_then(Value::as_str),
8417            target
8418        );
8419
8420        if response_code == "51000" {
8421            let ExecutionEvent::Order(OrderEventAny::Rejected(rejected)) =
8422                event_rx.try_recv().unwrap()
8423            else {
8424                panic!("expected rejection")
8425            };
8426
8427            assert_eq!(rejected.client_order_id, order.client_order_id());
8428            assert_eq!(rejected.instrument_id, instrument_id);
8429            assert_eq!(
8430                rejected.reason.as_str(),
8431                "OKX error 51000: Parameter tdMode error"
8432            );
8433        }
8434
8435        wait_until_async(
8436            || async { client.pending_tasks.is_empty() },
8437            Duration::from_secs(1),
8438        )
8439        .await;
8440
8441        // Wait for a later frame so the absence check includes queued order sends
8442        client
8443            .ws_private
8444            .subscribe_orders(OKXInstrumentType::Spot)
8445            .await
8446            .unwrap();
8447        tokio::time::timeout(Duration::from_secs(1), barrier_rx.recv())
8448            .await
8449            .unwrap()
8450            .unwrap();
8451
8452        assert!(event_rx.try_recv().is_err());
8453        assert!(request_rx.try_recv().is_err());
8454        client.disconnect().await.unwrap();
8455        server.abort();
8456    }
8457
8458    #[rstest]
8459    #[case(OrderSide::Buy, OKXPositionSide::Long)]
8460    #[case(OrderSide::Sell, OKXPositionSide::Short)]
8461    fn test_missing_hedge_leg_reports_flat(
8462        #[case] side: OrderSide,
8463        #[case] leg: OKXPositionSide,
8464        #[values(false, true)] other_leg_present: bool,
8465        #[values(OKXInstrumentType::Swap, OKXInstrumentType::Futures)]
8466        configured_type: OKXInstrumentType,
8467    ) {
8468        let (mut client, cache) = build_test_exec_client_with_cache();
8469        client.position_mode = OKXPositionMode::LongShortMode;
8470        client.config.instrument_types = vec![configured_type];
8471        let instrument = swap_instrument();
8472        let position_id = venue_position_id(instrument.id(), leg).unwrap();
8473        let order = OrderTestBuilder::new(OrderType::Market)
8474            .instrument_id(instrument.id())
8475            .side(side)
8476            .quantity(Quantity::from("2"))
8477            .build();
8478        let fill = TestOrderEventStubs::filled(
8479            &order,
8480            &instrument,
8481            Some(TradeId::from("T-HEDGE")),
8482            Some(position_id),
8483            Some(Price::from("123.4")),
8484            Some(Quantity::from("2")),
8485            Some(LiquiditySide::Taker),
8486            Some(Money::from("0.01 USDT")),
8487            None,
8488            Some(client.core.account_id),
8489        );
8490        let position = Position::new(&instrument, fill.into());
8491        cache
8492            .borrow_mut()
8493            .add_position(&position, OmsType::Hedging)
8494            .unwrap();
8495        let ts_init = UnixNanos::from(98765);
8496
8497        let other_side = if leg == OKXPositionSide::Long {
8498            OKXPositionSide::Short
8499        } else {
8500            OKXPositionSide::Long
8501        };
8502
8503        let mut reports = if other_leg_present {
8504            vec![PositionStatusReport::new(
8505                client.core.account_id,
8506                instrument.id(),
8507                other_side.into(),
8508                Quantity::from("3"),
8509                ts_init,
8510                ts_init,
8511                None,
8512                venue_position_id(instrument.id(), other_side),
8513                None,
8514            )]
8515        } else {
8516            Vec::new()
8517        };
8518
8519        let original_reports = reports.clone();
8520        client.add_flat_derivative_position_reports(&[], &[], &mut reports, ts_init);
8521
8522        if configured_type != OKXInstrumentType::Swap {
8523            assert_eq!(reports, original_reports);
8524            return;
8525        }
8526
8527        assert_eq!(reports.len(), 1 + usize::from(other_leg_present));
8528        let report = reports.last().unwrap();
8529        assert_eq!(report.account_id, client.core.account_id);
8530        assert_eq!(report.instrument_id, instrument.id());
8531        assert_eq!(report.venue_position_id, Some(position_id));
8532        assert_eq!(report.position_side, PositionSide::Flat);
8533        assert_eq!(report.quantity, Quantity::zero(position.quantity.precision));
8534        assert_eq!(report.ts_last, ts_init);
8535        assert_eq!(report.ts_init, ts_init);
8536        client.add_flat_derivative_position_reports(&[], &[], &mut reports, ts_init);
8537        assert_eq!(reports.len(), 1 + usize::from(other_leg_present));
8538    }
8539
8540    #[rstest]
8541    #[case(OKXPositionSide::Long, OrderSide::Sell)]
8542    #[case(OKXPositionSide::Short, OrderSide::Buy)]
8543    fn test_missing_hedge_history_leg_reports_flat(
8544        #[case] leg: OKXPositionSide,
8545        #[case] closing_side: OrderSide,
8546        #[values("order", "fill", "both")] source: &str,
8547        #[values(false, true)] other_leg_present: bool,
8548    ) {
8549        let mut client = build_test_exec_client();
8550        client.position_mode = OKXPositionMode::LongShortMode;
8551        client.config.instrument_types = vec![OKXInstrumentType::Swap];
8552        let instrument_id = InstrumentId::from("BTC-USDT-SWAP.OKX");
8553        let position_id = venue_position_id(instrument_id, leg).unwrap();
8554        let ts_init = UnixNanos::from(98765);
8555        let mut order = make_query_order_report(Some("O-CLOSE"), "V-CLOSE");
8556        order.instrument_id = instrument_id;
8557        order.order_side = closing_side.into();
8558        order.order_status = OrderStatus::Filled;
8559        order.quantity = Quantity::from("2.00");
8560        order.filled_qty = Quantity::from("2.00");
8561        order.venue_position_id = Some(position_id);
8562
8563        let fill = FillReport::new(
8564            client.core.account_id,
8565            instrument_id,
8566            VenueOrderId::from("V-CLOSE"),
8567            TradeId::from("T-CLOSE"),
8568            closing_side,
8569            Quantity::from("2.00"),
8570            Price::from("123.4"),
8571            Money::from("0.01 USDT"),
8572            LiquiditySide::Taker,
8573            Some(ClientOrderId::from("O-CLOSE")),
8574            Some(position_id),
8575            ts_init,
8576            ts_init,
8577            None,
8578        );
8579
8580        let orders = if source == "fill" {
8581            vec![]
8582        } else {
8583            vec![order]
8584        };
8585
8586        let fills = if source == "order" {
8587            vec![]
8588        } else {
8589            vec![fill]
8590        };
8591
8592        let other_leg = if leg == OKXPositionSide::Long {
8593            OKXPositionSide::Short
8594        } else {
8595            OKXPositionSide::Long
8596        };
8597
8598        let mut reports = if other_leg_present {
8599            vec![PositionStatusReport::new(
8600                client.core.account_id,
8601                instrument_id,
8602                other_leg.into(),
8603                Quantity::from("3.50"),
8604                ts_init,
8605                ts_init,
8606                None,
8607                venue_position_id(instrument_id, other_leg),
8608                None,
8609            )]
8610        } else {
8611            vec![]
8612        };
8613
8614        client.add_flat_derivative_position_reports(&orders, &fills, &mut reports, ts_init);
8615
8616        assert_eq!(reports.len(), 1 + usize::from(other_leg_present));
8617        let report = reports.last().unwrap();
8618        assert_eq!(report.account_id, client.core.account_id);
8619        assert_eq!(report.instrument_id, instrument_id);
8620        assert_eq!(report.venue_position_id, Some(position_id));
8621        assert_eq!(report.position_side, PositionSide::Flat);
8622        assert_eq!(report.quantity, Quantity::zero(2));
8623        assert_eq!(report.quantity.precision, 2);
8624        assert_eq!(report.ts_last, ts_init);
8625        assert_eq!(report.ts_init, ts_init);
8626        assert_eq!(report.avg_px_open, None);
8627
8628        if other_leg_present {
8629            assert_eq!(
8630                reports[0].venue_position_id,
8631                venue_position_id(instrument_id, other_leg)
8632            );
8633            assert_eq!(reports[0].quantity, Quantity::from("3.50"));
8634            assert_eq!(reports[0].position_side, PositionSide::from(other_leg));
8635        }
8636
8637        client.add_flat_derivative_position_reports(&orders, &fills, &mut reports, ts_init);
8638        assert_eq!(reports.len(), 1 + usize::from(other_leg_present));
8639    }
8640
8641    #[rstest]
8642    #[case(false)]
8643    #[case(true)]
8644    fn test_submit_order_denies_hedge_conflict(#[case] margin_conflict: bool) {
8645        let (mut client, cache) = build_test_exec_client_with_cache();
8646        client.position_mode = OKXPositionMode::LongShortMode;
8647        client.trade_mode = OKXTradeMode::Cross;
8648        let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel();
8649        client.emitter.set_sender(tx);
8650        let order = OrderTestBuilder::new(OrderType::Limit)
8651            .instrument_id(InstrumentId::from("ETH-USDT-SWAP.OKX"))
8652            .client_order_id(ClientOrderId::from("ODENYHEDGE"))
8653            .side(OrderSide::Sell)
8654            .price(Price::from("123.45"))
8655            .quantity(Quantity::from("2"))
8656            .build();
8657        cache
8658            .borrow_mut()
8659            .add_order(order.clone(), None, Some(*OKX_CLIENT_ID), false)
8660            .unwrap();
8661        let mut command = SubmitOrder::from_order(
8662            &order,
8663            client.core.trader_id,
8664            Some(*OKX_CLIENT_ID),
8665            Some(PositionId::from("ETH-USDT-SWAP.OKX-LONG")),
8666            UUID4::new(),
8667            UnixNanos::default(),
8668        );
8669
8670        if margin_conflict {
8671            command.position_id = None;
8672            let params =
8673                Params::new([("td_mode".to_string(), Value::String("cross".to_string()))].into());
8674            command.params = Some(params);
8675        }
8676
8677        client.submit_order(command).unwrap();
8678        let event = rx.try_recv().unwrap();
8679
8680        let ExecutionEvent::Order(OrderEventAny::Denied(denied)) = event else {
8681            panic!("Expected denial, received {event:?}");
8682        };
8683
8684        assert_eq!(denied.client_order_id, order.client_order_id());
8685        assert_eq!(
8686            denied.reason.as_str(),
8687            if margin_conflict {
8688                "VALIDATION_FAILED: OKX long/short mode requires configured trade mode Isolated, received Cross; mixed margin modes are not supported"
8689            } else {
8690                "INVALID_POSITION_ID: ETH-USDT-SWAP.OKX-LONG; expected OKX venue position ID ETH-USDT-SWAP.OKX-SHORT"
8691            }
8692        );
8693        assert_eq!(
8694            rx.try_recv().unwrap_err(),
8695            tokio::sync::mpsc::error::TryRecvError::Empty
8696        );
8697    }
8698
8699    #[rstest]
8700    #[case(false)]
8701    #[case(true)]
8702    fn test_submit_order_list_denies_hedge_conflict_atomically(#[case] margin_conflict: bool) {
8703        let (mut client, cache) = build_test_exec_client_with_cache();
8704        client.position_mode = OKXPositionMode::LongShortMode;
8705        client.trade_mode = OKXTradeMode::Cross;
8706        let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel();
8707        client.emitter.set_sender(tx);
8708        let instrument_id = InstrumentId::from("ETH-USDT-SWAP.OKX");
8709
8710        let orders: Vec<_> = [OrderSide::Buy, OrderSide::Sell]
8711            .into_iter()
8712            .enumerate()
8713            .map(|(i, side)| {
8714                OrderTestBuilder::new(OrderType::Limit)
8715                    .instrument_id(instrument_id)
8716                    .client_order_id(ClientOrderId::from(format!("OHEDGE{i}")))
8717                    .side(side)
8718                    .price(Price::from("123.45"))
8719                    .quantity(Quantity::from("2"))
8720                    .build()
8721            })
8722            .collect();
8723
8724        for order in &orders {
8725            cache
8726                .borrow_mut()
8727                .add_order(order.clone(), None, Some(*OKX_CLIENT_ID), false)
8728                .unwrap();
8729        }
8730
8731        let order_list = OrderList::new(
8732            OrderListId::from("OL-HEDGE"),
8733            instrument_id,
8734            orders[0].strategy_id(),
8735            orders.iter().map(Order::client_order_id).collect(),
8736            UnixNanos::default(),
8737        );
8738
8739        let mut command = SubmitOrderList::new(
8740            client.core.trader_id,
8741            Some(*OKX_CLIENT_ID),
8742            orders[0].strategy_id(),
8743            order_list,
8744            orders.iter().map(OrderInitialized::from).collect(),
8745            None,
8746            Some(PositionId::from("ETH-USDT-SWAP.OKX-LONG")),
8747            None,
8748            UUID4::new(),
8749            UnixNanos::default(),
8750            None,
8751        );
8752
8753        if margin_conflict {
8754            command.position_id = None;
8755            let params =
8756                Params::new([("td_mode".to_string(), Value::String("cross".to_string()))].into());
8757            command.params = Some(params);
8758        }
8759
8760        client.submit_order_list(command).unwrap();
8761
8762        for order in orders {
8763            let event = rx.try_recv().unwrap();
8764
8765            let ExecutionEvent::Order(OrderEventAny::Denied(denied)) = event else {
8766                panic!("Expected denial, received {event:?}");
8767            };
8768
8769            assert_eq!(denied.client_order_id, order.client_order_id());
8770
8771            let expected = if margin_conflict {
8772                "VALIDATION_FAILED: OKX long/short mode requires configured trade mode Isolated, received Cross; mixed margin modes are not supported"
8773            } else if order.order_side() == OrderSide::Sell {
8774                "INVALID_POSITION_ID: ETH-USDT-SWAP.OKX-LONG; expected OKX venue position ID ETH-USDT-SWAP.OKX-SHORT"
8775            } else {
8776                "ORDER_LIST_DENIED: OL-HEDGE"
8777            };
8778
8779            assert_eq!(denied.reason.as_str(), expected);
8780        }
8781
8782        assert_eq!(
8783            rx.try_recv().unwrap_err(),
8784            tokio::sync::mpsc::error::TryRecvError::Empty
8785        );
8786    }
8787}