rusty_model/

matching_engine.rs

//! Matching Engine for order matching and execution
//!
//! This module provides a high-performance matching engine implementation
//! for matching buy and sell orders based on price-time priority.
//! Should be partial-fill compatible because crypto exchanges support partial fills.

use crate::data::{
    book_snapshot::OrderBookSnapshot, orderbook::OrderBook, simd_orderbook::SharedSimdOrderBook,
};
use crate::enums::OrderSide;
use crate::instruments::InstrumentId;
use crate::trading_order::{Order, OrderStatus, OrderType};
use crate::types::{ClientId, OrderId};
use quanta::Clock;
use rust_decimal::Decimal;
use rusty_common::collections::FxHashMap;
use smallvec::SmallVec;
use smartstring::alias::String;
use uuid::Uuid;

/// Represents a limit order in the matching engine
#[derive(Debug, Clone)]
#[repr(align(16))] // Align for better memory access
pub struct LimitOrder {
    /// Unique order ID
    pub id: OrderId,

    /// Client-provided order ID (if any)
    pub client_order_id: Option<ClientId>,

    /// Order side (buy or sell)
    pub side: OrderSide,

    /// Limit price
    pub price: Decimal,

    /// Original order quantity
    pub original_quantity: Decimal,

    /// Remaining quantity
    pub remaining_quantity: Decimal,

    /// Order creation time in nanoseconds
    pub creation_time_ns: u64,
}

impl LimitOrder {
    /// Create a new limit order
    #[must_use]
    pub fn new(
        id: OrderId,
        client_order_id: Option<ClientId>,
        side: OrderSide,
        price: Decimal,
        quantity: Decimal,
    ) -> Self {
        let clock = Clock::new();
        let now = clock.raw();

        Self {
            id,
            client_order_id,
            side,
            price,
            original_quantity: quantity,
            remaining_quantity: quantity,
            creation_time_ns: now,
        }
    }

    /// Check if the order is fully filled
    #[must_use]
    pub const fn is_filled(&self) -> bool {
        self.remaining_quantity.is_zero()
    }
}

/// Represents a trade resulting from order matching
#[derive(Debug, Clone)]
pub struct ExecutedTrade {
    /// Unique trade ID
    pub id: Uuid,

    /// Instrument ID
    pub instrument_id: InstrumentId,

    /// Maker order ID
    pub maker_order_id: OrderId,

    /// Taker order ID
    pub taker_order_id: OrderId,

    /// Trade price
    pub price: Decimal,

    /// Trade quantity
    pub quantity: Decimal,

    /// Trade side (from taker's perspective)
    pub side: OrderSide,

    /// Trade timestamp in nanoseconds
    pub timestamp_ns: u64,
}

/// Represents the result of order processing
#[derive(Debug, Clone)]
pub struct OrderResult {
    /// Original order
    pub order: Order,

    /// Resulting trades (if any)
    /// Most orders result in only a few trades, so we optimize for small collections
    pub trades: SmallVec<[ExecutedTrade; 4]>,

    /// Error message (if any)
    pub error: Option<String>,
}

/// High-performance matching engine for order matching and execution
#[derive(Debug)]
pub struct MatchingEngine {
    /// Order books by instrument ID
    order_books: FxHashMap<InstrumentId, SharedSimdOrderBook>,

    /// Buy limit orders by instrument ID
    buy_orders: FxHashMap<InstrumentId, FxHashMap<OrderId, LimitOrder>>,

    /// Sell limit orders by instrument ID
    sell_orders: FxHashMap<InstrumentId, FxHashMap<OrderId, LimitOrder>>,

    /// Shared clock instance for time synchronization
    clock: Clock,
}

impl Default for MatchingEngine {
    fn default() -> Self {
        Self::new()
    }
}

impl MatchingEngine {
    /// Create a new matching engine
    #[must_use]
    pub fn new() -> Self {
        Self {
            order_books: FxHashMap::default(),
            buy_orders: FxHashMap::default(),
            sell_orders: FxHashMap::default(),
            clock: Clock::new(),
        }
    }

