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