hypercall/rsm/margin_service/

span_margin_service.rs

//! SpanMarginService - SPAN-style margin calculation implementation
//!
//! This service implements scenario-based margin calculations similar to
//! CME SPAN (Standard Portfolio Analysis of Risk).

use super::MarginService;
#[cfg(test)]
use crate::constants::MM_TO_IM_RATIO;
#[cfg(test)]
use crate::rsm::black_scholes::black_scholes_with_moments;
use crate::types::{Account, Config, MarginDetails};
use crate::vol_oracle::{SharedVolOracle, VolLookupError, VolOracleStatus, VolProviderKind};
use async_trait::async_trait;
use hypercall_margin::{
    compute_extended_risk_grid_from_snapshot, compute_risk_grid_from_snapshot,
    empty_portfolio_margin_details, has_portfolio_positions, market_state_from_snapshot,
    snapshot_from_account, ExtendedRiskGrid, ScenarioPnl,
};
use hypercall_margin::{
    PortfolioMarginMarketState, PortfolioMarginOptionMarketState, PortfolioMarginSnapshot,
};
use metrics::{counter, histogram};
use rust_decimal::prelude::ToPrimitive;
use rust_decimal::Decimal;
use std::sync::Arc;
use std::time::Instant;
use tracing::debug;

/// RAII guard for margin operation observability.
///
/// Records a counter increment and histogram observation on drop.
struct MarginObsGuard {
    op: &'static str,
    start: Instant,
}

impl MarginObsGuard {
    fn new(op: &'static str) -> Self {
        Self {
            op,
            start: Instant::now(),
        }
    }
}

impl Drop for MarginObsGuard {
    fn drop(&mut self) {
        counter!("margin_span_calls_total", "op" => self.op).increment(1);
        histogram!("margin_span_compute_seconds", "op" => self.op)
            .record(self.start.elapsed().as_secs_f64());
    }
}

fn current_margin_timestamp() -> i64 {
    chrono::Utc::now().timestamp()
}

#[derive(Debug, Clone)]
pub enum MarginError {
    InvalidStrike {
        underlying: String,
        strike: Decimal,
    },
    NonRepresentableDecimal {
        field: &'static str,
        underlying: String,
    },
    VolLookup(VolLookupError),
}

impl std::fmt::Display for MarginError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            Self::InvalidStrike { underlying, strike } => {
                write!(
                    f,
                    "invalid strike {strike} for underlying {underlying} in margin calculation"
                )
            }
            Self::NonRepresentableDecimal { field, underlying } => {
                write!(
                    f,
                    "non-representable decimal field {field} for underlying {underlying}"
                )
            }
            Self::VolLookup(err) => write!(f, "{err}"),
        }
    }
}

impl std::error::Error for MarginError {}

impl From<VolLookupError> for MarginError {
    fn from(value: VolLookupError) -> Self {
        Self::VolLookup(value)
    }
}

impl From<hypercall_margin::MarginError> for MarginError {
    fn from(value: hypercall_margin::MarginError) -> Self {
        match value {
            hypercall_margin::MarginError::InvalidStrike { underlying, strike } => {
                Self::InvalidStrike { underlying, strike }
            }
            hypercall_margin::MarginError::NonRepresentableDecimal { field, underlying } => {
                Self::NonRepresentableDecimal { field, underlying }
            }
        }
    }
}

pub struct FixedRiskVolOracle {
    fixed_vol: f64,
}

impl FixedRiskVolOracle {
    pub fn new(fixed_vol: f64) -> Self {
        Self { fixed_vol }
    }
}

impl crate::vol_oracle::RiskVolOracle for FixedRiskVolOracle {
    fn get_iv(
        &self,
        _underlying: &str,
        _strike: f64,
        _expiry_ts: i64,
    ) -> Result<f64, VolLookupError> {
        Ok(self.fixed_vol)
    }

    fn statuses(&self) -> Vec<VolOracleStatus> {
        Vec::new()
    }
}

struct MissingRiskVolOracle;

impl crate::vol_oracle::RiskVolOracle for MissingRiskVolOracle {
    fn get_iv(
        &self,
        underlying: &str,
        _strike: f64,
        _expiry_ts: i64,
    ) -> Result<f64, VolLookupError> {
        Err(VolLookupError::UnhealthyProvider {
            underlying: underlying.to_string(),
            provider: match underlying {
                "BTC" | "ETH" => VolProviderKind::BlockScholes,
                "US500" | "USOIL" => VolProviderKind::Polygon,
                _ => VolProviderKind::BlockScholes,
            },
            reason: "risk volatility oracle is not configured".to_string(),
        })
    }

    fn statuses(&self) -> Vec<VolOracleStatus> {
        ["BTC", "ETH", "US500", "USOIL"]
            .into_iter()
            .map(|underlying| VolOracleStatus {
                underlying: underlying.to_string(),
                provider: match underlying {
                    "BTC" | "ETH" => VolProviderKind::BlockScholes,
                    _ => VolProviderKind::Polygon,
                },
                route_facing: true,
                connected: false,
                ready: false,
                last_update_ts_ms: None,
                staleness_seconds: None,
                staleness_threshold_seconds: None,
                surface_points: 0,
                messages_received: 0,
                last_error: Some("risk volatility oracle is not configured".to_string()),
            })
            .collect()
    }
}

/// SPAN-style margin calculation service.
///
/// This consolidates margin logic that was previously scattered across UnifiedEngine,
/// providing a single source of truth for margin computations.
///
/// # Architecture
///
/// The service uses scenario-based risk analysis:
/// - Evaluates portfolio P&L across multiple market scenarios (spot moves, vol changes, etc.)
/// - Includes both delta (perp) P&L and options P&L in scenario evaluation
/// - Computes "scanning risk" as the worst-case loss across all scenarios
///
/// # Portfolio Margin (PM) Semantics
///
/// Any non-empty portfolio goes through SPAN scenario evaluation:
/// - Long options: scenario loss when spot drops (call loses value)
/// - Short options: scenario loss when spot rises (unlimited upside risk)
/// - Spreads: hedging benefits reduce net scenario loss
///
/// Only truly empty portfolios (no positions) return zero margin immediately.
pub struct SpanMarginService {
    config: Config,
    vol_oracle: SharedVolOracle,
}

impl SpanMarginService {
    /// Create a new SpanMarginService with the given configuration.
    pub fn new(config: Config) -> Self {
        Self::new_fail_closed(config)
    }

    /// Create a fail-closed SpanMarginService for production wiring.
    pub fn new_fail_closed(config: Config) -> Self {
        Self::new_with_vol_oracle(config, Arc::new(MissingRiskVolOracle))
    }

    /// Create a fixed-vol SPAN service for tests that do not exercise live vol wiring.
    pub fn new_for_tests(config: Config) -> Self {
        let fixed_vol = config.base_volatility;
        Self::new_with_vol_oracle(config, Arc::new(FixedRiskVolOracle::new(fixed_vol)))
    }

    pub fn new_with_vol_oracle(config: Config, vol_oracle: SharedVolOracle) -> Self {
        Self { config, vol_oracle }
    }

    pub fn config(&self) -> &Config {
        &self.config
    }

    pub fn set_vol_oracle(&mut self, oracle: SharedVolOracle) {
        self.vol_oracle = oracle;
    }

    fn snapshot_and_market_state_from_account(
        &self,
        account: &Account,
    ) -> (PortfolioMarginSnapshot, PortfolioMarginMarketState) {
        let snapshot = snapshot_from_account(account);
        let market_state =
            market_state_from_snapshot(&snapshot, self.config.portfolio_margin_config());
        (snapshot, market_state)
    }

    fn populate_option_market_state(
        &self,
        snapshot: &PortfolioMarginSnapshot,
        market_state: &mut PortfolioMarginMarketState,
    ) -> Result<(), MarginError> {
        for underlying in &snapshot.underlyings {
            let underlying_state = market_state
                .underlyings
                .get_mut(&underlying.underlying)
                .expect("market state missing underlying after prior validation");
            for option in underlying
                .executed_options
                .iter()
                .chain(underlying.hypothetical_open_order_options.iter())
            {
                if underlying_state.option_inputs.contains_key(&option.key) {
                    continue;
                }
                let strike =
                    option
                        .key
                        .strike
                        .to_f64()
                        .ok_or_else(|| MarginError::InvalidStrike {
                            underlying: underlying.underlying.clone(),
                            strike: option.key.strike,
                        })?;
                let iv = self
                    .lookup_option_iv_from_key(&option.key.underlying, strike, option.key.expiry_ts)
                    .map_err(|e| {
                        tracing::error!(
                            underlying = %option.key.underlying,
                            strike = strike,
                            expiry_ts = option.key.expiry_ts,
                            error = %e,
                            "IV lookup failed, rejecting margin computation"
                        );
                        e
                    })?;
                underlying_state.option_inputs.insert(
                    option.key.clone(),
                    PortfolioMarginOptionMarketState {
                        implied_volatility: iv,
                    },
                );
            }
        }
        Ok(())
    }

    // ===== Public API =====

    /// Compute margin details for one or more accounts using Portfolio Margin semantics.
    ///
    /// # Portfolio Margin Behavior
    ///
    /// All accounts with positions (long or short) are included in the result.
    /// Empty portfolios return zero margin. This follows PM semantics where:
    /// - equity = cash + executed option UPNL + executed perp UPNL
    ///   - `cash` comes from the engine-owned balance snapshot
    ///   - option UPNL is computed from Black-Scholes valuations
    ///   - perp UPNL comes from executed perp state only
    /// - IM = max(scanning_risk, option_floor) + gamma_overlay
    /// - MM = IM * 0.85
    pub fn compute_span(&self, accounts: &[Account]) -> Result<Vec<MarginDetails>, MarginError> {
        self.compute_span_at(accounts, current_margin_timestamp())
    }