    /// Add a new instrument to the matching engine
    pub fn add_instrument(&mut self, instrument_id: InstrumentId) {
        let order_book: OrderBook<64> = OrderBook::new_empty(instrument_id.clone());
        let shared_book = SharedSimdOrderBook::from_orderbook(&order_book);

        self.order_books.insert(instrument_id.clone(), shared_book);
        self.buy_orders
            .insert(instrument_id.clone(), FxHashMap::default());
        self.sell_orders.insert(instrument_id, FxHashMap::default());
    }

    /// Process a new order
    pub fn process_order(&mut self, order: Order) -> OrderResult {
        match order.order_type {
            OrderType::Market => self.process_market_order(order),
            OrderType::Limit => self.process_limit_order(order),
            _ => OrderResult {
                order: order.clone(),
                trades: SmallVec::with_capacity(4),
                error: Some(String::from(format!(
                    "Unsupported order type: {:?}",
                    order.order_type
                ))),
            },
        }
    }

    /// Process a market order
    fn process_market_order(&mut self, mut order: Order) -> OrderResult {
        let instrument_id = InstrumentId::new(order.symbol.clone(), order.venue);

        // Check if the instrument exists
        if !self.order_books.contains_key(&instrument_id) {
            return OrderResult {
                order,
                trades: SmallVec::with_capacity(4),
                error: Some(String::from(format!(
                    "Instrument not found: {instrument_id:?}"
                ))),
            };
        }

        let mut trades = SmallVec::with_capacity(8);
        let mut remaining_quantity = order.quantity;

        // Structure to hold orders that need to be updated and their new quantities
        // Most matching operations update only a few orders
        let mut orders_to_update: SmallVec<[(OrderId, OrderSide, Decimal); 8]> =
            SmallVec::with_capacity(8);

        // Match against the opposite side of the order book
        match order.side {
            OrderSide::Buy => {
                // Get the order book
                let order_book = self
                    .order_books
                    .get(&instrument_id)
                    .expect("Order book should exist after contains_key check");

                // Get sell orders for reading
                let sell_orders = self
                    .sell_orders
                    .get(&instrument_id)
                    .expect("Sell orders should exist after contains_key check");

                // Match against the order book
                order_book.read(|book| {
                    // Get the ask levels
                    let asks = book.asks();

                    // Match against each ask level
                    for ask_level in asks {
                        if remaining_quantity.is_zero() {
                            break;
                        }

                        // Find all sell orders at this price level
                        // Typically few orders at the exact same price
                        let mut orders_at_price: SmallVec<[_; 8]> = sell_orders
                            .values()
                            .filter(|o| o.price == ask_level.price && !o.is_filled())
                            .collect();

                        // Sort by creation time (oldest first)
                        orders_at_price.sort_by_key(|o| o.creation_time_ns);

                        // Match against each order
                        for sell_order in orders_at_price {
                            if remaining_quantity.is_zero() {
                                break;
                            }

                            // Calculate match quantity
                            let match_quantity =
                                std::cmp::min(remaining_quantity, sell_order.remaining_quantity);

                            // Create a trade
                            let trade = ExecutedTrade {
                                id: Uuid::new_v4(),
                                instrument_id: instrument_id.clone(),
                                maker_order_id: sell_order.id,
                                taker_order_id: order.id,
                                price: sell_order.price,
                                quantity: match_quantity,
                                side: OrderSide::Buy,
                                timestamp_ns: self.clock.raw(),
                            };

                            trades.push(trade);

                            // Update remaining quantities
                            remaining_quantity -= match_quantity;

                            // Store the order to update
                            let new_remaining = sell_order.remaining_quantity - match_quantity;
                            orders_to_update.push((sell_order.id, OrderSide::Sell, new_remaining));
                        }
                    }
                });

                // Now update the sell orders
                let sell_orders = self
                    .sell_orders
                    .get_mut(&instrument_id)
                    .expect("Sell orders should exist after contains_key check");
                for (order_id, _, new_quantity) in orders_to_update {
                    if let Some(order) = sell_orders.get_mut(&order_id) {
                        order.remaining_quantity = new_quantity;
                    }
                }
            }
            OrderSide::Sell => {
                // Get the order book
                let order_book = self
                    .order_books
                    .get(&instrument_id)
                    .expect("Order book should exist after contains_key check");

                // Get buy orders for reading
                let buy_orders = self
                    .buy_orders
                    .get(&instrument_id)
                    .expect("Buy orders should exist after contains_key check");

                // Match against the order book
                order_book.read(|book| {
                    // Get the bid levels
                    let bids = book.bids();

                    // Match against each bid level
                    for bid_level in bids {
                        if remaining_quantity.is_zero() {
                            break;
                        }

                        // Find all buy orders at this price level
                        // Typically few orders at the exact same price
                        let mut orders_at_price: SmallVec<[_; 8]> = buy_orders
                            .values()
                            .filter(|o| o.price == bid_level.price && !o.is_filled())
                            .collect();

                        // Sort by creation time (oldest first)
                        orders_at_price.sort_by_key(|o| o.creation_time_ns);

                        // Match against each order
                        for buy_order in orders_at_price {
                            if remaining_quantity.is_zero() {
                                break;
                            }

                            // Calculate match quantity
                            let match_quantity =
                                std::cmp::min(remaining_quantity, buy_order.remaining_quantity);

                            // Create a trade
                            let trade = ExecutedTrade {
                                id: Uuid::new_v4(),
                                instrument_id: instrument_id.clone(),
                                maker_order_id: buy_order.id,
                                taker_order_id: order.id,
                                price: buy_order.price,
                                quantity: match_quantity,
                                side: OrderSide::Sell,
                                timestamp_ns: self.clock.raw(),
                            };

                            trades.push(trade);

                            // Update remaining quantities
                            remaining_quantity -= match_quantity;

                            // Store the order to update
                            let new_remaining = buy_order.remaining_quantity - match_quantity;
                            orders_to_update.push((buy_order.id, OrderSide::Buy, new_remaining));
                        }
                    }
                });

                // Now update the buy orders
                let buy_orders = self
                    .buy_orders
                    .get_mut(&instrument_id)
                    .expect("Buy orders should exist after contains_key check");
                for (order_id, _, new_quantity) in orders_to_update {
                    if let Some(order) = buy_orders.get_mut(&order_id) {
                        order.remaining_quantity = new_quantity;
                    }
                }
            }
        }

        // Update the order
        order.filled_quantity = order.quantity - remaining_quantity;

        if order.filled_quantity.is_zero() {
            order.status = OrderStatus::Rejected;
        } else if order.filled_quantity < order.quantity {
            order.status = OrderStatus::PartiallyFilled;
        } else {
            order.status = OrderStatus::Filled;
        }

        // Calculate average fill price
        if !trades.is_empty() {
            let total_value = trades
                .iter()
                .fold(Decimal::ZERO, |acc, trade: &ExecutedTrade| {
                    acc + trade.price * trade.quantity
                });
            let total_quantity = trades
                .iter()
                .fold(Decimal::ZERO, |acc, trade: &ExecutedTrade| {
                    acc + trade.quantity
                });
            order.average_fill_price = Some(total_value / total_quantity);
        }

        // Update the order book
        self.update_order_book(&instrument_id);

        OrderResult {
            order,
            trades,
            error: None,
        }
    }

