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