1use std::{
19 future::Future,
20 sync::Arc,
21 time::{Duration, Instant},
22};
23
24use ahash::{AHashMap, AHashSet};
25use anyhow::Context;
26use async_trait::async_trait;
27use dashmap::DashMap;
28use futures_util::{StreamExt, pin_mut};
29use nautilus_common::{
30 clients::{ExecutionClient, ExecutionReportTask},
31 enums::LogLevel,
32 live::{runner::get_exec_event_sender, sender::EventSender},
33 logging::map_log_level_to_filter,
34 messages::{
35 ExecutionEvent,
36 execution::{
37 BatchCancelOrders, CancelAllOrders, CancelOrder, GenerateFillReports,
38 GenerateOrderStatusReport, GenerateOrderStatusReports, GeneratePositionStatusReports,
39 ModifyOrder, QueryAccount, QueryOrder, SubmitOrder, SubmitOrderList,
40 },
41 },
42 msgbus::{self, TypedHandler},
43};
44use nautilus_core::{
45 AtomicMap, DurationNanos, Params, UUID4, UnixNanos,
46 string::secret::SecretString,
47 time::{AtomicTime, get_atomic_clock_realtime},
48};
49use nautilus_live::{
50 ExecutionClientCore, ExecutionEventEmitter, SocketControl,
51 execution::{failure::CommandFailure, reports::retain_order_status_reports},
52 task::{TaskGroup, TaskGroupGuard},
53};
54use nautilus_model::{
55 accounts::AccountAny,
56 enums::{
57 AccountType, LiquiditySide, OmsType, OrderSide, OrderStatus, OrderType, PositionSide,
58 TimeInForce,
59 },
60 events::{
61 OrderAccepted, OrderCancelRejected, OrderCanceled, OrderDeniedReason, OrderEventAny,
62 OrderExpired, OrderFilled, OrderInitialized, OrderRejected, OrderUpdated,
63 },
64 fees::MakerTakerFeeRates,
65 identifiers::{
66 AccountId, ClientId, ClientOrderId, InstrumentId, StrategyId, TradeId, Venue, VenueOrderId,
67 },
68 instruments::{Instrument, InstrumentAny},
69 orders::{Order, OrderAny},
70 reports::{ExecutionMassStatus, FillReport, OrderStatusReport, PositionStatusReport},
71 types::{AccountBalance, Currency, MarginBalance, Money, Price, Quantity},
72};
73use rust_decimal::Decimal;
74use ustr::Ustr;
75
76use crate::{
77 common::{
78 auth::run_auth_token_refresh,
79 consts::{
80 AX_ACCOUNT_REGISTRATION_TIMEOUT_SECS, AX_AUTH_TOKEN_TTL_SECS, AX_FILL_ORDER_PREFIX,
81 AX_FILLS_MAX_LOOKBACK_DAYS, AX_POST_ONLY_REJECT, AX_VENUE,
82 },
83 credential::Credential,
84 enums::{
85 AxCancelRejectionReason, AxOrderSide, AxOrderStatus, AxSelfTradeBehavior, AxTimeInForce,
86 },
87 parse::{
88 ax_timestamp_stn_to_unix_nanos, cid_to_client_order_id, client_order_id_to_cid,
89 quantity_to_contracts,
90 },
91 },
92 config::AxExecutionClientConfig,
93 http::{
94 client::AxHttpClient,
95 error::AxHttpError,
96 models::{AxOrderRejectReason, PreviewAggressiveLimitOrderRequest, ReplaceOrderRequest},
97 parse::update_order_report_timestamps,
98 },
99 websocket::{
100 AxOrdersWsMessage, AxWsOrderEvent,
101 messages::{AxWsOrder, AxWsTradeExecution, OrderMetadata},
102 orders::{
103 AxOrdersWebSocketClient, AxOrdersWsClientError, OrdersCaches,
104 client::reserve_cid_mapping,
105 },
106 },
107};
108
109#[derive(Debug)]
111pub struct AxExecutionClient {
112 core: ExecutionClientCore,
113 clock: &'static AtomicTime,
114 config: AxExecutionClientConfig,
115 emitter: ExecutionEventEmitter,
116 http_client: AxHttpClient,
117 ws_orders: AxOrdersWebSocketClient,
118 order_event_handler: Option<TypedHandler<OrderEventAny>>,
119 session_tasks: TaskGroup,
120 pending_tasks: TaskGroup,
121 shutdown_errors: Vec<String>,
122}
123
124impl AxExecutionClient {
125 pub fn new(core: ExecutionClientCore, config: AxExecutionClientConfig) -> anyhow::Result<Self> {
131 config
132 .validate_proxy_url()
133 .context("Invalid AX proxy URL")?;
134
135 let http_client = AxHttpClient::with_credentials(
136 config
137 .api_key
138 .clone()
139 .map_or_default(|value| value.into_inner()),
140 config
141 .api_secret
142 .clone()
143 .map_or_default(|value| value.into_inner()),
144 Some(config.http_base_url()),
145 Some(config.orders_base_url()),
146 config.http_timeout_secs,
147 config.max_retries,
148 config.retry_delay_initial_ms,
149 config.retry_delay_max_ms,
150 config
151 .proxy_url
152 .as_ref()
153 .map(|url| url.expose_secret().to_owned()),
154 )?;
155
156 let clock = get_atomic_clock_realtime();
157 let trader_id = core.trader_id;
158 let account_id = core.account_id;
159 let emitter =
160 ExecutionEventEmitter::new(clock, trader_id, account_id, AccountType::Margin, None);
161 let ws_orders = AxOrdersWebSocketClient::new(
162 config.ws_private_url(),
163 account_id,
164 trader_id,
165 config.heartbeat_interval_secs,
166 config.transport_backend,
167 config
168 .proxy_url
169 .as_ref()
170 .map(|url| url.expose_secret().to_owned()),
171 )
172 .with_cancel_on_disconnect(config.cancel_on_disconnect)?
173 .with_socket_control(SocketControl::new(
174 core.client_id,
175 Some(*AX_VENUE),
176 "architect-ax-user-streams",
177 ));
178
179 let session_tasks = TaskGroup::new();
180 let pending_tasks = TaskGroup::new();
181
182 Ok(Self {
183 core,
184 clock,
185 config,
186 emitter,
187 http_client,
188 ws_orders,
189 order_event_handler: None,
190 session_tasks,
191 pending_tasks,
192 shutdown_errors: Vec::new(),
193 })
194 }
195
196 pub(crate) fn set_event_sender(&mut self, sender: EventSender<ExecutionEvent>) {
197 self.emitter.set_sender(sender);
198 }
199
200 fn ensure_order_event_subscription(&mut self) {
201 if self.order_event_handler.is_some() {
202 return;
203 }
204
205 let caches = self.ws_orders.caches().clone();
206 let account_id = self.core.account_id;
207
208 let handler = TypedHandler::from(move |event: &OrderEventAny| {
209 let OrderEventAny::Accepted(accepted) = event else {
210 return;
211 };
212
213 if accepted.account_id != account_id {
214 return;
215 }
216
217 let Some(mut metadata) = caches.orders_metadata.get_mut(&accepted.client_order_id)
218 else {
219 return;
220 };
221
222 if metadata.trader_id != accepted.trader_id
223 || metadata.strategy_id != accepted.strategy_id
224 || metadata.instrument_id != accepted.instrument_id
225 {
226 return;
227 }
228
229 metadata.is_accepted = true;
230 if metadata.venue_order_id.is_none() {
231 metadata.venue_order_id = Some(accepted.venue_order_id);
232 drop(metadata);
233 caches
234 .venue_to_client_id
235 .insert(accepted.venue_order_id, accepted.client_order_id);
236 }
237 });
238
239 msgbus::subscribe_order_events("events.order.*".into(), handler.clone(), Some(10));
240 self.order_event_handler = Some(handler);
241 }
242
243 fn clear_order_event_subscription(&mut self) {
244 if let Some(handler) = self.order_event_handler.take() {
245 msgbus::unsubscribe_order_events("events.order.*".into(), &handler);
246 }
247 }
248
249 async fn authenticate(&self, credential: &Credential) -> anyhow::Result<SecretString> {
250 self.http_client
251 .authenticate(
252 credential.api_key(),
253 credential.api_secret(),
254 AX_AUTH_TOKEN_TTL_SECS,
255 )
256 .await
257 .map_err(|e| anyhow::anyhow!("Authentication failed: {e}"))
258 }
259
260 fn update_account_state(&self) {
261 let http_client = self.http_client.clone();
262 let account_id = self.core.account_id;
263 let emitter = self.emitter.clone();
264 let clock = self.clock;
265
266 self.spawn_task("query_account", async move {
267 let account_state = http_client
268 .request_account_state(account_id)
269 .await
270 .context("failed to request AX account state")?;
271 let ts_event = clock.get_time_ns();
272 emitter.emit_account_state(
273 account_state.balances.clone(),
274 account_state.margins.clone(),
275 account_state.is_reported,
276 ts_event,
277 account_state.info,
278 );
279 Ok(())
280 });
281 }
282
283 fn submit_order_internal(
284 &self,
285 cmd: &SubmitOrder,
286 self_trade: Option<AxSelfTradeBehavior>,
287 ) -> anyhow::Result<()> {
288 let (
289 order_for_task,
290 client_order_id,
291 instrument_id,
292 order_side,
293 order_type,
294 quantity,
295 time_in_force,
296 is_post_only,
297 limit_price,
298 ) = {
299 let cache = self.core.cache();
300 let order = cache.try_order(&cmd.client_order_id)?;
301 (
302 order.clone(),
303 order.client_order_id(),
304 order.instrument_id(),
305 order.order_side(),
306 order.order_type(),
307 order.quantity(),
308 order.time_in_force(),
309 order.is_post_only(),
310 order.price(),
311 )
312 };
313
314 let order_init = cmd.order_init.clone();
315 let ws_orders = self.ws_orders.clone();
316 let caches = ws_orders.caches().clone();
317 let emitter = self.emitter.clone();
318 let clock = self.clock;
319
320 let http_client = self.http_client.clone();
321
322 self.spawn_task("submit_order", async move {
323 let (price, submit_time_in_force, submit_post_only) = if order_type
326 == OrderType::Market
327 {
328 let preview_result: anyhow::Result<Price> = async {
329 let symbol = instrument_id.symbol.inner();
330 let ax_side = AxOrderSide::from(order_side);
331 let qty_contracts = quantity_to_contracts(quantity)?;
332
333 let instrument = http_client.get_instrument(&symbol).ok_or_else(|| {
334 anyhow::anyhow!("Instrument {instrument_id} not found in cache")
335 })?;
336
337 let request =
338 PreviewAggressiveLimitOrderRequest::new(symbol, qty_contracts, ax_side);
339 let response = http_client
340 .inner
341 .preview_aggressive_limit_order(&request)
342 .await
343 .map_err(|e| {
344 anyhow::anyhow!("Failed to preview aggressive limit order: {e}")
345 })?;
346
347 if response.remaining_quantity > 0 {
348 log::warn!(
349 "Market order book depth insufficient: \
350 filled_qty={} remaining_qty={} for {instrument_id}",
351 response.filled_quantity,
352 response.remaining_quantity,
353 );
354 }
355
356 let limit_price_decimal = response.limit_price.ok_or_else(|| {
357 anyhow::anyhow!(
358 "No liquidity available for market order on {instrument_id}"
359 )
360 })?;
361
362 let price =
363 Price::from_decimal_dp(limit_price_decimal, instrument.price_precision())
364 .with_context(|| {
365 format!(
366 "Failed to convert AX take-through price {limit_price_decimal} for {instrument_id}"
367 )
368 })?;
369 log::debug!("Market order take-through price: {price} for {instrument_id}",);
370 Ok(price)
371 }
372 .await;
373
374 let price = match preview_result {
375 Ok(price) => price,
376 Err(e) => {
377 let reason = e.to_string();
378 log::warn!(
379 "AX market order preview failed for {client_order_id}: {reason}"
380 );
381 emitter.emit_order_rejected(
382 &order_for_task,
383 &reason,
384 clock.get_time_ns(),
385 false,
386 );
387 return Ok(());
388 }
389 };
390
391 (price, TimeInForce::Ioc, false)
392 } else {
393 (
394 limit_price.context("AX limit order is missing a price")?,
395 time_in_force,
396 is_post_only,
397 )
398 };
399
400 let result = ws_orders
401 .submit_order(
402 &order_init,
403 quantity,
404 submit_time_in_force,
405 price,
406 submit_post_only,
407 self_trade,
408 )
409 .await;
410
411 if let Err(e) = result {
412 match classify_ax_ws_failure(&e) {
413 CommandFailure::NotSent(reason) | CommandFailure::VenueRejected(reason) => {
416 log::warn!("AX submit failed for {client_order_id}: {reason}");
417 emitter.emit_order_rejected(
418 &order_for_task,
419 &reason,
420 clock.get_time_ns(),
421 false,
422 );
423
424 let cid = client_order_id_to_cid(&client_order_id);
425 let owns_tracking = caches.orders_metadata.contains_key(&client_order_id)
426 && caches
427 .cid_to_client_order_id
428 .get(&cid)
429 .is_some_and(|owner| *owner == client_order_id);
430
431 if owns_tracking {
432 cleanup_terminal_order_tracking_ids(
433 &caches,
434 None,
435 Some(cid),
436 Some(client_order_id),
437 );
438 }
439 }
440 CommandFailure::Ambiguous(reason) => {
441 log::warn!(
442 "Ambiguous AX submit failure for {client_order_id}, awaiting reconciliation: {reason}"
443 );
444 }
445 }
446 }
447
448 Ok(())
449 });
450
451 Ok(())
452 }
453
454 fn cancel_order_internal(&self, cmd: &CancelOrder) {
455 let ws_orders = self.ws_orders.clone();
456 let client_order_id = cmd.client_order_id;
457 let venue_order_id = cmd.venue_order_id;
458
459 let emitter = self.emitter.clone();
460 let clock = self.clock;
461 let strategy_id = cmd.strategy_id;
462 let instrument_id = cmd.instrument_id;
463 let command_id = cmd.command_id;
464
465 self.spawn_task("cancel_order", async move {
466 if let Err(e) = ws_orders
467 .cancel_order_with_command_id(client_order_id, venue_order_id, Some(command_id))
468 .await
469 {
470 match classify_ax_ws_failure(&e) {
471 CommandFailure::NotSent(reason) => {
472 emitter.emit_order_cancel_denied_event(
473 strategy_id,
474 instrument_id,
475 client_order_id,
476 venue_order_id,
477 &reason,
478 clock.get_time_ns(),
479 Some(command_id),
480 );
481 }
482 CommandFailure::VenueRejected(reason) => {
483 log::warn!("Cancel command failed for {client_order_id}: {reason}");
484 }
485 CommandFailure::Ambiguous(reason) => {
486 log::warn!(
487 "Ambiguous AX cancel failure for {client_order_id}, awaiting reconciliation: {reason}"
488 );
489 }
490 }
491 }
492
493 Ok(())
494 });
495 }
496
497 fn spawn_task<F>(&self, description: &'static str, fut: F)
498 where
499 F: Future<Output = anyhow::Result<()>> + Send + 'static,
500 {
501 let future = async move {
502 if let Err(e) = fut.await {
503 log::warn!("{description} failed: {e}");
504 }
505 };
506
507 if let Err(e) = self.pending_tasks.spawn(future) {
508 log::warn!("Skipping AX {description} after shutdown began: {e}");
509 }
510 }
511
512 fn abort_pending_tasks(&self) {
513 self.pending_tasks.begin_shutdown();
514 }
515
516 fn abort_session_tasks(&self) {
517 self.session_tasks.begin_shutdown();
518 self.ws_orders.begin_shutdown();
519 }
520
521 async fn await_pending_tasks(&self) -> anyhow::Result<()> {
522 self.pending_tasks.begin_shutdown();
523 self.pending_tasks
524 .finish_shutdown(Duration::from_secs(1), Duration::from_secs(2))
525 .await
526 .map_err(|e| anyhow::anyhow!("Failed to terminate AX execution tasks: {e}"))?;
527 Ok(())
528 }
529
530 async fn await_session_tasks(&self) -> anyhow::Result<()> {
531 self.session_tasks.begin_shutdown();
532 self.session_tasks
533 .finish_shutdown(Duration::from_secs(1), Duration::from_secs(2))
534 .await
535 .map_err(|e| anyhow::anyhow!("Failed to terminate AX execution session tasks: {e}"))?;
536 Ok(())
537 }
538
539 async fn teardown_partial_connect(&mut self) -> anyhow::Result<()> {
540 self.clear_order_event_subscription();
541 self.abort_session_tasks();
542 self.abort_pending_tasks();
543 self.http_client.cancel_all_requests();
544
545 if let Err(e) = self.ws_orders.close().await {
546 self.shutdown_errors
547 .push(format!("AX orders WebSocket shutdown failed: {e}"));
548 }
549
550 let (session_result, pending_result) =
551 tokio::join!(self.await_session_tasks(), self.await_pending_tasks());
552 cleanup_deferred_order_tracking(self.ws_orders.caches());
553 self.core.set_disconnected();
554
555 if let Err(e) = session_result {
556 self.shutdown_errors.push(e.to_string());
557 }
558
559 if let Err(e) = pending_result {
560 self.shutdown_errors.push(e.to_string());
561 }
562
563 if !self.shutdown_errors.is_empty() {
564 anyhow::bail!(std::mem::take(&mut self.shutdown_errors).join("; "));
565 }
566 Ok(())
567 }
568
569 async fn await_account_registered(&self, timeout_secs: f64) -> anyhow::Result<()> {
571 let account_id = self.core.account_id;
572
573 if self.core.cache().account(&account_id).is_some() {
574 log::info!("Account {account_id} registered");
575 return Ok(());
576 }
577
578 let start = Instant::now();
579 let timeout = Duration::from_secs_f64(timeout_secs);
580 let interval = Duration::from_millis(10);
581
582 loop {
583 tokio::time::sleep(interval).await;
584
585 if self.core.cache().account(&account_id).is_some() {
586 log::info!("Account {account_id} registered");
587 return Ok(());
588 }
589
590 if start.elapsed() >= timeout {
591 anyhow::bail!(
592 "Timeout waiting for account {account_id} to be registered after {timeout_secs}s"
593 );
594 }
595 }
596 }
597}
598
599#[async_trait(?Send)]
600impl ExecutionClient for AxExecutionClient {
601 fn is_connected(&self) -> bool {
602 self.core.is_connected() && self.ws_orders.is_active() && self.ws_orders.is_authenticated()
603 }
604
605 fn client_id(&self) -> ClientId {
606 self.core.client_id
607 }
608
609 fn account_id(&self) -> AccountId {
610 self.core.account_id
611 }
612
613 fn venue(&self) -> Venue {
614 *AX_VENUE
615 }
616
617 fn oms_type(&self) -> OmsType {
618 self.core.oms_type
619 }
620
621 fn get_account(&self) -> Option<AccountAny> {
622 self.core.cache().account_owned(&self.core.account_id)
623 }
624
625 async fn connect(&mut self) -> anyhow::Result<()> {
626 if self.is_connected() && self.pending_tasks.is_open() && self.session_tasks.is_open() {
627 return Ok(());
628 }
629
630 if self.core.is_connected()
631 || !self.pending_tasks.is_open()
632 || !self.session_tasks.is_open()
633 {
634 self.teardown_partial_connect().await?;
635 self.pending_tasks.start_generation().map_err(|e| {
636 anyhow::anyhow!("Failed to start AX execution task generation: {e}")
637 })?;
638 self.session_tasks.start_generation().map_err(|e| {
639 anyhow::anyhow!("Failed to start AX execution session generation: {e}")
640 })?;
641 }
642 let http_client = self.http_client.clone();
643 let ws_orders = self.ws_orders.clone();
644 let setup_guard =
645 TaskGroupGuard::new(&[&self.session_tasks, &self.pending_tasks], move || {
646 http_client.cancel_all_requests();
647 ws_orders.begin_shutdown();
648 });
649
650 self.http_client.reset_cancellation_token();
652
653 let credential = Credential::resolve(
654 self.config.api_key.clone().map(|value| value.into_inner()),
655 self.config
656 .api_secret
657 .clone()
658 .map(|value| value.into_inner()),
659 )
660 .context("API credentials not configured")?;
661 let token = self.authenticate(&credential).await?;
662
663 self.http_client
664 .request_account_fees()
665 .await
666 .context("failed to resolve AX account fee rates")?;
667
668 if !self.core.instruments_initialized() {
669 let instruments = self
670 .http_client
671 .request_instruments()
672 .await
673 .context("failed to request AX instruments")?;
674
675 if instruments.is_empty() {
676 log::warn!("No instruments returned from AX");
677 } else {
678 log::debug!("Loaded {} instruments", instruments.len());
679 self.http_client.cache_instruments(&instruments);
680 self.ws_orders.cache_instruments(&instruments);
681 }
682 self.core.set_instruments_initialized();
683 }
684
685 let orders = {
686 let cache = self.core.cache();
687 let mut orders = cache.orders_refs(Some(&AX_VENUE), None, None, None, None);
688 orders.retain(|order| {
689 (order.is_open() || order.is_inflight())
690 && order.trader_id() == self.core.trader_id
691 && order
692 .account_id()
693 .is_none_or(|account_id| account_id == self.core.account_id)
694 && cache
695 .client_id(&order.client_order_id())
696 .is_none_or(|client_id| *client_id == self.core.client_id)
697 });
698
699 orders
700 .into_iter()
701 .map(|order| order.cloned())
702 .collect::<Vec<_>>()
703 };
704
705 for order in orders {
706 let symbol = order.instrument_id().symbol.inner();
707 let needs_instrument = self.http_client.get_instrument(&symbol).is_none()
708 && self
709 .core
710 .cache()
711 .instrument(&order.instrument_id())
712 .is_none();
713
714 if needs_instrument {
715 let instrument = self
716 .http_client
717 .request_instrument(symbol)
718 .await
719 .with_context(|| format!("failed to restore AX instrument {symbol}"))?;
720 self.http_client.cache_instrument(instrument);
721 }
722
723 self.restore_order_tracking(&order, None)?;
724 }
725
726 self.ensure_order_event_subscription();
727 self.ws_orders.connect(token.expose_secret()).await?;
728 log::debug!("Connected to orders WebSocket");
729
730 let stream = self.ws_orders.stream();
731 let emitter = self.emitter.clone();
732 let caches = self.ws_orders.caches().clone();
733 let account_id = self.core.account_id;
734 let instruments_cache = self.ws_orders.instruments_cache();
735 let account_fee_rates = self.http_client.account_fee_rates.clone();
736 let clock = self.clock;
737
738 if let Err(e) = self.session_tasks.spawn(async move {
739 pin_mut!(stream);
740 while let Some(message) = stream.next().await {
741 dispatch_ws_message(
742 message,
743 &emitter,
744 &caches,
745 account_id,
746 &instruments_cache,
747 &account_fee_rates,
748 clock,
749 );
750 }
751 }) {
752 if let Err(teardown_error) = self.teardown_partial_connect().await {
753 return Err(anyhow::Error::new(e).context(format!(
754 "AX execution startup teardown failed: {teardown_error}"
755 )));
756 }
757 return Err(e.into());
758 }
759
760 let session_result = async {
761 let account_state = self
762 .http_client
763 .request_account_state(self.core.account_id)
764 .await
765 .context("failed to request AX account state")?;
766
767 if !account_state.balances.is_empty() {
768 log::debug!(
769 "Received account state with {} balance(s)",
770 account_state.balances.len()
771 );
772 }
773 self.emitter.send_account_state(account_state);
774
775 self.await_account_registered(AX_ACCOUNT_REGISTRATION_TIMEOUT_SECS)
776 .await?;
777
778 let ws_orders = self.ws_orders.clone();
779 self.session_tasks.spawn(run_auth_token_refresh(
780 self.http_client.clone(),
781 credential,
782 move |token| ws_orders.update_auth_token(token.expose_secret()),
783 ))?;
784 Ok::<(), anyhow::Error>(())
785 }
786 .await;
787
788 if let Err(e) = session_result {
789 if let Err(teardown_error) = self.teardown_partial_connect().await {
790 return Err(e.context(format!(
791 "AX execution startup teardown failed: {teardown_error}"
792 )));
793 }
794 return Err(e);
795 }
796
797 self.core.set_connected();
798 setup_guard.disarm();
799 log::info!("Connected: client_id={}", self.core.client_id);
800 Ok(())
801 }
802
803 async fn disconnect(&mut self) -> anyhow::Result<()> {
804 self.clear_order_event_subscription();
805 self.abort_session_tasks();
806 self.abort_pending_tasks();
807 self.http_client.cancel_all_requests();
808
809 let ws_result = self.ws_orders.close().await;
810 let (session_result, pending_result) =
811 tokio::join!(self.await_session_tasks(), self.await_pending_tasks());
812
813 cleanup_deferred_order_tracking(self.ws_orders.caches());
814 self.core.set_disconnected();
815 ws_result?;
816 session_result?;
817 pending_result?;
818 log::info!("Disconnected: client_id={}", self.core.client_id);
819 Ok(())
820 }
821
822 fn query_account(&self, _cmd: QueryAccount) -> anyhow::Result<()> {
823 self.update_account_state();
824 Ok(())
825 }
826
827 fn query_order(&self, cmd: QueryOrder) -> anyhow::Result<()> {
828 let http_client = self.http_client.clone();
829 let account_id = self.core.account_id;
830 let client_order_id = cmd.client_order_id;
831 let venue_order_id = self
832 .ws_orders
833 .orders_metadata()
834 .get(&client_order_id)
835 .and_then(|metadata| metadata.venue_order_id)
836 .or(cmd.venue_order_id);
837 let instrument_id = cmd.instrument_id;
838 let emitter = self.emitter.clone();
839 let caches = self.ws_orders.caches().clone();
840
841 let (order_side, order_type, time_in_force) = {
843 let cache = self.core.cache();
844 match cache.order(&client_order_id) {
845 Some(order) => (
846 Some(order.order_side()),
847 order.order_type(),
848 order.time_in_force(),
849 ),
850 None => (None, OrderType::Limit, TimeInForce::Gtc),
851 }
852 };
853
854 self.spawn_task("query_order", async move {
855 match http_client
856 .request_order_status(
857 account_id,
858 instrument_id,
859 Some(client_order_id),
860 venue_order_id,
861 order_side,
862 order_type,
863 time_in_force,
864 )
865 .await
866 {
867 Ok(report) => {
868 if let Some(report) =
869 resolve_order_status_report(&http_client, &caches, client_order_id, report)
870 .await?
871 {
872 cleanup_resolved_order_status_report(&report, &caches);
873 emitter.send_order_status_report(report);
874 }
875 }
876 Err(e) => log::warn!("AX query order failed: {e}"),
877 }
878 Ok(())
879 });
880
881 Ok(())
882 }
883
884 fn generate_account_state(
885 &self,
886 balances: Vec<AccountBalance>,
887 margins: Vec<MarginBalance>,
888 reported: bool,
889 ts_event: UnixNanos,
890 info: Option<Params>,
891 ) -> anyhow::Result<()> {
892 self.emitter
893 .emit_account_state(balances, margins, reported, ts_event, info);
894 Ok(())
895 }
896
897 fn start(&mut self) -> anyhow::Result<()> {
898 self.ensure_order_event_subscription();
899
900 if self.core.is_started() {
901 return Ok(());
902 }
903
904 self.emitter.set_sender(get_exec_event_sender());
905 self.core.set_started();
906 log::info!(
907 "Started: client_id={}, account_id={}, environment={}",
908 self.core.client_id,
909 self.core.account_id,
910 self.config.environment,
911 );
912 Ok(())
913 }
914
915 fn stop(&mut self) -> anyhow::Result<()> {
916 self.clear_order_event_subscription();
917
918 if self.core.is_stopped() {
919 return Ok(());
920 }
921
922 self.core.set_stopped();
923 self.core.set_disconnected();
924
925 self.abort_session_tasks();
926 self.abort_pending_tasks();
927 cleanup_deferred_order_tracking(self.ws_orders.caches());
928 log::info!("Stopped: client_id={}", self.core.client_id);
929 Ok(())
930 }
931
932 fn reset(&mut self) -> anyhow::Result<()> {
933 self.clear_order_event_subscription();
934 self.abort_session_tasks();
935 self.abort_pending_tasks();
936 cleanup_deferred_order_tracking(self.ws_orders.caches());
937 self.core.set_disconnected();
938 Ok(())
939 }
940
941 fn dispose(&mut self) -> anyhow::Result<()> {
942 self.clear_order_event_subscription();
943 self.abort_session_tasks();
944 self.abort_pending_tasks();
945 cleanup_deferred_order_tracking(self.ws_orders.caches());
946 self.core.set_disconnected();
947 Ok(())
948 }
949
950 fn submit_order(&self, cmd: SubmitOrder) -> anyhow::Result<()> {
951 let self_trade = {
952 let cache = self.core.cache();
953 let order = cache.try_order(&cmd.client_order_id)?;
954
955 if order.is_closed() {
956 log::warn!("Cannot submit closed order {}", order.client_order_id());
957 return Ok(());
958 }
959
960 let self_trade = match validate_order_for_ax_submit(&order)
961 .and_then(|()| validate_order_init_instructions(&cmd.order_init))
962 .and_then(|()| self_trade_from_params(cmd.params.as_ref()))
963 {
964 Ok(self_trade) => self_trade,
965 Err(e) => {
966 self.emitter.emit_order_denied(&order, &e.to_string());
967 return Ok(());
968 }
969 };
970
971 log::debug!("OrderSubmitted client_order_id={}", order.client_order_id());
972 self.emitter.emit_order_submitted(&order);
973
974 self_trade
975 };
976
977 self.submit_order_internal(&cmd, self_trade)
978 }
979
980 fn submit_order_list(&self, cmd: SubmitOrderList) -> anyhow::Result<()> {
981 for (client_order_id, order_init) in cmd
982 .order_list
983 .client_order_ids
984 .iter()
985 .zip(cmd.order_inits.iter())
986 {
987 let submit_cmd = SubmitOrder::new(
988 cmd.trader_id,
989 cmd.client_id,
990 cmd.strategy_id,
991 cmd.instrument_id,
992 *client_order_id,
993 order_init.clone(),
994 cmd.exec_algorithm_id,
995 cmd.position_id,
996 cmd.params.clone(),
997 UUID4::new(),
998 cmd.ts_init,
999 cmd.correlation_id,
1000 );
1001 self.submit_order(submit_cmd)?;
1002 }
1003 Ok(())
1004 }
1005
1006 fn modify_order(&self, cmd: ModifyOrder) -> anyhow::Result<()> {
1007 if cmd.trigger_price.is_some() {
1008 emit_ax_modify_denied(
1009 &self.emitter,
1010 self.clock,
1011 cmd.strategy_id,
1012 cmd.instrument_id,
1013 cmd.client_order_id,
1014 cmd.venue_order_id,
1015 "AX does not support venue-native trigger prices",
1016 cmd.command_id,
1017 );
1018 return Ok(());
1019 }
1020
1021 let tracked_venue_order_id = self
1022 .ws_orders
1023 .orders_metadata()
1024 .get(&cmd.client_order_id)
1025 .and_then(|metadata| metadata.venue_order_id);
1026
1027 let venue_order_id = match tracked_venue_order_id.or(cmd.venue_order_id) {
1028 Some(voi) => voi,
1029 None => {
1030 emit_ax_modify_denied(
1031 &self.emitter,
1032 self.clock,
1033 cmd.strategy_id,
1034 cmd.instrument_id,
1035 cmd.client_order_id,
1036 None,
1037 "missing venue_order_id",
1038 cmd.command_id,
1039 );
1040 return Ok(());
1041 }
1042 };
1043
1044 let quantity = match cmd.quantity {
1045 Some(quantity) => match quantity_to_contracts(quantity) {
1046 Ok(contracts) => Some(contracts),
1047 Err(e) => {
1048 emit_ax_modify_denied(
1049 &self.emitter,
1050 self.clock,
1051 cmd.strategy_id,
1052 cmd.instrument_id,
1053 cmd.client_order_id,
1054 Some(venue_order_id),
1055 &e.to_string(),
1056 cmd.command_id,
1057 );
1058 return Ok(());
1059 }
1060 },
1061 None => None,
1062 };
1063
1064 if !self.core.is_connected() {
1065 emit_ax_modify_denied(
1066 &self.emitter,
1067 self.clock,
1068 cmd.strategy_id,
1069 cmd.instrument_id,
1070 cmd.client_order_id,
1071 Some(venue_order_id),
1072 "AX execution client is not connected",
1073 cmd.command_id,
1074 );
1075 return Ok(());
1076 }
1077
1078 let http_client = self.http_client.clone();
1079 let emitter = self.emitter.clone();
1080 let clock = self.clock;
1081 let strategy_id = cmd.strategy_id;
1082 let instrument_id = cmd.instrument_id;
1083 let caches = self.ws_orders.caches().clone();
1084 let client_order_id = cmd.client_order_id;
1085 let price = cmd.price;
1086
1087 caches
1088 .pending_modifies
1089 .entry(venue_order_id)
1090 .and_modify(|(_, count, _)| *count += 1)
1091 .or_insert((client_order_id, 1, false));
1092
1093 self.spawn_task("modify_order", async move {
1094 let mut request = ReplaceOrderRequest::new(venue_order_id.as_str());
1095
1096 if let Some(price) = price {
1097 request = request.with_price(price.as_decimal());
1098 }
1099
1100 if let Some(contracts) = quantity {
1101 request = request.with_quantity(contracts);
1102 }
1103
1104 match http_client.inner.replace_order(&request).await {
1105 Ok(resp) => {
1106 let new_venue_order_id = match VenueOrderId::new_checked(&resp.oid) {
1107 Ok(venue_order_id) => venue_order_id,
1108 Err(e) => {
1109 log::warn!(
1110 "AX replace returned invalid venue order ID for {client_order_id}, awaiting reconciliation: {e}"
1111 );
1112 return Ok(());
1113 }
1114 };
1115
1116 record_replacement_proposal(&caches, client_order_id, venue_order_id, new_venue_order_id);
1117 log::debug!(
1118 "AX replace received: old={} proposed={new_venue_order_id}",
1119 request.oid,
1120 );
1121 }
1122 Err(e) => match classify_ax_http_failure(&e) {
1125 CommandFailure::NotSent(reason) => {
1126 complete_pending_modify(&caches, venue_order_id);
1127 emit_ax_modify_denied(
1128 &emitter,
1129 clock,
1130 strategy_id,
1131 instrument_id,
1132 client_order_id,
1133 Some(venue_order_id),
1134 &reason,
1135 cmd.command_id,
1136 );
1137 }
1138 CommandFailure::VenueRejected(reason) => {
1139 complete_pending_modify(&caches, venue_order_id);
1140 emit_ax_modify_rejected(
1141 &emitter,
1142 clock,
1143 strategy_id,
1144 instrument_id,
1145 client_order_id,
1146 Some(venue_order_id),
1147 &reason,
1148 Some(cmd.command_id),
1149 );
1150 }
1151 CommandFailure::Ambiguous(reason) => {
1152 log::warn!(
1153 "Ambiguous AX modify failure for {client_order_id}, awaiting reconciliation: {reason}"
1154 );
1155 }
1156 },
1157 }
1158
1159 Ok(())
1160 });
1161
1162 Ok(())
1163 }
1164
1165 fn cancel_order(&self, cmd: CancelOrder) -> anyhow::Result<()> {
1166 self.cancel_order_internal(&cmd);
1167 Ok(())
1168 }
1169
1170 fn cancel_all_orders(&self, cmd: CancelAllOrders) -> anyhow::Result<()> {
1171 if cmd.order_side.is_some() {
1172 let cancels: Vec<CancelOrder> = {
1175 let cache = self.core.cache();
1176 cache
1177 .orders_open(None, Some(&cmd.instrument_id), None, None, cmd.order_side)
1178 .iter()
1179 .map(|order| CancelOrder {
1180 trader_id: order.trader_id(),
1181 client_id: cmd.client_id,
1182 strategy_id: order.strategy_id(),
1183 instrument_id: order.instrument_id(),
1184 client_order_id: order.client_order_id(),
1185 venue_order_id: order.venue_order_id(),
1186 command_id: cmd.command_id,
1187 ts_init: cmd.ts_init,
1188 params: cmd.params.clone(),
1189 correlation_id: cmd.correlation_id,
1190 causation_id: cmd.causation_id,
1191 })
1192 .collect()
1193 };
1194
1195 if cancels.is_empty() {
1196 log::debug!("No open orders to cancel for {}", cmd.instrument_id);
1197 return Ok(());
1198 }
1199
1200 return self.batch_cancel_orders(BatchCancelOrders {
1201 trader_id: cmd.trader_id,
1202 client_id: cmd.client_id,
1203 strategy_id: cmd.strategy_id,
1204 instrument_id: cmd.instrument_id,
1205 cancels,
1206 command_id: cmd.command_id,
1207 ts_init: cmd.ts_init,
1208 params: cmd.params,
1209 correlation_id: cmd.correlation_id,
1210 causation_id: cmd.causation_id,
1211 });
1212 }
1213
1214 let http_client = self.http_client.clone();
1215 let emitter = self.emitter.clone();
1216 let clock = self.clock;
1217 let instrument_id = cmd.instrument_id;
1218 let account_id = self.core.account_id;
1219 let trader_id = self.core.trader_id;
1220
1221 let open_orders: Vec<(ClientOrderId, Option<VenueOrderId>, StrategyId)> = {
1223 let cache = self.core.cache();
1224 cache
1225 .orders_open(None, Some(&instrument_id), None, None, None)
1226 .iter()
1227 .map(|o| (o.client_order_id(), o.venue_order_id(), o.strategy_id()))
1228 .collect()
1229 };
1230
1231 let caches = self.ws_orders.caches().clone();
1232
1233 self.spawn_task("cancel_all_orders", async move {
1234 match http_client.cancel_all_orders(instrument_id).await {
1235 Ok(()) => {
1236 log::debug!("Canceled all orders for {instrument_id}");
1237
1238 let ts_event = clock.get_time_ns();
1242
1243 for (client_order_id, venue_order_id, strategy_id) in &open_orders {
1244 let event = OrderCanceled::new(
1245 trader_id,
1246 *strategy_id,
1247 instrument_id,
1248 *client_order_id,
1249 UUID4::new(),
1250 ts_event,
1251 clock.get_time_ns(),
1252 false,
1253 *venue_order_id,
1254 Some(account_id),
1255 None,
1256 );
1257 emitter.send_order_event(OrderEventAny::Canceled(event));
1258
1259 cleanup_terminal_order_tracking_ids(
1260 &caches,
1261 None,
1262 None,
1263 Some(*client_order_id),
1264 );
1265 }
1266 }
1267 Err(e) => match classify_ax_http_failure(&e) {
1270 CommandFailure::NotSent(reason) | CommandFailure::VenueRejected(reason) => {
1271 log::warn!("Cancel-all for {instrument_id} failed: {reason}");
1272 }
1273 CommandFailure::Ambiguous(reason) => {
1274 log::warn!(
1275 "Ambiguous AX cancel-all failure for {instrument_id}, awaiting reconciliation: {reason}"
1276 );
1277 }
1278 },
1279 }
1280 Ok(())
1281 });
1282
1283 Ok(())
1284 }
1285
1286 fn batch_cancel_orders(&self, cmd: BatchCancelOrders) -> anyhow::Result<()> {
1287 for cancel in &cmd.cancels {
1288 self.cancel_order_internal(cancel);
1289 }
1290 Ok(())
1291 }
1292
1293 fn generate_order_status_report_task(
1294 &self,
1295 cmd: &GenerateOrderStatusReport,
1296 ) -> Option<ExecutionReportTask<Option<OrderStatusReport>>> {
1297 let client = self.report_client();
1298 let command = cmd.clone();
1299 let caches = self.ws_orders.caches().clone();
1300 Some(ExecutionReportTask::new(
1301 async move { client.generate_order_status_report(&command).await },
1302 move |report| {
1303 if let Some(report) = &report {
1304 cleanup_closed_order_status_report(report, &caches);
1305 }
1306
1307 Ok(report)
1308 },
1309 ))
1310 }
1311
1312 fn generate_order_status_reports_task(
1313 &self,
1314 cmd: &GenerateOrderStatusReports,
1315 ) -> Option<ExecutionReportTask<Vec<OrderStatusReport>>> {
1316 let client = self.report_client();
1317 let command = cmd.clone();
1318 let caches = self.ws_orders.caches().clone();
1319 Some(ExecutionReportTask::new(
1320 async move { client.generate_order_status_reports(&command).await },
1321 move |reports| {
1322 for report in &reports {
1323 cleanup_closed_order_status_report(report, &caches);
1324 }
1325
1326 Ok(reports)
1327 },
1328 ))
1329 }
1330
1331 fn generate_fill_reports_task(
1332 &self,
1333 cmd: &GenerateFillReports,
1334 ) -> Option<ExecutionReportTask<Vec<FillReport>>> {
1335 let client = self.report_client();
1336 let command = cmd.clone();
1337 Some(ExecutionReportTask::new(
1338 async move { client.generate_fill_reports(command).await },
1339 Ok,
1340 ))
1341 }
1342
1343 fn generate_position_status_reports_task(
1344 &self,
1345 cmd: &GeneratePositionStatusReports,
1346 ) -> Option<ExecutionReportTask<Vec<PositionStatusReport>>> {
1347 let client = self.report_client();
1348 let command = cmd.clone();
1349 Some(ExecutionReportTask::new(
1350 async move { client.generate_position_status_reports(&command).await },
1351 Ok,
1352 ))
1353 }
1354
1355 async fn generate_order_status_report(
1356 &self,
1357 cmd: &GenerateOrderStatusReport,
1358 ) -> anyhow::Result<Option<OrderStatusReport>> {
1359 let report = self
1360 .report_client()
1361 .generate_order_status_report(cmd)
1362 .await?;
1363
1364 if let Some(report) = &report {
1365 cleanup_closed_order_status_report(report, self.ws_orders.caches());
1366 }
1367
1368 Ok(report)
1369 }
1370
1371 async fn generate_order_status_reports(
1372 &self,
1373 cmd: &GenerateOrderStatusReports,
1374 ) -> anyhow::Result<Vec<OrderStatusReport>> {
1375 let reports = self
1376 .report_client()
1377 .generate_order_status_reports(cmd)
1378 .await?;
1379
1380 for report in &reports {
1381 cleanup_closed_order_status_report(report, self.ws_orders.caches());
1382 }
1383
1384 Ok(reports)
1385 }
1386
1387 async fn generate_fill_reports(
1388 &self,
1389 cmd: GenerateFillReports,
1390 ) -> anyhow::Result<Vec<FillReport>> {
1391 self.report_client().generate_fill_reports(cmd).await
1392 }
1393
1394 async fn generate_position_status_reports(
1395 &self,
1396 cmd: &GeneratePositionStatusReports,
1397 ) -> anyhow::Result<Vec<PositionStatusReport>> {
1398 self.report_client()
1399 .generate_position_status_reports(cmd)
1400 .await
1401 }
1402
1403 async fn generate_mass_status(
1404 &self,
1405 lookback_mins: Option<u64>,
1406 ) -> anyhow::Result<Option<ExecutionMassStatus>> {
1407 log::info!("Generating ExecutionMassStatus (lookback_mins={lookback_mins:?})");
1408
1409 let ts_now = self.clock.get_time_ns();
1410
1411 let positions_cached = self
1412 .core
1413 .cache()
1414 .positions_open(
1415 Some(&AX_VENUE),
1416 None,
1417 None,
1418 Some(&self.core.account_id),
1419 None,
1420 )
1421 .into_iter()
1422 .map(|position| (position.instrument_id, position.quantity.precision))
1423 .collect();
1424
1425 let start = lookback_mins
1426 .map(DurationNanos::try_from_mins)
1427 .transpose()?
1428 .map(|lookback| ts_now.saturating_sub(lookback));
1429
1430 let fills_span = DurationNanos::try_from_days(u64::try_from(AX_FILLS_MAX_LOOKBACK_DAYS)?)?;
1432 let fills_floor = ts_now.saturating_sub(fills_span);
1433
1434 let fills_latest_start = ts_now.saturating_sub(DurationNanos::new(1));
1436 let declared_start = Some(
1437 start
1438 .unwrap_or(fills_floor)
1439 .max(fills_floor)
1440 .min(fills_latest_start),
1441 );
1442
1443 let order_cmd = GenerateOrderStatusReports::new(
1444 UUID4::new(),
1445 ts_now,
1446 false, None, start,
1449 None, None, None, );
1453
1454 let mut fill_cmd = GenerateFillReports::new(
1455 UUID4::new(),
1456 ts_now,
1457 None, None, declared_start,
1460 Some(ts_now), None, None, );
1464
1465 fill_cmd.log_receipt_level = LogLevel::Off;
1466
1467 let mut position_cmd = GeneratePositionStatusReports::new(
1468 UUID4::new(),
1469 ts_now,
1470 None, start,
1472 None, None, None, );
1476
1477 position_cmd.log_receipt_level = LogLevel::Off;
1478
1479 let (mut order_reports, fill_reports, mut position_reports) = tokio::try_join!(
1480 async {
1481 let cid_resolver = |cid| {
1482 self.ws_orders
1483 .caches()
1484 .cid_to_client_order_id
1485 .get(&cid)
1486 .map(|v| *v)
1487 };
1488 let mut reports = self
1489 .http_client
1490 .request_order_history(self.core.account_id, start, None, Some(&cid_resolver))
1491 .await?;
1492 let active = self
1493 .http_client
1494 .request_order_status_reports(self.core.account_id, Some(&cid_resolver))
1495 .await?;
1496 reports = merge_active_order_reports(reports, active);
1497 retain_order_status_reports(&mut reports, &order_cmd);
1498
1499 for report in &reports {
1500 cleanup_closed_order_status_report(report, self.ws_orders.caches());
1501 }
1502
1503 Ok::<_, anyhow::Error>(reports)
1504 },
1505 self.generate_fill_reports(fill_cmd),
1506 self.generate_position_status_reports(&position_cmd),
1507 )?;
1508
1509 self.add_flat_position_reports(positions_cached, &mut position_reports, ts_now);
1510
1511 log::info!("Received {} OrderStatusReports", order_reports.len());
1512 log::info!("Received {} FillReports", fill_reports.len());
1513 log::info!("Received {} PositionReports", position_reports.len());
1514
1515 let mut mass_status = ExecutionMassStatus::new(
1516 self.core.client_id,
1517 self.core.account_id,
1518 *AX_VENUE,
1519 ts_now,
1520 None,
1521 );
1522
1523 mass_status.set_report_window(declared_start, true);
1525
1526 update_order_report_timestamps(&mut order_reports, &fill_reports);
1527 add_special_fill_order_reports(&mut order_reports, &fill_reports);
1528
1529 mass_status.add_order_reports(order_reports);
1530 mass_status.add_fill_reports(fill_reports);
1531 mass_status.add_position_reports(position_reports);
1532
1533 Ok(Some(mass_status))
1534 }
1535
1536 fn register_external_order(
1537 &self,
1538 client_order_id: ClientOrderId,
1539 venue_order_id: VenueOrderId,
1540 instrument_id: InstrumentId,
1541 strategy_id: StrategyId,
1542 _ts_init: UnixNanos,
1543 ) {
1544 let order = self.core.cache().order_owned(&client_order_id);
1545 if let Some(order) = order {
1546 if let Err(e) = self.restore_order_tracking(&order, Some(venue_order_id)) {
1547 log::warn!("Cannot restore AX order {client_order_id}: {e}");
1548 }
1549
1550 return;
1551 }
1552
1553 self.ws_orders.register_external_order(
1554 client_order_id,
1555 venue_order_id,
1556 instrument_id,
1557 strategy_id,
1558 );
1559 }
1560}
1561
1562impl AxExecutionClient {
1563 fn restore_order_tracking(
1564 &self,
1565 order: &OrderAny,
1566 venue_order_id: Option<VenueOrderId>,
1567 ) -> anyhow::Result<()> {
1568 let client_order_id = order.client_order_id();
1569 let caches = self.ws_orders.caches();
1570
1571 let instrument = self
1572 .http_client
1573 .get_instrument(&order.instrument_id().symbol.inner())
1574 .or_else(|| {
1575 self.core
1576 .cache()
1577 .instrument(&order.instrument_id())
1578 .cloned()
1579 })
1580 .context("cannot restore AX order without its instrument")?;
1581
1582 self.http_client.cache_instrument(instrument.clone());
1583 self.ws_orders.cache_instrument(instrument.clone());
1584 let cid = client_order_id_to_cid(&client_order_id);
1585 let cid_owner = caches.cid_to_client_order_id.get(&cid).map(|entry| *entry);
1586 if cid_owner != Some(client_order_id) {
1587 reserve_cid_mapping(caches, cid, client_order_id)?;
1588 }
1589
1590 let metadata = OrderMetadata {
1591 trader_id: order.trader_id(),
1592 strategy_id: order.strategy_id(),
1593 instrument_id: order.instrument_id(),
1594 client_order_id,
1595 order_init: order
1596 .events()
1597 .into_iter()
1598 .rev()
1599 .find_map(|event| match event {
1600 OrderEventAny::Initialized(init) => Some(init.clone()),
1601 _ => None,
1602 }),
1603 is_accepted: order.status() != OrderStatus::Submitted,
1604 venue_order_id: order.venue_order_id().or(venue_order_id),
1605 ts_init: order.init_event().ts_init,
1606 size_precision: instrument.size_precision(),
1607 price_precision: instrument.price_precision(),
1608 quote_currency: instrument.quote_currency(),
1609 };
1610
1611 let venue_order_id = caches
1612 .orders_metadata
1613 .entry(client_order_id)
1614 .or_insert(metadata)
1615 .venue_order_id;
1616
1617 if let Some(venue_order_id) = venue_order_id {
1618 caches
1619 .venue_to_client_id
1620 .insert(venue_order_id, client_order_id);
1621 }
1622
1623 Ok(())
1624 }
1625
1626 fn report_client(&self) -> AxReportClient {
1627 AxReportClient {
1628 http_client: self.http_client.clone(),
1629 account_id: self.core.account_id,
1630 cid_to_client_order_id: self.ws_orders.caches().cid_to_client_order_id.clone(),
1631 }
1632 }
1633
1634 fn add_flat_position_reports(
1635 &self,
1636 mut positions_expected: AHashMap<InstrumentId, u8>,
1637 position_reports: &mut Vec<PositionStatusReport>,
1638 ts_init: UnixNanos,
1639 ) {
1640 for report in position_reports.iter() {
1641 positions_expected.remove(&report.instrument_id);
1642 }
1643
1644 let mut positions_expected: Vec<_> = positions_expected.into_iter().collect();
1645 positions_expected.sort_unstable_by_key(|(instrument_id, _)| *instrument_id);
1646
1647 for (instrument_id, precision) in positions_expected {
1649 position_reports.push(PositionStatusReport::new(
1650 self.core.account_id,
1651 instrument_id,
1652 PositionSide::Flat,
1653 Quantity::zero(precision),
1654 ts_init,
1655 ts_init,
1656 None,
1657 None,
1658 None,
1659 ));
1660 }
1661 }
1662}
1663
1664struct AxReportClient {
1665 http_client: AxHttpClient,
1666 account_id: AccountId,
1667 cid_to_client_order_id: Arc<DashMap<u64, ClientOrderId>>,
1668}
1669
1670impl AxReportClient {
1671 async fn generate_order_status_report(
1672 &self,
1673 cmd: &GenerateOrderStatusReport,
1674 ) -> anyhow::Result<Option<OrderStatusReport>> {
1675 let cid_map = self.cid_to_client_order_id.clone();
1676 let cid_resolver = move |cid: u64| cid_map.get(&cid).map(|v| *v);
1677
1678 let Some(report) = self
1679 .http_client
1680 .request_order_report(
1681 self.account_id,
1682 cmd.client_order_id,
1683 cmd.venue_order_id,
1684 Some(cid_resolver),
1685 )
1686 .await?
1687 else {
1688 return Ok(None);
1689 };
1690
1691 anyhow::ensure!(
1692 cmd.instrument_id
1693 .is_none_or(|id| report.instrument_id == id),
1694 "AX order report instrument does not match requested instrument"
1695 );
1696 anyhow::ensure!(
1697 cmd.venue_order_id
1698 .is_none_or(|id| report.venue_order_id == id),
1699 "AX order report venue identity does not match requested order"
1700 );
1701 Ok(Some(report))
1702 }
1703
1704 async fn generate_order_status_reports(
1705 &self,
1706 cmd: &GenerateOrderStatusReports,
1707 ) -> anyhow::Result<Vec<OrderStatusReport>> {
1708 let cid_map = self.cid_to_client_order_id.clone();
1709 let cid_resolver = move |cid: u64| cid_map.get(&cid).map(|v| *v);
1710
1711 let mut reports = if cmd.open_only {
1712 self.http_client
1713 .request_order_status_reports(self.account_id, Some(&cid_resolver))
1714 .await?
1715 } else {
1716 let reports = self
1717 .http_client
1718 .request_historical_order_status_reports(
1719 self.account_id,
1720 cmd.start,
1721 cmd.end,
1722 Some(&cid_resolver),
1723 )
1724 .await?;
1725 let active = self
1726 .http_client
1727 .request_order_status_reports(self.account_id, Some(&cid_resolver))
1728 .await?;
1729 merge_active_order_reports(reports, active)
1730 };
1731
1732 if let Some(instrument_id) = cmd.instrument_id {
1733 reports.retain(|report| report.instrument_id == instrument_id);
1734 }
1735
1736 retain_order_status_reports(&mut reports, cmd);
1737 log_report_receipt(reports.len(), "OrderStatusReport", cmd.log_receipt_level);
1738
1739 Ok(reports)
1740 }
1741
1742 async fn generate_fill_reports(
1743 &self,
1744 cmd: GenerateFillReports,
1745 ) -> anyhow::Result<Vec<FillReport>> {
1746 let log_level = cmd.log_receipt_level;
1747 let mut reports = self
1748 .http_client
1749 .request_fill_reports(self.account_id, cmd.start, cmd.end)
1750 .await?;
1751
1752 if let Some(instrument_id) = cmd.instrument_id {
1753 reports.retain(|report| report.instrument_id == instrument_id);
1754 }
1755
1756 if let Some(venue_order_id) = cmd.venue_order_id {
1757 reports.retain(|report| report.venue_order_id.as_str() == venue_order_id.as_str());
1758 }
1759
1760 log_report_receipt(reports.len(), "FillReport", log_level);
1761 Ok(reports)
1762 }
1763
1764 async fn generate_position_status_reports(
1765 &self,
1766 cmd: &GeneratePositionStatusReports,
1767 ) -> anyhow::Result<Vec<PositionStatusReport>> {
1768 let mut reports = self
1769 .http_client
1770 .request_position_reports(self.account_id)
1771 .await?;
1772
1773 if let Some(instrument_id) = cmd.instrument_id {
1774 reports.retain(|report| report.instrument_id == instrument_id);
1775 }
1776
1777 log_report_receipt(reports.len(), "PositionStatusReport", cmd.log_receipt_level);
1778 Ok(reports)
1779 }
1780}
1781
1782fn merge_active_order_reports(
1783 mut reports: Vec<OrderStatusReport>,
1784 active: Vec<OrderStatusReport>,
1785) -> Vec<OrderStatusReport> {
1786 let active_ids: AHashSet<_> = active.iter().map(|report| report.venue_order_id).collect();
1787 reports.retain(|report| !active_ids.contains(&report.venue_order_id));
1788 reports.extend(active);
1789 reports
1790}
1791
1792fn log_report_receipt(count: usize, report_type: &str, level: LogLevel) {
1793 if let Some(level) = map_log_level_to_filter(level).to_level() {
1794 log::log!(level, "Received {count} {report_type} reports");
1795 }
1796}
1797
1798fn add_special_fill_order_reports(
1799 order_reports: &mut Vec<OrderStatusReport>,
1800 fill_reports: &[FillReport],
1801) {
1802 for fill in fill_reports {
1803 if fill
1804 .venue_order_id
1805 .as_str()
1806 .strip_prefix(AX_FILL_ORDER_PREFIX)
1807 != Some(fill.trade_id.as_str())
1808 {
1809 continue;
1810 }
1811
1812 let report = OrderStatusReport::new(
1813 fill.account_id,
1814 fill.instrument_id,
1815 fill.client_order_id,
1816 fill.venue_order_id,
1817 Some(fill.order_side),
1818 OrderType::Market,
1819 TimeInForce::Gtc,
1820 OrderStatus::Filled,
1821 fill.last_qty,
1822 fill.last_qty,
1823 fill.ts_event,
1824 fill.ts_event,
1825 fill.ts_init,
1826 None,
1827 )
1828 .with_avg_px(fill.last_px.as_decimal());
1829 order_reports.push(report);
1830 }
1831}
1832
1833#[expect(
1834 clippy::too_many_arguments,
1835 reason = "Failure emission retains order identity and command correlation"
1836)]
1837fn emit_ax_modify_denied(
1838 emitter: &ExecutionEventEmitter,
1839 clock: &'static AtomicTime,
1840 strategy_id: StrategyId,
1841 instrument_id: InstrumentId,
1842 client_order_id: ClientOrderId,
1843 venue_order_id: Option<VenueOrderId>,
1844 reason: &str,
1845 causation_id: UUID4,
1846) {
1847 log::warn!("AX modify denied for {client_order_id}: {reason}");
1848 emitter.emit_order_modify_denied_event(
1849 strategy_id,
1850 instrument_id,
1851 client_order_id,
1852 venue_order_id,
1853 reason,
1854 clock.get_time_ns(),
1855 Some(causation_id),
1856 );
1857}
1858
1859#[expect(
1860 clippy::too_many_arguments,
1861 reason = "Failure emission retains order identity and command correlation"
1862)]
1863fn emit_ax_modify_rejected(
1864 emitter: &ExecutionEventEmitter,
1865 clock: &'static AtomicTime,
1866 strategy_id: StrategyId,
1867 instrument_id: InstrumentId,
1868 client_order_id: ClientOrderId,
1869 venue_order_id: Option<VenueOrderId>,
1870 reason: &str,
1871 causation_id: Option<UUID4>,
1872) {
1873 log::warn!("AX modify rejected for {client_order_id}: {reason}");
1874 emitter.emit_order_modify_rejected_event(
1875 strategy_id,
1876 instrument_id,
1877 client_order_id,
1878 venue_order_id,
1879 reason,
1880 clock.get_time_ns(),
1881 causation_id,
1882 );
1883}
1884
1885fn dispatch_ws_message(
1887 message: AxOrdersWsMessage,
1888 emitter: &ExecutionEventEmitter,
1889 caches: &OrdersCaches,
1890 account_id: AccountId,
1891 instruments: &AtomicMap<Ustr, InstrumentAny>,
1892 account_fee_rates: &AtomicMap<Option<Ustr>, MakerTakerFeeRates>,
1893 clock: &'static AtomicTime,
1894) {
1895 match message {
1896 AxOrdersWsMessage::Event(event) => {
1897 dispatch_order_event(
1898 *event,
1899 emitter,
1900 caches,
1901 account_id,
1902 instruments,
1903 account_fee_rates,
1904 clock,
1905 );
1906 }
1907 AxOrdersWsMessage::PlaceOrderResponse(resp) => {
1908 log::debug!(
1909 "Place order response: rid={} oid={}",
1910 resp.rid,
1911 resp.res.oid
1912 );
1913 }
1914 AxOrdersWsMessage::CancelOrderResponse(resp) => {
1915 log::debug!(
1916 "Cancel order response: rid={} accepted={}",
1917 resp.rid,
1918 resp.res.cxl_rx
1919 );
1920 }
1921 AxOrdersWsMessage::OpenOrdersResponse(resp) => {
1922 log::debug!("Open orders response: {} orders", resp.res.orders.len());
1923 }
1924 AxOrdersWsMessage::PlaceOrderError {
1925 client_order_id,
1926 reason,
1927 } => {
1928 let Some(metadata) = caches.orders_metadata.get(&client_order_id) else {
1929 log::error!("Cannot emit rejection for uncached order {client_order_id}");
1930 return;
1931 };
1932
1933 let ts_event = clock.get_time_ns();
1934
1935 let event = OrderRejected::new(
1936 metadata.trader_id,
1937 metadata.strategy_id,
1938 metadata.instrument_id,
1939 client_order_id,
1940 account_id,
1941 reason.into(),
1942 UUID4::new(),
1943 ts_event,
1944 ts_event,
1945 false,
1946 false,
1947 );
1948 emitter.send_order_event(OrderEventAny::Rejected(event));
1949 drop(metadata);
1950 cleanup_terminal_order_tracking_ids(
1951 caches,
1952 None,
1953 Some(client_order_id_to_cid(&client_order_id)),
1954 Some(client_order_id),
1955 );
1956 }
1957 AxOrdersWsMessage::CancelOrderError {
1958 client_order_id,
1959 reason,
1960 command_id,
1961 } => {
1962 let Some(metadata) = caches.orders_metadata.get(&client_order_id) else {
1963 log::error!("Cannot emit cancel denial for uncached order {client_order_id}");
1964 return;
1965 };
1966
1967 emitter.emit_order_cancel_denied_event(
1968 metadata.strategy_id,
1969 metadata.instrument_id,
1970 client_order_id,
1971 metadata.venue_order_id,
1972 &reason,
1973 clock.get_time_ns(),
1974 command_id,
1975 );
1976 }
1977 AxOrdersWsMessage::Error(err) => {
1978 log::debug!("WebSocket error: {}", err.message);
1979 }
1980 AxOrdersWsMessage::Reconnected => {
1981 log::info!("WebSocket reconnected");
1982 }
1983 AxOrdersWsMessage::Authenticated => {
1984 log::debug!("WebSocket authenticated");
1985 }
1986 }
1987}
1988
1989fn dispatch_order_event(
1990 event: AxWsOrderEvent,
1991 emitter: &ExecutionEventEmitter,
1992 caches: &OrdersCaches,
1993 account_id: AccountId,
1994 instruments: &AtomicMap<Ustr, InstrumentAny>,
1995 account_fee_rates: &AtomicMap<Option<Ustr>, MakerTakerFeeRates>,
1996 clock: &'static AtomicTime,
1997) {
1998 let (order, replacement_id) = match &event {
1999 AxWsOrderEvent::Acknowledged(msg) => (Some(&msg.o), None),
2000 AxWsOrderEvent::PartiallyFilled(msg) => (Some(&msg.o), None),
2001 AxWsOrderEvent::Filled(msg) => (Some(&msg.o), None),
2002 AxWsOrderEvent::Canceled(msg) => (Some(&msg.o), None),
2003 AxWsOrderEvent::Rejected(msg) => (Some(&msg.o), None),
2004 AxWsOrderEvent::Expired(msg) => (Some(&msg.o), None),
2005 AxWsOrderEvent::Replaced(msg) => {
2006 (Some(msg.ro.as_ref()), replacement_venue_order_id(msg).ok())
2007 }
2008 AxWsOrderEvent::DoneForDay(msg) => (Some(&msg.o), None),
2009 AxWsOrderEvent::Heartbeat | AxWsOrderEvent::CancelRejected(_) => (None, None),
2010 };
2011
2012 let allow_previous = matches!(
2013 &event,
2014 AxWsOrderEvent::PartiallyFilled(_) | AxWsOrderEvent::Filled(_)
2015 );
2016
2017 if let Some(order) = order
2018 && !is_valid_order_update(order, caches, replacement_id, allow_previous)
2019 {
2020 log::warn!(
2021 "Deferring stale or malformed AX order update, order_id={}",
2022 order.oid
2023 );
2024 return;
2025 }
2026
2027 match event {
2028 AxWsOrderEvent::Heartbeat => {}
2029 AxWsOrderEvent::Acknowledged(msg) => {
2030 if let Some(event) =
2031 create_order_accepted(&msg.o, msg.ts, msg.tn, caches, account_id, clock)
2032 {
2033 emitter.send_order_event(OrderEventAny::Accepted(event));
2034 } else if let Some(report) = create_order_status_report(
2035 &msg.o,
2036 OrderStatus::Accepted,
2037 msg.ts,
2038 msg.tn,
2039 caches,
2040 account_id,
2041 instruments,
2042 clock,
2043 ) {
2044 emitter.send_order_status_report(report);
2045 }
2046 }
2047 AxWsOrderEvent::PartiallyFilled(msg) => {
2048 dispatch_fill_event(
2049 &msg.o,
2050 &msg.xs,
2051 msg.ts,
2052 msg.tn,
2053 emitter,
2054 caches,
2055 account_id,
2056 instruments,
2057 account_fee_rates,
2058 false,
2059 clock,
2060 );
2061 }
2062 AxWsOrderEvent::Filled(msg) => {
2063 dispatch_fill_event(
2064 &msg.o,
2065 &msg.xs,
2066 msg.ts,
2067 msg.tn,
2068 emitter,
2069 caches,
2070 account_id,
2071 instruments,
2072 account_fee_rates,
2073 true,
2074 clock,
2075 );
2076 }
2077 AxWsOrderEvent::Canceled(msg) => {
2078 if let Some(event) =
2079 create_order_canceled(&msg.o, msg.ts, msg.tn, caches, account_id, clock)
2080 {
2081 emitter.send_order_event(OrderEventAny::Canceled(event));
2082 } else if let Some(report) = create_order_status_report(
2083 &msg.o,
2084 OrderStatus::Canceled,
2085 msg.ts,
2086 msg.tn,
2087 caches,
2088 account_id,
2089 instruments,
2090 clock,
2091 ) {
2092 emitter.send_order_status_report(report);
2093 } else {
2094 return;
2095 }
2096 cleanup_terminal_order_tracking(&msg.o, caches);
2097 }
2098 AxWsOrderEvent::Rejected(msg) => {
2099 let reason = AxOrderRejectReason::reason_str(msg.r, msg.txt.as_deref())
2100 .unwrap_or_else(|| "UNKNOWN".to_string());
2101
2102 if let Some(event) =
2103 create_order_rejected(&msg.o, &reason, msg.ts, msg.tn, caches, account_id, clock)
2104 {
2105 emitter.send_order_event(OrderEventAny::Rejected(event));
2106 } else {
2107 return;
2108 }
2109 cleanup_terminal_order_tracking(&msg.o, caches);
2110 }
2111 AxWsOrderEvent::Expired(msg) => {
2112 let as_canceled = matches!(msg.o.tif, AxTimeInForce::Ioc | AxTimeInForce::Fok);
2114 let event = if as_canceled {
2115 create_order_canceled(&msg.o, msg.ts, msg.tn, caches, account_id, clock)
2116 .map(OrderEventAny::Canceled)
2117 } else {
2118 create_order_expired(&msg.o, msg.ts, msg.tn, caches, account_id, clock)
2119 .map(OrderEventAny::Expired)
2120 };
2121
2122 if let Some(event) = event {
2123 emitter.send_order_event(event);
2124 } else if let Some(report) = create_order_status_report(
2125 &msg.o,
2126 if as_canceled {
2127 OrderStatus::Canceled
2128 } else {
2129 OrderStatus::Expired
2130 },
2131 msg.ts,
2132 msg.tn,
2133 caches,
2134 account_id,
2135 instruments,
2136 clock,
2137 ) {
2138 emitter.send_order_status_report(report);
2139 } else {
2140 return;
2141 }
2142 cleanup_terminal_order_tracking(&msg.o, caches);
2143 }
2144 AxWsOrderEvent::Replaced(msg) => {
2145 let replacement_venue_order_id = match replacement_venue_order_id(&msg) {
2146 Ok(venue_order_id) => venue_order_id,
2147 Err(e) => {
2148 log::warn!("Invalid AX replace event, awaiting reconciliation: {e}");
2149 return;
2150 }
2151 };
2152
2153 let order = msg.no.as_deref().unwrap_or(&msg.ro);
2154
2155 if let Some(event) = create_order_updated(
2156 order,
2157 &msg.ro,
2158 replacement_venue_order_id,
2159 (msg.ts, msg.tn),
2160 caches,
2161 account_id,
2162 clock,
2163 ) {
2164 emitter.send_order_event(OrderEventAny::Updated(event));
2165 } else if lookup_order_metadata(&msg.ro, caches).is_none()
2166 && let Some(report) = create_order_status_report(
2167 order,
2168 OrderStatus::Accepted,
2169 msg.ts,
2170 msg.tn,
2171 caches,
2172 account_id,
2173 instruments,
2174 clock,
2175 )
2176 {
2177 emitter.send_order_status_report(report);
2178 }
2179 }
2180 AxWsOrderEvent::DoneForDay(msg) => {
2181 if let Some(event) =
2182 create_order_expired(&msg.o, msg.ts, msg.tn, caches, account_id, clock)
2183 {
2184 emitter.send_order_event(OrderEventAny::Expired(event));
2185 } else if let Some(report) = create_order_status_report(
2186 &msg.o,
2187 OrderStatus::Expired,
2188 msg.ts,
2189 msg.tn,
2190 caches,
2191 account_id,
2192 instruments,
2193 clock,
2194 ) {
2195 emitter.send_order_status_report(report);
2196 } else {
2197 return;
2198 }
2199 cleanup_terminal_order_tracking(&msg.o, caches);
2200 }
2201 AxWsOrderEvent::CancelRejected(msg) => {
2202 let Ok(venue_order_id) = VenueOrderId::new_checked(&msg.oid) else {
2203 log::warn!("Invalid AX cancel rejection order ID");
2204 return;
2205 };
2206
2207 let reason = match msg.r {
2208 AxCancelRejectionReason::Unknown => msg
2209 .txt
2210 .as_deref()
2211 .filter(|text| !text.trim().is_empty())
2212 .unwrap_or(msg.r.as_ref()),
2213 _ => msg.r.as_ref(),
2214 };
2215
2216 let modify_rejected = reason == AX_POST_ONLY_REJECT;
2217
2218 let client_order_id = caches
2219 .venue_to_client_id
2220 .get(&venue_order_id)
2221 .map(|entry| *entry)
2222 .or_else(|| {
2223 modify_rejected
2224 .then(|| {
2225 caches
2226 .pending_modifies
2227 .get(&venue_order_id)
2228 .map(|entry| entry.0)
2229 })
2230 .flatten()
2231 });
2232
2233 if let Some(client_order_id) = client_order_id
2234 && let Some(metadata) = caches.orders_metadata.get(&client_order_id)
2235 && (modify_rejected
2236 || metadata
2237 .venue_order_id
2238 .is_none_or(|current| current == venue_order_id))
2239 {
2240 let strategy_id = metadata.strategy_id;
2241 let instrument_id = metadata.instrument_id;
2242 if modify_rejected {
2243 let active_venue_order_id = metadata.venue_order_id.unwrap_or(venue_order_id);
2244 drop(metadata);
2245 complete_pending_modify(caches, venue_order_id);
2246 emit_ax_modify_rejected(
2247 emitter,
2248 clock,
2249 strategy_id,
2250 instrument_id,
2251 client_order_id,
2252 Some(active_venue_order_id),
2253 reason,
2254 None,
2255 );
2256
2257 if let Some(order) = &msg.o
2258 && matches!(
2259 order.o,
2260 AxOrderStatus::Filled
2261 | AxOrderStatus::Canceled
2262 | AxOrderStatus::Expired
2263 )
2264 {
2265 cleanup_terminal_order_tracking(order, caches);
2266 }
2267 } else {
2268 let event = OrderCancelRejected::new(
2269 metadata.trader_id,
2270 strategy_id,
2271 instrument_id,
2272 client_order_id,
2273 Ustr::from(reason),
2274 UUID4::new(),
2275 clock.get_time_ns(),
2276 metadata.ts_init,
2277 false,
2278 Some(venue_order_id),
2279 Some(account_id),
2280 );
2281 emitter.send_order_event(OrderEventAny::CancelRejected(event));
2282 }
2283 } else {
2284 log::debug!(
2285 "Could not find metadata for cancel rejected order {}",
2286 msg.oid
2287 );
2288 }
2289 }
2290 }
2291}
2292
2293#[expect(clippy::too_many_arguments)]
2294fn dispatch_fill_event(
2295 order: &AxWsOrder,
2296 execution: &AxWsTradeExecution,
2297 ts: i64,
2298 tn: i64,
2299 emitter: &ExecutionEventEmitter,
2300 caches: &OrdersCaches,
2301 account_id: AccountId,
2302 instruments: &AtomicMap<Ustr, InstrumentAny>,
2303 account_fee_rates: &AtomicMap<Option<Ustr>, MakerTakerFeeRates>,
2304 complete: bool,
2305 clock: &'static AtomicTime,
2306) {
2307 if order.o == AxOrderStatus::Unknown || order.tif == AxTimeInForce::Unknown {
2308 log::warn!(
2309 "Unknown AX order classification in fill, order_id={}, instrument={}, trade_id={}, state={}, time_in_force={}",
2310 order.oid,
2311 order.s,
2312 execution.tid,
2313 order.o,
2314 order.tif,
2315 );
2316 }
2317
2318 if execution.s != order.s {
2319 log::warn!("Deferring inconsistent AX fill, trade_id={}", execution.tid);
2320 return;
2321 }
2322
2323 let commission =
2324 match calculate_fill_commission(order, execution, instruments, account_fee_rates) {
2325 Ok(commission) => commission,
2326 Err(e) => {
2327 log::warn!(
2328 "Cannot calculate AX commission for trade_id={}: {e}",
2329 execution.tid
2330 );
2331 return;
2332 }
2333 };
2334
2335 if let Some(event) = create_order_filled(
2336 order, execution, ts, tn, caches, account_id, commission, clock,
2337 ) {
2338 let current = caches
2339 .orders_metadata
2340 .get(&event.client_order_id)
2341 .and_then(|metadata| metadata.venue_order_id);
2342
2343 if let Some(parent) = current
2344 && parent != event.venue_order_id
2345 && caches.pending_modifies.contains_key(&parent)
2346 && !caches.pending_modifies.contains_key(&event.venue_order_id)
2347 {
2348 record_replacement_venue_id(
2349 caches,
2350 event.client_order_id,
2351 parent,
2352 event.venue_order_id,
2353 false,
2354 );
2355 }
2356
2357 let needs_acceptance =
2358 lookup_order_metadata(order, caches).is_some_and(|metadata| !metadata.is_accepted);
2359
2360 if needs_acceptance
2361 && let Some(accepted) = create_order_accepted(order, ts, tn, caches, account_id, clock)
2362 {
2363 emitter.send_order_event(OrderEventAny::Accepted(accepted));
2364 }
2365
2366 emitter.send_order_event(OrderEventAny::Filled(event));
2367 } else if let Some(report) = create_fill_report(
2368 order,
2369 execution,
2370 ts,
2371 tn,
2372 caches,
2373 account_id,
2374 instruments,
2375 commission,
2376 clock,
2377 ) {
2378 emitter.send_fill_report(report);
2379 } else {
2380 return;
2381 }
2382
2383 if complete {
2384 cleanup_terminal_order_tracking(order, caches);
2385 }
2386}
2387
2388fn calculate_fill_commission(
2389 order: &AxWsOrder,
2390 execution: &AxWsTradeExecution,
2391 instruments: &AtomicMap<Ustr, InstrumentAny>,
2392 account_fee_rates: &AtomicMap<Option<Ustr>, MakerTakerFeeRates>,
2393) -> anyhow::Result<Money> {
2394 let instruments = instruments.load();
2395 let instrument = instruments
2396 .get(&order.s)
2397 .context("AX fill instrument is not cached")?;
2398 let rates = account_fee_rates.load();
2399 let rates = rates
2400 .get(&execution.aid.or(order.aid))
2401 .context("AX fill account fee rates are not cached")?;
2402
2403 let liquidity_side = if execution.agg {
2404 LiquiditySide::Taker
2405 } else {
2406 LiquiditySide::Maker
2407 };
2408
2409 let rate = rates.rate_for(liquidity_side)?;
2410
2411 let commission = Decimal::from(execution.q)
2413 .checked_mul(execution.p.abs())
2414 .and_then(|notional| notional.checked_mul(instrument.multiplier().as_decimal()))
2415 .and_then(|notional| notional.checked_mul(rate))
2416 .context("AX fill commission calculation overflow")?;
2417
2418 Money::from_decimal(commission, Currency::USD())
2419 .context("failed to convert AX fill commission to Money")
2420}
2421
2422pub(crate) fn lookup_order_metadata<'a>(
2423 order: &AxWsOrder,
2424 caches: &'a OrdersCaches,
2425) -> Option<dashmap::mapref::one::Ref<'a, ClientOrderId, OrderMetadata>> {
2426 let client_order_id = VenueOrderId::new_checked(&order.oid)
2427 .ok()
2428 .and_then(|venue_order_id| {
2429 caches
2430 .venue_to_client_id
2431 .get(&venue_order_id)
2432 .map(|entry| *entry)
2433 });
2434
2435 if let Some(client_order_id) = client_order_id
2436 && let Some(metadata) = caches.orders_metadata.get(&client_order_id)
2437 {
2438 return Some(metadata);
2439 }
2440
2441 if let Some(cid) = order.cid
2442 && let Some(client_order_id) = caches.cid_to_client_order_id.get(&cid).map(|entry| *entry)
2443 && let Some(metadata) = caches.orders_metadata.get(&client_order_id)
2444 {
2445 return Some(metadata);
2446 }
2447
2448 None
2449}
2450
2451fn is_valid_order_update(
2452 order: &AxWsOrder,
2453 caches: &OrdersCaches,
2454 replacement_id: Option<VenueOrderId>,
2455 allow_previous: bool,
2456) -> bool {
2457 let Ok(venue_order_id) = VenueOrderId::new_checked(&order.oid) else {
2458 return false;
2459 };
2460
2461 let Some(metadata) = lookup_order_metadata(order, caches) else {
2462 return true;
2463 };
2464
2465 if metadata.instrument_id.symbol.inner() != order.s {
2466 return false;
2467 }
2468
2469 if let Some(order_init) = &metadata.order_init
2470 && order_init.order_side != OrderSide::from(order.d)
2471 {
2472 return false;
2473 }
2474
2475 let is_current = metadata
2476 .venue_order_id
2477 .is_none_or(|current| current == venue_order_id || replacement_id == Some(current));
2478 let client_order_id = metadata.client_order_id;
2479 drop(metadata);
2480
2481 is_current
2482 || (allow_previous
2483 && caches
2484 .venue_to_client_id
2485 .get(&venue_order_id)
2486 .is_some_and(|mapped| *mapped == client_order_id))
2487}
2488
2489pub(crate) fn replacement_venue_order_id(
2490 message: &crate::websocket::messages::AxWsOrderReplaced,
2491) -> anyhow::Result<VenueOrderId> {
2492 match (&message.noid, &message.no) {
2493 (Some(noid), Some(order)) if noid == &order.oid => {
2494 VenueOrderId::new_checked(noid).map_err(anyhow::Error::from)
2495 }
2496 (None, None) => VenueOrderId::new_checked(&message.ro.oid).map_err(anyhow::Error::from),
2497 _ => anyhow::bail!("Inconsistent AX replacement order identity"),
2498 }
2499}
2500
2501pub(crate) fn create_order_accepted(
2502 order: &AxWsOrder,
2503 event_ts: i64,
2504 event_tn: i64,
2505 caches: &OrdersCaches,
2506 account_id: AccountId,
2507 clock: &'static AtomicTime,
2508) -> Option<OrderAccepted> {
2509 if !is_valid_order_update(order, caches, None, false) {
2510 return None;
2511 }
2512
2513 let ts_event = ax_timestamp_stn_to_unix_nanos(event_ts, event_tn)
2514 .map_err(|e| log::error!("{e}"))
2515 .ok()?;
2516 let venue_order_id = VenueOrderId::new_checked(&order.oid).ok()?;
2517 let metadata = lookup_order_metadata(order, caches)?;
2518
2519 if metadata.is_accepted {
2520 return None;
2521 }
2522
2523 let client_order_id = metadata.client_order_id;
2524 let trader_id = metadata.trader_id;
2525 let strategy_id = metadata.strategy_id;
2526 let instrument_id = metadata.instrument_id;
2527 drop(metadata);
2528
2529 let mut entry = caches.orders_metadata.get_mut(&client_order_id)?;
2530 if entry.is_accepted
2531 || entry
2532 .venue_order_id
2533 .is_some_and(|current| current != venue_order_id)
2534 {
2535 return None;
2536 }
2537
2538 entry.venue_order_id = Some(venue_order_id);
2539 entry.is_accepted = true;
2540 drop(entry);
2541 caches
2542 .venue_to_client_id
2543 .insert(venue_order_id, client_order_id);
2544
2545 Some(OrderAccepted::new(
2546 trader_id,
2547 strategy_id,
2548 instrument_id,
2549 client_order_id,
2550 venue_order_id,
2551 account_id,
2552 UUID4::new(),
2553 ts_event,
2554 clock.get_time_ns(),
2555 false,
2556 ))
2557}
2558
2559pub(crate) fn create_order_updated(
2560 order: &AxWsOrder,
2561 replaced_order: &AxWsOrder,
2562 replacement_venue_order_id: VenueOrderId,
2563 event_timestamp: (i64, i64),
2564 caches: &OrdersCaches,
2565 account_id: AccountId,
2566 clock: &'static AtomicTime,
2567) -> Option<OrderUpdated> {
2568 let metadata = lookup_order_metadata(order, caches)
2569 .or_else(|| lookup_order_metadata(replaced_order, caches))?;
2570
2571 if metadata.instrument_id.symbol.inner() != order.s
2572 || metadata
2573 .order_init
2574 .as_ref()
2575 .is_some_and(|order_init| order_init.order_side != OrderSide::from(order.d))
2576 {
2577 log::warn!(
2578 "Deferring inconsistent AX replacement, order_id={}",
2579 order.oid
2580 );
2581 return None;
2582 }
2583
2584 let client_order_id = metadata.client_order_id;
2585 let trader_id = metadata.trader_id;
2586 let strategy_id = metadata.strategy_id;
2587 let instrument_id = metadata.instrument_id;
2588 let price_precision = metadata.price_precision;
2589 let size_precision = metadata.size_precision;
2590 drop(metadata);
2591
2592 let ts_event = ax_timestamp_stn_to_unix_nanos(event_timestamp.0, event_timestamp.1)
2593 .map_err(|e| log::error!("{e}"))
2594 .ok()?;
2595
2596 let quantity = Quantity::from_decimal_dp(Decimal::from(order.q), size_precision).ok()?;
2597 let price = Some(Price::from_decimal_dp(order.p, price_precision).ok()?);
2598 let previous_venue_order_id = VenueOrderId::new_checked(&replaced_order.oid).ok()?;
2599
2600 if !record_replacement_venue_id(
2601 caches,
2602 client_order_id,
2603 previous_venue_order_id,
2604 replacement_venue_order_id,
2605 true,
2606 ) {
2607 return None;
2608 }
2609
2610 complete_pending_modify(caches, previous_venue_order_id);
2611
2612 Some(OrderUpdated::new(
2613 trader_id,
2614 strategy_id,
2615 instrument_id,
2616 client_order_id,
2617 quantity,
2618 UUID4::new(),
2619 ts_event,
2620 clock.get_time_ns(),
2621 false,
2622 Some(replacement_venue_order_id),
2623 Some(account_id),
2624 price,
2625 None, None, false,
2628 ))
2629}
2630
2631#[expect(clippy::too_many_arguments)]
2632pub(crate) fn create_order_filled(
2633 order: &AxWsOrder,
2634 execution: &AxWsTradeExecution,
2635 event_ts: i64,
2636 event_tn: i64,
2637 caches: &OrdersCaches,
2638 account_id: AccountId,
2639 commission: Money,
2640 clock: &'static AtomicTime,
2641) -> Option<OrderFilled> {
2642 let venue_order_id = VenueOrderId::new_checked(&order.oid).ok()?;
2643 let metadata = lookup_order_metadata(order, caches)?;
2644
2645 let ts_event = ax_timestamp_stn_to_unix_nanos(event_ts, event_tn)
2646 .map_err(|e| log::error!("{e}"))
2647 .ok()?;
2648
2649 let last_qty =
2650 Quantity::from_decimal_dp(Decimal::from(execution.q), metadata.size_precision).ok()?;
2651 let last_px = Price::from_decimal_dp(execution.p, metadata.price_precision).ok()?;
2652
2653 let order_side = metadata.order_init.as_ref().map_or_else(
2654 || OrderSide::from(order.d),
2655 |order_init| order_init.order_side,
2656 );
2657 let order_type = metadata
2658 .order_init
2659 .as_ref()
2660 .map_or(OrderType::Limit, |order_init| order_init.order_type);
2661 let trade_id = TradeId::new_checked(&execution.tid).ok()?;
2662
2663 let liquidity_side = if execution.agg {
2664 LiquiditySide::Taker
2665 } else {
2666 LiquiditySide::Maker
2667 };
2668
2669 Some(OrderFilled::new(
2670 metadata.trader_id,
2671 metadata.strategy_id,
2672 metadata.instrument_id,
2673 metadata.client_order_id,
2674 venue_order_id,
2675 account_id,
2676 trade_id,
2677 order_side,
2678 order_type,
2679 last_qty,
2680 last_px,
2681 metadata.quote_currency,
2682 liquidity_side,
2683 UUID4::new(),
2684 ts_event,
2685 clock.get_time_ns(),
2686 false,
2687 None,
2688 Some(commission),
2689 None,
2690 ))
2691}
2692
2693pub(crate) fn create_order_canceled(
2694 order: &AxWsOrder,
2695 event_ts: i64,
2696 event_tn: i64,
2697 caches: &OrdersCaches,
2698 account_id: AccountId,
2699 clock: &'static AtomicTime,
2700) -> Option<OrderCanceled> {
2701 let venue_order_id = VenueOrderId::new_checked(&order.oid).ok()?;
2702 let metadata = lookup_order_metadata(order, caches)?;
2703
2704 let ts_event = ax_timestamp_stn_to_unix_nanos(event_ts, event_tn)
2705 .map_err(|e| log::error!("{e}"))
2706 .ok()?;
2707
2708 Some(OrderCanceled::new(
2709 metadata.trader_id,
2710 metadata.strategy_id,
2711 metadata.instrument_id,
2712 metadata.client_order_id,
2713 UUID4::new(),
2714 ts_event,
2715 clock.get_time_ns(),
2716 false,
2717 Some(venue_order_id),
2718 Some(account_id),
2719 None,
2720 ))
2721}
2722
2723pub(crate) fn create_order_expired(
2724 order: &AxWsOrder,
2725 event_ts: i64,
2726 event_tn: i64,
2727 caches: &OrdersCaches,
2728 account_id: AccountId,
2729 clock: &'static AtomicTime,
2730) -> Option<OrderExpired> {
2731 let venue_order_id = VenueOrderId::new_checked(&order.oid).ok()?;
2732 let metadata = lookup_order_metadata(order, caches)?;
2733
2734 let ts_event = ax_timestamp_stn_to_unix_nanos(event_ts, event_tn)
2735 .map_err(|e| log::error!("{e}"))
2736 .ok()?;
2737
2738 Some(OrderExpired::new(
2739 metadata.trader_id,
2740 metadata.strategy_id,
2741 metadata.instrument_id,
2742 metadata.client_order_id,
2743 UUID4::new(),
2744 ts_event,
2745 clock.get_time_ns(),
2746 false,
2747 Some(venue_order_id),
2748 Some(account_id),
2749 ))
2750}
2751
2752pub(crate) fn create_order_rejected(
2753 order: &AxWsOrder,
2754 reason: &str,
2755 event_ts: i64,
2756 event_tn: i64,
2757 caches: &OrdersCaches,
2758 account_id: AccountId,
2759 clock: &'static AtomicTime,
2760) -> Option<OrderRejected> {
2761 let metadata = lookup_order_metadata(order, caches)?;
2762
2763 let ts_event = ax_timestamp_stn_to_unix_nanos(event_ts, event_tn)
2764 .map_err(|e| log::error!("{e}"))
2765 .ok()?;
2766 let due_post_only = reason.contains(AX_POST_ONLY_REJECT);
2767
2768 Some(OrderRejected::new(
2769 metadata.trader_id,
2770 metadata.strategy_id,
2771 metadata.instrument_id,
2772 metadata.client_order_id,
2773 account_id,
2774 Ustr::from(reason),
2775 UUID4::new(),
2776 ts_event,
2777 clock.get_time_ns(),
2778 false,
2779 due_post_only,
2780 ))
2781}
2782
2783fn cleanup_closed_order_status_report(report: &OrderStatusReport, caches: &OrdersCaches) {
2784 if caches.pending_modifies.contains_key(&report.venue_order_id) {
2785 return;
2786 }
2787
2788 cleanup_resolved_order_status_report(report, caches);
2789}
2790
2791fn cleanup_resolved_order_status_report(report: &OrderStatusReport, caches: &OrdersCaches) {
2792 if !report.order_status.is_closed() {
2793 return;
2794 }
2795
2796 let client_order_id = report.client_order_id.or_else(|| {
2797 caches
2798 .venue_to_client_id
2799 .get(&report.venue_order_id)
2800 .map(|entry| *entry)
2801 });
2802
2803 if let Some(client_order_id) = client_order_id
2804 && let Some(metadata) = caches.orders_metadata.get(&client_order_id)
2805 && metadata
2806 .venue_order_id
2807 .is_some_and(|current| current != report.venue_order_id)
2808 {
2809 return;
2810 }
2811
2812 cleanup_terminal_order_tracking_ids(
2813 caches,
2814 Some(&report.venue_order_id),
2815 report.client_order_id.as_ref().map(client_order_id_to_cid),
2816 report.client_order_id,
2817 );
2818}
2819
2820pub(crate) fn cleanup_terminal_order_tracking(order: &AxWsOrder, caches: &OrdersCaches) {
2821 if !is_valid_order_update(order, caches, None, false) {
2822 return;
2823 }
2824
2825 let Ok(venue_order_id) = VenueOrderId::new_checked(&order.oid) else {
2826 return;
2827 };
2828
2829 cleanup_terminal_order_tracking_ids(caches, Some(&venue_order_id), order.cid, None);
2830}
2831
2832fn cleanup_terminal_order_tracking_ids(
2833 caches: &OrdersCaches,
2834 venue_order_id: Option<&VenueOrderId>,
2835 cid: Option<u64>,
2836 known_client_order_id: Option<ClientOrderId>,
2837) {
2838 if let Some(id) = venue_order_id
2840 && let Some(mut pending) = caches.pending_modifies.get_mut(id)
2841 {
2842 pending.2 = true;
2843 return;
2844 }
2845
2846 let client_order_id = venue_order_id
2847 .and_then(|venue_order_id| {
2848 caches
2849 .venue_to_client_id
2850 .remove(venue_order_id)
2851 .map(|(_, v)| v)
2852 })
2853 .or_else(|| cid.and_then(|cid| caches.cid_to_client_order_id.remove(&cid).map(|(_, v)| v)))
2854 .or(known_client_order_id);
2855
2856 if let Some(client_order_id) = client_order_id {
2857 caches.orders_metadata.remove(&client_order_id);
2858 caches
2859 .pending_modifies
2860 .retain(|_, (owner, _, _)| *owner != client_order_id);
2861 caches
2862 .venue_to_client_id
2863 .retain(|_, mapped_client_order_id| *mapped_client_order_id != client_order_id);
2864 caches
2865 .cid_to_client_order_id
2866 .retain(|_, mapped_client_order_id| *mapped_client_order_id != client_order_id);
2867 }
2868
2869 if let Some(cid) = cid {
2870 caches.cid_to_client_order_id.remove(&cid);
2871 }
2872}
2873
2874fn cleanup_deferred_order_tracking(caches: &OrdersCaches) {
2875 let terminal: Vec<_> = caches
2876 .pending_modifies
2877 .iter()
2878 .filter_map(|entry| entry.2.then_some((*entry.key(), entry.0)))
2879 .collect();
2880
2881 for (venue_order_id, client_order_id) in terminal {
2882 cleanup_deferred_order_tracking_ids(caches, venue_order_id, client_order_id);
2883 }
2884}
2885
2886fn complete_pending_modify(caches: &OrdersCaches, venue_order_id: VenueOrderId) {
2887 let completed = caches
2888 .pending_modifies
2889 .remove_if_mut(&venue_order_id, |_, (_, count, _)| {
2890 *count -= 1;
2891 *count == 0
2892 });
2893
2894 if let Some((_, (client_order_id, _, terminal))) = completed {
2895 if !caches
2896 .pending_modifies
2897 .iter()
2898 .any(|entry| entry.0 == client_order_id)
2899 {
2900 let current = caches
2901 .orders_metadata
2902 .get(&client_order_id)
2903 .and_then(|metadata| metadata.venue_order_id);
2904 caches
2905 .venue_to_client_id
2906 .retain(|venue_id, owner| *owner != client_order_id || Some(*venue_id) == current);
2907 }
2908
2909 if terminal {
2910 cleanup_deferred_order_tracking_ids(caches, venue_order_id, client_order_id);
2911 }
2912 }
2913}
2914
2915fn cleanup_deferred_order_tracking_ids(
2916 caches: &OrdersCaches,
2917 venue_order_id: VenueOrderId,
2918 client_order_id: ClientOrderId,
2919) {
2920 let is_current = caches
2921 .orders_metadata
2922 .get(&client_order_id)
2923 .is_some_and(|metadata| metadata.venue_order_id == Some(venue_order_id));
2924 if is_current {
2925 caches.pending_modifies.remove(&venue_order_id);
2926 cleanup_terminal_order_tracking_ids(
2927 caches,
2928 Some(&venue_order_id),
2929 None,
2930 Some(client_order_id),
2931 );
2932 }
2933}
2934
2935async fn resolve_order_status_report(
2936 http_client: &AxHttpClient,
2937 caches: &OrdersCaches,
2938 client_order_id: ClientOrderId,
2939 report: OrderStatusReport,
2940) -> anyhow::Result<Option<OrderStatusReport>> {
2941 let parent = report.venue_order_id;
2942 let stale = caches
2943 .orders_metadata
2944 .get(&client_order_id)
2945 .and_then(|metadata| metadata.venue_order_id)
2946 .is_some_and(|current| current != parent);
2947
2948 if stale {
2949 return Ok(None);
2950 }
2951
2952 if !report.order_status.is_closed() {
2953 return Ok(Some(report));
2954 }
2955
2956 let candidates: Vec<_> = caches
2957 .venue_to_client_id
2958 .iter()
2959 .filter_map(|entry| {
2960 (*entry.value() == client_order_id && *entry.key() != parent).then_some(*entry.key())
2961 })
2962 .collect();
2963
2964 if candidates.is_empty() && !caches.pending_modifies.contains_key(&parent) {
2965 return Ok(Some(report));
2966 }
2967
2968 let status = http_client
2969 .inner
2970 .get_order_status_by_id(parent.as_str())
2971 .await?;
2972
2973 if status.status.state != AxOrderStatus::Replaced {
2974 return Ok(Some(report));
2975 }
2976
2977 for candidate in candidates {
2978 let Some(candidate_report) = http_client
2979 .request_order_report(
2980 report.account_id,
2981 Some(client_order_id),
2982 Some(candidate),
2983 None::<fn(u64) -> Option<ClientOrderId>>,
2984 )
2985 .await?
2986 else {
2987 continue;
2988 };
2989
2990 anyhow::ensure!(
2991 candidate_report.venue_order_id == candidate
2992 && candidate_report.instrument_id == report.instrument_id,
2993 "AX replacement report identity does not match the tracked order"
2994 );
2995
2996 if candidate_report.order_status == OrderStatus::Rejected {
2997 continue;
2998 }
2999
3000 if candidate_report.order_status == OrderStatus::Canceled {
3001 let status = http_client
3002 .inner
3003 .get_order_status_by_id(candidate.as_str())
3004 .await?;
3005
3006 if status.status.state == AxOrderStatus::Replaced {
3007 continue;
3008 }
3009 }
3010
3011 if record_replacement_venue_id(caches, client_order_id, parent, candidate, false) {
3012 return Ok(Some(candidate_report));
3013 }
3014
3015 return Ok(None);
3016 }
3017
3018 log::warn!(
3019 "AX replaced parent {parent} has no confirmed working replacement, awaiting reconciliation"
3020 );
3021 Ok(None)
3022}
3023
3024fn record_replacement_proposal(
3025 caches: &OrdersCaches,
3026 client_order_id: ClientOrderId,
3027 parent: VenueOrderId,
3028 proposed: VenueOrderId,
3029) {
3030 let Some(pending) = caches.pending_modifies.get(&parent) else {
3031 return;
3032 };
3033
3034 let current = caches
3035 .orders_metadata
3036 .get(&client_order_id)
3037 .and_then(|metadata| metadata.venue_order_id);
3038
3039 if pending.0 == client_order_id && current == Some(parent) {
3040 caches.venue_to_client_id.insert(proposed, client_order_id);
3041 }
3042}
3043
3044fn record_replacement_venue_id(
3045 caches: &OrdersCaches,
3046 client_order_id: ClientOrderId,
3047 previous_venue_order_id: VenueOrderId,
3048 venue_order_id: VenueOrderId,
3049 remove_previous_venue_ids: bool,
3050) -> bool {
3051 let Some(mut entry) = caches.orders_metadata.get_mut(&client_order_id) else {
3052 return false;
3053 };
3054
3055 if entry
3056 .venue_order_id
3057 .is_some_and(|current| current != previous_venue_order_id && current != venue_order_id)
3058 {
3059 log::warn!("Deferring stale AX replacement for {client_order_id}");
3060 return false;
3061 }
3062
3063 entry.venue_order_id = Some(venue_order_id);
3064 drop(entry);
3065 caches
3066 .venue_to_client_id
3067 .insert(venue_order_id, client_order_id);
3068
3069 if remove_previous_venue_ids {
3070 caches
3071 .venue_to_client_id
3072 .retain(|mapped_venue_order_id, mapped_client_order_id| {
3073 *mapped_client_order_id != client_order_id
3074 || *mapped_venue_order_id == venue_order_id
3075 });
3076 }
3077
3078 true
3079}
3080
3081#[expect(clippy::too_many_arguments)]
3082fn create_order_status_report(
3083 order: &AxWsOrder,
3084 order_status: OrderStatus,
3085 event_ts: i64,
3086 event_tn: i64,
3087 caches: &OrdersCaches,
3088 account_id: AccountId,
3089 instruments: &AtomicMap<Ustr, InstrumentAny>,
3090 clock: &'static AtomicTime,
3091) -> Option<OrderStatusReport> {
3092 if lookup_order_metadata(order, caches).is_some() {
3093 return None;
3094 }
3095
3096 let instruments_snap = instruments.load();
3097 let instrument = instruments_snap.get(&order.s)?;
3098 let venue_order_id = VenueOrderId::new_checked(&order.oid).ok()?;
3099 let instrument_id = instrument.id();
3100 let order_side = OrderSide::from(order.d);
3101
3102 let time_in_force = TimeInForce::try_from(order.tif)
3103 .map_err(|e| {
3104 log::warn!(
3105 "Cannot map AX order time in force, order_id={}, instrument={}, error={e}",
3106 order.oid,
3107 order.s
3108 );
3109 })
3110 .ok()?;
3111
3112 let quantity =
3113 Quantity::from_decimal_dp(Decimal::from(order.q), instrument.size_precision()).ok()?;
3114 let filled_qty =
3115 Quantity::from_decimal_dp(Decimal::from(order.xq), instrument.size_precision()).ok()?;
3116
3117 let ts_event = ax_timestamp_stn_to_unix_nanos(event_ts, event_tn)
3118 .map_err(|e| log::error!("{e}"))
3119 .ok()?;
3120 let ts_init = clock.get_time_ns();
3121
3122 let client_order_id = order.cid.map(|cid| {
3123 caches
3124 .cid_to_client_order_id
3125 .get(&cid)
3126 .map_or_else(|| cid_to_client_order_id(cid), |v| *v)
3127 });
3128
3129 let mut report = OrderStatusReport::new(
3130 account_id,
3131 instrument_id,
3132 client_order_id,
3133 venue_order_id,
3134 order_side.into(),
3135 OrderType::Limit,
3136 time_in_force,
3137 order_status,
3138 quantity,
3139 filled_qty,
3140 ts_event,
3141 ts_event,
3142 ts_init,
3143 Some(UUID4::new()),
3144 );
3145
3146 if let Ok(price) = Price::from_decimal_dp(order.p, instrument.price_precision()) {
3147 report = report.with_price(price);
3148 }
3149
3150 report = report.with_post_only(order.po);
3151
3152 Some(report)
3153}
3154
3155#[expect(clippy::too_many_arguments)]
3156fn create_fill_report(
3157 order: &AxWsOrder,
3158 execution: &AxWsTradeExecution,
3159 event_ts: i64,
3160 event_tn: i64,
3161 caches: &OrdersCaches,
3162 account_id: AccountId,
3163 instruments: &AtomicMap<Ustr, InstrumentAny>,
3164 commission: Money,
3165 clock: &'static AtomicTime,
3166) -> Option<FillReport> {
3167 if lookup_order_metadata(order, caches).is_some() {
3168 return None;
3169 }
3170
3171 let instruments_snap = instruments.load();
3172 let instrument = instruments_snap.get(&order.s)?;
3173 let venue_order_id = VenueOrderId::new_checked(&order.oid).ok()?;
3174 let instrument_id = instrument.id();
3175 let order_side = order.d.into();
3176
3177 let last_qty =
3178 Quantity::from_decimal_dp(Decimal::from(execution.q), instrument.size_precision()).ok()?;
3179 let last_px = Price::from_decimal_dp(execution.p, instrument.price_precision()).ok()?;
3180
3181 let liquidity_side = if execution.agg {
3182 LiquiditySide::Taker
3183 } else {
3184 LiquiditySide::Maker
3185 };
3186
3187 let ts_event = ax_timestamp_stn_to_unix_nanos(event_ts, event_tn)
3188 .map_err(|e| log::error!("{e}"))
3189 .ok()?;
3190 let ts_init = clock.get_time_ns();
3191
3192 let client_order_id = order.cid.map(|cid| {
3193 caches
3194 .cid_to_client_order_id
3195 .get(&cid)
3196 .map_or_else(|| cid_to_client_order_id(cid), |v| *v)
3197 });
3198
3199 Some(FillReport::new(
3200 account_id,
3201 instrument_id,
3202 venue_order_id,
3203 TradeId::new(&execution.tid),
3204 order_side,
3205 last_qty,
3206 last_px,
3207 commission,
3208 liquidity_side,
3209 client_order_id,
3210 None,
3211 ts_event,
3212 ts_init,
3213 Some(UUID4::new()),
3214 ))
3215}
3216
3217fn validate_order_for_ax_submit(order: &OrderAny) -> anyhow::Result<()> {
3218 if !matches!(order.order_type(), OrderType::Market | OrderType::Limit) {
3219 anyhow::bail!(
3220 "Unsupported order type: {:?}, the Architect AX adapter accepts Nautilus MARKET and LIMIT orders",
3221 order.order_type(),
3222 );
3223 }
3224
3225 if !matches!(
3227 order.time_in_force(),
3228 TimeInForce::Gtc | TimeInForce::Ioc | TimeInForce::Day
3229 ) {
3230 anyhow::bail!(
3231 "Unsupported time in force: {:?}, AX supports GTC, IOC, and DAY",
3232 order.time_in_force(),
3233 );
3234 }
3235
3236 validate_order_instructions(
3237 order.is_reduce_only(),
3238 order.is_quote_quantity(),
3239 order.display_qty().is_some(),
3240 )?;
3241
3242 quantity_to_contracts(order.quantity())?;
3243
3244 Ok(())
3245}
3246
3247fn validate_order_init_instructions(order_init: &OrderInitialized) -> anyhow::Result<()> {
3248 validate_order_instructions(
3249 order_init.reduce_only,
3250 order_init.quote_quantity,
3251 order_init.display_qty.is_some(),
3252 )
3253}
3254
3255fn validate_order_instructions(
3256 reduce_only: bool,
3257 quote_quantity: bool,
3258 has_display_qty: bool,
3259) -> anyhow::Result<()> {
3260 if reduce_only {
3261 anyhow::bail!("AX does not support reduce-only orders");
3262 }
3263
3264 if quote_quantity {
3265 anyhow::bail!(OrderDeniedReason::unsupported_quote_quantity());
3266 }
3267
3268 if has_display_qty {
3269 anyhow::bail!("Architect AX adapter cannot encode display_qty iceberg instructions");
3270 }
3271
3272 Ok(())
3273}
3274
3275fn self_trade_from_params(params: Option<&Params>) -> anyhow::Result<Option<AxSelfTradeBehavior>> {
3278 let Some(value) = params.and_then(|params| params.get("st")) else {
3279 return Ok(None);
3280 };
3281
3282 let value = value
3283 .as_str()
3284 .ok_or_else(|| anyhow::anyhow!("Invalid self-trade behavior value: expected a string"))?;
3285
3286 AxSelfTradeBehavior::parse_wire(value).map(Some)
3287}
3288
3289fn classify_ax_http_failure(error: &AxHttpError) -> CommandFailure {
3294 let message = error.to_string();
3295 match error {
3296 AxHttpError::MissingCredentials
3297 | AxHttpError::MissingSessionToken
3298 | AxHttpError::ValidationError(_)
3299 | AxHttpError::BuildError(_) => CommandFailure::NotSent(message),
3300 AxHttpError::ApiError { .. }
3301 | AxHttpError::JsonError(_)
3302 | AxHttpError::Canceled(_)
3303 | AxHttpError::NetworkError(_)
3304 | AxHttpError::UnexpectedStatus { .. } => CommandFailure::Ambiguous(message),
3305 }
3306}
3307
3308fn classify_ax_ws_failure(error: &AxOrdersWsClientError) -> CommandFailure {
3309 match error {
3310 AxOrdersWsClientError::ClientError(message) => CommandFailure::NotSent(message.clone()),
3311 AxOrdersWsClientError::ChannelError(message) => CommandFailure::NotSent(message.clone()),
3312 AxOrdersWsClientError::Transport(_) | AxOrdersWsClientError::AuthenticationError(_) => {
3313 CommandFailure::Ambiguous(error.to_string())
3314 }
3315 }
3316}
3317
3318#[cfg(test)]
3319mod tests {
3320 use std::{cell::RefCell, rc::Rc, sync::Arc};
3321
3322 use dashmap::DashMap;
3323 use nautilus_common::{
3324 cache::Cache,
3325 messages::{ExecutionEvent, ExecutionReport},
3326 };
3327 use nautilus_core::time::get_atomic_clock_realtime;
3328 use nautilus_model::{
3329 enums::AssetClass,
3330 identifiers::{
3331 AccountId, ClientOrderId, InstrumentId, StrategyId, Symbol, TraderId, VenueOrderId,
3332 },
3333 instruments::{InstrumentAny, PerpetualContract},
3334 orders::builder::OrderTestBuilder,
3335 types::{Currency, Price, Quantity},
3336 };
3337 use rstest::rstest;
3338 use rust_decimal::Decimal;
3339 use rust_decimal_macros::dec;
3340 use ustr::Ustr;
3341
3342 use super::*;
3343 use crate::{
3344 common::{
3345 consts::{AX_CLIENT_ID, AX_VENUE},
3346 enums::{AxOrderSide, AxOrderStatus, AxTimeInForce},
3347 },
3348 http::error::AxBuildError,
3349 websocket::{
3350 messages::{AxWsOrderExpired, AxWsOrderFilled, AxWsTradeExecution, OrderMetadata},
3351 orders::OrdersCaches,
3352 },
3353 };
3354
3355 #[rstest]
3356 fn test_gate_errors_emit_domain_rejections() {
3357 let (sender, mut rx) = tokio::sync::mpsc::unbounded_channel();
3358 let cache = Rc::new(RefCell::new(Cache::default()));
3359 let client_order_id = ClientOrderId::from("CID-GATE");
3360 let order = OrderTestBuilder::new(OrderType::Limit)
3361 .trader_id(TraderId::from("TESTER-001"))
3362 .strategy_id(StrategyId::from("S-001"))
3363 .instrument_id(InstrumentId::from("EURUSD-PERP.AX"))
3364 .client_order_id(client_order_id)
3365 .side(OrderSide::Buy)
3366 .quantity(Quantity::from("100"))
3367 .price(Price::from("1.1000"))
3368 .build();
3369 cache
3370 .borrow_mut()
3371 .add_order(order, None, Some(*AX_CLIENT_ID), false)
3372 .unwrap();
3373
3374 let mut emitter = ExecutionEventEmitter::new(
3375 get_atomic_clock_realtime(),
3376 TraderId::from("TESTER-001"),
3377 AccountId::from("AX-001"),
3378 AccountType::Margin,
3379 None,
3380 );
3381 emitter.set_sender(sender);
3382 let caches = test_caches();
3383 caches.orders_metadata.insert(
3384 client_order_id,
3385 test_metadata(client_order_id, InstrumentId::from("EURUSD-PERP.AX")),
3386 );
3387 let cid = client_order_id_to_cid(&client_order_id);
3388 caches.cid_to_client_order_id.insert(cid, client_order_id);
3389 let instruments = AtomicMap::new();
3390 let fee_rates = AtomicMap::new();
3391 let clock = get_atomic_clock_realtime();
3392 let reason = "Orders WebSocket session login pending";
3393 let command_id = UUID4::new();
3394
3395 dispatch_ws_message(
3396 AxOrdersWsMessage::PlaceOrderError {
3397 client_order_id,
3398 reason: reason.to_string(),
3399 },
3400 &emitter,
3401 &caches,
3402 AccountId::from("AX-001"),
3403 &instruments,
3404 &fee_rates,
3405 clock,
3406 );
3407
3408 assert!(!caches.orders_metadata.contains_key(&client_order_id));
3409 assert!(!caches.cid_to_client_order_id.contains_key(&cid));
3410 caches.orders_metadata.insert(
3411 client_order_id,
3412 test_metadata(client_order_id, InstrumentId::from("EURUSD-PERP.AX")),
3413 );
3414
3415 dispatch_ws_message(
3416 AxOrdersWsMessage::CancelOrderError {
3417 client_order_id,
3418 reason: reason.to_string(),
3419 command_id: Some(command_id),
3420 },
3421 &emitter,
3422 &caches,
3423 AccountId::from("AX-001"),
3424 &instruments,
3425 &fee_rates,
3426 clock,
3427 );
3428
3429 let rejected = rx.try_recv().unwrap();
3430 assert!(matches!(
3431 rejected,
3432 ExecutionEvent::Order(OrderEventAny::Rejected(event))
3433 if event.client_order_id == client_order_id
3434 && event.reason == reason
3435 && event.ts_init == event.ts_event
3436 ));
3437 let denied = rx.try_recv().unwrap();
3438 assert!(matches!(
3439 denied,
3440 ExecutionEvent::Order(OrderEventAny::CancelDenied(event))
3441 if event.client_order_id == client_order_id
3442 && event.reason == reason
3443 && event.causation_id == Some(command_id)
3444 ));
3445 }
3446
3447 #[tokio::test]
3448 async fn test_channel_submit_failure_rejects_and_cleans_tracking() {
3449 let (sender, mut rx) = tokio::sync::mpsc::unbounded_channel();
3450 let cache = Rc::new(RefCell::new(Cache::default()));
3451
3452 let core = ExecutionClientCore::new(
3453 TraderId::from("TESTER-001"),
3454 *AX_CLIENT_ID,
3455 *AX_VENUE,
3456 OmsType::Netting,
3457 AccountId::from("AX-001"),
3458 AccountType::Margin,
3459 None,
3460 cache.clone(),
3461 );
3462 let mut client = AxExecutionClient::new(core, AxExecutionClientConfig::default()).unwrap();
3463 client.emitter.set_sender(sender);
3464 client
3465 .ws_orders
3466 .cache_instrument(test_perp_instrument("EURUSD-PERP"));
3467 let client_order_id = ClientOrderId::from("CID-CHANNEL-CLOSED");
3468 let order = OrderTestBuilder::new(OrderType::Limit)
3469 .trader_id(TraderId::from("TESTER-001"))
3470 .strategy_id(StrategyId::from("S-001"))
3471 .instrument_id(InstrumentId::from("EURUSD-PERP.AX"))
3472 .client_order_id(client_order_id)
3473 .side(OrderSide::Buy)
3474 .quantity(Quantity::from("100"))
3475 .price(Price::from("1.1000"))
3476 .build();
3477 cache
3478 .borrow_mut()
3479 .add_order(order.clone(), None, Some(*AX_CLIENT_ID), false)
3480 .unwrap();
3481 let cmd = SubmitOrder::from_order(
3482 &order,
3483 TraderId::from("TESTER-001"),
3484 Some(*AX_CLIENT_ID),
3485 None,
3486 UUID4::new(),
3487 UnixNanos::default(),
3488 );
3489
3490 client.submit_order(cmd).unwrap();
3491
3492 let submitted = tokio::time::timeout(std::time::Duration::from_secs(1), rx.recv())
3493 .await
3494 .unwrap()
3495 .unwrap();
3496 assert!(matches!(
3497 submitted,
3498 ExecutionEvent::Order(OrderEventAny::Submitted(event))
3499 if event.client_order_id == client_order_id
3500 ));
3501 let rejected = tokio::time::timeout(std::time::Duration::from_secs(1), rx.recv())
3502 .await
3503 .unwrap()
3504 .unwrap();
3505 assert!(matches!(
3506 rejected,
3507 ExecutionEvent::Order(OrderEventAny::Rejected(event))
3508 if event.client_order_id == client_order_id
3509 && event.reason.as_str().contains("channel closed")
3510 ));
3511 client.await_pending_tasks().await.unwrap();
3513 let cid = client_order_id_to_cid(&client_order_id);
3514 assert!(
3515 !client
3516 .ws_orders
3517 .caches()
3518 .orders_metadata
3519 .contains_key(&client_order_id)
3520 );
3521 assert_eq!(client.ws_orders.resolve_cid(cid), None);
3522 }
3523
3524 fn test_caches() -> OrdersCaches {
3525 OrdersCaches {
3526 orders_metadata: Arc::new(DashMap::new()),
3527 venue_to_client_id: Arc::new(DashMap::new()),
3528 cid_to_client_order_id: Arc::new(DashMap::new()),
3529 pending_modifies: Arc::new(DashMap::new()),
3530 }
3531 }
3532
3533 fn test_ws_order(oid: &str, price: Decimal, qty: u64) -> AxWsOrder {
3534 AxWsOrder {
3535 aid: None,
3536 po: false,
3537 rb: None,
3538 r: None,
3539 oid: oid.to_string(),
3540 u: Ustr::from("user"),
3541 s: Ustr::from("BTC-PERP"),
3542 p: price,
3543 q: qty,
3544 xq: 0,
3545 rq: qty,
3546 o: AxOrderStatus::Accepted,
3547 d: AxOrderSide::Buy,
3548 tif: AxTimeInForce::Gtc,
3549 ts: 1609459200,
3550 tn: 0,
3551 cid: None,
3552 tag: None,
3553 txt: None,
3554 }
3555 }
3556
3557 #[rstest]
3558 fn test_create_order_updated_uses_ws_replacement_id_before_http_response() {
3559 let caches = test_caches();
3560 let clock = get_atomic_clock_realtime();
3561 let account_id = AccountId::from("AX-001");
3562 let client_order_id = ClientOrderId::from("O-WS-FIRST");
3563 let old_venue_order_id = VenueOrderId::new("OLD-OID");
3564 let new_venue_order_id = VenueOrderId::new("NEW-OID");
3565
3566 let mut metadata = test_metadata(client_order_id, InstrumentId::from("BTC-PERP.AX"));
3567 metadata.venue_order_id = Some(old_venue_order_id);
3568 caches.orders_metadata.insert(client_order_id, metadata);
3569 caches
3570 .venue_to_client_id
3571 .insert(old_venue_order_id, client_order_id);
3572
3573 let old_order = test_ws_order(old_venue_order_id.as_str(), dec!(50000.00), 100);
3574 let new_order = test_ws_order(new_venue_order_id.as_str(), dec!(50001.00), 100);
3575 let event = create_order_updated(
3576 &new_order,
3577 &old_order,
3578 new_venue_order_id,
3579 (1609459200, 0),
3580 &caches,
3581 account_id,
3582 clock,
3583 )
3584 .expect("should produce OrderUpdated");
3585
3586 assert_eq!(event.venue_order_id, Some(new_venue_order_id));
3587 assert_eq!(
3588 caches
3589 .orders_metadata
3590 .get(&client_order_id)
3591 .unwrap()
3592 .venue_order_id,
3593 Some(new_venue_order_id),
3594 );
3595 assert!(!caches.venue_to_client_id.contains_key(&old_venue_order_id));
3596 assert_eq!(
3597 *caches.venue_to_client_id.get(&new_venue_order_id).unwrap(),
3598 client_order_id,
3599 );
3600 }
3601
3602 #[rstest]
3603 fn test_pending_replacement_retains_parent_until_ws_event() {
3604 let caches = test_caches();
3605 let client_order_id = ClientOrderId::from("O-HTTP-FIRST");
3606 let old_venue_order_id = VenueOrderId::new("OLD-OID");
3607 let new_venue_order_id = VenueOrderId::new("NEW-OID");
3608 let mut metadata = test_metadata(client_order_id, InstrumentId::from("BTC-PERP.AX"));
3609 metadata.venue_order_id = Some(old_venue_order_id);
3610 caches.orders_metadata.insert(client_order_id, metadata);
3611 caches
3612 .venue_to_client_id
3613 .insert(old_venue_order_id, client_order_id);
3614
3615 caches
3616 .pending_modifies
3617 .insert(old_venue_order_id, (client_order_id, 1, false));
3618 let mut parent = test_ws_order(old_venue_order_id.as_str(), dec!(50000), 100);
3619 parent.o = AxOrderStatus::Filled;
3620 parent.xq = 100;
3621 parent.rq = 0;
3622 cleanup_terminal_order_tracking(&parent, &caches);
3623
3624 assert!(caches.venue_to_client_id.contains_key(&old_venue_order_id));
3625 assert!(!caches.venue_to_client_id.contains_key(&new_venue_order_id));
3626 assert_eq!(
3627 caches
3628 .orders_metadata
3629 .get(&client_order_id)
3630 .unwrap()
3631 .venue_order_id,
3632 Some(old_venue_order_id),
3633 );
3634
3635 record_replacement_venue_id(
3636 &caches,
3637 client_order_id,
3638 old_venue_order_id,
3639 new_venue_order_id,
3640 true,
3641 );
3642
3643 assert!(!caches.venue_to_client_id.contains_key(&old_venue_order_id));
3644 assert!(caches.venue_to_client_id.contains_key(&new_venue_order_id));
3645 }
3646
3647 #[rstest]
3648 fn test_late_replacement_cannot_regress_active_leg() {
3649 let caches = test_caches();
3650 let client_order_id = ClientOrderId::from("O-CHAIN");
3651 let parent = VenueOrderId::from("OID-A");
3652 let child = VenueOrderId::from("OID-B");
3653 let current = VenueOrderId::from("OID-C");
3654 let mut metadata = test_metadata(client_order_id, InstrumentId::from("BTC-PERP.AX"));
3655 metadata.venue_order_id = Some(parent);
3656 caches.orders_metadata.insert(client_order_id, metadata);
3657 caches.venue_to_client_id.insert(parent, client_order_id);
3658 assert!(record_replacement_venue_id(
3659 &caches,
3660 client_order_id,
3661 parent,
3662 child,
3663 true
3664 ));
3665 assert!(record_replacement_venue_id(
3666 &caches,
3667 client_order_id,
3668 child,
3669 current,
3670 true
3671 ));
3672 let late_replacement =
3673 record_replacement_venue_id(&caches, client_order_id, parent, child, true);
3674 let old_order = test_ws_order(parent.as_str(), dec!(50000), 100);
3675 let new_order = test_ws_order(child.as_str(), dec!(50001), 100);
3676 caches.cid_to_client_order_id.insert(127, client_order_id);
3677 let mut old_order = old_order;
3678 old_order.cid = Some(127);
3679 let late_event = create_order_updated(
3680 &new_order,
3681 &old_order,
3682 child,
3683 (1609459200, 0),
3684 &caches,
3685 AccountId::from("AX-001"),
3686 get_atomic_clock_realtime(),
3687 );
3688
3689 assert!(!late_replacement);
3690 assert!(late_event.is_none());
3691 assert_eq!(
3692 caches
3693 .orders_metadata
3694 .get(&client_order_id)
3695 .unwrap()
3696 .venue_order_id,
3697 Some(current)
3698 );
3699 assert_eq!(
3700 *caches.venue_to_client_id.get(¤t).unwrap(),
3701 client_order_id
3702 );
3703 assert_eq!(caches.venue_to_client_id.len(), 1);
3704 }
3705
3706 #[rstest]
3707 #[case::timestamp(0)]
3708 #[case::price(1)]
3709 #[case::instrument(2)]
3710 #[case::side(3)]
3711 fn test_malformed_replacement_does_not_promote(#[case] invalid: u8) {
3712 let caches = test_caches();
3713 let client_order_id = ClientOrderId::from("O-BAD-REPLACE");
3714 let parent = VenueOrderId::from("OID-PARENT");
3715 let child = VenueOrderId::from("OID-CHILD");
3716 let mut metadata = test_metadata(client_order_id, InstrumentId::from("BTC-PERP.AX"));
3717 metadata.venue_order_id = Some(parent);
3718 let submitted = OrderTestBuilder::new(OrderType::Limit)
3719 .instrument_id(InstrumentId::from("BTC-PERP.AX"))
3720 .client_order_id(client_order_id)
3721 .side(OrderSide::Buy)
3722 .quantity(Quantity::from("100"))
3723 .price(Price::from("50000.00"))
3724 .build();
3725 metadata.order_init = Some(submitted.init_event().clone());
3726 caches.orders_metadata.insert(client_order_id, metadata);
3727 caches.venue_to_client_id.insert(parent, client_order_id);
3728 let old_order = test_ws_order(parent.as_str(), dec!(50000), 100);
3729
3730 let mut new_order = test_ws_order(
3731 child.as_str(),
3732 if invalid == 1 {
3733 Decimal::MAX
3734 } else {
3735 dec!(50001)
3736 },
3737 101,
3738 );
3739
3740 if invalid == 2 {
3741 new_order.s = Ustr::from("WRONG-PERP");
3742 }
3743
3744 if invalid == 3 {
3745 new_order.d = AxOrderSide::Sell;
3746 }
3747
3748 let event = create_order_updated(
3749 &new_order,
3750 &old_order,
3751 child,
3752 (if invalid == 0 { -1 } else { 1609459200 }, 0),
3753 &caches,
3754 AccountId::from("AX-001"),
3755 get_atomic_clock_realtime(),
3756 );
3757
3758 let mut message: crate::websocket::messages::AxWsOrderReplaced =
3759 serde_json::from_str(include_str!("../test_data/ws_order_replaced_live.json")).unwrap();
3760 message.ro = Box::new(old_order);
3761 message.no = Some(Box::new(new_order));
3762 message.noid = Some(child.to_string());
3763 if invalid == 0 {
3764 message.ts = -1;
3765 }
3766
3767 let instruments = AtomicMap::new();
3768 instruments.insert(Ustr::from("BTC-PERP"), test_perp_instrument("BTC-PERP"));
3769 let clock = get_atomic_clock_realtime();
3770 let account_id = AccountId::from("AX-001");
3771 let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel();
3772
3773 let mut emitter = ExecutionEventEmitter::new(
3774 clock,
3775 TraderId::from("TRADER-001"),
3776 account_id,
3777 AccountType::Margin,
3778 None,
3779 );
3780 emitter.set_sender(tx);
3781 dispatch_order_event(
3782 AxWsOrderEvent::Replaced(message),
3783 &emitter,
3784 &caches,
3785 account_id,
3786 &instruments,
3787 &AtomicMap::new(),
3788 clock,
3789 );
3790
3791 assert!(rx.try_recv().is_err());
3792 assert!(event.is_none());
3793 assert_eq!(
3794 caches
3795 .orders_metadata
3796 .get(&client_order_id)
3797 .unwrap()
3798 .venue_order_id,
3799 Some(parent)
3800 );
3801 assert_eq!(
3802 *caches.venue_to_client_id.get(&parent).unwrap(),
3803 client_order_id
3804 );
3805 assert_eq!(caches.venue_to_client_id.len(), 1);
3806 }
3807
3808 fn test_metadata(client_order_id: ClientOrderId, instrument_id: InstrumentId) -> OrderMetadata {
3809 OrderMetadata {
3810 trader_id: TraderId::from("TRADER-001"),
3811 strategy_id: StrategyId::from("S-001"),
3812 instrument_id,
3813 client_order_id,
3814 order_init: None,
3815 is_accepted: true,
3816 venue_order_id: None,
3817 ts_init: 0.into(),
3818 size_precision: 0,
3819 price_precision: 2,
3820 quote_currency: Currency::USD(),
3821 }
3822 }
3823
3824 fn test_execution(tid: &str, price: Decimal, qty: u64, agg: bool) -> AxWsTradeExecution {
3825 AxWsTradeExecution {
3826 aid: None,
3827 tid: tid.to_string(),
3828 s: Ustr::from("BTC-PERP"),
3829 q: qty,
3830 p: price,
3831 d: AxOrderSide::Buy,
3832 agg,
3833 }
3834 }
3835
3836 fn seed_terminal_tracking(
3837 caches: &OrdersCaches,
3838 client_order_id: ClientOrderId,
3839 venue_order_id: VenueOrderId,
3840 stale_venue_order_id: VenueOrderId,
3841 cid_value: u64,
3842 ) {
3843 caches.orders_metadata.insert(
3844 client_order_id,
3845 test_metadata(client_order_id, InstrumentId::from("BTC-PERP.AX")),
3846 );
3847 caches
3848 .venue_to_client_id
3849 .insert(venue_order_id, client_order_id);
3850 caches
3851 .venue_to_client_id
3852 .insert(stale_venue_order_id, client_order_id);
3853 caches
3854 .cid_to_client_order_id
3855 .insert(cid_value, client_order_id);
3856 }
3857
3858 fn test_perp_instrument(symbol: &str) -> InstrumentAny {
3859 let symbol = Symbol::new(symbol);
3860 let instrument = PerpetualContract::builder()
3861 .instrument_id(InstrumentId::new(symbol, *AX_VENUE))
3862 .raw_symbol(symbol)
3863 .underlying(Ustr::from("BTC"))
3864 .asset_class(AssetClass::Cryptocurrency)
3865 .quote_currency(Currency::USD())
3866 .settlement_currency(Currency::USD())
3867 .is_inverse(false)
3868 .price_precision(2)
3869 .size_precision(0)
3870 .price_increment(Price::from("0.01"))
3871 .size_increment(Quantity::from("1"))
3872 .margin_init(Decimal::new(1, 2))
3873 .margin_maint(Decimal::new(5, 3))
3874 .ts_event(0.into())
3875 .ts_init(0.into())
3876 .build()
3877 .unwrap();
3878 InstrumentAny::PerpetualContract(instrument)
3879 }
3880
3881 fn test_status_report(
3882 client_order_id: Option<ClientOrderId>,
3883 venue_order_id: VenueOrderId,
3884 order_status: OrderStatus,
3885 ) -> OrderStatusReport {
3886 OrderStatusReport::new(
3887 AccountId::from("AX-001"),
3888 InstrumentId::from("BTC-PERP.AX"),
3889 client_order_id,
3890 venue_order_id,
3891 Some(OrderSide::Buy),
3892 OrderType::Limit,
3893 TimeInForce::Gtc,
3894 order_status,
3895 Quantity::from("1"),
3896 Quantity::from("1"),
3897 0.into(),
3898 0.into(),
3899 0.into(),
3900 None,
3901 )
3902 }
3903
3904 #[rstest]
3905 fn test_create_order_accepted_populates_cache_and_event() {
3906 let caches = test_caches();
3907 let clock = get_atomic_clock_realtime();
3908 let account_id = AccountId::from("AX-001");
3909 let client_order_id = ClientOrderId::from("O-ACK");
3910 let instrument_id = InstrumentId::from("BTC-PERP.AX");
3911 let venue_order_id = VenueOrderId::new("OID-ACK");
3912
3913 let mut metadata = test_metadata(client_order_id, instrument_id);
3914 metadata.is_accepted = false;
3915 caches.orders_metadata.insert(client_order_id, metadata);
3916 let cid_value = 7u64;
3917 caches
3918 .cid_to_client_order_id
3919 .insert(cid_value, client_order_id);
3920
3921 let mut ws_order = test_ws_order(venue_order_id.as_str(), dec!(50500.00), 100);
3922 ws_order.cid = Some(cid_value);
3923
3924 let event = create_order_accepted(&ws_order, 1609459200, 500, &caches, account_id, clock)
3925 .expect("should produce OrderAccepted");
3926
3927 assert_eq!(event.venue_order_id, venue_order_id);
3928 assert_eq!(event.client_order_id, client_order_id);
3929 assert_eq!(event.account_id, account_id);
3930 assert_eq!(event.instrument_id, instrument_id);
3931 assert_eq!(event.trader_id, TraderId::from("TRADER-001"));
3932 assert_eq!(event.strategy_id, StrategyId::from("S-001"));
3933 assert_eq!(
3934 event.ts_event,
3935 UnixNanos::from(1_609_459_200_000_000_500u64)
3936 );
3937
3938 assert_eq!(
3940 *caches.venue_to_client_id.get(&venue_order_id).unwrap(),
3941 client_order_id,
3942 );
3943 let meta = caches.orders_metadata.get(&client_order_id).unwrap();
3944 assert_eq!(meta.venue_order_id, Some(venue_order_id));
3945 }
3946
3947 #[rstest]
3948 #[case::unbound_partial(false, false)]
3949 #[case::response_before_partial(true, false)]
3950 #[case::unbound_complete(false, true)]
3951 #[case::response_before_complete(true, true)]
3952 fn test_market_fill_before_acknowledgement(#[case] bound: bool, #[case] complete: bool) {
3953 let raw = if complete {
3954 include_str!("../test_data/ws_order_filled.json")
3955 } else {
3956 include_str!("../test_data/ws_order_partially_filled.json")
3957 };
3958
3959 let mut event: AxWsOrderEvent = serde_json::from_str(raw).unwrap();
3960
3961 let order = match &mut event {
3962 AxWsOrderEvent::Filled(msg) => &mut msg.o,
3963 AxWsOrderEvent::PartiallyFilled(msg) => &mut msg.o,
3964 _ => unreachable!(),
3965 };
3966
3967 order.cid = Some(117);
3968 let venue_order_id = VenueOrderId::from(order.oid.as_str());
3969 let client_order_id = ClientOrderId::from("O-ORIGINAL-MARKET");
3970 let instrument_id = InstrumentId::from("EURUSD-PERP.AX");
3971 let local_order = OrderTestBuilder::new(OrderType::Market)
3972 .trader_id(TraderId::from("TRADER-001"))
3973 .strategy_id(StrategyId::from("S-001"))
3974 .instrument_id(instrument_id)
3975 .client_order_id(client_order_id)
3976 .side(OrderSide::Buy)
3977 .quantity(Quantity::from("100"))
3978 .time_in_force(TimeInForce::Ioc)
3979 .build();
3980 let mut metadata = test_metadata(client_order_id, instrument_id);
3981 metadata.is_accepted = false;
3982 metadata.order_init = Some(local_order.init_event().clone());
3983 metadata.venue_order_id = bound.then_some(venue_order_id);
3984 let caches = test_caches();
3985 caches.orders_metadata.insert(client_order_id, metadata);
3986 caches.cid_to_client_order_id.insert(117, client_order_id);
3987 if bound {
3988 caches
3989 .venue_to_client_id
3990 .insert(venue_order_id, client_order_id);
3991 }
3992
3993 let instruments = AtomicMap::new();
3994 instruments.insert(
3995 Ustr::from("EURUSD-PERP"),
3996 test_perp_instrument("EURUSD-PERP"),
3997 );
3998 let rates = AtomicMap::new();
3999 rates.insert(
4000 Some(Ustr::from("fixture-account")),
4001 MakerTakerFeeRates::new(dec!(0.0002), dec!(0.0025)),
4002 );
4003 let clock = get_atomic_clock_realtime();
4004 let account_id = AccountId::from("AX-001");
4005 let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel();
4006
4007 let mut emitter = ExecutionEventEmitter::new(
4008 clock,
4009 TraderId::from("TRADER-001"),
4010 account_id,
4011 AccountType::Margin,
4012 None,
4013 );
4014 emitter.set_sender(tx);
4015 dispatch_order_event(
4016 event,
4017 &emitter,
4018 &caches,
4019 account_id,
4020 &instruments,
4021 &rates,
4022 clock,
4023 );
4024
4025 let ExecutionEvent::Order(OrderEventAny::Accepted(accepted)) = rx.try_recv().unwrap()
4026 else {
4027 panic!("expected acceptance before fill");
4028 };
4029
4030 let ExecutionEvent::Order(OrderEventAny::Filled(fill)) = rx.try_recv().unwrap() else {
4031 panic!("expected tracked fill");
4032 };
4033
4034 assert_eq!(accepted.client_order_id, client_order_id);
4035 assert_eq!(accepted.venue_order_id, venue_order_id);
4036 assert_eq!(accepted.instrument_id, instrument_id);
4037 assert_eq!(fill.client_order_id, client_order_id);
4038 assert_eq!(fill.trader_id, local_order.trader_id());
4039 assert_eq!(fill.strategy_id, local_order.strategy_id());
4040 assert_eq!(fill.instrument_id, instrument_id);
4041 assert_eq!(fill.account_id, account_id);
4042 assert_eq!(fill.venue_order_id, venue_order_id);
4043 assert_eq!(fill.order_type, OrderType::Market);
4044 assert_eq!(fill.order_side, OrderSide::Buy);
4045 assert_eq!(
4046 fill.last_qty.as_decimal(),
4047 if complete { dec!(100) } else { dec!(50) }
4048 );
4049 assert_eq!(fill.last_px.as_decimal(), dec!(50000));
4050 assert_eq!(
4051 fill.commission,
4052 Some(Money::from(if complete {
4053 "1000.00 USD"
4054 } else {
4055 "500.00 USD"
4056 }))
4057 );
4058 assert_eq!(fill.liquidity_side, LiquiditySide::Maker);
4059 assert!(rx.try_recv().is_err());
4060
4061 if complete {
4062 assert!(caches.orders_metadata.is_empty());
4063 assert!(caches.cid_to_client_order_id.is_empty());
4064 } else {
4065 let metadata = caches.orders_metadata.get(&client_order_id).unwrap();
4066 assert_eq!(metadata.venue_order_id, Some(venue_order_id));
4067 assert!(metadata.is_accepted);
4068 assert_eq!(metadata.order_init.as_ref(), Some(local_order.init_event()));
4069 }
4070 }
4071
4072 #[rstest]
4073 #[case::partial_first(false, false)]
4074 #[case::complete_first(true, false)]
4075 #[case::partial_second(false, true)]
4076 #[case::complete_second(true, true)]
4077 fn test_parent_fill_before_stream_replacement(#[case] complete: bool, #[case] second: bool) {
4078 let mut event: AxWsOrderEvent = serde_json::from_str(if complete {
4079 include_str!("../test_data/ws_order_filled.json")
4080 } else {
4081 include_str!("../test_data/ws_order_partially_filled.json")
4082 })
4083 .unwrap();
4084
4085 let order = match &mut event {
4086 AxWsOrderEvent::Filled(msg) => &mut msg.o,
4087 AxWsOrderEvent::PartiallyFilled(msg) => &mut msg.o,
4088 _ => unreachable!(),
4089 };
4090
4091 order.cid = Some(131);
4092 let first_id = VenueOrderId::from("OID-FIRST");
4093 let parent_id = VenueOrderId::from(order.oid.as_str());
4094 let child_id = VenueOrderId::from("OID-REPLACEMENT");
4095 let client_order_id = ClientOrderId::from("O-PARENT-FILL");
4096 let instrument_id = InstrumentId::from("EURUSD-PERP.AX");
4097 let caches = test_caches();
4098 let mut metadata = test_metadata(client_order_id, instrument_id);
4099 metadata.venue_order_id = Some(if second { first_id } else { parent_id });
4100 caches.orders_metadata.insert(client_order_id, metadata);
4101 caches.cid_to_client_order_id.insert(131, client_order_id);
4102 if second {
4103 caches.venue_to_client_id.insert(first_id, client_order_id);
4104 assert!(record_replacement_venue_id(
4105 &caches,
4106 client_order_id,
4107 first_id,
4108 parent_id,
4109 true
4110 ));
4111 }
4112
4113 caches.venue_to_client_id.insert(parent_id, client_order_id);
4114 caches
4115 .pending_modifies
4116 .insert(parent_id, (client_order_id, 1, false));
4117 record_replacement_proposal(&caches, client_order_id, parent_id, child_id);
4118 let parent_order = order.clone();
4119 let mut child_order = parent_order.clone();
4120 child_order.oid = child_id.to_string();
4121 child_order.p = dec!(50001);
4122 let instruments = AtomicMap::new();
4123 instruments.insert(
4124 Ustr::from("EURUSD-PERP"),
4125 test_perp_instrument("EURUSD-PERP"),
4126 );
4127 let rates = AtomicMap::new();
4128 rates.insert(
4129 Some(Ustr::from("fixture-account")),
4130 MakerTakerFeeRates::new(dec!(0.0002), dec!(0.0025)),
4131 );
4132 let clock = get_atomic_clock_realtime();
4133 let account_id = AccountId::from("AX-001");
4134 let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel();
4135
4136 let mut emitter = ExecutionEventEmitter::new(
4137 clock,
4138 TraderId::from("TRADER-001"),
4139 account_id,
4140 AccountType::Margin,
4141 None,
4142 );
4143 emitter.set_sender(tx);
4144 dispatch_order_event(
4145 event.clone(),
4146 &emitter,
4147 &caches,
4148 account_id,
4149 &instruments,
4150 &rates,
4151 clock,
4152 );
4153
4154 let ExecutionEvent::Order(OrderEventAny::Filled(fill)) = rx.try_recv().unwrap() else {
4155 panic!("expected tracked parent fill");
4156 };
4157
4158 assert_eq!(fill.client_order_id, client_order_id);
4159 assert_eq!(fill.trader_id, TraderId::from("TRADER-001"));
4160 assert_eq!(fill.strategy_id, StrategyId::from("S-001"));
4161 assert_eq!(fill.instrument_id, instrument_id);
4162 assert_eq!(fill.account_id, account_id);
4163 assert_eq!(fill.venue_order_id, parent_id);
4164 assert_eq!(fill.order_type, OrderType::Limit);
4165 assert_eq!(fill.order_side, OrderSide::Buy);
4166 assert_eq!(
4167 fill.last_qty.as_decimal(),
4168 if complete { dec!(100) } else { dec!(50) }
4169 );
4170 assert_eq!(fill.last_px.as_decimal(), dec!(50000));
4171 assert_eq!(
4172 fill.commission,
4173 Some(Money::from(if complete {
4174 "1000.00 USD"
4175 } else {
4176 "500.00 USD"
4177 }))
4178 );
4179 assert_eq!(fill.liquidity_side, LiquiditySide::Maker);
4180 assert_eq!(fill.ts_event, UnixNanos::from(1_609_459_200_123_456_789u64));
4181 assert_eq!(
4182 rx.try_recv().unwrap_err(),
4183 tokio::sync::mpsc::error::TryRecvError::Empty
4184 );
4185 assert_eq!(
4186 caches
4187 .orders_metadata
4188 .get(&client_order_id)
4189 .unwrap()
4190 .venue_order_id,
4191 Some(parent_id)
4192 );
4193 assert_eq!(
4194 *caches.venue_to_client_id.get(&parent_id).unwrap(),
4195 client_order_id
4196 );
4197 assert_eq!(
4198 *caches.venue_to_client_id.get(&child_id).unwrap(),
4199 client_order_id
4200 );
4201 assert_eq!(
4202 *caches.cid_to_client_order_id.get(&131).unwrap(),
4203 client_order_id
4204 );
4205
4206 let updated = create_order_updated(
4207 &child_order,
4208 &parent_order,
4209 child_id,
4210 (1609459201, 0),
4211 &caches,
4212 account_id,
4213 clock,
4214 )
4215 .unwrap();
4216 dispatch_order_event(
4217 event,
4218 &emitter,
4219 &caches,
4220 account_id,
4221 &instruments,
4222 &rates,
4223 clock,
4224 );
4225 assert_eq!(updated.venue_order_id, Some(child_id));
4226 assert_eq!(
4227 rx.try_recv().unwrap_err(),
4228 tokio::sync::mpsc::error::TryRecvError::Empty
4229 );
4230 assert!(!caches.venue_to_client_id.contains_key(&parent_id));
4231 assert_eq!(caches.venue_to_client_id.len(), 1);
4232 assert_eq!(
4233 caches
4234 .orders_metadata
4235 .get(&client_order_id)
4236 .unwrap()
4237 .venue_order_id,
4238 Some(child_id)
4239 );
4240 }
4241
4242 #[rstest]
4243 #[case::acknowledgement(false, false)]
4244 #[case::terminal_parent(true, false)]
4245 #[case::pending_acknowledgement(false, true)]
4246 #[case::pending_terminal_parent(true, true)]
4247 fn test_stale_parent_preserves_replacement(#[case] terminal: bool, #[case] mapped: bool) {
4248 let mut event: AxWsOrderEvent = serde_json::from_str(if terminal {
4249 include_str!("../test_data/ws_order_canceled.json")
4250 } else {
4251 include_str!("../test_data/ws_order_acknowledged.json")
4252 })
4253 .unwrap();
4254
4255 let order = match &mut event {
4256 AxWsOrderEvent::Acknowledged(msg) => &mut msg.o,
4257 AxWsOrderEvent::Canceled(msg) => &mut msg.o,
4258 _ => unreachable!(),
4259 };
4260
4261 order.cid = Some(119);
4262 let parent_id = VenueOrderId::from(order.oid.as_str());
4263 let child_id = VenueOrderId::from("OID-ACTIVE-CHILD");
4264 let client_order_id = ClientOrderId::from("O-STALE-PARENT");
4265 let caches = test_caches();
4266 let mut metadata = test_metadata(client_order_id, InstrumentId::from("EURUSD-PERP.AX"));
4267 metadata.venue_order_id = Some(child_id);
4268 metadata.is_accepted = true;
4269 caches.orders_metadata.insert(client_order_id, metadata);
4270 caches.cid_to_client_order_id.insert(119, client_order_id);
4271 caches.venue_to_client_id.insert(child_id, client_order_id);
4272 if mapped {
4273 caches.venue_to_client_id.insert(parent_id, client_order_id);
4274 }
4275
4276 let clock = get_atomic_clock_realtime();
4277 let account_id = AccountId::from("AX-001");
4278 let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel();
4279
4280 let mut emitter = ExecutionEventEmitter::new(
4281 clock,
4282 TraderId::from("TRADER-001"),
4283 account_id,
4284 AccountType::Margin,
4285 None,
4286 );
4287 emitter.set_sender(tx);
4288 let instruments = AtomicMap::new();
4289 instruments.insert(
4290 Ustr::from("EURUSD-PERP"),
4291 test_perp_instrument("EURUSD-PERP"),
4292 );
4293 dispatch_order_event(
4294 event,
4295 &emitter,
4296 &caches,
4297 account_id,
4298 &instruments,
4299 &AtomicMap::new(),
4300 clock,
4301 );
4302 let report = test_status_report(Some(client_order_id), parent_id, OrderStatus::Canceled);
4303 cleanup_closed_order_status_report(&report, &caches);
4304
4305 assert!(rx.try_recv().is_err());
4306 assert_eq!(
4307 caches
4308 .orders_metadata
4309 .get(&client_order_id)
4310 .unwrap()
4311 .venue_order_id,
4312 Some(child_id)
4313 );
4314 assert_eq!(
4315 *caches.venue_to_client_id.get(&child_id).unwrap(),
4316 client_order_id
4317 );
4318 assert_eq!(
4319 *caches.cid_to_client_order_id.get(&119).unwrap(),
4320 client_order_id
4321 );
4322 assert_eq!(caches.venue_to_client_id.len(), if mapped { 2 } else { 1 });
4323 }
4324
4325 #[rstest]
4326 #[case::cancel(false)]
4327 #[case::modify(true)]
4328 fn test_stale_parent_rejection_preserves_active_leg(#[case] modify: bool) {
4329 let mut event: AxWsOrderEvent =
4330 serde_json::from_str(include_str!("../test_data/ws_cancel_rejected.json")).unwrap();
4331
4332 if modify {
4333 let AxWsOrderEvent::CancelRejected(msg) = &mut event else {
4334 unreachable!()
4335 };
4336
4337 msg.r = AxCancelRejectionReason::Unknown;
4338 msg.txt = Some("post-only order would cross the book".to_string());
4339 }
4340
4341 let parent = VenueOrderId::from("O-01ARZ3NDEKTSV4RRFFQ69G5FAV");
4342 let child = VenueOrderId::from("OID-CHILD");
4343 let client_order_id = ClientOrderId::from("O-STALE-CANCEL");
4344 let caches = test_caches();
4345 let mut metadata = test_metadata(client_order_id, InstrumentId::from("EURUSD-PERP.AX"));
4346 metadata.venue_order_id = Some(child);
4347 caches.orders_metadata.insert(client_order_id, metadata);
4348 if !modify {
4349 caches.venue_to_client_id.insert(parent, client_order_id);
4350 }
4351
4352 caches
4353 .pending_modifies
4354 .insert(parent, (client_order_id, 1, false));
4355 caches.venue_to_client_id.insert(child, client_order_id);
4356 let clock = get_atomic_clock_realtime();
4357 let account_id = AccountId::from("AX-001");
4358 let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel();
4359
4360 let mut emitter = ExecutionEventEmitter::new(
4361 clock,
4362 TraderId::from("TRADER-001"),
4363 account_id,
4364 AccountType::Margin,
4365 None,
4366 );
4367 emitter.set_sender(tx);
4368 dispatch_order_event(
4369 event,
4370 &emitter,
4371 &caches,
4372 account_id,
4373 &AtomicMap::new(),
4374 &AtomicMap::new(),
4375 clock,
4376 );
4377
4378 if modify {
4379 let ExecutionEvent::Order(OrderEventAny::ModifyRejected(rejected)) =
4380 rx.try_recv().unwrap()
4381 else {
4382 panic!("expected stale parent modify rejection");
4383 };
4384
4385 assert_eq!(rejected.client_order_id, client_order_id);
4386 assert_eq!(rejected.venue_order_id, Some(child));
4387 assert_eq!(rejected.reason, "post-only order would cross the book");
4388 }
4389
4390 assert!(rx.try_recv().is_err());
4391 assert_eq!(caches.pending_modifies.contains_key(&parent), !modify);
4392 assert_eq!(
4393 caches
4394 .orders_metadata
4395 .get(&client_order_id)
4396 .unwrap()
4397 .venue_order_id,
4398 Some(child)
4399 );
4400 assert_eq!(
4401 *caches.venue_to_client_id.get(&child).unwrap(),
4402 client_order_id
4403 );
4404 }
4405
4406 #[rstest]
4407 #[case::trade_id(0)]
4408 #[case::timestamp(1)]
4409 #[case::venue_id(2)]
4410 #[case::instrument(3)]
4411 fn test_malformed_tracked_fill_preserves_context(#[case] invalid: u8) {
4412 let mut fill: AxWsOrderFilled =
4413 serde_json::from_str(include_str!("../test_data/ws_order_filled.json")).unwrap();
4414 fill.o.cid = Some(121);
4415 let venue_order_id = VenueOrderId::from(fill.o.oid.as_str());
4416 let client_order_id = ClientOrderId::from("O-MALFORMED");
4417 let caches = test_caches();
4418 let mut metadata = test_metadata(client_order_id, InstrumentId::from("EURUSD-PERP.AX"));
4419 metadata.venue_order_id = Some(venue_order_id);
4420 caches.orders_metadata.insert(client_order_id, metadata);
4421 caches.cid_to_client_order_id.insert(121, client_order_id);
4422 caches
4423 .venue_to_client_id
4424 .insert(venue_order_id, client_order_id);
4425
4426 match invalid {
4427 0 => fill.xs.tid.clear(),
4428 1 => fill.ts = -1,
4429 2 => fill.o.oid.clear(),
4430 3 => fill.o.s = Ustr::from("WRONG-PERP"),
4431 _ => unreachable!(),
4432 }
4433
4434 let instruments = AtomicMap::new();
4435 instruments.insert(
4436 Ustr::from("EURUSD-PERP"),
4437 test_perp_instrument("EURUSD-PERP"),
4438 );
4439 let rates = AtomicMap::new();
4440 rates.insert(
4441 Some(Ustr::from("fixture-account")),
4442 MakerTakerFeeRates::new(dec!(0.0002), dec!(0.0025)),
4443 );
4444 let clock = get_atomic_clock_realtime();
4445 let account_id = AccountId::from("AX-001");
4446 let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel();
4447
4448 let mut emitter = ExecutionEventEmitter::new(
4449 clock,
4450 TraderId::from("TRADER-001"),
4451 account_id,
4452 AccountType::Margin,
4453 None,
4454 );
4455 emitter.set_sender(tx);
4456 dispatch_order_event(
4457 AxWsOrderEvent::Filled(fill),
4458 &emitter,
4459 &caches,
4460 account_id,
4461 &instruments,
4462 &rates,
4463 clock,
4464 );
4465
4466 assert!(rx.try_recv().is_err());
4467 assert_eq!(
4468 caches
4469 .orders_metadata
4470 .get(&client_order_id)
4471 .unwrap()
4472 .venue_order_id,
4473 Some(venue_order_id)
4474 );
4475 assert_eq!(
4476 *caches.venue_to_client_id.get(&venue_order_id).unwrap(),
4477 client_order_id
4478 );
4479 assert_eq!(
4480 *caches.cid_to_client_order_id.get(&121).unwrap(),
4481 client_order_id
4482 );
4483 }
4484
4485 #[rstest]
4486 fn test_create_order_accepted_returns_none_without_metadata() {
4487 let caches = test_caches();
4488 let clock = get_atomic_clock_realtime();
4489 let account_id = AccountId::from("AX-001");
4490 let ws_order = test_ws_order("OID-UNKNOWN", dec!(100.00), 10);
4491
4492 let result = create_order_accepted(&ws_order, 1609459200, 0, &caches, account_id, clock);
4493 assert!(result.is_none());
4494 assert!(caches.venue_to_client_id.is_empty());
4495 }
4496
4497 #[rstest]
4498 fn test_lookup_order_metadata_cid_fallback() {
4499 let caches = test_caches();
4500 let client_order_id = ClientOrderId::from("O-CID");
4501 let instrument_id = InstrumentId::from("BTC-PERP.AX");
4502 caches.orders_metadata.insert(
4503 client_order_id,
4504 test_metadata(client_order_id, instrument_id),
4505 );
4506 caches.cid_to_client_order_id.insert(99, client_order_id);
4507
4508 let mut ws_order = test_ws_order("UNKNOWN-OID", dec!(0), 0);
4509 ws_order.cid = Some(99);
4510
4511 let found = lookup_order_metadata(&ws_order, &caches).expect("cid fallback should find");
4512 assert_eq!(found.client_order_id, client_order_id);
4513 }
4514
4515 #[rstest]
4516 #[case(true, LiquiditySide::Taker)]
4517 #[case(false, LiquiditySide::Maker)]
4518 fn test_create_order_filled_maps_liquidity_side(
4519 #[case] agg: bool,
4520 #[case] expected: LiquiditySide,
4521 ) {
4522 let caches = test_caches();
4523 let clock = get_atomic_clock_realtime();
4524 let account_id = AccountId::from("AX-001");
4525 let client_order_id = ClientOrderId::from("O-FILL");
4526 let instrument_id = InstrumentId::from("BTC-PERP.AX");
4527 let venue_order_id = VenueOrderId::new("OID-FILL");
4528
4529 caches.orders_metadata.insert(
4530 client_order_id,
4531 test_metadata(client_order_id, instrument_id),
4532 );
4533 caches
4534 .venue_to_client_id
4535 .insert(venue_order_id, client_order_id);
4536
4537 let order = test_ws_order(venue_order_id.as_str(), dec!(50500.00), 100);
4538 let execution = test_execution("TID-1", dec!(50500.00), 25, agg);
4539
4540 let event = create_order_filled(
4541 &order,
4542 &execution,
4543 1609459200,
4544 0,
4545 &caches,
4546 account_id,
4547 Money::from("12.34 USD"),
4548 clock,
4549 )
4550 .expect("should produce OrderFilled");
4551
4552 assert_eq!(event.venue_order_id, venue_order_id);
4553 assert_eq!(event.client_order_id, client_order_id);
4554 assert_eq!(event.trade_id, TradeId::new("TID-1"));
4555 assert_eq!(event.last_qty, Quantity::new(25.0, 0));
4556 assert_eq!(event.last_px, Price::from("50500.00"));
4557 assert_eq!(event.liquidity_side, expected);
4558 assert_eq!(event.commission, Some(Money::from("12.34 USD")));
4559 }
4560
4561 #[rstest]
4562 #[case::maker(false, dec!(0.0002), dec!(0.0025), dec!(100.25), 20, dec!(2.5), "1.00 USD")]
4563 #[case::taker(true, dec!(0.0002), dec!(0.0025), dec!(100.25), 20, dec!(2.5), "12.53 USD")]
4564 #[case::zero(false, dec!(0), dec!(0.0025), dec!(100.25), 20, dec!(2.5), "0.00 USD")]
4565 #[case::rebate(false, dec!(-0.0002), dec!(0.0025), dec!(100.25), 20, dec!(2.5), "-1.00 USD")]
4566 #[case::negative_price(false, dec!(0.0002), dec!(0.0025), dec!(-100.25), 20, dec!(2.5), "1.00 USD")]
4567 #[case::sub_cent_notional(false, dec!(0.0002), dec!(0.0025), dec!(0.007499), 10_001, dec!(1), "0.01 USD")]
4568 fn test_calculate_fill_commission(
4569 #[case] agg: bool,
4570 #[case] maker: Decimal,
4571 #[case] taker: Decimal,
4572 #[case] price: Decimal,
4573 #[case] quantity: u64,
4574 #[case] multiplier: Decimal,
4575 #[case] expected: &str,
4576 ) {
4577 let mut instrument = test_perp_instrument("BTC-PERP");
4578 if let InstrumentAny::PerpetualContract(ref mut instrument) = instrument {
4579 instrument.multiplier = Quantity::from_decimal(multiplier).unwrap();
4580 }
4581
4582 let instruments = AtomicMap::new();
4583 instruments.insert(Ustr::from("BTC-PERP"), instrument);
4584 let rates = AtomicMap::new();
4585 rates.insert(None, MakerTakerFeeRates::new(maker, taker));
4586 let order = test_ws_order("OID-FILL", price, quantity);
4587 let execution = test_execution("TID-FILL", price, quantity, agg);
4588
4589 let commission =
4590 calculate_fill_commission(&order, &execution, &instruments, &rates).unwrap();
4591
4592 assert_eq!(commission, Money::from(expected));
4593 }
4594
4595 #[rstest]
4596 #[case::default(None, None, "0.05 USD")]
4597 #[case::order_account(Some("order-account"), None, "0.10 USD")]
4598 #[case::execution_account(None, Some("execution-account"), "0.15 USD")]
4599 #[case::execution_account_precedence(
4600 Some("order-account"),
4601 Some("execution-account"),
4602 "0.15 USD"
4603 )]
4604 fn test_calculate_fill_commission_resolves_account(
4605 #[case] order_account: Option<&str>,
4606 #[case] execution_account: Option<&str>,
4607 #[case] expected: &str,
4608 ) {
4609 let instruments = AtomicMap::new();
4610 instruments.insert(Ustr::from("BTC-PERP"), test_perp_instrument("BTC-PERP"));
4611 let rates = AtomicMap::new();
4612 rates.insert(None, MakerTakerFeeRates::new(dec!(0.0001), dec!(0.0002)));
4613 rates.insert(
4614 Some(Ustr::from("order-account")),
4615 MakerTakerFeeRates::new(dec!(0.0003), dec!(0.0004)),
4616 );
4617 rates.insert(
4618 Some(Ustr::from("execution-account")),
4619 MakerTakerFeeRates::new(dec!(0.0005), dec!(0.0006)),
4620 );
4621 let mut order = test_ws_order("OID-FILL", dec!(10), 25);
4622 order.aid = order_account.map(Ustr::from);
4623 let mut execution = test_execution("TID-FILL", dec!(10), 25, true);
4624 execution.aid = execution_account.map(Ustr::from);
4625
4626 let commission =
4627 calculate_fill_commission(&order, &execution, &instruments, &rates).unwrap();
4628
4629 assert_eq!(commission, Money::from(expected));
4630 }
4631
4632 #[rstest]
4633 #[case::tracked_partial(true, false, "500.00 USD")]
4634 #[case::tracked_full(true, true, "1000.00 USD")]
4635 #[case::untracked_partial(false, false, "500.00 USD")]
4636 #[case::untracked_full(false, true, "1000.00 USD")]
4637 fn test_dispatch_stream_fill_carries_commission(
4638 #[case] tracked: bool,
4639 #[case] complete: bool,
4640 #[case] expected: &str,
4641 ) {
4642 let raw = if complete {
4643 include_str!("../test_data/ws_order_filled.json")
4644 } else {
4645 include_str!("../test_data/ws_order_partially_filled.json")
4646 };
4647
4648 let event: AxWsOrderEvent = serde_json::from_str(raw).unwrap();
4649 let clock = get_atomic_clock_realtime();
4650 let account_id = AccountId::from("AX-001");
4651 let client_order_id = ClientOrderId::from("O-FILL");
4652 let venue_order_id = VenueOrderId::new("O-01ARZ3NDEKTSV4RRFFQ69G5FAV");
4653 let instrument_id = InstrumentId::from("EURUSD-PERP.AX");
4654 let caches = test_caches();
4655 if tracked {
4656 caches.orders_metadata.insert(
4657 client_order_id,
4658 test_metadata(client_order_id, instrument_id),
4659 );
4660 caches
4661 .venue_to_client_id
4662 .insert(venue_order_id, client_order_id);
4663 }
4664
4665 let instruments = AtomicMap::new();
4666 instruments.insert(
4667 Ustr::from("EURUSD-PERP"),
4668 test_perp_instrument("EURUSD-PERP"),
4669 );
4670 let rates = AtomicMap::new();
4671 rates.insert(
4672 Some(Ustr::from("fixture-account")),
4673 MakerTakerFeeRates::new(dec!(0.0002), dec!(0.0025)),
4674 );
4675 let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel();
4676
4677 let mut emitter = ExecutionEventEmitter::new(
4678 clock,
4679 TraderId::from("TESTER-001"),
4680 account_id,
4681 AccountType::Margin,
4682 None,
4683 );
4684 emitter.set_sender(tx);
4685
4686 dispatch_order_event(
4687 event,
4688 &emitter,
4689 &caches,
4690 account_id,
4691 &instruments,
4692 &rates,
4693 clock,
4694 );
4695
4696 let expected_qty = if complete { dec!(100) } else { dec!(50) };
4697
4698 match rx.try_recv().unwrap() {
4699 ExecutionEvent::Order(OrderEventAny::Filled(fill)) => {
4700 assert!(tracked);
4701 assert_eq!(fill.commission, Some(Money::from(expected)));
4702 assert_eq!(fill.client_order_id, client_order_id);
4703 assert_eq!(fill.venue_order_id, venue_order_id);
4704 assert_eq!(fill.trade_id.as_str(), "T-01ARZ3NDEKTSV4RRFFQ69G5FAV");
4705 assert_eq!(fill.last_qty.as_decimal(), expected_qty);
4706 assert_eq!(fill.last_px.as_decimal(), dec!(50000));
4707 assert_eq!(fill.liquidity_side, LiquiditySide::Maker);
4708 }
4709 ExecutionEvent::Report(report) => {
4710 let ExecutionReport::Fill(fill) = report else {
4711 panic!("expected fill report");
4712 };
4713
4714 assert!(!tracked);
4715 assert_eq!(fill.commission, Money::from(expected));
4716 assert_eq!(fill.instrument_id, instrument_id);
4717 assert_eq!(fill.venue_order_id, venue_order_id);
4718 assert_eq!(fill.last_qty.as_decimal(), expected_qty);
4719 assert_eq!(fill.last_px.as_decimal(), dec!(50000));
4720 assert_eq!(fill.liquidity_side, LiquiditySide::Maker);
4721 }
4722 other => panic!("unexpected fill event: {other:?}"),
4723 }
4724
4725 assert!(rx.try_recv().is_err());
4726 assert_eq!(
4727 caches.orders_metadata.len(),
4728 usize::from(tracked && !complete)
4729 );
4730 assert_eq!(
4731 caches.venue_to_client_id.len(),
4732 usize::from(tracked && !complete)
4733 );
4734 }
4735
4736 #[rstest]
4737 #[case::missing_account(Some("unknown"), dec!(100), "AX fill account fee rates are not cached")]
4738 #[case::overflow(None, Decimal::MAX, "AX fill commission calculation overflow")]
4739 fn test_dispatch_fill_fee_error_retains_tracking(
4740 #[case] account: Option<&str>,
4741 #[case] price: Decimal,
4742 #[case] expected: &str,
4743 ) {
4744 let clock = get_atomic_clock_realtime();
4745 let account_id = AccountId::from("AX-001");
4746 let client_order_id = ClientOrderId::from("O-FILL");
4747 let venue_order_id = VenueOrderId::new("OID-FILL");
4748 let caches = test_caches();
4749 caches.orders_metadata.insert(
4750 client_order_id,
4751 test_metadata(client_order_id, InstrumentId::from("BTC-PERP.AX")),
4752 );
4753 caches
4754 .venue_to_client_id
4755 .insert(venue_order_id, client_order_id);
4756 let instruments = AtomicMap::new();
4757 instruments.insert(Ustr::from("BTC-PERP"), test_perp_instrument("BTC-PERP"));
4758 let rates = AtomicMap::new();
4759 rates.insert(None, MakerTakerFeeRates::new(dec!(0.0002), dec!(0.0025)));
4760 let mut order = test_ws_order("OID-FILL", dec!(100), 25);
4761 order.aid = account.map(Ustr::from);
4762 let execution = test_execution("TID-FILL", price, 25, true);
4763 let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel();
4764
4765 let mut emitter = ExecutionEventEmitter::new(
4766 clock,
4767 TraderId::from("TESTER-001"),
4768 account_id,
4769 AccountType::Margin,
4770 None,
4771 );
4772 emitter.set_sender(tx);
4773
4774 let event = AxWsOrderEvent::Filled(AxWsOrderFilled {
4775 ts: 1609459200,
4776 tn: 0,
4777 eid: "E-FILL".to_owned(),
4778 o: order.clone(),
4779 xs: execution.clone(),
4780 });
4781
4782 let error =
4783 calculate_fill_commission(&order, &execution, &instruments, &rates).unwrap_err();
4784 dispatch_order_event(
4785 event,
4786 &emitter,
4787 &caches,
4788 account_id,
4789 &instruments,
4790 &rates,
4791 clock,
4792 );
4793
4794 assert_eq!(error.to_string(), expected);
4795 assert!(rx.try_recv().is_err());
4796 assert_eq!(
4797 caches
4798 .orders_metadata
4799 .get(&client_order_id)
4800 .unwrap()
4801 .client_order_id,
4802 client_order_id
4803 );
4804 assert_eq!(
4805 *caches.venue_to_client_id.get(&venue_order_id).unwrap(),
4806 client_order_id
4807 );
4808 }
4809
4810 #[rstest]
4811 fn test_create_order_canceled_populates_identifiers() {
4812 let caches = test_caches();
4813 let clock = get_atomic_clock_realtime();
4814 let account_id = AccountId::from("AX-001");
4815 let client_order_id = ClientOrderId::from("O-CXL");
4816 let instrument_id = InstrumentId::from("BTC-PERP.AX");
4817 let venue_order_id = VenueOrderId::new("OID-CXL");
4818
4819 caches.orders_metadata.insert(
4820 client_order_id,
4821 test_metadata(client_order_id, instrument_id),
4822 );
4823 caches
4824 .venue_to_client_id
4825 .insert(venue_order_id, client_order_id);
4826
4827 let order = test_ws_order(venue_order_id.as_str(), dec!(100.00), 10);
4828 let event = create_order_canceled(&order, 1609459200, 0, &caches, account_id, clock)
4829 .expect("should produce OrderCanceled");
4830
4831 assert_eq!(event.venue_order_id, Some(venue_order_id));
4832 assert_eq!(event.client_order_id, client_order_id);
4833 assert_eq!(event.account_id, Some(account_id));
4834 assert_eq!(event.instrument_id, instrument_id);
4835 }
4836
4837 #[rstest]
4838 fn test_create_order_expired_populates_identifiers() {
4839 let caches = test_caches();
4840 let clock = get_atomic_clock_realtime();
4841 let account_id = AccountId::from("AX-001");
4842 let client_order_id = ClientOrderId::from("O-EXP");
4843 let instrument_id = InstrumentId::from("BTC-PERP.AX");
4844 let venue_order_id = VenueOrderId::new("OID-EXP");
4845
4846 caches.orders_metadata.insert(
4847 client_order_id,
4848 test_metadata(client_order_id, instrument_id),
4849 );
4850 caches
4851 .venue_to_client_id
4852 .insert(venue_order_id, client_order_id);
4853
4854 let order = test_ws_order(venue_order_id.as_str(), dec!(100.00), 10);
4855 let event = create_order_expired(&order, 1609459200, 0, &caches, account_id, clock)
4856 .expect("should produce OrderExpired");
4857
4858 assert_eq!(event.venue_order_id, Some(venue_order_id));
4859 assert_eq!(event.client_order_id, client_order_id);
4860 }
4861
4862 #[rstest]
4863 #[case(AxTimeInForce::Ioc, true)]
4864 #[case(AxTimeInForce::Fok, true)]
4865 #[case(AxTimeInForce::Day, false)]
4866 #[case(AxTimeInForce::Gtc, false)]
4867 fn test_dispatch_expired_maps_ioc_fok_to_canceled(
4868 #[case] tif: AxTimeInForce,
4869 #[case] expect_canceled: bool,
4870 ) {
4871 let clock = get_atomic_clock_realtime();
4872 let account_id = AccountId::from("AX-001");
4873 let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel();
4874 let mut emitter = ExecutionEventEmitter::new(
4875 clock,
4876 TraderId::from("TESTER-001"),
4877 account_id,
4878 AccountType::Margin,
4879 None,
4880 );
4881 emitter.set_sender(tx);
4882
4883 let caches = test_caches();
4884 let client_order_id = ClientOrderId::from("O-EXP");
4885 let instrument_id = InstrumentId::from("BTC-PERP.AX");
4886 caches.orders_metadata.insert(
4887 client_order_id,
4888 test_metadata(client_order_id, instrument_id),
4889 );
4890 caches
4891 .venue_to_client_id
4892 .insert(VenueOrderId::new("OID-EXP"), client_order_id);
4893
4894 let mut order = test_ws_order("OID-EXP", dec!(100.00), 10);
4895 order.tif = tif;
4896 let event = AxWsOrderEvent::Expired(AxWsOrderExpired {
4897 ts: 1609459200,
4898 tn: 0,
4899 eid: "E-EXP".to_string(),
4900 o: order,
4901 });
4902
4903 let instruments: AtomicMap<Ustr, InstrumentAny> = AtomicMap::new();
4904 dispatch_order_event(
4905 event,
4906 &emitter,
4907 &caches,
4908 account_id,
4909 &instruments,
4910 &AtomicMap::new(),
4911 clock,
4912 );
4913
4914 match rx.try_recv().expect("an order event should be emitted") {
4915 ExecutionEvent::Order(OrderEventAny::Canceled(_)) => assert!(expect_canceled),
4916 ExecutionEvent::Order(OrderEventAny::Expired(_)) => assert!(!expect_canceled),
4917 other => panic!("unexpected event: {other:?}"),
4918 }
4919 }
4920
4921 #[rstest]
4922 fn test_create_order_rejected_sets_due_post_only_when_reason_matches() {
4923 let caches = test_caches();
4924 let clock = get_atomic_clock_realtime();
4925 let account_id = AccountId::from("AX-001");
4926 let client_order_id = ClientOrderId::from("O-REJ");
4927 let instrument_id = InstrumentId::from("BTC-PERP.AX");
4928
4929 caches.orders_metadata.insert(
4930 client_order_id,
4931 test_metadata(client_order_id, instrument_id),
4932 );
4933 caches
4934 .venue_to_client_id
4935 .insert(VenueOrderId::new("OID-REJ"), client_order_id);
4936
4937 let order = test_ws_order("OID-REJ", dec!(100.00), 10);
4938 let reason = "post-only order would cross the book";
4940 let event =
4941 create_order_rejected(&order, reason, 1609459200, 0, &caches, account_id, clock)
4942 .expect("should produce OrderRejected");
4943
4944 assert!(event.due_post_only, "post-only reason should set flag");
4945 assert_eq!(event.reason, Ustr::from(reason));
4946 }
4947
4948 #[rstest]
4949 fn test_create_order_rejected_clears_due_post_only_for_other_reasons() {
4950 let caches = test_caches();
4951 let clock = get_atomic_clock_realtime();
4952 let account_id = AccountId::from("AX-001");
4953 let client_order_id = ClientOrderId::from("O-REJ-2");
4954 let instrument_id = InstrumentId::from("BTC-PERP.AX");
4955
4956 caches.orders_metadata.insert(
4957 client_order_id,
4958 test_metadata(client_order_id, instrument_id),
4959 );
4960 caches
4961 .venue_to_client_id
4962 .insert(VenueOrderId::new("OID-REJ-2"), client_order_id);
4963
4964 let order = test_ws_order("OID-REJ-2", dec!(100.00), 10);
4965 let event = create_order_rejected(
4966 &order,
4967 "INSUFFICIENT_MARGIN",
4968 1609459200,
4969 0,
4970 &caches,
4971 account_id,
4972 clock,
4973 )
4974 .expect("should produce OrderRejected");
4975
4976 assert!(!event.due_post_only);
4977 assert_eq!(event.reason, Ustr::from("INSUFFICIENT_MARGIN"));
4978 }
4979
4980 #[rstest]
4981 fn test_cleanup_terminal_order_tracking_removes_all_caches() {
4982 let caches = test_caches();
4983 let client_order_id = ClientOrderId::from("O-CLEAN");
4984 let instrument_id = InstrumentId::from("BTC-PERP.AX");
4985 let venue_order_id = VenueOrderId::new("OID-CLEAN");
4986 let stale_venue_order_id = VenueOrderId::new("OID-CLEAN-OLD");
4987 let cid_value = 123u64;
4988
4989 caches.orders_metadata.insert(
4990 client_order_id,
4991 test_metadata(client_order_id, instrument_id),
4992 );
4993 caches
4994 .venue_to_client_id
4995 .insert(venue_order_id, client_order_id);
4996 caches
4997 .venue_to_client_id
4998 .insert(stale_venue_order_id, client_order_id);
4999 caches
5000 .cid_to_client_order_id
5001 .insert(cid_value, client_order_id);
5002
5003 let mut order = test_ws_order(venue_order_id.as_str(), dec!(100.00), 10);
5004 order.cid = Some(cid_value);
5005
5006 cleanup_terminal_order_tracking(&order, &caches);
5007
5008 assert!(caches.orders_metadata.is_empty());
5009 assert!(caches.venue_to_client_id.is_empty());
5010 assert!(caches.cid_to_client_order_id.is_empty());
5011 }
5012
5013 #[rstest]
5014 fn test_cleanup_terminal_order_tracking_via_cid_when_venue_missing() {
5015 let caches = test_caches();
5016 let client_order_id = ClientOrderId::from("O-CLEAN-CID");
5017 let instrument_id = InstrumentId::from("BTC-PERP.AX");
5018 let cid_value = 321u64;
5019
5020 caches.orders_metadata.insert(
5021 client_order_id,
5022 test_metadata(client_order_id, instrument_id),
5023 );
5024 caches
5025 .cid_to_client_order_id
5026 .insert(cid_value, client_order_id);
5027
5028 let mut order = test_ws_order("OID-UNKNOWN", dec!(100.00), 10);
5030 order.cid = Some(cid_value);
5031
5032 cleanup_terminal_order_tracking(&order, &caches);
5033
5034 assert!(caches.orders_metadata.is_empty());
5035 assert!(caches.cid_to_client_order_id.is_empty());
5036 }
5037
5038 #[rstest]
5039 fn test_cleanup_terminal_order_tracking_noop_when_unknown() {
5040 let caches = test_caches();
5041 let other = ClientOrderId::from("OTHER");
5042 let instrument_id = InstrumentId::from("BTC-PERP.AX");
5043 caches
5044 .orders_metadata
5045 .insert(other, test_metadata(other, instrument_id));
5046
5047 let order = test_ws_order("OID-NOT-TRACKED", dec!(100.00), 10);
5048 cleanup_terminal_order_tracking(&order, &caches);
5049
5050 assert_eq!(caches.orders_metadata.len(), 1);
5052 }
5053
5054 #[rstest]
5055 fn test_cleanup_terminal_order_tracking_by_client_clears_pending_replacements() {
5056 let caches = test_caches();
5057 let client_order_id = ClientOrderId::from("O-CANCEL-ALL");
5058 let parent = VenueOrderId::from("OID-CANCEL-ALL-PARENT");
5059 let child = VenueOrderId::from("OID-CANCEL-ALL-CHILD");
5060 seed_terminal_tracking(&caches, client_order_id, parent, child, 891);
5061 caches
5062 .pending_modifies
5063 .insert(parent, (client_order_id, 2, false));
5064 caches
5065 .pending_modifies
5066 .insert(child, (client_order_id, 1, true));
5067
5068 cleanup_terminal_order_tracking_ids(&caches, None, None, Some(client_order_id));
5069
5070 assert!(caches.pending_modifies.is_empty());
5071 assert!(caches.orders_metadata.is_empty());
5072 assert!(caches.venue_to_client_id.is_empty());
5073 assert!(caches.cid_to_client_order_id.is_empty());
5074 }
5075
5076 #[rstest]
5077 fn test_cleanup_closed_order_status_report_removes_all_caches() {
5078 let caches = test_caches();
5079 let client_order_id = ClientOrderId::from("O-RECON-FILL");
5080 let venue_order_id = VenueOrderId::new("OID-RECON-FILL");
5081 let stale_venue_order_id = VenueOrderId::new("OID-RECON-FILL-OLD");
5082 let cid_value = client_order_id_to_cid(&client_order_id);
5083
5084 seed_terminal_tracking(
5085 &caches,
5086 client_order_id,
5087 venue_order_id,
5088 stale_venue_order_id,
5089 cid_value,
5090 );
5091
5092 let report = test_status_report(Some(client_order_id), venue_order_id, OrderStatus::Filled);
5093 cleanup_closed_order_status_report(&report, &caches);
5094
5095 assert!(caches.orders_metadata.is_empty());
5096 assert!(caches.venue_to_client_id.is_empty());
5097 assert!(caches.cid_to_client_order_id.is_empty());
5098 }
5099
5100 #[rstest]
5101 fn test_cleanup_closed_order_status_report_via_venue_when_client_id_absent() {
5102 let caches = test_caches();
5103 let client_order_id = ClientOrderId::from("O-RECON-CANCEL");
5104 let venue_order_id = VenueOrderId::new("OID-RECON-CANCEL");
5105 let stale_venue_order_id = VenueOrderId::new("OID-RECON-CANCEL-OLD");
5106 let cid_value = 654u64;
5107
5108 seed_terminal_tracking(
5109 &caches,
5110 client_order_id,
5111 venue_order_id,
5112 stale_venue_order_id,
5113 cid_value,
5114 );
5115
5116 let report = test_status_report(None, venue_order_id, OrderStatus::Canceled);
5117 cleanup_closed_order_status_report(&report, &caches);
5118
5119 assert!(caches.orders_metadata.is_empty());
5120 assert!(caches.venue_to_client_id.is_empty());
5121 assert!(caches.cid_to_client_order_id.is_empty());
5122 }
5123
5124 #[rstest]
5125 fn test_cleanup_closed_order_status_report_prefers_venue_identity() {
5126 let caches = test_caches();
5127 let client_order_id = ClientOrderId::from("O-EXT-RECON");
5128 let venue_order_id = VenueOrderId::new("OID-EXT-RECON");
5129 let stale_venue_order_id = VenueOrderId::new("OID-EXT-RECON-OLD");
5130
5131 caches.orders_metadata.insert(
5132 client_order_id,
5133 test_metadata(client_order_id, InstrumentId::from("BTC-PERP.AX")),
5134 );
5135 caches
5136 .venue_to_client_id
5137 .insert(venue_order_id, client_order_id);
5138 caches
5139 .venue_to_client_id
5140 .insert(stale_venue_order_id, client_order_id);
5141
5142 let report = test_status_report(
5143 Some(cid_to_client_order_id(99)),
5144 venue_order_id,
5145 OrderStatus::Filled,
5146 );
5147 cleanup_closed_order_status_report(&report, &caches);
5148
5149 assert!(caches.orders_metadata.is_empty());
5150 assert!(caches.venue_to_client_id.is_empty());
5151 assert!(caches.cid_to_client_order_id.is_empty());
5152 }
5153
5154 #[rstest]
5155 fn test_cleanup_open_order_status_report_retains_caches() {
5156 let caches = test_caches();
5157 let client_order_id = ClientOrderId::from("O-RECON-OPEN");
5158 let venue_order_id = VenueOrderId::new("OID-RECON-OPEN");
5159 let stale_venue_order_id = VenueOrderId::new("OID-RECON-OPEN-OLD");
5160 let cid_value = client_order_id_to_cid(&client_order_id);
5161
5162 seed_terminal_tracking(
5163 &caches,
5164 client_order_id,
5165 venue_order_id,
5166 stale_venue_order_id,
5167 cid_value,
5168 );
5169
5170 let report =
5171 test_status_report(Some(client_order_id), venue_order_id, OrderStatus::Accepted);
5172 cleanup_closed_order_status_report(&report, &caches);
5173
5174 assert!(caches.orders_metadata.contains_key(&client_order_id));
5175 assert_eq!(
5176 *caches.venue_to_client_id.get(&venue_order_id).unwrap(),
5177 client_order_id
5178 );
5179 assert_eq!(
5180 *caches.cid_to_client_order_id.get(&cid_value).unwrap(),
5181 client_order_id
5182 );
5183 }
5184
5185 fn limit_order_for_validation(quantity: Quantity) -> OrderAny {
5186 OrderTestBuilder::new(OrderType::Limit)
5187 .instrument_id(InstrumentId::from("EURUSD-PERP.AX"))
5188 .side(OrderSide::Buy)
5189 .quantity(quantity)
5190 .price(Price::from("1.10"))
5191 .build()
5192 }
5193
5194 #[rstest]
5195 fn test_self_trade_from_params_parses_wire_alias() {
5196 let params = Params::new([("st".to_string(), serde_json::json!("xb"))].into());
5197
5198 assert_eq!(
5199 self_trade_from_params(Some(¶ms)).unwrap(),
5200 Some(AxSelfTradeBehavior::CancelBoth)
5201 );
5202 }
5203
5204 #[rstest]
5205 fn test_self_trade_from_params_ignores_unknown_keys() {
5206 let params = Params::new(
5207 [
5208 (
5209 "execution_instruction".to_string(),
5210 serde_json::json!("anything"),
5211 ),
5212 ("tag".to_string(), serde_json::json!("ignored")),
5213 ]
5214 .into(),
5215 );
5216
5217 assert_eq!(self_trade_from_params(Some(¶ms)).unwrap(), None);
5218 }
5219
5220 #[rstest]
5221 fn test_self_trade_from_params_rejects_unknown_value() {
5222 let params = Params::new([("st".to_string(), serde_json::json!("cancel"))].into());
5223
5224 let err = self_trade_from_params(Some(¶ms)).unwrap_err();
5225
5226 assert!(
5227 err.to_string()
5228 .starts_with("Unsupported self-trade behavior")
5229 );
5230 }
5231
5232 #[rstest]
5233 fn test_self_trade_from_params_rejects_non_string_value() {
5234 let params = Params::new([("st".to_string(), serde_json::json!(1))].into());
5235
5236 let err = self_trade_from_params(Some(¶ms)).unwrap_err();
5237
5238 assert_eq!(
5239 err.to_string(),
5240 "Invalid self-trade behavior value: expected a string"
5241 );
5242 }
5243
5244 #[rstest]
5245 fn test_validate_order_for_ax_submit_accepts_supported_limit_order() {
5246 let order = limit_order_for_validation(Quantity::from("10"));
5247
5248 assert!(validate_order_for_ax_submit(&order).is_ok());
5249 }
5250
5251 #[rstest]
5252 fn test_validate_order_for_ax_submit_denies_unsupported_order_type() {
5253 let order = OrderTestBuilder::new(OrderType::StopMarket)
5254 .instrument_id(InstrumentId::from("EURUSD-PERP.AX"))
5255 .side(OrderSide::Buy)
5256 .quantity(Quantity::from("10"))
5257 .trigger_price(Price::from("1.10"))
5258 .build();
5259
5260 let err = validate_order_for_ax_submit(&order).unwrap_err();
5261
5262 assert!(err.to_string().contains("Unsupported order type"));
5263 }
5264
5265 #[rstest]
5266 fn test_validate_order_for_ax_submit_denies_gtd_time_in_force() {
5267 let order = OrderTestBuilder::new(OrderType::Limit)
5268 .instrument_id(InstrumentId::from("EURUSD-PERP.AX"))
5269 .side(OrderSide::Buy)
5270 .quantity(Quantity::from("10"))
5271 .price(Price::from("1.10"))
5272 .time_in_force(TimeInForce::Gtd)
5273 .expire_time(UnixNanos::from(2_000_000_000_000_000_000u64))
5274 .build();
5275
5276 let err = validate_order_for_ax_submit(&order).unwrap_err();
5277
5278 assert!(err.to_string().contains("Unsupported time in force"));
5279 }
5280
5281 #[rstest]
5282 fn test_validate_order_for_ax_submit_denies_stop_limit_order() {
5283 let order = OrderTestBuilder::new(OrderType::StopLimit)
5284 .instrument_id(InstrumentId::from("EURUSD-PERP.AX"))
5285 .side(OrderSide::Buy)
5286 .quantity(Quantity::from("10"))
5287 .price(Price::from("1.11"))
5288 .trigger_price(Price::from("1.10"))
5289 .build();
5290
5291 let err = validate_order_for_ax_submit(&order).unwrap_err();
5292
5293 assert!(err.to_string().contains("Unsupported order type"));
5294 }
5295
5296 #[rstest]
5297 fn test_validate_order_for_ax_submit_denies_fok_time_in_force() {
5298 let order = OrderTestBuilder::new(OrderType::Limit)
5299 .instrument_id(InstrumentId::from("EURUSD-PERP.AX"))
5300 .side(OrderSide::Buy)
5301 .quantity(Quantity::from("10"))
5302 .price(Price::from("1.10"))
5303 .time_in_force(TimeInForce::Fok)
5304 .build();
5305
5306 let err = validate_order_for_ax_submit(&order).unwrap_err();
5307
5308 assert!(err.to_string().contains("Unsupported time in force"));
5309 }
5310
5311 #[rstest]
5312 fn test_validate_order_for_ax_submit_denies_fractional_quantity() {
5313 let order = limit_order_for_validation(Quantity::from("10.5"));
5314
5315 let err = validate_order_for_ax_submit(&order).unwrap_err();
5316
5317 assert!(err.to_string().contains("whole contract"));
5318 }
5319
5320 #[rstest]
5321 fn test_validate_order_for_ax_submit_denies_quote_quantity() {
5322 let order = OrderTestBuilder::new(OrderType::Market)
5323 .instrument_id(InstrumentId::from("EURUSD-PERP.AX"))
5324 .side(OrderSide::Buy)
5325 .quantity(Quantity::from("10"))
5326 .time_in_force(TimeInForce::Ioc)
5327 .quote_quantity(true)
5328 .build();
5329
5330 let err = validate_order_for_ax_submit(&order).unwrap_err();
5331
5332 assert_eq!(err.to_string(), "UNSUPPORTED_QUOTE_QUANTITY");
5333 }
5334
5335 #[rstest]
5336 fn test_validate_order_for_ax_submit_denies_display_quantity() {
5337 let order = OrderTestBuilder::new(OrderType::Limit)
5338 .instrument_id(InstrumentId::from("EURUSD-PERP.AX"))
5339 .side(OrderSide::Buy)
5340 .quantity(Quantity::from("10"))
5341 .price(Price::from("1.10"))
5342 .display_qty(Quantity::from("5"))
5343 .build();
5344
5345 let err = validate_order_for_ax_submit(&order).unwrap_err();
5346
5347 assert!(err.to_string().contains("display_qty"));
5348 }
5349
5350 #[rstest]
5351 #[case(AxHttpError::MissingCredentials, true)]
5352 #[case(AxHttpError::MissingSessionToken, true)]
5353 #[case(AxHttpError::ValidationError("bad param".to_string()), true)]
5354 #[case(AxHttpError::BuildError(AxBuildError::MissingOrderId), true)]
5355 #[case(AxHttpError::ApiError { message: "invalid modification".to_string() }, false)]
5356 #[case(AxHttpError::JsonError("parse failure".to_string()), false)]
5357 #[case(AxHttpError::Canceled("shutdown".to_string()), false)]
5358 #[case(AxHttpError::NetworkError("timeout".to_string()), false)]
5359 #[case(AxHttpError::UnexpectedStatus { status: 400, body: "invalid".to_string() }, false)]
5360 #[case(AxHttpError::UnexpectedStatus { status: 503, body: String::new() }, false)]
5361 fn test_classify_ax_http_failure(#[case] error: AxHttpError, #[case] expect_not_sent: bool) {
5362 let expected = if expect_not_sent {
5364 CommandFailure::NotSent(error.to_string())
5365 } else {
5366 CommandFailure::Ambiguous(error.to_string())
5367 };
5368
5369 assert_eq!(classify_ax_http_failure(&error), expected);
5370 }
5371
5372 #[rstest]
5373 #[case(
5374 AxOrdersWsClientError::ClientError("missing venue_order_id".to_string()),
5375 Some("missing venue_order_id")
5376 )]
5377 #[case(AxOrdersWsClientError::ChannelError("handler closed".to_string()), Some("handler closed"))]
5378 #[case(AxOrdersWsClientError::Transport("connection reset".to_string()), None)]
5379 #[case(AxOrdersWsClientError::AuthenticationError("token expired".to_string()), None)]
5380 fn test_classify_ax_ws_failure(
5381 #[case] error: AxOrdersWsClientError,
5382 #[case] not_sent_reason: Option<&str>,
5383 ) {
5384 let expected = match not_sent_reason {
5386 Some(reason) => CommandFailure::NotSent(reason.to_string()),
5387 None => CommandFailure::Ambiguous(error.to_string()),
5388 };
5389
5390 assert_eq!(classify_ax_ws_failure(&error), expected);
5391 }
5392
5393 #[rstest]
5394 #[case(include_str!("../test_data/ws_order_filled_unknown_state.json"))]
5395 #[case(include_str!("../test_data/ws_order_filled_unknown_tif.json"))]
5396 fn test_dispatch_fill_with_unknown_sibling_classification(#[case] raw: &str) {
5397 let event: AxWsOrderEvent = serde_json::from_str(raw).unwrap();
5398 let clock = get_atomic_clock_realtime();
5399 let account_id = AccountId::from("AX-001");
5400 let client_order_id = ClientOrderId::from("O-UNKNOWN-STATE");
5401 let venue_order_id = VenueOrderId::new("O-01ARZ3NDEKTSV4RRFFQ69G5FAV");
5402 let caches = test_caches();
5403 caches.orders_metadata.insert(
5404 client_order_id,
5405 test_metadata(client_order_id, InstrumentId::from("EURUSD-PERP.AX")),
5406 );
5407 caches
5408 .venue_to_client_id
5409 .insert(venue_order_id, client_order_id);
5410 let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel();
5411
5412 let mut emitter = ExecutionEventEmitter::new(
5413 clock,
5414 TraderId::from("TESTER-001"),
5415 account_id,
5416 AccountType::Margin,
5417 None,
5418 );
5419 emitter.set_sender(tx);
5420 let instruments = AtomicMap::new();
5421 instruments.insert(
5422 Ustr::from("EURUSD-PERP"),
5423 test_perp_instrument("EURUSD-PERP"),
5424 );
5425 let account_fee_rates = AtomicMap::new();
5426 account_fee_rates.insert(
5427 Some(Ustr::from("fixture-account")),
5428 MakerTakerFeeRates::new(dec!(0.0002), dec!(0.0025)),
5429 );
5430
5431 dispatch_order_event(
5432 event,
5433 &emitter,
5434 &caches,
5435 account_id,
5436 &instruments,
5437 &account_fee_rates,
5438 clock,
5439 );
5440
5441 let ExecutionEvent::Order(OrderEventAny::Filled(fill)) = rx.try_recv().unwrap() else {
5442 panic!("expected fill")
5443 };
5444
5445 assert_eq!(fill.venue_order_id, venue_order_id);
5446 assert_eq!(fill.client_order_id, client_order_id);
5447 assert_eq!(fill.trade_id.as_str(), "T-01ARZ3NDEKTSV4RRFFQ69G5FAV");
5448 assert_eq!(fill.last_qty.as_decimal(), dec!(100));
5449 assert_eq!(fill.last_px.as_decimal(), dec!(50000));
5450 assert_eq!(fill.ts_event, UnixNanos::from(1609459200123456789));
5451 assert!(rx.try_recv().is_err());
5452 assert!(caches.orders_metadata.is_empty());
5453 assert!(caches.venue_to_client_id.is_empty());
5454 }
5455
5456 #[rstest]
5457 fn test_amendment_keeps_venue_identity_and_updates_quantity() {
5458 let message: crate::websocket::messages::AxWsOrderReplaced =
5459 serde_json::from_str(include_str!("../test_data/ws_order_amended.json")).unwrap();
5460 let venue_order_id = VenueOrderId::new(&message.ro.oid);
5461 let client_order_id = ClientOrderId::from("O-AMEND");
5462 let caches = test_caches();
5463 caches.orders_metadata.insert(
5464 client_order_id,
5465 test_metadata(client_order_id, InstrumentId::from("EURUSD-PERP.AX")),
5466 );
5467 caches
5468 .venue_to_client_id
5469 .insert(venue_order_id, client_order_id);
5470 let clock = get_atomic_clock_realtime();
5471 let account_id = AccountId::from("AX-001");
5472 let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel();
5473
5474 let mut emitter = ExecutionEventEmitter::new(
5475 clock,
5476 TraderId::from("TESTER-001"),
5477 account_id,
5478 AccountType::Margin,
5479 None,
5480 );
5481 emitter.set_sender(tx);
5482 let instruments = AtomicMap::new();
5483
5484 dispatch_order_event(
5485 AxWsOrderEvent::Replaced(message),
5486 &emitter,
5487 &caches,
5488 account_id,
5489 &instruments,
5490 &AtomicMap::new(),
5491 clock,
5492 );
5493
5494 let ExecutionEvent::Order(OrderEventAny::Updated(update)) = rx.try_recv().unwrap() else {
5495 panic!("expected update")
5496 };
5497
5498 assert_eq!(update.venue_order_id, Some(venue_order_id));
5499 assert_eq!(update.client_order_id, client_order_id);
5500 assert_eq!(update.quantity.as_decimal(), dec!(150));
5501 assert_eq!(
5502 *caches.venue_to_client_id.get(&venue_order_id).unwrap(),
5503 client_order_id
5504 );
5505 assert_eq!(caches.venue_to_client_id.len(), 1);
5506 assert!(rx.try_recv().is_err());
5507 }
5508
5509 #[rstest]
5510 #[case(true, false)]
5511 #[case(false, true)]
5512 #[case(true, true)]
5513 fn test_replacement_rejects_inconsistent_identity(
5514 #[case] has_id: bool,
5515 #[case] has_order: bool,
5516 ) {
5517 let mut message: crate::websocket::messages::AxWsOrderReplaced =
5518 serde_json::from_str(include_str!("../test_data/ws_order_replaced_live.json")).unwrap();
5519 message.noid = has_id.then(|| "MISMATCHED".to_owned());
5520
5521 if !has_order {
5522 message.no = None;
5523 }
5524
5525 assert_eq!(
5526 replacement_venue_order_id(&message)
5527 .unwrap_err()
5528 .to_string(),
5529 "Inconsistent AX replacement order identity"
5530 );
5531 }
5532
5533 #[rstest]
5534 #[case::known(
5535 AxCancelRejectionReason::OrderNotFound,
5536 Some("ignored"),
5537 "ORDER_NOT_FOUND",
5538 false
5539 )]
5540 #[case::unknown(
5541 AxCancelRejectionReason::Unknown,
5542 Some("cancel denied by venue"),
5543 "cancel denied by venue",
5544 false
5545 )]
5546 #[case::empty(AxCancelRejectionReason::Unknown, Some(" "), "UNKNOWN", false)]
5547 #[case::post_only(
5548 AxCancelRejectionReason::Unknown,
5549 Some("post-only order would cross the book"),
5550 "post-only order would cross the book",
5551 true
5552 )]
5553 fn test_pending_modify_does_not_misclassify_cancel_rejection(
5554 #[case] reason: AxCancelRejectionReason,
5555 #[case] text: Option<&str>,
5556 #[case] expected_reason: &str,
5557 #[case] modify: bool,
5558 ) {
5559 let mut event: AxWsOrderEvent =
5560 serde_json::from_str(include_str!("../test_data/ws_cancel_rejected.json")).unwrap();
5561
5562 let AxWsOrderEvent::CancelRejected(msg) = &mut event else {
5563 unreachable!()
5564 };
5565
5566 msg.r = reason;
5567 msg.txt = text.map(str::to_owned);
5568 let venue_order_id = VenueOrderId::from(msg.oid.as_str());
5569 let client_order_id = ClientOrderId::from("O-PENDING-MODIFY");
5570 let caches = test_caches();
5571 let mut metadata = test_metadata(client_order_id, InstrumentId::from("EURUSD-PERP.AX"));
5572 metadata.venue_order_id = Some(venue_order_id);
5573 caches.orders_metadata.insert(client_order_id, metadata);
5574 caches
5575 .venue_to_client_id
5576 .insert(venue_order_id, client_order_id);
5577 caches
5578 .pending_modifies
5579 .insert(venue_order_id, (client_order_id, 1, false));
5580 let clock = get_atomic_clock_realtime();
5581 let account_id = AccountId::from("AX-001");
5582 let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel();
5583
5584 let mut emitter = ExecutionEventEmitter::new(
5585 clock,
5586 TraderId::from("TRADER-001"),
5587 account_id,
5588 AccountType::Margin,
5589 None,
5590 );
5591 emitter.set_sender(tx);
5592 dispatch_order_event(
5593 event,
5594 &emitter,
5595 &caches,
5596 account_id,
5597 &AtomicMap::new(),
5598 &AtomicMap::new(),
5599 clock,
5600 );
5601
5602 let ExecutionEvent::Order(event) = rx.try_recv().unwrap() else {
5603 panic!("expected order event")
5604 };
5605
5606 let actual_reason = match &event {
5607 OrderEventAny::ModifyRejected(rejected) if modify => rejected.reason,
5608 OrderEventAny::CancelRejected(rejected) if !modify => rejected.reason,
5609 _ => panic!("unexpected event {event:?}"),
5610 };
5611
5612 assert_eq!(actual_reason.as_str(), expected_reason);
5613 assert_eq!(event.client_order_id(), client_order_id);
5614 assert_eq!(event.venue_order_id(), Some(venue_order_id));
5615 assert_eq!(
5616 caches.pending_modifies.contains_key(&venue_order_id),
5617 !modify
5618 );
5619 assert!(rx.try_recv().is_err());
5620 }
5621
5622 #[rstest]
5623 fn test_pending_modify_completes_deferred_terminal_cleanup() {
5624 let caches = test_caches();
5625 let venue_order_id = VenueOrderId::from("OID-DEFERRED");
5626 let client_order_id = ClientOrderId::from("O-DEFERRED");
5627 let mut metadata = test_metadata(client_order_id, InstrumentId::from("EURUSD-PERP.AX"));
5628 metadata.venue_order_id = Some(venue_order_id);
5629 caches.orders_metadata.insert(client_order_id, metadata);
5630 caches
5631 .venue_to_client_id
5632 .insert(venue_order_id, client_order_id);
5633 caches.cid_to_client_order_id.insert(765, client_order_id);
5634 caches
5635 .pending_modifies
5636 .insert(venue_order_id, (client_order_id, 2, false));
5637 cleanup_terminal_order_tracking_ids(&caches, Some(&venue_order_id), Some(765), None);
5638 complete_pending_modify(&caches, venue_order_id);
5639 assert_eq!(
5640 *caches.pending_modifies.get(&venue_order_id).unwrap(),
5641 (client_order_id, 1, true)
5642 );
5643 assert_eq!(caches.orders_metadata.len(), 1);
5644 complete_pending_modify(&caches, venue_order_id);
5645 assert!(caches.pending_modifies.is_empty());
5646 assert!(caches.orders_metadata.is_empty());
5647 assert!(caches.venue_to_client_id.is_empty());
5648 assert!(caches.cid_to_client_order_id.is_empty());
5649 }
5650
5651 #[rstest]
5652 #[case::without_stream_terminal(false, false)]
5653 #[case::after_stream_terminal(true, false)]
5654 #[case::resolved_terminal(false, true)]
5655 #[case::resolved_after_stream_terminal(true, true)]
5656 fn test_closed_parent_report_retains_pending_replacement(
5657 #[case] terminal: bool,
5658 #[case] resolved: bool,
5659 ) {
5660 let caches = test_caches();
5661 let venue_order_id = VenueOrderId::from("OID-AMBIGUOUS");
5662 let client_order_id = ClientOrderId::from("O-AMBIGUOUS");
5663 let old_venue_order_id = VenueOrderId::from("OID-AMBIGUOUS-OLD");
5664 seed_terminal_tracking(
5665 &caches,
5666 client_order_id,
5667 venue_order_id,
5668 old_venue_order_id,
5669 987,
5670 );
5671 caches
5672 .orders_metadata
5673 .get_mut(&client_order_id)
5674 .unwrap()
5675 .venue_order_id = Some(venue_order_id);
5676 caches
5677 .pending_modifies
5678 .insert(venue_order_id, (client_order_id, 1, terminal));
5679 let report =
5680 test_status_report(Some(client_order_id), venue_order_id, OrderStatus::Canceled);
5681
5682 if resolved {
5683 cleanup_resolved_order_status_report(&report, &caches);
5684 } else {
5685 cleanup_closed_order_status_report(&report, &caches);
5686 }
5687
5688 let terminal = terminal || resolved;
5689 assert_eq!(
5690 *caches.pending_modifies.get(&venue_order_id).unwrap(),
5691 (client_order_id, 1, terminal)
5692 );
5693 assert_eq!(
5694 caches
5695 .orders_metadata
5696 .get(&client_order_id)
5697 .unwrap()
5698 .venue_order_id,
5699 Some(venue_order_id)
5700 );
5701 assert_eq!(
5702 *caches.venue_to_client_id.get(&venue_order_id).unwrap(),
5703 client_order_id
5704 );
5705 assert_eq!(
5706 *caches.cid_to_client_order_id.get(&987).unwrap(),
5707 client_order_id
5708 );
5709 cleanup_deferred_order_tracking(&caches);
5710 assert_eq!(
5711 caches.orders_metadata.contains_key(&client_order_id),
5712 !terminal
5713 );
5714 assert_eq!(
5715 caches.pending_modifies.contains_key(&venue_order_id),
5716 !terminal
5717 );
5718 assert_eq!(
5719 caches.venue_to_client_id.contains_key(&venue_order_id),
5720 !terminal
5721 );
5722 assert_eq!(caches.cid_to_client_order_id.contains_key(&987), !terminal);
5723 }
5724
5725 #[rstest]
5726 #[case::terminal(true, false)]
5727 #[case::working(false, false)]
5728 #[case::replaced(true, true)]
5729 fn test_cleanup_deferred_order_tracking_preserves_working_legs(
5730 #[case] terminal: bool,
5731 #[case] replaced: bool,
5732 ) {
5733 let caches = test_caches();
5734 let parent = VenueOrderId::from("OID-TEARDOWN-PARENT");
5735 let child = VenueOrderId::from("OID-TEARDOWN-CHILD");
5736 let client_order_id = ClientOrderId::from("O-TEARDOWN");
5737
5738 let active = if replaced { child } else { parent };
5739 let mut metadata = test_metadata(client_order_id, InstrumentId::from("EURUSD-PERP.AX"));
5740 metadata.venue_order_id = Some(active);
5741 caches.orders_metadata.insert(client_order_id, metadata);
5742 caches.venue_to_client_id.insert(active, client_order_id);
5743 caches.cid_to_client_order_id.insert(678, client_order_id);
5744 caches
5745 .pending_modifies
5746 .insert(parent, (client_order_id, 1, terminal));
5747 if !terminal {
5748 record_replacement_proposal(&caches, client_order_id, parent, child);
5749 }
5750
5751 cleanup_deferred_order_tracking(&caches);
5752 let cleared = terminal && !replaced;
5753 assert_eq!(caches.pending_modifies.contains_key(&parent), !cleared);
5754
5755 if !cleared {
5756 assert_eq!(
5757 *caches.pending_modifies.get(&parent).unwrap(),
5758 (client_order_id, 1, terminal)
5759 );
5760 }
5761
5762 if cleared {
5763 assert!(caches.orders_metadata.is_empty());
5764 assert!(caches.venue_to_client_id.is_empty());
5765 assert!(caches.cid_to_client_order_id.is_empty());
5766 } else {
5767 assert_eq!(
5768 caches
5769 .orders_metadata
5770 .get(&client_order_id)
5771 .unwrap()
5772 .venue_order_id,
5773 Some(active)
5774 );
5775 assert_eq!(
5776 *caches.venue_to_client_id.get(&active).unwrap(),
5777 client_order_id
5778 );
5779 assert_eq!(
5780 *caches.cid_to_client_order_id.get(&678).unwrap(),
5781 client_order_id
5782 );
5783 assert_eq!(caches.orders_metadata.len(), 1);
5784 assert_eq!(
5785 caches.venue_to_client_id.len(),
5786 if terminal { 1 } else { 2 }
5787 );
5788
5789 if !terminal {
5790 assert_eq!(
5791 *caches.venue_to_client_id.get(&child).unwrap(),
5792 client_order_id
5793 );
5794 }
5795
5796 assert_eq!(caches.cid_to_client_order_id.len(), 1);
5797 }
5798 }
5799
5800 #[rstest]
5801 #[case::child(true, false)]
5802 #[case::child_after_reconnect(true, true)]
5803 #[case::parent(false, false)]
5804 #[case::parent_after_reconnect(false, true)]
5805 fn test_fill_confirms_child_without_regressing_parent(
5806 #[case] child_fill: bool,
5807 #[case] reconnect: bool,
5808 ) {
5809 let mut event: AxWsOrderEvent =
5810 serde_json::from_str(include_str!("../test_data/ws_order_partially_filled.json"))
5811 .unwrap();
5812
5813 let AxWsOrderEvent::PartiallyFilled(msg) = &mut event else {
5814 unreachable!()
5815 };
5816
5817 let parent = VenueOrderId::from(msg.o.oid.as_str());
5818 let child = VenueOrderId::from("OID-FILLED-CHILD");
5819 let client_order_id = ClientOrderId::from("O-FILL-CONFIRMATION");
5820 let instrument_id = InstrumentId::from("EURUSD-PERP.AX");
5821 let caches = test_caches();
5822 let mut metadata = test_metadata(client_order_id, instrument_id);
5823 metadata.venue_order_id = Some(parent);
5824 caches.orders_metadata.insert(client_order_id, metadata);
5825 caches.venue_to_client_id.insert(parent, client_order_id);
5826 caches
5827 .pending_modifies
5828 .insert(parent, (client_order_id, 1, false));
5829 record_replacement_proposal(&caches, client_order_id, parent, child);
5830 if child_fill {
5831 msg.o.oid = child.to_string();
5832 } else {
5833 assert!(record_replacement_venue_id(
5834 &caches,
5835 client_order_id,
5836 parent,
5837 child,
5838 false
5839 ));
5840 caches
5841 .pending_modifies
5842 .insert(child, (client_order_id, 1, false));
5843 }
5844
5845 if reconnect {
5846 cleanup_deferred_order_tracking(&caches);
5847 }
5848
5849 let instruments = AtomicMap::new();
5850 instruments.insert(
5851 Ustr::from("EURUSD-PERP"),
5852 test_perp_instrument("EURUSD-PERP"),
5853 );
5854 let rates = AtomicMap::new();
5855 rates.insert(
5856 Some(Ustr::from("fixture-account")),
5857 MakerTakerFeeRates::new(dec!(0.0002), dec!(0.0025)),
5858 );
5859 let clock = get_atomic_clock_realtime();
5860 let account_id = AccountId::from("AX-001");
5861 let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel();
5862
5863 let mut emitter = ExecutionEventEmitter::new(
5864 clock,
5865 TraderId::from("TRADER-001"),
5866 account_id,
5867 AccountType::Margin,
5868 None,
5869 );
5870 emitter.set_sender(tx);
5871 dispatch_order_event(
5872 event,
5873 &emitter,
5874 &caches,
5875 account_id,
5876 &instruments,
5877 &rates,
5878 clock,
5879 );
5880
5881 let ExecutionEvent::Order(OrderEventAny::Filled(fill)) = rx.try_recv().unwrap() else {
5882 panic!("expected correlated fill")
5883 };
5884
5885 assert_eq!(fill.client_order_id, client_order_id);
5886 assert_eq!(fill.account_id, account_id);
5887 assert_eq!(fill.instrument_id, instrument_id);
5888 assert_eq!(fill.venue_order_id, if child_fill { child } else { parent });
5889 assert_eq!(fill.last_qty, Quantity::from("50"));
5890 assert_eq!(fill.last_px, Price::from("50000"));
5891 assert_eq!(
5892 caches
5893 .orders_metadata
5894 .get(&client_order_id)
5895 .unwrap()
5896 .venue_order_id,
5897 Some(child)
5898 );
5899 assert_eq!(
5900 *caches.venue_to_client_id.get(&child).unwrap(),
5901 client_order_id
5902 );
5903 assert_eq!(
5904 *caches.pending_modifies.get(&parent).unwrap(),
5905 (client_order_id, 1, false)
5906 );
5907 assert!(rx.try_recv().is_err());
5908 }
5909}
5910
5911#[cfg(test)]
5912#[path = "execution/tests.rs"]
5913mod integration_tests;