hypercall_engine/

orderbook.rs

//! Pure orderbook data structure and matching engine.
//!
//! This module provides [`OrderBook`], a price-time priority limit order book
//! for a single instrument. It supports:
//!
//! - Adding and cancelling orders with full metadata
//! - Incremental matching (one maker at a time) with self-trade prevention
//! - L2 (price-level) snapshot and incremental diff computation
//! - Snapshot/restore for WAL-based persistence
//!
//! # Design
//!
//! The orderbook is a **pure data structure** with no async runtime, no channels,
//! and no side effects. All operations are synchronous and deterministic.
//!
//! Event emission is handled by the caller. The orderbook computes L2 diffs and
//! returns fill results, but never sends events itself. The runtime layer in the
//! `hypercall` crate is responsible for routing these to WebSocket clients,
//! persistence, and downstream caches.
//!
//! # Price-level storage
//!
//! Bids are stored in a `BTreeMap` keyed by negated price for descending order.
//! Asks are stored with natural (ascending) price keys. Within each price level,
//! orders are stored in a `VecDeque` for FIFO (time priority) matching.

use hypercall_types::{
    Fill, L2Message, L2Update, OptionType, OrderbookUpdate, Side, TradeMessage, TradeSide,
    WalletAddress,
};
use rust_decimal::Decimal;
use rust_decimal_macros::dec;
use std::collections::{BTreeMap, HashMap, VecDeque};
use tracing::{debug, error, info, warn};

/// Result of attempting to match a single maker order.
#[derive(Debug, Clone)]
pub enum MatchResult {
    /// Successful fill.
    Fill(Fill),
    /// Self-trade detected -- contains maker order ID that should be cancelled.
    SelfTrade { maker_order_id: u64 },
    /// No match possible (price does not cross or no liquidity).
    NoMatch,
}

/// An order resting on a price level.
#[derive(Debug, Clone)]
pub struct Order {
    pub id: u64,
    pub price: Decimal,
    pub quantity: Decimal,
    pub side: Side,
    pub timestamp: u64,
}

/// Metadata stored alongside the price-level [`Order`].
///
/// Keeps the hot-path `Order` struct lean (used in matching) while storing
/// extra metadata needed for snapshot persistence and order index rebuild.
#[derive(Debug, Clone)]
struct OrderMeta {
    side: Side,
    price: Decimal,
    wallet: WalletAddress,
    client_id: Option<String>,
    mmp_enabled: bool,
    original_size: Decimal,
}

/// Full order record returned by [`OrderBook::get_all_orders`] and accepted
/// by [`OrderBook::restore_from_orders`].
#[derive(Debug, Clone)]
pub struct OrderRecord {
    pub order_id: u64,
    pub price: Decimal,
    pub quantity: Decimal,
    pub side: Side,
    pub wallet: WalletAddress,
    pub timestamp: u64,
    pub client_id: Option<String>,
    pub mmp_enabled: bool,
    pub original_size: Decimal,
}

#[derive(Debug, Clone)]
struct PriceLevel {
    price: Decimal,
    orders: VecDeque<Order>,
    total_quantity: Decimal,
}

impl PriceLevel {
    fn new(price: Decimal) -> Self {
        Self {
            price,
            orders: VecDeque::new(),
            total_quantity: dec!(0),
        }
    }

    fn add_order(&mut self, order: Order) {
        self.total_quantity += order.quantity;
        self.orders.push_back(order);
    }

    fn remove_order(&mut self, order_id: u64) -> Option<Order> {
        if let Some(pos) = self.orders.iter().position(|o| o.id == order_id) {
            let order = self.orders.remove(pos)?;
            self.total_quantity -= order.quantity;
            Some(order)
        } else {
            None
        }
    }

    fn is_empty(&self) -> bool {
        self.orders.is_empty()
    }
}

/// Events produced by orderbook operations.
///
/// The caller collects these from [`OrderBook::drain_events`] after each
/// mutation and routes them to the appropriate downstream consumers
/// (WebSocket clients, persistence, metrics).
#[derive(Debug, Clone)]
pub enum OrderBookEvent {
    /// An order was filled (a trade occurred).
    OrderFilled(Fill),
    /// A trade message for the public trade feed.
    Trade(TradeMessage),
    /// Incremental L2 (price-level) update.
    L2Update(L2Message),
    /// Full orderbook snapshot (legacy, for backward compatibility).
    OrderbookUpdated(OrderbookUpdate),
}

/// A pure, synchronous limit order book for a single instrument.
///
/// All state transitions are deterministic. Events are collected into an
/// internal buffer and must be drained by the caller via [`drain_events`](Self::drain_events).
#[derive(Debug, Clone)]
pub struct OrderBook {
    pub expiry: u64,
    pub strike: Decimal,
    pub option_type: OptionType,
    pub symbol: String,
    bids: BTreeMap<Decimal, PriceLevel>, // Keys are negated for descending order
    asks: BTreeMap<Decimal, PriceLevel>,
    orders: HashMap<u64, OrderMeta>,
    /// Buffered events produced by the last operation.
    pending_events: Vec<OrderBookEvent>,
    pub last_bid_snapshot: Vec<(Decimal, Decimal)>,
    pub last_ask_snapshot: Vec<(Decimal, Decimal)>,
    pub pending_l2_sequence: Option<i64>,
}

impl OrderBook {
    fn remove_order_from_side_at_price(
        book: &mut BTreeMap<Decimal, PriceLevel>,
        price_key: Decimal,
        order_id: u64,
    ) -> Option<Order> {
        let (order, remove_level) = {
            let level = book.get_mut(&price_key)?;
            let order = level.remove_order(order_id);
            let remove_level = level.is_empty();
            (order, remove_level)
        };

        if remove_level {
            book.remove(&price_key);
        }

        order
    }

    fn remove_order_from_side_anywhere(
        book: &mut BTreeMap<Decimal, PriceLevel>,
        order_id: u64,
    ) -> Option<Order> {
        let price_key = book.iter().find_map(|(price_key, level)| {
            level
                .orders
                .iter()
                .any(|order| order.id == order_id)
                .then_some(*price_key)
        })?;

        Self::remove_order_from_side_at_price(book, price_key, order_id)
    }

    pub fn new(expiry: u64, strike: Decimal, option_type: OptionType) -> Self {
        Self::with_symbol(expiry, strike, option_type, String::new())
    }

