algo_sdk/

lib.rs

//! Sequence Algo SDK - Ultra Low Latency Trading
//!
//! Write HFT algorithms in Rust, compile to WASM, deploy to Sequence.
//!
//! # Example
//! ```rust,ignore
//! use algo_sdk::*;
//!
//! struct MyAlgo { next_id: u64 }
//!
//! impl Algo for MyAlgo {
//!     fn on_book(&mut self, book: &L2Book, state: &AlgoState, actions: &mut Actions) {
//!         if book.spread_bps() > 10 && state.position_1e8.abs() < 100_000_000 {
//!             self.next_id += 1;
//!             actions.buy(self.next_id, 1_000_000, book.bids[0].px_1e9 + 100);
//!         }
//!     }
//!     fn on_fill(&mut self, _: &Fill, _: &AlgoState) {}
//!     fn on_reject(&mut self, _: &Reject) {}
//!     fn on_shutdown(&mut self, _: &AlgoState, _: &mut Actions) {}
//! }
//!
//! export_algo!(MyAlgo { next_id: 0 });
//! ```

#![cfg_attr(not(feature = "std"), no_std)]
#![allow(non_snake_case)]

#[cfg(not(feature = "std"))]
extern crate alloc;

#[cfg(feature = "std")]
extern crate std as alloc;

// =============================================================================
// PRICE LEVEL
// =============================================================================

/// Single price level in the order book.
#[derive(Debug, Clone, Copy, Default)]
#[repr(C)]
pub struct Level {
    pub px_1e9: u64, // Price × 10⁹
    pub sz_1e8: u64, // Size × 10⁸
}

impl Level {
    pub const EMPTY: Self = Self {
        px_1e9: 0,
        sz_1e8: 0,
    };

    #[inline(always)]
    pub fn is_valid(&self) -> bool {
        self.px_1e9 > 0
    }
}

// =============================================================================
// L2 ORDER BOOK - 20 levels each side
// =============================================================================

/// L2 order book with up to 20 levels per side.
/// Total size: 688 bytes (fits in L1 cache).
#[derive(Clone, Copy)]
#[repr(C)]
pub struct L2Book {
    pub bids: [Level; 20], // Best (index 0) to worst
    pub asks: [Level; 20], // Best (index 0) to worst
    pub bid_ct: u8,        // Valid bid levels
    pub ask_ct: u8,        // Valid ask levels
    pub symbol_id: u16,
    pub _pad: u32,
    pub recv_ns: u64, // Receive timestamp
}

impl Default for L2Book {
    fn default() -> Self {
        Self {
            bids: [Level::EMPTY; 20],
            asks: [Level::EMPTY; 20],
            bid_ct: 0,
            ask_ct: 0,
            symbol_id: 0,
            _pad: 0,
            recv_ns: 0,
        }
    }
}

impl L2Book {
    #[inline(always)]
    pub fn best_bid(&self) -> Option<&Level> {
        if self.bid_ct > 0 && self.bids[0].px_1e9 > 0 {
            Some(&self.bids[0])
        } else {
            None
        }
    }

    #[inline(always)]
    pub fn best_ask(&self) -> Option<&Level> {
        if self.ask_ct > 0 && self.asks[0].px_1e9 > 0 {
            Some(&self.asks[0])
        } else {
            None
        }
    }

    #[inline(always)]
    pub fn mid_px_1e9(&self) -> u64 {
        if self.bid_ct == 0 || self.ask_ct == 0 {
            return 0;
        }
        (self.bids[0].px_1e9 + self.asks[0].px_1e9) / 2
    }

    /// Raw unsigned spread in 1e9 price units.
    /// Returns 0 for crossed books (ask < bid) due to `saturating_sub`.
    /// Use `spread_signed_1e9()` or `is_crossed()` for proper handling.
    #[inline(always)]
    pub fn spread_1e9(&self) -> u64 {
        if self.bid_ct == 0 || self.ask_ct == 0 {
            return u64::MAX;
        }
        self.asks[0].px_1e9.saturating_sub(self.bids[0].px_1e9)
    }

    /// Signed spread in 1e9 price units. Negative = crossed book.
    #[inline(always)]
    pub fn spread_signed_1e9(&self) -> i64 {
        if self.bid_ct == 0 || self.ask_ct == 0 {
            return i64::MAX;
        }
        self.asks[0].px_1e9 as i64 - self.bids[0].px_1e9 as i64
    }

    /// Spread in integer basis points (truncated).
    /// WARNING: Returns 0 for sub-bps spreads common on liquid assets (BTC, ETH).
    /// Use `spread_bps_x1000()` for milli-bps precision on liquid markets.
    #[inline(always)]
    pub fn spread_bps(&self) -> u32 {
        let mid = self.mid_px_1e9();
        if mid == 0 {
            return u32::MAX;
        }
        ((self.spread_1e9() * 10_000) / mid) as u32
    }

    /// Spread in milli-basis-points (1 bps = 1000 milli-bps), signed.
    /// Handles sub-bps precision for liquid markets and negative values for crossed books.
    /// Uses u128 intermediate to avoid overflow on high-priced assets.
    #[inline(always)]
    pub fn spread_bps_x1000(&self) -> i32 {
        let mid = self.mid_px_1e9();
        if mid == 0 {
            return i32::MAX;
        }
        let spread = self.asks[0].px_1e9 as i128 - self.bids[0].px_1e9 as i128;
        ((spread * 10_000_000) / mid as i128) as i32
    }

    /// Whether the book is crossed (best bid > best ask).
    /// Common in consolidated NBBO when different venues have different prices.
    #[inline(always)]
    pub fn is_crossed(&self) -> bool {
        self.bid_ct > 0
            && self.ask_ct > 0
            && self.bids[0].px_1e9 > self.asks[0].px_1e9
    }

    #[inline(always)]
    pub fn bid_depth_1e8(&self, levels: usize) -> u64 {
        let n = levels.min(self.bid_ct as usize);
        let mut sum = 0u64;
        for i in 0..n {
            sum += self.bids[i].sz_1e8;
        }
        sum
    }

    #[inline(always)]
    pub fn ask_depth_1e8(&self, levels: usize) -> u64 {
        let n = levels.min(self.ask_ct as usize);
        let mut sum = 0u64;
        for i in 0..n {
            sum += self.asks[i].sz_1e8;
        }
        sum
    }

    #[inline(always)]
    pub fn imbalance_bps(&self, levels: usize) -> i32 {
        let bid_depth = self.bid_depth_1e8(levels);
        let ask_depth = self.ask_depth_1e8(levels);
        let total = bid_depth + ask_depth;
        if total == 0 {
            return 0;
        }
        (((bid_depth as i64 - ask_depth as i64) * 10_000) / total as i64) as i32
    }
}

// =============================================================================
// OPEN ORDER
// =============================================================================

/// Order status.
pub mod Status {
    pub const PENDING: u8 = 0; // Sent, awaiting ack
    pub const ACKED: u8 = 1; // Acknowledged by exchange
    pub const PARTIAL: u8 = 2; // Partially filled
    pub const DEAD: u8 = 3; // Filled/cancelled/rejected
}

/// Open order tracked by server.
#[derive(Debug, Clone, Copy, Default)]
#[repr(C)]
pub struct OpenOrder {
    pub order_id: u64,
    pub px_1e9: u64,
    pub qty_1e8: i64,    // Signed: positive=buy, negative=sell
    pub filled_1e8: i64, // Amount filled
    pub side: i8,        // 1=buy, -1=sell
    pub status: u8,
    pub _pad: [u8; 6],
}

impl OpenOrder {
    pub const EMPTY: Self = Self {
        order_id: 0,
        px_1e9: 0,
        qty_1e8: 0,
        filled_1e8: 0,
        side: 0,
        status: 0,
        _pad: [0; 6],
    };

    #[inline(always)]
    pub fn is_live(&self) -> bool {
        self.status == Status::ACKED || self.status == Status::PARTIAL
    }

    #[inline(always)]
    pub fn is_pending(&self) -> bool {
        self.status == Status::PENDING
    }

    #[inline(always)]
    pub fn remaining_1e8(&self) -> i64 {
        self.qty_1e8.abs() - self.filled_1e8.abs()
    }
}

// =============================================================================
// SYMBOL METADATA (server-injected, read-only)
// =============================================================================

/// Symbol trading specifications from the exchange.
/// Injected by runtime — prevents rejects from wrong lot size / tick size.
/// Fields set to 0 mean "unknown" — helpers return input unchanged.
#[derive(Debug, Clone, Copy)]
#[repr(C)]
pub struct SymbolMeta {
    /// Minimum price increment (1e9 scaled, e.g. 10_000_000 = $0.01). 0 = unknown.
    pub tick_size_1e9: u64,
    /// Minimum qty increment (1e8 scaled, e.g. 1_000_000 = 0.01 units). 0 = unknown.
    pub lot_size_1e8: u64,
    /// Minimum order quantity (1e8 scaled). 0 = unknown.
    pub min_qty_1e8: u64,
    /// Minimum order notional value (1e9 scaled, e.g. 10_000_000_000 = $10). 0 = no minimum.
    pub min_notional_1e9: u64,
    /// Price decimal precision (e.g. 2 = $100.00).
    pub price_precision: u8,
    /// Quantity decimal precision (e.g. 8 = 0.00000001).
    pub qty_precision: u8,
    pub _pad: [u8; 6],
}

impl Default for SymbolMeta {
    fn default() -> Self {
        Self {
            tick_size_1e9: 0,
            lot_size_1e8: 0,
            min_qty_1e8: 0,
            min_notional_1e9: 0,
            price_precision: 0,
            qty_precision: 0,
            _pad: [0; 6],
        }
    }
}

impl SymbolMeta {
    pub const EMPTY: Self = Self {
        tick_size_1e9: 0,
        lot_size_1e8: 0,
        min_qty_1e8: 0,
        min_notional_1e9: 0,
        price_precision: 0,
        qty_precision: 0,
        _pad: [0; 6],
    };

    /// Round price DOWN to nearest tick. Returns raw if tick_size == 0 (unknown).
    #[inline(always)]
    pub fn round_px(&self, px_1e9: u64) -> u64 {
        if self.tick_size_1e9 == 0 {
            return px_1e9;
        }
        (px_1e9 / self.tick_size_1e9) * self.tick_size_1e9
    }

    /// Round qty DOWN to nearest lot. Returns raw if lot_size == 0 (unknown).
    #[inline(always)]
    pub fn round_qty(&self, qty_1e8: i64) -> i64 {
        if self.lot_size_1e8 == 0 {
            return qty_1e8;
        }
        let lot = self.lot_size_1e8 as i64;
        (qty_1e8 / lot) * lot
    }

    /// Check min notional. Returns true if unknown (0) — skip check, don't false-reject.
    #[inline(always)]
    pub fn check_notional(&self, qty_1e8: i64, px_1e9: u64) -> bool {
        if self.min_notional_1e9 == 0 {
            return true;
        }
        let notional = (qty_1e8.unsigned_abs() as u128 * px_1e9 as u128 / 100_000_000) as u64;
        notional >= self.min_notional_1e9
    }

    /// Check min quantity. Returns true if unknown (0).
    #[inline(always)]
    pub fn check_min_qty(&self, qty_1e8: i64) -> bool {
        if self.min_qty_1e8 == 0 {
            return true;
        }
        qty_1e8.unsigned_abs() >= self.min_qty_1e8
    }
}

// =============================================================================
// RISK SNAPSHOT (server-injected, read-only)
// =============================================================================

/// Current risk limits — read-only view for algos.
/// Allows pre-checking orders before placing (avoids wasting actions on rejects).
#[derive(Debug, Clone, Copy)]
#[repr(C)]
pub struct RiskSnapshot {
    /// Max absolute net position (1e8 scaled).
    pub max_position_1e8: i64,
    /// Daily loss limit (1e9 scaled). Algo paused if session PnL < -max_daily_loss. 0 = disabled.
    pub max_daily_loss_1e9: i64,
    /// Max single order notional (1e9 scaled).
    pub max_order_notional_1e9: u64,
    /// Max orders per second.
    pub max_order_rate: u32,
    /// 1 = reduce-only mode (can only close position).
    pub reduce_only: u8,
    pub _pad: [u8; 3],
}

impl Default for RiskSnapshot {
    fn default() -> Self {
        Self {
            max_position_1e8: 0,
            max_daily_loss_1e9: 0,
            max_order_notional_1e9: 0,
            max_order_rate: 0,
            reduce_only: 0,
            _pad: [0; 3],
        }
    }
}

impl RiskSnapshot {
    pub const EMPTY: Self = Self {
        max_position_1e8: 0,
        max_daily_loss_1e9: 0,
        max_order_notional_1e9: 0,
        max_order_rate: 0,
        reduce_only: 0,
        _pad: [0; 3],
    };

    /// Check if adding `delta_1e8` to `current_position_1e8` would exceed position limit.
    /// Returns true if order is safe. Returns true if limit is 0 (unknown/unlimited).
    #[inline(always)]
    pub fn check_position(&self, current_position_1e8: i64, delta_1e8: i64) -> bool {
        if self.max_position_1e8 == 0 {
            return true;
        }
        let projected = current_position_1e8.saturating_add(delta_1e8);
        projected.abs() <= self.max_position_1e8
    }
}

// =============================================================================
// ALGO STATE - Position + Orders (server-managed)
// =============================================================================

/// Maximum open orders per algo.
pub const MAX_ORDERS: usize = 32;

/// Algo state: position, orders, session stats, symbol metadata, and risk limits.
/// All managed by server — read-only from algo's perspective.
///
/// New fields (v0.2+) are appended after `_pad` for ABI backward compatibility.
/// Old WASM binaries compiled with v0.1.x read only up to `_pad` and ignore the rest.
#[derive(Clone, Copy)]
#[repr(C)]
pub struct AlgoState {
    // --- Position (v0.1) ---
    pub position_1e8: i64,       // Net position (positive=long)
    pub avg_entry_1e9: u64,      // Average entry price
    pub realized_pnl_1e9: i64,   // Realized PnL (lifetime)
    pub unrealized_pnl_1e9: i64, // Unrealized PnL (mark-to-market)
    // --- Orders (v0.1) ---
    pub orders: [OpenOrder; MAX_ORDERS],
    pub order_ct: u8,
    pub _pad: [u8; 7],
    // --- Session stats (v0.2) ---
    pub session_pnl_1e9: i64, // Session realized PnL (resets at UTC midnight)
    pub total_fill_count: u64, // Lifetime fill count (never resets)
    // --- Symbol metadata (v0.2) ---
    pub symbol: SymbolMeta, // Tick size, lot size, min notional
    // --- Risk limits (v0.2) ---
    pub risk: RiskSnapshot, // Max position, daily loss limit, etc.
}

impl Default for AlgoState {
    fn default() -> Self {
        Self {
            position_1e8: 0,
            avg_entry_1e9: 0,
            realized_pnl_1e9: 0,
            unrealized_pnl_1e9: 0,
            orders: [OpenOrder::EMPTY; MAX_ORDERS],
            order_ct: 0,
            _pad: [0; 7],
            session_pnl_1e9: 0,
            total_fill_count: 0,
            symbol: SymbolMeta::EMPTY,
            risk: RiskSnapshot::EMPTY,
        }
    }
}

/// PnL snapshot in fixed-point units (1e9 = $1.00).
#[derive(Debug, Clone, Copy, Default)]
pub struct PnlSnapshot {
    pub realized_1e9: i64,
    pub unrealized_1e9: i64,
    pub total_1e9: i64,
}

impl AlgoState {
    #[inline(always)]
    pub fn is_flat(&self) -> bool {
        self.position_1e8 == 0
    }

