hypercall_engine/

order_index.rs

//! In-process order index for the engine.
//!
//! `EngineOrderIndex` tracks all open orders inline as the engine processes them,
//! providing zero-latency, zero-divergence lookups for cancel, margin, and MMP
//! operations. All methods are synchronous — no locks, no async — because the
//! engine is single-threaded and owns this struct via `EngineCtx`.

use crate::instrument::{contract_key, ParsedInstrument};
use crate::position::EnginePosition;
use hypercall_types::{to_human_readable_decimal, Side, WalletAddress};
use rust_decimal::Decimal;
use rust_decimal_macros::dec;
use serde::{Deserialize, Serialize};
use std::collections::HashMap;

/// Summary of an open order tracked by the engine.
///
/// **Unit convention**: All sizes are stored in **human-readable** units
/// (e.g., 1.0 = 1 contract). Callers pass raw contract units (from `OrderInfo`,
/// `Fill`, orderbooks); the boundary methods (`add_order`, `fill_order`) convert
/// to human-readable on entry. See CALL-160 for the long-term newtype fix.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct OrderSummary {
    pub order_id: u64,
    pub symbol: String,
    pub side: Side,
    pub price: Decimal,
    /// Original order size in human-readable units (converted from raw on insert).
    pub original_size: Decimal,
    /// Remaining unfilled size in human-readable units (converted from raw on insert).
    pub remaining_size: Decimal,
    pub is_perp: bool,
    pub mmp_enabled: bool,
    pub client_id: Option<String>,
    /// Creation timestamp in milliseconds (from engine ACK time).
    pub created_at: i64,
}

/// Info about an open SELL option order as a hypothetical short position.
///
/// Used by Standard margin to calculate IM for pending shorts.
pub struct OpenSellPositionInfo {
    /// Premium that would be credited when this order fills.
    pub premium: Decimal,
    /// Hypothetical short position for margin calculation.
    pub position: hypercall_margin::OptionPosition,
}

/// In-process index of all open orders, owned by `EngineCtx`.
///
/// Provides synchronous lookups for cancel, margin, MMP, and order-limit checks.
/// Mutated inline by the engine after ACK, fill, and cancel.
pub struct EngineOrderIndex {
    /// wallet → order_id → OrderSummary
    orders_by_wallet: HashMap<WalletAddress, HashMap<u64, OrderSummary>>,
    /// (wallet, client_id) → order_id
    client_id_index: HashMap<(WalletAddress, String), u64>,
    /// (wallet, contract_key) → open sell quantity (in human-readable units)
    open_sells_by_contract: HashMap<(WalletAddress, String), Decimal>,
}

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

impl EngineOrderIndex {
    /// Create an empty index.
    pub fn new() -> Self {
        Self {
            orders_by_wallet: HashMap::new(),
            client_id_index: HashMap::new(),
            open_sells_by_contract: HashMap::new(),
        }
    }

    // ===== Read methods =====

    /// Look up the symbol for an order by wallet + order_id.
    pub fn get_order_symbol(&self, wallet: &WalletAddress, order_id: u64) -> Option<&str> {
        self.orders_by_wallet
            .get(wallet)?
            .get(&order_id)
            .map(|s| s.symbol.as_str())
    }

    /// Look up (order_id, symbol) by wallet + client_id.
    pub fn get_order_by_client_id(
        &self,
        wallet: &WalletAddress,
        client_id: &str,
    ) -> Option<(u64, &str)> {
        let order_id = self
            .client_id_index
            .get(&(*wallet, client_id.to_string()))?;
        let summary = self.orders_by_wallet.get(wallet)?.get(order_id)?;
        Some((*order_id, summary.symbol.as_str()))
    }

    /// Count of open orders for a wallet.
    pub fn open_order_count(&self, wallet: &WalletAddress) -> usize {
        self.orders_by_wallet
            .get(wallet)
            .map(|m| m.len())
            .unwrap_or(0)
    }

    /// Sum of (price × remaining_qty) for open BUY option orders that are
    /// NOT closing existing short positions. Buys that reduce a short are
    /// risk-reducing and should not reserve premium.
    pub fn calculate_open_buy_premium(
        &self,
        wallet: &WalletAddress,
        positions: &HashMap<(WalletAddress, String), EnginePosition>,
    ) -> Decimal {
        let Some(orders) = self.orders_by_wallet.get(wallet) else {
            return dec!(0);
        };

        let mut total = dec!(0);
        for summary in orders.values() {
            if !matches!(summary.side, Side::Buy) {
                continue;
            }
            // Only options (not perps)
            if summary.is_perp {
                continue;
            }
            if ParsedInstrument::parse(&summary.symbol).is_err() {
                continue;
            }
            if summary.remaining_size <= dec!(0) {
                continue;
            }
            // Only reserve premium for the portion that exceeds the existing short.
            // If short 2 and buying 5, only 3 contracts need premium reserved.
            let existing_qty = positions
                .get(&(*wallet, summary.symbol.clone()))
                .map(|p| p.quantity)
                .unwrap_or(dec!(0));
            let reservable_size = if existing_qty < dec!(0) {
                // Short position: only the excess beyond the close needs premium
                (summary.remaining_size + existing_qty).max(dec!(0))
            } else {
                summary.remaining_size
            };
            if reservable_size <= dec!(0) {
                continue;
            }
            total += summary.price * reservable_size;
        }
        total
    }