    /// Process a limit order
    fn process_limit_order(&mut self, mut order: Order) -> OrderResult {
        let instrument_id = InstrumentId::new(order.symbol.clone(), order.venue);

        // Check if the instrument exists
        if !self.order_books.contains_key(&instrument_id) {
            return OrderResult {
                order,
                trades: SmallVec::with_capacity(4),
                error: Some(String::from(format!(
                    "Instrument not found: {instrument_id:?}"
                ))),
            };
        }

        // Check if price is provided
        let Some(price) = order.price else {
            return OrderResult {
                order,
                trades: SmallVec::with_capacity(4),
                error: Some("Limit order requires a price".into()),
            };
        };

        let mut trades = SmallVec::with_capacity(8);
        let mut remaining_quantity = order.quantity;

        // Structure to hold orders that need to be updated and their new quantities
        // Most matching operations update only a few orders
        let mut orders_to_update: SmallVec<[(OrderId, OrderSide, Decimal); 8]> =
            SmallVec::with_capacity(8);

        // Match against the opposite side of the order book
        match order.side {
            OrderSide::Buy => {
                // Get the order book
                let order_book = self
                    .order_books
                    .get(&instrument_id)
                    .expect("Order book should exist after contains_key check");

                // Get sell orders for reading
                let sell_orders = self
                    .sell_orders
                    .get(&instrument_id)
                    .expect("Sell orders should exist after contains_key check");

                // Match against the order book
                order_book.read(|book| {
                    // Get the ask levels
                    let asks = book.asks();

                    // Match against each ask level that has a price <= our buy price
                    for ask_level in asks {
                        if remaining_quantity.is_zero() || ask_level.price > price {
                            break;
                        }

                        // Find all sell orders at this price level
                        // Typically few orders at the exact same price
                        let mut orders_at_price: SmallVec<[_; 8]> = sell_orders
                            .values()
                            .filter(|o| o.price == ask_level.price && !o.is_filled())
                            .collect();

                        // Sort by creation time (oldest first)
                        orders_at_price.sort_by_key(|o| o.creation_time_ns);

                        // Match against each order
                        for sell_order in orders_at_price {
                            if remaining_quantity.is_zero() {
                                break;
                            }

                            // Calculate match quantity
                            let match_quantity =
                                std::cmp::min(remaining_quantity, sell_order.remaining_quantity);

                            // Create a trade
                            let trade = ExecutedTrade {
                                id: Uuid::new_v4(),
                                instrument_id: instrument_id.clone(),
                                maker_order_id: sell_order.id,
                                taker_order_id: order.id,
                                price: sell_order.price,
                                quantity: match_quantity,
                                side: OrderSide::Buy,
                                timestamp_ns: self.clock.raw(),
                            };

                            trades.push(trade);

                            // Update remaining quantities
                            remaining_quantity -= match_quantity;

                            // Store the order to update
                            let new_remaining = sell_order.remaining_quantity - match_quantity;
                            orders_to_update.push((sell_order.id, OrderSide::Sell, new_remaining));
                        }
                    }
                });

                // Now update the sell orders
                let sell_orders = self
                    .sell_orders
                    .get_mut(&instrument_id)
                    .expect("Sell orders should exist after contains_key check");
                for (order_id, _, new_quantity) in orders_to_update {
                    if let Some(order) = sell_orders.get_mut(&order_id) {
                        order.remaining_quantity = new_quantity;
                    }
                }

                // If we have remaining quantity, add it to the order book
                if !remaining_quantity.is_zero() {
                    let limit_order = LimitOrder::new(
                        order.id,
                        Some(order.client_id.clone()),
                        OrderSide::Buy,
                        price,
                        remaining_quantity,
                    );

                    let buy_orders = self
                        .buy_orders
                        .get_mut(&instrument_id)
                        .expect("Buy orders should exist after contains_key check");
                    buy_orders.insert(order.id, limit_order);
                }
            }
            OrderSide::Sell => {
                // Get the order book
                let order_book = self
                    .order_books
                    .get(&instrument_id)
                    .expect("Order book should exist after contains_key check");

                // Get buy orders for reading
                let buy_orders = self
                    .buy_orders
                    .get(&instrument_id)
                    .expect("Buy orders should exist after contains_key check");

                // Match against the order book
                order_book.read(|book| {
                    // Get the bid levels
                    let bids = book.bids();

                    // Match against each bid level that has a price >= our sell price
                    for bid_level in bids {
                        if remaining_quantity.is_zero() || bid_level.price < price {
                            break;
                        }

                        // Find all buy orders at this price level
                        // Typically few orders at the exact same price
                        let mut orders_at_price: SmallVec<[_; 8]> = buy_orders
                            .values()
                            .filter(|o| o.price == bid_level.price && !o.is_filled())
                            .collect();

                        // Sort by creation time (oldest first)
                        orders_at_price.sort_by_key(|o| o.creation_time_ns);

                        // Match against each order
                        for buy_order in orders_at_price {
                            if remaining_quantity.is_zero() {
                                break;
                            }

                            // Calculate match quantity
                            let match_quantity =
                                std::cmp::min(remaining_quantity, buy_order.remaining_quantity);

                            // Create a trade
                            let trade = ExecutedTrade {
                                id: Uuid::new_v4(),
                                instrument_id: instrument_id.clone(),
                                maker_order_id: buy_order.id,
                                taker_order_id: order.id,
                                price: buy_order.price,
                                quantity: match_quantity,
                                side: OrderSide::Sell,
                                timestamp_ns: self.clock.raw(),
                            };

                            trades.push(trade);

                            // Update remaining quantities
                            remaining_quantity -= match_quantity;

                            // Store the order to update
                            let new_remaining = buy_order.remaining_quantity - match_quantity;
                            orders_to_update.push((buy_order.id, OrderSide::Buy, new_remaining));
                        }
                    }
                });

                // Now update the buy orders
                let buy_orders = self
                    .buy_orders
                    .get_mut(&instrument_id)
                    .expect("Buy orders should exist after contains_key check");
                for (order_id, _, new_quantity) in orders_to_update {
                    if let Some(order) = buy_orders.get_mut(&order_id) {
                        order.remaining_quantity = new_quantity;
                    }
                }

                // If we have remaining quantity, add it to the order book
                if !remaining_quantity.is_zero() {
                    let limit_order = LimitOrder::new(
                        order.id,
                        Some(order.client_id.clone()),
                        OrderSide::Sell,
                        price,
                        remaining_quantity,
                    );

                    let sell_orders = self
                        .sell_orders
                        .get_mut(&instrument_id)
                        .expect("Sell orders should exist after contains_key check");
                    sell_orders.insert(order.id, limit_order);
                }
            }
        }

        // Update the order
        order.filled_quantity = order.quantity - remaining_quantity;

        if order.filled_quantity.is_zero() {
            order.status = OrderStatus::Open;
        } else if order.filled_quantity < order.quantity {
            order.status = OrderStatus::PartiallyFilled;
        } else {
            order.status = OrderStatus::Filled;
        }

        // Calculate average fill price
        if !trades.is_empty() {
            let total_value = trades
                .iter()
                .fold(Decimal::ZERO, |acc, trade: &ExecutedTrade| {
                    acc + trade.price * trade.quantity
                });
            let total_quantity = trades
                .iter()
                .fold(Decimal::ZERO, |acc, trade: &ExecutedTrade| {
                    acc + trade.quantity
                });
            order.average_fill_price = Some(total_value / total_quantity);
        }

        // Update the order book
        self.update_order_book(&instrument_id);

        OrderResult {
            order,
            trades,
            error: None,
        }
    }

