Skip to main content

nautilus_model/events/
mod.rs

1// -------------------------------------------------------------------------------------------------
2//  Copyright (C) 2015-2026 Nautech Systems Pty Ltd. All rights reserved.
3//  https://nautechsystems.io
4//
5//  Licensed under the GNU Lesser General Public License Version 3.0 (the "License");
6//  You may not use this file except in compliance with the License.
7//  You may obtain a copy of the License at https://www.gnu.org/licenses/lgpl-3.0.en.html
8//
9//  Unless required by applicable law or agreed to in writing, software
10//  distributed under the License is distributed on an "AS IS" BASIS,
11//  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12//  See the License for the specific language governing permissions and
13//  limitations under the License.
14// -------------------------------------------------------------------------------------------------
15
16//! Events for the trading domain model.
17
18pub mod account;
19pub mod funding;
20pub mod order;
21pub mod portfolio;
22pub mod position;
23
24use nautilus_core::UnixNanos;
25
26use crate::data::HasTsInit;
27// Re-exports
28pub use crate::events::{
29    account::state::AccountState,
30    funding::settlement::FundingSettlement,
31    order::{
32        OrderEvent, OrderEventType,
33        accepted::OrderAccepted,
34        accepted_batch::OrderAcceptedBatch,
35        any::OrderEventAny,
36        cancel_denied::OrderCancelDenied,
37        cancel_rejected::OrderCancelRejected,
38        canceled::OrderCanceled,
39        canceled_batch::OrderCanceledBatch,
40        denied::OrderDenied,
41        denied_reason::{OrderDeniedCode, OrderDeniedReason, OrderPriceField},
42        emulated::OrderEmulated,
43        expired::OrderExpired,
44        fill_voided::OrderFillVoided,
45        filled::OrderFilled,
46        initialized::OrderInitialized,
47        modify_denied::OrderModifyDenied,
48        modify_rejected::OrderModifyRejected,
49        pending_cancel::OrderPendingCancel,
50        pending_update::OrderPendingUpdate,
51        rejected::OrderRejected,
52        released::OrderReleased,
53        snapshot::OrderSnapshot,
54        submitted::OrderSubmitted,
55        submitted_batch::OrderSubmittedBatch,
56        triggered::OrderTriggered,
57        updated::OrderUpdated,
58    },
59    portfolio::snapshot::PortfolioSnapshot,
60    position::{
61        PositionEvent, adjusted::PositionAdjusted, changed::PositionChanged,
62        closed::PositionClosed, opened::PositionOpened, snapshot::PositionSnapshot,
63    },
64};
65
66impl HasTsInit for AccountState {
67    fn ts_init(&self) -> UnixNanos {
68        self.ts_init
69    }
70}
71
72impl HasTsInit for FundingSettlement {
73    fn ts_init(&self) -> UnixNanos {
74        self.ts_init
75    }
76}
77
78impl HasTsInit for OrderInitialized {
79    fn ts_init(&self) -> UnixNanos {
80        self.ts_init
81    }
82}
83
84impl HasTsInit for OrderDenied {
85    fn ts_init(&self) -> UnixNanos {
86        self.ts_init
87    }
88}
89
90impl HasTsInit for OrderModifyDenied {
91    fn ts_init(&self) -> UnixNanos {
92        self.ts_init
93    }
94}
95
96impl HasTsInit for OrderCancelDenied {
97    fn ts_init(&self) -> UnixNanos {
98        self.ts_init
99    }
100}
101
102impl HasTsInit for OrderEmulated {
103    fn ts_init(&self) -> UnixNanos {
104        self.ts_init
105    }
106}
107
108impl HasTsInit for OrderSubmitted {
109    fn ts_init(&self) -> UnixNanos {
110        self.ts_init
111    }
112}
113
114impl HasTsInit for OrderAccepted {
115    fn ts_init(&self) -> UnixNanos {
116        self.ts_init
117    }
118}
119
120impl HasTsInit for OrderRejected {
121    fn ts_init(&self) -> UnixNanos {
122        self.ts_init
123    }
124}
125
126impl HasTsInit for OrderPendingCancel {
127    fn ts_init(&self) -> UnixNanos {
128        self.ts_init
129    }
130}
131
132impl HasTsInit for OrderCanceled {
133    fn ts_init(&self) -> UnixNanos {
134        self.ts_init
135    }
136}
137
138impl HasTsInit for OrderCancelRejected {
139    fn ts_init(&self) -> UnixNanos {
140        self.ts_init
141    }
142}
143
144impl HasTsInit for OrderExpired {
145    fn ts_init(&self) -> UnixNanos {
146        self.ts_init
147    }
148}
149
150impl HasTsInit for OrderTriggered {
151    fn ts_init(&self) -> UnixNanos {
152        self.ts_init
153    }
154}
155
156impl HasTsInit for OrderPendingUpdate {
157    fn ts_init(&self) -> UnixNanos {
158        self.ts_init
159    }
160}
161
162impl HasTsInit for OrderReleased {
163    fn ts_init(&self) -> UnixNanos {
164        self.ts_init
165    }
166}
167
168impl HasTsInit for OrderModifyRejected {
169    fn ts_init(&self) -> UnixNanos {
170        self.ts_init
171    }
172}
173
174impl HasTsInit for OrderUpdated {
175    fn ts_init(&self) -> UnixNanos {
176        self.ts_init
177    }
178}
179
180impl HasTsInit for OrderFilled {
181    fn ts_init(&self) -> UnixNanos {
182        self.ts_init
183    }
184}
185
186impl HasTsInit for OrderFillVoided {
187    fn ts_init(&self) -> UnixNanos {
188        self.ts_init
189    }
190}
191
192impl HasTsInit for OrderSnapshot {
193    fn ts_init(&self) -> UnixNanos {
194        self.ts_init
195    }
196}
197
198impl HasTsInit for PositionOpened {
199    fn ts_init(&self) -> UnixNanos {
200        self.ts_init
201    }
202}
203
204impl HasTsInit for PositionChanged {
205    fn ts_init(&self) -> UnixNanos {
206        self.ts_init
207    }
208}
209
210impl HasTsInit for PositionClosed {
211    fn ts_init(&self) -> UnixNanos {
212        self.ts_init
213    }
214}
215
216impl HasTsInit for PositionAdjusted {
217    fn ts_init(&self) -> UnixNanos {
218        self.ts_init
219    }
220}
221
222impl HasTsInit for PositionSnapshot {
223    fn ts_init(&self) -> UnixNanos {
224        self.ts_init
225    }
226}
227
228impl HasTsInit for PortfolioSnapshot {
229    fn ts_init(&self) -> UnixNanos {
230        self.ts_init
231    }
232}
233
234#[cfg(test)]
235mod tests {
236    use nautilus_core::UUID4;
237    use rstest::rstest;
238    use rust_decimal_macros::dec;
239
240    use super::*;
241    use crate::{
242        enums::{AccountType, OrderSide, OrderType, PositionAdjustmentType},
243        events::order::spec::{
244            OrderAcceptedSpec, OrderCancelRejectedSpec, OrderCanceledSpec, OrderDeniedSpec,
245            OrderEmulatedSpec, OrderExpiredSpec, OrderFillVoidedSpec, OrderFilledSpec,
246            OrderInitializedSpec, OrderModifyRejectedSpec, OrderPendingCancelSpec,
247            OrderPendingUpdateSpec, OrderRejectedSpec, OrderReleasedSpec, OrderSubmittedSpec,
248            OrderTriggeredSpec, OrderUpdatedSpec,
249        },
250        identifiers::{AccountId, InstrumentId, PositionId, StrategyId, TraderId},
251        orders::builder::OrderTestBuilder,
252        position::Position,
253        stubs::stub_position_long,
254        types::{Currency, Money, Price, Quantity},
255    };
256
257    #[rstest]
258    fn test_order_lifecycle_event_ts_init() {
259        let ts_init = UnixNanos::from(1);
260
261        assert_eq!(
262            HasTsInit::ts_init(&OrderInitializedSpec::builder().ts_init(ts_init).build()),
263            ts_init
264        );
265        assert_eq!(
266            HasTsInit::ts_init(&OrderDeniedSpec::builder().ts_init(ts_init).build()),
267            ts_init
268        );
269        assert_eq!(
270            HasTsInit::ts_init(&OrderEmulatedSpec::builder().ts_init(ts_init).build()),
271            ts_init
272        );
273        assert_eq!(
274            HasTsInit::ts_init(&OrderReleasedSpec::builder().ts_init(ts_init).build()),
275            ts_init
276        );
277        assert_eq!(
278            HasTsInit::ts_init(&OrderSubmittedSpec::builder().ts_init(ts_init).build()),
279            ts_init
280        );
281        assert_eq!(
282            HasTsInit::ts_init(&OrderAcceptedSpec::builder().ts_init(ts_init).build()),
283            ts_init
284        );
285        assert_eq!(
286            HasTsInit::ts_init(&OrderRejectedSpec::builder().ts_init(ts_init).build()),
287            ts_init
288        );
289        assert_eq!(
290            HasTsInit::ts_init(&OrderTriggeredSpec::builder().ts_init(ts_init).build()),
291            ts_init
292        );
293        assert_eq!(
294            HasTsInit::ts_init(&OrderExpiredSpec::builder().ts_init(ts_init).build()),
295            ts_init
296        );
297        assert_eq!(
298            HasTsInit::ts_init(&OrderCanceledSpec::builder().ts_init(ts_init).build()),
299            ts_init
300        );
301    }
302
303    #[rstest]
304    fn test_order_amendment_event_ts_init() {
305        let ts_init = UnixNanos::from(2);
306
307        assert_eq!(
308            HasTsInit::ts_init(&OrderPendingUpdateSpec::builder().ts_init(ts_init).build()),
309            ts_init
310        );
311        assert_eq!(
312            HasTsInit::ts_init(&OrderPendingCancelSpec::builder().ts_init(ts_init).build()),
313            ts_init
314        );
315        assert_eq!(
316            HasTsInit::ts_init(&OrderModifyRejectedSpec::builder().ts_init(ts_init).build()),
317            ts_init
318        );
319        assert_eq!(
320            HasTsInit::ts_init(&OrderCancelRejectedSpec::builder().ts_init(ts_init).build()),
321            ts_init
322        );
323        assert_eq!(
324            HasTsInit::ts_init(&OrderUpdatedSpec::builder().ts_init(ts_init).build()),
325            ts_init
326        );
327    }
328
329    #[rstest]
330    fn test_order_fill_event_ts_init() {
331        let ts_init = UnixNanos::from(3);
332
333        assert_eq!(
334            HasTsInit::ts_init(&OrderFilledSpec::builder().ts_init(ts_init).build()),
335            ts_init
336        );
337        assert_eq!(
338            HasTsInit::ts_init(&OrderFillVoidedSpec::builder().ts_init(ts_init).build()),
339            ts_init
340        );
341    }
342
343    #[rstest]
344    fn test_order_snapshot_ts_init() {
345        let ts_init = UnixNanos::from(4);
346        let order = OrderTestBuilder::new(OrderType::Market)
347            .instrument_id(InstrumentId::from("AUD/USD.SIM"))
348            .side(OrderSide::Buy)
349            .quantity(Quantity::from(1))
350            .build();
351        let mut snapshot = OrderSnapshot::from(order);
352        snapshot.ts_init = ts_init;
353
354        assert_eq!(HasTsInit::ts_init(&snapshot), ts_init);
355    }
356
357    #[rstest]
358    fn test_position_event_ts_init(mut stub_position_long: Position) {
359        let ts_init = UnixNanos::from(5);
360        let event_id = UUID4::default();
361        let fill = stub_position_long.last_event().unwrap();
362
363        assert_eq!(
364            HasTsInit::ts_init(&PositionOpened::create(
365                &stub_position_long,
366                &fill,
367                event_id,
368                ts_init
369            )),
370            ts_init
371        );
372        assert_eq!(
373            HasTsInit::ts_init(&PositionChanged::create(
374                &stub_position_long,
375                &fill,
376                event_id,
377                ts_init
378            )),
379            ts_init
380        );
381        assert_eq!(
382            HasTsInit::ts_init(&PositionClosed::create(
383                &stub_position_long,
384                &fill,
385                event_id,
386                ts_init
387            )),
388            ts_init
389        );
390
391        stub_position_long.ts_init = ts_init;
392
393        assert_eq!(
394            HasTsInit::ts_init(&PositionSnapshot::from(&stub_position_long, None)),
395            ts_init
396        );
397    }
398
399    #[rstest]
400    fn test_position_adjusted_ts_init() {
401        let ts_init = UnixNanos::from(6);
402
403        let event = PositionAdjusted::new(
404            TraderId::from("TRADER-001"),
405            StrategyId::from("EMA-CROSS"),
406            InstrumentId::from("AUD/USD.SIM"),
407            PositionId::from("P-001"),
408            AccountId::from("SIM-001"),
409            PositionAdjustmentType::Funding,
410            None,
411            Some(Money::new(1.0, Currency::USD())),
412            None,
413            UUID4::default(),
414            UnixNanos::from(5),
415            ts_init,
416        );
417
418        assert_eq!(HasTsInit::ts_init(&event), ts_init);
419    }
420
421    #[rstest]
422    fn test_account_state_ts_init() {
423        let ts_init = UnixNanos::from(7);
424
425        let event = AccountState::new(
426            AccountId::from("SIM-001"),
427            AccountType::Cash,
428            vec![],
429            vec![],
430            true,
431            UUID4::default(),
432            UnixNanos::from(6),
433            ts_init,
434            Some(Currency::USD()),
435        );
436
437        assert_eq!(HasTsInit::ts_init(&event), ts_init);
438    }
439
440    #[rstest]
441    fn test_portfolio_snapshot_ts_init() {
442        let ts_init = UnixNanos::from(8);
443
444        let event = PortfolioSnapshot::new(
445            AccountId::from("SIM-001"),
446            AccountType::Cash,
447            Some(Currency::USD()),
448            vec![],
449            vec![],
450            vec![],
451            vec![],
452            vec![],
453            None,
454            false,
455            vec![],
456            vec![],
457            vec![],
458            UUID4::default(),
459            UnixNanos::from(7),
460            ts_init,
461        );
462
463        assert_eq!(HasTsInit::ts_init(&event), ts_init);
464    }
465
466    #[rstest]
467    fn test_funding_settlement_ts_init() {
468        let ts_init = UnixNanos::from(9);
469
470        let event = FundingSettlement::new(
471            TraderId::from("TRADER-001"),
472            InstrumentId::from("AUD/USD.SIM"),
473            AccountId::from("SIM-001"),
474            dec!(0.0001),
475            Price::from("1.00000"),
476            Currency::USD(),
477            UUID4::default(),
478            UnixNanos::from(8),
479            ts_init,
480        );
481
482        assert_eq!(HasTsInit::ts_init(&event), ts_init);
483    }
484}