    #[inline(always)]
    pub fn is_long(&self) -> bool {
        self.position_1e8 > 0
    }

    #[inline(always)]
    pub fn is_short(&self) -> bool {
        self.position_1e8 < 0
    }

    #[inline(always)]
    pub fn has_orders(&self) -> bool {
        self.order_ct > 0
    }

    #[inline(always)]
    pub fn live_order_count(&self) -> usize {
        let mut ct = 0;
        for i in 0..self.order_ct as usize {
            if self.orders[i].is_live() {
                ct += 1;
            }
        }
        ct
    }

    #[inline(always)]
    pub fn find_order(&self, order_id: u64) -> Option<&OpenOrder> {
        for i in 0..self.order_ct as usize {
            if self.orders[i].order_id == order_id {
                return Some(&self.orders[i]);
            }
        }
        None
    }

    #[inline(always)]
    pub fn open_buy_qty_1e8(&self) -> i64 {
        let mut sum = 0i64;
        for i in 0..self.order_ct as usize {
            let o = &self.orders[i];
            if o.is_live() && o.side > 0 {
                sum += o.remaining_1e8();
            }
        }
        sum
    }

    #[inline(always)]
    pub fn open_sell_qty_1e8(&self) -> i64 {
        let mut sum = 0i64;
        for i in 0..self.order_ct as usize {
            let o = &self.orders[i];
            if o.is_live() && o.side < 0 {
                sum += o.remaining_1e8();
            }
        }
        sum
    }

    #[inline(always)]
    pub fn total_pnl_1e9(&self) -> i64 {
        self.realized_pnl_1e9 + self.unrealized_pnl_1e9
    }

    /// Ergonomic PnL accessor for strategies that want a single call.
    #[inline(always)]
    pub fn get_pnl(&self) -> PnlSnapshot {
        PnlSnapshot {
            realized_1e9: self.realized_pnl_1e9,
            unrealized_1e9: self.unrealized_pnl_1e9,
            total_1e9: self.total_pnl_1e9(),
        }
    }

    /// Realized PnL as USD float.
    #[inline(always)]
    pub fn realized_pnl_usd(&self) -> f64 {
        self.realized_pnl_1e9 as f64 / 1e9
    }

    /// Unrealized PnL as USD float.
    #[inline(always)]
    pub fn unrealized_pnl_usd(&self) -> f64 {
        self.unrealized_pnl_1e9 as f64 / 1e9
    }

    /// Total PnL as USD float.
    #[inline(always)]
    pub fn total_pnl_usd(&self) -> f64 {
        self.total_pnl_1e9() as f64 / 1e9
    }

    /// Session realized PnL as USD float. Resets at UTC midnight.
    #[inline(always)]
    pub fn session_pnl_usd(&self) -> f64 {
        self.session_pnl_1e9 as f64 / 1e9
    }
}

// =============================================================================
// FILL EVENT
// =============================================================================

#[derive(Debug, Clone, Copy)]
#[repr(C)]
pub struct Fill {
    pub order_id: u64,
    pub px_1e9: u64,
    pub qty_1e8: i64,
    pub recv_ns: u64, // Timestamp when fill was received
    pub side: i8,
    pub _pad: [u8; 7],
}

impl Fill {
    /// Elapsed time since a caller-provided start timestamp.
    /// Typical use: `fill.since_ms(start_ns)` where `start_ns` came from `book.recv_ns`.
    #[inline(always)]
    pub fn since_ns(&self, start_ns: u64) -> u64 {
        self.recv_ns.saturating_sub(start_ns)
    }

    #[inline(always)]
    pub fn since_us(&self, start_ns: u64) -> u64 {
        self.since_ns(start_ns) / 1_000
    }

    #[inline(always)]
    pub fn since_ms(&self, start_ns: u64) -> u64 {
        self.since_ns(start_ns) / 1_000_000
    }

    /// Symbol identifier (v0.4+). 0 = single-symbol or unset.
    /// In multi-symbol backtests, matches L2Book.symbol_id.
    /// Stored in _pad[0..2] as little-endian u16 for ABI backward compat.
    #[inline(always)]
    pub fn symbol_id(&self) -> u16 {
        u16::from_le_bytes([self._pad[0], self._pad[1]])
    }

    /// Set symbol identifier. Used by sim-engine orchestrator.
    #[inline(always)]
    pub fn set_symbol_id(&mut self, id: u16) {
        let bytes = id.to_le_bytes();
        self._pad[0] = bytes[0];
        self._pad[1] = bytes[1];
    }
}

// ABI size assertions — these must match the WASM memory layout expectations
const _: () = assert!(core::mem::size_of::<Fill>() == 40, "Fill size changed — ABI break");
const _: () = assert!(core::mem::size_of::<Reject>() == 16, "Reject size changed — ABI break");

// =============================================================================
// FILL EXTENDED METADATA
// =============================================================================

/// Extended fill metadata (NOT in WASM memory — delivered via separate channel).
///
/// Provides additional context about a fill that doesn't fit in the fixed-size
/// `Fill` struct in WASM shared memory. Delivered out-of-band by the runtime.
#[derive(Debug, Clone, Copy, Default)]
pub struct FillExt {
    /// 1 = maker, 0 = taker, 255 = unknown.
    pub is_maker: u8,
    /// Fee in 1e9 units. Negative = rebate.
    pub fee_1e9: i64,
    /// Estimated queue depth ahead at time of fill (1e8 units), or -1 if unknown.
    pub queue_ahead_1e8: i64,
}

// =============================================================================
// TIME HELPERS
// =============================================================================

/// Simple timing helpers for client-controlled latency measurement.
/// SDK/runtime does not force any logging; strategy decides how/when to log.
pub mod time {
    /// Start a timer from an event timestamp (usually `book.recv_ns` or `fill.recv_ns`).
    #[inline(always)]
    pub fn start(now_ns: u64) -> u64 {
        now_ns
    }

    /// Stop a timer and return elapsed nanoseconds.
    #[inline(always)]
    pub fn stop_ns(start_ns: u64, now_ns: u64) -> u64 {
        now_ns.saturating_sub(start_ns)
    }

    #[inline(always)]
    pub fn stop_us(start_ns: u64, now_ns: u64) -> u64 {
        stop_ns(start_ns, now_ns) / 1_000
    }

    #[inline(always)]
    pub fn stop_ms(start_ns: u64, now_ns: u64) -> u64 {
        stop_ns(start_ns, now_ns) / 1_000_000
    }

    /// Stateful timer for strategies that prefer start/stop on a struct.
    #[derive(Debug, Clone, Copy, Default)]
    pub struct Timer {
        start_ns: u64,
    }

    impl Timer {
        #[inline(always)]
        pub const fn new() -> Self {
            Self { start_ns: 0 }
        }

        #[inline(always)]
        pub fn start(&mut self, now_ns: u64) {
            self.start_ns = now_ns;
        }

        #[inline(always)]
        pub fn stop_ns(&self, now_ns: u64) -> u64 {
            now_ns.saturating_sub(self.start_ns)
        }

        #[inline(always)]
        pub fn stop_us(&self, now_ns: u64) -> u64 {
            self.stop_ns(now_ns) / 1_000
        }

        #[inline(always)]
        pub fn stop_ms(&self, now_ns: u64) -> u64 {
            self.stop_ns(now_ns) / 1_000_000
        }
    }
}

// =============================================================================
// REJECT EVENT
// =============================================================================

/// Reject codes from exchange (matches cc_proto::RejectClass).
pub mod RejectCode {
    /// Unknown error
    pub const UNKNOWN: u8 = 0;
    /// Insufficient balance/funds
    pub const INSUFFICIENT_BALANCE: u8 = 1;
    /// Invalid parameters (price, qty, symbol)
    pub const INVALID_PARAMS: u8 = 2;
    /// Exchange rate limit hit
    pub const RATE_LIMIT: u8 = 3;
    /// Exchange temporarily unavailable
    pub const EXCHANGE_BUSY: u8 = 4;
    /// Network error
    pub const NETWORK: u8 = 5;
    /// Authentication error (invalid API key/secret)
    pub const AUTH: u8 = 6;

    // Internal reject codes (from risk engine, >=100)
    /// Risk check failed
    pub const RISK: u8 = 100;
    /// Position limit exceeded
    pub const POSITION_LIMIT: u8 = 101;
    /// Kill switch triggered
    pub const KILL_SWITCH: u8 = 102;
    /// Fat-finger: price deviates too far from reference (best bid/ask)
    pub const PRICE_DEVIATION: u8 = 103;
    /// Daily P&L loss limit breached — algo paused
    pub const DAILY_LOSS_LIMIT: u8 = 104;
    /// Venue ID not in registered venue set (multi-venue)
    pub const BAD_VENUE: u8 = 105;
    /// Target venue data is stale (multi-venue)
    pub const STALE_VENUE: u8 = 106;

    /// Get human-readable description for a reject code.
    pub fn to_str(code: u8) -> &'static str {
        match code {
            UNKNOWN => "UNKNOWN",
            INSUFFICIENT_BALANCE => "INSUFFICIENT_BALANCE",
            INVALID_PARAMS => "INVALID_PARAMS",
            RATE_LIMIT => "RATE_LIMIT",
            EXCHANGE_BUSY => "EXCHANGE_BUSY",
            NETWORK => "NETWORK",
            AUTH => "AUTH",
            RISK => "RISK_CHECK_FAILED",
            POSITION_LIMIT => "POSITION_LIMIT",
            KILL_SWITCH => "KILL_SWITCH",
            PRICE_DEVIATION => "PRICE_DEVIATION",
            DAILY_LOSS_LIMIT => "DAILY_LOSS_LIMIT",
            BAD_VENUE => "BAD_VENUE",
            STALE_VENUE => "STALE_VENUE",
            _ => "UNKNOWN",
        }
    }
}

#[derive(Debug, Clone, Copy)]
#[repr(C)]
pub struct Reject {
    pub order_id: u64,
    pub code: u8,
    pub _pad: [u8; 7],
}

impl Reject {
    /// Get human-readable description of the reject reason.
    #[inline]
    pub fn reason(&self) -> &'static str {
        RejectCode::to_str(self.code)
    }

    /// Symbol identifier (v0.4+). 0 = single-symbol or unset.
    #[inline(always)]
    pub fn symbol_id(&self) -> u16 {
        u16::from_le_bytes([self._pad[0], self._pad[1]])
    }

    #[inline(always)]
    pub fn set_symbol_id(&mut self, id: u16) {
        let bytes = id.to_le_bytes();
        self._pad[0] = bytes[0];
        self._pad[1] = bytes[1];
    }
}

// =============================================================================
// ORDER TYPES
// =============================================================================

/// Order type for execution semantics.
pub mod OrderType {
    /// Limit order - sits on book until filled or canceled (default).
    pub const LIMIT: u8 = 0;
    /// Market order - fills immediately at best available price.
    pub const MARKET: u8 = 1;
    /// Immediate-Or-Cancel - fill what you can, cancel the rest.
    pub const IOC: u8 = 2;
    /// Fill-Or-Kill - fill entire qty or reject completely.
    pub const FOK: u8 = 3;
    /// Post-only - sits on book, rejected if it would cross (maker only).
    /// Maps to venue-native post-only (Kraken `post_only:true`, Binance `LIMIT_MAKER`).
    /// Venues without native post-only reject with `RejectCode::INVALID_PARAMS`.
    pub const POST_ONLY: u8 = 4;
}

// =============================================================================
// ACTIONS BUFFER
// =============================================================================

// ── Action type constants ────────────────────────────────────────────────
/// New order action (place on book).
pub const ACTION_NEW: u8 = 0;
/// Cancel an existing order.
pub const ACTION_CANCEL: u8 = 1;
/// Amend an existing order (atomic modify price/qty).
pub const ACTION_AMEND: u8 = 2;

/// Order action (place, cancel, or amend).
///
/// 32 bytes, `#[repr(C)]`. Byte 27 is `venue_id`:
/// - `0` = default venue (backward compatible — old algos never set this byte)
/// - `1..N` = specific VenueId (from `NbboSnapshot.venue_ids[]`)
///
/// `is_cancel` field doubles as action type:
/// - `0` = new order (ACTION_NEW)
/// - `1` = cancel (ACTION_CANCEL)
/// - `2` = amend (ACTION_AMEND) — modifies price/qty of existing order
#[derive(Debug, Clone, Copy, Default)]
#[repr(C)]
pub struct Action {
    pub order_id: u64,
    pub px_1e9: u64,
    pub qty_1e8: i64,
    pub side: i8, // 1=buy, -1=sell, 0=cancel
    pub is_cancel: u8,
    pub order_type: u8, // OrderType::LIMIT, MARKET, IOC, FOK
    pub venue_id: u8,   // 0=default, 1..N=specific venue (was _pad[0])
    pub _pad: [u8; 4],
}

/// Max actions per callback.
pub const MAX_ACTIONS: usize = 16;

/// Actions buffer - orders to send.
#[repr(C)]
pub struct Actions {
    actions: [Action; MAX_ACTIONS],
    len: usize,
}

impl Actions {
    #[inline(always)]
    pub const fn new() -> Self {
        Self {
            actions: [Action {
                order_id: 0,
                px_1e9: 0,
                qty_1e8: 0,
                side: 0,
                is_cancel: 0,
                order_type: 0,
                venue_id: 0,
                _pad: [0; 4],
            }; MAX_ACTIONS],
            len: 0,
        }
    }

    #[inline(always)]
    pub fn clear(&mut self) {
        self.len = 0;
    }

    #[inline(always)]
    pub fn len(&self) -> usize {
        self.len
    }

    #[inline(always)]
    pub fn is_empty(&self) -> bool {
        self.len == 0
    }

    #[inline(always)]
    pub fn is_full(&self) -> bool {
        self.len >= MAX_ACTIONS
    }

    // =========================================================================
    // LIMIT ORDERS (default) - sit on book until filled or canceled
    // =========================================================================

    /// Place a limit buy order (GTC - Good Till Canceled).
    #[inline(always)]
    pub fn buy(&mut self, order_id: u64, qty_1e8: i64, px_1e9: u64) -> bool {
        self.order_typed(order_id, 1, qty_1e8, px_1e9, OrderType::LIMIT)
    }

    /// Place a limit sell order (GTC - Good Till Canceled).
    #[inline(always)]
    pub fn sell(&mut self, order_id: u64, qty_1e8: i64, px_1e9: u64) -> bool {
        self.order_typed(order_id, -1, qty_1e8, px_1e9, OrderType::LIMIT)
    }

    /// Place limit order with explicit side (1=buy, -1=sell).
    #[inline(always)]
    pub fn order(&mut self, order_id: u64, side: i8, qty_1e8: i64, px_1e9: u64) -> bool {
        self.order_typed(order_id, side, qty_1e8, px_1e9, OrderType::LIMIT)
    }

    // =========================================================================
    // MARKET ORDERS - fill immediately at best available price
    // =========================================================================

    /// Place a market buy order (fills immediately).
    #[inline(always)]
    pub fn market_buy(&mut self, order_id: u64, qty_1e8: i64) -> bool {
        self.order_typed(order_id, 1, qty_1e8, 0, OrderType::MARKET)
    }

    /// Place a market sell order (fills immediately).
    #[inline(always)]
    pub fn market_sell(&mut self, order_id: u64, qty_1e8: i64) -> bool {
        self.order_typed(order_id, -1, qty_1e8, 0, OrderType::MARKET)
    }

    // =========================================================================
    // IOC ORDERS - Immediate-Or-Cancel (fill what you can, cancel rest)
    // =========================================================================

    /// Place IOC buy - fills available liquidity, cancels unfilled portion.
    #[inline(always)]
    pub fn ioc_buy(&mut self, order_id: u64, qty_1e8: i64, px_1e9: u64) -> bool {
        self.order_typed(order_id, 1, qty_1e8, px_1e9, OrderType::IOC)
    }

