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