1pub mod any;
36pub mod limit;
37pub mod limit_if_touched;
38pub mod list;
39pub mod market;
40pub mod market_if_touched;
41pub mod market_to_limit;
42pub mod stop_limit;
43pub mod stop_market;
44pub mod trailing_stop_limit;
45pub mod trailing_stop_market;
46
47#[cfg(any(test, feature = "test-support"))]
48pub mod builder;
49
50#[cfg(any(test, feature = "test-support"))]
51pub mod stubs;
52
53use ahash::{AHashMap, AHashSet};
55use enum_dispatch::enum_dispatch;
56use indexmap::IndexMap;
57use nautilus_core::{
58 UUID4, UnixNanos,
59 correctness::{CorrectnessError, check_predicate_false},
60};
61use rust_decimal::Decimal;
62use serde::{Deserialize, Serialize};
63use ustr::Ustr;
64
65#[cfg(any(test, feature = "test-support"))]
66pub use crate::orders::builder::OrderTestBuilder;
67pub use crate::orders::{
68 any::{LimitOrderAny, OrderAny, OrderReplayError, PassiveOrderAny, StopOrderAny},
69 limit::LimitOrder,
70 limit_if_touched::LimitIfTouchedOrder,
71 list::{OrderList, OrderListValidationError},
72 market::MarketOrder,
73 market_if_touched::MarketIfTouchedOrder,
74 market_to_limit::MarketToLimitOrder,
75 stop_limit::StopLimitOrder,
76 stop_market::StopMarketOrder,
77 trailing_stop_limit::TrailingStopLimitOrder,
78 trailing_stop_market::TrailingStopMarketOrder,
79};
80use crate::{
81 enums::{
82 ContingencyType, LiquiditySide, OrderSide, OrderStatus, OrderType, PositionSide,
83 TimeInForce, TrailingOffsetType, TriggerType,
84 },
85 events::{
86 OrderAccepted, OrderCancelRejected, OrderCanceled, OrderDenied, OrderEmulated,
87 OrderEventAny, OrderExpired, OrderFillVoided, OrderFilled, OrderInitialized,
88 OrderModifyRejected, OrderPendingCancel, OrderPendingUpdate, OrderRejected, OrderReleased,
89 OrderSubmitted, OrderTriggered, OrderUpdated,
90 },
91 identifiers::{
92 AccountId, ClientOrderId, ExecAlgorithmId, InstrumentId, OrderListId, PositionId,
93 StrategyId, Symbol, TradeId, TraderId, Venue, VenueOrderId,
94 },
95 orderbook::OwnBookOrder,
96 reports::OrderStatusReport,
97 types::{Currency, Money, Price, Quantity},
98};
99
100pub const STOP_ORDER_TYPES: &[OrderType] = &[
102 OrderType::StopMarket,
103 OrderType::StopLimit,
104 OrderType::MarketIfTouched,
105 OrderType::LimitIfTouched,
106];
107
108pub const LIMIT_ORDER_TYPES: &[OrderType] = &[
110 OrderType::Limit,
111 OrderType::StopLimit,
112 OrderType::LimitIfTouched,
113 OrderType::TrailingStopLimit,
114];
115
116pub const TRIGGERABLE_ORDER_TYPES: &[OrderType] = &[
121 OrderType::StopLimit,
122 OrderType::TrailingStopLimit,
123 OrderType::LimitIfTouched,
124];
125
126pub const LOCAL_ACTIVE_ORDER_STATUSES: &[OrderStatus] = &[
128 OrderStatus::Initialized,
129 OrderStatus::Emulated,
130 OrderStatus::Released,
131];
132
133#[derive(thiserror::Error, Debug)]
134pub enum OrderError {
135 #[error("Order not found: {0}")]
136 NotFound(ClientOrderId),
137 #[error("Order invariant failed: must have a side for this operation")]
138 NoOrderSide,
139 #[error("Invalid event for order type")]
140 InvalidOrderEvent,
141 #[error("Invalid order state transition")]
142 InvalidStateTransition,
143 #[error("Order was already initialized")]
144 AlreadyInitialized,
145 #[error("Order had no previous state")]
146 NoPreviousState,
147 #[error("Duplicate fill: trade_id {0} already applied to order")]
148 DuplicateFill(TradeId),
149 #[error("Duplicate fill void: trade_id {0} already has this cumulative correction")]
150 DuplicateFillVoid(TradeId),
151 #[error("Fill void for trade_id {0} is older than the applied correction")]
152 StaleFillVoid(TradeId),
153 #[error("Fill void quantity exceeds the original fill for trade_id {0}")]
154 OverVoid(TradeId),
155 #[error("Fill void commission is missing or conflicts with trade_id {0}")]
156 InvalidFillVoidCommission(TradeId),
157 #[error("{0}")]
158 Invariant(#[from] CorrectnessError),
159}
160
161#[must_use]
163pub fn ustr_indexmap_to_str(h: IndexMap<Ustr, Ustr>) -> IndexMap<String, String> {
164 h.into_iter()
165 .map(|(k, v)| (k.to_string(), v.to_string()))
166 .collect()
167}
168
169#[must_use]
171pub fn str_indexmap_to_ustr(h: IndexMap<String, String>) -> IndexMap<Ustr, Ustr> {
172 h.into_iter()
173 .map(|(k, v)| (Ustr::from(&k), Ustr::from(&v)))
174 .collect()
175}
176
177#[inline]
178pub(crate) fn check_display_qty(
179 display_qty: Option<Quantity>,
180 quantity: Quantity,
181) -> Result<(), OrderError> {
182 if let Some(q) = display_qty {
183 check_predicate_false(q > quantity, "`display_qty` may not exceed `quantity`")?;
184 }
185 Ok(())
186}
187
188#[inline]
189pub(crate) fn check_time_in_force(
190 time_in_force: TimeInForce,
191 expire_time: Option<UnixNanos>,
192) -> Result<(), OrderError> {
193 check_predicate_false(
194 time_in_force == TimeInForce::Gtd && expire_time.unwrap_or_default() == 0,
195 "`expire_time` is required for `GTD` order",
196 )?;
197 Ok(())
198}
199
200impl OrderStatus {
201 #[rustfmt::skip]
207 pub fn transition(&mut self, event: &OrderEventAny) -> Result<Self, OrderError> {
208 let new_state = match (self, event) {
209 (status, OrderEventAny::ModifyDenied(_) | OrderEventAny::CancelDenied(_)) => *status,
210 (Self::Initialized, OrderEventAny::Denied(_)) => Self::Denied,
211 (Self::Initialized, OrderEventAny::Emulated(_)) => Self::Emulated, (Self::Initialized, OrderEventAny::Released(_)) => Self::Released, (Self::Initialized, OrderEventAny::Submitted(_)) => Self::Submitted,
214 (Self::Initialized, OrderEventAny::Rejected(_)) => Self::Rejected, (Self::Initialized, OrderEventAny::Accepted(_)) => Self::Accepted, (Self::Initialized, OrderEventAny::Canceled(_)) => Self::Canceled, (Self::Initialized, OrderEventAny::Expired(_)) => Self::Expired, (Self::Initialized, OrderEventAny::Triggered(_)) => Self::Triggered, (Self::Initialized, OrderEventAny::Updated(_)) => Self::Initialized, (Self::Emulated, OrderEventAny::Canceled(_)) => Self::Canceled, (Self::Emulated, OrderEventAny::Expired(_)) => Self::Expired, (Self::Emulated, OrderEventAny::Updated(_)) => Self::Emulated, (Self::Emulated, OrderEventAny::Released(_)) => Self::Released, (Self::Released, OrderEventAny::Submitted(_)) => Self::Submitted, (Self::Released, OrderEventAny::Denied(_)) => Self::Denied, (Self::Released, OrderEventAny::Canceled(_)) => Self::Canceled, (Self::Released, OrderEventAny::Updated(_)) => Self::Released, (Self::Submitted, OrderEventAny::PendingUpdate(_)) => Self::PendingUpdate,
229 (Self::Submitted, OrderEventAny::PendingCancel(_)) => Self::PendingCancel,
230 (Self::Submitted, OrderEventAny::ModifyRejected(_)) => Self::Submitted,
231 (Self::Submitted, OrderEventAny::CancelRejected(_)) => Self::Submitted, (Self::Submitted, OrderEventAny::Rejected(_)) => Self::Rejected,
233 (Self::Submitted, OrderEventAny::Canceled(_)) => Self::Canceled, (Self::Submitted, OrderEventAny::Accepted(_)) => Self::Accepted,
235 (Self::Submitted, OrderEventAny::Updated(_)) => Self::Submitted,
236 (Self::Submitted, OrderEventAny::Filled(_)) => Self::Filled,
237 (Self::Accepted, OrderEventAny::Rejected(_)) => Self::Rejected, (Self::Accepted, OrderEventAny::PendingUpdate(_)) => Self::PendingUpdate,
239 (Self::Accepted, OrderEventAny::PendingCancel(_)) => Self::PendingCancel,
240 (Self::Accepted, OrderEventAny::ModifyRejected(_)) => Self::Accepted,
241 (Self::Accepted, OrderEventAny::CancelRejected(_)) => Self::Accepted, (Self::Accepted, OrderEventAny::Canceled(_)) => Self::Canceled,
243 (Self::Accepted, OrderEventAny::Triggered(_)) => Self::Triggered,
244 (Self::Accepted, OrderEventAny::Updated(_)) => Self::Accepted, (Self::Accepted, OrderEventAny::Expired(_)) => Self::Expired,
246 (Self::Accepted, OrderEventAny::Filled(_)) => Self::Filled,
247 (Self::Accepted, OrderEventAny::FillVoided(_)) => Self::Accepted,
248 (Self::Canceled, OrderEventAny::Filled(_)) => Self::Filled, (Self::Canceled, OrderEventAny::FillVoided(_)) => Self::Canceled,
250 (Self::Canceled, OrderEventAny::Updated(_)) => Self::Canceled,
251 (Self::PendingUpdate, OrderEventAny::Rejected(_)) => Self::Rejected,
252 (Self::PendingUpdate, OrderEventAny::Accepted(_)) => Self::Accepted,
253 (Self::PendingUpdate, OrderEventAny::Canceled(_)) => Self::Canceled,
254 (Self::PendingUpdate, OrderEventAny::Expired(_)) => Self::Expired,
255 (Self::PendingUpdate, OrderEventAny::Triggered(_)) => Self::Triggered,
256 (Self::PendingUpdate, OrderEventAny::Submitted(_)) => Self::PendingUpdate, (Self::PendingUpdate, OrderEventAny::PendingUpdate(_)) => Self::PendingUpdate, (Self::PendingUpdate, OrderEventAny::PendingCancel(_)) => Self::PendingCancel,
259 (Self::PendingUpdate, OrderEventAny::CancelRejected(_)) => Self::PendingUpdate, (Self::PendingUpdate, OrderEventAny::ModifyRejected(_)) => Self::PendingUpdate, (Self::PendingUpdate, OrderEventAny::Updated(_)) => Self::PendingUpdate, (Self::PendingUpdate, OrderEventAny::Filled(_)) => Self::Filled,
263 (Self::PendingUpdate, OrderEventAny::FillVoided(_)) => Self::PendingUpdate,
264 (Self::PendingCancel, OrderEventAny::Rejected(_)) => Self::Rejected,
265 (Self::PendingCancel, OrderEventAny::PendingCancel(_)) => Self::PendingCancel, (Self::PendingCancel, OrderEventAny::ModifyRejected(_)) => Self::PendingCancel, (Self::PendingCancel, OrderEventAny::CancelRejected(_)) => Self::PendingCancel, (Self::PendingCancel, OrderEventAny::Canceled(_)) => Self::Canceled,
269 (Self::PendingCancel, OrderEventAny::Expired(_)) => Self::Expired,
270 (Self::PendingCancel, OrderEventAny::Accepted(_)) => Self::Accepted, (Self::PendingCancel, OrderEventAny::Updated(_)) => Self::PendingCancel, (Self::PendingCancel, OrderEventAny::Filled(_)) => Self::Filled,
273 (Self::PendingCancel, OrderEventAny::FillVoided(_)) => Self::PendingCancel,
274 (Self::Triggered, OrderEventAny::Rejected(_)) => Self::Rejected,
275 (Self::Triggered, OrderEventAny::PendingUpdate(_)) => Self::PendingUpdate,
276 (Self::Triggered, OrderEventAny::PendingCancel(_)) => Self::PendingCancel,
277 (Self::Triggered, OrderEventAny::ModifyRejected(_)) => Self::Triggered,
278 (Self::Triggered, OrderEventAny::CancelRejected(_)) => Self::Triggered,
279 (Self::Triggered, OrderEventAny::Canceled(_)) => Self::Canceled,
280 (Self::Triggered, OrderEventAny::Expired(_)) => Self::Expired,
281 (Self::Triggered, OrderEventAny::Filled(_)) => Self::Filled,
282 (Self::Triggered, OrderEventAny::Updated(_)) => Self::Triggered,
283 (Self::Triggered, OrderEventAny::FillVoided(_)) => Self::Triggered,
284 (Self::PartiallyFilled, OrderEventAny::PendingUpdate(_)) => Self::PendingUpdate,
285 (Self::PartiallyFilled, OrderEventAny::PendingCancel(_)) => Self::PendingCancel,
286 (Self::PartiallyFilled, OrderEventAny::ModifyRejected(_)) => Self::PartiallyFilled,
287 (Self::PartiallyFilled, OrderEventAny::CancelRejected(_)) => Self::PartiallyFilled,
288 (Self::PartiallyFilled, OrderEventAny::Canceled(_)) => Self::Canceled,
289 (Self::PartiallyFilled, OrderEventAny::Expired(_)) => Self::Expired,
290 (Self::PartiallyFilled, OrderEventAny::Filled(_)) => Self::Filled,
291 (Self::PartiallyFilled, OrderEventAny::Accepted(_)) => Self::Accepted,
292 (Self::PartiallyFilled, OrderEventAny::Updated(_)) => Self::PartiallyFilled,
293 (Self::PartiallyFilled, OrderEventAny::FillVoided(_)) => Self::PartiallyFilled,
294 (Self::Filled, OrderEventAny::FillVoided(_)) => Self::Voided,
295 (Self::Filled, OrderEventAny::Updated(_)) => Self::Filled,
296 (Self::Expired, OrderEventAny::Filled(_)) => Self::Filled, (Self::Expired, OrderEventAny::FillVoided(_)) => Self::Expired,
298 (Self::Expired, OrderEventAny::Updated(_)) => Self::Expired,
299 (Self::Voided, OrderEventAny::FillVoided(_)) => Self::Voided,
300 _ => return Err(OrderError::InvalidStateTransition),
301 };
302 Ok(new_state)
303 }
304}
305
306#[enum_dispatch]
307pub trait Order: 'static + Send {
308 fn into_any(self) -> OrderAny;
309 fn status(&self) -> OrderStatus;
310 fn trader_id(&self) -> TraderId;
311 fn strategy_id(&self) -> StrategyId;
312 fn instrument_id(&self) -> InstrumentId;
313 fn symbol(&self) -> Symbol;
314 fn venue(&self) -> Venue;
315 fn client_order_id(&self) -> ClientOrderId;
316 fn venue_order_id(&self) -> Option<VenueOrderId>;
317 fn position_id(&self) -> Option<PositionId>;
318 fn account_id(&self) -> Option<AccountId>;
319 fn last_trade_id(&self) -> Option<TradeId>;
320 fn order_side(&self) -> OrderSide;
321 fn order_type(&self) -> OrderType;
322 fn quantity(&self) -> Quantity;
323 fn time_in_force(&self) -> TimeInForce;
324 fn expire_time(&self) -> Option<UnixNanos>;
325 fn price(&self) -> Option<Price>;
326 fn activation_price(&self) -> Option<Price> {
327 None
328 }
329 fn trigger_price(&self) -> Option<Price>;
330 fn trigger_type(&self) -> Option<TriggerType>;
331 fn liquidity_side(&self) -> Option<LiquiditySide>;
332 fn is_post_only(&self) -> bool;
333 fn is_reduce_only(&self) -> bool;
334 fn is_quote_quantity(&self) -> bool;
335 fn display_qty(&self) -> Option<Quantity>;
336 fn limit_offset(&self) -> Option<Decimal>;
337 fn trailing_offset(&self) -> Option<Decimal>;
338 fn trailing_offset_type(&self) -> Option<TrailingOffsetType>;
339 fn emulation_trigger(&self) -> Option<TriggerType>;
340 fn trigger_instrument_id(&self) -> Option<InstrumentId>;
341 fn contingency_type(&self) -> Option<ContingencyType>;
342 fn order_list_id(&self) -> Option<OrderListId>;
343 fn linked_order_ids(&self) -> Option<&[ClientOrderId]>;
344 fn parent_order_id(&self) -> Option<ClientOrderId>;
345 fn exec_algorithm_id(&self) -> Option<ExecAlgorithmId>;
346 fn exec_algorithm_params(&self) -> Option<&IndexMap<Ustr, Ustr>>;
347 fn exec_spawn_id(&self) -> Option<ClientOrderId>;
348 fn tags(&self) -> Option<&[Ustr]>;
349 fn filled_qty(&self) -> Quantity;
350 fn voided_qty(&self) -> Quantity;
351 fn non_reopened_voided_qty(&self) -> Quantity;
352 fn leaves_qty(&self) -> Quantity;
353 fn overfill_qty(&self) -> Quantity;
354
355 fn calculate_overfill(&self, fill_qty: Quantity) -> Quantity {
357 let potential_filled = self.filled_qty() + fill_qty;
358 let quantity = self.quantity();
359 if potential_filled > quantity {
360 potential_filled - quantity
361 } else {
362 Quantity::zero(fill_qty.precision)
363 }
364 }
365
366 fn avg_px(&self) -> Option<Decimal>;
367 fn slippage(&self) -> Option<Decimal>;
368 fn init_id(&self) -> UUID4;
369 fn ts_init(&self) -> UnixNanos;
370 fn ts_submitted(&self) -> Option<UnixNanos>;
371 fn ts_accepted(&self) -> Option<UnixNanos>;
372 fn ts_closed(&self) -> Option<UnixNanos>;
373 fn ts_last(&self) -> UnixNanos;
374
375 fn commissions(&self) -> &IndexMap<Currency, Money>;
376
377 fn apply(&mut self, event: OrderEventAny) -> Result<(), OrderError>;
383
384 fn update(&mut self, event: &OrderUpdated);
385
386 fn events(&self) -> Vec<&OrderEventAny>;
387
388 fn last_event(&self) -> &OrderEventAny {
389 self.events()
390 .last()
391 .expect("Order invariant violated: no events")
392 }
393
394 fn event_count(&self) -> usize {
395 self.events().len()
396 }
397
398 fn venue_order_ids(&self) -> Vec<&VenueOrderId>;
399
400 fn trade_ids(&self) -> Vec<&TradeId>;
401
402 fn has_price(&self) -> bool;
403
404 fn is_duplicate_fill(&self, fill: &OrderFilled) -> bool {
406 let mut latest = None;
407
408 for event in self.events() {
409 if let OrderEventAny::Filled(existing) = event
410 && existing.trade_id == fill.trade_id
411 && existing.order_side == fill.order_side
412 {
413 latest = Some(existing);
414 }
415 }
416
417 latest.is_some_and(|existing| {
418 existing.last_qty == fill.last_qty && existing.last_px == fill.last_px
419 })
420 }
421
422 fn is_buy(&self) -> bool {
423 self.order_side() == OrderSide::Buy
424 }
425
426 fn is_sell(&self) -> bool {
427 self.order_side() == OrderSide::Sell
428 }
429
430 fn is_passive(&self) -> bool {
431 self.order_type() != OrderType::Market
432 }
433
434 fn is_aggressive(&self) -> bool {
435 self.order_type() == OrderType::Market
436 }
437
438 fn is_emulated(&self) -> bool {
439 self.status() == OrderStatus::Emulated
440 }
441
442 fn is_active_local(&self) -> bool {
443 matches!(
444 self.status(),
445 OrderStatus::Initialized | OrderStatus::Emulated | OrderStatus::Released
446 )
447 }
448
449 fn is_primary(&self) -> bool {
450 self.exec_algorithm_id().is_some()
451 && self
452 .exec_spawn_id()
453 .is_some_and(|spawn_id| self.client_order_id() == spawn_id)
454 }
455
456 fn is_spawned(&self) -> bool {
457 self.exec_algorithm_id().is_some()
458 && self
459 .exec_spawn_id()
460 .is_some_and(|spawn_id| self.client_order_id() != spawn_id)
461 }
462
463 fn is_contingency(&self) -> bool {
464 self.contingency_type().is_some()
465 }
466
467 fn is_parent_order(&self) -> bool {
468 match self.contingency_type() {
469 Some(c) => c == ContingencyType::Oto,
470 None => false,
471 }
472 }
473
474 fn is_child_order(&self) -> bool {
475 self.parent_order_id().is_some()
476 }
477
478 fn is_open(&self) -> bool {
479 if self.emulation_trigger().is_some() {
480 return false;
481 }
482
483 matches!(
484 self.status(),
485 OrderStatus::Accepted
486 | OrderStatus::Triggered
487 | OrderStatus::PendingCancel
488 | OrderStatus::PendingUpdate
489 | OrderStatus::PartiallyFilled
490 )
491 }
492
493 fn is_canceled(&self) -> bool {
494 self.status() == OrderStatus::Canceled
495 }
496
497 fn is_closed(&self) -> bool {
498 matches!(
499 self.status(),
500 OrderStatus::Denied
501 | OrderStatus::Rejected
502 | OrderStatus::Canceled
503 | OrderStatus::Expired
504 | OrderStatus::Filled
505 | OrderStatus::Voided
506 )
507 }
508
509 fn is_inflight(&self) -> bool {
510 if self.emulation_trigger().is_some() {
511 return false;
512 }
513
514 matches!(
515 self.status(),
516 OrderStatus::Submitted | OrderStatus::PendingCancel | OrderStatus::PendingUpdate
517 )
518 }
519
520 fn is_pending_update(&self) -> bool {
521 self.status() == OrderStatus::PendingUpdate
522 }
523
524 fn is_pending_cancel(&self) -> bool {
525 self.status() == OrderStatus::PendingCancel
526 }
527
528 fn has_pending_update_command(&self) -> bool {
530 self.is_pending_update()
531 }
532
533 fn has_pending_cancel_command(&self) -> bool {
535 self.is_pending_cancel()
536 }
537
538 fn to_own_book_order(&self) -> OwnBookOrder {
539 OwnBookOrder::new(
540 self.trader_id(),
541 self.client_order_id(),
542 self.venue_order_id(),
543 self.order_side(),
544 self.price().expect("`OwnBookOrder` must have a price"),
545 self.leaves_qty(),
546 self.order_type(),
547 self.time_in_force(),
548 self.status(),
549 self.ts_last(),
550 self.ts_accepted().unwrap_or_default(),
551 self.ts_submitted().unwrap_or_default(),
552 self.ts_init(),
553 )
554 }
555
556 fn to_order_status_report(&self, report_id: Option<UUID4>) -> Option<OrderStatusReport> {
562 let account_id = self.account_id()?;
563 let venue_order_id = self.venue_order_id()?;
564
565 let mut report = OrderStatusReport::new(
566 account_id,
567 self.instrument_id(),
568 Some(self.client_order_id()),
569 venue_order_id,
570 self.order_side().into(),
571 self.order_type(),
572 self.time_in_force(),
573 self.status(),
574 self.quantity(),
575 self.filled_qty(),
576 self.ts_accepted().unwrap_or_else(|| self.ts_last()),
577 self.ts_last(),
578 self.ts_init(),
579 report_id,
580 )
581 .with_post_only(self.is_post_only())
582 .with_reduce_only(self.is_reduce_only());
583
584 if let Some(price) = self.price() {
585 report = report.with_price(price);
586 }
587
588 if let Some(activation_price) = self.activation_price() {
589 report = report.with_activation_price(activation_price);
590 }
591
592 if let Some(trigger_price) = self.trigger_price() {
593 report = report.with_trigger_price(trigger_price);
594 }
595
596 if let Some(trigger_type) = self.trigger_type() {
597 report = report.with_trigger_type(trigger_type);
598 }
599
600 if let Some(limit_offset) = self.limit_offset() {
601 report = report.with_limit_offset(limit_offset);
602 }
603
604 if let Some(trailing_offset) = self.trailing_offset() {
605 report = report.with_trailing_offset(trailing_offset);
606 }
607
608 if let Some(trailing_offset_type) = self.trailing_offset_type() {
609 report = report.with_trailing_offset_type(trailing_offset_type);
610 }
611
612 if let Some(display_qty) = self.display_qty() {
613 report = report.with_display_qty(display_qty);
614 }
615
616 if let Some(expire_time) = self.expire_time() {
617 report = report.with_expire_time(expire_time);
618 }
619
620 if let Some(contingency_type) = self.contingency_type() {
621 report = report.with_contingency_type(contingency_type);
622 }
623
624 if let Some(order_list_id) = self.order_list_id() {
625 report = report.with_order_list_id(order_list_id);
626 }
627
628 if let Some(linked_order_ids) = self.linked_order_ids() {
629 report = report.with_linked_order_ids(linked_order_ids.iter().copied());
630 }
631
632 if let Some(parent_order_id) = self.parent_order_id() {
633 report = report.with_parent_order_id(parent_order_id);
634 }
635
636 if let Some(position_id) = self.position_id() {
637 report = report.with_venue_position_id(position_id);
638 }
639
640 let mut ts_triggered = None;
643 let mut rejected_reason = None;
644
645 for event in self.events() {
646 match event {
647 OrderEventAny::Triggered(triggered) => ts_triggered = Some(triggered.ts_event),
648 OrderEventAny::Rejected(rejected) => rejected_reason = Some(rejected.reason),
649 _ => {}
650 }
651 }
652
653 if let Some(ts_triggered) = ts_triggered {
654 report = report.with_ts_triggered(ts_triggered);
655 }
656
657 if let Some(reason) = rejected_reason {
660 report = report.with_cancel_reason(reason.to_string());
661 }
662
663 if let Some(avg_px) = self.avg_px() {
664 report = report.with_avg_px(avg_px);
665 }
666
667 Some(report)
668 }
669
670 fn is_triggered(&self) -> Option<bool>; fn set_position_id(&mut self, position_id: Option<PositionId>);
672 fn set_quantity(&mut self, quantity: Quantity);
673 fn set_leaves_qty(&mut self, leaves_qty: Quantity);
674 fn set_emulation_trigger(&mut self, emulation_trigger: Option<TriggerType>);
675 fn set_is_quote_quantity(&mut self, is_quote_quantity: bool);
676 fn set_liquidity_side(&mut self, liquidity_side: LiquiditySide);
677 fn would_reduce_only(&self, side: PositionSide, position_qty: Quantity) -> bool;
678 fn previous_status(&self) -> Option<OrderStatus>;
679}
680
681impl<T> From<&T> for OrderInitialized
682where
683 T: Order,
684{
685 fn from(order: &T) -> Self {
686 Self {
687 trader_id: order.trader_id(),
688 strategy_id: order.strategy_id(),
689 instrument_id: order.instrument_id(),
690 client_order_id: order.client_order_id(),
691 order_side: order.order_side(),
692 order_type: order.order_type(),
693 quantity: order.quantity(),
694 price: order.price(),
695 activation_price: order.activation_price(),
696 trigger_price: order.trigger_price(),
697 trigger_type: order.trigger_type(),
698 time_in_force: order.time_in_force(),
699 expire_time: order.expire_time(),
700 post_only: order.is_post_only(),
701 reduce_only: order.is_reduce_only(),
702 quote_quantity: order.is_quote_quantity(),
703 display_qty: order.display_qty(),
704 limit_offset: order.limit_offset(),
705 trailing_offset: order.trailing_offset(),
706 trailing_offset_type: order.trailing_offset_type(),
707 emulation_trigger: order.emulation_trigger(),
708 trigger_instrument_id: order.trigger_instrument_id(),
709 contingency_type: order.contingency_type(),
710 order_list_id: order.order_list_id(),
711 linked_order_ids: order.linked_order_ids().map(<[ClientOrderId]>::to_vec),
712 parent_order_id: order.parent_order_id(),
713 exec_algorithm_id: order.exec_algorithm_id(),
714 exec_algorithm_params: order.exec_algorithm_params().map(ToOwned::to_owned),
715 exec_spawn_id: order.exec_spawn_id(),
716 tags: order.tags().map(<[Ustr]>::to_vec),
717 event_id: order.init_id(),
718 ts_event: order.ts_init(),
719 ts_init: order.ts_init(),
720 reconciliation: false,
721 causation_id: None,
722 }
723 }
724}
725
726#[derive(Clone, Debug, Serialize, Deserialize)]
733pub struct OrderCore {
734 events: Vec<OrderEventAny>,
735 #[serde(default, skip_serializing_if = "Vec::is_empty")]
736 pending_commands: Vec<(OrderStatus, Option<UUID4>)>,
737 #[serde(default, skip_serializing_if = "Option::is_none")]
738 pending_previous_status: Option<OrderStatus>,
739 #[serde(skip)]
740 fill_totals: Option<FillTotals>,
741 pub commissions: IndexMap<Currency, Money>,
742 pub venue_order_ids: Vec<VenueOrderId>,
743 pub trade_ids: Vec<TradeId>,
744 pub previous_status: Option<OrderStatus>,
745 pub status: OrderStatus,
746 pub trader_id: TraderId,
747 pub strategy_id: StrategyId,
748 pub instrument_id: InstrumentId,
749 pub client_order_id: ClientOrderId,
750 pub venue_order_id: Option<VenueOrderId>,
751 pub position_id: Option<PositionId>,
752 pub account_id: Option<AccountId>,
753 pub last_trade_id: Option<TradeId>,
754 pub side: OrderSide,
755 pub order_type: OrderType,
756 pub quantity: Quantity,
757 pub time_in_force: TimeInForce,
758 pub liquidity_side: Option<LiquiditySide>,
759 pub is_reduce_only: bool,
760 pub is_quote_quantity: bool,
761 #[serde(default, with = "crate::enums::serde_option_trigger_type")]
762 pub emulation_trigger: Option<TriggerType>,
763 #[serde(default, with = "crate::enums::serde_option_contingency_type")]
764 pub contingency_type: Option<ContingencyType>,
765 pub order_list_id: Option<OrderListId>,
766 pub linked_order_ids: Option<Vec<ClientOrderId>>,
767 pub parent_order_id: Option<ClientOrderId>,
768 pub exec_algorithm_id: Option<ExecAlgorithmId>,
769 pub exec_algorithm_params: Option<IndexMap<Ustr, Ustr>>,
770 pub exec_spawn_id: Option<ClientOrderId>,
771 pub tags: Option<Vec<Ustr>>,
772 pub filled_qty: Quantity,
773 #[serde(default)]
774 pub voided_qty: Quantity,
775 #[serde(default)]
778 pub non_reopened_voided_qty: Quantity,
779 pub leaves_qty: Quantity,
780 pub overfill_qty: Quantity,
781 pub avg_px: Option<Decimal>,
782 pub slippage: Option<Decimal>,
783 pub init_id: UUID4,
784 pub ts_init: UnixNanos,
785 pub ts_submitted: Option<UnixNanos>,
786 pub ts_accepted: Option<UnixNanos>,
787 pub ts_closed: Option<UnixNanos>,
788 pub ts_last: UnixNanos,
789}
790
791impl OrderCore {
792 #[must_use]
794 pub fn new(init: OrderInitialized) -> Self {
795 let events: Vec<OrderEventAny> = vec![OrderEventAny::Initialized(init.clone())];
796 Self {
797 events,
798 pending_commands: Vec::new(),
799 pending_previous_status: None,
800 fill_totals: Some(FillTotals::default()),
801 commissions: IndexMap::new(),
802 venue_order_ids: Vec::new(),
803 trade_ids: Vec::new(),
804 previous_status: None,
805 status: OrderStatus::Initialized,
806 trader_id: init.trader_id,
807 strategy_id: init.strategy_id,
808 instrument_id: init.instrument_id,
809 client_order_id: init.client_order_id,
810 venue_order_id: None,
811 position_id: None,
812 account_id: None,
813 last_trade_id: None,
814 side: init.order_side,
815 order_type: init.order_type,
816 quantity: init.quantity,
817 time_in_force: init.time_in_force,
818 liquidity_side: Some(LiquiditySide::NoLiquiditySide),
819 is_reduce_only: init.reduce_only,
820 is_quote_quantity: init.quote_quantity,
821 emulation_trigger: init.emulation_trigger,
822 contingency_type: init.contingency_type,
823 order_list_id: init.order_list_id,
824 linked_order_ids: init.linked_order_ids,
825 parent_order_id: init.parent_order_id,
826 exec_algorithm_id: init.exec_algorithm_id,
827 exec_algorithm_params: init.exec_algorithm_params,
828 exec_spawn_id: init.exec_spawn_id,
829 tags: init.tags,
830 filled_qty: Quantity::zero(init.quantity.precision),
831 voided_qty: Quantity::zero(init.quantity.precision),
832 non_reopened_voided_qty: Quantity::zero(init.quantity.precision),
833 leaves_qty: init.quantity,
834 overfill_qty: Quantity::zero(init.quantity.precision),
835 avg_px: None,
836 slippage: None,
837 init_id: init.event_id,
838 ts_init: init.ts_event,
839 ts_submitted: None,
840 ts_accepted: None,
841 ts_closed: None,
842 ts_last: init.ts_event,
843 }
844 }
845
846 pub fn apply(&mut self, event: OrderEventAny) -> Result<(), OrderError> {
855 if self.client_order_id != event.client_order_id() {
856 return Err(CorrectnessError::PredicateViolation {
857 message: format!(
858 "Event client_order_id {} does not match order client_order_id {}",
859 event.client_order_id(),
860 self.client_order_id
861 ),
862 }
863 .into());
864 }
865
866 if self.strategy_id != event.strategy_id() {
867 return Err(CorrectnessError::PredicateViolation {
868 message: format!(
869 "Event strategy_id {} does not match order strategy_id {}",
870 event.strategy_id(),
871 self.strategy_id
872 ),
873 }
874 .into());
875 }
876
877 if let OrderEventAny::FillVoided(event) = &event {
878 self.validate_fill_void(event)?;
879 }
880
881 let mut has_prior_fill_void = false;
882
883 if let OrderEventAny::Filled(fill) = &event {
885 has_prior_fill_void = self.has_prior_fill_void(fill.trade_id);
886 if self.is_price_restatement_fill(fill)? {
887 self.restate_fill_price(event);
888 return Ok(());
889 }
890 }
891
892 if matches!(event, OrderEventAny::Triggered(_))
893 && !TRIGGERABLE_ORDER_TYPES.contains(&self.order_type)
894 {
895 return Err(OrderError::InvalidOrderEvent);
896 }
897
898 match &event {
899 OrderEventAny::Initialized(_) => return Err(OrderError::AlreadyInitialized),
900
901 OrderEventAny::Expired(_)
903 if matches!(self.status, OrderStatus::Expired | OrderStatus::Filled)
904 && self
905 .events
906 .iter()
907 .rposition(|event| matches!(event, OrderEventAny::Expired(_)))
908 .is_some_and(|index| {
909 self.events[index + 1..]
910 .iter()
911 .any(|event| matches!(event, OrderEventAny::Filled(_)))
912 }) =>
913 {
914 self.events.push(event);
916 return Ok(());
917 }
918 _ => {}
919 }
920
921 let is_reclose_after_fill = self.status == OrderStatus::Canceled
922 && matches!(event, OrderEventAny::Canceled(_))
923 && self
924 .events
925 .iter()
926 .rev()
927 .take_while(|event| !matches!(event, OrderEventAny::Canceled(_)))
928 .any(|event| matches!(event, OrderEventAny::Filled(_)));
929
930 let new_status = if is_reclose_after_fill {
931 OrderStatus::Canceled
932 } else {
933 self.status.transition(&event)?
934 };
935
936 if let OrderEventAny::Filled(fill) = &event
937 && self.filled_qty.checked_add(fill.last_qty).is_none()
938 {
939 return Err(CorrectnessError::PredicateViolation {
940 message: format!(
941 "filled quantity overflowed Quantity raw bounds: {} + {}",
942 self.filled_qty, fill.last_qty
943 ),
944 }
945 .into());
946 }
947
948 if let OrderEventAny::Filled(fill) = &event
949 && let Some(commission) = fill.commission
950 && let Some(total) = self.commissions.get(&commission.currency)
951 && total.checked_add(commission).is_none()
952 {
953 return Err(CorrectnessError::PredicateViolation {
954 message: format!(
955 "cumulative commission overflowed Money bounds: {total} + {commission}"
956 ),
957 }
958 .into());
959 }
960
961 let rejection_status = if matches!(
962 (&event, self.status),
963 (OrderEventAny::ModifyRejected(_), OrderStatus::PendingUpdate)
964 | (OrderEventAny::CancelRejected(_), OrderStatus::PendingCancel)
965 ) {
966 self.previous_status.ok_or(OrderError::NoPreviousState)?
967 } else {
968 self.status
969 };
970
971 if let OrderEventAny::Updated(update) = &event {
975 let invalid_fields = match self.order_type {
976 OrderType::Market => update.price.is_some() || update.trigger_price.is_some(),
977 OrderType::StopMarket
978 | OrderType::MarketIfTouched
979 | OrderType::TrailingStopMarket => update.price.is_some(),
980 OrderType::Limit | OrderType::MarketToLimit => update.trigger_price.is_some(),
981 OrderType::StopLimit | OrderType::LimitIfTouched | OrderType::TrailingStopLimit => {
982 false
983 }
984 };
985
986 if invalid_fields {
987 return Err(OrderError::InvalidOrderEvent);
988 }
989 }
990
991 let source_status = self.status;
992
993 if !matches!(
998 event,
999 OrderEventAny::Initialized(_)
1000 | OrderEventAny::ModifyDenied(_)
1001 | OrderEventAny::ModifyRejected(_)
1002 | OrderEventAny::CancelDenied(_)
1003 | OrderEventAny::CancelRejected(_)
1004 ) && !matches!(
1005 self.status,
1006 OrderStatus::PendingUpdate | OrderStatus::PendingCancel
1007 ) {
1008 self.previous_status = Some(self.status);
1009 }
1010
1011 self.status = new_status;
1012 self.record_pending_command(&event, source_status);
1013
1014 match &event {
1015 OrderEventAny::Initialized(_) => return Err(OrderError::AlreadyInitialized),
1017 OrderEventAny::Denied(event) => self.denied(event),
1018 OrderEventAny::ModifyDenied(event) => {
1019 self.command_refused(event.causation_id, OrderStatus::PendingUpdate, None);
1020 }
1021 OrderEventAny::CancelDenied(event) => {
1022 self.command_refused(event.causation_id, OrderStatus::PendingCancel, None);
1023 }
1024 OrderEventAny::Emulated(event) => self.emulated(event),
1025 OrderEventAny::Released(event) => self.released(event),
1026 OrderEventAny::Submitted(event) => self.submitted(event),
1027 OrderEventAny::Rejected(event) => self.rejected(event),
1028 OrderEventAny::Accepted(event) => self.accepted(event),
1029 OrderEventAny::PendingUpdate(event) => self.pending_update(event),
1030 OrderEventAny::PendingCancel(event) => self.pending_cancel(event),
1031 OrderEventAny::ModifyRejected(event) => self.modify_rejected(event, rejection_status),
1032 OrderEventAny::CancelRejected(event) => self.cancel_rejected(event, rejection_status),
1033 OrderEventAny::Updated(event) => self.updated(event),
1034 OrderEventAny::Triggered(event) => self.triggered(event),
1035 OrderEventAny::Canceled(event) => self.canceled(event),
1036 OrderEventAny::Expired(event) => self.expired(event),
1037 OrderEventAny::Filled(event) => self.filled(event, source_status),
1038 OrderEventAny::FillVoided(event) => self.fill_voided(event, source_status),
1039 }
1040
1041 self.record_event(event, has_prior_fill_void);
1042 Ok(())
1043 }
1044
1045 fn record_event(&mut self, event: OrderEventAny, has_prior_fill_void: bool) {
1046 if self.status.is_closed() {
1047 self.pending_commands.clear();
1048 self.pending_previous_status = None;
1049 }
1050
1051 if has_prior_fill_void {
1052 self.fill_totals = None;
1055 }
1056
1057 self.ts_last = event.ts_event();
1058 self.events.push(event);
1059 }
1060
1061 fn denied(&mut self, event: &OrderDenied) {
1062 self.ts_closed = Some(event.ts_event);
1063 }
1064
1065 fn command_refused(
1066 &mut self,
1067 causation_id: Option<UUID4>,
1068 kind: OrderStatus,
1069 legacy_status: Option<OrderStatus>,
1070 ) {
1071 let previous_status = self.pending_previous_status;
1072
1073 if let Some(command_id) = causation_id {
1074 let Some(index) = self
1075 .pending_commands
1076 .iter()
1077 .position(|pending| *pending == (kind, Some(command_id)))
1078 else {
1079 return;
1080 };
1081
1082 self.pending_commands.remove(index);
1083 } else if legacy_status.is_some() {
1084 self.pending_commands.retain(|(status, _)| *status != kind);
1085 } else {
1086 return;
1087 }
1088
1089 if self.pending_commands.is_empty() {
1090 self.pending_previous_status = None;
1091 }
1092
1093 if !matches!(
1094 self.status,
1095 OrderStatus::PendingUpdate | OrderStatus::PendingCancel
1096 ) {
1097 return;
1098 }
1099
1100 let restored = if self.filled_qty.is_zero() {
1101 previous_status.or(legacy_status).or(self.previous_status)
1102 } else {
1103 Some(OrderStatus::PartiallyFilled)
1104 };
1105
1106 self.status = self
1107 .pending_commands
1108 .last()
1109 .map(|(status, _)| *status)
1110 .or(restored)
1111 .unwrap_or(self.status);
1112 }
1113
1114 fn record_pending_command(&mut self, event: &OrderEventAny, source_status: OrderStatus) {
1115 let command = match event {
1116 OrderEventAny::PendingUpdate(event) => {
1117 Some((OrderStatus::PendingUpdate, event.causation_id))
1118 }
1119 OrderEventAny::PendingCancel(event) => {
1120 Some((OrderStatus::PendingCancel, event.causation_id))
1121 }
1122 OrderEventAny::Accepted(_) | OrderEventAny::Triggered(_) => {
1123 self.pending_commands.clear();
1124 self.pending_previous_status = None;
1125 return;
1126 }
1127 OrderEventAny::Updated(event) => {
1128 self.pending_commands.retain(|(status, command_id)| {
1129 *status != OrderStatus::PendingUpdate
1130 || event
1131 .causation_id
1132 .is_some_and(|cause| *command_id != Some(cause))
1133 });
1134
1135 return;
1136 }
1137 _ => None,
1138 };
1139
1140 if let Some(command) = command {
1141 if self.pending_commands.is_empty()
1142 || !matches!(
1143 source_status,
1144 OrderStatus::PendingUpdate | OrderStatus::PendingCancel
1145 )
1146 {
1147 self.pending_commands.clear();
1148 self.pending_previous_status = Some(
1149 if matches!(
1150 source_status,
1151 OrderStatus::PendingUpdate | OrderStatus::PendingCancel
1152 ) {
1153 self.previous_status.unwrap_or(source_status)
1154 } else {
1155 source_status
1156 },
1157 );
1158 }
1159
1160 if !self.pending_commands.contains(&command) {
1161 self.pending_commands.push(command);
1162 }
1163 }
1164 }
1165
1166 fn has_pending_update_command(&self) -> bool {
1167 !self.status.is_closed()
1168 && (self.status == OrderStatus::PendingUpdate
1169 || self
1170 .pending_commands
1171 .iter()
1172 .any(|(status, _)| *status == OrderStatus::PendingUpdate))
1173 }
1174
1175 fn has_pending_cancel_command(&self) -> bool {
1176 !self.status.is_closed()
1177 && (self.status == OrderStatus::PendingCancel
1178 || self
1179 .pending_commands
1180 .iter()
1181 .any(|(status, _)| *status == OrderStatus::PendingCancel))
1182 }
1183
1184 fn emulated(&self, _event: &OrderEmulated) {
1185 }
1187
1188 fn released(&mut self, _event: &OrderReleased) {
1189 self.emulation_trigger = None;
1190 }
1191
1192 fn submitted(&mut self, event: &OrderSubmitted) {
1193 self.account_id = Some(event.account_id);
1194 self.ts_submitted = Some(event.ts_event);
1195 }
1196
1197 fn accepted(&mut self, event: &OrderAccepted) {
1198 self.account_id = Some(event.account_id);
1199 self.venue_order_id = Some(event.venue_order_id);
1200 self.venue_order_ids.push(event.venue_order_id);
1201 self.ts_accepted = Some(event.ts_event);
1202 }
1203
1204 fn rejected(&mut self, event: &OrderRejected) {
1205 self.ts_closed = Some(event.ts_event);
1206 }
1207
1208 fn pending_update(&self, _event: &OrderPendingUpdate) {
1209 }
1211
1212 fn pending_cancel(&self, _event: &OrderPendingCancel) {
1213 }
1215
1216 fn modify_rejected(&mut self, event: &OrderModifyRejected, rejection_status: OrderStatus) {
1217 self.command_refused(
1218 event.causation_id,
1219 OrderStatus::PendingUpdate,
1220 Some(rejection_status),
1221 );
1222 }
1223
1224 fn cancel_rejected(&mut self, event: &OrderCancelRejected, previous_status: OrderStatus) {
1225 self.command_refused(
1226 event.causation_id,
1227 OrderStatus::PendingCancel,
1228 Some(previous_status),
1229 );
1230 }
1231
1232 fn triggered(&self, _event: &OrderTriggered) {}
1233
1234 fn canceled(&mut self, event: &OrderCanceled) {
1235 self.ts_closed = Some(event.ts_event);
1236 }
1237
1238 fn expired(&mut self, event: &OrderExpired) {
1239 self.ts_closed = Some(event.ts_event);
1240 }
1241
1242 fn validate_fill_void(&self, event: &OrderFillVoided) -> Result<(), OrderError> {
1243 let fill = self.events.iter().find_map(|candidate| match candidate {
1244 OrderEventAny::Filled(fill) if fill.trade_id == event.trade_id => Some(fill),
1245 _ => None,
1246 });
1247
1248 if event.voided_qty.is_zero() {
1249 return Err(OrderError::OverVoid(event.trade_id));
1250 }
1251
1252 let previous = self.latest_fill_void(event.trade_id);
1253 if let Some(previous) = previous {
1254 if event.voided_qty < previous.voided_qty {
1255 return Err(OrderError::StaleFillVoid(event.trade_id));
1256 }
1257
1258 if event.voided_qty == previous.voided_qty
1259 && event.commission_voided == previous.commission_voided
1260 && event.is_reopened == previous.is_reopened
1261 {
1262 return Err(OrderError::DuplicateFillVoid(event.trade_id));
1263 }
1264 }
1265
1266 let Some(fill) = fill else {
1267 if event.is_reopened {
1268 return Err(OrderError::InvalidOrderEvent);
1269 }
1270
1271 if !self.matches_fill_void_identity(event) {
1272 return Err(OrderError::InvalidOrderEvent);
1273 }
1274
1275 if event.voided_qty > self.quantity
1276 || event
1277 .commission_voided
1278 .is_some_and(|commission| !commission.is_zero())
1279 {
1280 return Err(OrderError::OverVoid(event.trade_id));
1281 }
1282 return Ok(());
1283 };
1284
1285 if fill.venue_order_id != event.venue_order_id
1286 || fill.account_id != event.account_id
1287 || fill.order_side != event.order_side
1288 || fill.order_type != event.order_type
1289 || fill.last_px != event.last_px
1290 || fill.currency != event.currency
1291 || fill.liquidity_side != event.liquidity_side
1292 || fill.position_id != event.position_id
1293 {
1294 return Err(OrderError::InvalidOrderEvent);
1295 }
1296
1297 if event.voided_qty > fill.last_qty {
1298 return Err(OrderError::OverVoid(event.trade_id));
1299 }
1300
1301 self.validate_fill_void_commission(fill, event, previous)
1302 }
1303
1304 fn matches_fill_void_identity(&self, event: &OrderFillVoided) -> bool {
1305 event.trader_id == self.trader_id
1306 && event.instrument_id == self.instrument_id
1307 && event.order_side == self.side
1308 && event.order_type == self.order_type
1309 && (self.venue_order_id == Some(event.venue_order_id)
1310 || self.venue_order_ids.contains(&event.venue_order_id))
1311 && self.account_id == Some(event.account_id)
1312 }
1313
1314 fn validate_fill_void_commission(
1315 &self,
1316 fill: &OrderFilled,
1317 event: &OrderFillVoided,
1318 previous: Option<&OrderFillVoided>,
1319 ) -> Result<(), OrderError> {
1320 match (fill.commission, event.commission_voided) {
1321 (None, None) => Ok(()),
1322 (None, Some(commission)) if commission.is_zero() => Ok(()),
1323 (Some(_), None) if previous.and_then(|prior| prior.commission_voided).is_none() => {
1324 Ok(())
1325 }
1326 (Some(commission), Some(voided))
1327 if commission.currency == voided.currency
1328 && commission.is_positive() == voided.is_positive()
1329 && commission.is_negative() == voided.is_negative()
1330 && voided.abs() <= commission.abs()
1331 && previous
1332 .and_then(|prior| prior.commission_voided)
1333 .is_none_or(|prior| voided.abs() >= prior.abs()) =>
1334 {
1335 Ok(())
1336 }
1337 _ => Err(OrderError::InvalidFillVoidCommission(event.trade_id)),
1338 }
1339 }
1340
1341 fn latest_fill_void(&self, trade_id: TradeId) -> Option<&OrderFillVoided> {
1342 self.events
1343 .iter()
1344 .rev()
1345 .find_map(|candidate| match candidate {
1346 OrderEventAny::FillVoided(event) if event.trade_id == trade_id => Some(event),
1347 _ => None,
1348 })
1349 }
1350
1351 fn fill_voided(&mut self, event: &OrderFillVoided, source_status: OrderStatus) {
1352 let has_local_fill = self.events.iter().any(
1353 |candidate| matches!(candidate, OrderEventAny::Filled(fill) if fill.trade_id == event.trade_id),
1354 );
1355 let non_reopened_voided_qty = self.recompute_fill_state(Some(event));
1356 let unfilled_qty = self.quantity.saturating_sub(self.filled_qty);
1357 let working_leaves = unfilled_qty.saturating_sub(non_reopened_voided_qty);
1358
1359 match source_status {
1360 OrderStatus::Voided => {
1361 self.status = OrderStatus::Voided;
1362 self.leaves_qty = Quantity::zero(self.quantity.precision);
1363 }
1364 _ if !has_local_fill && !event.is_reopened => {
1365 self.status = OrderStatus::Voided;
1366 self.leaves_qty = Quantity::zero(self.quantity.precision);
1367 }
1368 OrderStatus::Canceled | OrderStatus::Expired => {
1369 self.status = source_status;
1370 self.leaves_qty = unfilled_qty;
1371 }
1372 _ if working_leaves.is_zero() => {
1373 self.status = OrderStatus::Voided;
1374 self.leaves_qty = working_leaves;
1375 }
1376 OrderStatus::PendingUpdate | OrderStatus::PendingCancel | OrderStatus::Triggered => {
1377 self.status = source_status;
1378 self.leaves_qty = working_leaves;
1379 }
1380 _ => {
1381 self.status = if self.filled_qty.is_zero() {
1382 OrderStatus::Accepted
1383 } else {
1384 OrderStatus::PartiallyFilled
1385 };
1386 self.leaves_qty = working_leaves;
1387 }
1388 }
1389
1390 if self.status.is_open() {
1391 self.ts_closed = None;
1392 } else if self.status.is_closed() {
1393 self.ts_closed = self.ts_closed.or(Some(event.ts_event));
1394 }
1395 }
1396
1397 fn recompute_fill_state(&mut self, additional: Option<&OrderFillVoided>) -> Quantity {
1398 let corrections = self.fill_corrections(additional);
1399
1400 let mut totals = FillTotals::default();
1401 let mut filled = Quantity::zero(self.quantity.precision);
1402 let mut voided = Quantity::zero(self.quantity.precision);
1403 let mut non_reopened_voided = Quantity::zero(self.quantity.precision);
1404
1405 let mut commissions = IndexMap::<Currency, Money>::new();
1406 let mut trade_ids = Vec::new();
1407 let mut last_trade_id = None;
1408 let mut position_id = None;
1409 let mut liquidity_side = Some(LiquiditySide::NoLiquiditySide);
1410 let mut matched_corrections = AHashSet::new();
1411 let prices = self.accounting_prices();
1412
1413 for fill in self.quantity_fills() {
1414 let correction = corrections.get(&fill.trade_id).copied();
1415 if correction.is_some() {
1416 matched_corrections.insert(fill.trade_id);
1417 }
1418 let removed = Self::removed_fill_qty(fill, correction);
1419 let effective = fill.last_qty - removed;
1420 voided = voided.saturating_add(removed);
1421 if correction.is_some_and(|event| !event.is_reopened) {
1422 non_reopened_voided = non_reopened_voided.saturating_add(removed);
1423 }
1424
1425 if !effective.is_zero() {
1426 let price = prices
1427 .get(&fill.trade_id)
1428 .copied()
1429 .unwrap_or(fill.last_px.as_decimal());
1430 totals.add(effective.as_decimal(), price);
1431 filled = filled.saturating_add(effective);
1432 trade_ids.push(fill.trade_id);
1433 last_trade_id = Some(fill.trade_id);
1434 position_id = fill.position_id;
1435 liquidity_side = Some(fill.liquidity_side);
1436 }
1437
1438 if let Some(commission) = fill.commission {
1439 let surviving = correction
1440 .and_then(|event| event.commission_voided)
1441 .filter(|voided| !voided.is_zero())
1442 .map_or(commission, |voided| commission - voided);
1443
1444 if !surviving.is_zero() {
1445 commissions
1446 .entry(surviving.currency)
1447 .and_modify(|total| *total = *total + surviving)
1448 .or_insert(surviving);
1449 }
1450 }
1451 }
1452
1453 for (trade_id, correction) in corrections {
1454 if !matched_corrections.contains(&trade_id) {
1455 voided = voided.saturating_add(correction.voided_qty);
1456 }
1457 }
1458
1459 self.filled_qty = filled;
1460 self.voided_qty = voided;
1461 self.non_reopened_voided_qty = non_reopened_voided;
1462 self.overfill_qty = self.filled_qty.saturating_sub(self.quantity);
1463 self.avg_px = totals.average();
1464 self.fill_totals = Some(totals);
1465 self.commissions = commissions;
1466 self.trade_ids = trade_ids;
1467 self.last_trade_id = last_trade_id;
1468 self.position_id = position_id;
1469 self.liquidity_side = liquidity_side;
1470
1471 non_reopened_voided
1472 }
1473
1474 fn updated(&mut self, event: &OrderUpdated) {
1475 if matches!(
1476 self.status,
1477 OrderStatus::PendingUpdate | OrderStatus::PendingCancel,
1478 ) && let Some(previous) = self.previous_status
1479 {
1480 self.status = self
1481 .pending_commands
1482 .last()
1483 .map_or(previous, |(status, _)| *status);
1484 }
1485
1486 if event.reconciliation && !self.filled_qty.is_zero() && event.quantity == self.filled_qty {
1487 self.status = OrderStatus::Filled;
1488 self.ts_closed = Some(event.ts_event);
1489 }
1490
1491 if let Some(venue_order_id) = &event.venue_order_id
1492 && (self.venue_order_id.is_none()
1493 || venue_order_id != self.venue_order_id.as_ref().unwrap())
1494 {
1495 self.venue_order_id = Some(*venue_order_id);
1496 self.venue_order_ids.push(*venue_order_id);
1497 }
1498
1499 self.is_quote_quantity = event.is_quote_quantity;
1500 }
1501
1502 pub(crate) fn apply_updated_quantity(&mut self, new_quantity: Quantity) {
1506 self.quantity = new_quantity;
1507 let unfilled_qty = self.quantity.saturating_sub(self.filled_qty);
1508 let voided_qty = self.non_reopened_voided_qty;
1509
1510 self.leaves_qty = if voided_qty > unfilled_qty {
1513 Quantity::zero(unfilled_qty.precision.max(voided_qty.precision))
1514 } else {
1515 unfilled_qty - voided_qty
1516 };
1517 }
1518
1519 fn filled(&mut self, event: &OrderFilled, source_status: OrderStatus) {
1520 let new_filled_qty = self
1521 .filled_qty
1522 .checked_add(event.last_qty)
1523 .expect("fill quantity bounds pre-checked");
1524
1525 if new_filled_qty > self.quantity {
1527 let overfill = new_filled_qty - self.quantity;
1528 self.overfill_qty = self.overfill_qty.saturating_add(overfill);
1529 }
1530
1531 let new_leaves_qty = self.leaves_qty.saturating_sub(event.last_qty);
1532
1533 if new_filled_qty >= self.quantity {
1534 self.status = OrderStatus::Filled;
1535 self.ts_closed = Some(event.ts_event);
1536 } else if new_leaves_qty.is_zero() && !self.voided_qty.is_zero() {
1537 self.status = OrderStatus::Voided;
1538 self.ts_closed = Some(event.ts_event);
1539 } else if matches!(source_status, OrderStatus::Canceled | OrderStatus::Expired) {
1540 self.status = source_status;
1541 } else {
1542 self.status = OrderStatus::PartiallyFilled;
1543
1544 if matches!(
1545 source_status,
1546 OrderStatus::PendingUpdate | OrderStatus::PendingCancel,
1547 ) {
1548 self.previous_status = Some(self.status);
1549 self.status = source_status;
1550 }
1551 }
1552
1553 let is_historical_venue_order_id = self.venue_order_id.is_some_and(|current| {
1554 current != event.venue_order_id && self.venue_order_ids.contains(&event.venue_order_id)
1555 });
1556
1557 if !is_historical_venue_order_id {
1558 self.venue_order_id = Some(event.venue_order_id);
1559 }
1560 self.position_id = event.position_id;
1561 self.trade_ids.push(event.trade_id);
1562 self.last_trade_id = Some(event.trade_id);
1563 self.liquidity_side = Some(event.liquidity_side);
1564 self.filled_qty = new_filled_qty;
1565 self.leaves_qty = new_leaves_qty;
1566 self.ts_last = event.ts_event;
1567
1568 if let Some(commission) = event.commission {
1569 let commission_currency = commission.currency;
1570 if let Some(existing_commission) = self.commissions.get_mut(&commission_currency) {
1571 *existing_commission = *existing_commission + commission;
1572 } else {
1573 self.commissions.insert(commission_currency, commission);
1574 }
1575 }
1576
1577 if self.ts_accepted.is_none() {
1578 self.ts_accepted = Some(event.ts_event);
1580 }
1581
1582 if self.fill_totals.is_none() {
1583 self.fill_totals = Some(self.fill_totals_from_events());
1584 }
1585
1586 let totals = self.fill_totals.as_mut().expect("fill totals initialized");
1587 totals.add(event.last_qty.as_decimal(), event.last_px.as_decimal());
1588 self.avg_px = totals.average();
1589
1590 debug_assert!(
1591 matches!(
1592 self.status,
1593 OrderStatus::PartiallyFilled | OrderStatus::Filled | OrderStatus::Voided
1594 ) || (self.status == source_status
1595 && matches!(
1596 source_status,
1597 OrderStatus::Canceled
1598 | OrderStatus::Expired
1599 | OrderStatus::PendingUpdate
1600 | OrderStatus::PendingCancel
1601 )),
1602 "Invariant: status must reflect the fill or preserve a closed or pending source status after fill handler (status={:?})",
1603 self.status
1604 );
1605 debug_assert!(
1606 self.venue_order_id.is_some()
1607 && self.last_trade_id.is_some()
1608 && !self.trade_ids.is_empty(),
1609 "Invariant: venue_order_id, last_trade_id, and trade_ids must be set after fill"
1610 );
1611 debug_assert!(
1612 self.filled_qty
1613 .saturating_add(self.voided_qty)
1614 .saturating_add(self.leaves_qty)
1615 >= self.quantity,
1616 "Invariant: filled_qty + voided_qty + leaves_qty >= quantity (filled={}, voided={}, leaves={}, quantity={})",
1617 self.filled_qty,
1618 self.voided_qty,
1619 self.leaves_qty,
1620 self.quantity
1621 );
1622 }
1623
1624 fn has_prior_fill_void(&self, trade_id: TradeId) -> bool {
1625 self.events.iter().any(|candidate| {
1626 matches!(
1627 candidate,
1628 OrderEventAny::FillVoided(existing) if existing.trade_id == trade_id
1629 )
1630 })
1631 }
1632
1633 fn is_price_restatement_fill(&self, fill: &OrderFilled) -> Result<bool, OrderError> {
1634 let mut latest = None;
1635
1636 for candidate in &self.events {
1637 let OrderEventAny::Filled(existing) = candidate else {
1638 continue;
1639 };
1640
1641 if existing.trade_id != fill.trade_id {
1642 continue;
1643 }
1644
1645 latest = Some(existing.last_px);
1646 }
1647
1648 match latest {
1649 Some(price) if price == fill.last_px => Err(OrderError::DuplicateFill(fill.trade_id)),
1650 Some(_) => Ok(true),
1651 None => Ok(false),
1652 }
1653 }
1654
1655 fn restate_fill_price(&mut self, event: OrderEventAny) {
1656 self.ts_last = event.ts_event();
1657 self.events.push(event);
1658 let totals = self.fill_totals_from_events();
1659 self.avg_px = totals.average();
1660 self.fill_totals = Some(totals);
1661 }
1662
1663 fn fill_totals_from_events(&self) -> FillTotals {
1664 let corrections = self.fill_corrections(None);
1665 let prices = self.accounting_prices();
1666 let mut totals = FillTotals::default();
1667
1668 for fill in self.quantity_fills() {
1669 let removed = Self::removed_fill_qty(fill, corrections.get(&fill.trade_id).copied());
1670 let effective = (fill.last_qty - removed).as_decimal();
1671 if !effective.is_zero() {
1672 let price = prices
1673 .get(&fill.trade_id)
1674 .copied()
1675 .unwrap_or(fill.last_px.as_decimal());
1676 totals.add(effective, price);
1677 }
1678 }
1679
1680 totals
1681 }
1682
1683 fn quantity_fills(&self) -> Vec<&OrderFilled> {
1684 let mut seen = AHashSet::new();
1685 let mut fills = Vec::new();
1686
1687 for candidate in &self.events {
1688 let OrderEventAny::Filled(fill) = candidate else {
1689 continue;
1690 };
1691
1692 if seen.insert(fill.trade_id) {
1693 fills.push(fill);
1694 }
1695 }
1696
1697 fills
1698 }
1699
1700 fn accounting_prices(&self) -> AHashMap<TradeId, Decimal> {
1701 let mut prices = AHashMap::new();
1702
1703 for candidate in &self.events {
1704 if let OrderEventAny::Filled(fill) = candidate {
1705 prices.insert(fill.trade_id, fill.last_px.as_decimal());
1706 }
1707 }
1708
1709 prices
1710 }
1711
1712 fn fill_corrections<'a>(
1713 &'a self,
1714 additional: Option<&'a OrderFillVoided>,
1715 ) -> IndexMap<TradeId, &'a OrderFillVoided> {
1716 let mut corrections = IndexMap::new();
1717
1718 for candidate in &self.events {
1719 if let OrderEventAny::FillVoided(event) = candidate {
1720 corrections.insert(event.trade_id, event);
1721 }
1722 }
1723
1724 if let Some(event) = additional {
1725 corrections.insert(event.trade_id, event);
1726 }
1727
1728 corrections
1729 }
1730
1731 fn removed_fill_qty(fill: &OrderFilled, correction: Option<&OrderFillVoided>) -> Quantity {
1732 correction.map_or_else(
1733 || Quantity::zero(fill.last_qty.precision),
1734 |event| event.voided_qty.min(fill.last_qty),
1735 )
1736 }
1737
1738 pub fn set_slippage(&mut self, price: Price) {
1739 self.slippage = self.avg_px.and_then(|avg_px| {
1740 let current_price = price.as_decimal();
1741 match self.side {
1742 OrderSide::Buy if avg_px > current_price => avg_px.checked_sub(current_price),
1743 OrderSide::Sell if avg_px < current_price => current_price.checked_sub(avg_px),
1744 _ => None,
1745 }
1746 });
1747 }
1748
1749 #[must_use]
1751 pub fn opposite_side(side: OrderSide) -> OrderSide {
1752 side.opposite()
1753 }
1754
1755 #[must_use]
1757 pub fn closing_side(side: PositionSide) -> Option<OrderSide> {
1758 match side {
1759 PositionSide::Long => Some(OrderSide::Sell),
1760 PositionSide::Short => Some(OrderSide::Buy),
1761 PositionSide::Flat => None,
1762 }
1763 }
1764
1765 #[must_use]
1766 pub fn signed_decimal_qty(&self) -> Decimal {
1767 match self.side {
1768 OrderSide::Buy => self.quantity.as_decimal(),
1769 OrderSide::Sell => -self.quantity.as_decimal(),
1770 }
1771 }
1772
1773 #[must_use]
1774 pub fn would_reduce_only(&self, side: PositionSide, position_qty: Quantity) -> bool {
1775 if side == PositionSide::Flat {
1776 return false;
1777 }
1778
1779 match (self.side, side) {
1780 (OrderSide::Buy, PositionSide::Long) => false,
1781 (OrderSide::Buy, PositionSide::Short) => self.leaves_qty <= position_qty,
1782 (OrderSide::Sell, PositionSide::Short) => false,
1783 (OrderSide::Sell, PositionSide::Long) => self.leaves_qty <= position_qty,
1784 (_, PositionSide::Flat) => false,
1785 }
1786 }
1787
1788 #[must_use]
1789 pub fn commission(&self, currency: &Currency) -> Option<Money> {
1790 self.commissions.get(currency).copied()
1791 }
1792
1793 #[must_use]
1794 pub fn commissions(&self) -> IndexMap<Currency, Money> {
1795 self.commissions.clone()
1796 }
1797
1798 #[must_use]
1799 pub fn commissions_vec(&self) -> Vec<Money> {
1800 self.commissions.values().copied().collect()
1801 }
1802
1803 #[must_use]
1805 pub fn events(&self) -> &[OrderEventAny] {
1806 &self.events
1807 }
1808
1809 pub fn prepend_events(&mut self, events: impl IntoIterator<Item = OrderEventAny>) {
1814 self.fill_totals = None;
1815 self.events.splice(..0, events);
1816 }
1817
1818 pub(crate) fn set_init_metadata(
1820 &mut self,
1821 reconciliation: bool,
1822 causation_id: Option<UUID4>,
1823 ts_init: UnixNanos,
1824 ) {
1825 if let Some(OrderEventAny::Initialized(init)) = self.events.first_mut() {
1826 init.reconciliation = reconciliation;
1827 init.causation_id = causation_id;
1828 init.ts_init = ts_init;
1829 }
1830 }
1831
1832 #[must_use]
1833 pub fn init_event(&self) -> Option<OrderEventAny> {
1834 self.events.first().cloned()
1835 }
1836}
1837
1838#[derive(Clone, Debug, Default)]
1841struct FillTotals {
1842 notional: Decimal,
1843 quantity: Decimal,
1844}
1845
1846impl FillTotals {
1847 fn add(&mut self, quantity: Decimal, price: Decimal) {
1848 self.notional = self.notional.saturating_add(quantity.saturating_mul(price));
1849 self.quantity = self.quantity.saturating_add(quantity);
1850 }
1851
1852 fn average(&self) -> Option<Decimal> {
1853 self.notional.checked_div(self.quantity)
1854 }
1855}
1856
1857#[cfg(test)]
1858mod tests {
1859 use std::str::FromStr;
1860
1861 use rstest::rstest;
1862 use rust_decimal_macros::dec;
1863 use strum::IntoEnumIterator;
1864
1865 use super::*;
1866 use crate::{
1867 enums::{
1868 LiquiditySide, OrderSide, OrderStatus, OrderType, PositionSide, TrailingOffsetType,
1869 TriggerType,
1870 },
1871 events::order::spec::{
1872 OrderAcceptedSpec, OrderCancelDeniedSpec, OrderCancelRejectedSpec, OrderCanceledSpec,
1873 OrderDeniedSpec, OrderExpiredSpec, OrderFillVoidedSpec, OrderFilledSpec,
1874 OrderInitializedSpec, OrderModifyDeniedSpec, OrderModifyRejectedSpec,
1875 OrderPendingCancelSpec, OrderPendingUpdateSpec, OrderRejectedSpec, OrderSubmittedSpec,
1876 OrderTriggeredSpec, OrderUpdatedSpec,
1877 },
1878 identifiers::InstrumentId,
1879 instruments::{CurrencyPair, Instrument, InstrumentAny, stubs::audusd_sim},
1880 orders::{MarketOrder, builder::OrderTestBuilder, stubs::TestOrderStubs},
1881 stubs::TestDefault,
1882 types::{
1883 Price, Quantity,
1884 money::{MONEY_RAW_MAX, MONEY_RAW_MIN, MoneyRaw},
1885 quantity::{QUANTITY_RAW_MAX, QuantityRaw},
1886 },
1887 };
1888
1889 #[rstest]
1900 #[case(OrderSide::Buy, OrderSide::Sell)]
1901 #[case(OrderSide::Sell, OrderSide::Buy)]
1902 fn test_order_opposite_side(#[case] order_side: OrderSide, #[case] expected_side: OrderSide) {
1903 let result = OrderCore::opposite_side(order_side);
1904 assert_eq!(result, expected_side);
1905 }
1906
1907 #[rstest]
1908 #[case(PositionSide::Long, Some(OrderSide::Sell))]
1909 #[case(PositionSide::Short, Some(OrderSide::Buy))]
1910 #[case(PositionSide::Flat, None)]
1911 fn test_closing_side(
1912 #[case] position_side: PositionSide,
1913 #[case] expected_side: Option<OrderSide>,
1914 ) {
1915 let result = OrderCore::closing_side(position_side);
1916 assert_eq!(result, expected_side);
1917 }
1918
1919 #[rstest]
1920 #[case(OrderSide::Buy, dec!(10_000))]
1921 #[case(OrderSide::Sell, dec!(-10_000))]
1922 fn test_signed_decimal_qty(#[case] order_side: OrderSide, #[case] expected: Decimal) {
1923 let order: MarketOrder = OrderInitializedSpec::builder()
1924 .order_side(order_side)
1925 .quantity(Quantity::from(10_000))
1926 .build()
1927 .try_into()
1928 .unwrap();
1929
1930 let result = order.signed_decimal_qty();
1931 assert_eq!(result, expected);
1932 }
1933
1934 #[rustfmt::skip]
1935 #[rstest]
1936 #[case(OrderSide::Buy, Quantity::from(100), PositionSide::Long, Quantity::from(50), false)]
1937 #[case(OrderSide::Buy, Quantity::from(50), PositionSide::Short, Quantity::from(50), true)]
1938 #[case(OrderSide::Buy, Quantity::from(50), PositionSide::Short, Quantity::from(100), true)]
1939 #[case(OrderSide::Buy, Quantity::from(50), PositionSide::Flat, Quantity::from(0), false)]
1940 #[case(OrderSide::Sell, Quantity::from(50), PositionSide::Flat, Quantity::from(0), false)]
1941 #[case(OrderSide::Sell, Quantity::from(50), PositionSide::Long, Quantity::from(50), true)]
1942 #[case(OrderSide::Sell, Quantity::from(50), PositionSide::Long, Quantity::from(100), true)]
1943 #[case(OrderSide::Sell, Quantity::from(100), PositionSide::Short, Quantity::from(50), false)]
1944 fn test_would_reduce_only(
1945 #[case] order_side: OrderSide,
1946 #[case] order_qty: Quantity,
1947 #[case] position_side: PositionSide,
1948 #[case] position_qty: Quantity,
1949 #[case] expected: bool,
1950 ) {
1951 let order: MarketOrder = OrderInitializedSpec::builder()
1952 .order_side(order_side)
1953 .quantity(order_qty)
1954 .build()
1955 .try_into()
1956 .unwrap();
1957
1958 assert_eq!(
1959 order.would_reduce_only(position_side, position_qty),
1960 expected
1961 );
1962 }
1963
1964 #[rstest]
1965 fn test_order_state_transition_denied() {
1966 let mut order: MarketOrder = OrderInitializedSpec::builder().build().try_into().unwrap();
1967 let denied = OrderDeniedSpec::builder().build();
1968 let event = OrderEventAny::Denied(denied);
1969
1970 order.apply(event.clone()).unwrap();
1971
1972 assert_eq!(order.status, OrderStatus::Denied);
1973 assert!(order.is_closed());
1974 assert!(!order.is_open());
1975 assert_eq!(order.event_count(), 2);
1976 assert_eq!(order.last_event(), &event);
1977 }
1978
1979 #[rstest]
1980 fn test_order_life_cycle_to_filled() {
1981 let init = OrderInitializedSpec::builder().build();
1982 let submitted = OrderSubmittedSpec::builder().build();
1983 let accepted = OrderAcceptedSpec::builder().build();
1984 let filled = OrderFilledSpec::builder().build();
1985
1986 let mut order: MarketOrder = init.clone().try_into().unwrap();
1987 order.apply(OrderEventAny::Submitted(submitted)).unwrap();
1988 order.apply(OrderEventAny::Accepted(accepted)).unwrap();
1989 order.apply(OrderEventAny::Filled(filled)).unwrap();
1990
1991 assert_eq!(order.client_order_id, init.client_order_id);
1992 assert_eq!(order.status(), OrderStatus::Filled);
1993 assert_eq!(order.filled_qty(), Quantity::from(100_000));
1994 assert_eq!(order.leaves_qty(), Quantity::from(0));
1995 assert_eq!(order.avg_px(), Some(dec!(1.0)));
1996 assert!(!order.is_open());
1997 assert!(order.is_closed());
1998 assert_eq!(order.commission(&Currency::USD()), None);
1999 assert_eq!(order.commissions(), &IndexMap::new());
2000 }
2001
2002 #[rstest]
2003 fn test_order_life_cycle_fills_with_negative_prices() {
2004 let init = OrderInitializedSpec::builder()
2008 .quantity(Quantity::from(100_000))
2009 .build();
2010 let submitted = OrderSubmittedSpec::builder().build();
2011 let accepted = OrderAcceptedSpec::builder().build();
2012 let fill1 = OrderFilledSpec::builder()
2013 .last_qty(Quantity::from(50_000))
2014 .last_px(Price::from("-5.00000"))
2015 .trade_id(TradeId::from("TRADE-1"))
2016 .build();
2017 let fill2 = OrderFilledSpec::builder()
2018 .last_qty(Quantity::from(50_000))
2019 .last_px(Price::from("-7.00000"))
2020 .trade_id(TradeId::from("TRADE-2"))
2021 .build();
2022
2023 let mut order: MarketOrder = init.try_into().unwrap();
2024 order.apply(OrderEventAny::Submitted(submitted)).unwrap();
2025 order.apply(OrderEventAny::Accepted(accepted)).unwrap();
2026 order.apply(OrderEventAny::Filled(fill1)).unwrap();
2027 order.apply(OrderEventAny::Filled(fill2)).unwrap();
2028
2029 assert_eq!(order.status(), OrderStatus::Filled);
2030 assert_eq!(order.filled_qty(), Quantity::from(100_000));
2031 assert_eq!(order.leaves_qty(), Quantity::from(0));
2032 assert_eq!(order.avg_px(), Some(dec!(-6.0)));
2034 }
2035
2036 fn fill(trade_id: &str, last_qty: &str, last_px: &str) -> (TradeId, Quantity, Price) {
2037 (
2038 TradeId::from(trade_id),
2039 Quantity::from(last_qty),
2040 Price::from(last_px),
2041 )
2042 }
2043
2044 fn market_order_with_fills(
2045 order_side: OrderSide,
2046 quantity: Quantity,
2047 fills: &[(TradeId, Quantity, Price)],
2048 ) -> MarketOrder {
2049 let mut order: MarketOrder = OrderInitializedSpec::builder()
2050 .order_side(order_side)
2051 .quantity(quantity)
2052 .build()
2053 .try_into()
2054 .unwrap();
2055 order
2056 .apply(OrderEventAny::Accepted(
2057 OrderAcceptedSpec::builder().build(),
2058 ))
2059 .unwrap();
2060
2061 for (trade_id, last_qty, last_px) in fills {
2062 order
2063 .apply(OrderEventAny::Filled(
2064 OrderFilledSpec::builder()
2065 .order_side(order_side)
2066 .trade_id(*trade_id)
2067 .last_qty(*last_qty)
2068 .last_px(*last_px)
2069 .build(),
2070 ))
2071 .unwrap();
2072 }
2073
2074 order
2075 }
2076
2077 #[rstest]
2078 #[case::cloned("clone")]
2079 #[case::snapshot("snapshot")]
2080 #[case::replayed("replay")]
2081 fn test_fill_totals_survive_corrections_and_restoration(#[case] restoration: &str) {
2082 let mut order = market_order_with_fills(OrderSide::Buy, Quantity::from(20), &[]);
2083 let first = OrderFilledSpec::builder()
2084 .trade_id(TradeId::from("T-1"))
2085 .last_qty(Quantity::from(4))
2086 .last_px(Price::from("1.00"))
2087 .build();
2088 let second = OrderFilledSpec::builder()
2089 .trade_id(TradeId::from("T-2"))
2090 .last_qty(Quantity::from(2))
2091 .last_px(Price::from("2.00"))
2092 .build();
2093 let third = OrderFilledSpec::builder()
2094 .trade_id(TradeId::from("T-3"))
2095 .last_qty(Quantity::from(1))
2096 .last_px(Price::from("-3.00"))
2097 .build();
2098 let fourth = OrderFilledSpec::builder()
2099 .trade_id(TradeId::from("T-4"))
2100 .last_qty(Quantity::from(2))
2101 .last_px(Price::from("0.15"))
2102 .build();
2103 let steps = [
2104 (
2105 OrderEventAny::Filled(first.clone()),
2106 4,
2107 0,
2108 16,
2109 Some(dec!(1)),
2110 ),
2111 (
2112 OrderEventAny::Filled(second.clone()),
2113 6,
2114 0,
2115 14,
2116 Some(dec!(1.3333333333333333333333333333)),
2117 ),
2118 (
2119 OrderEventAny::FillVoided(matching_fill_void(&first, Quantity::from(1), None)),
2120 5,
2121 1,
2122 15,
2123 Some(dec!(1.4)),
2124 ),
2125 (
2126 OrderEventAny::FillVoided(matching_fill_void(&first, Quantity::from(3), None)),
2127 3,
2128 3,
2129 17,
2130 Some(dec!(1.6666666666666666666666666667)),
2131 ),
2132 (
2133 OrderEventAny::Filled(third.clone()),
2134 4,
2135 3,
2136 16,
2137 Some(dec!(0.5)),
2138 ),
2139 (
2140 OrderEventAny::FillVoided(matching_fill_void(&first, Quantity::from(4), None)),
2141 3,
2142 4,
2143 17,
2144 Some(dec!(0.3333333333333333333333333333)),
2145 ),
2146 (
2147 OrderEventAny::FillVoided(matching_fill_void(&second, Quantity::from(2), None)),
2148 1,
2149 6,
2150 19,
2151 Some(dec!(-3)),
2152 ),
2153 (
2154 OrderEventAny::FillVoided(matching_fill_void(&third, Quantity::from(1), None)),
2155 0,
2156 7,
2157 20,
2158 None,
2159 ),
2160 (OrderEventAny::Filled(fourth), 2, 7, 18, Some(dec!(0.15))),
2161 ];
2162 let mut expected_events = OrderCore::events(&order).to_vec();
2163
2164 for (event, filled, voided, leaves, average) in steps {
2165 let mut restored = match restoration {
2166 "clone" => order.clone(),
2167 "snapshot" => {
2168 let snapshot = serde_json::to_value(&order).unwrap();
2169 assert!(
2170 !snapshot["core"]
2171 .as_object()
2172 .unwrap()
2173 .contains_key("fill_totals")
2174 );
2175 serde_json::from_value(snapshot).unwrap()
2176 }
2177 "replay" => {
2178 let replayed = OrderAny::from_events(expected_events.clone()).unwrap();
2179
2180 let OrderAny::Market(replayed) = replayed else {
2181 panic!("Expected a market order");
2182 };
2183
2184 replayed
2185 }
2186 _ => unreachable!(),
2187 };
2188
2189 order.apply(event.clone()).unwrap();
2190 restored.apply(event.clone()).unwrap();
2191 expected_events.push(event);
2192
2193 assert_eq!(restored.avg_px(), average);
2194 assert_eq!(restored.filled_qty(), Quantity::from(filled));
2195 assert_eq!(restored.voided_qty(), Quantity::from(voided));
2196 assert_eq!(restored.leaves_qty(), Quantity::from(leaves));
2197 assert_eq!(OrderCore::events(&restored), expected_events);
2198 assert_eq!(
2199 serde_json::to_value(&restored).unwrap(),
2200 serde_json::to_value(&order).unwrap()
2201 );
2202 order = restored;
2203 }
2204 }
2205
2206 #[rstest]
2207 fn test_prepended_events_invalidate_fill_totals_without_applying_state() {
2208 let mut order = market_order_with_fills(
2209 OrderSide::Buy,
2210 Quantity::from(10),
2211 &[fill("T-CURRENT", "1", "2.00")],
2212 );
2213 let historical = [
2214 OrderEventAny::Filled(
2215 OrderFilledSpec::builder()
2216 .trade_id(TradeId::from("T-PAST-1"))
2217 .last_qty(Quantity::from(2))
2218 .last_px(Price::from("3.00"))
2219 .build(),
2220 ),
2221 OrderEventAny::Filled(
2222 OrderFilledSpec::builder()
2223 .trade_id(TradeId::from("T-PAST-2"))
2224 .last_qty(Quantity::from(1))
2225 .last_px(Price::from("4.00"))
2226 .build(),
2227 ),
2228 ];
2229 let mut expected_events = historical.to_vec();
2230 expected_events.extend_from_slice(OrderCore::events(&order));
2231 order.prepend_events(historical);
2232 assert_eq!(OrderCore::events(&order), expected_events);
2233 assert_eq!(order.avg_px(), Some(dec!(2)));
2234 assert_eq!(order.filled_qty(), Quantity::from(1));
2235 assert_eq!(order.leaves_qty(), Quantity::from(9));
2236
2237 let next = OrderEventAny::Filled(
2238 OrderFilledSpec::builder()
2239 .trade_id(TradeId::from("T-NEXT"))
2240 .last_qty(Quantity::from(2))
2241 .last_px(Price::from("3.00"))
2242 .build(),
2243 );
2244 expected_events.push(next.clone());
2245 order.apply(next).unwrap();
2246
2247 assert_eq!(OrderCore::events(&order), expected_events);
2248 assert_eq!(order.avg_px(), Some(dec!(3)));
2249 assert_eq!(order.filled_qty(), Quantity::from(3));
2250 assert_eq!(order.leaves_qty(), Quantity::from(7));
2251 assert_eq!(order.voided_qty(), Quantity::from(0));
2252 }
2253
2254 #[rstest]
2255 fn test_restored_fill_totals_use_history_instead_of_snapshot_average() {
2256 let order = market_order_with_fills(
2257 OrderSide::Buy,
2258 Quantity::from(10),
2259 &[fill("T-1", "1", "0.10"), fill("T-2", "2", "0.20")],
2260 );
2261 let mut snapshot = serde_json::to_value(&order).unwrap();
2262 snapshot["core"]["avg_px"] = serde_json::to_value(dec!(99)).unwrap();
2263 let mut restored: MarketOrder = serde_json::from_value(snapshot).unwrap();
2264 restored
2265 .apply(OrderEventAny::Filled(
2266 OrderFilledSpec::builder()
2267 .trade_id(TradeId::from("T-3"))
2268 .last_qty(Quantity::from(2))
2269 .last_px(Price::from("0.35"))
2270 .build(),
2271 ))
2272 .unwrap();
2273
2274 assert_eq!(restored.avg_px(), Some(dec!(0.24)));
2275 assert_eq!(restored.filled_qty(), Quantity::from(5));
2276 assert_eq!(restored.leaves_qty(), Quantity::from(5));
2277 assert_eq!(restored.voided_qty(), Quantity::from(0));
2278 }
2279
2280 #[rstest]
2281 fn test_restored_unknown_fill_void_applies_after_matching_fill() {
2282 let mut order = market_order_with_fills(OrderSide::Buy, Quantity::from(10), &[]);
2283 let first = OrderFilledSpec::builder()
2284 .trade_id(TradeId::from("T-RESTORED"))
2285 .last_qty(Quantity::from(4))
2286 .last_px(Price::from("1.00"))
2287 .build();
2288 let mut correction = matching_fill_void(&first, Quantity::from(2), None);
2289 correction.is_reopened = false;
2290 order.apply(OrderEventAny::FillVoided(correction)).unwrap();
2291 let mut snapshot = serde_json::to_value(&order).unwrap();
2292 snapshot["core"]["status"] = serde_json::to_value(OrderStatus::Accepted).unwrap();
2293 snapshot["core"]["leaves_qty"] = serde_json::to_value(Quantity::from(8)).unwrap();
2294 let mut restored: MarketOrder = serde_json::from_value(snapshot).unwrap();
2295 restored.apply(OrderEventAny::Filled(first)).unwrap();
2296 assert_eq!(restored.avg_px(), Some(dec!(1)));
2297
2298 restored
2299 .apply(OrderEventAny::Filled(
2300 OrderFilledSpec::builder()
2301 .trade_id(TradeId::from("T-NEXT"))
2302 .last_qty(Quantity::from(2))
2303 .last_px(Price::from("3.00"))
2304 .build(),
2305 ))
2306 .unwrap();
2307
2308 assert_eq!(restored.avg_px(), Some(dec!(2)));
2309 assert_eq!(restored.filled_qty(), Quantity::from(6));
2310 assert_eq!(restored.voided_qty(), Quantity::from(2));
2311 assert_eq!(restored.leaves_qty(), Quantity::from(2));
2312 }
2313
2314 #[rstest]
2315 #[case::positive(Decimal::MAX, Decimal::ONE, Decimal::MAX)]
2316 #[case::negative(Decimal::MIN, -Decimal::ONE, Decimal::MIN)]
2317 fn test_fill_totals_preserve_saturation_order(
2318 #[case] price: Decimal,
2319 #[case] increment: Decimal,
2320 #[case] saturated: Decimal,
2321 ) {
2322 let mut totals = FillTotals::default();
2323 totals.add(dec!(2), price);
2324 totals.add(Decimal::ONE, increment);
2325 totals.add(Decimal::ONE, -increment);
2326
2327 assert_eq!(totals.notional, saturated - increment);
2328 assert_eq!(totals.quantity, dec!(4));
2329 assert_eq!(
2330 totals.average(),
2331 (saturated - increment).checked_div(dec!(4))
2332 );
2333 }
2334
2335 #[rstest]
2336 fn test_fill_totals_preserve_quantity_saturation() {
2337 let mut totals = FillTotals::default();
2338 totals.add(Decimal::MAX, Decimal::ZERO);
2339 totals.add(Decimal::ONE, Decimal::ONE);
2340
2341 assert_eq!(totals.notional, Decimal::ONE);
2342 assert_eq!(totals.quantity, Decimal::MAX);
2343 assert_eq!(totals.average(), Decimal::ONE.checked_div(Decimal::MAX));
2344 }
2345
2346 #[rstest]
2347 #[case(OrderSide::Buy)]
2348 #[case(OrderSide::Sell)]
2349 fn test_avg_px_weighted_average_is_exact(#[case] order_side: OrderSide) {
2350 let order = market_order_with_fills(
2353 order_side,
2354 Quantity::from(6),
2355 &[
2356 fill("TRADE-1", "1", "0.07"),
2357 fill("TRADE-2", "2", "0.13"),
2358 fill("TRADE-3", "3", "0.29"),
2359 ],
2360 );
2361
2362 assert_eq!(order.status(), OrderStatus::Filled);
2363 assert_eq!(order.filled_qty(), Quantity::from(6));
2364 assert_eq!(order.leaves_qty(), Quantity::from(0));
2365 assert_eq!(order.voided_qty(), Quantity::from(0));
2366 assert_eq!(order.avg_px(), Some(dec!(0.2)));
2367 }
2368
2369 #[rstest]
2370 fn test_avg_px_keeps_a_quotient_no_f64_can_hold() {
2371 let order = market_order_with_fills(
2374 OrderSide::Buy,
2375 Quantity::from(3),
2376 &[fill("TRADE-1", "1", "1.00"), fill("TRADE-2", "2", "2.00")],
2377 );
2378
2379 assert_eq!(order.status(), OrderStatus::Filled);
2380 assert_eq!(order.filled_qty(), Quantity::from(3));
2381 assert_eq!(order.avg_px(), Some(dec!(1.6666666666666666666666666667)));
2382 assert_ne!(
2383 order.avg_px(),
2384 Some(Decimal::from_f64_retain(5.0_f64 / 3.0).unwrap())
2385 );
2386 }
2387
2388 #[rstest]
2389 #[case(OrderSide::Buy, "1.07", "1.00", Some(dec!(0.07)))]
2390 #[case(OrderSide::Sell, "0.93", "1.00", Some(dec!(0.07)))]
2391 #[case(OrderSide::Buy, "0.93", "1.00", None)]
2392 #[case(OrderSide::Sell, "1.07", "1.00", None)]
2393 fn test_set_slippage_by_side(
2394 #[case] order_side: OrderSide,
2395 #[case] fill_px: &str,
2396 #[case] reference_px: &str,
2397 #[case] expected: Option<Decimal>,
2398 ) {
2399 let mut order =
2402 market_order_with_fills(order_side, Quantity::from(1), &[fill("T-1", "1", fill_px)]);
2403
2404 order.set_slippage(Price::from(reference_px));
2405
2406 assert_eq!(order.avg_px(), Some(Decimal::from_str(fill_px).unwrap()));
2407 assert_eq!(order.slippage(), expected);
2408 }
2409
2410 #[rstest]
2411 #[case::limit(OrderType::Limit)]
2412 #[case::limit_if_touched(OrderType::LimitIfTouched)]
2413 #[case::market_if_touched(OrderType::MarketIfTouched)]
2414 #[case::market_to_limit(OrderType::MarketToLimit)]
2415 #[case::stop_limit(OrderType::StopLimit)]
2416 #[case::stop_market(OrderType::StopMarket)]
2417 #[case::trailing_stop_limit(OrderType::TrailingStopLimit)]
2418 #[case::trailing_stop_market(OrderType::TrailingStopMarket)]
2419 fn test_fill_void_recomputes_slippage(#[case] order_type: OrderType) {
2420 let venue_order_id = VenueOrderId::from("V-SLIPPAGE");
2421 let account_id = AccountId::from("SIM-SLIPPAGE");
2422 let mut order = OrderTestBuilder::new(order_type)
2423 .instrument_id(InstrumentId::from("ETHUSDT-LINEAR.BYBIT"))
2424 .client_order_id(ClientOrderId::from("O-SLIPPAGE"))
2425 .side(OrderSide::Buy)
2426 .quantity(Quantity::from(10))
2427 .price(Price::from("100.00"))
2428 .trigger_price(Price::from("100.00"))
2429 .trigger_type(TriggerType::LastPrice)
2430 .limit_offset(dec!(1))
2431 .trailing_offset(dec!(1))
2432 .trailing_offset_type(TrailingOffsetType::Price)
2433 .build();
2434 let accepted = OrderAcceptedSpec::builder()
2435 .trader_id(order.trader_id())
2436 .strategy_id(order.strategy_id())
2437 .instrument_id(order.instrument_id())
2438 .client_order_id(order.client_order_id())
2439 .venue_order_id(venue_order_id)
2440 .account_id(account_id)
2441 .build();
2442 order.apply(OrderEventAny::Accepted(accepted)).unwrap();
2443
2444 if order_type == OrderType::MarketToLimit {
2445 order
2446 .apply(OrderEventAny::Updated(
2447 OrderUpdatedSpec::builder()
2448 .trader_id(order.trader_id())
2449 .strategy_id(order.strategy_id())
2450 .instrument_id(order.instrument_id())
2451 .client_order_id(order.client_order_id())
2452 .quantity(order.quantity())
2453 .venue_order_id(venue_order_id)
2454 .account_id(account_id)
2455 .price(Price::from("100.00"))
2456 .build(),
2457 ))
2458 .unwrap();
2459 }
2460
2461 let fill = |trade_id: &str, last_px: &str| {
2462 OrderFilledSpec::builder()
2463 .trader_id(order.trader_id())
2464 .strategy_id(order.strategy_id())
2465 .instrument_id(order.instrument_id())
2466 .client_order_id(order.client_order_id())
2467 .venue_order_id(venue_order_id)
2468 .account_id(account_id)
2469 .trade_id(TradeId::from(trade_id))
2470 .order_side(order.order_side())
2471 .order_type(order.order_type())
2472 .last_qty(Quantity::from(5))
2473 .last_px(Price::from(last_px))
2474 .build()
2475 };
2476 let unfavorable_fill = fill("T-SLIPPAGE-1", "110.00");
2477 let reference_fill = fill("T-SLIPPAGE-2", "100.00");
2478 order
2479 .apply(OrderEventAny::Filled(unfavorable_fill.clone()))
2480 .unwrap();
2481 order.apply(OrderEventAny::Filled(reference_fill)).unwrap();
2482 assert_eq!(order.avg_px(), Some(dec!(105)));
2483 assert_eq!(order.slippage(), Some(dec!(5)));
2484
2485 let correction = matching_fill_void(&unfavorable_fill, unfavorable_fill.last_qty, None);
2486 let event_count = order.event_count();
2487 order.apply(OrderEventAny::FillVoided(correction)).unwrap();
2488 let replayed =
2489 OrderAny::from_events(order.events().into_iter().cloned().collect()).unwrap();
2490
2491 assert_eq!(order.status(), OrderStatus::PartiallyFilled);
2492 assert_eq!(order.filled_qty(), Quantity::from(5));
2493 assert_eq!(order.voided_qty(), Quantity::from(5));
2494 assert_eq!(order.leaves_qty(), Quantity::from(5));
2495 assert_eq!(order.avg_px(), Some(dec!(100)));
2496 assert_eq!(order.slippage(), None);
2497 assert_eq!(order.event_count(), event_count + 1);
2498 assert_eq!(replayed.status(), order.status());
2499 assert_eq!(replayed.filled_qty(), order.filled_qty());
2500 assert_eq!(replayed.voided_qty(), order.voided_qty());
2501 assert_eq!(replayed.leaves_qty(), order.leaves_qty());
2502 assert_eq!(replayed.avg_px(), order.avg_px());
2503 assert_eq!(replayed.slippage(), order.slippage());
2504 }
2505
2506 #[rstest]
2507 fn test_avg_px_invariant_to_fill_arrival_order() {
2508 let mut fills = [
2512 fill("TRADE-1", "50000", "1.00001"),
2513 fill("TRADE-2", "30000", "1.00002"),
2514 fill("TRADE-3", "20000", "1.00003"),
2515 ];
2516
2517 let ascending = market_order_with_fills(OrderSide::Buy, Quantity::from(100_000), &fills);
2518 fills.reverse();
2519 let descending = market_order_with_fills(OrderSide::Buy, Quantity::from(100_000), &fills);
2520
2521 assert_eq!(ascending.avg_px(), Some(dec!(1.000_017)));
2522 assert_eq!(descending.avg_px(), ascending.avg_px());
2523 assert_eq!(descending.filled_qty(), ascending.filled_qty());
2524 }
2525
2526 #[rstest]
2527 fn test_avg_px_after_fill_void_matches_order_without_voided_fill() {
2528 let surviving = [fill("TRADE-1", "1", "0.05"), fill("TRADE-2", "3", "0.15")];
2529 let voided = fill("TRADE-VOIDED", "2", "0.13");
2530
2531 let expected = market_order_with_fills(OrderSide::Buy, Quantity::from(6), &surviving);
2532 let mut corrected = market_order_with_fills(
2533 OrderSide::Buy,
2534 Quantity::from(6),
2535 &[surviving[0], surviving[1], voided],
2536 );
2537 corrected
2538 .apply(OrderEventAny::FillVoided(
2539 OrderFillVoidedSpec::builder()
2540 .trade_id(voided.0)
2541 .voided_qty(voided.1)
2542 .last_px(voided.2)
2543 .build(),
2544 ))
2545 .unwrap();
2546
2547 let replayed =
2548 OrderAny::from_events(corrected.events().into_iter().cloned().collect()).unwrap();
2549
2550 assert_eq!(expected.avg_px(), Some(dec!(0.125)));
2554 assert_eq!(corrected.avg_px(), expected.avg_px());
2555 assert_eq!(replayed.avg_px(), expected.avg_px());
2556 assert_eq!(corrected.status(), OrderStatus::Voided);
2557 assert_eq!(corrected.filled_qty(), Quantity::from(4));
2558 assert_eq!(corrected.voided_qty(), Quantity::from(2));
2559 assert_eq!(corrected.leaves_qty(), Quantity::from(0));
2560 assert_eq!(replayed.filled_qty(), corrected.filled_qty());
2561 assert_eq!(replayed.voided_qty(), corrected.voided_qty());
2562 }
2563
2564 #[rstest]
2565 #[case::lower("1")]
2566 #[case::equal("1.000")]
2567 fn test_fractional_fill_correction_preserves_quantity_precision(#[case] quantity: &str) {
2568 let mut order = market_order_with_fills(
2569 OrderSide::Buy,
2570 Quantity::from(quantity),
2571 &[fill("TRADE-1", "0.750", "1.00")],
2572 );
2573 assert_eq!(order.status(), OrderStatus::PartiallyFilled);
2574 assert_eq!(order.filled_qty().as_decimal(), dec!(0.750));
2575 assert_eq!(order.leaves_qty().as_decimal(), dec!(0.250));
2576
2577 order
2578 .apply(OrderEventAny::FillVoided(
2579 OrderFillVoidedSpec::builder()
2580 .trade_id(TradeId::from("TRADE-1"))
2581 .voided_qty(Quantity::from("0.125"))
2582 .last_px(Price::from("1.00"))
2583 .build(),
2584 ))
2585 .unwrap();
2586
2587 assert_eq!(order.filled_qty().as_decimal(), dec!(0.625));
2588 assert_eq!(order.voided_qty().as_decimal(), dec!(0.125));
2589 assert_eq!(order.leaves_qty().as_decimal(), dec!(0.250));
2590 assert_eq!(order.overfill_qty().as_decimal(), dec!(0));
2591 }
2592
2593 #[rstest]
2594 #[case::lower("1")]
2595 #[case::equal("1.000")]
2596 fn test_fractional_overfill_preserves_quantity_precision(
2597 #[case] quantity: &str,
2598 #[values(false, true)] partial_fill_first: bool,
2599 ) {
2600 let fills = if partial_fill_first {
2601 vec![
2602 fill("TRADE-1", "0.750", "1.00"),
2603 fill("TRADE-2", "0.500", "1.00"),
2604 ]
2605 } else {
2606 vec![fill("TRADE-1", "1.250", "1.00")]
2607 };
2608 let order = market_order_with_fills(OrderSide::Buy, Quantity::from(quantity), &fills);
2609
2610 assert_eq!(order.status(), OrderStatus::Filled);
2611 assert_eq!(order.filled_qty().as_decimal(), dec!(1.250));
2612 assert_eq!(order.overfill_qty().as_decimal(), dec!(0.250));
2613 assert_eq!(order.leaves_qty().as_decimal(), dec!(0));
2614 }
2615
2616 #[rstest]
2617 fn test_avg_px_recomputed_from_partially_voided_fill() {
2618 let mut order = market_order_with_fills(
2619 OrderSide::Buy,
2620 Quantity::from(6),
2621 &[fill("TRADE-1", "4", "1.00"), fill("TRADE-2", "2", "1.14")],
2622 );
2623 order
2624 .apply(OrderEventAny::FillVoided(
2625 OrderFillVoidedSpec::builder()
2626 .trade_id(TradeId::from("TRADE-1"))
2627 .voided_qty(Quantity::from(2))
2628 .last_px(Price::from("1.00"))
2629 .build(),
2630 ))
2631 .unwrap();
2632
2633 assert_eq!(order.status(), OrderStatus::Voided);
2636 assert_eq!(order.filled_qty(), Quantity::from(4));
2637 assert_eq!(order.voided_qty(), Quantity::from(2));
2638 assert_eq!(order.leaves_qty(), Quantity::from(0));
2639 assert_eq!(order.avg_px(), Some(dec!(1.07)));
2640 }
2641
2642 #[rstest]
2643 fn test_avg_px_over_reopened_fill_void_and_replacement_fill() {
2644 let mut order = market_order_with_fills(
2645 OrderSide::Buy,
2646 Quantity::from(6),
2647 &[fill("TRADE-1", "4", "1.00")],
2648 );
2649 order
2650 .apply(OrderEventAny::FillVoided(
2651 OrderFillVoidedSpec::builder()
2652 .trade_id(TradeId::from("TRADE-1"))
2653 .voided_qty(Quantity::from(2))
2654 .last_px(Price::from("1.00"))
2655 .is_reopened(true)
2656 .build(),
2657 ))
2658 .unwrap();
2659 order
2660 .apply(OrderEventAny::Filled(
2661 OrderFilledSpec::builder()
2662 .trade_id(TradeId::from("TRADE-2"))
2663 .last_qty(Quantity::from(2))
2664 .last_px(Price::from("1.14"))
2665 .build(),
2666 ))
2667 .unwrap();
2668 order.set_slippage(Price::from("1.00"));
2669
2670 assert_eq!(order.status(), OrderStatus::PartiallyFilled);
2674 assert_eq!(order.filled_qty(), Quantity::from(4));
2675 assert_eq!(order.voided_qty(), Quantity::from(2));
2676 assert_eq!(order.leaves_qty(), Quantity::from(2));
2677 assert_eq!(order.avg_px(), Some(dec!(1.07)));
2678 assert_eq!(order.slippage(), Some(dec!(0.07)));
2679 }
2680
2681 #[rstest]
2682 fn test_avg_px_cleared_when_every_fill_is_voided() {
2683 let mut order = market_order_with_fills(
2684 OrderSide::Buy,
2685 Quantity::from(6),
2686 &[fill("TRADE-1", "4", "1.50")],
2687 );
2688 order
2689 .apply(OrderEventAny::FillVoided(
2690 OrderFillVoidedSpec::builder()
2691 .trade_id(TradeId::from("TRADE-1"))
2692 .voided_qty(Quantity::from(4))
2693 .last_px(Price::from("1.50"))
2694 .build(),
2695 ))
2696 .unwrap();
2697
2698 assert_eq!(order.status(), OrderStatus::Accepted);
2699 assert_eq!(order.filled_qty(), Quantity::from(0));
2700 assert_eq!(order.voided_qty(), Quantity::from(4));
2701 assert_eq!(order.leaves_qty(), Quantity::from(2));
2702 assert_eq!(order.avg_px(), None);
2703 }
2704
2705 #[cfg(feature = "high-precision")]
2706 #[rstest]
2707 fn test_avg_px_exact_over_high_precision_quantities() {
2708 let order = market_order_with_fills(
2711 OrderSide::Buy,
2712 Quantity::from("0.000000000010"),
2713 &[
2714 fill("TRADE-1", "0.000000000005", "1.00001"),
2715 fill("TRADE-2", "0.000000000003", "1.00002"),
2716 fill("TRADE-3", "0.000000000002", "1.00003"),
2717 ],
2718 );
2719
2720 assert_eq!(order.status(), OrderStatus::Filled);
2721 assert_eq!(order.filled_qty(), Quantity::from("0.000000000010"));
2722 assert_eq!(order.avg_px(), Some(dec!(1.000_017)));
2723 }
2724
2725 #[cfg(feature = "high-precision")]
2726 #[rstest]
2727 fn test_avg_px_exact_at_the_widest_representable_fill_scale() {
2728 let order = market_order_with_fills(
2731 OrderSide::Buy,
2732 Quantity::from("0.0000000000000008"),
2733 &[
2734 fill("TRADE-1", "0.0000000000000002", "0.000000000001"),
2735 fill("TRADE-2", "0.0000000000000006", "0.000000000003"),
2736 ],
2737 );
2738
2739 assert_eq!(order.status(), OrderStatus::Filled);
2741 assert_eq!(order.filled_qty(), Quantity::from("0.0000000000000008"));
2742 assert_eq!(order.avg_px(), Some(dec!(2.5e-12)));
2743 }
2744
2745 #[rstest]
2746 fn test_order_life_cycle_accumulates_fill_commissions() {
2747 let init = OrderInitializedSpec::builder()
2748 .quantity(Quantity::from(100_000))
2749 .build();
2750 let submitted = OrderSubmittedSpec::builder().build();
2751 let accepted = OrderAcceptedSpec::builder().build();
2752 let fill1 = OrderFilledSpec::builder()
2753 .last_qty(Quantity::from(50_000))
2754 .trade_id(TradeId::from("TRADE-1"))
2755 .commission(Money::from("1.25 USD"))
2756 .build();
2757 let fill2 = OrderFilledSpec::builder()
2758 .last_qty(Quantity::from(50_000))
2759 .trade_id(TradeId::from("TRADE-2"))
2760 .commission(Money::from("1.35 USD"))
2761 .build();
2762
2763 let mut order: MarketOrder = init.try_into().unwrap();
2764 order.apply(OrderEventAny::Submitted(submitted)).unwrap();
2765 order.apply(OrderEventAny::Accepted(accepted)).unwrap();
2766 order.apply(OrderEventAny::Filled(fill1)).unwrap();
2767 order.apply(OrderEventAny::Filled(fill2)).unwrap();
2768
2769 assert_eq!(order.status(), OrderStatus::Filled);
2770 assert_eq!(
2771 order.commission(&Currency::USD()),
2772 Some(Money::from("2.60 USD"))
2773 );
2774 assert_eq!(order.commissions_vec(), vec![Money::from("2.60 USD")]);
2775 }
2776
2777 #[rstest]
2778 fn test_fill_void_reopens_only_when_explicitly_marked() {
2779 let init = OrderInitializedSpec::builder()
2780 .quantity(Quantity::from(100_000))
2781 .build();
2782 let filled = OrderFilledSpec::builder()
2783 .trade_id(TradeId::from("TRADE-VOID"))
2784 .last_qty(Quantity::from(100_000))
2785 .commission(Money::from("1.00 USD"))
2786 .build();
2787 let fill_voided = OrderFillVoidedSpec::builder()
2788 .trade_id(filled.trade_id)
2789 .voided_qty(Quantity::from(40_000))
2790 .commission_voided(Money::from("0.40 USD"))
2791 .build();
2792 let later_fill = OrderFilledSpec::builder()
2793 .trade_id(TradeId::from("TRADE-AFTER-REOPEN"))
2794 .last_qty(Quantity::from(40_000))
2795 .build();
2796 let mut order: MarketOrder = init.try_into().unwrap();
2797 order
2798 .apply(OrderEventAny::Accepted(
2799 OrderAcceptedSpec::builder().build(),
2800 ))
2801 .unwrap();
2802 order.apply(OrderEventAny::Filled(filled)).unwrap();
2803
2804 let mut terminal = order.clone();
2805 terminal
2806 .apply(OrderEventAny::FillVoided(fill_voided.clone()))
2807 .unwrap();
2808 let fill_while_terminal = terminal.apply(OrderEventAny::Filled(later_fill.clone()));
2809
2810 order
2811 .apply(OrderEventAny::FillVoided(OrderFillVoided {
2812 is_reopened: true,
2813 ..fill_voided
2814 }))
2815 .unwrap();
2816 let status_after_correction = order.status();
2817 order.apply(OrderEventAny::Filled(later_fill)).unwrap();
2818
2819 assert!(matches!(
2820 fill_while_terminal,
2821 Err(OrderError::InvalidStateTransition)
2822 ));
2823 assert_eq!(terminal.status(), OrderStatus::Voided);
2824 assert_eq!(status_after_correction, OrderStatus::PartiallyFilled);
2825 assert_eq!(order.status(), OrderStatus::Filled);
2826 assert_eq!(order.filled_qty(), Quantity::from(100_000));
2827 assert_eq!(order.voided_qty(), Quantity::from(40_000));
2828 assert_eq!(order.leaves_qty(), Quantity::from(0));
2829 assert_eq!(
2830 order.commission(&Currency::USD()),
2831 Some(Money::from("0.60 USD"))
2832 );
2833 }
2834
2835 #[rstest]
2836 fn test_fill_void_preserves_existing_working_remainder() {
2837 let init = OrderInitializedSpec::builder()
2838 .quantity(Quantity::from(100_000))
2839 .build();
2840 let filled = OrderFilledSpec::builder()
2841 .trade_id(TradeId::from("TRADE-VOID"))
2842 .last_qty(Quantity::from(40_000))
2843 .build();
2844 let later_fill = OrderFilledSpec::builder()
2845 .trade_id(TradeId::from("TRADE-REMAINDER"))
2846 .last_qty(Quantity::from(60_000))
2847 .build();
2848 let mut order: MarketOrder = init.try_into().unwrap();
2849 order
2850 .apply(OrderEventAny::Accepted(
2851 OrderAcceptedSpec::builder().build(),
2852 ))
2853 .unwrap();
2854 order.apply(OrderEventAny::Filled(filled.clone())).unwrap();
2855
2856 order
2857 .apply(OrderEventAny::FillVoided(
2858 OrderFillVoidedSpec::builder()
2859 .trade_id(filled.trade_id)
2860 .voided_qty(filled.last_qty)
2861 .build(),
2862 ))
2863 .unwrap();
2864
2865 assert_eq!(order.status(), OrderStatus::Accepted);
2866 assert_eq!(order.filled_qty(), Quantity::from(0));
2867 assert_eq!(order.voided_qty(), Quantity::from(40_000));
2868 assert_eq!(order.leaves_qty(), Quantity::from(60_000));
2869 assert!(order.is_open());
2870
2871 order.apply(OrderEventAny::Filled(later_fill)).unwrap();
2872
2873 assert_eq!(order.status(), OrderStatus::Voided);
2874 assert_eq!(order.filled_qty(), Quantity::from(60_000));
2875 assert_eq!(order.voided_qty(), Quantity::from(40_000));
2876 assert_eq!(order.leaves_qty(), Quantity::from(0));
2877 assert!(order.is_closed());
2878 }
2879
2880 #[rstest]
2881 fn test_order_updated_after_non_reopened_fill_void_keeps_void_out_of_leaves(
2882 #[values(
2883 OrderType::Market,
2884 OrderType::Limit,
2885 OrderType::LimitIfTouched,
2886 OrderType::MarketIfTouched,
2887 OrderType::MarketToLimit,
2888 OrderType::StopLimit,
2889 OrderType::StopMarket,
2890 OrderType::TrailingStopLimit,
2891 OrderType::TrailingStopMarket
2892 )]
2893 order_type: OrderType,
2894 #[values(8, 10, 12)] updated_qty: u64,
2895 ) {
2896 let venue_order_id = VenueOrderId::from("V-VOID-UPDATE");
2897 let account_id = AccountId::from("SIM-VOID-UPDATE");
2898 let mut order = OrderTestBuilder::new(order_type)
2899 .instrument_id(InstrumentId::from("ETHUSDT-LINEAR.BYBIT"))
2900 .client_order_id(ClientOrderId::from("O-VOID-UPDATE"))
2901 .side(OrderSide::Buy)
2902 .quantity(Quantity::from(10))
2903 .price(Price::from("100.00"))
2904 .trigger_price(Price::from("100.00"))
2905 .trigger_type(TriggerType::LastPrice)
2906 .limit_offset(dec!(1))
2907 .trailing_offset(dec!(1))
2908 .trailing_offset_type(TrailingOffsetType::Price)
2909 .build();
2910 order
2911 .apply(OrderEventAny::Accepted(
2912 OrderAcceptedSpec::builder()
2913 .trader_id(order.trader_id())
2914 .strategy_id(order.strategy_id())
2915 .instrument_id(order.instrument_id())
2916 .client_order_id(order.client_order_id())
2917 .venue_order_id(venue_order_id)
2918 .account_id(account_id)
2919 .build(),
2920 ))
2921 .unwrap();
2922 let fill = |trade_id: &str, last_qty: u64| {
2923 OrderFilledSpec::builder()
2924 .trader_id(order.trader_id())
2925 .strategy_id(order.strategy_id())
2926 .instrument_id(order.instrument_id())
2927 .client_order_id(order.client_order_id())
2928 .venue_order_id(venue_order_id)
2929 .account_id(account_id)
2930 .trade_id(TradeId::from(trade_id))
2931 .order_side(order.order_side())
2932 .order_type(order.order_type())
2933 .last_qty(Quantity::from(last_qty))
2934 .last_px(Price::from("100.00"))
2935 .build()
2936 };
2937 let expected_leaves = updated_qty - 4;
2939 let first_fill = fill("T-VOID-UPDATE-1", 4);
2940 let remainder_fill = fill("T-VOID-UPDATE-2", expected_leaves);
2941 order
2942 .apply(OrderEventAny::Filled(first_fill.clone()))
2943 .unwrap();
2944 order
2945 .apply(OrderEventAny::FillVoided(OrderFillVoided {
2946 is_reopened: false,
2947 ..matching_fill_void(&first_fill, Quantity::from(1), None)
2948 }))
2949 .unwrap();
2950 assert_eq!(order.status(), OrderStatus::PartiallyFilled);
2951 assert_eq!(order.filled_qty(), Quantity::from(3));
2952 assert_eq!(order.leaves_qty(), Quantity::from(6));
2953
2954 order
2955 .apply(OrderEventAny::Updated(
2956 OrderUpdatedSpec::builder()
2957 .trader_id(order.trader_id())
2958 .strategy_id(order.strategy_id())
2959 .instrument_id(order.instrument_id())
2960 .client_order_id(order.client_order_id())
2961 .quantity(Quantity::from(updated_qty))
2962 .venue_order_id(venue_order_id)
2963 .account_id(account_id)
2964 .build(),
2965 ))
2966 .unwrap();
2967
2968 assert_eq!(order.leaves_qty(), Quantity::from(expected_leaves));
2969
2970 order.apply(OrderEventAny::Filled(remainder_fill)).unwrap();
2971
2972 assert_eq!(order.status(), OrderStatus::Voided);
2973 assert_eq!(order.leaves_qty(), Quantity::from(0));
2974 assert!(order.is_closed());
2975 }
2976
2977 fn accepted_order_with_first_fill() -> (OrderAny, VenueOrderId, AccountId, OrderFilled) {
2980 let venue_order_id = VenueOrderId::from("V-VOID-UPDATE");
2981 let account_id = AccountId::from("SIM-VOID-UPDATE");
2982 let mut order = OrderTestBuilder::new(OrderType::Limit)
2983 .instrument_id(InstrumentId::from("ETHUSDT-LINEAR.BYBIT"))
2984 .client_order_id(ClientOrderId::from("O-VOID-UPDATE"))
2985 .side(OrderSide::Buy)
2986 .quantity(Quantity::from(10))
2987 .price(Price::from("100.00"))
2988 .build();
2989 order
2990 .apply(OrderEventAny::Accepted(
2991 OrderAcceptedSpec::builder()
2992 .trader_id(order.trader_id())
2993 .strategy_id(order.strategy_id())
2994 .instrument_id(order.instrument_id())
2995 .client_order_id(order.client_order_id())
2996 .venue_order_id(venue_order_id)
2997 .account_id(account_id)
2998 .build(),
2999 ))
3000 .unwrap();
3001 let first_fill = OrderFilledSpec::builder()
3002 .trader_id(order.trader_id())
3003 .strategy_id(order.strategy_id())
3004 .instrument_id(order.instrument_id())
3005 .client_order_id(order.client_order_id())
3006 .venue_order_id(venue_order_id)
3007 .account_id(account_id)
3008 .trade_id(TradeId::from("T-VOID-UPDATE-1"))
3009 .order_side(order.order_side())
3010 .order_type(order.order_type())
3011 .last_qty(Quantity::from(4))
3012 .last_px(Price::from("100.00"))
3013 .build();
3014 order
3015 .apply(OrderEventAny::Filled(first_fill.clone()))
3016 .unwrap();
3017 (order, venue_order_id, account_id, first_fill)
3018 }
3019
3020 #[rstest]
3021 fn test_order_updated_after_reopened_fill_void_keeps_void_in_leaves() {
3022 let (mut order, venue_order_id, account_id, first_fill) = accepted_order_with_first_fill();
3023
3024 order
3025 .apply(OrderEventAny::FillVoided(OrderFillVoided {
3026 is_reopened: true,
3027 ..matching_fill_void(&first_fill, Quantity::from(1), None)
3028 }))
3029 .unwrap();
3030 assert_eq!(order.filled_qty(), Quantity::from(3));
3031 assert_eq!(order.non_reopened_voided_qty(), Quantity::from(0));
3032 assert_eq!(order.leaves_qty(), Quantity::from(7));
3034
3035 order
3036 .apply(OrderEventAny::Updated(
3037 OrderUpdatedSpec::builder()
3038 .trader_id(order.trader_id())
3039 .strategy_id(order.strategy_id())
3040 .instrument_id(order.instrument_id())
3041 .client_order_id(order.client_order_id())
3042 .quantity(Quantity::from(12))
3043 .venue_order_id(venue_order_id)
3044 .account_id(account_id)
3045 .build(),
3046 ))
3047 .unwrap();
3048
3049 assert_eq!(order.non_reopened_voided_qty(), Quantity::from(0));
3050 assert_eq!(order.leaves_qty(), Quantity::from(9));
3051 }
3052
3053 #[rstest]
3054 fn test_order_updated_uses_latest_superseding_correction() {
3055 let (mut order, venue_order_id, account_id, first_fill) = accepted_order_with_first_fill();
3056
3057 order
3058 .apply(OrderEventAny::FillVoided(OrderFillVoided {
3059 is_reopened: false,
3060 ..matching_fill_void(&first_fill, Quantity::from(1), None)
3061 }))
3062 .unwrap();
3063 assert_eq!(order.non_reopened_voided_qty(), Quantity::from(1));
3064
3065 order
3068 .apply(OrderEventAny::FillVoided(OrderFillVoided {
3069 is_reopened: false,
3070 ..matching_fill_void(&first_fill, Quantity::from(3), None)
3071 }))
3072 .unwrap();
3073 assert_eq!(order.filled_qty(), Quantity::from(1));
3074 assert_eq!(order.non_reopened_voided_qty(), Quantity::from(3));
3075
3076 order
3077 .apply(OrderEventAny::Updated(
3078 OrderUpdatedSpec::builder()
3079 .trader_id(order.trader_id())
3080 .strategy_id(order.strategy_id())
3081 .instrument_id(order.instrument_id())
3082 .client_order_id(order.client_order_id())
3083 .quantity(Quantity::from(12))
3084 .venue_order_id(venue_order_id)
3085 .account_id(account_id)
3086 .build(),
3087 ))
3088 .unwrap();
3089
3090 assert_eq!(order.leaves_qty(), Quantity::from(8));
3092 }
3093
3094 #[rstest]
3095 fn test_order_updated_to_zero_leaves_sets_no_new_terminal_transition() {
3096 let (mut order, venue_order_id, account_id, first_fill) = accepted_order_with_first_fill();
3097
3098 order
3099 .apply(OrderEventAny::FillVoided(OrderFillVoided {
3100 is_reopened: false,
3101 ..matching_fill_void(&first_fill, Quantity::from(1), None)
3102 }))
3103 .unwrap();
3104 assert_eq!(order.status(), OrderStatus::PartiallyFilled);
3105 assert_eq!(order.filled_qty(), Quantity::from(3));
3106 assert_eq!(order.non_reopened_voided_qty(), Quantity::from(1));
3107
3108 order
3111 .apply(OrderEventAny::Updated(
3112 OrderUpdatedSpec::builder()
3113 .trader_id(order.trader_id())
3114 .strategy_id(order.strategy_id())
3115 .instrument_id(order.instrument_id())
3116 .client_order_id(order.client_order_id())
3117 .quantity(Quantity::from(4))
3118 .venue_order_id(venue_order_id)
3119 .account_id(account_id)
3120 .reconciliation(false)
3121 .build(),
3122 ))
3123 .unwrap();
3124
3125 assert_eq!(order.leaves_qty(), Quantity::from(0));
3126 assert_eq!(order.status(), OrderStatus::PartiallyFilled);
3127 assert!(order.ts_closed().is_none());
3128 assert!(!order.is_closed());
3129
3130 order
3132 .apply(OrderEventAny::Canceled(
3133 OrderCanceledSpec::builder()
3134 .trader_id(order.trader_id())
3135 .strategy_id(order.strategy_id())
3136 .instrument_id(order.instrument_id())
3137 .client_order_id(order.client_order_id())
3138 .venue_order_id(venue_order_id)
3139 .account_id(account_id)
3140 .build(),
3141 ))
3142 .unwrap();
3143 assert_eq!(order.status(), OrderStatus::Canceled);
3144 }
3145
3146 #[rstest]
3147 fn test_reconciliation_to_filled_exception_fires_with_non_reopened_void_present() {
3148 let (mut order, venue_order_id, account_id, first_fill) = accepted_order_with_first_fill();
3149
3150 order
3151 .apply(OrderEventAny::FillVoided(OrderFillVoided {
3152 is_reopened: false,
3153 ..matching_fill_void(&first_fill, Quantity::from(1), None)
3154 }))
3155 .unwrap();
3156 assert_eq!(order.filled_qty(), Quantity::from(3));
3157
3158 order
3161 .apply(OrderEventAny::Updated(
3162 OrderUpdatedSpec::builder()
3163 .trader_id(order.trader_id())
3164 .strategy_id(order.strategy_id())
3165 .instrument_id(order.instrument_id())
3166 .client_order_id(order.client_order_id())
3167 .quantity(Quantity::from(3))
3168 .venue_order_id(venue_order_id)
3169 .account_id(account_id)
3170 .reconciliation(true)
3171 .build(),
3172 ))
3173 .unwrap();
3174
3175 assert_eq!(order.status(), OrderStatus::Filled);
3176 assert!(order.ts_closed().is_some());
3177 assert_eq!(order.leaves_qty(), Quantity::from(0));
3178 }
3179
3180 #[rstest]
3181 fn test_order_updated_restores_pending_status_with_non_reopened_void_present() {
3182 let (mut order, venue_order_id, account_id, first_fill) = accepted_order_with_first_fill();
3183
3184 order
3185 .apply(OrderEventAny::FillVoided(OrderFillVoided {
3186 is_reopened: false,
3187 ..matching_fill_void(&first_fill, Quantity::from(1), None)
3188 }))
3189 .unwrap();
3190 assert_eq!(order.status(), OrderStatus::PartiallyFilled);
3191
3192 order
3193 .apply(OrderEventAny::PendingUpdate(
3194 OrderPendingUpdateSpec::builder()
3195 .trader_id(order.trader_id())
3196 .strategy_id(order.strategy_id())
3197 .instrument_id(order.instrument_id())
3198 .client_order_id(order.client_order_id())
3199 .account_id(account_id)
3200 .build(),
3201 ))
3202 .unwrap();
3203 assert_eq!(order.status(), OrderStatus::PendingUpdate);
3204
3205 order
3206 .apply(OrderEventAny::Updated(
3207 OrderUpdatedSpec::builder()
3208 .trader_id(order.trader_id())
3209 .strategy_id(order.strategy_id())
3210 .instrument_id(order.instrument_id())
3211 .client_order_id(order.client_order_id())
3212 .quantity(Quantity::from(12))
3213 .venue_order_id(venue_order_id)
3214 .account_id(account_id)
3215 .build(),
3216 ))
3217 .unwrap();
3218
3219 assert_eq!(order.status(), OrderStatus::PartiallyFilled);
3221 assert_eq!(order.leaves_qty(), Quantity::from(8));
3222 }
3223
3224 #[rstest]
3225 fn test_order_updated_after_fill_void_replays_to_same_state() {
3226 let (mut order, venue_order_id, account_id, first_fill) = accepted_order_with_first_fill();
3227
3228 order
3229 .apply(OrderEventAny::FillVoided(OrderFillVoided {
3230 is_reopened: false,
3231 ..matching_fill_void(&first_fill, Quantity::from(1), None)
3232 }))
3233 .unwrap();
3234 order
3235 .apply(OrderEventAny::Updated(
3236 OrderUpdatedSpec::builder()
3237 .trader_id(order.trader_id())
3238 .strategy_id(order.strategy_id())
3239 .instrument_id(order.instrument_id())
3240 .client_order_id(order.client_order_id())
3241 .quantity(Quantity::from(12))
3242 .venue_order_id(venue_order_id)
3243 .account_id(account_id)
3244 .build(),
3245 ))
3246 .unwrap();
3247
3248 let replayed =
3249 OrderAny::from_events(order.events().into_iter().cloned().collect()).unwrap();
3250
3251 assert_eq!(replayed.status(), order.status());
3252 assert_eq!(replayed.filled_qty(), order.filled_qty());
3253 assert_eq!(
3254 replayed.non_reopened_voided_qty(),
3255 order.non_reopened_voided_qty()
3256 );
3257 assert_eq!(replayed.leaves_qty(), order.leaves_qty());
3258 assert_eq!(replayed.leaves_qty(), Quantity::from(8));
3259 }
3260
3261 #[rstest]
3262 fn test_canceled_order_with_voided_qty_becomes_voided_when_late_fill_exhausts_leaves() {
3263 let initial_trade_id = TradeId::from("TRADE-VOID");
3264 let late_trade_id = TradeId::from("TRADE-LATE");
3265 let init = OrderInitializedSpec::builder()
3266 .quantity(Quantity::from(100_000))
3267 .build();
3268 let accepted = OrderAcceptedSpec::builder()
3269 .ts_event(UnixNanos::from(1_000))
3270 .build();
3271 let filled = OrderFilledSpec::builder()
3272 .trade_id(initial_trade_id)
3273 .last_qty(Quantity::from(60_000))
3274 .ts_event(UnixNanos::from(2_000))
3275 .build();
3276 let fill_voided = OrderFillVoidedSpec::builder()
3277 .trade_id(initial_trade_id)
3278 .voided_qty(Quantity::from(20_000))
3279 .ts_event(UnixNanos::from(3_000))
3280 .is_reopened(false)
3281 .build();
3282 let canceled = OrderCanceledSpec::builder()
3283 .ts_event(UnixNanos::from(4_000))
3284 .build();
3285 let late_fill = OrderFilledSpec::builder()
3286 .trade_id(late_trade_id)
3287 .last_qty(Quantity::from(40_000))
3288 .ts_event(UnixNanos::from(5_000))
3289 .build();
3290 let mut order: MarketOrder = init.try_into().unwrap();
3291
3292 order.apply(OrderEventAny::Accepted(accepted)).unwrap();
3293 order.apply(OrderEventAny::Filled(filled)).unwrap();
3294 order.apply(OrderEventAny::FillVoided(fill_voided)).unwrap();
3295 order.apply(OrderEventAny::Canceled(canceled)).unwrap();
3296
3297 assert_eq!(order.status(), OrderStatus::Canceled);
3298 assert_eq!(order.filled_qty(), Quantity::from(40_000));
3299 assert_eq!(order.voided_qty(), Quantity::from(20_000));
3300 assert_eq!(order.leaves_qty(), Quantity::from(40_000));
3301 assert_eq!(order.ts_closed(), Some(UnixNanos::from(4_000)));
3302 assert_eq!(order.last_trade_id(), Some(initial_trade_id));
3303 assert!(order.is_closed());
3304 assert!(!order.is_open());
3305
3306 order.apply(OrderEventAny::Filled(late_fill)).unwrap();
3307
3308 assert_eq!(order.status(), OrderStatus::Voided);
3309 assert_eq!(order.filled_qty(), Quantity::from(80_000));
3310 assert_eq!(order.voided_qty(), Quantity::from(20_000));
3311 assert_eq!(order.leaves_qty(), Quantity::from(0));
3312 assert_eq!(order.overfill_qty(), Quantity::from(0));
3313 assert_eq!(order.ts_closed(), Some(UnixNanos::from(5_000)));
3314 assert_eq!(order.last_trade_id(), Some(late_trade_id));
3315 assert_eq!(order.trade_ids(), vec![&initial_trade_id, &late_trade_id]);
3316 assert!(order.is_closed());
3317 assert!(!order.is_open());
3318 }
3319
3320 #[rstest]
3321 fn test_reopened_fill_void_requires_existing_fill() {
3322 let trade_id = TradeId::from("TRADE-OUT-OF-ORDER");
3323 let init = OrderInitializedSpec::builder()
3324 .quantity(Quantity::from(100_000))
3325 .build();
3326 let early_void = OrderFillVoidedSpec::builder()
3327 .trade_id(trade_id)
3328 .voided_qty(Quantity::from(10_000))
3329 .is_reopened(true)
3330 .build();
3331 let late_fill = OrderFilledSpec::builder()
3332 .trade_id(trade_id)
3333 .last_qty(Quantity::from(40_000))
3334 .build();
3335 let mut order: MarketOrder = init.try_into().unwrap();
3336 order
3337 .apply(OrderEventAny::Accepted(
3338 OrderAcceptedSpec::builder().build(),
3339 ))
3340 .unwrap();
3341
3342 let result = order.apply(OrderEventAny::FillVoided(early_void));
3343 order.apply(OrderEventAny::Filled(late_fill)).unwrap();
3344
3345 assert!(matches!(result, Err(OrderError::InvalidOrderEvent)));
3346 assert_eq!(order.status(), OrderStatus::PartiallyFilled);
3347 assert_eq!(order.filled_qty(), Quantity::from(40_000));
3348 assert_eq!(order.voided_qty(), Quantity::from(0));
3349 assert_eq!(order.leaves_qty(), Quantity::from(60_000));
3350 }
3351
3352 #[rstest]
3353 #[case(OrderStatus::Accepted)]
3354 #[case(OrderStatus::Canceled)]
3355 #[case(OrderStatus::Expired)]
3356 fn test_terminal_fill_void_rejects_later_order_events(#[case] status_before_void: OrderStatus) {
3357 let trade_id = TradeId::from("TRADE-TERMINAL-VOID");
3358 let init = OrderInitializedSpec::builder()
3359 .quantity(Quantity::from(100_000))
3360 .build();
3361 let terminal_void = OrderFillVoidedSpec::builder()
3362 .trade_id(trade_id)
3363 .voided_qty(Quantity::from(40_000))
3364 .commission_voided(Money::from("0 USD"))
3365 .build();
3366 let late_fill = OrderFilledSpec::builder()
3367 .trade_id(trade_id)
3368 .last_qty(Quantity::from(40_000))
3369 .build();
3370 let mut order: MarketOrder = init.try_into().unwrap();
3371 order
3372 .apply(OrderEventAny::Accepted(
3373 OrderAcceptedSpec::builder().build(),
3374 ))
3375 .unwrap();
3376
3377 match status_before_void {
3378 OrderStatus::Accepted => {}
3379 OrderStatus::Canceled => order
3380 .apply(OrderEventAny::Canceled(
3381 OrderCanceledSpec::builder().build(),
3382 ))
3383 .unwrap(),
3384 OrderStatus::Expired => order
3385 .apply(OrderEventAny::Expired(OrderExpiredSpec::builder().build()))
3386 .unwrap(),
3387 _ => unreachable!(),
3388 }
3389
3390 order
3391 .apply(OrderEventAny::FillVoided(terminal_void))
3392 .unwrap();
3393 let update_result = order.apply(OrderEventAny::Updated(
3394 OrderUpdatedSpec::builder()
3395 .quantity(Quantity::from(120_000))
3396 .build(),
3397 ));
3398 let cancel_result = order.apply(OrderEventAny::Canceled(
3399 OrderCanceledSpec::builder().build(),
3400 ));
3401 let fill_result = order.apply(OrderEventAny::Filled(late_fill));
3402
3403 assert!(matches!(
3404 update_result,
3405 Err(OrderError::InvalidStateTransition)
3406 ));
3407 assert!(matches!(
3408 cancel_result,
3409 Err(OrderError::InvalidStateTransition)
3410 ));
3411 assert!(matches!(
3412 fill_result,
3413 Err(OrderError::InvalidStateTransition)
3414 ));
3415 assert_eq!(order.status(), OrderStatus::Voided);
3416 assert_eq!(order.filled_qty(), Quantity::from(0));
3417 assert_eq!(order.voided_qty(), Quantity::from(40_000));
3418 assert_eq!(order.leaves_qty(), Quantity::from(0));
3419 }
3420
3421 #[rstest]
3422 #[case(Quantity::from(100_001), None)]
3423 #[case(Quantity::from(100_000), Some(Money::from("1 USD")))]
3424 fn test_terminal_fill_void_rejects_invalid_economic_values(
3425 #[case] voided_qty: Quantity,
3426 #[case] commission_voided: Option<Money>,
3427 ) {
3428 let trade_id = TradeId::from("TRADE-TERMINAL-VOID");
3429 let init = OrderInitializedSpec::builder()
3430 .quantity(Quantity::from(100_000))
3431 .build();
3432 let mut order: MarketOrder = init.try_into().unwrap();
3433 order
3434 .apply(OrderEventAny::Accepted(
3435 OrderAcceptedSpec::builder().build(),
3436 ))
3437 .unwrap();
3438 let mut invalid = OrderFillVoidedSpec::builder()
3439 .trade_id(trade_id)
3440 .voided_qty(voided_qty)
3441 .build();
3442 invalid.commission_voided = commission_voided;
3443
3444 let result = order.apply(OrderEventAny::FillVoided(invalid));
3445
3446 assert!(matches!(
3447 result,
3448 Err(OrderError::OverVoid(error_trade_id)) if error_trade_id == trade_id
3449 ));
3450 assert_eq!(order.status(), OrderStatus::Accepted);
3451 assert_eq!(order.voided_qty(), Quantity::from(0));
3452 }
3453
3454 #[rstest]
3455 fn test_terminal_fill_void_accepts_current_venue_order_id_after_fill_before_accept() {
3456 let init = OrderInitializedSpec::builder()
3457 .quantity(Quantity::from(100_000))
3458 .build();
3459 let submitted = OrderSubmittedSpec::builder().build();
3460 let filled = OrderFilledSpec::builder()
3461 .account_id(submitted.account_id)
3462 .trade_id(TradeId::from("TRADE-APPLIED"))
3463 .last_qty(Quantity::from(40_000))
3464 .build();
3465 let terminal_void = OrderFillVoidedSpec::builder()
3466 .venue_order_id(filled.venue_order_id)
3467 .account_id(filled.account_id)
3468 .trade_id(TradeId::from("TRADE-TERMINAL-VOID"))
3469 .voided_qty(Quantity::from(10_000))
3470 .build();
3471 let mut order: MarketOrder = init.try_into().unwrap();
3472 order.apply(OrderEventAny::Submitted(submitted)).unwrap();
3473 order.apply(OrderEventAny::Filled(filled)).unwrap();
3474
3475 order
3476 .apply(OrderEventAny::FillVoided(terminal_void))
3477 .unwrap();
3478
3479 assert_eq!(order.status(), OrderStatus::Voided);
3480 assert_eq!(order.filled_qty(), Quantity::from(40_000));
3481 assert_eq!(order.voided_qty(), Quantity::from(10_000));
3482 assert_eq!(order.leaves_qty(), Quantity::from(0));
3483 }
3484
3485 #[rstest]
3486 fn test_terminal_fill_void_requires_matching_order_identity() {
3487 let init = OrderInitializedSpec::builder()
3488 .quantity(Quantity::from(100_000))
3489 .build();
3490 let mut order: MarketOrder = init.try_into().unwrap();
3491 order
3492 .apply(OrderEventAny::Accepted(
3493 OrderAcceptedSpec::builder().build(),
3494 ))
3495 .unwrap();
3496 let mismatched = OrderFillVoidedSpec::builder()
3497 .instrument_id(InstrumentId::from("OTHER.SIM"))
3498 .trade_id(TradeId::from("TRADE-TERMINAL-VOID"))
3499 .voided_qty(Quantity::from(100_000))
3500 .build();
3501
3502 let result = order.apply(OrderEventAny::FillVoided(mismatched));
3503
3504 assert!(matches!(result, Err(OrderError::InvalidOrderEvent)));
3505 assert_eq!(order.status(), OrderStatus::Accepted);
3506 assert_eq!(order.voided_qty(), Quantity::from(0));
3507 }
3508
3509 #[rstest]
3510 #[case(OrderStatus::Canceled)]
3511 #[case(OrderStatus::Expired)]
3512 fn test_fill_void_does_not_reopen_canceled_or_expired_order(
3513 #[case] terminal_status: OrderStatus,
3514 ) {
3515 let init = OrderInitializedSpec::builder()
3516 .quantity(Quantity::from(100_000))
3517 .build();
3518 let filled = OrderFilledSpec::builder()
3519 .trade_id(TradeId::from("TRADE-TERMINAL-VOID"))
3520 .last_qty(Quantity::from(60_000))
3521 .build();
3522 let mut order: MarketOrder = init.try_into().unwrap();
3523 order
3524 .apply(OrderEventAny::Accepted(
3525 OrderAcceptedSpec::builder().build(),
3526 ))
3527 .unwrap();
3528 order.apply(OrderEventAny::Filled(filled.clone())).unwrap();
3529 match terminal_status {
3530 OrderStatus::Canceled => order
3531 .apply(OrderEventAny::Canceled(
3532 OrderCanceledSpec::builder().build(),
3533 ))
3534 .unwrap(),
3535 OrderStatus::Expired => order
3536 .apply(OrderEventAny::Expired(OrderExpiredSpec::builder().build()))
3537 .unwrap(),
3538 _ => unreachable!(),
3539 }
3540 let voided = OrderFillVoidedSpec::builder()
3541 .trade_id(filled.trade_id)
3542 .voided_qty(Quantity::from(20_000))
3543 .is_reopened(true)
3544 .build();
3545
3546 order.apply(OrderEventAny::FillVoided(voided)).unwrap();
3547
3548 assert_eq!(order.status(), terminal_status);
3549 assert_eq!(order.filled_qty(), Quantity::from(40_000));
3550 assert_eq!(order.voided_qty(), Quantity::from(20_000));
3551 assert!(order.is_closed());
3552 assert!(order.ts_closed().is_some());
3553 }
3554
3555 #[rstest]
3556 fn test_fill_void_rejects_duplicate_stale_and_over_void() {
3557 let init = OrderInitializedSpec::builder()
3558 .quantity(Quantity::from(100_000))
3559 .build();
3560 let filled = OrderFilledSpec::builder()
3561 .trade_id(TradeId::from("TRADE-VOID"))
3562 .last_qty(Quantity::from(100_000))
3563 .build();
3564 let mut order: MarketOrder = init.try_into().unwrap();
3565 order
3566 .apply(OrderEventAny::Accepted(
3567 OrderAcceptedSpec::builder().build(),
3568 ))
3569 .unwrap();
3570 order.apply(OrderEventAny::Filled(filled)).unwrap();
3571 order
3572 .apply(OrderEventAny::FillVoided(
3573 OrderFillVoidedSpec::builder()
3574 .trade_id(TradeId::from("TRADE-VOID"))
3575 .voided_qty(Quantity::from(40_000))
3576 .build(),
3577 ))
3578 .unwrap();
3579
3580 let duplicate = order.apply(OrderEventAny::FillVoided(
3581 OrderFillVoidedSpec::builder()
3582 .trade_id(TradeId::from("TRADE-VOID"))
3583 .voided_qty(Quantity::from(40_000))
3584 .build(),
3585 ));
3586 let stale = order.apply(OrderEventAny::FillVoided(
3587 OrderFillVoidedSpec::builder()
3588 .trade_id(TradeId::from("TRADE-VOID"))
3589 .voided_qty(Quantity::from(30_000))
3590 .build(),
3591 ));
3592 let over_void = order.apply(OrderEventAny::FillVoided(
3593 OrderFillVoidedSpec::builder()
3594 .trade_id(TradeId::from("TRADE-VOID"))
3595 .voided_qty(Quantity::from(100_001))
3596 .build(),
3597 ));
3598 assert!(matches!(
3599 duplicate,
3600 Err(OrderError::DuplicateFillVoid(trade_id))
3601 if trade_id == TradeId::from("TRADE-VOID")
3602 ));
3603 assert!(matches!(
3604 stale,
3605 Err(OrderError::StaleFillVoid(trade_id))
3606 if trade_id == TradeId::from("TRADE-VOID")
3607 ));
3608 assert!(matches!(
3609 over_void,
3610 Err(OrderError::OverVoid(trade_id))
3611 if trade_id == TradeId::from("TRADE-VOID")
3612 ));
3613 assert_eq!(order.filled_qty(), Quantity::from(60_000));
3614 assert_eq!(order.voided_qty(), Quantity::from(40_000));
3615 }
3616
3617 enum FillVoidIdentityField {
3618 VenueOrderId,
3619 AccountId,
3620 OrderSide,
3621 OrderType,
3622 LastPx,
3623 Currency,
3624 LiquiditySide,
3625 PositionId,
3626 }
3627
3628 #[rstest]
3629 #[case::venue_order_id(FillVoidIdentityField::VenueOrderId)]
3630 #[case::account_id(FillVoidIdentityField::AccountId)]
3631 #[case::order_side(FillVoidIdentityField::OrderSide)]
3632 #[case::order_type(FillVoidIdentityField::OrderType)]
3633 #[case::last_px(FillVoidIdentityField::LastPx)]
3634 #[case::currency(FillVoidIdentityField::Currency)]
3635 #[case::liquidity_side(FillVoidIdentityField::LiquiditySide)]
3636 #[case::position_id(FillVoidIdentityField::PositionId)]
3637 fn test_fill_void_rejects_known_fill_identity_mismatch(#[case] field: FillVoidIdentityField) {
3638 let (mut order, fill) = filled_market_order_for_void();
3639 let events_before: Vec<_> = order.events().into_iter().cloned().collect();
3640 let mut correction =
3641 matching_fill_void(&fill, Quantity::from(40), Some(Money::from("0.40 USD")));
3642
3643 match field {
3644 FillVoidIdentityField::VenueOrderId => {
3645 correction.venue_order_id = VenueOrderId::from("V-OTHER");
3646 }
3647 FillVoidIdentityField::AccountId => {
3648 correction.account_id = AccountId::from("SIM-OTHER");
3649 }
3650 FillVoidIdentityField::OrderSide => correction.order_side = OrderSide::Sell,
3651 FillVoidIdentityField::OrderType => correction.order_type = OrderType::Limit,
3652 FillVoidIdentityField::LastPx => correction.last_px = Price::from("1.50"),
3653 FillVoidIdentityField::Currency => correction.currency = Currency::EUR(),
3654 FillVoidIdentityField::LiquiditySide => {
3655 correction.liquidity_side = LiquiditySide::Maker;
3656 }
3657 FillVoidIdentityField::PositionId => {
3658 correction.position_id = Some(PositionId::from("P-OTHER"));
3659 }
3660 }
3661
3662 let result = order.apply(OrderEventAny::FillVoided(correction));
3663
3664 assert!(matches!(result, Err(OrderError::InvalidOrderEvent)));
3665 assert_fill_void_rejected_without_mutation(&order, &events_before);
3666 }
3667
3668 #[rstest]
3669 #[case::currency("0.40 EUR")]
3670 #[case::sign("-0.40 USD")]
3671 #[case::amount("1.01 USD")]
3672 fn test_fill_void_rejects_invalid_commission_without_mutation(#[case] commission: &str) {
3673 let (mut order, fill) = filled_market_order_for_void();
3674 let events_before: Vec<_> = order.events().into_iter().cloned().collect();
3675 let correction =
3676 matching_fill_void(&fill, Quantity::from(40), Some(Money::from(commission)));
3677
3678 let result = order.apply(OrderEventAny::FillVoided(correction));
3679
3680 assert!(matches!(
3681 result,
3682 Err(OrderError::InvalidFillVoidCommission(trade_id)) if trade_id == fill.trade_id
3683 ));
3684 assert_fill_void_rejected_without_mutation(&order, &events_before);
3685 }
3686
3687 #[rstest]
3688 fn test_fill_void_rejects_zero_quantity_without_mutation() {
3689 let (mut order, fill) = filled_market_order_for_void();
3690 let events_before: Vec<_> = order.events().into_iter().cloned().collect();
3691 let correction = matching_fill_void(
3692 &fill,
3693 Quantity::zero(fill.last_qty.precision),
3694 Some(Money::from("0.00 USD")),
3695 );
3696
3697 let result = order.apply(OrderEventAny::FillVoided(correction));
3698
3699 assert!(matches!(
3700 result,
3701 Err(OrderError::OverVoid(trade_id)) if trade_id == fill.trade_id
3702 ));
3703 assert_fill_void_rejected_without_mutation(&order, &events_before);
3704 }
3705
3706 #[rstest]
3707 fn test_fill_void_uses_latest_cumulative_correction() {
3708 let (mut order, fill) = filled_market_order_for_void();
3709 order
3710 .apply(OrderEventAny::FillVoided(matching_fill_void(
3711 &fill,
3712 Quantity::from(40),
3713 Some(Money::from("0.40 USD")),
3714 )))
3715 .unwrap();
3716 let event_count = order.event_count();
3717
3718 let decreasing_commission = order.apply(OrderEventAny::FillVoided(matching_fill_void(
3719 &fill,
3720 Quantity::from(50),
3721 Some(Money::from("0.30 USD")),
3722 )));
3723
3724 assert!(matches!(
3725 decreasing_commission,
3726 Err(OrderError::InvalidFillVoidCommission(trade_id)) if trade_id == fill.trade_id
3727 ));
3728 assert_eq!(order.event_count(), event_count);
3729 assert_eq!(order.filled_qty(), Quantity::from(60));
3730 assert_eq!(order.voided_qty(), Quantity::from(40));
3731 assert_eq!(
3732 order.commission(&Currency::USD()),
3733 Some(Money::from("0.60 USD")),
3734 );
3735
3736 order
3737 .apply(OrderEventAny::FillVoided(matching_fill_void(
3738 &fill,
3739 Quantity::from(60),
3740 Some(Money::from("0.60 USD")),
3741 )))
3742 .unwrap();
3743 let replayed =
3744 OrderAny::from_events(order.events().into_iter().cloned().collect()).unwrap();
3745
3746 assert_eq!(order.status(), OrderStatus::PartiallyFilled);
3747 assert_eq!(order.filled_qty(), Quantity::from(40));
3748 assert_eq!(order.voided_qty(), Quantity::from(60));
3749 assert_eq!(order.leaves_qty(), Quantity::from(60));
3750 assert_eq!(order.avg_px(), Some(dec!(1.25)));
3751 assert_eq!(
3752 order.commission(&Currency::USD()),
3753 Some(Money::from("0.40 USD")),
3754 );
3755 assert_eq!(order.trade_ids(), vec![&fill.trade_id]);
3756 assert_eq!(order.last_trade_id(), Some(fill.trade_id));
3757 assert_eq!(order.event_count(), event_count + 1);
3758 assert_eq!(replayed.status(), order.status());
3759 assert_eq!(replayed.filled_qty(), order.filled_qty());
3760 assert_eq!(replayed.voided_qty(), order.voided_qty());
3761 assert_eq!(replayed.leaves_qty(), order.leaves_qty());
3762 assert_eq!(replayed.avg_px(), order.avg_px());
3763 assert_eq!(replayed.commissions(), order.commissions());
3764 assert_eq!(replayed.trade_ids(), order.trade_ids());
3765 assert_eq!(replayed.last_trade_id(), order.last_trade_id());
3766 }
3767
3768 fn filled_market_order_for_void() -> (MarketOrder, OrderFilled) {
3769 let venue_order_id = VenueOrderId::from("V-FILL-VOID");
3770 let account_id = AccountId::from("SIM-FILL-VOID");
3771 let fill = OrderFilledSpec::builder()
3772 .venue_order_id(venue_order_id)
3773 .account_id(account_id)
3774 .trade_id(TradeId::from("T-FILL-VOID"))
3775 .last_qty(Quantity::from(100))
3776 .last_px(Price::from("1.25"))
3777 .position_id(PositionId::from("P-FILL-VOID"))
3778 .commission(Money::from("1.00 USD"))
3779 .build();
3780 let mut order: MarketOrder = OrderInitializedSpec::builder()
3781 .quantity(Quantity::from(100))
3782 .build()
3783 .try_into()
3784 .unwrap();
3785 order
3786 .apply(OrderEventAny::Accepted(
3787 OrderAcceptedSpec::builder()
3788 .venue_order_id(venue_order_id)
3789 .account_id(account_id)
3790 .build(),
3791 ))
3792 .unwrap();
3793 order.apply(OrderEventAny::Filled(fill.clone())).unwrap();
3794
3795 (order, fill)
3796 }
3797
3798 fn matching_fill_void(
3799 fill: &OrderFilled,
3800 voided_qty: Quantity,
3801 commission_voided: Option<Money>,
3802 ) -> OrderFillVoided {
3803 OrderFillVoidedSpec::builder()
3804 .trader_id(fill.trader_id)
3805 .strategy_id(fill.strategy_id)
3806 .instrument_id(fill.instrument_id)
3807 .client_order_id(fill.client_order_id)
3808 .venue_order_id(fill.venue_order_id)
3809 .account_id(fill.account_id)
3810 .trade_id(fill.trade_id)
3811 .voided_qty(voided_qty)
3812 .order_side(fill.order_side)
3813 .order_type(fill.order_type)
3814 .last_px(fill.last_px)
3815 .currency(fill.currency)
3816 .liquidity_side(fill.liquidity_side)
3817 .maybe_position_id(fill.position_id)
3818 .maybe_commission_voided(commission_voided)
3819 .is_reopened(true)
3820 .build()
3821 }
3822
3823 fn assert_fill_void_rejected_without_mutation(
3824 order: &MarketOrder,
3825 events_before: &[OrderEventAny],
3826 ) {
3827 assert_eq!(order.status(), OrderStatus::Filled);
3828 assert_eq!(order.filled_qty(), Quantity::from(100));
3829 assert_eq!(order.voided_qty(), Quantity::from(0));
3830 assert_eq!(order.leaves_qty(), Quantity::from(0));
3831 assert_eq!(order.avg_px(), Some(dec!(1.25)));
3832 assert_eq!(
3833 order.commission(&Currency::USD()),
3834 Some(Money::from("1.00 USD")),
3835 );
3836 assert_eq!(
3837 order.events().into_iter().cloned().collect::<Vec<_>>(),
3838 events_before,
3839 );
3840 }
3841
3842 #[rstest]
3843 fn test_unknown_fill_void_does_not_reverse_surviving_fill() {
3844 let init = OrderInitializedSpec::builder()
3845 .quantity(Quantity::from(100_000))
3846 .build();
3847 let filled = OrderFilledSpec::builder()
3848 .trade_id(TradeId::from("TRADE-APPLIED"))
3849 .last_qty(Quantity::from(60_000))
3850 .build();
3851 let voided = OrderFillVoidedSpec::builder()
3852 .trade_id(TradeId::from("TRADE-NEVER-APPLIED"))
3853 .voided_qty(Quantity::from(40_000))
3854 .build();
3855 let mut order: MarketOrder = init.try_into().unwrap();
3856 order
3857 .apply(OrderEventAny::Accepted(
3858 OrderAcceptedSpec::builder().build(),
3859 ))
3860 .unwrap();
3861 order.apply(OrderEventAny::Filled(filled)).unwrap();
3862
3863 order.apply(OrderEventAny::FillVoided(voided)).unwrap();
3864 order
3865 .apply(OrderEventAny::FillVoided(
3866 OrderFillVoidedSpec::builder()
3867 .trade_id(TradeId::from("TRADE-APPLIED"))
3868 .voided_qty(Quantity::from(10_000))
3869 .is_reopened(true)
3870 .build(),
3871 ))
3872 .unwrap();
3873 let late_fill = order.apply(OrderEventAny::Filled(
3874 OrderFilledSpec::builder()
3875 .trade_id(TradeId::from("TRADE-LATE"))
3876 .last_qty(Quantity::from(10_000))
3877 .build(),
3878 ));
3879
3880 assert_eq!(order.status(), OrderStatus::Voided);
3881 assert_eq!(order.filled_qty(), Quantity::from(50_000));
3882 assert_eq!(order.voided_qty(), Quantity::from(50_000));
3883 assert_eq!(order.leaves_qty(), Quantity::zero(0));
3884 assert!(order.is_closed());
3885 assert!(matches!(late_fill, Err(OrderError::InvalidStateTransition)));
3886 }
3887
3888 #[rstest]
3889 fn test_order_state_transition_to_canceled() {
3890 let mut order: MarketOrder = OrderInitializedSpec::builder().build().try_into().unwrap();
3891 let submitted = OrderSubmittedSpec::builder().build();
3892 let canceled = OrderCanceledSpec::builder().build();
3893
3894 order.apply(OrderEventAny::Submitted(submitted)).unwrap();
3895 order.apply(OrderEventAny::Canceled(canceled)).unwrap();
3896
3897 assert_eq!(order.status(), OrderStatus::Canceled);
3898 assert!(order.is_closed());
3899 assert!(!order.is_open());
3900 }
3901
3902 #[rstest]
3903 fn test_order_life_cycle_to_partially_filled() {
3904 let init = OrderInitializedSpec::builder().build();
3905 let submitted = OrderSubmittedSpec::builder().build();
3906 let accepted = OrderAcceptedSpec::builder().build();
3907 let filled = OrderFilledSpec::builder()
3908 .last_qty(Quantity::from(50_000))
3909 .build();
3910
3911 let mut order: MarketOrder = init.clone().try_into().unwrap();
3912 order.apply(OrderEventAny::Submitted(submitted)).unwrap();
3913 order.apply(OrderEventAny::Accepted(accepted)).unwrap();
3914 order.apply(OrderEventAny::Filled(filled)).unwrap();
3915
3916 assert_eq!(order.client_order_id, init.client_order_id);
3917 assert_eq!(order.status(), OrderStatus::PartiallyFilled);
3918 assert_eq!(order.filled_qty(), Quantity::from(50_000));
3919 assert_eq!(order.leaves_qty(), Quantity::from(50_000));
3920 assert!(order.is_open());
3921 assert!(!order.is_closed());
3922 }
3923
3924 #[rstest]
3925 fn test_order_commission_calculation() {
3926 let mut order: MarketOrder = OrderInitializedSpec::builder().build().try_into().unwrap();
3927 order
3928 .commissions
3929 .insert(Currency::USD(), Money::new(10.0, Currency::USD()));
3930
3931 assert_eq!(
3932 order.commission(&Currency::USD()),
3933 Some(Money::new(10.0, Currency::USD()))
3934 );
3935 assert_eq!(
3936 order.commissions_vec(),
3937 vec![Money::new(10.0, Currency::USD())]
3938 );
3939 }
3940
3941 #[rstest]
3942 fn test_order_is_primary() {
3943 let order: MarketOrder = OrderInitializedSpec::builder()
3944 .exec_algorithm_id(ExecAlgorithmId::from("ALGO-001"))
3945 .exec_spawn_id(ClientOrderId::from("O-001"))
3946 .client_order_id(ClientOrderId::from("O-001"))
3947 .build()
3948 .try_into()
3949 .unwrap();
3950
3951 assert!(order.is_primary());
3952 assert!(!order.is_spawned());
3953 }
3954
3955 #[rstest]
3956 fn test_order_is_spawned() {
3957 let order: MarketOrder = OrderInitializedSpec::builder()
3958 .exec_algorithm_id(ExecAlgorithmId::from("ALGO-001"))
3959 .exec_spawn_id(ClientOrderId::from("O-002"))
3960 .client_order_id(ClientOrderId::from("O-001"))
3961 .build()
3962 .try_into()
3963 .unwrap();
3964
3965 assert!(!order.is_primary());
3966 assert!(order.is_spawned());
3967 }
3968
3969 #[rstest]
3970 fn test_order_is_contingency() {
3971 let order: MarketOrder = OrderInitializedSpec::builder()
3972 .contingency_type(ContingencyType::Oto)
3973 .linked_order_ids(vec![ClientOrderId::from("O-LINKED")])
3974 .build()
3975 .try_into()
3976 .unwrap();
3977
3978 assert!(order.is_contingency());
3979 assert!(order.is_parent_order());
3980 assert!(!order.is_child_order());
3981 }
3982
3983 #[rstest]
3984 fn test_order_is_child_order() {
3985 let order: MarketOrder = OrderInitializedSpec::builder()
3986 .parent_order_id(ClientOrderId::from("PARENT-001"))
3987 .build()
3988 .try_into()
3989 .unwrap();
3990
3991 assert!(order.is_child_order());
3992 assert!(!order.is_parent_order());
3993 }
3994
3995 #[rstest]
3996 fn test_to_own_book_order_timestamp_ordering() {
3997 use crate::orders::limit::LimitOrder;
3998
3999 let init = OrderInitializedSpec::builder()
4001 .price(Price::from("100.00"))
4002 .build();
4003 let submitted = OrderSubmittedSpec::builder()
4004 .ts_event(UnixNanos::from(1_000_000))
4005 .build();
4006 let accepted = OrderAcceptedSpec::builder()
4007 .ts_event(UnixNanos::from(2_000_000))
4008 .build();
4009
4010 let mut order: LimitOrder = init.try_into().unwrap();
4011 order.apply(OrderEventAny::Submitted(submitted)).unwrap();
4012 order.apply(OrderEventAny::Accepted(accepted)).unwrap();
4013
4014 let own_book_order = order.to_own_book_order();
4015
4016 assert_eq!(own_book_order.ts_submitted, UnixNanos::from(1_000_000));
4018 assert_eq!(own_book_order.ts_accepted, UnixNanos::from(2_000_000));
4019 assert_eq!(own_book_order.ts_last, UnixNanos::from(2_000_000));
4020 }
4021
4022 #[rstest]
4023 fn test_to_own_book_order_partial_fill_uses_leaves_qty() {
4024 use crate::orders::limit::LimitOrder;
4025
4026 let init = OrderInitializedSpec::builder()
4027 .price(Price::from("100.00"))
4028 .quantity(Quantity::from(100_000))
4029 .build();
4030 let submitted = OrderSubmittedSpec::builder().build();
4031 let accepted = OrderAcceptedSpec::builder().build();
4032 let filled = OrderFilledSpec::builder()
4033 .order_type(OrderType::Limit)
4034 .last_qty(Quantity::from(40_000))
4035 .last_px(Price::from("100.00"))
4036 .build();
4037
4038 let mut order: LimitOrder = init.try_into().unwrap();
4039 order.apply(OrderEventAny::Submitted(submitted)).unwrap();
4040 order.apply(OrderEventAny::Accepted(accepted)).unwrap();
4041 order.apply(OrderEventAny::Filled(filled)).unwrap();
4042
4043 let own_book_order = order.to_own_book_order();
4044
4045 assert_eq!(order.status(), OrderStatus::PartiallyFilled);
4046 assert_eq!(order.leaves_qty(), Quantity::from(60_000));
4047 assert_eq!(own_book_order.size, Quantity::from(60_000));
4048 }
4049
4050 #[rstest]
4051 fn test_order_accepted_without_submitted_sets_account_id() {
4052 let init = OrderInitializedSpec::builder().build();
4054 let accepted = OrderAcceptedSpec::builder()
4055 .account_id(AccountId::from("EXTERNAL-001"))
4056 .build();
4057
4058 let mut order: MarketOrder = init.try_into().unwrap();
4059
4060 assert_eq!(order.account_id(), None);
4062
4063 order.apply(OrderEventAny::Accepted(accepted)).unwrap();
4065
4066 assert_eq!(order.account_id(), Some(AccountId::from("EXTERNAL-001")));
4068 assert_eq!(order.status(), OrderStatus::Accepted);
4069 }
4070
4071 #[rstest]
4072 fn test_order_accepted_after_submitted_preserves_account_id() {
4073 let init = OrderInitializedSpec::builder().build();
4075 let submitted = OrderSubmittedSpec::builder()
4076 .account_id(AccountId::from("SUBMITTED-001"))
4077 .build();
4078 let accepted = OrderAcceptedSpec::builder()
4079 .account_id(AccountId::from("ACCEPTED-001"))
4080 .build();
4081
4082 let mut order: MarketOrder = init.try_into().unwrap();
4083 order.apply(OrderEventAny::Submitted(submitted)).unwrap();
4084
4085 assert_eq!(order.account_id(), Some(AccountId::from("SUBMITTED-001")));
4087
4088 order.apply(OrderEventAny::Accepted(accepted)).unwrap();
4090
4091 assert_eq!(order.account_id(), Some(AccountId::from("ACCEPTED-001")));
4093 assert_eq!(order.status(), OrderStatus::Accepted);
4094 }
4095
4096 #[rstest]
4097 fn test_overfill_tracks_overfill_qty() {
4098 let init = OrderInitializedSpec::builder()
4100 .quantity(Quantity::from(100_000))
4101 .build();
4102 let submitted = OrderSubmittedSpec::builder().build();
4103 let accepted = OrderAcceptedSpec::builder().build();
4104 let overfill = OrderFilledSpec::builder()
4105 .last_qty(Quantity::from(110_000)) .build();
4107
4108 let mut order: MarketOrder = init.try_into().unwrap();
4109 order.apply(OrderEventAny::Submitted(submitted)).unwrap();
4110 order.apply(OrderEventAny::Accepted(accepted)).unwrap();
4111 order.apply(OrderEventAny::Filled(overfill)).unwrap();
4112
4113 assert_eq!(order.overfill_qty(), Quantity::from(10_000));
4115 assert_eq!(order.filled_qty(), Quantity::from(110_000));
4116 assert_eq!(order.leaves_qty(), Quantity::from(0));
4117 assert_eq!(order.status(), OrderStatus::Filled);
4118 }
4119
4120 #[rstest]
4121 fn test_partial_fill_then_overfill() {
4122 let init = OrderInitializedSpec::builder()
4124 .quantity(Quantity::from(100_000))
4125 .build();
4126 let submitted = OrderSubmittedSpec::builder().build();
4127 let accepted = OrderAcceptedSpec::builder().build();
4128 let fill1 = OrderFilledSpec::builder()
4129 .last_qty(Quantity::from(80_000))
4130 .trade_id(TradeId::from("TRADE-1"))
4131 .build();
4132 let fill2 = OrderFilledSpec::builder()
4133 .last_qty(Quantity::from(30_000)) .trade_id(TradeId::from("TRADE-2"))
4135 .build();
4136
4137 let mut order: MarketOrder = init.try_into().unwrap();
4138 order.apply(OrderEventAny::Submitted(submitted)).unwrap();
4139 order.apply(OrderEventAny::Accepted(accepted)).unwrap();
4140 order.apply(OrderEventAny::Filled(fill1)).unwrap();
4141
4142 assert_eq!(order.overfill_qty(), Quantity::from(0));
4144 assert_eq!(order.filled_qty(), Quantity::from(80_000));
4145 assert_eq!(order.leaves_qty(), Quantity::from(20_000));
4146
4147 order.apply(OrderEventAny::Filled(fill2)).unwrap();
4148
4149 assert_eq!(order.overfill_qty(), Quantity::from(10_000));
4151 assert_eq!(order.filled_qty(), Quantity::from(110_000));
4152 assert_eq!(order.leaves_qty(), Quantity::from(0));
4153 assert_eq!(order.status(), OrderStatus::Filled);
4154 }
4155
4156 #[rstest]
4157 fn test_exact_fill_no_overfill() {
4158 let init = OrderInitializedSpec::builder()
4160 .quantity(Quantity::from(100_000))
4161 .build();
4162 let submitted = OrderSubmittedSpec::builder().build();
4163 let accepted = OrderAcceptedSpec::builder().build();
4164 let filled = OrderFilledSpec::builder()
4165 .last_qty(Quantity::from(100_000)) .build();
4167
4168 let mut order: MarketOrder = init.try_into().unwrap();
4169 order.apply(OrderEventAny::Submitted(submitted)).unwrap();
4170 order.apply(OrderEventAny::Accepted(accepted)).unwrap();
4171 order.apply(OrderEventAny::Filled(filled)).unwrap();
4172
4173 assert_eq!(order.overfill_qty(), Quantity::from(0));
4175 assert_eq!(order.filled_qty(), Quantity::from(100_000));
4176 assert_eq!(order.leaves_qty(), Quantity::from(0));
4177 }
4178
4179 #[rstest]
4180 fn test_partial_fill_then_overfill_with_fractional_quantities() {
4181 let init = OrderInitializedSpec::builder()
4185 .quantity(Quantity::from("2450.5"))
4186 .build();
4187 let submitted = OrderSubmittedSpec::builder().build();
4188 let accepted = OrderAcceptedSpec::builder().build();
4189 let fill1 = OrderFilledSpec::builder()
4190 .last_qty(Quantity::from("1202.5"))
4191 .trade_id(TradeId::from("TRADE-1"))
4192 .build();
4193 let fill2 = OrderFilledSpec::builder()
4194 .last_qty(Quantity::from("1285.5")) .trade_id(TradeId::from("TRADE-2"))
4196 .build();
4197
4198 let mut order: MarketOrder = init.try_into().unwrap();
4199 order.apply(OrderEventAny::Submitted(submitted)).unwrap();
4200 order.apply(OrderEventAny::Accepted(accepted)).unwrap();
4201 order.apply(OrderEventAny::Filled(fill1)).unwrap();
4202
4203 assert_eq!(order.overfill_qty(), Quantity::from(0));
4205 assert_eq!(order.filled_qty(), Quantity::from("1202.5"));
4206 assert_eq!(order.leaves_qty(), Quantity::from("1248.0"));
4207 assert_eq!(order.status(), OrderStatus::PartiallyFilled);
4208
4209 order.apply(OrderEventAny::Filled(fill2)).unwrap();
4210
4211 assert_eq!(order.overfill_qty(), Quantity::from("37.5"));
4213 assert_eq!(order.filled_qty(), Quantity::from("2488.0"));
4214 assert_eq!(order.leaves_qty(), Quantity::from(0));
4215 assert_eq!(order.status(), OrderStatus::Filled);
4216 }
4217
4218 #[rstest]
4219 fn test_calculate_overfill_returns_zero_when_no_overfill() {
4220 let order: MarketOrder = OrderInitializedSpec::builder()
4221 .quantity(Quantity::from(100_000))
4222 .build()
4223 .try_into()
4224 .unwrap();
4225
4226 let overfill = order.calculate_overfill(Quantity::from(50_000));
4228 assert_eq!(overfill, Quantity::from(0));
4229
4230 let overfill = order.calculate_overfill(Quantity::from(100_000));
4232 assert_eq!(overfill, Quantity::from(0));
4233 }
4234
4235 #[rstest]
4236 fn test_calculate_overfill_returns_overfill_amount() {
4237 let order: MarketOrder = OrderInitializedSpec::builder()
4238 .quantity(Quantity::from(100_000))
4239 .build()
4240 .try_into()
4241 .unwrap();
4242
4243 let overfill = order.calculate_overfill(Quantity::from(110_000));
4245 assert_eq!(overfill, Quantity::from(10_000));
4246 }
4247
4248 #[rstest]
4249 fn test_calculate_overfill_accounts_for_existing_fills() {
4250 let init = OrderInitializedSpec::builder()
4251 .quantity(Quantity::from(100_000))
4252 .build();
4253 let submitted = OrderSubmittedSpec::builder().build();
4254 let accepted = OrderAcceptedSpec::builder().build();
4255 let partial_fill = OrderFilledSpec::builder()
4256 .last_qty(Quantity::from(60_000))
4257 .build();
4258
4259 let mut order: MarketOrder = init.try_into().unwrap();
4260 order.apply(OrderEventAny::Submitted(submitted)).unwrap();
4261 order.apply(OrderEventAny::Accepted(accepted)).unwrap();
4262 order.apply(OrderEventAny::Filled(partial_fill)).unwrap();
4263
4264 let overfill = order.calculate_overfill(Quantity::from(50_000));
4267 assert_eq!(overfill, Quantity::from(10_000));
4268
4269 let overfill = order.calculate_overfill(Quantity::from(40_000));
4271 assert_eq!(overfill, Quantity::from(0));
4272 }
4273
4274 #[rstest]
4275 fn test_calculate_overfill_with_fractional_quantities() {
4276 let order: MarketOrder = OrderInitializedSpec::builder()
4277 .quantity(Quantity::from("2450.5"))
4278 .build()
4279 .try_into()
4280 .unwrap();
4281
4282 let overfill = order.calculate_overfill(Quantity::from("2488.0"));
4285 assert_eq!(overfill, Quantity::from("37.5"));
4286 }
4287
4288 #[rstest]
4289 fn test_calculate_overfill_zero_after_fractional_partial_fill() {
4290 let init = OrderInitializedSpec::builder()
4291 .quantity(Quantity::from("1.000"))
4292 .build();
4293 let submitted = OrderSubmittedSpec::builder().build();
4294 let accepted = OrderAcceptedSpec::builder().build();
4295 let partial_fill = OrderFilledSpec::builder()
4296 .last_qty(Quantity::from("0.072"))
4297 .build();
4298
4299 let mut order: MarketOrder = init.try_into().unwrap();
4300 order.apply(OrderEventAny::Submitted(submitted)).unwrap();
4301 order.apply(OrderEventAny::Accepted(accepted)).unwrap();
4302 order.apply(OrderEventAny::Filled(partial_fill)).unwrap();
4303
4304 let overfill = order.calculate_overfill(Quantity::from("0.072"));
4306 assert_eq!(overfill, Quantity::from("0.000"));
4307 }
4308
4309 #[rstest]
4310 fn test_duplicate_fill_rejected() {
4311 let init = OrderInitializedSpec::builder()
4312 .quantity(Quantity::from(100_000))
4313 .build();
4314 let submitted = OrderSubmittedSpec::builder().build();
4315 let accepted = OrderAcceptedSpec::builder().build();
4316 let fill1 = OrderFilledSpec::builder()
4317 .last_qty(Quantity::from(50_000))
4318 .trade_id(TradeId::from("TRADE-001"))
4319 .build();
4320 let fill2_duplicate = OrderFilledSpec::builder()
4321 .last_qty(Quantity::from(50_000))
4322 .trade_id(TradeId::from("TRADE-001")) .build();
4324
4325 let mut order: MarketOrder = init.try_into().unwrap();
4326 order.apply(OrderEventAny::Submitted(submitted)).unwrap();
4327 order.apply(OrderEventAny::Accepted(accepted)).unwrap();
4328 order.apply(OrderEventAny::Filled(fill1)).unwrap();
4329
4330 assert_eq!(order.filled_qty(), Quantity::from(50_000));
4332 assert_eq!(order.status(), OrderStatus::PartiallyFilled);
4333
4334 let result = order.apply(OrderEventAny::Filled(fill2_duplicate));
4336 assert!(result.is_err());
4337 match result.unwrap_err() {
4338 OrderError::DuplicateFill(trade_id) => {
4339 assert_eq!(trade_id, TradeId::from("TRADE-001"));
4340 }
4341 e => panic!("Expected DuplicateFill error, was: {e:?}"),
4342 }
4343
4344 assert_eq!(order.filled_qty(), Quantity::from(50_000));
4346 assert_eq!(order.status(), OrderStatus::PartiallyFilled);
4347 }
4348
4349 #[rstest]
4350 fn test_same_trade_id_new_price_restates_average_and_void_matches_original_price() {
4351 let trade_id = TradeId::from("TRADE-1");
4352 let qty = Quantity::from("2");
4353 let original_px = Price::from("12");
4354 let restated_px = Price::from("9.47");
4355 let mut order =
4356 market_order_with_fills(OrderSide::Buy, qty, &[(trade_id, qty, original_px)]);
4357 let restatement = OrderFilledSpec::builder()
4358 .order_side(OrderSide::Buy)
4359 .trade_id(trade_id)
4360 .last_qty(qty)
4361 .last_px(restated_px)
4362 .event_id(UUID4::new())
4363 .build();
4364
4365 order
4366 .apply(OrderEventAny::Filled(restatement.clone()))
4367 .unwrap();
4368 let repeated = order.apply(OrderEventAny::Filled(restatement));
4369 assert!(matches!(repeated, Err(OrderError::DuplicateFill(_))));
4370
4371 let stored_px = order.events().iter().find_map(|event| match event {
4372 OrderEventAny::Filled(fill) if fill.last_px == original_px => Some(fill.last_px),
4373 _ => None,
4374 });
4375
4376 let replayed =
4377 OrderAny::from_events(order.events().into_iter().cloned().collect()).unwrap();
4378
4379 assert_eq!(order.status(), OrderStatus::Filled);
4380 assert_eq!(order.filled_qty(), qty);
4381 assert!(order.leaves_qty().is_zero());
4382 let returned = OrderFilledSpec::builder()
4383 .order_side(OrderSide::Buy)
4384 .trade_id(trade_id)
4385 .last_qty(qty)
4386 .last_px(original_px)
4387 .event_id(UUID4::new())
4388 .build();
4389 order.apply(OrderEventAny::Filled(returned)).unwrap();
4390 assert_eq!(order.avg_px(), Some(dec!(12)));
4391 assert_eq!(order.filled_qty(), qty);
4392 assert_eq!(order.trade_ids().len(), 1);
4393 assert_eq!(stored_px, Some(original_px));
4394 assert_eq!(replayed.status(), OrderStatus::Filled);
4395 assert_eq!(replayed.filled_qty(), qty);
4396 assert_eq!(replayed.avg_px(), Some(dec!(9.47)));
4397
4398 order
4399 .apply(OrderEventAny::FillVoided(
4400 OrderFillVoidedSpec::builder()
4401 .trade_id(trade_id)
4402 .voided_qty(qty)
4403 .last_px(original_px)
4404 .order_side(OrderSide::Buy)
4405 .build(),
4406 ))
4407 .unwrap();
4408
4409 let mut mismatched =
4410 market_order_with_fills(OrderSide::Buy, qty, &[(trade_id, qty, original_px)]);
4411 mismatched
4412 .apply(OrderEventAny::Filled(
4413 OrderFilledSpec::builder()
4414 .order_side(OrderSide::Buy)
4415 .trade_id(trade_id)
4416 .last_qty(qty)
4417 .last_px(restated_px)
4418 .event_id(UUID4::new())
4419 .build(),
4420 ))
4421 .unwrap();
4422 let rejected = mismatched.apply(OrderEventAny::FillVoided(
4423 OrderFillVoidedSpec::builder()
4424 .trade_id(trade_id)
4425 .voided_qty(qty)
4426 .last_px(restated_px)
4427 .order_side(OrderSide::Buy)
4428 .build(),
4429 ));
4430
4431 assert!(matches!(rejected, Err(OrderError::InvalidOrderEvent)));
4432 }
4433
4434 #[rstest]
4435 fn test_fill_raw_overflow_rejected_without_mutation() {
4436 let unit = Quantity::from(1);
4437 let almost_max = Quantity::from_raw(QUANTITY_RAW_MAX - unit.raw(), 0);
4438 let max = Quantity::from_raw(QUANTITY_RAW_MAX, 0);
4439 let init = OrderInitializedSpec::builder().quantity(max).build();
4440 let accepted = OrderAcceptedSpec::builder().build();
4441 let fill1 = OrderFilledSpec::builder()
4442 .last_qty(almost_max)
4443 .trade_id(TradeId::from("TRADE-001"))
4444 .build();
4445 let fill2 = OrderFilledSpec::builder()
4446 .last_qty(Quantity::from(2))
4447 .trade_id(TradeId::from("TRADE-002"))
4448 .build();
4449
4450 let mut order: MarketOrder = init.try_into().unwrap();
4451 order.apply(OrderEventAny::Accepted(accepted)).unwrap();
4452 order.apply(OrderEventAny::Filled(fill1)).unwrap();
4453
4454 assert_eq!(order.filled_qty(), almost_max);
4455 assert_eq!(order.status(), OrderStatus::PartiallyFilled);
4456
4457 let result = order.apply(OrderEventAny::Filled(fill2));
4458 let Err(OrderError::Invariant(CorrectnessError::PredicateViolation { message })) = result
4459 else {
4460 panic!("Expected typed invariant error, was: {result:?}");
4461 };
4462 assert_eq!(
4463 message,
4464 format!("filled quantity overflowed Quantity raw bounds: {almost_max} + 2")
4465 );
4466 assert_eq!(order.filled_qty(), almost_max);
4467 assert_eq!(order.status(), OrderStatus::PartiallyFilled);
4468 assert_eq!(order.event_count(), 3);
4469 }
4470
4471 #[rstest]
4472 #[case::domain_overflow(1)]
4473 #[case::integer_overflow(Money::from("1 USD").raw())]
4474 fn test_fill_commission_overflow_rejected_without_mutation(
4475 #[case] increment: MoneyRaw,
4476 #[values(false, true)] negative: bool,
4477 ) {
4478 let usd = Currency::USD();
4479
4480 let bound = if negative {
4481 MONEY_RAW_MIN
4482 } else {
4483 MONEY_RAW_MAX
4484 };
4485
4486 let commission = Money::from_raw_checked(bound, usd).unwrap();
4487 let additional =
4488 Money::from_raw_checked(if negative { -increment } else { increment }, usd).unwrap();
4489 let init = OrderInitializedSpec::builder()
4490 .quantity(Quantity::from(2))
4491 .build();
4492 let mut order: MarketOrder = init.try_into().unwrap();
4493 order
4494 .apply(OrderEventAny::Accepted(
4495 OrderAcceptedSpec::builder().build(),
4496 ))
4497 .unwrap();
4498 let first = OrderFilledSpec::builder()
4499 .trade_id(TradeId::from("TRADE-1"))
4500 .last_qty(Quantity::from(1))
4501 .commission(commission)
4502 .ts_event(11.into())
4503 .build();
4504 let second = OrderFilledSpec::builder()
4505 .trade_id(TradeId::from("TRADE-2"))
4506 .last_qty(Quantity::from(1))
4507 .commission(additional)
4508 .position_id(PositionId::from("POSITION-2"))
4509 .ts_event(29.into())
4510 .build();
4511 order.apply(OrderEventAny::Filled(first)).unwrap();
4512 let before = serde_json::to_value(&order).unwrap();
4513 let totals_before = order
4514 .fill_totals
4515 .as_ref()
4516 .map(|totals| (totals.notional, totals.quantity));
4517
4518 let result = order.apply(OrderEventAny::Filled(second));
4519
4520 let Err(OrderError::Invariant(CorrectnessError::PredicateViolation { message })) = result
4521 else {
4522 panic!("Expected typed invariant error, was: {result:?}");
4523 };
4524
4525 assert_eq!(
4526 message,
4527 format!("cumulative commission overflowed Money bounds: {commission} + {additional}")
4528 );
4529 assert_eq!(serde_json::to_value(&order).unwrap(), before);
4530 assert_eq!(
4531 order
4532 .fill_totals
4533 .as_ref()
4534 .map(|totals| (totals.notional, totals.quantity)),
4535 totals_before
4536 );
4537 }
4538
4539 #[rstest]
4540 fn test_fill_commission_bounds_survive_corrections_and_replay() {
4541 let usd = Currency::USD();
4542 let aud = Currency::AUD();
4543 let unit = Money::from("1 USD");
4544 let max = Money::from_raw_checked(MONEY_RAW_MAX, usd).unwrap();
4545 let other_max = Money::from_raw_checked(MONEY_RAW_MAX, aud).unwrap();
4546 let init = OrderInitializedSpec::builder()
4547 .quantity(Quantity::from(6))
4548 .build();
4549 let mut order: MarketOrder = init.try_into().unwrap();
4550 order
4551 .apply(OrderEventAny::Accepted(
4552 OrderAcceptedSpec::builder().build(),
4553 ))
4554 .unwrap();
4555 let first = OrderFilledSpec::builder()
4556 .trade_id(TradeId::from("TRADE-1"))
4557 .last_qty(Quantity::from(2))
4558 .commission(max - unit)
4559 .build();
4560 order.apply(OrderEventAny::Filled(first.clone())).unwrap();
4561 order
4562 .apply(OrderEventAny::Filled(
4563 OrderFilledSpec::builder()
4564 .trade_id(TradeId::from("TRADE-2"))
4565 .last_qty(Quantity::from(1))
4566 .commission(unit)
4567 .build(),
4568 ))
4569 .unwrap();
4570 order
4571 .apply(OrderEventAny::Filled(
4572 OrderFilledSpec::builder()
4573 .trade_id(TradeId::from("TRADE-3"))
4574 .last_qty(Quantity::from(1))
4575 .commission(other_max)
4576 .build(),
4577 ))
4578 .unwrap();
4579 order
4580 .apply(OrderEventAny::FillVoided(matching_fill_void(
4581 &first,
4582 Quantity::from(1),
4583 Some(unit),
4584 )))
4585 .unwrap();
4586 assert_eq!(order.commission(&usd), Some(max - unit));
4587 order
4588 .apply(OrderEventAny::Filled(
4589 OrderFilledSpec::builder()
4590 .trade_id(TradeId::from("TRADE-4"))
4591 .last_qty(Quantity::from(1))
4592 .commission(unit)
4593 .build(),
4594 ))
4595 .unwrap();
4596 let replayed =
4597 OrderAny::from_events(order.events().into_iter().cloned().collect()).unwrap();
4598 let before = serde_json::to_value(&order).unwrap();
4599 let overflow = OrderFilledSpec::builder()
4600 .trade_id(TradeId::from("TRADE-5"))
4601 .last_qty(Quantity::from(1))
4602 .commission(unit)
4603 .build();
4604
4605 let result = order.apply(OrderEventAny::Filled(overflow));
4606
4607 assert!(matches!(result, Err(OrderError::Invariant(_))));
4608 assert_eq!(serde_json::to_value(&order).unwrap(), before);
4609 assert_eq!(order.commission(&usd), Some(max));
4610 assert_eq!(order.commission(&aud), Some(other_max));
4611 assert_eq!(order.filled_qty(), Quantity::from(4));
4612 assert_eq!(order.leaves_qty(), Quantity::from(2));
4613 assert_eq!(replayed.commissions(), order.commissions());
4614 assert_eq!(replayed.filled_qty(), order.filled_qty());
4615 assert_eq!(replayed.leaves_qty(), order.leaves_qty());
4616 }
4617
4618 #[rstest]
4619 fn test_late_fill_on_filled_order_is_invalid_transition_not_overflow() {
4620 let max = Quantity::from_raw(QUANTITY_RAW_MAX, 0);
4621 let init = OrderInitializedSpec::builder().quantity(max).build();
4622 let accepted = OrderAcceptedSpec::builder().build();
4623 let fill1 = OrderFilledSpec::builder()
4624 .last_qty(max)
4625 .trade_id(TradeId::from("TRADE-001"))
4626 .build();
4627 let fill2 = OrderFilledSpec::builder()
4628 .last_qty(Quantity::from(1))
4629 .trade_id(TradeId::from("TRADE-002"))
4630 .build();
4631
4632 let mut order: MarketOrder = init.try_into().unwrap();
4633 order.apply(OrderEventAny::Accepted(accepted)).unwrap();
4634 order.apply(OrderEventAny::Filled(fill1)).unwrap();
4635
4636 let result = order.apply(OrderEventAny::Filled(fill2));
4637 assert!(matches!(result, Err(OrderError::InvalidStateTransition)));
4638 assert_eq!(order.filled_qty(), max);
4639 assert_eq!(order.status(), OrderStatus::Filled);
4640 }
4641
4642 #[rstest]
4643 fn test_quantity_saturating_add_clamps_undef_sentinel() {
4644 let qty = Quantity::from_raw(QuantityRaw::MAX, 0).saturating_add(Quantity::zero(0));
4645
4646 assert_eq!(qty, Quantity::from_raw(QUANTITY_RAW_MAX, 0));
4647 assert!(!qty.is_undefined());
4648 }
4649
4650 #[rstest]
4651 fn test_check_display_qty_returns_typed_invariant_with_stable_display() {
4652 let error = check_display_qty(Some(Quantity::from(2)), Quantity::from(1)).unwrap_err();
4653
4654 match error {
4655 OrderError::Invariant(CorrectnessError::PredicateViolation { ref message }) => {
4656 assert_eq!(message, "`display_qty` may not exceed `quantity`");
4657 }
4658 other => panic!("Expected typed invariant error, was: {other:?}"),
4659 }
4660
4661 assert_eq!(error.to_string(), "`display_qty` may not exceed `quantity`");
4662 }
4663
4664 #[rstest]
4665 fn test_check_time_in_force_returns_typed_invariant_with_stable_display() {
4666 let error = check_time_in_force(TimeInForce::Gtd, None).unwrap_err();
4667
4668 match error {
4669 OrderError::Invariant(CorrectnessError::PredicateViolation { ref message }) => {
4670 assert_eq!(message, "`expire_time` is required for `GTD` order");
4671 }
4672 other => panic!("Expected typed invariant error, was: {other:?}"),
4673 }
4674
4675 assert_eq!(
4676 error.to_string(),
4677 "`expire_time` is required for `GTD` order"
4678 );
4679 }
4680
4681 #[rstest]
4682 fn test_different_trade_ids_allowed() {
4683 let init = OrderInitializedSpec::builder()
4684 .quantity(Quantity::from(100_000))
4685 .build();
4686 let submitted = OrderSubmittedSpec::builder().build();
4687 let accepted = OrderAcceptedSpec::builder().build();
4688 let fill1 = OrderFilledSpec::builder()
4689 .last_qty(Quantity::from(50_000))
4690 .trade_id(TradeId::from("TRADE-001"))
4691 .build();
4692 let fill2 = OrderFilledSpec::builder()
4693 .last_qty(Quantity::from(50_000))
4694 .trade_id(TradeId::from("TRADE-002")) .build();
4696
4697 let mut order: MarketOrder = init.try_into().unwrap();
4698 order.apply(OrderEventAny::Submitted(submitted)).unwrap();
4699 order.apply(OrderEventAny::Accepted(accepted)).unwrap();
4700 order.apply(OrderEventAny::Filled(fill1)).unwrap();
4701 order.apply(OrderEventAny::Filled(fill2)).unwrap();
4702
4703 assert_eq!(order.filled_qty(), Quantity::from(100_000));
4705 assert_eq!(order.status(), OrderStatus::Filled);
4706 assert_eq!(order.trade_ids.len(), 2);
4707 }
4708
4709 #[rstest]
4710 fn test_pending_update_order_restores_status_on_updated() {
4711 let init = OrderInitializedSpec::builder()
4712 .quantity(Quantity::from(100_000))
4713 .build();
4714 let submitted = OrderSubmittedSpec::builder().build();
4715 let accepted = OrderAcceptedSpec::builder().build();
4716 let pending_update = OrderPendingUpdateSpec::builder().build();
4717 let fill = OrderFilledSpec::builder()
4718 .last_qty(Quantity::from(10_000))
4719 .build();
4720 let updated = OrderUpdatedSpec::builder()
4721 .quantity(Quantity::from(50_000))
4722 .build();
4723
4724 let mut order: MarketOrder = init.try_into().unwrap();
4725 order.apply(OrderEventAny::Submitted(submitted)).unwrap();
4726 order.apply(OrderEventAny::Accepted(accepted)).unwrap();
4727
4728 assert_eq!(order.status(), OrderStatus::Accepted);
4729
4730 order
4731 .apply(OrderEventAny::PendingUpdate(pending_update))
4732 .unwrap();
4733 order.apply(OrderEventAny::Filled(fill)).unwrap();
4734 assert_eq!(order.status(), OrderStatus::PendingUpdate);
4735 assert_eq!(order.previous_status(), Some(OrderStatus::PartiallyFilled));
4736 assert_eq!(order.filled_qty(), Quantity::from(10_000));
4737
4738 order.apply(OrderEventAny::Updated(updated)).unwrap();
4739
4740 assert_eq!(order.status(), OrderStatus::PartiallyFilled);
4741 assert_eq!(order.quantity(), Quantity::from(50_000));
4742 assert_eq!(order.leaves_qty(), Quantity::from(40_000));
4743 }
4744
4745 #[rstest]
4746 fn test_pending_cancel_supersedes_pending_update_without_losing_previous_status() {
4747 let mut order: MarketOrder = OrderInitializedSpec::builder().build().try_into().unwrap();
4748 order
4749 .apply(OrderEventAny::Submitted(
4750 OrderSubmittedSpec::builder().build(),
4751 ))
4752 .unwrap();
4753 order
4754 .apply(OrderEventAny::Accepted(
4755 OrderAcceptedSpec::builder().build(),
4756 ))
4757 .unwrap();
4758 order
4759 .apply(OrderEventAny::PendingUpdate(
4760 OrderPendingUpdateSpec::builder().build(),
4761 ))
4762 .unwrap();
4763
4764 assert_eq!(order.status(), OrderStatus::PendingUpdate);
4765 assert_eq!(order.previous_status(), Some(OrderStatus::Accepted));
4766
4767 order
4768 .apply(OrderEventAny::PendingCancel(
4769 OrderPendingCancelSpec::builder().build(),
4770 ))
4771 .unwrap();
4772
4773 assert_eq!(order.status(), OrderStatus::PendingCancel);
4774 assert_eq!(order.previous_status(), Some(OrderStatus::Accepted));
4775
4776 let repeated = OrderEventAny::PendingCancel(OrderPendingCancelSpec::builder().build());
4777 order.apply(repeated.clone()).unwrap();
4778
4779 assert_eq!(order.status(), OrderStatus::PendingCancel);
4780 assert_eq!(order.previous_status(), Some(OrderStatus::Accepted));
4781 assert_eq!(order.event_count(), 6);
4782 assert_eq!(order.last_event(), &repeated);
4783 }
4784
4785 #[rstest]
4786 fn test_late_fill_for_historical_venue_order_keeps_current_venue_order_id() {
4787 let old_venue_order_id = VenueOrderId::from("V-OLD");
4788 let new_venue_order_id = VenueOrderId::from("V-NEW");
4789 let init = OrderInitializedSpec::builder()
4790 .quantity(Quantity::from(10))
4791 .build();
4792 let accepted = OrderAcceptedSpec::builder()
4793 .venue_order_id(old_venue_order_id)
4794 .build();
4795 let updated = OrderUpdatedSpec::builder()
4796 .quantity(Quantity::from(10))
4797 .venue_order_id(new_venue_order_id)
4798 .build();
4799 let late_fill = OrderFilledSpec::builder()
4800 .venue_order_id(old_venue_order_id)
4801 .last_qty(Quantity::from(2))
4802 .trade_id(TradeId::from("T-LATE"))
4803 .build();
4804
4805 let mut order: MarketOrder = init.try_into().unwrap();
4806 order.apply(OrderEventAny::Accepted(accepted)).unwrap();
4807 order.apply(OrderEventAny::Updated(updated)).unwrap();
4808 order.apply(OrderEventAny::Filled(late_fill)).unwrap();
4809
4810 assert_eq!(order.status(), OrderStatus::PartiallyFilled);
4811 assert_eq!(order.quantity(), Quantity::from(10));
4812 assert_eq!(order.filled_qty(), Quantity::from(2));
4813 assert_eq!(order.leaves_qty(), Quantity::from(8));
4814 assert_eq!(order.venue_order_id(), Some(new_venue_order_id));
4815 assert_eq!(
4816 order
4817 .venue_order_ids()
4818 .into_iter()
4819 .copied()
4820 .collect::<Vec<_>>(),
4821 vec![old_venue_order_id, new_venue_order_id],
4822 );
4823 let OrderEventAny::Filled(event) = order.last_event() else {
4824 panic!("last event was not the late fill");
4825 };
4826 assert_eq!(event.venue_order_id, old_venue_order_id);
4827 }
4828
4829 #[rstest]
4830 fn test_pending_update_accepts_delayed_submitted() {
4831 let init = OrderInitializedSpec::builder()
4832 .quantity(Quantity::from(100_000))
4833 .build();
4834 let submitted = OrderSubmittedSpec::builder()
4835 .ts_event(UnixNanos::from(1_000))
4836 .build();
4837 let accepted = OrderAcceptedSpec::builder().build();
4838 let pending_update = OrderPendingUpdateSpec::builder().build();
4839
4840 let delayed_submitted = OrderSubmittedSpec::builder()
4844 .account_id(AccountId::from("SIM-002"))
4845 .ts_event(UnixNanos::from(3_000))
4846 .build();
4847 let updated = OrderUpdatedSpec::builder()
4848 .quantity(Quantity::from(50_000))
4849 .build();
4850
4851 let mut order: MarketOrder = init.try_into().unwrap();
4852 order.apply(OrderEventAny::Submitted(submitted)).unwrap();
4853 order.apply(OrderEventAny::Accepted(accepted)).unwrap();
4854 order
4855 .apply(OrderEventAny::PendingUpdate(pending_update))
4856 .unwrap();
4857
4858 assert_eq!(order.status(), OrderStatus::PendingUpdate);
4859 assert_eq!(order.previous_status(), Some(OrderStatus::Accepted));
4860 assert_eq!(order.account_id(), Some(AccountId::from("SIM-001")));
4861 assert_eq!(order.ts_submitted(), Some(UnixNanos::from(1_000)));
4862
4863 order
4864 .apply(OrderEventAny::Submitted(delayed_submitted))
4865 .unwrap();
4866
4867 assert_eq!(order.status(), OrderStatus::PendingUpdate);
4870 assert_eq!(order.previous_status(), Some(OrderStatus::Accepted));
4871
4872 assert_eq!(order.account_id(), Some(AccountId::from("SIM-002")));
4873 assert_eq!(order.ts_submitted(), Some(UnixNanos::from(3_000)));
4874
4875 order.apply(OrderEventAny::Updated(updated)).unwrap();
4876
4877 assert_eq!(order.status(), OrderStatus::Accepted);
4878 assert_eq!(order.quantity(), Quantity::from(50_000));
4879 }
4880
4881 #[rstest]
4882 #[case::submitted(false, OrderStatus::Submitted)]
4883 #[case::accepted(true, OrderStatus::Accepted)]
4884 fn test_rejected_event_preserves_status_restoration(
4885 #[case] accepted_first: bool,
4886 #[case] restored_status: OrderStatus,
4887 ) {
4888 let init = OrderInitializedSpec::builder().build();
4889 let submitted = OrderSubmittedSpec::builder().build();
4890 let accepted = OrderAcceptedSpec::builder().build();
4891 let invalid = OrderSubmittedSpec::builder().build();
4892 let pending_update = OrderPendingUpdateSpec::builder().build();
4893 let modify_rejected = OrderModifyRejectedSpec::builder().build();
4894 let mut order: MarketOrder = init.try_into().unwrap();
4895 order.apply(OrderEventAny::Submitted(submitted)).unwrap();
4896 if accepted_first {
4897 order.apply(OrderEventAny::Accepted(accepted)).unwrap();
4898 }
4899
4900 let previous_status = order.previous_status();
4901
4902 let result = order.apply(OrderEventAny::Submitted(invalid));
4903
4904 assert!(matches!(result, Err(OrderError::InvalidStateTransition)));
4905 assert_eq!(order.previous_status(), previous_status);
4906
4907 order
4908 .apply(OrderEventAny::PendingUpdate(pending_update))
4909 .unwrap();
4910 order
4911 .apply(OrderEventAny::ModifyRejected(modify_rejected))
4912 .unwrap();
4913 assert_eq!(order.status(), restored_status);
4914 }
4915
4916 #[rstest]
4917 #[case(false, false)]
4918 #[case(false, true)]
4919 #[case(true, false)]
4920 #[case(true, true)]
4921 fn test_command_refusals_preserve_other_pending_commands(
4922 #[case] second_is_cancel: bool,
4923 #[case] first_denied_first: bool,
4924 #[values(false, true)] venue_rejected: bool,
4925 ) {
4926 let mut order = OrderTestBuilder::new(OrderType::Limit)
4927 .instrument_id(InstrumentId::test_default())
4928 .quantity(Quantity::from(10))
4929 .price(Price::from("98.00"))
4930 .submit(true)
4931 .build();
4932 order
4933 .apply(OrderEventAny::Accepted(
4934 OrderAcceptedSpec::builder().build(),
4935 ))
4936 .unwrap();
4937 let first = UUID4::new();
4938 let second = UUID4::new();
4939 let mut pending_first = OrderPendingUpdateSpec::builder().build();
4940 pending_first.causation_id = Some(first);
4941 order
4942 .apply(OrderEventAny::PendingUpdate(pending_first))
4943 .unwrap();
4944
4945 let second_kind = if second_is_cancel {
4946 let mut pending = OrderPendingCancelSpec::builder().build();
4947 pending.causation_id = Some(second);
4948 order.apply(OrderEventAny::PendingCancel(pending)).unwrap();
4949 OrderStatus::PendingCancel
4950 } else {
4951 let mut pending = OrderPendingUpdateSpec::builder().build();
4952 pending.causation_id = Some(second);
4953 order.apply(OrderEventAny::PendingUpdate(pending)).unwrap();
4954 OrderStatus::PendingUpdate
4955 };
4956
4957 let deny_first = OrderEventAny::ModifyDenied(
4958 OrderModifyDeniedSpec::builder().causation_id(first).build(),
4959 );
4960
4961 let deny_second = if second_is_cancel {
4962 OrderEventAny::CancelDenied(
4963 OrderCancelDeniedSpec::builder()
4964 .causation_id(second)
4965 .build(),
4966 )
4967 } else {
4968 OrderEventAny::ModifyDenied(
4969 OrderModifyDeniedSpec::builder()
4970 .causation_id(second)
4971 .build(),
4972 )
4973 };
4974
4975 let (deny_first, deny_second) = if venue_rejected {
4976 let first_event = OrderEventAny::ModifyRejected(OrderModifyRejected {
4977 causation_id: Some(first),
4978 ..OrderModifyRejectedSpec::builder().build()
4979 });
4980
4981 let second_event = if second_is_cancel {
4982 OrderEventAny::CancelRejected(OrderCancelRejected {
4983 causation_id: Some(second),
4984 ..OrderCancelRejectedSpec::builder().build()
4985 })
4986 } else {
4987 OrderEventAny::ModifyRejected(OrderModifyRejected {
4988 causation_id: Some(second),
4989 ..OrderModifyRejectedSpec::builder().build()
4990 })
4991 };
4992
4993 (first_event, second_event)
4994 } else {
4995 (deny_first, deny_second)
4996 };
4997
4998 let (first_event, second_event, remaining_status) = if first_denied_first {
4999 (deny_first, deny_second, second_kind)
5000 } else {
5001 (deny_second, deny_first, OrderStatus::PendingUpdate)
5002 };
5003
5004 order.apply(first_event).unwrap();
5005
5006 assert_eq!(order.status(), remaining_status);
5007 assert_eq!(
5008 order.has_pending_cancel_command(),
5009 second_is_cancel && first_denied_first
5010 );
5011
5012 let mut restored =
5013 OrderAny::from_events(order.events().into_iter().cloned().collect()).unwrap();
5014 assert_eq!(restored.status(), remaining_status);
5015 assert_eq!(
5016 restored.has_pending_cancel_command(),
5017 order.has_pending_cancel_command()
5018 );
5019 restored.apply(second_event.clone()).unwrap();
5020 order.apply(second_event).unwrap();
5021
5022 assert_eq!(order.status(), OrderStatus::Accepted);
5023 assert_eq!(order.quantity(), Quantity::from(10));
5024 assert_eq!(order.price(), Some(Price::from("98.00")));
5025 assert_eq!(order.filled_qty(), Quantity::zero(0));
5026 assert_eq!(order.leaves_qty(), Quantity::from(10));
5027 assert_eq!(order.ts_closed(), None);
5028 assert!(!order.has_pending_cancel_command());
5029 assert_eq!(
5030 serde_json::to_value(&restored).unwrap(),
5031 serde_json::to_value(&order).unwrap()
5032 );
5033 }
5034
5035 #[rstest]
5036 fn test_known_modify_outcome_preserves_legacy_pending_command(
5037 #[values(false, true)] legacy_cancel: bool,
5038 #[values(false, true)] updated: bool,
5039 ) {
5040 let mut order = OrderTestBuilder::new(OrderType::Limit)
5041 .instrument_id(InstrumentId::test_default())
5042 .quantity(Quantity::from(10))
5043 .price(Price::from("98.00"))
5044 .submit(true)
5045 .build();
5046 order
5047 .apply(OrderEventAny::Accepted(
5048 OrderAcceptedSpec::builder().build(),
5049 ))
5050 .unwrap();
5051 let cause = UUID4::new();
5052 let mut pending = OrderPendingUpdateSpec::builder().build();
5053 pending.causation_id = Some(cause);
5054 let legacy_status = if legacy_cancel {
5055 order.apply(OrderEventAny::PendingUpdate(pending)).unwrap();
5056 order
5057 .apply(OrderEventAny::PendingCancel(
5058 OrderPendingCancelSpec::builder().build(),
5059 ))
5060 .unwrap();
5061 OrderStatus::PendingCancel
5062 } else {
5063 order
5064 .apply(OrderEventAny::PendingUpdate(
5065 OrderPendingUpdateSpec::builder().build(),
5066 ))
5067 .unwrap();
5068 order.apply(OrderEventAny::PendingUpdate(pending)).unwrap();
5069 OrderStatus::PendingUpdate
5070 };
5071
5072 if updated {
5073 let mut event = OrderUpdatedSpec::builder()
5074 .quantity(Quantity::from(21))
5075 .price(Price::from("99.00"))
5076 .build();
5077 event.causation_id = Some(cause);
5078 order.apply(OrderEventAny::Updated(event)).unwrap();
5079 } else {
5080 order
5081 .apply(OrderEventAny::ModifyDenied(
5082 OrderModifyDeniedSpec::builder().causation_id(cause).build(),
5083 ))
5084 .unwrap();
5085 }
5086
5087 assert_eq!(order.status(), legacy_status);
5088 assert_eq!(order.has_pending_cancel_command(), legacy_cancel);
5089 let mut replayed =
5090 OrderAny::from_events(order.events().into_iter().cloned().collect()).unwrap();
5091
5092 let resolution = if legacy_cancel {
5093 OrderEventAny::CancelRejected(OrderCancelRejectedSpec::builder().build())
5094 } else {
5095 OrderEventAny::ModifyRejected(OrderModifyRejectedSpec::builder().build())
5096 };
5097
5098 replayed.apply(resolution.clone()).unwrap();
5099 order.apply(resolution).unwrap();
5100 assert_eq!(order.status(), OrderStatus::Accepted);
5101 assert_eq!(
5102 order.quantity(),
5103 Quantity::from(if updated { 21 } else { 10 })
5104 );
5105 assert_eq!(
5106 order.price(),
5107 Some(Price::from(if updated { "99.00" } else { "98.00" }))
5108 );
5109 assert_eq!(order.filled_qty(), Quantity::zero(0));
5110 assert_eq!(order.ts_closed(), None);
5111 assert_eq!(
5112 serde_json::to_value(&order).unwrap(),
5113 serde_json::to_value(&replayed).unwrap()
5114 );
5115 }
5116
5117 #[rstest]
5118 #[case(false)]
5119 #[case(true)]
5120 fn test_denied_command_preserves_intervening_fill(#[case] fully_filled: bool) {
5121 let mut order = OrderTestBuilder::new(OrderType::Limit)
5122 .instrument_id(InstrumentId::test_default())
5123 .quantity(Quantity::from(10))
5124 .price(Price::from("98.00"))
5125 .submit(true)
5126 .build();
5127 order
5128 .apply(OrderEventAny::Accepted(
5129 OrderAcceptedSpec::builder().build(),
5130 ))
5131 .unwrap();
5132 let command_id = UUID4::new();
5133 let mut pending = OrderPendingCancelSpec::builder().build();
5134 pending.causation_id = Some(command_id);
5135 order.apply(OrderEventAny::PendingCancel(pending)).unwrap();
5136 let filled_qty = Quantity::from(if fully_filled { 10 } else { 4 });
5137 order
5138 .apply(OrderEventAny::Filled(
5139 OrderFilledSpec::builder()
5140 .last_qty(filled_qty)
5141 .last_px(Price::from("97.50"))
5142 .build(),
5143 ))
5144 .unwrap();
5145 let closed = order.ts_closed();
5146 let previous = order.previous_status();
5147
5148 order
5149 .apply(OrderEventAny::CancelDenied(
5150 OrderCancelDeniedSpec::builder()
5151 .causation_id(command_id)
5152 .build(),
5153 ))
5154 .unwrap();
5155
5156 assert_eq!(
5157 order.status(),
5158 if fully_filled {
5159 OrderStatus::Filled
5160 } else {
5161 OrderStatus::PartiallyFilled
5162 }
5163 );
5164 assert_eq!(order.previous_status(), previous);
5165 assert_eq!(order.quantity(), Quantity::from(10));
5166 assert_eq!(order.price(), Some(Price::from("98.00")));
5167 assert_eq!(order.filled_qty(), filled_qty);
5168 assert_eq!(
5169 order.leaves_qty(),
5170 Quantity::from(if fully_filled { 0 } else { 6 })
5171 );
5172 assert_eq!(order.avg_px(), Some(dec!(97.50)));
5173 assert_eq!(order.ts_closed(), closed);
5174 assert!(!order.has_pending_cancel_command());
5175 }
5176
5177 #[rstest]
5178 #[case(false)]
5179 #[case(true)]
5180 fn test_denied_cancel_after_fill_void_resolves_only_current_lifecycle(
5181 #[case] filled_before_void: bool,
5182 ) {
5183 let mut order = OrderTestBuilder::new(OrderType::Limit)
5184 .instrument_id(InstrumentId::test_default())
5185 .quantity(Quantity::from(10))
5186 .price(Price::from("98.00"))
5187 .submit(true)
5188 .build();
5189 order
5190 .apply(OrderEventAny::Accepted(
5191 OrderAcceptedSpec::builder().build(),
5192 ))
5193 .unwrap();
5194 let first_command = UUID4::new();
5195 let mut pending = OrderPendingCancelSpec::builder().build();
5196 pending.causation_id = Some(first_command);
5197 order.apply(OrderEventAny::PendingCancel(pending)).unwrap();
5198 let fill_qty = Quantity::from(if filled_before_void { 10 } else { 4 });
5199 order
5200 .apply(OrderEventAny::Filled(
5201 OrderFilledSpec::builder()
5202 .order_type(OrderType::Limit)
5203 .last_qty(fill_qty)
5204 .last_px(Price::from("97.50"))
5205 .build(),
5206 ))
5207 .unwrap();
5208 order
5209 .apply(OrderEventAny::FillVoided(
5210 OrderFillVoidedSpec::builder()
5211 .order_type(OrderType::Limit)
5212 .voided_qty(fill_qty)
5213 .last_px(Price::from("97.50"))
5214 .is_reopened(true)
5215 .build(),
5216 ))
5217 .unwrap();
5218
5219 let denied_command = if filled_before_void {
5220 let command_id = UUID4::new();
5221 let mut pending = OrderPendingCancelSpec::builder().build();
5222 pending.causation_id = Some(command_id);
5223 order.apply(OrderEventAny::PendingCancel(pending)).unwrap();
5224 command_id
5225 } else {
5226 first_command
5227 };
5228
5229 order
5230 .apply(OrderEventAny::CancelDenied(
5231 OrderCancelDeniedSpec::builder()
5232 .causation_id(denied_command)
5233 .build(),
5234 ))
5235 .unwrap();
5236
5237 assert_eq!(order.status(), OrderStatus::Accepted);
5238 assert_eq!(order.quantity(), Quantity::from(10));
5239 assert_eq!(order.price(), Some(Price::from("98.00")));
5240 assert_eq!(order.filled_qty(), Quantity::zero(0));
5241 assert_eq!(order.leaves_qty(), Quantity::from(10));
5242 assert_eq!(order.ts_closed(), None);
5243 assert!(!order.has_pending_cancel_command());
5244 }
5245
5246 #[rstest]
5247 #[case(false)]
5248 #[case(true)]
5249 fn test_denied_command_does_not_restore_superseded_pending_status(#[case] triggered: bool) {
5250 let mut order = OrderTestBuilder::new(OrderType::StopLimit)
5251 .instrument_id(InstrumentId::test_default())
5252 .quantity(Quantity::from(10))
5253 .price(Price::from("98.00"))
5254 .trigger_price(Price::from("97.00"))
5255 .submit(true)
5256 .build();
5257 order
5258 .apply(OrderEventAny::Accepted(
5259 OrderAcceptedSpec::builder().build(),
5260 ))
5261 .unwrap();
5262 let first = UUID4::new();
5263
5264 let first_pending = if triggered {
5265 OrderEventAny::PendingUpdate(OrderPendingUpdate {
5266 causation_id: Some(first),
5267 ..OrderPendingUpdateSpec::builder().build()
5268 })
5269 } else {
5270 OrderEventAny::PendingCancel(OrderPendingCancel {
5271 causation_id: Some(first),
5272 ..OrderPendingCancelSpec::builder().build()
5273 })
5274 };
5275
5276 order.apply(first_pending).unwrap();
5277 let expected = if triggered {
5278 order
5279 .apply(OrderEventAny::Triggered(
5280 OrderTriggeredSpec::builder().build(),
5281 ))
5282 .unwrap();
5283 OrderStatus::Triggered
5284 } else {
5285 order
5286 .apply(OrderEventAny::Accepted(
5287 OrderAcceptedSpec::builder().build(),
5288 ))
5289 .unwrap();
5290 OrderStatus::Accepted
5291 };
5292
5293 let second = UUID4::new();
5294 order
5295 .apply(OrderEventAny::PendingCancel(OrderPendingCancel {
5296 causation_id: Some(second),
5297 ..OrderPendingCancelSpec::builder().build()
5298 }))
5299 .unwrap();
5300
5301 order
5302 .apply(OrderEventAny::CancelDenied(
5303 OrderCancelDeniedSpec::builder()
5304 .causation_id(second)
5305 .build(),
5306 ))
5307 .unwrap();
5308 assert_eq!(order.status(), expected);
5309 assert!(!order.has_pending_cancel_command());
5310 assert_eq!(order.quantity(), Quantity::from(10));
5311 assert_eq!(order.filled_qty(), Quantity::zero(0));
5312 }
5313
5314 #[rstest]
5315 fn test_denied_cancel_after_triggered_fill_void_preserves_triggered_status() {
5316 let mut order = OrderTestBuilder::new(OrderType::StopLimit)
5317 .instrument_id(InstrumentId::test_default())
5318 .quantity(Quantity::from(10))
5319 .price(Price::from("98.00"))
5320 .trigger_price(Price::from("97.00"))
5321 .submit(true)
5322 .build();
5323 order
5324 .apply(OrderEventAny::Accepted(
5325 OrderAcceptedSpec::builder().build(),
5326 ))
5327 .unwrap();
5328 order
5329 .apply(OrderEventAny::Triggered(
5330 OrderTriggeredSpec::builder().build(),
5331 ))
5332 .unwrap();
5333 let command_id = UUID4::new();
5334 order
5335 .apply(OrderEventAny::PendingCancel(OrderPendingCancel {
5336 causation_id: Some(command_id),
5337 ..OrderPendingCancelSpec::builder().build()
5338 }))
5339 .unwrap();
5340
5341 let fill = OrderFilledSpec::builder()
5342 .order_type(OrderType::StopLimit)
5343 .last_qty(Quantity::from(4))
5344 .last_px(Price::from("97.50"))
5345 .build();
5346 order.apply(OrderEventAny::Filled(fill.clone())).unwrap();
5347 order
5348 .apply(OrderEventAny::FillVoided(
5349 OrderFillVoidedSpec::builder()
5350 .trade_id(fill.trade_id)
5351 .order_type(OrderType::StopLimit)
5352 .last_px(fill.last_px)
5353 .voided_qty(fill.last_qty)
5354 .is_reopened(true)
5355 .build(),
5356 ))
5357 .unwrap();
5358 order
5359 .apply(OrderEventAny::CancelDenied(
5360 OrderCancelDeniedSpec::builder()
5361 .causation_id(command_id)
5362 .build(),
5363 ))
5364 .unwrap();
5365 assert_eq!(order.status(), OrderStatus::Triggered);
5366 assert_eq!(order.filled_qty(), Quantity::zero(0));
5367 assert_eq!(order.leaves_qty(), Quantity::from(10));
5368 assert_eq!(order.ts_closed(), None);
5369 assert!(!order.has_pending_cancel_command());
5370 }
5371
5372 #[rstest]
5373 fn test_command_update_preserves_another_pending_cancel() {
5374 let mut order = OrderTestBuilder::new(OrderType::Limit)
5375 .instrument_id(InstrumentId::test_default())
5376 .quantity(Quantity::from(10))
5377 .price(Price::from("98.00"))
5378 .submit(true)
5379 .build();
5380 order
5381 .apply(OrderEventAny::Accepted(
5382 OrderAcceptedSpec::builder().build(),
5383 ))
5384 .unwrap();
5385 let modify = UUID4::new();
5386 let cancel = UUID4::new();
5387 order
5388 .apply(OrderEventAny::PendingUpdate(OrderPendingUpdate {
5389 causation_id: Some(modify),
5390 ..OrderPendingUpdateSpec::builder().build()
5391 }))
5392 .unwrap();
5393
5394 order
5395 .apply(OrderEventAny::PendingCancel(OrderPendingCancel {
5396 causation_id: Some(cancel),
5397 ..OrderPendingCancelSpec::builder().build()
5398 }))
5399 .unwrap();
5400
5401 let update = OrderUpdated {
5402 causation_id: Some(modify),
5403 ..OrderUpdatedSpec::builder()
5404 .quantity(Quantity::from(11))
5405 .price(Price::from("99.00"))
5406 .build()
5407 };
5408
5409 order.apply(OrderEventAny::Updated(update)).unwrap();
5410 assert_eq!(order.status(), OrderStatus::PendingCancel);
5411 assert!(order.has_pending_cancel_command());
5412 order
5413 .apply(OrderEventAny::CancelDenied(
5414 OrderCancelDeniedSpec::builder()
5415 .causation_id(cancel)
5416 .build(),
5417 ))
5418 .unwrap();
5419 assert_eq!(order.status(), OrderStatus::Accepted);
5420 assert_eq!(order.quantity(), Quantity::from(11));
5421 assert_eq!(order.price(), Some(Price::from("99.00")));
5422 assert!(!order.has_pending_cancel_command());
5423 }
5424
5425 #[rstest]
5426 #[case(None)]
5427 #[case(Some(UUID4::new()))]
5428 fn test_denied_command_without_matching_causation_keeps_pending(
5429 #[case] causation_id: Option<UUID4>,
5430 ) {
5431 let mut order = OrderTestBuilder::new(OrderType::Limit)
5432 .instrument_id(InstrumentId::test_default())
5433 .quantity(Quantity::from(10))
5434 .price(Price::from("98.00"))
5435 .submit(true)
5436 .build();
5437 order
5438 .apply(OrderEventAny::Accepted(
5439 OrderAcceptedSpec::builder().build(),
5440 ))
5441 .unwrap();
5442 let mut pending = OrderPendingCancelSpec::builder().build();
5443 pending.causation_id = Some(UUID4::new());
5444 order.apply(OrderEventAny::PendingCancel(pending)).unwrap();
5445 let previous = order.previous_status();
5446
5447 order
5448 .apply(OrderEventAny::CancelDenied(
5449 OrderCancelDeniedSpec::builder()
5450 .maybe_causation_id(causation_id)
5451 .build(),
5452 ))
5453 .unwrap();
5454
5455 assert_eq!(order.status(), OrderStatus::PendingCancel);
5456 assert_eq!(order.previous_status(), previous);
5457 assert_eq!(order.quantity(), Quantity::from(10));
5458 assert_eq!(order.price(), Some(Price::from("98.00")));
5459 assert_eq!(order.ts_closed(), None);
5460 assert!(order.has_pending_cancel_command());
5461 }
5462
5463 #[rstest]
5464 #[case::submitted(OrderStatus::Submitted)]
5465 #[case::accepted(OrderStatus::Accepted)]
5466 #[case::partially_filled(OrderStatus::PartiallyFilled)]
5467 fn test_modify_rejected_after_venue_update(#[case] expected_status: OrderStatus) {
5468 let mut order = OrderTestBuilder::new(OrderType::Limit)
5469 .instrument_id(InstrumentId::test_default())
5470 .quantity(Quantity::from(10))
5471 .price(Price::from("98.00"))
5472 .build();
5473 order
5474 .apply(OrderEventAny::Submitted(
5475 OrderSubmittedSpec::builder().build(),
5476 ))
5477 .unwrap();
5478
5479 if expected_status != OrderStatus::Submitted {
5480 order
5481 .apply(OrderEventAny::Accepted(
5482 OrderAcceptedSpec::builder().build(),
5483 ))
5484 .unwrap();
5485 }
5486
5487 let filled_qty = if expected_status == OrderStatus::PartiallyFilled {
5488 order
5489 .apply(OrderEventAny::Filled(
5490 OrderFilledSpec::builder()
5491 .order_type(OrderType::Limit)
5492 .last_qty(Quantity::from(3))
5493 .build(),
5494 ))
5495 .unwrap();
5496 Quantity::from(3)
5497 } else {
5498 Quantity::from(0)
5499 };
5500
5501 order
5502 .apply(OrderEventAny::PendingUpdate(
5503 OrderPendingUpdateSpec::builder().build(),
5504 ))
5505 .unwrap();
5506 order
5507 .apply(OrderEventAny::Updated(
5508 OrderUpdatedSpec::builder()
5509 .quantity(Quantity::from(20))
5510 .price(Price::from("97.00"))
5511 .build(),
5512 ))
5513 .unwrap();
5514 assert_eq!(order.status(), expected_status);
5515 let previous_status = order.previous_status();
5516 let events_before = order.events().len();
5517
5518 let rejection = OrderEventAny::ModifyRejected(OrderModifyRejectedSpec::builder().build());
5519 order.apply(rejection.clone()).unwrap();
5520
5521 assert_eq!(order.status(), expected_status);
5522 assert_eq!(order.previous_status(), previous_status);
5523 assert_eq!(order.quantity(), Quantity::from(20));
5524 assert_eq!(order.price(), Some(Price::from("97.00")));
5525 assert_eq!(order.filled_qty(), filled_qty);
5526 assert_eq!(order.leaves_qty(), Quantity::from(20) - filled_qty);
5527 assert_eq!(order.events().len(), events_before + 1);
5528 assert_eq!(order.last_event(), &rejection);
5529 }
5530
5531 #[rstest]
5532 fn test_modify_rejected_preserves_triggered_with_stale_previous_status() {
5533 let mut order = OrderTestBuilder::new(OrderType::StopLimit)
5534 .instrument_id(InstrumentId::test_default())
5535 .quantity(Quantity::from(10))
5536 .price(Price::from("98.00"))
5537 .trigger_price(Price::from("99.00"))
5538 .build();
5539 order
5540 .apply(OrderEventAny::Submitted(
5541 OrderSubmittedSpec::builder().build(),
5542 ))
5543 .unwrap();
5544 order
5545 .apply(OrderEventAny::Accepted(
5546 OrderAcceptedSpec::builder().build(),
5547 ))
5548 .unwrap();
5549 order
5550 .apply(OrderEventAny::PendingUpdate(
5551 OrderPendingUpdateSpec::builder().build(),
5552 ))
5553 .unwrap();
5554 order
5555 .apply(OrderEventAny::Updated(
5556 OrderUpdatedSpec::builder()
5557 .quantity(Quantity::from(20))
5558 .price(Price::from("97.00"))
5559 .trigger_price(Price::from("98.00"))
5560 .build(),
5561 ))
5562 .unwrap();
5563 order
5564 .apply(OrderEventAny::Triggered(
5565 OrderTriggeredSpec::builder().build(),
5566 ))
5567 .unwrap();
5568 assert_eq!(order.status(), OrderStatus::Triggered);
5569 assert_eq!(order.previous_status(), Some(OrderStatus::Accepted));
5570
5571 let rejection = OrderEventAny::ModifyRejected(OrderModifyRejectedSpec::builder().build());
5572 order.apply(rejection.clone()).unwrap();
5573
5574 assert_eq!(order.status(), OrderStatus::Triggered);
5575 assert_eq!(order.quantity(), Quantity::from(20));
5576 assert_eq!(order.price(), Some(Price::from("97.00")));
5577 assert_eq!(order.trigger_price(), Some(Price::from("98.00")));
5578 assert_eq!(order.last_event(), &rejection);
5579 }
5580
5581 #[rstest]
5582 #[case::submitted(OrderStatus::Submitted)]
5583 #[case::accepted(OrderStatus::Accepted)]
5584 #[case::pending_update(OrderStatus::PendingUpdate)]
5585 #[case::pending_cancel(OrderStatus::PendingCancel)]
5586 fn test_modify_rejected_without_previous_status(#[case] status: OrderStatus) {
5587 let mut order: MarketOrder = OrderInitializedSpec::builder()
5588 .quantity(Quantity::from(10))
5589 .build()
5590 .try_into()
5591 .unwrap();
5592
5593 if status == OrderStatus::Submitted {
5594 order
5595 .apply(OrderEventAny::Submitted(
5596 OrderSubmittedSpec::builder().build(),
5597 ))
5598 .unwrap();
5599 } else {
5600 order
5601 .apply(OrderEventAny::Accepted(
5602 OrderAcceptedSpec::builder().build(),
5603 ))
5604 .unwrap();
5605 }
5606
5607 match status {
5608 OrderStatus::PendingUpdate => order
5609 .apply(OrderEventAny::PendingUpdate(
5610 OrderPendingUpdateSpec::builder().build(),
5611 ))
5612 .unwrap(),
5613 OrderStatus::PendingCancel => order
5614 .apply(OrderEventAny::PendingCancel(
5615 OrderPendingCancelSpec::builder().build(),
5616 ))
5617 .unwrap(),
5618 _ => {}
5619 }
5620
5621 order.previous_status = None;
5622 let events_before = order.events().len();
5623 let rejection = OrderEventAny::ModifyRejected(OrderModifyRejectedSpec::builder().build());
5624 let result = order.apply(rejection.clone());
5625
5626 if status == OrderStatus::PendingUpdate {
5627 assert!(matches!(result, Err(OrderError::NoPreviousState)));
5628 assert_eq!(order.events().len(), events_before);
5629 } else {
5630 result.unwrap();
5631 assert_eq!(order.last_event(), &rejection);
5632 }
5633
5634 assert_eq!(order.status(), status);
5635 assert_eq!(order.quantity(), Quantity::from(10));
5636 assert_eq!(order.previous_status(), None);
5637 }
5638
5639 #[rstest]
5640 #[case::submitted(false, OrderStatus::Submitted)]
5641 #[case::accepted(true, OrderStatus::Accepted)]
5642 fn test_modify_rejected_preserves_pending_cancel(
5643 #[case] accepted_first: bool,
5644 #[case] restored_status: OrderStatus,
5645 ) {
5646 let init = OrderInitializedSpec::builder().build();
5647 let submitted = OrderSubmittedSpec::builder().build();
5648 let accepted = OrderAcceptedSpec::builder().build();
5649 let pending_update = OrderPendingUpdateSpec::builder().build();
5650 let pending_cancel = OrderPendingCancelSpec::builder().build();
5651 let modify_rejected = OrderModifyRejectedSpec::builder().build();
5652 let cancel_rejected = OrderCancelRejectedSpec::builder().build();
5653 let mut order: MarketOrder = init.try_into().unwrap();
5654
5655 order.apply(OrderEventAny::Submitted(submitted)).unwrap();
5656 if accepted_first {
5657 order.apply(OrderEventAny::Accepted(accepted)).unwrap();
5658 }
5659
5660 order
5661 .apply(OrderEventAny::PendingUpdate(pending_update))
5662 .unwrap();
5663 order
5664 .apply(OrderEventAny::PendingCancel(pending_cancel))
5665 .unwrap();
5666 order
5667 .apply(OrderEventAny::ModifyRejected(modify_rejected))
5668 .unwrap();
5669
5670 assert_eq!(order.status(), OrderStatus::PendingCancel);
5671 assert_eq!(order.previous_status(), Some(restored_status));
5672
5673 order
5674 .apply(OrderEventAny::CancelRejected(cancel_rejected))
5675 .unwrap();
5676
5677 assert_eq!(order.status(), restored_status);
5678 }
5679
5680 #[rstest]
5681 fn test_modify_rejected_transition_matrix() {
5682 let event = OrderEventAny::ModifyRejected(OrderModifyRejectedSpec::builder().build());
5683
5684 for status in OrderStatus::iter() {
5685 let expected = matches!(
5686 status,
5687 OrderStatus::Submitted
5688 | OrderStatus::Accepted
5689 | OrderStatus::Triggered
5690 | OrderStatus::PartiallyFilled
5691 | OrderStatus::PendingUpdate
5692 | OrderStatus::PendingCancel
5693 );
5694 let mut current = status;
5695 let result = current.transition(&event);
5696
5697 if expected {
5698 assert_eq!(result.unwrap(), status, "status={status}");
5699 } else {
5700 assert!(
5701 matches!(result, Err(OrderError::InvalidStateTransition)),
5702 "status={status}"
5703 );
5704 }
5705
5706 assert_eq!(current, status);
5707 }
5708 }
5709
5710 #[rstest]
5711 fn test_cancel_rejected_transition_matrix() {
5712 let event = OrderEventAny::CancelRejected(OrderCancelRejectedSpec::builder().build());
5713
5714 for status in OrderStatus::iter() {
5715 let expected = match status {
5716 OrderStatus::Submitted
5717 | OrderStatus::Accepted
5718 | OrderStatus::Triggered
5719 | OrderStatus::PartiallyFilled
5720 | OrderStatus::PendingUpdate
5721 | OrderStatus::PendingCancel => Some(status),
5722 OrderStatus::Initialized
5723 | OrderStatus::Emulated
5724 | OrderStatus::Released
5725 | OrderStatus::Denied
5726 | OrderStatus::Rejected
5727 | OrderStatus::Canceled
5728 | OrderStatus::Expired
5729 | OrderStatus::Filled
5730 | OrderStatus::Voided => None,
5731 };
5732
5733 let mut current = status;
5734 let result = current.transition(&event);
5735
5736 if let Some(expected) = expected {
5737 assert_eq!(result.unwrap(), expected, "status={status}");
5738 } else {
5739 assert!(
5740 matches!(result, Err(OrderError::InvalidStateTransition)),
5741 "status={status}"
5742 );
5743 }
5744
5745 assert_eq!(current, status);
5746 }
5747 }
5748
5749 #[rstest]
5750 #[case::submitted(&[], OrderStatus::Submitted, false)]
5751 #[case::accepted(&[OrderStatus::Accepted], OrderStatus::Accepted, false)]
5752 #[case::pending_submitted(&[OrderStatus::PendingCancel], OrderStatus::Submitted, false)]
5753 #[case::pending_accepted(&[OrderStatus::Accepted, OrderStatus::PendingCancel], OrderStatus::Accepted, false)]
5754 #[case::acceptance_overtakes_submitted_cancel(&[OrderStatus::PendingCancel, OrderStatus::Accepted], OrderStatus::Accepted, false)]
5755 #[case::acceptance_overtakes_accepted_cancel(&[OrderStatus::Accepted, OrderStatus::PendingCancel, OrderStatus::Accepted], OrderStatus::Accepted, false)]
5756 #[case::triggered(&[OrderStatus::Accepted, OrderStatus::Triggered], OrderStatus::Triggered, false)]
5757 #[case::partially_filled(&[OrderStatus::Accepted, OrderStatus::PartiallyFilled], OrderStatus::PartiallyFilled, false)]
5758 #[case::pending_triggered(&[OrderStatus::Accepted, OrderStatus::Triggered, OrderStatus::PendingCancel], OrderStatus::Triggered, false)]
5759 #[case::pending_partially_filled(&[OrderStatus::Accepted, OrderStatus::PartiallyFilled, OrderStatus::PendingCancel], OrderStatus::PartiallyFilled, false)]
5760 #[case::fill_overtakes_cancel(&[OrderStatus::Accepted, OrderStatus::PendingCancel, OrderStatus::PartiallyFilled], OrderStatus::PartiallyFilled, false)]
5761 #[case::pending_update_accepted_updated(&[OrderStatus::Accepted, OrderStatus::PendingUpdate], OrderStatus::PendingUpdate, false)]
5762 #[case::pending_update_accepted_rejected(&[OrderStatus::Accepted, OrderStatus::PendingUpdate], OrderStatus::PendingUpdate, true)]
5763 #[case::pending_update_triggered_updated(&[OrderStatus::Accepted, OrderStatus::Triggered, OrderStatus::PendingUpdate], OrderStatus::PendingUpdate, false)]
5764 #[case::pending_update_triggered_rejected(&[OrderStatus::Accepted, OrderStatus::Triggered, OrderStatus::PendingUpdate], OrderStatus::PendingUpdate, true)]
5765 #[case::pending_update_partially_filled_updated(&[OrderStatus::Accepted, OrderStatus::PartiallyFilled, OrderStatus::PendingUpdate], OrderStatus::PendingUpdate, false)]
5766 #[case::pending_update_partially_filled_rejected(&[OrderStatus::Accepted, OrderStatus::PartiallyFilled, OrderStatus::PendingUpdate], OrderStatus::PendingUpdate, true)]
5767 fn test_cancel_rejected_preserves_order_state(
5768 #[case] statuses: &[OrderStatus],
5769 #[case] expected_status: OrderStatus,
5770 #[case] modify_rejected: bool,
5771 ) {
5772 let order_type = if statuses.contains(&OrderStatus::Triggered) {
5773 OrderType::StopLimit
5774 } else {
5775 OrderType::Market
5776 };
5777
5778 let mut order = OrderTestBuilder::new(order_type)
5779 .instrument_id(InstrumentId::test_default())
5780 .quantity(Quantity::from(100_000))
5781 .price(Price::from("1.00000"))
5782 .trigger_price(Price::from("1.00000"))
5783 .trigger_type(TriggerType::LastPrice)
5784 .build();
5785 order
5786 .apply(OrderEventAny::Submitted(
5787 OrderSubmittedSpec::builder().build(),
5788 ))
5789 .unwrap();
5790
5791 for status in statuses {
5792 let source_status = order.status();
5793
5794 let event = match status {
5795 OrderStatus::Accepted => {
5796 OrderEventAny::Accepted(OrderAcceptedSpec::builder().build())
5797 }
5798 OrderStatus::Triggered => {
5799 OrderEventAny::Triggered(OrderTriggeredSpec::builder().build())
5800 }
5801 OrderStatus::PartiallyFilled => OrderEventAny::Filled(
5802 OrderFilledSpec::builder()
5803 .order_type(order_type)
5804 .last_qty(Quantity::from(40_000))
5805 .build(),
5806 ),
5807 OrderStatus::PendingUpdate => {
5808 OrderEventAny::PendingUpdate(OrderPendingUpdateSpec::builder().build())
5809 }
5810 OrderStatus::PendingCancel => {
5811 OrderEventAny::PendingCancel(OrderPendingCancelSpec::builder().build())
5812 }
5813 _ => panic!("Unsupported setup status: {status}"),
5814 };
5815
5816 order.apply(event).unwrap();
5817
5818 let expected = if *status == OrderStatus::PartiallyFilled
5819 && source_status == OrderStatus::PendingCancel
5820 {
5821 OrderStatus::PendingCancel
5822 } else {
5823 *status
5824 };
5825
5826 assert_eq!(order.status(), expected);
5827 }
5828
5829 let previous_status = order.previous_status();
5830 let quantity = order.quantity();
5831 let filled_qty = order.filled_qty();
5832 let leaves_qty = order.leaves_qty();
5833 let venue_order_id = order.venue_order_id();
5834 let event_count = order.events().len();
5835 let cancel_rejected =
5836 OrderEventAny::CancelRejected(OrderCancelRejectedSpec::builder().build());
5837
5838 order.apply(cancel_rejected.clone()).unwrap();
5839
5840 assert_eq!(order.status(), expected_status);
5841 assert_eq!(order.previous_status(), previous_status);
5842 assert_eq!(order.quantity(), quantity);
5843 assert_eq!(order.filled_qty(), filled_qty);
5844 assert_eq!(order.leaves_qty(), leaves_qty);
5845 assert_eq!(order.venue_order_id(), venue_order_id);
5846 assert_eq!(order.events().len(), event_count + 1);
5847 assert_eq!(order.last_event(), &cancel_rejected);
5848
5849 if expected_status == OrderStatus::Submitted {
5850 order
5851 .apply(OrderEventAny::Accepted(
5852 OrderAcceptedSpec::builder().build(),
5853 ))
5854 .unwrap();
5855 assert_eq!(order.status(), OrderStatus::Accepted);
5856 }
5857
5858 if expected_status == OrderStatus::PendingUpdate {
5859 let restored_status = previous_status.unwrap();
5860
5861 let resolution = if modify_rejected {
5862 OrderEventAny::ModifyRejected(OrderModifyRejectedSpec::builder().build())
5863 } else {
5864 OrderEventAny::Updated(
5865 OrderUpdatedSpec::builder()
5866 .quantity(Quantity::from(80_000))
5867 .build(),
5868 )
5869 };
5870
5871 order.apply(resolution).unwrap();
5872
5873 assert_eq!(order.status(), restored_status);
5874 assert_eq!(order.previous_status(), previous_status);
5875 assert_eq!(
5876 order.quantity(),
5877 if modify_rejected {
5878 quantity
5879 } else {
5880 Quantity::from(80_000)
5881 }
5882 );
5883 assert_eq!(order.filled_qty(), filled_qty);
5884 assert_eq!(order.leaves_qty(), order.quantity() - filled_qty);
5885 assert_eq!(order.venue_order_id(), venue_order_id);
5886 }
5887
5888 order
5889 .apply(OrderEventAny::PendingCancel(
5890 OrderPendingCancelSpec::builder().build(),
5891 ))
5892 .unwrap();
5893 order
5894 .apply(OrderEventAny::Canceled(
5895 OrderCanceledSpec::builder().build(),
5896 ))
5897 .unwrap();
5898
5899 assert_eq!(order.status(), OrderStatus::Canceled);
5900 }
5901
5902 #[rstest]
5903 fn test_rejected_event_preserves_cancel_rejected_restoration() {
5904 let init = OrderInitializedSpec::builder().build();
5905 let submitted = OrderSubmittedSpec::builder().build();
5906 let accepted = OrderAcceptedSpec::builder().build();
5907 let invalid = OrderSubmittedSpec::builder().build();
5908 let pending_cancel = OrderPendingCancelSpec::builder().build();
5909 let cancel_rejected = OrderCancelRejectedSpec::builder().build();
5910 let mut order: MarketOrder = init.try_into().unwrap();
5911 order.apply(OrderEventAny::Submitted(submitted)).unwrap();
5912 order.apply(OrderEventAny::Accepted(accepted)).unwrap();
5913 let previous_status = order.previous_status();
5914
5915 let result = order.apply(OrderEventAny::Submitted(invalid));
5916
5917 assert!(matches!(result, Err(OrderError::InvalidStateTransition)));
5918 assert_eq!(order.previous_status(), previous_status);
5919
5920 order
5921 .apply(OrderEventAny::PendingCancel(pending_cancel))
5922 .unwrap();
5923 order
5924 .apply(OrderEventAny::CancelRejected(cancel_rejected))
5925 .unwrap();
5926 assert_eq!(order.status(), OrderStatus::Accepted);
5927 }
5928
5929 #[rstest]
5930 #[case(true, false, "client_order_id")]
5931 #[case(false, true, "strategy_id")]
5932 fn test_update_identity_mismatch_precedes_field_validation(
5933 #[case] wrong_client: bool,
5934 #[case] wrong_strategy: bool,
5935 #[case] expected_field: &str,
5936 ) {
5937 let init = OrderInitializedSpec::builder().build();
5938 let submitted = OrderSubmittedSpec::builder().build();
5939 let accepted = OrderAcceptedSpec::builder().build();
5940 let mut order: MarketOrder = init.try_into().unwrap();
5941 order.apply(OrderEventAny::Submitted(submitted)).unwrap();
5942 order.apply(OrderEventAny::Accepted(accepted)).unwrap();
5943 let state = (
5944 order.status(),
5945 order.previous_status(),
5946 order.ts_last(),
5947 order.events().len(),
5948 );
5949 let client_order_id = if wrong_client {
5950 ClientOrderId::from("O-INVALID")
5951 } else {
5952 order.client_order_id()
5953 };
5954 let strategy_id = if wrong_strategy {
5955 StrategyId::from("OTHER-001")
5956 } else {
5957 order.strategy_id()
5958 };
5959 let updated = OrderUpdatedSpec::builder()
5962 .client_order_id(client_order_id)
5963 .strategy_id(strategy_id)
5964 .price(Price::new(95.0, 2))
5965 .build();
5966
5967 let result = order.apply(OrderEventAny::Updated(updated));
5968
5969 let Err(OrderError::Invariant(CorrectnessError::PredicateViolation { message })) = result
5971 else {
5972 panic!("expected an identity predicate violation, was {result:?}");
5973 };
5974 assert!(
5975 message.contains(expected_field),
5976 "message did not name {expected_field}: {message}"
5977 );
5978 assert_eq!(order.status(), state.0);
5979 assert_eq!(order.previous_status(), state.1);
5980 assert_eq!(order.ts_last(), state.2);
5981 assert_eq!(order.events().len(), state.3);
5982 }
5983
5984 #[rstest]
5985 fn test_update_invalid_transition_precedes_field_validation() {
5986 let init = OrderInitializedSpec::builder().build();
5987 let denied = OrderDeniedSpec::builder().build();
5988 let mut order: MarketOrder = init.try_into().unwrap();
5989 order.apply(OrderEventAny::Denied(denied)).unwrap();
5990 let state = (
5991 order.status(),
5992 order.previous_status(),
5993 order.ts_last(),
5994 order.events().len(),
5995 );
5996 let updated = OrderUpdatedSpec::builder()
5999 .price(Price::new(95.0, 2))
6000 .build();
6001
6002 let result = order.apply(OrderEventAny::Updated(updated));
6003
6004 assert!(matches!(result, Err(OrderError::InvalidStateTransition)));
6005 assert_eq!(order.status(), state.0);
6006 assert_eq!(order.previous_status(), state.1);
6007 assert_eq!(order.ts_last(), state.2);
6008 assert_eq!(order.events().len(), state.3);
6009 }
6010
6011 #[rstest]
6012 fn test_direct_update_panics_on_invalid_field_before_mutation() {
6013 let init = OrderInitializedSpec::builder()
6014 .quantity(Quantity::from(100_000))
6015 .build();
6016 let mut order: MarketOrder = init.try_into().unwrap();
6017 let original_quantity = order.quantity();
6018 let updated = OrderUpdatedSpec::builder()
6023 .quantity(Quantity::from(50_000))
6024 .price(Price::new(95.0, 2))
6025 .build();
6026
6027 let result =
6028 std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| order.update(&updated)));
6029
6030 assert!(result.is_err());
6031 assert_eq!(order.quantity(), original_quantity);
6032 }
6033
6034 #[rstest]
6035 fn test_partially_filled_order_can_be_updated() {
6036 let init = OrderInitializedSpec::builder()
6039 .quantity(Quantity::from(100_000))
6040 .build();
6041 let submitted = OrderSubmittedSpec::builder().build();
6042 let accepted = OrderAcceptedSpec::builder().build();
6043 let partial_fill = OrderFilledSpec::builder()
6044 .last_qty(Quantity::from(40_000))
6045 .build();
6046 let updated = OrderUpdatedSpec::builder()
6047 .quantity(Quantity::from(80_000)) .build();
6049
6050 let mut order: MarketOrder = init.try_into().unwrap();
6051 order.apply(OrderEventAny::Submitted(submitted)).unwrap();
6052 order.apply(OrderEventAny::Accepted(accepted)).unwrap();
6053 order.apply(OrderEventAny::Filled(partial_fill)).unwrap();
6054
6055 assert_eq!(order.status(), OrderStatus::PartiallyFilled);
6056 assert_eq!(order.filled_qty(), Quantity::from(40_000));
6057
6058 order.apply(OrderEventAny::Updated(updated)).unwrap();
6059
6060 assert_eq!(order.status(), OrderStatus::PartiallyFilled);
6061 assert_eq!(order.quantity(), Quantity::from(80_000));
6062 assert_eq!(order.leaves_qty(), Quantity::from(40_000)); }
6064
6065 #[rstest]
6066 fn test_reconciliation_update_closes_order_at_filled_quantity() {
6067 let mut order: MarketOrder = OrderInitializedSpec::builder()
6068 .quantity(Quantity::from(100))
6069 .build()
6070 .try_into()
6071 .unwrap();
6072 order
6073 .apply(OrderEventAny::Accepted(
6074 OrderAcceptedSpec::builder().build(),
6075 ))
6076 .unwrap();
6077 order
6078 .apply(OrderEventAny::Filled(
6079 OrderFilledSpec::builder()
6080 .last_qty(Quantity::from(40))
6081 .build(),
6082 ))
6083 .unwrap();
6084 let updated = OrderEventAny::Updated(
6085 OrderUpdatedSpec::builder()
6086 .quantity(Quantity::from(40))
6087 .reconciliation(true)
6088 .ts_event(UnixNanos::from(5_000))
6089 .build(),
6090 );
6091
6092 order.apply(updated.clone()).unwrap();
6093 let replayed =
6094 OrderAny::from_events(order.events().into_iter().cloned().collect()).unwrap();
6095
6096 assert_eq!(order.status(), OrderStatus::Filled);
6097 assert_eq!(order.previous_status(), Some(OrderStatus::PartiallyFilled));
6098 assert_eq!(order.quantity(), Quantity::from(40));
6099 assert_eq!(order.filled_qty(), Quantity::from(40));
6100 assert_eq!(order.leaves_qty(), Quantity::from(0));
6101 assert_eq!(order.ts_closed(), Some(UnixNanos::from(5_000)));
6102 assert_eq!(order.ts_last(), UnixNanos::from(5_000));
6103 assert_eq!(order.event_count(), 4);
6104 assert_eq!(order.last_event(), &updated);
6105 assert_eq!(replayed.status(), order.status());
6106 assert_eq!(replayed.previous_status(), order.previous_status());
6107 assert_eq!(replayed.quantity(), order.quantity());
6108 assert_eq!(replayed.filled_qty(), order.filled_qty());
6109 assert_eq!(replayed.leaves_qty(), order.leaves_qty());
6110 assert_eq!(replayed.ts_closed(), order.ts_closed());
6111 assert_eq!(replayed.ts_last(), order.ts_last());
6112 }
6113
6114 #[rstest]
6115 fn test_triggered_order_can_be_updated() {
6116 let instrument_id = InstrumentId::from("ETHUSDT-LINEAR.BYBIT");
6119 let submitted = OrderSubmittedSpec::builder().build();
6120 let accepted = OrderAcceptedSpec::builder().build();
6121 let triggered = OrderTriggeredSpec::builder().build();
6122 let updated = OrderUpdatedSpec::builder()
6123 .quantity(Quantity::from(80_000))
6124 .build();
6125
6126 let mut order = OrderTestBuilder::new(OrderType::StopLimit)
6127 .instrument_id(instrument_id)
6128 .quantity(Quantity::from(100_000))
6129 .price(Price::from("0.99500"))
6130 .trigger_price(Price::from("1.00000"))
6131 .trigger_type(TriggerType::LastPrice)
6132 .build();
6133 order.apply(OrderEventAny::Submitted(submitted)).unwrap();
6134 order.apply(OrderEventAny::Accepted(accepted)).unwrap();
6135 order.apply(OrderEventAny::Triggered(triggered)).unwrap();
6136
6137 assert_eq!(order.status(), OrderStatus::Triggered);
6138
6139 order.apply(OrderEventAny::Updated(updated)).unwrap();
6140
6141 assert_eq!(order.status(), OrderStatus::Triggered);
6142 assert_eq!(order.quantity(), Quantity::from(80_000));
6143 }
6144
6145 #[rstest]
6146 fn test_order_updated_with_is_quote_quantity_clears_flag() {
6147 let init = OrderInitializedSpec::builder()
6148 .quantity(Quantity::new(10.0, 6))
6149 .quote_quantity(true)
6150 .build();
6151 let submitted = OrderSubmittedSpec::builder().build();
6152 let accepted = OrderAcceptedSpec::builder().build();
6153 let updated = OrderUpdatedSpec::builder()
6154 .quantity(Quantity::new(47.393_365, 6))
6155 .is_quote_quantity(false)
6156 .build();
6157
6158 let mut order: MarketOrder = init.try_into().unwrap();
6159 assert!(order.is_quote_quantity());
6160
6161 order.apply(OrderEventAny::Submitted(submitted)).unwrap();
6162 order.apply(OrderEventAny::Accepted(accepted)).unwrap();
6163 order.apply(OrderEventAny::Updated(updated)).unwrap();
6164
6165 assert!(!order.is_quote_quantity());
6166 assert_eq!(order.quantity(), Quantity::new(47.393_365, 6));
6167 assert_eq!(order.leaves_qty(), Quantity::new(47.393_365, 6));
6168 }
6169
6170 #[rstest]
6171 fn test_order_updated_default_is_quote_quantity_clears_flag() {
6172 let init = OrderInitializedSpec::builder()
6173 .quantity(Quantity::new(10.0, 6))
6174 .quote_quantity(true)
6175 .build();
6176 let submitted = OrderSubmittedSpec::builder().build();
6177 let accepted = OrderAcceptedSpec::builder().build();
6178 let updated = OrderUpdatedSpec::builder()
6180 .quantity(Quantity::new(8.0, 6))
6181 .build();
6182
6183 let mut order: MarketOrder = init.try_into().unwrap();
6184 assert!(order.is_quote_quantity());
6185
6186 order.apply(OrderEventAny::Submitted(submitted)).unwrap();
6187 order.apply(OrderEventAny::Accepted(accepted)).unwrap();
6188 order.apply(OrderEventAny::Updated(updated)).unwrap();
6189
6190 assert!(!order.is_quote_quantity());
6191 assert_eq!(order.quantity(), Quantity::new(8.0, 6));
6192 }
6193
6194 #[rstest]
6195 #[case::partial(40_000, OrderStatus::Expired, 10)]
6196 #[case::complete(100_000, OrderStatus::Filled, 20)]
6197 fn test_expired_order_receiving_fill(
6198 #[case] fill_qty: u64,
6199 #[case] expected_status: OrderStatus,
6200 #[case] closed_at: u64,
6201 ) {
6202 let mut order: LimitOrder = OrderInitializedSpec::builder()
6203 .order_type(OrderType::Limit)
6204 .quantity(Quantity::from(100_000))
6205 .price(Price::from("1.00000"))
6206 .time_in_force(TimeInForce::Gtd)
6207 .expire_time(UnixNanos::from(10))
6208 .build()
6209 .try_into()
6210 .unwrap();
6211 order
6212 .apply(OrderEventAny::Accepted(
6213 OrderAcceptedSpec::builder().build(),
6214 ))
6215 .unwrap();
6216 let expired = OrderEventAny::Expired(
6217 OrderExpiredSpec::builder()
6218 .ts_event(UnixNanos::from(10))
6219 .build(),
6220 );
6221 order.apply(expired).unwrap();
6222 let fill = OrderEventAny::Filled(
6223 OrderFilledSpec::builder()
6224 .order_type(OrderType::Limit)
6225 .last_qty(Quantity::from(fill_qty))
6226 .last_px(Price::from("1.25000"))
6227 .commission(Money::from("2 USD"))
6228 .ts_event(UnixNanos::from(20))
6229 .build(),
6230 );
6231 let mut persisted_events: Vec<_> = order.events().into_iter().cloned().collect();
6232 order.apply(fill.clone()).unwrap();
6233 persisted_events.push(order.last_event().clone());
6234 let repeated_expiry = OrderEventAny::Expired(
6235 OrderExpiredSpec::builder()
6236 .ts_event(UnixNanos::from(30))
6237 .build(),
6238 );
6239 order.apply(repeated_expiry.clone()).unwrap();
6240 persisted_events.push(order.last_event().clone());
6241 let replayed = OrderAny::from_events(persisted_events).unwrap();
6242
6243 assert_eq!(order.status(), expected_status);
6244 assert_eq!(order.filled_qty(), Quantity::from(fill_qty));
6245 assert_eq!(order.leaves_qty(), Quantity::from(100_000 - fill_qty));
6246 assert_eq!(order.avg_px(), Some(dec!(1.25)));
6247 assert_eq!(
6248 order.commissions().get(&Currency::USD()),
6249 Some(&Money::from("2 USD"))
6250 );
6251 assert_eq!(order.ts_closed(), Some(UnixNanos::from(closed_at)));
6252 assert_eq!(order.ts_last(), UnixNanos::from(20));
6253 assert_eq!(order.events().len(), 5);
6254 assert_eq!(order.last_event(), &repeated_expiry);
6255 assert_eq!(replayed.status(), expected_status);
6256 assert_eq!(replayed.filled_qty(), Quantity::from(fill_qty));
6257 assert_eq!(replayed.leaves_qty(), Quantity::from(100_000 - fill_qty));
6258 assert_eq!(replayed.avg_px(), Some(dec!(1.25)));
6259 assert_eq!(replayed.commissions(), order.commissions());
6260 assert_eq!(replayed.ts_closed(), Some(UnixNanos::from(closed_at)));
6261 assert_eq!(replayed.ts_last(), UnixNanos::from(20));
6262 assert_eq!(replayed.events(), order.events());
6263 assert!(matches!(
6264 order.apply(repeated_expiry),
6265 Err(OrderError::InvalidStateTransition)
6266 ));
6267 assert_eq!(order.events(), replayed.events());
6268 assert!(order.is_closed());
6269 assert!(!order.is_open());
6270 assert!(matches!(
6271 order.apply(fill),
6272 Err(OrderError::DuplicateFill(_))
6273 ));
6274 assert_eq!(order.filled_qty(), Quantity::from(fill_qty));
6275 }
6276
6277 #[rstest]
6278 fn test_expired_order_rejects_expiry_without_new_fill() {
6279 let mut order: MarketOrder = OrderInitializedSpec::builder().build().try_into().unwrap();
6280 order
6281 .apply(OrderEventAny::Accepted(
6282 OrderAcceptedSpec::builder().build(),
6283 ))
6284 .unwrap();
6285 order
6286 .apply(OrderEventAny::Expired(
6287 OrderExpiredSpec::builder()
6288 .ts_event(UnixNanos::from(10))
6289 .build(),
6290 ))
6291 .unwrap();
6292 let events: Vec<_> = order.events().into_iter().cloned().collect();
6293
6294 let result = order.apply(OrderEventAny::Expired(
6295 OrderExpiredSpec::builder()
6296 .ts_event(UnixNanos::from(30))
6297 .build(),
6298 ));
6299
6300 assert!(matches!(result, Err(OrderError::InvalidStateTransition)));
6301 assert_eq!(order.status(), OrderStatus::Expired);
6302 assert_eq!(order.ts_closed(), Some(UnixNanos::from(10)));
6303 assert_eq!(order.ts_last(), UnixNanos::from(10));
6304 assert_eq!(order.events(), events.iter().collect::<Vec<_>>());
6305 }
6306
6307 #[rstest]
6308 fn test_filled_order_rejects_expiry_without_prior_expiry() {
6309 let mut order: MarketOrder = OrderInitializedSpec::builder().build().try_into().unwrap();
6310 order
6311 .apply(OrderEventAny::Accepted(
6312 OrderAcceptedSpec::builder().build(),
6313 ))
6314 .unwrap();
6315 order
6316 .apply(OrderEventAny::Filled(OrderFilledSpec::builder().build()))
6317 .unwrap();
6318
6319 let result = order.apply(OrderEventAny::Expired(OrderExpiredSpec::builder().build()));
6320
6321 assert!(matches!(result, Err(OrderError::InvalidStateTransition)));
6322 assert_eq!(order.status(), OrderStatus::Filled);
6323 assert_eq!(order.filled_qty(), Quantity::from(100_000));
6324 assert_eq!(order.events().len(), 3);
6325 }
6326
6327 #[rstest]
6328 fn test_canceled_order_accepts_repeated_cancel_after_partial_fill() {
6329 let mut order: MarketOrder = OrderInitializedSpec::builder().build().try_into().unwrap();
6330 let submitted = OrderSubmittedSpec::builder().build();
6331 let accepted = OrderAcceptedSpec::builder().build();
6332 let canceled1 = OrderCanceledSpec::builder().build();
6333 let fill = OrderFilledSpec::builder()
6334 .last_qty(Quantity::from(50_000))
6335 .trade_id(TradeId::from("FILL-1"))
6336 .build();
6337 let canceled2 = OrderCanceledSpec::builder().build();
6338
6339 order.apply(OrderEventAny::Submitted(submitted)).unwrap();
6340 order.apply(OrderEventAny::Accepted(accepted)).unwrap();
6341 order.apply(OrderEventAny::Canceled(canceled1)).unwrap();
6342 assert_eq!(order.status(), OrderStatus::Canceled);
6343 assert!(order.is_closed());
6344
6345 order.apply(OrderEventAny::Filled(fill)).unwrap();
6346 assert_eq!(order.status(), OrderStatus::Canceled);
6347 assert_eq!(order.filled_qty(), Quantity::from(50_000));
6348 assert_eq!(order.leaves_qty(), Quantity::from(50_000));
6349 assert!(order.is_closed());
6350 assert!(!order.is_open());
6351
6352 order.apply(OrderEventAny::Canceled(canceled2)).unwrap();
6353 assert_eq!(order.status(), OrderStatus::Canceled);
6354 assert_eq!(order.filled_qty(), Quantity::from(50_000));
6355 assert_eq!(order.leaves_qty(), Quantity::from(50_000));
6356 assert_eq!(
6357 order
6358 .events()
6359 .iter()
6360 .filter(|event| matches!(event, OrderEventAny::Canceled(_)))
6361 .count(),
6362 2
6363 );
6364 assert!(order.is_closed());
6365 assert!(!order.is_open());
6366 }
6367
6368 #[rstest]
6369 fn test_updated_preserves_pending_cancel_after_fill() {
6370 let mut order: MarketOrder = OrderInitializedSpec::builder().build().try_into().unwrap();
6371 let submitted = OrderSubmittedSpec::builder().build();
6372 let accepted = OrderAcceptedSpec::builder().build();
6373 let pending_cancel = OrderPendingCancelSpec::builder().build();
6374 let fill = OrderFilledSpec::builder()
6375 .last_qty(Quantity::from(10_000))
6376 .build();
6377 let updated = OrderUpdatedSpec::builder()
6378 .quantity(Quantity::from(150_000))
6379 .build();
6380
6381 order.apply(OrderEventAny::Submitted(submitted)).unwrap();
6382 order.apply(OrderEventAny::Accepted(accepted)).unwrap();
6383 let ts_accepted = order.ts_accepted();
6384 let venue_order_ids: Vec<VenueOrderId> =
6385 order.venue_order_ids().into_iter().copied().collect();
6386 order
6387 .apply(OrderEventAny::PendingCancel(pending_cancel))
6388 .unwrap();
6389 order.apply(OrderEventAny::Filled(fill)).unwrap();
6390 assert_eq!(order.status(), OrderStatus::PendingCancel);
6391 assert_eq!(order.previous_status(), Some(OrderStatus::PartiallyFilled));
6392 order.apply(OrderEventAny::Updated(updated)).unwrap();
6393
6394 assert_eq!(order.status(), OrderStatus::PendingCancel);
6395 assert!(order.has_pending_cancel_command());
6396 assert_eq!(order.quantity(), Quantity::from(150_000));
6397 assert_eq!(order.filled_qty(), Quantity::from(10_000));
6398 assert_eq!(order.leaves_qty(), Quantity::from(140_000));
6399 assert_eq!(order.ts_accepted(), ts_accepted);
6400 assert_eq!(
6401 order
6402 .venue_order_ids()
6403 .into_iter()
6404 .copied()
6405 .collect::<Vec<_>>(),
6406 venue_order_ids,
6407 );
6408 }
6409
6410 #[rstest]
6411 fn test_apply_triggered_to_stop_market_order_returns_error() {
6412 let instrument_id = InstrumentId::from("ETHUSDT-LINEAR.BYBIT");
6413 let submitted = OrderSubmittedSpec::builder().build();
6414 let accepted = OrderAcceptedSpec::builder().build();
6415 let triggered = OrderTriggeredSpec::builder().build();
6416
6417 let mut order = OrderTestBuilder::new(OrderType::StopMarket)
6418 .instrument_id(instrument_id)
6419 .quantity(Quantity::from(1))
6420 .trigger_price(Price::from("1.00000"))
6421 .trigger_type(TriggerType::LastPrice)
6422 .build();
6423 order.apply(OrderEventAny::Submitted(submitted)).unwrap();
6424 order.apply(OrderEventAny::Accepted(accepted)).unwrap();
6425
6426 let result = order.apply(OrderEventAny::Triggered(triggered));
6427 assert!(result.is_err());
6428 assert_eq!(order.status(), OrderStatus::Accepted);
6429 }
6430
6431 #[rstest]
6432 fn test_apply_triggered_to_stop_limit_order_succeeds() {
6433 let instrument_id = InstrumentId::from("ETHUSDT-LINEAR.BYBIT");
6434 let submitted = OrderSubmittedSpec::builder().build();
6435 let accepted = OrderAcceptedSpec::builder().build();
6436 let triggered = OrderTriggeredSpec::builder().build();
6437
6438 let mut order = OrderTestBuilder::new(OrderType::StopLimit)
6439 .instrument_id(instrument_id)
6440 .quantity(Quantity::from(1))
6441 .price(Price::from("0.99500"))
6442 .trigger_price(Price::from("1.00000"))
6443 .trigger_type(TriggerType::LastPrice)
6444 .build();
6445 order.apply(OrderEventAny::Submitted(submitted)).unwrap();
6446 order.apply(OrderEventAny::Accepted(accepted)).unwrap();
6447 order.apply(OrderEventAny::Triggered(triggered)).unwrap();
6448
6449 assert_eq!(order.status(), OrderStatus::Triggered);
6450 }
6451
6452 #[rstest]
6453 fn test_to_order_status_report_for_accepted_limit_order() {
6454 let order = OrderTestBuilder::new(OrderType::Limit)
6455 .instrument_id(InstrumentId::from("AUDUSD.SIM"))
6456 .side(OrderSide::Buy)
6457 .quantity(Quantity::from(100_000))
6458 .price(Price::from("1.00000"))
6459 .build();
6460 let accepted = TestOrderStubs::make_accepted_order(&order);
6461
6462 let report = accepted.to_order_status_report(None).unwrap();
6463
6464 assert_eq!(report.account_id, AccountId::from("SIM-001"));
6465 assert_eq!(report.instrument_id, InstrumentId::from("AUDUSD.SIM"));
6466 assert_eq!(report.client_order_id, Some(accepted.client_order_id()));
6467 assert_eq!(report.venue_order_id, VenueOrderId::from("V-001"));
6468 assert_eq!(report.order_side, Some(OrderSide::Buy));
6469 assert_eq!(report.order_type, OrderType::Limit);
6470 assert_eq!(report.time_in_force, accepted.time_in_force());
6471 assert_eq!(report.order_status, OrderStatus::Accepted);
6472 assert_eq!(report.quantity, Quantity::from(100_000));
6473 assert_eq!(report.filled_qty, Quantity::from(0));
6474 assert_eq!(report.price, Some(Price::from("1.00000")));
6475 assert_eq!(report.avg_px, None);
6476 assert_eq!(report.ts_accepted, accepted.ts_accepted().unwrap());
6477 assert_eq!(report.ts_last, accepted.ts_last());
6478 assert_eq!(report.ts_init, accepted.ts_init());
6479 }
6480
6481 #[rstest]
6482 fn test_to_order_status_report_for_filled_market_order(audusd_sim: CurrencyPair) {
6483 let audusd_sim = InstrumentAny::CurrencyPair(audusd_sim);
6484 let order = OrderTestBuilder::new(OrderType::Market)
6485 .instrument_id(audusd_sim.id())
6486 .side(OrderSide::Buy)
6487 .quantity(Quantity::from(100_000))
6488 .build();
6489 let filled = TestOrderStubs::make_filled_order(&order, &audusd_sim, LiquiditySide::Maker);
6490 let report_id = UUID4::new();
6491
6492 let report = filled.to_order_status_report(Some(report_id)).unwrap();
6493
6494 assert_eq!(report.report_id, report_id);
6495 assert_eq!(report.order_status, OrderStatus::Filled);
6496 assert_eq!(report.quantity, Quantity::from(100_000));
6497 assert_eq!(report.filled_qty, Quantity::from(100_000));
6498 assert_eq!(report.price, None);
6499 assert_eq!(report.avg_px, Some(dec!(1)));
6500 assert_eq!(report.venue_position_id, Some(PositionId::from("1")));
6501 assert_eq!(report.ts_accepted, filled.ts_accepted().unwrap());
6502 assert_eq!(report.ts_last, filled.ts_last());
6503 }
6504
6505 #[rstest]
6506 fn test_to_order_status_report_maps_optional_fields() {
6507 let order = OrderTestBuilder::new(OrderType::StopLimit)
6508 .instrument_id(InstrumentId::from("AUDUSD.SIM"))
6509 .side(OrderSide::Sell)
6510 .quantity(Quantity::from(100_000))
6511 .price(Price::from("0.99500"))
6512 .trigger_price(Price::from("1.00000"))
6513 .trigger_type(TriggerType::LastPrice)
6514 .time_in_force(TimeInForce::Gtd)
6515 .expire_time(UnixNanos::from(5_000_000_000))
6516 .display_qty(Quantity::from(10_000))
6517 .post_only(true)
6518 .reduce_only(true)
6519 .contingency_type(ContingencyType::Oto)
6520 .order_list_id(OrderListId::from("OL-001"))
6521 .linked_order_ids(vec![ClientOrderId::from("O-CHILD")])
6522 .parent_order_id(ClientOrderId::from("O-PARENT"))
6523 .build();
6524 let accepted = TestOrderStubs::make_accepted_order(&order);
6525
6526 let report = accepted.to_order_status_report(None).unwrap();
6527
6528 assert_eq!(report.price, Some(Price::from("0.99500")));
6529 assert_eq!(report.trigger_price, Some(Price::from("1.00000")));
6530 assert_eq!(report.trigger_type, Some(TriggerType::LastPrice));
6531 assert_eq!(report.expire_time, Some(UnixNanos::from(5_000_000_000)));
6532 assert_eq!(report.display_qty, Some(Quantity::from(10_000)));
6533 assert!(report.post_only);
6534 assert!(report.reduce_only);
6535 assert_eq!(report.contingency_type, Some(ContingencyType::Oto));
6536 assert_eq!(report.order_list_id, Some(OrderListId::from("OL-001")));
6537 assert_eq!(
6538 report.linked_order_ids,
6539 Some(vec![ClientOrderId::from("O-CHILD")])
6540 );
6541 assert_eq!(
6542 report.parent_order_id,
6543 Some(ClientOrderId::from("O-PARENT"))
6544 );
6545 }
6546
6547 #[rstest]
6548 fn test_to_order_status_report_maps_ts_triggered() {
6549 let order = OrderTestBuilder::new(OrderType::StopLimit)
6550 .instrument_id(InstrumentId::from("AUDUSD.SIM"))
6551 .side(OrderSide::Buy)
6552 .quantity(Quantity::from(100_000))
6553 .price(Price::from("0.99500"))
6554 .trigger_price(Price::from("1.00000"))
6555 .trigger_type(TriggerType::LastPrice)
6556 .build();
6557 let mut order = TestOrderStubs::make_accepted_order(&order);
6558 let triggered = OrderTriggeredSpec::builder()
6559 .ts_event(UnixNanos::from(1_500_000_000))
6560 .build();
6561 order.apply(OrderEventAny::Triggered(triggered)).unwrap();
6562
6563 let report = order.to_order_status_report(None).unwrap();
6564
6565 assert_eq!(report.order_status, OrderStatus::Triggered);
6566 assert_eq!(report.ts_triggered, Some(UnixNanos::from(1_500_000_000)));
6567 }
6568
6569 #[rstest]
6570 fn test_to_order_status_report_maps_rejection_reason() {
6571 let order = OrderTestBuilder::new(OrderType::Limit)
6572 .instrument_id(InstrumentId::from("AUDUSD.SIM"))
6573 .side(OrderSide::Buy)
6574 .quantity(Quantity::from(100_000))
6575 .price(Price::from("1.00000"))
6576 .build();
6577 let mut order = TestOrderStubs::make_accepted_order(&order);
6578 let rejected = OrderRejectedSpec::builder()
6579 .reason(Ustr::from("INSUFFICIENT_MARGIN"))
6580 .build();
6581 order.apply(OrderEventAny::Rejected(rejected)).unwrap();
6582
6583 let report = order.to_order_status_report(None).unwrap();
6584
6585 assert_eq!(report.order_status, OrderStatus::Rejected);
6586 assert_eq!(
6587 report.cancel_reason,
6588 Some("INSUFFICIENT_MARGIN".to_string())
6589 );
6590 }
6591
6592 #[rstest]
6593 fn test_to_order_status_report_maps_distinct_timestamps() {
6594 let mut order = OrderTestBuilder::new(OrderType::Limit)
6595 .instrument_id(InstrumentId::from("AUDUSD.SIM"))
6596 .side(OrderSide::Buy)
6597 .quantity(Quantity::from(100_000))
6598 .price(Price::from("1.00000"))
6599 .ts_init(UnixNanos::from(1_000))
6600 .build();
6601 let submitted = OrderSubmittedSpec::builder()
6602 .ts_event(UnixNanos::from(2_000))
6603 .build();
6604 let accepted = OrderAcceptedSpec::builder()
6605 .ts_event(UnixNanos::from(3_000))
6606 .build();
6607 let filled = OrderFilledSpec::builder()
6608 .last_qty(Quantity::from(50_000))
6609 .ts_event(UnixNanos::from(4_000))
6610 .build();
6611 order.apply(OrderEventAny::Submitted(submitted)).unwrap();
6612 order.apply(OrderEventAny::Accepted(accepted)).unwrap();
6613 order.apply(OrderEventAny::Filled(filled)).unwrap();
6614
6615 let report = order.to_order_status_report(None).unwrap();
6616
6617 assert_eq!(report.order_status, OrderStatus::PartiallyFilled);
6618 assert_eq!(report.filled_qty, Quantity::from(50_000));
6619 assert_eq!(report.ts_accepted, UnixNanos::from(3_000));
6620 assert_eq!(report.ts_last, UnixNanos::from(4_000));
6621 assert_eq!(report.ts_init, UnixNanos::from(1_000));
6622 }
6623
6624 #[rstest]
6625 fn test_to_order_status_report_ts_accepted_falls_back_to_ts_last() {
6626 let mut order = OrderTestBuilder::new(OrderType::Limit)
6628 .instrument_id(InstrumentId::from("AUDUSD.SIM"))
6629 .side(OrderSide::Buy)
6630 .quantity(Quantity::from(100_000))
6631 .price(Price::from("1.00000"))
6632 .build();
6633 let submitted = OrderSubmittedSpec::builder()
6634 .ts_event(UnixNanos::from(2_000))
6635 .build();
6636 let updated = OrderUpdatedSpec::builder()
6637 .venue_order_id(VenueOrderId::from("V-001"))
6638 .ts_event(UnixNanos::from(3_000))
6639 .build();
6640 order.apply(OrderEventAny::Submitted(submitted)).unwrap();
6641 order.apply(OrderEventAny::Updated(updated)).unwrap();
6642
6643 let report = order.to_order_status_report(None).unwrap();
6644
6645 assert_eq!(report.order_status, OrderStatus::Submitted);
6646 assert_eq!(report.venue_order_id, VenueOrderId::from("V-001"));
6647 assert_eq!(report.ts_accepted, UnixNanos::from(3_000));
6648 assert_eq!(report.ts_last, UnixNanos::from(3_000));
6649 }
6650
6651 #[rstest]
6652 fn test_to_order_status_report_maps_trailing_offsets() {
6653 let order = OrderTestBuilder::new(OrderType::TrailingStopLimit)
6654 .instrument_id(InstrumentId::from("AUDUSD.SIM"))
6655 .side(OrderSide::Sell)
6656 .quantity(Quantity::from(100_000))
6657 .price(Price::from("0.99500"))
6658 .activation_price(Price::from("1.00500"))
6659 .trigger_price(Price::from("1.00000"))
6660 .trigger_type(TriggerType::LastPrice)
6661 .limit_offset(dec!(0.0001))
6662 .trailing_offset(dec!(0.0002))
6663 .trailing_offset_type(TrailingOffsetType::Price)
6664 .build();
6665 let accepted = TestOrderStubs::make_accepted_order(&order);
6666
6667 let report = accepted.to_order_status_report(None).unwrap();
6668
6669 assert_eq!(report.activation_price, Some(Price::from("1.00500")));
6670 assert_eq!(report.limit_offset, Some(dec!(0.0001)));
6671 assert_eq!(report.trailing_offset, Some(dec!(0.0002)));
6672 assert_eq!(report.trailing_offset_type, Some(TrailingOffsetType::Price),);
6673 }
6674
6675 #[rstest]
6676 fn test_to_order_status_report_returns_none_before_venue_ack() {
6677 let order = OrderTestBuilder::new(OrderType::Limit)
6678 .instrument_id(InstrumentId::from("AUDUSD.SIM"))
6679 .side(OrderSide::Buy)
6680 .quantity(Quantity::from(100_000))
6681 .price(Price::from("1.00000"))
6682 .build();
6683
6684 assert!(order.to_order_status_report(None).is_none());
6685 }
6686
6687 #[rstest]
6688 fn test_to_order_status_report_returns_none_for_submitted_order() {
6689 let mut order = OrderTestBuilder::new(OrderType::Limit)
6691 .instrument_id(InstrumentId::from("AUDUSD.SIM"))
6692 .side(OrderSide::Buy)
6693 .quantity(Quantity::from(100_000))
6694 .price(Price::from("1.00000"))
6695 .build();
6696 let submitted = OrderSubmittedSpec::builder().build();
6697 order.apply(OrderEventAny::Submitted(submitted)).unwrap();
6698
6699 assert!(order.account_id().is_some());
6700 assert!(order.to_order_status_report(None).is_none());
6701 }
6702}