    /// Place IOC sell - fills available liquidity, cancels unfilled portion.
    #[inline(always)]
    pub fn ioc_sell(&mut self, order_id: u64, qty_1e8: i64, px_1e9: u64) -> bool {
        self.order_typed(order_id, -1, qty_1e8, px_1e9, OrderType::IOC)
    }

    // =========================================================================
    // FOK ORDERS - Fill-Or-Kill (fill entire qty or reject)
    // =========================================================================

    /// Place FOK buy - must fill entire quantity or rejected.
    #[inline(always)]
    pub fn fok_buy(&mut self, order_id: u64, qty_1e8: i64, px_1e9: u64) -> bool {
        self.order_typed(order_id, 1, qty_1e8, px_1e9, OrderType::FOK)
    }

    /// Place FOK sell - must fill entire quantity or rejected.
    #[inline(always)]
    pub fn fok_sell(&mut self, order_id: u64, qty_1e8: i64, px_1e9: u64) -> bool {
        self.order_typed(order_id, -1, qty_1e8, px_1e9, OrderType::FOK)
    }

    // =========================================================================
    // POST-ONLY ORDERS - maker only, rejected if would cross book
    // =========================================================================

    /// Place a post-only buy order (maker only, rejected if would cross).
    #[inline(always)]
    pub fn post_only_buy(&mut self, order_id: u64, qty_1e8: i64, px_1e9: u64) -> bool {
        self.order_typed(order_id, 1, qty_1e8, px_1e9, OrderType::POST_ONLY)
    }

    /// Place a post-only sell order (maker only, rejected if would cross).
    #[inline(always)]
    pub fn post_only_sell(&mut self, order_id: u64, qty_1e8: i64, px_1e9: u64) -> bool {
        self.order_typed(order_id, -1, qty_1e8, px_1e9, OrderType::POST_ONLY)
    }

    // =========================================================================
    // CORE ORDER PLACEMENT
    // =========================================================================

    /// Place order with explicit type.
    #[inline(always)]
    pub fn order_typed(
        &mut self,
        order_id: u64,
        side: i8,
        qty_1e8: i64,
        px_1e9: u64,
        order_type: u8,
    ) -> bool {
        if self.len >= MAX_ACTIONS {
            return false;
        }
        self.actions[self.len] = Action {
            order_id,
            px_1e9,
            qty_1e8,
            side,
            is_cancel: 0,
            order_type,
            venue_id: 0,
            _pad: [0; 4],
        };
        self.len += 1;
        true
    }

    /// Cancel an order.
    #[inline(always)]
    pub fn cancel(&mut self, order_id: u64) -> bool {
        if self.len >= MAX_ACTIONS {
            return false;
        }
        self.actions[self.len] = Action {
            order_id,
            px_1e9: 0,
            qty_1e8: 0,
            side: 0,
            is_cancel: 1,
            order_type: 0,
            venue_id: 0,
            _pad: [0; 4],
        };
        self.len += 1;
        true
    }

    /// Cancel all open orders.
    #[inline(always)]
    pub fn cancel_all(&mut self, state: &AlgoState) {
        for i in 0..state.order_ct as usize {
            let o = &state.orders[i];
            if o.is_live() && self.len < MAX_ACTIONS {
                self.cancel(o.order_id);
            }
        }
    }

    // =========================================================================
    // AMEND ORDERS - atomic modify price/qty of existing order
    // =========================================================================

    /// Amend an existing order's price and/or quantity.
    ///
    /// Uses `is_cancel = ACTION_AMEND (2)`. The venue performs an atomic
    /// edit — the order keeps its ID and (when only qty decreases) its
    /// queue position.
    ///
    /// Returns `false` if the actions buffer is full.
    #[inline(always)]
    pub fn amend(&mut self, order_id: u64, new_qty_1e8: i64, new_px_1e9: u64) -> bool {
        if self.len >= MAX_ACTIONS {
            return false;
        }
        self.actions[self.len] = Action {
            order_id,
            px_1e9: new_px_1e9,
            qty_1e8: new_qty_1e8,
            side: 0,                // not relevant for amend
            is_cancel: ACTION_AMEND,
            order_type: 0,
            venue_id: 0,
            _pad: [0; 4],
        };
        self.len += 1;
        true
    }

    /// Amend an existing order on a specific venue.
    #[inline(always)]
    pub fn amend_on(&mut self, venue_id: u8, order_id: u64, new_qty_1e8: i64, new_px_1e9: u64) -> bool {
        if self.len >= MAX_ACTIONS {
            return false;
        }
        self.actions[self.len] = Action {
            order_id,
            px_1e9: new_px_1e9,
            qty_1e8: new_qty_1e8,
            side: 0,
            is_cancel: ACTION_AMEND,
            order_type: 0,
            venue_id,
            _pad: [0; 4],
        };
        self.len += 1;
        true
    }

    // =========================================================================
    // VENUE-TARGETED ORDERS (multi-venue algos)
    // =========================================================================

    /// Place a limit buy on a specific venue.
    /// `venue_id` is a VenueId value from `NbboSnapshot.venue_ids[]`.
    #[inline(always)]
    pub fn buy_on(&mut self, venue_id: u8, order_id: u64, qty_1e8: i64, px_1e9: u64) -> bool {
        self.order_on_venue(venue_id, order_id, 1, qty_1e8, px_1e9, OrderType::LIMIT)
    }

    /// Place a limit sell on a specific venue.
    #[inline(always)]
    pub fn sell_on(&mut self, venue_id: u8, order_id: u64, qty_1e8: i64, px_1e9: u64) -> bool {
        self.order_on_venue(venue_id, order_id, -1, qty_1e8, px_1e9, OrderType::LIMIT)
    }

    /// Place an IOC buy on a specific venue.
    #[inline(always)]
    pub fn ioc_buy_on(&mut self, venue_id: u8, order_id: u64, qty_1e8: i64, px_1e9: u64) -> bool {
        self.order_on_venue(venue_id, order_id, 1, qty_1e8, px_1e9, OrderType::IOC)
    }

    /// Place an IOC sell on a specific venue.
    #[inline(always)]
    pub fn ioc_sell_on(&mut self, venue_id: u8, order_id: u64, qty_1e8: i64, px_1e9: u64) -> bool {
        self.order_on_venue(venue_id, order_id, -1, qty_1e8, px_1e9, OrderType::IOC)
    }

    /// Place a venue-targeted order with explicit side and order type.
    /// Used by the runtime to replay actions read from WASM memory.
    #[inline(always)]
    pub fn order_on_venue(
        &mut self,
        venue_id: u8,
        order_id: u64,
        side: i8,
        qty_1e8: i64,
        px_1e9: u64,
        order_type: u8,
    ) -> bool {
        if self.len >= MAX_ACTIONS {
            return false;
        }
        self.actions[self.len] = Action {
            order_id,
            px_1e9,
            qty_1e8,
            side,
            is_cancel: 0,
            order_type,
            venue_id,
            _pad: [0; 4],
        };
        self.len += 1;
        true
    }

    /// Zero out an action at index (marks as no-op).
    /// Used by risk engine to neutralize rejected actions in-place.
    #[inline(always)]
    pub fn clear_at(&mut self, idx: usize) {
        if idx < self.len {
            self.actions[idx] = Action {
                order_id: 0,
                px_1e9: 0,
                qty_1e8: 0,
                side: 0,
                is_cancel: 0,
                order_type: 0,
                venue_id: 0,
                _pad: [0; 4],
            };
        }
    }

    #[inline(always)]
    pub fn get(&self, idx: usize) -> Option<&Action> {
        if idx < self.len {
            Some(&self.actions[idx])
        } else {
            None
        }
    }

    #[inline(always)]
    pub fn iter(&self) -> impl Iterator<Item = &Action> {
        self.actions[..self.len].iter()
    }
}

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

// =============================================================================
// ALGO TRAIT
// =============================================================================

/// Trading algorithm trait.
/// All methods run on HOT PATH - avoid heap allocations.
pub trait Algo: Send {
    /// Called on every book update.
    /// - book: L2 order book (20 levels)
    /// - state: Your position + open orders (server-managed)
    /// - actions: Buffer to place/cancel orders
    fn on_book(&mut self, book: &L2Book, state: &AlgoState, actions: &mut Actions);

    /// Order filled.
    fn on_fill(&mut self, fill: &Fill, state: &AlgoState);

    /// Order rejected.
    fn on_reject(&mut self, reject: &Reject);

    /// Shutdown - cancel open orders here.
    fn on_shutdown(&mut self, state: &AlgoState, actions: &mut Actions);
}

// =============================================================================
// ALGO V3 TRAIT (single-venue + OnlineFeatures)
// =============================================================================

/// Extended algo trait with OnlineFeatures access.
///
/// Detected at load time via WASM export probe for `algo_on_book_v3`.
/// Falls back to `Algo` trait if not present.
///
/// All methods run on HOT PATH — avoid heap allocations.
pub trait AlgoV3: Send {
    /// Called on every book update with OnlineFeatures from the data engine.
    fn on_book(
        &mut self,
        book: &L2Book,
        state: &AlgoState,
        features: &OnlineFeatures,
        actions: &mut Actions,
    );

    /// Order filled.
    fn on_fill(&mut self, fill: &Fill, state: &AlgoState);

    /// Order rejected.
    fn on_reject(&mut self, reject: &Reject);

    /// Shutdown — cancel open orders here.
    fn on_shutdown(&mut self, state: &AlgoState, actions: &mut Actions);

    /// Heartbeat callback (1 Hz, optional). Default: no-op.
    fn on_heartbeat(
        &mut self,
        _state: &AlgoState,
        _features: &OnlineFeatures,
        _actions: &mut Actions,
    ) {
    }
}

// =============================================================================
// MULTI-VENUE ALGO (cross-venue arbitrage, cross-venue market making)
// =============================================================================

/// Maximum number of venues in a multi-venue snapshot.
pub const MAX_VENUES: usize = 20; // 9 CEX + 7 DEX + 4 headroom

// =============================================================================
// VENUE ID CONSTANTS (wire format = CC VenueId + 1, 0 = default/local)
// =============================================================================

/// Kraken (CEX)
pub const VENUE_KRAKEN: u8 = 1;
/// Coinbase (CEX)
pub const VENUE_COINBASE: u8 = 2;
/// Binance (CEX)
pub const VENUE_BINANCE: u8 = 3;
/// Bitget (CEX)
pub const VENUE_BITGET: u8 = 4;
/// Crypto.com (CEX)
pub const VENUE_CRYPTOCOM: u8 = 5;
/// Bitmart (CEX)
pub const VENUE_BITMART: u8 = 6;
/// Generic DEX (aggregated across chains)
pub const VENUE_DEX: u8 = 7;
/// OKX (CEX)
pub const VENUE_OKX: u8 = 8;
/// Bybit (CEX)
pub const VENUE_BYBIT: u8 = 9;
/// Unknown venue (wire ID 10, maps to CC VenueId::Unknown)
pub const VENUE_UNKNOWN: u8 = 10;
/// DEX — Ethereum mainnet (Uniswap V2/V3, Curve, Balancer V2)
pub const VENUE_DEX_ETH: u8 = 11;
/// DEX — Arbitrum (Uniswap V3, Camelot)
pub const VENUE_DEX_ARB: u8 = 12;
/// DEX — Base (Uniswap V3, Aerodrome)
pub const VENUE_DEX_BASE: u8 = 13;
/// DEX — Optimism (Uniswap V3, Velodrome)
pub const VENUE_DEX_OP: u8 = 14;
/// DEX — Polygon (Uniswap V2, Balancer V2, Curve)
pub const VENUE_DEX_POLY: u8 = 15;
/// DEX — Solana (Raydium, Orca, Jupiter aggregated)
pub const VENUE_DEX_SOL: u8 = 16;
/// Hyperliquid (CEX — L1 with on-chain settlement, EIP-712 signing)
pub const VENUE_HYPERLIQUID: u8 = 17;

/// Returns `true` if this venue is a DEX (on-chain liquidity).
#[inline(always)]
pub fn is_dex(venue_id: u8) -> bool {
    venue_id == VENUE_DEX
        || (venue_id >= VENUE_DEX_ETH && venue_id <= VENUE_DEX_POLY)
        || venue_id == VENUE_DEX_SOL
}

/// Returns `true` if this venue is a CEX (centralized exchange).
#[inline(always)]
pub fn is_cex(venue_id: u8) -> bool {
    (venue_id >= VENUE_KRAKEN && venue_id <= VENUE_BYBIT && venue_id != VENUE_DEX)
        || venue_id == VENUE_HYPERLIQUID
}

/// Human-readable name for a venue ID.
pub fn venue_name(venue_id: u8) -> &'static str {
    match venue_id {
        0 => "default",
        VENUE_KRAKEN => "kraken",
        VENUE_COINBASE => "coinbase",
        VENUE_BINANCE => "binance",
        VENUE_BITGET => "bitget",
        VENUE_CRYPTOCOM => "cryptocom",
        VENUE_BITMART => "bitmart",
        VENUE_DEX => "dex",
        VENUE_OKX => "okx",
        VENUE_BYBIT => "bybit",
        VENUE_UNKNOWN => "unknown",
        VENUE_DEX_ETH => "dex-eth",
        VENUE_DEX_ARB => "dex-arb",
        VENUE_DEX_BASE => "dex-base",
        VENUE_DEX_OP => "dex-op",
        VENUE_DEX_POLY => "dex-poly",
        VENUE_DEX_SOL => "dex-sol",
        VENUE_HYPERLIQUID => "hyperliquid",
        _ => "unknown",
    }
}

/// Cross-venue NBBO snapshot delivered to multi-venue algos.
///
/// Contains the global NBBO plus per-venue BBO data in struct-of-arrays
/// layout for cache efficiency. ~480 bytes, fits in a single WASM page.
///
/// ## Venue-index convention (frozen — all paths use this):
/// - `venue_ids[slot]` = VenueId for array slot `slot` (populated by runtime, sorted ascending)
/// - `venue_bid_px[slot]`, `venue_ask_px[slot]`, etc. all use the same `slot` index
/// - `nbbo_bid_venue`, `nbbo_ask_venue` = array slot index (0..venue_ct-1), NOT VenueId
///   - Use `venue_ids[nbbo_bid_venue]` to get the VenueId of the best bidder
/// - `Action.venue_id` = VenueId VALUE (not array slot). Runtime maps via `venue_ids[]`
#[derive(Clone, Copy, Debug)]
#[repr(C)]
pub struct NbboSnapshot {
    // --- Global NBBO ---
    pub nbbo_bid_px_1e9: u64,
    pub nbbo_ask_px_1e9: u64,
    pub nbbo_bid_sz_1e8: u64,
    pub nbbo_ask_sz_1e8: u64,
    // --- Venue identification ---
    pub nbbo_bid_venue: u8, // array slot index of best bid venue
    pub nbbo_ask_venue: u8, // array slot index of best ask venue
    pub venue_ct: u8,       // number of active venues
    pub _pad0: u8,
    pub sequence: u32, // monotonic counter — algo can detect stale snapshots
    // --- Venue ID mapping: slot → VenueId (sorted ascending) ---
    pub venue_ids: [u8; MAX_VENUES],
    // --- Per-venue BBO (struct-of-arrays for cache efficiency) ---
    pub venue_bid_px: [u64; MAX_VENUES],
    pub venue_ask_px: [u64; MAX_VENUES],
    pub venue_bid_sz: [u32; MAX_VENUES],
    pub venue_ask_sz: [u32; MAX_VENUES],
    // --- Per-venue staleness ---
    pub venue_update_ms: [u16; MAX_VENUES], // ms since last update (0=fresh, 65535=stale)
    // --- Timestamp ---
    pub recv_ns: u64,
}

