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