    pub fn with_symbol(
        expiry: u64,
        strike: Decimal,
        option_type: OptionType,
        symbol: String,
    ) -> Self {
        Self {
            expiry,
            strike,
            option_type,
            symbol,
            bids: BTreeMap::new(),
            asks: BTreeMap::new(),
            orders: HashMap::new(),
            pending_events: Vec::new(),
            last_bid_snapshot: Vec::new(),
            last_ask_snapshot: Vec::new(),
            pending_l2_sequence: None,
        }
    }

    /// Drain all pending events produced by recent operations.
    ///
    /// The caller must drain events after each mutation to forward them to
    /// downstream consumers. Events are returned in the order they were produced.
    pub fn drain_events(&mut self) -> Vec<OrderBookEvent> {
        std::mem::take(&mut self.pending_events)
    }

    pub fn add_order(
        &mut self,
        order_id: u64,
        price: Decimal,
        quantity: Decimal,
        side: Side,
        timestamp: u64,
    ) {
        self.add_order_with_wallet(
            order_id,
            price,
            quantity,
            side,
            WalletAddress::from(alloy::primitives::Address::ZERO),
            timestamp,
        )
    }

    pub fn set_pending_l2_sequence(&mut self, sequence: i64) {
        self.pending_l2_sequence = Some(sequence);
    }

    pub fn add_order_with_wallet(
        &mut self,
        order_id: u64,
        price: Decimal,
        quantity: Decimal,
        side: Side,
        wallet: WalletAddress,
        timestamp: u64,
    ) {
        self.add_order_with_metadata(
            order_id, price, quantity, side, wallet, timestamp, None, false, quantity,
        );
    }

    /// Add an order with full metadata (client_id, mmp_enabled, original_size).
    ///
    /// Production code paths should prefer this over `add_order_with_wallet()`
    /// so that metadata survives WAL snapshot round-trips.
    pub fn add_order_with_metadata(
        &mut self,
        order_id: u64,
        price: Decimal,
        quantity: Decimal,
        side: Side,
        wallet: WalletAddress,
        timestamp: u64,
        client_id: Option<String>,
        mmp_enabled: bool,
        original_size: Decimal,
    ) {
        let order = Order {
            id: order_id,
            price,
            quantity,
            side,
            timestamp,
        };

        let price_key = match side {
            Side::Buy => -price,
            Side::Sell => price,
        };

        let book = match side {
            Side::Buy => &mut self.bids,
            Side::Sell => &mut self.asks,
        };

        self.orders.insert(
            order_id,
            OrderMeta {
                side,
                price,
                wallet,
                client_id,
                mmp_enabled,
                original_size,
            },
        );

        book.entry(price_key)
            .or_insert_with(|| PriceLevel::new(price))
            .add_order(order);
    }

    /// O(1) count of live orders in this book.
    pub fn order_count(&self) -> usize {
        self.orders.len()
    }

    /// Append lightweight `(order_id, wallet)` pairs for live orders.
    ///
    /// This avoids constructing full [`OrderRecord`] values when callers only
    /// need ownership metadata for snapshot fallback paths.
    pub fn append_order_wallets(&self, out: &mut Vec<(u64, WalletAddress)>) {
        out.extend(
            self.orders
                .iter()
                .map(|(order_id, meta)| (*order_id, meta.wallet)),
        );
    }

    /// Check if an order exists in the orderbook.
    pub fn has_order(&self, order_id: u64) -> bool {
        self.orders.contains_key(&order_id)
    }

    /// Get all order IDs in this orderbook.
    pub fn get_all_order_ids(&self) -> Vec<u64> {
        self.orders.keys().copied().collect()
    }

    pub fn cancel_order(&mut self, order_id: u64) -> Option<Order> {
        let meta = self.orders.remove(&order_id)?;
        let (side, price) = (meta.side, meta.price);

        let price_key = match side {
            Side::Buy => -price,
            Side::Sell => price,
        };

        let book = match side {
            Side::Buy => &mut self.bids,
            Side::Sell => &mut self.asks,
        };

        if let Some(level) = book.get_mut(&price_key) {
            let order = level.remove_order(order_id);
            if level.is_empty() {
                book.remove(&price_key);
            }
            order
        } else {
            None
        }
    }

    /// Recovery-only cancel path.
    ///
    /// During replay, the cancel command is authoritative. If a stale snapshot
    /// left an order at the wrong price level, wrong side, or with missing
    /// metadata, scrub that `order_id` from the book instead of leaving a
    /// ghost order that can cross a newer replayed order.
    pub fn cancel_order_for_replay(&mut self, order_id: u64) -> Option<Order> {
        let meta = self.orders.get(&order_id).cloned();

        let removed = if let Some(meta) = meta.as_ref() {
            let price_key = match meta.side {
                Side::Buy => -meta.price,
                Side::Sell => meta.price,
            };

            let primary = match meta.side {
                Side::Buy => {
                    Self::remove_order_from_side_at_price(&mut self.bids, price_key, order_id)
                }
                Side::Sell => {
                    Self::remove_order_from_side_at_price(&mut self.asks, price_key, order_id)
                }
            };

            if primary.is_some() {
                primary
            } else {
                let fallback = Self::remove_order_from_side_anywhere(&mut self.bids, order_id)
                    .or_else(|| Self::remove_order_from_side_anywhere(&mut self.asks, order_id));

                if fallback.is_some() {
                    error!(
                        "RECOVERY_INVARIANT: order {} for {} was not present at replay cancel target {:?}@{}; removed via full-book scan",
                        order_id, self.symbol, meta.side, meta.price
                    );
                }

                fallback
            }
        } else {
            let fallback = Self::remove_order_from_side_anywhere(&mut self.bids, order_id)
                .or_else(|| Self::remove_order_from_side_anywhere(&mut self.asks, order_id));

            if fallback.is_some() {
                error!(
                    "RECOVERY_INVARIANT: order {} for {} existed in price levels without metadata during replay cancel; removed ghost order",
                    order_id, self.symbol
                );
            }

            fallback
        };

        let removed_meta = self.orders.remove(&order_id);
        if removed.is_none() && removed_meta.is_some() {
            error!(
                "RECOVERY_INVARIANT: replay cancel removed metadata-only ghost order {} from {}",
                order_id, self.symbol
            );
        }

        removed
    }

