Skip to main content

nautilus_model/orders/
mod.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//! Order types for the trading domain model.
17//!
18//! Each order type wraps an [`OrderCore`] carrying the state common to all of them and adds its
19//! own type-specific fields. [`OrderAny`] dispatches over the concrete types.
20//!
21//! Orders are event sourced. [`OrderCore::apply`] validates the status transition, runs the
22//! handler for that event, then appends it, so [`OrderAny::from_events`] replays a stream to
23//! reconstruct its event-derived state.
24//!
25//! A fill-void correction rebuilds the derived fill state from the fills that survive it.
26//! `avg_px` retains the chronological `Decimal` notional and quantity fold between fills and
27//! keeps the quotient at that precision. Corrections rebuild the fold rather than subtracting
28//! from saturated or rounded totals. Deserialized orders rebuild the cached fold from stored
29//! events on the next fill. `slippage` derives from `avg_px` in the same arithmetic.
30//! A later fill with the same `trade_id` and a new price restates the price that trade
31//! contributes to `avg_px`. The original fill's `last_px` stays so a void still matches it,
32//! and quantity and status stay unchanged. Repeating the latest price for that trade ID
33//! returns [`OrderError::DuplicateFill`]. A return to an earlier price restates the average.
34
35pub mod any;
36pub mod limit;
37pub mod limit_if_touched;
38pub mod list;
39pub mod market;
40pub mod market_if_touched;
41pub mod market_to_limit;
42pub mod stop_limit;
43pub mod stop_market;
44pub mod trailing_stop_limit;
45pub mod trailing_stop_market;
46
47#[cfg(any(test, feature = "test-support"))]
48pub mod builder;
49
50#[cfg(any(test, feature = "test-support"))]
51pub mod stubs;
52
53// Re-exports
54use ahash::{AHashMap, AHashSet};
55use enum_dispatch::enum_dispatch;
56use indexmap::IndexMap;
57use nautilus_core::{
58    UUID4, UnixNanos,
59    correctness::{CorrectnessError, check_predicate_false},
60};
61use rust_decimal::Decimal;
62use serde::{Deserialize, Serialize};
63use ustr::Ustr;
64
65#[cfg(any(test, feature = "test-support"))]
66pub use crate::orders::builder::OrderTestBuilder;
67pub use crate::orders::{
68    any::{LimitOrderAny, OrderAny, OrderReplayError, PassiveOrderAny, StopOrderAny},
69    limit::LimitOrder,
70    limit_if_touched::LimitIfTouchedOrder,
71    list::{OrderList, OrderListValidationError},
72    market::MarketOrder,
73    market_if_touched::MarketIfTouchedOrder,
74    market_to_limit::MarketToLimitOrder,
75    stop_limit::StopLimitOrder,
76    stop_market::StopMarketOrder,
77    trailing_stop_limit::TrailingStopLimitOrder,
78    trailing_stop_market::TrailingStopMarketOrder,
79};
80use crate::{
81    enums::{
82        ContingencyType, LiquiditySide, OrderSide, OrderStatus, OrderType, PositionSide,
83        TimeInForce, TrailingOffsetType, TriggerType,
84    },
85    events::{
86        OrderAccepted, OrderCancelRejected, OrderCanceled, OrderDenied, OrderEmulated,
87        OrderEventAny, OrderExpired, OrderFillVoided, OrderFilled, OrderInitialized,
88        OrderModifyRejected, OrderPendingCancel, OrderPendingUpdate, OrderRejected, OrderReleased,
89        OrderSubmitted, OrderTriggered, OrderUpdated,
90    },
91    identifiers::{
92        AccountId, ClientOrderId, ExecAlgorithmId, InstrumentId, OrderListId, PositionId,
93        StrategyId, Symbol, TradeId, TraderId, Venue, VenueOrderId,
94    },
95    orderbook::OwnBookOrder,
96    reports::OrderStatusReport,
97    types::{Currency, Money, Price, Quantity},
98};
99
100/// Tags market orders the engine creates from standalone fill reports.
101///
102/// See [`OrderAny::is_fill_report_order`] for the classification requirements.
103pub const FILL_REPORT_ORDER_TAG: &str = "FILL_REPORT";
104
105/// Order types that have stop/trigger prices.
106pub const STOP_ORDER_TYPES: &[OrderType] = &[
107    OrderType::StopMarket,
108    OrderType::StopLimit,
109    OrderType::MarketIfTouched,
110    OrderType::LimitIfTouched,
111];
112
113/// Order types that have limit prices.
114pub const LIMIT_ORDER_TYPES: &[OrderType] = &[
115    OrderType::Limit,
116    OrderType::StopLimit,
117    OrderType::LimitIfTouched,
118    OrderType::TrailingStopLimit,
119];
120
121/// Order types that support the TRIGGERED order status.
122///
123/// Market-style stops (`StopMarket`, `MarketIfTouched`, `TrailingStopMarket`) execute
124/// immediately on trigger and have no intermediate TRIGGERED state.
125pub const TRIGGERABLE_ORDER_TYPES: &[OrderType] = &[
126    OrderType::StopLimit,
127    OrderType::TrailingStopLimit,
128    OrderType::LimitIfTouched,
129];
130
131/// Order statuses for locally active orders (pre-submission to venue).
132pub const LOCAL_ACTIVE_ORDER_STATUSES: &[OrderStatus] = &[
133    OrderStatus::Initialized,
134    OrderStatus::Emulated,
135    OrderStatus::Released,
136];
137
138// Shorter histories are scanned, which costs less than hashing each trade ID
139const FILL_INDEX_MIN_EVENTS: usize = 16;
140
141#[derive(thiserror::Error, Debug)]
142pub enum OrderError {
143    #[error("Order not found: {0}")]
144    NotFound(ClientOrderId),
145    #[error("Order invariant failed: must have a side for this operation")]
146    NoOrderSide,
147    #[error("Invalid event for order type")]
148    InvalidOrderEvent,
149    #[error("Invalid order state transition")]
150    InvalidStateTransition,
151    #[error("Order was already initialized")]
152    AlreadyInitialized,
153    #[error("Order had no previous state")]
154    NoPreviousState,
155    #[error("Duplicate fill: trade_id {0} already applied to order")]
156    DuplicateFill(TradeId),
157    #[error("Duplicate fill void: trade_id {0} already has this cumulative correction")]
158    DuplicateFillVoid(TradeId),
159    #[error("Fill void for trade_id {0} is older than the applied correction")]
160    StaleFillVoid(TradeId),
161    #[error("Fill void quantity exceeds the original fill for trade_id {0}")]
162    OverVoid(TradeId),
163    #[error("Fill void commission is missing or conflicts with trade_id {0}")]
164    InvalidFillVoidCommission(TradeId),
165    #[error("{0}")]
166    Invariant(#[from] CorrectnessError),
167}
168
169/// Converts an `IndexMap` with `Ustr` keys and values to `String` keys and values.
170#[must_use]
171pub fn ustr_indexmap_to_str(h: IndexMap<Ustr, Ustr>) -> IndexMap<String, String> {
172    h.into_iter()
173        .map(|(k, v)| (k.to_string(), v.to_string()))
174        .collect()
175}
176
177/// Converts an `IndexMap` with `String` keys and values to `Ustr` keys and values.
178#[must_use]
179pub fn str_indexmap_to_ustr(h: IndexMap<String, String>) -> IndexMap<Ustr, Ustr> {
180    h.into_iter()
181        .map(|(k, v)| (Ustr::from(&k), Ustr::from(&v)))
182        .collect()
183}
184
185#[inline]
186pub(crate) fn check_display_qty(
187    display_qty: Option<Quantity>,
188    quantity: Quantity,
189) -> Result<(), OrderError> {
190    if let Some(q) = display_qty {
191        check_predicate_false(q > quantity, "`display_qty` may not exceed `quantity`")?;
192    }
193    Ok(())
194}
195
196#[inline]
197pub(crate) fn check_time_in_force(
198    time_in_force: TimeInForce,
199    expire_time: Option<UnixNanos>,
200) -> Result<(), OrderError> {
201    check_predicate_false(
202        time_in_force == TimeInForce::Gtd && expire_time.unwrap_or_default() == 0,
203        "`expire_time` is required for `GTD` order",
204    )?;
205    Ok(())
206}
207
208impl OrderStatus {
209    /// Transitions the order state machine based on the given `event`.
210    ///
211    /// # Errors
212    ///
213    /// Returns an error if the state transition is invalid from the current status.
214    #[rustfmt::skip]
215    pub fn transition(&mut self, event: &OrderEventAny) -> Result<Self, OrderError> {
216        let new_state = match (self, event) {
217            (status, OrderEventAny::ModifyDenied(_) | OrderEventAny::CancelDenied(_)) => *status,
218            (Self::Initialized, OrderEventAny::Denied(_)) => Self::Denied,
219            (Self::Initialized, OrderEventAny::Emulated(_)) => Self::Emulated,  // Emulated orders
220            (Self::Initialized, OrderEventAny::Released(_)) => Self::Released,  // Emulated orders
221            (Self::Initialized, OrderEventAny::Submitted(_)) => Self::Submitted,
222            (Self::Initialized, OrderEventAny::Rejected(_)) => Self::Rejected,  // External orders
223            (Self::Initialized, OrderEventAny::Accepted(_)) => Self::Accepted,  // External orders
224            (Self::Initialized, OrderEventAny::Canceled(_)) => Self::Canceled,  // External orders
225            (Self::Initialized, OrderEventAny::Expired(_)) => Self::Expired,  // External orders
226            (Self::Initialized, OrderEventAny::Triggered(_)) => Self::Triggered, // External orders
227            (Self::Initialized, OrderEventAny::Updated(_)) => Self::Initialized, // In-place modification
228            (Self::Emulated, OrderEventAny::Canceled(_)) => Self::Canceled,  // Emulated orders
229            (Self::Emulated, OrderEventAny::Expired(_)) => Self::Expired,  // Emulated orders
230            (Self::Emulated, OrderEventAny::Updated(_)) => Self::Emulated, // In-place modification
231            (Self::Emulated, OrderEventAny::Released(_)) => Self::Released,  // Emulated orders
232            (Self::Released, OrderEventAny::Submitted(_)) => Self::Submitted,  // Emulated orders
233            (Self::Released, OrderEventAny::Denied(_)) => Self::Denied,  // Emulated orders
234            (Self::Released, OrderEventAny::Canceled(_)) => Self::Canceled,  // Execution algo
235            (Self::Released, OrderEventAny::Updated(_)) => Self::Released, // In-place modification
236            (Self::Submitted, OrderEventAny::PendingUpdate(_)) => Self::PendingUpdate,
237            (Self::Submitted, OrderEventAny::PendingCancel(_)) => Self::PendingCancel,
238            (Self::Submitted, OrderEventAny::ModifyRejected(_)) => Self::Submitted,
239            (Self::Submitted, OrderEventAny::CancelRejected(_)) => Self::Submitted,  // Cancel can fail before submission is acknowledged
240            (Self::Submitted, OrderEventAny::Rejected(_)) => Self::Rejected,
241            (Self::Submitted, OrderEventAny::Canceled(_)) => Self::Canceled,  // FOK and IOC cases
242            (Self::Submitted, OrderEventAny::Accepted(_)) => Self::Accepted,
243            (Self::Submitted, OrderEventAny::Updated(_)) => Self::Submitted,
244            (Self::Submitted, OrderEventAny::Filled(_)) => Self::Filled,
245            (Self::Accepted, OrderEventAny::Rejected(_)) => Self::Rejected,  // StopLimit order
246            (Self::Accepted, OrderEventAny::PendingUpdate(_)) => Self::PendingUpdate,
247            (Self::Accepted, OrderEventAny::PendingCancel(_)) => Self::PendingCancel,
248            (Self::Accepted, OrderEventAny::ModifyRejected(_)) => Self::Accepted,
249            (Self::Accepted, OrderEventAny::CancelRejected(_)) => Self::Accepted,  // Acceptance can overtake a cancel rejection
250            (Self::Accepted, OrderEventAny::Canceled(_)) => Self::Canceled,
251            (Self::Accepted, OrderEventAny::Triggered(_)) => Self::Triggered,
252            (Self::Accepted, OrderEventAny::Updated(_)) => Self::Accepted,  // Updates should preserve state
253            (Self::Accepted, OrderEventAny::Expired(_)) => Self::Expired,
254            (Self::Accepted, OrderEventAny::Filled(_)) => Self::Filled,
255            (Self::Accepted, OrderEventAny::FillVoided(_)) => Self::Accepted,
256            (Self::Canceled, OrderEventAny::Filled(_)) => Self::Filled,  // Real world possibility
257            (Self::Canceled, OrderEventAny::FillVoided(_)) => Self::Canceled,
258            (Self::Canceled, OrderEventAny::Updated(_)) => Self::Canceled,
259            (Self::PendingUpdate, OrderEventAny::Rejected(_)) => Self::Rejected,
260            (Self::PendingUpdate, OrderEventAny::Accepted(_)) => Self::Accepted,
261            (Self::PendingUpdate, OrderEventAny::Canceled(_)) => Self::Canceled,
262            (Self::PendingUpdate, OrderEventAny::Expired(_)) => Self::Expired,
263            (Self::PendingUpdate, OrderEventAny::Triggered(_)) => Self::Triggered,
264            (Self::PendingUpdate, OrderEventAny::Submitted(_)) => Self::PendingUpdate,  // Real world possibility
265            (Self::PendingUpdate, OrderEventAny::PendingUpdate(_)) => Self::PendingUpdate,  // Allow multiple requests
266            (Self::PendingUpdate, OrderEventAny::PendingCancel(_)) => Self::PendingCancel,
267            (Self::PendingUpdate, OrderEventAny::CancelRejected(_)) => Self::PendingUpdate,  // Preserve in-flight modification
268            (Self::PendingUpdate, OrderEventAny::ModifyRejected(_)) => Self::PendingUpdate,  // Handled by modify_rejected to restore previous_status
269            (Self::PendingUpdate, OrderEventAny::Updated(_)) => Self::PendingUpdate,  // Handled by updated to restore previous_status
270            (Self::PendingUpdate, OrderEventAny::Filled(_)) => Self::Filled,
271            (Self::PendingUpdate, OrderEventAny::FillVoided(_)) => Self::PendingUpdate,
272            (Self::PendingCancel, OrderEventAny::Rejected(_)) => Self::Rejected,
273            (Self::PendingCancel, OrderEventAny::PendingCancel(_)) => Self::PendingCancel,  // Allow multiple requests
274            (Self::PendingCancel, OrderEventAny::ModifyRejected(_)) => Self::PendingCancel, // Preserve in-flight cancellation
275            (Self::PendingCancel, OrderEventAny::CancelRejected(_)) => Self::PendingCancel,  // Handled by cancel_rejected to restore previous_status
276            (Self::PendingCancel, OrderEventAny::Canceled(_)) => Self::Canceled,
277            (Self::PendingCancel, OrderEventAny::Expired(_)) => Self::Expired,
278            (Self::PendingCancel, OrderEventAny::Accepted(_)) => Self::Accepted,  // Allow failed cancel requests
279            (Self::PendingCancel, OrderEventAny::Updated(_)) => Self::PendingCancel,  // Handled by updated to restore previous_status
280            (Self::PendingCancel, OrderEventAny::Filled(_)) => Self::Filled,
281            (Self::PendingCancel, OrderEventAny::FillVoided(_)) => Self::PendingCancel,
282            (Self::Triggered, OrderEventAny::Rejected(_)) => Self::Rejected,
283            (Self::Triggered, OrderEventAny::PendingUpdate(_)) => Self::PendingUpdate,
284            (Self::Triggered, OrderEventAny::PendingCancel(_)) => Self::PendingCancel,
285            (Self::Triggered, OrderEventAny::ModifyRejected(_)) => Self::Triggered,
286            (Self::Triggered, OrderEventAny::CancelRejected(_)) => Self::Triggered,
287            (Self::Triggered, OrderEventAny::Canceled(_)) => Self::Canceled,
288            (Self::Triggered, OrderEventAny::Expired(_)) => Self::Expired,
289            (Self::Triggered, OrderEventAny::Filled(_)) => Self::Filled,
290            (Self::Triggered, OrderEventAny::Updated(_)) => Self::Triggered,
291            (Self::Triggered, OrderEventAny::FillVoided(_)) => Self::Triggered,
292            (Self::PartiallyFilled, OrderEventAny::PendingUpdate(_)) => Self::PendingUpdate,
293            (Self::PartiallyFilled, OrderEventAny::PendingCancel(_)) => Self::PendingCancel,
294            (Self::PartiallyFilled, OrderEventAny::ModifyRejected(_)) => Self::PartiallyFilled,
295            (Self::PartiallyFilled, OrderEventAny::CancelRejected(_)) => Self::PartiallyFilled,
296            (Self::PartiallyFilled, OrderEventAny::Canceled(_)) => Self::Canceled,
297            (Self::PartiallyFilled, OrderEventAny::Expired(_)) => Self::Expired,
298            (Self::PartiallyFilled, OrderEventAny::Filled(_)) => Self::Filled,
299            (Self::PartiallyFilled, OrderEventAny::Accepted(_)) => Self::Accepted,
300            (Self::PartiallyFilled, OrderEventAny::Updated(_)) => Self::PartiallyFilled,
301            (Self::PartiallyFilled, OrderEventAny::FillVoided(_)) => Self::PartiallyFilled,
302            (Self::Filled, OrderEventAny::FillVoided(_)) => Self::Voided,
303            (Self::Filled, OrderEventAny::Updated(_)) => Self::Filled,
304            (Self::Expired, OrderEventAny::Filled(_)) => Self::Filled,  // Real world possibility
305            (Self::Expired, OrderEventAny::FillVoided(_)) => Self::Expired,
306            (Self::Expired, OrderEventAny::Updated(_)) => Self::Expired,
307            (Self::Voided, OrderEventAny::FillVoided(_)) => Self::Voided,
308            _ => return Err(OrderError::InvalidStateTransition),
309        };
310        Ok(new_state)
311    }
312}
313
314#[enum_dispatch]
315pub trait Order: 'static + Send {
316    fn into_any(self) -> OrderAny;
317    fn status(&self) -> OrderStatus;
318    fn trader_id(&self) -> TraderId;
319    fn strategy_id(&self) -> StrategyId;
320    fn instrument_id(&self) -> InstrumentId;
321    fn symbol(&self) -> Symbol;
322    fn venue(&self) -> Venue;
323    fn client_order_id(&self) -> ClientOrderId;
324    fn venue_order_id(&self) -> Option<VenueOrderId>;
325    fn position_id(&self) -> Option<PositionId>;
326    fn account_id(&self) -> Option<AccountId>;
327    fn last_trade_id(&self) -> Option<TradeId>;
328    fn order_side(&self) -> OrderSide;
329    fn order_type(&self) -> OrderType;
330    fn quantity(&self) -> Quantity;
331    fn time_in_force(&self) -> TimeInForce;
332    fn expire_time(&self) -> Option<UnixNanos>;
333    fn price(&self) -> Option<Price>;
334    fn activation_price(&self) -> Option<Price> {
335        None
336    }
337    fn trigger_price(&self) -> Option<Price>;
338    fn trigger_type(&self) -> Option<TriggerType>;
339    fn liquidity_side(&self) -> Option<LiquiditySide>;
340    fn is_post_only(&self) -> bool;
341    fn is_reduce_only(&self) -> bool;
342    fn is_quote_quantity(&self) -> bool;
343    fn display_qty(&self) -> Option<Quantity>;
344    fn limit_offset(&self) -> Option<Decimal>;
345    fn trailing_offset(&self) -> Option<Decimal>;
346    fn trailing_offset_type(&self) -> Option<TrailingOffsetType>;
347    fn emulation_trigger(&self) -> Option<TriggerType>;
348    fn trigger_instrument_id(&self) -> Option<InstrumentId>;
349    fn contingency_type(&self) -> Option<ContingencyType>;
350    fn order_list_id(&self) -> Option<OrderListId>;
351    fn linked_order_ids(&self) -> Option<&[ClientOrderId]>;
352    fn parent_order_id(&self) -> Option<ClientOrderId>;
353    fn exec_algorithm_id(&self) -> Option<ExecAlgorithmId>;
354    fn exec_algorithm_params(&self) -> Option<&IndexMap<Ustr, Ustr>>;
355    fn exec_spawn_id(&self) -> Option<ClientOrderId>;
356    fn tags(&self) -> Option<&[Ustr]>;
357    fn filled_qty(&self) -> Quantity;
358    fn voided_qty(&self) -> Quantity;
359    fn non_reopened_voided_qty(&self) -> Quantity;
360    fn leaves_qty(&self) -> Quantity;
361    fn overfill_qty(&self) -> Quantity;
362
363    /// Calculates potential overfill quantity without mutating order state.
364    fn calculate_overfill(&self, fill_qty: Quantity) -> Quantity {
365        let potential_filled = self.filled_qty() + fill_qty;
366        let quantity = self.quantity();
367        if potential_filled > quantity {
368            potential_filled - quantity
369        } else {
370            Quantity::zero(fill_qty.precision)
371        }
372    }
373
374    fn avg_px(&self) -> Option<Decimal>;
375    fn slippage(&self) -> Option<Decimal>;
376    fn init_id(&self) -> UUID4;
377    fn ts_init(&self) -> UnixNanos;
378    fn ts_submitted(&self) -> Option<UnixNanos>;
379    fn ts_accepted(&self) -> Option<UnixNanos>;
380    fn ts_closed(&self) -> Option<UnixNanos>;
381    fn ts_last(&self) -> UnixNanos;
382
383    fn commissions(&self) -> &IndexMap<Currency, Money>;
384
385    /// Applies the `event` to the order.
386    ///
387    /// # Errors
388    ///
389    /// Returns an error if the event is invalid for the current order status.
390    fn apply(&mut self, event: OrderEventAny) -> Result<(), OrderError>;
391
392    fn update(&mut self, event: &OrderUpdated);
393
394    fn events(&self) -> Vec<&OrderEventAny>;
395
396    fn last_event(&self) -> &OrderEventAny {
397        self.events()
398            .last()
399            .expect("Order invariant violated: no events")
400    }
401
402    fn event_count(&self) -> usize {
403        self.events().len()
404    }
405
406    fn venue_order_ids(&self) -> Vec<&VenueOrderId>;
407
408    fn trade_ids(&self) -> Vec<&TradeId>;
409
410    fn has_price(&self) -> bool;
411
412    /// Returns `true` if the latest fill for this `trade_id` already has this side, quantity, and price.
413    fn is_duplicate_fill(&self, fill: &OrderFilled) -> bool {
414        let mut latest = None;
415
416        for event in self.events() {
417            if let OrderEventAny::Filled(existing) = event
418                && existing.trade_id == fill.trade_id
419                && existing.order_side == fill.order_side
420            {
421                latest = Some(existing);
422            }
423        }
424
425        latest.is_some_and(|existing| {
426            existing.last_qty == fill.last_qty && existing.last_px == fill.last_px
427        })
428    }
429
430    fn is_buy(&self) -> bool {
431        self.order_side() == OrderSide::Buy
432    }
433
434    fn is_sell(&self) -> bool {
435        self.order_side() == OrderSide::Sell
436    }
437
438    fn is_passive(&self) -> bool {
439        self.order_type() != OrderType::Market
440    }
441
442    fn is_aggressive(&self) -> bool {
443        self.order_type() == OrderType::Market
444    }
445
446    fn is_emulated(&self) -> bool {
447        self.status() == OrderStatus::Emulated
448    }
449
450    fn is_active_local(&self) -> bool {
451        matches!(
452            self.status(),
453            OrderStatus::Initialized | OrderStatus::Emulated | OrderStatus::Released
454        )
455    }
456
457    fn is_primary(&self) -> bool {
458        self.exec_algorithm_id().is_some()
459            && self
460                .exec_spawn_id()
461                .is_some_and(|spawn_id| self.client_order_id() == spawn_id)
462    }
463
464    fn is_spawned(&self) -> bool {
465        self.exec_algorithm_id().is_some()
466            && self
467                .exec_spawn_id()
468                .is_some_and(|spawn_id| self.client_order_id() != spawn_id)
469    }
470
471    fn is_contingency(&self) -> bool {
472        self.contingency_type().is_some()
473    }
474
475    fn is_parent_order(&self) -> bool {
476        match self.contingency_type() {
477            Some(c) => c == ContingencyType::Oto,
478            None => false,
479        }
480    }
481
482    fn is_child_order(&self) -> bool {
483        self.parent_order_id().is_some()
484    }
485
486    fn is_open(&self) -> bool {
487        if self.emulation_trigger().is_some() {
488            return false;
489        }
490
491        matches!(
492            self.status(),
493            OrderStatus::Accepted
494                | OrderStatus::Triggered
495                | OrderStatus::PendingCancel
496                | OrderStatus::PendingUpdate
497                | OrderStatus::PartiallyFilled
498        )
499    }
500
501    fn is_canceled(&self) -> bool {
502        self.status() == OrderStatus::Canceled
503    }
504
505    fn is_closed(&self) -> bool {
506        matches!(
507            self.status(),
508            OrderStatus::Denied
509                | OrderStatus::Rejected
510                | OrderStatus::Canceled
511                | OrderStatus::Expired
512                | OrderStatus::Filled
513                | OrderStatus::Voided
514        )
515    }
516
517    fn is_inflight(&self) -> bool {
518        if self.emulation_trigger().is_some() {
519            return false;
520        }
521
522        matches!(
523            self.status(),
524            OrderStatus::Submitted | OrderStatus::PendingCancel | OrderStatus::PendingUpdate
525        )
526    }
527
528    fn is_pending_update(&self) -> bool {
529        self.status() == OrderStatus::PendingUpdate
530    }
531
532    fn is_pending_cancel(&self) -> bool {
533        self.status() == OrderStatus::PendingCancel
534    }
535
536    /// Returns whether recorded modify commands still await an outcome.
537    fn has_pending_update_command(&self) -> bool {
538        self.is_pending_update()
539    }
540
541    /// Returns whether recorded cancel commands still await an outcome.
542    fn has_pending_cancel_command(&self) -> bool {
543        self.is_pending_cancel()
544    }
545
546    fn to_own_book_order(&self) -> OwnBookOrder {
547        OwnBookOrder::new(
548            self.trader_id(),
549            self.client_order_id(),
550            self.venue_order_id(),
551            self.order_side(),
552            self.price().expect("`OwnBookOrder` must have a price"),
553            self.leaves_qty(),
554            self.order_type(),
555            self.time_in_force(),
556            self.status(),
557            self.ts_last(),
558            self.ts_accepted().unwrap_or_default(),
559            self.ts_submitted().unwrap_or_default(),
560            self.ts_init(),
561        )
562    }
563
564    /// Builds an [`OrderStatusReport`] snapshot from the order's current state.
565    ///
566    /// Returns `None` if the order has no `venue_order_id` or `account_id`:
567    /// a status report describes a venue-acknowledged order, and both fields
568    /// are set by the time a venue acknowledges the order.
569    fn to_order_status_report(&self, report_id: Option<UUID4>) -> Option<OrderStatusReport> {
570        let account_id = self.account_id()?;
571        let venue_order_id = self.venue_order_id()?;
572
573        let mut report = OrderStatusReport::new(
574            account_id,
575            self.instrument_id(),
576            Some(self.client_order_id()),
577            venue_order_id,
578            self.order_side().into(),
579            self.order_type(),
580            self.time_in_force(),
581            self.status(),
582            self.quantity(),
583            self.filled_qty(),
584            self.ts_accepted().unwrap_or_else(|| self.ts_last()),
585            self.ts_last(),
586            self.ts_init(),
587            report_id,
588        )
589        .with_post_only(self.is_post_only())
590        .with_reduce_only(self.is_reduce_only());
591
592        report.price = self.price();
593        report.activation_price = self.activation_price();
594        report.trigger_price = self.trigger_price();
595        report.trigger_type = self.trigger_type();
596        report.limit_offset = self.limit_offset();
597        report.trailing_offset = self.trailing_offset();
598        report.trailing_offset_type = self.trailing_offset_type();
599        report.display_qty = self.display_qty();
600        report.expire_time = self.expire_time();
601        report.contingency_type = self.contingency_type();
602        report.order_list_id = self.order_list_id();
603        report.linked_order_ids = self.linked_order_ids().map(<[ClientOrderId]>::to_vec);
604        report.parent_order_id = self.parent_order_id();
605        report.venue_position_id = self.position_id();
606
607        // The trait exposes no trigger or rejection metadata accessors,
608        // recover the last occurrences from the event history.
609        let mut ts_triggered = None;
610        let mut rejected_reason = None;
611
612        for event in self.events() {
613            match event {
614                OrderEventAny::Triggered(triggered) => ts_triggered = Some(triggered.ts_event),
615                OrderEventAny::Rejected(rejected) => rejected_reason = Some(rejected.reason),
616                _ => {}
617            }
618        }
619
620        report.ts_triggered = ts_triggered;
621
622        // `cancel_reason` is the report's only reason channel,
623        // reconciliation reads it for rejected orders.
624        report.cancel_reason = rejected_reason.map(|reason| reason.to_string());
625        report.avg_px = self.avg_px();
626
627        Some(report)
628    }
629
630    fn is_triggered(&self) -> Option<bool>; // TODO: Temporary on trait
631    fn set_position_id(&mut self, position_id: Option<PositionId>);
632    fn set_quantity(&mut self, quantity: Quantity);
633    fn set_leaves_qty(&mut self, leaves_qty: Quantity);
634    fn set_emulation_trigger(&mut self, emulation_trigger: Option<TriggerType>);
635    fn set_is_quote_quantity(&mut self, is_quote_quantity: bool);
636    fn set_liquidity_side(&mut self, liquidity_side: LiquiditySide);
637    fn would_reduce_only(&self, side: PositionSide, position_qty: Quantity) -> bool;
638    fn previous_status(&self) -> Option<OrderStatus>;
639}
640
641impl<T> From<&T> for OrderInitialized
642where
643    T: Order,
644{
645    fn from(order: &T) -> Self {
646        Self {
647            trader_id: order.trader_id(),
648            strategy_id: order.strategy_id(),
649            instrument_id: order.instrument_id(),
650            client_order_id: order.client_order_id(),
651            order_side: order.order_side(),
652            order_type: order.order_type(),
653            quantity: order.quantity(),
654            price: order.price(),
655            activation_price: order.activation_price(),
656            trigger_price: order.trigger_price(),
657            trigger_type: order.trigger_type(),
658            time_in_force: order.time_in_force(),
659            expire_time: order.expire_time(),
660            post_only: order.is_post_only(),
661            reduce_only: order.is_reduce_only(),
662            quote_quantity: order.is_quote_quantity(),
663            display_qty: order.display_qty(),
664            limit_offset: order.limit_offset(),
665            trailing_offset: order.trailing_offset(),
666            trailing_offset_type: order.trailing_offset_type(),
667            emulation_trigger: order.emulation_trigger(),
668            trigger_instrument_id: order.trigger_instrument_id(),
669            contingency_type: order.contingency_type(),
670            order_list_id: order.order_list_id(),
671            linked_order_ids: order.linked_order_ids().map(<[ClientOrderId]>::to_vec),
672            parent_order_id: order.parent_order_id(),
673            exec_algorithm_id: order.exec_algorithm_id(),
674            exec_algorithm_params: order.exec_algorithm_params().map(ToOwned::to_owned),
675            exec_spawn_id: order.exec_spawn_id(),
676            tags: order.tags().map(<[Ustr]>::to_vec),
677            event_id: order.init_id(),
678            ts_event: order.ts_init(),
679            ts_init: order.ts_init(),
680            reconciliation: false,
681            causation_id: None,
682        }
683    }
684}
685
686/// Common event-sourced state shared by order types.
687///
688/// Construct with [`Self::new`] and update through [`Self::apply`]. Inspect history with
689/// [`Self::events`]; use [`Self::prepend_events`] to retain history when transforming an order,
690/// or [`OrderAny::from_events`] to reconstruct its state from an event stream.
691/// Outstanding command correlations distinguish overlapping operations independently of status.
692#[derive(Clone, Debug, Serialize, Deserialize)]
693pub struct OrderCore {
694    events: Vec<OrderEventAny>,
695    #[serde(default, skip_serializing_if = "Vec::is_empty")]
696    pending_commands: Vec<(OrderStatus, Option<UUID4>)>,
697    #[serde(default, skip_serializing_if = "Option::is_none")]
698    pending_previous_status: Option<OrderStatus>,
699    #[serde(skip)]
700    fill_totals: Option<FillTotals>,
701    #[serde(skip)]
702    fill_index: Option<AHashMap<TradeId, FillRecord>>,
703    pub commissions: IndexMap<Currency, Money>,
704    pub venue_order_ids: Vec<VenueOrderId>,
705    pub trade_ids: Vec<TradeId>,
706    pub previous_status: Option<OrderStatus>,
707    pub status: OrderStatus,
708    pub trader_id: TraderId,
709    pub strategy_id: StrategyId,
710    pub instrument_id: InstrumentId,
711    pub client_order_id: ClientOrderId,
712    pub venue_order_id: Option<VenueOrderId>,
713    pub position_id: Option<PositionId>,
714    pub account_id: Option<AccountId>,
715    pub last_trade_id: Option<TradeId>,
716    pub side: OrderSide,
717    pub order_type: OrderType,
718    pub quantity: Quantity,
719    pub time_in_force: TimeInForce,
720    pub liquidity_side: Option<LiquiditySide>,
721    pub is_reduce_only: bool,
722    pub is_quote_quantity: bool,
723    #[serde(default, with = "crate::enums::serde_option_trigger_type")]
724    pub emulation_trigger: Option<TriggerType>,
725    #[serde(default, with = "crate::enums::serde_option_contingency_type")]
726    pub contingency_type: Option<ContingencyType>,
727    pub order_list_id: Option<OrderListId>,
728    pub linked_order_ids: Option<Vec<ClientOrderId>>,
729    pub parent_order_id: Option<ClientOrderId>,
730    pub exec_algorithm_id: Option<ExecAlgorithmId>,
731    pub exec_algorithm_params: Option<IndexMap<Ustr, Ustr>>,
732    pub exec_spawn_id: Option<ClientOrderId>,
733    pub tags: Option<Vec<Ustr>>,
734    pub filled_qty: Quantity,
735    #[serde(default)]
736    pub voided_qty: Quantity,
737    /// Cumulative quantity voided by non-reopened `OrderFillVoided` corrections, already excluded
738    /// from both `filled_qty` and `leaves_qty`. Kept current by `recompute_fill_state`.
739    #[serde(default)]
740    pub non_reopened_voided_qty: Quantity,
741    pub leaves_qty: Quantity,
742    pub overfill_qty: Quantity,
743    pub avg_px: Option<Decimal>,
744    pub slippage: Option<Decimal>,
745    pub init_id: UUID4,
746    pub ts_init: UnixNanos,
747    pub ts_submitted: Option<UnixNanos>,
748    pub ts_accepted: Option<UnixNanos>,
749    pub ts_closed: Option<UnixNanos>,
750    pub ts_last: UnixNanos,
751}
752
753impl OrderCore {
754    /// Creates a new [`OrderCore`] instance.
755    #[must_use]
756    pub fn new(init: OrderInitialized) -> Self {
757        let events: Vec<OrderEventAny> = vec![OrderEventAny::Initialized(init.clone())];
758        Self {
759            events,
760            pending_commands: Vec::new(),
761            pending_previous_status: None,
762            fill_totals: Some(FillTotals::default()),
763            fill_index: None,
764            commissions: IndexMap::new(),
765            venue_order_ids: Vec::new(),
766            trade_ids: Vec::new(),
767            previous_status: None,
768            status: OrderStatus::Initialized,
769            trader_id: init.trader_id,
770            strategy_id: init.strategy_id,
771            instrument_id: init.instrument_id,
772            client_order_id: init.client_order_id,
773            venue_order_id: None,
774            position_id: None,
775            account_id: None,
776            last_trade_id: None,
777            side: init.order_side,
778            order_type: init.order_type,
779            quantity: init.quantity,
780            time_in_force: init.time_in_force,
781            liquidity_side: Some(LiquiditySide::NoLiquiditySide),
782            is_reduce_only: init.reduce_only,
783            is_quote_quantity: init.quote_quantity,
784            emulation_trigger: init.emulation_trigger,
785            contingency_type: init.contingency_type,
786            order_list_id: init.order_list_id,
787            linked_order_ids: init.linked_order_ids,
788            parent_order_id: init.parent_order_id,
789            exec_algorithm_id: init.exec_algorithm_id,
790            exec_algorithm_params: init.exec_algorithm_params,
791            exec_spawn_id: init.exec_spawn_id,
792            tags: init.tags,
793            filled_qty: Quantity::zero(init.quantity.precision),
794            voided_qty: Quantity::zero(init.quantity.precision),
795            non_reopened_voided_qty: Quantity::zero(init.quantity.precision),
796            leaves_qty: init.quantity,
797            overfill_qty: Quantity::zero(init.quantity.precision),
798            avg_px: None,
799            slippage: None,
800            init_id: init.event_id,
801            ts_init: init.ts_event,
802            ts_submitted: None,
803            ts_accepted: None,
804            ts_closed: None,
805            ts_last: init.ts_event,
806        }
807    }
808
809    /// Applies the `event` to the order.
810    ///
811    /// # Errors
812    ///
813    /// Returns an error if the event is invalid for the current order status, or if
814    /// `event.client_order_id()` or `event.strategy_id()` does not match the order.
815    /// A fill that overflows the filled quantity or cumulative commission is rejected
816    /// without changing the order.
817    pub fn apply(&mut self, event: OrderEventAny) -> Result<(), OrderError> {
818        self.validate_event_identity(&event)?;
819
820        if let OrderEventAny::FillVoided(event) = &event {
821            self.validate_fill_void(event)?;
822        }
823
824        let mut has_prior_fill_void = false;
825
826        // Check for duplicate fill before state transition to maintain consistency
827        if let OrderEventAny::Filled(fill) = &event {
828            let record = self.fill_record(fill.trade_id);
829            has_prior_fill_void = record.is_voided;
830
831            match record.last_px {
832                Some(price) if price == fill.last_px => {
833                    return Err(OrderError::DuplicateFill(fill.trade_id));
834                }
835                Some(_) => {
836                    self.restate_fill_price(event);
837                    return Ok(());
838                }
839                None => {}
840            }
841        }
842
843        if matches!(event, OrderEventAny::Triggered(_))
844            && !TRIGGERABLE_ORDER_TYPES.contains(&self.order_type)
845        {
846            return Err(OrderError::InvalidOrderEvent);
847        }
848
849        match &event {
850            OrderEventAny::Initialized(_) => return Err(OrderError::AlreadyInitialized),
851
852            // A replayed expiry must not overwrite a later fill's status or timestamps
853            OrderEventAny::Expired(_)
854                if matches!(self.status, OrderStatus::Expired | OrderStatus::Filled)
855                    && self
856                        .events
857                        .iter()
858                        .rposition(|event| matches!(event, OrderEventAny::Expired(_)))
859                        .is_some_and(|index| {
860                            self.events[index + 1..]
861                                .iter()
862                                .any(|event| matches!(event, OrderEventAny::Filled(_)))
863                        }) =>
864            {
865                // Cache persistence writes last_event after every successful apply
866                self.push_event(event);
867                return Ok(());
868            }
869            _ => {}
870        }
871
872        let new_status = self.transition_for_event(&event)?;
873
874        if let OrderEventAny::Filled(fill) = &event {
875            self.validate_fill_totals(fill)?;
876        }
877
878        let rejection_status = if matches!(
879            (&event, self.status),
880            (OrderEventAny::ModifyRejected(_), OrderStatus::PendingUpdate)
881                | (OrderEventAny::CancelRejected(_), OrderStatus::PendingCancel)
882        ) {
883            self.previous_status.ok_or(OrderError::NoPreviousState)?
884        } else {
885            self.status
886        };
887
888        if let OrderEventAny::Updated(update) = &event {
889            self.validate_update_fields(update)?;
890        }
891
892        let source_status = self.status;
893
894        // Save current status as previous_status for ALL transitions except:
895        // - Initialized (no prior state exists)
896        // - ModifyRejected/CancelRejected (need to preserve the pre Pending state)
897        // - When already in Pending* state (avoid overwriting the pre Pending state when receiving multiple pending requests)
898        if !matches!(
899            event,
900            OrderEventAny::Initialized(_)
901                | OrderEventAny::ModifyDenied(_)
902                | OrderEventAny::ModifyRejected(_)
903                | OrderEventAny::CancelDenied(_)
904                | OrderEventAny::CancelRejected(_)
905        ) && !matches!(
906            self.status,
907            OrderStatus::PendingUpdate | OrderStatus::PendingCancel
908        ) {
909            self.previous_status = Some(self.status);
910        }
911
912        self.status = new_status;
913        self.record_pending_command(&event, source_status);
914
915        match &event {
916            // Rejected by the pre-commit check above; kept for exhaustiveness
917            OrderEventAny::Initialized(_) => return Err(OrderError::AlreadyInitialized),
918            OrderEventAny::Denied(event) => self.denied(event),
919            OrderEventAny::ModifyDenied(event) => {
920                self.command_refused(event.causation_id, OrderStatus::PendingUpdate, None);
921            }
922            OrderEventAny::CancelDenied(event) => {
923                self.command_refused(event.causation_id, OrderStatus::PendingCancel, None);
924            }
925            OrderEventAny::Emulated(event) => self.emulated(event),
926            OrderEventAny::Released(event) => self.released(event),
927            OrderEventAny::Submitted(event) => self.submitted(event),
928            OrderEventAny::Rejected(event) => self.rejected(event),
929            OrderEventAny::Accepted(event) => self.accepted(event),
930            OrderEventAny::PendingUpdate(event) => self.pending_update(event),
931            OrderEventAny::PendingCancel(event) => self.pending_cancel(event),
932            OrderEventAny::ModifyRejected(event) => self.modify_rejected(event, rejection_status),
933            OrderEventAny::CancelRejected(event) => self.cancel_rejected(event, rejection_status),
934            OrderEventAny::Updated(event) => self.updated(event),
935            OrderEventAny::Triggered(event) => self.triggered(event),
936            OrderEventAny::Canceled(event) => self.canceled(event),
937            OrderEventAny::Expired(event) => self.expired(event),
938            OrderEventAny::Filled(event) => self.filled(event, source_status),
939            OrderEventAny::FillVoided(event) => self.fill_voided(event, source_status),
940        }
941
942        self.record_event(event, has_prior_fill_void);
943        Ok(())
944    }
945
946    fn validate_event_identity(&self, event: &OrderEventAny) -> Result<(), OrderError> {
947        if self.client_order_id != event.client_order_id() {
948            return Err(CorrectnessError::PredicateViolation {
949                message: format!(
950                    "Event client_order_id {} does not match order client_order_id {}",
951                    event.client_order_id(),
952                    self.client_order_id
953                ),
954            }
955            .into());
956        }
957
958        if self.strategy_id != event.strategy_id() {
959            return Err(CorrectnessError::PredicateViolation {
960                message: format!(
961                    "Event strategy_id {} does not match order strategy_id {}",
962                    event.strategy_id(),
963                    self.strategy_id
964                ),
965            }
966            .into());
967        }
968
969        if let OrderEventAny::Filled(fill) = event
970            && self.is_fill_report_order()
971            && (fill.instrument_id != self.instrument_id
972                || fill.order_side != self.side
973                || self.account_id != Some(fill.account_id)
974                || self.venue_order_id != Some(fill.venue_order_id))
975        {
976            return Err(OrderError::InvalidOrderEvent);
977        }
978
979        Ok(())
980    }
981
982    fn transition_for_event(&mut self, event: &OrderEventAny) -> Result<OrderStatus, OrderError> {
983        let is_reclose_after_fill = self.status == OrderStatus::Canceled
984            && matches!(event, OrderEventAny::Canceled(_))
985            && self
986                .events
987                .iter()
988                .rev()
989                .take_while(|event| !matches!(event, OrderEventAny::Canceled(_)))
990                .any(|event| matches!(event, OrderEventAny::Filled(_)));
991
992        let new_status = if is_reclose_after_fill {
993            OrderStatus::Canceled
994        } else if self.status == OrderStatus::Filled
995            && matches!(event, OrderEventAny::Filled(_))
996            && self.is_fill_report_order()
997        {
998            OrderStatus::Filled
999        } else {
1000            self.status.transition(event)?
1001        };
1002
1003        Ok(new_status)
1004    }
1005
1006    fn validate_fill_totals(&self, fill: &OrderFilled) -> Result<(), OrderError> {
1007        if self.filled_qty.checked_add(fill.last_qty).is_none() {
1008            return Err(CorrectnessError::PredicateViolation {
1009                message: format!(
1010                    "filled quantity overflowed Quantity raw bounds: {} + {}",
1011                    self.filled_qty, fill.last_qty
1012                ),
1013            }
1014            .into());
1015        }
1016
1017        if let Some(commission) = fill.commission
1018            && let Some(total) = self.commissions.get(&commission.currency)
1019            && total.checked_add(commission).is_none()
1020        {
1021            return Err(CorrectnessError::PredicateViolation {
1022                message: format!(
1023                    "cumulative commission overflowed Money bounds: {total} + {commission}"
1024                ),
1025            }
1026            .into());
1027        }
1028
1029        Ok(())
1030    }
1031
1032    // Reject an update carrying fields the order type cannot hold before any
1033    // mutation. Runs after the identity and transition checks so an identity
1034    // mismatch or invalid transition is reported ahead of a field violation.
1035    fn validate_update_fields(&self, update: &OrderUpdated) -> Result<(), OrderError> {
1036        let invalid_fields = match self.order_type {
1037            OrderType::Market => update.price.is_some() || update.trigger_price.is_some(),
1038            OrderType::StopMarket | OrderType::MarketIfTouched | OrderType::TrailingStopMarket => {
1039                update.price.is_some()
1040            }
1041            OrderType::Limit | OrderType::MarketToLimit => update.trigger_price.is_some(),
1042            OrderType::StopLimit | OrderType::LimitIfTouched | OrderType::TrailingStopLimit => {
1043                false
1044            }
1045        };
1046
1047        if invalid_fields {
1048            return Err(OrderError::InvalidOrderEvent);
1049        }
1050
1051        Ok(())
1052    }
1053
1054    fn record_event(&mut self, event: OrderEventAny, has_prior_fill_void: bool) {
1055        if self.status.is_closed() {
1056            self.pending_commands.clear();
1057            self.pending_previous_status = None;
1058        }
1059
1060        if has_prior_fill_void {
1061            // Pending fills contribute in full, a restored correction applies once the fill
1062            // becomes historical, so the next fill must rebuild rather than reuse this fold.
1063            self.fill_totals = None;
1064        }
1065
1066        self.ts_last = event.ts_event();
1067        self.push_event(event);
1068    }
1069
1070    fn denied(&mut self, event: &OrderDenied) {
1071        self.ts_closed = Some(event.ts_event);
1072    }
1073
1074    fn command_refused(
1075        &mut self,
1076        causation_id: Option<UUID4>,
1077        kind: OrderStatus,
1078        legacy_status: Option<OrderStatus>,
1079    ) {
1080        let previous_status = self.pending_previous_status;
1081
1082        if let Some(command_id) = causation_id {
1083            let Some(index) = self
1084                .pending_commands
1085                .iter()
1086                .position(|pending| *pending == (kind, Some(command_id)))
1087            else {
1088                return;
1089            };
1090
1091            self.pending_commands.remove(index);
1092        } else if legacy_status.is_some() {
1093            self.pending_commands.retain(|(status, _)| *status != kind);
1094        } else {
1095            return;
1096        }
1097
1098        if self.pending_commands.is_empty() {
1099            self.pending_previous_status = None;
1100        }
1101
1102        if !matches!(
1103            self.status,
1104            OrderStatus::PendingUpdate | OrderStatus::PendingCancel
1105        ) {
1106            return;
1107        }
1108
1109        let restored = if self.filled_qty.is_zero() {
1110            previous_status.or(legacy_status).or(self.previous_status)
1111        } else {
1112            Some(OrderStatus::PartiallyFilled)
1113        };
1114
1115        self.status = self
1116            .pending_commands
1117            .last()
1118            .map(|(status, _)| *status)
1119            .or(restored)
1120            .unwrap_or(self.status);
1121    }
1122
1123    fn record_pending_command(&mut self, event: &OrderEventAny, source_status: OrderStatus) {
1124        let command = match event {
1125            OrderEventAny::PendingUpdate(event) => {
1126                Some((OrderStatus::PendingUpdate, event.causation_id))
1127            }
1128            OrderEventAny::PendingCancel(event) => {
1129                Some((OrderStatus::PendingCancel, event.causation_id))
1130            }
1131            OrderEventAny::Accepted(_) | OrderEventAny::Triggered(_) => {
1132                self.pending_commands.clear();
1133                self.pending_previous_status = None;
1134                return;
1135            }
1136            OrderEventAny::Updated(event) => {
1137                self.pending_commands.retain(|(status, command_id)| {
1138                    *status != OrderStatus::PendingUpdate
1139                        || event
1140                            .causation_id
1141                            .is_some_and(|cause| *command_id != Some(cause))
1142                });
1143
1144                return;
1145            }
1146            _ => None,
1147        };
1148
1149        if let Some(command) = command {
1150            if self.pending_commands.is_empty()
1151                || !matches!(
1152                    source_status,
1153                    OrderStatus::PendingUpdate | OrderStatus::PendingCancel
1154                )
1155            {
1156                self.pending_commands.clear();
1157                self.pending_previous_status = Some(
1158                    if matches!(
1159                        source_status,
1160                        OrderStatus::PendingUpdate | OrderStatus::PendingCancel
1161                    ) {
1162                        self.previous_status.unwrap_or(source_status)
1163                    } else {
1164                        source_status
1165                    },
1166                );
1167            }
1168
1169            if !self.pending_commands.contains(&command) {
1170                self.pending_commands.push(command);
1171            }
1172        }
1173    }
1174
1175    fn has_pending_update_command(&self) -> bool {
1176        !self.status.is_closed()
1177            && (self.status == OrderStatus::PendingUpdate
1178                || self
1179                    .pending_commands
1180                    .iter()
1181                    .any(|(status, _)| *status == OrderStatus::PendingUpdate))
1182    }
1183
1184    fn has_pending_cancel_command(&self) -> bool {
1185        !self.status.is_closed()
1186            && (self.status == OrderStatus::PendingCancel
1187                || self
1188                    .pending_commands
1189                    .iter()
1190                    .any(|(status, _)| *status == OrderStatus::PendingCancel))
1191    }
1192
1193    fn emulated(&self, _event: &OrderEmulated) {
1194        // Do nothing else
1195    }
1196
1197    fn released(&mut self, _event: &OrderReleased) {
1198        self.emulation_trigger = None;
1199    }
1200
1201    fn submitted(&mut self, event: &OrderSubmitted) {
1202        self.account_id = Some(event.account_id);
1203        self.ts_submitted = Some(event.ts_event);
1204    }
1205
1206    fn accepted(&mut self, event: &OrderAccepted) {
1207        self.account_id = Some(event.account_id);
1208        self.venue_order_id = Some(event.venue_order_id);
1209        self.venue_order_ids.push(event.venue_order_id);
1210        self.ts_accepted = Some(event.ts_event);
1211    }
1212
1213    fn rejected(&mut self, event: &OrderRejected) {
1214        self.ts_closed = Some(event.ts_event);
1215    }
1216
1217    fn pending_update(&self, _event: &OrderPendingUpdate) {
1218        // Do nothing else
1219    }
1220
1221    fn pending_cancel(&self, _event: &OrderPendingCancel) {
1222        // Do nothing else
1223    }
1224
1225    fn modify_rejected(&mut self, event: &OrderModifyRejected, rejection_status: OrderStatus) {
1226        self.command_refused(
1227            event.causation_id,
1228            OrderStatus::PendingUpdate,
1229            Some(rejection_status),
1230        );
1231    }
1232
1233    fn cancel_rejected(&mut self, event: &OrderCancelRejected, previous_status: OrderStatus) {
1234        self.command_refused(
1235            event.causation_id,
1236            OrderStatus::PendingCancel,
1237            Some(previous_status),
1238        );
1239    }
1240
1241    fn triggered(&self, _event: &OrderTriggered) {}
1242
1243    fn canceled(&mut self, event: &OrderCanceled) {
1244        self.ts_closed = Some(event.ts_event);
1245    }
1246
1247    fn expired(&mut self, event: &OrderExpired) {
1248        self.ts_closed = Some(event.ts_event);
1249    }
1250
1251    fn validate_fill_void(&self, event: &OrderFillVoided) -> Result<(), OrderError> {
1252        let fill = self.events.iter().find_map(|candidate| match candidate {
1253            OrderEventAny::Filled(fill) if fill.trade_id == event.trade_id => Some(fill),
1254            _ => None,
1255        });
1256
1257        if event.voided_qty.is_zero() {
1258            return Err(OrderError::OverVoid(event.trade_id));
1259        }
1260
1261        let previous = self.latest_fill_void(event.trade_id);
1262        if let Some(previous) = previous {
1263            if event.voided_qty < previous.voided_qty {
1264                return Err(OrderError::StaleFillVoid(event.trade_id));
1265            }
1266
1267            if event.voided_qty == previous.voided_qty
1268                && event.commission_voided == previous.commission_voided
1269                && event.is_reopened == previous.is_reopened
1270            {
1271                return Err(OrderError::DuplicateFillVoid(event.trade_id));
1272            }
1273        }
1274
1275        let Some(fill) = fill else {
1276            return self.validate_unrecorded_fill_void(event);
1277        };
1278
1279        if fill.venue_order_id != event.venue_order_id
1280            || fill.account_id != event.account_id
1281            || fill.order_side != event.order_side
1282            || fill.order_type != event.order_type
1283            || fill.last_px != event.last_px
1284            || fill.currency != event.currency
1285            || fill.liquidity_side != event.liquidity_side
1286            || fill.position_id != event.position_id
1287        {
1288            return Err(OrderError::InvalidOrderEvent);
1289        }
1290
1291        if event.voided_qty > fill.last_qty {
1292            return Err(OrderError::OverVoid(event.trade_id));
1293        }
1294
1295        self.validate_fill_void_commission(fill, event, previous)
1296    }
1297
1298    fn validate_unrecorded_fill_void(&self, event: &OrderFillVoided) -> Result<(), OrderError> {
1299        if event.is_reopened || !self.matches_fill_void_identity(event) {
1300            return Err(OrderError::InvalidOrderEvent);
1301        }
1302
1303        if event.voided_qty > self.quantity
1304            || event
1305                .commission_voided
1306                .is_some_and(|commission| !commission.is_zero())
1307        {
1308            return Err(OrderError::OverVoid(event.trade_id));
1309        }
1310
1311        Ok(())
1312    }
1313
1314    fn matches_fill_void_identity(&self, event: &OrderFillVoided) -> bool {
1315        event.trader_id == self.trader_id
1316            && event.instrument_id == self.instrument_id
1317            && event.order_side == self.side
1318            && event.order_type == self.order_type
1319            && (self.venue_order_id == Some(event.venue_order_id)
1320                || self.venue_order_ids.contains(&event.venue_order_id))
1321            && self.account_id == Some(event.account_id)
1322    }
1323
1324    fn validate_fill_void_commission(
1325        &self,
1326        fill: &OrderFilled,
1327        event: &OrderFillVoided,
1328        previous: Option<&OrderFillVoided>,
1329    ) -> Result<(), OrderError> {
1330        match (fill.commission, event.commission_voided) {
1331            (None, None) => Ok(()),
1332            (None, Some(commission)) if commission.is_zero() => Ok(()),
1333            (Some(_), None) if previous.and_then(|prior| prior.commission_voided).is_none() => {
1334                Ok(())
1335            }
1336            (Some(commission), Some(voided))
1337                if commission.currency == voided.currency
1338                    && commission.is_positive() == voided.is_positive()
1339                    && commission.is_negative() == voided.is_negative()
1340                    && voided.abs() <= commission.abs()
1341                    && previous
1342                        .and_then(|prior| prior.commission_voided)
1343                        .is_none_or(|prior| voided.abs() >= prior.abs()) =>
1344            {
1345                Ok(())
1346            }
1347            _ => Err(OrderError::InvalidFillVoidCommission(event.trade_id)),
1348        }
1349    }
1350
1351    fn latest_fill_void(&self, trade_id: TradeId) -> Option<&OrderFillVoided> {
1352        self.events
1353            .iter()
1354            .rev()
1355            .find_map(|candidate| match candidate {
1356                OrderEventAny::FillVoided(event) if event.trade_id == trade_id => Some(event),
1357                _ => None,
1358            })
1359    }
1360
1361    fn fill_voided(&mut self, event: &OrderFillVoided, source_status: OrderStatus) {
1362        let has_local_fill = self.events.iter().any(
1363            |candidate| matches!(candidate, OrderEventAny::Filled(fill) if fill.trade_id == event.trade_id),
1364        );
1365        let non_reopened_voided_qty = self.recompute_fill_state(Some(event));
1366        let unfilled_qty = self.quantity.saturating_sub(self.filled_qty);
1367        let working_leaves = unfilled_qty.saturating_sub(non_reopened_voided_qty);
1368
1369        match source_status {
1370            OrderStatus::Voided => {
1371                self.status = OrderStatus::Voided;
1372                self.leaves_qty = Quantity::zero(self.quantity.precision);
1373            }
1374            _ if !has_local_fill && !event.is_reopened => {
1375                self.status = OrderStatus::Voided;
1376                self.leaves_qty = Quantity::zero(self.quantity.precision);
1377            }
1378            OrderStatus::Canceled | OrderStatus::Expired => {
1379                self.status = source_status;
1380                self.leaves_qty = unfilled_qty;
1381            }
1382            _ if working_leaves.is_zero() => {
1383                self.status = OrderStatus::Voided;
1384                self.leaves_qty = working_leaves;
1385            }
1386            OrderStatus::PendingUpdate | OrderStatus::PendingCancel | OrderStatus::Triggered => {
1387                self.status = source_status;
1388                self.leaves_qty = working_leaves;
1389            }
1390            _ => {
1391                self.status = if self.filled_qty.is_zero() {
1392                    OrderStatus::Accepted
1393                } else {
1394                    OrderStatus::PartiallyFilled
1395                };
1396                self.leaves_qty = working_leaves;
1397            }
1398        }
1399
1400        if self.status.is_open() {
1401            self.ts_closed = None;
1402        } else if self.status.is_closed() {
1403            self.ts_closed = self.ts_closed.or(Some(event.ts_event));
1404        }
1405    }
1406
1407    fn recompute_fill_state(&mut self, additional: Option<&OrderFillVoided>) -> Quantity {
1408        let corrections = self.fill_corrections(additional);
1409
1410        let mut totals = FillTotals::default();
1411        let mut filled = Quantity::zero(self.quantity.precision);
1412        let mut voided = Quantity::zero(self.quantity.precision);
1413        let mut non_reopened_voided = Quantity::zero(self.quantity.precision);
1414
1415        let mut commissions = IndexMap::<Currency, Money>::new();
1416        let mut trade_ids = Vec::new();
1417        let mut last_trade_id = None;
1418        let mut position_id = None;
1419        let mut liquidity_side = Some(LiquiditySide::NoLiquiditySide);
1420        let mut matched_corrections = AHashSet::new();
1421        let prices = self.accounting_prices();
1422
1423        for fill in self.quantity_fills() {
1424            let correction = corrections.get(&fill.trade_id).copied();
1425            if correction.is_some() {
1426                matched_corrections.insert(fill.trade_id);
1427            }
1428            let removed = Self::removed_fill_qty(fill, correction);
1429            let effective = fill.last_qty - removed;
1430            voided = voided.saturating_add(removed);
1431            if correction.is_some_and(|event| !event.is_reopened) {
1432                non_reopened_voided = non_reopened_voided.saturating_add(removed);
1433            }
1434
1435            if !effective.is_zero() {
1436                let price = prices
1437                    .get(&fill.trade_id)
1438                    .copied()
1439                    .unwrap_or(fill.last_px.as_decimal());
1440                totals.add(effective.as_decimal(), price);
1441                filled = filled.saturating_add(effective);
1442                trade_ids.push(fill.trade_id);
1443                last_trade_id = Some(fill.trade_id);
1444                position_id = fill.position_id;
1445                liquidity_side = Some(fill.liquidity_side);
1446            }
1447
1448            if let Some(commission) = fill.commission {
1449                let surviving = correction
1450                    .and_then(|event| event.commission_voided)
1451                    .filter(|voided| !voided.is_zero())
1452                    .map_or(commission, |voided| commission - voided);
1453
1454                if !surviving.is_zero() {
1455                    commissions
1456                        .entry(surviving.currency)
1457                        .and_modify(|total| *total = *total + surviving)
1458                        .or_insert(surviving);
1459                }
1460            }
1461        }
1462
1463        for (trade_id, correction) in corrections {
1464            if !matched_corrections.contains(&trade_id) {
1465                voided = voided.saturating_add(correction.voided_qty);
1466            }
1467        }
1468
1469        self.filled_qty = filled;
1470        self.voided_qty = voided;
1471        self.non_reopened_voided_qty = non_reopened_voided;
1472        self.overfill_qty = self.filled_qty.saturating_sub(self.quantity);
1473        self.avg_px = totals.average();
1474        self.fill_totals = Some(totals);
1475        self.commissions = commissions;
1476        self.trade_ids = trade_ids;
1477        self.last_trade_id = last_trade_id;
1478        self.position_id = position_id;
1479        self.liquidity_side = liquidity_side;
1480
1481        non_reopened_voided
1482    }
1483
1484    fn updated(&mut self, event: &OrderUpdated) {
1485        if matches!(
1486            self.status,
1487            OrderStatus::PendingUpdate | OrderStatus::PendingCancel,
1488        ) && let Some(previous) = self.previous_status
1489        {
1490            self.status = self
1491                .pending_commands
1492                .last()
1493                .map_or(previous, |(status, _)| *status);
1494        }
1495
1496        if event.reconciliation && !self.filled_qty.is_zero() && event.quantity == self.filled_qty {
1497            self.status = OrderStatus::Filled;
1498            self.ts_closed = Some(event.ts_event);
1499        }
1500
1501        if let Some(venue_order_id) = &event.venue_order_id
1502            && (self.venue_order_id.is_none()
1503                || venue_order_id != self.venue_order_id.as_ref().unwrap())
1504        {
1505            self.venue_order_id = Some(*venue_order_id);
1506            self.venue_order_ids.push(*venue_order_id);
1507        }
1508
1509        self.is_quote_quantity = event.is_quote_quantity;
1510    }
1511
1512    /// Applies a new order quantity from an `OrderUpdated` event, keeping `leaves_qty` net of any
1513    /// non-reopened voided quantity so it does not become working again (see
1514    /// `docs/concepts/events/order_fill_voided.md`).
1515    pub(crate) fn apply_updated_quantity(&mut self, new_quantity: Quantity) {
1516        self.quantity = new_quantity;
1517        let unfilled_qty = self.quantity.saturating_sub(self.filled_qty);
1518        let voided_qty = self.non_reopened_voided_qty;
1519
1520        // A terminal update sets the quantity to the filled quantity, so a non-reopened void
1521        // exceeds what is unfilled without anything being wrong
1522        self.leaves_qty = if voided_qty > unfilled_qty {
1523            Quantity::zero(unfilled_qty.precision.max(voided_qty.precision))
1524        } else {
1525            unfilled_qty - voided_qty
1526        };
1527    }
1528
1529    fn filled(&mut self, event: &OrderFilled, source_status: OrderStatus) {
1530        let new_filled_qty = self
1531            .filled_qty
1532            .checked_add(event.last_qty)
1533            .expect("fill quantity bounds pre-checked");
1534
1535        if self.is_fill_report_order() && new_filled_qty > self.quantity {
1536            self.quantity = new_filled_qty;
1537            self.leaves_qty = event.last_qty;
1538        }
1539
1540        // Calculate overfill if any
1541        if new_filled_qty > self.quantity {
1542            let overfill = new_filled_qty - self.quantity;
1543            self.overfill_qty = self.overfill_qty.saturating_add(overfill);
1544        }
1545
1546        let new_leaves_qty = self.leaves_qty.saturating_sub(event.last_qty);
1547
1548        self.update_fill_status(event, source_status, new_filled_qty, new_leaves_qty);
1549        let is_historical_venue_order_id = self.venue_order_id.is_some_and(|current| {
1550            current != event.venue_order_id && self.venue_order_ids.contains(&event.venue_order_id)
1551        });
1552
1553        if !is_historical_venue_order_id {
1554            self.venue_order_id = Some(event.venue_order_id);
1555        }
1556        self.position_id = event.position_id;
1557        self.trade_ids.push(event.trade_id);
1558        self.last_trade_id = Some(event.trade_id);
1559        self.liquidity_side = Some(event.liquidity_side);
1560        self.filled_qty = new_filled_qty;
1561        self.leaves_qty = new_leaves_qty;
1562        self.ts_last = event.ts_event;
1563
1564        if let Some(commission) = event.commission {
1565            let commission_currency = commission.currency;
1566            if let Some(existing_commission) = self.commissions.get_mut(&commission_currency) {
1567                *existing_commission = *existing_commission + commission;
1568            } else {
1569                self.commissions.insert(commission_currency, commission);
1570            }
1571        }
1572
1573        if self.ts_accepted.is_none() {
1574            // Set ts_accepted to time of first fill if not previously set
1575            self.ts_accepted = Some(event.ts_event);
1576        }
1577
1578        if self.fill_totals.is_none() {
1579            self.fill_totals = Some(self.fill_totals_from_events());
1580        }
1581
1582        let totals = self.fill_totals.as_mut().expect("fill totals initialized");
1583        totals.add(event.last_qty.as_decimal(), event.last_px.as_decimal());
1584        self.avg_px = totals.average();
1585
1586        debug_assert!(
1587            matches!(
1588                self.status,
1589                OrderStatus::PartiallyFilled | OrderStatus::Filled | OrderStatus::Voided
1590            ) || (self.status == source_status
1591                && matches!(
1592                    source_status,
1593                    OrderStatus::Canceled
1594                        | OrderStatus::Expired
1595                        | OrderStatus::PendingUpdate
1596                        | OrderStatus::PendingCancel
1597                )),
1598            "Invariant: status must reflect the fill or preserve a closed or pending source status after fill handler (status={:?})",
1599            self.status
1600        );
1601        debug_assert!(
1602            self.venue_order_id.is_some()
1603                && self.last_trade_id.is_some()
1604                && !self.trade_ids.is_empty(),
1605            "Invariant: venue_order_id, last_trade_id, and trade_ids must be set after fill"
1606        );
1607        debug_assert!(
1608            self.filled_qty
1609                .saturating_add(self.voided_qty)
1610                .saturating_add(self.leaves_qty)
1611                >= self.quantity,
1612            "Invariant: filled_qty + voided_qty + leaves_qty >= quantity (filled={}, voided={}, leaves={}, quantity={})",
1613            self.filled_qty,
1614            self.voided_qty,
1615            self.leaves_qty,
1616            self.quantity
1617        );
1618    }
1619
1620    fn update_fill_status(
1621        &mut self,
1622        event: &OrderFilled,
1623        source_status: OrderStatus,
1624        new_filled_qty: Quantity,
1625        new_leaves_qty: Quantity,
1626    ) {
1627        if new_filled_qty >= self.quantity {
1628            self.status = OrderStatus::Filled;
1629            self.ts_closed = Some(event.ts_event);
1630        } else if new_leaves_qty.is_zero() && !self.voided_qty.is_zero() {
1631            self.status = OrderStatus::Voided;
1632            self.ts_closed = Some(event.ts_event);
1633        } else if matches!(source_status, OrderStatus::Canceled | OrderStatus::Expired) {
1634            self.status = source_status;
1635        } else {
1636            self.status = OrderStatus::PartiallyFilled;
1637
1638            if self.is_fill_report_order() {
1639                self.ts_closed = None;
1640            }
1641
1642            if matches!(
1643                source_status,
1644                OrderStatus::PendingUpdate | OrderStatus::PendingCancel,
1645            ) {
1646                self.previous_status = Some(self.status);
1647                self.status = source_status;
1648            }
1649        }
1650    }
1651
1652    fn is_fill_report_order(&self) -> bool {
1653        self.order_type == OrderType::Market
1654            && self.ts_submitted.is_none()
1655            && matches!(self.events.first(), Some(OrderEventAny::Initialized(init))
1656                if init.reconciliation && init.tags.as_ref().is_some_and(|tags|
1657                    tags.contains(&Ustr::from(FILL_REPORT_ORDER_TAG))))
1658    }
1659
1660    fn fill_record(&mut self, trade_id: TradeId) -> FillRecord {
1661        if self.fill_index.is_none() && self.events.len() >= FILL_INDEX_MIN_EVENTS {
1662            self.fill_index = Some(self.fill_index_from_events());
1663        }
1664
1665        if let Some(index) = &self.fill_index {
1666            return index.get(&trade_id).copied().unwrap_or_default();
1667        }
1668
1669        let mut record = FillRecord::default();
1670
1671        for event in &self.events {
1672            match event {
1673                OrderEventAny::Filled(fill) if fill.trade_id == trade_id => {
1674                    record.last_px = Some(fill.last_px);
1675                }
1676                OrderEventAny::FillVoided(void) if void.trade_id == trade_id => {
1677                    record.is_voided = true;
1678                }
1679                _ => {}
1680            }
1681        }
1682
1683        record
1684    }
1685
1686    fn fill_index_from_events(&self) -> AHashMap<TradeId, FillRecord> {
1687        let mut index = AHashMap::<TradeId, FillRecord>::new();
1688
1689        for event in &self.events {
1690            if let Some(trade_id) = fill_trade_id(event) {
1691                index.entry(*trade_id).or_default().update(event);
1692            }
1693        }
1694
1695        index
1696    }
1697
1698    fn restate_fill_price(&mut self, event: OrderEventAny) {
1699        self.ts_last = event.ts_event();
1700        self.push_event(event);
1701        let totals = self.fill_totals_from_events();
1702        self.avg_px = totals.average();
1703        self.fill_totals = Some(totals);
1704    }
1705
1706    fn push_event(&mut self, event: OrderEventAny) {
1707        if let Some(index) = &mut self.fill_index
1708            && let Some(trade_id) = fill_trade_id(&event)
1709        {
1710            index.entry(*trade_id).or_default().update(&event);
1711        }
1712
1713        self.events.push(event);
1714    }
1715
1716    fn fill_totals_from_events(&self) -> FillTotals {
1717        let corrections = self.fill_corrections(None);
1718        let prices = self.accounting_prices();
1719        let mut totals = FillTotals::default();
1720
1721        for fill in self.quantity_fills() {
1722            let removed = Self::removed_fill_qty(fill, corrections.get(&fill.trade_id).copied());
1723            let effective = (fill.last_qty - removed).as_decimal();
1724            if !effective.is_zero() {
1725                let price = prices
1726                    .get(&fill.trade_id)
1727                    .copied()
1728                    .unwrap_or(fill.last_px.as_decimal());
1729                totals.add(effective, price);
1730            }
1731        }
1732
1733        totals
1734    }
1735
1736    fn quantity_fills(&self) -> Vec<&OrderFilled> {
1737        let mut seen = AHashSet::new();
1738        let mut fills = Vec::new();
1739
1740        for candidate in &self.events {
1741            let OrderEventAny::Filled(fill) = candidate else {
1742                continue;
1743            };
1744
1745            if seen.insert(fill.trade_id) {
1746                fills.push(fill);
1747            }
1748        }
1749
1750        fills
1751    }
1752
1753    fn accounting_prices(&self) -> AHashMap<TradeId, Decimal> {
1754        let mut prices = AHashMap::new();
1755
1756        for candidate in &self.events {
1757            if let OrderEventAny::Filled(fill) = candidate {
1758                prices.insert(fill.trade_id, fill.last_px.as_decimal());
1759            }
1760        }
1761
1762        prices
1763    }
1764
1765    fn fill_corrections<'a>(
1766        &'a self,
1767        additional: Option<&'a OrderFillVoided>,
1768    ) -> IndexMap<TradeId, &'a OrderFillVoided> {
1769        let mut corrections = IndexMap::new();
1770
1771        for candidate in &self.events {
1772            if let OrderEventAny::FillVoided(event) = candidate {
1773                corrections.insert(event.trade_id, event);
1774            }
1775        }
1776
1777        if let Some(event) = additional {
1778            corrections.insert(event.trade_id, event);
1779        }
1780
1781        corrections
1782    }
1783
1784    fn removed_fill_qty(fill: &OrderFilled, correction: Option<&OrderFillVoided>) -> Quantity {
1785        correction.map_or_else(
1786            || Quantity::zero(fill.last_qty.precision),
1787            |event| event.voided_qty.min(fill.last_qty),
1788        )
1789    }
1790
1791    pub fn set_slippage(&mut self, price: Price) {
1792        self.slippage = self.avg_px.and_then(|avg_px| {
1793            let current_price = price.as_decimal();
1794            match self.side {
1795                OrderSide::Buy if avg_px > current_price => avg_px.checked_sub(current_price),
1796                OrderSide::Sell if avg_px < current_price => current_price.checked_sub(avg_px),
1797                _ => None,
1798            }
1799        });
1800    }
1801
1802    /// Returns the opposite order side.
1803    #[must_use]
1804    pub fn opposite_side(side: OrderSide) -> OrderSide {
1805        side.opposite()
1806    }
1807
1808    /// Returns the order side needed to close a position.
1809    #[must_use]
1810    pub fn closing_side(side: PositionSide) -> Option<OrderSide> {
1811        match side {
1812            PositionSide::Long => Some(OrderSide::Sell),
1813            PositionSide::Short => Some(OrderSide::Buy),
1814            PositionSide::Flat => None,
1815        }
1816    }
1817
1818    #[must_use]
1819    pub fn signed_decimal_qty(&self) -> Decimal {
1820        match self.side {
1821            OrderSide::Buy => self.quantity.as_decimal(),
1822            OrderSide::Sell => -self.quantity.as_decimal(),
1823        }
1824    }
1825
1826    #[must_use]
1827    pub fn would_reduce_only(&self, side: PositionSide, position_qty: Quantity) -> bool {
1828        if side == PositionSide::Flat {
1829            return false;
1830        }
1831
1832        match (self.side, side) {
1833            (OrderSide::Buy, PositionSide::Long) => false,
1834            (OrderSide::Buy, PositionSide::Short) => self.leaves_qty <= position_qty,
1835            (OrderSide::Sell, PositionSide::Short) => false,
1836            (OrderSide::Sell, PositionSide::Long) => self.leaves_qty <= position_qty,
1837            (_, PositionSide::Flat) => false,
1838        }
1839    }
1840
1841    #[must_use]
1842    pub fn commission(&self, currency: &Currency) -> Option<Money> {
1843        self.commissions.get(currency).copied()
1844    }
1845
1846    #[must_use]
1847    pub fn commissions(&self) -> IndexMap<Currency, Money> {
1848        self.commissions.clone()
1849    }
1850
1851    #[must_use]
1852    pub fn commissions_vec(&self) -> Vec<Money> {
1853        self.commissions.values().copied().collect()
1854    }
1855
1856    /// Returns the order events in application order.
1857    #[must_use]
1858    pub fn events(&self) -> &[OrderEventAny] {
1859        &self.events
1860    }
1861
1862    /// Prepends historical events in iterator order without applying their state transitions.
1863    ///
1864    /// Used when transforming an order into another type. The next fill rebuilds the
1865    /// average-price fold from the combined history; other derived state is unchanged.
1866    pub fn prepend_events(&mut self, events: impl IntoIterator<Item = OrderEventAny>) {
1867        self.fill_totals = None;
1868        self.fill_index = None;
1869        self.events.splice(..0, events);
1870    }
1871
1872    /// Restores metadata omitted by order constructors when converting an [`OrderInitialized`].
1873    pub(crate) fn set_init_metadata(
1874        &mut self,
1875        reconciliation: bool,
1876        causation_id: Option<UUID4>,
1877        ts_init: UnixNanos,
1878    ) {
1879        if let Some(OrderEventAny::Initialized(init)) = self.events.first_mut() {
1880            init.reconciliation = reconciliation;
1881            init.causation_id = causation_id;
1882            init.ts_init = ts_init;
1883        }
1884    }
1885
1886    #[must_use]
1887    pub fn init_event(&self) -> Option<OrderEventAny> {
1888        self.events.first().cloned()
1889    }
1890}
1891
1892// Keep the chronological fold, not a value reconstructed from the rounded average,
1893// corrections rebuild it because saturation and Decimal rounding are not reversible.
1894#[derive(Clone, Debug, Default)]
1895struct FillTotals {
1896    notional: Decimal,
1897    quantity: Decimal,
1898}
1899
1900impl FillTotals {
1901    fn add(&mut self, quantity: Decimal, price: Decimal) {
1902        self.notional = self.notional.saturating_add(quantity.saturating_mul(price));
1903        self.quantity = self.quantity.saturating_add(quantity);
1904    }
1905
1906    fn average(&self) -> Option<Decimal> {
1907        self.notional.checked_div(self.quantity)
1908    }
1909}
1910
1911// What `events` holds for one trade ID: the latest fill price and whether a fill void exists.
1912// A present `fill_index` equals folding every fill and fill void in history order, and
1913// `push_event` keeps it so. Deserialization and prepended history leave it absent; the next
1914// fill then scans, or rebuilds it once history reaches `FILL_INDEX_MIN_EVENTS`.
1915// Fill arithmetic stays with `FillTotals`.
1916#[derive(Clone, Copy, Debug, Default)]
1917struct FillRecord {
1918    last_px: Option<Price>,
1919    is_voided: bool,
1920}
1921
1922impl FillRecord {
1923    fn update(&mut self, event: &OrderEventAny) {
1924        match event {
1925            OrderEventAny::Filled(fill) => self.last_px = Some(fill.last_px),
1926            OrderEventAny::FillVoided(_) => self.is_voided = true,
1927            _ => {}
1928        }
1929    }
1930}
1931
1932fn fill_trade_id(event: &OrderEventAny) -> Option<&TradeId> {
1933    match event {
1934        OrderEventAny::Filled(fill) => Some(&fill.trade_id),
1935        OrderEventAny::FillVoided(void) => Some(&void.trade_id),
1936        _ => None,
1937    }
1938}
1939
1940#[cfg(test)]
1941mod tests {
1942    use std::str::FromStr;
1943
1944    use rstest::rstest;
1945    use rust_decimal_macros::dec;
1946    use strum::IntoEnumIterator;
1947
1948    use super::*;
1949    use crate::{
1950        enums::{
1951            LiquiditySide, OrderSide, OrderStatus, OrderType, PositionSide, TrailingOffsetType,
1952            TriggerType,
1953        },
1954        events::order::spec::{
1955            OrderAcceptedSpec, OrderCancelDeniedSpec, OrderCancelRejectedSpec, OrderCanceledSpec,
1956            OrderDeniedSpec, OrderExpiredSpec, OrderFillVoidedSpec, OrderFilledSpec,
1957            OrderInitializedSpec, OrderModifyDeniedSpec, OrderModifyRejectedSpec,
1958            OrderPendingCancelSpec, OrderPendingUpdateSpec, OrderRejectedSpec, OrderSubmittedSpec,
1959            OrderTriggeredSpec, OrderUpdatedSpec,
1960        },
1961        identifiers::InstrumentId,
1962        instruments::{CurrencyPair, Instrument, InstrumentAny, stubs::audusd_sim},
1963        orders::{MarketOrder, builder::OrderTestBuilder, stubs::TestOrderStubs},
1964        stubs::TestDefault,
1965        types::{
1966            Price, Quantity,
1967            money::{MONEY_RAW_MAX, MONEY_RAW_MIN, MoneyRaw},
1968            quantity::{QUANTITY_RAW_MAX, QuantityRaw},
1969        },
1970    };
1971
1972    // TODO: WIP
1973    // fn test_display_market_order() {
1974    //     let order = MarketOrder::default();
1975    //     assert_eq!(order.events().len(), 1);
1976    //     assert_eq!(
1977    //         stringify!(order.events().get(0)),
1978    //         stringify!(OrderInitialized)
1979    //     );
1980    // }
1981
1982    #[rstest]
1983    #[case(OrderSide::Buy, OrderSide::Sell)]
1984    #[case(OrderSide::Sell, OrderSide::Buy)]
1985    fn test_order_opposite_side(#[case] order_side: OrderSide, #[case] expected_side: OrderSide) {
1986        let result = OrderCore::opposite_side(order_side);
1987        assert_eq!(result, expected_side);
1988    }
1989
1990    #[rstest]
1991    #[case(PositionSide::Long, Some(OrderSide::Sell))]
1992    #[case(PositionSide::Short, Some(OrderSide::Buy))]
1993    #[case(PositionSide::Flat, None)]
1994    fn test_closing_side(
1995        #[case] position_side: PositionSide,
1996        #[case] expected_side: Option<OrderSide>,
1997    ) {
1998        let result = OrderCore::closing_side(position_side);
1999        assert_eq!(result, expected_side);
2000    }
2001
2002    #[rstest]
2003    #[case(OrderSide::Buy, dec!(10_000))]
2004    #[case(OrderSide::Sell, dec!(-10_000))]
2005    fn test_signed_decimal_qty(#[case] order_side: OrderSide, #[case] expected: Decimal) {
2006        let order: MarketOrder = OrderInitializedSpec::builder()
2007            .order_side(order_side)
2008            .quantity(Quantity::from(10_000))
2009            .build()
2010            .try_into()
2011            .unwrap();
2012
2013        let result = order.signed_decimal_qty();
2014        assert_eq!(result, expected);
2015    }
2016
2017    #[rustfmt::skip]
2018    #[rstest]
2019    #[case(OrderSide::Buy, Quantity::from(100), PositionSide::Long, Quantity::from(50), false)]
2020    #[case(OrderSide::Buy, Quantity::from(50), PositionSide::Short, Quantity::from(50), true)]
2021    #[case(OrderSide::Buy, Quantity::from(50), PositionSide::Short, Quantity::from(100), true)]
2022    #[case(OrderSide::Buy, Quantity::from(50), PositionSide::Flat, Quantity::from(0), false)]
2023    #[case(OrderSide::Sell, Quantity::from(50), PositionSide::Flat, Quantity::from(0), false)]
2024    #[case(OrderSide::Sell, Quantity::from(50), PositionSide::Long, Quantity::from(50), true)]
2025    #[case(OrderSide::Sell, Quantity::from(50), PositionSide::Long, Quantity::from(100), true)]
2026    #[case(OrderSide::Sell, Quantity::from(100), PositionSide::Short, Quantity::from(50), false)]
2027    fn test_would_reduce_only(
2028        #[case] order_side: OrderSide,
2029        #[case] order_qty: Quantity,
2030        #[case] position_side: PositionSide,
2031        #[case] position_qty: Quantity,
2032        #[case] expected: bool,
2033    ) {
2034        let order: MarketOrder = OrderInitializedSpec::builder()
2035            .order_side(order_side)
2036            .quantity(order_qty)
2037            .build()
2038            .try_into()
2039            .unwrap();
2040
2041        assert_eq!(
2042            order.would_reduce_only(position_side, position_qty),
2043            expected
2044        );
2045    }
2046
2047    #[rstest]
2048    fn test_order_state_transition_denied() {
2049        let mut order: MarketOrder = OrderInitializedSpec::builder().build().try_into().unwrap();
2050        let denied = OrderDeniedSpec::builder().build();
2051        let event = OrderEventAny::Denied(denied);
2052
2053        order.apply(event.clone()).unwrap();
2054
2055        assert_eq!(order.status, OrderStatus::Denied);
2056        assert!(order.is_closed());
2057        assert!(!order.is_open());
2058        assert_eq!(order.event_count(), 2);
2059        assert_eq!(order.last_event(), &event);
2060    }
2061
2062    #[rstest]
2063    fn test_order_life_cycle_to_filled() {
2064        let init = OrderInitializedSpec::builder().build();
2065        let submitted = OrderSubmittedSpec::builder().build();
2066        let accepted = OrderAcceptedSpec::builder().build();
2067        let filled = OrderFilledSpec::builder().build();
2068
2069        let mut order: MarketOrder = init.clone().try_into().unwrap();
2070        order.apply(OrderEventAny::Submitted(submitted)).unwrap();
2071        order.apply(OrderEventAny::Accepted(accepted)).unwrap();
2072        order.apply(OrderEventAny::Filled(filled)).unwrap();
2073
2074        assert_eq!(order.client_order_id, init.client_order_id);
2075        assert_eq!(order.status(), OrderStatus::Filled);
2076        assert_eq!(order.filled_qty(), Quantity::from(100_000));
2077        assert_eq!(order.leaves_qty(), Quantity::from(0));
2078        assert_eq!(order.avg_px(), Some(dec!(1.0)));
2079        assert!(!order.is_open());
2080        assert!(order.is_closed());
2081        assert_eq!(order.commission(&Currency::USD()), None);
2082        assert_eq!(order.commissions(), &IndexMap::new());
2083    }
2084
2085    #[rstest]
2086    fn test_order_life_cycle_fills_with_negative_prices() {
2087        // Options and spreads can legitimately trade at negative prices. The
2088        // weighted average-price update must not panic when `last_px` or the
2089        // prior `avg_px` is below zero.
2090        let init = OrderInitializedSpec::builder()
2091            .quantity(Quantity::from(100_000))
2092            .build();
2093        let submitted = OrderSubmittedSpec::builder().build();
2094        let accepted = OrderAcceptedSpec::builder().build();
2095        let fill1 = OrderFilledSpec::builder()
2096            .last_qty(Quantity::from(50_000))
2097            .last_px(Price::from("-5.00000"))
2098            .trade_id(TradeId::from("TRADE-1"))
2099            .build();
2100        let fill2 = OrderFilledSpec::builder()
2101            .last_qty(Quantity::from(50_000))
2102            .last_px(Price::from("-7.00000"))
2103            .trade_id(TradeId::from("TRADE-2"))
2104            .build();
2105
2106        let mut order: MarketOrder = init.try_into().unwrap();
2107        order.apply(OrderEventAny::Submitted(submitted)).unwrap();
2108        order.apply(OrderEventAny::Accepted(accepted)).unwrap();
2109        order.apply(OrderEventAny::Filled(fill1)).unwrap();
2110        order.apply(OrderEventAny::Filled(fill2)).unwrap();
2111
2112        assert_eq!(order.status(), OrderStatus::Filled);
2113        assert_eq!(order.filled_qty(), Quantity::from(100_000));
2114        assert_eq!(order.leaves_qty(), Quantity::from(0));
2115        // Weighted avg: (50_000 * -5.0 + 50_000 * -7.0) / 100_000 = -6.0
2116        assert_eq!(order.avg_px(), Some(dec!(-6.0)));
2117    }
2118
2119    fn fill(trade_id: &str, last_qty: &str, last_px: &str) -> (TradeId, Quantity, Price) {
2120        (
2121            TradeId::from(trade_id),
2122            Quantity::from(last_qty),
2123            Price::from(last_px),
2124        )
2125    }
2126
2127    fn market_order_with_fills(
2128        order_side: OrderSide,
2129        quantity: Quantity,
2130        fills: &[(TradeId, Quantity, Price)],
2131    ) -> MarketOrder {
2132        let mut order: MarketOrder = OrderInitializedSpec::builder()
2133            .order_side(order_side)
2134            .quantity(quantity)
2135            .build()
2136            .try_into()
2137            .unwrap();
2138        order
2139            .apply(OrderEventAny::Accepted(
2140                OrderAcceptedSpec::builder().build(),
2141            ))
2142            .unwrap();
2143
2144        for (trade_id, last_qty, last_px) in fills {
2145            order
2146                .apply(OrderEventAny::Filled(
2147                    OrderFilledSpec::builder()
2148                        .order_side(order_side)
2149                        .trade_id(*trade_id)
2150                        .last_qty(*last_qty)
2151                        .last_px(*last_px)
2152                        .build(),
2153                ))
2154                .unwrap();
2155        }
2156
2157        order
2158    }
2159
2160    // Lengthens history with events that leave fill state unchanged
2161    fn pad_history(order: &mut MarketOrder, count: usize) {
2162        for _ in 0..count {
2163            order
2164                .apply(OrderEventAny::Updated(
2165                    OrderUpdatedSpec::builder()
2166                        .quantity(order.quantity())
2167                        .build(),
2168                ))
2169                .unwrap();
2170        }
2171    }
2172
2173    // The initialized and accepted events complete the shortest indexed history
2174    const INDEXED_PADDING: usize = FILL_INDEX_MIN_EVENTS - 2;
2175
2176    #[rstest]
2177    fn test_fill_totals_survive_corrections_and_restoration(
2178        #[values("clone", "snapshot", "replay")] restoration: &str,
2179        #[values(0, INDEXED_PADDING)] padding: usize,
2180    ) {
2181        let mut order = market_order_with_fills(OrderSide::Buy, Quantity::from(20), &[]);
2182        pad_history(&mut order, padding);
2183        let first = OrderFilledSpec::builder()
2184            .trade_id(TradeId::from("T-1"))
2185            .last_qty(Quantity::from(4))
2186            .last_px(Price::from("1.00"))
2187            .build();
2188        let second = OrderFilledSpec::builder()
2189            .trade_id(TradeId::from("T-2"))
2190            .last_qty(Quantity::from(2))
2191            .last_px(Price::from("2.00"))
2192            .build();
2193        let third = OrderFilledSpec::builder()
2194            .trade_id(TradeId::from("T-3"))
2195            .last_qty(Quantity::from(1))
2196            .last_px(Price::from("-3.00"))
2197            .build();
2198        let fourth = OrderFilledSpec::builder()
2199            .trade_id(TradeId::from("T-4"))
2200            .last_qty(Quantity::from(2))
2201            .last_px(Price::from("0.15"))
2202            .build();
2203        let mut restated = first.clone();
2204        restated.last_px = Price::from("1.50");
2205
2206        let steps = [
2207            (
2208                OrderEventAny::Filled(first.clone()),
2209                false,
2210                4,
2211                0,
2212                16,
2213                Some(dec!(1)),
2214            ),
2215            (
2216                OrderEventAny::Filled(second.clone()),
2217                false,
2218                6,
2219                0,
2220                14,
2221                Some(dec!(1.3333333333333333333333333333)),
2222            ),
2223            (
2224                OrderEventAny::Filled(first.clone()),
2225                true,
2226                6,
2227                0,
2228                14,
2229                Some(dec!(1.3333333333333333333333333333)),
2230            ),
2231            (
2232                OrderEventAny::Filled(restated.clone()),
2233                false,
2234                6,
2235                0,
2236                14,
2237                Some(dec!(1.6666666666666666666666666667)),
2238            ),
2239            (
2240                OrderEventAny::Filled(restated),
2241                true,
2242                6,
2243                0,
2244                14,
2245                Some(dec!(1.6666666666666666666666666667)),
2246            ),
2247            (
2248                OrderEventAny::Filled(first.clone()),
2249                false,
2250                6,
2251                0,
2252                14,
2253                Some(dec!(1.3333333333333333333333333333)),
2254            ),
2255            (
2256                OrderEventAny::FillVoided(matching_fill_void(&first, Quantity::from(1), None)),
2257                false,
2258                5,
2259                1,
2260                15,
2261                Some(dec!(1.4)),
2262            ),
2263            (
2264                OrderEventAny::FillVoided(matching_fill_void(&first, Quantity::from(3), None)),
2265                false,
2266                3,
2267                3,
2268                17,
2269                Some(dec!(1.6666666666666666666666666667)),
2270            ),
2271            (
2272                OrderEventAny::Filled(third.clone()),
2273                false,
2274                4,
2275                3,
2276                16,
2277                Some(dec!(0.5)),
2278            ),
2279            (
2280                OrderEventAny::FillVoided(matching_fill_void(&first, Quantity::from(4), None)),
2281                false,
2282                3,
2283                4,
2284                17,
2285                Some(dec!(0.3333333333333333333333333333)),
2286            ),
2287            (
2288                OrderEventAny::Filled(first.clone()),
2289                true,
2290                3,
2291                4,
2292                17,
2293                Some(dec!(0.3333333333333333333333333333)),
2294            ),
2295            (
2296                OrderEventAny::FillVoided(matching_fill_void(&second, Quantity::from(2), None)),
2297                false,
2298                1,
2299                6,
2300                19,
2301                Some(dec!(-3)),
2302            ),
2303            (
2304                OrderEventAny::FillVoided(matching_fill_void(&third, Quantity::from(1), None)),
2305                false,
2306                0,
2307                7,
2308                20,
2309                None,
2310            ),
2311            (
2312                OrderEventAny::Filled(fourth),
2313                false,
2314                2,
2315                7,
2316                18,
2317                Some(dec!(0.15)),
2318            ),
2319        ];
2320        let mut expected_events = OrderCore::events(&order).to_vec();
2321
2322        for (event, is_duplicate, filled, voided, leaves, average) in steps {
2323            let mut restored = match restoration {
2324                "clone" => order.clone(),
2325                "snapshot" => {
2326                    let snapshot = serde_json::to_value(&order).unwrap();
2327                    assert!(
2328                        !snapshot["core"]
2329                            .as_object()
2330                            .unwrap()
2331                            .contains_key("fill_totals")
2332                    );
2333                    serde_json::from_value(snapshot).unwrap()
2334                }
2335                "replay" => {
2336                    let replayed = OrderAny::from_events(expected_events.clone()).unwrap();
2337
2338                    let OrderAny::Market(replayed) = replayed else {
2339                        panic!("Expected a market order");
2340                    };
2341
2342                    replayed
2343                }
2344                _ => unreachable!(),
2345            };
2346
2347            let result = order.apply(event.clone());
2348            let restored_result = restored.apply(event.clone());
2349
2350            if is_duplicate {
2351                assert!(matches!(
2352                    result,
2353                    Err(OrderError::DuplicateFill(trade_id)) if trade_id == first.trade_id
2354                ));
2355                assert!(matches!(
2356                    restored_result,
2357                    Err(OrderError::DuplicateFill(trade_id)) if trade_id == first.trade_id
2358                ));
2359            } else {
2360                result.unwrap();
2361                restored_result.unwrap();
2362                expected_events.push(event);
2363            }
2364
2365            assert_eq!(restored.avg_px(), average);
2366            assert_eq!(restored.filled_qty(), Quantity::from(filled));
2367            assert_eq!(restored.voided_qty(), Quantity::from(voided));
2368            assert_eq!(restored.leaves_qty(), Quantity::from(leaves));
2369            assert_eq!(OrderCore::events(&restored), expected_events);
2370            assert_eq!(
2371                serde_json::to_value(&restored).unwrap(),
2372                serde_json::to_value(&order).unwrap()
2373            );
2374            order = restored;
2375        }
2376
2377        let mut records: Vec<_> = order
2378            .fill_index
2379            .iter()
2380            .flatten()
2381            .map(|(trade_id, record)| (trade_id.to_string(), record.last_px, record.is_voided))
2382            .collect();
2383        records.sort_by(|a, b| a.0.cmp(&b.0));
2384
2385        let expected_records = if padding == 0 {
2386            vec![]
2387        } else {
2388            vec![
2389                ("T-1".to_string(), Some(Price::from("1.00")), true),
2390                ("T-2".to_string(), Some(Price::from("2.00")), true),
2391                ("T-3".to_string(), Some(Price::from("-3.00")), true),
2392                ("T-4".to_string(), Some(Price::from("0.15")), false),
2393            ]
2394        };
2395
2396        assert_eq!(order.fill_index.is_some(), padding == INDEXED_PADDING);
2397        assert_eq!(records, expected_records);
2398    }
2399
2400    #[rstest]
2401    #[case::scanned(0)]
2402    #[case::indexed(INDEXED_PADDING)]
2403    fn test_prepended_events_invalidate_fill_totals_without_applying_state(#[case] padding: usize) {
2404        let mut order = market_order_with_fills(OrderSide::Buy, Quantity::from(10), &[]);
2405        pad_history(&mut order, padding);
2406        order
2407            .apply(OrderEventAny::Filled(
2408                OrderFilledSpec::builder()
2409                    .trade_id(TradeId::from("T-CURRENT"))
2410                    .last_qty(Quantity::from(1))
2411                    .last_px(Price::from("2.00"))
2412                    .build(),
2413            ))
2414            .unwrap();
2415        assert_eq!(order.fill_index.is_some(), padding == INDEXED_PADDING);
2416
2417        let historical = [
2418            OrderEventAny::Filled(
2419                OrderFilledSpec::builder()
2420                    .trade_id(TradeId::from("T-PAST-1"))
2421                    .last_qty(Quantity::from(2))
2422                    .last_px(Price::from("3.00"))
2423                    .build(),
2424            ),
2425            OrderEventAny::Filled(
2426                OrderFilledSpec::builder()
2427                    .trade_id(TradeId::from("T-PAST-2"))
2428                    .last_qty(Quantity::from(1))
2429                    .last_px(Price::from("4.00"))
2430                    .build(),
2431            ),
2432        ];
2433        let mut expected_events = historical.to_vec();
2434        expected_events.extend_from_slice(OrderCore::events(&order));
2435        let duplicate = historical[0].clone();
2436        order.prepend_events(historical);
2437        assert_eq!(OrderCore::events(&order), expected_events);
2438        assert_eq!(order.avg_px(), Some(dec!(2)));
2439        assert_eq!(order.filled_qty(), Quantity::from(1));
2440        assert_eq!(order.leaves_qty(), Quantity::from(9));
2441        assert!(matches!(
2442            order.apply(duplicate),
2443            Err(OrderError::DuplicateFill(trade_id)) if trade_id == TradeId::from("T-PAST-1")
2444        ));
2445
2446        let next = OrderEventAny::Filled(
2447            OrderFilledSpec::builder()
2448                .trade_id(TradeId::from("T-NEXT"))
2449                .last_qty(Quantity::from(2))
2450                .last_px(Price::from("3.00"))
2451                .build(),
2452        );
2453        expected_events.push(next.clone());
2454        order.apply(next).unwrap();
2455
2456        assert_eq!(OrderCore::events(&order), expected_events);
2457        assert_eq!(order.avg_px(), Some(dec!(3)));
2458        assert_eq!(order.filled_qty(), Quantity::from(3));
2459        assert_eq!(order.leaves_qty(), Quantity::from(7));
2460        assert_eq!(order.voided_qty(), Quantity::from(0));
2461    }
2462
2463    #[rstest]
2464    fn test_restored_fill_totals_use_history_instead_of_snapshot_average() {
2465        let order = market_order_with_fills(
2466            OrderSide::Buy,
2467            Quantity::from(10),
2468            &[fill("T-1", "1", "0.10"), fill("T-2", "2", "0.20")],
2469        );
2470        let mut snapshot = serde_json::to_value(&order).unwrap();
2471        snapshot["core"]["avg_px"] = serde_json::to_value(dec!(99)).unwrap();
2472        let mut restored: MarketOrder = serde_json::from_value(snapshot).unwrap();
2473        restored
2474            .apply(OrderEventAny::Filled(
2475                OrderFilledSpec::builder()
2476                    .trade_id(TradeId::from("T-3"))
2477                    .last_qty(Quantity::from(2))
2478                    .last_px(Price::from("0.35"))
2479                    .build(),
2480            ))
2481            .unwrap();
2482
2483        assert_eq!(restored.avg_px(), Some(dec!(0.24)));
2484        assert_eq!(restored.filled_qty(), Quantity::from(5));
2485        assert_eq!(restored.leaves_qty(), Quantity::from(5));
2486        assert_eq!(restored.voided_qty(), Quantity::from(0));
2487    }
2488
2489    #[rstest]
2490    #[case::scanned(0)]
2491    #[case::indexed(INDEXED_PADDING)]
2492    fn test_restored_unknown_fill_void_applies_after_matching_fill(#[case] padding: usize) {
2493        let mut order = market_order_with_fills(OrderSide::Buy, Quantity::from(10), &[]);
2494        pad_history(&mut order, padding);
2495        let first = OrderFilledSpec::builder()
2496            .trade_id(TradeId::from("T-RESTORED"))
2497            .last_qty(Quantity::from(4))
2498            .last_px(Price::from("1.00"))
2499            .build();
2500        let mut correction = matching_fill_void(&first, Quantity::from(2), None);
2501        correction.is_reopened = false;
2502        order.apply(OrderEventAny::FillVoided(correction)).unwrap();
2503        let mut snapshot = serde_json::to_value(&order).unwrap();
2504        snapshot["core"]["status"] = serde_json::to_value(OrderStatus::Accepted).unwrap();
2505        snapshot["core"]["leaves_qty"] = serde_json::to_value(Quantity::from(8)).unwrap();
2506        let mut restored: MarketOrder = serde_json::from_value(snapshot).unwrap();
2507        restored.apply(OrderEventAny::Filled(first)).unwrap();
2508        assert_eq!(restored.avg_px(), Some(dec!(1)));
2509
2510        restored
2511            .apply(OrderEventAny::Filled(
2512                OrderFilledSpec::builder()
2513                    .trade_id(TradeId::from("T-NEXT"))
2514                    .last_qty(Quantity::from(2))
2515                    .last_px(Price::from("3.00"))
2516                    .build(),
2517            ))
2518            .unwrap();
2519
2520        assert_eq!(restored.avg_px(), Some(dec!(2)));
2521        assert_eq!(restored.filled_qty(), Quantity::from(6));
2522        assert_eq!(restored.voided_qty(), Quantity::from(2));
2523        assert_eq!(restored.leaves_qty(), Quantity::from(2));
2524    }
2525
2526    #[rstest]
2527    #[case::positive(Decimal::MAX, Decimal::ONE, Decimal::MAX)]
2528    #[case::negative(Decimal::MIN, -Decimal::ONE, Decimal::MIN)]
2529    fn test_fill_totals_preserve_saturation_order(
2530        #[case] price: Decimal,
2531        #[case] increment: Decimal,
2532        #[case] saturated: Decimal,
2533    ) {
2534        let mut totals = FillTotals::default();
2535        totals.add(dec!(2), price);
2536        totals.add(Decimal::ONE, increment);
2537        totals.add(Decimal::ONE, -increment);
2538
2539        assert_eq!(totals.notional, saturated - increment);
2540        assert_eq!(totals.quantity, dec!(4));
2541        assert_eq!(
2542            totals.average(),
2543            (saturated - increment).checked_div(dec!(4))
2544        );
2545    }
2546
2547    #[rstest]
2548    fn test_fill_totals_preserve_quantity_saturation() {
2549        let mut totals = FillTotals::default();
2550        totals.add(Decimal::MAX, Decimal::ZERO);
2551        totals.add(Decimal::ONE, Decimal::ONE);
2552
2553        assert_eq!(totals.notional, Decimal::ONE);
2554        assert_eq!(totals.quantity, Decimal::MAX);
2555        assert_eq!(totals.average(), Decimal::ONE.checked_div(Decimal::MAX));
2556    }
2557
2558    #[rstest]
2559    #[case(OrderSide::Buy)]
2560    #[case(OrderSide::Sell)]
2561    fn test_avg_px_weighted_average_is_exact(#[case] order_side: OrderSide) {
2562        // (1 * 0.07) + (2 * 0.13) + (3 * 0.29) = 1.20 over 6 filled, so the exact average is
2563        // 0.20. Accumulating the notional in f64 returns 0.19999999999999998 instead.
2564        let order = market_order_with_fills(
2565            order_side,
2566            Quantity::from(6),
2567            &[
2568                fill("TRADE-1", "1", "0.07"),
2569                fill("TRADE-2", "2", "0.13"),
2570                fill("TRADE-3", "3", "0.29"),
2571            ],
2572        );
2573
2574        assert_eq!(order.status(), OrderStatus::Filled);
2575        assert_eq!(order.filled_qty(), Quantity::from(6));
2576        assert_eq!(order.leaves_qty(), Quantity::from(0));
2577        assert_eq!(order.voided_qty(), Quantity::from(0));
2578        assert_eq!(order.avg_px(), Some(dec!(0.2)));
2579    }
2580
2581    #[rstest]
2582    fn test_avg_px_keeps_a_quotient_no_f64_can_hold() {
2583        // (1 * 1.00) + (2 * 2.00) = 5.00 over 3 filled. The exact quotient repeats, so `Decimal`
2584        // carries it to its full 28-place scale where the widest `f64` holds 1.6666666666666667.
2585        let order = market_order_with_fills(
2586            OrderSide::Buy,
2587            Quantity::from(3),
2588            &[fill("TRADE-1", "1", "1.00"), fill("TRADE-2", "2", "2.00")],
2589        );
2590
2591        assert_eq!(order.status(), OrderStatus::Filled);
2592        assert_eq!(order.filled_qty(), Quantity::from(3));
2593        assert_eq!(order.avg_px(), Some(dec!(1.6666666666666666666666666667)));
2594        assert_ne!(
2595            order.avg_px(),
2596            Some(Decimal::from_f64_retain(5.0_f64 / 3.0).unwrap())
2597        );
2598    }
2599
2600    #[rstest]
2601    #[case(OrderSide::Buy, "1.07", "1.00", Some(dec!(0.07)))]
2602    #[case(OrderSide::Sell, "0.93", "1.00", Some(dec!(0.07)))]
2603    #[case(OrderSide::Buy, "0.93", "1.00", None)]
2604    #[case(OrderSide::Sell, "1.07", "1.00", None)]
2605    fn test_set_slippage_by_side(
2606        #[case] order_side: OrderSide,
2607        #[case] fill_px: &str,
2608        #[case] reference_px: &str,
2609        #[case] expected: Option<Decimal>,
2610    ) {
2611        // Slippage only accrues against the order: a buy filled above the reference price and a
2612        // sell filled below it. The opposite cases are price improvement and stay `None`.
2613        let mut order =
2614            market_order_with_fills(order_side, Quantity::from(1), &[fill("T-1", "1", fill_px)]);
2615
2616        order.set_slippage(Price::from(reference_px));
2617
2618        assert_eq!(order.avg_px(), Some(Decimal::from_str(fill_px).unwrap()));
2619        assert_eq!(order.slippage(), expected);
2620    }
2621
2622    #[rstest]
2623    #[case::limit(OrderType::Limit)]
2624    #[case::limit_if_touched(OrderType::LimitIfTouched)]
2625    #[case::market_if_touched(OrderType::MarketIfTouched)]
2626    #[case::market_to_limit(OrderType::MarketToLimit)]
2627    #[case::stop_limit(OrderType::StopLimit)]
2628    #[case::stop_market(OrderType::StopMarket)]
2629    #[case::trailing_stop_limit(OrderType::TrailingStopLimit)]
2630    #[case::trailing_stop_market(OrderType::TrailingStopMarket)]
2631    fn test_fill_void_recomputes_slippage(#[case] order_type: OrderType) {
2632        let venue_order_id = VenueOrderId::from("V-SLIPPAGE");
2633        let account_id = AccountId::from("SIM-SLIPPAGE");
2634        let mut order = OrderTestBuilder::new(order_type)
2635            .instrument_id(InstrumentId::from("ETHUSDT-LINEAR.BYBIT"))
2636            .client_order_id(ClientOrderId::from("O-SLIPPAGE"))
2637            .side(OrderSide::Buy)
2638            .quantity(Quantity::from(10))
2639            .price(Price::from("100.00"))
2640            .trigger_price(Price::from("100.00"))
2641            .trigger_type(TriggerType::LastPrice)
2642            .limit_offset(dec!(1))
2643            .trailing_offset(dec!(1))
2644            .trailing_offset_type(TrailingOffsetType::Price)
2645            .build();
2646        let accepted = OrderAcceptedSpec::builder()
2647            .trader_id(order.trader_id())
2648            .strategy_id(order.strategy_id())
2649            .instrument_id(order.instrument_id())
2650            .client_order_id(order.client_order_id())
2651            .venue_order_id(venue_order_id)
2652            .account_id(account_id)
2653            .build();
2654        order.apply(OrderEventAny::Accepted(accepted)).unwrap();
2655
2656        if order_type == OrderType::MarketToLimit {
2657            order
2658                .apply(OrderEventAny::Updated(
2659                    OrderUpdatedSpec::builder()
2660                        .trader_id(order.trader_id())
2661                        .strategy_id(order.strategy_id())
2662                        .instrument_id(order.instrument_id())
2663                        .client_order_id(order.client_order_id())
2664                        .quantity(order.quantity())
2665                        .venue_order_id(venue_order_id)
2666                        .account_id(account_id)
2667                        .price(Price::from("100.00"))
2668                        .build(),
2669                ))
2670                .unwrap();
2671        }
2672
2673        let fill = |trade_id: &str, last_px: &str| {
2674            OrderFilledSpec::builder()
2675                .trader_id(order.trader_id())
2676                .strategy_id(order.strategy_id())
2677                .instrument_id(order.instrument_id())
2678                .client_order_id(order.client_order_id())
2679                .venue_order_id(venue_order_id)
2680                .account_id(account_id)
2681                .trade_id(TradeId::from(trade_id))
2682                .order_side(order.order_side())
2683                .order_type(order.order_type())
2684                .last_qty(Quantity::from(5))
2685                .last_px(Price::from(last_px))
2686                .build()
2687        };
2688        let unfavorable_fill = fill("T-SLIPPAGE-1", "110.00");
2689        let reference_fill = fill("T-SLIPPAGE-2", "100.00");
2690        order
2691            .apply(OrderEventAny::Filled(unfavorable_fill.clone()))
2692            .unwrap();
2693        order.apply(OrderEventAny::Filled(reference_fill)).unwrap();
2694        assert_eq!(order.avg_px(), Some(dec!(105)));
2695        assert_eq!(order.slippage(), Some(dec!(5)));
2696
2697        let correction = matching_fill_void(&unfavorable_fill, unfavorable_fill.last_qty, None);
2698        let event_count = order.event_count();
2699        order.apply(OrderEventAny::FillVoided(correction)).unwrap();
2700        let replayed =
2701            OrderAny::from_events(order.events().into_iter().cloned().collect()).unwrap();
2702
2703        assert_eq!(order.status(), OrderStatus::PartiallyFilled);
2704        assert_eq!(order.filled_qty(), Quantity::from(5));
2705        assert_eq!(order.voided_qty(), Quantity::from(5));
2706        assert_eq!(order.leaves_qty(), Quantity::from(5));
2707        assert_eq!(order.avg_px(), Some(dec!(100)));
2708        assert_eq!(order.slippage(), None);
2709        assert_eq!(order.event_count(), event_count + 1);
2710        assert_eq!(replayed.status(), order.status());
2711        assert_eq!(replayed.filled_qty(), order.filled_qty());
2712        assert_eq!(replayed.voided_qty(), order.voided_qty());
2713        assert_eq!(replayed.leaves_qty(), order.leaves_qty());
2714        assert_eq!(replayed.avg_px(), order.avg_px());
2715        assert_eq!(replayed.slippage(), order.slippage());
2716    }
2717
2718    #[rstest]
2719    fn test_avg_px_invariant_to_fill_arrival_order() {
2720        // (50_000 * 1.00001) + (30_000 * 1.00002) + (20_000 * 1.00003) = 100_001.7 over
2721        // 100_000 filled, so the exact average is 1.000017 whichever order the fills arrive
2722        // in. The f64 fold returns 1.0000170000000002 for the ascending sequence only.
2723        let mut fills = [
2724            fill("TRADE-1", "50000", "1.00001"),
2725            fill("TRADE-2", "30000", "1.00002"),
2726            fill("TRADE-3", "20000", "1.00003"),
2727        ];
2728
2729        let ascending = market_order_with_fills(OrderSide::Buy, Quantity::from(100_000), &fills);
2730        fills.reverse();
2731        let descending = market_order_with_fills(OrderSide::Buy, Quantity::from(100_000), &fills);
2732
2733        assert_eq!(ascending.avg_px(), Some(dec!(1.000_017)));
2734        assert_eq!(descending.avg_px(), ascending.avg_px());
2735        assert_eq!(descending.filled_qty(), ascending.filled_qty());
2736    }
2737
2738    #[rstest]
2739    fn test_avg_px_after_fill_void_matches_order_without_voided_fill() {
2740        let surviving = [fill("TRADE-1", "1", "0.05"), fill("TRADE-2", "3", "0.15")];
2741        let voided = fill("TRADE-VOIDED", "2", "0.13");
2742
2743        let expected = market_order_with_fills(OrderSide::Buy, Quantity::from(6), &surviving);
2744        let mut corrected = market_order_with_fills(
2745            OrderSide::Buy,
2746            Quantity::from(6),
2747            &[surviving[0], surviving[1], voided],
2748        );
2749        corrected
2750            .apply(OrderEventAny::FillVoided(
2751                OrderFillVoidedSpec::builder()
2752                    .trade_id(voided.0)
2753                    .voided_qty(voided.1)
2754                    .last_px(voided.2)
2755                    .build(),
2756            ))
2757            .unwrap();
2758
2759        let replayed =
2760            OrderAny::from_events(corrected.events().into_iter().cloned().collect()).unwrap();
2761
2762        // (1 * 0.05) + (3 * 0.15) = 0.50 over 4 filled: 0.125 exactly, whether the fold runs
2763        // incrementally over the fills, as the rebuild after the void drops the third fill, or
2764        // over the whole event stream on replay. The f64 rebuild returns 0.12499999999999999.
2765        assert_eq!(expected.avg_px(), Some(dec!(0.125)));
2766        assert_eq!(corrected.avg_px(), expected.avg_px());
2767        assert_eq!(replayed.avg_px(), expected.avg_px());
2768        assert_eq!(corrected.status(), OrderStatus::Voided);
2769        assert_eq!(corrected.filled_qty(), Quantity::from(4));
2770        assert_eq!(corrected.voided_qty(), Quantity::from(2));
2771        assert_eq!(corrected.leaves_qty(), Quantity::from(0));
2772        assert_eq!(replayed.filled_qty(), corrected.filled_qty());
2773        assert_eq!(replayed.voided_qty(), corrected.voided_qty());
2774    }
2775
2776    #[rstest]
2777    #[case::lower("1")]
2778    #[case::equal("1.000")]
2779    fn test_fractional_fill_correction_preserves_quantity_precision(#[case] quantity: &str) {
2780        let mut order = market_order_with_fills(
2781            OrderSide::Buy,
2782            Quantity::from(quantity),
2783            &[fill("TRADE-1", "0.750", "1.00")],
2784        );
2785        assert_eq!(order.status(), OrderStatus::PartiallyFilled);
2786        assert_eq!(order.filled_qty().as_decimal(), dec!(0.750));
2787        assert_eq!(order.leaves_qty().as_decimal(), dec!(0.250));
2788
2789        order
2790            .apply(OrderEventAny::FillVoided(
2791                OrderFillVoidedSpec::builder()
2792                    .trade_id(TradeId::from("TRADE-1"))
2793                    .voided_qty(Quantity::from("0.125"))
2794                    .last_px(Price::from("1.00"))
2795                    .build(),
2796            ))
2797            .unwrap();
2798
2799        assert_eq!(order.filled_qty().as_decimal(), dec!(0.625));
2800        assert_eq!(order.voided_qty().as_decimal(), dec!(0.125));
2801        assert_eq!(order.leaves_qty().as_decimal(), dec!(0.250));
2802        assert_eq!(order.overfill_qty().as_decimal(), dec!(0));
2803    }
2804
2805    #[rstest]
2806    #[case::lower("1")]
2807    #[case::equal("1.000")]
2808    fn test_fractional_overfill_preserves_quantity_precision(
2809        #[case] quantity: &str,
2810        #[values(false, true)] partial_fill_first: bool,
2811    ) {
2812        let fills = if partial_fill_first {
2813            vec![
2814                fill("TRADE-1", "0.750", "1.00"),
2815                fill("TRADE-2", "0.500", "1.00"),
2816            ]
2817        } else {
2818            vec![fill("TRADE-1", "1.250", "1.00")]
2819        };
2820        let order = market_order_with_fills(OrderSide::Buy, Quantity::from(quantity), &fills);
2821
2822        assert_eq!(order.status(), OrderStatus::Filled);
2823        assert_eq!(order.filled_qty().as_decimal(), dec!(1.250));
2824        assert_eq!(order.overfill_qty().as_decimal(), dec!(0.250));
2825        assert_eq!(order.leaves_qty().as_decimal(), dec!(0));
2826    }
2827
2828    #[rstest]
2829    fn test_avg_px_recomputed_from_partially_voided_fill() {
2830        let mut order = market_order_with_fills(
2831            OrderSide::Buy,
2832            Quantity::from(6),
2833            &[fill("TRADE-1", "4", "1.00"), fill("TRADE-2", "2", "1.14")],
2834        );
2835        order
2836            .apply(OrderEventAny::FillVoided(
2837                OrderFillVoidedSpec::builder()
2838                    .trade_id(TradeId::from("TRADE-1"))
2839                    .voided_qty(Quantity::from(2))
2840                    .last_px(Price::from("1.00"))
2841                    .build(),
2842            ))
2843            .unwrap();
2844
2845        // Surviving (2 * 1.00) + (2 * 1.14) = 4.28 over 4 filled: 1.07 exactly, where the f64
2846        // rebuild returns 1.0699999999999998.
2847        assert_eq!(order.status(), OrderStatus::Voided);
2848        assert_eq!(order.filled_qty(), Quantity::from(4));
2849        assert_eq!(order.voided_qty(), Quantity::from(2));
2850        assert_eq!(order.leaves_qty(), Quantity::from(0));
2851        assert_eq!(order.avg_px(), Some(dec!(1.07)));
2852    }
2853
2854    #[rstest]
2855    fn test_avg_px_over_reopened_fill_void_and_replacement_fill() {
2856        let mut order = market_order_with_fills(
2857            OrderSide::Buy,
2858            Quantity::from(6),
2859            &[fill("TRADE-1", "4", "1.00")],
2860        );
2861        order
2862            .apply(OrderEventAny::FillVoided(
2863                OrderFillVoidedSpec::builder()
2864                    .trade_id(TradeId::from("TRADE-1"))
2865                    .voided_qty(Quantity::from(2))
2866                    .last_px(Price::from("1.00"))
2867                    .is_reopened(true)
2868                    .build(),
2869            ))
2870            .unwrap();
2871        order
2872            .apply(OrderEventAny::Filled(
2873                OrderFilledSpec::builder()
2874                    .trade_id(TradeId::from("TRADE-2"))
2875                    .last_qty(Quantity::from(2))
2876                    .last_px(Price::from("1.14"))
2877                    .build(),
2878            ))
2879            .unwrap();
2880        order.set_slippage(Price::from("1.00"));
2881
2882        // The reopened void leaves 2 of the first fill, so the replacement fill folds against
2883        // the surviving quantity: (2 * 1.00) + (2 * 1.14) = 4.28 over 4 filled, or 1.07
2884        // exactly. The f64 update returns 1.0699999999999998, which slippage then inherits.
2885        assert_eq!(order.status(), OrderStatus::PartiallyFilled);
2886        assert_eq!(order.filled_qty(), Quantity::from(4));
2887        assert_eq!(order.voided_qty(), Quantity::from(2));
2888        assert_eq!(order.leaves_qty(), Quantity::from(2));
2889        assert_eq!(order.avg_px(), Some(dec!(1.07)));
2890        assert_eq!(order.slippage(), Some(dec!(0.07)));
2891    }
2892
2893    #[rstest]
2894    fn test_avg_px_cleared_when_every_fill_is_voided() {
2895        let mut order = market_order_with_fills(
2896            OrderSide::Buy,
2897            Quantity::from(6),
2898            &[fill("TRADE-1", "4", "1.50")],
2899        );
2900        order
2901            .apply(OrderEventAny::FillVoided(
2902                OrderFillVoidedSpec::builder()
2903                    .trade_id(TradeId::from("TRADE-1"))
2904                    .voided_qty(Quantity::from(4))
2905                    .last_px(Price::from("1.50"))
2906                    .build(),
2907            ))
2908            .unwrap();
2909
2910        assert_eq!(order.status(), OrderStatus::Accepted);
2911        assert_eq!(order.filled_qty(), Quantity::from(0));
2912        assert_eq!(order.voided_qty(), Quantity::from(4));
2913        assert_eq!(order.leaves_qty(), Quantity::from(2));
2914        assert_eq!(order.avg_px(), None);
2915    }
2916
2917    #[cfg(feature = "high-precision")]
2918    #[rstest]
2919    fn test_avg_px_exact_over_high_precision_quantities() {
2920        // Same weighting as `test_avg_px_invariant_to_fill_arrival_order`, at a quantity
2921        // precision only the wider raw backing can hold.
2922        let order = market_order_with_fills(
2923            OrderSide::Buy,
2924            Quantity::from("0.000000000010"),
2925            &[
2926                fill("TRADE-1", "0.000000000005", "1.00001"),
2927                fill("TRADE-2", "0.000000000003", "1.00002"),
2928                fill("TRADE-3", "0.000000000002", "1.00003"),
2929            ],
2930        );
2931
2932        assert_eq!(order.status(), OrderStatus::Filled);
2933        assert_eq!(order.filled_qty(), Quantity::from("0.000000000010"));
2934        assert_eq!(order.avg_px(), Some(dec!(1.000_017)));
2935    }
2936
2937    #[cfg(feature = "high-precision")]
2938    #[rstest]
2939    fn test_avg_px_exact_at_the_widest_representable_fill_scale() {
2940        // Pins the exactness bound: a 16-decimal quantity against a 12-decimal price needs the
2941        // 28 fractional digits Decimal carries, so no product rounds.
2942        let order = market_order_with_fills(
2943            OrderSide::Buy,
2944            Quantity::from("0.0000000000000008"),
2945            &[
2946                fill("TRADE-1", "0.0000000000000002", "0.000000000001"),
2947                fill("TRADE-2", "0.0000000000000006", "0.000000000003"),
2948            ],
2949        );
2950
2951        // (2e-16 * 1e-12) + (6e-16 * 3e-12) = 2e-27 over 8e-16 filled: 2.5e-12 exactly.
2952        assert_eq!(order.status(), OrderStatus::Filled);
2953        assert_eq!(order.filled_qty(), Quantity::from("0.0000000000000008"));
2954        assert_eq!(order.avg_px(), Some(dec!(2.5e-12)));
2955    }
2956
2957    #[rstest]
2958    fn test_order_life_cycle_accumulates_fill_commissions() {
2959        let init = OrderInitializedSpec::builder()
2960            .quantity(Quantity::from(100_000))
2961            .build();
2962        let submitted = OrderSubmittedSpec::builder().build();
2963        let accepted = OrderAcceptedSpec::builder().build();
2964        let fill1 = OrderFilledSpec::builder()
2965            .last_qty(Quantity::from(50_000))
2966            .trade_id(TradeId::from("TRADE-1"))
2967            .commission(Money::from("1.25 USD"))
2968            .build();
2969        let fill2 = OrderFilledSpec::builder()
2970            .last_qty(Quantity::from(50_000))
2971            .trade_id(TradeId::from("TRADE-2"))
2972            .commission(Money::from("1.35 USD"))
2973            .build();
2974
2975        let mut order: MarketOrder = init.try_into().unwrap();
2976        order.apply(OrderEventAny::Submitted(submitted)).unwrap();
2977        order.apply(OrderEventAny::Accepted(accepted)).unwrap();
2978        order.apply(OrderEventAny::Filled(fill1)).unwrap();
2979        order.apply(OrderEventAny::Filled(fill2)).unwrap();
2980
2981        assert_eq!(order.status(), OrderStatus::Filled);
2982        assert_eq!(
2983            order.commission(&Currency::USD()),
2984            Some(Money::from("2.60 USD"))
2985        );
2986        assert_eq!(order.commissions_vec(), vec![Money::from("2.60 USD")]);
2987    }
2988
2989    #[rstest]
2990    fn test_fill_void_reopens_only_when_explicitly_marked() {
2991        let init = OrderInitializedSpec::builder()
2992            .quantity(Quantity::from(100_000))
2993            .build();
2994        let filled = OrderFilledSpec::builder()
2995            .trade_id(TradeId::from("TRADE-VOID"))
2996            .last_qty(Quantity::from(100_000))
2997            .commission(Money::from("1.00 USD"))
2998            .build();
2999        let fill_voided = OrderFillVoidedSpec::builder()
3000            .trade_id(filled.trade_id)
3001            .voided_qty(Quantity::from(40_000))
3002            .commission_voided(Money::from("0.40 USD"))
3003            .build();
3004        let later_fill = OrderFilledSpec::builder()
3005            .trade_id(TradeId::from("TRADE-AFTER-REOPEN"))
3006            .last_qty(Quantity::from(40_000))
3007            .build();
3008        let mut order: MarketOrder = init.try_into().unwrap();
3009        order
3010            .apply(OrderEventAny::Accepted(
3011                OrderAcceptedSpec::builder().build(),
3012            ))
3013            .unwrap();
3014        order.apply(OrderEventAny::Filled(filled)).unwrap();
3015
3016        let mut terminal = order.clone();
3017        terminal
3018            .apply(OrderEventAny::FillVoided(fill_voided.clone()))
3019            .unwrap();
3020        let fill_while_terminal = terminal.apply(OrderEventAny::Filled(later_fill.clone()));
3021
3022        order
3023            .apply(OrderEventAny::FillVoided(OrderFillVoided {
3024                is_reopened: true,
3025                ..fill_voided
3026            }))
3027            .unwrap();
3028        let status_after_correction = order.status();
3029        order.apply(OrderEventAny::Filled(later_fill)).unwrap();
3030
3031        assert!(matches!(
3032            fill_while_terminal,
3033            Err(OrderError::InvalidStateTransition)
3034        ));
3035        assert_eq!(terminal.status(), OrderStatus::Voided);
3036        assert_eq!(status_after_correction, OrderStatus::PartiallyFilled);
3037        assert_eq!(order.status(), OrderStatus::Filled);
3038        assert_eq!(order.filled_qty(), Quantity::from(100_000));
3039        assert_eq!(order.voided_qty(), Quantity::from(40_000));
3040        assert_eq!(order.leaves_qty(), Quantity::from(0));
3041        assert_eq!(
3042            order.commission(&Currency::USD()),
3043            Some(Money::from("0.60 USD"))
3044        );
3045    }
3046
3047    #[rstest]
3048    fn test_fill_void_preserves_existing_working_remainder() {
3049        let init = OrderInitializedSpec::builder()
3050            .quantity(Quantity::from(100_000))
3051            .build();
3052        let filled = OrderFilledSpec::builder()
3053            .trade_id(TradeId::from("TRADE-VOID"))
3054            .last_qty(Quantity::from(40_000))
3055            .build();
3056        let later_fill = OrderFilledSpec::builder()
3057            .trade_id(TradeId::from("TRADE-REMAINDER"))
3058            .last_qty(Quantity::from(60_000))
3059            .build();
3060        let mut order: MarketOrder = init.try_into().unwrap();
3061        order
3062            .apply(OrderEventAny::Accepted(
3063                OrderAcceptedSpec::builder().build(),
3064            ))
3065            .unwrap();
3066        order.apply(OrderEventAny::Filled(filled.clone())).unwrap();
3067
3068        order
3069            .apply(OrderEventAny::FillVoided(
3070                OrderFillVoidedSpec::builder()
3071                    .trade_id(filled.trade_id)
3072                    .voided_qty(filled.last_qty)
3073                    .build(),
3074            ))
3075            .unwrap();
3076
3077        assert_eq!(order.status(), OrderStatus::Accepted);
3078        assert_eq!(order.filled_qty(), Quantity::from(0));
3079        assert_eq!(order.voided_qty(), Quantity::from(40_000));
3080        assert_eq!(order.leaves_qty(), Quantity::from(60_000));
3081        assert!(order.is_open());
3082
3083        order.apply(OrderEventAny::Filled(later_fill)).unwrap();
3084
3085        assert_eq!(order.status(), OrderStatus::Voided);
3086        assert_eq!(order.filled_qty(), Quantity::from(60_000));
3087        assert_eq!(order.voided_qty(), Quantity::from(40_000));
3088        assert_eq!(order.leaves_qty(), Quantity::from(0));
3089        assert!(order.is_closed());
3090    }
3091
3092    #[rstest]
3093    fn test_order_updated_after_non_reopened_fill_void_keeps_void_out_of_leaves(
3094        #[values(
3095            OrderType::Market,
3096            OrderType::Limit,
3097            OrderType::LimitIfTouched,
3098            OrderType::MarketIfTouched,
3099            OrderType::MarketToLimit,
3100            OrderType::StopLimit,
3101            OrderType::StopMarket,
3102            OrderType::TrailingStopLimit,
3103            OrderType::TrailingStopMarket
3104        )]
3105        order_type: OrderType,
3106        #[values(8, 10, 12)] updated_qty: u64,
3107    ) {
3108        let venue_order_id = VenueOrderId::from("V-VOID-UPDATE");
3109        let account_id = AccountId::from("SIM-VOID-UPDATE");
3110        let mut order = OrderTestBuilder::new(order_type)
3111            .instrument_id(InstrumentId::from("ETHUSDT-LINEAR.BYBIT"))
3112            .client_order_id(ClientOrderId::from("O-VOID-UPDATE"))
3113            .side(OrderSide::Buy)
3114            .quantity(Quantity::from(10))
3115            .price(Price::from("100.00"))
3116            .trigger_price(Price::from("100.00"))
3117            .trigger_type(TriggerType::LastPrice)
3118            .limit_offset(dec!(1))
3119            .trailing_offset(dec!(1))
3120            .trailing_offset_type(TrailingOffsetType::Price)
3121            .build();
3122        order
3123            .apply(OrderEventAny::Accepted(
3124                OrderAcceptedSpec::builder()
3125                    .trader_id(order.trader_id())
3126                    .strategy_id(order.strategy_id())
3127                    .instrument_id(order.instrument_id())
3128                    .client_order_id(order.client_order_id())
3129                    .venue_order_id(venue_order_id)
3130                    .account_id(account_id)
3131                    .build(),
3132            ))
3133            .unwrap();
3134        let fill = |trade_id: &str, last_qty: u64| {
3135            OrderFilledSpec::builder()
3136                .trader_id(order.trader_id())
3137                .strategy_id(order.strategy_id())
3138                .instrument_id(order.instrument_id())
3139                .client_order_id(order.client_order_id())
3140                .venue_order_id(venue_order_id)
3141                .account_id(account_id)
3142                .trade_id(TradeId::from(trade_id))
3143                .order_side(order.order_side())
3144                .order_type(order.order_type())
3145                .last_qty(Quantity::from(last_qty))
3146                .last_px(Price::from("100.00"))
3147                .build()
3148        };
3149        // The one non-reopened voided unit stays out of working leaves
3150        let expected_leaves = updated_qty - 4;
3151        let first_fill = fill("T-VOID-UPDATE-1", 4);
3152        let remainder_fill = fill("T-VOID-UPDATE-2", expected_leaves);
3153        order
3154            .apply(OrderEventAny::Filled(first_fill.clone()))
3155            .unwrap();
3156        order
3157            .apply(OrderEventAny::FillVoided(OrderFillVoided {
3158                is_reopened: false,
3159                ..matching_fill_void(&first_fill, Quantity::from(1), None)
3160            }))
3161            .unwrap();
3162        assert_eq!(order.status(), OrderStatus::PartiallyFilled);
3163        assert_eq!(order.filled_qty(), Quantity::from(3));
3164        assert_eq!(order.leaves_qty(), Quantity::from(6));
3165
3166        order
3167            .apply(OrderEventAny::Updated(
3168                OrderUpdatedSpec::builder()
3169                    .trader_id(order.trader_id())
3170                    .strategy_id(order.strategy_id())
3171                    .instrument_id(order.instrument_id())
3172                    .client_order_id(order.client_order_id())
3173                    .quantity(Quantity::from(updated_qty))
3174                    .venue_order_id(venue_order_id)
3175                    .account_id(account_id)
3176                    .build(),
3177            ))
3178            .unwrap();
3179
3180        assert_eq!(order.leaves_qty(), Quantity::from(expected_leaves));
3181
3182        order.apply(OrderEventAny::Filled(remainder_fill)).unwrap();
3183
3184        assert_eq!(order.status(), OrderStatus::Voided);
3185        assert_eq!(order.leaves_qty(), Quantity::from(0));
3186        assert!(order.is_closed());
3187    }
3188
3189    /// Builds an accepted Limit order (qty 10) with a `T-VOID-UPDATE-1` fill of 4, for reuse
3190    /// across the `OrderUpdated`-after-fill-void boundary tests below.
3191    fn accepted_order_with_first_fill() -> (OrderAny, VenueOrderId, AccountId, OrderFilled) {
3192        let venue_order_id = VenueOrderId::from("V-VOID-UPDATE");
3193        let account_id = AccountId::from("SIM-VOID-UPDATE");
3194        let mut order = OrderTestBuilder::new(OrderType::Limit)
3195            .instrument_id(InstrumentId::from("ETHUSDT-LINEAR.BYBIT"))
3196            .client_order_id(ClientOrderId::from("O-VOID-UPDATE"))
3197            .side(OrderSide::Buy)
3198            .quantity(Quantity::from(10))
3199            .price(Price::from("100.00"))
3200            .build();
3201        order
3202            .apply(OrderEventAny::Accepted(
3203                OrderAcceptedSpec::builder()
3204                    .trader_id(order.trader_id())
3205                    .strategy_id(order.strategy_id())
3206                    .instrument_id(order.instrument_id())
3207                    .client_order_id(order.client_order_id())
3208                    .venue_order_id(venue_order_id)
3209                    .account_id(account_id)
3210                    .build(),
3211            ))
3212            .unwrap();
3213        let first_fill = OrderFilledSpec::builder()
3214            .trader_id(order.trader_id())
3215            .strategy_id(order.strategy_id())
3216            .instrument_id(order.instrument_id())
3217            .client_order_id(order.client_order_id())
3218            .venue_order_id(venue_order_id)
3219            .account_id(account_id)
3220            .trade_id(TradeId::from("T-VOID-UPDATE-1"))
3221            .order_side(order.order_side())
3222            .order_type(order.order_type())
3223            .last_qty(Quantity::from(4))
3224            .last_px(Price::from("100.00"))
3225            .build();
3226        order
3227            .apply(OrderEventAny::Filled(first_fill.clone()))
3228            .unwrap();
3229        (order, venue_order_id, account_id, first_fill)
3230    }
3231
3232    #[rstest]
3233    fn test_order_updated_after_reopened_fill_void_keeps_void_in_leaves() {
3234        let (mut order, venue_order_id, account_id, first_fill) = accepted_order_with_first_fill();
3235
3236        order
3237            .apply(OrderEventAny::FillVoided(OrderFillVoided {
3238                is_reopened: true,
3239                ..matching_fill_void(&first_fill, Quantity::from(1), None)
3240            }))
3241            .unwrap();
3242        assert_eq!(order.filled_qty(), Quantity::from(3));
3243        assert_eq!(order.non_reopened_voided_qty(), Quantity::from(0));
3244        // A reopened void puts its quantity back into leaves rather than excluding it
3245        assert_eq!(order.leaves_qty(), Quantity::from(7));
3246
3247        order
3248            .apply(OrderEventAny::Updated(
3249                OrderUpdatedSpec::builder()
3250                    .trader_id(order.trader_id())
3251                    .strategy_id(order.strategy_id())
3252                    .instrument_id(order.instrument_id())
3253                    .client_order_id(order.client_order_id())
3254                    .quantity(Quantity::from(12))
3255                    .venue_order_id(venue_order_id)
3256                    .account_id(account_id)
3257                    .build(),
3258            ))
3259            .unwrap();
3260
3261        assert_eq!(order.non_reopened_voided_qty(), Quantity::from(0));
3262        assert_eq!(order.leaves_qty(), Quantity::from(9));
3263    }
3264
3265    #[rstest]
3266    fn test_order_updated_uses_latest_superseding_correction() {
3267        let (mut order, venue_order_id, account_id, first_fill) = accepted_order_with_first_fill();
3268
3269        order
3270            .apply(OrderEventAny::FillVoided(OrderFillVoided {
3271                is_reopened: false,
3272                ..matching_fill_void(&first_fill, Quantity::from(1), None)
3273            }))
3274            .unwrap();
3275        assert_eq!(order.non_reopened_voided_qty(), Quantity::from(1));
3276
3277        // A second, larger correction for the same trade supersedes the first rather than
3278        // stacking with it.
3279        order
3280            .apply(OrderEventAny::FillVoided(OrderFillVoided {
3281                is_reopened: false,
3282                ..matching_fill_void(&first_fill, Quantity::from(3), None)
3283            }))
3284            .unwrap();
3285        assert_eq!(order.filled_qty(), Quantity::from(1));
3286        assert_eq!(order.non_reopened_voided_qty(), Quantity::from(3));
3287
3288        order
3289            .apply(OrderEventAny::Updated(
3290                OrderUpdatedSpec::builder()
3291                    .trader_id(order.trader_id())
3292                    .strategy_id(order.strategy_id())
3293                    .instrument_id(order.instrument_id())
3294                    .client_order_id(order.client_order_id())
3295                    .quantity(Quantity::from(12))
3296                    .venue_order_id(venue_order_id)
3297                    .account_id(account_id)
3298                    .build(),
3299            ))
3300            .unwrap();
3301
3302        // 12 - filled(1) - superseding correction(3), not 12 - 1 - (1 + 3)
3303        assert_eq!(order.leaves_qty(), Quantity::from(8));
3304    }
3305
3306    #[rstest]
3307    fn test_order_updated_to_zero_leaves_sets_no_new_terminal_transition() {
3308        let (mut order, venue_order_id, account_id, first_fill) = accepted_order_with_first_fill();
3309
3310        order
3311            .apply(OrderEventAny::FillVoided(OrderFillVoided {
3312                is_reopened: false,
3313                ..matching_fill_void(&first_fill, Quantity::from(1), None)
3314            }))
3315            .unwrap();
3316        assert_eq!(order.status(), OrderStatus::PartiallyFilled);
3317        assert_eq!(order.filled_qty(), Quantity::from(3));
3318        assert_eq!(order.non_reopened_voided_qty(), Quantity::from(1));
3319
3320        // 4 - filled(3) - non-reopened voided(1) = 0 leaves, with reconciliation left false so
3321        // the exception below does not apply and no new terminal transition should occur.
3322        order
3323            .apply(OrderEventAny::Updated(
3324                OrderUpdatedSpec::builder()
3325                    .trader_id(order.trader_id())
3326                    .strategy_id(order.strategy_id())
3327                    .instrument_id(order.instrument_id())
3328                    .client_order_id(order.client_order_id())
3329                    .quantity(Quantity::from(4))
3330                    .venue_order_id(venue_order_id)
3331                    .account_id(account_id)
3332                    .reconciliation(false)
3333                    .build(),
3334            ))
3335            .unwrap();
3336
3337        assert_eq!(order.leaves_qty(), Quantity::from(0));
3338        assert_eq!(order.status(), OrderStatus::PartiallyFilled);
3339        assert!(order.ts_closed().is_none());
3340        assert!(!order.is_closed());
3341
3342        // The venue's own cancellation still applies normally afterward
3343        order
3344            .apply(OrderEventAny::Canceled(
3345                OrderCanceledSpec::builder()
3346                    .trader_id(order.trader_id())
3347                    .strategy_id(order.strategy_id())
3348                    .instrument_id(order.instrument_id())
3349                    .client_order_id(order.client_order_id())
3350                    .venue_order_id(venue_order_id)
3351                    .account_id(account_id)
3352                    .build(),
3353            ))
3354            .unwrap();
3355        assert_eq!(order.status(), OrderStatus::Canceled);
3356    }
3357
3358    #[rstest]
3359    fn test_reconciliation_to_filled_exception_fires_with_non_reopened_void_present() {
3360        let (mut order, venue_order_id, account_id, first_fill) = accepted_order_with_first_fill();
3361
3362        order
3363            .apply(OrderEventAny::FillVoided(OrderFillVoided {
3364                is_reopened: false,
3365                ..matching_fill_void(&first_fill, Quantity::from(1), None)
3366            }))
3367            .unwrap();
3368        assert_eq!(order.filled_qty(), Quantity::from(3));
3369
3370        // event.quantity == filled_qty with reconciliation=true fires the exception even though
3371        // a non-reopened void is present on the order.
3372        order
3373            .apply(OrderEventAny::Updated(
3374                OrderUpdatedSpec::builder()
3375                    .trader_id(order.trader_id())
3376                    .strategy_id(order.strategy_id())
3377                    .instrument_id(order.instrument_id())
3378                    .client_order_id(order.client_order_id())
3379                    .quantity(Quantity::from(3))
3380                    .venue_order_id(venue_order_id)
3381                    .account_id(account_id)
3382                    .reconciliation(true)
3383                    .build(),
3384            ))
3385            .unwrap();
3386
3387        assert_eq!(order.status(), OrderStatus::Filled);
3388        assert!(order.ts_closed().is_some());
3389        assert_eq!(order.leaves_qty(), Quantity::from(0));
3390    }
3391
3392    #[rstest]
3393    fn test_order_updated_restores_pending_status_with_non_reopened_void_present() {
3394        let (mut order, venue_order_id, account_id, first_fill) = accepted_order_with_first_fill();
3395
3396        order
3397            .apply(OrderEventAny::FillVoided(OrderFillVoided {
3398                is_reopened: false,
3399                ..matching_fill_void(&first_fill, Quantity::from(1), None)
3400            }))
3401            .unwrap();
3402        assert_eq!(order.status(), OrderStatus::PartiallyFilled);
3403
3404        order
3405            .apply(OrderEventAny::PendingUpdate(
3406                OrderPendingUpdateSpec::builder()
3407                    .trader_id(order.trader_id())
3408                    .strategy_id(order.strategy_id())
3409                    .instrument_id(order.instrument_id())
3410                    .client_order_id(order.client_order_id())
3411                    .account_id(account_id)
3412                    .build(),
3413            ))
3414            .unwrap();
3415        assert_eq!(order.status(), OrderStatus::PendingUpdate);
3416
3417        order
3418            .apply(OrderEventAny::Updated(
3419                OrderUpdatedSpec::builder()
3420                    .trader_id(order.trader_id())
3421                    .strategy_id(order.strategy_id())
3422                    .instrument_id(order.instrument_id())
3423                    .client_order_id(order.client_order_id())
3424                    .quantity(Quantity::from(12))
3425                    .venue_order_id(venue_order_id)
3426                    .account_id(account_id)
3427                    .build(),
3428            ))
3429            .unwrap();
3430
3431        // Restored to the pre-PendingUpdate status, with leaves still excluding the void
3432        assert_eq!(order.status(), OrderStatus::PartiallyFilled);
3433        assert_eq!(order.leaves_qty(), Quantity::from(8));
3434    }
3435
3436    #[rstest]
3437    fn test_order_updated_after_fill_void_replays_to_same_state() {
3438        let (mut order, venue_order_id, account_id, first_fill) = accepted_order_with_first_fill();
3439
3440        order
3441            .apply(OrderEventAny::FillVoided(OrderFillVoided {
3442                is_reopened: false,
3443                ..matching_fill_void(&first_fill, Quantity::from(1), None)
3444            }))
3445            .unwrap();
3446        order
3447            .apply(OrderEventAny::Updated(
3448                OrderUpdatedSpec::builder()
3449                    .trader_id(order.trader_id())
3450                    .strategy_id(order.strategy_id())
3451                    .instrument_id(order.instrument_id())
3452                    .client_order_id(order.client_order_id())
3453                    .quantity(Quantity::from(12))
3454                    .venue_order_id(venue_order_id)
3455                    .account_id(account_id)
3456                    .build(),
3457            ))
3458            .unwrap();
3459
3460        let replayed =
3461            OrderAny::from_events(order.events().into_iter().cloned().collect()).unwrap();
3462
3463        assert_eq!(replayed.status(), order.status());
3464        assert_eq!(replayed.filled_qty(), order.filled_qty());
3465        assert_eq!(
3466            replayed.non_reopened_voided_qty(),
3467            order.non_reopened_voided_qty()
3468        );
3469        assert_eq!(replayed.leaves_qty(), order.leaves_qty());
3470        assert_eq!(replayed.leaves_qty(), Quantity::from(8));
3471    }
3472
3473    #[rstest]
3474    fn test_canceled_order_with_voided_qty_becomes_voided_when_late_fill_exhausts_leaves() {
3475        let initial_trade_id = TradeId::from("TRADE-VOID");
3476        let late_trade_id = TradeId::from("TRADE-LATE");
3477        let init = OrderInitializedSpec::builder()
3478            .quantity(Quantity::from(100_000))
3479            .build();
3480        let accepted = OrderAcceptedSpec::builder()
3481            .ts_event(UnixNanos::from(1_000))
3482            .build();
3483        let filled = OrderFilledSpec::builder()
3484            .trade_id(initial_trade_id)
3485            .last_qty(Quantity::from(60_000))
3486            .ts_event(UnixNanos::from(2_000))
3487            .build();
3488        let fill_voided = OrderFillVoidedSpec::builder()
3489            .trade_id(initial_trade_id)
3490            .voided_qty(Quantity::from(20_000))
3491            .ts_event(UnixNanos::from(3_000))
3492            .is_reopened(false)
3493            .build();
3494        let canceled = OrderCanceledSpec::builder()
3495            .ts_event(UnixNanos::from(4_000))
3496            .build();
3497        let late_fill = OrderFilledSpec::builder()
3498            .trade_id(late_trade_id)
3499            .last_qty(Quantity::from(40_000))
3500            .ts_event(UnixNanos::from(5_000))
3501            .build();
3502        let mut order: MarketOrder = init.try_into().unwrap();
3503
3504        order.apply(OrderEventAny::Accepted(accepted)).unwrap();
3505        order.apply(OrderEventAny::Filled(filled)).unwrap();
3506        order.apply(OrderEventAny::FillVoided(fill_voided)).unwrap();
3507        order.apply(OrderEventAny::Canceled(canceled)).unwrap();
3508
3509        assert_eq!(order.status(), OrderStatus::Canceled);
3510        assert_eq!(order.filled_qty(), Quantity::from(40_000));
3511        assert_eq!(order.voided_qty(), Quantity::from(20_000));
3512        assert_eq!(order.leaves_qty(), Quantity::from(40_000));
3513        assert_eq!(order.ts_closed(), Some(UnixNanos::from(4_000)));
3514        assert_eq!(order.last_trade_id(), Some(initial_trade_id));
3515        assert!(order.is_closed());
3516        assert!(!order.is_open());
3517
3518        order.apply(OrderEventAny::Filled(late_fill)).unwrap();
3519
3520        assert_eq!(order.status(), OrderStatus::Voided);
3521        assert_eq!(order.filled_qty(), Quantity::from(80_000));
3522        assert_eq!(order.voided_qty(), Quantity::from(20_000));
3523        assert_eq!(order.leaves_qty(), Quantity::from(0));
3524        assert_eq!(order.overfill_qty(), Quantity::from(0));
3525        assert_eq!(order.ts_closed(), Some(UnixNanos::from(5_000)));
3526        assert_eq!(order.last_trade_id(), Some(late_trade_id));
3527        assert_eq!(order.trade_ids(), vec![&initial_trade_id, &late_trade_id]);
3528        assert!(order.is_closed());
3529        assert!(!order.is_open());
3530    }
3531
3532    #[rstest]
3533    fn test_reopened_fill_void_requires_existing_fill() {
3534        let trade_id = TradeId::from("TRADE-OUT-OF-ORDER");
3535        let init = OrderInitializedSpec::builder()
3536            .quantity(Quantity::from(100_000))
3537            .build();
3538        let early_void = OrderFillVoidedSpec::builder()
3539            .trade_id(trade_id)
3540            .voided_qty(Quantity::from(10_000))
3541            .is_reopened(true)
3542            .build();
3543        let late_fill = OrderFilledSpec::builder()
3544            .trade_id(trade_id)
3545            .last_qty(Quantity::from(40_000))
3546            .build();
3547        let mut order: MarketOrder = init.try_into().unwrap();
3548        order
3549            .apply(OrderEventAny::Accepted(
3550                OrderAcceptedSpec::builder().build(),
3551            ))
3552            .unwrap();
3553
3554        let result = order.apply(OrderEventAny::FillVoided(early_void));
3555        order.apply(OrderEventAny::Filled(late_fill)).unwrap();
3556
3557        assert!(matches!(result, Err(OrderError::InvalidOrderEvent)));
3558        assert_eq!(order.status(), OrderStatus::PartiallyFilled);
3559        assert_eq!(order.filled_qty(), Quantity::from(40_000));
3560        assert_eq!(order.voided_qty(), Quantity::from(0));
3561        assert_eq!(order.leaves_qty(), Quantity::from(60_000));
3562    }
3563
3564    #[rstest]
3565    #[case(OrderStatus::Accepted)]
3566    #[case(OrderStatus::Canceled)]
3567    #[case(OrderStatus::Expired)]
3568    fn test_terminal_fill_void_rejects_later_order_events(#[case] status_before_void: OrderStatus) {
3569        let trade_id = TradeId::from("TRADE-TERMINAL-VOID");
3570        let init = OrderInitializedSpec::builder()
3571            .quantity(Quantity::from(100_000))
3572            .build();
3573        let terminal_void = OrderFillVoidedSpec::builder()
3574            .trade_id(trade_id)
3575            .voided_qty(Quantity::from(40_000))
3576            .commission_voided(Money::from("0 USD"))
3577            .build();
3578        let late_fill = OrderFilledSpec::builder()
3579            .trade_id(trade_id)
3580            .last_qty(Quantity::from(40_000))
3581            .build();
3582        let mut order: MarketOrder = init.try_into().unwrap();
3583        order
3584            .apply(OrderEventAny::Accepted(
3585                OrderAcceptedSpec::builder().build(),
3586            ))
3587            .unwrap();
3588
3589        match status_before_void {
3590            OrderStatus::Accepted => {}
3591            OrderStatus::Canceled => order
3592                .apply(OrderEventAny::Canceled(
3593                    OrderCanceledSpec::builder().build(),
3594                ))
3595                .unwrap(),
3596            OrderStatus::Expired => order
3597                .apply(OrderEventAny::Expired(OrderExpiredSpec::builder().build()))
3598                .unwrap(),
3599            _ => unreachable!(),
3600        }
3601
3602        order
3603            .apply(OrderEventAny::FillVoided(terminal_void))
3604            .unwrap();
3605        let update_result = order.apply(OrderEventAny::Updated(
3606            OrderUpdatedSpec::builder()
3607                .quantity(Quantity::from(120_000))
3608                .build(),
3609        ));
3610        let cancel_result = order.apply(OrderEventAny::Canceled(
3611            OrderCanceledSpec::builder().build(),
3612        ));
3613        let fill_result = order.apply(OrderEventAny::Filled(late_fill));
3614
3615        assert!(matches!(
3616            update_result,
3617            Err(OrderError::InvalidStateTransition)
3618        ));
3619        assert!(matches!(
3620            cancel_result,
3621            Err(OrderError::InvalidStateTransition)
3622        ));
3623        assert!(matches!(
3624            fill_result,
3625            Err(OrderError::InvalidStateTransition)
3626        ));
3627        assert_eq!(order.status(), OrderStatus::Voided);
3628        assert_eq!(order.filled_qty(), Quantity::from(0));
3629        assert_eq!(order.voided_qty(), Quantity::from(40_000));
3630        assert_eq!(order.leaves_qty(), Quantity::from(0));
3631    }
3632
3633    #[rstest]
3634    #[case(Quantity::from(100_001), None)]
3635    #[case(Quantity::from(100_000), Some(Money::from("1 USD")))]
3636    fn test_terminal_fill_void_rejects_invalid_economic_values(
3637        #[case] voided_qty: Quantity,
3638        #[case] commission_voided: Option<Money>,
3639    ) {
3640        let trade_id = TradeId::from("TRADE-TERMINAL-VOID");
3641        let init = OrderInitializedSpec::builder()
3642            .quantity(Quantity::from(100_000))
3643            .build();
3644        let mut order: MarketOrder = init.try_into().unwrap();
3645        order
3646            .apply(OrderEventAny::Accepted(
3647                OrderAcceptedSpec::builder().build(),
3648            ))
3649            .unwrap();
3650        let mut invalid = OrderFillVoidedSpec::builder()
3651            .trade_id(trade_id)
3652            .voided_qty(voided_qty)
3653            .build();
3654        invalid.commission_voided = commission_voided;
3655
3656        let result = order.apply(OrderEventAny::FillVoided(invalid));
3657
3658        assert!(matches!(
3659            result,
3660            Err(OrderError::OverVoid(error_trade_id)) if error_trade_id == trade_id
3661        ));
3662        assert_eq!(order.status(), OrderStatus::Accepted);
3663        assert_eq!(order.voided_qty(), Quantity::from(0));
3664    }
3665
3666    #[rstest]
3667    fn test_terminal_fill_void_accepts_current_venue_order_id_after_fill_before_accept() {
3668        let init = OrderInitializedSpec::builder()
3669            .quantity(Quantity::from(100_000))
3670            .build();
3671        let submitted = OrderSubmittedSpec::builder().build();
3672        let filled = OrderFilledSpec::builder()
3673            .account_id(submitted.account_id)
3674            .trade_id(TradeId::from("TRADE-APPLIED"))
3675            .last_qty(Quantity::from(40_000))
3676            .build();
3677        let terminal_void = OrderFillVoidedSpec::builder()
3678            .venue_order_id(filled.venue_order_id)
3679            .account_id(filled.account_id)
3680            .trade_id(TradeId::from("TRADE-TERMINAL-VOID"))
3681            .voided_qty(Quantity::from(10_000))
3682            .build();
3683        let mut order: MarketOrder = init.try_into().unwrap();
3684        order.apply(OrderEventAny::Submitted(submitted)).unwrap();
3685        order.apply(OrderEventAny::Filled(filled)).unwrap();
3686
3687        order
3688            .apply(OrderEventAny::FillVoided(terminal_void))
3689            .unwrap();
3690
3691        assert_eq!(order.status(), OrderStatus::Voided);
3692        assert_eq!(order.filled_qty(), Quantity::from(40_000));
3693        assert_eq!(order.voided_qty(), Quantity::from(10_000));
3694        assert_eq!(order.leaves_qty(), Quantity::from(0));
3695    }
3696
3697    #[rstest]
3698    fn test_terminal_fill_void_requires_matching_order_identity() {
3699        let init = OrderInitializedSpec::builder()
3700            .quantity(Quantity::from(100_000))
3701            .build();
3702        let mut order: MarketOrder = init.try_into().unwrap();
3703        order
3704            .apply(OrderEventAny::Accepted(
3705                OrderAcceptedSpec::builder().build(),
3706            ))
3707            .unwrap();
3708        let mismatched = OrderFillVoidedSpec::builder()
3709            .instrument_id(InstrumentId::from("OTHER.SIM"))
3710            .trade_id(TradeId::from("TRADE-TERMINAL-VOID"))
3711            .voided_qty(Quantity::from(100_000))
3712            .build();
3713
3714        let result = order.apply(OrderEventAny::FillVoided(mismatched));
3715
3716        assert!(matches!(result, Err(OrderError::InvalidOrderEvent)));
3717        assert_eq!(order.status(), OrderStatus::Accepted);
3718        assert_eq!(order.voided_qty(), Quantity::from(0));
3719    }
3720
3721    #[rstest]
3722    #[case(OrderStatus::Canceled)]
3723    #[case(OrderStatus::Expired)]
3724    fn test_fill_void_does_not_reopen_canceled_or_expired_order(
3725        #[case] terminal_status: OrderStatus,
3726    ) {
3727        let init = OrderInitializedSpec::builder()
3728            .quantity(Quantity::from(100_000))
3729            .build();
3730        let filled = OrderFilledSpec::builder()
3731            .trade_id(TradeId::from("TRADE-TERMINAL-VOID"))
3732            .last_qty(Quantity::from(60_000))
3733            .build();
3734        let mut order: MarketOrder = init.try_into().unwrap();
3735        order
3736            .apply(OrderEventAny::Accepted(
3737                OrderAcceptedSpec::builder().build(),
3738            ))
3739            .unwrap();
3740        order.apply(OrderEventAny::Filled(filled.clone())).unwrap();
3741        match terminal_status {
3742            OrderStatus::Canceled => order
3743                .apply(OrderEventAny::Canceled(
3744                    OrderCanceledSpec::builder().build(),
3745                ))
3746                .unwrap(),
3747            OrderStatus::Expired => order
3748                .apply(OrderEventAny::Expired(OrderExpiredSpec::builder().build()))
3749                .unwrap(),
3750            _ => unreachable!(),
3751        }
3752        let voided = OrderFillVoidedSpec::builder()
3753            .trade_id(filled.trade_id)
3754            .voided_qty(Quantity::from(20_000))
3755            .is_reopened(true)
3756            .build();
3757
3758        order.apply(OrderEventAny::FillVoided(voided)).unwrap();
3759
3760        assert_eq!(order.status(), terminal_status);
3761        assert_eq!(order.filled_qty(), Quantity::from(40_000));
3762        assert_eq!(order.voided_qty(), Quantity::from(20_000));
3763        assert!(order.is_closed());
3764        assert!(order.ts_closed().is_some());
3765    }
3766
3767    #[rstest]
3768    fn test_fill_void_rejects_duplicate_stale_and_over_void() {
3769        let init = OrderInitializedSpec::builder()
3770            .quantity(Quantity::from(100_000))
3771            .build();
3772        let filled = OrderFilledSpec::builder()
3773            .trade_id(TradeId::from("TRADE-VOID"))
3774            .last_qty(Quantity::from(100_000))
3775            .build();
3776        let mut order: MarketOrder = init.try_into().unwrap();
3777        order
3778            .apply(OrderEventAny::Accepted(
3779                OrderAcceptedSpec::builder().build(),
3780            ))
3781            .unwrap();
3782        order.apply(OrderEventAny::Filled(filled)).unwrap();
3783        order
3784            .apply(OrderEventAny::FillVoided(
3785                OrderFillVoidedSpec::builder()
3786                    .trade_id(TradeId::from("TRADE-VOID"))
3787                    .voided_qty(Quantity::from(40_000))
3788                    .build(),
3789            ))
3790            .unwrap();
3791
3792        let duplicate = order.apply(OrderEventAny::FillVoided(
3793            OrderFillVoidedSpec::builder()
3794                .trade_id(TradeId::from("TRADE-VOID"))
3795                .voided_qty(Quantity::from(40_000))
3796                .build(),
3797        ));
3798        let stale = order.apply(OrderEventAny::FillVoided(
3799            OrderFillVoidedSpec::builder()
3800                .trade_id(TradeId::from("TRADE-VOID"))
3801                .voided_qty(Quantity::from(30_000))
3802                .build(),
3803        ));
3804        let over_void = order.apply(OrderEventAny::FillVoided(
3805            OrderFillVoidedSpec::builder()
3806                .trade_id(TradeId::from("TRADE-VOID"))
3807                .voided_qty(Quantity::from(100_001))
3808                .build(),
3809        ));
3810        assert!(matches!(
3811            duplicate,
3812            Err(OrderError::DuplicateFillVoid(trade_id))
3813                if trade_id == TradeId::from("TRADE-VOID")
3814        ));
3815        assert!(matches!(
3816            stale,
3817            Err(OrderError::StaleFillVoid(trade_id))
3818                if trade_id == TradeId::from("TRADE-VOID")
3819        ));
3820        assert!(matches!(
3821            over_void,
3822            Err(OrderError::OverVoid(trade_id))
3823                if trade_id == TradeId::from("TRADE-VOID")
3824        ));
3825        assert_eq!(order.filled_qty(), Quantity::from(60_000));
3826        assert_eq!(order.voided_qty(), Quantity::from(40_000));
3827    }
3828
3829    enum FillVoidIdentityField {
3830        VenueOrderId,
3831        AccountId,
3832        OrderSide,
3833        OrderType,
3834        LastPx,
3835        Currency,
3836        LiquiditySide,
3837        PositionId,
3838    }
3839
3840    #[rstest]
3841    #[case::venue_order_id(FillVoidIdentityField::VenueOrderId)]
3842    #[case::account_id(FillVoidIdentityField::AccountId)]
3843    #[case::order_side(FillVoidIdentityField::OrderSide)]
3844    #[case::order_type(FillVoidIdentityField::OrderType)]
3845    #[case::last_px(FillVoidIdentityField::LastPx)]
3846    #[case::currency(FillVoidIdentityField::Currency)]
3847    #[case::liquidity_side(FillVoidIdentityField::LiquiditySide)]
3848    #[case::position_id(FillVoidIdentityField::PositionId)]
3849    fn test_fill_void_rejects_known_fill_identity_mismatch(#[case] field: FillVoidIdentityField) {
3850        let (mut order, fill) = filled_market_order_for_void();
3851        let events_before: Vec<_> = order.events().into_iter().cloned().collect();
3852        let mut correction =
3853            matching_fill_void(&fill, Quantity::from(40), Some(Money::from("0.40 USD")));
3854
3855        match field {
3856            FillVoidIdentityField::VenueOrderId => {
3857                correction.venue_order_id = VenueOrderId::from("V-OTHER");
3858            }
3859            FillVoidIdentityField::AccountId => {
3860                correction.account_id = AccountId::from("SIM-OTHER");
3861            }
3862            FillVoidIdentityField::OrderSide => correction.order_side = OrderSide::Sell,
3863            FillVoidIdentityField::OrderType => correction.order_type = OrderType::Limit,
3864            FillVoidIdentityField::LastPx => correction.last_px = Price::from("1.50"),
3865            FillVoidIdentityField::Currency => correction.currency = Currency::EUR(),
3866            FillVoidIdentityField::LiquiditySide => {
3867                correction.liquidity_side = LiquiditySide::Maker;
3868            }
3869            FillVoidIdentityField::PositionId => {
3870                correction.position_id = Some(PositionId::from("P-OTHER"));
3871            }
3872        }
3873
3874        let result = order.apply(OrderEventAny::FillVoided(correction));
3875
3876        assert!(matches!(result, Err(OrderError::InvalidOrderEvent)));
3877        assert_fill_void_rejected_without_mutation(&order, &events_before);
3878    }
3879
3880    #[rstest]
3881    #[case::currency("0.40 EUR")]
3882    #[case::sign("-0.40 USD")]
3883    #[case::amount("1.01 USD")]
3884    fn test_fill_void_rejects_invalid_commission_without_mutation(#[case] commission: &str) {
3885        let (mut order, fill) = filled_market_order_for_void();
3886        let events_before: Vec<_> = order.events().into_iter().cloned().collect();
3887        let correction =
3888            matching_fill_void(&fill, Quantity::from(40), Some(Money::from(commission)));
3889
3890        let result = order.apply(OrderEventAny::FillVoided(correction));
3891
3892        assert!(matches!(
3893            result,
3894            Err(OrderError::InvalidFillVoidCommission(trade_id)) if trade_id == fill.trade_id
3895        ));
3896        assert_fill_void_rejected_without_mutation(&order, &events_before);
3897    }
3898
3899    #[rstest]
3900    fn test_fill_void_rejects_zero_quantity_without_mutation() {
3901        let (mut order, fill) = filled_market_order_for_void();
3902        let events_before: Vec<_> = order.events().into_iter().cloned().collect();
3903        let correction = matching_fill_void(
3904            &fill,
3905            Quantity::zero(fill.last_qty.precision),
3906            Some(Money::from("0.00 USD")),
3907        );
3908
3909        let result = order.apply(OrderEventAny::FillVoided(correction));
3910
3911        assert!(matches!(
3912            result,
3913            Err(OrderError::OverVoid(trade_id)) if trade_id == fill.trade_id
3914        ));
3915        assert_fill_void_rejected_without_mutation(&order, &events_before);
3916    }
3917
3918    #[rstest]
3919    fn test_fill_void_uses_latest_cumulative_correction() {
3920        let (mut order, fill) = filled_market_order_for_void();
3921        order
3922            .apply(OrderEventAny::FillVoided(matching_fill_void(
3923                &fill,
3924                Quantity::from(40),
3925                Some(Money::from("0.40 USD")),
3926            )))
3927            .unwrap();
3928        let event_count = order.event_count();
3929
3930        let decreasing_commission = order.apply(OrderEventAny::FillVoided(matching_fill_void(
3931            &fill,
3932            Quantity::from(50),
3933            Some(Money::from("0.30 USD")),
3934        )));
3935
3936        assert!(matches!(
3937            decreasing_commission,
3938            Err(OrderError::InvalidFillVoidCommission(trade_id)) if trade_id == fill.trade_id
3939        ));
3940        assert_eq!(order.event_count(), event_count);
3941        assert_eq!(order.filled_qty(), Quantity::from(60));
3942        assert_eq!(order.voided_qty(), Quantity::from(40));
3943        assert_eq!(
3944            order.commission(&Currency::USD()),
3945            Some(Money::from("0.60 USD")),
3946        );
3947
3948        order
3949            .apply(OrderEventAny::FillVoided(matching_fill_void(
3950                &fill,
3951                Quantity::from(60),
3952                Some(Money::from("0.60 USD")),
3953            )))
3954            .unwrap();
3955        let replayed =
3956            OrderAny::from_events(order.events().into_iter().cloned().collect()).unwrap();
3957
3958        assert_eq!(order.status(), OrderStatus::PartiallyFilled);
3959        assert_eq!(order.filled_qty(), Quantity::from(40));
3960        assert_eq!(order.voided_qty(), Quantity::from(60));
3961        assert_eq!(order.leaves_qty(), Quantity::from(60));
3962        assert_eq!(order.avg_px(), Some(dec!(1.25)));
3963        assert_eq!(
3964            order.commission(&Currency::USD()),
3965            Some(Money::from("0.40 USD")),
3966        );
3967        assert_eq!(order.trade_ids(), vec![&fill.trade_id]);
3968        assert_eq!(order.last_trade_id(), Some(fill.trade_id));
3969        assert_eq!(order.event_count(), event_count + 1);
3970        assert_eq!(replayed.status(), order.status());
3971        assert_eq!(replayed.filled_qty(), order.filled_qty());
3972        assert_eq!(replayed.voided_qty(), order.voided_qty());
3973        assert_eq!(replayed.leaves_qty(), order.leaves_qty());
3974        assert_eq!(replayed.avg_px(), order.avg_px());
3975        assert_eq!(replayed.commissions(), order.commissions());
3976        assert_eq!(replayed.trade_ids(), order.trade_ids());
3977        assert_eq!(replayed.last_trade_id(), order.last_trade_id());
3978    }
3979
3980    fn filled_market_order_for_void() -> (MarketOrder, OrderFilled) {
3981        let venue_order_id = VenueOrderId::from("V-FILL-VOID");
3982        let account_id = AccountId::from("SIM-FILL-VOID");
3983        let fill = OrderFilledSpec::builder()
3984            .venue_order_id(venue_order_id)
3985            .account_id(account_id)
3986            .trade_id(TradeId::from("T-FILL-VOID"))
3987            .last_qty(Quantity::from(100))
3988            .last_px(Price::from("1.25"))
3989            .position_id(PositionId::from("P-FILL-VOID"))
3990            .commission(Money::from("1.00 USD"))
3991            .build();
3992        let mut order: MarketOrder = OrderInitializedSpec::builder()
3993            .quantity(Quantity::from(100))
3994            .build()
3995            .try_into()
3996            .unwrap();
3997        order
3998            .apply(OrderEventAny::Accepted(
3999                OrderAcceptedSpec::builder()
4000                    .venue_order_id(venue_order_id)
4001                    .account_id(account_id)
4002                    .build(),
4003            ))
4004            .unwrap();
4005        order.apply(OrderEventAny::Filled(fill.clone())).unwrap();
4006
4007        (order, fill)
4008    }
4009
4010    fn matching_fill_void(
4011        fill: &OrderFilled,
4012        voided_qty: Quantity,
4013        commission_voided: Option<Money>,
4014    ) -> OrderFillVoided {
4015        OrderFillVoidedSpec::builder()
4016            .trader_id(fill.trader_id)
4017            .strategy_id(fill.strategy_id)
4018            .instrument_id(fill.instrument_id)
4019            .client_order_id(fill.client_order_id)
4020            .venue_order_id(fill.venue_order_id)
4021            .account_id(fill.account_id)
4022            .trade_id(fill.trade_id)
4023            .voided_qty(voided_qty)
4024            .order_side(fill.order_side)
4025            .order_type(fill.order_type)
4026            .last_px(fill.last_px)
4027            .currency(fill.currency)
4028            .liquidity_side(fill.liquidity_side)
4029            .maybe_position_id(fill.position_id)
4030            .maybe_commission_voided(commission_voided)
4031            .is_reopened(true)
4032            .build()
4033    }
4034
4035    fn assert_fill_void_rejected_without_mutation(
4036        order: &MarketOrder,
4037        events_before: &[OrderEventAny],
4038    ) {
4039        assert_eq!(order.status(), OrderStatus::Filled);
4040        assert_eq!(order.filled_qty(), Quantity::from(100));
4041        assert_eq!(order.voided_qty(), Quantity::from(0));
4042        assert_eq!(order.leaves_qty(), Quantity::from(0));
4043        assert_eq!(order.avg_px(), Some(dec!(1.25)));
4044        assert_eq!(
4045            order.commission(&Currency::USD()),
4046            Some(Money::from("1.00 USD")),
4047        );
4048        assert_eq!(
4049            order.events().into_iter().cloned().collect::<Vec<_>>(),
4050            events_before,
4051        );
4052    }
4053
4054    #[rstest]
4055    fn test_unknown_fill_void_does_not_reverse_surviving_fill() {
4056        let init = OrderInitializedSpec::builder()
4057            .quantity(Quantity::from(100_000))
4058            .build();
4059        let filled = OrderFilledSpec::builder()
4060            .trade_id(TradeId::from("TRADE-APPLIED"))
4061            .last_qty(Quantity::from(60_000))
4062            .build();
4063        let voided = OrderFillVoidedSpec::builder()
4064            .trade_id(TradeId::from("TRADE-NEVER-APPLIED"))
4065            .voided_qty(Quantity::from(40_000))
4066            .build();
4067        let mut order: MarketOrder = init.try_into().unwrap();
4068        order
4069            .apply(OrderEventAny::Accepted(
4070                OrderAcceptedSpec::builder().build(),
4071            ))
4072            .unwrap();
4073        order.apply(OrderEventAny::Filled(filled)).unwrap();
4074
4075        order.apply(OrderEventAny::FillVoided(voided)).unwrap();
4076        order
4077            .apply(OrderEventAny::FillVoided(
4078                OrderFillVoidedSpec::builder()
4079                    .trade_id(TradeId::from("TRADE-APPLIED"))
4080                    .voided_qty(Quantity::from(10_000))
4081                    .is_reopened(true)
4082                    .build(),
4083            ))
4084            .unwrap();
4085        let late_fill = order.apply(OrderEventAny::Filled(
4086            OrderFilledSpec::builder()
4087                .trade_id(TradeId::from("TRADE-LATE"))
4088                .last_qty(Quantity::from(10_000))
4089                .build(),
4090        ));
4091
4092        assert_eq!(order.status(), OrderStatus::Voided);
4093        assert_eq!(order.filled_qty(), Quantity::from(50_000));
4094        assert_eq!(order.voided_qty(), Quantity::from(50_000));
4095        assert_eq!(order.leaves_qty(), Quantity::zero(0));
4096        assert!(order.is_closed());
4097        assert!(matches!(late_fill, Err(OrderError::InvalidStateTransition)));
4098    }
4099
4100    #[rstest]
4101    fn test_order_state_transition_to_canceled() {
4102        let mut order: MarketOrder = OrderInitializedSpec::builder().build().try_into().unwrap();
4103        let submitted = OrderSubmittedSpec::builder().build();
4104        let canceled = OrderCanceledSpec::builder().build();
4105
4106        order.apply(OrderEventAny::Submitted(submitted)).unwrap();
4107        order.apply(OrderEventAny::Canceled(canceled)).unwrap();
4108
4109        assert_eq!(order.status(), OrderStatus::Canceled);
4110        assert!(order.is_closed());
4111        assert!(!order.is_open());
4112    }
4113
4114    #[rstest]
4115    fn test_order_life_cycle_to_partially_filled() {
4116        let init = OrderInitializedSpec::builder().build();
4117        let submitted = OrderSubmittedSpec::builder().build();
4118        let accepted = OrderAcceptedSpec::builder().build();
4119        let filled = OrderFilledSpec::builder()
4120            .last_qty(Quantity::from(50_000))
4121            .build();
4122
4123        let mut order: MarketOrder = init.clone().try_into().unwrap();
4124        order.apply(OrderEventAny::Submitted(submitted)).unwrap();
4125        order.apply(OrderEventAny::Accepted(accepted)).unwrap();
4126        order.apply(OrderEventAny::Filled(filled)).unwrap();
4127
4128        assert_eq!(order.client_order_id, init.client_order_id);
4129        assert_eq!(order.status(), OrderStatus::PartiallyFilled);
4130        assert_eq!(order.filled_qty(), Quantity::from(50_000));
4131        assert_eq!(order.leaves_qty(), Quantity::from(50_000));
4132        assert!(order.is_open());
4133        assert!(!order.is_closed());
4134    }
4135
4136    #[rstest]
4137    fn test_order_commission_calculation() {
4138        let mut order: MarketOrder = OrderInitializedSpec::builder().build().try_into().unwrap();
4139        order
4140            .commissions
4141            .insert(Currency::USD(), Money::new(10.0, Currency::USD()));
4142
4143        assert_eq!(
4144            order.commission(&Currency::USD()),
4145            Some(Money::new(10.0, Currency::USD()))
4146        );
4147        assert_eq!(
4148            order.commissions_vec(),
4149            vec![Money::new(10.0, Currency::USD())]
4150        );
4151    }
4152
4153    #[rstest]
4154    fn test_order_is_primary() {
4155        let order: MarketOrder = OrderInitializedSpec::builder()
4156            .exec_algorithm_id(ExecAlgorithmId::from("ALGO-001"))
4157            .exec_spawn_id(ClientOrderId::from("O-001"))
4158            .client_order_id(ClientOrderId::from("O-001"))
4159            .build()
4160            .try_into()
4161            .unwrap();
4162
4163        assert!(order.is_primary());
4164        assert!(!order.is_spawned());
4165    }
4166
4167    #[rstest]
4168    fn test_order_is_spawned() {
4169        let order: MarketOrder = OrderInitializedSpec::builder()
4170            .exec_algorithm_id(ExecAlgorithmId::from("ALGO-001"))
4171            .exec_spawn_id(ClientOrderId::from("O-002"))
4172            .client_order_id(ClientOrderId::from("O-001"))
4173            .build()
4174            .try_into()
4175            .unwrap();
4176
4177        assert!(!order.is_primary());
4178        assert!(order.is_spawned());
4179    }
4180
4181    #[rstest]
4182    fn test_order_is_contingency() {
4183        let order: MarketOrder = OrderInitializedSpec::builder()
4184            .contingency_type(ContingencyType::Oto)
4185            .linked_order_ids(vec![ClientOrderId::from("O-LINKED")])
4186            .build()
4187            .try_into()
4188            .unwrap();
4189
4190        assert!(order.is_contingency());
4191        assert!(order.is_parent_order());
4192        assert!(!order.is_child_order());
4193    }
4194
4195    #[rstest]
4196    fn test_order_is_child_order() {
4197        let order: MarketOrder = OrderInitializedSpec::builder()
4198            .parent_order_id(ClientOrderId::from("PARENT-001"))
4199            .build()
4200            .try_into()
4201            .unwrap();
4202
4203        assert!(order.is_child_order());
4204        assert!(!order.is_parent_order());
4205    }
4206
4207    #[rstest]
4208    fn test_to_own_book_order_timestamp_ordering() {
4209        use crate::orders::limit::LimitOrder;
4210
4211        // Create order with distinct timestamps to verify parameter ordering
4212        let init = OrderInitializedSpec::builder()
4213            .price(Price::from("100.00"))
4214            .build();
4215        let submitted = OrderSubmittedSpec::builder()
4216            .ts_event(UnixNanos::from(1_000_000))
4217            .build();
4218        let accepted = OrderAcceptedSpec::builder()
4219            .ts_event(UnixNanos::from(2_000_000))
4220            .build();
4221
4222        let mut order: LimitOrder = init.try_into().unwrap();
4223        order.apply(OrderEventAny::Submitted(submitted)).unwrap();
4224        order.apply(OrderEventAny::Accepted(accepted)).unwrap();
4225
4226        let own_book_order = order.to_own_book_order();
4227
4228        // Verify timestamps are in correct positions
4229        assert_eq!(own_book_order.ts_submitted, UnixNanos::from(1_000_000));
4230        assert_eq!(own_book_order.ts_accepted, UnixNanos::from(2_000_000));
4231        assert_eq!(own_book_order.ts_last, UnixNanos::from(2_000_000));
4232    }
4233
4234    #[rstest]
4235    fn test_to_own_book_order_partial_fill_uses_leaves_qty() {
4236        use crate::orders::limit::LimitOrder;
4237
4238        let init = OrderInitializedSpec::builder()
4239            .price(Price::from("100.00"))
4240            .quantity(Quantity::from(100_000))
4241            .build();
4242        let submitted = OrderSubmittedSpec::builder().build();
4243        let accepted = OrderAcceptedSpec::builder().build();
4244        let filled = OrderFilledSpec::builder()
4245            .order_type(OrderType::Limit)
4246            .last_qty(Quantity::from(40_000))
4247            .last_px(Price::from("100.00"))
4248            .build();
4249
4250        let mut order: LimitOrder = init.try_into().unwrap();
4251        order.apply(OrderEventAny::Submitted(submitted)).unwrap();
4252        order.apply(OrderEventAny::Accepted(accepted)).unwrap();
4253        order.apply(OrderEventAny::Filled(filled)).unwrap();
4254
4255        let own_book_order = order.to_own_book_order();
4256
4257        assert_eq!(order.status(), OrderStatus::PartiallyFilled);
4258        assert_eq!(order.leaves_qty(), Quantity::from(60_000));
4259        assert_eq!(own_book_order.size, Quantity::from(60_000));
4260    }
4261
4262    #[rstest]
4263    fn test_order_accepted_without_submitted_sets_account_id() {
4264        // Test external order flow: Initialized -> Accepted (no Submitted)
4265        let init = OrderInitializedSpec::builder().build();
4266        let accepted = OrderAcceptedSpec::builder()
4267            .account_id(AccountId::from("EXTERNAL-001"))
4268            .build();
4269
4270        let mut order: MarketOrder = init.try_into().unwrap();
4271
4272        // Verify account_id is initially None
4273        assert_eq!(order.account_id(), None);
4274
4275        // Apply accepted event directly (external order case)
4276        order.apply(OrderEventAny::Accepted(accepted)).unwrap();
4277
4278        // Verify account_id is now set from the accepted event
4279        assert_eq!(order.account_id(), Some(AccountId::from("EXTERNAL-001")));
4280        assert_eq!(order.status(), OrderStatus::Accepted);
4281    }
4282
4283    #[rstest]
4284    fn test_order_accepted_after_submitted_preserves_account_id() {
4285        // Test normal order flow: Initialized -> Submitted -> Accepted
4286        let init = OrderInitializedSpec::builder().build();
4287        let submitted = OrderSubmittedSpec::builder()
4288            .account_id(AccountId::from("SUBMITTED-001"))
4289            .build();
4290        let accepted = OrderAcceptedSpec::builder()
4291            .account_id(AccountId::from("ACCEPTED-001"))
4292            .build();
4293
4294        let mut order: MarketOrder = init.try_into().unwrap();
4295        order.apply(OrderEventAny::Submitted(submitted)).unwrap();
4296
4297        // After submitted, account_id should be set
4298        assert_eq!(order.account_id(), Some(AccountId::from("SUBMITTED-001")));
4299
4300        // Apply accepted event
4301        order.apply(OrderEventAny::Accepted(accepted)).unwrap();
4302
4303        // account_id should now be updated to the accepted event's account_id
4304        assert_eq!(order.account_id(), Some(AccountId::from("ACCEPTED-001")));
4305        assert_eq!(order.status(), OrderStatus::Accepted);
4306    }
4307
4308    #[rstest]
4309    fn test_overfill_tracks_overfill_qty() {
4310        // Test that overfill is tracked on the order
4311        let init = OrderInitializedSpec::builder()
4312            .quantity(Quantity::from(100_000))
4313            .build();
4314        let submitted = OrderSubmittedSpec::builder().build();
4315        let accepted = OrderAcceptedSpec::builder().build();
4316        let overfill = OrderFilledSpec::builder()
4317            .last_qty(Quantity::from(110_000)) // Overfill: 110k > 100k
4318            .build();
4319
4320        let mut order: MarketOrder = init.try_into().unwrap();
4321        order.apply(OrderEventAny::Submitted(submitted)).unwrap();
4322        order.apply(OrderEventAny::Accepted(accepted)).unwrap();
4323        order.apply(OrderEventAny::Filled(overfill)).unwrap();
4324
4325        // Order should track overfill
4326        assert_eq!(order.overfill_qty(), Quantity::from(10_000));
4327        assert_eq!(order.filled_qty(), Quantity::from(110_000));
4328        assert_eq!(order.leaves_qty(), Quantity::from(0));
4329        assert_eq!(order.status(), OrderStatus::Filled);
4330    }
4331
4332    #[rstest]
4333    fn test_partial_fill_then_overfill() {
4334        // Test multiple fills resulting in overfill
4335        let init = OrderInitializedSpec::builder()
4336            .quantity(Quantity::from(100_000))
4337            .build();
4338        let submitted = OrderSubmittedSpec::builder().build();
4339        let accepted = OrderAcceptedSpec::builder().build();
4340        let fill1 = OrderFilledSpec::builder()
4341            .last_qty(Quantity::from(80_000))
4342            .trade_id(TradeId::from("TRADE-1"))
4343            .build();
4344        let fill2 = OrderFilledSpec::builder()
4345            .last_qty(Quantity::from(30_000)) // Total 110k > 100k
4346            .trade_id(TradeId::from("TRADE-2"))
4347            .build();
4348
4349        let mut order: MarketOrder = init.try_into().unwrap();
4350        order.apply(OrderEventAny::Submitted(submitted)).unwrap();
4351        order.apply(OrderEventAny::Accepted(accepted)).unwrap();
4352        order.apply(OrderEventAny::Filled(fill1)).unwrap();
4353
4354        // After first fill, no overfill
4355        assert_eq!(order.overfill_qty(), Quantity::from(0));
4356        assert_eq!(order.filled_qty(), Quantity::from(80_000));
4357        assert_eq!(order.leaves_qty(), Quantity::from(20_000));
4358
4359        order.apply(OrderEventAny::Filled(fill2)).unwrap();
4360
4361        // After second fill, overfill detected
4362        assert_eq!(order.overfill_qty(), Quantity::from(10_000));
4363        assert_eq!(order.filled_qty(), Quantity::from(110_000));
4364        assert_eq!(order.leaves_qty(), Quantity::from(0));
4365        assert_eq!(order.status(), OrderStatus::Filled);
4366    }
4367
4368    #[rstest]
4369    fn test_exact_fill_no_overfill() {
4370        // Test that exact fill doesn't trigger overfill tracking
4371        let init = OrderInitializedSpec::builder()
4372            .quantity(Quantity::from(100_000))
4373            .build();
4374        let submitted = OrderSubmittedSpec::builder().build();
4375        let accepted = OrderAcceptedSpec::builder().build();
4376        let filled = OrderFilledSpec::builder()
4377            .last_qty(Quantity::from(100_000)) // Exact fill
4378            .build();
4379
4380        let mut order: MarketOrder = init.try_into().unwrap();
4381        order.apply(OrderEventAny::Submitted(submitted)).unwrap();
4382        order.apply(OrderEventAny::Accepted(accepted)).unwrap();
4383        order.apply(OrderEventAny::Filled(filled)).unwrap();
4384
4385        // No overfill
4386        assert_eq!(order.overfill_qty(), Quantity::from(0));
4387        assert_eq!(order.filled_qty(), Quantity::from(100_000));
4388        assert_eq!(order.leaves_qty(), Quantity::from(0));
4389    }
4390
4391    #[rstest]
4392    fn test_partial_fill_then_overfill_with_fractional_quantities() {
4393        // Simulates real exchange scenario with fractional fills:
4394        // Order for 2450.5 units, partially filled 1202.5, then fill of 1285.5 arrives
4395        // Total filled: 2488.0, overfill: 37.5
4396        let init = OrderInitializedSpec::builder()
4397            .quantity(Quantity::from("2450.5"))
4398            .build();
4399        let submitted = OrderSubmittedSpec::builder().build();
4400        let accepted = OrderAcceptedSpec::builder().build();
4401        let fill1 = OrderFilledSpec::builder()
4402            .last_qty(Quantity::from("1202.5"))
4403            .trade_id(TradeId::from("TRADE-1"))
4404            .build();
4405        let fill2 = OrderFilledSpec::builder()
4406            .last_qty(Quantity::from("1285.5")) // 1202.5 + 1285.5 = 2488 > 2450.5
4407            .trade_id(TradeId::from("TRADE-2"))
4408            .build();
4409
4410        let mut order: MarketOrder = init.try_into().unwrap();
4411        order.apply(OrderEventAny::Submitted(submitted)).unwrap();
4412        order.apply(OrderEventAny::Accepted(accepted)).unwrap();
4413        order.apply(OrderEventAny::Filled(fill1)).unwrap();
4414
4415        // After first fill, no overfill
4416        assert_eq!(order.overfill_qty(), Quantity::from(0));
4417        assert_eq!(order.filled_qty(), Quantity::from("1202.5"));
4418        assert_eq!(order.leaves_qty(), Quantity::from("1248.0"));
4419        assert_eq!(order.status(), OrderStatus::PartiallyFilled);
4420
4421        order.apply(OrderEventAny::Filled(fill2)).unwrap();
4422
4423        // After second fill, overfill detected and tracked
4424        assert_eq!(order.overfill_qty(), Quantity::from("37.5"));
4425        assert_eq!(order.filled_qty(), Quantity::from("2488.0"));
4426        assert_eq!(order.leaves_qty(), Quantity::from(0));
4427        assert_eq!(order.status(), OrderStatus::Filled);
4428    }
4429
4430    #[rstest]
4431    fn test_calculate_overfill_returns_zero_when_no_overfill() {
4432        let order: MarketOrder = OrderInitializedSpec::builder()
4433            .quantity(Quantity::from(100_000))
4434            .build()
4435            .try_into()
4436            .unwrap();
4437
4438        // Fill qty less than order qty - no overfill
4439        let overfill = order.calculate_overfill(Quantity::from(50_000));
4440        assert_eq!(overfill, Quantity::from(0));
4441
4442        // Fill qty equals order qty - no overfill
4443        let overfill = order.calculate_overfill(Quantity::from(100_000));
4444        assert_eq!(overfill, Quantity::from(0));
4445    }
4446
4447    #[rstest]
4448    fn test_calculate_overfill_returns_overfill_amount() {
4449        let order: MarketOrder = OrderInitializedSpec::builder()
4450            .quantity(Quantity::from(100_000))
4451            .build()
4452            .try_into()
4453            .unwrap();
4454
4455        // Fill qty exceeds order qty
4456        let overfill = order.calculate_overfill(Quantity::from(110_000));
4457        assert_eq!(overfill, Quantity::from(10_000));
4458    }
4459
4460    #[rstest]
4461    fn test_calculate_overfill_accounts_for_existing_fills() {
4462        let init = OrderInitializedSpec::builder()
4463            .quantity(Quantity::from(100_000))
4464            .build();
4465        let submitted = OrderSubmittedSpec::builder().build();
4466        let accepted = OrderAcceptedSpec::builder().build();
4467        let partial_fill = OrderFilledSpec::builder()
4468            .last_qty(Quantity::from(60_000))
4469            .build();
4470
4471        let mut order: MarketOrder = init.try_into().unwrap();
4472        order.apply(OrderEventAny::Submitted(submitted)).unwrap();
4473        order.apply(OrderEventAny::Accepted(accepted)).unwrap();
4474        order.apply(OrderEventAny::Filled(partial_fill)).unwrap();
4475
4476        // Order is 60k filled, 40k remaining
4477        // Fill of 50k would overfill by 10k
4478        let overfill = order.calculate_overfill(Quantity::from(50_000));
4479        assert_eq!(overfill, Quantity::from(10_000));
4480
4481        // Fill of 40k would not overfill
4482        let overfill = order.calculate_overfill(Quantity::from(40_000));
4483        assert_eq!(overfill, Quantity::from(0));
4484    }
4485
4486    #[rstest]
4487    fn test_calculate_overfill_with_fractional_quantities() {
4488        let order: MarketOrder = OrderInitializedSpec::builder()
4489            .quantity(Quantity::from("2450.5"))
4490            .build()
4491            .try_into()
4492            .unwrap();
4493
4494        // Simulates the exact scenario from user's log
4495        // Order for 2450.5, if fill of 2488.0 arrives
4496        let overfill = order.calculate_overfill(Quantity::from("2488.0"));
4497        assert_eq!(overfill, Quantity::from("37.5"));
4498    }
4499
4500    #[rstest]
4501    fn test_calculate_overfill_zero_after_fractional_partial_fill() {
4502        let init = OrderInitializedSpec::builder()
4503            .quantity(Quantity::from("1.000"))
4504            .build();
4505        let submitted = OrderSubmittedSpec::builder().build();
4506        let accepted = OrderAcceptedSpec::builder().build();
4507        let partial_fill = OrderFilledSpec::builder()
4508            .last_qty(Quantity::from("0.072"))
4509            .build();
4510
4511        let mut order: MarketOrder = init.try_into().unwrap();
4512        order.apply(OrderEventAny::Submitted(submitted)).unwrap();
4513        order.apply(OrderEventAny::Accepted(accepted)).unwrap();
4514        order.apply(OrderEventAny::Filled(partial_fill)).unwrap();
4515
4516        // After filling 0.072 of 1.000, another 0.072 fill should not overfill
4517        let overfill = order.calculate_overfill(Quantity::from("0.072"));
4518        assert_eq!(overfill, Quantity::from("0.000"));
4519    }
4520
4521    #[rstest]
4522    fn test_duplicate_fill_rejected() {
4523        let init = OrderInitializedSpec::builder()
4524            .quantity(Quantity::from(100_000))
4525            .build();
4526        let submitted = OrderSubmittedSpec::builder().build();
4527        let accepted = OrderAcceptedSpec::builder().build();
4528        let fill1 = OrderFilledSpec::builder()
4529            .last_qty(Quantity::from(50_000))
4530            .trade_id(TradeId::from("TRADE-001"))
4531            .build();
4532        let fill2_duplicate = OrderFilledSpec::builder()
4533            .last_qty(Quantity::from(50_000))
4534            .trade_id(TradeId::from("TRADE-001")) // Same trade_id as fill1
4535            .build();
4536
4537        let mut order: MarketOrder = init.try_into().unwrap();
4538        order.apply(OrderEventAny::Submitted(submitted)).unwrap();
4539        order.apply(OrderEventAny::Accepted(accepted)).unwrap();
4540        order.apply(OrderEventAny::Filled(fill1)).unwrap();
4541
4542        // Verify first fill applied successfully
4543        assert_eq!(order.filled_qty(), Quantity::from(50_000));
4544        assert_eq!(order.status(), OrderStatus::PartiallyFilled);
4545
4546        // Applying duplicate fill should return DuplicateFill error
4547        let result = order.apply(OrderEventAny::Filled(fill2_duplicate));
4548        assert!(result.is_err());
4549        match result.unwrap_err() {
4550            OrderError::DuplicateFill(trade_id) => {
4551                assert_eq!(trade_id, TradeId::from("TRADE-001"));
4552            }
4553            e => panic!("Expected DuplicateFill error, was: {e:?}"),
4554        }
4555
4556        // Order state should be unchanged after rejected duplicate
4557        assert_eq!(order.filled_qty(), Quantity::from(50_000));
4558        assert_eq!(order.status(), OrderStatus::PartiallyFilled);
4559    }
4560
4561    #[rstest]
4562    fn test_same_trade_id_new_price_restates_average_and_void_matches_original_price() {
4563        let trade_id = TradeId::from("TRADE-1");
4564        let qty = Quantity::from("2");
4565        let original_px = Price::from("12");
4566        let restated_px = Price::from("9.47");
4567        let mut order =
4568            market_order_with_fills(OrderSide::Buy, qty, &[(trade_id, qty, original_px)]);
4569        let restatement = OrderFilledSpec::builder()
4570            .order_side(OrderSide::Buy)
4571            .trade_id(trade_id)
4572            .last_qty(qty)
4573            .last_px(restated_px)
4574            .event_id(UUID4::new())
4575            .build();
4576
4577        order
4578            .apply(OrderEventAny::Filled(restatement.clone()))
4579            .unwrap();
4580        let repeated = order.apply(OrderEventAny::Filled(restatement));
4581        assert!(matches!(repeated, Err(OrderError::DuplicateFill(_))));
4582
4583        let stored_px = order.events().iter().find_map(|event| match event {
4584            OrderEventAny::Filled(fill) if fill.last_px == original_px => Some(fill.last_px),
4585            _ => None,
4586        });
4587
4588        let replayed =
4589            OrderAny::from_events(order.events().into_iter().cloned().collect()).unwrap();
4590
4591        assert_eq!(order.status(), OrderStatus::Filled);
4592        assert_eq!(order.filled_qty(), qty);
4593        assert!(order.leaves_qty().is_zero());
4594        let returned = OrderFilledSpec::builder()
4595            .order_side(OrderSide::Buy)
4596            .trade_id(trade_id)
4597            .last_qty(qty)
4598            .last_px(original_px)
4599            .event_id(UUID4::new())
4600            .build();
4601        order.apply(OrderEventAny::Filled(returned)).unwrap();
4602        assert_eq!(order.avg_px(), Some(dec!(12)));
4603        assert_eq!(order.filled_qty(), qty);
4604        assert_eq!(order.trade_ids().len(), 1);
4605        assert_eq!(stored_px, Some(original_px));
4606        assert_eq!(replayed.status(), OrderStatus::Filled);
4607        assert_eq!(replayed.filled_qty(), qty);
4608        assert_eq!(replayed.avg_px(), Some(dec!(9.47)));
4609
4610        order
4611            .apply(OrderEventAny::FillVoided(
4612                OrderFillVoidedSpec::builder()
4613                    .trade_id(trade_id)
4614                    .voided_qty(qty)
4615                    .last_px(original_px)
4616                    .order_side(OrderSide::Buy)
4617                    .build(),
4618            ))
4619            .unwrap();
4620
4621        let mut mismatched =
4622            market_order_with_fills(OrderSide::Buy, qty, &[(trade_id, qty, original_px)]);
4623        mismatched
4624            .apply(OrderEventAny::Filled(
4625                OrderFilledSpec::builder()
4626                    .order_side(OrderSide::Buy)
4627                    .trade_id(trade_id)
4628                    .last_qty(qty)
4629                    .last_px(restated_px)
4630                    .event_id(UUID4::new())
4631                    .build(),
4632            ))
4633            .unwrap();
4634        let rejected = mismatched.apply(OrderEventAny::FillVoided(
4635            OrderFillVoidedSpec::builder()
4636                .trade_id(trade_id)
4637                .voided_qty(qty)
4638                .last_px(restated_px)
4639                .order_side(OrderSide::Buy)
4640                .build(),
4641        ));
4642
4643        assert!(matches!(rejected, Err(OrderError::InvalidOrderEvent)));
4644    }
4645
4646    #[rstest]
4647    fn test_fill_raw_overflow_rejected_without_mutation() {
4648        let unit = Quantity::from(1);
4649        let almost_max = Quantity::from_raw(QUANTITY_RAW_MAX - unit.raw(), 0);
4650        let max = Quantity::from_raw(QUANTITY_RAW_MAX, 0);
4651        let init = OrderInitializedSpec::builder().quantity(max).build();
4652        let accepted = OrderAcceptedSpec::builder().build();
4653        let fill1 = OrderFilledSpec::builder()
4654            .last_qty(almost_max)
4655            .trade_id(TradeId::from("TRADE-001"))
4656            .build();
4657        let fill2 = OrderFilledSpec::builder()
4658            .last_qty(Quantity::from(2))
4659            .trade_id(TradeId::from("TRADE-002"))
4660            .build();
4661
4662        let mut order: MarketOrder = init.try_into().unwrap();
4663        order.apply(OrderEventAny::Accepted(accepted)).unwrap();
4664        order.apply(OrderEventAny::Filled(fill1)).unwrap();
4665
4666        assert_eq!(order.filled_qty(), almost_max);
4667        assert_eq!(order.status(), OrderStatus::PartiallyFilled);
4668
4669        let result = order.apply(OrderEventAny::Filled(fill2));
4670        let Err(OrderError::Invariant(CorrectnessError::PredicateViolation { message })) = result
4671        else {
4672            panic!("Expected typed invariant error, was: {result:?}");
4673        };
4674        assert_eq!(
4675            message,
4676            format!("filled quantity overflowed Quantity raw bounds: {almost_max} + 2")
4677        );
4678        assert_eq!(order.filled_qty(), almost_max);
4679        assert_eq!(order.status(), OrderStatus::PartiallyFilled);
4680        assert_eq!(order.event_count(), 3);
4681    }
4682
4683    #[rstest]
4684    #[case::domain_overflow(1)]
4685    #[case::integer_overflow(Money::from("1 USD").raw())]
4686    fn test_fill_commission_overflow_rejected_without_mutation(
4687        #[case] increment: MoneyRaw,
4688        #[values(false, true)] negative: bool,
4689        #[values(false, true)] fill_report_order: bool,
4690    ) {
4691        let usd = Currency::USD();
4692
4693        let bound = if negative {
4694            MONEY_RAW_MIN
4695        } else {
4696            MONEY_RAW_MAX
4697        };
4698
4699        let commission = Money::from_raw_checked(bound, usd).unwrap();
4700        let additional =
4701            Money::from_raw_checked(if negative { -increment } else { increment }, usd).unwrap();
4702        let init = OrderInitializedSpec::builder()
4703            .quantity(Quantity::from(if fill_report_order { 1 } else { 2 }))
4704            .reconciliation(fill_report_order)
4705            .maybe_tags(fill_report_order.then(|| vec![Ustr::from(FILL_REPORT_ORDER_TAG)]))
4706            .build();
4707        let mut order: MarketOrder = init.try_into().unwrap();
4708        order
4709            .apply(OrderEventAny::Accepted(
4710                OrderAcceptedSpec::builder().build(),
4711            ))
4712            .unwrap();
4713        let first = OrderFilledSpec::builder()
4714            .trade_id(TradeId::from("TRADE-1"))
4715            .last_qty(Quantity::from(1))
4716            .commission(commission)
4717            .ts_event(11.into())
4718            .build();
4719        let second = OrderFilledSpec::builder()
4720            .trade_id(TradeId::from("TRADE-2"))
4721            .last_qty(Quantity::from(1))
4722            .commission(additional)
4723            .position_id(PositionId::from("POSITION-2"))
4724            .ts_event(29.into())
4725            .build();
4726        order.apply(OrderEventAny::Filled(first)).unwrap();
4727        let before = serde_json::to_value(&order).unwrap();
4728        let totals_before = order
4729            .fill_totals
4730            .as_ref()
4731            .map(|totals| (totals.notional, totals.quantity));
4732
4733        let result = order.apply(OrderEventAny::Filled(second));
4734
4735        let Err(OrderError::Invariant(CorrectnessError::PredicateViolation { message })) = result
4736        else {
4737            panic!("Expected typed invariant error, was: {result:?}");
4738        };
4739
4740        assert_eq!(
4741            message,
4742            format!("cumulative commission overflowed Money bounds: {commission} + {additional}")
4743        );
4744        assert_eq!(serde_json::to_value(&order).unwrap(), before);
4745        assert_eq!(
4746            order
4747                .fill_totals
4748                .as_ref()
4749                .map(|totals| (totals.notional, totals.quantity)),
4750            totals_before
4751        );
4752    }
4753
4754    #[rstest]
4755    fn test_fill_commission_bounds_survive_corrections_and_replay() {
4756        let usd = Currency::USD();
4757        let aud = Currency::AUD();
4758        let unit = Money::from("1 USD");
4759        let max = Money::from_raw_checked(MONEY_RAW_MAX, usd).unwrap();
4760        let other_max = Money::from_raw_checked(MONEY_RAW_MAX, aud).unwrap();
4761        let init = OrderInitializedSpec::builder()
4762            .quantity(Quantity::from(6))
4763            .build();
4764        let mut order: MarketOrder = init.try_into().unwrap();
4765        order
4766            .apply(OrderEventAny::Accepted(
4767                OrderAcceptedSpec::builder().build(),
4768            ))
4769            .unwrap();
4770        let first = OrderFilledSpec::builder()
4771            .trade_id(TradeId::from("TRADE-1"))
4772            .last_qty(Quantity::from(2))
4773            .commission(max - unit)
4774            .build();
4775        order.apply(OrderEventAny::Filled(first.clone())).unwrap();
4776        order
4777            .apply(OrderEventAny::Filled(
4778                OrderFilledSpec::builder()
4779                    .trade_id(TradeId::from("TRADE-2"))
4780                    .last_qty(Quantity::from(1))
4781                    .commission(unit)
4782                    .build(),
4783            ))
4784            .unwrap();
4785        order
4786            .apply(OrderEventAny::Filled(
4787                OrderFilledSpec::builder()
4788                    .trade_id(TradeId::from("TRADE-3"))
4789                    .last_qty(Quantity::from(1))
4790                    .commission(other_max)
4791                    .build(),
4792            ))
4793            .unwrap();
4794        order
4795            .apply(OrderEventAny::FillVoided(matching_fill_void(
4796                &first,
4797                Quantity::from(1),
4798                Some(unit),
4799            )))
4800            .unwrap();
4801        assert_eq!(order.commission(&usd), Some(max - unit));
4802        order
4803            .apply(OrderEventAny::Filled(
4804                OrderFilledSpec::builder()
4805                    .trade_id(TradeId::from("TRADE-4"))
4806                    .last_qty(Quantity::from(1))
4807                    .commission(unit)
4808                    .build(),
4809            ))
4810            .unwrap();
4811        let replayed =
4812            OrderAny::from_events(order.events().into_iter().cloned().collect()).unwrap();
4813        let before = serde_json::to_value(&order).unwrap();
4814        let overflow = OrderFilledSpec::builder()
4815            .trade_id(TradeId::from("TRADE-5"))
4816            .last_qty(Quantity::from(1))
4817            .commission(unit)
4818            .build();
4819
4820        let result = order.apply(OrderEventAny::Filled(overflow));
4821
4822        assert!(matches!(result, Err(OrderError::Invariant(_))));
4823        assert_eq!(serde_json::to_value(&order).unwrap(), before);
4824        assert_eq!(order.commission(&usd), Some(max));
4825        assert_eq!(order.commission(&aud), Some(other_max));
4826        assert_eq!(order.filled_qty(), Quantity::from(4));
4827        assert_eq!(order.leaves_qty(), Quantity::from(2));
4828        assert_eq!(replayed.commissions(), order.commissions());
4829        assert_eq!(replayed.filled_qty(), order.filled_qty());
4830        assert_eq!(replayed.leaves_qty(), order.leaves_qty());
4831    }
4832
4833    #[rstest]
4834    fn test_late_fill_on_filled_order_is_invalid_transition_not_overflow() {
4835        let max = Quantity::from_raw(QUANTITY_RAW_MAX, 0);
4836        let init = OrderInitializedSpec::builder().quantity(max).build();
4837        let accepted = OrderAcceptedSpec::builder().build();
4838        let fill1 = OrderFilledSpec::builder()
4839            .last_qty(max)
4840            .trade_id(TradeId::from("TRADE-001"))
4841            .build();
4842        let fill2 = OrderFilledSpec::builder()
4843            .last_qty(Quantity::from(1))
4844            .trade_id(TradeId::from("TRADE-002"))
4845            .build();
4846
4847        let mut order: MarketOrder = init.try_into().unwrap();
4848        order.apply(OrderEventAny::Accepted(accepted)).unwrap();
4849        order.apply(OrderEventAny::Filled(fill1)).unwrap();
4850
4851        let result = order.apply(OrderEventAny::Filled(fill2));
4852        assert!(matches!(result, Err(OrderError::InvalidStateTransition)));
4853        assert_eq!(order.filled_qty(), max);
4854        assert_eq!(order.status(), OrderStatus::Filled);
4855    }
4856
4857    #[rstest]
4858    fn test_quantity_saturating_add_clamps_undef_sentinel() {
4859        let qty = Quantity::from_raw(QuantityRaw::MAX, 0).saturating_add(Quantity::zero(0));
4860
4861        assert_eq!(qty, Quantity::from_raw(QUANTITY_RAW_MAX, 0));
4862        assert!(!qty.is_undefined());
4863    }
4864
4865    #[rstest]
4866    fn test_check_display_qty_returns_typed_invariant_with_stable_display() {
4867        let error = check_display_qty(Some(Quantity::from(2)), Quantity::from(1)).unwrap_err();
4868
4869        match error {
4870            OrderError::Invariant(CorrectnessError::PredicateViolation { ref message }) => {
4871                assert_eq!(message, "`display_qty` may not exceed `quantity`");
4872            }
4873            other => panic!("Expected typed invariant error, was: {other:?}"),
4874        }
4875
4876        assert_eq!(error.to_string(), "`display_qty` may not exceed `quantity`");
4877    }
4878
4879    #[rstest]
4880    fn test_check_time_in_force_returns_typed_invariant_with_stable_display() {
4881        let error = check_time_in_force(TimeInForce::Gtd, None).unwrap_err();
4882
4883        match error {
4884            OrderError::Invariant(CorrectnessError::PredicateViolation { ref message }) => {
4885                assert_eq!(message, "`expire_time` is required for `GTD` order");
4886            }
4887            other => panic!("Expected typed invariant error, was: {other:?}"),
4888        }
4889
4890        assert_eq!(
4891            error.to_string(),
4892            "`expire_time` is required for `GTD` order"
4893        );
4894    }
4895
4896    #[rstest]
4897    fn test_different_trade_ids_allowed() {
4898        let init = OrderInitializedSpec::builder()
4899            .quantity(Quantity::from(100_000))
4900            .build();
4901        let submitted = OrderSubmittedSpec::builder().build();
4902        let accepted = OrderAcceptedSpec::builder().build();
4903        let fill1 = OrderFilledSpec::builder()
4904            .last_qty(Quantity::from(50_000))
4905            .trade_id(TradeId::from("TRADE-001"))
4906            .build();
4907        let fill2 = OrderFilledSpec::builder()
4908            .last_qty(Quantity::from(50_000))
4909            .trade_id(TradeId::from("TRADE-002")) // Different trade_id
4910            .build();
4911
4912        let mut order: MarketOrder = init.try_into().unwrap();
4913        order.apply(OrderEventAny::Submitted(submitted)).unwrap();
4914        order.apply(OrderEventAny::Accepted(accepted)).unwrap();
4915        order.apply(OrderEventAny::Filled(fill1)).unwrap();
4916        order.apply(OrderEventAny::Filled(fill2)).unwrap();
4917
4918        // Both fills should be applied
4919        assert_eq!(order.filled_qty(), Quantity::from(100_000));
4920        assert_eq!(order.status(), OrderStatus::Filled);
4921        assert_eq!(order.trade_ids.len(), 2);
4922    }
4923
4924    #[rstest]
4925    fn test_pending_update_order_restores_status_on_updated() {
4926        let init = OrderInitializedSpec::builder()
4927            .quantity(Quantity::from(100_000))
4928            .build();
4929        let submitted = OrderSubmittedSpec::builder().build();
4930        let accepted = OrderAcceptedSpec::builder().build();
4931        let pending_update = OrderPendingUpdateSpec::builder().build();
4932        let fill = OrderFilledSpec::builder()
4933            .last_qty(Quantity::from(10_000))
4934            .build();
4935        let updated = OrderUpdatedSpec::builder()
4936            .quantity(Quantity::from(50_000))
4937            .build();
4938
4939        let mut order: MarketOrder = init.try_into().unwrap();
4940        order.apply(OrderEventAny::Submitted(submitted)).unwrap();
4941        order.apply(OrderEventAny::Accepted(accepted)).unwrap();
4942
4943        assert_eq!(order.status(), OrderStatus::Accepted);
4944
4945        order
4946            .apply(OrderEventAny::PendingUpdate(pending_update))
4947            .unwrap();
4948        order.apply(OrderEventAny::Filled(fill)).unwrap();
4949        assert_eq!(order.status(), OrderStatus::PendingUpdate);
4950        assert_eq!(order.previous_status(), Some(OrderStatus::PartiallyFilled));
4951        assert_eq!(order.filled_qty(), Quantity::from(10_000));
4952
4953        order.apply(OrderEventAny::Updated(updated)).unwrap();
4954
4955        assert_eq!(order.status(), OrderStatus::PartiallyFilled);
4956        assert_eq!(order.quantity(), Quantity::from(50_000));
4957        assert_eq!(order.leaves_qty(), Quantity::from(40_000));
4958    }
4959
4960    #[rstest]
4961    fn test_pending_cancel_supersedes_pending_update_without_losing_previous_status() {
4962        let mut order: MarketOrder = OrderInitializedSpec::builder().build().try_into().unwrap();
4963        order
4964            .apply(OrderEventAny::Submitted(
4965                OrderSubmittedSpec::builder().build(),
4966            ))
4967            .unwrap();
4968        order
4969            .apply(OrderEventAny::Accepted(
4970                OrderAcceptedSpec::builder().build(),
4971            ))
4972            .unwrap();
4973        order
4974            .apply(OrderEventAny::PendingUpdate(
4975                OrderPendingUpdateSpec::builder().build(),
4976            ))
4977            .unwrap();
4978
4979        assert_eq!(order.status(), OrderStatus::PendingUpdate);
4980        assert_eq!(order.previous_status(), Some(OrderStatus::Accepted));
4981
4982        order
4983            .apply(OrderEventAny::PendingCancel(
4984                OrderPendingCancelSpec::builder().build(),
4985            ))
4986            .unwrap();
4987
4988        assert_eq!(order.status(), OrderStatus::PendingCancel);
4989        assert_eq!(order.previous_status(), Some(OrderStatus::Accepted));
4990
4991        let repeated = OrderEventAny::PendingCancel(OrderPendingCancelSpec::builder().build());
4992        order.apply(repeated.clone()).unwrap();
4993
4994        assert_eq!(order.status(), OrderStatus::PendingCancel);
4995        assert_eq!(order.previous_status(), Some(OrderStatus::Accepted));
4996        assert_eq!(order.event_count(), 6);
4997        assert_eq!(order.last_event(), &repeated);
4998    }
4999
5000    #[rstest]
5001    fn test_late_fill_for_historical_venue_order_keeps_current_venue_order_id() {
5002        let old_venue_order_id = VenueOrderId::from("V-OLD");
5003        let new_venue_order_id = VenueOrderId::from("V-NEW");
5004        let init = OrderInitializedSpec::builder()
5005            .quantity(Quantity::from(10))
5006            .build();
5007        let accepted = OrderAcceptedSpec::builder()
5008            .venue_order_id(old_venue_order_id)
5009            .build();
5010        let updated = OrderUpdatedSpec::builder()
5011            .quantity(Quantity::from(10))
5012            .venue_order_id(new_venue_order_id)
5013            .build();
5014        let late_fill = OrderFilledSpec::builder()
5015            .venue_order_id(old_venue_order_id)
5016            .last_qty(Quantity::from(2))
5017            .trade_id(TradeId::from("T-LATE"))
5018            .build();
5019
5020        let mut order: MarketOrder = init.try_into().unwrap();
5021        order.apply(OrderEventAny::Accepted(accepted)).unwrap();
5022        order.apply(OrderEventAny::Updated(updated)).unwrap();
5023        order.apply(OrderEventAny::Filled(late_fill)).unwrap();
5024
5025        assert_eq!(order.status(), OrderStatus::PartiallyFilled);
5026        assert_eq!(order.quantity(), Quantity::from(10));
5027        assert_eq!(order.filled_qty(), Quantity::from(2));
5028        assert_eq!(order.leaves_qty(), Quantity::from(8));
5029        assert_eq!(order.venue_order_id(), Some(new_venue_order_id));
5030        assert_eq!(
5031            order
5032                .venue_order_ids()
5033                .into_iter()
5034                .copied()
5035                .collect::<Vec<_>>(),
5036            vec![old_venue_order_id, new_venue_order_id],
5037        );
5038        let OrderEventAny::Filled(event) = order.last_event() else {
5039            panic!("last event was not the late fill");
5040        };
5041        assert_eq!(event.venue_order_id, old_venue_order_id);
5042    }
5043
5044    #[rstest]
5045    fn test_pending_update_accepts_delayed_submitted() {
5046        let init = OrderInitializedSpec::builder()
5047            .quantity(Quantity::from(100_000))
5048            .build();
5049        let submitted = OrderSubmittedSpec::builder()
5050            .ts_event(UnixNanos::from(1_000))
5051            .build();
5052        let accepted = OrderAcceptedSpec::builder().build();
5053        let pending_update = OrderPendingUpdateSpec::builder().build();
5054
5055        // A distinct account and timestamp so the `submitted` handler's writes are
5056        // observable: with identical specs the assertions below cannot tell whether
5057        // the handler ran at all.
5058        let delayed_submitted = OrderSubmittedSpec::builder()
5059            .account_id(AccountId::from("SIM-002"))
5060            .ts_event(UnixNanos::from(3_000))
5061            .build();
5062        let updated = OrderUpdatedSpec::builder()
5063            .quantity(Quantity::from(50_000))
5064            .build();
5065
5066        let mut order: MarketOrder = init.try_into().unwrap();
5067        order.apply(OrderEventAny::Submitted(submitted)).unwrap();
5068        order.apply(OrderEventAny::Accepted(accepted)).unwrap();
5069        order
5070            .apply(OrderEventAny::PendingUpdate(pending_update))
5071            .unwrap();
5072
5073        assert_eq!(order.status(), OrderStatus::PendingUpdate);
5074        assert_eq!(order.previous_status(), Some(OrderStatus::Accepted));
5075        assert_eq!(order.account_id(), Some(AccountId::from("SIM-001")));
5076        assert_eq!(order.ts_submitted(), Some(UnixNanos::from(1_000)));
5077
5078        order
5079            .apply(OrderEventAny::Submitted(delayed_submitted))
5080            .unwrap();
5081
5082        // The order holds PendingUpdate and keeps the pre-update status, so the
5083        // in-flight modify can still be resolved.
5084        assert_eq!(order.status(), OrderStatus::PendingUpdate);
5085        assert_eq!(order.previous_status(), Some(OrderStatus::Accepted));
5086
5087        assert_eq!(order.account_id(), Some(AccountId::from("SIM-002")));
5088        assert_eq!(order.ts_submitted(), Some(UnixNanos::from(3_000)));
5089
5090        order.apply(OrderEventAny::Updated(updated)).unwrap();
5091
5092        assert_eq!(order.status(), OrderStatus::Accepted);
5093        assert_eq!(order.quantity(), Quantity::from(50_000));
5094    }
5095
5096    #[rstest]
5097    #[case::submitted(false, OrderStatus::Submitted)]
5098    #[case::accepted(true, OrderStatus::Accepted)]
5099    fn test_rejected_event_preserves_status_restoration(
5100        #[case] accepted_first: bool,
5101        #[case] restored_status: OrderStatus,
5102    ) {
5103        let init = OrderInitializedSpec::builder().build();
5104        let submitted = OrderSubmittedSpec::builder().build();
5105        let accepted = OrderAcceptedSpec::builder().build();
5106        let invalid = OrderSubmittedSpec::builder().build();
5107        let pending_update = OrderPendingUpdateSpec::builder().build();
5108        let modify_rejected = OrderModifyRejectedSpec::builder().build();
5109        let mut order: MarketOrder = init.try_into().unwrap();
5110        order.apply(OrderEventAny::Submitted(submitted)).unwrap();
5111        if accepted_first {
5112            order.apply(OrderEventAny::Accepted(accepted)).unwrap();
5113        }
5114
5115        let previous_status = order.previous_status();
5116
5117        let result = order.apply(OrderEventAny::Submitted(invalid));
5118
5119        assert!(matches!(result, Err(OrderError::InvalidStateTransition)));
5120        assert_eq!(order.previous_status(), previous_status);
5121
5122        order
5123            .apply(OrderEventAny::PendingUpdate(pending_update))
5124            .unwrap();
5125        order
5126            .apply(OrderEventAny::ModifyRejected(modify_rejected))
5127            .unwrap();
5128        assert_eq!(order.status(), restored_status);
5129    }
5130
5131    #[rstest]
5132    #[case(false, false)]
5133    #[case(false, true)]
5134    #[case(true, false)]
5135    #[case(true, true)]
5136    fn test_command_refusals_preserve_other_pending_commands(
5137        #[case] second_is_cancel: bool,
5138        #[case] first_denied_first: bool,
5139        #[values(false, true)] venue_rejected: bool,
5140    ) {
5141        let mut order = OrderTestBuilder::new(OrderType::Limit)
5142            .instrument_id(InstrumentId::test_default())
5143            .quantity(Quantity::from(10))
5144            .price(Price::from("98.00"))
5145            .submit(true)
5146            .build();
5147        order
5148            .apply(OrderEventAny::Accepted(
5149                OrderAcceptedSpec::builder().build(),
5150            ))
5151            .unwrap();
5152        let first = UUID4::new();
5153        let second = UUID4::new();
5154        let mut pending_first = OrderPendingUpdateSpec::builder().build();
5155        pending_first.causation_id = Some(first);
5156        order
5157            .apply(OrderEventAny::PendingUpdate(pending_first))
5158            .unwrap();
5159
5160        let second_kind = if second_is_cancel {
5161            let mut pending = OrderPendingCancelSpec::builder().build();
5162            pending.causation_id = Some(second);
5163            order.apply(OrderEventAny::PendingCancel(pending)).unwrap();
5164            OrderStatus::PendingCancel
5165        } else {
5166            let mut pending = OrderPendingUpdateSpec::builder().build();
5167            pending.causation_id = Some(second);
5168            order.apply(OrderEventAny::PendingUpdate(pending)).unwrap();
5169            OrderStatus::PendingUpdate
5170        };
5171
5172        let deny_first = OrderEventAny::ModifyDenied(
5173            OrderModifyDeniedSpec::builder().causation_id(first).build(),
5174        );
5175
5176        let deny_second = if second_is_cancel {
5177            OrderEventAny::CancelDenied(
5178                OrderCancelDeniedSpec::builder()
5179                    .causation_id(second)
5180                    .build(),
5181            )
5182        } else {
5183            OrderEventAny::ModifyDenied(
5184                OrderModifyDeniedSpec::builder()
5185                    .causation_id(second)
5186                    .build(),
5187            )
5188        };
5189
5190        let (deny_first, deny_second) = if venue_rejected {
5191            let first_event = OrderEventAny::ModifyRejected(OrderModifyRejected {
5192                causation_id: Some(first),
5193                ..OrderModifyRejectedSpec::builder().build()
5194            });
5195
5196            let second_event = if second_is_cancel {
5197                OrderEventAny::CancelRejected(OrderCancelRejected {
5198                    causation_id: Some(second),
5199                    ..OrderCancelRejectedSpec::builder().build()
5200                })
5201            } else {
5202                OrderEventAny::ModifyRejected(OrderModifyRejected {
5203                    causation_id: Some(second),
5204                    ..OrderModifyRejectedSpec::builder().build()
5205                })
5206            };
5207
5208            (first_event, second_event)
5209        } else {
5210            (deny_first, deny_second)
5211        };
5212
5213        let (first_event, second_event, remaining_status) = if first_denied_first {
5214            (deny_first, deny_second, second_kind)
5215        } else {
5216            (deny_second, deny_first, OrderStatus::PendingUpdate)
5217        };
5218
5219        order.apply(first_event).unwrap();
5220
5221        assert_eq!(order.status(), remaining_status);
5222        assert_eq!(
5223            order.has_pending_cancel_command(),
5224            second_is_cancel && first_denied_first
5225        );
5226
5227        let mut restored =
5228            OrderAny::from_events(order.events().into_iter().cloned().collect()).unwrap();
5229        assert_eq!(restored.status(), remaining_status);
5230        assert_eq!(
5231            restored.has_pending_cancel_command(),
5232            order.has_pending_cancel_command()
5233        );
5234        restored.apply(second_event.clone()).unwrap();
5235        order.apply(second_event).unwrap();
5236
5237        assert_eq!(order.status(), OrderStatus::Accepted);
5238        assert_eq!(order.quantity(), Quantity::from(10));
5239        assert_eq!(order.price(), Some(Price::from("98.00")));
5240        assert_eq!(order.filled_qty(), Quantity::zero(0));
5241        assert_eq!(order.leaves_qty(), Quantity::from(10));
5242        assert_eq!(order.ts_closed(), None);
5243        assert!(!order.has_pending_cancel_command());
5244        assert_eq!(
5245            serde_json::to_value(&restored).unwrap(),
5246            serde_json::to_value(&order).unwrap()
5247        );
5248    }
5249
5250    #[rstest]
5251    fn test_known_modify_outcome_preserves_legacy_pending_command(
5252        #[values(false, true)] legacy_cancel: bool,
5253        #[values(false, true)] updated: bool,
5254    ) {
5255        let mut order = OrderTestBuilder::new(OrderType::Limit)
5256            .instrument_id(InstrumentId::test_default())
5257            .quantity(Quantity::from(10))
5258            .price(Price::from("98.00"))
5259            .submit(true)
5260            .build();
5261        order
5262            .apply(OrderEventAny::Accepted(
5263                OrderAcceptedSpec::builder().build(),
5264            ))
5265            .unwrap();
5266        let cause = UUID4::new();
5267        let mut pending = OrderPendingUpdateSpec::builder().build();
5268        pending.causation_id = Some(cause);
5269        let legacy_status = if legacy_cancel {
5270            order.apply(OrderEventAny::PendingUpdate(pending)).unwrap();
5271            order
5272                .apply(OrderEventAny::PendingCancel(
5273                    OrderPendingCancelSpec::builder().build(),
5274                ))
5275                .unwrap();
5276            OrderStatus::PendingCancel
5277        } else {
5278            order
5279                .apply(OrderEventAny::PendingUpdate(
5280                    OrderPendingUpdateSpec::builder().build(),
5281                ))
5282                .unwrap();
5283            order.apply(OrderEventAny::PendingUpdate(pending)).unwrap();
5284            OrderStatus::PendingUpdate
5285        };
5286
5287        if updated {
5288            let mut event = OrderUpdatedSpec::builder()
5289                .quantity(Quantity::from(21))
5290                .price(Price::from("99.00"))
5291                .build();
5292            event.causation_id = Some(cause);
5293            order.apply(OrderEventAny::Updated(event)).unwrap();
5294        } else {
5295            order
5296                .apply(OrderEventAny::ModifyDenied(
5297                    OrderModifyDeniedSpec::builder().causation_id(cause).build(),
5298                ))
5299                .unwrap();
5300        }
5301
5302        assert_eq!(order.status(), legacy_status);
5303        assert_eq!(order.has_pending_cancel_command(), legacy_cancel);
5304        let mut replayed =
5305            OrderAny::from_events(order.events().into_iter().cloned().collect()).unwrap();
5306
5307        let resolution = if legacy_cancel {
5308            OrderEventAny::CancelRejected(OrderCancelRejectedSpec::builder().build())
5309        } else {
5310            OrderEventAny::ModifyRejected(OrderModifyRejectedSpec::builder().build())
5311        };
5312
5313        replayed.apply(resolution.clone()).unwrap();
5314        order.apply(resolution).unwrap();
5315        assert_eq!(order.status(), OrderStatus::Accepted);
5316        assert_eq!(
5317            order.quantity(),
5318            Quantity::from(if updated { 21 } else { 10 })
5319        );
5320        assert_eq!(
5321            order.price(),
5322            Some(Price::from(if updated { "99.00" } else { "98.00" }))
5323        );
5324        assert_eq!(order.filled_qty(), Quantity::zero(0));
5325        assert_eq!(order.ts_closed(), None);
5326        assert_eq!(
5327            serde_json::to_value(&order).unwrap(),
5328            serde_json::to_value(&replayed).unwrap()
5329        );
5330    }
5331
5332    #[rstest]
5333    #[case(false)]
5334    #[case(true)]
5335    fn test_denied_command_preserves_intervening_fill(#[case] fully_filled: bool) {
5336        let mut order = OrderTestBuilder::new(OrderType::Limit)
5337            .instrument_id(InstrumentId::test_default())
5338            .quantity(Quantity::from(10))
5339            .price(Price::from("98.00"))
5340            .submit(true)
5341            .build();
5342        order
5343            .apply(OrderEventAny::Accepted(
5344                OrderAcceptedSpec::builder().build(),
5345            ))
5346            .unwrap();
5347        let command_id = UUID4::new();
5348        let mut pending = OrderPendingCancelSpec::builder().build();
5349        pending.causation_id = Some(command_id);
5350        order.apply(OrderEventAny::PendingCancel(pending)).unwrap();
5351        let filled_qty = Quantity::from(if fully_filled { 10 } else { 4 });
5352        order
5353            .apply(OrderEventAny::Filled(
5354                OrderFilledSpec::builder()
5355                    .last_qty(filled_qty)
5356                    .last_px(Price::from("97.50"))
5357                    .build(),
5358            ))
5359            .unwrap();
5360        let closed = order.ts_closed();
5361        let previous = order.previous_status();
5362
5363        order
5364            .apply(OrderEventAny::CancelDenied(
5365                OrderCancelDeniedSpec::builder()
5366                    .causation_id(command_id)
5367                    .build(),
5368            ))
5369            .unwrap();
5370
5371        assert_eq!(
5372            order.status(),
5373            if fully_filled {
5374                OrderStatus::Filled
5375            } else {
5376                OrderStatus::PartiallyFilled
5377            }
5378        );
5379        assert_eq!(order.previous_status(), previous);
5380        assert_eq!(order.quantity(), Quantity::from(10));
5381        assert_eq!(order.price(), Some(Price::from("98.00")));
5382        assert_eq!(order.filled_qty(), filled_qty);
5383        assert_eq!(
5384            order.leaves_qty(),
5385            Quantity::from(if fully_filled { 0 } else { 6 })
5386        );
5387        assert_eq!(order.avg_px(), Some(dec!(97.50)));
5388        assert_eq!(order.ts_closed(), closed);
5389        assert!(!order.has_pending_cancel_command());
5390    }
5391
5392    #[rstest]
5393    #[case(false)]
5394    #[case(true)]
5395    fn test_denied_cancel_after_fill_void_resolves_only_current_lifecycle(
5396        #[case] filled_before_void: bool,
5397    ) {
5398        let mut order = OrderTestBuilder::new(OrderType::Limit)
5399            .instrument_id(InstrumentId::test_default())
5400            .quantity(Quantity::from(10))
5401            .price(Price::from("98.00"))
5402            .submit(true)
5403            .build();
5404        order
5405            .apply(OrderEventAny::Accepted(
5406                OrderAcceptedSpec::builder().build(),
5407            ))
5408            .unwrap();
5409        let first_command = UUID4::new();
5410        let mut pending = OrderPendingCancelSpec::builder().build();
5411        pending.causation_id = Some(first_command);
5412        order.apply(OrderEventAny::PendingCancel(pending)).unwrap();
5413        let fill_qty = Quantity::from(if filled_before_void { 10 } else { 4 });
5414        order
5415            .apply(OrderEventAny::Filled(
5416                OrderFilledSpec::builder()
5417                    .order_type(OrderType::Limit)
5418                    .last_qty(fill_qty)
5419                    .last_px(Price::from("97.50"))
5420                    .build(),
5421            ))
5422            .unwrap();
5423        order
5424            .apply(OrderEventAny::FillVoided(
5425                OrderFillVoidedSpec::builder()
5426                    .order_type(OrderType::Limit)
5427                    .voided_qty(fill_qty)
5428                    .last_px(Price::from("97.50"))
5429                    .is_reopened(true)
5430                    .build(),
5431            ))
5432            .unwrap();
5433
5434        let denied_command = if filled_before_void {
5435            let command_id = UUID4::new();
5436            let mut pending = OrderPendingCancelSpec::builder().build();
5437            pending.causation_id = Some(command_id);
5438            order.apply(OrderEventAny::PendingCancel(pending)).unwrap();
5439            command_id
5440        } else {
5441            first_command
5442        };
5443
5444        order
5445            .apply(OrderEventAny::CancelDenied(
5446                OrderCancelDeniedSpec::builder()
5447                    .causation_id(denied_command)
5448                    .build(),
5449            ))
5450            .unwrap();
5451
5452        assert_eq!(order.status(), OrderStatus::Accepted);
5453        assert_eq!(order.quantity(), Quantity::from(10));
5454        assert_eq!(order.price(), Some(Price::from("98.00")));
5455        assert_eq!(order.filled_qty(), Quantity::zero(0));
5456        assert_eq!(order.leaves_qty(), Quantity::from(10));
5457        assert_eq!(order.ts_closed(), None);
5458        assert!(!order.has_pending_cancel_command());
5459    }
5460
5461    #[rstest]
5462    #[case(false)]
5463    #[case(true)]
5464    fn test_denied_command_does_not_restore_superseded_pending_status(#[case] triggered: bool) {
5465        let mut order = OrderTestBuilder::new(OrderType::StopLimit)
5466            .instrument_id(InstrumentId::test_default())
5467            .quantity(Quantity::from(10))
5468            .price(Price::from("98.00"))
5469            .trigger_price(Price::from("97.00"))
5470            .submit(true)
5471            .build();
5472        order
5473            .apply(OrderEventAny::Accepted(
5474                OrderAcceptedSpec::builder().build(),
5475            ))
5476            .unwrap();
5477        let first = UUID4::new();
5478
5479        let first_pending = if triggered {
5480            OrderEventAny::PendingUpdate(OrderPendingUpdate {
5481                causation_id: Some(first),
5482                ..OrderPendingUpdateSpec::builder().build()
5483            })
5484        } else {
5485            OrderEventAny::PendingCancel(OrderPendingCancel {
5486                causation_id: Some(first),
5487                ..OrderPendingCancelSpec::builder().build()
5488            })
5489        };
5490
5491        order.apply(first_pending).unwrap();
5492        let expected = if triggered {
5493            order
5494                .apply(OrderEventAny::Triggered(
5495                    OrderTriggeredSpec::builder().build(),
5496                ))
5497                .unwrap();
5498            OrderStatus::Triggered
5499        } else {
5500            order
5501                .apply(OrderEventAny::Accepted(
5502                    OrderAcceptedSpec::builder().build(),
5503                ))
5504                .unwrap();
5505            OrderStatus::Accepted
5506        };
5507
5508        let second = UUID4::new();
5509        order
5510            .apply(OrderEventAny::PendingCancel(OrderPendingCancel {
5511                causation_id: Some(second),
5512                ..OrderPendingCancelSpec::builder().build()
5513            }))
5514            .unwrap();
5515
5516        order
5517            .apply(OrderEventAny::CancelDenied(
5518                OrderCancelDeniedSpec::builder()
5519                    .causation_id(second)
5520                    .build(),
5521            ))
5522            .unwrap();
5523        assert_eq!(order.status(), expected);
5524        assert!(!order.has_pending_cancel_command());
5525        assert_eq!(order.quantity(), Quantity::from(10));
5526        assert_eq!(order.filled_qty(), Quantity::zero(0));
5527    }
5528
5529    #[rstest]
5530    fn test_denied_cancel_after_triggered_fill_void_preserves_triggered_status() {
5531        let mut order = OrderTestBuilder::new(OrderType::StopLimit)
5532            .instrument_id(InstrumentId::test_default())
5533            .quantity(Quantity::from(10))
5534            .price(Price::from("98.00"))
5535            .trigger_price(Price::from("97.00"))
5536            .submit(true)
5537            .build();
5538        order
5539            .apply(OrderEventAny::Accepted(
5540                OrderAcceptedSpec::builder().build(),
5541            ))
5542            .unwrap();
5543        order
5544            .apply(OrderEventAny::Triggered(
5545                OrderTriggeredSpec::builder().build(),
5546            ))
5547            .unwrap();
5548        let command_id = UUID4::new();
5549        order
5550            .apply(OrderEventAny::PendingCancel(OrderPendingCancel {
5551                causation_id: Some(command_id),
5552                ..OrderPendingCancelSpec::builder().build()
5553            }))
5554            .unwrap();
5555
5556        let fill = OrderFilledSpec::builder()
5557            .order_type(OrderType::StopLimit)
5558            .last_qty(Quantity::from(4))
5559            .last_px(Price::from("97.50"))
5560            .build();
5561        order.apply(OrderEventAny::Filled(fill.clone())).unwrap();
5562        order
5563            .apply(OrderEventAny::FillVoided(
5564                OrderFillVoidedSpec::builder()
5565                    .trade_id(fill.trade_id)
5566                    .order_type(OrderType::StopLimit)
5567                    .last_px(fill.last_px)
5568                    .voided_qty(fill.last_qty)
5569                    .is_reopened(true)
5570                    .build(),
5571            ))
5572            .unwrap();
5573        order
5574            .apply(OrderEventAny::CancelDenied(
5575                OrderCancelDeniedSpec::builder()
5576                    .causation_id(command_id)
5577                    .build(),
5578            ))
5579            .unwrap();
5580        assert_eq!(order.status(), OrderStatus::Triggered);
5581        assert_eq!(order.filled_qty(), Quantity::zero(0));
5582        assert_eq!(order.leaves_qty(), Quantity::from(10));
5583        assert_eq!(order.ts_closed(), None);
5584        assert!(!order.has_pending_cancel_command());
5585    }
5586
5587    #[rstest]
5588    fn test_command_update_preserves_another_pending_cancel() {
5589        let mut order = OrderTestBuilder::new(OrderType::Limit)
5590            .instrument_id(InstrumentId::test_default())
5591            .quantity(Quantity::from(10))
5592            .price(Price::from("98.00"))
5593            .submit(true)
5594            .build();
5595        order
5596            .apply(OrderEventAny::Accepted(
5597                OrderAcceptedSpec::builder().build(),
5598            ))
5599            .unwrap();
5600        let modify = UUID4::new();
5601        let cancel = UUID4::new();
5602        order
5603            .apply(OrderEventAny::PendingUpdate(OrderPendingUpdate {
5604                causation_id: Some(modify),
5605                ..OrderPendingUpdateSpec::builder().build()
5606            }))
5607            .unwrap();
5608
5609        order
5610            .apply(OrderEventAny::PendingCancel(OrderPendingCancel {
5611                causation_id: Some(cancel),
5612                ..OrderPendingCancelSpec::builder().build()
5613            }))
5614            .unwrap();
5615
5616        let update = OrderUpdated {
5617            causation_id: Some(modify),
5618            ..OrderUpdatedSpec::builder()
5619                .quantity(Quantity::from(11))
5620                .price(Price::from("99.00"))
5621                .build()
5622        };
5623
5624        order.apply(OrderEventAny::Updated(update)).unwrap();
5625        assert_eq!(order.status(), OrderStatus::PendingCancel);
5626        assert!(order.has_pending_cancel_command());
5627        order
5628            .apply(OrderEventAny::CancelDenied(
5629                OrderCancelDeniedSpec::builder()
5630                    .causation_id(cancel)
5631                    .build(),
5632            ))
5633            .unwrap();
5634        assert_eq!(order.status(), OrderStatus::Accepted);
5635        assert_eq!(order.quantity(), Quantity::from(11));
5636        assert_eq!(order.price(), Some(Price::from("99.00")));
5637        assert!(!order.has_pending_cancel_command());
5638    }
5639
5640    #[rstest]
5641    #[case(None)]
5642    #[case(Some(UUID4::new()))]
5643    fn test_denied_command_without_matching_causation_keeps_pending(
5644        #[case] causation_id: Option<UUID4>,
5645    ) {
5646        let mut order = OrderTestBuilder::new(OrderType::Limit)
5647            .instrument_id(InstrumentId::test_default())
5648            .quantity(Quantity::from(10))
5649            .price(Price::from("98.00"))
5650            .submit(true)
5651            .build();
5652        order
5653            .apply(OrderEventAny::Accepted(
5654                OrderAcceptedSpec::builder().build(),
5655            ))
5656            .unwrap();
5657        let mut pending = OrderPendingCancelSpec::builder().build();
5658        pending.causation_id = Some(UUID4::new());
5659        order.apply(OrderEventAny::PendingCancel(pending)).unwrap();
5660        let previous = order.previous_status();
5661
5662        order
5663            .apply(OrderEventAny::CancelDenied(
5664                OrderCancelDeniedSpec::builder()
5665                    .maybe_causation_id(causation_id)
5666                    .build(),
5667            ))
5668            .unwrap();
5669
5670        assert_eq!(order.status(), OrderStatus::PendingCancel);
5671        assert_eq!(order.previous_status(), previous);
5672        assert_eq!(order.quantity(), Quantity::from(10));
5673        assert_eq!(order.price(), Some(Price::from("98.00")));
5674        assert_eq!(order.ts_closed(), None);
5675        assert!(order.has_pending_cancel_command());
5676    }
5677
5678    #[rstest]
5679    #[case::submitted(OrderStatus::Submitted)]
5680    #[case::accepted(OrderStatus::Accepted)]
5681    #[case::partially_filled(OrderStatus::PartiallyFilled)]
5682    fn test_modify_rejected_after_venue_update(#[case] expected_status: OrderStatus) {
5683        let mut order = OrderTestBuilder::new(OrderType::Limit)
5684            .instrument_id(InstrumentId::test_default())
5685            .quantity(Quantity::from(10))
5686            .price(Price::from("98.00"))
5687            .build();
5688        order
5689            .apply(OrderEventAny::Submitted(
5690                OrderSubmittedSpec::builder().build(),
5691            ))
5692            .unwrap();
5693
5694        if expected_status != OrderStatus::Submitted {
5695            order
5696                .apply(OrderEventAny::Accepted(
5697                    OrderAcceptedSpec::builder().build(),
5698                ))
5699                .unwrap();
5700        }
5701
5702        let filled_qty = if expected_status == OrderStatus::PartiallyFilled {
5703            order
5704                .apply(OrderEventAny::Filled(
5705                    OrderFilledSpec::builder()
5706                        .order_type(OrderType::Limit)
5707                        .last_qty(Quantity::from(3))
5708                        .build(),
5709                ))
5710                .unwrap();
5711            Quantity::from(3)
5712        } else {
5713            Quantity::from(0)
5714        };
5715
5716        order
5717            .apply(OrderEventAny::PendingUpdate(
5718                OrderPendingUpdateSpec::builder().build(),
5719            ))
5720            .unwrap();
5721        order
5722            .apply(OrderEventAny::Updated(
5723                OrderUpdatedSpec::builder()
5724                    .quantity(Quantity::from(20))
5725                    .price(Price::from("97.00"))
5726                    .build(),
5727            ))
5728            .unwrap();
5729        assert_eq!(order.status(), expected_status);
5730        let previous_status = order.previous_status();
5731        let events_before = order.events().len();
5732
5733        let rejection = OrderEventAny::ModifyRejected(OrderModifyRejectedSpec::builder().build());
5734        order.apply(rejection.clone()).unwrap();
5735
5736        assert_eq!(order.status(), expected_status);
5737        assert_eq!(order.previous_status(), previous_status);
5738        assert_eq!(order.quantity(), Quantity::from(20));
5739        assert_eq!(order.price(), Some(Price::from("97.00")));
5740        assert_eq!(order.filled_qty(), filled_qty);
5741        assert_eq!(order.leaves_qty(), Quantity::from(20) - filled_qty);
5742        assert_eq!(order.events().len(), events_before + 1);
5743        assert_eq!(order.last_event(), &rejection);
5744    }
5745
5746    #[rstest]
5747    fn test_modify_rejected_preserves_triggered_with_stale_previous_status() {
5748        let mut order = OrderTestBuilder::new(OrderType::StopLimit)
5749            .instrument_id(InstrumentId::test_default())
5750            .quantity(Quantity::from(10))
5751            .price(Price::from("98.00"))
5752            .trigger_price(Price::from("99.00"))
5753            .build();
5754        order
5755            .apply(OrderEventAny::Submitted(
5756                OrderSubmittedSpec::builder().build(),
5757            ))
5758            .unwrap();
5759        order
5760            .apply(OrderEventAny::Accepted(
5761                OrderAcceptedSpec::builder().build(),
5762            ))
5763            .unwrap();
5764        order
5765            .apply(OrderEventAny::PendingUpdate(
5766                OrderPendingUpdateSpec::builder().build(),
5767            ))
5768            .unwrap();
5769        order
5770            .apply(OrderEventAny::Updated(
5771                OrderUpdatedSpec::builder()
5772                    .quantity(Quantity::from(20))
5773                    .price(Price::from("97.00"))
5774                    .trigger_price(Price::from("98.00"))
5775                    .build(),
5776            ))
5777            .unwrap();
5778        order
5779            .apply(OrderEventAny::Triggered(
5780                OrderTriggeredSpec::builder().build(),
5781            ))
5782            .unwrap();
5783        assert_eq!(order.status(), OrderStatus::Triggered);
5784        assert_eq!(order.previous_status(), Some(OrderStatus::Accepted));
5785
5786        let rejection = OrderEventAny::ModifyRejected(OrderModifyRejectedSpec::builder().build());
5787        order.apply(rejection.clone()).unwrap();
5788
5789        assert_eq!(order.status(), OrderStatus::Triggered);
5790        assert_eq!(order.quantity(), Quantity::from(20));
5791        assert_eq!(order.price(), Some(Price::from("97.00")));
5792        assert_eq!(order.trigger_price(), Some(Price::from("98.00")));
5793        assert_eq!(order.last_event(), &rejection);
5794    }
5795
5796    #[rstest]
5797    #[case::submitted(OrderStatus::Submitted)]
5798    #[case::accepted(OrderStatus::Accepted)]
5799    #[case::pending_update(OrderStatus::PendingUpdate)]
5800    #[case::pending_cancel(OrderStatus::PendingCancel)]
5801    fn test_modify_rejected_without_previous_status(#[case] status: OrderStatus) {
5802        let mut order: MarketOrder = OrderInitializedSpec::builder()
5803            .quantity(Quantity::from(10))
5804            .build()
5805            .try_into()
5806            .unwrap();
5807
5808        if status == OrderStatus::Submitted {
5809            order
5810                .apply(OrderEventAny::Submitted(
5811                    OrderSubmittedSpec::builder().build(),
5812                ))
5813                .unwrap();
5814        } else {
5815            order
5816                .apply(OrderEventAny::Accepted(
5817                    OrderAcceptedSpec::builder().build(),
5818                ))
5819                .unwrap();
5820        }
5821
5822        match status {
5823            OrderStatus::PendingUpdate => order
5824                .apply(OrderEventAny::PendingUpdate(
5825                    OrderPendingUpdateSpec::builder().build(),
5826                ))
5827                .unwrap(),
5828            OrderStatus::PendingCancel => order
5829                .apply(OrderEventAny::PendingCancel(
5830                    OrderPendingCancelSpec::builder().build(),
5831                ))
5832                .unwrap(),
5833            _ => {}
5834        }
5835
5836        order.previous_status = None;
5837        let events_before = order.events().len();
5838        let rejection = OrderEventAny::ModifyRejected(OrderModifyRejectedSpec::builder().build());
5839        let result = order.apply(rejection.clone());
5840
5841        if status == OrderStatus::PendingUpdate {
5842            assert!(matches!(result, Err(OrderError::NoPreviousState)));
5843            assert_eq!(order.events().len(), events_before);
5844        } else {
5845            result.unwrap();
5846            assert_eq!(order.last_event(), &rejection);
5847        }
5848
5849        assert_eq!(order.status(), status);
5850        assert_eq!(order.quantity(), Quantity::from(10));
5851        assert_eq!(order.previous_status(), None);
5852    }
5853
5854    #[rstest]
5855    #[case::submitted(false, OrderStatus::Submitted)]
5856    #[case::accepted(true, OrderStatus::Accepted)]
5857    fn test_modify_rejected_preserves_pending_cancel(
5858        #[case] accepted_first: bool,
5859        #[case] restored_status: OrderStatus,
5860    ) {
5861        let init = OrderInitializedSpec::builder().build();
5862        let submitted = OrderSubmittedSpec::builder().build();
5863        let accepted = OrderAcceptedSpec::builder().build();
5864        let pending_update = OrderPendingUpdateSpec::builder().build();
5865        let pending_cancel = OrderPendingCancelSpec::builder().build();
5866        let modify_rejected = OrderModifyRejectedSpec::builder().build();
5867        let cancel_rejected = OrderCancelRejectedSpec::builder().build();
5868        let mut order: MarketOrder = init.try_into().unwrap();
5869
5870        order.apply(OrderEventAny::Submitted(submitted)).unwrap();
5871        if accepted_first {
5872            order.apply(OrderEventAny::Accepted(accepted)).unwrap();
5873        }
5874
5875        order
5876            .apply(OrderEventAny::PendingUpdate(pending_update))
5877            .unwrap();
5878        order
5879            .apply(OrderEventAny::PendingCancel(pending_cancel))
5880            .unwrap();
5881        order
5882            .apply(OrderEventAny::ModifyRejected(modify_rejected))
5883            .unwrap();
5884
5885        assert_eq!(order.status(), OrderStatus::PendingCancel);
5886        assert_eq!(order.previous_status(), Some(restored_status));
5887
5888        order
5889            .apply(OrderEventAny::CancelRejected(cancel_rejected))
5890            .unwrap();
5891
5892        assert_eq!(order.status(), restored_status);
5893    }
5894
5895    #[rstest]
5896    fn test_modify_rejected_transition_matrix() {
5897        let event = OrderEventAny::ModifyRejected(OrderModifyRejectedSpec::builder().build());
5898
5899        for status in OrderStatus::iter() {
5900            let expected = matches!(
5901                status,
5902                OrderStatus::Submitted
5903                    | OrderStatus::Accepted
5904                    | OrderStatus::Triggered
5905                    | OrderStatus::PartiallyFilled
5906                    | OrderStatus::PendingUpdate
5907                    | OrderStatus::PendingCancel
5908            );
5909            let mut current = status;
5910            let result = current.transition(&event);
5911
5912            if expected {
5913                assert_eq!(result.unwrap(), status, "status={status}");
5914            } else {
5915                assert!(
5916                    matches!(result, Err(OrderError::InvalidStateTransition)),
5917                    "status={status}"
5918                );
5919            }
5920
5921            assert_eq!(current, status);
5922        }
5923    }
5924
5925    #[rstest]
5926    fn test_cancel_rejected_transition_matrix() {
5927        let event = OrderEventAny::CancelRejected(OrderCancelRejectedSpec::builder().build());
5928
5929        for status in OrderStatus::iter() {
5930            let expected = match status {
5931                OrderStatus::Submitted
5932                | OrderStatus::Accepted
5933                | OrderStatus::Triggered
5934                | OrderStatus::PartiallyFilled
5935                | OrderStatus::PendingUpdate
5936                | OrderStatus::PendingCancel => Some(status),
5937                OrderStatus::Initialized
5938                | OrderStatus::Emulated
5939                | OrderStatus::Released
5940                | OrderStatus::Denied
5941                | OrderStatus::Rejected
5942                | OrderStatus::Canceled
5943                | OrderStatus::Expired
5944                | OrderStatus::Filled
5945                | OrderStatus::Voided => None,
5946            };
5947
5948            let mut current = status;
5949            let result = current.transition(&event);
5950
5951            if let Some(expected) = expected {
5952                assert_eq!(result.unwrap(), expected, "status={status}");
5953            } else {
5954                assert!(
5955                    matches!(result, Err(OrderError::InvalidStateTransition)),
5956                    "status={status}"
5957                );
5958            }
5959
5960            assert_eq!(current, status);
5961        }
5962    }
5963
5964    #[rstest]
5965    #[case::submitted(&[], OrderStatus::Submitted, false)]
5966    #[case::accepted(&[OrderStatus::Accepted], OrderStatus::Accepted, false)]
5967    #[case::pending_submitted(&[OrderStatus::PendingCancel], OrderStatus::Submitted, false)]
5968    #[case::pending_accepted(&[OrderStatus::Accepted, OrderStatus::PendingCancel], OrderStatus::Accepted, false)]
5969    #[case::acceptance_overtakes_submitted_cancel(&[OrderStatus::PendingCancel, OrderStatus::Accepted], OrderStatus::Accepted, false)]
5970    #[case::acceptance_overtakes_accepted_cancel(&[OrderStatus::Accepted, OrderStatus::PendingCancel, OrderStatus::Accepted], OrderStatus::Accepted, false)]
5971    #[case::triggered(&[OrderStatus::Accepted, OrderStatus::Triggered], OrderStatus::Triggered, false)]
5972    #[case::partially_filled(&[OrderStatus::Accepted, OrderStatus::PartiallyFilled], OrderStatus::PartiallyFilled, false)]
5973    #[case::pending_triggered(&[OrderStatus::Accepted, OrderStatus::Triggered, OrderStatus::PendingCancel], OrderStatus::Triggered, false)]
5974    #[case::pending_partially_filled(&[OrderStatus::Accepted, OrderStatus::PartiallyFilled, OrderStatus::PendingCancel], OrderStatus::PartiallyFilled, false)]
5975    #[case::fill_overtakes_cancel(&[OrderStatus::Accepted, OrderStatus::PendingCancel, OrderStatus::PartiallyFilled], OrderStatus::PartiallyFilled, false)]
5976    #[case::pending_update_accepted_updated(&[OrderStatus::Accepted, OrderStatus::PendingUpdate], OrderStatus::PendingUpdate, false)]
5977    #[case::pending_update_accepted_rejected(&[OrderStatus::Accepted, OrderStatus::PendingUpdate], OrderStatus::PendingUpdate, true)]
5978    #[case::pending_update_triggered_updated(&[OrderStatus::Accepted, OrderStatus::Triggered, OrderStatus::PendingUpdate], OrderStatus::PendingUpdate, false)]
5979    #[case::pending_update_triggered_rejected(&[OrderStatus::Accepted, OrderStatus::Triggered, OrderStatus::PendingUpdate], OrderStatus::PendingUpdate, true)]
5980    #[case::pending_update_partially_filled_updated(&[OrderStatus::Accepted, OrderStatus::PartiallyFilled, OrderStatus::PendingUpdate], OrderStatus::PendingUpdate, false)]
5981    #[case::pending_update_partially_filled_rejected(&[OrderStatus::Accepted, OrderStatus::PartiallyFilled, OrderStatus::PendingUpdate], OrderStatus::PendingUpdate, true)]
5982    fn test_cancel_rejected_preserves_order_state(
5983        #[case] statuses: &[OrderStatus],
5984        #[case] expected_status: OrderStatus,
5985        #[case] modify_rejected: bool,
5986    ) {
5987        let order_type = if statuses.contains(&OrderStatus::Triggered) {
5988            OrderType::StopLimit
5989        } else {
5990            OrderType::Market
5991        };
5992
5993        let mut order = OrderTestBuilder::new(order_type)
5994            .instrument_id(InstrumentId::test_default())
5995            .quantity(Quantity::from(100_000))
5996            .price(Price::from("1.00000"))
5997            .trigger_price(Price::from("1.00000"))
5998            .trigger_type(TriggerType::LastPrice)
5999            .build();
6000        order
6001            .apply(OrderEventAny::Submitted(
6002                OrderSubmittedSpec::builder().build(),
6003            ))
6004            .unwrap();
6005
6006        for status in statuses {
6007            let source_status = order.status();
6008
6009            let event = match status {
6010                OrderStatus::Accepted => {
6011                    OrderEventAny::Accepted(OrderAcceptedSpec::builder().build())
6012                }
6013                OrderStatus::Triggered => {
6014                    OrderEventAny::Triggered(OrderTriggeredSpec::builder().build())
6015                }
6016                OrderStatus::PartiallyFilled => OrderEventAny::Filled(
6017                    OrderFilledSpec::builder()
6018                        .order_type(order_type)
6019                        .last_qty(Quantity::from(40_000))
6020                        .build(),
6021                ),
6022                OrderStatus::PendingUpdate => {
6023                    OrderEventAny::PendingUpdate(OrderPendingUpdateSpec::builder().build())
6024                }
6025                OrderStatus::PendingCancel => {
6026                    OrderEventAny::PendingCancel(OrderPendingCancelSpec::builder().build())
6027                }
6028                _ => panic!("Unsupported setup status: {status}"),
6029            };
6030
6031            order.apply(event).unwrap();
6032
6033            let expected = if *status == OrderStatus::PartiallyFilled
6034                && source_status == OrderStatus::PendingCancel
6035            {
6036                OrderStatus::PendingCancel
6037            } else {
6038                *status
6039            };
6040
6041            assert_eq!(order.status(), expected);
6042        }
6043
6044        let previous_status = order.previous_status();
6045        let quantity = order.quantity();
6046        let filled_qty = order.filled_qty();
6047        let leaves_qty = order.leaves_qty();
6048        let venue_order_id = order.venue_order_id();
6049        let event_count = order.events().len();
6050        let cancel_rejected =
6051            OrderEventAny::CancelRejected(OrderCancelRejectedSpec::builder().build());
6052
6053        order.apply(cancel_rejected.clone()).unwrap();
6054
6055        assert_eq!(order.status(), expected_status);
6056        assert_eq!(order.previous_status(), previous_status);
6057        assert_eq!(order.quantity(), quantity);
6058        assert_eq!(order.filled_qty(), filled_qty);
6059        assert_eq!(order.leaves_qty(), leaves_qty);
6060        assert_eq!(order.venue_order_id(), venue_order_id);
6061        assert_eq!(order.events().len(), event_count + 1);
6062        assert_eq!(order.last_event(), &cancel_rejected);
6063
6064        if expected_status == OrderStatus::Submitted {
6065            order
6066                .apply(OrderEventAny::Accepted(
6067                    OrderAcceptedSpec::builder().build(),
6068                ))
6069                .unwrap();
6070            assert_eq!(order.status(), OrderStatus::Accepted);
6071        }
6072
6073        if expected_status == OrderStatus::PendingUpdate {
6074            let restored_status = previous_status.unwrap();
6075
6076            let resolution = if modify_rejected {
6077                OrderEventAny::ModifyRejected(OrderModifyRejectedSpec::builder().build())
6078            } else {
6079                OrderEventAny::Updated(
6080                    OrderUpdatedSpec::builder()
6081                        .quantity(Quantity::from(80_000))
6082                        .build(),
6083                )
6084            };
6085
6086            order.apply(resolution).unwrap();
6087
6088            assert_eq!(order.status(), restored_status);
6089            assert_eq!(order.previous_status(), previous_status);
6090            assert_eq!(
6091                order.quantity(),
6092                if modify_rejected {
6093                    quantity
6094                } else {
6095                    Quantity::from(80_000)
6096                }
6097            );
6098            assert_eq!(order.filled_qty(), filled_qty);
6099            assert_eq!(order.leaves_qty(), order.quantity() - filled_qty);
6100            assert_eq!(order.venue_order_id(), venue_order_id);
6101        }
6102
6103        order
6104            .apply(OrderEventAny::PendingCancel(
6105                OrderPendingCancelSpec::builder().build(),
6106            ))
6107            .unwrap();
6108        order
6109            .apply(OrderEventAny::Canceled(
6110                OrderCanceledSpec::builder().build(),
6111            ))
6112            .unwrap();
6113
6114        assert_eq!(order.status(), OrderStatus::Canceled);
6115    }
6116
6117    #[rstest]
6118    fn test_rejected_event_preserves_cancel_rejected_restoration() {
6119        let init = OrderInitializedSpec::builder().build();
6120        let submitted = OrderSubmittedSpec::builder().build();
6121        let accepted = OrderAcceptedSpec::builder().build();
6122        let invalid = OrderSubmittedSpec::builder().build();
6123        let pending_cancel = OrderPendingCancelSpec::builder().build();
6124        let cancel_rejected = OrderCancelRejectedSpec::builder().build();
6125        let mut order: MarketOrder = init.try_into().unwrap();
6126        order.apply(OrderEventAny::Submitted(submitted)).unwrap();
6127        order.apply(OrderEventAny::Accepted(accepted)).unwrap();
6128        let previous_status = order.previous_status();
6129
6130        let result = order.apply(OrderEventAny::Submitted(invalid));
6131
6132        assert!(matches!(result, Err(OrderError::InvalidStateTransition)));
6133        assert_eq!(order.previous_status(), previous_status);
6134
6135        order
6136            .apply(OrderEventAny::PendingCancel(pending_cancel))
6137            .unwrap();
6138        order
6139            .apply(OrderEventAny::CancelRejected(cancel_rejected))
6140            .unwrap();
6141        assert_eq!(order.status(), OrderStatus::Accepted);
6142    }
6143
6144    #[rstest]
6145    #[case(true, false, "client_order_id")]
6146    #[case(false, true, "strategy_id")]
6147    fn test_update_identity_mismatch_precedes_field_validation(
6148        #[case] wrong_client: bool,
6149        #[case] wrong_strategy: bool,
6150        #[case] expected_field: &str,
6151    ) {
6152        let init = OrderInitializedSpec::builder().build();
6153        let submitted = OrderSubmittedSpec::builder().build();
6154        let accepted = OrderAcceptedSpec::builder().build();
6155        let mut order: MarketOrder = init.try_into().unwrap();
6156        order.apply(OrderEventAny::Submitted(submitted)).unwrap();
6157        order.apply(OrderEventAny::Accepted(accepted)).unwrap();
6158        let state = (
6159            order.status(),
6160            order.previous_status(),
6161            order.ts_last(),
6162            order.events().len(),
6163        );
6164        let client_order_id = if wrong_client {
6165            ClientOrderId::from("O-INVALID")
6166        } else {
6167            order.client_order_id()
6168        };
6169        let strategy_id = if wrong_strategy {
6170            StrategyId::from("OTHER-001")
6171        } else {
6172            order.strategy_id()
6173        };
6174        // Carry both a mismatched identity and a price a MarketOrder cannot hold:
6175        // the identity mismatch must be reported ahead of the field violation.
6176        let updated = OrderUpdatedSpec::builder()
6177            .client_order_id(client_order_id)
6178            .strategy_id(strategy_id)
6179            .price(Price::new(95.0, 2))
6180            .build();
6181
6182        let result = order.apply(OrderEventAny::Updated(updated));
6183
6184        // The specific identity predicate must surface, not the field violation.
6185        let Err(OrderError::Invariant(CorrectnessError::PredicateViolation { message })) = result
6186        else {
6187            panic!("expected an identity predicate violation, was {result:?}");
6188        };
6189        assert!(
6190            message.contains(expected_field),
6191            "message did not name {expected_field}: {message}"
6192        );
6193        assert_eq!(order.status(), state.0);
6194        assert_eq!(order.previous_status(), state.1);
6195        assert_eq!(order.ts_last(), state.2);
6196        assert_eq!(order.events().len(), state.3);
6197    }
6198
6199    #[rstest]
6200    fn test_update_invalid_transition_precedes_field_validation() {
6201        let init = OrderInitializedSpec::builder().build();
6202        let denied = OrderDeniedSpec::builder().build();
6203        let mut order: MarketOrder = init.try_into().unwrap();
6204        order.apply(OrderEventAny::Denied(denied)).unwrap();
6205        let state = (
6206            order.status(),
6207            order.previous_status(),
6208            order.ts_last(),
6209            order.events().len(),
6210        );
6211        // No (Denied, Updated) transition exists, and the price is invalid for a
6212        // MarketOrder: the transition check must win over the field violation.
6213        let updated = OrderUpdatedSpec::builder()
6214            .price(Price::new(95.0, 2))
6215            .build();
6216
6217        let result = order.apply(OrderEventAny::Updated(updated));
6218
6219        assert!(matches!(result, Err(OrderError::InvalidStateTransition)));
6220        assert_eq!(order.status(), state.0);
6221        assert_eq!(order.previous_status(), state.1);
6222        assert_eq!(order.ts_last(), state.2);
6223        assert_eq!(order.events().len(), state.3);
6224    }
6225
6226    #[rstest]
6227    fn test_direct_update_panics_on_invalid_field_before_mutation() {
6228        let init = OrderInitializedSpec::builder()
6229            .quantity(Quantity::from(100_000))
6230            .build();
6231        let mut order: MarketOrder = init.try_into().unwrap();
6232        let original_quantity = order.quantity();
6233        // A distinct quantity so any mutation would be observable, alongside a
6234        // price the type cannot hold. The low-level mutation path retains a
6235        // defensive guard: a direct update() panics on the invalid field before
6236        // it reaches the quantity assignment.
6237        let updated = OrderUpdatedSpec::builder()
6238            .quantity(Quantity::from(50_000))
6239            .price(Price::new(95.0, 2))
6240            .build();
6241
6242        let result =
6243            std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| order.update(&updated)));
6244
6245        assert!(result.is_err());
6246        assert_eq!(order.quantity(), original_quantity);
6247    }
6248
6249    #[rstest]
6250    fn test_partially_filled_order_can_be_updated() {
6251        // Test that a partially filled order can receive an Updated event
6252        // and remain in PartiallyFilled status
6253        let init = OrderInitializedSpec::builder()
6254            .quantity(Quantity::from(100_000))
6255            .build();
6256        let submitted = OrderSubmittedSpec::builder().build();
6257        let accepted = OrderAcceptedSpec::builder().build();
6258        let partial_fill = OrderFilledSpec::builder()
6259            .last_qty(Quantity::from(40_000))
6260            .build();
6261        let updated = OrderUpdatedSpec::builder()
6262            .quantity(Quantity::from(80_000)) // Reduce to 80k (still > 40k filled)
6263            .build();
6264
6265        let mut order: MarketOrder = init.try_into().unwrap();
6266        order.apply(OrderEventAny::Submitted(submitted)).unwrap();
6267        order.apply(OrderEventAny::Accepted(accepted)).unwrap();
6268        order.apply(OrderEventAny::Filled(partial_fill)).unwrap();
6269
6270        assert_eq!(order.status(), OrderStatus::PartiallyFilled);
6271        assert_eq!(order.filled_qty(), Quantity::from(40_000));
6272
6273        order.apply(OrderEventAny::Updated(updated)).unwrap();
6274
6275        assert_eq!(order.status(), OrderStatus::PartiallyFilled);
6276        assert_eq!(order.quantity(), Quantity::from(80_000));
6277        assert_eq!(order.leaves_qty(), Quantity::from(40_000)); // 80k - 40k filled
6278    }
6279
6280    #[rstest]
6281    #[case::ordinary(false, false, OrderType::Market)]
6282    #[case::submitted(true, true, OrderType::Market)]
6283    #[case::limit(true, false, OrderType::Limit)]
6284    fn test_fill_report_tag_does_not_extend_ordinary_accepted_order(
6285        #[case] reconciliation: bool,
6286        #[case] submitted: bool,
6287        #[case] order_type: OrderType,
6288    ) {
6289        let init = OrderInitializedSpec::builder()
6290            .quantity(Quantity::from(1))
6291            .order_type(order_type)
6292            .maybe_price((order_type == OrderType::Limit).then(|| Price::from("1.10")))
6293            .reconciliation(reconciliation)
6294            .tags(vec![Ustr::from(FILL_REPORT_ORDER_TAG)])
6295            .build();
6296        let mut order = OrderAny::try_from(init).unwrap();
6297        if submitted {
6298            order
6299                .apply(OrderEventAny::Submitted(
6300                    OrderSubmittedSpec::builder().build(),
6301                ))
6302                .unwrap();
6303        }
6304
6305        order
6306            .apply(OrderEventAny::Accepted(
6307                OrderAcceptedSpec::builder().build(),
6308            ))
6309            .unwrap();
6310        let first = OrderFilledSpec::builder()
6311            .trade_id(TradeId::from("T-OWNED-1"))
6312            .order_type(order_type)
6313            .last_qty(Quantity::from(1))
6314            .build();
6315        let second = OrderFilledSpec::builder()
6316            .trade_id(TradeId::from("T-OWNED-2"))
6317            .order_type(order_type)
6318            .last_qty(Quantity::from(1))
6319            .build();
6320        order.apply(OrderEventAny::Filled(first)).unwrap();
6321        let before = serde_json::to_value(&order).unwrap();
6322
6323        let result = order.apply(OrderEventAny::Filled(second));
6324
6325        assert!(matches!(result, Err(OrderError::InvalidStateTransition)));
6326        assert!(!order.is_fill_report_order());
6327        assert_eq!(serde_json::to_value(&order).unwrap(), before);
6328    }
6329
6330    #[rstest]
6331    #[case::instrument("instrument")]
6332    #[case::side("side")]
6333    #[case::account("account")]
6334    #[case::venue_order("venue")]
6335    fn test_fill_report_order_rejects_mismatched_fill_identity(#[case] field: &str) {
6336        let init = OrderInitializedSpec::builder()
6337            .quantity(Quantity::from(1))
6338            .reconciliation(true)
6339            .tags(vec![Ustr::from(FILL_REPORT_ORDER_TAG)])
6340            .build();
6341        let mut order = OrderAny::try_from(init).unwrap();
6342        order
6343            .apply(OrderEventAny::Accepted(
6344                OrderAcceptedSpec::builder().build(),
6345            ))
6346            .unwrap();
6347        let first = OrderFilledSpec::builder()
6348            .trade_id(TradeId::from("T-IDENTITY-1"))
6349            .last_qty(Quantity::from(1))
6350            .build();
6351        order.apply(OrderEventAny::Filled(first.clone())).unwrap();
6352        let before = serde_json::to_value(&order).unwrap();
6353        let mut invalid = first;
6354        invalid.event_id = UUID4::new();
6355        invalid.trade_id = TradeId::from("T-IDENTITY-2");
6356        match field {
6357            "instrument" => invalid.instrument_id = InstrumentId::from("GBP/USD.SIM"),
6358            "side" => invalid.order_side = OrderSide::Sell,
6359            "account" => invalid.account_id = AccountId::from("OTHER-001"),
6360            "venue" => invalid.venue_order_id = VenueOrderId::from("V-OTHER"),
6361            _ => unreachable!(),
6362        }
6363
6364        let result = order.apply(OrderEventAny::Filled(invalid));
6365
6366        assert!(matches!(result, Err(OrderError::InvalidOrderEvent)));
6367        assert_eq!(serde_json::to_value(&order).unwrap(), before);
6368    }
6369
6370    #[rstest]
6371    fn test_fill_report_order_expands_and_replays() {
6372        let init = OrderInitializedSpec::builder()
6373            .quantity(Quantity::from(1))
6374            .reconciliation(true)
6375            .tags(vec![Ustr::from(FILL_REPORT_ORDER_TAG)])
6376            .build();
6377        let mut order = OrderAny::try_from(init).unwrap();
6378        order
6379            .apply(OrderEventAny::Accepted(
6380                OrderAcceptedSpec::builder().build(),
6381            ))
6382            .unwrap();
6383
6384        for (trade_id, qty, price) in [("T-1", 1, "1.10"), ("T-2", 2, "1.20"), ("T-3", 3, "1.30")] {
6385            let fill = OrderFilledSpec::builder()
6386                .trade_id(TradeId::from(trade_id))
6387                .last_qty(Quantity::from(qty))
6388                .last_px(Price::from(price))
6389                .commission(Money::from("0.10 USD"))
6390                .build();
6391            order.apply(OrderEventAny::Filled(fill)).unwrap();
6392        }
6393
6394        let replayed =
6395            OrderAny::from_events(order.events().into_iter().cloned().collect()).unwrap();
6396
6397        assert!(order.is_fill_report_order());
6398        assert_eq!(order.quantity(), Quantity::from(6));
6399        assert_eq!(order.filled_qty(), Quantity::from(6));
6400        assert_eq!(order.leaves_qty(), Quantity::from(0));
6401        assert_eq!(order.overfill_qty(), Quantity::from(0));
6402        assert_eq!(order.status(), OrderStatus::Filled);
6403        assert_eq!(
6404            order.trade_ids(),
6405            vec![
6406                &TradeId::from("T-1"),
6407                &TradeId::from("T-2"),
6408                &TradeId::from("T-3")
6409            ]
6410        );
6411        assert_eq!(
6412            order.commissions().get(&Currency::USD()),
6413            Some(&Money::from("0.30 USD"))
6414        );
6415        assert_eq!(
6416            serde_json::to_value(&replayed).unwrap(),
6417            serde_json::to_value(&order).unwrap()
6418        );
6419    }
6420
6421    #[rstest]
6422    fn test_fill_report_order_partial_fill_clears_closed_timestamp() {
6423        let init = OrderInitializedSpec::builder()
6424            .quantity(Quantity::from(1))
6425            .reconciliation(true)
6426            .tags(vec![Ustr::from(FILL_REPORT_ORDER_TAG)])
6427            .build();
6428        let mut order = OrderAny::try_from(init).unwrap();
6429        order
6430            .apply(OrderEventAny::Accepted(
6431                OrderAcceptedSpec::builder().build(),
6432            ))
6433            .unwrap();
6434        order
6435            .apply(OrderEventAny::Filled(
6436                OrderFilledSpec::builder()
6437                    .trade_id(TradeId::from("T-1"))
6438                    .last_qty(Quantity::from(1))
6439                    .ts_event(UnixNanos::from(10))
6440                    .build(),
6441            ))
6442            .unwrap();
6443        assert_eq!(order.status(), OrderStatus::Filled);
6444        assert_eq!(order.ts_closed(), Some(UnixNanos::from(10)));
6445        order
6446            .apply(OrderEventAny::Updated(
6447                OrderUpdatedSpec::builder()
6448                    .quantity(Quantity::from(4))
6449                    .reconciliation(true)
6450                    .build(),
6451            ))
6452            .unwrap();
6453
6454        order
6455            .apply(OrderEventAny::Filled(
6456                OrderFilledSpec::builder()
6457                    .trade_id(TradeId::from("T-2"))
6458                    .last_qty(Quantity::from(1))
6459                    .ts_event(UnixNanos::from(20))
6460                    .build(),
6461            ))
6462            .unwrap();
6463        let replayed =
6464            OrderAny::from_events(order.events().into_iter().cloned().collect()).unwrap();
6465
6466        assert_eq!(order.quantity(), Quantity::from(4));
6467        assert_eq!(order.filled_qty(), Quantity::from(2));
6468        assert_eq!(order.leaves_qty(), Quantity::from(2));
6469        assert_eq!(order.status(), OrderStatus::PartiallyFilled);
6470        assert_eq!(order.ts_closed(), None);
6471        assert_eq!(
6472            serde_json::to_value(&replayed).unwrap(),
6473            serde_json::to_value(&order).unwrap()
6474        );
6475    }
6476
6477    #[rstest]
6478    fn test_reconciliation_update_closes_order_at_filled_quantity() {
6479        let mut order: MarketOrder = OrderInitializedSpec::builder()
6480            .quantity(Quantity::from(100))
6481            .build()
6482            .try_into()
6483            .unwrap();
6484        order
6485            .apply(OrderEventAny::Accepted(
6486                OrderAcceptedSpec::builder().build(),
6487            ))
6488            .unwrap();
6489        order
6490            .apply(OrderEventAny::Filled(
6491                OrderFilledSpec::builder()
6492                    .last_qty(Quantity::from(40))
6493                    .build(),
6494            ))
6495            .unwrap();
6496        let updated = OrderEventAny::Updated(
6497            OrderUpdatedSpec::builder()
6498                .quantity(Quantity::from(40))
6499                .reconciliation(true)
6500                .ts_event(UnixNanos::from(5_000))
6501                .build(),
6502        );
6503
6504        order.apply(updated.clone()).unwrap();
6505        let replayed =
6506            OrderAny::from_events(order.events().into_iter().cloned().collect()).unwrap();
6507
6508        assert_eq!(order.status(), OrderStatus::Filled);
6509        assert_eq!(order.previous_status(), Some(OrderStatus::PartiallyFilled));
6510        assert_eq!(order.quantity(), Quantity::from(40));
6511        assert_eq!(order.filled_qty(), Quantity::from(40));
6512        assert_eq!(order.leaves_qty(), Quantity::from(0));
6513        assert_eq!(order.ts_closed(), Some(UnixNanos::from(5_000)));
6514        assert_eq!(order.ts_last(), UnixNanos::from(5_000));
6515        assert_eq!(order.event_count(), 4);
6516        assert_eq!(order.last_event(), &updated);
6517        assert_eq!(replayed.status(), order.status());
6518        assert_eq!(replayed.previous_status(), order.previous_status());
6519        assert_eq!(replayed.quantity(), order.quantity());
6520        assert_eq!(replayed.filled_qty(), order.filled_qty());
6521        assert_eq!(replayed.leaves_qty(), order.leaves_qty());
6522        assert_eq!(replayed.ts_closed(), order.ts_closed());
6523        assert_eq!(replayed.ts_last(), order.ts_last());
6524    }
6525
6526    #[rstest]
6527    fn test_triggered_order_can_be_updated() {
6528        // Test that a triggered order can receive an Updated event
6529        // and remain in Triggered status
6530        let instrument_id = InstrumentId::from("ETHUSDT-LINEAR.BYBIT");
6531        let submitted = OrderSubmittedSpec::builder().build();
6532        let accepted = OrderAcceptedSpec::builder().build();
6533        let triggered = OrderTriggeredSpec::builder().build();
6534        let updated = OrderUpdatedSpec::builder()
6535            .quantity(Quantity::from(80_000))
6536            .build();
6537
6538        let mut order = OrderTestBuilder::new(OrderType::StopLimit)
6539            .instrument_id(instrument_id)
6540            .quantity(Quantity::from(100_000))
6541            .price(Price::from("0.99500"))
6542            .trigger_price(Price::from("1.00000"))
6543            .trigger_type(TriggerType::LastPrice)
6544            .build();
6545        order.apply(OrderEventAny::Submitted(submitted)).unwrap();
6546        order.apply(OrderEventAny::Accepted(accepted)).unwrap();
6547        order.apply(OrderEventAny::Triggered(triggered)).unwrap();
6548
6549        assert_eq!(order.status(), OrderStatus::Triggered);
6550
6551        order.apply(OrderEventAny::Updated(updated)).unwrap();
6552
6553        assert_eq!(order.status(), OrderStatus::Triggered);
6554        assert_eq!(order.quantity(), Quantity::from(80_000));
6555    }
6556
6557    #[rstest]
6558    fn test_order_updated_with_is_quote_quantity_clears_flag() {
6559        let init = OrderInitializedSpec::builder()
6560            .quantity(Quantity::new(10.0, 6))
6561            .quote_quantity(true)
6562            .build();
6563        let submitted = OrderSubmittedSpec::builder().build();
6564        let accepted = OrderAcceptedSpec::builder().build();
6565        let updated = OrderUpdatedSpec::builder()
6566            .quantity(Quantity::new(47.393_365, 6))
6567            .is_quote_quantity(false)
6568            .build();
6569
6570        let mut order: MarketOrder = init.try_into().unwrap();
6571        assert!(order.is_quote_quantity());
6572
6573        order.apply(OrderEventAny::Submitted(submitted)).unwrap();
6574        order.apply(OrderEventAny::Accepted(accepted)).unwrap();
6575        order.apply(OrderEventAny::Updated(updated)).unwrap();
6576
6577        assert!(!order.is_quote_quantity());
6578        assert_eq!(order.quantity(), Quantity::new(47.393_365, 6));
6579        assert_eq!(order.leaves_qty(), Quantity::new(47.393_365, 6));
6580    }
6581
6582    #[rstest]
6583    fn test_order_updated_default_is_quote_quantity_clears_flag() {
6584        let init = OrderInitializedSpec::builder()
6585            .quantity(Quantity::new(10.0, 6))
6586            .quote_quantity(true)
6587            .build();
6588        let submitted = OrderSubmittedSpec::builder().build();
6589        let accepted = OrderAcceptedSpec::builder().build();
6590        // Builder defaults is_quote_quantity to false
6591        let updated = OrderUpdatedSpec::builder()
6592            .quantity(Quantity::new(8.0, 6))
6593            .build();
6594
6595        let mut order: MarketOrder = init.try_into().unwrap();
6596        assert!(order.is_quote_quantity());
6597
6598        order.apply(OrderEventAny::Submitted(submitted)).unwrap();
6599        order.apply(OrderEventAny::Accepted(accepted)).unwrap();
6600        order.apply(OrderEventAny::Updated(updated)).unwrap();
6601
6602        assert!(!order.is_quote_quantity());
6603        assert_eq!(order.quantity(), Quantity::new(8.0, 6));
6604    }
6605
6606    #[rstest]
6607    #[case::partial(40_000, OrderStatus::Expired, 10)]
6608    #[case::complete(100_000, OrderStatus::Filled, 20)]
6609    fn test_expired_order_receiving_fill(
6610        #[case] fill_qty: u64,
6611        #[case] expected_status: OrderStatus,
6612        #[case] closed_at: u64,
6613    ) {
6614        let mut order: LimitOrder = OrderInitializedSpec::builder()
6615            .order_type(OrderType::Limit)
6616            .quantity(Quantity::from(100_000))
6617            .price(Price::from("1.00000"))
6618            .time_in_force(TimeInForce::Gtd)
6619            .expire_time(UnixNanos::from(10))
6620            .build()
6621            .try_into()
6622            .unwrap();
6623        order
6624            .apply(OrderEventAny::Accepted(
6625                OrderAcceptedSpec::builder().build(),
6626            ))
6627            .unwrap();
6628        let expired = OrderEventAny::Expired(
6629            OrderExpiredSpec::builder()
6630                .ts_event(UnixNanos::from(10))
6631                .build(),
6632        );
6633        order.apply(expired).unwrap();
6634        let fill = OrderEventAny::Filled(
6635            OrderFilledSpec::builder()
6636                .order_type(OrderType::Limit)
6637                .last_qty(Quantity::from(fill_qty))
6638                .last_px(Price::from("1.25000"))
6639                .commission(Money::from("2 USD"))
6640                .ts_event(UnixNanos::from(20))
6641                .build(),
6642        );
6643        let mut persisted_events: Vec<_> = order.events().into_iter().cloned().collect();
6644        order.apply(fill.clone()).unwrap();
6645        persisted_events.push(order.last_event().clone());
6646        let repeated_expiry = OrderEventAny::Expired(
6647            OrderExpiredSpec::builder()
6648                .ts_event(UnixNanos::from(30))
6649                .build(),
6650        );
6651        order.apply(repeated_expiry.clone()).unwrap();
6652        persisted_events.push(order.last_event().clone());
6653        let replayed = OrderAny::from_events(persisted_events).unwrap();
6654
6655        assert_eq!(order.status(), expected_status);
6656        assert_eq!(order.filled_qty(), Quantity::from(fill_qty));
6657        assert_eq!(order.leaves_qty(), Quantity::from(100_000 - fill_qty));
6658        assert_eq!(order.avg_px(), Some(dec!(1.25)));
6659        assert_eq!(
6660            order.commissions().get(&Currency::USD()),
6661            Some(&Money::from("2 USD"))
6662        );
6663        assert_eq!(order.ts_closed(), Some(UnixNanos::from(closed_at)));
6664        assert_eq!(order.ts_last(), UnixNanos::from(20));
6665        assert_eq!(order.events().len(), 5);
6666        assert_eq!(order.last_event(), &repeated_expiry);
6667        assert_eq!(replayed.status(), expected_status);
6668        assert_eq!(replayed.filled_qty(), Quantity::from(fill_qty));
6669        assert_eq!(replayed.leaves_qty(), Quantity::from(100_000 - fill_qty));
6670        assert_eq!(replayed.avg_px(), Some(dec!(1.25)));
6671        assert_eq!(replayed.commissions(), order.commissions());
6672        assert_eq!(replayed.ts_closed(), Some(UnixNanos::from(closed_at)));
6673        assert_eq!(replayed.ts_last(), UnixNanos::from(20));
6674        assert_eq!(replayed.events(), order.events());
6675        assert!(matches!(
6676            order.apply(repeated_expiry),
6677            Err(OrderError::InvalidStateTransition)
6678        ));
6679        assert_eq!(order.events(), replayed.events());
6680        assert!(order.is_closed());
6681        assert!(!order.is_open());
6682        assert!(matches!(
6683            order.apply(fill),
6684            Err(OrderError::DuplicateFill(_))
6685        ));
6686        assert_eq!(order.filled_qty(), Quantity::from(fill_qty));
6687    }
6688
6689    #[rstest]
6690    fn test_expired_order_rejects_expiry_without_new_fill() {
6691        let mut order: MarketOrder = OrderInitializedSpec::builder().build().try_into().unwrap();
6692        order
6693            .apply(OrderEventAny::Accepted(
6694                OrderAcceptedSpec::builder().build(),
6695            ))
6696            .unwrap();
6697        order
6698            .apply(OrderEventAny::Expired(
6699                OrderExpiredSpec::builder()
6700                    .ts_event(UnixNanos::from(10))
6701                    .build(),
6702            ))
6703            .unwrap();
6704        let events: Vec<_> = order.events().into_iter().cloned().collect();
6705
6706        let result = order.apply(OrderEventAny::Expired(
6707            OrderExpiredSpec::builder()
6708                .ts_event(UnixNanos::from(30))
6709                .build(),
6710        ));
6711
6712        assert!(matches!(result, Err(OrderError::InvalidStateTransition)));
6713        assert_eq!(order.status(), OrderStatus::Expired);
6714        assert_eq!(order.ts_closed(), Some(UnixNanos::from(10)));
6715        assert_eq!(order.ts_last(), UnixNanos::from(10));
6716        assert_eq!(order.events(), events.iter().collect::<Vec<_>>());
6717    }
6718
6719    #[rstest]
6720    fn test_filled_order_rejects_expiry_without_prior_expiry() {
6721        let mut order: MarketOrder = OrderInitializedSpec::builder().build().try_into().unwrap();
6722        order
6723            .apply(OrderEventAny::Accepted(
6724                OrderAcceptedSpec::builder().build(),
6725            ))
6726            .unwrap();
6727        order
6728            .apply(OrderEventAny::Filled(OrderFilledSpec::builder().build()))
6729            .unwrap();
6730
6731        let result = order.apply(OrderEventAny::Expired(OrderExpiredSpec::builder().build()));
6732
6733        assert!(matches!(result, Err(OrderError::InvalidStateTransition)));
6734        assert_eq!(order.status(), OrderStatus::Filled);
6735        assert_eq!(order.filled_qty(), Quantity::from(100_000));
6736        assert_eq!(order.events().len(), 3);
6737    }
6738
6739    #[rstest]
6740    fn test_canceled_order_accepts_repeated_cancel_after_partial_fill() {
6741        let mut order: MarketOrder = OrderInitializedSpec::builder().build().try_into().unwrap();
6742        let submitted = OrderSubmittedSpec::builder().build();
6743        let accepted = OrderAcceptedSpec::builder().build();
6744        let canceled1 = OrderCanceledSpec::builder().build();
6745        let fill = OrderFilledSpec::builder()
6746            .last_qty(Quantity::from(50_000))
6747            .trade_id(TradeId::from("FILL-1"))
6748            .build();
6749        let canceled2 = OrderCanceledSpec::builder().build();
6750
6751        order.apply(OrderEventAny::Submitted(submitted)).unwrap();
6752        order.apply(OrderEventAny::Accepted(accepted)).unwrap();
6753        order.apply(OrderEventAny::Canceled(canceled1)).unwrap();
6754        assert_eq!(order.status(), OrderStatus::Canceled);
6755        assert!(order.is_closed());
6756
6757        order.apply(OrderEventAny::Filled(fill)).unwrap();
6758        assert_eq!(order.status(), OrderStatus::Canceled);
6759        assert_eq!(order.filled_qty(), Quantity::from(50_000));
6760        assert_eq!(order.leaves_qty(), Quantity::from(50_000));
6761        assert!(order.is_closed());
6762        assert!(!order.is_open());
6763
6764        order.apply(OrderEventAny::Canceled(canceled2)).unwrap();
6765        assert_eq!(order.status(), OrderStatus::Canceled);
6766        assert_eq!(order.filled_qty(), Quantity::from(50_000));
6767        assert_eq!(order.leaves_qty(), Quantity::from(50_000));
6768        assert_eq!(
6769            order
6770                .events()
6771                .iter()
6772                .filter(|event| matches!(event, OrderEventAny::Canceled(_)))
6773                .count(),
6774            2
6775        );
6776        assert!(order.is_closed());
6777        assert!(!order.is_open());
6778    }
6779
6780    #[rstest]
6781    fn test_updated_preserves_pending_cancel_after_fill() {
6782        let mut order: MarketOrder = OrderInitializedSpec::builder().build().try_into().unwrap();
6783        let submitted = OrderSubmittedSpec::builder().build();
6784        let accepted = OrderAcceptedSpec::builder().build();
6785        let pending_cancel = OrderPendingCancelSpec::builder().build();
6786        let fill = OrderFilledSpec::builder()
6787            .last_qty(Quantity::from(10_000))
6788            .build();
6789        let updated = OrderUpdatedSpec::builder()
6790            .quantity(Quantity::from(150_000))
6791            .build();
6792
6793        order.apply(OrderEventAny::Submitted(submitted)).unwrap();
6794        order.apply(OrderEventAny::Accepted(accepted)).unwrap();
6795        let ts_accepted = order.ts_accepted();
6796        let venue_order_ids: Vec<VenueOrderId> =
6797            order.venue_order_ids().into_iter().copied().collect();
6798        order
6799            .apply(OrderEventAny::PendingCancel(pending_cancel))
6800            .unwrap();
6801        order.apply(OrderEventAny::Filled(fill)).unwrap();
6802        assert_eq!(order.status(), OrderStatus::PendingCancel);
6803        assert_eq!(order.previous_status(), Some(OrderStatus::PartiallyFilled));
6804        order.apply(OrderEventAny::Updated(updated)).unwrap();
6805
6806        assert_eq!(order.status(), OrderStatus::PendingCancel);
6807        assert!(order.has_pending_cancel_command());
6808        assert_eq!(order.quantity(), Quantity::from(150_000));
6809        assert_eq!(order.filled_qty(), Quantity::from(10_000));
6810        assert_eq!(order.leaves_qty(), Quantity::from(140_000));
6811        assert_eq!(order.ts_accepted(), ts_accepted);
6812        assert_eq!(
6813            order
6814                .venue_order_ids()
6815                .into_iter()
6816                .copied()
6817                .collect::<Vec<_>>(),
6818            venue_order_ids,
6819        );
6820    }
6821
6822    #[rstest]
6823    fn test_apply_triggered_to_stop_market_order_returns_error() {
6824        let instrument_id = InstrumentId::from("ETHUSDT-LINEAR.BYBIT");
6825        let submitted = OrderSubmittedSpec::builder().build();
6826        let accepted = OrderAcceptedSpec::builder().build();
6827        let triggered = OrderTriggeredSpec::builder().build();
6828
6829        let mut order = OrderTestBuilder::new(OrderType::StopMarket)
6830            .instrument_id(instrument_id)
6831            .quantity(Quantity::from(1))
6832            .trigger_price(Price::from("1.00000"))
6833            .trigger_type(TriggerType::LastPrice)
6834            .build();
6835        order.apply(OrderEventAny::Submitted(submitted)).unwrap();
6836        order.apply(OrderEventAny::Accepted(accepted)).unwrap();
6837
6838        let result = order.apply(OrderEventAny::Triggered(triggered));
6839        assert!(result.is_err());
6840        assert_eq!(order.status(), OrderStatus::Accepted);
6841    }
6842
6843    #[rstest]
6844    fn test_apply_triggered_to_stop_limit_order_succeeds() {
6845        let instrument_id = InstrumentId::from("ETHUSDT-LINEAR.BYBIT");
6846        let submitted = OrderSubmittedSpec::builder().build();
6847        let accepted = OrderAcceptedSpec::builder().build();
6848        let triggered = OrderTriggeredSpec::builder().build();
6849
6850        let mut order = OrderTestBuilder::new(OrderType::StopLimit)
6851            .instrument_id(instrument_id)
6852            .quantity(Quantity::from(1))
6853            .price(Price::from("0.99500"))
6854            .trigger_price(Price::from("1.00000"))
6855            .trigger_type(TriggerType::LastPrice)
6856            .build();
6857        order.apply(OrderEventAny::Submitted(submitted)).unwrap();
6858        order.apply(OrderEventAny::Accepted(accepted)).unwrap();
6859        order.apply(OrderEventAny::Triggered(triggered)).unwrap();
6860
6861        assert_eq!(order.status(), OrderStatus::Triggered);
6862    }
6863
6864    #[rstest]
6865    fn test_to_order_status_report_for_accepted_limit_order() {
6866        let order = OrderTestBuilder::new(OrderType::Limit)
6867            .instrument_id(InstrumentId::from("AUDUSD.SIM"))
6868            .side(OrderSide::Buy)
6869            .quantity(Quantity::from(100_000))
6870            .price(Price::from("1.00000"))
6871            .build();
6872        let accepted = TestOrderStubs::make_accepted_order(&order);
6873
6874        let report = accepted.to_order_status_report(None).unwrap();
6875
6876        assert_eq!(report.account_id, AccountId::from("SIM-001"));
6877        assert_eq!(report.instrument_id, InstrumentId::from("AUDUSD.SIM"));
6878        assert_eq!(report.client_order_id, Some(accepted.client_order_id()));
6879        assert_eq!(report.venue_order_id, VenueOrderId::from("V-001"));
6880        assert_eq!(report.order_side, Some(OrderSide::Buy));
6881        assert_eq!(report.order_type, OrderType::Limit);
6882        assert_eq!(report.time_in_force, accepted.time_in_force());
6883        assert_eq!(report.order_status, OrderStatus::Accepted);
6884        assert_eq!(report.quantity, Quantity::from(100_000));
6885        assert_eq!(report.filled_qty, Quantity::from(0));
6886        assert_eq!(report.price, Some(Price::from("1.00000")));
6887        assert_eq!(report.avg_px, None);
6888        assert_eq!(report.ts_accepted, accepted.ts_accepted().unwrap());
6889        assert_eq!(report.ts_last, accepted.ts_last());
6890        assert_eq!(report.ts_init, accepted.ts_init());
6891    }
6892
6893    #[rstest]
6894    fn test_to_order_status_report_for_filled_market_order(audusd_sim: CurrencyPair) {
6895        let audusd_sim = InstrumentAny::CurrencyPair(audusd_sim);
6896        let order = OrderTestBuilder::new(OrderType::Market)
6897            .instrument_id(audusd_sim.id())
6898            .side(OrderSide::Buy)
6899            .quantity(Quantity::from(100_000))
6900            .build();
6901        let filled = TestOrderStubs::make_filled_order(&order, &audusd_sim, LiquiditySide::Maker);
6902        let report_id = UUID4::new();
6903
6904        let report = filled.to_order_status_report(Some(report_id)).unwrap();
6905
6906        assert_eq!(report.report_id, report_id);
6907        assert_eq!(report.order_status, OrderStatus::Filled);
6908        assert_eq!(report.quantity, Quantity::from(100_000));
6909        assert_eq!(report.filled_qty, Quantity::from(100_000));
6910        assert_eq!(report.price, None);
6911        assert_eq!(report.avg_px, Some(dec!(1)));
6912        assert_eq!(report.venue_position_id, Some(PositionId::from("1")));
6913        assert_eq!(report.ts_accepted, filled.ts_accepted().unwrap());
6914        assert_eq!(report.ts_last, filled.ts_last());
6915    }
6916
6917    #[rstest]
6918    fn test_to_order_status_report_maps_optional_fields() {
6919        let order = OrderTestBuilder::new(OrderType::StopLimit)
6920            .instrument_id(InstrumentId::from("AUDUSD.SIM"))
6921            .side(OrderSide::Sell)
6922            .quantity(Quantity::from(100_000))
6923            .price(Price::from("0.99500"))
6924            .trigger_price(Price::from("1.00000"))
6925            .trigger_type(TriggerType::LastPrice)
6926            .time_in_force(TimeInForce::Gtd)
6927            .expire_time(UnixNanos::from(5_000_000_000))
6928            .display_qty(Quantity::from(10_000))
6929            .post_only(true)
6930            .reduce_only(true)
6931            .contingency_type(ContingencyType::Oto)
6932            .order_list_id(OrderListId::from("OL-001"))
6933            .linked_order_ids(vec![ClientOrderId::from("O-CHILD")])
6934            .parent_order_id(ClientOrderId::from("O-PARENT"))
6935            .build();
6936        let accepted = TestOrderStubs::make_accepted_order(&order);
6937
6938        let report = accepted.to_order_status_report(None).unwrap();
6939
6940        assert_eq!(report.price, Some(Price::from("0.99500")));
6941        assert_eq!(report.trigger_price, Some(Price::from("1.00000")));
6942        assert_eq!(report.trigger_type, Some(TriggerType::LastPrice));
6943        assert_eq!(report.expire_time, Some(UnixNanos::from(5_000_000_000)));
6944        assert_eq!(report.display_qty, Some(Quantity::from(10_000)));
6945        assert!(report.post_only);
6946        assert!(report.reduce_only);
6947        assert_eq!(report.contingency_type, Some(ContingencyType::Oto));
6948        assert_eq!(report.order_list_id, Some(OrderListId::from("OL-001")));
6949        assert_eq!(
6950            report.linked_order_ids,
6951            Some(vec![ClientOrderId::from("O-CHILD")])
6952        );
6953        assert_eq!(
6954            report.parent_order_id,
6955            Some(ClientOrderId::from("O-PARENT"))
6956        );
6957    }
6958
6959    #[rstest]
6960    fn test_to_order_status_report_maps_ts_triggered() {
6961        let order = OrderTestBuilder::new(OrderType::StopLimit)
6962            .instrument_id(InstrumentId::from("AUDUSD.SIM"))
6963            .side(OrderSide::Buy)
6964            .quantity(Quantity::from(100_000))
6965            .price(Price::from("0.99500"))
6966            .trigger_price(Price::from("1.00000"))
6967            .trigger_type(TriggerType::LastPrice)
6968            .build();
6969        let mut order = TestOrderStubs::make_accepted_order(&order);
6970        let triggered = OrderTriggeredSpec::builder()
6971            .ts_event(UnixNanos::from(1_500_000_000))
6972            .build();
6973        order.apply(OrderEventAny::Triggered(triggered)).unwrap();
6974
6975        let report = order.to_order_status_report(None).unwrap();
6976
6977        assert_eq!(report.order_status, OrderStatus::Triggered);
6978        assert_eq!(report.ts_triggered, Some(UnixNanos::from(1_500_000_000)));
6979    }
6980
6981    #[rstest]
6982    fn test_to_order_status_report_maps_rejection_reason() {
6983        let order = OrderTestBuilder::new(OrderType::Limit)
6984            .instrument_id(InstrumentId::from("AUDUSD.SIM"))
6985            .side(OrderSide::Buy)
6986            .quantity(Quantity::from(100_000))
6987            .price(Price::from("1.00000"))
6988            .build();
6989        let mut order = TestOrderStubs::make_accepted_order(&order);
6990        let rejected = OrderRejectedSpec::builder()
6991            .reason(Ustr::from("INSUFFICIENT_MARGIN"))
6992            .build();
6993        order.apply(OrderEventAny::Rejected(rejected)).unwrap();
6994
6995        let report = order.to_order_status_report(None).unwrap();
6996
6997        assert_eq!(report.order_status, OrderStatus::Rejected);
6998        assert_eq!(
6999            report.cancel_reason,
7000            Some("INSUFFICIENT_MARGIN".to_string())
7001        );
7002    }
7003
7004    #[rstest]
7005    fn test_to_order_status_report_maps_distinct_timestamps() {
7006        let mut order = OrderTestBuilder::new(OrderType::Limit)
7007            .instrument_id(InstrumentId::from("AUDUSD.SIM"))
7008            .side(OrderSide::Buy)
7009            .quantity(Quantity::from(100_000))
7010            .price(Price::from("1.00000"))
7011            .ts_init(UnixNanos::from(1_000))
7012            .build();
7013        let submitted = OrderSubmittedSpec::builder()
7014            .ts_event(UnixNanos::from(2_000))
7015            .build();
7016        let accepted = OrderAcceptedSpec::builder()
7017            .ts_event(UnixNanos::from(3_000))
7018            .build();
7019        let filled = OrderFilledSpec::builder()
7020            .last_qty(Quantity::from(50_000))
7021            .ts_event(UnixNanos::from(4_000))
7022            .build();
7023        order.apply(OrderEventAny::Submitted(submitted)).unwrap();
7024        order.apply(OrderEventAny::Accepted(accepted)).unwrap();
7025        order.apply(OrderEventAny::Filled(filled)).unwrap();
7026
7027        let report = order.to_order_status_report(None).unwrap();
7028
7029        assert_eq!(report.order_status, OrderStatus::PartiallyFilled);
7030        assert_eq!(report.filled_qty, Quantity::from(50_000));
7031        assert_eq!(report.ts_accepted, UnixNanos::from(3_000));
7032        assert_eq!(report.ts_last, UnixNanos::from(4_000));
7033        assert_eq!(report.ts_init, UnixNanos::from(1_000));
7034    }
7035
7036    #[rstest]
7037    fn test_to_order_status_report_ts_accepted_falls_back_to_ts_last() {
7038        // Venue ack can arrive through an update before any acceptance event
7039        let mut order = OrderTestBuilder::new(OrderType::Limit)
7040            .instrument_id(InstrumentId::from("AUDUSD.SIM"))
7041            .side(OrderSide::Buy)
7042            .quantity(Quantity::from(100_000))
7043            .price(Price::from("1.00000"))
7044            .build();
7045        let submitted = OrderSubmittedSpec::builder()
7046            .ts_event(UnixNanos::from(2_000))
7047            .build();
7048        let updated = OrderUpdatedSpec::builder()
7049            .venue_order_id(VenueOrderId::from("V-001"))
7050            .ts_event(UnixNanos::from(3_000))
7051            .build();
7052        order.apply(OrderEventAny::Submitted(submitted)).unwrap();
7053        order.apply(OrderEventAny::Updated(updated)).unwrap();
7054
7055        let report = order.to_order_status_report(None).unwrap();
7056
7057        assert_eq!(report.order_status, OrderStatus::Submitted);
7058        assert_eq!(report.venue_order_id, VenueOrderId::from("V-001"));
7059        assert_eq!(report.ts_accepted, UnixNanos::from(3_000));
7060        assert_eq!(report.ts_last, UnixNanos::from(3_000));
7061    }
7062
7063    #[rstest]
7064    fn test_to_order_status_report_maps_trailing_offsets() {
7065        let order = OrderTestBuilder::new(OrderType::TrailingStopLimit)
7066            .instrument_id(InstrumentId::from("AUDUSD.SIM"))
7067            .side(OrderSide::Sell)
7068            .quantity(Quantity::from(100_000))
7069            .price(Price::from("0.99500"))
7070            .activation_price(Price::from("1.00500"))
7071            .trigger_price(Price::from("1.00000"))
7072            .trigger_type(TriggerType::LastPrice)
7073            .limit_offset(dec!(0.0001))
7074            .trailing_offset(dec!(0.0002))
7075            .trailing_offset_type(TrailingOffsetType::Price)
7076            .build();
7077        let accepted = TestOrderStubs::make_accepted_order(&order);
7078
7079        let report = accepted.to_order_status_report(None).unwrap();
7080
7081        assert_eq!(report.activation_price, Some(Price::from("1.00500")));
7082        assert_eq!(report.limit_offset, Some(dec!(0.0001)));
7083        assert_eq!(report.trailing_offset, Some(dec!(0.0002)));
7084        assert_eq!(report.trailing_offset_type, Some(TrailingOffsetType::Price),);
7085    }
7086
7087    #[rstest]
7088    fn test_to_order_status_report_returns_none_before_venue_ack() {
7089        let order = OrderTestBuilder::new(OrderType::Limit)
7090            .instrument_id(InstrumentId::from("AUDUSD.SIM"))
7091            .side(OrderSide::Buy)
7092            .quantity(Quantity::from(100_000))
7093            .price(Price::from("1.00000"))
7094            .build();
7095
7096        assert!(order.to_order_status_report(None).is_none());
7097    }
7098
7099    #[rstest]
7100    fn test_to_order_status_report_returns_none_for_submitted_order() {
7101        // Inflight orders have an account_id but no venue_order_id yet
7102        let mut order = OrderTestBuilder::new(OrderType::Limit)
7103            .instrument_id(InstrumentId::from("AUDUSD.SIM"))
7104            .side(OrderSide::Buy)
7105            .quantity(Quantity::from(100_000))
7106            .price(Price::from("1.00000"))
7107            .build();
7108        let submitted = OrderSubmittedSpec::builder().build();
7109        order.apply(OrderEventAny::Submitted(submitted)).unwrap();
7110
7111        assert!(order.account_id().is_some());
7112        assert!(order.to_order_status_report(None).is_none());
7113    }
7114}