    /// Cancel an order
    ///
    /// # Panics
    ///
    /// Panics if the instrument exists in `order_books` but not in `buy_orders` or `sell_orders`.
    /// This should never happen in normal operation as these data structures are kept in sync.
    pub fn cancel_order(
        &mut self,
        order_id: OrderId,
        instrument_id: &InstrumentId,
    ) -> Option<Order> {
        // Check if the instrument exists
        if !self.order_books.contains_key(instrument_id) {
            return None;
        }

        // Check if the order exists in the buy orders
        let buy_orders = self.buy_orders.get_mut(instrument_id).unwrap();
        if let Some(order) = buy_orders.remove(&order_id) {
            // Update the order book
            self.update_order_book(instrument_id);

            // Create an Order object to return
            let mut result = Order::new(
                instrument_id.venue,
                instrument_id.symbol.clone(),
                order.side,
                OrderType::Limit,
                order.original_quantity,
                Some(order.price),
                order.client_order_id.unwrap_or_else(|| ClientId::from("")),
            );

            result.id = order_id;
            result.filled_quantity = order.original_quantity - order.remaining_quantity;
            result.status = OrderStatus::Cancelled;

            return Some(result);
        }

        // Check if the order exists in the sell orders
        let sell_orders = self.sell_orders.get_mut(instrument_id).unwrap();
        if let Some(order) = sell_orders.remove(&order_id) {
            // Update the order book
            self.update_order_book(instrument_id);

            // Create an Order object to return
            let mut result = Order::new(
                instrument_id.venue,
                instrument_id.symbol.clone(),
                order.side,
                OrderType::Limit,
                order.original_quantity,
                Some(order.price),
                order.client_order_id.unwrap_or_else(|| ClientId::from("")),
            );

            result.id = order_id;
            result.filled_quantity = order.original_quantity - order.remaining_quantity;
            result.status = OrderStatus::Cancelled;

            return Some(result);
        }

        None
    }