    /// Reduce an order's quantity by `qty`. If remaining quantity hits zero,
    /// the order is removed from the book. Returns `true` if the order was
    /// fully consumed (removed), `false` if partially reduced or not found.
    ///
    /// Used during journal replay to apply fills that occurred after the
    /// maker's original command was replayed.
    pub fn reduce_order_quantity(&mut self, order_id: u64, qty: Decimal) -> bool {
        let (side, price) = match self.orders.get(&order_id) {
            Some(meta) => (meta.side, meta.price),
            None => return false,
        };

        let price_key = match side {
            Side::Buy => -price,
            Side::Sell => price,
        };

        let book = match side {
            Side::Buy => &mut self.bids,
            Side::Sell => &mut self.asks,
        };

        if let Some(level) = book.get_mut(&price_key) {
            if let Some(order) = level.orders.iter_mut().find(|o| o.id == order_id) {
                order.quantity -= qty;
                level.total_quantity -= qty;

                if order.quantity <= dec!(0) {
                    // Fully consumed -- remove from the book
                    level.remove_order(order_id);
                    if level.is_empty() {
                        book.remove(&price_key);
                    }
                    self.orders.remove(&order_id);
                    return true;
                }
            }
        }
        false
    }

    pub fn get_best_bid(&self) -> Option<Decimal> {
        self.bids.keys().next().map(|k| -(*k))
    }

    pub fn get_best_ask(&self) -> Option<Decimal> {
        self.asks.keys().next().copied()
    }

    /// Returns true if the orderbook is in a crossed state (best bid >= best ask).
    pub fn is_crossed(&self) -> bool {
        if let (Some(best_bid), Some(best_ask)) = (self.get_best_bid(), self.get_best_ask()) {
            best_bid >= best_ask
        } else {
            false
        }
    }

    pub fn get_bid_depth(&self) -> Vec<(Decimal, Decimal)> {
        self.bids
            .values()
            .map(|level| (level.price, level.total_quantity))
            .collect()
    }

    pub fn get_ask_depth(&self) -> Vec<(Decimal, Decimal)> {
        self.asks
            .values()
            .map(|level| (level.price, level.total_quantity))
            .collect()
    }

    pub fn get_spread(&self) -> Option<Decimal> {
        match (self.get_best_bid(), self.get_best_ask()) {
            (Some(bid), Some(ask)) => Some(ask - bid),
            _ => None,
        }
    }

    pub fn total_bid_volume(&self) -> Decimal {
        self.bids.values().map(|level| level.total_quantity).sum()
    }

    pub fn total_ask_volume(&self) -> Decimal {
        self.asks.values().map(|level| level.total_quantity).sum()
    }

    /// Process an order incrementally -- matches one maker order at a time.
    ///
    /// Convenience wrapper that stores default metadata. Tests should use this;
    /// production callers should prefer `process_order_with_metadata()`.
    pub fn process_order(
        &mut self,
        order_id: u64,
        price: Decimal,
        quantity: Decimal,
        side: Side,
        wallet: WalletAddress,
        timestamp: u64,
        trade_id: u64,
    ) -> (MatchResult, bool) {
        self.process_order_with_metadata(
            order_id, price, quantity, side, wallet, timestamp, trade_id, None, false, quantity,
        )
    }

    /// Process an order incrementally with full metadata.
    ///
    /// Returns: `(MatchResult, bool)`
    ///   - `MatchResult`: The result of matching (Fill, SelfTrade, or NoMatch)
    ///   - `bool`: Whether more matching is possible (`true` = can call again,
    ///     `false` = order complete/rejected/self-trade)
    ///
    /// Note: For SelfTrade result, the order is NOT added to the book.
    /// The caller must handle cancellation.
    ///
    /// Events (fills, L2 updates, orderbook snapshots) are buffered internally.
    /// Call [`drain_events`](Self::drain_events) to retrieve them.
    pub fn process_order_with_metadata(
        &mut self,
        order_id: u64,
        price: Decimal,
        quantity: Decimal,
        side: Side,
        wallet: WalletAddress,
        timestamp: u64,
        trade_id: u64,
        client_id: Option<String>,
        mmp_enabled: bool,
        original_size: Decimal,
    ) -> (MatchResult, bool) {
        debug!(
            "Processing order incrementally: symbol={}, price={}, quantity={}, side={:?}, wallet={}",
            self.symbol, price, quantity, side, wallet
        );

        if quantity == dec!(0) {
            return (MatchResult::NoMatch, false);
        }

        // Try to match one maker order
        match self.try_match_one_maker(
            order_id, price, quantity, &side, &wallet, timestamp, trade_id,
        ) {
            MatchResult::Fill(fill) => {
                // Emit events for the fill
                self.emit_events(std::slice::from_ref(&fill), timestamp);

                // Check if more matching is possible
                let remaining = quantity - fill.size;
                let has_more = remaining > dec!(0) && self.has_more_liquidity(&side, price);

                (MatchResult::Fill(fill), has_more)
            }
            MatchResult::SelfTrade { maker_order_id } => {
                // Self-trade detected - DO NOT add order to book
                // Caller (unified_engine) will handle cancelling both orders
                (MatchResult::SelfTrade { maker_order_id }, false)
            }
            MatchResult::NoMatch => {
                // No match - add order to book and emit events
                self.add_order_to_book_with_events_full(
                    order_id,
                    price,
                    quantity,
                    side,
                    wallet,
                    timestamp,
                    client_id,
                    mmp_enabled,
                    original_size,
                );
                // Return false for should_continue since order is now in the book
                (MatchResult::NoMatch, false)
            }
        }
    }

    /// Try to match with one maker order.
    fn try_match_one_maker(
        &mut self,
        order_id: u64,
        price: Decimal,
        quantity: Decimal,
        side: &Side,
        wallet: &WalletAddress,
        timestamp: u64,
        trade_id: u64,
    ) -> MatchResult {
        match side {
            Side::Buy => self.try_match_buy(order_id, price, quantity, wallet, timestamp, trade_id),
            Side::Sell => {
                self.try_match_sell(order_id, price, quantity, wallet, timestamp, trade_id)
            }
        }
    }

