1use std::collections::BTreeMap;
104
105use ahash::AHashMap;
106use nautilus_model::{
107 enums::{OrderSide, OrderType, TriggerType},
108 identifiers::{ClientOrderId, InstrumentId},
109 orders::{Order, OrderError, PassiveOrderAny, StopOrderAny},
110 types::Price,
111};
112use smallvec::SmallVec;
113
114const INLINE_ORDERS_PER_LEVEL: usize = 4;
118
119type OrderBucket = SmallVec<[RestingOrder; INLINE_ORDERS_PER_LEVEL]>;
120
121#[derive(Debug, Clone, Copy, PartialEq, Eq)]
123pub enum MatchAction {
124 FillLimit(ClientOrderId),
125 TriggerStop(ClientOrderId),
126}
127
128#[derive(Clone, Debug)]
131pub struct OrderMatchingCore {
132 pub instrument_id: InstrumentId,
134 pub price_increment: Price,
136 pub bid: Option<Price>,
138 pub ask: Option<Price>,
140 pub last: Option<Price>,
142 fill_limit_inside_spread: bool,
143 bid_limits: BTreeMap<Price, OrderBucket>,
144 ask_limits: BTreeMap<Price, OrderBucket>,
145 bid_stops: BTreeMap<Price, OrderBucket>,
146 ask_stops: BTreeMap<Price, OrderBucket>,
147 pending_bid: SmallVec<[RestingOrder; 2]>,
148 pending_ask: SmallVec<[RestingOrder; 2]>,
149 order_index: AHashMap<ClientOrderId, (OrderSide, Option<(BookKind, Price)>)>,
150 pub(crate) mark: Option<Price>,
151}
152
153impl OrderMatchingCore {
154 #[must_use]
156 pub fn new(instrument_id: InstrumentId, price_increment: Price) -> Self {
157 Self {
158 instrument_id,
159 price_increment,
160 bid: None,
161 ask: None,
162 last: None,
163 fill_limit_inside_spread: false,
164 bid_limits: BTreeMap::new(),
165 ask_limits: BTreeMap::new(),
166 bid_stops: BTreeMap::new(),
167 ask_stops: BTreeMap::new(),
168 pending_bid: SmallVec::new(),
169 pending_ask: SmallVec::new(),
170 order_index: AHashMap::new(),
171 mark: None,
172 }
173 }
174
175 #[must_use]
177 pub const fn price_precision(&self) -> u8 {
178 self.price_increment.precision
179 }
180
181 #[must_use]
183 pub fn get_order(&self, client_order_id: ClientOrderId) -> Option<&RestingOrder> {
184 let (side, location) = self.order_index.get(&client_order_id).copied()?;
185 let orders: &[RestingOrder] = if let Some((kind, price)) = location {
186 self.book_for(side, kind).get(&price)?
187 } else {
188 self.pending_for(side)
189 };
190
191 orders.iter().find(|o| o.client_order_id == client_order_id)
192 }
193
194 pub fn iter_bid_orders(&self) -> impl Iterator<Item = &RestingOrder> {
199 self.iter_bid_book_orders().chain(self.pending_bid.iter())
200 }
201
202 pub fn iter_ask_orders(&self) -> impl Iterator<Item = &RestingOrder> {
207 self.iter_ask_book_orders().chain(self.pending_ask.iter())
208 }
209
210 pub fn iter_orders(&self) -> impl Iterator<Item = &RestingOrder> {
214 self.iter_bid_orders().chain(self.iter_ask_orders())
215 }
216
217 #[must_use]
222 pub fn get_orders_bid(&self) -> Vec<RestingOrder> {
223 self.iter_bid_orders().copied().collect()
224 }
225
226 #[must_use]
231 pub fn get_orders_ask(&self) -> Vec<RestingOrder> {
232 self.iter_ask_orders().copied().collect()
233 }
234
235 #[must_use]
239 pub fn get_orders(&self) -> Vec<RestingOrder> {
240 self.iter_orders().copied().collect()
241 }
242
243 #[must_use]
245 pub fn order_exists(&self, client_order_id: ClientOrderId) -> bool {
246 self.order_index.contains_key(&client_order_id)
247 }
248
249 pub const fn set_last_raw(&mut self, last: Price) {
251 self.last = Some(last);
252 }
253
254 pub const fn set_bid_raw(&mut self, bid: Price) {
256 self.bid = Some(bid);
257 }
258
259 pub const fn set_ask_raw(&mut self, ask: Price) {
261 self.ask = Some(ask);
262 }
263
264 pub const fn update_price_increment(&mut self, price_increment: Price) {
266 self.price_increment = price_increment;
267 }
268
269 pub fn reset(&mut self) {
271 self.bid = None;
272 self.ask = None;
273 self.last = None;
274 self.mark = None;
275 self.bid_limits.clear();
276 self.ask_limits.clear();
277 self.bid_stops.clear();
278 self.ask_stops.clear();
279 self.pending_bid.clear();
280 self.pending_ask.clear();
281 self.order_index.clear();
282 }
283
284 pub fn add_order(&mut self, order: RestingOrder) {
304 debug_assert!(
305 !self.order_exists(order.client_order_id),
306 "duplicate add_order for {}; caller must delete before re-adding",
307 order.client_order_id,
308 );
309
310 let side = order.order_side;
311 let client_order_id = order.client_order_id;
312 let location = Self::locate(&order);
313
314 if let Some((kind, price)) = location {
315 let book = self.book_for_mut(side, kind);
316 book.entry(price).or_default().push(order);
317 } else {
318 self.pending_for_mut(side).push(order);
319 }
320 self.order_index.insert(client_order_id, (side, location));
321 }
322
323 pub fn delete_order(&mut self, client_order_id: ClientOrderId) -> Result<(), OrderError> {
334 let Some((side, location)) = self.order_index.remove(&client_order_id) else {
335 return Err(OrderError::NotFound(client_order_id));
336 };
337
338 if let Some((kind, price)) = location {
339 let book = self.book_for_mut(side, kind);
340 let bucket = book
341 .get_mut(&price)
342 .expect("order_index points to existing bucket");
343 let pos = bucket
344 .iter()
345 .position(|o| o.client_order_id == client_order_id)
346 .expect("order_index points to existing slot");
347
348 bucket.remove(pos);
349 if bucket.is_empty() {
350 book.remove(&price);
351 }
352 } else {
353 let pending = self.pending_for_mut(side);
354 let pos = pending
355 .iter()
356 .position(|o| o.client_order_id == client_order_id)
357 .expect("order_index points to existing pending slot");
358 pending.remove(pos);
359 }
360 Ok(())
361 }
362
363 pub fn iterate(&self) -> Vec<MatchAction> {
366 let mut actions = self.iterate_bids();
367 actions.extend(self.iterate_asks());
368 actions
369 }
370
371 pub fn iterate_bids(&self) -> Vec<MatchAction> {
374 self.bid_limits
375 .iter()
376 .rev()
377 .take_while(|(price, _)| self.is_limit_fillable(OrderSide::Buy, **price))
378 .flat_map(|(_, bucket)| bucket)
379 .chain(self.bid_stops.values().flatten())
380 .filter_map(|order| self.match_order(order))
381 .collect()
382 }
383
384 pub fn iterate_asks(&self) -> Vec<MatchAction> {
387 self.ask_limits
388 .iter()
389 .take_while(|(price, _)| self.is_limit_fillable(OrderSide::Sell, **price))
390 .flat_map(|(_, bucket)| bucket)
391 .chain(self.ask_stops.values().rev().flatten())
392 .filter_map(|order| self.match_order(order))
393 .collect()
394 }
395
396 pub fn match_order(&self, order: &RestingOrder) -> Option<MatchAction> {
399 if order.is_stop() {
400 self.match_stop_order(order)
401 } else if order.is_limit() {
402 self.match_limit_order(order)
403 } else {
404 None
405 }
406 }
407
408 #[must_use]
411 pub fn is_limit_matched(&self, side: OrderSide, price: Price) -> bool {
412 match side {
413 OrderSide::Buy => self.ask.is_some_and(|a| a <= price),
414 OrderSide::Sell => self.bid.is_some_and(|b| b >= price),
415 }
416 }
417
418 #[must_use]
421 pub fn is_stop_matched(&self, side: OrderSide, price: Price) -> bool {
422 self.is_stop_matched_with_trigger_type(side, price, TriggerType::BidAsk)
423 }
424
425 #[must_use]
426 pub(crate) fn is_stop_matched_with_trigger_type(
427 &self,
428 side: OrderSide,
429 price: Price,
430 trigger_type: TriggerType,
431 ) -> bool {
432 self.market_price_for_trigger(side, trigger_type)
433 .is_some_and(|market_price| match side {
434 OrderSide::Buy => market_price >= price,
435 OrderSide::Sell => market_price <= price,
436 })
437 }
438
439 #[must_use]
442 pub fn is_touch_triggered(&self, side: OrderSide, trigger_price: Price) -> bool {
443 self.is_touch_triggered_with_trigger_type(side, trigger_price, TriggerType::BidAsk)
444 }
445
446 #[must_use]
447 pub(crate) fn is_touch_triggered_with_trigger_type(
448 &self,
449 side: OrderSide,
450 trigger_price: Price,
451 trigger_type: TriggerType,
452 ) -> bool {
453 self.market_price_for_trigger(side, trigger_type)
454 .is_some_and(|market_price| match side {
455 OrderSide::Buy => market_price <= trigger_price,
456 OrderSide::Sell => market_price >= trigger_price,
457 })
458 }
459
460 pub fn set_fill_limit_inside_spread(&mut self, value: bool) {
462 self.fill_limit_inside_spread = value;
463 }
464
465 #[must_use]
471 pub fn is_limit_fillable(&self, side: OrderSide, price: Price) -> bool {
472 if self.is_limit_matched(side, price) {
474 return true;
475 }
476
477 if !self.fill_limit_inside_spread {
478 return false;
479 }
480
481 if let (Some(bid), Some(ask)) = (self.bid, self.ask) {
482 match side {
483 OrderSide::Buy => price >= bid,
484 OrderSide::Sell => price <= ask,
485 }
486 } else {
487 false
488 }
489 }
490
491 fn book_for(&self, side: OrderSide, kind: BookKind) -> &BTreeMap<Price, OrderBucket> {
492 match (side, kind) {
493 (OrderSide::Buy, BookKind::Limit) => &self.bid_limits,
494 (OrderSide::Buy, BookKind::Stop) => &self.bid_stops,
495 (OrderSide::Sell, BookKind::Limit) => &self.ask_limits,
496 (OrderSide::Sell, BookKind::Stop) => &self.ask_stops,
497 }
498 }
499
500 fn book_for_mut(
501 &mut self,
502 side: OrderSide,
503 kind: BookKind,
504 ) -> &mut BTreeMap<Price, OrderBucket> {
505 match (side, kind) {
506 (OrderSide::Buy, BookKind::Limit) => &mut self.bid_limits,
507 (OrderSide::Buy, BookKind::Stop) => &mut self.bid_stops,
508 (OrderSide::Sell, BookKind::Limit) => &mut self.ask_limits,
509 (OrderSide::Sell, BookKind::Stop) => &mut self.ask_stops,
510 }
511 }
512
513 fn pending_for(&self, side: OrderSide) -> &[RestingOrder] {
514 match side {
515 OrderSide::Buy => &self.pending_bid,
516 OrderSide::Sell => &self.pending_ask,
517 }
518 }
519
520 fn pending_for_mut(&mut self, side: OrderSide) -> &mut SmallVec<[RestingOrder; 2]> {
521 match side {
522 OrderSide::Buy => &mut self.pending_bid,
523 OrderSide::Sell => &mut self.pending_ask,
524 }
525 }
526
527 fn iter_bid_book_orders(&self) -> impl Iterator<Item = &RestingOrder> {
528 self.bid_limits
529 .values()
530 .rev()
531 .flatten()
532 .chain(self.bid_stops.values().flatten())
533 }
534
535 fn iter_ask_book_orders(&self) -> impl Iterator<Item = &RestingOrder> {
536 self.ask_limits
537 .values()
538 .flatten()
539 .chain(self.ask_stops.values().rev().flatten())
540 }
541
542 fn locate(order: &RestingOrder) -> Option<(BookKind, Price)> {
543 if let Some(price) = order.trigger_price {
544 Some((BookKind::Stop, price))
545 } else {
546 order.limit_price.map(|price| (BookKind::Limit, price))
547 }
548 }
549
550 fn match_limit_order(&self, order: &RestingOrder) -> Option<MatchAction> {
551 self.is_limit_fillable(order.order_side, order.limit_price?)
552 .then_some(MatchAction::FillLimit(order.client_order_id))
553 }
554
555 fn match_stop_order(&self, order: &RestingOrder) -> Option<MatchAction> {
556 if !order.is_activated {
557 return None;
558 }
559
560 let trigger_price = order.trigger_price?;
561 let trigger_type = order.trigger_type.unwrap_or(TriggerType::Default);
562
563 let is_triggered = match order.order_type {
564 OrderType::MarketIfTouched | OrderType::LimitIfTouched => self
565 .is_touch_triggered_with_trigger_type(
566 order.order_side,
567 trigger_price,
568 trigger_type,
569 ),
570 _ => self.is_stop_matched_with_trigger_type(
571 order.order_side,
572 trigger_price,
573 trigger_type,
574 ),
575 };
576
577 if is_triggered {
578 Some(MatchAction::TriggerStop(order.client_order_id))
579 } else {
580 None
581 }
582 }
583
584 fn market_price_for_trigger(
585 &self,
586 side: OrderSide,
587 trigger_type: TriggerType,
588 ) -> Option<Price> {
589 let quote_price = match side {
590 OrderSide::Buy => self.ask,
591 OrderSide::Sell => self.bid,
592 };
593
594 match trigger_type {
595 TriggerType::LastPrice => self.last,
596 TriggerType::MarkPrice => self.mark,
597 TriggerType::LastOrBidAsk => self.last.or(quote_price),
598 _ => quote_price,
599 }
600 }
601}
602
603#[derive(Clone, Copy, Debug, PartialEq, Eq)]
605pub struct RestingOrder {
606 pub client_order_id: ClientOrderId,
607 pub order_side: OrderSide,
608 pub order_type: OrderType,
609 pub trigger_type: Option<TriggerType>,
610 pub trigger_price: Option<Price>,
611 pub limit_price: Option<Price>,
612 pub is_activated: bool,
613}
614
615impl RestingOrder {
616 #[must_use]
623 pub const fn new(
624 client_order_id: ClientOrderId,
625 order_side: OrderSide,
626 order_type: OrderType,
627 trigger_price: Option<Price>,
628 limit_price: Option<Price>,
629 is_activated: bool,
630 ) -> Self {
631 Self::new_with_trigger_type(
632 client_order_id,
633 order_side,
634 order_type,
635 match trigger_price {
636 Some(_) => Some(TriggerType::Default),
637 None => None,
638 },
639 trigger_price,
640 limit_price,
641 is_activated,
642 )
643 }
644
645 #[must_use]
646 pub(crate) const fn new_with_trigger_type(
647 client_order_id: ClientOrderId,
648 order_side: OrderSide,
649 order_type: OrderType,
650 trigger_type: Option<TriggerType>,
651 trigger_price: Option<Price>,
652 limit_price: Option<Price>,
653 is_activated: bool,
654 ) -> Self {
655 Self {
656 client_order_id,
657 order_side,
658 order_type,
659 trigger_type,
660 trigger_price,
661 limit_price,
662 is_activated,
663 }
664 }
665
666 #[must_use]
668 pub const fn is_stop(&self) -> bool {
669 self.trigger_price.is_some()
670 }
671
672 #[must_use]
674 pub const fn is_limit(&self) -> bool {
675 self.limit_price.is_some() && self.trigger_price.is_none()
676 }
677}
678
679impl From<&PassiveOrderAny> for RestingOrder {
680 fn from(order: &PassiveOrderAny) -> Self {
681 match order {
682 PassiveOrderAny::Limit(limit) => Self {
683 client_order_id: limit.client_order_id(),
684 order_side: limit.order_side(),
685 order_type: limit.order_type(),
686 trigger_type: None,
687 trigger_price: None,
688 limit_price: Some(limit.limit_px()),
689 is_activated: true,
690 },
691 PassiveOrderAny::Stop(stop) => {
692 let limit_price = match stop {
693 StopOrderAny::LimitIfTouched(o) => Some(o.price),
694 StopOrderAny::StopLimit(o) => Some(o.price),
695 StopOrderAny::TrailingStopLimit(o) => o.price,
696 StopOrderAny::MarketIfTouched(_)
697 | StopOrderAny::StopMarket(_)
698 | StopOrderAny::TrailingStopMarket(_) => None,
699 };
700 let is_activated = match stop {
701 StopOrderAny::TrailingStopMarket(o) => o.is_activated,
702 StopOrderAny::TrailingStopLimit(o) => o.is_activated,
703 _ => true,
704 };
705 Self {
706 client_order_id: stop.client_order_id(),
707 order_side: stop.order_side(),
708 order_type: stop.order_type(),
709 trigger_type: Some(stop.trigger_type().unwrap_or(TriggerType::Default)),
710 trigger_price: stop.stop_px(),
711 limit_price,
712 is_activated,
713 }
714 }
715 }
716 }
717}
718
719#[derive(Debug, Clone, Copy, PartialEq, Eq)]
720enum BookKind {
721 Limit,
722 Stop,
723}
724
725#[cfg(test)]
726mod tests {
727 use nautilus_model::{
728 enums::{OrderSide, OrderType, TrailingOffsetType, TriggerType},
729 events::{OrderEventAny, OrderInitialized, order::spec::OrderInitializedSpec},
730 orders::{Order, OrderAny, builder::OrderTestBuilder},
731 types::Quantity,
732 };
733 use rstest::rstest;
734 use rust_decimal::Decimal;
735
736 use super::*;
737
738 fn create_matching_core(
739 instrument_id: InstrumentId,
740 price_increment: Price,
741 ) -> OrderMatchingCore {
742 OrderMatchingCore::new(instrument_id, price_increment)
743 }
744
745 #[rstest]
746 #[case::bid(OrderSide::Buy)]
747 #[case::ask(OrderSide::Sell)]
748 fn test_add_order_routes_to_side(#[case] side: OrderSide) {
749 let instrument_id = InstrumentId::from("AAPL.XNAS");
750 let mut matching_core = create_matching_core(instrument_id, Price::from("0.01"));
751
752 let order = OrderTestBuilder::new(OrderType::Limit)
753 .instrument_id(instrument_id)
754 .side(side)
755 .price(Price::from("100.00"))
756 .quantity(Quantity::from("100"))
757 .build();
758
759 let match_info = RestingOrder::from(&PassiveOrderAny::try_from(order).unwrap());
760 matching_core.add_order(match_info);
761
762 let (expected_bids, expected_asks) = match side {
763 OrderSide::Buy => (vec![match_info], vec![]),
764 OrderSide::Sell => (vec![], vec![match_info]),
765 };
766
767 assert_eq!(matching_core.get_orders_bid(), expected_bids);
768 assert_eq!(matching_core.get_orders_ask(), expected_asks);
769 assert!(matching_core.order_exists(match_info.client_order_id));
770 }
771
772 #[cfg(debug_assertions)]
773 #[rstest]
774 #[should_panic(expected = "duplicate add_order")]
775 fn test_add_order_with_duplicate_id_panics() {
776 let mut core = create_matching_core(InstrumentId::from("AAPL.XNAS"), Price::from("0.01"));
777 let order = limit_order(OrderSide::Buy, "100.00", "O-DUPLICATE");
778
779 core.add_order(order);
780 core.add_order(order);
781 }
782
783 #[rstest]
784 fn test_reset() {
785 let instrument_id = InstrumentId::from("AAPL.XNAS");
786 let mut matching_core = create_matching_core(instrument_id, Price::from("0.01"));
787
788 let orders = [
789 limit_order(OrderSide::Buy, "110.00", "O-B-LMT"),
790 stop_order(OrderSide::Buy, "101.00", "O-B-STP"),
791 pending_order(OrderSide::Buy, "O-B-PENDING"),
792 limit_order(OrderSide::Sell, "90.00", "O-A-LMT"),
793 stop_order(OrderSide::Sell, "99.00", "O-A-STP"),
794 pending_order(OrderSide::Sell, "O-A-PENDING"),
795 ];
796
797 for order in orders {
798 matching_core.add_order(order);
799 }
800 matching_core.set_bid_raw(Price::from("94.00"));
801 matching_core.set_ask_raw(Price::from("106.00"));
802 matching_core.set_last_raw(Price::from("100.00"));
803
804 assert_eq!(matching_core.get_orders(), orders);
805
806 matching_core.reset();
807
808 assert!(matching_core.bid.is_none());
809 assert!(matching_core.ask.is_none());
810 assert!(matching_core.last.is_none());
811 assert!(matching_core.get_orders_bid().is_empty());
812 assert!(matching_core.get_orders_ask().is_empty());
813 assert!(matching_core.get_orders().is_empty());
814 for order in orders {
815 assert_eq!(matching_core.get_order(order.client_order_id), None);
816 assert!(!matching_core.order_exists(order.client_order_id));
817 }
818
819 matching_core.set_bid_raw(Price::from("94.00"));
820 matching_core.set_ask_raw(Price::from("106.00"));
821
822 assert!(matching_core.iterate().is_empty());
823
824 for order in orders {
825 matching_core.add_order(order);
826 }
827
828 assert_eq!(matching_core.get_orders(), orders);
829 }
830
831 #[rstest]
832 fn test_delete_order_when_not_exists() {
833 let instrument_id = InstrumentId::from("AAPL.XNAS");
834 let mut matching_core = create_matching_core(instrument_id, Price::from("0.01"));
835
836 let order = OrderTestBuilder::new(OrderType::Limit)
837 .instrument_id(instrument_id)
838 .side(OrderSide::Buy)
839 .price(Price::from("100.00"))
840 .quantity(Quantity::from("100"))
841 .build();
842
843 let result = matching_core.delete_order(order.client_order_id());
844 assert!(result.is_err());
845 }
846
847 #[rstest]
848 #[case(OrderSide::Buy)]
849 #[case(OrderSide::Sell)]
850 fn test_delete_order_when_exists(#[case] order_side: OrderSide) {
851 let instrument_id = InstrumentId::from("AAPL.XNAS");
852 let mut matching_core = create_matching_core(instrument_id, Price::from("0.01"));
853
854 let order = OrderTestBuilder::new(OrderType::Limit)
855 .instrument_id(instrument_id)
856 .side(order_side)
857 .price(Price::from("100.00"))
858 .quantity(Quantity::from("100"))
859 .build();
860
861 let client_order_id = order.client_order_id();
862 let match_info = RestingOrder::from(&PassiveOrderAny::try_from(order).unwrap());
863 matching_core.add_order(match_info);
864 matching_core.delete_order(client_order_id).unwrap();
865
866 assert!(matching_core.get_orders_ask().is_empty());
867 assert!(matching_core.get_orders_bid().is_empty());
868 }
869
870 #[rstest]
871 #[case(None, None, Price::from("100.00"), OrderSide::Buy, false)]
872 #[case(None, None, Price::from("100.00"), OrderSide::Sell, false)]
873 #[case(
874 Some(Price::from("100.00")),
875 Some(Price::from("101.00")),
876 Price::from("100.00"),
877 OrderSide::Buy,
878 false
879 )]
880 #[case(
881 Some(Price::from("100.00")),
882 Some(Price::from("101.00")),
883 Price::from("101.00"),
884 OrderSide::Buy,
885 true
886 )]
887 #[case(
888 Some(Price::from("100.00")),
889 Some(Price::from("101.00")),
890 Price::from("102.00"),
891 OrderSide::Buy,
892 true
893 )]
894 #[case(
895 Some(Price::from("100.00")),
896 Some(Price::from("101.00")),
897 Price::from("101.00"),
898 OrderSide::Sell,
899 false
900 )]
901 #[case(
902 Some(Price::from("100.00")),
903 Some(Price::from("101.00")),
904 Price::from("100.00"),
905 OrderSide::Sell,
906 true
907 )]
908 #[case(
909 Some(Price::from("100.00")),
910 Some(Price::from("101.00")),
911 Price::from("99.00"),
912 OrderSide::Sell,
913 true
914 )]
915 fn test_is_limit_matched(
916 #[case] bid: Option<Price>,
917 #[case] ask: Option<Price>,
918 #[case] price: Price,
919 #[case] order_side: OrderSide,
920 #[case] expected: bool,
921 ) {
922 let instrument_id = InstrumentId::from("AAPL.XNAS");
923 let mut matching_core = create_matching_core(instrument_id, Price::from("0.01"));
924 matching_core.bid = bid;
925 matching_core.ask = ask;
926
927 let order = OrderTestBuilder::new(OrderType::Limit)
928 .instrument_id(instrument_id)
929 .side(order_side)
930 .price(price)
931 .quantity(Quantity::from("100"))
932 .build();
933
934 let result = matching_core.is_limit_matched(order.order_side(), order.price().unwrap());
935 assert_eq!(result, expected);
936 }
937
938 #[rstest]
939 #[case(None, None, Price::from("100.00"), OrderSide::Buy, false)]
940 #[case(None, None, Price::from("100.00"), OrderSide::Sell, false)]
941 #[case(
942 Some(Price::from("100.00")),
943 Some(Price::from("101.00")),
944 Price::from("102.00"),
945 OrderSide::Buy,
946 false
947 )]
948 #[case(
949 Some(Price::from("100.00")),
950 Some(Price::from("101.00")),
951 Price::from("101.00"),
952 OrderSide::Buy,
953 true
954 )]
955 #[case(
956 Some(Price::from("100.00")),
957 Some(Price::from("101.00")),
958 Price::from("100.00"),
959 OrderSide::Buy,
960 true
961 )]
962 #[case(
963 Some(Price::from("100.00")),
964 Some(Price::from("101.00")),
965 Price::from("99.00"),
966 OrderSide::Sell,
967 false
968 )]
969 #[case(
970 Some(Price::from("100.00")),
971 Some(Price::from("101.00")),
972 Price::from("100.00"),
973 OrderSide::Sell,
974 true
975 )]
976 #[case(
977 Some(Price::from("100.00")),
978 Some(Price::from("101.00")),
979 Price::from("101.00"),
980 OrderSide::Sell,
981 true
982 )]
983 fn test_is_stop_matched(
984 #[case] bid: Option<Price>,
985 #[case] ask: Option<Price>,
986 #[case] trigger_price: Price,
987 #[case] order_side: OrderSide,
988 #[case] expected: bool,
989 ) {
990 let instrument_id = InstrumentId::from("AAPL.XNAS");
991 let mut matching_core = create_matching_core(instrument_id, Price::from("0.01"));
992 matching_core.bid = bid;
993 matching_core.ask = ask;
994
995 let order = OrderTestBuilder::new(OrderType::StopMarket)
996 .instrument_id(instrument_id)
997 .side(order_side)
998 .trigger_price(trigger_price)
999 .quantity(Quantity::from("100"))
1000 .build();
1001
1002 let result =
1003 matching_core.is_stop_matched(order.order_side(), order.trigger_price().unwrap());
1004 assert_eq!(result, expected);
1005 }
1006
1007 #[rstest]
1008 #[case::last_price_below_trigger(Some(Price::from("99.00")), TriggerType::LastPrice, false)]
1009 #[case::last_price_at_trigger(Some(Price::from("100.00")), TriggerType::LastPrice, true)]
1010 #[case::last_price_unavailable(None, TriggerType::LastPrice, false)]
1011 #[case::last_or_bid_ask_prefers_last(
1012 Some(Price::from("99.00")),
1013 TriggerType::LastOrBidAsk,
1014 false
1015 )]
1016 #[case::last_or_bid_ask_falls_back_to_quote(None, TriggerType::LastOrBidAsk, true)]
1017 #[case::bid_ask_uses_quote(Some(Price::from("99.00")), TriggerType::BidAsk, true)]
1018 fn test_is_stop_matched_uses_trigger_type(
1019 #[case] last: Option<Price>,
1020 #[case] trigger_type: TriggerType,
1021 #[case] expected: bool,
1022 ) {
1023 let instrument_id = InstrumentId::from("AAPL.XNAS");
1024 let mut matching_core = create_matching_core(instrument_id, Price::from("0.01"));
1025 matching_core.ask = Some(Price::from("101.00"));
1026 matching_core.last = last;
1027
1028 let result = matching_core.is_stop_matched_with_trigger_type(
1029 OrderSide::Buy,
1030 Price::from("100.00"),
1031 trigger_type,
1032 );
1033
1034 assert_eq!(result, expected);
1035 }
1036
1037 #[rstest]
1038 #[case::missing(None, false)]
1039 #[case::safe(Some(Price::from("100.00")), false)]
1040 #[case::crossed(Some(Price::from("110.00")), true)]
1041 fn test_mark_price_trigger_ignores_quote_and_last(
1042 #[case] mark: Option<Price>,
1043 #[case] expected: bool,
1044 ) {
1045 let mut core = create_matching_core(InstrumentId::from("AAPL.XNAS"), Price::from("0.01"));
1046 core.bid = Some(Price::from("120.00"));
1047 core.ask = Some(Price::from("121.00"));
1048 core.last = Some(Price::from("122.00"));
1049 core.mark = mark;
1050 assert_eq!(
1051 core.is_stop_matched_with_trigger_type(
1052 OrderSide::Buy,
1053 Price::from("105.00"),
1054 TriggerType::MarkPrice
1055 ),
1056 expected
1057 );
1058 core.reset();
1059 assert_eq!(core.mark, None);
1060 }
1061
1062 #[rstest]
1063 fn test_iterate_returns_empty_when_no_orders() {
1064 let instrument_id = InstrumentId::from("AAPL.XNAS");
1065 let mut matching_core = create_matching_core(instrument_id, Price::from("0.01"));
1066 matching_core.set_bid_raw(Price::from("100.00"));
1067 matching_core.set_ask_raw(Price::from("101.00"));
1068
1069 let actions = matching_core.iterate();
1070
1071 assert!(actions.is_empty());
1072 }
1073
1074 #[rstest]
1075 fn test_iterate_returns_empty_when_no_market_data() {
1076 let instrument_id = InstrumentId::from("AAPL.XNAS");
1077 let mut matching_core = create_matching_core(instrument_id, Price::from("0.01"));
1078
1079 let order = OrderTestBuilder::new(OrderType::Limit)
1080 .instrument_id(instrument_id)
1081 .side(OrderSide::Buy)
1082 .price(Price::from("100.00"))
1083 .quantity(Quantity::from("100"))
1084 .build();
1085 let match_info = RestingOrder::from(&PassiveOrderAny::try_from(order).unwrap());
1086 matching_core.add_order(match_info);
1087
1088 let actions = matching_core.iterate();
1089
1090 assert!(actions.is_empty());
1091 }
1092
1093 #[rstest]
1094 #[case::buy(OrderSide::Buy)]
1095 #[case::sell(OrderSide::Sell)]
1096 fn test_iterate_returns_fill_limit_for_matched_order(#[case] side: OrderSide) {
1097 let instrument_id = InstrumentId::from("AAPL.XNAS");
1098 let mut matching_core = create_matching_core(instrument_id, Price::from("0.01"));
1099 match side {
1100 OrderSide::Buy => matching_core.set_ask_raw(Price::from("100.00")),
1101 OrderSide::Sell => matching_core.set_bid_raw(Price::from("100.00")),
1102 }
1103
1104 let order = OrderTestBuilder::new(OrderType::Limit)
1105 .instrument_id(instrument_id)
1106 .side(side)
1107 .price(Price::from("100.00"))
1108 .quantity(Quantity::from("100"))
1109 .build();
1110 let client_order_id = order.client_order_id();
1111 let match_info = RestingOrder::from(&PassiveOrderAny::try_from(order).unwrap());
1112 matching_core.add_order(match_info);
1113
1114 let actions = matching_core.iterate();
1115
1116 assert_eq!(actions, vec![MatchAction::FillLimit(client_order_id)]);
1117 }
1118
1119 #[rstest]
1120 fn test_iterate_returns_no_fill_for_unmatched_limit() {
1121 let instrument_id = InstrumentId::from("AAPL.XNAS");
1122 let mut matching_core = create_matching_core(instrument_id, Price::from("0.01"));
1123 matching_core.set_ask_raw(Price::from("101.00"));
1124
1125 let order = OrderTestBuilder::new(OrderType::Limit)
1126 .instrument_id(instrument_id)
1127 .side(OrderSide::Buy)
1128 .price(Price::from("100.00"))
1129 .quantity(Quantity::from("100"))
1130 .build();
1131 let match_info = RestingOrder::from(&PassiveOrderAny::try_from(order).unwrap());
1132 matching_core.add_order(match_info);
1133
1134 let actions = matching_core.iterate();
1135
1136 assert!(actions.is_empty());
1137 }
1138
1139 #[rstest]
1140 #[case::buy(OrderSide::Buy, "101.00")]
1141 #[case::sell(OrderSide::Sell, "99.00")]
1142 fn test_iterate_returns_trigger_stop_for_matched_order(
1143 #[case] side: OrderSide,
1144 #[case] price: &str,
1145 ) {
1146 let instrument_id = InstrumentId::from("AAPL.XNAS");
1147 let mut matching_core = create_matching_core(instrument_id, Price::from("0.01"));
1148 match side {
1149 OrderSide::Buy => matching_core.set_ask_raw(Price::from(price)),
1150 OrderSide::Sell => matching_core.set_bid_raw(Price::from(price)),
1151 }
1152
1153 let order = OrderTestBuilder::new(OrderType::StopMarket)
1154 .instrument_id(instrument_id)
1155 .side(side)
1156 .trigger_price(Price::from(price))
1157 .trigger_type(TriggerType::Default)
1158 .quantity(Quantity::from("100"))
1159 .build();
1160 let client_order_id = order.client_order_id();
1161 let match_info = RestingOrder::from(&PassiveOrderAny::try_from(order).unwrap());
1162 matching_core.add_order(match_info);
1163
1164 let actions = matching_core.iterate();
1165
1166 assert_eq!(actions, vec![MatchAction::TriggerStop(client_order_id)]);
1167 }
1168
1169 #[rstest]
1170 fn test_iterate_skips_unactivated_stop_order() {
1171 let instrument_id = InstrumentId::from("AAPL.XNAS");
1172 let mut matching_core = create_matching_core(instrument_id, Price::from("0.01"));
1173 matching_core.set_ask_raw(Price::from("110.00"));
1174
1175 let match_info = RestingOrder::new(
1176 ClientOrderId::from("O-001"),
1177 OrderSide::Buy,
1178 OrderType::TrailingStopMarket,
1179 Some(Price::from("105.00")),
1180 None,
1181 false,
1182 );
1183 matching_core.add_order(match_info);
1184
1185 let actions = matching_core.iterate();
1186
1187 assert!(actions.is_empty());
1188 }
1189
1190 #[rstest]
1191 fn test_iterate_triggers_activated_stop_order() {
1192 let instrument_id = InstrumentId::from("AAPL.XNAS");
1193 let mut matching_core = create_matching_core(instrument_id, Price::from("0.01"));
1194 matching_core.set_ask_raw(Price::from("110.00"));
1195
1196 let client_order_id = ClientOrderId::from("O-001");
1197 let match_info = RestingOrder::new(
1198 client_order_id,
1199 OrderSide::Buy,
1200 OrderType::TrailingStopMarket,
1201 Some(Price::from("105.00")),
1202 None,
1203 true,
1204 );
1205 matching_core.add_order(match_info);
1206
1207 let actions = matching_core.iterate();
1208
1209 assert_eq!(actions, vec![MatchAction::TriggerStop(client_order_id)]);
1210 }
1211
1212 #[rstest]
1213 #[case(false, "101.00", "99.00")]
1214 #[case(true, "99.00", "101.00")]
1215 fn test_iterate_returns_mixed_actions_for_limits_and_stops(
1216 #[case] fill_inside: bool,
1217 #[case] buy_price: &str,
1218 #[case] sell_price: &str,
1219 ) {
1220 let mut core = create_matching_core(InstrumentId::from("AAPL.XNAS"), Price::from("0.01"));
1221 core.set_bid_raw(Price::from("99.00"));
1222 core.set_ask_raw(Price::from("101.00"));
1223 core.set_fill_limit_inside_spread(fill_inside);
1224
1225 core.add_order(limit_order(OrderSide::Buy, "102.00", "O-BUY-BEST"));
1226 core.add_order(limit_order(OrderSide::Buy, buy_price, "O-BUY-LIMIT"));
1227 core.add_order(limit_order(OrderSide::Buy, "98.00", "O-BUY-MISS"));
1228 core.add_order(stop_order(OrderSide::Buy, "101.00", "O-BUY-STOP"));
1229 core.add_order(limit_order(OrderSide::Sell, "98.00", "O-SELL-BEST"));
1230 core.add_order(limit_order(OrderSide::Sell, sell_price, "O-SELL-LIMIT"));
1231 core.add_order(limit_order(OrderSide::Sell, "102.00", "O-SELL-MISS"));
1232 core.add_order(stop_order(OrderSide::Sell, "99.00", "O-SELL-STOP"));
1233
1234 let actions = core.iterate();
1235
1236 assert_eq!(
1237 actions,
1238 vec![
1239 MatchAction::FillLimit(ClientOrderId::from("O-BUY-BEST")),
1240 MatchAction::FillLimit(ClientOrderId::from("O-BUY-LIMIT")),
1241 MatchAction::TriggerStop(ClientOrderId::from("O-BUY-STOP")),
1242 MatchAction::FillLimit(ClientOrderId::from("O-SELL-BEST")),
1243 MatchAction::FillLimit(ClientOrderId::from("O-SELL-LIMIT")),
1244 MatchAction::TriggerStop(ClientOrderId::from("O-SELL-STOP")),
1245 ],
1246 );
1247 }
1248
1249 #[rstest]
1250 fn test_is_limit_fillable_delegates_to_is_limit_matched_by_default() {
1251 let instrument_id = InstrumentId::from("AAPL.XNAS");
1252 let mut core = create_matching_core(instrument_id, Price::from("0.01"));
1253 core.set_bid_raw(Price::from("100.00"));
1254 core.set_ask_raw(Price::from("101.00"));
1255
1256 assert!(core.is_limit_fillable(OrderSide::Buy, Price::from("101.00")));
1257 assert!(!core.is_limit_fillable(OrderSide::Buy, Price::from("100.00")));
1258 assert!(core.is_limit_fillable(OrderSide::Sell, Price::from("100.00")));
1259 assert!(!core.is_limit_fillable(OrderSide::Sell, Price::from("101.00")));
1260 }
1261
1262 #[rstest]
1263 #[case::buy_at_bid(OrderSide::Buy, "100.00", "99.00")]
1264 #[case::sell_at_ask(OrderSide::Sell, "101.00", "102.00")]
1265 fn test_is_limit_fillable_inside_spread_at_best_quote(
1266 #[case] side: OrderSide,
1267 #[case] best_quote: &str,
1268 #[case] outside_price: &str,
1269 ) {
1270 let instrument_id = InstrumentId::from("AAPL.XNAS");
1271 let mut core = create_matching_core(instrument_id, Price::from("0.01"));
1272 core.set_bid_raw(Price::from("100.00"));
1273 core.set_ask_raw(Price::from("101.00"));
1274 core.set_fill_limit_inside_spread(true);
1275
1276 assert!(core.is_limit_fillable(side, Price::from(best_quote)));
1277 assert!(core.is_limit_fillable(side, Price::from("100.50")));
1278 assert!(!core.is_limit_fillable(side, Price::from(outside_price)));
1279 }
1280
1281 #[rstest]
1282 fn test_is_limit_fillable_inside_spread_requires_both_quotes_present() {
1283 let instrument_id = InstrumentId::from("AAPL.XNAS");
1284 let mut core = create_matching_core(instrument_id, Price::from("0.01"));
1285 core.set_fill_limit_inside_spread(true);
1286
1287 core.set_bid_raw(Price::from("100.00"));
1288 assert!(!core.is_limit_fillable(OrderSide::Buy, Price::from("100.00")));
1289
1290 let mut core2 = create_matching_core(instrument_id, Price::from("0.01"));
1291 core2.set_fill_limit_inside_spread(true);
1292 core2.set_ask_raw(Price::from("101.00"));
1293 assert!(!core2.is_limit_fillable(OrderSide::Sell, Price::from("101.00")));
1294
1295 let mut core3 = create_matching_core(instrument_id, Price::from("0.01"));
1296 core3.set_fill_limit_inside_spread(true);
1297 core3.set_bid_raw(Price::from("100.00"));
1298 core3.set_ask_raw(Price::from("101.00"));
1299 core3.ask = None;
1300 assert!(!core3.is_limit_fillable(OrderSide::Buy, Price::from("100.00")));
1301 }
1302
1303 #[rstest]
1304 fn test_iterate_fills_limit_inside_spread_when_enabled() {
1305 let instrument_id = InstrumentId::from("AAPL.XNAS");
1306 let mut core = create_matching_core(instrument_id, Price::from("0.01"));
1307 core.set_bid_raw(Price::from("100.00"));
1308 core.set_ask_raw(Price::from("101.00"));
1309 core.set_fill_limit_inside_spread(true);
1310
1311 let order = OrderTestBuilder::new(OrderType::Limit)
1312 .instrument_id(instrument_id)
1313 .side(OrderSide::Buy)
1314 .price(Price::from("100.00"))
1315 .quantity(Quantity::from("100"))
1316 .build();
1317 let client_order_id = order.client_order_id();
1318 let match_info = RestingOrder::from(&PassiveOrderAny::try_from(order).unwrap());
1319 core.add_order(match_info);
1320
1321 let actions = core.iterate();
1322 assert_eq!(actions, vec![MatchAction::FillLimit(client_order_id)]);
1323 }
1324
1325 #[rstest]
1326 #[case(None, None, Price::from("100.00"), OrderSide::Buy, false)]
1327 #[case(None, None, Price::from("100.00"), OrderSide::Sell, false)]
1328 #[case(
1329 Some(Price::from("100.00")),
1330 Some(Price::from("101.00")),
1331 Price::from("102.00"),
1332 OrderSide::Buy,
1333 true
1334 )]
1335 #[case(
1336 Some(Price::from("100.00")),
1337 Some(Price::from("101.00")),
1338 Price::from("101.00"),
1339 OrderSide::Buy,
1340 true
1341 )]
1342 #[case(
1343 Some(Price::from("100.00")),
1344 Some(Price::from("101.00")),
1345 Price::from("100.00"),
1346 OrderSide::Buy,
1347 false
1348 )]
1349 #[case(
1350 Some(Price::from("100.00")),
1351 Some(Price::from("101.00")),
1352 Price::from("99.00"),
1353 OrderSide::Sell,
1354 true
1355 )]
1356 #[case(
1357 Some(Price::from("100.00")),
1358 Some(Price::from("101.00")),
1359 Price::from("100.00"),
1360 OrderSide::Sell,
1361 true
1362 )]
1363 #[case(
1364 Some(Price::from("100.00")),
1365 Some(Price::from("101.00")),
1366 Price::from("101.00"),
1367 OrderSide::Sell,
1368 false
1369 )]
1370 fn test_is_touch_triggered(
1371 #[case] bid: Option<Price>,
1372 #[case] ask: Option<Price>,
1373 #[case] trigger_price: Price,
1374 #[case] order_side: OrderSide,
1375 #[case] expected: bool,
1376 ) {
1377 let instrument_id = InstrumentId::from("AAPL.XNAS");
1378 let mut matching_core = create_matching_core(instrument_id, Price::from("0.01"));
1379 matching_core.bid = bid;
1380 matching_core.ask = ask;
1381
1382 let result = matching_core.is_touch_triggered(order_side, trigger_price);
1383 assert_eq!(result, expected);
1384 }
1385
1386 #[rstest]
1387 fn test_update_price_increment_updates_increment_and_precision() {
1388 let instrument_id = InstrumentId::from("AAPL.XNAS");
1389 let mut matching_core = create_matching_core(instrument_id, Price::from("0.01"));
1390
1391 assert_eq!(matching_core.price_increment, Price::from("0.01"));
1392 assert_eq!(matching_core.price_precision(), 2);
1393
1394 matching_core.update_price_increment(Price::from("0.001"));
1395
1396 assert_eq!(matching_core.price_increment, Price::from("0.001"));
1397 assert_eq!(matching_core.price_precision(), 3);
1398 }
1399
1400 fn order_from_init(spec: OrderInitialized) -> OrderAny {
1401 OrderAny::from_events(vec![OrderEventAny::Initialized(spec)]).unwrap()
1402 }
1403
1404 #[rstest]
1405 fn test_get_order_finds_orders_on_either_side() {
1406 let instrument_id = InstrumentId::from("AAPL.XNAS");
1407 let mut core = create_matching_core(instrument_id, Price::from("0.01"));
1408
1409 let buy = order_from_init(
1410 OrderInitializedSpec::builder()
1411 .instrument_id(instrument_id)
1412 .client_order_id(ClientOrderId::from("O-BUY"))
1413 .order_side(OrderSide::Buy)
1414 .order_type(OrderType::Limit)
1415 .quantity(Quantity::from("10"))
1416 .price(Price::from("100.00"))
1417 .build(),
1418 );
1419 let buy_id = buy.client_order_id();
1420 core.add_order(RestingOrder::from(&PassiveOrderAny::try_from(buy).unwrap()));
1421
1422 let sell = order_from_init(
1423 OrderInitializedSpec::builder()
1424 .instrument_id(instrument_id)
1425 .client_order_id(ClientOrderId::from("O-SELL"))
1426 .order_side(OrderSide::Sell)
1427 .order_type(OrderType::Limit)
1428 .quantity(Quantity::from("10"))
1429 .price(Price::from("101.00"))
1430 .build(),
1431 );
1432 let sell_id = sell.client_order_id();
1433 core.add_order(RestingOrder::from(
1434 &PassiveOrderAny::try_from(sell).unwrap(),
1435 ));
1436
1437 assert_eq!(
1438 core.get_order(buy_id).map(|o| o.client_order_id),
1439 Some(buy_id)
1440 );
1441 assert_eq!(
1442 core.get_order(sell_id).map(|o| o.client_order_id),
1443 Some(sell_id)
1444 );
1445 assert!(core.get_order(ClientOrderId::from("O-MISSING")).is_none());
1446 }
1447
1448 #[rstest]
1449 fn test_match_order_returns_none_when_neither_price_set() {
1450 let instrument_id = InstrumentId::from("AAPL.XNAS");
1451 let mut core = create_matching_core(instrument_id, Price::from("0.01"));
1452 core.set_bid_raw(Price::from("100.00"));
1453 core.set_ask_raw(Price::from("101.00"));
1454
1455 let info = RestingOrder::new(
1456 ClientOrderId::from("O-NEITHER"),
1457 OrderSide::Buy,
1458 OrderType::MarketToLimit,
1459 None,
1460 None,
1461 true,
1462 );
1463 assert!(core.match_order(&info).is_none());
1464 }
1465
1466 #[rstest]
1467 fn test_from_passive_order_extracts_limit_price_for_stop_limit() {
1468 let order = order_from_init(
1469 OrderInitializedSpec::builder()
1470 .order_type(OrderType::StopLimit)
1471 .order_side(OrderSide::Buy)
1472 .quantity(Quantity::from("10"))
1473 .price(Price::from("101.00"))
1474 .trigger_price(Price::from("100.00"))
1475 .trigger_type(TriggerType::Default)
1476 .build(),
1477 );
1478
1479 let info = RestingOrder::from(&PassiveOrderAny::try_from(order).unwrap());
1480
1481 assert_eq!(info.trigger_price, Some(Price::from("100.00")));
1482 assert_eq!(info.limit_price, Some(Price::from("101.00")));
1483 assert!(info.is_activated);
1484 }
1485
1486 #[rstest]
1487 fn test_from_passive_order_extracts_limit_price_for_limit_if_touched() {
1488 let order = order_from_init(
1489 OrderInitializedSpec::builder()
1490 .order_type(OrderType::LimitIfTouched)
1491 .order_side(OrderSide::Sell)
1492 .quantity(Quantity::from("10"))
1493 .price(Price::from("99.00"))
1494 .trigger_price(Price::from("100.00"))
1495 .trigger_type(TriggerType::LastPrice)
1496 .build(),
1497 );
1498
1499 let info = RestingOrder::from(&PassiveOrderAny::try_from(order).unwrap());
1500
1501 assert_eq!(info.trigger_price, Some(Price::from("100.00")));
1502 assert_eq!(info.limit_price, Some(Price::from("99.00")));
1503 assert_eq!(info.trigger_type, Some(TriggerType::LastPrice));
1504 assert!(info.is_activated);
1505 }
1506
1507 #[rstest]
1508 fn test_from_passive_order_extracts_is_activated_for_trailing_stop_market() {
1509 let order = order_from_init(
1510 OrderInitializedSpec::builder()
1511 .order_type(OrderType::TrailingStopMarket)
1512 .order_side(OrderSide::Buy)
1513 .quantity(Quantity::from("10"))
1514 .trigger_price(Price::from("101.00"))
1515 .trigger_type(TriggerType::Default)
1516 .trailing_offset(Decimal::from(1))
1517 .trailing_offset_type(TrailingOffsetType::Price)
1518 .build(),
1519 );
1520
1521 let info = RestingOrder::from(&PassiveOrderAny::try_from(order).unwrap());
1522
1523 assert_eq!(info.trigger_price, Some(Price::from("101.00")));
1524 assert_eq!(info.limit_price, None);
1525 assert!(!info.is_activated);
1526 }
1527
1528 #[rstest]
1529 fn test_from_passive_order_extracts_limit_and_is_activated_for_trailing_stop_limit() {
1530 let order = order_from_init(
1531 OrderInitializedSpec::builder()
1532 .order_type(OrderType::TrailingStopLimit)
1533 .order_side(OrderSide::Sell)
1534 .quantity(Quantity::from("10"))
1535 .price(Price::from("99.00"))
1536 .trigger_price(Price::from("100.00"))
1537 .trigger_type(TriggerType::Default)
1538 .limit_offset(Decimal::from(1))
1539 .trailing_offset(Decimal::from(1))
1540 .trailing_offset_type(TrailingOffsetType::Price)
1541 .build(),
1542 );
1543
1544 let info = RestingOrder::from(&PassiveOrderAny::try_from(order).unwrap());
1545
1546 assert_eq!(info.trigger_price, Some(Price::from("100.00")));
1547 assert_eq!(info.limit_price, Some(Price::from("99.00")));
1548 assert!(!info.is_activated);
1549 }
1550
1551 fn limit_order(side: OrderSide, price: &str, id: &str) -> RestingOrder {
1552 let order = order_from_init(
1553 OrderInitializedSpec::builder()
1554 .client_order_id(ClientOrderId::from(id))
1555 .order_type(OrderType::Limit)
1556 .order_side(side)
1557 .quantity(Quantity::from("10"))
1558 .price(Price::from(price))
1559 .build(),
1560 );
1561 RestingOrder::from(&PassiveOrderAny::try_from(order).unwrap())
1562 }
1563
1564 fn stop_order(side: OrderSide, trigger: &str, id: &str) -> RestingOrder {
1565 let order = order_from_init(
1566 OrderInitializedSpec::builder()
1567 .client_order_id(ClientOrderId::from(id))
1568 .order_type(OrderType::StopMarket)
1569 .order_side(side)
1570 .quantity(Quantity::from("10"))
1571 .trigger_price(Price::from(trigger))
1572 .trigger_type(TriggerType::Default)
1573 .build(),
1574 );
1575 RestingOrder::from(&PassiveOrderAny::try_from(order).unwrap())
1576 }
1577
1578 fn stop_limit_order(side: OrderSide, trigger: &str, limit: &str, id: &str) -> RestingOrder {
1579 let order = order_from_init(
1580 OrderInitializedSpec::builder()
1581 .client_order_id(ClientOrderId::from(id))
1582 .order_type(OrderType::StopLimit)
1583 .order_side(side)
1584 .quantity(Quantity::from("10"))
1585 .price(Price::from(limit))
1586 .trigger_price(Price::from(trigger))
1587 .trigger_type(TriggerType::Default)
1588 .build(),
1589 );
1590 RestingOrder::from(&PassiveOrderAny::try_from(order).unwrap())
1591 }
1592
1593 #[rstest]
1594 fn test_iterate_bids_returns_limits_in_descending_price_order() {
1595 let mut core = create_matching_core(InstrumentId::from("AAPL.XNAS"), Price::from("0.01"));
1596 core.set_ask_raw(Price::from("99.00"));
1597
1598 core.add_order(limit_order(OrderSide::Buy, "100.00", "O-MID"));
1599 core.add_order(limit_order(OrderSide::Buy, "100.50", "O-HIGH"));
1600 core.add_order(limit_order(OrderSide::Buy, "99.50", "O-LOW"));
1601
1602 let actions = core.iterate_bids();
1603 assert_eq!(
1604 actions,
1605 vec![
1606 MatchAction::FillLimit(ClientOrderId::from("O-HIGH")),
1607 MatchAction::FillLimit(ClientOrderId::from("O-MID")),
1608 MatchAction::FillLimit(ClientOrderId::from("O-LOW")),
1609 ],
1610 );
1611 }
1612
1613 #[rstest]
1614 fn test_iterate_asks_returns_limits_in_ascending_price_order() {
1615 let mut core = create_matching_core(InstrumentId::from("AAPL.XNAS"), Price::from("0.01"));
1616 core.set_bid_raw(Price::from("101.00"));
1617
1618 core.add_order(limit_order(OrderSide::Sell, "100.50", "O-MID"));
1619 core.add_order(limit_order(OrderSide::Sell, "100.00", "O-LOW"));
1620 core.add_order(limit_order(OrderSide::Sell, "100.75", "O-HIGH"));
1621
1622 let actions = core.iterate_asks();
1623 assert_eq!(
1624 actions,
1625 vec![
1626 MatchAction::FillLimit(ClientOrderId::from("O-LOW")),
1627 MatchAction::FillLimit(ClientOrderId::from("O-MID")),
1628 MatchAction::FillLimit(ClientOrderId::from("O-HIGH")),
1629 ],
1630 );
1631 }
1632
1633 #[rstest]
1634 fn test_iterate_limits_preserves_fifo_within_same_price() {
1635 let mut core = create_matching_core(InstrumentId::from("AAPL.XNAS"), Price::from("0.01"));
1636 core.set_ask_raw(Price::from("99.00"));
1637
1638 for id in ["O-1", "O-2", "O-3", "O-4"] {
1639 core.add_order(limit_order(OrderSide::Buy, "100.00", id));
1640 }
1641
1642 let actions = core.iterate_bids();
1643 assert_eq!(
1644 actions,
1645 vec![
1646 MatchAction::FillLimit(ClientOrderId::from("O-1")),
1647 MatchAction::FillLimit(ClientOrderId::from("O-2")),
1648 MatchAction::FillLimit(ClientOrderId::from("O-3")),
1649 MatchAction::FillLimit(ClientOrderId::from("O-4")),
1650 ],
1651 );
1652 }
1653
1654 #[rstest]
1655 fn test_buy_stops_trigger_in_ascending_price_order_when_ask_crosses_multiple() {
1656 let mut core = create_matching_core(InstrumentId::from("AAPL.XNAS"), Price::from("0.01"));
1657 core.set_ask_raw(Price::from("106.00"));
1658
1659 core.add_order(stop_order(OrderSide::Buy, "105.00", "O-FAR"));
1660 core.add_order(stop_order(OrderSide::Buy, "101.00", "O-NEAR"));
1661
1662 let actions = core.iterate_bids();
1663 assert_eq!(
1664 actions,
1665 vec![
1666 MatchAction::TriggerStop(ClientOrderId::from("O-NEAR")),
1667 MatchAction::TriggerStop(ClientOrderId::from("O-FAR")),
1668 ],
1669 );
1670 }
1671
1672 #[rstest]
1673 fn test_sell_stops_trigger_in_descending_price_order_when_bid_crosses_multiple() {
1674 let mut core = create_matching_core(InstrumentId::from("AAPL.XNAS"), Price::from("0.01"));
1675 core.set_bid_raw(Price::from("94.00"));
1676
1677 core.add_order(stop_order(OrderSide::Sell, "95.00", "O-FAR"));
1678 core.add_order(stop_order(OrderSide::Sell, "99.00", "O-NEAR"));
1679
1680 let actions = core.iterate_asks();
1681 assert_eq!(
1682 actions,
1683 vec![
1684 MatchAction::TriggerStop(ClientOrderId::from("O-NEAR")),
1685 MatchAction::TriggerStop(ClientOrderId::from("O-FAR")),
1686 ],
1687 );
1688 }
1689
1690 #[rstest]
1691 fn test_iterate_stops_preserves_fifo_within_same_trigger() {
1692 let mut core = create_matching_core(InstrumentId::from("AAPL.XNAS"), Price::from("0.01"));
1693 core.set_ask_raw(Price::from("106.00"));
1694
1695 for id in ["O-S1", "O-S2", "O-S3"] {
1696 core.add_order(stop_order(OrderSide::Buy, "101.00", id));
1697 }
1698
1699 let actions = core.iterate_bids();
1700 assert_eq!(
1701 actions,
1702 vec![
1703 MatchAction::TriggerStop(ClientOrderId::from("O-S1")),
1704 MatchAction::TriggerStop(ClientOrderId::from("O-S2")),
1705 MatchAction::TriggerStop(ClientOrderId::from("O-S3")),
1706 ],
1707 );
1708 }
1709
1710 #[rstest]
1711 fn test_iterate_bids_processes_limits_before_stops() {
1712 let mut core = create_matching_core(InstrumentId::from("AAPL.XNAS"), Price::from("0.01"));
1713 core.set_ask_raw(Price::from("106.00"));
1714
1715 core.add_order(limit_order(OrderSide::Buy, "110.00", "O-LMT"));
1716 core.add_order(stop_order(OrderSide::Buy, "101.00", "O-STP"));
1717
1718 let actions = core.iterate_bids();
1719 assert_eq!(
1720 actions,
1721 vec![
1722 MatchAction::FillLimit(ClientOrderId::from("O-LMT")),
1723 MatchAction::TriggerStop(ClientOrderId::from("O-STP")),
1724 ],
1725 );
1726 }
1727
1728 #[rstest]
1729 fn test_iterate_asks_processes_limits_before_stops() {
1730 let mut core = create_matching_core(InstrumentId::from("AAPL.XNAS"), Price::from("0.01"));
1731 core.set_bid_raw(Price::from("94.00"));
1732
1733 core.add_order(limit_order(OrderSide::Sell, "90.00", "O-LMT"));
1734 core.add_order(stop_order(OrderSide::Sell, "99.00", "O-STP"));
1735
1736 let actions = core.iterate_asks();
1737 assert_eq!(
1738 actions,
1739 vec![
1740 MatchAction::FillLimit(ClientOrderId::from("O-LMT")),
1741 MatchAction::TriggerStop(ClientOrderId::from("O-STP")),
1742 ],
1743 );
1744 }
1745
1746 #[rstest]
1747 fn test_stop_limit_routed_to_stop_book_keyed_by_trigger() {
1748 let mut core = create_matching_core(InstrumentId::from("AAPL.XNAS"), Price::from("0.01"));
1749 core.set_ask_raw(Price::from("106.00"));
1750
1751 core.add_order(stop_limit_order(
1753 OrderSide::Buy,
1754 "105.00",
1755 "110.00",
1756 "O-FAR",
1757 ));
1758 core.add_order(stop_limit_order(
1759 OrderSide::Buy,
1760 "101.00",
1761 "110.00",
1762 "O-NEAR",
1763 ));
1764
1765 let actions = core.iterate_bids();
1766 assert_eq!(
1767 actions,
1768 vec![
1769 MatchAction::TriggerStop(ClientOrderId::from("O-NEAR")),
1770 MatchAction::TriggerStop(ClientOrderId::from("O-FAR")),
1771 ],
1772 );
1773 }
1774
1775 #[rstest]
1776 fn test_iterate_full_walk_combines_bids_then_asks_each_with_limits_then_stops() {
1777 let mut core = create_matching_core(InstrumentId::from("AAPL.XNAS"), Price::from("0.01"));
1779 core.set_bid_raw(Price::from("94.00"));
1780 core.set_ask_raw(Price::from("106.00"));
1781
1782 core.add_order(limit_order(OrderSide::Buy, "110.00", "O-B-LMT-HIGH"));
1783 core.add_order(limit_order(OrderSide::Buy, "107.00", "O-B-LMT-LOW"));
1784 core.add_order(stop_order(OrderSide::Buy, "105.00", "O-B-STP-FAR"));
1785 core.add_order(stop_order(OrderSide::Buy, "101.00", "O-B-STP-NEAR"));
1786
1787 core.add_order(limit_order(OrderSide::Sell, "90.00", "O-A-LMT-LOW"));
1788 core.add_order(limit_order(OrderSide::Sell, "93.00", "O-A-LMT-HIGH"));
1789 core.add_order(stop_order(OrderSide::Sell, "95.00", "O-A-STP-FAR"));
1790 core.add_order(stop_order(OrderSide::Sell, "99.00", "O-A-STP-NEAR"));
1791
1792 let actions = core.iterate();
1793 assert_eq!(
1794 actions,
1795 vec![
1796 MatchAction::FillLimit(ClientOrderId::from("O-B-LMT-HIGH")),
1797 MatchAction::FillLimit(ClientOrderId::from("O-B-LMT-LOW")),
1798 MatchAction::TriggerStop(ClientOrderId::from("O-B-STP-NEAR")),
1799 MatchAction::TriggerStop(ClientOrderId::from("O-B-STP-FAR")),
1800 MatchAction::FillLimit(ClientOrderId::from("O-A-LMT-LOW")),
1801 MatchAction::FillLimit(ClientOrderId::from("O-A-LMT-HIGH")),
1802 MatchAction::TriggerStop(ClientOrderId::from("O-A-STP-NEAR")),
1803 MatchAction::TriggerStop(ClientOrderId::from("O-A-STP-FAR")),
1804 ],
1805 );
1806 }
1807
1808 #[rstest]
1809 fn test_pending_orders_skipped_in_iterate_but_visible_in_get_orders() {
1810 let instrument_id = InstrumentId::from("AAPL.XNAS");
1811 let mut core = create_matching_core(instrument_id, Price::from("0.01"));
1812 core.set_bid_raw(Price::from("99.00"));
1813 core.set_ask_raw(Price::from("100.00"));
1814
1815 core.add_order(limit_order(OrderSide::Buy, "100.00", "O-LMT"));
1816
1817 let pending = RestingOrder::new(
1818 ClientOrderId::from("O-PENDING"),
1819 OrderSide::Buy,
1820 OrderType::MarketToLimit,
1821 None,
1822 None,
1823 true,
1824 );
1825 core.add_order(pending);
1826
1827 assert_eq!(
1828 core.iterate_bids(),
1829 vec![MatchAction::FillLimit(ClientOrderId::from("O-LMT"))],
1830 );
1831
1832 let bid_ids: Vec<_> = core
1833 .get_orders_bid()
1834 .iter()
1835 .map(|o| o.client_order_id)
1836 .collect();
1837 assert_eq!(
1838 bid_ids,
1839 vec![
1840 ClientOrderId::from("O-LMT"),
1841 ClientOrderId::from("O-PENDING"),
1842 ],
1843 );
1844 }
1845
1846 #[rstest]
1847 fn test_modify_then_readd_moves_order_to_back_of_new_level() {
1848 let mut core = create_matching_core(InstrumentId::from("AAPL.XNAS"), Price::from("0.01"));
1849 core.set_ask_raw(Price::from("99.00"));
1850
1851 core.add_order(limit_order(OrderSide::Buy, "100.00", "O-A"));
1852 core.add_order(limit_order(OrderSide::Buy, "100.00", "O-B"));
1853 core.add_order(limit_order(OrderSide::Buy, "100.00", "O-C"));
1854
1855 core.delete_order(ClientOrderId::from("O-A")).unwrap();
1856 core.add_order(limit_order(OrderSide::Buy, "100.50", "O-A"));
1857
1858 core.delete_order(ClientOrderId::from("O-B")).unwrap();
1860 core.add_order(limit_order(OrderSide::Buy, "100.00", "O-B"));
1861
1862 let actions = core.iterate_bids();
1863 assert_eq!(
1864 actions,
1865 vec![
1866 MatchAction::FillLimit(ClientOrderId::from("O-A")),
1867 MatchAction::FillLimit(ClientOrderId::from("O-C")),
1868 MatchAction::FillLimit(ClientOrderId::from("O-B")),
1869 ],
1870 );
1871 }
1872
1873 #[rstest]
1874 fn test_delete_unknown_order_returns_not_found() {
1875 let mut core = create_matching_core(InstrumentId::from("AAPL.XNAS"), Price::from("0.01"));
1876 let missing_id = ClientOrderId::from("O-MISSING");
1877
1878 let result = core.delete_order(missing_id);
1879
1880 assert!(matches!(result, Err(OrderError::NotFound(id)) if id == missing_id));
1881 }
1882
1883 #[rstest]
1884 #[case::buy(OrderSide::Buy)]
1885 #[case::sell(OrderSide::Sell)]
1886 fn test_pending_order_lookup_delete_and_conversion(#[case] side: OrderSide) {
1887 let mut core = create_matching_core(InstrumentId::from("AAPL.XNAS"), Price::from("0.01"));
1888 core.set_bid_raw(Price::from("100.00"));
1889 core.set_ask_raw(Price::from("100.00"));
1890 let first = pending_order(side, "O-FIRST");
1891 let second = pending_order(side, "O-SECOND");
1892 core.add_order(first);
1893 core.add_order(second);
1894
1895 assert_eq!(core.get_order(first.client_order_id), Some(&first));
1896 assert_eq!(core.get_order(second.client_order_id), Some(&second));
1897 assert!(core.order_exists(first.client_order_id));
1898 assert!(core.order_exists(second.client_order_id));
1899 assert_eq!(core.get_orders(), vec![first, second]);
1900 assert!(core.iterate().is_empty());
1901
1902 core.delete_order(second.client_order_id).unwrap();
1903
1904 assert_eq!(core.get_order(second.client_order_id), None);
1905 assert!(!core.order_exists(second.client_order_id));
1906 assert_eq!(core.get_order(first.client_order_id), Some(&first));
1907 assert!(core.order_exists(first.client_order_id));
1908 assert_eq!(core.get_orders(), vec![first]);
1909
1910 core.delete_order(first.client_order_id).unwrap();
1911
1912 assert_eq!(core.get_order(first.client_order_id), None);
1913 assert!(!core.order_exists(first.client_order_id));
1914 assert!(core.get_orders().is_empty());
1915
1916 let converted = RestingOrder {
1917 limit_price: Some(Price::from("100.00")),
1918 ..first
1919 };
1920 core.add_order(converted);
1921
1922 assert_eq!(core.get_order(first.client_order_id), Some(&converted));
1923 assert!(core.order_exists(first.client_order_id));
1924 assert_eq!(core.get_orders(), vec![converted]);
1925 assert_eq!(
1926 core.iterate(),
1927 vec![MatchAction::FillLimit(first.client_order_id)]
1928 );
1929 }
1930
1931 #[rstest]
1932 fn test_order_views_preserve_price_time_priority() {
1933 let mut core = create_matching_core(InstrumentId::from("AAPL.XNAS"), Price::from("0.01"));
1934 let bids = [
1935 limit_order(OrderSide::Buy, "101.00", "O-B-LMT-1"),
1936 limit_order(OrderSide::Buy, "101.00", "O-B-LMT-2"),
1937 limit_order(OrderSide::Buy, "100.00", "O-B-LMT-3"),
1938 stop_order(OrderSide::Buy, "102.00", "O-B-STP-1"),
1939 stop_order(OrderSide::Buy, "102.00", "O-B-STP-2"),
1940 stop_order(OrderSide::Buy, "103.00", "O-B-STP-3"),
1941 pending_order(OrderSide::Buy, "O-B-PENDING-1"),
1942 pending_order(OrderSide::Buy, "O-B-PENDING-2"),
1943 ];
1944 let asks = [
1945 limit_order(OrderSide::Sell, "100.00", "O-A-LMT-1"),
1946 limit_order(OrderSide::Sell, "100.00", "O-A-LMT-2"),
1947 limit_order(OrderSide::Sell, "101.00", "O-A-LMT-3"),
1948 stop_order(OrderSide::Sell, "99.00", "O-A-STP-1"),
1949 stop_order(OrderSide::Sell, "99.00", "O-A-STP-2"),
1950 stop_order(OrderSide::Sell, "98.00", "O-A-STP-3"),
1951 pending_order(OrderSide::Sell, "O-A-PENDING-1"),
1952 pending_order(OrderSide::Sell, "O-A-PENDING-2"),
1953 ];
1954
1955 for index in [6, 5, 2, 3, 0, 4, 1, 7] {
1956 core.add_order(asks[index]);
1957 core.add_order(bids[index]);
1958 }
1959 let orders = [bids, asks].concat();
1960
1961 assert_eq!(core.iter_bid_orders().copied().collect::<Vec<_>>(), bids);
1962 assert_eq!(core.get_orders_bid(), bids);
1963 assert_eq!(core.iter_ask_orders().copied().collect::<Vec<_>>(), asks);
1964 assert_eq!(core.get_orders_ask(), asks);
1965 assert_eq!(core.iter_orders().copied().collect::<Vec<_>>(), orders);
1966 assert_eq!(core.get_orders(), orders);
1967 }
1968
1969 #[rstest]
1970 #[case::buy(OrderSide::Buy, "99.00", "101.00")]
1971 #[case::sell(OrderSide::Sell, "101.00", "99.00")]
1972 fn test_touch_order_last_or_bid_ask_prefers_last_then_falls_back(
1973 #[case] side: OrderSide,
1974 #[case] crossed_price: &str,
1975 #[case] uncrossed_price: &str,
1976 #[values(OrderType::MarketIfTouched, OrderType::LimitIfTouched)] order_type: OrderType,
1977 ) {
1978 let instrument_id = InstrumentId::from("AAPL.XNAS");
1979 let mut core = create_matching_core(instrument_id, Price::from("0.01"));
1980 let trigger_price = Price::from("100.00");
1981 let crossed = Price::from(crossed_price);
1982 let uncrossed = Price::from(uncrossed_price);
1983 let order = OrderTestBuilder::new(order_type)
1984 .instrument_id(instrument_id)
1985 .client_order_id(ClientOrderId::from("O-TOUCH"))
1986 .side(side)
1987 .price(uncrossed)
1988 .trigger_price(trigger_price)
1989 .trigger_type(TriggerType::LastOrBidAsk)
1990 .quantity(Quantity::from("10"))
1991 .build();
1992 let resting = RestingOrder::from(&PassiveOrderAny::try_from(order).unwrap());
1993 let action = Some(MatchAction::TriggerStop(resting.client_order_id));
1994
1995 match side {
1996 OrderSide::Buy => {
1997 core.set_bid_raw(Price::from("98.00"));
1998 core.set_ask_raw(crossed);
1999 }
2000 OrderSide::Sell => {
2001 core.set_bid_raw(crossed);
2002 core.set_ask_raw(Price::from("102.00"));
2003 }
2004 }
2005 core.set_last_raw(uncrossed);
2006
2007 assert_eq!(core.match_order(&resting), None);
2008
2009 match side {
2010 OrderSide::Buy => core.set_ask_raw(uncrossed),
2011 OrderSide::Sell => core.set_bid_raw(uncrossed),
2012 }
2013 core.set_last_raw(trigger_price);
2014
2015 assert_eq!(core.match_order(&resting), action);
2016
2017 core.last = None;
2018
2019 assert_eq!(core.match_order(&resting), None);
2020
2021 match side {
2022 OrderSide::Buy => core.set_ask_raw(crossed),
2023 OrderSide::Sell => core.set_bid_raw(crossed),
2024 }
2025
2026 assert_eq!(core.match_order(&resting), action);
2027
2028 match side {
2029 OrderSide::Buy => core.ask = None,
2030 OrderSide::Sell => core.bid = None,
2031 }
2032
2033 assert_eq!(core.match_order(&resting), None);
2034 }
2035
2036 fn pending_order(side: OrderSide, id: &str) -> RestingOrder {
2037 RestingOrder::new(
2038 ClientOrderId::from(id),
2039 side,
2040 OrderType::MarketToLimit,
2041 None,
2042 None,
2043 true,
2044 )
2045 }
2046}