impl Default for NbboSnapshot {
    fn default() -> Self {
        Self {
            nbbo_bid_px_1e9: 0,
            nbbo_ask_px_1e9: 0,
            nbbo_bid_sz_1e8: 0,
            nbbo_ask_sz_1e8: 0,
            nbbo_bid_venue: 0,
            nbbo_ask_venue: 0,
            venue_ct: 0,
            _pad0: 0,
            sequence: 0,
            venue_ids: [0; MAX_VENUES],
            venue_bid_px: [0; MAX_VENUES],
            venue_ask_px: [0; MAX_VENUES],
            venue_bid_sz: [0; MAX_VENUES],
            venue_ask_sz: [0; MAX_VENUES],
            venue_update_ms: [0; MAX_VENUES],
            recv_ns: 0,
        }
    }
}

impl NbboSnapshot {
    /// NBBO spread in integer basis points. Returns `u32::MAX` if no valid NBBO.
    /// WARNING: Returns 0 for sub-bps spreads. Use `nbbo_spread_bps_x1000()` for precision.
    #[inline(always)]
    pub fn nbbo_spread_bps(&self) -> u32 {
        if self.nbbo_bid_px_1e9 == 0 || self.nbbo_ask_px_1e9 == 0 {
            return u32::MAX;
        }
        let mid = (self.nbbo_bid_px_1e9 + self.nbbo_ask_px_1e9) / 2;
        if mid == 0 {
            return u32::MAX;
        }
        ((self.nbbo_ask_px_1e9.saturating_sub(self.nbbo_bid_px_1e9)) * 10_000 / mid) as u32
    }

    /// NBBO spread in milli-basis-points (1 bps = 1000), signed.
    /// Negative = crossed market. Uses u128 to avoid overflow.
    #[inline(always)]
    pub fn nbbo_spread_bps_x1000(&self) -> i32 {
        if self.nbbo_bid_px_1e9 == 0 || self.nbbo_ask_px_1e9 == 0 {
            return i32::MAX;
        }
        let mid = (self.nbbo_bid_px_1e9 + self.nbbo_ask_px_1e9) / 2;
        if mid == 0 {
            return i32::MAX;
        }
        let spread = self.nbbo_ask_px_1e9 as i128 - self.nbbo_bid_px_1e9 as i128;
        ((spread * 10_000_000) / mid as i128) as i32
    }

    /// Whether any venue's bid > another venue's ask (crossed market = arb opportunity).
    #[inline(always)]
    pub fn is_crossed(&self) -> bool {
        self.nbbo_bid_px_1e9 > 0
            && self.nbbo_ask_px_1e9 > 0
            && self.nbbo_bid_px_1e9 > self.nbbo_ask_px_1e9
            && self.nbbo_bid_venue != self.nbbo_ask_venue
    }

    /// Get bid price for a venue slot.
    #[inline(always)]
    pub fn venue_bid(&self, slot: usize) -> u64 {
        if slot < self.venue_ct as usize {
            self.venue_bid_px[slot]
        } else {
            0
        }
    }

    /// Get ask price for a venue slot.
    #[inline(always)]
    pub fn venue_ask(&self, slot: usize) -> u64 {
        if slot < self.venue_ct as usize {
            self.venue_ask_px[slot]
        } else {
            0
        }
    }

    /// Check if a venue's data is stale.
    #[inline(always)]
    pub fn is_venue_stale(&self, slot: usize, max_ms: u16) -> bool {
        if slot < self.venue_ct as usize {
            self.venue_update_ms[slot] > max_ms
        } else {
            true
        }
    }

    /// Find the array slot for a given VenueId. Linear scan of `venue_ids[0..venue_ct]`.
    #[inline]
    pub fn slot_for_venue(&self, venue_id: u8) -> Option<usize> {
        let ct = self.venue_ct as usize;
        for i in 0..ct {
            if self.venue_ids[i] == venue_id {
                return Some(i);
            }
        }
        None
    }

    /// VenueId of the best bid venue.
    #[inline(always)]
    pub fn best_bid_venue_id(&self) -> u8 {
        self.venue_ids[self.nbbo_bid_venue as usize]
    }

    /// VenueId of the best ask venue.
    #[inline(always)]
    pub fn best_ask_venue_id(&self) -> u8 {
        self.venue_ids[self.nbbo_ask_venue as usize]
    }
}

// =============================================================================
// VENUE BOOKS (per-venue full-depth order books for multi-venue algos)
// =============================================================================

/// WASM memory offset where VenueBooks is written by the runtime.
/// Multi-venue algos read per-venue depth from this fixed address.
pub const VENUE_BOOKS_WASM_OFFSET: u32 = 0x10000; // page 2 start

/// Per-venue full-depth order books delivered to multi-venue algos.
///
/// Contains a merged cross-venue L2Book plus individual per-venue L2Books.
/// Venue ordering matches `NbboSnapshot.venue_ids[]` — same slot index,
/// same VenueId mapping.
///
/// ## DEX depth
///
/// DEX books are **synthetic**: constructed by probing AMM pools (Uniswap V2/V3,
/// Curve, Balancer, etc.) at discrete USD sizes ($10 → $500K). Prices are
/// gas-adjusted. Below $10K: single best-pool routing. Above $10K: greedy split
/// across multiple pools. Accuracy is validated every 10th emission and
/// suppressed if error exceeds 25 bps vs live requote.
///
/// ## Size
///
/// ~14 KB (at MAX_VENUES=20). Written to WASM memory at offset `VENUE_BOOKS_WASM_OFFSET` (0x10000,
/// page 2). Well within the 16 MB default WASM memory allocation.
#[derive(Clone)]
#[repr(C)]
pub struct VenueBooks {
    /// Merged cross-venue depth book (all venues aggregated, same-price sizes summed).
    /// Same data previously available as the `book` parameter in v0.2 `on_nbbo`.
    pub merged: L2Book,
    /// Number of valid per-venue books (0..MAX_VENUES).
    pub book_ct: u8,
    pub _pad: [u8; 7],
    /// Wire VenueIds for each book slot (same ordering as `NbboSnapshot.venue_ids`).
    /// Use `VENUE_KRAKEN`, `VENUE_DEX_ARB`, etc. to identify venues.
    pub venue_ids: [u8; MAX_VENUES],
    /// Per-venue L2 order books. `books[i]` corresponds to `venue_ids[i]`.
    /// Each book has up to 20 levels per side. `bid_ct`/`ask_ct` indicate valid levels.
    /// A venue with no depth data will have `bid_ct == 0 && ask_ct == 0`.
    pub books: [L2Book; MAX_VENUES],
}

impl Default for VenueBooks {
    fn default() -> Self {
        Self {
            merged: L2Book::default(),
            book_ct: 0,
            _pad: [0; 7],
            venue_ids: [0; MAX_VENUES],
            books: [L2Book::default(); MAX_VENUES],
        }
    }
}

impl VenueBooks {
    /// Look up the L2Book for a specific venue by VenueId.
    /// Returns `None` if the venue is not present.
    #[inline]
    pub fn book_for_venue(&self, venue_id: u8) -> Option<&L2Book> {
        let ct = self.book_ct as usize;
        for i in 0..ct {
            if self.venue_ids[i] == venue_id {
                return Some(&self.books[i]);
            }
        }
        None
    }

    /// Direct access to the L2Book at a given slot index.
    /// Returns default (empty) book if slot is out of range.
    #[inline(always)]
    pub fn book_at_slot(&self, slot: usize) -> &L2Book {
        if slot < self.book_ct as usize {
            &self.books[slot]
        } else {
            // Return the first book as a default (all zeros if no books)
            &self.books[0]
        }
    }

    /// Whether a venue has depth data (at least one bid or ask level).
    #[inline]
    pub fn has_depth_for(&self, venue_id: u8) -> bool {
        self.book_for_venue(venue_id)
            .map_or(false, |b| b.bid_ct > 0 || b.ask_ct > 0)
    }

    /// Get the VenueId at a given slot.
    #[inline(always)]
    pub fn venue_id_at(&self, slot: usize) -> u8 {
        if slot < self.book_ct as usize {
            self.venue_ids[slot]
        } else {
            0
        }
    }

    /// Number of CEX venues with book data.
    #[inline]
    pub fn cex_count(&self) -> usize {
        let ct = self.book_ct as usize;
        (0..ct).filter(|&i| is_cex(self.venue_ids[i])).count()
    }

    /// Number of DEX venues with book data.
    #[inline]
    pub fn dex_count(&self) -> usize {
        let ct = self.book_ct as usize;
        (0..ct).filter(|&i| is_dex(self.venue_ids[i])).count()
    }
}

// =============================================================================
// Per-Pool Books (A6 — separate from NBBO hot path)
// =============================================================================

/// Maximum number of individual pool slots tracked per symbol.
pub const MAX_POOLS: usize = 32;

/// WASM memory offset where PoolBooks is written by the runtime.
/// Located after VenueBooks to avoid overlap.
pub const POOL_BOOKS_WASM_OFFSET: u32 = 0x14000;

/// Per-pool metadata: compact identity for a single DEX pool.
///
/// Fixed-size (40 bytes) to avoid heap allocations in WASM memory.
/// Layout: address(32) + pair_index(2) + fee_bps(2) + venue_id(1) + protocol_id(1) + pad(2) = 40.
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PoolMeta {
    /// Pool contract address: 32 bytes (EVM uses first 20, Solana uses all 32).
    pub address: [u8; 32],
    /// Pair index for multi-asset pools (0 for standard 2-token pools).
    pub pair_index: u16,
    /// Pool fee in basis points.
    pub fee_bps: u16,
    /// Venue ID (VENUE_DEX_ARB, VENUE_DEX_SOL, etc.)
    pub venue_id: u8,
    /// Protocol: 0=unknown, 1=uniswap_v2, 2=uniswap_v3, 3=curve,
    /// 4=balancer_v2, 5=aerodrome, 6=velodrome, 7=camelot,
    /// 8=raydium_clmm, 9=orca_whirlpool
    pub protocol_id: u8,
    /// Padding to align to 8 bytes (40 is already 8-aligned, but keep for future).
    pub _pad: [u8; 2],
}

impl Default for PoolMeta {
    fn default() -> Self {
        Self {
            address: [0; 32],
            pair_index: 0,
            fee_bps: 0,
            venue_id: 0,
            protocol_id: 0,
            _pad: [0; 2],
        }
    }
}

/// Per-pool depth books delivered to multi-venue algos.
///
/// Written to WASM memory at `POOL_BOOKS_WASM_OFFSET` (0x14000) on a
/// separate cadence from NBBO — typically per-block, not per-tick.
/// Algos read this on demand during `on_nbbo()` via fixed WASM offset.
///
/// ~23 KB total. Conditional memcpy: skipped when `pool_ct == 0`.
#[derive(Clone)]
#[repr(C)]
pub struct PoolBooks {
    /// Number of valid pool slots (0..MAX_POOLS).
    pub pool_ct: u8,
    pub _pad: [u8; 7],
    /// Metadata for each pool slot.
    pub metas: [PoolMeta; MAX_POOLS],
    /// L2 books for each pool. `books[i]` corresponds to `metas[i]`.
    pub books: [L2Book; MAX_POOLS],
}

impl Default for PoolBooks {
    fn default() -> Self {
        Self {
            pool_ct: 0,
            _pad: [0; 7],
            metas: [PoolMeta::default(); MAX_POOLS],
            books: [L2Book::default(); MAX_POOLS],
        }
    }
}

impl PoolBooks {
    /// Look up the L2Book for a specific pool by address and pair_index.
    #[inline]
    pub fn book_for_pool(&self, addr: &[u8; 32], pair_index: u16) -> Option<&L2Book> {
        let ct = self.pool_ct as usize;
        for i in 0..ct {
            if self.metas[i].address == *addr && self.metas[i].pair_index == pair_index {
                return Some(&self.books[i]);
            }
        }
        None
    }

    /// Direct access to the L2Book at a given slot index.
    #[inline(always)]
    pub fn book_at_slot(&self, slot: usize) -> &L2Book {
        if slot < self.pool_ct as usize {
            &self.books[slot]
        } else {
            &self.books[0]
        }
    }

    /// Direct access to the PoolMeta at a given slot index.
    #[inline(always)]
    pub fn meta_at_slot(&self, slot: usize) -> &PoolMeta {
        if slot < self.pool_ct as usize {
            &self.metas[slot]
        } else {
            &self.metas[0]
        }
    }
}

// =============================================================================
// Online Features (Phase 2B — microstructure features delivered to algos)
// =============================================================================

/// WASM offset for OnlineFeatures — page-aligned after PoolBooks.
/// PoolBooks at 0x14000, size ~23KB -> ends well before 0x1A000.
pub const ONLINE_FEATURES_WASM_OFFSET: u32 = 0x1A000;

/// Online microstructure features delivered by the CC data engine.
/// Written to WASM memory before each algo callback.
/// Old algos that never read 0x1A000 are unaffected (backward compatible).
#[derive(Clone, Copy, Debug)]
#[repr(C)]
pub struct OnlineFeatures {
    /// ABI version (currently 1).
    pub version: u16,
    /// Bit flags: bit 0 = vpin_valid.
    pub flags: u16,
    pub _pad0: [u8; 4],

    // ── Microprice ───────────────────────────────────────────────────────
    /// Microprice scaled 1e9.
    pub microprice_1e9: u64,

    // ── OFI / MLOFI (scaled 1e8) ────────────────────────────────────────
    /// Order flow imbalance, top-of-book, scaled 1e8.
    pub ofi_1level_1e8: i64,
    /// Order flow imbalance, 5 levels, scaled 1e8.
    pub ofi_5level_1e8: i64,
    /// Multi-level OFI (10 levels), scaled 1e8.
    pub mlofi_10_1e8: i64,
    /// OFI EWMA, scaled 1e6.
    pub ofi_ewma_1e6: i64,

    // ── Trade flow ───────────────────────────────────────────────────────
    /// Trade sign imbalance [-1e6, +1e6].
    pub trade_sign_imbalance_1e6: i64,
    /// Trades/sec x 1000.
    pub trade_arrival_rate_1e3: u32,
    /// VPIN [0, 10000] — only valid when flags bit 0 is set.
    pub vpin_1e4: u16,
    pub _pad1: u16,

    // ── Spread state ─────────────────────────────────────────────────────
    /// 0=tight, 1=normal, 2=wide, 3=crisis.
    pub spread_regime: u8,
    pub _pad2a: u8,
    /// Spread z-score x 1000.
    pub spread_zscore_1e3: i16,

    // ── Depth analytics ──────────────────────────────────────────────────
    /// Cancel rate [0, 10000].
    pub cancel_rate_1e4: u16,
    /// Depth imbalance [-10000, +10000].
    pub depth_imbalance_1e4: i16,

    // ── Realized vol ─────────────────────────────────────────────────────
    /// 1-minute realized vol in basis points.
    pub rv_1m_bps: u32,
    /// 5-minute realized vol in basis points.
    pub rv_5m_bps: u32,
    /// 1-hour realized vol in basis points.
    pub rv_1h_bps: u32,
    pub _pad3: u32,

    // ── Multi-head prediction (populated by Phase 6 sidecar) ─────────────
    /// Probability of up direction [0, 10000].
    pub pred_dir_up_1e4: u16,
    /// Probability of flat direction [0, 10000].
    pub pred_dir_flat_1e4: u16,
    /// Probability of down direction [0, 10000].
    pub pred_dir_down_1e4: u16,
    /// Probability of normal stress [0, 10000].
    pub pred_stress_normal_1e4: u16,
    /// Probability of widening stress [0, 10000].
    pub pred_stress_widening_1e4: u16,
    /// Probability of crisis stress [0, 10000].
    pub pred_stress_crisis_1e4: u16,
    /// Probability of toxic flow [0, 10000].
    pub pred_toxic_1e4: u16,
    /// Age of prediction in ms.
    pub prediction_age_ms: u16,

