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
18pub mod any;
19#[cfg(any(test, feature = "stubs"))]
20pub mod builder;
21pub mod limit;
22pub mod limit_if_touched;
23pub mod list;
24pub mod market;
25pub mod market_if_touched;
26pub mod market_to_limit;
27pub mod stop_limit;
28pub mod stop_market;
29pub mod trailing_stop_limit;
30pub mod trailing_stop_market;
31
32#[cfg(any(test, feature = "stubs"))]
33pub mod stubs;
34
35// Re-exports
36use ahash::AHashSet;
37use enum_dispatch::enum_dispatch;
38use indexmap::IndexMap;
39use nautilus_core::{UUID4, UnixNanos};
40use rust_decimal::Decimal;
41use serde::{Deserialize, Serialize};
42use ustr::Ustr;
43
44#[cfg(any(test, feature = "stubs"))]
45pub use crate::orders::builder::OrderTestBuilder;
46pub use crate::orders::{
47    any::{LimitOrderAny, OrderAny, PassiveOrderAny, StopOrderAny},
48    limit::LimitOrder,
49    limit_if_touched::LimitIfTouchedOrder,
50    list::OrderList,
51    market::MarketOrder,
52    market_if_touched::MarketIfTouchedOrder,
53    market_to_limit::MarketToLimitOrder,
54    stop_limit::StopLimitOrder,
55    stop_market::StopMarketOrder,
56    trailing_stop_limit::TrailingStopLimitOrder,
57    trailing_stop_market::TrailingStopMarketOrder,
58};
59use crate::{
60    enums::{
61        ContingencyType, LiquiditySide, OrderSide, OrderSideSpecified, OrderStatus, OrderType,
62        PositionSide, TimeInForce, TrailingOffsetType, TriggerType,
63    },
64    events::{
65        OrderAccepted, OrderCancelRejected, OrderCanceled, OrderDenied, OrderEmulated,
66        OrderEventAny, OrderExpired, OrderFilled, OrderInitialized, OrderModifyRejected,
67        OrderPendingCancel, OrderPendingUpdate, OrderRejected, OrderReleased, OrderSubmitted,
68        OrderTriggered, OrderUpdated,
69    },
70    identifiers::{
71        AccountId, ClientOrderId, ExecAlgorithmId, InstrumentId, OrderListId, PositionId,
72        StrategyId, Symbol, TradeId, TraderId, Venue, VenueOrderId,
73    },
74    orderbook::OwnBookOrder,
75    types::{Currency, Money, Price, Quantity},
76};
77
78/// Order types that have stop/trigger prices.
79pub const STOP_ORDER_TYPES: &[OrderType] = &[
80    OrderType::StopMarket,
81    OrderType::StopLimit,
82    OrderType::MarketIfTouched,
83    OrderType::LimitIfTouched,
84];
85
86/// Order types that have limit prices.
87pub const LIMIT_ORDER_TYPES: &[OrderType] = &[
88    OrderType::Limit,
89    OrderType::StopLimit,
90    OrderType::LimitIfTouched,
91    OrderType::MarketIfTouched,
92];
93
94/// Order statuses for locally active orders (pre-submission to venue).
95pub const LOCAL_ACTIVE_ORDER_STATUSES: &[OrderStatus] = &[
96    OrderStatus::Initialized,
97    OrderStatus::Emulated,
98    OrderStatus::Released,
99];
100
101/// Order statuses that are safe for cancellation queries.
102///
103/// These are statuses where an order is working on the venue but not already
104/// in the process of being cancelled. Including `PENDING_CANCEL` in cancellation
105/// filters can cause duplicate cancel attempts or incorrect open order counts.
106///
107/// Note: `PENDING_UPDATE` is included as orders being updated can typically still
108/// be cancelled (update and cancel are independent operations on most venues).
109pub const CANCELLABLE_ORDER_STATUSES: &[OrderStatus] = &[
110    OrderStatus::Accepted,
111    OrderStatus::Triggered,
112    OrderStatus::PendingUpdate,
113    OrderStatus::PartiallyFilled,
114];
115
116/// Returns a cached `AHashSet` of cancellable order statuses for O(1) lookups.
117///
118/// For the small set (4 elements), using `CANCELLABLE_ORDER_STATUSES.contains()` may be
119/// equally fast due to better cache locality. Use this function when you need set operations
120/// or are building HashSet-based filters.
121///
122/// Note: This is a module-level convenience function. You can also use
123/// `OrderStatus::cancellable_statuses_set()` directly.
124#[must_use]
125pub fn cancellable_order_statuses_set() -> &'static AHashSet<OrderStatus> {
126    OrderStatus::cancellable_statuses_set()
127}
128
129#[derive(thiserror::Error, Debug)]
130pub enum OrderError {
131    #[error("Order not found: {0}")]
132    NotFound(ClientOrderId),
133    #[error("Order invariant failed: must have a side for this operation")]
134    NoOrderSide,
135    #[error("Invalid event for order type")]
136    InvalidOrderEvent,
137    #[error("Invalid order state transition")]
138    InvalidStateTransition,
139    #[error("Order was already initialized")]
140    AlreadyInitialized,
141    #[error("Order had no previous state")]
142    NoPreviousState,
143    #[error("Duplicate fill: trade_id {0} already applied to order")]
144    DuplicateFill(TradeId),
145    #[error("{0}")]
146    Invariant(#[from] anyhow::Error),
147}
148
149/// Converts an IndexMap with `Ustr` keys and values to `String` keys and values.
150#[must_use]
151pub fn ustr_indexmap_to_str(h: IndexMap<Ustr, Ustr>) -> IndexMap<String, String> {
152    h.into_iter()
153        .map(|(k, v)| (k.to_string(), v.to_string()))
154        .collect()
155}
156
157/// Converts an IndexMap with `String` keys and values to `Ustr` keys and values.
158#[must_use]
159pub fn str_indexmap_to_ustr(h: IndexMap<String, String>) -> IndexMap<Ustr, Ustr> {
160    h.into_iter()
161        .map(|(k, v)| (Ustr::from(&k), Ustr::from(&v)))
162        .collect()
163}
164
165#[inline]
166pub(crate) fn check_display_qty(
167    display_qty: Option<Quantity>,
168    quantity: Quantity,
169) -> Result<(), OrderError> {
170    if let Some(q) = display_qty
171        && q > quantity
172    {
173        return Err(OrderError::Invariant(anyhow::anyhow!(
174            "`display_qty` may not exceed `quantity`"
175        )));
176    }
177    Ok(())
178}
179
180#[inline]
181pub(crate) fn check_time_in_force(
182    time_in_force: TimeInForce,
183    expire_time: Option<UnixNanos>,
184) -> Result<(), OrderError> {
185    if time_in_force == TimeInForce::Gtd && expire_time.unwrap_or_default() == 0 {
186        return Err(OrderError::Invariant(anyhow::anyhow!(
187            "`expire_time` is required for `GTD` order"
188        )));
189    }
190    Ok(())
191}
192
193impl OrderStatus {
194    /// Transitions the order state machine based on the given `event`.
195    ///
196    /// # Errors
197    ///
198    /// Returns an error if the state transition is invalid from the current status.
199    #[rustfmt::skip]
200    pub fn transition(&mut self, event: &OrderEventAny) -> Result<Self, OrderError> {
201        let new_state = match (self, event) {
202            (Self::Initialized, OrderEventAny::Denied(_)) => Self::Denied,
203            (Self::Initialized, OrderEventAny::Emulated(_)) => Self::Emulated,  // Emulated orders
204            (Self::Initialized, OrderEventAny::Released(_)) => Self::Released,  // Emulated orders
205            (Self::Initialized, OrderEventAny::Submitted(_)) => Self::Submitted,
206            (Self::Initialized, OrderEventAny::Rejected(_)) => Self::Rejected,  // External orders
207            (Self::Initialized, OrderEventAny::Accepted(_)) => Self::Accepted,  // External orders
208            (Self::Initialized, OrderEventAny::Canceled(_)) => Self::Canceled,  // External orders
209            (Self::Initialized, OrderEventAny::Expired(_)) => Self::Expired,  // External orders
210            (Self::Initialized, OrderEventAny::Triggered(_)) => Self::Triggered, // External orders
211            (Self::Initialized, OrderEventAny::Updated(_)) => Self::Initialized, // In-place modification
212            (Self::Emulated, OrderEventAny::Canceled(_)) => Self::Canceled,  // Emulated orders
213            (Self::Emulated, OrderEventAny::Expired(_)) => Self::Expired,  // Emulated orders
214            (Self::Emulated, OrderEventAny::Released(_)) => Self::Released,  // Emulated orders
215            (Self::Released, OrderEventAny::Submitted(_)) => Self::Submitted,  // Emulated orders
216            (Self::Released, OrderEventAny::Denied(_)) => Self::Denied,  // Emulated orders
217            (Self::Released, OrderEventAny::Canceled(_)) => Self::Canceled,  // Execution algo
218            (Self::Released, OrderEventAny::Updated(_)) => Self::Released, // In-place modification
219            (Self::Submitted, OrderEventAny::PendingUpdate(_)) => Self::PendingUpdate,
220            (Self::Submitted, OrderEventAny::PendingCancel(_)) => Self::PendingCancel,
221            (Self::Submitted, OrderEventAny::Rejected(_)) => Self::Rejected,
222            (Self::Submitted, OrderEventAny::Canceled(_)) => Self::Canceled,  // FOK and IOC cases
223            (Self::Submitted, OrderEventAny::Accepted(_)) => Self::Accepted,
224            (Self::Submitted, OrderEventAny::Updated(_)) => Self::Submitted,
225            (Self::Submitted, OrderEventAny::Filled(_)) => Self::Filled,
226            (Self::Accepted, OrderEventAny::Rejected(_)) => Self::Rejected,  // StopLimit order
227            (Self::Accepted, OrderEventAny::PendingUpdate(_)) => Self::PendingUpdate,
228            (Self::Accepted, OrderEventAny::PendingCancel(_)) => Self::PendingCancel,
229            (Self::Accepted, OrderEventAny::Canceled(_)) => Self::Canceled,
230            (Self::Accepted, OrderEventAny::Triggered(_)) => Self::Triggered,
231            (Self::Accepted, OrderEventAny::Updated(_)) => Self::Accepted,  // Updates should preserve state
232            (Self::Accepted, OrderEventAny::Expired(_)) => Self::Expired,
233            (Self::Accepted, OrderEventAny::Filled(_)) => Self::Filled,
234            (Self::Canceled, OrderEventAny::Filled(_)) => Self::Filled,  // Real world possibility
235            (Self::PendingUpdate, OrderEventAny::Rejected(_)) => Self::Rejected,
236            (Self::PendingUpdate, OrderEventAny::Accepted(_)) => Self::Accepted,
237            (Self::PendingUpdate, OrderEventAny::Canceled(_)) => Self::Canceled,
238            (Self::PendingUpdate, OrderEventAny::Expired(_)) => Self::Expired,
239            (Self::PendingUpdate, OrderEventAny::Triggered(_)) => Self::Triggered,
240            (Self::PendingUpdate, OrderEventAny::PendingUpdate(_)) => Self::PendingUpdate,  // Allow multiple requests
241            (Self::PendingUpdate, OrderEventAny::PendingCancel(_)) => Self::PendingCancel,
242            (Self::PendingUpdate, OrderEventAny::ModifyRejected(_)) => Self::PendingUpdate,  // Handled by modify_rejected to restore previous_status
243            (Self::PendingUpdate, OrderEventAny::Filled(_)) => Self::Filled,
244            (Self::PendingCancel, OrderEventAny::Rejected(_)) => Self::Rejected,
245            (Self::PendingCancel, OrderEventAny::PendingCancel(_)) => Self::PendingCancel,  // Allow multiple requests
246            (Self::PendingCancel, OrderEventAny::CancelRejected(_)) => Self::PendingCancel,  // Handled by cancel_rejected to restore previous_status
247            (Self::PendingCancel, OrderEventAny::Canceled(_)) => Self::Canceled,
248            (Self::PendingCancel, OrderEventAny::Expired(_)) => Self::Expired,
249            (Self::PendingCancel, OrderEventAny::Accepted(_)) => Self::Accepted,  // Allow failed cancel requests
250            (Self::PendingCancel, OrderEventAny::Filled(_)) => Self::Filled,
251            (Self::Triggered, OrderEventAny::Rejected(_)) => Self::Rejected,
252            (Self::Triggered, OrderEventAny::PendingUpdate(_)) => Self::PendingUpdate,
253            (Self::Triggered, OrderEventAny::PendingCancel(_)) => Self::PendingCancel,
254            (Self::Triggered, OrderEventAny::Canceled(_)) => Self::Canceled,
255            (Self::Triggered, OrderEventAny::Expired(_)) => Self::Expired,
256            (Self::Triggered, OrderEventAny::Filled(_)) => Self::Filled,
257            (Self::Triggered, OrderEventAny::Updated(_)) => Self::Triggered,
258            (Self::PartiallyFilled, OrderEventAny::PendingUpdate(_)) => Self::PendingUpdate,
259            (Self::PartiallyFilled, OrderEventAny::PendingCancel(_)) => Self::PendingCancel,
260            (Self::PartiallyFilled, OrderEventAny::Canceled(_)) => Self::Canceled,
261            (Self::PartiallyFilled, OrderEventAny::Expired(_)) => Self::Expired,
262            (Self::PartiallyFilled, OrderEventAny::Filled(_)) => Self::Filled,
263            (Self::PartiallyFilled, OrderEventAny::Accepted(_)) => Self::Accepted,
264            (Self::PartiallyFilled, OrderEventAny::Updated(_)) => Self::PartiallyFilled,
265            _ => return Err(OrderError::InvalidStateTransition),
266        };
267        Ok(new_state)
268    }
269}
270
271#[enum_dispatch]
272pub trait Order: 'static + Send {
273    fn into_any(self) -> OrderAny;
274    fn status(&self) -> OrderStatus;
275    fn trader_id(&self) -> TraderId;
276    fn strategy_id(&self) -> StrategyId;
277    fn instrument_id(&self) -> InstrumentId;
278    fn symbol(&self) -> Symbol;
279    fn venue(&self) -> Venue;
280    fn client_order_id(&self) -> ClientOrderId;
281    fn venue_order_id(&self) -> Option<VenueOrderId>;
282    fn position_id(&self) -> Option<PositionId>;
283    fn account_id(&self) -> Option<AccountId>;
284    fn last_trade_id(&self) -> Option<TradeId>;
285    fn order_side(&self) -> OrderSide;
286    fn order_type(&self) -> OrderType;
287    fn quantity(&self) -> Quantity;
288    fn time_in_force(&self) -> TimeInForce;
289    fn expire_time(&self) -> Option<UnixNanos>;
290    fn price(&self) -> Option<Price>;
291    fn trigger_price(&self) -> Option<Price>;
292    fn activation_price(&self) -> Option<Price> {
293        None
294    }
295    fn trigger_type(&self) -> Option<TriggerType>;
296    fn liquidity_side(&self) -> Option<LiquiditySide>;
297    fn is_post_only(&self) -> bool;
298    fn is_reduce_only(&self) -> bool;
299    fn is_quote_quantity(&self) -> bool;
300    fn display_qty(&self) -> Option<Quantity>;
301    fn limit_offset(&self) -> Option<Decimal>;
302    fn trailing_offset(&self) -> Option<Decimal>;
303    fn trailing_offset_type(&self) -> Option<TrailingOffsetType>;
304    fn emulation_trigger(&self) -> Option<TriggerType>;
305    fn trigger_instrument_id(&self) -> Option<InstrumentId>;
306    fn contingency_type(&self) -> Option<ContingencyType>;
307    fn order_list_id(&self) -> Option<OrderListId>;
308    fn linked_order_ids(&self) -> Option<&[ClientOrderId]>;
309    fn parent_order_id(&self) -> Option<ClientOrderId>;
310    fn exec_algorithm_id(&self) -> Option<ExecAlgorithmId>;
311    fn exec_algorithm_params(&self) -> Option<&IndexMap<Ustr, Ustr>>;
312    fn exec_spawn_id(&self) -> Option<ClientOrderId>;
313    fn tags(&self) -> Option<&[Ustr]>;
314    fn filled_qty(&self) -> Quantity;
315    fn leaves_qty(&self) -> Quantity;
316    fn overfill_qty(&self) -> Quantity;
317
318    /// Calculates potential overfill quantity without mutating order state.
319    fn calculate_overfill(&self, fill_qty: Quantity) -> Quantity {
320        let potential_filled = self.filled_qty() + fill_qty;
321        potential_filled.saturating_sub(self.quantity())
322    }
323
324    fn avg_px(&self) -> Option<f64>;
325    fn slippage(&self) -> Option<f64>;
326    fn init_id(&self) -> UUID4;
327    fn ts_init(&self) -> UnixNanos;
328    fn ts_submitted(&self) -> Option<UnixNanos>;
329    fn ts_accepted(&self) -> Option<UnixNanos>;
330    fn ts_closed(&self) -> Option<UnixNanos>;
331    fn ts_last(&self) -> UnixNanos;
332
333    fn order_side_specified(&self) -> OrderSideSpecified {
334        self.order_side().as_specified()
335    }
336    fn commissions(&self) -> &IndexMap<Currency, Money>;
337
338    /// Applies the `event` to the order.
339    ///
340    /// # Errors
341    ///
342    /// Returns an error if the event is invalid for the current order status.
343    fn apply(&mut self, event: OrderEventAny) -> Result<(), OrderError>;
344    fn update(&mut self, event: &OrderUpdated);
345
346    fn events(&self) -> Vec<&OrderEventAny>;
347
348    fn last_event(&self) -> &OrderEventAny {
349        // SAFETY: Order specification guarantees at least one event (OrderInitialized)
350        self.events()
351            .last()
352            .expect("Order invariant violated: no events")
353    }
354
355    fn event_count(&self) -> usize {
356        self.events().len()
357    }
358
359    fn venue_order_ids(&self) -> Vec<&VenueOrderId>;
360
361    fn trade_ids(&self) -> Vec<&TradeId>;
362
363    fn has_price(&self) -> bool;
364
365    /// Returns `true` if a fill with matching trade_id, side, qty, and price already exists.
366    fn is_duplicate_fill(&self, fill: &OrderFilled) -> bool {
367        self.events().iter().any(|event| {
368            if let OrderEventAny::Filled(existing) = event {
369                existing.trade_id == fill.trade_id
370                    && existing.order_side == fill.order_side
371                    && existing.last_qty == fill.last_qty
372                    && existing.last_px == fill.last_px
373            } else {
374                false
375            }
376        })
377    }
378
379    fn is_buy(&self) -> bool {
380        self.order_side() == OrderSide::Buy
381    }
382
383    fn is_sell(&self) -> bool {
384        self.order_side() == OrderSide::Sell
385    }
386
387    fn is_passive(&self) -> bool {
388        self.order_type() != OrderType::Market
389    }
390
391    fn is_aggressive(&self) -> bool {
392        self.order_type() == OrderType::Market
393    }
394
395    fn is_emulated(&self) -> bool {
396        self.status() == OrderStatus::Emulated
397    }
398
399    fn is_active_local(&self) -> bool {
400        matches!(
401            self.status(),
402            OrderStatus::Initialized | OrderStatus::Emulated | OrderStatus::Released
403        )
404    }
405
406    fn is_primary(&self) -> bool {
407        self.exec_algorithm_id().is_some()
408            && self
409                .exec_spawn_id()
410                .is_some_and(|spawn_id| self.client_order_id() == spawn_id)
411    }
412
413    fn is_spawned(&self) -> bool {
414        self.exec_algorithm_id().is_some()
415            && self
416                .exec_spawn_id()
417                .is_some_and(|spawn_id| self.client_order_id() != spawn_id)
418    }
419
420    fn is_contingency(&self) -> bool {
421        self.contingency_type().is_some()
422    }
423
424    fn is_parent_order(&self) -> bool {
425        match self.contingency_type() {
426            Some(c) => c == ContingencyType::Oto,
427            None => false,
428        }
429    }
430
431    fn is_child_order(&self) -> bool {
432        self.parent_order_id().is_some()
433    }
434
435    fn is_open(&self) -> bool {
436        if let Some(emulation_trigger) = self.emulation_trigger()
437            && emulation_trigger != TriggerType::NoTrigger
438        {
439            return false;
440        }
441
442        matches!(
443            self.status(),
444            OrderStatus::Accepted
445                | OrderStatus::Triggered
446                | OrderStatus::PendingCancel
447                | OrderStatus::PendingUpdate
448                | OrderStatus::PartiallyFilled
449        )
450    }
451
452    fn is_canceled(&self) -> bool {
453        self.status() == OrderStatus::Canceled
454    }
455
456    fn is_closed(&self) -> bool {
457        matches!(
458            self.status(),
459            OrderStatus::Denied
460                | OrderStatus::Rejected
461                | OrderStatus::Canceled
462                | OrderStatus::Expired
463                | OrderStatus::Filled
464        )
465    }
466
467    fn is_inflight(&self) -> bool {
468        if let Some(emulation_trigger) = self.emulation_trigger()
469            && emulation_trigger != TriggerType::NoTrigger
470        {
471            return false;
472        }
473
474        matches!(
475            self.status(),
476            OrderStatus::Submitted | OrderStatus::PendingCancel | OrderStatus::PendingUpdate
477        )
478    }
479
480    fn is_pending_update(&self) -> bool {
481        self.status() == OrderStatus::PendingUpdate
482    }
483
484    fn is_pending_cancel(&self) -> bool {
485        self.status() == OrderStatus::PendingCancel
486    }
487
488    fn to_own_book_order(&self) -> OwnBookOrder {
489        OwnBookOrder::new(
490            self.trader_id(),
491            self.client_order_id(),
492            self.venue_order_id(),
493            self.order_side().as_specified(),
494            self.price().expect("`OwnBookOrder` must have a price"), // TBD
495            self.quantity(),
496            self.order_type(),
497            self.time_in_force(),
498            self.status(),
499            self.ts_last(),
500            self.ts_accepted().unwrap_or_default(),
501            self.ts_submitted().unwrap_or_default(),
502            self.ts_init(),
503        )
504    }
505
506    fn is_triggered(&self) -> Option<bool>; // TODO: Temporary on trait
507    fn set_position_id(&mut self, position_id: Option<PositionId>);
508    fn set_quantity(&mut self, quantity: Quantity);
509    fn set_leaves_qty(&mut self, leaves_qty: Quantity);
510    fn set_emulation_trigger(&mut self, emulation_trigger: Option<TriggerType>);
511    fn set_is_quote_quantity(&mut self, is_quote_quantity: bool);
512    fn set_liquidity_side(&mut self, liquidity_side: LiquiditySide);
513    fn would_reduce_only(&self, side: PositionSide, position_qty: Quantity) -> bool;
514    fn previous_status(&self) -> Option<OrderStatus>;
515}
516
517impl<T> From<&T> for OrderInitialized
518where
519    T: Order,
520{
521    fn from(order: &T) -> Self {
522        Self {
523            trader_id: order.trader_id(),
524            strategy_id: order.strategy_id(),
525            instrument_id: order.instrument_id(),
526            client_order_id: order.client_order_id(),
527            order_side: order.order_side(),
528            order_type: order.order_type(),
529            quantity: order.quantity(),
530            price: order.price(),
531            trigger_price: order.trigger_price(),
532            trigger_type: order.trigger_type(),
533            time_in_force: order.time_in_force(),
534            expire_time: order.expire_time(),
535            post_only: order.is_post_only(),
536            reduce_only: order.is_reduce_only(),
537            quote_quantity: order.is_quote_quantity(),
538            display_qty: order.display_qty(),
539            limit_offset: order.limit_offset(),
540            trailing_offset: order.trailing_offset(),
541            trailing_offset_type: order.trailing_offset_type(),
542            emulation_trigger: order.emulation_trigger(),
543            trigger_instrument_id: order.trigger_instrument_id(),
544            contingency_type: order.contingency_type(),
545            order_list_id: order.order_list_id(),
546            linked_order_ids: order.linked_order_ids().map(|x| x.to_vec()),
547            parent_order_id: order.parent_order_id(),
548            exec_algorithm_id: order.exec_algorithm_id(),
549            exec_algorithm_params: order.exec_algorithm_params().map(|x| x.to_owned()),
550            exec_spawn_id: order.exec_spawn_id(),
551            tags: order.tags().map(|x| x.to_vec()),
552            event_id: order.init_id(),
553            ts_event: order.ts_init(),
554            ts_init: order.ts_init(),
555            reconciliation: false,
556        }
557    }
558}
559
560#[derive(Clone, Debug, Serialize, Deserialize)]
561pub struct OrderCore {
562    pub events: Vec<OrderEventAny>,
563    pub commissions: IndexMap<Currency, Money>,
564    pub venue_order_ids: Vec<VenueOrderId>,
565    pub trade_ids: Vec<TradeId>,
566    pub previous_status: Option<OrderStatus>,
567    pub status: OrderStatus,
568    pub trader_id: TraderId,
569    pub strategy_id: StrategyId,
570    pub instrument_id: InstrumentId,
571    pub client_order_id: ClientOrderId,
572    pub venue_order_id: Option<VenueOrderId>,
573    pub position_id: Option<PositionId>,
574    pub account_id: Option<AccountId>,
575    pub last_trade_id: Option<TradeId>,
576    pub side: OrderSide,
577    pub order_type: OrderType,
578    pub quantity: Quantity,
579    pub time_in_force: TimeInForce,
580    pub liquidity_side: Option<LiquiditySide>,
581    pub is_reduce_only: bool,
582    pub is_quote_quantity: bool,
583    pub emulation_trigger: Option<TriggerType>,
584    pub contingency_type: Option<ContingencyType>,
585    pub order_list_id: Option<OrderListId>,
586    pub linked_order_ids: Option<Vec<ClientOrderId>>,
587    pub parent_order_id: Option<ClientOrderId>,
588    pub exec_algorithm_id: Option<ExecAlgorithmId>,
589    pub exec_algorithm_params: Option<IndexMap<Ustr, Ustr>>,
590    pub exec_spawn_id: Option<ClientOrderId>,
591    pub tags: Option<Vec<Ustr>>,
592    pub filled_qty: Quantity,
593    pub leaves_qty: Quantity,
594    pub overfill_qty: Quantity,
595    pub avg_px: Option<f64>,
596    pub slippage: Option<f64>,
597    pub init_id: UUID4,
598    pub ts_init: UnixNanos,
599    pub ts_submitted: Option<UnixNanos>,
600    pub ts_accepted: Option<UnixNanos>,
601    pub ts_closed: Option<UnixNanos>,
602    pub ts_last: UnixNanos,
603}
604
605impl OrderCore {
606    /// Creates a new [`OrderCore`] instance.
607    pub fn new(init: OrderInitialized) -> Self {
608        let events: Vec<OrderEventAny> = vec![OrderEventAny::Initialized(init.clone())];
609        Self {
610            events,
611            commissions: IndexMap::new(),
612            venue_order_ids: Vec::new(),
613            trade_ids: Vec::new(),
614            previous_status: None,
615            status: OrderStatus::Initialized,
616            trader_id: init.trader_id,
617            strategy_id: init.strategy_id,
618            instrument_id: init.instrument_id,
619            client_order_id: init.client_order_id,
620            venue_order_id: None,
621            position_id: None,
622            account_id: None,
623            last_trade_id: None,
624            side: init.order_side,
625            order_type: init.order_type,
626            quantity: init.quantity,
627            time_in_force: init.time_in_force,
628            liquidity_side: Some(LiquiditySide::NoLiquiditySide),
629            is_reduce_only: init.reduce_only,
630            is_quote_quantity: init.quote_quantity,
631            emulation_trigger: init.emulation_trigger.or(Some(TriggerType::NoTrigger)),
632            contingency_type: init
633                .contingency_type
634                .or(Some(ContingencyType::NoContingency)),
635            order_list_id: init.order_list_id,
636            linked_order_ids: init.linked_order_ids,
637            parent_order_id: init.parent_order_id,
638            exec_algorithm_id: init.exec_algorithm_id,
639            exec_algorithm_params: init.exec_algorithm_params,
640            exec_spawn_id: init.exec_spawn_id,
641            tags: init.tags,
642            filled_qty: Quantity::zero(init.quantity.precision),
643            leaves_qty: init.quantity,
644            overfill_qty: Quantity::zero(init.quantity.precision),
645            avg_px: None,
646            slippage: None,
647            init_id: init.event_id,
648            ts_init: init.ts_event,
649            ts_submitted: None,
650            ts_accepted: None,
651            ts_closed: None,
652            ts_last: init.ts_event,
653        }
654    }
655
656    /// Applies the `event` to the order.
657    ///
658    /// # Errors
659    ///
660    /// Returns an error if the event is invalid for the current order status, or if
661    /// `event.client_order_id()` or `event.strategy_id()` does not match the order.
662    pub fn apply(&mut self, event: OrderEventAny) -> Result<(), OrderError> {
663        if self.client_order_id != event.client_order_id() {
664            return Err(OrderError::Invariant(anyhow::anyhow!(
665                "Event client_order_id {} does not match order client_order_id {}",
666                event.client_order_id(),
667                self.client_order_id
668            )));
669        }
670        if self.strategy_id != event.strategy_id() {
671            return Err(OrderError::Invariant(anyhow::anyhow!(
672                "Event strategy_id {} does not match order strategy_id {}",
673                event.strategy_id(),
674                self.strategy_id
675            )));
676        }
677
678        // Save current status as previous_status for ALL transitions except:
679        // - Initialized (no prior state exists)
680        // - ModifyRejected/CancelRejected (need to preserve the pre Pending state)
681        // - When already in Pending* state (avoid overwriting the pre Pending state when receiving multiple pending requests)
682        if !matches!(
683            event,
684            OrderEventAny::Initialized(_)
685                | OrderEventAny::ModifyRejected(_)
686                | OrderEventAny::CancelRejected(_)
687        ) && !matches!(
688            self.status,
689            OrderStatus::PendingUpdate | OrderStatus::PendingCancel
690        ) {
691            self.previous_status = Some(self.status);
692        }
693
694        // Check for duplicate fill before state transition to maintain consistency
695        if let OrderEventAny::Filled(fill) = &event
696            && self.trade_ids.contains(&fill.trade_id)
697        {
698            return Err(OrderError::DuplicateFill(fill.trade_id));
699        }
700
701        let new_status = self.status.transition(&event)?;
702        self.status = new_status;
703
704        match &event {
705            OrderEventAny::Initialized(_) => return Err(OrderError::AlreadyInitialized),
706            OrderEventAny::Denied(event) => self.denied(event),
707            OrderEventAny::Emulated(event) => self.emulated(event),
708            OrderEventAny::Released(event) => self.released(event),
709            OrderEventAny::Submitted(event) => self.submitted(event),
710            OrderEventAny::Rejected(event) => self.rejected(event),
711            OrderEventAny::Accepted(event) => self.accepted(event),
712            OrderEventAny::PendingUpdate(event) => self.pending_update(event),
713            OrderEventAny::PendingCancel(event) => self.pending_cancel(event),
714            OrderEventAny::ModifyRejected(event) => self.modify_rejected(event)?,
715            OrderEventAny::CancelRejected(event) => self.cancel_rejected(event)?,
716            OrderEventAny::Updated(event) => self.updated(event),
717            OrderEventAny::Triggered(event) => self.triggered(event),
718            OrderEventAny::Canceled(event) => self.canceled(event),
719            OrderEventAny::Expired(event) => self.expired(event),
720            OrderEventAny::Filled(event) => self.filled(event),
721        }
722
723        self.ts_last = event.ts_event();
724        self.events.push(event);
725        Ok(())
726    }
727
728    fn denied(&mut self, event: &OrderDenied) {
729        self.ts_closed = Some(event.ts_event);
730    }
731
732    fn emulated(&self, _event: &OrderEmulated) {
733        // Do nothing else
734    }
735
736    fn released(&mut self, _event: &OrderReleased) {
737        self.emulation_trigger = None;
738    }
739
740    fn submitted(&mut self, event: &OrderSubmitted) {
741        self.account_id = Some(event.account_id);
742        self.ts_submitted = Some(event.ts_event);
743    }
744
745    fn accepted(&mut self, event: &OrderAccepted) {
746        self.account_id = Some(event.account_id);
747        self.venue_order_id = Some(event.venue_order_id);
748        self.venue_order_ids.push(event.venue_order_id);
749        self.ts_accepted = Some(event.ts_event);
750    }
751
752    fn rejected(&mut self, event: &OrderRejected) {
753        self.ts_closed = Some(event.ts_event);
754    }
755
756    fn pending_update(&self, _event: &OrderPendingUpdate) {
757        // Do nothing else
758    }
759
760    fn pending_cancel(&self, _event: &OrderPendingCancel) {
761        // Do nothing else
762    }
763
764    fn modify_rejected(&mut self, _event: &OrderModifyRejected) -> Result<(), OrderError> {
765        self.status = self.previous_status.ok_or(OrderError::NoPreviousState)?;
766        Ok(())
767    }
768
769    fn cancel_rejected(&mut self, _event: &OrderCancelRejected) -> Result<(), OrderError> {
770        self.status = self.previous_status.ok_or(OrderError::NoPreviousState)?;
771        Ok(())
772    }
773
774    fn triggered(&mut self, _event: &OrderTriggered) {}
775
776    fn canceled(&mut self, event: &OrderCanceled) {
777        self.ts_closed = Some(event.ts_event);
778    }
779
780    fn expired(&mut self, event: &OrderExpired) {
781        self.ts_closed = Some(event.ts_event);
782    }
783
784    fn updated(&mut self, event: &OrderUpdated) {
785        if let Some(venue_order_id) = &event.venue_order_id
786            && (self.venue_order_id.is_none()
787                || venue_order_id != self.venue_order_id.as_ref().unwrap())
788        {
789            self.venue_order_id = Some(*venue_order_id);
790            self.venue_order_ids.push(*venue_order_id);
791        }
792    }
793
794    fn filled(&mut self, event: &OrderFilled) {
795        // Use saturating arithmetic to prevent overflow
796        let new_filled_qty = Quantity::from_raw(
797            self.filled_qty.raw.saturating_add(event.last_qty.raw),
798            self.filled_qty.precision,
799        );
800
801        // Calculate overfill if any
802        if new_filled_qty > self.quantity {
803            let overfill_raw = new_filled_qty.raw - self.quantity.raw;
804            self.overfill_qty = Quantity::from_raw(
805                self.overfill_qty.raw.saturating_add(overfill_raw),
806                self.filled_qty.precision,
807            );
808        }
809
810        if new_filled_qty < self.quantity {
811            self.status = OrderStatus::PartiallyFilled;
812        } else {
813            self.status = OrderStatus::Filled;
814            self.ts_closed = Some(event.ts_event);
815        }
816
817        self.venue_order_id = Some(event.venue_order_id);
818        self.position_id = event.position_id;
819        self.trade_ids.push(event.trade_id);
820        self.last_trade_id = Some(event.trade_id);
821        self.liquidity_side = Some(event.liquidity_side);
822        self.filled_qty = new_filled_qty;
823        self.leaves_qty = self.leaves_qty.saturating_sub(event.last_qty);
824        self.ts_last = event.ts_event;
825        if self.ts_accepted.is_none() {
826            // Set ts_accepted to time of first fill if not previously set
827            self.ts_accepted = Some(event.ts_event);
828        }
829
830        self.set_avg_px(event.last_qty, event.last_px);
831    }
832
833    fn set_avg_px(&mut self, last_qty: Quantity, last_px: Price) {
834        if self.avg_px.is_none() {
835            self.avg_px = Some(last_px.as_f64());
836            return;
837        }
838
839        // Use previous filled quantity (before current fill) to avoid double-counting
840        let prev_filled_qty = (self.filled_qty - last_qty).as_f64();
841        let last_qty_f64 = last_qty.as_f64();
842        let total_qty = prev_filled_qty + last_qty_f64;
843
844        let avg_px = self
845            .avg_px
846            .unwrap()
847            .mul_add(prev_filled_qty, last_px.as_f64() * last_qty_f64)
848            / total_qty;
849        self.avg_px = Some(avg_px);
850    }
851
852    pub fn set_slippage(&mut self, price: Price) {
853        self.slippage = self.avg_px.and_then(|avg_px| {
854            let current_price = price.as_f64();
855            match self.side {
856                OrderSide::Buy if avg_px > current_price => Some(avg_px - current_price),
857                OrderSide::Sell if avg_px < current_price => Some(current_price - avg_px),
858                _ => None,
859            }
860        });
861    }
862
863    /// Returns the opposite order side.
864    #[must_use]
865    pub fn opposite_side(side: OrderSide) -> OrderSide {
866        match side {
867            OrderSide::Buy => OrderSide::Sell,
868            OrderSide::Sell => OrderSide::Buy,
869            OrderSide::NoOrderSide => OrderSide::NoOrderSide,
870        }
871    }
872
873    /// Returns the order side needed to close a position.
874    #[must_use]
875    pub fn closing_side(side: PositionSide) -> OrderSide {
876        match side {
877            PositionSide::Long => OrderSide::Sell,
878            PositionSide::Short => OrderSide::Buy,
879            PositionSide::Flat => OrderSide::NoOrderSide,
880            PositionSide::NoPositionSide => OrderSide::NoOrderSide,
881        }
882    }
883
884    /// # Panics
885    ///
886    /// Panics if the order side is neither `Buy` nor `Sell`.
887    #[must_use]
888    pub fn signed_decimal_qty(&self) -> Decimal {
889        match self.side {
890            OrderSide::Buy => self.quantity.as_decimal(),
891            OrderSide::Sell => -self.quantity.as_decimal(),
892            _ => panic!("Invalid order side"),
893        }
894    }
895
896    #[must_use]
897    pub fn would_reduce_only(&self, side: PositionSide, position_qty: Quantity) -> bool {
898        if side == PositionSide::Flat {
899            return false;
900        }
901
902        match (self.side, side) {
903            (OrderSide::Buy, PositionSide::Long) => false,
904            (OrderSide::Buy, PositionSide::Short) => self.leaves_qty <= position_qty,
905            (OrderSide::Sell, PositionSide::Short) => false,
906            (OrderSide::Sell, PositionSide::Long) => self.leaves_qty <= position_qty,
907            _ => true,
908        }
909    }
910
911    #[must_use]
912    pub fn commission(&self, currency: &Currency) -> Option<Money> {
913        self.commissions.get(currency).copied()
914    }
915
916    #[must_use]
917    pub fn commissions(&self) -> IndexMap<Currency, Money> {
918        self.commissions.clone()
919    }
920
921    #[must_use]
922    pub fn commissions_vec(&self) -> Vec<Money> {
923        self.commissions.values().copied().collect()
924    }
925
926    #[must_use]
927    pub fn init_event(&self) -> Option<OrderEventAny> {
928        self.events.first().cloned()
929    }
930}
931
932#[cfg(test)]
933mod tests {
934    use rstest::rstest;
935    use rust_decimal_macros::dec;
936
937    use super::*;
938    use crate::{
939        enums::{OrderSide, OrderStatus, PositionSide},
940        events::order::{
941            accepted::OrderAcceptedBuilder, canceled::OrderCanceledBuilder,
942            denied::OrderDeniedBuilder, filled::OrderFilledBuilder,
943            initialized::OrderInitializedBuilder, submitted::OrderSubmittedBuilder,
944            triggered::OrderTriggeredBuilder, updated::OrderUpdatedBuilder,
945        },
946        orders::MarketOrder,
947    };
948
949    // TODO: WIP
950    // fn test_display_market_order() {
951    //     let order = MarketOrder::default();
952    //     assert_eq!(order.events().len(), 1);
953    //     assert_eq!(
954    //         stringify!(order.events().get(0)),
955    //         stringify!(OrderInitialized)
956    //     );
957    // }
958
959    #[rstest]
960    #[case(OrderSide::Buy, OrderSide::Sell)]
961    #[case(OrderSide::Sell, OrderSide::Buy)]
962    #[case(OrderSide::NoOrderSide, OrderSide::NoOrderSide)]
963    fn test_order_opposite_side(#[case] order_side: OrderSide, #[case] expected_side: OrderSide) {
964        let result = OrderCore::opposite_side(order_side);
965        assert_eq!(result, expected_side);
966    }
967
968    #[rstest]
969    #[case(PositionSide::Long, OrderSide::Sell)]
970    #[case(PositionSide::Short, OrderSide::Buy)]
971    #[case(PositionSide::NoPositionSide, OrderSide::NoOrderSide)]
972    fn test_closing_side(#[case] position_side: PositionSide, #[case] expected_side: OrderSide) {
973        let result = OrderCore::closing_side(position_side);
974        assert_eq!(result, expected_side);
975    }
976
977    #[rstest]
978    #[case(OrderSide::Buy, dec!(10_000))]
979    #[case(OrderSide::Sell, dec!(-10_000))]
980    fn test_signed_decimal_qty(#[case] order_side: OrderSide, #[case] expected: Decimal) {
981        let order: MarketOrder = OrderInitializedBuilder::default()
982            .order_side(order_side)
983            .quantity(Quantity::from(10_000))
984            .build()
985            .unwrap()
986            .into();
987
988        let result = order.signed_decimal_qty();
989        assert_eq!(result, expected);
990    }
991
992    #[rustfmt::skip]
993    #[rstest]
994    #[case(OrderSide::Buy, Quantity::from(100), PositionSide::Long, Quantity::from(50), false)]
995    #[case(OrderSide::Buy, Quantity::from(50), PositionSide::Short, Quantity::from(50), true)]
996    #[case(OrderSide::Buy, Quantity::from(50), PositionSide::Short, Quantity::from(100), true)]
997    #[case(OrderSide::Buy, Quantity::from(50), PositionSide::Flat, Quantity::from(0), false)]
998    #[case(OrderSide::Sell, Quantity::from(50), PositionSide::Flat, Quantity::from(0), false)]
999    #[case(OrderSide::Sell, Quantity::from(50), PositionSide::Long, Quantity::from(50), true)]
1000    #[case(OrderSide::Sell, Quantity::from(50), PositionSide::Long, Quantity::from(100), true)]
1001    #[case(OrderSide::Sell, Quantity::from(100), PositionSide::Short, Quantity::from(50), false)]
1002    fn test_would_reduce_only(
1003        #[case] order_side: OrderSide,
1004        #[case] order_qty: Quantity,
1005        #[case] position_side: PositionSide,
1006        #[case] position_qty: Quantity,
1007        #[case] expected: bool,
1008    ) {
1009        let order: MarketOrder = OrderInitializedBuilder::default()
1010            .order_side(order_side)
1011            .quantity(order_qty)
1012            .build()
1013            .unwrap()
1014            .into();
1015
1016        assert_eq!(
1017            order.would_reduce_only(position_side, position_qty),
1018            expected
1019        );
1020    }
1021
1022    #[rstest]
1023    fn test_order_state_transition_denied() {
1024        let mut order: MarketOrder = OrderInitializedBuilder::default().build().unwrap().into();
1025        let denied = OrderDeniedBuilder::default().build().unwrap();
1026        let event = OrderEventAny::Denied(denied);
1027
1028        order.apply(event.clone()).unwrap();
1029
1030        assert_eq!(order.status, OrderStatus::Denied);
1031        assert!(order.is_closed());
1032        assert!(!order.is_open());
1033        assert_eq!(order.event_count(), 2);
1034        assert_eq!(order.last_event(), &event);
1035    }
1036
1037    #[rstest]
1038    fn test_order_life_cycle_to_filled() {
1039        let init = OrderInitializedBuilder::default().build().unwrap();
1040        let submitted = OrderSubmittedBuilder::default().build().unwrap();
1041        let accepted = OrderAcceptedBuilder::default().build().unwrap();
1042        let filled = OrderFilledBuilder::default().build().unwrap();
1043
1044        let mut order: MarketOrder = init.clone().into();
1045        order.apply(OrderEventAny::Submitted(submitted)).unwrap();
1046        order.apply(OrderEventAny::Accepted(accepted)).unwrap();
1047        order.apply(OrderEventAny::Filled(filled)).unwrap();
1048
1049        assert_eq!(order.client_order_id, init.client_order_id);
1050        assert_eq!(order.status(), OrderStatus::Filled);
1051        assert_eq!(order.filled_qty(), Quantity::from(100_000));
1052        assert_eq!(order.leaves_qty(), Quantity::from(0));
1053        assert_eq!(order.avg_px(), Some(1.0));
1054        assert!(!order.is_open());
1055        assert!(order.is_closed());
1056        assert_eq!(order.commission(&Currency::USD()), None);
1057        assert_eq!(order.commissions(), &IndexMap::new());
1058    }
1059
1060    #[rstest]
1061    fn test_order_state_transition_to_canceled() {
1062        let mut order: MarketOrder = OrderInitializedBuilder::default().build().unwrap().into();
1063        let submitted = OrderSubmittedBuilder::default().build().unwrap();
1064        let canceled = OrderCanceledBuilder::default().build().unwrap();
1065
1066        order.apply(OrderEventAny::Submitted(submitted)).unwrap();
1067        order.apply(OrderEventAny::Canceled(canceled)).unwrap();
1068
1069        assert_eq!(order.status(), OrderStatus::Canceled);
1070        assert!(order.is_closed());
1071        assert!(!order.is_open());
1072    }
1073
1074    #[rstest]
1075    fn test_order_life_cycle_to_partially_filled() {
1076        let init = OrderInitializedBuilder::default().build().unwrap();
1077        let submitted = OrderSubmittedBuilder::default().build().unwrap();
1078        let accepted = OrderAcceptedBuilder::default().build().unwrap();
1079        let filled = OrderFilledBuilder::default()
1080            .last_qty(Quantity::from(50_000))
1081            .build()
1082            .unwrap();
1083
1084        let mut order: MarketOrder = init.clone().into();
1085        order.apply(OrderEventAny::Submitted(submitted)).unwrap();
1086        order.apply(OrderEventAny::Accepted(accepted)).unwrap();
1087        order.apply(OrderEventAny::Filled(filled)).unwrap();
1088
1089        assert_eq!(order.client_order_id, init.client_order_id);
1090        assert_eq!(order.status(), OrderStatus::PartiallyFilled);
1091        assert_eq!(order.filled_qty(), Quantity::from(50_000));
1092        assert_eq!(order.leaves_qty(), Quantity::from(50_000));
1093        assert!(order.is_open());
1094        assert!(!order.is_closed());
1095    }
1096
1097    #[rstest]
1098    fn test_order_commission_calculation() {
1099        let mut order: MarketOrder = OrderInitializedBuilder::default().build().unwrap().into();
1100        order
1101            .commissions
1102            .insert(Currency::USD(), Money::new(10.0, Currency::USD()));
1103
1104        assert_eq!(
1105            order.commission(&Currency::USD()),
1106            Some(Money::new(10.0, Currency::USD()))
1107        );
1108        assert_eq!(
1109            order.commissions_vec(),
1110            vec![Money::new(10.0, Currency::USD())]
1111        );
1112    }
1113
1114    #[rstest]
1115    fn test_order_is_primary() {
1116        let order: MarketOrder = OrderInitializedBuilder::default()
1117            .exec_algorithm_id(Some(ExecAlgorithmId::from("ALGO-001")))
1118            .exec_spawn_id(Some(ClientOrderId::from("O-001")))
1119            .client_order_id(ClientOrderId::from("O-001"))
1120            .build()
1121            .unwrap()
1122            .into();
1123
1124        assert!(order.is_primary());
1125        assert!(!order.is_spawned());
1126    }
1127
1128    #[rstest]
1129    fn test_order_is_spawned() {
1130        let order: MarketOrder = OrderInitializedBuilder::default()
1131            .exec_algorithm_id(Some(ExecAlgorithmId::from("ALGO-001")))
1132            .exec_spawn_id(Some(ClientOrderId::from("O-002")))
1133            .client_order_id(ClientOrderId::from("O-001"))
1134            .build()
1135            .unwrap()
1136            .into();
1137
1138        assert!(!order.is_primary());
1139        assert!(order.is_spawned());
1140    }
1141
1142    #[rstest]
1143    fn test_order_is_contingency() {
1144        let order: MarketOrder = OrderInitializedBuilder::default()
1145            .contingency_type(Some(ContingencyType::Oto))
1146            .build()
1147            .unwrap()
1148            .into();
1149
1150        assert!(order.is_contingency());
1151        assert!(order.is_parent_order());
1152        assert!(!order.is_child_order());
1153    }
1154
1155    #[rstest]
1156    fn test_order_is_child_order() {
1157        let order: MarketOrder = OrderInitializedBuilder::default()
1158            .parent_order_id(Some(ClientOrderId::from("PARENT-001")))
1159            .build()
1160            .unwrap()
1161            .into();
1162
1163        assert!(order.is_child_order());
1164        assert!(!order.is_parent_order());
1165    }
1166
1167    #[rstest]
1168    fn test_to_own_book_order_timestamp_ordering() {
1169        use crate::orders::limit::LimitOrder;
1170
1171        // Create order with distinct timestamps to verify parameter ordering
1172        let init = OrderInitializedBuilder::default()
1173            .price(Some(Price::from("100.00")))
1174            .build()
1175            .unwrap();
1176        let submitted = OrderSubmittedBuilder::default()
1177            .ts_event(UnixNanos::from(1_000_000))
1178            .build()
1179            .unwrap();
1180        let accepted = OrderAcceptedBuilder::default()
1181            .ts_event(UnixNanos::from(2_000_000))
1182            .build()
1183            .unwrap();
1184
1185        let mut order: LimitOrder = init.into();
1186        order.apply(OrderEventAny::Submitted(submitted)).unwrap();
1187        order.apply(OrderEventAny::Accepted(accepted)).unwrap();
1188
1189        let own_book_order = order.to_own_book_order();
1190
1191        // Verify timestamps are in correct positions
1192        assert_eq!(own_book_order.ts_submitted, UnixNanos::from(1_000_000));
1193        assert_eq!(own_book_order.ts_accepted, UnixNanos::from(2_000_000));
1194        assert_eq!(own_book_order.ts_last, UnixNanos::from(2_000_000));
1195    }
1196
1197    #[rstest]
1198    fn test_order_accepted_without_submitted_sets_account_id() {
1199        // Test external order flow: Initialized -> Accepted (no Submitted)
1200        let init = OrderInitializedBuilder::default().build().unwrap();
1201        let accepted = OrderAcceptedBuilder::default()
1202            .account_id(AccountId::from("EXTERNAL-001"))
1203            .build()
1204            .unwrap();
1205
1206        let mut order: MarketOrder = init.into();
1207
1208        // Verify account_id is initially None
1209        assert_eq!(order.account_id(), None);
1210
1211        // Apply accepted event directly (external order case)
1212        order.apply(OrderEventAny::Accepted(accepted)).unwrap();
1213
1214        // Verify account_id is now set from the accepted event
1215        assert_eq!(order.account_id(), Some(AccountId::from("EXTERNAL-001")));
1216        assert_eq!(order.status(), OrderStatus::Accepted);
1217    }
1218
1219    #[rstest]
1220    fn test_order_accepted_after_submitted_preserves_account_id() {
1221        // Test normal order flow: Initialized -> Submitted -> Accepted
1222        let init = OrderInitializedBuilder::default().build().unwrap();
1223        let submitted = OrderSubmittedBuilder::default()
1224            .account_id(AccountId::from("SUBMITTED-001"))
1225            .build()
1226            .unwrap();
1227        let accepted = OrderAcceptedBuilder::default()
1228            .account_id(AccountId::from("ACCEPTED-001"))
1229            .build()
1230            .unwrap();
1231
1232        let mut order: MarketOrder = init.into();
1233        order.apply(OrderEventAny::Submitted(submitted)).unwrap();
1234
1235        // After submitted, account_id should be set
1236        assert_eq!(order.account_id(), Some(AccountId::from("SUBMITTED-001")));
1237
1238        // Apply accepted event
1239        order.apply(OrderEventAny::Accepted(accepted)).unwrap();
1240
1241        // account_id should now be updated to the accepted event's account_id
1242        assert_eq!(order.account_id(), Some(AccountId::from("ACCEPTED-001")));
1243        assert_eq!(order.status(), OrderStatus::Accepted);
1244    }
1245
1246    #[rstest]
1247    fn test_overfill_tracks_overfill_qty() {
1248        // Test that overfill is tracked on the order
1249        let init = OrderInitializedBuilder::default()
1250            .quantity(Quantity::from(100_000))
1251            .build()
1252            .unwrap();
1253        let submitted = OrderSubmittedBuilder::default().build().unwrap();
1254        let accepted = OrderAcceptedBuilder::default().build().unwrap();
1255        let overfill = OrderFilledBuilder::default()
1256            .last_qty(Quantity::from(110_000)) // Overfill: 110k > 100k
1257            .build()
1258            .unwrap();
1259
1260        let mut order: MarketOrder = init.into();
1261        order.apply(OrderEventAny::Submitted(submitted)).unwrap();
1262        order.apply(OrderEventAny::Accepted(accepted)).unwrap();
1263        order.apply(OrderEventAny::Filled(overfill)).unwrap();
1264
1265        // Order should track overfill
1266        assert_eq!(order.overfill_qty(), Quantity::from(10_000));
1267        assert_eq!(order.filled_qty(), Quantity::from(110_000));
1268        assert_eq!(order.leaves_qty(), Quantity::from(0));
1269        assert_eq!(order.status(), OrderStatus::Filled);
1270    }
1271
1272    #[rstest]
1273    fn test_partial_fill_then_overfill() {
1274        // Test multiple fills resulting in overfill
1275        let init = OrderInitializedBuilder::default()
1276            .quantity(Quantity::from(100_000))
1277            .build()
1278            .unwrap();
1279        let submitted = OrderSubmittedBuilder::default().build().unwrap();
1280        let accepted = OrderAcceptedBuilder::default().build().unwrap();
1281        let fill1 = OrderFilledBuilder::default()
1282            .last_qty(Quantity::from(80_000))
1283            .trade_id(TradeId::from("TRADE-1"))
1284            .build()
1285            .unwrap();
1286        let fill2 = OrderFilledBuilder::default()
1287            .last_qty(Quantity::from(30_000)) // Total 110k > 100k
1288            .trade_id(TradeId::from("TRADE-2"))
1289            .build()
1290            .unwrap();
1291
1292        let mut order: MarketOrder = init.into();
1293        order.apply(OrderEventAny::Submitted(submitted)).unwrap();
1294        order.apply(OrderEventAny::Accepted(accepted)).unwrap();
1295        order.apply(OrderEventAny::Filled(fill1)).unwrap();
1296
1297        // After first fill, no overfill
1298        assert_eq!(order.overfill_qty(), Quantity::from(0));
1299        assert_eq!(order.filled_qty(), Quantity::from(80_000));
1300        assert_eq!(order.leaves_qty(), Quantity::from(20_000));
1301
1302        order.apply(OrderEventAny::Filled(fill2)).unwrap();
1303
1304        // After second fill, overfill detected
1305        assert_eq!(order.overfill_qty(), Quantity::from(10_000));
1306        assert_eq!(order.filled_qty(), Quantity::from(110_000));
1307        assert_eq!(order.leaves_qty(), Quantity::from(0));
1308        assert_eq!(order.status(), OrderStatus::Filled);
1309    }
1310
1311    #[rstest]
1312    fn test_exact_fill_no_overfill() {
1313        // Test that exact fill doesn't trigger overfill tracking
1314        let init = OrderInitializedBuilder::default()
1315            .quantity(Quantity::from(100_000))
1316            .build()
1317            .unwrap();
1318        let submitted = OrderSubmittedBuilder::default().build().unwrap();
1319        let accepted = OrderAcceptedBuilder::default().build().unwrap();
1320        let filled = OrderFilledBuilder::default()
1321            .last_qty(Quantity::from(100_000)) // Exact fill
1322            .build()
1323            .unwrap();
1324
1325        let mut order: MarketOrder = init.into();
1326        order.apply(OrderEventAny::Submitted(submitted)).unwrap();
1327        order.apply(OrderEventAny::Accepted(accepted)).unwrap();
1328        order.apply(OrderEventAny::Filled(filled)).unwrap();
1329
1330        // No overfill
1331        assert_eq!(order.overfill_qty(), Quantity::from(0));
1332        assert_eq!(order.filled_qty(), Quantity::from(100_000));
1333        assert_eq!(order.leaves_qty(), Quantity::from(0));
1334    }
1335
1336    #[rstest]
1337    fn test_partial_fill_then_overfill_with_fractional_quantities() {
1338        // Simulates real exchange scenario with fractional fills:
1339        // Order for 2450.5 units, partially filled 1202.5, then fill of 1285.5 arrives
1340        // Total filled: 2488.0, overfill: 37.5
1341        let init = OrderInitializedBuilder::default()
1342            .quantity(Quantity::from("2450.5"))
1343            .build()
1344            .unwrap();
1345        let submitted = OrderSubmittedBuilder::default().build().unwrap();
1346        let accepted = OrderAcceptedBuilder::default().build().unwrap();
1347        let fill1 = OrderFilledBuilder::default()
1348            .last_qty(Quantity::from("1202.5"))
1349            .trade_id(TradeId::from("TRADE-1"))
1350            .build()
1351            .unwrap();
1352        let fill2 = OrderFilledBuilder::default()
1353            .last_qty(Quantity::from("1285.5")) // 1202.5 + 1285.5 = 2488 > 2450.5
1354            .trade_id(TradeId::from("TRADE-2"))
1355            .build()
1356            .unwrap();
1357
1358        let mut order: MarketOrder = init.into();
1359        order.apply(OrderEventAny::Submitted(submitted)).unwrap();
1360        order.apply(OrderEventAny::Accepted(accepted)).unwrap();
1361        order.apply(OrderEventAny::Filled(fill1)).unwrap();
1362
1363        // After first fill, no overfill
1364        assert_eq!(order.overfill_qty(), Quantity::from(0));
1365        assert_eq!(order.filled_qty(), Quantity::from("1202.5"));
1366        assert_eq!(order.leaves_qty(), Quantity::from("1248.0"));
1367        assert_eq!(order.status(), OrderStatus::PartiallyFilled);
1368
1369        order.apply(OrderEventAny::Filled(fill2)).unwrap();
1370
1371        // After second fill, overfill detected and tracked
1372        assert_eq!(order.overfill_qty(), Quantity::from("37.5"));
1373        assert_eq!(order.filled_qty(), Quantity::from("2488.0"));
1374        assert_eq!(order.leaves_qty(), Quantity::from(0));
1375        assert_eq!(order.status(), OrderStatus::Filled);
1376    }
1377
1378    #[rstest]
1379    fn test_calculate_overfill_returns_zero_when_no_overfill() {
1380        let order: MarketOrder = OrderInitializedBuilder::default()
1381            .quantity(Quantity::from(100_000))
1382            .build()
1383            .unwrap()
1384            .into();
1385
1386        // Fill qty less than order qty - no overfill
1387        let overfill = order.calculate_overfill(Quantity::from(50_000));
1388        assert_eq!(overfill, Quantity::from(0));
1389
1390        // Fill qty equals order qty - no overfill
1391        let overfill = order.calculate_overfill(Quantity::from(100_000));
1392        assert_eq!(overfill, Quantity::from(0));
1393    }
1394
1395    #[rstest]
1396    fn test_calculate_overfill_returns_overfill_amount() {
1397        let order: MarketOrder = OrderInitializedBuilder::default()
1398            .quantity(Quantity::from(100_000))
1399            .build()
1400            .unwrap()
1401            .into();
1402
1403        // Fill qty exceeds order qty
1404        let overfill = order.calculate_overfill(Quantity::from(110_000));
1405        assert_eq!(overfill, Quantity::from(10_000));
1406    }
1407
1408    #[rstest]
1409    fn test_calculate_overfill_accounts_for_existing_fills() {
1410        let init = OrderInitializedBuilder::default()
1411            .quantity(Quantity::from(100_000))
1412            .build()
1413            .unwrap();
1414        let submitted = OrderSubmittedBuilder::default().build().unwrap();
1415        let accepted = OrderAcceptedBuilder::default().build().unwrap();
1416        let partial_fill = OrderFilledBuilder::default()
1417            .last_qty(Quantity::from(60_000))
1418            .build()
1419            .unwrap();
1420
1421        let mut order: MarketOrder = init.into();
1422        order.apply(OrderEventAny::Submitted(submitted)).unwrap();
1423        order.apply(OrderEventAny::Accepted(accepted)).unwrap();
1424        order.apply(OrderEventAny::Filled(partial_fill)).unwrap();
1425
1426        // Order is 60k filled, 40k remaining
1427        // Fill of 50k would overfill by 10k
1428        let overfill = order.calculate_overfill(Quantity::from(50_000));
1429        assert_eq!(overfill, Quantity::from(10_000));
1430
1431        // Fill of 40k would not overfill
1432        let overfill = order.calculate_overfill(Quantity::from(40_000));
1433        assert_eq!(overfill, Quantity::from(0));
1434    }
1435
1436    #[rstest]
1437    fn test_calculate_overfill_with_fractional_quantities() {
1438        let order: MarketOrder = OrderInitializedBuilder::default()
1439            .quantity(Quantity::from("2450.5"))
1440            .build()
1441            .unwrap()
1442            .into();
1443
1444        // Simulates the exact scenario from user's log
1445        // Order for 2450.5, if fill of 2488.0 arrives
1446        let overfill = order.calculate_overfill(Quantity::from("2488.0"));
1447        assert_eq!(overfill, Quantity::from("37.5"));
1448    }
1449
1450    #[rstest]
1451    fn test_duplicate_fill_rejected() {
1452        let init = OrderInitializedBuilder::default()
1453            .quantity(Quantity::from(100_000))
1454            .build()
1455            .unwrap();
1456        let submitted = OrderSubmittedBuilder::default().build().unwrap();
1457        let accepted = OrderAcceptedBuilder::default().build().unwrap();
1458        let fill1 = OrderFilledBuilder::default()
1459            .last_qty(Quantity::from(50_000))
1460            .trade_id(TradeId::from("TRADE-001"))
1461            .build()
1462            .unwrap();
1463        let fill2_duplicate = OrderFilledBuilder::default()
1464            .last_qty(Quantity::from(50_000))
1465            .trade_id(TradeId::from("TRADE-001")) // Same trade_id as fill1
1466            .build()
1467            .unwrap();
1468
1469        let mut order: MarketOrder = init.into();
1470        order.apply(OrderEventAny::Submitted(submitted)).unwrap();
1471        order.apply(OrderEventAny::Accepted(accepted)).unwrap();
1472        order.apply(OrderEventAny::Filled(fill1)).unwrap();
1473
1474        // Verify first fill applied successfully
1475        assert_eq!(order.filled_qty(), Quantity::from(50_000));
1476        assert_eq!(order.status(), OrderStatus::PartiallyFilled);
1477
1478        // Applying duplicate fill should return DuplicateFill error
1479        let result = order.apply(OrderEventAny::Filled(fill2_duplicate));
1480        assert!(result.is_err());
1481        match result.unwrap_err() {
1482            OrderError::DuplicateFill(trade_id) => {
1483                assert_eq!(trade_id, TradeId::from("TRADE-001"));
1484            }
1485            e => panic!("Expected DuplicateFill error, got: {e:?}"),
1486        }
1487
1488        // Order state should be unchanged after rejected duplicate
1489        assert_eq!(order.filled_qty(), Quantity::from(50_000));
1490        assert_eq!(order.status(), OrderStatus::PartiallyFilled);
1491    }
1492
1493    #[rstest]
1494    fn test_different_trade_ids_allowed() {
1495        let init = OrderInitializedBuilder::default()
1496            .quantity(Quantity::from(100_000))
1497            .build()
1498            .unwrap();
1499        let submitted = OrderSubmittedBuilder::default().build().unwrap();
1500        let accepted = OrderAcceptedBuilder::default().build().unwrap();
1501        let fill1 = OrderFilledBuilder::default()
1502            .last_qty(Quantity::from(50_000))
1503            .trade_id(TradeId::from("TRADE-001"))
1504            .build()
1505            .unwrap();
1506        let fill2 = OrderFilledBuilder::default()
1507            .last_qty(Quantity::from(50_000))
1508            .trade_id(TradeId::from("TRADE-002")) // Different trade_id
1509            .build()
1510            .unwrap();
1511
1512        let mut order: MarketOrder = init.into();
1513        order.apply(OrderEventAny::Submitted(submitted)).unwrap();
1514        order.apply(OrderEventAny::Accepted(accepted)).unwrap();
1515        order.apply(OrderEventAny::Filled(fill1)).unwrap();
1516        order.apply(OrderEventAny::Filled(fill2)).unwrap();
1517
1518        // Both fills should be applied
1519        assert_eq!(order.filled_qty(), Quantity::from(100_000));
1520        assert_eq!(order.status(), OrderStatus::Filled);
1521        assert_eq!(order.trade_ids.len(), 2);
1522    }
1523
1524    #[rstest]
1525    fn test_partially_filled_order_can_be_updated() {
1526        // Test that a partially filled order can receive an Updated event
1527        // and remain in PartiallyFilled status
1528        let init = OrderInitializedBuilder::default()
1529            .quantity(Quantity::from(100_000))
1530            .build()
1531            .unwrap();
1532        let submitted = OrderSubmittedBuilder::default().build().unwrap();
1533        let accepted = OrderAcceptedBuilder::default().build().unwrap();
1534        let partial_fill = OrderFilledBuilder::default()
1535            .last_qty(Quantity::from(40_000))
1536            .build()
1537            .unwrap();
1538        let updated = OrderUpdatedBuilder::default()
1539            .quantity(Quantity::from(80_000)) // Reduce to 80k (still > 40k filled)
1540            .build()
1541            .unwrap();
1542
1543        let mut order: MarketOrder = init.into();
1544        order.apply(OrderEventAny::Submitted(submitted)).unwrap();
1545        order.apply(OrderEventAny::Accepted(accepted)).unwrap();
1546        order.apply(OrderEventAny::Filled(partial_fill)).unwrap();
1547
1548        assert_eq!(order.status(), OrderStatus::PartiallyFilled);
1549        assert_eq!(order.filled_qty(), Quantity::from(40_000));
1550
1551        order.apply(OrderEventAny::Updated(updated)).unwrap();
1552
1553        assert_eq!(order.status(), OrderStatus::PartiallyFilled);
1554        assert_eq!(order.quantity(), Quantity::from(80_000));
1555        assert_eq!(order.leaves_qty(), Quantity::from(40_000)); // 80k - 40k filled
1556    }
1557
1558    #[rstest]
1559    fn test_triggered_order_can_be_updated() {
1560        // Test that a triggered order can receive an Updated event
1561        // and remain in Triggered status
1562        let init = OrderInitializedBuilder::default()
1563            .quantity(Quantity::from(100_000))
1564            .build()
1565            .unwrap();
1566        let submitted = OrderSubmittedBuilder::default().build().unwrap();
1567        let accepted = OrderAcceptedBuilder::default().build().unwrap();
1568        let triggered = OrderTriggeredBuilder::default().build().unwrap();
1569        let updated = OrderUpdatedBuilder::default()
1570            .quantity(Quantity::from(80_000))
1571            .build()
1572            .unwrap();
1573
1574        let mut order: MarketOrder = init.into();
1575        order.apply(OrderEventAny::Submitted(submitted)).unwrap();
1576        order.apply(OrderEventAny::Accepted(accepted)).unwrap();
1577        order.apply(OrderEventAny::Triggered(triggered)).unwrap();
1578
1579        assert_eq!(order.status(), OrderStatus::Triggered);
1580
1581        order.apply(OrderEventAny::Updated(updated)).unwrap();
1582
1583        assert_eq!(order.status(), OrderStatus::Triggered);
1584        assert_eq!(order.quantity(), Quantity::from(80_000));
1585    }
1586}
nautilus_model/orders/mod.rs

nautilus_model/orders/
mod.rs
