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