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