    // ── Fill probability (populated by Phase 6 sidecar) ──────────────────
    /// Fill probability on bid side [0, 10000].
    pub fill_prob_bid_1e4: u16,
    /// Fill probability on ask side [0, 10000].
    pub fill_prob_ask_1e4: u16,
    /// Queue decay rate [0, 10000].
    pub queue_decay_rate_1e4: u16,
    pub _fill_pad: u16,

    // ── Timestamp ────────────────────────────────────────────────────────
    /// Feature computation timestamp in nanoseconds.
    pub feature_ts_ns: u64,

    /// Reserved for future expansion.
    pub _reserved: [u8; 136],
}

impl Default for OnlineFeatures {
    fn default() -> Self {
        // Safety: all-zero is valid for every field, then set version=1
        let mut f = unsafe { core::mem::zeroed::<Self>() };
        f.version = 1;
        f
    }
}

impl OnlineFeatures {
    /// Whether the VPIN field is valid (flags bit 0).
    #[inline(always)]
    pub fn vpin_valid(&self) -> bool {
        self.flags & 1 != 0
    }

    /// Microprice as f64 (divide by 1e9).
    #[inline(always)]
    pub fn microprice_f64(&self) -> f64 {
        self.microprice_1e9 as f64 / 1_000_000_000.0
    }

    /// OFI 1-level as f64 (divide by 1e8).
    #[inline(always)]
    pub fn ofi_1level_f64(&self) -> f64 {
        self.ofi_1level_1e8 as f64 / 100_000_000.0
    }

    /// Trade sign imbalance as f64 in [-1.0, +1.0].
    #[inline(always)]
    pub fn trade_sign_imbalance_f64(&self) -> f64 {
        self.trade_sign_imbalance_1e6 as f64 / 1_000_000.0
    }
}

// Compile-time ABI checks for OnlineFeatures
const _: () = assert!(
    core::mem::size_of::<OnlineFeatures>() == 256,
    "OnlineFeatures must be exactly 256 bytes"
);
const _: () = assert!(
    0x1A000 >= 0x14000 + core::mem::size_of::<PoolBooks>(),
    "ONLINE_FEATURES_WASM_OFFSET overlaps with PoolBooks"
);
const _: () = assert!(
    ONLINE_FEATURES_WASM_OFFSET as usize + core::mem::size_of::<OnlineFeatures>() < 0x1000000,
    "OnlineFeatures exceeds WASM 16MB memory limit"
);

/// Multi-venue trading algorithm trait.
///
/// Parallel to `Algo` (single-venue). The runtime detects which trait a WASM
/// module implements by probing for the `algo_on_nbbo` export. If present,
/// the multi-venue path is used; otherwise, the single-venue `Algo` path.
///
/// All methods run on HOT PATH — avoid heap allocations.
pub trait MultiVenueAlgo: Send {
    /// Called on every cross-venue NBBO update.
    ///
    /// `nbbo`: Cross-venue NBBO with per-venue BBO and staleness tracking.
    /// `books`: Per-venue full-depth L2 books + merged cross-venue depth.
    ///   - `books.merged` — aggregated depth across all venues (same-price sizes summed)
    ///   - `books.books[slot]` — individual venue depth, indexed by slot
    ///   - Use `books.book_for_venue(VENUE_KRAKEN)` to look up by VenueId
    /// `state`: Your position + open orders (server-managed).
    /// `actions`: Buffer to place/cancel orders. Use `Action.venue_id` to target specific venues.
    fn on_nbbo(
        &mut self,
        nbbo: &NbboSnapshot,
        books: &VenueBooks,
        state: &AlgoState,
        actions: &mut Actions,
    );

    /// Order filled.
    fn on_fill(&mut self, fill: &Fill, state: &AlgoState);

    /// Order rejected.
    fn on_reject(&mut self, reject: &Reject);

    /// Shutdown — cancel open orders here.
    fn on_shutdown(&mut self, state: &AlgoState, actions: &mut Actions);
}

// =============================================================================
// WASM EXPORTS
// =============================================================================

/// Wire format for actions buffer.
#[repr(C)]
pub struct WasmActions {
    pub count: u32,
    pub _pad: u32,
    pub actions: [Action; MAX_ACTIONS],
}

impl WasmActions {
    pub const fn new() -> Self {
        Self {
            count: 0,
            _pad: 0,
            actions: [Action {
                order_id: 0,
                px_1e9: 0,
                qty_1e8: 0,
                side: 0,
                is_cancel: 0,
                order_type: 0,
                venue_id: 0,
                _pad: [0; 4],
            }; MAX_ACTIONS],
        }
    }

    pub fn from_actions(&mut self, actions: &Actions) {
        self.count = actions.len() as u32;
        for i in 0..actions.len() {
            self.actions[i] = actions.actions[i];
        }
    }
}

/// Generate WASM exports for your algo (only for WASM builds).
#[cfg(target_arch = "wasm32")]
#[macro_export]
macro_rules! export_algo {
    ($init:expr) => {
        extern crate alloc;
        static mut ALGO: Option<alloc::boxed::Box<dyn $crate::Algo>> = None;
        static mut ACTIONS: $crate::Actions = $crate::Actions::new();
        static mut WASM_OUT: $crate::WasmActions = $crate::WasmActions::new();

        #[inline(always)]
        fn init() {
            unsafe {
                if ALGO.is_none() {
                    ALGO = Some(alloc::boxed::Box::new($init));
                }
            }
        }

        #[no_mangle]
        pub extern "C" fn algo_on_book(book_ptr: u32, state_ptr: u32) -> u32 {
            init();
            unsafe {
                let book = &*(book_ptr as *const $crate::L2Book);
                let state = &*(state_ptr as *const $crate::AlgoState);
                ACTIONS.clear();
                if let Some(algo) = ALGO.as_mut() {
                    algo.on_book(book, state, &mut ACTIONS);
                }
                WASM_OUT.from_actions(&ACTIONS);
                &WASM_OUT as *const _ as u32
            }
        }

        #[no_mangle]
        pub extern "C" fn algo_on_fill(fill_ptr: u32, state_ptr: u32) {
            init();
            unsafe {
                let fill = &*(fill_ptr as *const $crate::Fill);
                let state = &*(state_ptr as *const $crate::AlgoState);
                if let Some(algo) = ALGO.as_mut() {
                    algo.on_fill(fill, state);
                }
            }
        }

        #[no_mangle]
        pub extern "C" fn algo_on_reject(reject_ptr: u32) {
            init();
            unsafe {
                let reject = &*(reject_ptr as *const $crate::Reject);
                if let Some(algo) = ALGO.as_mut() {
                    algo.on_reject(reject);
                }
            }
        }

        #[no_mangle]
        pub extern "C" fn algo_on_shutdown(state_ptr: u32) -> u32 {
            init();
            unsafe {
                let state = &*(state_ptr as *const $crate::AlgoState);
                ACTIONS.clear();
                if let Some(algo) = ALGO.as_mut() {
                    algo.on_shutdown(state, &mut ACTIONS);
                }
                WASM_OUT.from_actions(&ACTIONS);
                &WASM_OUT as *const _ as u32
            }
        }

        #[no_mangle]
        pub extern "C" fn algo_alloc(size: u32) -> u32 {
            let layout = core::alloc::Layout::from_size_align(size as usize, 8).unwrap();
            unsafe { alloc::alloc::alloc(layout) as u32 }
        }
    };
}

/// Stub macro for native builds (no-op).
#[cfg(not(target_arch = "wasm32"))]
#[macro_export]
macro_rules! export_algo {
    ($init:expr) => {};
}

/// Generate WASM exports for an AlgoV3 (single-venue with OnlineFeatures).
///
/// Exports:
/// - `algo_on_book_v3(book_ptr, state_ptr) -> action_ptr` — main entry, reads OnlineFeatures from 0x1A000
/// - `algo_on_book` (no-op stub so runtime detects V3 via `algo_on_book_v3` probe)
/// - `algo_on_heartbeat(state_ptr) -> action_ptr` — 1Hz heartbeat
/// - `algo_on_fill`, `algo_on_reject`, `algo_on_shutdown`, `algo_alloc`
#[cfg(target_arch = "wasm32")]
#[macro_export]
macro_rules! export_algo_v3 {
    ($init:expr) => {
        extern crate alloc;
        static mut ALGO: Option<alloc::boxed::Box<dyn $crate::AlgoV3>> = None;
        static mut ACTIONS: $crate::Actions = $crate::Actions::new();
        static mut WASM_OUT: $crate::WasmActions = $crate::WasmActions::new();

        #[inline(always)]
        fn init() {
            unsafe {
                if ALGO.is_none() {
                    ALGO = Some(alloc::boxed::Box::new($init));
                }
            }
        }

        /// V3 entry point: book + OnlineFeatures from fixed WASM offset.
        #[no_mangle]
        pub extern "C" fn algo_on_book_v3(book_ptr: u32, state_ptr: u32) -> u32 {
            init();
            unsafe {
                let book = &*(book_ptr as *const $crate::L2Book);
                let state = &*(state_ptr as *const $crate::AlgoState);
                let features =
                    &*($crate::ONLINE_FEATURES_WASM_OFFSET as *const $crate::OnlineFeatures);
                ACTIONS.clear();
                if let Some(algo) = ALGO.as_mut() {
                    algo.on_book(book, state, features, &mut ACTIONS);
                }
                WASM_OUT.from_actions(&ACTIONS);
                &WASM_OUT as *const _ as u32
            }
        }

        /// Stub: runtime probes for algo_on_book_v3 to detect V3 support.
        #[no_mangle]
        pub extern "C" fn algo_on_book(_book_ptr: u32, _state_ptr: u32) -> u32 {
            0 // no-op — V3 algos use algo_on_book_v3
        }

        /// 1Hz heartbeat with OnlineFeatures.
        #[no_mangle]
        pub extern "C" fn algo_on_heartbeat(state_ptr: u32) -> u32 {
            init();
            unsafe {
                let state = &*(state_ptr as *const $crate::AlgoState);
                let features =
                    &*($crate::ONLINE_FEATURES_WASM_OFFSET as *const $crate::OnlineFeatures);
                ACTIONS.clear();
                if let Some(algo) = ALGO.as_mut() {
                    algo.on_heartbeat(state, features, &mut ACTIONS);
                }
                WASM_OUT.from_actions(&ACTIONS);
                &WASM_OUT as *const _ as u32
            }
        }

        #[no_mangle]
        pub extern "C" fn algo_on_fill(fill_ptr: u32, state_ptr: u32) {
            init();
            unsafe {
                let fill = &*(fill_ptr as *const $crate::Fill);
                let state = &*(state_ptr as *const $crate::AlgoState);
                if let Some(algo) = ALGO.as_mut() {
                    algo.on_fill(fill, state);
                }
            }
        }

        #[no_mangle]
        pub extern "C" fn algo_on_reject(reject_ptr: u32) {
            init();
            unsafe {
                let reject = &*(reject_ptr as *const $crate::Reject);
                if let Some(algo) = ALGO.as_mut() {
                    algo.on_reject(reject);
                }
            }
        }

        #[no_mangle]
        pub extern "C" fn algo_on_shutdown(state_ptr: u32) -> u32 {
            init();
            unsafe {
                let state = &*(state_ptr as *const $crate::AlgoState);
                ACTIONS.clear();
                if let Some(algo) = ALGO.as_mut() {
                    algo.on_shutdown(state, &mut ACTIONS);
                }
                WASM_OUT.from_actions(&ACTIONS);
                &WASM_OUT as *const _ as u32
            }
        }

        #[no_mangle]
        pub extern "C" fn algo_alloc(size: u32) -> u32 {
            let layout = core::alloc::Layout::from_size_align(size as usize, 8).unwrap();
            unsafe { alloc::alloc::alloc(layout) as u32 }
        }
    };
}

/// Stub macro for native builds (no-op).
#[cfg(not(target_arch = "wasm32"))]
#[macro_export]
macro_rules! export_algo_v3 {
    ($init:expr) => {};
}

/// Generate WASM exports for a multi-venue algo (only for WASM builds).
///
/// Exports:
/// - `algo_on_nbbo(nbbo_ptr, book_ptr, state_ptr) -> action_ptr`
/// - `algo_on_book` (no-op stub so runtime can probe for multi-venue support)
/// - `algo_on_fill`, `algo_on_reject`, `algo_on_shutdown` (same as `export_algo!`)
/// - `algo_alloc`
///
/// The runtime writes `VenueBooks` at `VENUE_BOOKS_WASM_OFFSET` (0x10000) and
/// a merged `L2Book` at `BOOK_OFFSET` (0x8000). The macro reads `VenueBooks`
/// from the fixed offset and passes it to `on_nbbo`. The `book_ptr` parameter
/// is kept for ABI compatibility with old runtimes.
#[cfg(target_arch = "wasm32")]
#[macro_export]
macro_rules! export_multi_venue_algo {
    ($init:expr) => {
        extern crate alloc;
        static mut ALGO: Option<alloc::boxed::Box<dyn $crate::MultiVenueAlgo>> = None;
        static mut ACTIONS: $crate::Actions = $crate::Actions::new();
        static mut WASM_OUT: $crate::WasmActions = $crate::WasmActions::new();

        #[inline(always)]
        fn init() {
            unsafe {
                if ALGO.is_none() {
                    ALGO = Some(alloc::boxed::Box::new($init));
                }
            }
        }

        /// Multi-venue entry point: called on every cross-venue NBBO update.
        /// Runtime writes VenueBooks at 0x10000 before calling this.
        #[no_mangle]
        pub extern "C" fn algo_on_nbbo(nbbo_ptr: u32, _book_ptr: u32, state_ptr: u32) -> u32 {
            init();
            unsafe {
                let nbbo = &*(nbbo_ptr as *const $crate::NbboSnapshot);
                let books = &*($crate::VENUE_BOOKS_WASM_OFFSET as *const $crate::VenueBooks);
                let state = &*(state_ptr as *const $crate::AlgoState);
                ACTIONS.clear();
                if let Some(algo) = ALGO.as_mut() {
                    algo.on_nbbo(nbbo, books, state, &mut ACTIONS);
                }
                WASM_OUT.from_actions(&ACTIONS);
                &WASM_OUT as *const _ as u32
            }
        }

        /// Stub: runtime probes for this to detect algo type.
        /// Multi-venue algos export algo_on_nbbo as the real entry point.
        #[no_mangle]
        pub extern "C" fn algo_on_book(_book_ptr: u32, _state_ptr: u32) -> u32 {
            0 // no-op — multi-venue algos use algo_on_nbbo
        }

        #[no_mangle]
        pub extern "C" fn algo_on_fill(fill_ptr: u32, state_ptr: u32) {
            init();
            unsafe {
                let fill = &*(fill_ptr as *const $crate::Fill);
                let state = &*(state_ptr as *const $crate::AlgoState);
                if let Some(algo) = ALGO.as_mut() {
                    algo.on_fill(fill, state);
                }
            }
        }

        #[no_mangle]
        pub extern "C" fn algo_on_reject(reject_ptr: u32) {
            init();
            unsafe {
                let reject = &*(reject_ptr as *const $crate::Reject);
                if let Some(algo) = ALGO.as_mut() {
                    algo.on_reject(reject);
                }
            }
        }

        #[no_mangle]
        pub extern "C" fn algo_on_shutdown(state_ptr: u32) -> u32 {
            init();
            unsafe {
                let state = &*(state_ptr as *const $crate::AlgoState);
                ACTIONS.clear();
                if let Some(algo) = ALGO.as_mut() {
                    algo.on_shutdown(state, &mut ACTIONS);
                }
                WASM_OUT.from_actions(&ACTIONS);
                &WASM_OUT as *const _ as u32
            }
        }

        #[no_mangle]
        pub extern "C" fn algo_alloc(size: u32) -> u32 {
            let layout = core::alloc::Layout::from_size_align(size as usize, 8).unwrap();
            unsafe { alloc::alloc::alloc(layout) as u32 }
        }
    };
}

