Skip to main content

nautilus_serialization/arrow/
order_event.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::collections::HashMap;
17
18use arrow::{datatypes::Schema, error::ArrowError, record_batch::RecordBatch};
19use nautilus_model::events::{
20    OrderAccepted, OrderCancelDenied, OrderCancelRejected, OrderCanceled, OrderDenied,
21    OrderEmulated, OrderExpired, OrderFillVoided, OrderFilled, OrderInitialized, OrderModifyDenied,
22    OrderModifyRejected, OrderPendingCancel, OrderPendingUpdate, OrderRejected, OrderReleased,
23    OrderSubmitted, OrderTriggered, OrderUpdated,
24};
25
26use super::{
27    ArrowSchemaProvider, DecodeTypedFromRecordBatch, EncodeToRecordBatch, EncodingError,
28    KEY_INSTRUMENT_ID,
29    json::{JsonFieldSpec, decode_batch, encode_batch, metadata_for_type, schema_for_type},
30};
31
32const ORDER_INITIALIZED_FIELDS: &[JsonFieldSpec] = &[
33    JsonFieldSpec::utf8("trader_id", false),
34    JsonFieldSpec::utf8("strategy_id", false),
35    JsonFieldSpec::utf8("instrument_id", false),
36    JsonFieldSpec::utf8("client_order_id", false),
37    JsonFieldSpec::utf8("order_side", false),
38    JsonFieldSpec::utf8("order_type", false),
39    JsonFieldSpec::utf8("quantity", false),
40    JsonFieldSpec::utf8("time_in_force", false),
41    JsonFieldSpec::boolean("post_only", false),
42    JsonFieldSpec::boolean("reduce_only", false),
43    JsonFieldSpec::boolean("quote_quantity", false),
44    JsonFieldSpec::boolean("reconciliation", false),
45    JsonFieldSpec::utf8("event_id", false),
46    JsonFieldSpec::timestamp("ts_event", false),
47    JsonFieldSpec::timestamp("ts_init", false),
48    JsonFieldSpec::utf8("price", true),
49    JsonFieldSpec::utf8("trigger_price", true),
50    JsonFieldSpec::utf8("trigger_type", true),
51    JsonFieldSpec::utf8("limit_offset", true),
52    JsonFieldSpec::utf8("trailing_offset", true),
53    JsonFieldSpec::utf8("trailing_offset_type", true),
54    JsonFieldSpec::timestamp("expire_time", true),
55    JsonFieldSpec::utf8("display_qty", true),
56    JsonFieldSpec::utf8("emulation_trigger", true),
57    JsonFieldSpec::utf8("trigger_instrument_id", true),
58    JsonFieldSpec::utf8("contingency_type", true),
59    JsonFieldSpec::utf8("order_list_id", true),
60    JsonFieldSpec::utf8_json("linked_order_ids", true),
61    JsonFieldSpec::utf8("parent_order_id", true),
62    JsonFieldSpec::utf8("exec_algorithm_id", true),
63    JsonFieldSpec::utf8_json("exec_algorithm_params", true),
64    JsonFieldSpec::utf8("exec_spawn_id", true),
65    JsonFieldSpec::utf8_json("tags", true),
66    // Appended (not inserted) so older batches without this column fail with a clean
67    // `MissingColumn` error rather than silently reading a shifted column.
68    JsonFieldSpec::utf8("activation_price", true),
69];
70
71const ORDER_DENIED_FIELDS: &[JsonFieldSpec] = &[
72    JsonFieldSpec::utf8("trader_id", false),
73    JsonFieldSpec::utf8("strategy_id", false),
74    JsonFieldSpec::utf8("instrument_id", false),
75    JsonFieldSpec::utf8("client_order_id", false),
76    JsonFieldSpec::utf8("reason", false),
77    JsonFieldSpec::utf8("event_id", false),
78    JsonFieldSpec::timestamp("ts_event", false),
79    JsonFieldSpec::timestamp("ts_init", false),
80];
81
82const ORDER_COMMAND_DENIED_FIELDS: &[JsonFieldSpec] = &[
83    JsonFieldSpec::utf8("trader_id", false),
84    JsonFieldSpec::utf8("strategy_id", false),
85    JsonFieldSpec::utf8("instrument_id", false),
86    JsonFieldSpec::utf8("client_order_id", false),
87    JsonFieldSpec::utf8("reason", false),
88    JsonFieldSpec::utf8("event_id", false),
89    JsonFieldSpec::timestamp("ts_event", false),
90    JsonFieldSpec::timestamp("ts_init", false),
91    JsonFieldSpec::utf8("venue_order_id", true),
92    JsonFieldSpec::utf8("account_id", true),
93    JsonFieldSpec::utf8("causation_id", true),
94];
95
96const ORDER_EMULATED_FIELDS: &[JsonFieldSpec] = &[
97    JsonFieldSpec::utf8("trader_id", false),
98    JsonFieldSpec::utf8("strategy_id", false),
99    JsonFieldSpec::utf8("instrument_id", false),
100    JsonFieldSpec::utf8("client_order_id", false),
101    JsonFieldSpec::utf8("event_id", false),
102    JsonFieldSpec::timestamp("ts_event", false),
103    JsonFieldSpec::timestamp("ts_init", false),
104];
105
106const ORDER_SUBMITTED_FIELDS: &[JsonFieldSpec] = &[
107    JsonFieldSpec::utf8("trader_id", false),
108    JsonFieldSpec::utf8("strategy_id", false),
109    JsonFieldSpec::utf8("instrument_id", false),
110    JsonFieldSpec::utf8("client_order_id", false),
111    JsonFieldSpec::utf8("account_id", false),
112    JsonFieldSpec::utf8("event_id", false),
113    JsonFieldSpec::timestamp("ts_event", false),
114    JsonFieldSpec::timestamp("ts_init", false),
115];
116
117const ORDER_ACCEPTED_FIELDS: &[JsonFieldSpec] = &[
118    JsonFieldSpec::utf8("trader_id", false),
119    JsonFieldSpec::utf8("strategy_id", false),
120    JsonFieldSpec::utf8("instrument_id", false),
121    JsonFieldSpec::utf8("client_order_id", false),
122    JsonFieldSpec::utf8("venue_order_id", false),
123    JsonFieldSpec::utf8("account_id", false),
124    JsonFieldSpec::utf8("event_id", false),
125    JsonFieldSpec::timestamp("ts_event", false),
126    JsonFieldSpec::timestamp("ts_init", false),
127    JsonFieldSpec::boolean("reconciliation", false),
128];
129
130const ORDER_REJECTED_FIELDS: &[JsonFieldSpec] = &[
131    JsonFieldSpec::utf8("trader_id", false),
132    JsonFieldSpec::utf8("strategy_id", false),
133    JsonFieldSpec::utf8("instrument_id", false),
134    JsonFieldSpec::utf8("client_order_id", false),
135    JsonFieldSpec::utf8("account_id", false),
136    JsonFieldSpec::utf8("reason", false),
137    JsonFieldSpec::utf8("event_id", false),
138    JsonFieldSpec::timestamp("ts_event", false),
139    JsonFieldSpec::timestamp("ts_init", false),
140    JsonFieldSpec::boolean("reconciliation", false),
141    JsonFieldSpec::boolean("due_post_only", false),
142];
143
144const ORDER_PENDING_CANCEL_FIELDS: &[JsonFieldSpec] = &[
145    JsonFieldSpec::utf8("trader_id", false),
146    JsonFieldSpec::utf8("strategy_id", false),
147    JsonFieldSpec::utf8("instrument_id", false),
148    JsonFieldSpec::utf8("client_order_id", false),
149    JsonFieldSpec::utf8("account_id", true),
150    JsonFieldSpec::utf8("event_id", false),
151    JsonFieldSpec::timestamp("ts_event", false),
152    JsonFieldSpec::timestamp("ts_init", false),
153    JsonFieldSpec::boolean("reconciliation", false),
154    JsonFieldSpec::utf8("venue_order_id", true),
155    JsonFieldSpec::utf8("causation_id", true),
156];
157
158const ORDER_CANCELED_FIELDS: &[JsonFieldSpec] = &[
159    JsonFieldSpec::utf8("trader_id", false),
160    JsonFieldSpec::utf8("strategy_id", false),
161    JsonFieldSpec::utf8("instrument_id", false),
162    JsonFieldSpec::utf8("client_order_id", false),
163    JsonFieldSpec::utf8("event_id", false),
164    JsonFieldSpec::timestamp("ts_event", false),
165    JsonFieldSpec::timestamp("ts_init", false),
166    JsonFieldSpec::boolean("reconciliation", false),
167    JsonFieldSpec::utf8("venue_order_id", true),
168    JsonFieldSpec::utf8("account_id", true),
169];
170
171const ORDER_CANCEL_REJECTED_FIELDS: &[JsonFieldSpec] = &[
172    JsonFieldSpec::utf8("trader_id", false),
173    JsonFieldSpec::utf8("strategy_id", false),
174    JsonFieldSpec::utf8("instrument_id", false),
175    JsonFieldSpec::utf8("client_order_id", false),
176    JsonFieldSpec::utf8("reason", false),
177    JsonFieldSpec::utf8("event_id", false),
178    JsonFieldSpec::timestamp("ts_event", false),
179    JsonFieldSpec::timestamp("ts_init", false),
180    JsonFieldSpec::boolean("reconciliation", false),
181    JsonFieldSpec::utf8("venue_order_id", true),
182    JsonFieldSpec::utf8("account_id", true),
183    JsonFieldSpec::utf8("causation_id", true),
184];
185
186const ORDER_EXPIRED_FIELDS: &[JsonFieldSpec] = &[
187    JsonFieldSpec::utf8("trader_id", false),
188    JsonFieldSpec::utf8("strategy_id", false),
189    JsonFieldSpec::utf8("instrument_id", false),
190    JsonFieldSpec::utf8("client_order_id", false),
191    JsonFieldSpec::utf8("event_id", false),
192    JsonFieldSpec::timestamp("ts_event", false),
193    JsonFieldSpec::timestamp("ts_init", false),
194    JsonFieldSpec::boolean("reconciliation", false),
195    JsonFieldSpec::utf8("venue_order_id", true),
196    JsonFieldSpec::utf8("account_id", true),
197];
198
199const ORDER_TRIGGERED_FIELDS: &[JsonFieldSpec] = &[
200    JsonFieldSpec::utf8("trader_id", false),
201    JsonFieldSpec::utf8("strategy_id", false),
202    JsonFieldSpec::utf8("instrument_id", false),
203    JsonFieldSpec::utf8("client_order_id", false),
204    JsonFieldSpec::utf8("event_id", false),
205    JsonFieldSpec::timestamp("ts_event", false),
206    JsonFieldSpec::timestamp("ts_init", false),
207    JsonFieldSpec::boolean("reconciliation", false),
208    JsonFieldSpec::utf8("venue_order_id", true),
209    JsonFieldSpec::utf8("account_id", true),
210];
211
212const ORDER_PENDING_UPDATE_FIELDS: &[JsonFieldSpec] = &[
213    JsonFieldSpec::utf8("trader_id", false),
214    JsonFieldSpec::utf8("strategy_id", false),
215    JsonFieldSpec::utf8("instrument_id", false),
216    JsonFieldSpec::utf8("client_order_id", false),
217    JsonFieldSpec::utf8("account_id", true),
218    JsonFieldSpec::utf8("event_id", false),
219    JsonFieldSpec::timestamp("ts_event", false),
220    JsonFieldSpec::timestamp("ts_init", false),
221    JsonFieldSpec::boolean("reconciliation", false),
222    JsonFieldSpec::utf8("venue_order_id", true),
223    JsonFieldSpec::utf8("causation_id", true),
224];
225
226const ORDER_RELEASED_FIELDS: &[JsonFieldSpec] = &[
227    JsonFieldSpec::utf8("trader_id", false),
228    JsonFieldSpec::utf8("strategy_id", false),
229    JsonFieldSpec::utf8("instrument_id", false),
230    JsonFieldSpec::utf8("client_order_id", false),
231    JsonFieldSpec::utf8("released_price", false),
232    JsonFieldSpec::utf8("event_id", false),
233    JsonFieldSpec::timestamp("ts_event", false),
234    JsonFieldSpec::timestamp("ts_init", false),
235];
236
237const ORDER_MODIFY_REJECTED_FIELDS: &[JsonFieldSpec] = &[
238    JsonFieldSpec::utf8("trader_id", false),
239    JsonFieldSpec::utf8("strategy_id", false),
240    JsonFieldSpec::utf8("instrument_id", false),
241    JsonFieldSpec::utf8("client_order_id", false),
242    JsonFieldSpec::utf8("reason", false),
243    JsonFieldSpec::utf8("event_id", false),
244    JsonFieldSpec::timestamp("ts_event", false),
245    JsonFieldSpec::timestamp("ts_init", false),
246    JsonFieldSpec::boolean("reconciliation", false),
247    JsonFieldSpec::utf8("venue_order_id", true),
248    JsonFieldSpec::utf8("account_id", true),
249    JsonFieldSpec::utf8("causation_id", true),
250];
251
252const ORDER_UPDATED_FIELDS: &[JsonFieldSpec] = &[
253    JsonFieldSpec::utf8("trader_id", false),
254    JsonFieldSpec::utf8("strategy_id", false),
255    JsonFieldSpec::utf8("instrument_id", false),
256    JsonFieldSpec::utf8("client_order_id", false),
257    JsonFieldSpec::utf8("venue_order_id", true),
258    JsonFieldSpec::utf8("account_id", true),
259    JsonFieldSpec::utf8("quantity", false),
260    JsonFieldSpec::utf8("price", true),
261    JsonFieldSpec::utf8("trigger_price", true),
262    JsonFieldSpec::utf8("protection_price", true),
263    JsonFieldSpec::boolean("is_quote_quantity", false),
264    JsonFieldSpec::utf8("event_id", false),
265    JsonFieldSpec::timestamp("ts_event", false),
266    JsonFieldSpec::timestamp("ts_init", false),
267    JsonFieldSpec::boolean("reconciliation", false),
268    JsonFieldSpec::utf8("causation_id", true),
269];
270
271const ORDER_FILLED_FIELDS: &[JsonFieldSpec] = &[
272    JsonFieldSpec::utf8("trader_id", false),
273    JsonFieldSpec::utf8("strategy_id", false),
274    JsonFieldSpec::utf8("instrument_id", false),
275    JsonFieldSpec::utf8("client_order_id", false),
276    JsonFieldSpec::utf8("venue_order_id", false),
277    JsonFieldSpec::utf8("account_id", false),
278    JsonFieldSpec::utf8("trade_id", false),
279    JsonFieldSpec::utf8("order_side", false),
280    JsonFieldSpec::utf8("order_type", false),
281    JsonFieldSpec::utf8("last_qty", false),
282    JsonFieldSpec::utf8("last_px", false),
283    JsonFieldSpec::utf8("currency", false),
284    JsonFieldSpec::utf8("liquidity_side", false),
285    JsonFieldSpec::utf8("event_id", false),
286    JsonFieldSpec::timestamp("ts_event", false),
287    JsonFieldSpec::timestamp("ts_init", false),
288    JsonFieldSpec::boolean("reconciliation", false),
289    JsonFieldSpec::utf8("position_id", true),
290    JsonFieldSpec::utf8("commission", true),
291    JsonFieldSpec::utf8_json("info", true),
292];
293
294const ORDER_FILL_VOIDED_FIELDS: &[JsonFieldSpec] = &[
295    JsonFieldSpec::utf8("trader_id", false),
296    JsonFieldSpec::utf8("strategy_id", false),
297    JsonFieldSpec::utf8("instrument_id", false),
298    JsonFieldSpec::utf8("client_order_id", false),
299    JsonFieldSpec::utf8("venue_order_id", false),
300    JsonFieldSpec::utf8("account_id", false),
301    JsonFieldSpec::utf8("correction_id", false),
302    JsonFieldSpec::utf8("trade_id", false),
303    JsonFieldSpec::utf8("voided_qty", false),
304    JsonFieldSpec::utf8("commission_voided", true),
305    JsonFieldSpec::utf8("order_side", false),
306    JsonFieldSpec::utf8("order_type", false),
307    JsonFieldSpec::utf8("last_px", false),
308    JsonFieldSpec::utf8("currency", false),
309    JsonFieldSpec::utf8("liquidity_side", false),
310    JsonFieldSpec::utf8("position_id", true),
311    JsonFieldSpec::utf8("reason", true),
312    JsonFieldSpec::utf8_json("info", true),
313    JsonFieldSpec::utf8("event_id", false),
314    JsonFieldSpec::timestamp("ts_event", false),
315    JsonFieldSpec::timestamp("ts_init", false),
316    JsonFieldSpec::boolean("reconciliation", false),
317    JsonFieldSpec::boolean("is_reopened", false),
318    JsonFieldSpec::utf8("causation_id", true),
319];
320
321fn instrument_metadata(type_name: &'static str, instrument_id: &str) -> HashMap<String, String> {
322    let mut metadata = metadata_for_type(type_name);
323    metadata.insert(KEY_INSTRUMENT_ID.to_string(), instrument_id.to_string());
324    metadata
325}
326
327macro_rules! impl_order_event_arrow {
328    ($type:ty, $type_name:expr, $fields:expr) => {
329        impl ArrowSchemaProvider for $type {
330            fn get_schema(metadata: Option<HashMap<String, String>>) -> Schema {
331                schema_for_type($type_name, metadata, $fields)
332            }
333        }
334
335        impl EncodeToRecordBatch for $type {
336            fn encode_batch<T>(
337                metadata: &HashMap<String, String>,
338                data: &[T],
339            ) -> Result<RecordBatch, ArrowError>
340            where
341                T: std::borrow::Borrow<Self>,
342            {
343                encode_batch(
344                    $type_name,
345                    metadata,
346                    data.iter().map(std::borrow::Borrow::borrow),
347                    $fields,
348                )
349            }
350
351            fn metadata(&self) -> HashMap<String, String> {
352                instrument_metadata($type_name, &self.instrument_id.to_string())
353            }
354        }
355
356        impl DecodeTypedFromRecordBatch for $type {
357            fn decode_typed_batch(
358                metadata: &HashMap<String, String>,
359                record_batch: RecordBatch,
360            ) -> Result<Vec<Self>, EncodingError> {
361                if record_batch.column_by_name("causation_id").is_none() {
362                    let fields: Vec<_> = $fields
363                        .iter()
364                        .copied()
365                        .filter(|field| field.name != "causation_id")
366                        .collect();
367                    return decode_batch(metadata, &record_batch, &fields, Some($type_name));
368                }
369                decode_batch(metadata, &record_batch, $fields, Some($type_name))
370            }
371        }
372    };
373}
374
375impl_order_event_arrow!(
376    OrderInitialized,
377    "OrderInitialized",
378    ORDER_INITIALIZED_FIELDS
379);
380impl_order_event_arrow!(OrderDenied, "OrderDenied", ORDER_DENIED_FIELDS);
381impl_order_event_arrow!(
382    OrderModifyDenied,
383    "OrderModifyDenied",
384    ORDER_COMMAND_DENIED_FIELDS
385);
386impl_order_event_arrow!(
387    OrderCancelDenied,
388    "OrderCancelDenied",
389    ORDER_COMMAND_DENIED_FIELDS
390);
391impl_order_event_arrow!(OrderEmulated, "OrderEmulated", ORDER_EMULATED_FIELDS);
392impl_order_event_arrow!(OrderSubmitted, "OrderSubmitted", ORDER_SUBMITTED_FIELDS);
393impl_order_event_arrow!(OrderAccepted, "OrderAccepted", ORDER_ACCEPTED_FIELDS);
394impl_order_event_arrow!(OrderRejected, "OrderRejected", ORDER_REJECTED_FIELDS);
395impl_order_event_arrow!(
396    OrderPendingCancel,
397    "OrderPendingCancel",
398    ORDER_PENDING_CANCEL_FIELDS
399);
400impl_order_event_arrow!(OrderCanceled, "OrderCanceled", ORDER_CANCELED_FIELDS);
401impl_order_event_arrow!(
402    OrderCancelRejected,
403    "OrderCancelRejected",
404    ORDER_CANCEL_REJECTED_FIELDS
405);
406impl_order_event_arrow!(OrderExpired, "OrderExpired", ORDER_EXPIRED_FIELDS);
407impl_order_event_arrow!(OrderTriggered, "OrderTriggered", ORDER_TRIGGERED_FIELDS);
408impl_order_event_arrow!(
409    OrderPendingUpdate,
410    "OrderPendingUpdate",
411    ORDER_PENDING_UPDATE_FIELDS
412);
413impl_order_event_arrow!(OrderReleased, "OrderReleased", ORDER_RELEASED_FIELDS);
414impl_order_event_arrow!(
415    OrderModifyRejected,
416    "OrderModifyRejected",
417    ORDER_MODIFY_REJECTED_FIELDS
418);
419impl_order_event_arrow!(OrderUpdated, "OrderUpdated", ORDER_UPDATED_FIELDS);
420impl_order_event_arrow!(OrderFilled, "OrderFilled", ORDER_FILLED_FIELDS);
421impl_order_event_arrow!(OrderFillVoided, "OrderFillVoided", ORDER_FILL_VOIDED_FIELDS);
422
423#[cfg(test)]
424mod tests {
425    use std::str::FromStr;
426
427    use indexmap::IndexMap;
428    use nautilus_core::UUID4;
429    use nautilus_model::{
430        events::order::{
431            spec::OrderFillVoidedSpec,
432            stubs::{
433                order_accepted, order_cancel_rejected, order_denied_max_submitted_rate,
434                order_emulated, order_expired, order_filled, order_initialized_buy_limit,
435                order_modify_rejected, order_pending_cancel, order_pending_update,
436                order_rejected_insufficient_margin, order_released, order_submitted,
437                order_triggered, order_updated,
438            },
439        },
440        identifiers::PositionId,
441        types::{Money, Quantity},
442    };
443    use rstest::rstest;
444    use rust_decimal::Decimal;
445    use ustr::Ustr;
446
447    use super::*;
448
449    #[rstest]
450    fn test_order_initialized_round_trip(order_initialized_buy_limit: OrderInitialized) {
451        let event = OrderInitialized {
452            limit_offset: Some(Decimal::from_str("0.123456789123456789").unwrap()),
453            trailing_offset: Some(Decimal::from_str("0.987654321987654321").unwrap()),
454            ..order_initialized_buy_limit
455        };
456        let metadata = event.metadata();
457        let batch =
458            OrderInitialized::encode_batch(&metadata, std::slice::from_ref(&event)).unwrap();
459        let decoded =
460            OrderInitialized::decode_typed_batch(batch.schema().metadata(), batch).unwrap();
461
462        assert_eq!(decoded, vec![event]);
463    }
464
465    #[rstest]
466    fn test_order_filled_round_trip(order_filled: OrderFilled) {
467        let event = order_filled;
468        let metadata = event.metadata();
469        let batch = OrderFilled::encode_batch(&metadata, std::slice::from_ref(&event)).unwrap();
470        let decoded = OrderFilled::decode_typed_batch(batch.schema().metadata(), batch).unwrap();
471
472        assert_eq!(decoded, vec![event]);
473    }
474
475    #[rstest]
476    fn test_order_filled_exact_usd_round_trip(mut order_filled: OrderFilled) {
477        order_filled.commission = Some(Money::from_str_exact("0.000001 USD").unwrap());
478        let metadata = order_filled.metadata();
479        let batch =
480            OrderFilled::encode_batch(&metadata, std::slice::from_ref(&order_filled)).unwrap();
481        let decoded = OrderFilled::decode_typed_batch(batch.schema().metadata(), batch).unwrap();
482
483        assert_eq!(decoded, vec![order_filled]);
484    }
485
486    #[rstest]
487    fn test_order_fill_voided_round_trip() {
488        roundtrip(OrderFillVoidedSpec::builder().is_reopened(true).build());
489    }
490
491    #[rstest]
492    fn test_order_fill_voided_populated_optionals_round_trip() {
493        let mut event = OrderFillVoidedSpec::builder()
494            .voided_qty(Quantity::from("0.561000"))
495            .commission_voided(Money::from("12.20000000 USDT"))
496            .position_id(PositionId::from("P-001"))
497            .reason(Ustr::from("VENUE_VOID"))
498            .info(IndexMap::from([(Ustr::from("source"), Ustr::from("test"))]))
499            .is_reopened(true)
500            .build();
501        event.causation_id = Some(UUID4::new());
502
503        roundtrip(event);
504    }
505
506    fn roundtrip<T>(event: T)
507    where
508        T: ArrowSchemaProvider
509            + EncodeToRecordBatch
510            + DecodeTypedFromRecordBatch
511            + Clone
512            + PartialEq
513            + std::fmt::Debug,
514    {
515        let metadata = event.metadata();
516        let batch = T::encode_batch(&metadata, std::slice::from_ref(&event)).unwrap();
517        let decoded = T::decode_typed_batch(batch.schema().metadata(), batch).unwrap();
518        assert_eq!(decoded, vec![event]);
519    }
520
521    #[rstest]
522    #[case::updated(0)]
523    #[case::pending_update(1)]
524    #[case::pending_cancel(2)]
525    #[case::modify_rejected(3)]
526    #[case::cancel_rejected(4)]
527    fn test_legacy_command_event_without_causation_column(
528        #[case] kind: usize,
529        order_updated: OrderUpdated,
530        order_pending_update: OrderPendingUpdate,
531        order_pending_cancel: OrderPendingCancel,
532        order_modify_rejected: OrderModifyRejected,
533        order_cancel_rejected: OrderCancelRejected,
534    ) {
535        match kind {
536            0 => roundtrip_without_causation(order_updated),
537            1 => roundtrip_without_causation(order_pending_update),
538            2 => roundtrip_without_causation(order_pending_cancel),
539            3 => roundtrip_without_causation(order_modify_rejected),
540            4 => roundtrip_without_causation(order_cancel_rejected),
541            _ => unreachable!(),
542        }
543    }
544
545    fn roundtrip_without_causation<T>(event: T)
546    where
547        T: ArrowSchemaProvider
548            + EncodeToRecordBatch
549            + DecodeTypedFromRecordBatch
550            + Clone
551            + PartialEq
552            + std::fmt::Debug,
553    {
554        let metadata = event.metadata();
555        let batch = T::encode_batch(&metadata, std::slice::from_ref(&event)).unwrap();
556        let columns: Vec<_> = batch
557            .schema()
558            .fields()
559            .iter()
560            .enumerate()
561            .filter_map(|(index, field)| (field.name() != "causation_id").then_some(index))
562            .collect();
563        let batch = batch.project(&columns).unwrap();
564        let decoded = T::decode_typed_batch(batch.schema().metadata(), batch).unwrap();
565        assert_eq!(decoded, vec![event]);
566    }
567
568    #[rstest]
569    fn test_order_denied_round_trip(order_denied_max_submitted_rate: OrderDenied) {
570        roundtrip(order_denied_max_submitted_rate);
571    }
572
573    #[rstest]
574    #[case(true)]
575    #[case(false)]
576    fn test_order_command_denied_round_trip(#[case] known_order: bool) {
577        use nautilus_model::{
578            events::order::spec::{OrderCancelDeniedSpec, OrderModifyDeniedSpec},
579            identifiers::{AccountId, VenueOrderId},
580        };
581        let cause = UUID4::new();
582        let venue = known_order.then(|| VenueOrderId::new("VENUE-21"));
583        let account = known_order.then(|| AccountId::new("ACCOUNT-45"));
584        roundtrip(
585            OrderModifyDeniedSpec::builder()
586                .reason("modify refused".into())
587                .causation_id(cause)
588                .maybe_venue_order_id(venue)
589                .maybe_account_id(account)
590                .ts_event(17.into())
591                .ts_init(29.into())
592                .build(),
593        );
594        roundtrip(
595            OrderCancelDeniedSpec::builder()
596                .reason("cancel refused".into())
597                .causation_id(cause)
598                .maybe_venue_order_id(venue)
599                .maybe_account_id(account)
600                .ts_event(31.into())
601                .ts_init(47.into())
602                .build(),
603        );
604    }
605
606    #[rstest]
607    fn test_order_submitted_round_trip(order_submitted: OrderSubmitted) {
608        roundtrip(order_submitted);
609    }
610
611    #[rstest]
612    fn test_order_accepted_round_trip(order_accepted: OrderAccepted) {
613        roundtrip(order_accepted);
614    }
615
616    #[rstest]
617    fn test_order_rejected_round_trip(order_rejected_insufficient_margin: OrderRejected) {
618        roundtrip(order_rejected_insufficient_margin);
619    }
620
621    #[rstest]
622    fn test_order_canceled_round_trip() {
623        use nautilus_model::events::OrderCanceled;
624        roundtrip(OrderCanceled::default());
625    }
626
627    #[rstest]
628    fn test_order_updated_round_trip(mut order_updated: OrderUpdated) {
629        order_updated.causation_id = Some(UUID4::new());
630        roundtrip(order_updated);
631    }
632
633    #[rstest]
634    fn test_order_triggered_round_trip(order_triggered: OrderTriggered) {
635        roundtrip(order_triggered);
636    }
637
638    #[rstest]
639    fn test_order_expired_round_trip(order_expired: OrderExpired) {
640        roundtrip(order_expired);
641    }
642
643    #[rstest]
644    fn test_order_pending_update_round_trip(mut order_pending_update: OrderPendingUpdate) {
645        order_pending_update.causation_id = Some(UUID4::new());
646        roundtrip(order_pending_update);
647    }
648
649    #[rstest]
650    fn test_order_pending_update_none_account_round_trip(order_pending_update: OrderPendingUpdate) {
651        roundtrip(OrderPendingUpdate {
652            account_id: None,
653            ..order_pending_update
654        });
655    }
656
657    #[rstest]
658    fn test_order_pending_cancel_round_trip(mut order_pending_cancel: OrderPendingCancel) {
659        order_pending_cancel.causation_id = Some(UUID4::new());
660        roundtrip(order_pending_cancel);
661    }
662
663    #[rstest]
664    fn test_order_pending_cancel_none_account_round_trip(order_pending_cancel: OrderPendingCancel) {
665        roundtrip(OrderPendingCancel {
666            account_id: None,
667            ..order_pending_cancel
668        });
669    }
670
671    #[rstest]
672    fn test_order_cancel_rejected_round_trip(mut order_cancel_rejected: OrderCancelRejected) {
673        order_cancel_rejected.causation_id = Some(UUID4::new());
674        roundtrip(order_cancel_rejected);
675    }
676
677    #[rstest]
678    fn test_order_modify_rejected_round_trip(mut order_modify_rejected: OrderModifyRejected) {
679        order_modify_rejected.causation_id = Some(UUID4::new());
680        roundtrip(order_modify_rejected);
681    }
682
683    #[rstest]
684    fn test_order_emulated_round_trip(order_emulated: OrderEmulated) {
685        roundtrip(order_emulated);
686    }
687
688    #[rstest]
689    fn test_order_released_round_trip(order_released: OrderReleased) {
690        roundtrip(order_released);
691    }
692}