    pub fn compute_span_at(
        &self,
        accounts: &[Account],
        now_ts: i64,
    ) -> Result<Vec<MarginDetails>, MarginError> {
        let _m = MarginObsGuard::new("compute_span");
        let mut results = Vec::with_capacity(accounts.len());

        for account in accounts {
            results.push(self.compute_margin_for_account_at(account, now_ts)?);
        }

        Ok(results)
    }

    // ===== Risk Grid API =====

    /// Compute the risk grid showing scenario PnL for each configured scenario.
    ///
    /// This provides introspection into how SPAN scenarios affect the portfolio,
    /// similar to Deribit's risk grid endpoint.
    ///
    /// # Returns
    /// A vector of scenario PnL entries, one per configured scenario.
    pub fn compute_risk_grid(&self, account: &Account) -> Result<Vec<ScenarioPnl>, MarginError> {
        let _m = MarginObsGuard::new("compute_risk_grid");
        let (snapshot, market_state) = self.snapshot_and_market_state_from_account(account);
        self.compute_risk_grid_from_snapshot(&snapshot, market_state)
    }

    /// Compute extended risk grid with per-instrument breakdown.
    ///
    /// This provides a full risk matrix like Deribit's Extended Risk Matrix,
    /// showing P&L for each position under each scenario.
    pub fn compute_extended_risk_grid(
        &self,
        account: &Account,
    ) -> Result<ExtendedRiskGrid, MarginError> {
        let _m = MarginObsGuard::new("compute_extended_risk_grid");
        let (snapshot, market_state) = self.snapshot_and_market_state_from_account(account);
        self.compute_extended_risk_grid_from_snapshot(&snapshot, market_state)
    }

    pub fn compute_margin_from_snapshot(
        &self,
        snapshot: &PortfolioMarginSnapshot,
        market_state: PortfolioMarginMarketState,
    ) -> Result<MarginDetails, MarginError> {
        self.compute_margin_from_snapshot_at(snapshot, market_state, current_margin_timestamp())
    }

    pub fn compute_margin_from_snapshot_at(
        &self,
        snapshot: &PortfolioMarginSnapshot,
        mut market_state: PortfolioMarginMarketState,
        now_ts: i64,
    ) -> Result<MarginDetails, MarginError> {
        self.populate_option_market_state(snapshot, &mut market_state)?;
        let margin_result =
            hypercall_margin::compute_span_margin_at(snapshot, &market_state, now_ts)?;
        Ok(MarginDetails {
            account_id: margin_result.account_id,
            scanning_risk: margin_result.scanning_risk,
            option_floor: margin_result.option_floor,
            gamma_overlay: margin_result.gamma_overlay,
            net_option_value: margin_result.net_option_value,
            equity: margin_result.equity,
            initial_margin_required: margin_result.initial_margin_required,
            maintenance_margin_required: margin_result.maintenance_margin_required,
        })
    }

    pub fn compute_risk_grid_from_snapshot(
        &self,
        snapshot: &PortfolioMarginSnapshot,
        mut market_state: PortfolioMarginMarketState,
    ) -> Result<Vec<ScenarioPnl>, MarginError> {
        self.populate_option_market_state(snapshot, &mut market_state)?;
        Ok(compute_risk_grid_from_snapshot(snapshot, &market_state)?)
    }

    pub fn compute_extended_risk_grid_from_snapshot(
        &self,
        snapshot: &PortfolioMarginSnapshot,
        mut market_state: PortfolioMarginMarketState,
    ) -> Result<ExtendedRiskGrid, MarginError> {
        self.populate_option_market_state(snapshot, &mut market_state)?;
        Ok(compute_extended_risk_grid_from_snapshot(
            snapshot,
            &market_state,
        )?)
    }

    // ===== Private Helper Methods =====

    fn lookup_option_iv_from_key(
        &self,
        underlying: &str,
        strike: f64,
        expiry_ts: i64,
    ) -> Result<f64, MarginError> {
        match self.vol_oracle.get_iv(underlying, strike, expiry_ts) {
            Ok(iv) => Ok(iv),
            Err(err) => {
                counter!(
                    "ht_vol_lookup_failures_total",
                    "underlying" => underlying.to_string()
                )
                .increment(1);
                Err(err.into())
            }
        }
    }

    /// Check if account has any positions (options or delta exposure).
    ///
    /// Returns true if:
    /// - Any options positions exist (long or short)
    /// - Any significant delta (perp) exposure exists
    ///
    /// Used to determine if SPAN scenario evaluation should run.
    /// Empty portfolios can skip SPAN and return zero margin immediately.
    ///
    /// Note: We iterate by underlying (e.g., "BTC", "ETH"), not individual symbols.
    /// Each Position contains all options for that underlying plus delta exposure.
    /// No symbol-level filtering is needed here since we're checking existence, not value.
    fn has_positions(&self, account: &Account) -> bool {
        has_portfolio_positions(account, self.config.delta_threshold)
    }
}

#[async_trait]
impl MarginService for SpanMarginService {
    async fn compute_margin_for_account(
        &self,
        account: &Account,
    ) -> Result<MarginDetails, MarginError> {
        self.compute_margin_for_account_at(account, current_margin_timestamp())
    }
}