    /// Open SELL option orders as hypothetical short positions for Standard margin.
    pub fn get_open_sell_option_positions(
        &self,
        wallet: &WalletAddress,
    ) -> Vec<OpenSellPositionInfo> {
        let Some(orders) = self.orders_by_wallet.get(wallet) else {
            return Vec::new();
        };

        let mut positions = Vec::new();
        for summary in orders.values() {
            if !matches!(summary.side, Side::Sell) {
                continue;
            }
            if summary.is_perp {
                continue;
            }
            let parsed = match ParsedInstrument::parse(&summary.symbol) {
                Ok(p) => p,
                Err(_) => continue,
            };
            if summary.remaining_size <= dec!(0) {
                continue;
            }

            let premium = summary.price * summary.remaining_size;

            let expiry_ts = match parsed.expiry_timestamp() {
                Ok(ts) => ts,
                Err(_) => continue,
            };

            let position = hypercall_margin::OptionPosition {
                symbol: summary.symbol.clone(),
                underlying: parsed.underlying.clone(),
                expiry_ts,
                strike: parsed.strike,
                is_call: matches!(parsed.option_type, hypercall_types::OptionType::Call),
                size: -summary.remaining_size,
                mark_price: summary.price,
                entry_price: summary.price,
                spot_price: dec!(0), // Caller updates with actual spot
            };

            positions.push(OpenSellPositionInfo { premium, position });
        }
        positions
    }

    /// Total open sell quantity for a specific contract (wallet + symbol).
    pub fn get_open_sells_for_contract(&self, wallet: &WalletAddress, symbol: &str) -> Decimal {
        if let Some(key) = contract_key(symbol) {
            self.open_sells_by_contract
                .get(&(*wallet, key))
                .copied()
                .unwrap_or(dec!(0))
        } else {
            dec!(0)
        }
    }

    /// Clone all orders for snapshot publication via ArcSwap.
    pub fn snapshot_orders(&self) -> HashMap<WalletAddress, Vec<OrderSummary>> {
        self.orders_by_wallet
            .iter()
            .map(|(wallet, orders)| (*wallet, orders.values().cloned().collect()))
            .collect()
    }

    /// Get all order summaries for a wallet (used by margin manager).
    pub fn get_all_orders_for_wallet(&self, wallet: &WalletAddress) -> Vec<&OrderSummary> {
        match self.orders_by_wallet.get(wallet) {
            Some(orders) => orders.values().collect(),
            None => Vec::new(),
        }
    }

    /// Get (order_id, symbol) pairs for all MMP-enabled orders matching wallet + underlying.
    pub fn get_mmp_order_ids(
        &self,
        wallet: &WalletAddress,
        underlying: &str,
    ) -> Vec<(u64, String)> {
        let Some(orders) = self.orders_by_wallet.get(wallet) else {
            return Vec::new();
        };

        orders
            .values()
            .filter(|s| {
                if !s.mmp_enabled {
                    return false;
                }
                if let Ok(parsed) = ParsedInstrument::parse(&s.symbol) {
                    parsed.underlying == underlying
                } else {
                    false
                }
            })
            .map(|s| (s.order_id, s.symbol.clone()))
            .collect()
    }

    // ===== Mutation methods =====

    /// Track a new order after ACK.
    ///
    /// Sizes in `summary` are expected in **raw contract units** (from `OrderInfo`);
    /// this method converts them to human-readable before storing.
    pub fn add_order(&mut self, wallet: &WalletAddress, mut summary: OrderSummary) {
        // Convert raw contract units → human-readable at the boundary
        summary.original_size = to_human_readable_decimal(&summary.symbol, summary.original_size);
        summary.remaining_size = to_human_readable_decimal(&summary.symbol, summary.remaining_size);

        let order_id = summary.order_id;

        // Update client_id index
        if let Some(ref cid) = summary.client_id {
            self.client_id_index
                .insert((*wallet, cid.clone()), order_id);
        }

        // Update open sells index (now in human-readable units)
        if matches!(summary.side, Side::Sell) {
            if let Some(key) = contract_key(&summary.symbol) {
                *self
                    .open_sells_by_contract
                    .entry((*wallet, key))
                    .or_insert(dec!(0)) += summary.remaining_size;
            }
        }

        // Insert order
        self.orders_by_wallet
            .entry(*wallet)
            .or_default()
            .insert(order_id, summary);
    }