/// Stub macro for native builds (no-op).
#[cfg(not(target_arch = "wasm32"))]
#[macro_export]
macro_rules! export_multi_venue_algo {
    ($init:expr) => {};
}

// =============================================================================
// LOGGING - HFT-safe async logging
// =============================================================================

/// Log levels for algo logging.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
#[repr(u8)]
pub enum LogLevel {
    Trace = 0,
    Debug = 1,
    Info = 2,
    Warn = 3,
    Error = 4,
}

// Host import - only for WASM builds
#[cfg(target_arch = "wasm32")]
extern "C" {
    fn host_log_impl(level: u8, ptr: *const u8, len: u32);
}

#[cfg(target_arch = "wasm32")]
#[inline(always)]
fn host_log(level: u8, ptr: *const u8, len: u32) {
    unsafe {
        host_log_impl(level, ptr, len);
    }
}

// Stub for native builds (no-op)
#[cfg(not(target_arch = "wasm32"))]
#[inline(always)]
fn host_log(_level: u8, _ptr: *const u8, _len: u32) {}

/// Algo logging - non-blocking, ~100ns per call.
/// Logs are batched and viewable via dashboard with 1-2s delay.
pub mod log {
    use super::LogLevel;
    use core::fmt::Write;

    /// Log buffer for formatting.
    struct LogBuf {
        buf: [u8; 255],
        pos: usize,
    }

    impl LogBuf {
        #[inline(always)]
        const fn new() -> Self {
            Self {
                buf: [0u8; 255],
                pos: 0,
            }
        }

        #[inline(always)]
        fn as_slice(&self) -> &[u8] {
            &self.buf[..self.pos]
        }
    }

    impl Write for LogBuf {
        fn write_str(&mut self, s: &str) -> core::fmt::Result {
            let bytes = s.as_bytes();
            let space = self.buf.len() - self.pos;
            let n = bytes.len().min(space);
            self.buf[self.pos..self.pos + n].copy_from_slice(&bytes[..n]);
            self.pos += n;
            Ok(())
        }
    }

    #[inline(always)]
    fn send(level: LogLevel, msg: &[u8]) {
        super::host_log(level as u8, msg.as_ptr(), msg.len() as u32);
    }

    /// Log a trace message.
    #[inline(always)]
    pub fn trace(msg: &str) {
        send(LogLevel::Trace, msg.as_bytes());
    }

    /// Log a debug message.
    #[inline(always)]
    pub fn debug(msg: &str) {
        send(LogLevel::Debug, msg.as_bytes());
    }

    /// Log an info message.
    #[inline(always)]
    pub fn info(msg: &str) {
        send(LogLevel::Info, msg.as_bytes());
    }

    /// Log a warning message.
    #[inline(always)]
    pub fn warn(msg: &str) {
        send(LogLevel::Warn, msg.as_bytes());
    }

    /// Log an error message.
    #[inline(always)]
    pub fn error(msg: &str) {
        send(LogLevel::Error, msg.as_bytes());
    }

    /// Log with formatting (slightly slower).
    #[inline]
    pub fn log_fmt(level: LogLevel, args: core::fmt::Arguments<'_>) {
        let mut buf = LogBuf::new();
        let _ = buf.write_fmt(args);
        send(level, buf.as_slice());
    }

    /// Formatted info log.
    #[inline]
    pub fn info_fmt(args: core::fmt::Arguments<'_>) {
        log_fmt(LogLevel::Info, args);
    }

    /// Formatted warn log.
    #[inline]
    pub fn warn_fmt(args: core::fmt::Arguments<'_>) {
        log_fmt(LogLevel::Warn, args);
    }

    /// Formatted error log.
    #[inline]
    pub fn error_fmt(args: core::fmt::Arguments<'_>) {
        log_fmt(LogLevel::Error, args);
    }

    /// Formatted debug log.
    #[inline]
    pub fn debug_fmt(args: core::fmt::Arguments<'_>) {
        log_fmt(LogLevel::Debug, args);
    }
}

/// Log info message with formatting.
#[macro_export]
macro_rules! log_info {
    ($($arg:tt)*) => {
        $crate::log::info_fmt(format_args!($($arg)*))
    };
}

/// Log warning with formatting.
#[macro_export]
macro_rules! log_warn {
    ($($arg:tt)*) => {
        $crate::log::warn_fmt(format_args!($($arg)*))
    };
}

/// Log error with formatting.
#[macro_export]
macro_rules! log_error {
    ($($arg:tt)*) => {
        $crate::log::error_fmt(format_args!($($arg)*))
    };
}

/// Log debug with formatting.
#[macro_export]
macro_rules! log_debug {
    ($($arg:tt)*) => {
        $crate::log::debug_fmt(format_args!($($arg)*))
    };
}