    /// Try to match a buy order with the best ask.
    fn try_match_buy(
        &mut self,
        order_id: u64,
        price: Decimal,
        quantity: Decimal,
        wallet: &WalletAddress,
        timestamp: u64,
        trade_id: u64,
    ) -> MatchResult {
        let best_ask_price = match self.get_best_ask() {
            Some(p) => p,
            None => return MatchResult::NoMatch,
        };
        if best_ask_price > price {
            return MatchResult::NoMatch;
        }

        let price_key = best_ask_price;
        let level = match self.asks.get_mut(&price_key) {
            Some(l) => l,
            None => return MatchResult::NoMatch,
        };
        let maker_order = match level.orders.front().cloned() {
            Some(o) => o,
            None => return MatchResult::NoMatch,
        };

        let maker_id = maker_order.id;
        let maker_wallet = match self.orders.get(&maker_id) {
            Some(meta) => meta.wallet,
            None => {
                // Data inconsistency: order in price level but not in orders map
                warn!(
                    "Data inconsistency: maker_order_id={} in ask level but not in orders map, symbol={}",
                    maker_id, self.symbol
                );
                return MatchResult::NoMatch;
            }
        };

        // SELF-TRADE CHECK: Compare taker wallet with maker wallet
        if wallet == &maker_wallet {
            warn!(
                "STP_AUDIT: self-trade on BUY side: symbol={}, taker_id={}, taker_price={}, taker_qty={}, maker_id={}, maker_price={}, maker_qty={}, wallet={}",
                self.symbol, order_id, price, quantity,
                maker_id, best_ask_price, maker_order.quantity, wallet
            );
            return MatchResult::SelfTrade {
                maker_order_id: maker_id,
            };
        }

        let match_quantity = maker_order.quantity.min(quantity);

        info!(
            "MATCH FOUND: Buy order matched with ask - price={}, quantity={}, maker_id={}, trade_id={}",
            best_ask_price, match_quantity, maker_id, trade_id
        );

        // Update or remove maker order
        if match_quantity >= maker_order.quantity {
            self.cancel_order(maker_id);
        } else if let Some(level) = self.asks.get_mut(&price_key) {
            if let Some(order) = level.orders.front_mut() {
                order.quantity -= match_quantity;
                level.total_quantity -= match_quantity;
            }
        }

        MatchResult::Fill(Fill {
            trade_id,
            taker_order_id: order_id,
            maker_order_id: maker_id,
            symbol: self.symbol.clone(),
            price: best_ask_price,
            size: match_quantity,
            taker_side: Side::Buy,
            taker_wallet_address: *wallet,
            maker_wallet_address: maker_wallet,
            fee: dec!(0),
            is_taker: true,
            timestamp,
            builder_code_address: None,
            builder_code_fee: None,
            source: Default::default(),
            taker_realized_pnl: None,
            maker_realized_pnl: None,
            underlying_notional: None,
        })
    }

    /// Try to match a sell order with the best bid.
    fn try_match_sell(
        &mut self,
        order_id: u64,
        price: Decimal,
        quantity: Decimal,
        wallet: &WalletAddress,
        timestamp: u64,
        trade_id: u64,
    ) -> MatchResult {
        let best_bid_price = match self.get_best_bid() {
            Some(p) => p,
            None => return MatchResult::NoMatch,
        };
        if best_bid_price < price {
            return MatchResult::NoMatch;
        }

        let price_key = -best_bid_price;
        let level = match self.bids.get_mut(&price_key) {
            Some(l) => l,
            None => return MatchResult::NoMatch,
        };
        let maker_order = match level.orders.front().cloned() {
            Some(o) => o,
            None => return MatchResult::NoMatch,
        };

        let maker_id = maker_order.id;
        let maker_wallet = match self.orders.get(&maker_id) {
            Some(meta) => meta.wallet,
            None => {
                // Data inconsistency: order in price level but not in orders map
                warn!(
                    "Data inconsistency: maker_order_id={} in bid level but not in orders map, symbol={}",
                    maker_id, self.symbol
                );
                return MatchResult::NoMatch;
            }
        };

        // SELF-TRADE CHECK: Compare taker wallet with maker wallet
        if wallet == &maker_wallet {
            warn!(
                "STP_AUDIT: self-trade on SELL side: symbol={}, taker_id={}, taker_price={}, taker_qty={}, maker_id={}, maker_price={}, maker_qty={}, wallet={}",
                self.symbol, order_id, price, quantity,
                maker_id, best_bid_price, maker_order.quantity, wallet
            );
            return MatchResult::SelfTrade {
                maker_order_id: maker_id,
            };
        }

        let match_quantity = maker_order.quantity.min(quantity);

        info!(
            "MATCH FOUND: Sell order matched with bid - price={}, quantity={}, maker_id={}, trade_id={}",
            best_bid_price, match_quantity, maker_id, trade_id
        );

        // Update or remove maker order
        if match_quantity >= maker_order.quantity {
            self.cancel_order(maker_id);
        } else if let Some(level) = self.bids.get_mut(&price_key) {
            if let Some(order) = level.orders.front_mut() {
                order.quantity -= match_quantity;
                level.total_quantity -= match_quantity;
            }
        }

        MatchResult::Fill(Fill {
            trade_id,
            taker_order_id: order_id,
            maker_order_id: maker_id,
            symbol: self.symbol.clone(),
            price: best_bid_price,
            size: match_quantity,
            taker_side: Side::Sell,
            taker_wallet_address: *wallet,
            maker_wallet_address: maker_wallet,
            fee: dec!(0),
            is_taker: true,
            timestamp,
            builder_code_address: None,
            builder_code_fee: None,
            source: Default::default(),
            taker_realized_pnl: None,
            maker_realized_pnl: None,
            underlying_notional: None,
        })
    }

    /// Check if there is more liquidity available at the given price.
    fn has_more_liquidity(&self, side: &Side, price: Decimal) -> bool {
        match side {
            Side::Buy => self.get_best_ask().is_some_and(|ask| ask <= price),
            Side::Sell => self.get_best_bid().is_some_and(|bid| bid >= price),
        }
    }

    /// Add order to book and emit L2 and orderbook update events.
    pub fn add_order_to_book_with_events(
        &mut self,
        order_id: u64,
        price: Decimal,
        quantity: Decimal,
        side: Side,
        wallet: WalletAddress,
        timestamp: u64,
    ) {
        self.add_order_to_book_with_events_full(
            order_id, price, quantity, side, wallet, timestamp, None, false, quantity,
        );
    }

