Skip to main content

nautilus_architect_ax/
execution.rs

1// -------------------------------------------------------------------------------------------------
2//  Copyright (C) 2015-2026 Nautech Systems Pty Ltd. All rights reserved.
3//  https://nautechsystems.io
4//
5//  Licensed under the GNU Lesser General Public License Version 3.0 (the "License");
6//  You may not use this file except in compliance with the License.
7//  You may obtain a copy of the License at https://www.gnu.org/licenses/lgpl-3.0.en.html
8//
9//  Unless required by applicable law or agreed to in writing, software
10//  distributed under the License is distributed on an "AS IS" BASIS,
11//  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12//  See the License for the specific language governing permissions and
13//  limitations under the License.
14// -------------------------------------------------------------------------------------------------
15
16//! Live execution client implementation for the AX Exchange adapter.
17
18use 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/// Live execution client for the AX Exchange.
110#[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    /// Creates a new [`AxExecutionClient`].
126    ///
127    /// # Errors
128    ///
129    /// Returns an error if the client fails to initialize.
130    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            // AX emulates market orders with preview-priced IOC limits, so book moves
326            // between preview and submission can produce partial fills.
327            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                    // AX classifies no send failure as a venue rejection (see
416                    // `classify_ax_ws_failure`); both terminal-valid classes reject the same way.
417                    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    /// Polls the cache until the account is registered or timeout is reached.
572    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        // Reset so requests work after a previous disconnect
653        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        // Read immutable order fields from cache before spawning
844        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                // No replace failure is an unambiguous rejection (see
1125                // `classify_ax_http_failure`); leave the order pending.
1126                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            // AX cancel-all has no side parameter, so select matching open
1175            // orders and cancel their explicit IDs through the batch path.
1176            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        // Snapshot open orders so we can emit cancel events after the HTTP request
1224        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                    // AX does not push WS cancel confirmations for HTTP-initiated
1241                    // cancels, so emit OrderCanceled events locally and clean up
1242                    // tracking state to prevent duplicates if WS events arrive
1243                    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                // A whole-request failure has no per-order venue results and
1270                // must not fan out per-order rejections.
1271                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        // Floor the declared window at the /fills span cap so it does not overstate coverage
1433        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        // AX rejects zero-width fill windows, including a zero-minute lookback
1437        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, // open_only
1449            None,  // instrument_id
1450            start,
1451            None, // end
1452            None, // params
1453            None, // correlation_id
1454        );
1455
1456        let mut fill_cmd = GenerateFillReports::new(
1457            UUID4::new(),
1458            ts_now,
1459            None, // instrument_id
1460            None, // venue_order_id
1461            declared_start,
1462            Some(ts_now), // end
1463            None,         // params
1464            None,         // correlation_id
1465        );
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, // instrument_id
1473            start,
1474            None, // end
1475            None, // params
1476            None, // correlation_id
1477        );
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        // Declare the window so these fills are bounded history, not live fills
1526        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        // The successful complete AX positions snapshot establishes absent instruments as flat
1650        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
1887/// Dispatches a WebSocket message using the event emitter.
1888fn 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            // AX reports an unfilled IOC/FOK as EXPIRED; Nautilus models those as canceled
2115            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    // Keep notional in Decimal so sub-cent rounding happens only after applying the rate
2414    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, // trigger_price
2628        None, // protection_price
2629        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    // A terminal parent can precede the replacement result on the stream
2841    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    // AX accepts only GTC, IOC, and DAY; deny others locally to avoid an opaque venue error
3228    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
3277// Maps the optional strategy `st` order param onto the venue's self-trade behavior.
3278// Unknown keys are ignored; an invalid value is denied by the caller before submission.
3279fn 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
3291// The AX HTTP API documents only a bare 400 with no error schema, so no venue
3292// failure can be allowlisted as an unambiguous rejection; those arrive via the
3293// orders WS `Rejected` and `CancelRejected` events instead. AX therefore never
3294// classifies a send failure as `CommandFailure::VenueRejected`.
3295fn 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        // Rejection wakes the receiver before the submission task finishes cleanup
3514        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(&current).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        // Side effects on caches
3941        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        // Use the literal venue reason text so this guards the AX_POST_ONLY_REJECT constant
4941        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        // Venue id missing from cache
5031        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        // Unrelated metadata still present
5053        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(&params)).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(&params)).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(&params)).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(&params)).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        // Asserting the exact variant also pins that AX never classifies a venue rejection
5365        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        // Asserting the exact variant also pins that AX never classifies a venue rejection
5387        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;