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