    /// Add order to book with full metadata and emit L2/orderbook update events.
    ///
    /// Production code paths should prefer this over `add_order_to_book_with_events()`
    /// so that metadata survives WAL snapshot round-trips.
    pub fn add_order_to_book_with_events_full(
        &mut self,
        order_id: u64,
        price: Decimal,
        quantity: Decimal,
        side: Side,
        wallet: WalletAddress,
        timestamp: u64,
        client_id: Option<String>,
        mmp_enabled: bool,
        original_size: Decimal,
    ) {
        info!(
            "No match found - adding {} to orderbook at price {}",
            quantity, price
        );
        self.add_order_with_metadata(
            order_id,
            price,
            quantity,
            side,
            wallet,
            timestamp,
            client_id,
            mmp_enabled,
            original_size,
        );

        let (bids, asks) = self.get_orderbook_snapshot();
        let l2_update = self.compute_l2_updates(&bids, &asks);
        let sequence = self.pending_l2_sequence.take();

        // Emit L2 update if there are changes
        if !l2_update.bid_updates.is_empty() || !l2_update.ask_updates.is_empty() {
            let l2_msg = L2Message {
                symbol: self.symbol.clone(),
                bid_updates: l2_update.bid_updates,
                ask_updates: l2_update.ask_updates,
                timestamp,
                sequence,
            };
            self.pending_events.push(OrderBookEvent::L2Update(l2_msg));
        }

        // Store current snapshot
        self.last_bid_snapshot = bids.clone();
        self.last_ask_snapshot = asks.clone();

        // Emit legacy orderbook update
        let update = OrderbookUpdate {
            symbol: self.symbol.clone(),
            bids,
            asks,
            timestamp,
        };
        self.pending_events
            .push(OrderBookEvent::OrderbookUpdated(update));
    }

    fn emit_events(&mut self, fills: &[Fill], timestamp: u64) {
        // Emit fill events
        for fill in fills {
            self.pending_events
                .push(OrderBookEvent::OrderFilled(fill.clone()));

            // Also emit TradeMessage
            let trade_msg = TradeMessage {
                symbol: self.symbol.clone(),
                price: fill.price,
                size: fill.size,
                side: match fill.taker_side {
                    Side::Buy => TradeSide::Buy,
                    Side::Sell => TradeSide::Sell,
                },
                timestamp: fill.timestamp,
            };
            self.pending_events.push(OrderBookEvent::Trade(trade_msg));
        }

        // Get current orderbook snapshot
        let (bids, asks) = self.get_orderbook_snapshot();

        // Emit L2 updates (incremental changes)
        let l2_update = self.compute_l2_updates(&bids, &asks);
        let sequence = self.pending_l2_sequence.take();
        if !l2_update.bid_updates.is_empty() || !l2_update.ask_updates.is_empty() {
            let l2_msg = L2Message {
                symbol: self.symbol.clone(),
                bid_updates: l2_update.bid_updates,
                ask_updates: l2_update.ask_updates,
                timestamp,
                sequence,
            };
            self.pending_events.push(OrderBookEvent::L2Update(l2_msg));
        }

        // Store current snapshot for next update
        self.last_bid_snapshot = bids.clone();
        self.last_ask_snapshot = asks.clone();

        // Also emit legacy orderbook update for backward compatibility
        let update = OrderbookUpdate {
            symbol: self.symbol.clone(),
            bids,
            asks,
            timestamp,
        };
        self.pending_events
            .push(OrderBookEvent::OrderbookUpdated(update));
    }

    pub fn get_orderbook_snapshot(&self) -> (Vec<(Decimal, Decimal)>, Vec<(Decimal, Decimal)>) {
        let bids = self.get_bid_depth();
        let asks = self.get_ask_depth();
        (bids, asks)
    }

    /// Sync the L2 snapshot baseline to the current orderbook state.
    ///
    /// Must be called after journal replay so that subsequent L2 diffs
    /// are computed against the replayed state, not against an empty book.
    pub fn sync_l2_snapshot_baseline(&mut self) {
        let (bids, asks) = self.get_orderbook_snapshot();
        self.last_bid_snapshot = bids;
        self.last_ask_snapshot = asks;
    }

    /// Emit L2 and orderbook update events after a modification (cancel, etc.)
    /// Call this after modifying the orderbook when you need to notify subscribers.
    pub fn emit_orderbook_events(&mut self, timestamp: u64) {
        let (bids, asks) = self.get_orderbook_snapshot();
        let l2_update = self.compute_l2_updates(&bids, &asks);
        let sequence = self.pending_l2_sequence.take();

        // Emit L2 update if there are changes
        if !l2_update.bid_updates.is_empty() || !l2_update.ask_updates.is_empty() {
            let l2_msg = L2Message {
                symbol: self.symbol.clone(),
                bid_updates: l2_update.bid_updates,
                ask_updates: l2_update.ask_updates,
                timestamp,
                sequence,
            };
            self.pending_events.push(OrderBookEvent::L2Update(l2_msg));
        }

        // Store current snapshot
        self.last_bid_snapshot = bids.clone();
        self.last_ask_snapshot = asks.clone();

        // Emit legacy orderbook update
        let update = OrderbookUpdate {
            symbol: self.symbol.clone(),
            bids,
            asks,
            timestamp,
        };
        self.pending_events
            .push(OrderBookEvent::OrderbookUpdated(update));
    }

    pub fn compute_l2_updates(
        &self,
        current_bids: &[(Decimal, Decimal)],
        current_asks: &[(Decimal, Decimal)],
    ) -> L2UpdateSet {
        let mut bid_updates = Vec::new();
        let mut ask_updates = Vec::new();

        // Convert to hashmaps for easy lookup using string keys for precise comparison
        let last_bids: HashMap<String, Decimal> = self
            .last_bid_snapshot
            .iter()
            .map(|(p, s)| (p.to_string(), *s))
            .collect();
        let current_bids_map: HashMap<String, Decimal> = current_bids
            .iter()
            .map(|(p, s)| (p.to_string(), *s))
            .collect();

        let last_asks: HashMap<String, Decimal> = self
            .last_ask_snapshot
            .iter()
            .map(|(p, s)| (p.to_string(), *s))
            .collect();
        let current_asks_map: HashMap<String, Decimal> = current_asks
            .iter()
            .map(|(p, s)| (p.to_string(), *s))
            .collect();

        let threshold = dec!(0.0001);

        // Check for bid changes
        for (price_str, &current_size) in &current_bids_map {
            if let Some(&last_size) = last_bids.get(price_str) {
                let diff = current_size - last_size;
                if diff.abs() > threshold {
                    bid_updates.push(L2Update {
                        price: Decimal::from_str_exact(price_str).unwrap_or_default(),
                        size: current_size,
                    });
                }
            } else {
                bid_updates.push(L2Update {
                    price: Decimal::from_str_exact(price_str).unwrap_or_default(),
                    size: current_size,
                });
            }
        }

        // Check for removed bid levels
        for price_str in last_bids.keys() {
            if !current_bids_map.contains_key(price_str) {
                bid_updates.push(L2Update {
                    price: Decimal::from_str_exact(price_str).unwrap_or_default(),
                    size: dec!(0),
                });
            }
        }

        // Check for ask changes
        for (price_str, &current_size) in &current_asks_map {
            if let Some(&last_size) = last_asks.get(price_str) {
                let diff = current_size - last_size;
                if diff.abs() > threshold {
                    ask_updates.push(L2Update {
                        price: Decimal::from_str_exact(price_str).unwrap_or_default(),
                        size: current_size,
                    });
                }
            } else {
                ask_updates.push(L2Update {
                    price: Decimal::from_str_exact(price_str).unwrap_or_default(),
                    size: current_size,
                });
            }
        }

        // Check for removed ask levels
        for price_str in last_asks.keys() {
            if !current_asks_map.contains_key(price_str) {
                ask_updates.push(L2Update {
                    price: Decimal::from_str_exact(price_str).unwrap_or_default(),
                    size: dec!(0),
                });
            }
        }

        L2UpdateSet {
            bid_updates,
            ask_updates,
        }
    }