    /// Get the order book for an instrument
    #[must_use]
    pub fn get_order_book(&self, instrument_id: &InstrumentId) -> Option<&SharedSimdOrderBook> {
        self.order_books.get(instrument_id)
    }

    /// Update the order book for an instrument
    fn update_order_book(&self, instrument_id: &InstrumentId) {
        // Get the order book
        let Some(order_book) = self.order_books.get(instrument_id) else {
            return;
        };

        // Get the buy and sell orders
        let buy_orders = self.buy_orders.get(instrument_id).unwrap();
        let sell_orders = self.sell_orders.get(instrument_id).unwrap();

        // Create price levels for the order book
        let mut bids = SmallVec::<[(Decimal, Decimal); 32]>::new();
        let mut asks = SmallVec::<[(Decimal, Decimal); 32]>::new();

        // Aggregate buy orders by price
        let mut buy_levels = FxHashMap::default();
        for order in buy_orders.values() {
            if order.is_filled() {
                continue;
            }

            let entry = buy_levels.entry(order.price).or_insert(Decimal::ZERO);
            *entry += order.remaining_quantity;
        }

        // Aggregate sell orders by price
        let mut sell_levels = FxHashMap::default();
        for order in sell_orders.values() {
            if order.is_filled() {
                continue;
            }

            let entry = sell_levels.entry(order.price).or_insert(Decimal::ZERO);
            *entry += order.remaining_quantity;
        }

        // Convert to vectors
        for (price, quantity) in buy_levels {
            bids.push((price, quantity));
        }

        for (price, quantity) in sell_levels {
            asks.push((price, quantity));
        }

        // Sort bids in descending order by price
        bids.sort_by(|a, b| b.0.cmp(&a.0));

        // Sort asks in ascending order by price
        asks.sort_by(|a, b| a.0.cmp(&b.0));

        // Update the order book
        order_book.write(|book| {
            // Create a snapshot from the current state
            let snapshot: OrderBookSnapshot<64> =
                crate::data::book_snapshot::OrderBookSnapshot::new(
                    instrument_id.clone(),
                    bids.iter()
                        .map(|(price, quantity)| {
                            crate::data::orderbook::PriceLevel::new(*price, *quantity)
                        })
                        .collect(),
                    asks.iter()
                        .map(|(price, quantity)| {
                            crate::data::orderbook::PriceLevel::new(*price, *quantity)
                        })
                        .collect(),
                    0,                // sequence_id - not used in this context
                    self.clock.raw(), // timestamp_event
                    self.clock.raw(), // timestamp_init
                );
            book.apply_snapshot(snapshot);
        });
    }

