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