    pub fn has_open_orders(&self) -> bool {
        !self.orders.is_empty()
    }

    /// Get all orders as a snapshot for persistence.
    pub fn get_all_orders(&self) -> Vec<OrderRecord> {
        let mut all_orders = Vec::new();

        // Collect all bid orders
        for level in self.bids.values() {
            for order in &level.orders {
                let meta = self.orders.get(&order.id).unwrap_or_else(|| {
                    panic!(
                        "CRITICAL_FAILURE: order {} exists in bid price levels but not in metadata map for {}",
                        order.id, self.symbol
                    )
                });
                all_orders.push(OrderRecord {
                    order_id: order.id,
                    price: order.price,
                    quantity: order.quantity,
                    side: order.side,
                    wallet: meta.wallet,
                    timestamp: order.timestamp,
                    client_id: meta.client_id.clone(),
                    mmp_enabled: meta.mmp_enabled,
                    original_size: meta.original_size,
                });
            }
        }

        // Collect all ask orders
        for level in self.asks.values() {
            for order in &level.orders {
                let meta = self.orders.get(&order.id).unwrap_or_else(|| {
                    panic!(
                        "CRITICAL_FAILURE: order {} exists in ask price levels but not in metadata map for {}",
                        order.id, self.symbol
                    )
                });
                all_orders.push(OrderRecord {
                    order_id: order.id,
                    price: order.price,
                    quantity: order.quantity,
                    side: order.side,
                    wallet: meta.wallet,
                    timestamp: order.timestamp,
                    client_id: meta.client_id.clone(),
                    mmp_enabled: meta.mmp_enabled,
                    original_size: meta.original_size,
                });
            }
        }

        all_orders
    }

    /// Restore orderbook from a list of orders.
    pub fn restore_from_orders(&mut self, mut orders: Vec<OrderRecord>) {
        // Clear existing orders
        self.bids.clear();
        self.asks.clear();
        self.orders.clear();

        // Sort by timestamp to preserve original time priority within each
        // price level. This is critical for journal replay fill inference:
        // when a taker's response says Filled, we walk the opposing book in
        // price-time priority to infer which makers were filled. Without
        // correct time ordering, the wrong makers get filled.
        orders.sort_by_key(|r| r.timestamp);

        // Restore each order
        for r in orders {
            let order = Order {
                id: r.order_id,
                price: r.price,
                quantity: r.quantity,
                side: r.side,
                timestamp: r.timestamp,
            };

            let price_key = match r.side {
                Side::Buy => -r.price,
                Side::Sell => r.price,
            };

            let book = match r.side {
                Side::Buy => &mut self.bids,
                Side::Sell => &mut self.asks,
            };

            self.orders.insert(
                r.order_id,
                OrderMeta {
                    side: r.side,
                    price: r.price,
                    wallet: r.wallet,
                    client_id: r.client_id,
                    mmp_enabled: r.mmp_enabled,
                    original_size: r.original_size,
                },
            );

            book.entry(price_key)
                .or_insert_with(|| PriceLevel::new(r.price))
                .add_order(order);
        }

        // CRITICAL: Initialize L2 snapshots so that compute_l2_updates() can
        // correctly detect removed levels after fills. Without this, the first
        // fill after restore will not emit delete updates for fully-filled levels,
        // causing L2-derived caches to retain stale price levels.
        let (bids, asks) = self.get_orderbook_snapshot();
        self.last_bid_snapshot = bids;
        self.last_ask_snapshot = asks;
    }
}

/// Set of L2 incremental updates computed by [`OrderBook::compute_l2_updates`].
pub struct L2UpdateSet {
    pub bid_updates: Vec<L2Update>,
    pub ask_updates: Vec<L2Update>,
}

#[cfg(test)]
mod tests {
    use super::*;

    // Test-only MatchingEngine for managing multiple orderbooks
    struct MatchingEngine {
        books: HashMap<u64, HashMap<Decimal, HashMap<OptionType, OrderBook>>>,
        next_order_id: u64,
    }

    impl MatchingEngine {
        fn new() -> Self {
            Self {
                books: HashMap::new(),
                next_order_id: 1,
            }
        }

        fn get_or_create_book(
            &mut self,
            expiry: u64,
            strike: Decimal,
            option_type: OptionType,
        ) -> &mut OrderBook {
            self.books
                .entry(expiry)
                .or_default()
                .entry(strike)
                .or_default()
                .entry(option_type)
                .or_insert_with(|| OrderBook::new(expiry, strike, option_type))
        }

        fn get_book(
            &self,
            expiry: u64,
            strike: Decimal,
            option_type: &OptionType,
        ) -> Option<&OrderBook> {
            self.books.get(&expiry)?.get(&strike)?.get(option_type)
        }

        fn get_book_mut(
            &mut self,
            expiry: u64,
            strike: Decimal,
            option_type: &OptionType,
        ) -> Option<&mut OrderBook> {
            self.books
                .get_mut(&expiry)?
                .get_mut(&strike)?
                .get_mut(option_type)
        }

        fn add_order(
            &mut self,
            expiry: u64,
            strike: Decimal,
            option_type: OptionType,
            price: Decimal,
            quantity: Decimal,
            side: Side,
            timestamp: u64,
        ) -> u64 {
            let order_id = self.next_order_id;
            self.next_order_id += 1;
            let book = self.get_or_create_book(expiry, strike, option_type);
            book.add_order(order_id, price, quantity, side, timestamp);
            order_id
        }

