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