    /// Update after a partial or full fill. Returns `true` if fully filled (removed).
    ///
    /// `filled_qty` is expected in **raw contract units** (from `Fill`);
    /// this method converts it to human-readable before applying.
    pub fn fill_order(
        &mut self,
        wallet: &WalletAddress,
        order_id: u64,
        filled_qty: Decimal,
    ) -> bool {
        let wallet_orders = match self.orders_by_wallet.get_mut(wallet) {
            Some(m) => m,
            None => return false,
        };

        let summary = match wallet_orders.get_mut(&order_id) {
            Some(s) => s,
            None => return false,
        };

        // Convert raw → human-readable at the boundary
        let filled_qty = to_human_readable_decimal(&summary.symbol, filled_qty);

        // Update open sells tracking
        if matches!(summary.side, Side::Sell) {
            if let Some(key) = contract_key(&summary.symbol) {
                let map_key = (*wallet, key);
                let should_remove = if let Some(qty) = self.open_sells_by_contract.get_mut(&map_key)
                {
                    *qty = (*qty - filled_qty).max(dec!(0));
                    *qty == dec!(0)
                } else {
                    false
                };
                if should_remove {
                    self.open_sells_by_contract.remove(&map_key);
                }
            }
        }

        summary.remaining_size -= filled_qty;
        if summary.remaining_size <= dec!(0) {
            // Fully filled — remove from all indexes
            let removed = wallet_orders.remove(&order_id).unwrap();
            if let Some(ref cid) = removed.client_id {
                self.client_id_index.remove(&(*wallet, cid.clone()));
            }
            if wallet_orders.is_empty() {
                self.orders_by_wallet.remove(wallet);
            }
            true
        } else {
            false
        }
    }

    /// Remove an order after cancel/reject.
    pub fn remove_order(&mut self, wallet: &WalletAddress, order_id: u64) {
        let wallet_orders = match self.orders_by_wallet.get_mut(wallet) {
            Some(m) => m,
            None => return,
        };

        if let Some(removed) = wallet_orders.remove(&order_id) {
            // Clean up client_id index
            if let Some(ref cid) = removed.client_id {
                self.client_id_index.remove(&(*wallet, cid.clone()));
            }

            // Clean up open sells
            if matches!(removed.side, Side::Sell) {
                if let Some(key) = contract_key(&removed.symbol) {
                    let map_key = (*wallet, key);
                    let should_remove =
                        if let Some(qty) = self.open_sells_by_contract.get_mut(&map_key) {
                            *qty = (*qty - removed.remaining_size).max(dec!(0));
                            *qty == dec!(0)
                        } else {
                            false
                        };
                    if should_remove {
                        self.open_sells_by_contract.remove(&map_key);
                    }
                }
            }

            if wallet_orders.is_empty() {
                self.orders_by_wallet.remove(wallet);
            }
        }
    }

    /// Remove an order by ID without knowing the wallet.
    ///
    /// Used by post-startup reconciliation where we only have order_ids from the DB.
    /// Scans all wallets to find the owner — O(n) in wallet count but only
    /// called during startup for a small number of ghost orders.
    pub fn remove_order_by_id(&mut self, order_id: u64) {
        let wallet = self
            .orders_by_wallet
            .iter()
            .find(|(_, orders)| orders.contains_key(&order_id))
            .map(|(w, _)| *w);

        if let Some(wallet) = wallet {
            self.remove_order(&wallet, order_id);
        }
    }