        fn cancel_order(
            &mut self,
            expiry: u64,
            strike: Decimal,
            option_type: &OptionType,
            order_id: u64,
        ) -> Option<Order> {
            self.get_book_mut(expiry, strike, option_type)?
                .cancel_order(order_id)
        }

        #[allow(dead_code)]
        fn get_all_books(&self) -> Vec<&OrderBook> {
            self.books
                .values()
                .flat_map(|by_strike| by_strike.values())
                .flat_map(|by_type| by_type.values())
                .collect()
        }

        fn count_books(&self) -> usize {
            self.books
                .values()
                .map(|by_strike| {
                    by_strike
                        .values()
                        .map(|by_type| by_type.len())
                        .sum::<usize>()
                })
                .sum()
        }
    }

    #[test]
    fn test_orderbook_basic_operations() {
        let mut book = OrderBook::new(1735689600, dec!(100), OptionType::Call);

        let order1 = 1u64;
        book.add_order(order1, dec!(99.5), dec!(100), Side::Buy, 1000);
        let order2 = 2u64;
        book.add_order(order2, dec!(100.5), dec!(150), Side::Sell, 1001);
        let order3 = 3u64;
        book.add_order(order3, dec!(99), dec!(50), Side::Buy, 1002);

        assert_eq!(book.get_best_bid(), Some(dec!(99.5)));
        assert_eq!(book.get_best_ask(), Some(dec!(100.5)));
        assert_eq!(book.get_spread(), Some(dec!(1)));

        book.cancel_order(order1);
        assert_eq!(book.get_best_bid(), Some(dec!(99)));

        assert_eq!(book.total_bid_volume(), dec!(50));
        assert_eq!(book.total_ask_volume(), dec!(150));
    }

    #[test]
    fn test_append_order_wallets_uses_live_order_metadata() {
        let mut book = OrderBook::new(1735689600, dec!(100), OptionType::Call);
        let wallet_a = WalletAddress::from(alloy::primitives::Address::repeat_byte(1));
        let wallet_b = WalletAddress::from(alloy::primitives::Address::repeat_byte(2));

        book.add_order_with_wallet(1, dec!(99), dec!(10), Side::Buy, wallet_a, 1000);
        book.add_order_with_wallet(2, dec!(101), dec!(20), Side::Sell, wallet_b, 1001);

        let mut order_wallets = Vec::new();
        book.append_order_wallets(&mut order_wallets);
        order_wallets.sort_by_key(|(order_id, _)| *order_id);

        assert_eq!(order_wallets, vec![(1, wallet_a), (2, wallet_b)]);
    }

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

        let order1 = engine.add_order(
            1735689600,
            dec!(100),
            OptionType::Call,
            dec!(99.5),
            dec!(100),
            Side::Buy,
            1000,
        );
        let _order2 = engine.add_order(
            1735689600,
            dec!(100),
            OptionType::Put,
            dec!(5.5),
            dec!(200),
            Side::Sell,
            1001,
        );
        let _order3 = engine.add_order(
            1735689600,
            dec!(110),
            OptionType::Call,
            dec!(89.5),
            dec!(150),
            Side::Buy,
            1002,
        );
        let _order4 = engine.add_order(
            1738368000,
            dec!(100),
            OptionType::Call,
            dec!(105),
            dec!(75),
            Side::Sell,
            1003,
        );

        assert_eq!(engine.count_books(), 4);

        let call_100_book = engine
            .get_book(1735689600, dec!(100), &OptionType::Call)
            .unwrap();
        assert_eq!(call_100_book.get_best_bid(), Some(dec!(99.5)));

        let put_100_book = engine
            .get_book(1735689600, dec!(100), &OptionType::Put)
            .unwrap();
        assert_eq!(put_100_book.get_best_ask(), Some(dec!(5.5)));

