Struct OrderBook 

pub struct OrderBook {
    pub expiry: u64,
    pub strike: Decimal,
    pub option_type: OptionType,
    pub symbol: String,
    bids: BTreeMap<Decimal, PriceLevel>,
    asks: BTreeMap<Decimal, PriceLevel>,
    orders: HashMap<u64, OrderMeta>,
    pending_events: Vec<OrderBookEvent>,
    pub last_bid_snapshot: Vec<(Decimal, Decimal)>,
    pub last_ask_snapshot: Vec<(Decimal, Decimal)>,
    pub pending_l2_sequence: Option<i64>,
}

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.

Fields

expiry: u64

strike: Decimal

option_type: OptionType

symbol: String

bids: BTreeMap<Decimal, PriceLevel>

asks: BTreeMap<Decimal, PriceLevel>

orders: HashMap<u64, OrderMeta>

pending_events: Vec<OrderBookEvent>

Buffered events produced by the last operation.

last_bid_snapshot: Vec<(Decimal, Decimal)>

last_ask_snapshot: Vec<(Decimal, Decimal)>

pending_l2_sequence: Option<i64>

Implementations

impl OrderBook

fn remove_order_from_side_at_price( book: &mut BTreeMap<Decimal, PriceLevel>, price_key: Decimal, order_id: u64, ) -> Option<Order>

fn remove_order_from_side_anywhere( book: &mut BTreeMap<Decimal, PriceLevel>, order_id: u64, ) -> Option<Order>

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

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

pub fn drain_events(&mut self) -> Vec<OrderBookEvent>

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 add_order( &mut self, order_id: u64, price: Decimal, quantity: Decimal, side: Side, timestamp: u64, )

pub fn set_pending_l2_sequence(&mut self, sequence: i64)

pub fn add_order_with_wallet( &mut self, order_id: u64, price: Decimal, quantity: Decimal, side: Side, wallet: WalletAddress, timestamp: u64, )

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, )

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 order_count(&self) -> usize

O(1) count of live orders in this book.

pub fn append_order_wallets(&self, out: &mut Vec<(u64, WalletAddress)>)

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 has_order(&self, order_id: u64) -> bool

Check if an order exists in the orderbook.

pub fn get_all_order_ids(&self) -> Vec<u64>

Get all order IDs in this orderbook.

pub fn cancel_order(&mut self, order_id: u64) -> Option<Order>

pub fn cancel_order_for_replay(&mut self, order_id: u64) -> Option<Order>

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 reduce_order_quantity(&mut self, order_id: u64, qty: Decimal) -> bool

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 get_best_bid(&self) -> Option<Decimal>

pub fn get_best_ask(&self) -> Option<Decimal>

pub fn is_crossed(&self) -> bool

Returns true if the orderbook is in a crossed state (best bid >= best ask).

pub fn get_bid_depth(&self) -> Vec<(Decimal, Decimal)>

pub fn get_ask_depth(&self) -> Vec<(Decimal, Decimal)>

pub fn get_spread(&self) -> Option<Decimal>

pub fn total_bid_volume(&self) -> Decimal

pub fn total_ask_volume(&self) -> Decimal

pub fn process_order( &mut self, order_id: u64, price: Decimal, quantity: Decimal, side: Side, wallet: WalletAddress, timestamp: u64, trade_id: u64, ) -> (MatchResult, bool)

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_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)

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 to retrieve them.

fn try_match_one_maker( &mut self, order_id: u64, price: Decimal, quantity: Decimal, side: &Side, wallet: &WalletAddress, timestamp: u64, trade_id: u64, ) -> MatchResult

Try to match with one maker order.

fn try_match_buy( &mut self, order_id: u64, price: Decimal, quantity: Decimal, wallet: &WalletAddress, timestamp: u64, trade_id: u64, ) -> MatchResult

Try to match a buy order with the best ask.

fn try_match_sell( &mut self, order_id: u64, price: Decimal, quantity: Decimal, wallet: &WalletAddress, timestamp: u64, trade_id: u64, ) -> MatchResult

Try to match a sell order with the best bid.

fn has_more_liquidity(&self, side: &Side, price: Decimal) -> bool

Check if there is more liquidity available at the given price.

pub fn add_order_to_book_with_events( &mut self, order_id: u64, price: Decimal, quantity: Decimal, side: Side, wallet: WalletAddress, timestamp: u64, )

Add order to book and emit L2 and orderbook update events.

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, )

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.

fn emit_events(&mut self, fills: &[Fill], timestamp: u64)

pub fn get_orderbook_snapshot( &self, ) -> (Vec<(Decimal, Decimal)>, Vec<(Decimal, Decimal)>)

pub fn sync_l2_snapshot_baseline(&mut self)

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 emit_orderbook_events(&mut self, timestamp: u64)

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 compute_l2_updates( &self, current_bids: &[(Decimal, Decimal)], current_asks: &[(Decimal, Decimal)], ) -> L2UpdateSet

pub fn has_open_orders(&self) -> bool

pub fn get_all_orders(&self) -> Vec<OrderRecord>

Get all orders as a snapshot for persistence.

pub fn restore_from_orders(&mut self, orders: Vec<OrderRecord>)

Restore orderbook from a list of orders.

Trait Implementations

impl Clone for OrderBook

fn clone(&self) -> OrderBook

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for OrderBook

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.