// =============================================================================
// TESTS
// =============================================================================

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

    // ── helper ───────────────────────────────────────────────────────────
    fn make_book(bid_px: u64, bid_sz: u64, ask_px: u64, ask_sz: u64) -> L2Book {
        let mut book = L2Book::default();
        if bid_px > 0 {
            book.bids[0] = Level {
                px_1e9: bid_px,
                sz_1e8: bid_sz,
            };
            book.bid_ct = 1;
        }
        if ask_px > 0 {
            book.asks[0] = Level {
                px_1e9: ask_px,
                sz_1e8: ask_sz,
            };
            book.ask_ct = 1;
        }
        book
    }

    // ── Level ────────────────────────────────────────────────────────────

    #[test]
    fn level_empty_is_zero() {
        let l = Level::EMPTY;
        assert_eq!(l.px_1e9, 0);
        assert_eq!(l.sz_1e8, 0);
    }

    #[test]
    fn level_is_valid() {
        assert!(!Level::EMPTY.is_valid());
        assert!(Level {
            px_1e9: 1,
            sz_1e8: 0
        }
        .is_valid());
    }

    // ── L2Book ───────────────────────────────────────────────────────────

    #[test]
    fn book_best_bid_ask_empty() {
        let book = L2Book::default();
        assert!(book.best_bid().is_none());
        assert!(book.best_ask().is_none());
    }

    #[test]
    fn book_best_bid_ask_populated() {
        let book = make_book(99_000_000_000, 1_000_000, 101_000_000_000, 2_000_000);
        let bid = book.best_bid().unwrap();
        assert_eq!(bid.px_1e9, 99_000_000_000);
        let ask = book.best_ask().unwrap();
        assert_eq!(ask.px_1e9, 101_000_000_000);
    }

    #[test]
    fn book_mid_px_empty() {
        assert_eq!(L2Book::default().mid_px_1e9(), 0);
    }

    #[test]
    fn book_mid_px_correct() {
        let book = make_book(99_000_000_000, 1, 101_000_000_000, 1);
        assert_eq!(book.mid_px_1e9(), 100_000_000_000);
    }

    #[test]
    fn book_spread_empty() {
        assert_eq!(L2Book::default().spread_1e9(), u64::MAX);
    }

    #[test]
    fn book_spread_correct() {
        let book = make_book(99_000_000_000, 1, 101_000_000_000, 1);
        assert_eq!(book.spread_1e9(), 2_000_000_000);
    }

    #[test]
    fn book_spread_bps_empty() {
        assert_eq!(L2Book::default().spread_bps(), u32::MAX);
    }

    #[test]
    fn book_spread_bps_correct() {
        // bid=99e9, ask=101e9 -> spread=2e9, mid=100e9, bps = 2e9*10000/100e9 = 200
        let book = make_book(99_000_000_000, 1, 101_000_000_000, 1);
        assert_eq!(book.spread_bps(), 200);
    }

    #[test]
    fn book_spread_bps_x1000_sub_bps() {
        // BTC-like: bid=67270.00e9, ask=67270.10e9 -> spread=0.10e9=100_000_000
        // 0.10/67270.05 * 10000 = 0.00149 bps -> spread_bps() truncates to 0
        // spread_bps_x1000() should give ~15 milli-bps
        let book = make_book(67_270_000_000_000, 1, 67_270_100_000_000, 1);
        assert_eq!(book.spread_bps(), 0); // proves the precision loss
        let mbps = book.spread_bps_x1000();
        assert!(mbps > 0, "milli-bps should be positive: {}", mbps);
        assert_eq!(mbps, 14); // 0.014 bps * 1000 = 14 milli-bps
    }

    #[test]
    fn book_spread_bps_x1000_crossed() {
        // Crossed book: bid > ask (common in multi-venue NBBO)
        let book = make_book(67_270_000_000_000, 1, 67_261_990_000_000, 1);
        assert!(book.is_crossed());
        let mbps = book.spread_bps_x1000();
        assert!(mbps < 0, "crossed book should have negative milli-bps: {}", mbps);
    }

    #[test]
    fn book_spread_bps_x1000_normal() {
        // Normal spread: bid=99, ask=101 -> 200 bps -> 200_000 milli-bps
        let book = make_book(99_000_000_000, 1, 101_000_000_000, 1);
        assert!(!book.is_crossed());
        assert_eq!(book.spread_bps_x1000(), 200_000);
    }

    #[test]
    fn book_is_crossed() {
        // Not crossed
        let book = make_book(99_000_000_000, 1, 101_000_000_000, 1);
        assert!(!book.is_crossed());

        // Crossed
        let book = make_book(101_000_000_000, 1, 99_000_000_000, 1);
        assert!(book.is_crossed());

        // Empty book
        assert!(!L2Book::default().is_crossed());
    }

    #[test]
    fn book_spread_signed_1e9() {
        // Normal
        let book = make_book(99_000_000_000, 1, 101_000_000_000, 1);
        assert_eq!(book.spread_signed_1e9(), 2_000_000_000);

        // Crossed
        let book = make_book(101_000_000_000, 1, 99_000_000_000, 1);
        assert_eq!(book.spread_signed_1e9(), -2_000_000_000);
    }

    #[test]
    fn book_depth_and_imbalance() {
        let mut book = make_book(100_000_000_000, 500, 101_000_000_000, 300);
        // Add a second bid level
        book.bids[1] = Level {
            px_1e9: 99_000_000_000,
            sz_1e8: 200,
        };
        book.bid_ct = 2;

        assert_eq!(book.bid_depth_1e8(1), 500);
        assert_eq!(book.bid_depth_1e8(5), 700); // capped at bid_ct=2
        assert_eq!(book.ask_depth_1e8(1), 300);

        // imbalance: (700-300)*10000 / 1000 = 4000 bps (bids dominate)
        let imb = book.imbalance_bps(5);
        assert_eq!(imb, 4000);
    }

    #[test]
    fn book_imbalance_empty() {
        assert_eq!(L2Book::default().imbalance_bps(5), 0);
    }

    // ── OpenOrder ────────────────────────────────────────────────────────

    #[test]
    fn open_order_is_live() {
        let mut o = OpenOrder::EMPTY;
        o.status = Status::ACKED;
        assert!(o.is_live());
        o.status = Status::PARTIAL;
        assert!(o.is_live());
        o.status = Status::PENDING;
        assert!(!o.is_live());
        o.status = Status::DEAD;
        assert!(!o.is_live());
    }

    #[test]
    fn open_order_is_pending() {
        let mut o = OpenOrder::EMPTY;
        o.status = Status::PENDING;
        assert!(o.is_pending());
        o.status = Status::ACKED;
        assert!(!o.is_pending());
    }

    #[test]
    fn open_order_remaining() {
        let o = OpenOrder {
            qty_1e8: 100,
            filled_1e8: 30,
            ..OpenOrder::EMPTY
        };
        assert_eq!(o.remaining_1e8(), 70);

        // Sell side (negative qty)
        let o2 = OpenOrder {
            qty_1e8: -100,
            filled_1e8: -40,
            ..OpenOrder::EMPTY
        };
        assert_eq!(o2.remaining_1e8(), 60);
    }

    // ── SymbolMeta ───────────────────────────────────────────────────────

    #[test]
    fn symbol_round_px() {
        let meta = SymbolMeta {
            tick_size_1e9: 10_000_000,
            ..SymbolMeta::EMPTY
        };
        // 95_000_000 / 10_000_000 = 9 * 10_000_000 = 90_000_000
        assert_eq!(meta.round_px(95_000_000), 90_000_000);
        // pass-through when tick_size = 0
        assert_eq!(SymbolMeta::EMPTY.round_px(95_000_000), 95_000_000);
    }

    #[test]
    fn symbol_round_qty() {
        let meta = SymbolMeta {
            lot_size_1e8: 1_000_000,
            ..SymbolMeta::EMPTY
        };
        assert_eq!(meta.round_qty(1_500_000), 1_000_000);
        assert_eq!(SymbolMeta::EMPTY.round_qty(1_500_000), 1_500_000);
    }

    #[test]
    fn symbol_check_notional() {
        // Unknown min_notional -> true
        assert!(SymbolMeta::EMPTY.check_notional(1, 1));
        let meta = SymbolMeta {
            min_notional_1e9: 10_000_000_000,
            ..SymbolMeta::EMPTY
        };
        // notional = (100_000_000 * 100_000_000_000) / 1e8 = 100_000_000_000 >= 10e9 -> true
        assert!(meta.check_notional(100_000_000, 100_000_000_000));
        // notional = (1 * 1_000_000_000) / 1e8 = 10 < 10e9 -> false
        assert!(!meta.check_notional(1, 1_000_000_000));
    }

    #[test]
    fn symbol_check_min_qty() {
        assert!(SymbolMeta::EMPTY.check_min_qty(1));
        let meta = SymbolMeta {
            min_qty_1e8: 100,
            ..SymbolMeta::EMPTY
        };
        assert!(meta.check_min_qty(100));
        assert!(meta.check_min_qty(-100)); // abs check
        assert!(!meta.check_min_qty(99));
    }

    // ── RiskSnapshot ─────────────────────────────────────────────────────

    #[test]
    fn risk_check_position() {
        // max_position = 0 -> unlimited
        assert!(RiskSnapshot::EMPTY.check_position(999, 999));

        let risk = RiskSnapshot {
            max_position_1e8: 100,
            ..RiskSnapshot::default()
        };
        assert!(risk.check_position(50, 40)); // projected 90 <= 100
        assert!(risk.check_position(50, 50)); // projected 100 <= 100
        assert!(!risk.check_position(50, 51)); // projected 101 > 100
                                               // Negative side
        assert!(risk.check_position(-50, -50)); // projected -100, abs=100 <= 100
        assert!(!risk.check_position(-50, -51));
    }

    // ── AlgoState ────────────────────────────────────────────────────────

    #[test]
    fn algo_state_position_flags() {
        let mut s = AlgoState::default();
        assert!(s.is_flat());
        assert!(!s.is_long());
        assert!(!s.is_short());

        s.position_1e8 = 100;
        assert!(s.is_long());
        assert!(!s.is_flat());

        s.position_1e8 = -100;
        assert!(s.is_short());
    }

    #[test]
    fn algo_state_live_order_count() {
        let mut s = AlgoState::default();
        s.order_ct = 3;
        s.orders[0] = OpenOrder {
            status: Status::ACKED,
            ..OpenOrder::EMPTY
        };
        s.orders[1] = OpenOrder {
            status: Status::PENDING,
            ..OpenOrder::EMPTY
        };
        s.orders[2] = OpenOrder {
            status: Status::PARTIAL,
            ..OpenOrder::EMPTY
        };
        assert_eq!(s.live_order_count(), 2); // ACKED + PARTIAL
    }

    #[test]
    fn algo_state_find_order() {
        let mut s = AlgoState::default();
        s.order_ct = 1;
        s.orders[0] = OpenOrder {
            order_id: 42,
            ..OpenOrder::EMPTY
        };
        assert!(s.find_order(42).is_some());
        assert!(s.find_order(99).is_none());
    }

    #[test]
    fn algo_state_open_buy_sell_qty() {
        let mut s = AlgoState::default();
        s.order_ct = 2;
        s.orders[0] = OpenOrder {
            order_id: 1,
            side: 1,
            qty_1e8: 100,
            filled_1e8: 20,
            status: Status::ACKED,
            ..OpenOrder::EMPTY
        };
        s.orders[1] = OpenOrder {
            order_id: 2,
            side: -1,
            qty_1e8: -200,
            filled_1e8: -50,
            status: Status::PARTIAL,
            ..OpenOrder::EMPTY
        };
        assert_eq!(s.open_buy_qty_1e8(), 80); // 100 - 20
        assert_eq!(s.open_sell_qty_1e8(), 150); // 200 - 50
    }

    #[test]
    fn algo_state_pnl() {
        let mut s = AlgoState::default();
        s.realized_pnl_1e9 = 5_000_000_000;
        s.unrealized_pnl_1e9 = -2_000_000_000;
        s.session_pnl_1e9 = 1_500_000_000;

        assert_eq!(s.total_pnl_1e9(), 3_000_000_000);

        let snap = s.get_pnl();
        assert_eq!(snap.realized_1e9, 5_000_000_000);
        assert_eq!(snap.unrealized_1e9, -2_000_000_000);
        assert_eq!(snap.total_1e9, 3_000_000_000);

        assert!((s.realized_pnl_usd() - 5.0).abs() < 1e-9);
        assert!((s.unrealized_pnl_usd() - (-2.0)).abs() < 1e-9);
        assert!((s.total_pnl_usd() - 3.0).abs() < 1e-9);
        assert!((s.session_pnl_usd() - 1.5).abs() < 1e-9);
    }

    // ── Fill ─────────────────────────────────────────────────────────────

    #[test]
    fn fill_since() {
        let fill = Fill {
            order_id: 1,
            px_1e9: 0,
            qty_1e8: 0,
            recv_ns: 10_000_000,
            side: 1,
            _pad: [0; 7],
        };
        assert_eq!(fill.since_ns(5_000_000), 5_000_000);
        assert_eq!(fill.since_us(5_000_000), 5_000);
        assert_eq!(fill.since_ms(5_000_000), 5);
        // Saturating: start > recv
        assert_eq!(fill.since_ns(99_000_000), 0);
    }

    // ── time module ──────────────────────────────────────────────────────

    #[test]
    fn time_helpers() {
        let t = time::start(1000);
        assert_eq!(t, 1000);
        assert_eq!(time::stop_ns(1000, 2500), 1500);
        assert_eq!(time::stop_us(1000, 2_001_000), 2_000);
        assert_eq!(time::stop_ms(1000, 5_000_001_000), 5_000);
        // Saturating
        assert_eq!(time::stop_ns(5000, 1000), 0);
    }

    #[test]
    fn timer_struct() {
        let mut t = time::Timer::new();
        t.start(1_000_000);
        assert_eq!(t.stop_ns(3_000_000), 2_000_000);
        assert_eq!(t.stop_us(3_000_000), 2_000);
        assert_eq!(t.stop_ms(3_000_000), 2);
        // Saturating
        assert_eq!(t.stop_ns(500_000), 0);
    }

    // ── RejectCode / Reject ──────────────────────────────────────────────

    #[test]
    fn reject_code_to_str() {
        assert_eq!(RejectCode::to_str(RejectCode::UNKNOWN), "UNKNOWN");
        assert_eq!(
            RejectCode::to_str(RejectCode::INSUFFICIENT_BALANCE),
            "INSUFFICIENT_BALANCE"
        );
        assert_eq!(RejectCode::to_str(RejectCode::RATE_LIMIT), "RATE_LIMIT");
        assert_eq!(RejectCode::to_str(RejectCode::RISK), "RISK_CHECK_FAILED");
        assert_eq!(
            RejectCode::to_str(RejectCode::DAILY_LOSS_LIMIT),
            "DAILY_LOSS_LIMIT"
        );
        assert_eq!(RejectCode::to_str(255), "UNKNOWN");
    }

    #[test]
    fn reject_reason_delegates() {
        let r = Reject {
            order_id: 1,
            code: RejectCode::AUTH,
            _pad: [0; 7],
        };
        assert_eq!(r.reason(), "AUTH");
    }

    // ── OrderType constants ──────────────────────────────────────────────

    #[test]
    fn order_type_values() {
        assert_eq!(OrderType::LIMIT, 0);
        assert_eq!(OrderType::MARKET, 1);
        assert_eq!(OrderType::IOC, 2);
        assert_eq!(OrderType::FOK, 3);
        assert_eq!(OrderType::POST_ONLY, 4);
    }

    // ── LogLevel ─────────────────────────────────────────────────────────

    #[test]
    fn log_level_discriminants() {
        assert_eq!(LogLevel::Trace as u8, 0);
        assert_eq!(LogLevel::Debug as u8, 1);
        assert_eq!(LogLevel::Info as u8, 2);
        assert_eq!(LogLevel::Warn as u8, 3);
        assert_eq!(LogLevel::Error as u8, 4);
    }

    // ── Actions ──────────────────────────────────────────────────────────

    #[test]
    fn actions_new_is_empty() {
        let a = Actions::new();
        assert_eq!(a.len(), 0);
        assert!(a.is_empty());
        assert!(!a.is_full());
    }

    #[test]
    fn actions_buy_sell() {
        let mut a = Actions::new();
        assert!(a.buy(1, 100, 50_000));
        assert!(a.sell(2, 200, 60_000));
        assert_eq!(a.len(), 2);

        let buy = a.get(0).unwrap();
        assert_eq!(buy.side, 1);
        assert_eq!(buy.qty_1e8, 100);
        assert_eq!(buy.px_1e9, 50_000);
        assert_eq!(buy.order_type, OrderType::LIMIT);
        assert_eq!(buy.is_cancel, 0);

        let sell = a.get(1).unwrap();
        assert_eq!(sell.side, -1);
        assert_eq!(sell.qty_1e8, 200);
    }

    #[test]
    fn actions_cancel() {
        let mut a = Actions::new();
        assert!(a.cancel(42));
        let c = a.get(0).unwrap();
        assert_eq!(c.is_cancel, 1);
        assert_eq!(c.order_id, 42);
    }

    #[test]
    fn actions_full_rejects() {
        let mut a = Actions::new();
        for i in 0..MAX_ACTIONS {
            assert!(a.buy(i as u64, 1, 1));
        }
        assert!(a.is_full());
        assert!(!a.buy(999, 1, 1));
    }

    #[test]
    fn actions_clear() {
        let mut a = Actions::new();
        a.buy(1, 1, 1);
        a.buy(2, 1, 1);
        a.clear();
        assert_eq!(a.len(), 0);
        assert!(a.is_empty());
    }

    #[test]
    fn actions_market_orders() {
        let mut a = Actions::new();
        a.market_buy(1, 100);
        a.market_sell(2, 200);
        let mb = a.get(0).unwrap();
        assert_eq!(mb.order_type, OrderType::MARKET);
        assert_eq!(mb.px_1e9, 0);
        assert_eq!(mb.side, 1);
        let ms = a.get(1).unwrap();
        assert_eq!(ms.order_type, OrderType::MARKET);
        assert_eq!(ms.side, -1);
    }

    #[test]
    fn actions_ioc_fok_post_only() {
        let mut a = Actions::new();
        a.ioc_buy(1, 10, 100);
        a.fok_buy(2, 20, 200);
        a.post_only_buy(3, 30, 300);
        assert_eq!(a.get(0).unwrap().order_type, OrderType::IOC);
        assert_eq!(a.get(1).unwrap().order_type, OrderType::FOK);
        assert_eq!(a.get(2).unwrap().order_type, OrderType::POST_ONLY);
    }

    #[test]
    fn actions_cancel_all() {
        let mut state = AlgoState::default();
        state.order_ct = 3;
        state.orders[0] = OpenOrder {
            order_id: 10,
            status: Status::ACKED,
            ..OpenOrder::EMPTY
        };
        state.orders[1] = OpenOrder {
            order_id: 11,
            status: Status::DEAD,
            ..OpenOrder::EMPTY
        };
        state.orders[2] = OpenOrder {
            order_id: 12,
            status: Status::PARTIAL,
            ..OpenOrder::EMPTY
        };

        let mut a = Actions::new();
        a.cancel_all(&state);
        // Only ACKED and PARTIAL are live -> 2 cancels
        assert_eq!(a.len(), 2);
        assert_eq!(a.get(0).unwrap().order_id, 10);
        assert_eq!(a.get(1).unwrap().order_id, 12);
    }

    #[test]
    fn actions_clear_at() {
        let mut a = Actions::new();
        a.buy(1, 100, 50_000);
        a.buy(2, 200, 60_000);
        a.clear_at(0);
        let zeroed = a.get(0).unwrap();
        assert_eq!(zeroed.order_id, 0);
        assert_eq!(zeroed.qty_1e8, 0);
        // len unchanged — slot is zeroed, not removed
        assert_eq!(a.len(), 2);
    }

    #[test]
    fn actions_get_out_of_bounds() {
        let a = Actions::new();
        assert!(a.get(0).is_none());
        assert!(a.get(100).is_none());
    }

    #[test]
    fn actions_iter() {
        let mut a = Actions::new();
        a.buy(1, 1, 1);
        a.sell(2, 1, 1);
        a.cancel(3);
        assert_eq!(a.iter().count(), 3);
    }

    // ── ABI tests — static compile-time layout verification ─────────────

    #[test]
    fn abi_action_size_is_32() {
        assert_eq!(core::mem::size_of::<Action>(), 32);
    }

    #[test]
    fn abi_action_field_offsets() {
        use core::mem;
        // order_id at 0, px_1e9 at 8, qty_1e8 at 16, side at 24, is_cancel at 25,
        // order_type at 26, venue_id at 27, _pad at 28
        assert_eq!(mem::offset_of!(Action, order_id), 0);
        assert_eq!(mem::offset_of!(Action, px_1e9), 8);
        assert_eq!(mem::offset_of!(Action, qty_1e8), 16);
        assert_eq!(mem::offset_of!(Action, side), 24);
        assert_eq!(mem::offset_of!(Action, is_cancel), 25);
        assert_eq!(mem::offset_of!(Action, order_type), 26);
        assert_eq!(mem::offset_of!(Action, venue_id), 27);
        assert_eq!(mem::offset_of!(Action, _pad), 28);
    }

    #[test]
    fn abi_nbbo_snapshot_fits_512() {
        assert!(core::mem::size_of::<NbboSnapshot>() <= 640);
    }

    #[test]
    fn abi_l2book_size_unchanged() {
        // L2Book: 20 levels × 16 bytes × 2 sides + metadata
        let size = core::mem::size_of::<L2Book>();
        assert_eq!(size, 656, "L2Book size changed — ABI break!");
    }

    #[test]
    fn abi_fill_size_unchanged() {
        assert_eq!(core::mem::size_of::<Fill>(), 40);
    }

    #[test]
    fn abi_reject_size_unchanged() {
        assert_eq!(core::mem::size_of::<Reject>(), 16);
    }

    #[test]
    fn abi_action_default_venue_is_zero() {
        // Old algos never set venue_id → Default produces 0 → "default venue"
        let a = Action::default();
        assert_eq!(a.venue_id, 0);
    }

    // ── Venue-index convention tests ────────────────────────────────────

    #[test]
    fn venue_index_convention_slot_to_id() {
        let mut snap = NbboSnapshot::default();
        snap.venue_ct = 3;
        snap.venue_ids = [10, 20, 30, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
        snap.venue_bid_px[0] = 100; // slot 0 = VenueId 10
        snap.venue_bid_px[1] = 200; // slot 1 = VenueId 20
        snap.venue_bid_px[2] = 150; // slot 2 = VenueId 30
        snap.nbbo_bid_venue = 1; // best bid is slot 1

        // nbbo_bid_venue is an array INDEX, not a VenueId
        assert_eq!(snap.venue_ids[snap.nbbo_bid_venue as usize], 20);
        assert_eq!(snap.venue_bid_px[snap.nbbo_bid_venue as usize], 200);

        // slot_for_venue maps VenueId → slot
        assert_eq!(snap.slot_for_venue(20), Some(1));
        assert_eq!(snap.slot_for_venue(10), Some(0));
        assert_eq!(snap.slot_for_venue(30), Some(2));
        assert_eq!(snap.slot_for_venue(99), None);
    }

    #[test]
    fn venue_index_convention_best_venue_id() {
        let mut snap = NbboSnapshot::default();
        snap.venue_ct = 2;
        snap.venue_ids = [5, 15, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
        snap.nbbo_bid_venue = 0; // slot 0
        snap.nbbo_ask_venue = 1; // slot 1

        assert_eq!(snap.best_bid_venue_id(), 5);
        assert_eq!(snap.best_ask_venue_id(), 15);
    }

    #[test]
    fn action_venue_id_is_value_not_slot() {
        // Action.venue_id stores the VenueId VALUE (e.g., 20), not the array slot
        let mut a = Actions::new();
        a.buy_on(20, 1, 100, 50_000);
        let action = a.get(0).unwrap();
        assert_eq!(action.venue_id, 20); // VenueId 20, NOT slot 20
        assert_eq!(action.side, 1);
        assert_eq!(action.order_type, OrderType::LIMIT);
    }

    #[test]
    fn nbbo_spread_bps_empty() {
        assert_eq!(NbboSnapshot::default().nbbo_spread_bps(), u32::MAX);
    }

    #[test]
    fn nbbo_spread_bps_correct() {
        let mut snap = NbboSnapshot::default();
        snap.nbbo_bid_px_1e9 = 99_000_000_000;
        snap.nbbo_ask_px_1e9 = 101_000_000_000;
        // spread = 2e9, mid = 100e9, bps = 2e9 * 10000 / 100e9 = 200
        assert_eq!(snap.nbbo_spread_bps(), 200);
    }

    #[test]
    fn nbbo_spread_bps_x1000_sub_bps() {
        // BTC-like sub-bps spread
        let mut snap = NbboSnapshot::default();
        snap.nbbo_bid_px_1e9 = 67_270_000_000_000;
        snap.nbbo_ask_px_1e9 = 67_270_100_000_000;
        assert_eq!(snap.nbbo_spread_bps(), 0); // truncated
        let mbps = snap.nbbo_spread_bps_x1000();
        assert!(mbps > 0);
        assert_eq!(mbps, 14); // ~0.014 bps * 1000
    }

    #[test]
    fn nbbo_spread_bps_x1000_crossed() {
        let mut snap = NbboSnapshot::default();
        snap.nbbo_bid_px_1e9 = 67_270_000_000_000;
        snap.nbbo_ask_px_1e9 = 67_261_990_000_000;
        let mbps = snap.nbbo_spread_bps_x1000();
        assert!(mbps < 0, "crossed NBBO should have negative milli-bps");
    }

    #[test]
    fn nbbo_is_crossed() {
        let mut snap = NbboSnapshot::default();
        snap.venue_ct = 2;
        // Not crossed: bid < ask
        snap.nbbo_bid_px_1e9 = 99_000_000_000;
        snap.nbbo_ask_px_1e9 = 101_000_000_000;
        snap.nbbo_bid_venue = 0;
        snap.nbbo_ask_venue = 1;
        assert!(!snap.is_crossed());

        // Crossed: bid > ask on different venues
        snap.nbbo_bid_px_1e9 = 101_500_000_000;
        snap.nbbo_ask_px_1e9 = 101_000_000_000;
        assert!(snap.is_crossed());

        // Same venue → not a real cross
        snap.nbbo_bid_venue = 1;
        snap.nbbo_ask_venue = 1;
        assert!(!snap.is_crossed());
    }

    #[test]
    fn nbbo_venue_staleness() {
        let mut snap = NbboSnapshot::default();
        snap.venue_ct = 3;
        snap.venue_update_ms = [0, 100, 6000, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];

        assert!(!snap.is_venue_stale(0, 5000)); // 0ms < 5000ms
        assert!(!snap.is_venue_stale(1, 5000)); // 100ms < 5000ms
        assert!(snap.is_venue_stale(2, 5000)); // 6000ms > 5000ms
        assert!(snap.is_venue_stale(15, 5000)); // out of range = stale
    }

    #[test]
    fn actions_venue_targeted() {
        let mut a = Actions::new();
        assert!(a.buy_on(5, 1, 100, 50_000));
        assert!(a.sell_on(10, 2, 200, 60_000));
        assert!(a.ioc_buy_on(5, 3, 50, 49_000));
        assert!(a.ioc_sell_on(10, 4, 75, 61_000));
        assert_eq!(a.len(), 4);

        let b = a.get(0).unwrap();
        assert_eq!(b.venue_id, 5);
        assert_eq!(b.side, 1);
        assert_eq!(b.order_type, OrderType::LIMIT);

        let s = a.get(1).unwrap();
        assert_eq!(s.venue_id, 10);
        assert_eq!(s.side, -1);

        let ib = a.get(2).unwrap();
        assert_eq!(ib.order_type, OrderType::IOC);
        assert_eq!(ib.venue_id, 5);

        let is = a.get(3).unwrap();
        assert_eq!(is.order_type, OrderType::IOC);
        assert_eq!(is.venue_id, 10);
    }

    // ── Venue ID constants tests ──────────────────────────────────────

    #[test]
    fn venue_id_constants_are_correct() {
        // Wire format = CC VenueId + 1
        assert_eq!(VENUE_KRAKEN, 1);
        assert_eq!(VENUE_COINBASE, 2);
        assert_eq!(VENUE_BINANCE, 3);
        assert_eq!(VENUE_BITGET, 4);
        assert_eq!(VENUE_CRYPTOCOM, 5);
        assert_eq!(VENUE_BITMART, 6);
        assert_eq!(VENUE_DEX, 7);
        assert_eq!(VENUE_OKX, 8);
        assert_eq!(VENUE_BYBIT, 9);
        assert_eq!(VENUE_UNKNOWN, 10);
        assert_eq!(VENUE_DEX_ETH, 11);
        assert_eq!(VENUE_DEX_ARB, 12);
        assert_eq!(VENUE_DEX_BASE, 13);
        assert_eq!(VENUE_DEX_OP, 14);
        assert_eq!(VENUE_DEX_POLY, 15);
        assert_eq!(VENUE_DEX_SOL, 16);
    }

    #[test]
    fn is_dex_classification() {
        assert!(is_dex(VENUE_DEX));
        assert!(is_dex(VENUE_DEX_ETH));
        assert!(is_dex(VENUE_DEX_ARB));
        assert!(is_dex(VENUE_DEX_BASE));
        assert!(is_dex(VENUE_DEX_OP));
        assert!(is_dex(VENUE_DEX_POLY));
        assert!(is_dex(VENUE_DEX_SOL));
        assert!(!is_dex(VENUE_KRAKEN));
        assert!(!is_dex(VENUE_BINANCE));
        assert!(!is_dex(VENUE_OKX));
        assert!(!is_dex(VENUE_UNKNOWN));
        assert!(!is_dex(0)); // default venue
    }

    #[test]
    fn is_cex_classification() {
        assert!(is_cex(VENUE_KRAKEN));
        assert!(is_cex(VENUE_COINBASE));
        assert!(is_cex(VENUE_BINANCE));
        assert!(is_cex(VENUE_BITGET));
        assert!(is_cex(VENUE_CRYPTOCOM));
        assert!(is_cex(VENUE_BITMART));
        assert!(is_cex(VENUE_OKX));
        assert!(is_cex(VENUE_BYBIT));
        assert!(!is_cex(VENUE_DEX));
        assert!(!is_cex(VENUE_DEX_ARB));
        assert!(!is_cex(VENUE_UNKNOWN));
        assert!(!is_cex(0)); // default venue
    }

    #[test]
    fn venue_name_all_known() {
        assert_eq!(venue_name(VENUE_KRAKEN), "kraken");
        assert_eq!(venue_name(VENUE_COINBASE), "coinbase");
        assert_eq!(venue_name(VENUE_BINANCE), "binance");
        assert_eq!(venue_name(VENUE_DEX), "dex");
        assert_eq!(venue_name(VENUE_DEX_ARB), "dex-arb");
        assert_eq!(venue_name(VENUE_DEX_BASE), "dex-base");
        assert_eq!(venue_name(VENUE_DEX_SOL), "dex-sol");
        assert_eq!(venue_name(VENUE_UNKNOWN), "unknown");
        assert_eq!(venue_name(0), "default");
        assert_eq!(venue_name(255), "unknown");
    }

    #[test]
    fn venue_id_cc_wire_mapping() {
        // Wire ID = CC VenueId ordinal + 1 (0 reserved for default/local)
        // CC: Kraken=0, Coinbase=1, Binance=2, Bitget=3, Cryptocom=4,
        //     Bitmart=5, Dex=6, Okx=7, Bybit=8, Unknown=9,
        //     DexEth=10, DexArb=11, DexBase=12, DexOp=13, DexPoly=14
        assert_eq!(VENUE_KRAKEN, 0 + 1);
        assert_eq!(VENUE_COINBASE, 1 + 1);
        assert_eq!(VENUE_BINANCE, 2 + 1);
        assert_eq!(VENUE_BITGET, 3 + 1);
        assert_eq!(VENUE_CRYPTOCOM, 4 + 1);
        assert_eq!(VENUE_BITMART, 5 + 1);
        assert_eq!(VENUE_DEX, 6 + 1);
        assert_eq!(VENUE_OKX, 7 + 1);
        assert_eq!(VENUE_BYBIT, 8 + 1);
        assert_eq!(VENUE_UNKNOWN, 9 + 1);
        assert_eq!(VENUE_DEX_ETH, 10 + 1);
        assert_eq!(VENUE_DEX_ARB, 11 + 1);
        assert_eq!(VENUE_DEX_BASE, 12 + 1);
        assert_eq!(VENUE_DEX_OP, 13 + 1);
        assert_eq!(VENUE_DEX_POLY, 14 + 1);
        assert_eq!(VENUE_DEX_SOL, 15 + 1);

        // Unknown is neither CEX nor DEX
        assert!(!is_cex(VENUE_UNKNOWN));
        assert!(!is_dex(VENUE_UNKNOWN));
        assert_eq!(venue_name(VENUE_UNKNOWN), "unknown");
    }

    // ── VenueBooks tests ──────────────────────────────────────────────

    #[test]
    fn abi_venue_books_layout() {
        let size = core::mem::size_of::<VenueBooks>();
        // merged (656) + book_ct+pad (8) + venue_ids (20) + pad (4) + books (656*20 = 13120)
        assert_eq!(size, 13808, "VenueBooks size changed — ABI break!");

        // Verify alignment: VenueBooks must be 8-byte aligned (L2Book contains u64)
        assert_eq!(core::mem::align_of::<VenueBooks>(), 8);
    }

    #[test]
    fn venue_books_book_for_venue() {
        let mut vb = VenueBooks::default();
        vb.book_ct = 3;
        vb.venue_ids[0] = VENUE_KRAKEN;
        vb.venue_ids[1] = VENUE_COINBASE;
        vb.venue_ids[2] = VENUE_DEX_ARB;

        // Set distinct bid prices per venue
        vb.books[0].bid_ct = 1;
        vb.books[0].bids[0].px_1e9 = 100_000_000_000;
        vb.books[1].bid_ct = 2;
        vb.books[1].bids[0].px_1e9 = 100_100_000_000;
        vb.books[2].bid_ct = 3;
        vb.books[2].bids[0].px_1e9 = 99_900_000_000;

        // Lookup by VenueId
        let kraken = vb.book_for_venue(VENUE_KRAKEN).unwrap();
        assert_eq!(kraken.bids[0].px_1e9, 100_000_000_000);
        assert_eq!(kraken.bid_ct, 1);

        let coinbase = vb.book_for_venue(VENUE_COINBASE).unwrap();
        assert_eq!(coinbase.bids[0].px_1e9, 100_100_000_000);
        assert_eq!(coinbase.bid_ct, 2);

        let dex = vb.book_for_venue(VENUE_DEX_ARB).unwrap();
        assert_eq!(dex.bids[0].px_1e9, 99_900_000_000);
        assert_eq!(dex.bid_ct, 3);

        // Not present
        assert!(vb.book_for_venue(VENUE_BINANCE).is_none());
    }

    #[test]
    fn venue_books_has_depth_for() {
        let mut vb = VenueBooks::default();
        vb.book_ct = 2;
        vb.venue_ids[0] = VENUE_KRAKEN;
        vb.venue_ids[1] = VENUE_DEX_ARB;
        vb.books[0].bid_ct = 5; // Kraken has depth
                                // DEX_ARB has no levels (bid_ct=0, ask_ct=0)

        assert!(vb.has_depth_for(VENUE_KRAKEN));
        assert!(!vb.has_depth_for(VENUE_DEX_ARB));
        assert!(!vb.has_depth_for(VENUE_BINANCE)); // not present
    }

    #[test]
    fn venue_books_cex_dex_counts() {
        let mut vb = VenueBooks::default();
        vb.book_ct = 5;
        vb.venue_ids[0] = VENUE_KRAKEN;
        vb.venue_ids[1] = VENUE_COINBASE;
        vb.venue_ids[2] = VENUE_DEX_ARB;
        vb.venue_ids[3] = VENUE_DEX_BASE;
        vb.venue_ids[4] = VENUE_BINANCE;

        assert_eq!(vb.cex_count(), 3);
        assert_eq!(vb.dex_count(), 2);
    }

    #[test]
    fn venue_books_book_at_slot() {
        let mut vb = VenueBooks::default();
        vb.book_ct = 2;
        vb.venue_ids[0] = VENUE_KRAKEN;
        vb.venue_ids[1] = VENUE_BINANCE;
        vb.books[0].bid_ct = 10;
        vb.books[1].bid_ct = 15;

        assert_eq!(vb.book_at_slot(0).bid_ct, 10);
        assert_eq!(vb.book_at_slot(1).bid_ct, 15);
    }

    #[test]
    fn venue_books_venue_id_at() {
        let mut vb = VenueBooks::default();
        vb.book_ct = 2;
        vb.venue_ids[0] = VENUE_KRAKEN;
        vb.venue_ids[1] = VENUE_DEX_ETH;

        assert_eq!(vb.venue_id_at(0), VENUE_KRAKEN);
        assert_eq!(vb.venue_id_at(1), VENUE_DEX_ETH);
        assert_eq!(vb.venue_id_at(99), 0); // out of range
    }

    // ── PoolBooks tests ──────────────────────────────────────────────────

    #[test]
    fn pool_meta_is_40_bytes() {
        // 32 (address) + 2 (pair_index) + 2 (fee_bps) + 1 (venue_id) + 1 (protocol_id) + 2 (pad) = 40
        assert_eq!(core::mem::size_of::<PoolMeta>(), 40);
    }

    #[test]
    fn pool_books_repr_c_layout() {
        // PoolBooks must be repr(C) for zero-copy WASM memcpy.
        let pb = PoolBooks::default();
        assert_eq!(pb.pool_ct, 0);
        assert_eq!(pb.metas[0].address, [0; 32]);
        assert_eq!(pb.books[0].bid_ct, 0);
    }

    #[test]
    fn pool_books_wasm_offset_after_venue_books() {
        let venue_end = VENUE_BOOKS_WASM_OFFSET as usize + core::mem::size_of::<VenueBooks>();
        assert!(
            (POOL_BOOKS_WASM_OFFSET as usize) >= venue_end,
            "PoolBooks offset {:#x} would overlap VenueBooks ending at {:#x}",
            POOL_BOOKS_WASM_OFFSET,
            venue_end,
        );
    }

    #[test]
    fn pool_books_book_for_pool() {
        let mut pb = PoolBooks::default();
        pb.pool_ct = 2;
        pb.metas[0].address = [0x11; 32];
        pb.metas[0].pair_index = 0;
        pb.books[0].bid_ct = 3;

        pb.metas[1].address = [0x22; 32];
        pb.metas[1].pair_index = 2;
        pb.books[1].ask_ct = 5;

        let addr1 = [0x11u8; 32];
        let book1 = pb.book_for_pool(&addr1, 0).unwrap();
        assert_eq!(book1.bid_ct, 3);

        let addr2 = [0x22u8; 32];
        let book2 = pb.book_for_pool(&addr2, 2).unwrap();
        assert_eq!(book2.ask_ct, 5);

        // Wrong pair_index → None
        assert!(pb.book_for_pool(&addr2, 0).is_none());
        // Unknown address → None
        let unknown = [0xFF; 32];
        assert!(pb.book_for_pool(&unknown, 0).is_none());
    }

    // ── OnlineFeatures tests ────────────────────────────────────────────

    #[test]
    fn online_features_size_is_256() {
        assert_eq!(core::mem::size_of::<OnlineFeatures>(), 256);
    }

    #[test]
    fn online_features_default_version() {
        let f = OnlineFeatures::default();
        assert_eq!(f.version, 1);
        assert_eq!(f.flags, 0);
        assert_eq!(f.microprice_1e9, 0);
        assert_eq!(f.feature_ts_ns, 0);
    }

    #[test]
    fn online_features_vpin_flag() {
        let mut f = OnlineFeatures::default();
        assert!(!f.vpin_valid());
        f.flags = 1;
        assert!(f.vpin_valid());
        f.flags = 0b11;
        assert!(f.vpin_valid());
        f.flags = 0b10;
        assert!(!f.vpin_valid());
    }

    #[test]
    fn online_features_wasm_offset_after_pool_books() {
        let pool_end = POOL_BOOKS_WASM_OFFSET as usize + core::mem::size_of::<PoolBooks>();
        assert!(
            (ONLINE_FEATURES_WASM_OFFSET as usize) >= pool_end,
            "OnlineFeatures offset {:#x} would overlap PoolBooks ending at {:#x}",
            ONLINE_FEATURES_WASM_OFFSET,
            pool_end,
        );
    }

    #[test]
    fn online_features_helpers() {
        let mut f = OnlineFeatures::default();
        f.microprice_1e9 = 50_000_000_000_000; // $50,000
        assert!((f.microprice_f64() - 50_000.0).abs() < 0.001);

        f.ofi_1level_1e8 = 150_000_000; // 1.5
        assert!((f.ofi_1level_f64() - 1.5).abs() < 0.001);

        f.trade_sign_imbalance_1e6 = -500_000; // -0.5
        assert!((f.trade_sign_imbalance_f64() - (-0.5)).abs() < 0.001);
    }

    #[test]
    fn online_features_is_copy() {
        let f = OnlineFeatures::default();
        let g = f; // Copy
        assert_eq!(g.version, f.version);
    }
}