    /// Clean up filled orders
    pub fn clean_up_filled_orders(&mut self) {
        // Collect instrument IDs that need to be updated
        // Typically a small number of instruments are active
        let instrument_ids: SmallVec<[InstrumentId; 16]> =
            self.buy_orders.keys().cloned().collect();

        // First, clean up all buy and sell orders
        for instrument_id in &instrument_ids {
            // Clean up buy orders
            if let Some(buy_orders) = self.buy_orders.get_mut(instrument_id) {
                buy_orders.retain(|_, order| !order.is_filled());
            }

            // Clean up sell orders
            if let Some(sell_orders) = self.sell_orders.get_mut(instrument_id) {
                sell_orders.retain(|_, order| !order.is_filled());
            }
        }

        // Then, update all order books
        for instrument_id in instrument_ids {
            self.update_order_book(&instrument_id);
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::types::ClientId;
    use crate::venues::Venue;
    use rust_decimal_macros::dec;

    fn create_instrument_id() -> InstrumentId {
        InstrumentId::new(String::from("BTCUSDT"), Venue::Binance)
    }

    #[test]
    fn test_matching_engine_creation() {
        let mut engine = MatchingEngine::new();
        let instrument_id = create_instrument_id();

        engine.add_instrument(instrument_id.clone());

        assert!(engine.order_books.contains_key(&instrument_id));
        assert!(engine.buy_orders.contains_key(&instrument_id));
        assert!(engine.sell_orders.contains_key(&instrument_id));
    }

    #[test]
    fn test_limit_order_matching() {
        let mut engine = MatchingEngine::new();
        let instrument_id = create_instrument_id();

        engine.add_instrument(instrument_id.clone());

        // Create a buy limit order
        let buy_order = Order::new(
            Venue::Binance,
            String::from("BTCUSDT"),
            OrderSide::Buy,
            OrderType::Limit,
            dec!(1.0),
            Some(dec!(100.0)),
            ClientId::from("client1"),
        );

        // Process the buy order
        let result = engine.process_order(buy_order);

        // Check that the order was accepted
        assert_eq!(result.order.status, OrderStatus::Open);
        assert!(result.trades.is_empty());

        // Create a sell limit order at a higher price
        let sell_order_higher = Order::new(
            Venue::Binance,
            String::from("BTCUSDT"),
            OrderSide::Sell,
            OrderType::Limit,
            dec!(1.0),
            Some(dec!(110.0)),
            ClientId::from("client2"),
        );

        // Process the sell order
        let result = engine.process_order(sell_order_higher);

        // Check that the order was accepted but not matched
        assert_eq!(result.order.status, OrderStatus::Open);
        assert!(result.trades.is_empty());

        // Create a sell limit order at a matching price
        let sell_order_matching = Order::new(
            Venue::Binance,
            "BTCUSDT",
            OrderSide::Sell,
            OrderType::Limit,
            dec!(0.5),
            Some(dec!(100.0)),
            ClientId::from("client3"),
        );

        // Process the sell order
        let result = engine.process_order(sell_order_matching);

        // Check that the order was partially filled
        assert_eq!(result.order.status, OrderStatus::Filled);
        assert_eq!(result.trades.len(), 1);
        assert_eq!(result.trades[0].price, dec!(100.0));
        assert_eq!(result.trades[0].quantity, dec!(0.5));

        // Create another sell limit order at a matching price
        let sell_order_matching2 = Order::new(
            Venue::Binance,
            "BTCUSDT",
            OrderSide::Sell,
            OrderType::Limit,
            dec!(0.5),
            Some(dec!(100.0)),
            ClientId::from("client4"),
        );

        // Process the sell order
        let result = engine.process_order(sell_order_matching2);

        // Check that the order was filled
        assert_eq!(result.order.status, OrderStatus::Filled);
        assert_eq!(result.trades.len(), 1);
        assert_eq!(result.trades[0].price, dec!(100.0));
        assert_eq!(result.trades[0].quantity, dec!(0.5));

        // Check the order book
        let order_book = engine.get_order_book(&instrument_id).unwrap();

        order_book.read(|book| {
            // The buy order should be fully matched
            assert!(book.bids().is_empty());

            // The higher-priced sell order should still be there
            assert_eq!(book.asks().len(), 1);
            assert_eq!(book.asks()[0].price, dec!(110.0));
            assert_eq!(book.asks()[0].quantity, dec!(1.0));
        });
    }

    #[test]
    fn test_market_order_matching() {
        let mut engine = MatchingEngine::new();
        let instrument_id = create_instrument_id();

        engine.add_instrument(instrument_id.clone());

        // Create a sell limit order
        let sell_order = Order::new(
            Venue::Binance,
            "BTCUSDT",
            OrderSide::Sell,
            OrderType::Limit,
            dec!(1.0),
            Some(dec!(100.0)),
            ClientId::from("client1"),
        );

        // Process the sell order
        let result = engine.process_order(sell_order);

        // Check that the order was accepted
        assert_eq!(result.order.status, OrderStatus::Open);
        assert!(result.trades.is_empty());

        // Create a buy market order
        let buy_order = Order::new(
            Venue::Binance,
            "BTCUSDT",
            OrderSide::Buy,
            OrderType::Market,
            dec!(0.5),
            None,
            ClientId::from("client2"),
        );

        // Process the buy order
        let result = engine.process_order(buy_order);

        // Check that the order was filled
        assert_eq!(result.order.status, OrderStatus::Filled);
        assert_eq!(result.trades.len(), 1);
        assert_eq!(result.trades[0].price, dec!(100.0));
        assert_eq!(result.trades[0].quantity, dec!(0.5));

        // Create another buy market order that can't be fully filled
        let buy_order2 = Order::new(
            Venue::Binance,
            "BTCUSDT",
            OrderSide::Buy,
            OrderType::Market,
            dec!(1.0),
            None,
            ClientId::from("client3"),
        );

        // Process the buy order
        let result = engine.process_order(buy_order2);

        // Check that the order was partially filled
        assert_eq!(result.order.status, OrderStatus::PartiallyFilled);
        assert_eq!(result.trades.len(), 1);
        assert_eq!(result.trades[0].price, dec!(100.0));
        assert_eq!(result.trades[0].quantity, dec!(0.5));

        // Check the order book
        let order_book = engine.get_order_book(&instrument_id).unwrap();

        order_book.read(|book| {
            // The sell order should be fully matched
            assert!(book.asks().is_empty());
        });
    }

    #[test]
    fn test_cancel_order() {
        let mut engine = MatchingEngine::new();
        let instrument_id = create_instrument_id();

        engine.add_instrument(instrument_id.clone());

        // Create a buy limit order
        let buy_order = Order::new(
            Venue::Binance,
            "BTCUSDT",
            OrderSide::Buy,
            OrderType::Limit,
            dec!(1.0),
            Some(dec!(100.0)),
            ClientId::from("client1"),
        );

        // Process the buy order
        let result = engine.process_order(buy_order);

        // Check that the order was accepted
        assert_eq!(result.order.status, OrderStatus::Open);

        // Cancel the order
        let canceled_order = engine.cancel_order(result.order.id, &instrument_id);

        // Check that the order was canceled
        assert!(canceled_order.is_some());
        let canceled_order = canceled_order.unwrap();
        assert_eq!(canceled_order.status, OrderStatus::Cancelled);

        // Check the order book
        let order_book = engine.get_order_book(&instrument_id).unwrap();

        order_book.read(|book| {
            // The buy order should be removed
            assert!(book.bids().is_empty());
        });
    }

    #[test]
    fn test_clean_up_filled_orders() {
        let mut engine = MatchingEngine::new();
        let instrument_id = create_instrument_id();

        engine.add_instrument(instrument_id.clone());

        // Create a buy limit order
        let buy_order = Order::new(
            Venue::Binance,
            "BTCUSDT",
            OrderSide::Buy,
            OrderType::Limit,
            dec!(1.0),
            Some(dec!(100.0)),
            ClientId::from("client1"),
        );

        // Process the buy order
        let _result = engine.process_order(buy_order);

        // Create a sell limit order at a matching price
        let sell_order = Order::new(
            Venue::Binance,
            "BTCUSDT",
            OrderSide::Sell,
            OrderType::Limit,
            dec!(1.0),
            Some(dec!(100.0)),
            ClientId::from("client2"),
        );

        // Process the sell order
        let result = engine.process_order(sell_order);

        // Check that the order was filled
        assert_eq!(result.order.status, OrderStatus::Filled);

        // Clean up filled orders
        engine.clean_up_filled_orders();

        // Check the order book
        let order_book = engine.get_order_book(&instrument_id).unwrap();

        order_book.read(|book| {
            // Both orders should be removed
            assert!(book.bids().is_empty());
            assert!(book.asks().is_empty());
        });
    }
}