        engine.cancel_order(1735689600, dec!(100), &OptionType::Call, order1);
        let call_100_book = engine
            .get_book(1735689600, dec!(100), &OptionType::Call)
            .unwrap();
        assert_eq!(call_100_book.get_best_bid(), None);
    }

    #[test]
    fn test_multiple_orders_same_price() {
        let mut book = OrderBook::new(1735689600, dec!(100), OptionType::Call);

        let order1 = 1u64;
        book.add_order(order1, dec!(100), dec!(100), Side::Buy, 1000);
        let order2 = 2u64;
        book.add_order(order2, dec!(100), dec!(200), Side::Buy, 1001);
        let order3 = 3u64;
        book.add_order(order3, dec!(100), dec!(150), Side::Buy, 1002);

        assert_eq!(book.total_bid_volume(), dec!(450));
        assert_eq!(book.get_best_bid(), Some(dec!(100)));

        book.cancel_order(order2);
        assert_eq!(book.total_bid_volume(), dec!(250));
        assert_eq!(book.get_best_bid(), Some(dec!(100)));

        book.cancel_order(order1);
        book.cancel_order(order3);
        assert_eq!(book.total_bid_volume(), dec!(0));
        assert_eq!(book.get_best_bid(), None);
    }

    #[test]
    fn test_order_depth() {
        let mut book = OrderBook::new(1735689600, dec!(100), OptionType::Put);
        let mut order_id_counter = 1u64;

        book.add_order(order_id_counter, dec!(10), dec!(100), Side::Buy, 1000);
        order_id_counter += 1;
        book.add_order(order_id_counter, dec!(9.5), dec!(200), Side::Buy, 1001);
        order_id_counter += 1;
        book.add_order(order_id_counter, dec!(9), dec!(150), Side::Buy, 1002);
        order_id_counter += 1;

        book.add_order(order_id_counter, dec!(11), dec!(120), Side::Sell, 1003);
        order_id_counter += 1;
        book.add_order(order_id_counter, dec!(11.5), dec!(180), Side::Sell, 1004);
        order_id_counter += 1;
        book.add_order(order_id_counter, dec!(12), dec!(90), Side::Sell, 1005);

        let bid_depth = book.get_bid_depth();
        assert_eq!(bid_depth.len(), 3);
        assert_eq!(bid_depth[0], (dec!(10), dec!(100)));
        assert_eq!(bid_depth[1], (dec!(9.5), dec!(200)));
        assert_eq!(bid_depth[2], (dec!(9), dec!(150)));

        let ask_depth = book.get_ask_depth();
        assert_eq!(ask_depth.len(), 3);
        assert_eq!(ask_depth[0], (dec!(11), dec!(120)));
        assert_eq!(ask_depth[1], (dec!(11.5), dec!(180)));
        assert_eq!(ask_depth[2], (dec!(12), dec!(90)));

        assert_eq!(book.get_spread(), Some(dec!(1)));
    }

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

        let expiries = vec![1735689600u64, 1738368000u64];
        let strikes = vec![dec!(90), dec!(100), dec!(110)];
        let types = vec![OptionType::Call, OptionType::Put];

        for &expiry in &expiries {
            for strike in &strikes {
                for option_type in &types {
                    engine.add_order(
                        expiry,
                        *strike,
                        *option_type,
                        dec!(50),
                        dec!(100),
                        Side::Buy,
                        1000,
                    );
                }
            }
        }

        assert_eq!(engine.count_books(), 12);

        for &expiry in &expiries {
            for strike in &strikes {
                for option_type in &types {
                    let book = engine.get_book(expiry, *strike, option_type).unwrap();
                    assert_eq!(book.expiry, expiry);
                    assert_eq!(book.strike, *strike);
                    assert_eq!(book.option_type, option_type.clone());
                    assert_eq!(book.get_best_bid(), Some(dec!(50)));
                }
            }
        }
    }

    // ============================================
    // Self-Trade Prevention Tests
    // ============================================

    #[test]
    fn test_self_trade_prevention_same_wallet_buy() {
        let mut book = OrderBook::with_symbol(
            1735689600,
            dec!(100),
            OptionType::Call,
            "BTC-20260131-100000-C".to_string(),
        );

        let wallet = WalletAddress::from(alloy::primitives::Address::repeat_byte(1));

        book.add_order_with_wallet(1, dec!(100), dec!(10), Side::Sell, wallet, 1000);

        let (result, should_continue) =
            book.process_order(2, dec!(100), dec!(5), Side::Buy, wallet, 1001, 100);

        assert!(
            matches!(result, MatchResult::SelfTrade { maker_order_id: 1 }),
            "Expected SelfTrade with maker_order_id=1, got {:?}",
            result
        );
        assert!(!should_continue);

        assert_eq!(book.get_best_ask(), Some(dec!(100)));
        assert_eq!(book.total_ask_volume(), dec!(10));
    }

    #[test]
    fn test_self_trade_prevention_same_wallet_sell() {
        let mut book = OrderBook::with_symbol(
            1735689600,
            dec!(100),
            OptionType::Call,
            "BTC-20260131-100000-C".to_string(),
        );

        let wallet = WalletAddress::from(alloy::primitives::Address::repeat_byte(1));

        book.add_order_with_wallet(1, dec!(100), dec!(10), Side::Buy, wallet, 1000);

        let (result, should_continue) =
            book.process_order(2, dec!(100), dec!(5), Side::Sell, wallet, 1001, 100);

        assert!(
            matches!(result, MatchResult::SelfTrade { maker_order_id: 1 }),
            "Expected SelfTrade with maker_order_id=1, got {:?}",
            result
        );
        assert!(!should_continue);

        assert_eq!(book.get_best_bid(), Some(dec!(100)));
        assert_eq!(book.total_bid_volume(), dec!(10));
    }

    #[test]
    fn test_no_self_trade_different_wallets() {
        let mut book = OrderBook::with_symbol(
            1735689600,
            dec!(100),
            OptionType::Call,
            "BTC-20260131-100000-C".to_string(),
        );

        let wallet_a = WalletAddress::from(alloy::primitives::Address::repeat_byte(1));
        let wallet_b = WalletAddress::from(alloy::primitives::Address::repeat_byte(2));

        book.add_order_with_wallet(1, dec!(100), dec!(10), Side::Sell, wallet_a, 1000);

        let (result, _should_continue) =
            book.process_order(2, dec!(100), dec!(5), Side::Buy, wallet_b, 1001, 100);

        assert!(
            matches!(result, MatchResult::Fill(_)),
            "Expected Fill, got {:?}",
            result
        );

        if let MatchResult::Fill(fill) = result {
            assert_eq!(fill.size, dec!(5));
            assert_eq!(fill.price, dec!(100));
            assert_eq!(fill.taker_wallet_address, wallet_b);
            assert_eq!(fill.maker_wallet_address, wallet_a);
        }

        assert_eq!(book.total_ask_volume(), dec!(5));
    }

    #[test]
    fn test_partial_fill_then_self_trade() {
        let mut book = OrderBook::with_symbol(
            1735689600,
            dec!(100),
            OptionType::Call,
            "BTC-20260131-100000-C".to_string(),
        );

        let wallet_a = WalletAddress::from(alloy::primitives::Address::repeat_byte(1));
        let wallet_b = WalletAddress::from(alloy::primitives::Address::repeat_byte(2));

        book.add_order_with_wallet(1, dec!(100), dec!(5), Side::Sell, wallet_b, 1000);
        book.add_order_with_wallet(2, dec!(100), dec!(5), Side::Sell, wallet_a, 1001);

        let (result1, should_continue1) =
            book.process_order(3, dec!(100), dec!(10), Side::Buy, wallet_a, 1002, 100);

        assert!(
            matches!(result1, MatchResult::Fill(_)),
            "First call should produce a Fill, got {:?}",
            result1
        );
        assert!(
            should_continue1,
            "Should indicate more matching is possible"
        );

        let (result2, should_continue2) =
            book.process_order(3, dec!(100), dec!(5), Side::Buy, wallet_a, 1003, 101);

        assert!(
            matches!(result2, MatchResult::SelfTrade { maker_order_id: 2 }),
            "Second call should detect SelfTrade with maker_order_id=2, got {:?}",
            result2
        );
        assert!(!should_continue2);

        assert_eq!(book.get_best_ask(), Some(dec!(100)));
        assert_eq!(book.total_ask_volume(), dec!(5));
    }

    #[test]
    fn test_self_trade_no_match_when_price_doesnt_cross() {
        let mut book = OrderBook::with_symbol(
            1735689600,
            dec!(100),
            OptionType::Call,
            "BTC-20260131-100000-C".to_string(),
        );

        let wallet = WalletAddress::from(alloy::primitives::Address::repeat_byte(1));

        book.add_order_with_wallet(1, dec!(100), dec!(10), Side::Sell, wallet, 1000);

        let (result, should_continue) =
            book.process_order(2, dec!(99), dec!(5), Side::Buy, wallet, 1001, 100);

        assert!(
            matches!(result, MatchResult::NoMatch),
            "Expected NoMatch when price does not cross, got {:?}",
            result
        );
        assert!(!should_continue);

        assert_eq!(book.get_best_bid(), Some(dec!(99)));
        assert_eq!(book.get_best_ask(), Some(dec!(100)));
    }
}