impl SpanMarginService {
    pub fn compute_margin_for_account_at(
        &self,
        account: &Account,
        now_ts: i64,
    ) -> Result<MarginDetails, MarginError> {
        let _m = MarginObsGuard::new("compute_margin_for_account");
        // Empty portfolio: return zeros immediately (no SPAN needed)
        // This is the only case where we skip scenario evaluation.
        if !self.has_positions(account) {
            return Ok(empty_portfolio_margin_details(account));
        }

        // Portfolio Margin: ALL non-empty portfolios go through SPAN scenario evaluation
        debug!(
            "MarginService: Computing SPAN margin for account {} (PM mode)",
            account.id
        );
        let (snapshot, market_state) = self.snapshot_and_market_state_from_account(account);
        self.compute_margin_from_snapshot_at(&snapshot, market_state, now_ts)
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::types::{OptionContract, OptionType, Position, Scenario, ScenarioType};
    use crate::vol_oracle::{RiskVolOracle, VolLookupError, VolOracleStatus, VolProviderKind};
    use chrono::Utc;
    use hypercall_engine::FeeConfig;
    use hypercall_types::wallet_address::test_wallet;
    use rust_decimal_macros::dec;
    use std::collections::HashMap;
    use std::sync::Arc;

    const FIXED_NOW_TS: i64 = 1_700_000_000;
    const TEST_EXPIRY_TS: i64 = 1_767_225_600;
    const NEAR_EXPIRY_TS: i64 = FIXED_NOW_TS + 24 * 3600;

    fn create_test_config() -> Config {
        Config {
            risk_free_rate: 0.05,
            base_volatility: 0.8,
            base_skew: 0.0,
            base_excess_kurtosis: 0.0,
            scenarios: vec![
                Scenario {
                    scenario_type: ScenarioType::SpotChange,
                    value: 0.15,
                },
                Scenario {
                    scenario_type: ScenarioType::SpotChange,
                    value: -0.15,
                },
            ],
            delta_threshold: 0.0001,
            strike_match_tolerance: 0.01,
            expiry_match_tolerance_years: 0.001,
            allow_standard_margin_shorts: false,
            fee_config: FeeConfig::default(),
        }
    }

    fn create_low_shock_config() -> Config {
        Config {
            risk_free_rate: 0.05,
            base_volatility: 0.8,
            base_skew: 0.0,
            base_excess_kurtosis: 0.0,
            scenarios: vec![
                Scenario {
                    scenario_type: ScenarioType::SpotChange,
                    value: 0.0001,
                },
                Scenario {
                    scenario_type: ScenarioType::SpotChange,
                    value: -0.0001,
                },
            ],
            delta_threshold: 0.0001,
            strike_match_tolerance: 0.01,
            expiry_match_tolerance_years: 0.001,
            allow_standard_margin_shorts: false,
            fee_config: FeeConfig::default(),
        }
    }

    fn create_high_shock_config() -> Config {
        Config {
            risk_free_rate: 0.05,
            base_volatility: 0.8,
            base_skew: 0.0,
            base_excess_kurtosis: 0.0,
            scenarios: vec![
                Scenario {
                    scenario_type: ScenarioType::SpotChange,
                    value: 0.35,
                },
                Scenario {
                    scenario_type: ScenarioType::SpotChange,
                    value: -0.35,
                },
            ],
            delta_threshold: 0.0001,
            strike_match_tolerance: 0.01,
            expiry_match_tolerance_years: 0.001,
            allow_standard_margin_shorts: false,
            fee_config: FeeConfig::default(),
        }
    }

    fn expiry_years_from_timestamps(now_ts: i64, expiry_ts: i64) -> Decimal {
        Decimal::from(expiry_ts - now_ts) / Decimal::from(365_i64 * 24 * 3600)
    }

    fn make_near_expiry_short_snapshot() -> PortfolioMarginSnapshot {
        PortfolioMarginSnapshot {
            wallet: test_wallet(180),
            cash_balance: dec!(10000),
            underlyings: vec![hypercall_margin::PortfolioMarginUnderlyingSnapshot {
                underlying: "BTC".to_string(),
                spot_price: dec!(100000),
                executed_options: vec![hypercall_margin::PortfolioMarginOptionExposure {
                    key: hypercall_margin::PortfolioMarginOptionKey {
                        underlying: "BTC".to_string(),
                        option_type: OptionType::Call,
                        strike: dec!(100000),
                        expiry_ts: NEAR_EXPIRY_TS,
                    },
                    expiry_years: expiry_years_from_timestamps(FIXED_NOW_TS, NEAR_EXPIRY_TS),
                    quantity: dec!(-1),
                    entry_price: dec!(5000),
                    source: hypercall_margin::SnapshotComponentKind::ExecutedPositions,
                }],
                hypothetical_open_order_options: Vec::new(),
                executed_perps: Vec::new(),
                hypothetical_open_order_perps: Vec::new(),
            }],
        }
    }

    fn make_near_expiry_vertical_spread_snapshot() -> PortfolioMarginSnapshot {
        PortfolioMarginSnapshot {
            wallet: test_wallet(182),
            cash_balance: dec!(10000),
            underlyings: vec![hypercall_margin::PortfolioMarginUnderlyingSnapshot {
                underlying: "BTC".to_string(),
                spot_price: dec!(100000),
                executed_options: vec![
                    hypercall_margin::PortfolioMarginOptionExposure {
                        key: hypercall_margin::PortfolioMarginOptionKey {
                            underlying: "BTC".to_string(),
                            option_type: OptionType::Call,
                            strike: dec!(100000),
                            expiry_ts: NEAR_EXPIRY_TS,
                        },
                        expiry_years: expiry_years_from_timestamps(FIXED_NOW_TS, NEAR_EXPIRY_TS),
                        quantity: dec!(-1),
                        entry_price: dec!(5000),
                        source: hypercall_margin::SnapshotComponentKind::ExecutedPositions,
                    },
                    hypercall_margin::PortfolioMarginOptionExposure {
                        key: hypercall_margin::PortfolioMarginOptionKey {
                            underlying: "BTC".to_string(),
                            option_type: OptionType::Call,
                            strike: dec!(100500),
                            expiry_ts: NEAR_EXPIRY_TS,
                        },
                        expiry_years: expiry_years_from_timestamps(FIXED_NOW_TS, NEAR_EXPIRY_TS),
                        quantity: dec!(1),
                        entry_price: dec!(4700),
                        source: hypercall_margin::SnapshotComponentKind::ExecutedPositions,
                    },
                ],
                hypothetical_open_order_options: Vec::new(),
                executed_perps: Vec::new(),
                hypothetical_open_order_perps: Vec::new(),
            }],
        }
    }

    struct TestRiskVolOracle {
        iv: f64,
        error: Option<VolLookupError>,
    }

    impl TestRiskVolOracle {
        fn with_iv(iv: f64) -> Self {
            Self { iv, error: None }
        }

        fn with_error(error: VolLookupError) -> Self {
            Self {
                iv: 0.0,
                error: Some(error),
            }
        }
    }

    impl RiskVolOracle for TestRiskVolOracle {
        fn get_iv(
            &self,
            _underlying: &str,
            _strike: f64,
            _expiry_ts: i64,
        ) -> Result<f64, VolLookupError> {
            match &self.error {
                Some(error) => Err(error.clone()),
                None => Ok(self.iv),
            }
        }

        fn statuses(&self) -> Vec<VolOracleStatus> {
            vec![VolOracleStatus {
                underlying: "BTC".to_string(),
                provider: VolProviderKind::BlockScholes,
                route_facing: true,
                connected: self.error.is_none(),
                ready: self.error.is_none(),
                last_update_ts_ms: Some(Utc::now().timestamp_millis()),
                staleness_seconds: Some(0.0),
                staleness_threshold_seconds: Some(120.0),
                surface_points: 1,
                messages_received: 1,
                last_error: self.error.as_ref().map(ToString::to_string),
            }]
        }
    }

    #[test]
    fn test_compute_span_empty_accounts() {
        let service = SpanMarginService::new_for_tests(create_test_config());
        let results = service
            .compute_span(&[])
            .expect("empty compute_span should succeed");
        assert!(results.is_empty());
    }

    #[test]
    fn test_compute_span_cash_only_account_returns_zero_margin_entry() {
        let service = SpanMarginService::new_for_tests(create_test_config());
        let account = Account {
            id: test_wallet(99),
            portfolio: HashMap::new(),
            cash: 50_000.0,
            address: None,
        };

        let results = service
            .compute_span(&[account])
            .expect("cash-only compute_span should succeed");

        assert_eq!(results.len(), 1);
        assert_eq!(results[0].equity, dec!(50000));
        assert_eq!(results[0].initial_margin_required, Decimal::ZERO);
        assert_eq!(results[0].maintenance_margin_required, Decimal::ZERO);
    }

    #[test]
    fn test_compute_span_long_only_computes_margin() {
        let service = SpanMarginService::new_for_tests(create_test_config());

        let mut portfolio = HashMap::new();
        portfolio.insert(
            "BTC".to_string(),
            Position {
                spot: dec!(50000),
                delta: dec!(0),
                perp_unrealized_pnl: Decimal::ZERO,
                options: vec![OptionContract {
                    option_type: OptionType::Call,
                    strike: dec!(50000),
                    expiry_ts: TEST_EXPIRY_TS,
                    expiry: dec!(0.25),
                    quantity: dec!(10),   // Long only
                    entry_price: dec!(0), // Test: acquired at zero cost
                }],
            },
        );

        let account = Account {
            id: test_wallet(100),
            portfolio,
            cash: 10000.0,
            address: None,
        };

        // PM semantics: long-only portfolios also get margin computed
        let results = service
            .compute_span(&[account])
            .expect("long-only compute_span should succeed");
        assert_eq!(results.len(), 1);
        // Long options have positive MTM and scenario-based IM
        assert!(results[0].net_option_value > Decimal::ZERO);
        assert!(results[0].initial_margin_required >= Decimal::ZERO);
    }

    #[test]
    fn test_snapshot_pipeline_matches_legacy_account_margin() {
        let service = SpanMarginService::new_for_tests(create_test_config());

        let mut portfolio = HashMap::new();
        portfolio.insert(
            "BTC".to_string(),
            Position {
                spot: dec!(50000),
                delta: dec!(0),
                perp_unrealized_pnl: Decimal::ZERO,
                options: vec![OptionContract {
                    option_type: OptionType::Call,
                    strike: dec!(50000),
                    expiry_ts: TEST_EXPIRY_TS,
                    expiry: dec!(0.25),
                    quantity: dec!(2),
                    entry_price: dec!(1000),
                }],
            },
        );

        let account = Account {
            id: test_wallet(101),
            portfolio,
            cash: 10000.0,
            address: None,
        };

        let legacy = futures::executor::block_on(service.compute_margin_for_account(&account))
            .expect("legacy account margin should succeed");
        let snapshot = snapshot_from_account(&account);
        let market_state =
            market_state_from_snapshot(&snapshot, service.config().portfolio_margin_config());
        let pipeline = service
            .compute_margin_from_snapshot(&snapshot, market_state)
            .expect("snapshot pipeline should succeed");

        assert_eq!(
            legacy.initial_margin_required,
            pipeline.initial_margin_required
        );
        assert_eq!(
            legacy.maintenance_margin_required,
            pipeline.maintenance_margin_required
        );
        assert_eq!(legacy.equity, pipeline.equity);
    }

    #[test]
    fn test_snapshot_pipeline_risk_grid_matches_legacy_count() {
        let service = SpanMarginService::new_for_tests(create_test_config());

        let mut portfolio = HashMap::new();
        portfolio.insert(
            "BTC".to_string(),
            Position {
                spot: dec!(50000),
                delta: dec!(0),
                perp_unrealized_pnl: Decimal::ZERO,
                options: vec![OptionContract {
                    option_type: OptionType::Put,
                    strike: dec!(45000),
                    expiry_ts: TEST_EXPIRY_TS,
                    expiry: dec!(0.25),
                    quantity: dec!(1),
                    entry_price: dec!(800),
                }],
            },
        );

        let account = Account {
            id: test_wallet(102),
            portfolio,
            cash: 5000.0,
            address: None,
        };

        let legacy = service
            .compute_risk_grid(&account)
            .expect("legacy risk grid should succeed");
        let snapshot = snapshot_from_account(&account);
        let market_state =
            market_state_from_snapshot(&snapshot, service.config().portfolio_margin_config());
        let pipeline = service
            .compute_risk_grid_from_snapshot(&snapshot, market_state)
            .expect("snapshot risk grid should succeed");

        assert_eq!(legacy.len(), pipeline.len());
        for (left, right) in legacy.iter().zip(pipeline.iter()) {
            assert_eq!(left.scenario.id, right.scenario.id);
            assert_eq!(left.scenario.spot_shock_pct, right.scenario.spot_shock_pct);
            assert_eq!(left.scenario.vol_shock_pct, right.scenario.vol_shock_pct);
            assert_eq!(left.scenario.pnl_weight, right.scenario.pnl_weight);
            assert_eq!(left.scenario.is_tail, right.scenario.is_tail);
            assert_eq!(left.total_pnl, right.total_pnl);
        }
    }

    #[test]
    fn test_snapshot_pipeline_extended_grid_includes_perp_rows() {
        let service = SpanMarginService::new_for_tests(create_test_config());

        let mut portfolio = HashMap::new();
        portfolio.insert(
            "BTC".to_string(),
            Position {
                spot: dec!(50000),
                delta: dec!(2),
                perp_unrealized_pnl: Decimal::ZERO,
                options: vec![OptionContract {
                    option_type: OptionType::Call,
                    strike: dec!(50000),
                    expiry_ts: TEST_EXPIRY_TS,
                    expiry: dec!(0.25),
                    quantity: dec!(1),
                    entry_price: dec!(1000),
                }],
            },
        );

        let account = Account {
            id: test_wallet(103),
            portfolio,
            cash: 10000.0,
            address: None,
        };

        let legacy = service
            .compute_extended_risk_grid(&account)
            .expect("legacy extended risk grid should succeed");
        let snapshot = snapshot_from_account(&account);
        let market_state =
            market_state_from_snapshot(&snapshot, service.config().portfolio_margin_config());
        let pipeline = service
            .compute_extended_risk_grid_from_snapshot(&snapshot, market_state)
            .expect("snapshot extended risk grid should succeed");

        assert_eq!(legacy.instruments.len(), pipeline.instruments.len());
        assert!(
            pipeline
                .instruments
                .iter()
                .any(|row| row.symbol == "BTC-PERP"),
            "pipeline grid should preserve perp instrument rows"
        );
        assert_eq!(legacy.total_pnls, pipeline.total_pnls);
        assert_eq!(legacy.worst_scenario_index, pipeline.worst_scenario_index);
        assert_eq!(legacy.worst_scenario_pnl, pipeline.worst_scenario_pnl);
    }

    #[test]
    fn test_snapshot_pipeline_includes_executed_perp_upnl_in_equity() {
        let service = SpanMarginService::new_for_tests(create_test_config());
        let wallet = test_wallet(105);
        let snapshot = PortfolioMarginSnapshot {
            wallet,
            cash_balance: dec!(1000),
            underlyings: vec![hypercall_margin::PortfolioMarginUnderlyingSnapshot {
                underlying: "BTC".to_string(),
                spot_price: dec!(100),
                executed_options: Vec::new(),
                hypothetical_open_order_options: Vec::new(),
                executed_perps: vec![hypercall_margin::PortfolioMarginPerpExposure {
                    underlying: "BTC".to_string(),
                    quantity: dec!(2),
                    entry_price: Some(dec!(90)),
                    unrealized_pnl: dec!(20),
                }],
                hypothetical_open_order_perps: Vec::new(),
            }],
        };
        let market_state =
            market_state_from_snapshot(&snapshot, service.config().portfolio_margin_config());

        let details = service
            .compute_margin_from_snapshot(&snapshot, market_state)
            .expect("snapshot margin should succeed");

        assert_eq!(details.equity, dec!(1020));
    }

    #[test]
    fn test_snapshot_pipeline_reprices_executed_perp_upnl_from_live_mark() {
        let service = SpanMarginService::new_for_tests(create_test_config());
        let wallet = test_wallet(108);
        let snapshot = PortfolioMarginSnapshot {
            wallet,
            cash_balance: dec!(1000),
            underlyings: vec![hypercall_margin::PortfolioMarginUnderlyingSnapshot {
                underlying: "BTC".to_string(),
                spot_price: dec!(100),
                executed_options: Vec::new(),
                hypothetical_open_order_options: Vec::new(),
                executed_perps: vec![hypercall_margin::PortfolioMarginPerpExposure {
                    underlying: "BTC".to_string(),
                    quantity: dec!(2),
                    entry_price: Some(dec!(90)),
                    unrealized_pnl: dec!(5),
                }],
                hypothetical_open_order_perps: Vec::new(),
            }],
        };
        let market_state =
            market_state_from_snapshot(&snapshot, service.config().portfolio_margin_config());

        let details = service
            .compute_margin_from_snapshot(&snapshot, market_state)
            .expect("snapshot margin should succeed");

        assert_eq!(details.equity, dec!(1020));
    }

    #[test]
    fn test_extended_risk_grid_worst_scenario_pnl_uses_weighted_total() {
        let service = SpanMarginService::new_for_tests(create_test_config());
        let wallet = test_wallet(109);
        let snapshot = PortfolioMarginSnapshot {
            wallet,
            cash_balance: dec!(1000),
            underlyings: vec![hypercall_margin::PortfolioMarginUnderlyingSnapshot {
                underlying: "BTC".to_string(),
                spot_price: dec!(100),
                executed_options: Vec::new(),
                hypothetical_open_order_options: Vec::new(),
                executed_perps: vec![hypercall_margin::PortfolioMarginPerpExposure {
                    underlying: "BTC".to_string(),
                    quantity: dec!(1),
                    entry_price: Some(dec!(100)),
                    unrealized_pnl: Decimal::ZERO,
                }],
                hypothetical_open_order_perps: Vec::new(),
            }],
        };
        let extended_grid_market_state =
            market_state_from_snapshot(&snapshot, service.config().portfolio_margin_config());
        let grid = service
            .compute_extended_risk_grid_from_snapshot(&snapshot, extended_grid_market_state)
            .expect("extended risk grid should succeed");

        let worst_scenario = &grid.scenarios[grid.worst_scenario_index];
        assert_eq!(worst_scenario.id, "T1");
        let raw_worst_pnl = grid.total_pnls[grid.worst_scenario_index];
        assert!((raw_worst_pnl + 25.0).abs() < 1e-9);
        assert!((grid.worst_scenario_pnl + 15.0).abs() < 1e-9);
        assert!((grid.worst_scenario_pnl - raw_worst_pnl * worst_scenario.pnl_weight).abs() < 1e-9);

        let margin_market_state =
            market_state_from_snapshot(&snapshot, service.config().portfolio_margin_config());
        let details = service
            .compute_margin_from_snapshot(&snapshot, margin_market_state)
            .expect("snapshot margin should succeed");
        assert_eq!(details.scanning_risk, dec!(15));
        assert!((details.scanning_risk.to_f64().unwrap() + grid.worst_scenario_pnl).abs() < 1e-9);
    }

    #[test]
    fn test_legacy_account_perp_equity_uses_stored_upnl_without_entry_price() {
        let service = SpanMarginService::new_for_tests(create_test_config());

        let mut portfolio = HashMap::new();
        portfolio.insert(
            "BTC".to_string(),
            Position {
                spot: dec!(100),
                delta: dec!(0),
                perp_unrealized_pnl: dec!(20),
                options: Vec::new(),
            },
        );

        let account = Account {
            id: test_wallet(110),
            portfolio,
            cash: 1000.0,
            address: None,
        };

        let details = futures::executor::block_on(service.compute_margin_for_account(&account))
            .expect("account margin should succeed");

        assert_eq!(details.equity, dec!(1020));
    }

    #[test]
    fn test_extended_risk_grid_prefers_explicit_perp_upnl() {
        let service = SpanMarginService::new_for_tests(create_test_config());
        let wallet = test_wallet(110);
        let snapshot = PortfolioMarginSnapshot {
            wallet,
            cash_balance: dec!(1000),
            underlyings: vec![hypercall_margin::PortfolioMarginUnderlyingSnapshot {
                underlying: "BTC".to_string(),
                spot_price: dec!(100),
                executed_options: Vec::new(),
                hypothetical_open_order_options: Vec::new(),
                executed_perps: vec![hypercall_margin::PortfolioMarginPerpExposure {
                    underlying: "BTC".to_string(),
                    quantity: dec!(2),
                    entry_price: Some(dec!(90)),
                    unrealized_pnl: dec!(5),
                }],
                hypothetical_open_order_perps: Vec::new(),
            }],
        };
        let market_state =
            market_state_from_snapshot(&snapshot, service.config().portfolio_margin_config());

        let grid = service
            .compute_extended_risk_grid_from_snapshot(&snapshot, market_state)
            .expect("extended risk grid should succeed");

        let perp_row = grid
            .instruments
            .iter()
            .find(|row| row.symbol == "BTC-PERP")
            .expect("perp row should be present");
        assert_eq!(perp_row.current_value, 5.0);
    }

    #[test]
    fn test_snapshot_pipeline_equity_uses_option_upnl_with_nonzero_entry_price() {
        let service = SpanMarginService::new_for_tests(create_test_config());

        let mut portfolio = HashMap::new();
        portfolio.insert(
            "BTC".to_string(),
            Position {
                spot: dec!(50000),
                delta: dec!(0),
                perp_unrealized_pnl: Decimal::ZERO,
                options: vec![OptionContract {
                    option_type: OptionType::Call,
                    strike: dec!(50000),
                    expiry_ts: TEST_EXPIRY_TS,
                    expiry: dec!(0.25),
                    quantity: dec!(1),
                    entry_price: dec!(1000),
                }],
            },
        );

        let account = Account {
            id: test_wallet(106),
            portfolio,
            cash: 10000.0,
            address: None,
        };

        let details = futures::executor::block_on(service.compute_margin_for_account(&account))
            .expect("account margin should succeed");
        let expected_equity = dec!(10000) + (details.net_option_value - dec!(1000));

        assert!(
            (details.equity - expected_equity).abs() < dec!(0.000000001),
            "equity ({}) should equal cash + option UPNL ({})",
            details.equity,
            expected_equity
        );
    }

    #[test]
    fn test_snapshot_pipeline_excludes_open_orders_from_equity() {
        let service = SpanMarginService::new_for_tests(create_test_config());

        let mut portfolio = HashMap::new();
        portfolio.insert(
            "BTC".to_string(),
            Position {
                spot: dec!(50000),
                delta: dec!(0),
                perp_unrealized_pnl: Decimal::ZERO,
                options: vec![OptionContract {
                    option_type: OptionType::Call,
                    strike: dec!(50000.5),
                    expiry_ts: TEST_EXPIRY_TS,
                    expiry: dec!(0.25),
                    quantity: dec!(1),
                    entry_price: dec!(1000),
                }],
            },
        );

        let account = Account {
            id: test_wallet(104),
            portfolio,
            cash: 10000.0,
            address: None,
        };

        let executed_only_snapshot = snapshot_from_account(&account);
        let executed_only_market_state = market_state_from_snapshot(
            &executed_only_snapshot,
            service.config().portfolio_margin_config(),
        );
        let executed_only_details = service
            .compute_margin_from_snapshot(&executed_only_snapshot, executed_only_market_state)
            .expect("executed-only snapshot should succeed");

        let mut snapshot_with_open_order = executed_only_snapshot.clone();
        snapshot_with_open_order.underlyings[0]
            .hypothetical_open_order_options
            .push(hypercall_margin::PortfolioMarginOptionExposure {
                key: hypercall_margin::PortfolioMarginOptionKey {
                    underlying: "BTC".to_string(),
                    option_type: OptionType::Call,
                    strike: dec!(50000.5),
                    expiry_ts: TEST_EXPIRY_TS,
                },
                expiry_years: dec!(0.25),
                quantity: dec!(1),
                entry_price: dec!(1200),
                source: hypercall_margin::SnapshotComponentKind::OpenOrders,
            });
        let market_state_with_open_order = market_state_from_snapshot(
            &snapshot_with_open_order,
            service.config().portfolio_margin_config(),
        );
        let details_with_open_order = service
            .compute_margin_from_snapshot(&snapshot_with_open_order, market_state_with_open_order)
            .expect("snapshot with open order should succeed");

        assert_eq!(executed_only_details.equity, details_with_open_order.equity);
        assert_eq!(
            executed_only_details.net_option_value,
            details_with_open_order.net_option_value
        );
    }

    #[test]
    fn test_snapshot_pipeline_open_perp_overlay_changes_im_not_equity() {
        let service = SpanMarginService::new_for_tests(create_test_config());
        let wallet = test_wallet(107);
        let executed_snapshot = PortfolioMarginSnapshot {
            wallet,
            cash_balance: dec!(1000),
            underlyings: vec![hypercall_margin::PortfolioMarginUnderlyingSnapshot {
                underlying: "BTC".to_string(),
                spot_price: dec!(100),
                executed_options: Vec::new(),
                hypothetical_open_order_options: Vec::new(),
                executed_perps: vec![hypercall_margin::PortfolioMarginPerpExposure {
                    underlying: "BTC".to_string(),
                    quantity: dec!(1),
                    entry_price: Some(dec!(80)),
                    unrealized_pnl: dec!(20),
                }],
                hypothetical_open_order_perps: Vec::new(),
            }],
        };
        let executed_market_state = market_state_from_snapshot(
            &executed_snapshot,
            service.config().portfolio_margin_config(),
        );
        let executed_details = service
            .compute_margin_from_snapshot(&executed_snapshot, executed_market_state)
            .expect("executed snapshot should succeed");

        let mut snapshot_with_open_order = executed_snapshot.clone();
        snapshot_with_open_order.underlyings[0]
            .hypothetical_open_order_perps
            .push(hypercall_margin::PortfolioMarginPerpExposure {
                underlying: "BTC".to_string(),
                quantity: dec!(1),
                entry_price: None,
                unrealized_pnl: dec!(0),
            });
        let market_state_with_open_order = market_state_from_snapshot(
            &snapshot_with_open_order,
            service.config().portfolio_margin_config(),
        );
        let details_with_open_order = service
            .compute_margin_from_snapshot(&snapshot_with_open_order, market_state_with_open_order)
            .expect("snapshot with open perp order should succeed");

        assert_eq!(executed_details.equity, dec!(1020));
        assert_eq!(executed_details.equity, details_with_open_order.equity);
        assert!(
            details_with_open_order.initial_margin_required
                > executed_details.initial_margin_required
        );
    }

    #[test]
    fn test_extended_grid_nets_split_perps_before_threshold() {
        let mut config = create_test_config();
        config.delta_threshold = 0.5;
        let service = SpanMarginService::new_for_tests(config);
        let snapshot = PortfolioMarginSnapshot {
            wallet: test_wallet(108),
            cash_balance: dec!(0),
            underlyings: vec![hypercall_margin::PortfolioMarginUnderlyingSnapshot {
                underlying: "BTC".to_string(),
                spot_price: dec!(100),
                executed_options: Vec::new(),
                hypothetical_open_order_options: Vec::new(),
                executed_perps: vec![
                    hypercall_margin::PortfolioMarginPerpExposure {
                        underlying: "BTC".to_string(),
                        quantity: dec!(0.3),
                        entry_price: Some(dec!(100)),
                        unrealized_pnl: dec!(0),
                    },
                    hypercall_margin::PortfolioMarginPerpExposure {
                        underlying: "BTC".to_string(),
                        quantity: dec!(0.3),
                        entry_price: Some(dec!(100)),
                        unrealized_pnl: dec!(0),
                    },
                ],
                hypothetical_open_order_perps: Vec::new(),
            }],
        };
        let market_state =
            market_state_from_snapshot(&snapshot, service.config().portfolio_margin_config());

        let grid = service
            .compute_extended_risk_grid_from_snapshot(&snapshot, market_state)
            .expect("split perps should produce an aggregated perp row");

        let perp_row = grid
            .instruments
            .iter()
            .find(|row| row.symbol == "BTC-PERP")
            .expect("net perp row should be present");

        assert_eq!(perp_row.amount, 0.6);
        assert_eq!(grid.instruments.len(), 1);
        assert!(
            grid.total_pnls.iter().any(|pnl| pnl.abs() > 0.0),
            "net perp row should contribute non-zero scenario pnl"
        );
    }

    #[test]
    fn test_snapshot_pipeline_deterministic_replay_preserves_gamma_and_worst_case() {
        let service = SpanMarginService::new_for_tests(create_test_config());
        let snapshot = PortfolioMarginSnapshot {
            wallet: test_wallet(181),
            cash_balance: dec!(10000),
            underlyings: vec![hypercall_margin::PortfolioMarginUnderlyingSnapshot {
                underlying: "BTC".to_string(),
                spot_price: dec!(100000),
                executed_options: vec![hypercall_margin::PortfolioMarginOptionExposure {
                    key: hypercall_margin::PortfolioMarginOptionKey {
                        underlying: "BTC".to_string(),
                        option_type: OptionType::Call,
                        strike: dec!(100000),
                        expiry_ts: NEAR_EXPIRY_TS,
                    },
                    expiry_years: expiry_years_from_timestamps(FIXED_NOW_TS, NEAR_EXPIRY_TS),
                    quantity: dec!(-1),
                    entry_price: dec!(5000),
                    source: hypercall_margin::SnapshotComponentKind::ExecutedPositions,
                }],
                hypothetical_open_order_options: Vec::new(),
                executed_perps: vec![hypercall_margin::PortfolioMarginPerpExposure {
                    underlying: "BTC".to_string(),
                    quantity: dec!(-0.4),
                    entry_price: Some(dec!(99000)),
                    unrealized_pnl: dec!(750),
                }],
                hypothetical_open_order_perps: Vec::new(),
            }],
        };

        let first_market_state =
            market_state_from_snapshot(&snapshot, service.config().portfolio_margin_config());
        let second_market_state =
            market_state_from_snapshot(&snapshot, service.config().portfolio_margin_config());
        let first = service
            .compute_margin_from_snapshot_at(&snapshot, first_market_state, FIXED_NOW_TS)
            .expect("first deterministic replay should succeed");
        let second = service
            .compute_margin_from_snapshot_at(&snapshot, second_market_state, FIXED_NOW_TS)
            .expect("second deterministic replay should succeed");

        assert_eq!(first.equity, second.equity);
        assert_eq!(first.scanning_risk, second.scanning_risk);
        assert_eq!(first.option_floor, second.option_floor);
        assert_eq!(first.gamma_overlay, second.gamma_overlay);
        assert_eq!(
            first.initial_margin_required,
            second.initial_margin_required
        );
        assert_eq!(
            first.maintenance_margin_required,
            second.maintenance_margin_required
        );

        let first_grid = service
            .compute_extended_risk_grid_from_snapshot(
                &snapshot,
                market_state_from_snapshot(&snapshot, service.config().portfolio_margin_config()),
            )
            .expect("first extended grid replay should succeed");
        let second_grid = service
            .compute_extended_risk_grid_from_snapshot(
                &snapshot,
                market_state_from_snapshot(&snapshot, service.config().portfolio_margin_config()),
            )
            .expect("second extended grid replay should succeed");

        assert_eq!(first_grid.total_pnls, second_grid.total_pnls);
        assert_eq!(
            first_grid.worst_scenario_index,
            second_grid.worst_scenario_index
        );
        assert_eq!(
            first_grid.worst_scenario_pnl,
            second_grid.worst_scenario_pnl
        );
        assert_eq!(first_grid.instruments.len(), second_grid.instruments.len());
        for (left, right) in first_grid
            .instruments
            .iter()
            .zip(second_grid.instruments.iter())
        {
            assert_eq!(left.symbol, right.symbol);
            assert_eq!(left.scenario_pnls, right.scenario_pnls);
        }
    }

    #[test]
    fn test_snapshot_pipeline_im_uses_option_floor_plus_gamma_when_floor_dominates() {
        let service = SpanMarginService::new_for_tests(create_low_shock_config());
        let snapshot = make_near_expiry_vertical_spread_snapshot();
        let market_state =
            market_state_from_snapshot(&snapshot, service.config().portfolio_margin_config());

        let details = service
            .compute_margin_from_snapshot_at(&snapshot, market_state, FIXED_NOW_TS)
            .expect("low-shock margin should succeed");

        assert!(
            details.scanning_risk < details.option_floor,
            "expected option_floor to dominate low-shock book, scanning_risk={} option_floor={}",
            details.scanning_risk,
            details.option_floor
        );
        assert!(details.gamma_overlay > Decimal::ZERO);
        let expected_im = details.option_floor + details.gamma_overlay;
        assert!(
            (details.initial_margin_required - expected_im).abs() < dec!(0.000000001),
            "expected IM={} to match option_floor + gamma_overlay={}",
            details.initial_margin_required,
            expected_im
        );
    }

    #[test]
    fn test_snapshot_pipeline_im_uses_scanning_risk_plus_gamma_when_scanning_dominates() {
        let service = SpanMarginService::new_for_tests(create_high_shock_config());
        let snapshot = make_near_expiry_short_snapshot();
        let market_state =
            market_state_from_snapshot(&snapshot, service.config().portfolio_margin_config());

        let details = service
            .compute_margin_from_snapshot_at(&snapshot, market_state, FIXED_NOW_TS)
            .expect("high-shock margin should succeed");

        assert!(
            details.scanning_risk > details.option_floor,
            "expected scanning_risk to dominate high-shock book, scanning_risk={} option_floor={}",
            details.scanning_risk,
            details.option_floor
        );
        assert!(details.gamma_overlay > Decimal::ZERO);
        let expected_im = details.scanning_risk + details.gamma_overlay;
        assert!(
            (details.initial_margin_required - expected_im).abs() < dec!(0.000000001),
            "expected IM={} to match scanning_risk + gamma_overlay={}",
            details.initial_margin_required,
            expected_im
        );
    }

    #[test]
    fn test_compute_span_with_short_options() {
        let service = SpanMarginService::new_for_tests(create_test_config());

        let mut portfolio = HashMap::new();
        portfolio.insert(
            "BTC".to_string(),
            Position {
                spot: dec!(50000),
                delta: dec!(0),
                perp_unrealized_pnl: Decimal::ZERO,
                options: vec![OptionContract {
                    option_type: OptionType::Call,
                    strike: dec!(50000),
                    expiry_ts: TEST_EXPIRY_TS,
                    expiry: dec!(0.25),
                    quantity: dec!(-10),  // Short position
                    entry_price: dec!(0), // Test: sold at zero premium
                }],
            },
        );

        let account = Account {
            id: test_wallet(100),
            portfolio,
            cash: 10000.0,
            address: None,
        };

        let results = service
            .compute_span(&[account])
            .expect("short compute_span should succeed");
        assert_eq!(results.len(), 1);
        assert_eq!(results[0].account_id, test_wallet(100));
        assert!(results[0].scanning_risk > Decimal::ZERO);
        assert!(results[0].initial_margin_required > Decimal::ZERO);
    }

    #[tokio::test]
    async fn test_margin_service_uses_live_iv_over_config_vol() {
        let mut config = create_test_config();
        config.base_volatility = 0.10;
        let oracle = Arc::new(TestRiskVolOracle::with_iv(1.20));
        let service = SpanMarginService::new_with_vol_oracle(config.clone(), oracle);

        let account = create_long_call_account(10_000.0, 50_000.0, 1.0);
        let margin = service
            .compute_margin_for_account(&account)
            .await
            .expect("margin should compute");

        let expected_price = black_scholes_with_moments(
            &OptionType::Call,
            50_000.0,
            50_000.0,
            0.25,
            config.risk_free_rate,
            1.20,
            config.base_skew,
            config.base_excess_kurtosis,
        );
        let expected_value = Decimal::from_f64_retain(expected_price).unwrap();
        assert!(
            (margin.net_option_value - expected_value).abs() < dec!(0.000000001),
            "net option value should use live IV, got {} expected {}",
            margin.net_option_value,
            expected_value
        );
    }

    #[tokio::test]
    async fn test_margin_service_fails_closed_when_vol_missing() {
        let oracle = Arc::new(TestRiskVolOracle::with_error(
            VolLookupError::MissingSurface {
                underlying: "BTC".to_string(),
                provider: VolProviderKind::BlockScholes,
                strike: 50_000.0,
                expiry_ts: TEST_EXPIRY_TS,
            },
        ));
        let service = SpanMarginService::new_with_vol_oracle(create_test_config(), oracle);

        let account = create_long_call_account(10_000.0, 50_000.0, 1.0);
        let err = service
            .compute_margin_for_account(&account)
            .await
            .expect_err("missing vol must fail closed");
        assert!(matches!(
            err,
            MarginError::VolLookup(VolLookupError::MissingSurface { .. })
        ));
    }

    /// Test that long-only positions now go through SPAN and have margin requirements.
    ///
    /// Under Portfolio Margin, long options have scenario risk:
    /// - Long calls lose value when spot drops
    /// - Long puts lose value when spot rises
    ///
    /// This test validates the PM semantic change from the old behavior
    /// where long-only positions had zero margin.
    #[tokio::test]
    async fn test_margin_service_trait_computes_margin_for_long_only() {
        let service = SpanMarginService::new_for_tests(create_test_config());

        let mut portfolio = HashMap::new();
        portfolio.insert(
            "BTC".to_string(),
            Position {
                spot: dec!(50000),
                delta: dec!(0),
                perp_unrealized_pnl: Decimal::ZERO,
                options: vec![OptionContract {
                    option_type: OptionType::Call,
                    strike: dec!(50000),
                    expiry_ts: TEST_EXPIRY_TS,
                    expiry: dec!(0.25),
                    quantity: dec!(10),   // Long only
                    entry_price: dec!(0), // Test: acquired at zero cost
                }],
            },
        );

        let account = Account {
            id: test_wallet(100),
            portfolio,
            cash: 10000.0,
            address: None,
        };

        let result = service.compute_margin_for_account(&account).await;
        assert!(result.is_ok(), "Long positions should return Ok");

        let margin = result.unwrap();

        // PM CHANGE: Long positions now have nonzero margin (scenario risk)
        // With ±15% spot scenarios, ATM call loses value when spot drops -15%
        assert!(
            margin.scanning_risk > Decimal::ZERO,
            "Long call should have positive scanning_risk from spot-down scenario. Got {}",
            margin.scanning_risk
        );
        assert!(
            margin.initial_margin_required > Decimal::ZERO,
            "Long call should have positive IM. Got {}",
            margin.initial_margin_required
        );

        // Net option value should be positive for long ATM call
        assert!(
            margin.net_option_value > Decimal::ZERO,
            "Long ATM call should have positive MTM value. Got {}",
            margin.net_option_value
        );

        // Equity = cash + executed option UPNL + executed perp UPNL
        // Long call has positive MTM, so equity > cash
        let expected_equity = dec!(10000) + margin.net_option_value;
        assert!(
            (margin.equity - expected_equity).abs() < dec!(0.000000001),
            "equity ({}) should equal cash + MTM ({})",
            margin.equity,
            expected_equity
        );
    }

    #[tokio::test]
    async fn test_margin_service_trait_returns_some_for_short() {
        let service = SpanMarginService::new_for_tests(create_test_config());

        let mut portfolio = HashMap::new();
        portfolio.insert(
            "BTC".to_string(),
            Position {
                spot: dec!(50000),
                delta: dec!(0),
                perp_unrealized_pnl: Decimal::ZERO,
                options: vec![OptionContract {
                    option_type: OptionType::Call,
                    strike: dec!(50000),
                    expiry_ts: TEST_EXPIRY_TS,
                    expiry: dec!(0.25),
                    quantity: dec!(-10),  // Short position
                    entry_price: dec!(0), // Test: sold at zero premium
                }],
            },
        );

        let account = Account {
            id: test_wallet(100),
            portfolio,
            cash: 10000.0,
            address: None,
        };

        let result = service.compute_margin_for_account(&account).await;
        assert!(result.is_ok());
        let details = result.unwrap();
        assert_eq!(details.account_id, test_wallet(100));
        assert!(details.scanning_risk > Decimal::ZERO);
    }

    /// Test that IM/MM fields follow PM semantics.
    /// Invariants (Step 4 PM semantics):
    /// - initial_margin_required == scanning_risk (+ hypercore_margin if present)
    /// - maintenance_margin_required == 0.85 * IM
    /// - equity == account.cash (until Step 5)
    #[tokio::test]
    async fn test_new_im_mm_fields_with_divergence() {
        let service = SpanMarginService::new_for_tests(create_test_config());

        let mut portfolio = HashMap::new();
        portfolio.insert(
            "BTC".to_string(),
            Position {
                spot: dec!(50000),
                delta: dec!(0),
                perp_unrealized_pnl: Decimal::ZERO,
                options: vec![OptionContract {
                    option_type: OptionType::Call,
                    strike: dec!(50000),
                    expiry_ts: TEST_EXPIRY_TS,
                    expiry: dec!(0.25),
                    quantity: dec!(-10),  // Short position
                    entry_price: dec!(0), // Test: sold at zero premium
                }],
            },
        );

        let account_cash_f64 = 50000.0;
        let account_cash = dec!(50000);
        let account = Account {
            id: test_wallet(101),
            portfolio,
            cash: account_cash_f64,
            address: None,
        };

        let result = service.compute_margin_for_account(&account).await;
        assert!(result.is_ok());
        let details = result.unwrap();

        let expected_initial_margin =
            details.scanning_risk.max(details.option_floor) + details.gamma_overlay;
        assert!(
            (details.initial_margin_required - expected_initial_margin).abs() < dec!(0.000000001),
            "initial_margin_required ({}) should equal max(scanning_risk={}, option_floor={}) + gamma_overlay={}",
            details.initial_margin_required,
            details.scanning_risk,
            details.option_floor,
            details.gamma_overlay
        );

        // MM = MM_TO_IM_RATIO * IM (lower threshold for liquidation)
        let expected_mm =
            details.initial_margin_required * Decimal::from_f64_retain(MM_TO_IM_RATIO).unwrap();
        assert!(
            (details.maintenance_margin_required - expected_mm).abs() < dec!(0.000000001),
            "maintenance_margin_required ({}) should equal 0.85 * IM ({})",
            details.maintenance_margin_required,
            expected_mm
        );

        // MM < IM (you need more to open than to maintain)
        assert!(
            details.maintenance_margin_required < details.initial_margin_required,
            "MM ({}) should be less than IM ({})",
            details.maintenance_margin_required,
            details.initial_margin_required
        );

        // Equity = cash + executed option UPNL + executed perp UPNL
        // Short call has negative MTM (liability), so equity < cash
        let expected_equity = account_cash + details.net_option_value; // Both are Decimal
        assert!(
            (details.equity - expected_equity).abs() < dec!(0.000000001),
            "equity ({}) should equal cash ({}) + MTM ({})",
            details.equity,
            account_cash,
            details.net_option_value
        );
        // Short positions have negative MTM
        assert!(
            details.net_option_value < Decimal::ZERO,
            "Short call should have negative MTM. Got {}",
            details.net_option_value
        );
    }

    /// Test that sync compute_span also follows PM semantics.
    #[test]
    fn test_compute_span_populates_new_fields() {
        let service = SpanMarginService::new_for_tests(create_test_config());

        let mut portfolio = HashMap::new();
        portfolio.insert(
            "BTC".to_string(),
            Position {
                spot: dec!(50000),
                delta: dec!(0),
                perp_unrealized_pnl: Decimal::ZERO,
                options: vec![OptionContract {
                    option_type: OptionType::Call,
                    strike: dec!(50000),
                    expiry_ts: TEST_EXPIRY_TS,
                    expiry: dec!(0.25),
                    quantity: dec!(-10),  // Short position
                    entry_price: dec!(0), // Test: sold at zero premium
                }],
            },
        );

        let account_cash_f64 = 25000.0;
        let account_cash = dec!(25000);
        let account = Account {
            id: test_wallet(102),
            portfolio,
            cash: account_cash_f64,
            address: None,
        };

        let results = service
            .compute_span(&[account])
            .expect("sync compute_span should succeed");
        assert_eq!(results.len(), 1);
        let details = &results[0];

        let expected_initial_margin =
            details.scanning_risk.max(details.option_floor) + details.gamma_overlay;
        assert!(
            (details.initial_margin_required - expected_initial_margin).abs() < dec!(0.000000001),
            "initial_margin_required ({}) should equal max(scanning_risk={}, option_floor={}) + gamma_overlay={}",
            details.initial_margin_required,
            details.scanning_risk,
            details.option_floor,
            details.gamma_overlay
        );

        // Verify MM = MM_TO_IM_RATIO * IM
        let expected_mm =
            details.initial_margin_required * Decimal::from_f64_retain(MM_TO_IM_RATIO).unwrap();
        assert!(
            (details.maintenance_margin_required - expected_mm).abs() < dec!(0.000000001),
            "maintenance_margin_required should equal 0.85 * IM"
        );

        // Verify MM < IM
        assert!(
            details.maintenance_margin_required < details.initial_margin_required,
            "MM should be less than IM"
        );

        // Equity = cash + executed option UPNL + executed perp UPNL
        let expected_equity = account_cash + details.net_option_value;
        assert!(
            (details.equity - expected_equity).abs() < dec!(0.000000001),
            "equity ({}) should equal cash ({}) + MTM ({})",
            details.equity,
            account_cash,
            details.net_option_value
        );
    }

    // =========================================================================
    // Portfolio Margin v1 Tests (Step 1)
    //
    // These tests describe the DESIRED behavior for portfolio margin.
    // Initially, some may fail because the current implementation doesn't
    // compute margin for long-only positions.
    //
    // Goal: After completing the PM refactor:
    //   - Any non-empty portfolio should go through SPAN
    //   - Long options should have nonzero IM (scenario loss from spot down)
    //   - Short options should have higher IM than equivalent longs
    //   - Spreads should have lower IM than naked shorts
    // =========================================================================

    /// Create a config with more aggressive scenarios for portfolio margin testing.
    /// Includes spot down -25% to ensure long calls show meaningful scenario loss.
    fn create_pm_test_config() -> Config {
        Config {
            risk_free_rate: 0.05,
            base_volatility: 0.8,
            base_skew: 0.0,
            base_excess_kurtosis: 0.0,
            scenarios: vec![
                // Spot moves
                Scenario {
                    scenario_type: ScenarioType::SpotChange,
                    value: 0.15, // +15%
                },
                Scenario {
                    scenario_type: ScenarioType::SpotChange,
                    value: -0.15, // -15%
                },
                Scenario {
                    scenario_type: ScenarioType::SpotChange,
                    value: 0.25, // +25%
                },
                Scenario {
                    scenario_type: ScenarioType::SpotChange,
                    value: -0.25, // -25% (should hurt long calls)
                },
                // Vol moves
                Scenario {
                    scenario_type: ScenarioType::VolChange,
                    value: 0.25, // +25% vol
                },
                Scenario {
                    scenario_type: ScenarioType::VolChange,
                    value: -0.25, // -25% vol (should hurt long options)
                },
            ],
            delta_threshold: 0.0001,
            strike_match_tolerance: 0.01,
            expiry_match_tolerance_years: 0.001,
            allow_standard_margin_shorts: false,
            fee_config: FeeConfig::default(),
        }
    }

    /// Helper to create an ATM long call account
    fn create_long_call_account(cash: f64, spot: f64, quantity: f64) -> Account {
        let spot_dec = Decimal::from_f64_retain(spot).unwrap_or(Decimal::ZERO);
        let quantity_dec = Decimal::from_f64_retain(quantity).unwrap_or(Decimal::ZERO);
        let mut portfolio = HashMap::new();
        portfolio.insert(
            "BTC".to_string(),
            Position {
                spot: spot_dec,
                delta: Decimal::ZERO,
                perp_unrealized_pnl: Decimal::ZERO,
                options: vec![OptionContract {
                    option_type: OptionType::Call,
                    strike: spot_dec, // ATM
                    expiry_ts: TEST_EXPIRY_TS,
                    expiry: dec!(0.25),         // 3 months
                    quantity: quantity_dec,     // positive = long
                    entry_price: Decimal::ZERO, // Test: acquired at zero cost
                }],
            },
        );
        Account {
            id: test_wallet(103),
            portfolio,
            cash,
            address: None,
        }
    }

    /// Helper to create an ATM short call account
    fn create_short_call_account(cash: f64, spot: f64, quantity: f64) -> Account {
        let spot_dec = Decimal::from_f64_retain(spot).unwrap_or(Decimal::ZERO);
        let quantity_dec = Decimal::from_f64_retain(quantity).unwrap_or(Decimal::ZERO);
        let mut portfolio = HashMap::new();
        portfolio.insert(
            "BTC".to_string(),
            Position {
                spot: spot_dec,
                delta: Decimal::ZERO,
                perp_unrealized_pnl: Decimal::ZERO,
                options: vec![OptionContract {
                    option_type: OptionType::Call,
                    strike: spot_dec, // ATM
                    expiry_ts: TEST_EXPIRY_TS,
                    expiry: dec!(0.25),         // 3 months
                    quantity: -quantity_dec,    // negative = short
                    entry_price: Decimal::ZERO, // Test: sold at zero premium
                }],
            },
        );
        Account {
            id: test_wallet(104),
            portfolio,
            cash,
            address: None,
        }
    }

    /// PM Test: A pure long call should have nonzero initial margin.
    ///
    /// Rationale: Even long options have risk. In a portfolio margin system,
    /// the margin requirement represents the worst-case scenario loss.
    /// A long call loses value when spot goes down, so SPAN should capture this.
    ///
    /// After Step 2 (remove short-only gating): IM > 0 for long positions. ✅
    #[tokio::test]
    async fn test_pm_long_call_has_nonzero_im() {
        let config = create_pm_test_config();
        let service = SpanMarginService::new_for_tests(config);

        let account = create_long_call_account(100_000.0, 100_000.0, 10.0);

        let result = service.compute_margin_for_account(&account).await;
        assert!(
            result.is_ok(),
            "Should return Ok for any non-empty portfolio"
        );

        let details = result.unwrap();

        // Log the actual values for debugging
        println!("PM Test - Long Call:");
        println!("  scanning_risk: {}", details.scanning_risk);
        println!("  net_option_value: {}", details.net_option_value);
        println!(
            "  initial_margin_required: {}",
            details.initial_margin_required
        );

        // Step 2 complete: Long calls now have scenario loss when spot drops
        assert!(
            details.initial_margin_required > Decimal::ZERO,
            "Long call should have nonzero IM (scenario loss from spot down). Got IM={}",
            details.initial_margin_required
        );

        assert!(
            details.net_option_value > Decimal::ZERO,
            "ATM long call should have positive MTM value. Got {}",
            details.net_option_value
        );
    }

    /// PM Test: A short call should have higher IM than an equivalent long call.
    ///
    /// Rationale: Selling options is riskier than buying them. The max loss on
    /// a long call is limited to the premium paid, but a short call can lose
    /// theoretically unlimited amounts.
    ///
    /// After Step 2: IM(short) > IM(long) > 0 ✅
    #[tokio::test]
    async fn test_pm_short_margin_greater_than_long_margin() {
        let config = create_pm_test_config();
        let service = SpanMarginService::new_for_tests(config);

        let spot = 100_000.0;
        let quantity = 10.0;
        let cash = 100_000.0;

        let long_account = create_long_call_account(cash, spot, quantity);
        let short_account = create_short_call_account(cash, spot, quantity);

        let long_result = service.compute_margin_for_account(&long_account).await;
        let short_result = service.compute_margin_for_account(&short_account).await;

        assert!(long_result.is_ok(), "Long should return Ok");
        assert!(short_result.is_ok(), "Short should return Ok");

        let long_details = long_result.unwrap();
        let short_details = short_result.unwrap();

        // Log values for debugging
        println!("PM Test - Long vs Short:");
        println!("  Long IM: {}", long_details.initial_margin_required);
        println!("  Short IM: {}", short_details.initial_margin_required);

        // Both should have positive IM under PM
        assert!(
            long_details.initial_margin_required > Decimal::ZERO,
            "Long call must have nonzero IM under PM. Got {}",
            long_details.initial_margin_required
        );
        assert!(
            short_details.initial_margin_required > Decimal::ZERO,
            "Short call must have nonzero IM. Got {}",
            short_details.initial_margin_required
        );

        // Short should be strictly greater than long (unlimited upside risk vs limited downside)
        assert!(
            short_details.initial_margin_required > long_details.initial_margin_required,
            "Short IM ({}) should be greater than Long IM ({})",
            short_details.initial_margin_required,
            long_details.initial_margin_required
        );
    }

    /// PM Test: A spread (long + short same series) should have less margin than naked short.
    ///
    /// Rationale: Portfolio margin recognizes offsetting positions. If you have
    /// a long call at strike K and a short call at the same strike, the long
    /// provides a hedge for the short. The net risk is reduced.
    ///
    /// EXPECTED: IM(spread) < IM(naked_short)
    #[tokio::test]
    async fn test_pm_spread_has_less_margin_than_naked_short() {
        let config = create_pm_test_config();
        let service = SpanMarginService::new_for_tests(config);

        let spot = 100_000.0;
        let spot_dec = dec!(100000);
        let cash = 100_000.0;

        // Naked short: 10 short calls
        let short_account = create_short_call_account(cash, spot, 10.0);

        // Spread: 5 long + 5 short at same strike (net 0)
        // Actually, let's do a more realistic spread: 10 short low strike, 10 long higher strike
        let mut spread_portfolio = HashMap::new();
        spread_portfolio.insert(
            "BTC".to_string(),
            Position {
                spot: spot_dec,
                delta: Decimal::ZERO,
                perp_unrealized_pnl: Decimal::ZERO,
                options: vec![
                    // Short 10 calls at 100k
                    OptionContract {
                        option_type: OptionType::Call,
                        strike: spot_dec,
                        expiry_ts: TEST_EXPIRY_TS,
                        expiry: dec!(0.25),
                        quantity: dec!(-10),
                        entry_price: Decimal::ZERO, // Test: sold at zero premium
                    },
                    // Long 10 calls at 110k (higher strike)
                    OptionContract {
                        option_type: OptionType::Call,
                        strike: spot_dec * dec!(1.10),
                        expiry_ts: TEST_EXPIRY_TS,
                        expiry: dec!(0.25),
                        quantity: dec!(10),
                        entry_price: Decimal::ZERO, // Test: acquired at zero cost
                    },
                ],
            },
        );
        let spread_account = Account {
            id: test_wallet(105),
            portfolio: spread_portfolio,
            cash,
            address: None,
        };

        let short_result = service.compute_margin_for_account(&short_account).await;
        let spread_result = service.compute_margin_for_account(&spread_account).await;

        assert!(short_result.is_ok(), "Naked short should return Ok");
        assert!(spread_result.is_ok(), "Spread should return Ok");

        let short_details = short_result.unwrap();
        let spread_details = spread_result.unwrap();

        // Log values
        println!("PM Test - Spread vs Naked Short:");
        println!(
            "  Naked Short IM: {}",
            short_details.initial_margin_required
        );
        println!("  Spread IM: {}", spread_details.initial_margin_required);
        println!("  Spread scanning_risk: {}", spread_details.scanning_risk);
        println!(
            "  Spread net_option_value: {}",
            spread_details.net_option_value
        );

        // Both should require margin (spread has short leg)
        assert!(
            short_details.initial_margin_required > Decimal::ZERO,
            "Naked short must have positive IM"
        );
        assert!(
            spread_details.initial_margin_required > Decimal::ZERO,
            "Spread with short leg should have positive IM"
        );

        // The spread should have LOWER margin than the naked short
        // because the long higher-strike call provides a hedge.
        // Max loss on the spread = (110k - 100k) * 10 = 100k (capped by long strike)
        // Max loss on naked short = theoretically unlimited
        assert!(
            spread_details.initial_margin_required < short_details.initial_margin_required,
            "Spread IM ({}) should be less than Naked Short IM ({})",
            spread_details.initial_margin_required,
            short_details.initial_margin_required
        );
    }

    /// PM Test: Empty portfolio with only cash should return Some with zero margin.
    ///
    /// Rationale: An account with just cash and no positions should still return
    /// a valid MarginDetails, but with zero margin requirements.
    #[tokio::test]
    async fn test_pm_empty_portfolio_returns_some_with_zero_margin() {
        let config = create_pm_test_config();
        let service = SpanMarginService::new_for_tests(config);

        let account = Account {
            id: test_wallet(106),
            portfolio: HashMap::new(),
            cash: 50_000.0,
            address: None,
        };

        let result = service.compute_margin_for_account(&account).await;

        assert!(result.is_ok(), "Empty portfolio should return Ok");

        let details = result.unwrap();
        assert_eq!(
            details.initial_margin_required,
            Decimal::ZERO,
            "Empty portfolio should have zero IM"
        );
        assert_eq!(
            details.equity,
            dec!(50000),
            "Equity should equal cash for empty portfolio"
        );
    }

    // =========================================================================
    // SPAN fail-closed behavior: unhealthy vol oracle rejects margin
    // =========================================================================

    /// A vol oracle that returns OK for some underlyings and Unhealthy for
    /// others, used to test the per-underlying fail-open behavior.
    struct PerUnderlyingTestOracle {
        healthy_iv: f64,
        unhealthy_underlyings: std::collections::HashSet<String>,
    }

    impl PerUnderlyingTestOracle {
        fn new(healthy_iv: f64, unhealthy: &[&str]) -> Self {
            Self {
                healthy_iv,
                unhealthy_underlyings: unhealthy.iter().map(|s| s.to_string()).collect(),
            }
        }
    }

    impl RiskVolOracle for PerUnderlyingTestOracle {
        fn get_iv(
            &self,
            underlying: &str,
            _strike: f64,
            _expiry_ts: i64,
        ) -> Result<f64, VolLookupError> {
            if self.unhealthy_underlyings.contains(underlying) {
                Err(VolLookupError::UnhealthyProvider {
                    underlying: underlying.to_string(),
                    provider: VolProviderKind::BlockScholes,
                    reason: "test: simulated unhealthy".to_string(),
                })
            } else {
                Ok(self.healthy_iv)
            }
        }

        fn statuses(&self) -> Vec<VolOracleStatus> {
            vec![]
        }
    }

    #[tokio::test]
    async fn test_span_rejects_when_any_underlying_unhealthy() {
        let oracle = Arc::new(PerUnderlyingTestOracle::new(0.80, &["GOLD"]));
        let service = SpanMarginService::new_with_vol_oracle(create_test_config(), oracle);

        let mut portfolio = HashMap::new();
        portfolio.insert(
            "BTC".to_string(),
            Position {
                spot: dec!(50000),
                delta: dec!(0),
                perp_unrealized_pnl: Decimal::ZERO,
                options: vec![OptionContract {
                    option_type: OptionType::Call,
                    strike: dec!(50000),
                    expiry_ts: TEST_EXPIRY_TS,
                    expiry: dec!(0.25),
                    quantity: dec!(-1),
                    entry_price: dec!(5000),
                }],
            },
        );
        portfolio.insert(
            "GOLD".to_string(),
            Position {
                spot: dec!(3000),
                delta: dec!(0),
                perp_unrealized_pnl: Decimal::ZERO,
                options: vec![OptionContract {
                    option_type: OptionType::Put,
                    strike: dec!(3000),
                    expiry_ts: TEST_EXPIRY_TS,
                    expiry: dec!(0.25),
                    quantity: dec!(-2),
                    entry_price: dec!(200),
                }],
            },
        );

        let account = Account {
            id: test_wallet(200),
            portfolio,
            cash: 100_000.0,
            address: None,
        };

        let result = service.compute_margin_for_account(&account).await;
        assert!(
            result.is_err(),
            "SPAN must fail when any underlying has unhealthy IV"
        );
    }

    #[tokio::test]
    async fn test_span_all_healthy_no_fallback_used() {
        let oracle = Arc::new(PerUnderlyingTestOracle::new(0.80, &[]));
        let service = SpanMarginService::new_with_vol_oracle(create_test_config(), oracle);

        let account = create_long_call_account(10_000.0, 50_000.0, 1.0);
        let result = service.compute_margin_for_account(&account).await;
        assert!(result.is_ok(), "All-healthy compute must succeed");
    }
}