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