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