1use std::{
17 fmt::Display,
18 ops::{Deref, DerefMut},
19};
20
21use indexmap::IndexMap;
22use nautilus_core::{
23 UUID4, UnixNanos,
24 correctness::{CorrectnessError, FAILED},
25};
26use rust_decimal::Decimal;
27use serde::{Deserialize, Serialize};
28use ustr::Ustr;
29
30use super::{Order, OrderAny, OrderCore, OrderError, check_time_in_force};
31use crate::{
32 enums::{
33 ContingencyType, LiquiditySide, OrderSide, OrderStatus, OrderType, PositionSide,
34 TimeInForce, TrailingOffsetType, TriggerType,
35 },
36 events::{OrderEventAny, OrderInitialized, OrderUpdated},
37 identifiers::{
38 AccountId, ClientOrderId, ExecAlgorithmId, InstrumentId, OrderListId, PositionId,
39 StrategyId, Symbol, TradeId, TraderId, Venue, VenueOrderId,
40 },
41 types::{Currency, Money, Price, Quantity, quantity::check_positive_quantity},
42};
43
44#[derive(Clone, Debug, Serialize, Deserialize)]
45#[cfg_attr(
46 feature = "python",
47 pyo3::pyclass(module = "nautilus_trader.model", from_py_object)
48)]
49#[cfg_attr(
50 feature = "python",
51 pyo3_stub_gen::derive::gen_stub_pyclass(module = "nautilus_trader.model")
52)]
53pub struct MarketIfTouchedOrder {
54 pub trigger_price: Price,
55 pub trigger_type: TriggerType,
56 pub expire_time: Option<UnixNanos>,
57 pub trigger_instrument_id: Option<InstrumentId>,
58 pub is_triggered: bool,
59 pub ts_triggered: Option<UnixNanos>,
60 core: OrderCore,
61}
62
63impl MarketIfTouchedOrder {
64 #[expect(clippy::too_many_arguments)]
73 pub fn new_checked(
74 trader_id: TraderId,
75 strategy_id: StrategyId,
76 instrument_id: InstrumentId,
77 client_order_id: ClientOrderId,
78 order_side: OrderSide,
79 quantity: Quantity,
80 trigger_price: Price,
81 trigger_type: TriggerType,
82 time_in_force: TimeInForce,
83 expire_time: Option<UnixNanos>,
84 reduce_only: bool,
85 quote_quantity: bool,
86 emulation_trigger: Option<TriggerType>,
87 trigger_instrument_id: Option<InstrumentId>,
88 contingency_type: Option<ContingencyType>,
89 order_list_id: Option<OrderListId>,
90 linked_order_ids: Option<Vec<ClientOrderId>>,
91 parent_order_id: Option<ClientOrderId>,
92 exec_algorithm_id: Option<ExecAlgorithmId>,
93 exec_algorithm_params: Option<IndexMap<Ustr, Ustr>>,
94 exec_spawn_id: Option<ClientOrderId>,
95 tags: Option<Vec<Ustr>>,
96 init_id: UUID4,
97 ts_init: UnixNanos,
98 ) -> Result<Self, OrderError> {
99 check_positive_quantity(quantity, stringify!(quantity))?;
100 check_time_in_force(time_in_force, expire_time)?;
101
102 let init_order = OrderInitialized::new_checked(
103 trader_id,
104 strategy_id,
105 instrument_id,
106 client_order_id,
107 order_side,
108 OrderType::MarketIfTouched,
109 quantity,
110 time_in_force,
111 false,
112 reduce_only,
113 quote_quantity,
114 false,
115 init_id,
116 ts_init,
117 ts_init,
118 None,
119 None,
120 Some(trigger_price),
121 Some(trigger_type),
122 None,
123 None,
124 None,
125 expire_time,
126 None,
127 emulation_trigger,
128 trigger_instrument_id,
129 contingency_type,
130 order_list_id,
131 linked_order_ids,
132 parent_order_id,
133 exec_algorithm_id,
134 exec_algorithm_params,
135 exec_spawn_id,
136 tags,
137 )?;
138
139 Ok(Self {
140 core: OrderCore::new(init_order),
141 trigger_price,
142 trigger_type,
143 expire_time,
144 trigger_instrument_id,
145 is_triggered: false,
146 ts_triggered: None,
147 })
148 }
149
150 #[expect(clippy::too_many_arguments)]
156 #[must_use]
157 pub fn new(
158 trader_id: TraderId,
159 strategy_id: StrategyId,
160 instrument_id: InstrumentId,
161 client_order_id: ClientOrderId,
162 order_side: OrderSide,
163 quantity: Quantity,
164 trigger_price: Price,
165 trigger_type: TriggerType,
166 time_in_force: TimeInForce,
167 expire_time: Option<UnixNanos>,
168 reduce_only: bool,
169 quote_quantity: bool,
170 emulation_trigger: Option<TriggerType>,
171 trigger_instrument_id: Option<InstrumentId>,
172 contingency_type: Option<ContingencyType>,
173 order_list_id: Option<OrderListId>,
174 linked_order_ids: Option<Vec<ClientOrderId>>,
175 parent_order_id: Option<ClientOrderId>,
176 exec_algorithm_id: Option<ExecAlgorithmId>,
177 exec_algorithm_params: Option<IndexMap<Ustr, Ustr>>,
178 exec_spawn_id: Option<ClientOrderId>,
179 tags: Option<Vec<Ustr>>,
180 init_id: UUID4,
181 ts_init: UnixNanos,
182 ) -> Self {
183 Self::new_checked(
184 trader_id,
185 strategy_id,
186 instrument_id,
187 client_order_id,
188 order_side,
189 quantity,
190 trigger_price,
191 trigger_type,
192 time_in_force,
193 expire_time,
194 reduce_only,
195 quote_quantity,
196 emulation_trigger,
197 trigger_instrument_id,
198 contingency_type,
199 order_list_id,
200 linked_order_ids,
201 parent_order_id,
202 exec_algorithm_id,
203 exec_algorithm_params,
204 exec_spawn_id,
205 tags,
206 init_id,
207 ts_init,
208 )
209 .unwrap_or_else(|e| panic!("{FAILED}: {e}"))
210 }
211}
212
213impl PartialEq for MarketIfTouchedOrder {
214 fn eq(&self, other: &Self) -> bool {
215 self.client_order_id == other.client_order_id
216 }
217}
218
219impl Deref for MarketIfTouchedOrder {
220 type Target = OrderCore;
221
222 fn deref(&self) -> &Self::Target {
223 &self.core
224 }
225}
226
227impl DerefMut for MarketIfTouchedOrder {
228 fn deref_mut(&mut self) -> &mut Self::Target {
229 &mut self.core
230 }
231}
232
233impl Order for MarketIfTouchedOrder {
234 fn into_any(self) -> OrderAny {
235 OrderAny::MarketIfTouched(self)
236 }
237
238 fn status(&self) -> OrderStatus {
239 self.status
240 }
241
242 fn trader_id(&self) -> TraderId {
243 self.trader_id
244 }
245
246 fn strategy_id(&self) -> StrategyId {
247 self.strategy_id
248 }
249
250 fn instrument_id(&self) -> InstrumentId {
251 self.instrument_id
252 }
253
254 fn symbol(&self) -> Symbol {
255 self.instrument_id.symbol
256 }
257
258 fn venue(&self) -> Venue {
259 self.instrument_id.venue
260 }
261
262 fn client_order_id(&self) -> ClientOrderId {
263 self.client_order_id
264 }
265
266 fn venue_order_id(&self) -> Option<VenueOrderId> {
267 self.venue_order_id
268 }
269
270 fn position_id(&self) -> Option<PositionId> {
271 self.position_id
272 }
273
274 fn account_id(&self) -> Option<AccountId> {
275 self.account_id
276 }
277
278 fn last_trade_id(&self) -> Option<TradeId> {
279 self.last_trade_id
280 }
281
282 fn order_side(&self) -> OrderSide {
283 self.side
284 }
285
286 fn order_type(&self) -> OrderType {
287 self.order_type
288 }
289
290 fn quantity(&self) -> Quantity {
291 self.quantity
292 }
293
294 fn time_in_force(&self) -> TimeInForce {
295 self.time_in_force
296 }
297
298 fn expire_time(&self) -> Option<UnixNanos> {
299 self.expire_time
300 }
301
302 fn price(&self) -> Option<Price> {
303 None
304 }
305
306 fn trigger_price(&self) -> Option<Price> {
307 Some(self.trigger_price)
308 }
309
310 fn trigger_type(&self) -> Option<TriggerType> {
311 Some(self.trigger_type)
312 }
313
314 fn liquidity_side(&self) -> Option<LiquiditySide> {
315 self.liquidity_side
316 }
317
318 fn is_post_only(&self) -> bool {
319 false
320 }
321
322 fn is_reduce_only(&self) -> bool {
323 self.is_reduce_only
324 }
325
326 fn is_quote_quantity(&self) -> bool {
327 self.is_quote_quantity
328 }
329
330 fn has_price(&self) -> bool {
331 false
332 }
333
334 fn display_qty(&self) -> Option<Quantity> {
335 None
336 }
337
338 fn limit_offset(&self) -> Option<Decimal> {
339 None
340 }
341
342 fn trailing_offset(&self) -> Option<Decimal> {
343 None
344 }
345
346 fn trailing_offset_type(&self) -> Option<TrailingOffsetType> {
347 None
348 }
349
350 fn emulation_trigger(&self) -> Option<TriggerType> {
351 self.emulation_trigger
352 }
353
354 fn trigger_instrument_id(&self) -> Option<InstrumentId> {
355 self.trigger_instrument_id
356 }
357
358 fn contingency_type(&self) -> Option<ContingencyType> {
359 self.contingency_type
360 }
361
362 fn order_list_id(&self) -> Option<OrderListId> {
363 self.order_list_id
364 }
365
366 fn linked_order_ids(&self) -> Option<&[ClientOrderId]> {
367 self.linked_order_ids.as_deref()
368 }
369
370 fn parent_order_id(&self) -> Option<ClientOrderId> {
371 self.parent_order_id
372 }
373
374 fn exec_algorithm_id(&self) -> Option<ExecAlgorithmId> {
375 self.exec_algorithm_id
376 }
377
378 fn exec_algorithm_params(&self) -> Option<&IndexMap<Ustr, Ustr>> {
379 self.exec_algorithm_params.as_ref()
380 }
381
382 fn exec_spawn_id(&self) -> Option<ClientOrderId> {
383 self.exec_spawn_id
384 }
385
386 fn tags(&self) -> Option<&[Ustr]> {
387 self.tags.as_deref()
388 }
389
390 fn filled_qty(&self) -> Quantity {
391 self.filled_qty
392 }
393
394 fn voided_qty(&self) -> Quantity {
395 self.voided_qty
396 }
397
398 fn non_reopened_voided_qty(&self) -> Quantity {
399 self.non_reopened_voided_qty
400 }
401
402 fn leaves_qty(&self) -> Quantity {
403 self.leaves_qty
404 }
405
406 fn overfill_qty(&self) -> Quantity {
407 self.overfill_qty
408 }
409
410 fn avg_px(&self) -> Option<Decimal> {
411 self.avg_px
412 }
413
414 fn slippage(&self) -> Option<Decimal> {
415 self.slippage
416 }
417
418 fn init_id(&self) -> UUID4 {
419 self.init_id
420 }
421
422 fn ts_init(&self) -> UnixNanos {
423 self.ts_init
424 }
425
426 fn ts_submitted(&self) -> Option<UnixNanos> {
427 self.ts_submitted
428 }
429
430 fn ts_accepted(&self) -> Option<UnixNanos> {
431 self.ts_accepted
432 }
433
434 fn ts_closed(&self) -> Option<UnixNanos> {
435 self.ts_closed
436 }
437
438 fn ts_last(&self) -> UnixNanos {
439 self.ts_last
440 }
441
442 fn has_pending_update_command(&self) -> bool {
443 self.core.has_pending_update_command()
444 }
445
446 fn has_pending_cancel_command(&self) -> bool {
447 self.core.has_pending_cancel_command()
448 }
449
450 fn events(&self) -> Vec<&OrderEventAny> {
451 self.events.iter().collect()
452 }
453
454 fn last_event(&self) -> &OrderEventAny {
455 self.events
456 .last()
457 .expect("Order invariant violated: no events")
458 }
459
460 fn commissions(&self) -> &IndexMap<Currency, Money> {
461 &self.commissions
462 }
463
464 fn venue_order_ids(&self) -> Vec<&VenueOrderId> {
465 self.venue_order_ids.iter().collect()
466 }
467
468 fn trade_ids(&self) -> Vec<&TradeId> {
469 self.trade_ids.iter().collect()
470 }
471
472 fn apply(&mut self, event: OrderEventAny) -> Result<(), OrderError> {
473 let updates_slippage = matches!(
474 event,
475 OrderEventAny::Filled(_) | OrderEventAny::FillVoided(_),
476 );
477 let is_order_triggered = matches!(event, OrderEventAny::Triggered(_));
478 let ts_event = if is_order_triggered {
479 Some(event.ts_event())
480 } else {
481 None
482 };
483
484 self.core.apply(event.clone())?;
485
486 if let OrderEventAny::Updated(ref event) = event {
487 self.update(event);
488 }
489
490 if is_order_triggered {
491 self.is_triggered = true;
492 self.ts_triggered = ts_event;
493 }
494
495 if updates_slippage {
496 self.core.set_slippage(self.trigger_price);
497 }
498
499 Ok(())
500 }
501
502 fn update(&mut self, event: &OrderUpdated) {
503 assert!(event.price.is_none(), "{}", OrderError::InvalidOrderEvent);
504
505 if let Some(trigger_price) = event.trigger_price {
506 self.trigger_price = trigger_price;
507 }
508
509 self.core.apply_updated_quantity(event.quantity);
510 }
511
512 fn is_triggered(&self) -> Option<bool> {
513 Some(self.is_triggered)
514 }
515
516 fn set_position_id(&mut self, position_id: Option<PositionId>) {
517 self.position_id = position_id;
518 }
519
520 fn set_quantity(&mut self, quantity: Quantity) {
521 self.quantity = quantity;
522 }
523
524 fn set_leaves_qty(&mut self, leaves_qty: Quantity) {
525 self.leaves_qty = leaves_qty;
526 }
527
528 fn set_emulation_trigger(&mut self, emulation_trigger: Option<TriggerType>) {
529 self.emulation_trigger = emulation_trigger;
530 }
531
532 fn set_is_quote_quantity(&mut self, is_quote_quantity: bool) {
533 self.is_quote_quantity = is_quote_quantity;
534 }
535
536 fn set_liquidity_side(&mut self, liquidity_side: LiquiditySide) {
537 self.liquidity_side = Some(liquidity_side);
538 }
539
540 fn would_reduce_only(&self, side: PositionSide, position_qty: Quantity) -> bool {
541 self.core.would_reduce_only(side, position_qty)
542 }
543
544 fn previous_status(&self) -> Option<OrderStatus> {
545 self.core.previous_status
546 }
547}
548
549impl TryFrom<OrderInitialized> for MarketIfTouchedOrder {
550 type Error = OrderError;
551
552 fn try_from(event: OrderInitialized) -> Result<Self, Self::Error> {
553 let trigger_price =
554 event
555 .trigger_price
556 .ok_or_else(|| CorrectnessError::PredicateViolation {
557 message:
558 "`trigger_price` is required for `MarketIfTouchedOrder` initialization"
559 .to_string(),
560 })?;
561 let trigger_type =
562 event
563 .trigger_type
564 .ok_or_else(|| CorrectnessError::PredicateViolation {
565 message: "`trigger_type` is required for `MarketIfTouchedOrder` initialization"
566 .to_string(),
567 })?;
568 let mut order = Self::new_checked(
569 event.trader_id,
570 event.strategy_id,
571 event.instrument_id,
572 event.client_order_id,
573 event.order_side,
574 event.quantity,
575 trigger_price,
576 trigger_type,
577 event.time_in_force,
578 event.expire_time,
579 event.reduce_only,
580 event.quote_quantity,
581 event.emulation_trigger,
582 event.trigger_instrument_id,
583 event.contingency_type,
584 event.order_list_id,
585 event.linked_order_ids,
586 event.parent_order_id,
587 event.exec_algorithm_id,
588 event.exec_algorithm_params,
589 event.exec_spawn_id,
590 event.tags,
591 event.event_id,
592 event.ts_event,
593 )?;
594 order.set_init_metadata(event.reconciliation, event.causation_id, event.ts_init);
595 Ok(order)
596 }
597}
598
599impl Display for MarketIfTouchedOrder {
600 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
601 write!(
602 f,
603 "MarketIfTouchedOrder(\
604 side={}, \
605 qty={}, \
606 instrument={}, \
607 tif={}, \
608 trigger_price={}, \
609 trigger_type={}, \
610 status={}\
611 )",
612 self.side,
613 self.quantity,
614 self.instrument_id,
615 self.time_in_force,
616 self.trigger_price,
617 self.trigger_type,
618 self.status
619 )
620 }
621}
622
623#[cfg(test)]
624mod tests {
625 use rstest::rstest;
626 use rust_decimal_macros::dec;
627
628 use super::*;
629 use crate::{
630 enums::{OrderSide, OrderType, TimeInForce, TriggerType},
631 events::order::spec::{OrderFilledSpec, OrderInitializedSpec},
632 identifiers::{InstrumentId, TradeId, VenueOrderId},
633 instruments::{CurrencyPair, stubs::*},
634 orders::{builder::OrderTestBuilder, stubs::TestOrderStubs},
635 types::{Price, Quantity},
636 };
637
638 #[rstest]
639 fn test_initialize(audusd_sim: CurrencyPair) {
640 let order = OrderTestBuilder::new(OrderType::MarketIfTouched)
641 .instrument_id(audusd_sim.id)
642 .side(OrderSide::Buy)
643 .trigger_price(Price::from("0.68000"))
644 .quantity(Quantity::from(1))
645 .build();
646
647 assert_eq!(order.trigger_price(), Some(Price::from("0.68000")));
648 assert_eq!(order.price(), None);
649
650 assert_eq!(order.time_in_force(), TimeInForce::Gtc);
651
652 assert_eq!(order.is_triggered(), Some(false));
653 assert_eq!(order.filled_qty(), Quantity::from(0));
654 assert_eq!(order.leaves_qty(), Quantity::from(1));
655
656 assert_eq!(order.display_qty(), None);
657 assert_eq!(order.trigger_instrument_id(), None);
658 assert_eq!(order.order_list_id(), None);
659 }
660
661 #[rstest]
662 fn test_display(audusd_sim: CurrencyPair) {
663 let order = OrderTestBuilder::new(OrderType::MarketIfTouched)
664 .instrument_id(audusd_sim.id)
665 .side(OrderSide::Buy)
666 .trigger_price(Price::from("30000"))
667 .trigger_type(TriggerType::LastPrice)
668 .quantity(Quantity::from(1))
669 .build();
670
671 assert_eq!(
672 order.to_string(),
673 "MarketIfTouchedOrder(\
674 side=BUY, \
675 qty=1, \
676 instrument=AUD/USD.SIM, \
677 tif=GTC, \
678 trigger_price=30000, \
679 trigger_type=LAST_PRICE, \
680 status=INITIALIZED\
681 )"
682 );
683 }
684
685 #[rstest]
686 #[should_panic(
687 expected = "Condition failed: invalid `Quantity` for 'quantity' not positive, was 0"
688 )]
689 fn test_quantity_zero(audusd_sim: CurrencyPair) {
690 let _ = OrderTestBuilder::new(OrderType::MarketIfTouched)
691 .instrument_id(audusd_sim.id)
692 .side(OrderSide::Buy)
693 .trigger_price(Price::from("30000"))
694 .trigger_type(TriggerType::LastPrice)
695 .quantity(Quantity::from(0))
696 .build();
697 }
698
699 #[rstest]
700 #[should_panic(expected = "Condition failed: `expire_time` is required for `GTD` order")]
701 fn test_gtd_without_expire(audusd_sim: CurrencyPair) {
702 let _ = OrderTestBuilder::new(OrderType::MarketIfTouched)
703 .instrument_id(audusd_sim.id)
704 .side(OrderSide::Buy)
705 .trigger_price(Price::from("30000"))
706 .trigger_type(TriggerType::LastPrice)
707 .quantity(Quantity::from(1))
708 .time_in_force(TimeInForce::Gtd)
709 .build();
710 }
711
712 #[rstest]
713 fn test_market_if_touched_order_update() {
714 let order = OrderTestBuilder::new(OrderType::MarketIfTouched)
716 .instrument_id(InstrumentId::from("BTC-USDT.BINANCE"))
717 .quantity(Quantity::from(10))
718 .trigger_price(Price::new(100.0, 2))
719 .build();
720
721 let mut accepted_order = TestOrderStubs::make_accepted_order(&order);
722
723 let updated_trigger_price = Price::new(95.0, 2);
725 let updated_quantity = Quantity::from(5);
726
727 let event = OrderUpdated {
728 client_order_id: accepted_order.client_order_id(),
729 strategy_id: accepted_order.strategy_id(),
730 trigger_price: Some(updated_trigger_price),
731 quantity: updated_quantity,
732 ..Default::default()
733 };
734
735 accepted_order.apply(OrderEventAny::Updated(event)).unwrap();
736
737 assert_eq!(accepted_order.quantity(), updated_quantity);
739 assert_eq!(accepted_order.trigger_price(), Some(updated_trigger_price));
740 }
741
742 #[rstest]
743 fn test_market_if_touched_order_rejects_invalid_update_atomically() {
744 let order = OrderTestBuilder::new(OrderType::MarketIfTouched)
745 .instrument_id(InstrumentId::from("BTC-USDT.BINANCE"))
746 .quantity(Quantity::from(10))
747 .trigger_price(Price::new(100.0, 2))
748 .build();
749 let mut accepted_order = TestOrderStubs::make_accepted_order(&order);
750 let state = (
751 accepted_order.status(),
752 accepted_order.previous_status(),
753 accepted_order.ts_last(),
754 accepted_order.events().len(),
755 );
756 let event = OrderUpdated {
757 client_order_id: accepted_order.client_order_id(),
758 strategy_id: accepted_order.strategy_id(),
759 price: Some(Price::new(95.0, 2)),
760 ..Default::default()
761 };
762
763 let result = accepted_order.apply(OrderEventAny::Updated(event));
764
765 assert!(matches!(result, Err(OrderError::InvalidOrderEvent)));
766 assert_eq!(accepted_order.status(), state.0);
767 assert_eq!(accepted_order.previous_status(), state.1);
768 assert_eq!(accepted_order.ts_last(), state.2);
769 assert_eq!(accepted_order.events().len(), state.3);
770 }
771
772 #[rstest]
773 fn test_market_if_touched_order_from_order_initialized() {
774 let order_initialized = OrderInitializedSpec::builder()
776 .trigger_price(Price::new(100.0, 2))
777 .trigger_type(TriggerType::Default)
778 .order_type(OrderType::MarketIfTouched)
779 .build();
780
781 let order: MarketIfTouchedOrder = order_initialized.clone().try_into().unwrap();
783
784 assert_eq!(order.trader_id(), order_initialized.trader_id);
786 assert_eq!(order.strategy_id(), order_initialized.strategy_id);
787 assert_eq!(order.instrument_id(), order_initialized.instrument_id);
788 assert_eq!(order.client_order_id(), order_initialized.client_order_id);
789 assert_eq!(order.order_side(), order_initialized.order_side);
790 assert_eq!(order.quantity(), order_initialized.quantity);
791
792 assert_eq!(
794 order.trigger_price,
795 order_initialized.trigger_price.unwrap()
796 );
797 assert_eq!(order.trigger_type, order_initialized.trigger_type.unwrap());
798 }
799
800 #[rstest]
801 fn test_market_if_touched_order_sets_slippage_when_filled() {
802 let order = OrderTestBuilder::new(OrderType::MarketIfTouched)
804 .instrument_id(InstrumentId::from("BTC-USDT.BINANCE"))
805 .quantity(Quantity::from(10))
806 .side(OrderSide::Buy) .trigger_price(Price::new(90.0, 2)) .build();
809
810 let mut accepted_order = TestOrderStubs::make_accepted_order(&order);
812
813 let fill_quantity = accepted_order.quantity(); let fill_price = Price::new(98.50, 2); let order_filled_event = OrderFilledSpec::builder()
818 .client_order_id(accepted_order.client_order_id())
819 .strategy_id(accepted_order.strategy_id())
820 .instrument_id(accepted_order.instrument_id())
821 .order_side(accepted_order.order_side())
822 .last_qty(fill_quantity)
823 .last_px(fill_price)
824 .venue_order_id(VenueOrderId::from("TEST-001"))
825 .trade_id(TradeId::from("TRADE-001"))
826 .build();
827
828 accepted_order
830 .apply(OrderEventAny::Filled(order_filled_event))
831 .unwrap();
832
833 assert_eq!(accepted_order.slippage(), Some(dec!(8.50)));
835 }
836}