nautilus_model/orders/
base.rs

1// -------------------------------------------------------------------------------------------------
2//  Copyright (C) 2015-2025 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 indexmap::IndexMap;
17use nautilus_core::{UUID4, UnixNanos};
18use rust_decimal::Decimal;
19use serde::{Deserialize, Serialize};
20use ustr::Ustr;
21
22use super::any::OrderAny;
23use crate::{
24    enums::{
25        ContingencyType, LiquiditySide, OrderSide, OrderStatus, OrderType, PositionSide,
26        TimeInForce, TrailingOffsetType, TriggerType,
27    },
28    events::{
29        OrderAccepted, OrderCancelRejected, OrderCanceled, OrderDenied, OrderEmulated,
30        OrderEventAny, OrderExpired, OrderFilled, OrderInitialized, OrderModifyRejected,
31        OrderPendingCancel, OrderPendingUpdate, OrderRejected, OrderReleased, OrderSubmitted,
32        OrderTriggered, OrderUpdated,
33    },
34    identifiers::{
35        AccountId, ClientOrderId, ExecAlgorithmId, InstrumentId, OrderListId, PositionId,
36        StrategyId, Symbol, TradeId, TraderId, Venue, VenueOrderId,
37    },
38    types::{Currency, Money, Price, Quantity},
39};
40
41const STOP_ORDER_TYPES: &[OrderType] = &[
42    OrderType::StopMarket,
43    OrderType::StopLimit,
44    OrderType::MarketIfTouched,
45    OrderType::LimitIfTouched,
46];
47
48const LIMIT_ORDER_TYPES: &[OrderType] = &[
49    OrderType::Limit,
50    OrderType::StopLimit,
51    OrderType::LimitIfTouched,
52    OrderType::MarketIfTouched,
53];
54
55const LOCAL_ACTIVE_ORDER_STATUS: &[OrderStatus] = &[
56    OrderStatus::Initialized,
57    OrderStatus::Emulated,
58    OrderStatus::Released,
59];
60
61#[derive(thiserror::Error, Debug)]
62pub enum OrderError {
63    #[error("Order not found: {0}")]
64    NotFound(ClientOrderId),
65    #[error("Order invariant failed: must have a side for this operation")]
66    NoOrderSide,
67    #[error("Invalid event for order type")]
68    InvalidOrderEvent,
69    #[error("Invalid order state transition")]
70    InvalidStateTransition,
71    #[error("Order was already initialized")]
72    AlreadyInitialized,
73    #[error("Order had no previous state")]
74    NoPreviousState,
75}
76
77#[must_use]
78pub fn ustr_indexmap_to_str(h: IndexMap<Ustr, Ustr>) -> IndexMap<String, String> {
79    h.into_iter()
80        .map(|(k, v)| (k.to_string(), v.to_string()))
81        .collect()
82}
83
84#[must_use]
85pub fn str_indexmap_to_ustr(h: IndexMap<String, String>) -> IndexMap<Ustr, Ustr> {
86    h.into_iter()
87        .map(|(k, v)| (Ustr::from(&k), Ustr::from(&v)))
88        .collect()
89}
90
91impl OrderStatus {
92    #[rustfmt::skip]
93    pub fn transition(&mut self, event: &OrderEventAny) -> Result<Self, OrderError> {
94        let new_state = match (self, event) {
95            (Self::Initialized, OrderEventAny::Denied(_)) => Self::Denied,
96            (Self::Initialized, OrderEventAny::Emulated(_)) => Self::Emulated,  // Emulated orders
97            (Self::Initialized, OrderEventAny::Released(_)) => Self::Released,  // Emulated orders
98            (Self::Initialized, OrderEventAny::Submitted(_)) => Self::Submitted,
99            (Self::Initialized, OrderEventAny::Rejected(_)) => Self::Rejected,  // External orders
100            (Self::Initialized, OrderEventAny::Accepted(_)) => Self::Accepted,  // External orders
101            (Self::Initialized, OrderEventAny::Canceled(_)) => Self::Canceled,  // External orders
102            (Self::Initialized, OrderEventAny::Expired(_)) => Self::Expired,  // External orders
103            (Self::Initialized, OrderEventAny::Triggered(_)) => Self::Triggered, // External orders
104            (Self::Emulated, OrderEventAny::Canceled(_)) => Self::Canceled,  // Emulated orders
105            (Self::Emulated, OrderEventAny::Expired(_)) => Self::Expired,  // Emulated orders
106            (Self::Emulated, OrderEventAny::Released(_)) => Self::Released,  // Emulated orders
107            (Self::Released, OrderEventAny::Submitted(_)) => Self::Submitted,  // Emulated orders
108            (Self::Released, OrderEventAny::Denied(_)) => Self::Denied,  // Emulated orders
109            (Self::Released, OrderEventAny::Canceled(_)) => Self::Canceled,  // Execution algo
110            (Self::Submitted, OrderEventAny::PendingUpdate(_)) => Self::PendingUpdate,
111            (Self::Submitted, OrderEventAny::PendingCancel(_)) => Self::PendingCancel,
112            (Self::Submitted, OrderEventAny::Rejected(_)) => Self::Rejected,
113            (Self::Submitted, OrderEventAny::Canceled(_)) => Self::Canceled,  // FOK and IOC cases
114            (Self::Submitted, OrderEventAny::Accepted(_)) => Self::Accepted,
115            (Self::Submitted, OrderEventAny::Filled(_)) => Self::Filled,
116            (Self::Submitted, OrderEventAny::Updated(_)) => Self::Submitted,
117            (Self::Accepted, OrderEventAny::Rejected(_)) => Self::Rejected,  // StopLimit order
118            (Self::Accepted, OrderEventAny::PendingUpdate(_)) => Self::PendingUpdate,
119            (Self::Accepted, OrderEventAny::PendingCancel(_)) => Self::PendingCancel,
120            (Self::Accepted, OrderEventAny::Canceled(_)) => Self::Canceled,
121            (Self::Accepted, OrderEventAny::Triggered(_)) => Self::Triggered,
122            (Self::Accepted, OrderEventAny::Expired(_)) => Self::Expired,
123            (Self::Accepted, OrderEventAny::Filled(_)) => Self::Filled,
124            (Self::Accepted, OrderEventAny::Updated(_)) => Self::Accepted,  // Updates should preserve state
125            (Self::Canceled, OrderEventAny::Filled(_)) => Self::Filled,  // Real world possibility
126            (Self::PendingUpdate, OrderEventAny::Rejected(_)) => Self::Rejected,
127            (Self::PendingUpdate, OrderEventAny::Accepted(_)) => Self::Accepted,
128            (Self::PendingUpdate, OrderEventAny::Canceled(_)) => Self::Canceled,
129            (Self::PendingUpdate, OrderEventAny::Expired(_)) => Self::Expired,
130            (Self::PendingUpdate, OrderEventAny::Triggered(_)) => Self::Triggered,
131            (Self::PendingUpdate, OrderEventAny::PendingUpdate(_)) => Self::PendingUpdate,  // Allow multiple requests
132            (Self::PendingUpdate, OrderEventAny::PendingCancel(_)) => Self::PendingCancel,
133            (Self::PendingUpdate, OrderEventAny::Filled(_)) => Self::Filled,
134            (Self::PendingCancel, OrderEventAny::Rejected(_)) => Self::Rejected,
135            (Self::PendingCancel, OrderEventAny::PendingCancel(_)) => Self::PendingCancel,  // Allow multiple requests
136            (Self::PendingCancel, OrderEventAny::Canceled(_)) => Self::Canceled,
137            (Self::PendingCancel, OrderEventAny::Expired(_)) => Self::Expired,
138            (Self::PendingCancel, OrderEventAny::Accepted(_)) => Self::Accepted,  // Allow failed cancel requests
139            (Self::PendingCancel, OrderEventAny::Filled(_)) => Self::Filled,
140            (Self::Triggered, OrderEventAny::Rejected(_)) => Self::Rejected,
141            (Self::Triggered, OrderEventAny::PendingUpdate(_)) => Self::PendingUpdate,
142            (Self::Triggered, OrderEventAny::PendingCancel(_)) => Self::PendingCancel,
143            (Self::Triggered, OrderEventAny::Canceled(_)) => Self::Canceled,
144            (Self::Triggered, OrderEventAny::Expired(_)) => Self::Expired,
145            (Self::Triggered, OrderEventAny::Filled(_)) => Self::Filled,
146            (Self::PartiallyFilled, OrderEventAny::PendingUpdate(_)) => Self::PendingUpdate,
147            (Self::PartiallyFilled, OrderEventAny::PendingCancel(_)) => Self::PendingCancel,
148            (Self::PartiallyFilled, OrderEventAny::Canceled(_)) => Self::Canceled,
149            (Self::PartiallyFilled, OrderEventAny::Expired(_)) => Self::Expired,
150            (Self::PartiallyFilled, OrderEventAny::Filled(_)) => Self::Filled,
151            (Self::PartiallyFilled, OrderEventAny::Accepted(_)) => Self::Accepted,
152            _ => return Err(OrderError::InvalidStateTransition),
153        };
154        Ok(new_state)
155    }
156}
157
158pub trait Order: 'static + Send {
159    fn into_any(self) -> OrderAny;
160    fn status(&self) -> OrderStatus;
161    fn trader_id(&self) -> TraderId;
162    fn strategy_id(&self) -> StrategyId;
163    fn instrument_id(&self) -> InstrumentId;
164    fn symbol(&self) -> Symbol;
165    fn venue(&self) -> Venue;
166    fn client_order_id(&self) -> ClientOrderId;
167    fn venue_order_id(&self) -> Option<VenueOrderId>;
168    fn position_id(&self) -> Option<PositionId>;
169    fn account_id(&self) -> Option<AccountId>;
170    fn last_trade_id(&self) -> Option<TradeId>;
171    fn side(&self) -> OrderSide;
172    fn order_type(&self) -> OrderType;
173    fn quantity(&self) -> Quantity;
174    fn time_in_force(&self) -> TimeInForce;
175    fn expire_time(&self) -> Option<UnixNanos>;
176    fn price(&self) -> Option<Price>;
177    fn trigger_price(&self) -> Option<Price>;
178    fn trigger_type(&self) -> Option<TriggerType>;
179    fn liquidity_side(&self) -> Option<LiquiditySide>;
180    fn is_post_only(&self) -> bool;
181    fn is_reduce_only(&self) -> bool;
182    fn is_quote_quantity(&self) -> bool;
183    fn display_qty(&self) -> Option<Quantity>;
184    fn limit_offset(&self) -> Option<Decimal>;
185    fn trailing_offset(&self) -> Option<Decimal>;
186    fn trailing_offset_type(&self) -> Option<TrailingOffsetType>;
187    fn emulation_trigger(&self) -> Option<TriggerType>;
188    fn trigger_instrument_id(&self) -> Option<InstrumentId>;
189    fn contingency_type(&self) -> Option<ContingencyType>;
190    fn order_list_id(&self) -> Option<OrderListId>;
191    fn linked_order_ids(&self) -> Option<&[ClientOrderId]>;
192    fn parent_order_id(&self) -> Option<ClientOrderId>;
193    fn exec_algorithm_id(&self) -> Option<ExecAlgorithmId>;
194    fn exec_algorithm_params(&self) -> Option<&IndexMap<Ustr, Ustr>>;
195    fn exec_spawn_id(&self) -> Option<ClientOrderId>;
196    fn tags(&self) -> Option<&[Ustr]>;
197    fn filled_qty(&self) -> Quantity;
198    fn leaves_qty(&self) -> Quantity;
199    fn avg_px(&self) -> Option<f64>;
200    fn slippage(&self) -> Option<f64>;
201    fn init_id(&self) -> UUID4;
202    fn ts_init(&self) -> UnixNanos;
203    fn ts_last(&self) -> UnixNanos;
204
205    fn apply(&mut self, event: OrderEventAny) -> Result<(), OrderError>;
206    fn update(&mut self, event: &OrderUpdated);
207
208    fn events(&self) -> Vec<&OrderEventAny>;
209    fn last_event(&self) -> &OrderEventAny {
210        // SAFETY: Unwrap safe as `Order` specification guarantees at least one event (`OrderInitialized`)
211        self.events().last().unwrap()
212    }
213
214    fn event_count(&self) -> usize {
215        self.events().len()
216    }
217
218    fn venue_order_ids(&self) -> Vec<&VenueOrderId>;
219
220    fn trade_ids(&self) -> Vec<&TradeId>;
221
222    fn is_buy(&self) -> bool {
223        self.side() == OrderSide::Buy
224    }
225
226    fn is_sell(&self) -> bool {
227        self.side() == OrderSide::Sell
228    }
229
230    fn is_passive(&self) -> bool {
231        self.order_type() != OrderType::Market
232    }
233
234    fn is_aggressive(&self) -> bool {
235        self.order_type() == OrderType::Market
236    }
237
238    fn is_emulated(&self) -> bool {
239        self.status() == OrderStatus::Emulated
240    }
241
242    fn is_active_local(&self) -> bool {
243        matches!(
244            self.status(),
245            OrderStatus::Initialized | OrderStatus::Emulated | OrderStatus::Released
246        )
247    }
248
249    fn is_primary(&self) -> bool {
250        // TODO: Guarantee `exec_spawn_id` is some if `exec_algorithm_id` is some
251        self.exec_algorithm_id().is_some()
252            && self.client_order_id() == self.exec_spawn_id().unwrap()
253    }
254
255    fn is_secondary(&self) -> bool {
256        // TODO: Guarantee `exec_spawn_id` is some if `exec_algorithm_id` is some
257        self.exec_algorithm_id().is_some()
258            && self.client_order_id() != self.exec_spawn_id().unwrap()
259    }
260
261    fn is_contingency(&self) -> bool {
262        self.contingency_type().is_some()
263    }
264
265    fn is_parent_order(&self) -> bool {
266        match self.contingency_type() {
267            Some(c) => c == ContingencyType::Oto,
268            None => false,
269        }
270    }
271
272    fn is_child_order(&self) -> bool {
273        self.parent_order_id().is_some()
274    }
275
276    fn is_open(&self) -> bool {
277        if let Some(emulation_trigger) = self.emulation_trigger() {
278            if emulation_trigger != TriggerType::NoTrigger {
279                return false;
280            }
281        }
282
283        matches!(
284            self.status(),
285            OrderStatus::Accepted
286                | OrderStatus::Triggered
287                | OrderStatus::PendingCancel
288                | OrderStatus::PendingUpdate
289                | OrderStatus::PartiallyFilled
290        )
291    }
292
293    fn is_canceled(&self) -> bool {
294        self.status() == OrderStatus::Canceled
295    }
296
297    fn is_closed(&self) -> bool {
298        matches!(
299            self.status(),
300            OrderStatus::Denied
301                | OrderStatus::Rejected
302                | OrderStatus::Canceled
303                | OrderStatus::Expired
304                | OrderStatus::Filled
305        )
306    }
307
308    fn is_inflight(&self) -> bool {
309        if let Some(emulation_trigger) = self.emulation_trigger() {
310            if emulation_trigger != TriggerType::NoTrigger {
311                return false;
312            }
313        }
314
315        matches!(
316            self.status(),
317            OrderStatus::Submitted | OrderStatus::PendingCancel | OrderStatus::PendingUpdate
318        )
319    }
320
321    fn is_pending_update(&self) -> bool {
322        self.status() == OrderStatus::PendingUpdate
323    }
324
325    fn is_pending_cancel(&self) -> bool {
326        self.status() == OrderStatus::PendingCancel
327    }
328
329    fn is_spawned(&self) -> bool {
330        self.exec_spawn_id()
331            .is_some_and(|exec_spawn_id| exec_spawn_id != self.client_order_id())
332    }
333}
334
335impl From<OrderAny> for Box<dyn Order> {
336    fn from(order: OrderAny) -> Box<dyn Order> {
337        match order {
338            OrderAny::Limit(order) => Box::new(order),
339            OrderAny::LimitIfTouched(order) => Box::new(order),
340            OrderAny::Market(order) => Box::new(order),
341            OrderAny::MarketIfTouched(order) => Box::new(order),
342            OrderAny::MarketToLimit(order) => Box::new(order),
343            OrderAny::StopLimit(order) => Box::new(order),
344            OrderAny::StopMarket(order) => Box::new(order),
345            OrderAny::TrailingStopLimit(order) => Box::new(order),
346            OrderAny::TrailingStopMarket(order) => Box::new(order),
347        }
348    }
349}
350
351impl<T> From<&T> for OrderInitialized
352where
353    T: Order,
354{
355    fn from(order: &T) -> Self {
356        Self {
357            trader_id: order.trader_id(),
358            strategy_id: order.strategy_id(),
359            instrument_id: order.instrument_id(),
360            client_order_id: order.client_order_id(),
361            order_side: order.side(),
362            order_type: order.order_type(),
363            quantity: order.quantity(),
364            price: order.price(),
365            trigger_price: order.trigger_price(),
366            trigger_type: order.trigger_type(),
367            time_in_force: order.time_in_force(),
368            expire_time: order.expire_time(),
369            post_only: order.is_post_only(),
370            reduce_only: order.is_reduce_only(),
371            quote_quantity: order.is_quote_quantity(),
372            display_qty: order.display_qty(),
373            limit_offset: order.limit_offset(),
374            trailing_offset: order.trailing_offset(),
375            trailing_offset_type: order.trailing_offset_type(),
376            emulation_trigger: order.emulation_trigger(),
377            trigger_instrument_id: order.trigger_instrument_id(),
378            contingency_type: order.contingency_type(),
379            order_list_id: order.order_list_id(),
380            linked_order_ids: order.linked_order_ids().map(|x| x.to_vec()),
381            parent_order_id: order.parent_order_id(),
382            exec_algorithm_id: order.exec_algorithm_id(),
383            exec_algorithm_params: order.exec_algorithm_params().map(|x| x.to_owned()),
384            exec_spawn_id: order.exec_spawn_id(),
385            tags: order.tags().map(|x| x.to_vec()),
386            event_id: order.init_id(),
387            ts_event: order.ts_init(),
388            ts_init: order.ts_init(),
389            reconciliation: false,
390        }
391    }
392}
393
394#[derive(Clone, Debug, Serialize, Deserialize)]
395pub struct OrderCore {
396    pub events: Vec<OrderEventAny>,
397    pub commissions: IndexMap<Currency, Money>,
398    pub venue_order_ids: Vec<VenueOrderId>,
399    pub trade_ids: Vec<TradeId>,
400    pub previous_status: Option<OrderStatus>,
401    pub status: OrderStatus,
402    pub trader_id: TraderId,
403    pub strategy_id: StrategyId,
404    pub instrument_id: InstrumentId,
405    pub client_order_id: ClientOrderId,
406    pub venue_order_id: Option<VenueOrderId>,
407    pub position_id: Option<PositionId>,
408    pub account_id: Option<AccountId>,
409    pub last_trade_id: Option<TradeId>,
410    pub side: OrderSide,
411    pub order_type: OrderType,
412    pub quantity: Quantity,
413    pub time_in_force: TimeInForce,
414    pub liquidity_side: Option<LiquiditySide>,
415    pub is_reduce_only: bool,
416    pub is_quote_quantity: bool,
417    pub emulation_trigger: Option<TriggerType>,
418    pub contingency_type: Option<ContingencyType>,
419    pub order_list_id: Option<OrderListId>,
420    pub linked_order_ids: Option<Vec<ClientOrderId>>,
421    pub parent_order_id: Option<ClientOrderId>,
422    pub exec_algorithm_id: Option<ExecAlgorithmId>,
423    pub exec_algorithm_params: Option<IndexMap<Ustr, Ustr>>,
424    pub exec_spawn_id: Option<ClientOrderId>,
425    pub tags: Option<Vec<Ustr>>,
426    pub filled_qty: Quantity,
427    pub leaves_qty: Quantity,
428    pub avg_px: Option<f64>,
429    pub slippage: Option<f64>,
430    pub init_id: UUID4,
431    pub ts_init: UnixNanos,
432    pub ts_last: UnixNanos,
433}
434
435impl OrderCore {
436    /// Creates a new [`OrderCore`] instance.
437    pub fn new(init: OrderInitialized) -> Self {
438        let events: Vec<OrderEventAny> = vec![OrderEventAny::Initialized(init.clone())];
439        Self {
440            events,
441            commissions: IndexMap::new(),
442            venue_order_ids: Vec::new(),
443            trade_ids: Vec::new(),
444            previous_status: None,
445            status: OrderStatus::Initialized,
446            trader_id: init.trader_id,
447            strategy_id: init.strategy_id,
448            instrument_id: init.instrument_id,
449            client_order_id: init.client_order_id,
450            venue_order_id: None,
451            position_id: None,
452            account_id: None,
453            last_trade_id: None,
454            side: init.order_side,
455            order_type: init.order_type,
456            quantity: init.quantity,
457            time_in_force: init.time_in_force,
458            liquidity_side: Some(LiquiditySide::NoLiquiditySide),
459            is_reduce_only: init.reduce_only,
460            is_quote_quantity: init.quote_quantity,
461            emulation_trigger: init.emulation_trigger.or(Some(TriggerType::NoTrigger)),
462            contingency_type: init
463                .contingency_type
464                .or(Some(ContingencyType::NoContingency)),
465            order_list_id: init.order_list_id,
466            linked_order_ids: init.linked_order_ids,
467            parent_order_id: init.parent_order_id,
468            exec_algorithm_id: init.exec_algorithm_id,
469            exec_algorithm_params: init.exec_algorithm_params,
470            exec_spawn_id: init.exec_spawn_id,
471            tags: init.tags,
472            filled_qty: Quantity::zero(init.quantity.precision),
473            leaves_qty: init.quantity,
474            avg_px: None,
475            slippage: None,
476            init_id: init.event_id,
477            ts_init: init.ts_event,
478            ts_last: init.ts_event,
479        }
480    }
481
482    pub fn apply(&mut self, event: OrderEventAny) -> Result<(), OrderError> {
483        assert_eq!(self.client_order_id, event.client_order_id());
484        assert_eq!(self.strategy_id, event.strategy_id());
485
486        let new_status = self.status.transition(&event)?;
487        self.previous_status = Some(self.status);
488        self.status = new_status;
489
490        match &event {
491            OrderEventAny::Initialized(_) => return Err(OrderError::AlreadyInitialized),
492            OrderEventAny::Denied(event) => self.denied(event),
493            OrderEventAny::Emulated(event) => self.emulated(event),
494            OrderEventAny::Released(event) => self.released(event),
495            OrderEventAny::Submitted(event) => self.submitted(event),
496            OrderEventAny::Rejected(event) => self.rejected(event),
497            OrderEventAny::Accepted(event) => self.accepted(event),
498            OrderEventAny::PendingUpdate(event) => self.pending_update(event),
499            OrderEventAny::PendingCancel(event) => self.pending_cancel(event),
500            OrderEventAny::ModifyRejected(event) => self.modify_rejected(event),
501            OrderEventAny::CancelRejected(event) => self.cancel_rejected(event),
502            OrderEventAny::Updated(event) => self.updated(event),
503            OrderEventAny::Triggered(event) => self.triggered(event),
504            OrderEventAny::Canceled(event) => self.canceled(event),
505            OrderEventAny::Expired(event) => self.expired(event),
506            OrderEventAny::Filled(event) => self.filled(event),
507        }
508
509        self.ts_last = event.ts_event();
510        self.events.push(event);
511        Ok(())
512    }
513
514    fn denied(&self, _event: &OrderDenied) {
515        // Do nothing else
516    }
517
518    fn emulated(&self, _event: &OrderEmulated) {
519        // Do nothing else
520    }
521
522    fn released(&mut self, _event: &OrderReleased) {
523        self.emulation_trigger = None;
524    }
525
526    fn submitted(&mut self, event: &OrderSubmitted) {
527        self.account_id = Some(event.account_id);
528    }
529
530    fn accepted(&mut self, event: &OrderAccepted) {
531        self.venue_order_id = Some(event.venue_order_id);
532    }
533
534    fn rejected(&self, _event: &OrderRejected) {
535        // Do nothing else
536    }
537
538    fn pending_update(&self, _event: &OrderPendingUpdate) {
539        // Do nothing else
540    }
541
542    fn pending_cancel(&self, _event: &OrderPendingCancel) {
543        // Do nothing else
544    }
545
546    fn modify_rejected(&mut self, _event: &OrderModifyRejected) {
547        self.status = self
548            .previous_status
549            .unwrap_or_else(|| panic!("{}", OrderError::NoPreviousState));
550    }
551
552    fn cancel_rejected(&mut self, _event: &OrderCancelRejected) {
553        self.status = self
554            .previous_status
555            .unwrap_or_else(|| panic!("{}", OrderError::NoPreviousState));
556    }
557
558    fn triggered(&mut self, _event: &OrderTriggered) {}
559
560    fn canceled(&mut self, _event: &OrderCanceled) {}
561
562    fn expired(&mut self, _event: &OrderExpired) {}
563
564    fn updated(&mut self, event: &OrderUpdated) {
565        if let Some(venue_order_id) = &event.venue_order_id {
566            if self.venue_order_id.is_none()
567                || venue_order_id != self.venue_order_id.as_ref().unwrap()
568            {
569                self.venue_order_id = Some(*venue_order_id);
570                self.venue_order_ids.push(*venue_order_id);
571            }
572        }
573    }
574
575    fn filled(&mut self, event: &OrderFilled) {
576        if self.filled_qty + event.last_qty < self.quantity {
577            self.status = OrderStatus::PartiallyFilled;
578        } else {
579            self.status = OrderStatus::Filled;
580        }
581
582        self.venue_order_id = Some(event.venue_order_id);
583        self.position_id = event.position_id;
584        self.trade_ids.push(event.trade_id);
585        self.last_trade_id = Some(event.trade_id);
586        self.liquidity_side = Some(event.liquidity_side);
587        self.filled_qty += event.last_qty;
588        self.leaves_qty -= event.last_qty;
589        self.ts_last = event.ts_event;
590        self.set_avg_px(event.last_qty, event.last_px);
591    }
592
593    fn set_avg_px(&mut self, last_qty: Quantity, last_px: Price) {
594        if self.avg_px.is_none() {
595            self.avg_px = Some(last_px.as_f64());
596        }
597
598        let filled_qty = self.filled_qty.as_f64();
599        let total_qty = filled_qty + last_qty.as_f64();
600
601        let avg_px = self
602            .avg_px
603            .unwrap()
604            .mul_add(filled_qty, last_px.as_f64() * last_qty.as_f64())
605            / total_qty;
606        self.avg_px = Some(avg_px);
607    }
608
609    pub fn set_slippage(&mut self, price: Price) {
610        self.slippage = self.avg_px.and_then(|avg_px| {
611            let current_price = price.as_f64();
612            match self.side {
613                OrderSide::Buy if avg_px > current_price => Some(avg_px - current_price),
614                OrderSide::Sell if avg_px < current_price => Some(current_price - avg_px),
615                _ => None,
616            }
617        });
618    }
619
620    #[must_use]
621    pub fn opposite_side(side: OrderSide) -> OrderSide {
622        match side {
623            OrderSide::Buy => OrderSide::Sell,
624            OrderSide::Sell => OrderSide::Buy,
625            OrderSide::NoOrderSide => OrderSide::NoOrderSide,
626        }
627    }
628
629    #[must_use]
630    pub fn closing_side(side: PositionSide) -> OrderSide {
631        match side {
632            PositionSide::Long => OrderSide::Sell,
633            PositionSide::Short => OrderSide::Buy,
634            PositionSide::Flat => OrderSide::NoOrderSide,
635            PositionSide::NoPositionSide => OrderSide::NoOrderSide,
636        }
637    }
638
639    #[must_use]
640    pub fn signed_decimal_qty(&self) -> Decimal {
641        match self.side {
642            OrderSide::Buy => self.quantity.as_decimal(),
643            OrderSide::Sell => -self.quantity.as_decimal(),
644            _ => panic!("Invalid order side"),
645        }
646    }
647
648    #[must_use]
649    pub fn would_reduce_only(&self, side: PositionSide, position_qty: Quantity) -> bool {
650        if side == PositionSide::Flat {
651            return false;
652        }
653
654        match (self.side, side) {
655            (OrderSide::Buy, PositionSide::Long) => false,
656            (OrderSide::Buy, PositionSide::Short) => self.leaves_qty <= position_qty,
657            (OrderSide::Sell, PositionSide::Short) => false,
658            (OrderSide::Sell, PositionSide::Long) => self.leaves_qty <= position_qty,
659            _ => true,
660        }
661    }
662
663    #[must_use]
664    pub fn commission(&self, currency: &Currency) -> Option<Money> {
665        self.commissions.get(currency).copied()
666    }
667
668    #[must_use]
669    pub fn commissions(&self) -> IndexMap<Currency, Money> {
670        self.commissions.clone()
671    }
672
673    #[must_use]
674    pub fn commissions_vec(&self) -> Vec<Money> {
675        self.commissions.values().cloned().collect()
676    }
677
678    #[must_use]
679    pub fn init_event(&self) -> Option<OrderEventAny> {
680        self.events.first().cloned()
681    }
682}
683
684////////////////////////////////////////////////////////////////////////////////
685// Tests
686////////////////////////////////////////////////////////////////////////////////
687#[cfg(test)]
688mod tests {
689    use rstest::rstest;
690    use rust_decimal_macros::dec;
691
692    use super::*;
693    use crate::{
694        enums::{OrderSide, OrderStatus, PositionSide},
695        events::order::{
696            accepted::OrderAcceptedBuilder, denied::OrderDeniedBuilder, filled::OrderFilledBuilder,
697            initialized::OrderInitializedBuilder, submitted::OrderSubmittedBuilder,
698        },
699        orders::MarketOrder,
700    };
701
702    fn test_initialize_market_order() {
703        let order = MarketOrder::default();
704        assert_eq!(order.events().len(), 1);
705        assert_eq!(
706            stringify!(order.events().get(0)),
707            stringify!(OrderInitialized)
708        );
709    }
710
711    #[rstest]
712    #[case(OrderSide::Buy, OrderSide::Sell)]
713    #[case(OrderSide::Sell, OrderSide::Buy)]
714    #[case(OrderSide::NoOrderSide, OrderSide::NoOrderSide)]
715    fn test_order_opposite_side(#[case] order_side: OrderSide, #[case] expected_side: OrderSide) {
716        let result = OrderCore::opposite_side(order_side);
717        assert_eq!(result, expected_side);
718    }
719
720    #[rstest]
721    #[case(PositionSide::Long, OrderSide::Sell)]
722    #[case(PositionSide::Short, OrderSide::Buy)]
723    #[case(PositionSide::NoPositionSide, OrderSide::NoOrderSide)]
724    fn test_closing_side(#[case] position_side: PositionSide, #[case] expected_side: OrderSide) {
725        let result = OrderCore::closing_side(position_side);
726        assert_eq!(result, expected_side);
727    }
728
729    #[rstest]
730    #[case(OrderSide::Buy, dec!(10_000))]
731    #[case(OrderSide::Sell, dec!(-10_000))]
732    fn test_signed_decimal_qty(#[case] order_side: OrderSide, #[case] expected: Decimal) {
733        let order: MarketOrder = OrderInitializedBuilder::default()
734            .order_side(order_side)
735            .quantity(Quantity::from(10_000))
736            .build()
737            .unwrap()
738            .into();
739
740        let result = order.signed_decimal_qty();
741        assert_eq!(result, expected);
742    }
743
744    #[rustfmt::skip]
745    #[rstest]
746    #[case(OrderSide::Buy, Quantity::from(100), PositionSide::Long, Quantity::from(50), false)]
747    #[case(OrderSide::Buy, Quantity::from(50), PositionSide::Short, Quantity::from(50), true)]
748    #[case(OrderSide::Buy, Quantity::from(50), PositionSide::Short, Quantity::from(100), true)]
749    #[case(OrderSide::Buy, Quantity::from(50), PositionSide::Flat, Quantity::from(0), false)]
750    #[case(OrderSide::Sell, Quantity::from(50), PositionSide::Flat, Quantity::from(0), false)]
751    #[case(OrderSide::Sell, Quantity::from(50), PositionSide::Long, Quantity::from(50), true)]
752    #[case(OrderSide::Sell, Quantity::from(50), PositionSide::Long, Quantity::from(100), true)]
753    #[case(OrderSide::Sell, Quantity::from(100), PositionSide::Short, Quantity::from(50), false)]
754    fn test_would_reduce_only(
755        #[case] order_side: OrderSide,
756        #[case] order_qty: Quantity,
757        #[case] position_side: PositionSide,
758        #[case] position_qty: Quantity,
759        #[case] expected: bool,
760    ) {
761        let order: MarketOrder = OrderInitializedBuilder::default()
762            .order_side(order_side)
763            .quantity(order_qty)
764            .build()
765            .unwrap()
766            .into();
767
768        assert_eq!(
769            order.would_reduce_only(position_side, position_qty),
770            expected
771        );
772    }
773
774    #[rstest]
775    fn test_order_state_transition_denied() {
776        let mut order: MarketOrder = OrderInitializedBuilder::default().build().unwrap().into();
777        let denied = OrderDeniedBuilder::default().build().unwrap();
778        let event = OrderEventAny::Denied(denied);
779
780        order.apply(event.clone()).unwrap();
781
782        assert_eq!(order.status, OrderStatus::Denied);
783        assert!(order.is_closed());
784        assert!(!order.is_open());
785        assert_eq!(order.event_count(), 2);
786        assert_eq!(order.last_event(), &event);
787    }
788
789    #[rstest]
790    fn test_order_life_cycle_to_filled() {
791        let init = OrderInitializedBuilder::default().build().unwrap();
792        let submitted = OrderSubmittedBuilder::default().build().unwrap();
793        let accepted = OrderAcceptedBuilder::default().build().unwrap();
794        let filled = OrderFilledBuilder::default().build().unwrap();
795
796        let mut order: MarketOrder = init.clone().into();
797        order.apply(OrderEventAny::Submitted(submitted)).unwrap();
798        order.apply(OrderEventAny::Accepted(accepted)).unwrap();
799        order.apply(OrderEventAny::Filled(filled)).unwrap();
800
801        assert_eq!(order.client_order_id, init.client_order_id);
802        assert_eq!(order.status(), OrderStatus::Filled);
803        assert_eq!(order.filled_qty(), Quantity::from(100_000));
804        assert_eq!(order.leaves_qty(), Quantity::from(0));
805        assert_eq!(order.avg_px(), Some(1.0));
806        assert!(!order.is_open());
807        assert!(order.is_closed());
808        assert_eq!(order.commission(&Currency::USD()), None);
809        assert_eq!(order.commissions(), IndexMap::new());
810    }
811}
nautilus_model/orders/base.rs

nautilus_model/orders/
base.rs
