Skip to main content

nautilus_execution/
matching.rs

1// -------------------------------------------------------------------------------------------------
2//  Copyright (C) 2015-2026 Nautech Systems Pty Ltd. All rights reserved.
3//  https://nautechsystems.io
4//
5//  Licensed under the GNU Lesser General Public License Version 3.0 (the "License");
6//  You may not use this file except in compliance with the License.
7//  You may obtain a copy of the License at https://www.gnu.org/licenses/lgpl-3.0.en.html
8//
9//  Unless required by applicable law or agreed to in writing, software
10//  distributed under the License is distributed on an "AS IS" BASIS,
11//  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12//  See the License for the specific language governing permissions and
13//  limitations under the License.
14// -------------------------------------------------------------------------------------------------
15
16//! Order matching core shared by the `OrderMatchingEngine` and other components.
17//!
18//! Evaluates resting orders against a market-price snapshot and returns fill or
19//! trigger actions without removing orders from the books.
20//!
21//! # Book Layout
22//!
23//! Each side has separate limit and stop books, keyed by price in a `BTreeMap`:
24//!
25//! - **Limit book**: keyed by limit price. Holds orders with a limit price and no
26//!   trigger price, including converted `MARKET_TO_LIMIT` orders and triggered
27//!   stop-limit orders whose trigger price has been cleared.
28//! - **Stop book**: keyed by trigger price. Holds `STOP_*`, `*_IF_TOUCHED`, and
29//!   `TRAILING_STOP_*` orders that require trigger checks.
30//!
31//! A per-side pending `SmallVec` holds orders with neither price, such as
32//! `MARKET_TO_LIMIT` orders before conversion. These orders remain visible in
33//! lookups and snapshots but are excluded from matching.
34//!
35//! # Ordering Invariant
36//!
37//! [`OrderMatchingCore::iterate`] processes bids before asks. On each side,
38//! limits precede stops, with the following price order:
39//!
40//! - **Bid limits**: highest price first.
41//! - **Ask limits**: lowest price first.
42//! - **Bid stops**: lowest trigger first, following the crossing order as the
43//!   ask rises through buy-stop levels.
44//! - **Ask stops**: highest trigger first, following the crossing order as the
45//!   bid falls through sell-stop levels.
46//!
47//! Each price level stores orders in a `SmallVec` in insertion order, preserving
48//! time priority (FIFO at the same price). Traversing the `BTreeMap` forward or
49//! backward supplies price order without a separate sort. Order snapshots use
50//! the same book order and append pending orders after the stops on each side.
51//!
52//! # Modify Semantics
53//!
54//! The core has no in-place modify API. To change a resting order, call
55//! [`OrderMatchingCore::delete_order`] followed by [`OrderMatchingCore::add_order`].
56//! The order joins the back of its price level, even if the price is unchanged.
57//! This models loss of queue position on price changes, but also loses position
58//! for quantity-only changes. Preserving position for quantity-only changes
59//! would require an in-place update API.
60//!
61//! # Snapshot Ordering Limitation
62//!
63//! [`OrderMatchingCore::iterate_bids`] and [`OrderMatchingCore::iterate_asks`]
64//! emit all matchable limits before triggered stops on their side. This emission
65//! order is deterministic, but it does not reconstruct the order in which prices
66//! cross levels. A stop can trigger during a price move and then aggress against
67//! the limit book; a snapshot alone cannot recover that sequence when both
68//! limits and stops are matchable.
69//!
70//! Callers must not interpret the limits-then-stops sequence as price-path order,
71//! particularly when a gap crosses several limit and stop levels on the same
72//! side. The engine supplies the snapshot. Replaying crossings would require
73//! additional price-path information, such as previous bid/ask values, and an
74//! engine/core change to emit fills and triggers in crossing order.
75//!
76//! # Duplicate Inserts
77//!
78//! Each `client_order_id` must appear at most once across both sides.
79//! [`OrderMatchingCore::add_order`] panics on duplicate IDs when debug assertions
80//! are enabled. Without debug assertions, adding the same ID twice without an
81//! intervening [`OrderMatchingCore::delete_order`] leaves duplicate entries that
82//! can both match.
83//!
84//! # Performance
85//!
86//! Each price-level `SmallVec` stores up to four orders inline, covering the
87//! common case of 1-3 orders without a per-bucket heap allocation. The bucket
88//! spills to the heap when it exceeds that capacity.
89//!
90//! For L distinct price levels and B orders at a level, insertion requires an
91//! O(log L) tree lookup and an amortized O(1) append. A bucket allocation can
92//! move O(B) orders. Deletion requires an O(log L) tree lookup and an O(B) scan
93//! and shift. Both L and B are expected to be small in typical use.
94//!
95//! An `AHashMap` maps each `ClientOrderId` to its side and optional book location.
96//! [`OrderMatchingCore::order_exists`] uses only this index.
97//! [`OrderMatchingCore::get_order`] and [`OrderMatchingCore::delete_order`] use
98//! the index to locate the book, then perform a tree lookup and bucket scan.
99//! Pending orders require only the per-side pending-bucket scan after the index
100//! lookup. The index serves only point queries and is never iterated, so its
101//! randomized hash seed does not affect ordering.
102
103use 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
114/// Inline capacity for orders at a single price level. Sized to cover the
115/// typical 1-3 orders per level; above this the per-bucket `SmallVec` spills
116/// to the heap.
117const INLINE_ORDERS_PER_LEVEL: usize = 4;
118
119type OrderBucket = SmallVec<[RestingOrder; INLINE_ORDERS_PER_LEVEL]>;
120
121/// An action returned by [`OrderMatchingCore::iterate`] when an order matches.
122#[derive(Debug, Clone, Copy, PartialEq, Eq)]
123pub enum MatchAction {
124    FillLimit(ClientOrderId),
125    TriggerStop(ClientOrderId),
126}
127
128/// A generic order matching core. See module docs for ordering, modify,
129/// duplicate, and performance contracts.
130#[derive(Clone, Debug)]
131pub struct OrderMatchingCore {
132    /// The instrument ID for the matching core.
133    pub instrument_id: InstrumentId,
134    /// The price increment for the matching core.
135    pub price_increment: Price,
136    /// The current bid price for the matching core.
137    pub bid: Option<Price>,
138    /// The current ask price for the matching core.
139    pub ask: Option<Price>,
140    /// The last price for the matching core.
141    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    /// Creates a new [`OrderMatchingCore`] for the given instrument.
155    #[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    /// Returns the price precision of the instrument's tick size.
176    #[must_use]
177    pub const fn price_precision(&self) -> u8 {
178        self.price_increment.precision
179    }
180
181    /// Returns the order with the given `client_order_id`, searching both sides.
182    #[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    /// Iterates the bid-side orders in price-time priority without
195    /// allocating: limits best (highest) first, then stops nearest-trigger
196    /// (lowest) first, then pending unkeyed orders. Borrowed view; for an
197    /// owned snapshot use [`Self::get_orders_bid`].
198    pub fn iter_bid_orders(&self) -> impl Iterator<Item = &RestingOrder> {
199        self.iter_bid_book_orders().chain(self.pending_bid.iter())
200    }
201
202    /// Iterates the ask-side orders in price-time priority without
203    /// allocating: limits best (lowest) first, then stops nearest-trigger
204    /// (highest) first, then pending unkeyed orders. Borrowed view; for an
205    /// owned snapshot use [`Self::get_orders_ask`].
206    pub fn iter_ask_orders(&self) -> impl Iterator<Item = &RestingOrder> {
207        self.iter_ask_book_orders().chain(self.pending_ask.iter())
208    }
209
210    /// Iterates all orders without allocating, bids (best first) then asks
211    /// (best first). Borrowed view; for an owned snapshot use
212    /// [`Self::get_orders`].
213    pub fn iter_orders(&self) -> impl Iterator<Item = &RestingOrder> {
214        self.iter_bid_orders().chain(self.iter_ask_orders())
215    }
216
217    /// Returns the bid-side orders in price-time priority: limits best
218    /// (highest) first, then stops nearest-trigger (lowest) first, then
219    /// pending unkeyed orders. Allocates an owned snapshot; for borrowed
220    /// iteration use [`Self::iter_bid_orders`].
221    #[must_use]
222    pub fn get_orders_bid(&self) -> Vec<RestingOrder> {
223        self.iter_bid_orders().copied().collect()
224    }
225
226    /// Returns the ask-side orders in price-time priority: limits best
227    /// (lowest) first, then stops nearest-trigger (highest) first, then
228    /// pending unkeyed orders. Allocates an owned snapshot; for borrowed
229    /// iteration use [`Self::iter_ask_orders`].
230    #[must_use]
231    pub fn get_orders_ask(&self) -> Vec<RestingOrder> {
232        self.iter_ask_orders().copied().collect()
233    }
234
235    /// Returns all orders, bids (best first) then asks (best first).
236    /// Allocates an owned snapshot; for borrowed iteration use
237    /// [`Self::iter_orders`].
238    #[must_use]
239    pub fn get_orders(&self) -> Vec<RestingOrder> {
240        self.iter_orders().copied().collect()
241    }
242
243    /// Returns whether an order with `client_order_id` is present on either side.
244    #[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    /// Sets the last traded price.
250    pub const fn set_last_raw(&mut self, last: Price) {
251        self.last = Some(last);
252    }
253
254    /// Sets the best bid price.
255    pub const fn set_bid_raw(&mut self, bid: Price) {
256        self.bid = Some(bid);
257    }
258
259    /// Sets the best ask price.
260    pub const fn set_ask_raw(&mut self, ask: Price) {
261        self.ask = Some(ask);
262    }
263
264    /// Updates the price increment (tick size) for the matching core.
265    pub const fn update_price_increment(&mut self, price_increment: Price) {
266        self.price_increment = price_increment;
267    }
268
269    /// Clears all orders and resets bid, ask, last, and mark prices to uninitialized.
270    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    /// Adds an order to the matching core.
285    ///
286    /// # Invariant
287    ///
288    /// Each `client_order_id` must appear at most once across all books.
289    /// To re-add an order under the same ID (e.g. a price-changing modify),
290    /// call [`Self::delete_order`] first. Inserting duplicates puts two entries
291    /// in the bucket and the order will match twice.
292    ///
293    /// Routing:
294    /// - `is_stop()` orders go to the side's stop book, keyed by trigger price.
295    /// - Orders with only a limit price go to the side's limit book, keyed by limit price.
296    /// - Orders with neither price (e.g. `MARKET_TO_LIMIT` before conversion)
297    ///   go to the per-side pending bucket. They remain visible to `get_order`
298    ///   / `order_exists` but `iterate_*` skips them.
299    ///
300    /// # Panics
301    ///
302    /// Panics if the invariant is violated and debug assertions are enabled.
303    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    /// Deletes an order from the matching core by client order ID.
324    ///
325    /// # Errors
326    ///
327    /// Returns an error if the order is not present.
328    ///
329    /// # Panics
330    ///
331    /// Panics if the index points at a bucket that is missing or no longer
332    /// contains the expected order, indicating internal index corruption.
333    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    /// Matches all bid then ask orders against the current market and returns
364    /// the resulting actions in price-time priority.
365    pub fn iterate(&self) -> Vec<MatchAction> {
366        let mut actions = self.iterate_bids();
367        actions.extend(self.iterate_asks());
368        actions
369    }
370
371    /// Matches bid-side orders: limits best (highest) first, then stops
372    /// nearest-trigger (lowest) first. FIFO within each price level.
373    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    /// Matches ask-side orders: limits best (lowest) first, then stops
385    /// nearest-trigger (highest) first. FIFO within each price level.
386    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    /// Returns a [`MatchAction`] if the order matches the current market,
397    /// or `None` if it does not (or has neither trigger nor limit price).
398    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    /// Returns whether a limit order at `price` would cross the opposite side
409    /// (BUY: `ask <= price`, SELL: `bid >= price`).
410    #[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    /// Returns whether a stop trigger at `price` has been reached
419    /// (BUY: `ask >= price`, SELL: `bid <= price`).
420    #[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    /// Returns whether a touch trigger at `trigger_price` has been reached
440    /// (BUY: `ask <= trigger_price`, SELL: `bid >= trigger_price`).
441    #[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    /// Toggles whether limit orders fill at-or-inside the spread (vs only on cross).
461    pub fn set_fill_limit_inside_spread(&mut self, value: bool) {
462        self.fill_limit_inside_spread = value;
463    }
464
465    /// Returns whether a limit order is fillable at the given price.
466    ///
467    /// Checks `is_limit_matched` first (crosses the spread). When
468    /// `fill_limit_inside_spread` is set, also checks at-or-inside spread
469    /// (BUY >= bid, SELL <= ask), requiring both sides initialized.
470    #[must_use]
471    pub fn is_limit_fillable(&self, side: OrderSide, price: Price) -> bool {
472        // Limit traversal relies on fillability being monotonic in price
473        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/// Lightweight order information for matching/trigger checking.
604#[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    /// Creates a new [`RestingOrder`] instance.
617    ///
618    /// `MARKET_TO_LIMIT` orders may legitimately be constructed with both
619    /// `trigger_price` and `limit_price` set to `None` until they convert to
620    /// a limit at execution time; [`OrderMatchingCore::match_order`] returns
621    /// `None` for such orders.
622    #[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    /// Returns whether a trigger price is set.
667    #[must_use]
668    pub const fn is_stop(&self) -> bool {
669        self.trigger_price.is_some()
670    }
671
672    /// Returns whether a limit price is set without a trigger price.
673    #[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        // Equal limit prices ensure that trigger prices determine priority
1752        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        // Prices make limits and stops matchable on both sides in the same snapshot
1778        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        // Re-adding at the same price still loses queue position to O-C
1859        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}