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