Skip to main content

nautilus_model/orders/
any.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
16use std::fmt::Display;
17
18use enum_dispatch::enum_dispatch;
19use serde::{Deserialize, Serialize};
20use thiserror::Error;
21
22use super::{
23    Order, OrderCore, OrderError, limit::LimitOrder, limit_if_touched::LimitIfTouchedOrder,
24    market::MarketOrder, market_if_touched::MarketIfTouchedOrder,
25    market_to_limit::MarketToLimitOrder, stop_limit::StopLimitOrder, stop_market::StopMarketOrder,
26    trailing_stop_limit::TrailingStopLimitOrder, trailing_stop_market::TrailingStopMarketOrder,
27};
28use crate::{events::OrderEventAny, identifiers::OrderListId, types::Price};
29
30/// Error returned when [`OrderAny::from_events`] cannot replay order events.
31#[derive(Debug, Error)]
32pub enum OrderReplayError {
33    /// No events were supplied.
34    #[error("No order events provided to create OrderAny")]
35    EmptyInput,
36    /// The first event was not an initialization event.
37    #[error("First event must be `OrderInitialized`")]
38    WrongFirstEvent,
39    /// The initialization event could not be converted into an order.
40    #[error("Invalid `OrderInitialized` event: {source}")]
41    InvalidInitialization {
42        /// The source order conversion error.
43        #[source]
44        source: OrderError,
45    },
46    /// A later event could not be applied to the initialized order.
47    #[error("{source}")]
48    ApplyFailed {
49        /// The source event application error.
50        #[source]
51        source: OrderError,
52    },
53}
54
55#[derive(Clone, Debug, Serialize, Deserialize)]
56#[enum_dispatch(Order)]
57pub enum OrderAny {
58    Limit(LimitOrder),
59    LimitIfTouched(LimitIfTouchedOrder),
60    Market(MarketOrder),
61    MarketIfTouched(MarketIfTouchedOrder),
62    MarketToLimit(MarketToLimitOrder),
63    StopLimit(StopLimitOrder),
64    StopMarket(StopMarketOrder),
65    TrailingStopLimit(TrailingStopLimitOrder),
66    TrailingStopMarket(TrailingStopMarketOrder),
67}
68
69impl OrderAny {
70    /// Creates a new [`OrderAny`] instance from the given `events`.
71    ///
72    /// # Errors
73    ///
74    /// Returns an error if:
75    /// - The `events` is empty.
76    /// - The first event is not `OrderInitialized`.
77    /// - The initialization event violates an order invariant
78    ///   (e.g. missing required price/trigger fields, invalid quantity, invalid TIF/expire combo).
79    /// - Any subsequent event has an invalid state transition when applied to the order.
80    pub fn from_events(events: Vec<OrderEventAny>) -> Result<Self, OrderReplayError> {
81        let Some(init_event) = events.first() else {
82            return Err(OrderReplayError::EmptyInput);
83        };
84
85        let OrderEventAny::Initialized(init) = init_event else {
86            return Err(OrderReplayError::WrongFirstEvent);
87        };
88
89        let mut order = Self::try_from(init.clone())
90            .map_err(|source| OrderReplayError::InvalidInitialization { source })?;
91
92        for event in events.into_iter().skip(1) {
93            order
94                .apply(event)
95                .map_err(|source| OrderReplayError::ApplyFailed { source })?;
96        }
97
98        Ok(order)
99    }
100
101    /// Returns a reference to the [`crate::events::OrderInitialized`] event.
102    ///
103    /// This is always the first event in the order's event list (invariant).
104    ///
105    /// # Panics
106    ///
107    /// Panics if the first event is not `OrderInitialized` (violates invariant).
108    #[must_use]
109    pub fn init_event(&self) -> &crate::events::OrderInitialized {
110        match self
111            .events()
112            .first()
113            .expect("Order invariant violated: no events")
114        {
115            OrderEventAny::Initialized(init) => init,
116            _ => panic!("Order invariant violated: first event must be OrderInitialized"),
117        }
118    }
119
120    /// Returns whether standalone venue fills determine this synthetic order's quantity.
121    ///
122    /// Each distinct fill can increase the quantity, including after the order is filled.
123    /// Requires a never-submitted market order that reconciliation initialized with
124    /// [`super::FILL_REPORT_ORDER_TAG`]; a user tag alone does not qualify.
125    #[must_use]
126    pub fn is_fill_report_order(&self) -> bool {
127        matches!(self, Self::Market(order) if order.is_fill_report_order())
128    }
129
130    /// Assigns the order to the list identified by `id`.
131    ///
132    /// # Panics
133    ///
134    /// Panics if the order has no events or its first event is not `OrderInitialized`.
135    pub fn set_order_list_id(&mut self, id: OrderListId) {
136        let order: &mut OrderCore = match self {
137            Self::Limit(order) => order,
138            Self::LimitIfTouched(order) => order,
139            Self::Market(order) => order,
140            Self::MarketIfTouched(order) => order,
141            Self::MarketToLimit(order) => order,
142            Self::StopLimit(order) => order,
143            Self::StopMarket(order) => order,
144            Self::TrailingStopLimit(order) => order,
145            Self::TrailingStopMarket(order) => order,
146        };
147        let init = match order
148            .events
149            .first_mut()
150            .expect("Order invariant violated: no events")
151        {
152            OrderEventAny::Initialized(init) => init,
153            _ => panic!("Order invariant violated: first event must be OrderInitialized"),
154        };
155
156        order.order_list_id = Some(id);
157        init.order_list_id = Some(id);
158    }
159}
160
161impl PartialEq for OrderAny {
162    fn eq(&self, other: &Self) -> bool {
163        self.client_order_id() == other.client_order_id()
164    }
165}
166
167// TODO: fix equality
168impl Eq for OrderAny {}
169
170impl Display for OrderAny {
171    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
172        write!(
173            f,
174            "{}",
175            match self {
176                Self::Limit(order) => order.to_string(),
177                Self::LimitIfTouched(order) => order.to_string(),
178                Self::Market(order) => order.to_string(),
179                Self::MarketIfTouched(order) => order.to_string(),
180                Self::MarketToLimit(order) => order.to_string(),
181                Self::StopLimit(order) => order.to_string(),
182                Self::StopMarket(order) => order.to_string(),
183                Self::TrailingStopLimit(order) => order.to_string(),
184                Self::TrailingStopMarket(order) => order.to_string(),
185            }
186        )
187    }
188}
189
190impl TryFrom<OrderAny> for PassiveOrderAny {
191    type Error = String;
192
193    fn try_from(order: OrderAny) -> Result<Self, Self::Error> {
194        match order {
195            OrderAny::Limit(_) => Ok(Self::Limit(LimitOrderAny::try_from(order)?)),
196            OrderAny::LimitIfTouched(_) => Ok(Self::Stop(StopOrderAny::try_from(order)?)),
197            OrderAny::MarketIfTouched(_) => Ok(Self::Stop(StopOrderAny::try_from(order)?)),
198            OrderAny::StopLimit(_) => Ok(Self::Stop(StopOrderAny::try_from(order)?)),
199            OrderAny::StopMarket(_) => Ok(Self::Stop(StopOrderAny::try_from(order)?)),
200            OrderAny::TrailingStopLimit(_) => Ok(Self::Stop(StopOrderAny::try_from(order)?)),
201            OrderAny::TrailingStopMarket(_) => Ok(Self::Stop(StopOrderAny::try_from(order)?)),
202            OrderAny::MarketToLimit(_) => Ok(Self::Limit(LimitOrderAny::try_from(order)?)),
203            OrderAny::Market(_) => Ok(Self::Limit(LimitOrderAny::try_from(order)?)),
204        }
205    }
206}
207
208impl From<PassiveOrderAny> for OrderAny {
209    fn from(order: PassiveOrderAny) -> Self {
210        match order {
211            PassiveOrderAny::Limit(order) => order.into(),
212            PassiveOrderAny::Stop(order) => order.into(),
213        }
214    }
215}
216
217impl TryFrom<OrderAny> for StopOrderAny {
218    type Error = String;
219
220    fn try_from(order: OrderAny) -> Result<Self, Self::Error> {
221        match order {
222            OrderAny::LimitIfTouched(order) => Ok(Self::LimitIfTouched(order)),
223            OrderAny::MarketIfTouched(order) => Ok(Self::MarketIfTouched(order)),
224            OrderAny::StopLimit(order) => Ok(Self::StopLimit(order)),
225            OrderAny::StopMarket(order) => Ok(Self::StopMarket(order)),
226            OrderAny::TrailingStopLimit(order) => Ok(Self::TrailingStopLimit(order)),
227            OrderAny::TrailingStopMarket(order) => Ok(Self::TrailingStopMarket(order)),
228            _ => Err(format!(
229                "Cannot convert {:?} order to StopOrderAny: order type does not have a stop/trigger price",
230                order.order_type()
231            )),
232        }
233    }
234}
235
236impl From<StopOrderAny> for OrderAny {
237    fn from(order: StopOrderAny) -> Self {
238        match order {
239            StopOrderAny::LimitIfTouched(order) => Self::LimitIfTouched(order),
240            StopOrderAny::MarketIfTouched(order) => Self::MarketIfTouched(order),
241            StopOrderAny::StopLimit(order) => Self::StopLimit(order),
242            StopOrderAny::StopMarket(order) => Self::StopMarket(order),
243            StopOrderAny::TrailingStopLimit(order) => Self::TrailingStopLimit(order),
244            StopOrderAny::TrailingStopMarket(order) => Self::TrailingStopMarket(order),
245        }
246    }
247}
248
249impl TryFrom<OrderAny> for LimitOrderAny {
250    type Error = String;
251
252    fn try_from(order: OrderAny) -> Result<Self, Self::Error> {
253        match order {
254            OrderAny::Limit(order) => Ok(Self::Limit(order)),
255            OrderAny::MarketToLimit(order) => Ok(Self::MarketToLimit(order)),
256            OrderAny::StopLimit(order) => Ok(Self::StopLimit(order)),
257            OrderAny::TrailingStopLimit(order) => Ok(Self::TrailingStopLimit(order)),
258            OrderAny::Market(order) => Ok(Self::MarketOrderWithProtection(order)),
259            _ => Err(format!(
260                "Cannot convert {:?} order to LimitOrderAny: order type does not have a limit price",
261                order.order_type()
262            )),
263        }
264    }
265}
266
267impl From<LimitOrderAny> for OrderAny {
268    fn from(order: LimitOrderAny) -> Self {
269        match order {
270            LimitOrderAny::Limit(order) => Self::Limit(order),
271            LimitOrderAny::MarketToLimit(order) => Self::MarketToLimit(order),
272            LimitOrderAny::StopLimit(order) => Self::StopLimit(order),
273            LimitOrderAny::TrailingStopLimit(order) => Self::TrailingStopLimit(order),
274            LimitOrderAny::MarketOrderWithProtection(order) => Self::Market(order),
275        }
276    }
277}
278
279#[derive(Clone, Debug)]
280#[enum_dispatch(Order)]
281pub enum PassiveOrderAny {
282    Limit(LimitOrderAny),
283    Stop(StopOrderAny),
284}
285
286impl PassiveOrderAny {
287    #[must_use]
288    pub fn to_any(&self) -> OrderAny {
289        match self {
290            Self::Limit(order) => order.clone().into(),
291            Self::Stop(order) => order.clone().into(),
292        }
293    }
294}
295
296// TODO: Derive equality
297impl PartialEq for PassiveOrderAny {
298    fn eq(&self, rhs: &Self) -> bool {
299        match self {
300            Self::Limit(order) => order.client_order_id() == rhs.client_order_id(),
301            Self::Stop(order) => order.client_order_id() == rhs.client_order_id(),
302        }
303    }
304}
305
306#[derive(Clone, Debug)]
307#[enum_dispatch(Order)]
308pub enum LimitOrderAny {
309    Limit(LimitOrder),
310    MarketToLimit(MarketToLimitOrder),
311    StopLimit(StopLimitOrder),
312    TrailingStopLimit(TrailingStopLimitOrder),
313    MarketOrderWithProtection(MarketOrder),
314}
315
316impl LimitOrderAny {
317    /// Returns the limit price for this order.
318    ///
319    /// # Panics
320    ///
321    /// Panics if the `MarketToLimit` order price is not set.
322    #[must_use]
323    pub fn limit_px(&self) -> Price {
324        match self {
325            Self::Limit(order) => order.price,
326            Self::MarketToLimit(order) => order.price.expect("MarketToLimit order price not set"),
327            Self::StopLimit(order) => order.price,
328            Self::TrailingStopLimit(order) => {
329                order.price.expect("TrailingStopLimit order price not set")
330            }
331            Self::MarketOrderWithProtection(order) => {
332                order.protection_price.expect("No price for order")
333            }
334        }
335    }
336}
337
338impl PartialEq for LimitOrderAny {
339    fn eq(&self, rhs: &Self) -> bool {
340        match self {
341            Self::Limit(order) => order.client_order_id == rhs.client_order_id(),
342            Self::MarketToLimit(order) => order.client_order_id == rhs.client_order_id(),
343            Self::StopLimit(order) => order.client_order_id == rhs.client_order_id(),
344            Self::TrailingStopLimit(order) => order.client_order_id == rhs.client_order_id(),
345            Self::MarketOrderWithProtection(order) => {
346                order.client_order_id == rhs.client_order_id()
347            }
348        }
349    }
350}
351
352#[derive(Clone, Debug)]
353#[enum_dispatch(Order)]
354pub enum StopOrderAny {
355    LimitIfTouched(LimitIfTouchedOrder),
356    MarketIfTouched(MarketIfTouchedOrder),
357    StopLimit(StopLimitOrder),
358    StopMarket(StopMarketOrder),
359    TrailingStopLimit(TrailingStopLimitOrder),
360    TrailingStopMarket(TrailingStopMarketOrder),
361}
362
363impl StopOrderAny {
364    #[must_use]
365    pub fn stop_px(&self) -> Option<Price> {
366        match self {
367            Self::LimitIfTouched(o) => Some(o.trigger_price),
368            Self::MarketIfTouched(o) => Some(o.trigger_price),
369            Self::StopLimit(o) => Some(o.trigger_price),
370            Self::StopMarket(o) => Some(o.trigger_price),
371            Self::TrailingStopLimit(o) => o.activation_price.or(o.trigger_price),
372            Self::TrailingStopMarket(o) => o.activation_price.or(o.trigger_price),
373        }
374    }
375}
376
377// TODO: Derive equality
378impl PartialEq for StopOrderAny {
379    fn eq(&self, rhs: &Self) -> bool {
380        match self {
381            Self::LimitIfTouched(order) => order.client_order_id == rhs.client_order_id(),
382            Self::StopLimit(order) => order.client_order_id == rhs.client_order_id(),
383            Self::StopMarket(order) => order.client_order_id == rhs.client_order_id(),
384            Self::MarketIfTouched(order) => order.client_order_id == rhs.client_order_id(),
385            Self::TrailingStopLimit(order) => order.client_order_id == rhs.client_order_id(),
386            Self::TrailingStopMarket(order) => order.client_order_id == rhs.client_order_id(),
387        }
388    }
389}
390
391#[cfg(test)]
392mod tests {
393    use nautilus_core::{UUID4, UnixNanos};
394    use rstest::rstest;
395    use rust_decimal::Decimal;
396    use rust_decimal_macros::dec;
397
398    use super::*;
399    use crate::{
400        enums::{OrderSide, OrderType, TrailingOffsetType, TriggerType},
401        events::{
402            OrderEventAny, OrderInitialized, OrderUpdated, order::spec::OrderInitializedSpec,
403        },
404        identifiers::{ClientOrderId, InstrumentId, StrategyId},
405        orders::{OrderError, builder::OrderTestBuilder},
406        types::{Price, Quantity},
407    };
408
409    #[rstest]
410    #[should_panic(expected = "Order invariant violated: first event must be OrderInitialized")]
411    fn test_init_event_panics_when_first_event_is_not_initialized() {
412        let mut order = OrderTestBuilder::new(OrderType::Market)
413            .instrument_id(InstrumentId::from("BTC-USDT.BINANCE"))
414            .quantity(Quantity::from(10))
415            .build();
416
417        let OrderAny::Market(inner) = &mut order else {
418            panic!("expected a market order");
419        };
420
421        inner.events[0] =
422            OrderEventAny::Denied(crate::events::order::spec::OrderDeniedSpec::builder().build());
423
424        let _ = order.init_event();
425    }
426
427    #[rstest]
428    fn test_order_any_equality() {
429        // Create two orders with different types but same client_order_id
430        let client_order_id = ClientOrderId::from("ORDER-001");
431
432        let market_order = OrderTestBuilder::new(OrderType::Market)
433            .instrument_id(InstrumentId::from("BTC-USDT.BINANCE"))
434            .quantity(Quantity::from(10))
435            .client_order_id(client_order_id)
436            .build();
437
438        let limit_order = OrderTestBuilder::new(OrderType::Limit)
439            .instrument_id(InstrumentId::from("BTC-USDT.BINANCE"))
440            .quantity(Quantity::from(10))
441            .price(Price::new(100.0, 2))
442            .client_order_id(client_order_id)
443            .build();
444
445        // They should be equal because they have the same client_order_id
446        assert_eq!(market_order, limit_order);
447    }
448
449    #[rstest]
450    fn test_order_any_conversion_from_events() {
451        // Create an OrderInitialized event
452        let init_event = OrderInitializedSpec::builder()
453            .order_type(OrderType::Market)
454            .instrument_id(InstrumentId::from("BTC-USDT.BINANCE"))
455            .quantity(Quantity::from(10))
456            .build();
457
458        // Create a vector of events
459        let events = vec![OrderEventAny::Initialized(init_event.clone())];
460
461        // Create OrderAny from events
462        let order = OrderAny::from_events(events).unwrap();
463
464        // Verify the order was created properly
465        assert_eq!(order.order_type(), OrderType::Market);
466        assert_eq!(order.instrument_id(), init_event.instrument_id);
467        assert_eq!(order.quantity(), init_event.quantity);
468    }
469
470    #[rstest]
471    #[case::limit(OrderType::Limit)]
472    #[case::limit_if_touched(OrderType::LimitIfTouched)]
473    #[case::market(OrderType::Market)]
474    #[case::market_if_touched(OrderType::MarketIfTouched)]
475    #[case::market_to_limit(OrderType::MarketToLimit)]
476    #[case::stop_limit(OrderType::StopLimit)]
477    #[case::stop_market(OrderType::StopMarket)]
478    #[case::trailing_stop_limit(OrderType::TrailingStopLimit)]
479    #[case::trailing_stop_market(OrderType::TrailingStopMarket)]
480    fn test_set_order_list_id_updates_init_event_and_replay(#[case] order_type: OrderType) {
481        let mut order = order_for_list_id_test(order_type);
482        let init_before = order.init_event().clone();
483        let event_count = order.event_count();
484        let order_list_id = OrderListId::from("OL-SET-LIST-001");
485
486        order.set_order_list_id(order_list_id);
487
488        let mut expected_init = init_before;
489        expected_init.order_list_id = Some(order_list_id);
490        assert_eq!(order.order_list_id(), Some(order_list_id));
491        assert_eq!(order.init_event(), &expected_init);
492        assert_eq!(order.event_count(), event_count);
493
494        let persisted_events: Vec<_> = order.events().into_iter().cloned().collect();
495        assert_eq!(
496            persisted_events,
497            vec![OrderEventAny::Initialized(expected_init.clone())]
498        );
499
500        let replayed = OrderAny::from_events(persisted_events).unwrap();
501        assert_eq!(replayed.order_list_id(), Some(order_list_id));
502        assert_eq!(replayed.init_event(), &expected_init);
503    }
504
505    #[rstest]
506    #[case::limit(OrderType::Limit)]
507    #[case::limit_if_touched(OrderType::LimitIfTouched)]
508    #[case::market(OrderType::Market)]
509    #[case::market_if_touched(OrderType::MarketIfTouched)]
510    #[case::market_to_limit(OrderType::MarketToLimit)]
511    #[case::stop_limit(OrderType::StopLimit)]
512    #[case::stop_market(OrderType::StopMarket)]
513    #[case::trailing_stop_limit(OrderType::TrailingStopLimit)]
514    #[case::trailing_stop_market(OrderType::TrailingStopMarket)]
515    fn test_order_any_from_events_preserves_init_metadata(
516        #[case] order_type: OrderType,
517        #[values(false, true)] reconciliation: bool,
518        #[values(None, Some(UUID4::from("775e3ce7-e768-43ad-859a-14b42d8a4ab0")))]
519        causation_id: Option<UUID4>,
520    ) {
521        let mut init = order_for_list_id_test(order_type).init_event().clone();
522        init.ts_init = UnixNanos::from(987_654_321);
523        init.reconciliation = reconciliation;
524        init.causation_id = causation_id;
525
526        let converted = OrderAny::try_from(init.clone()).unwrap();
527        let order = OrderAny::from_events(vec![OrderEventAny::Initialized(init.clone())]).unwrap();
528
529        assert_eq!(converted.init_event(), &init);
530        assert_eq!(order.init_event(), &init);
531        assert_eq!(converted.ts_init(), init.ts_event);
532        assert_eq!(order.ts_init(), init.ts_event);
533        assert_eq!(converted.ts_last(), init.ts_event);
534        assert_eq!(order.ts_last(), init.ts_event);
535    }
536
537    fn assert_last_event_views(order: &OrderAny) {
538        fn generic_last_event<T: Order + ?Sized>(order: &T) -> &OrderEventAny {
539            order.last_event()
540        }
541
542        let events = order.events();
543        let expected = *events.last().unwrap();
544        assert!(std::ptr::eq(order.last_event(), expected));
545        assert!(std::ptr::eq(generic_last_event(order), expected));
546
547        let concrete: &dyn Order = match order {
548            OrderAny::Limit(order) => order,
549            OrderAny::LimitIfTouched(order) => order,
550            OrderAny::Market(order) => order,
551            OrderAny::MarketIfTouched(order) => order,
552            OrderAny::MarketToLimit(order) => order,
553            OrderAny::StopLimit(order) => order,
554            OrderAny::StopMarket(order) => order,
555            OrderAny::TrailingStopLimit(order) => order,
556            OrderAny::TrailingStopMarket(order) => order,
557        };
558        assert!(std::ptr::eq(concrete.last_event(), expected));
559    }
560
561    #[rstest]
562    #[case::limit(OrderType::Limit)]
563    #[case::limit_if_touched(OrderType::LimitIfTouched)]
564    #[case::market(OrderType::Market)]
565    #[case::market_if_touched(OrderType::MarketIfTouched)]
566    #[case::market_to_limit(OrderType::MarketToLimit)]
567    #[case::stop_limit(OrderType::StopLimit)]
568    #[case::stop_market(OrderType::StopMarket)]
569    #[case::trailing_stop_limit(OrderType::TrailingStopLimit)]
570    #[case::trailing_stop_market(OrderType::TrailingStopMarket)]
571    fn test_last_event_borrows_latest_native_event(#[case] order_type: OrderType) {
572        let mut order = order_for_list_id_test(order_type);
573        assert_last_event_views(&order);
574
575        let denied = crate::events::OrderDenied::new(
576            order.trader_id(),
577            order.strategy_id(),
578            order.instrument_id(),
579            order.client_order_id(),
580            "Risk denied".into(),
581            UUID4::new(),
582            UnixNanos::from(1),
583            UnixNanos::from(1),
584        );
585        order.apply(OrderEventAny::Denied(denied)).unwrap();
586        assert_last_event_views(&order);
587    }
588
589    #[rstest]
590    #[case::limit(OrderType::Limit)]
591    #[case::limit_if_touched(OrderType::LimitIfTouched)]
592    #[case::market(OrderType::Market)]
593    #[case::market_if_touched(OrderType::MarketIfTouched)]
594    #[case::market_to_limit(OrderType::MarketToLimit)]
595    #[case::stop_limit(OrderType::StopLimit)]
596    #[case::stop_market(OrderType::StopMarket)]
597    #[case::trailing_stop_limit(OrderType::TrailingStopLimit)]
598    #[case::trailing_stop_market(OrderType::TrailingStopMarket)]
599    #[should_panic(expected = "Order invariant violated: no events")]
600    fn test_last_event_preserves_empty_history_panic(#[case] order_type: OrderType) {
601        let mut order = order_for_list_id_test(order_type);
602        let core: &mut OrderCore = match &mut order {
603            OrderAny::Limit(order) => order,
604            OrderAny::LimitIfTouched(order) => order,
605            OrderAny::Market(order) => order,
606            OrderAny::MarketIfTouched(order) => order,
607            OrderAny::MarketToLimit(order) => order,
608            OrderAny::StopLimit(order) => order,
609            OrderAny::StopMarket(order) => order,
610            OrderAny::TrailingStopLimit(order) => order,
611            OrderAny::TrailingStopMarket(order) => order,
612        };
613        core.events.clear();
614
615        let _ = Order::last_event(&order);
616    }
617
618    fn order_for_list_id_test(order_type: OrderType) -> OrderAny {
619        OrderTestBuilder::new(order_type)
620            .instrument_id(InstrumentId::from("BTC-USDT.BINANCE"))
621            .client_order_id(ClientOrderId::from("ORDER-LIST-001"))
622            .quantity(Quantity::from(10))
623            .price(Price::from("101.00"))
624            .trigger_price(Price::from("100.00"))
625            .trigger_type(TriggerType::LastPrice)
626            .limit_offset(dec!(1))
627            .trailing_offset(dec!(1))
628            .trailing_offset_type(TrailingOffsetType::Price)
629            .init_id(UUID4::from("16578139-a945-4b65-b46c-bc131a15d8e7"))
630            .ts_init(UnixNanos::from(123_456_789))
631            .build()
632    }
633
634    #[rstest]
635    fn test_order_any_from_events_empty_error() {
636        let events: Vec<OrderEventAny> = vec![];
637        let err = OrderAny::from_events(events).expect_err("empty events should fail");
638
639        assert!(matches!(err, OrderReplayError::EmptyInput));
640        assert_eq!(
641            err.to_string(),
642            "No order events provided to create OrderAny"
643        );
644    }
645
646    #[rstest]
647    fn test_order_any_from_events_invalid_init_returns_error() {
648        // Limit order with `price = None` violates `LimitOrder` invariants. Previously this
649        // panicked inside `From<OrderInitialized>`; `from_events` must now surface it as `Err`.
650        let init_event = OrderInitializedSpec::builder()
651            .order_type(OrderType::Limit)
652            .instrument_id(InstrumentId::from("BTC-USDT.BINANCE"))
653            .quantity(Quantity::from(10))
654            .build();
655
656        let events = vec![OrderEventAny::Initialized(init_event)];
657        let err =
658            OrderAny::from_events(events).expect_err("invalid initialization should fail replay");
659
660        match &err {
661            OrderReplayError::InvalidInitialization { source } => {
662                assert_eq!(
663                    source.to_string(),
664                    "`price` is required for `LimitOrder` initialization",
665                );
666            }
667            _ => panic!("expected InvalidInitialization, was {err:?}"),
668        }
669        assert_eq!(
670            err.to_string(),
671            "Invalid `OrderInitialized` event: `price` is required for `LimitOrder` initialization",
672        );
673    }
674
675    #[rstest]
676    #[case::buy(
677        OrderSide::Buy,
678        Price::from("100.00"),
679        Price::from("101.00"),
680        "BUY Limit-If-Touched"
681    )]
682    #[case::sell(
683        OrderSide::Sell,
684        Price::from("100.00"),
685        Price::from("99.00"),
686        "SELL Limit-If-Touched"
687    )]
688    fn test_order_any_from_events_invalid_predicate_returns_error(
689        #[case] side: OrderSide,
690        #[case] price: Price,
691        #[case] trigger_price: Price,
692        #[case] expected_msg: &str,
693    ) {
694        // LimitIfTouched enforces `trigger_price <= price` for BUY and `trigger_price >= price`
695        // for SELL inside `new_checked`. Reconciliation must see violations as `Err` rather
696        // than panicking, on either side.
697        let init_event = OrderInitializedSpec::builder()
698            .order_type(OrderType::LimitIfTouched)
699            .order_side(side)
700            .instrument_id(InstrumentId::from("BTC-USDT.BINANCE"))
701            .quantity(Quantity::from(10))
702            .price(price)
703            .trigger_price(trigger_price)
704            .trigger_type(TriggerType::LastPrice)
705            .build();
706
707        let events = vec![OrderEventAny::Initialized(init_event)];
708        let err =
709            OrderAny::from_events(events).expect_err("invalid initialization should fail replay");
710
711        assert!(matches!(
712            err,
713            OrderReplayError::InvalidInitialization { .. }
714        ));
715        let msg = err.to_string();
716        assert!(
717            msg.contains("Invalid `OrderInitialized` event") && msg.contains(expected_msg),
718            "unexpected error message: {msg}"
719        );
720    }
721
722    fn make_init_with_optional_fields(
723        order_type: OrderType,
724        price: Option<Price>,
725        trigger_price: Option<Price>,
726        trigger_type: Option<TriggerType>,
727        limit_offset: Option<Decimal>,
728        trailing_offset: Option<Decimal>,
729        trailing_offset_type: Option<TrailingOffsetType>,
730    ) -> OrderInitialized {
731        OrderInitializedSpec::builder()
732            .order_type(order_type)
733            .instrument_id(InstrumentId::from("BTC-USDT.BINANCE"))
734            .quantity(Quantity::from(10))
735            .maybe_price(price)
736            .maybe_trigger_price(trigger_price)
737            .maybe_trigger_type(trigger_type)
738            .maybe_limit_offset(limit_offset)
739            .maybe_trailing_offset(trailing_offset)
740            .maybe_trailing_offset_type(trailing_offset_type)
741            .build()
742    }
743
744    #[rstest]
745    #[case::lit_missing_price(
746        make_init_with_optional_fields(
747            OrderType::LimitIfTouched,
748            None,
749            Some(Price::from("100.00")),
750            Some(TriggerType::LastPrice),
751            None,
752            None,
753            None,
754        ),
755        "`price` is required for `LimitIfTouchedOrder`"
756    )]
757    #[case::lit_missing_trigger_price(
758        make_init_with_optional_fields(
759            OrderType::LimitIfTouched,
760            Some(Price::from("100.00")),
761            None,
762            Some(TriggerType::LastPrice),
763            None,
764            None,
765            None,
766        ),
767        "`trigger_price` is required for `LimitIfTouchedOrder`"
768    )]
769    #[case::lit_missing_trigger_type(
770        make_init_with_optional_fields(
771            OrderType::LimitIfTouched,
772            Some(Price::from("100.00")),
773            Some(Price::from("99.00")),
774            None,
775            None,
776            None,
777            None,
778        ),
779        "`trigger_type` is required for `LimitIfTouchedOrder`"
780    )]
781    #[case::stop_limit_missing_price(
782        make_init_with_optional_fields(
783            OrderType::StopLimit,
784            None,
785            Some(Price::from("100.00")),
786            Some(TriggerType::LastPrice),
787            None,
788            None,
789            None,
790        ),
791        "`price` is required for `StopLimitOrder`"
792    )]
793    #[case::stop_limit_missing_trigger_price(
794        make_init_with_optional_fields(
795            OrderType::StopLimit,
796            Some(Price::from("100.00")),
797            None,
798            Some(TriggerType::LastPrice),
799            None,
800            None,
801            None,
802        ),
803        "`trigger_price` is required for `StopLimitOrder`"
804    )]
805    #[case::stop_limit_missing_trigger_type(
806        make_init_with_optional_fields(
807            OrderType::StopLimit,
808            Some(Price::from("100.00")),
809            Some(Price::from("99.00")),
810            None,
811            None,
812            None,
813            None,
814        ),
815        "`trigger_type` is required for `StopLimitOrder`"
816    )]
817    #[case::stop_market_missing_trigger_price(
818        make_init_with_optional_fields(
819            OrderType::StopMarket,
820            None,
821            None,
822            Some(TriggerType::LastPrice),
823            None,
824            None,
825            None,
826        ),
827        "`trigger_price` is required for `StopMarketOrder`"
828    )]
829    #[case::stop_market_missing_trigger_type(
830        make_init_with_optional_fields(
831            OrderType::StopMarket,
832            None,
833            Some(Price::from("100.00")),
834            None,
835            None,
836            None,
837            None,
838        ),
839        "`trigger_type` is required for `StopMarketOrder`"
840    )]
841    #[case::mit_missing_trigger_price(
842        make_init_with_optional_fields(
843            OrderType::MarketIfTouched,
844            None,
845            None,
846            Some(TriggerType::LastPrice),
847            None,
848            None,
849            None,
850        ),
851        "`trigger_price` is required for `MarketIfTouchedOrder`"
852    )]
853    #[case::mit_missing_trigger_type(
854        make_init_with_optional_fields(
855            OrderType::MarketIfTouched,
856            None,
857            Some(Price::from("100.00")),
858            None,
859            None,
860            None,
861            None,
862        ),
863        "`trigger_type` is required for `MarketIfTouchedOrder`"
864    )]
865    #[case::tsl_missing_trigger_type(
866        make_init_with_optional_fields(
867            OrderType::TrailingStopLimit,
868            Some(Price::from("100.00")), Some(Price::from("99.00")), None,
869            Some(dec!(1)), Some(dec!(1)), Some(TrailingOffsetType::Price),
870        ),
871        "`trigger_type` is required for `TrailingStopLimitOrder`",
872    )]
873    #[case::tsl_missing_limit_offset(
874        make_init_with_optional_fields(
875            OrderType::TrailingStopLimit,
876            Some(Price::from("100.00")), Some(Price::from("99.00")), Some(TriggerType::LastPrice),
877            None, Some(dec!(1)), Some(TrailingOffsetType::Price),
878        ),
879        "`limit_offset` is required for `TrailingStopLimitOrder`",
880    )]
881    #[case::tsl_missing_trailing_offset(
882        make_init_with_optional_fields(
883            OrderType::TrailingStopLimit,
884            Some(Price::from("100.00")), Some(Price::from("99.00")), Some(TriggerType::LastPrice),
885            Some(dec!(1)), None, Some(TrailingOffsetType::Price),
886        ),
887        "`trailing_offset` is required for `TrailingStopLimitOrder`",
888    )]
889    #[case::tsl_missing_trailing_offset_type(
890        make_init_with_optional_fields(
891            OrderType::TrailingStopLimit,
892            Some(Price::from("100.00")), Some(Price::from("99.00")), Some(TriggerType::LastPrice),
893            Some(dec!(1)), Some(dec!(1)), None,
894        ),
895        "`trailing_offset_type` is required for `TrailingStopLimitOrder`",
896    )]
897    #[case::tsm_missing_trigger_type(
898        make_init_with_optional_fields(
899            OrderType::TrailingStopMarket,
900            None, Some(Price::from("100.00")), None,
901            None, Some(dec!(1)), Some(TrailingOffsetType::Price),
902        ),
903        "`trigger_type` is required for `TrailingStopMarketOrder`",
904    )]
905    #[case::tsm_missing_trailing_offset(
906        make_init_with_optional_fields(
907            OrderType::TrailingStopMarket,
908            None,
909            Some(Price::from("100.00")),
910            Some(TriggerType::LastPrice),
911            None,
912            None,
913            Some(TrailingOffsetType::Price),
914        ),
915        "`trailing_offset` is required for `TrailingStopMarketOrder`"
916    )]
917    #[case::tsm_missing_trailing_offset_type(
918        make_init_with_optional_fields(
919            OrderType::TrailingStopMarket,
920            None, Some(Price::from("100.00")), Some(TriggerType::LastPrice),
921            None, Some(dec!(1)), None,
922        ),
923        "`trailing_offset_type` is required for `TrailingStopMarketOrder`",
924    )]
925    fn test_order_any_from_events_missing_required_field_returns_error(
926        #[case] init: OrderInitialized,
927        #[case] expected_field_msg: &str,
928    ) {
929        // Each case omits exactly one required field for its order type. `from_events` must
930        // surface the per-type `TryFrom` error rather than panicking inside `OrderAny::from`.
931        let events = vec![OrderEventAny::Initialized(init)];
932        let err =
933            OrderAny::from_events(events).expect_err("invalid initialization should fail replay");
934
935        assert!(matches!(
936            err,
937            OrderReplayError::InvalidInitialization { .. }
938        ));
939        let msg = err.to_string();
940        assert!(
941            msg.contains("Invalid `OrderInitialized` event") && msg.contains(expected_field_msg),
942            "unexpected error message: {msg}"
943        );
944    }
945
946    #[rstest]
947    fn test_order_any_from_events_wrong_first_event() {
948        // Create an event that is not OrderInitialized
949        let client_order_id = ClientOrderId::from("ORDER-001");
950        let strategy_id = StrategyId::from("STRATEGY-001");
951
952        let update_event = OrderUpdated {
953            client_order_id,
954            strategy_id,
955            quantity: Quantity::from(20),
956            ..Default::default()
957        };
958
959        // Create a vector with a non-initialization event first
960        let events = vec![OrderEventAny::Updated(update_event)];
961
962        // Attempt to create order should fail
963        let err = OrderAny::from_events(events).expect_err("wrong first event should fail replay");
964        assert!(matches!(err, OrderReplayError::WrongFirstEvent));
965        assert_eq!(err.to_string(), "First event must be `OrderInitialized`");
966    }
967
968    #[rstest]
969    fn test_order_any_from_events_apply_failure() {
970        let init_event = OrderInitializedSpec::builder()
971            .order_type(OrderType::Market)
972            .instrument_id(InstrumentId::from("BTC-USDT.BINANCE"))
973            .quantity(Quantity::from(10))
974            .build();
975
976        let events = vec![
977            OrderEventAny::Initialized(init_event.clone()),
978            OrderEventAny::Initialized(init_event),
979        ];
980        let err =
981            OrderAny::from_events(events).expect_err("later invalid event should fail replay");
982
983        match &err {
984            OrderReplayError::ApplyFailed { source } => {
985                assert!(matches!(source, OrderError::AlreadyInitialized));
986            }
987            _ => panic!("expected ApplyFailed, was {err:?}"),
988        }
989        assert_eq!(err.to_string(), "Order was already initialized");
990    }
991
992    #[rstest]
993    fn test_passive_order_any_conversion() {
994        // Create a limit order
995        let limit_order = OrderTestBuilder::new(OrderType::Limit)
996            .instrument_id(InstrumentId::from("BTC-USDT.BINANCE"))
997            .quantity(Quantity::from(10))
998            .price(Price::new(100.0, 2))
999            .build();
1000
1001        // Convert to PassiveOrderAny and back
1002        let passive_order = PassiveOrderAny::try_from(limit_order).unwrap();
1003        let order_any: OrderAny = passive_order.into();
1004
1005        // Verify it maintained its properties
1006        assert_eq!(order_any.order_type(), OrderType::Limit);
1007        assert_eq!(order_any.quantity(), Quantity::from(10));
1008    }
1009
1010    #[rstest]
1011    fn test_stop_order_any_conversion() {
1012        // Create a stop market order
1013        let stop_order = OrderTestBuilder::new(OrderType::StopMarket)
1014            .instrument_id(InstrumentId::from("BTC-USDT.BINANCE"))
1015            .quantity(Quantity::from(10))
1016            .trigger_price(Price::new(100.0, 2))
1017            .build();
1018
1019        // Convert to StopOrderAny and back
1020        let stop_order_any = StopOrderAny::try_from(stop_order).unwrap();
1021        let order_any: OrderAny = stop_order_any.into();
1022
1023        // Verify it maintained its properties
1024        assert_eq!(order_any.order_type(), OrderType::StopMarket);
1025        assert_eq!(order_any.quantity(), Quantity::from(10));
1026        assert_eq!(order_any.trigger_price(), Some(Price::new(100.0, 2)));
1027    }
1028
1029    #[rstest]
1030    fn test_limit_order_any_conversion() {
1031        // Create a limit order
1032        let limit_order = OrderTestBuilder::new(OrderType::Limit)
1033            .instrument_id(InstrumentId::from("BTC-USDT.BINANCE"))
1034            .quantity(Quantity::from(10))
1035            .price(Price::new(100.0, 2))
1036            .build();
1037
1038        // Convert to LimitOrderAny and back
1039        let limit_order_any = LimitOrderAny::try_from(limit_order).unwrap();
1040        let order_any: OrderAny = limit_order_any.into();
1041
1042        // Verify it maintained its properties
1043        assert_eq!(order_any.order_type(), OrderType::Limit);
1044        assert_eq!(order_any.quantity(), Quantity::from(10));
1045    }
1046
1047    #[rstest]
1048    fn test_limit_order_any_limit_price() {
1049        // Create a limit order
1050        let limit_order = OrderTestBuilder::new(OrderType::Limit)
1051            .instrument_id(InstrumentId::from("BTC-USDT.BINANCE"))
1052            .quantity(Quantity::from(10))
1053            .price(Price::new(100.0, 2))
1054            .build();
1055
1056        // Convert to LimitOrderAny
1057        let limit_order_any = LimitOrderAny::try_from(limit_order).unwrap();
1058
1059        // Check limit price accessor
1060        let limit_px = limit_order_any.limit_px();
1061        assert_eq!(limit_px, Price::new(100.0, 2));
1062    }
1063
1064    #[rstest]
1065    fn test_stop_order_any_stop_price() {
1066        // Create a stop market order
1067        let stop_order = OrderTestBuilder::new(OrderType::StopMarket)
1068            .instrument_id(InstrumentId::from("BTC-USDT.BINANCE"))
1069            .quantity(Quantity::from(10))
1070            .trigger_price(Price::new(100.0, 2))
1071            .build();
1072
1073        // Convert to StopOrderAny
1074        let stop_order_any = StopOrderAny::try_from(stop_order).unwrap();
1075
1076        // Check stop price accessor
1077        let stop_px = stop_order_any.stop_px();
1078        assert_eq!(stop_px, Some(Price::new(100.0, 2)));
1079    }
1080
1081    #[rstest]
1082    fn test_trailing_stop_market_order_conversion() {
1083        // Create a trailing stop market order
1084        let trailing_stop_order = OrderTestBuilder::new(OrderType::TrailingStopMarket)
1085            .instrument_id(InstrumentId::from("BTC-USDT.BINANCE"))
1086            .quantity(Quantity::from(10))
1087            .trigger_price(Price::new(100.0, 2))
1088            .trailing_offset(Decimal::new(5, 1)) // 0.5
1089            .trailing_offset_type(TrailingOffsetType::Price)
1090            .build();
1091
1092        // Convert to StopOrderAny
1093        let stop_order_any = StopOrderAny::try_from(trailing_stop_order).unwrap();
1094
1095        // And back to OrderAny
1096        let order_any: OrderAny = stop_order_any.into();
1097
1098        // Verify properties are preserved
1099        assert_eq!(order_any.order_type(), OrderType::TrailingStopMarket);
1100        assert_eq!(order_any.quantity(), Quantity::from(10));
1101        assert_eq!(order_any.trigger_price(), Some(Price::new(100.0, 2)));
1102        assert_eq!(order_any.trailing_offset(), Some(dec!(0.5)));
1103        assert_eq!(
1104            order_any.trailing_offset_type(),
1105            Some(TrailingOffsetType::Price)
1106        );
1107    }
1108
1109    #[rstest]
1110    fn test_trailing_stop_limit_order_conversion() {
1111        // Create a trailing stop limit order
1112        let trailing_stop_limit = OrderTestBuilder::new(OrderType::TrailingStopLimit)
1113            .instrument_id(InstrumentId::from("BTC-USDT.BINANCE"))
1114            .quantity(Quantity::from(10))
1115            .price(Price::new(99.0, 2))
1116            .trigger_price(Price::new(100.0, 2))
1117            .limit_offset(Decimal::new(10, 1)) // 1.0
1118            .trailing_offset(Decimal::new(5, 1)) // 0.5
1119            .trailing_offset_type(TrailingOffsetType::Price)
1120            .build();
1121
1122        // Convert to LimitOrderAny
1123        let limit_order_any = LimitOrderAny::try_from(trailing_stop_limit).unwrap();
1124
1125        // Check limit price
1126        assert_eq!(limit_order_any.limit_px(), Price::new(99.0, 2));
1127
1128        // Convert back to OrderAny
1129        let order_any: OrderAny = limit_order_any.into();
1130
1131        // Verify properties are preserved
1132        assert_eq!(order_any.order_type(), OrderType::TrailingStopLimit);
1133        assert_eq!(order_any.quantity(), Quantity::from(10));
1134        assert_eq!(order_any.price(), Some(Price::new(99.0, 2)));
1135        assert_eq!(order_any.trigger_price(), Some(Price::new(100.0, 2)));
1136        assert_eq!(order_any.trailing_offset(), Some(dec!(0.5)));
1137    }
1138
1139    #[rstest]
1140    fn test_passive_order_any_to_any() {
1141        // Create a limit order
1142        let limit_order = OrderTestBuilder::new(OrderType::Limit)
1143            .instrument_id(InstrumentId::from("BTC-USDT.BINANCE"))
1144            .quantity(Quantity::from(10))
1145            .price(Price::new(100.0, 2))
1146            .build();
1147
1148        // Convert to PassiveOrderAny
1149        let passive_order = PassiveOrderAny::try_from(limit_order).unwrap();
1150
1151        // Use to_any method
1152        let order_any = passive_order.to_any();
1153
1154        // Verify it maintained its properties
1155        assert_eq!(order_any.order_type(), OrderType::Limit);
1156        assert_eq!(order_any.quantity(), Quantity::from(10));
1157        assert_eq!(order_any.price(), Some(Price::new(100.0, 2)));
1158    }
1159}