    /// Populate from orderbooks after snapshot restore.
    ///
    /// For snapshot-loaded orders, client_id and mmp_enabled are unknown,
    /// so they default to `None`/`false`. Replay will add subsequent orders
    /// with full metadata.
    pub fn rebuild_from_orderbooks(
        &mut self,
        orderbooks: &HashMap<String, crate::orderbook::OrderBook>,
    ) {
        self.orders_by_wallet.clear();
        self.client_id_index.clear();
        self.open_sells_by_contract.clear();

        for (symbol, orderbook) in orderbooks {
            let is_perp = ParsedInstrument::parse(symbol).is_err();
            for r in orderbook.get_all_orders() {
                let summary = OrderSummary {
                    order_id: r.order_id,
                    symbol: symbol.clone(),
                    side: r.side,
                    price: r.price,
                    original_size: r.original_size,
                    remaining_size: r.quantity,
                    is_perp,
                    mmp_enabled: r.mmp_enabled,
                    client_id: r.client_id,
                    created_at: r.timestamp as i64,
                };
                self.add_order(&r.wallet, summary);
            }
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use hypercall_types::CONTRACT_UNIT_MULTIPLIER_DECIMAL;
    use rust_decimal_macros::dec;

    /// Convert a human-readable quantity to raw contract units for test inputs.
    /// add_order/fill_order expect raw units and convert internally.
    fn raw(human: Decimal) -> Decimal {
        human * CONTRACT_UNIT_MULTIPLIER_DECIMAL
    }

    fn wallet(byte: u8) -> WalletAddress {
        WalletAddress::from(alloy::primitives::Address::repeat_byte(byte))
    }

    fn make_summary(
        order_id: u64,
        symbol: &str,
        side: Side,
        price: Decimal,
        size_raw: Decimal,
    ) -> OrderSummary {
        OrderSummary {
            order_id,
            symbol: symbol.to_string(),
            side,
            price,
            original_size: size_raw,
            remaining_size: size_raw,
            is_perp: ParsedInstrument::parse(symbol).is_err(),
            mmp_enabled: false,
            client_id: None,
            created_at: 0,
        }
    }

    #[test]
    fn test_add_and_lookup() {
        let mut idx = EngineOrderIndex::new();
        let w = wallet(1);
        let sym = "ETH-20260131-4000-C";

        idx.add_order(
            &w,
            make_summary(1, sym, Side::Buy, dec!(100), raw(dec!(10))),
        );

        assert_eq!(idx.get_order_symbol(&w, 1), Some("ETH-20260131-4000-C"));
        assert_eq!(idx.open_order_count(&w), 1);
        assert_eq!(idx.get_order_symbol(&w, 999), None);
    }

    #[test]
    fn test_add_converts_to_human_readable() {
        let mut idx = EngineOrderIndex::new();
        let w = wallet(1);
        let sym = "ETH-20260131-4000-C";

        // Pass 5 contracts in raw units (5_000_000)
        idx.add_order(&w, make_summary(1, sym, Side::Buy, dec!(100), raw(dec!(5))));

        // Stored size should be human-readable (5.0)
        let orders = idx.get_all_orders_for_wallet(&w);
        assert_eq!(orders.len(), 1);
        assert_eq!(orders[0].remaining_size, dec!(5));
        assert_eq!(orders[0].original_size, dec!(5));
    }

    #[test]
    fn test_client_id_lookup() {
        let mut idx = EngineOrderIndex::new();
        let w = wallet(1);
        let mut summary =
            make_summary(42, "ETH-20260131-4000-C", Side::Buy, dec!(50), raw(dec!(5)));
        summary.client_id = Some("my-order-1".to_string());

        idx.add_order(&w, summary);

        let result = idx.get_order_by_client_id(&w, "my-order-1");
        assert_eq!(result, Some((42, "ETH-20260131-4000-C")));
        assert_eq!(idx.get_order_by_client_id(&w, "nonexistent"), None);
    }

    #[test]
    fn test_fill_partial_and_full() {
        let mut idx = EngineOrderIndex::new();
        let w = wallet(1);
        idx.add_order(
            &w,
            make_summary(
                1,
                "ETH-20260131-4000-C",
                Side::Buy,
                dec!(100),
                raw(dec!(10)),
            ),
        );

        // Partial fill (3 contracts in raw units)
        let fully_filled = idx.fill_order(&w, 1, raw(dec!(3)));
        assert!(!fully_filled);
        assert_eq!(idx.open_order_count(&w), 1);

        // Full fill (remaining 7 contracts in raw units)
        let fully_filled = idx.fill_order(&w, 1, raw(dec!(7)));
        assert!(fully_filled);
        assert_eq!(idx.open_order_count(&w), 0);
    }

    #[test]
    fn test_remove_order() {
        let mut idx = EngineOrderIndex::new();
        let w = wallet(1);
        let mut summary = make_summary(
            1,
            "ETH-20260131-4000-C",
            Side::Sell,
            dec!(100),
            raw(dec!(10)),
        );
        summary.client_id = Some("cid-1".to_string());
        idx.add_order(&w, summary);

        assert_eq!(idx.open_order_count(&w), 1);
        assert!(idx.get_order_by_client_id(&w, "cid-1").is_some());

        idx.remove_order(&w, 1);

        assert_eq!(idx.open_order_count(&w), 0);
        assert!(idx.get_order_by_client_id(&w, "cid-1").is_none());
    }

    #[test]
    fn test_open_buy_premium() {
        let mut idx = EngineOrderIndex::new();
        let w = wallet(1);

        // Buy option: price=100, qty=5 contracts → premium=500
        idx.add_order(
            &w,
            make_summary(1, "ETH-20260131-4000-C", Side::Buy, dec!(100), raw(dec!(5))),
        );
        // Buy option: price=50, qty=2 contracts → premium=100
        idx.add_order(
            &w,
            make_summary(2, "ETH-20260131-5000-P", Side::Buy, dec!(50), raw(dec!(2))),
        );
        // Sell option: should NOT be counted
        idx.add_order(
            &w,
            make_summary(
                3,
                "ETH-20260131-4000-C",
                Side::Sell,
                dec!(200),
                raw(dec!(1)),
            ),
        );

        let no_positions = std::collections::HashMap::new();
        assert_eq!(idx.calculate_open_buy_premium(&w, &no_positions), dec!(600));
    }

    #[test]
    fn test_open_buy_premium_skips_closing_buys() {
        let mut idx = EngineOrderIndex::new();
        let w = wallet(1);

        // Buy order on a symbol where wallet has a SHORT position → closing buy, skip premium
        idx.add_order(
            &w,
            make_summary(1, "ETH-20260131-4000-C", Side::Buy, dec!(100), raw(dec!(5))),
        );
        // Buy order on a symbol where wallet has NO position → new buy, reserve premium
        idx.add_order(
            &w,
            make_summary(2, "ETH-20260131-5000-P", Side::Buy, dec!(50), raw(dec!(2))),
        );

        let mut positions = std::collections::HashMap::new();
        positions.insert(
            (w, "ETH-20260131-4000-C".to_string()),
            EnginePosition {
                quantity: dec!(-5),
                entry_price: dec!(100),
            },
        );

        // Only the 5000-P buy (no position) should reserve premium: 50 * 2 = 100
        assert_eq!(idx.calculate_open_buy_premium(&w, &positions), dec!(100));

        // Partial close: short 2 but buying 5 → only 3 contracts need premium
        let mut idx2 = EngineOrderIndex::new();
        idx2.add_order(
            &w,
            make_summary(1, "ETH-20260131-4000-C", Side::Buy, dec!(100), raw(dec!(5))),
        );
        let mut positions2 = std::collections::HashMap::new();
        positions2.insert(
            (w, "ETH-20260131-4000-C".to_string()),
            EnginePosition {
                quantity: dec!(-2),
                entry_price: dec!(100),
            },
        );
        // 5 buy - 2 short = 3 excess → premium = 100 * 3 = 300
        assert_eq!(idx2.calculate_open_buy_premium(&w, &positions2), dec!(300));
    }

    #[test]
    fn test_open_sells_for_contract() {
        let mut idx = EngineOrderIndex::new();
        let w = wallet(1);
        let sym = "ETH-20260131-4000-C";

        idx.add_order(
            &w,
            make_summary(1, sym, Side::Sell, dec!(100), raw(dec!(5))),
        );
        idx.add_order(&w, make_summary(2, sym, Side::Sell, dec!(90), raw(dec!(3))));

        assert_eq!(idx.get_open_sells_for_contract(&w, sym), dec!(8));

        // Partial fill on order 1 (2 contracts in raw units)
        idx.fill_order(&w, 1, raw(dec!(2)));
        assert_eq!(idx.get_open_sells_for_contract(&w, sym), dec!(6));

        // Cancel order 2
        idx.remove_order(&w, 2);
        assert_eq!(idx.get_open_sells_for_contract(&w, sym), dec!(3));
    }

    #[test]
    fn test_mmp_order_ids() {
        let mut idx = EngineOrderIndex::new();
        let w = wallet(1);

        let mut s1 = make_summary(1, "ETH-20260131-4000-C", Side::Buy, dec!(100), raw(dec!(5)));
        s1.mmp_enabled = true;
        idx.add_order(&w, s1);

        let mut s2 = make_summary(2, "ETH-20260131-5000-P", Side::Sell, dec!(50), raw(dec!(3)));
        s2.mmp_enabled = true;
        idx.add_order(&w, s2);

        // Not MMP
        idx.add_order(
            &w,
            make_summary(3, "ETH-20260131-6000-C", Side::Buy, dec!(10), raw(dec!(1))),
        );

        // Different underlying
        let mut s4 = make_summary(
            4,
            "BTC-20260131-100000-C",
            Side::Buy,
            dec!(500),
            raw(dec!(1)),
        );
        s4.mmp_enabled = true;
        idx.add_order(&w, s4);

        let mmp_eth = idx.get_mmp_order_ids(&w, "ETH");
        assert_eq!(mmp_eth.len(), 2);
        let ids: Vec<u64> = mmp_eth.iter().map(|(id, _)| *id).collect();
        assert!(ids.contains(&1));
        assert!(ids.contains(&2));

        let mmp_btc = idx.get_mmp_order_ids(&w, "BTC");
        assert_eq!(mmp_btc.len(), 1);
        assert_eq!(mmp_btc[0].0, 4);
    }

    #[test]
    fn test_open_sell_option_positions() {
        let mut idx = EngineOrderIndex::new();
        let w = wallet(1);

        // Sell option: 5 contracts
        idx.add_order(
            &w,
            make_summary(
                1,
                "ETH-20260131-4000-C",
                Side::Sell,
                dec!(100),
                raw(dec!(5)),
            ),
        );
        // Buy option — should not appear
        idx.add_order(
            &w,
            make_summary(2, "ETH-20260131-4000-C", Side::Buy, dec!(80), raw(dec!(3))),
        );

        let positions = idx.get_open_sell_option_positions(&w);
        assert_eq!(positions.len(), 1);
        assert_eq!(positions[0].premium, dec!(500)); // 100 * 5
        assert_eq!(positions[0].position.size, dec!(-5));
        assert_eq!(positions[0].position.strike, dec!(4000));
        assert!(positions[0].position.is_call);
    }

    #[test]
    fn test_fill_cleans_client_id_index() {
        let mut idx = EngineOrderIndex::new();
        let w = wallet(1);
        let mut summary =
            make_summary(1, "ETH-20260131-4000-C", Side::Buy, dec!(100), raw(dec!(5)));
        summary.client_id = Some("cid-fill".to_string());
        idx.add_order(&w, summary);

        assert!(idx.get_order_by_client_id(&w, "cid-fill").is_some());

        idx.fill_order(&w, 1, raw(dec!(5)));
        assert!(idx.get_order_by_client_id(&w, "cid-fill").is_none());
    }

    #[test]
    fn test_multiple_wallets() {
        let mut idx = EngineOrderIndex::new();
        let w1 = wallet(1);
        let w2 = wallet(2);

        idx.add_order(
            &w1,
            make_summary(1, "ETH-20260131-4000-C", Side::Buy, dec!(100), raw(dec!(5))),
        );
        idx.add_order(
            &w2,
            make_summary(2, "ETH-20260131-4000-C", Side::Buy, dec!(50), raw(dec!(3))),
        );

        assert_eq!(idx.open_order_count(&w1), 1);
        assert_eq!(idx.open_order_count(&w2), 1);
        assert_eq!(idx.get_order_symbol(&w1, 1), Some("ETH-20260131-4000-C"));
        assert_eq!(idx.get_order_symbol(&w2, 2), Some("ETH-20260131-4000-C"));
        assert_eq!(idx.get_order_symbol(&w1, 2), None);
    }

    #[test]
    fn test_remove_nonexistent_is_noop() {
        let mut idx = EngineOrderIndex::new();
        let w = wallet(1);
        // Should not panic
        idx.remove_order(&w, 999);
        assert_eq!(idx.open_order_count(&w), 0);
    }

    #[test]
    fn test_fill_nonexistent_returns_false() {
        let mut idx = EngineOrderIndex::new();
        let w = wallet(1);
        assert!(!idx.fill_order(&w, 999, raw(dec!(5))));
    }

    #[test]
    fn test_partial_fill_reduces_remaining() {
        let mut idx = EngineOrderIndex::new();
        let w = wallet(1);
        idx.add_order(
            &w,
            make_summary(
                1,
                "ETH-20260131-4000-C",
                Side::Buy,
                dec!(100),
                raw(dec!(10)),
            ),
        );

        let fully_filled = idx.fill_order(&w, 1, raw(dec!(3)));
        assert!(!fully_filled);
        assert_eq!(idx.open_order_count(&w), 1);

        let orders = idx.get_all_orders_for_wallet(&w);
        assert_eq!(orders[0].remaining_size, dec!(7));
    }

    #[test]
    fn test_full_fill_removes_order() {
        let mut idx = EngineOrderIndex::new();
        let w = wallet(1);
        idx.add_order(
            &w,
            make_summary(
                1,
                "ETH-20260131-4000-C",
                Side::Buy,
                dec!(100),
                raw(dec!(10)),
            ),
        );

        let fully_filled = idx.fill_order(&w, 1, raw(dec!(10)));
        assert!(fully_filled);
        assert_eq!(idx.open_order_count(&w), 0);
    }

    #[test]
    fn test_overfill_removes_order() {
        let mut idx = EngineOrderIndex::new();
        let w = wallet(1);
        idx.add_order(
            &w,
            make_summary(1, "ETH-20260131-4000-C", Side::Buy, dec!(100), raw(dec!(5))),
        );

        let fully_filled = idx.fill_order(&w, 1, raw(dec!(10)));
        assert!(fully_filled);
        assert_eq!(idx.open_order_count(&w), 0);
    }

    #[test]
    fn test_fill_sell_updates_open_sells() {
        let mut idx = EngineOrderIndex::new();
        let w = wallet(1);
        idx.add_order(
            &w,
            make_summary(
                1,
                "ETH-20260131-4000-C",
                Side::Sell,
                dec!(100),
                raw(dec!(10)),
            ),
        );

        let initial_sells = idx.get_open_sells_for_contract(&w, "ETH-20260131-4000-C");
        assert!(initial_sells > dec!(0));

        idx.fill_order(&w, 1, raw(dec!(5)));
        let after_partial = idx.get_open_sells_for_contract(&w, "ETH-20260131-4000-C");
        assert!(after_partial < initial_sells);

        idx.fill_order(&w, 1, raw(dec!(5)));
        let after_full = idx.get_open_sells_for_contract(&w, "ETH-20260131-4000-C");
        assert_eq!(after_full, dec!(0));
    }

    #[test]
    fn test_premium_calculation_single_buy() {
        let mut idx = EngineOrderIndex::new();
        let w = wallet(1);
        idx.add_order(
            &w,
            make_summary(1, "ETH-20260131-4000-C", Side::Buy, dec!(500), raw(dec!(2))),
        );

        let premium = idx.calculate_open_buy_premium(&w, &HashMap::new());
        assert_eq!(premium, dec!(500) * dec!(2));
    }

    #[test]
    fn test_premium_reduces_for_existing_short() {
        let mut idx = EngineOrderIndex::new();
        let w = wallet(1);
        idx.add_order(
            &w,
            make_summary(1, "ETH-20260131-4000-C", Side::Buy, dec!(100), raw(dec!(5))),
        );

        let mut positions = HashMap::new();
        positions.insert(
            (w, "ETH-20260131-4000-C".to_string()),
            EnginePosition {
                quantity: dec!(-3),
                entry_price: dec!(100),
            },
        );

        let premium = idx.calculate_open_buy_premium(&w, &positions);
        assert_eq!(premium, dec!(100) * dec!(2));
    }

    #[test]
    fn test_premium_zero_when_fully_closing_short() {
        let mut idx = EngineOrderIndex::new();
        let w = wallet(1);
        idx.add_order(
            &w,
            make_summary(1, "ETH-20260131-4000-C", Side::Buy, dec!(100), raw(dec!(3))),
        );

        let mut positions = HashMap::new();
        positions.insert(
            (w, "ETH-20260131-4000-C".to_string()),
            EnginePosition {
                quantity: dec!(-5),
                entry_price: dec!(100),
            },
        );

        let premium = idx.calculate_open_buy_premium(&w, &positions);
        assert_eq!(premium, dec!(0));
    }

    #[test]
    fn test_premium_ignores_perps() {
        let mut idx = EngineOrderIndex::new();
        let w = wallet(1);
        idx.add_order(
            &w,
            make_summary(1, "ETH-PERP", Side::Buy, dec!(3000), raw(dec!(10))),
        );

        let premium = idx.calculate_open_buy_premium(&w, &HashMap::new());
        assert_eq!(premium, dec!(0));
    }

    #[test]
    fn test_premium_ignores_sell_orders() {
        let mut idx = EngineOrderIndex::new();
        let w = wallet(1);
        idx.add_order(
            &w,
            make_summary(
                1,
                "ETH-20260131-4000-C",
                Side::Sell,
                dec!(500),
                raw(dec!(5)),
            ),
        );

        let premium = idx.calculate_open_buy_premium(&w, &HashMap::new());
        assert_eq!(premium, dec!(0));
    }

    // --- rebuild_from_orderbooks round-trip tests ---

    #[test]
    fn rebuild_preserves_orders_from_single_book() {
        let w = wallet(1);
        let mut book = crate::orderbook::OrderBook::with_symbol(
            20260131,
            dec!(4000),
            hypercall_types::OptionType::Call,
            "ETH-20260131-4000-C".to_string(),
        );
        book.add_order_with_metadata(
            1,
            dec!(500),
            raw(dec!(3)),
            Side::Buy,
            w,
            1000,
            Some("client-1".to_string()),
            false,
            raw(dec!(3)),
        );
        book.add_order_with_metadata(
            2,
            dec!(600),
            raw(dec!(5)),
            Side::Sell,
            w,
            1001,
            None,
            true,
            raw(dec!(5)),
        );

        let mut orderbooks = HashMap::new();
        orderbooks.insert("ETH-20260131-4000-C".to_string(), book);

        let mut idx = EngineOrderIndex::new();
        idx.rebuild_from_orderbooks(&orderbooks);

        assert_eq!(idx.open_order_count(&w), 2);
        assert_eq!(idx.get_order_symbol(&w, 1), Some("ETH-20260131-4000-C"));
        assert_eq!(idx.get_order_symbol(&w, 2), Some("ETH-20260131-4000-C"));
        assert_eq!(
            idx.get_order_by_client_id(&w, "client-1").map(|(id, _)| id),
            Some(1)
        );
    }

    #[test]
    fn rebuild_preserves_orders_across_multiple_books() {
        let w = wallet(1);
        let mut book1 = crate::orderbook::OrderBook::with_symbol(
            20260131,
            dec!(4000),
            hypercall_types::OptionType::Call,
            "ETH-20260131-4000-C".to_string(),
        );
        book1.add_order_with_metadata(
            1,
            dec!(500),
            raw(dec!(2)),
            Side::Buy,
            w,
            1000,
            None,
            false,
            raw(dec!(2)),
        );

        let mut book2 = crate::orderbook::OrderBook::with_symbol(
            20260131,
            dec!(100000),
            hypercall_types::OptionType::Put,
            "BTC-20260131-100000-P".to_string(),
        );
        book2.add_order_with_metadata(
            2,
            dec!(8000),
            raw(dec!(1)),
            Side::Sell,
            w,
            1001,
            None,
            false,
            raw(dec!(1)),
        );

        let mut orderbooks = HashMap::new();
        orderbooks.insert("ETH-20260131-4000-C".to_string(), book1);
        orderbooks.insert("BTC-20260131-100000-P".to_string(), book2);

        let mut idx = EngineOrderIndex::new();
        idx.rebuild_from_orderbooks(&orderbooks);

        assert_eq!(idx.open_order_count(&w), 2);
        assert_eq!(idx.get_order_symbol(&w, 1), Some("ETH-20260131-4000-C"));
        assert_eq!(idx.get_order_symbol(&w, 2), Some("BTC-20260131-100000-P"));
    }

    #[test]
    fn rebuild_tracks_open_sells() {
        let w = wallet(1);
        let mut book = crate::orderbook::OrderBook::with_symbol(
            20260131,
            dec!(4000),
            hypercall_types::OptionType::Call,
            "ETH-20260131-4000-C".to_string(),
        );
        book.add_order_with_metadata(
            1,
            dec!(500),
            raw(dec!(7)),
            Side::Sell,
            w,
            1000,
            None,
            false,
            raw(dec!(7)),
        );

        let mut orderbooks = HashMap::new();
        orderbooks.insert("ETH-20260131-4000-C".to_string(), book);

        let mut idx = EngineOrderIndex::new();
        idx.rebuild_from_orderbooks(&orderbooks);

        let sells = idx.get_open_sells_for_contract(&w, "ETH-20260131-4000-C");
        assert!(sells > dec!(0));
    }

    #[test]
    fn rebuild_clears_previous_state() {
        let w = wallet(1);
        let mut idx = EngineOrderIndex::new();
        idx.add_order(
            &w,
            make_summary(
                99,
                "OLD-20260131-1000-C",
                Side::Buy,
                dec!(100),
                raw(dec!(1)),
            ),
        );
        assert_eq!(idx.open_order_count(&w), 1);

        let orderbooks = HashMap::new();
        idx.rebuild_from_orderbooks(&orderbooks);
        assert_eq!(idx.open_order_count(&w), 0);
    }

    // --- get_open_sell_option_positions tests ---

    #[test]
    fn open_sell_positions_returns_sell_options_only() {
        let mut idx = EngineOrderIndex::new();
        let w = wallet(1);

        // Sell option — should appear
        idx.add_order(
            &w,
            make_summary(
                1,
                "ETH-20260131-4000-C",
                Side::Sell,
                dec!(500),
                raw(dec!(3)),
            ),
        );
        // Buy option — should NOT appear
        idx.add_order(
            &w,
            make_summary(2, "ETH-20260131-4000-C", Side::Buy, dec!(500), raw(dec!(2))),
        );
        // Sell perp — should NOT appear
        let mut perp_sell = make_summary(3, "ETH-PERP", Side::Sell, dec!(3000), raw(dec!(1)));
        perp_sell.is_perp = true;
        idx.add_order(&w, perp_sell);

        let positions = idx.get_open_sell_option_positions(&w);
        assert_eq!(positions.len(), 1);
    }

    #[test]
    fn open_sell_positions_has_negative_size() {
        let mut idx = EngineOrderIndex::new();
        let w = wallet(1);
        idx.add_order(
            &w,
            make_summary(
                1,
                "ETH-20260131-4000-C",
                Side::Sell,
                dec!(500),
                raw(dec!(3)),
            ),
        );

        let positions = idx.get_open_sell_option_positions(&w);
        assert_eq!(positions.len(), 1);
        assert!(
            positions[0].position.size < dec!(0),
            "sell position size should be negative, got {}",
            positions[0].position.size
        );
    }

    #[test]
    fn open_sell_positions_premium_equals_price_times_size() {
        let mut idx = EngineOrderIndex::new();
        let w = wallet(1);
        idx.add_order(
            &w,
            make_summary(
                1,
                "ETH-20260131-4000-C",
                Side::Sell,
                dec!(500),
                raw(dec!(4)),
            ),
        );

        let positions = idx.get_open_sell_option_positions(&w);
        assert_eq!(positions.len(), 1);
        assert_eq!(positions[0].premium, dec!(500) * dec!(4));
    }

    #[test]
    fn open_sell_positions_parses_instrument_fields() {
        let mut idx = EngineOrderIndex::new();
        let w = wallet(1);
        idx.add_order(
            &w,
            make_summary(
                1,
                "ETH-20260131-4000-C",
                Side::Sell,
                dec!(500),
                raw(dec!(1)),
            ),
        );

        let positions = idx.get_open_sell_option_positions(&w);
        assert_eq!(positions.len(), 1);
        assert_eq!(positions[0].position.underlying, "ETH");
        assert_eq!(positions[0].position.strike, dec!(4000));
        assert!(positions[0].position.is_call);
        assert_eq!(positions[0].position.symbol, "ETH-20260131-4000-C");
    }

    #[test]
    fn open_sell_positions_empty_for_no_orders() {
        let idx = EngineOrderIndex::new();
        let w = wallet(1);
        assert!(idx.get_open_sell_option_positions(&w).is_empty());
    }
}