hypercall/rsm/

margin_manager.rs

//! Margin checking logic for order admission.
//!
//! `MarginManager` owns the `SpanMarginService` and `StandardMarginService`,
//! and implements both Portfolio (SPAN) and Standard (Deribit-style) margin
//! checks. The engine delegates all margin decisions here.

use crate::portfolio::PortfolioBalance;
use crate::rsm::engine_deps::{engine_positions_to_portfolio_balance, EngineDeps, EnginePosition};
use crate::rsm::portfolio_margin::account_builder::{build_account_from_balance, expiry_to_years};
use hypercall_engine::contract_key;
use hypercall_engine::order_index::EngineOrderIndex;
use hypercall_types::api_models::Order as ApiOrder;

/// Position map type alias to keep method signatures readable.
pub type EnginePositionMap = HashMap<(WalletAddress, String), EnginePosition>;
use crate::rsm::margin_mode::MarginMode;
use crate::rsm::margin_service::SpanMarginService;
use crate::shared::order_types::{get_timestamp_millis, ParsedSymbol};
use crate::standard_margin::StandardMarginService;
use crate::types::{Account, MarginDetails, OptionContract, Position};
use crate::vol_oracle::SharedVolOracle;
use hypercall_engine::margin_admission::{
    decide_portfolio_margin, decide_standard_margin, MarginAdmissionDecision,
    PortfolioMarginAdmissionInput, StandardMarginAdmissionInput,
};
use hypercall_types::OrderInfo;
use hypercall_types::{to_contract_units_decimal, to_human_readable_decimal, Side, WalletAddress};
use rust_decimal::prelude::ToPrimitive;
use rust_decimal::Decimal;
use rust_decimal_macros::dec;
use std::collections::HashMap;
use tracing::{debug, info, warn};

/// Margin manager encapsulating SPAN and Standard margin services.
///
/// Methods borrow `&EngineDeps` for access to caches, portfolio service, etc.
pub struct MarginManager {
    /// SPAN scenario-based margin service (Portfolio mode).
    pub span_margin_service: SpanMarginService,
    /// Deribit-style linear margin service (Standard mode).
    pub standard_margin_service: StandardMarginService,
}

impl MarginManager {
    /// Create a new `MarginManager` from config.
    pub fn new(config: &crate::types::Config) -> Self {
        Self::new_with_vol_oracle(config, None)
    }

    pub fn new_with_vol_oracle(
        config: &crate::types::Config,
        vol_oracle: Option<SharedVolOracle>,
    ) -> Self {
        Self {
            span_margin_service: match vol_oracle {
                Some(oracle) => SpanMarginService::new_with_vol_oracle(config.clone(), oracle),
                None => SpanMarginService::new_fail_closed(config.clone()),
            },
            standard_margin_service: StandardMarginService::new(),
        }
    }

    // ===== Public entry point =====

    /// Unified margin check for both option and perp orders.
    ///
    /// Branches on margin mode:
    /// - Portfolio mode: SPAN-based scenario margin
    /// - Standard mode: Deribit-style linear margin
    pub fn check_margin_for_order(
        &self,
        deps: &EngineDeps,
        engine_positions: &EnginePositionMap,
        balance_ledger: &HashMap<WalletAddress, Decimal>,
        wallet: &WalletAddress,
        order_info: &OrderInfo,
        order_index: &EngineOrderIndex,
    ) -> Result<(), String> {
        let margin_mode = self.get_margin_mode(deps, wallet)?;

        debug!(
            "Unified margin check: Starting for wallet {} on symbol {} (mode: {:?})",
            wallet, order_info.symbol, margin_mode
        );

        match margin_mode {
            MarginMode::Portfolio => self.check_margin_portfolio(
                deps,
                engine_positions,
                balance_ledger,
                wallet,
                order_info,
                order_index,
            ),
            MarginMode::Standard => self.check_margin_standard(
                deps,
                engine_positions,
                balance_ledger,
                wallet,
                order_info,
                order_index,
            ),
        }
    }

    /// Margin check for a batch of orders that must be accepted or rejected
    /// together, e.g. a multi-leg RFQ where leg N-1 hedges leg N and the
    /// combination is healthy even though individual legs would not pass
    /// margin in isolation.
    ///
    /// Branches on the wallet's configured margin mode, matching the
    /// single-order admission path. RFQ is an immediately executed product,
    /// so the Standard path checks the post-execution account state rather
    /// than treating the proposed legs as resting open orders.
    pub fn check_margin_for_orders(
        &self,
        deps: &EngineDeps,
        engine_positions: &EnginePositionMap,
        balance_ledger: &HashMap<WalletAddress, Decimal>,
        wallet: &WalletAddress,
        proposed_orders: &[OrderInfo],
        order_index: &EngineOrderIndex,
    ) -> Result<(), String> {
        self.check_margin_for_orders_with_standard_short_bypass(
            deps,
            engine_positions,
            balance_ledger,
            wallet,
            proposed_orders,
            order_index,
            false,
        )
    }

    /// RFQ quote-provider margin check.
    ///
    /// The RFQ gateway only sends active registered quote providers to this
    /// engine path. Let those providers open Standard-margin shorts while
    /// keeping the normal Standard short ban for takers and orderbook orders.
    pub fn check_margin_for_quote_provider_orders(
        &self,
        deps: &EngineDeps,
        engine_positions: &EnginePositionMap,
        balance_ledger: &HashMap<WalletAddress, Decimal>,
        wallet: &WalletAddress,
        proposed_orders: &[OrderInfo],
        order_index: &EngineOrderIndex,
    ) -> Result<(), String> {
        self.check_margin_for_orders_with_standard_short_bypass(
            deps,
            engine_positions,
            balance_ledger,
            wallet,
            proposed_orders,
            order_index,
            true,
        )
    }

    fn check_margin_for_orders_with_standard_short_bypass(
        &self,
        deps: &EngineDeps,
        engine_positions: &EnginePositionMap,
        balance_ledger: &HashMap<WalletAddress, Decimal>,
        wallet: &WalletAddress,
        proposed_orders: &[OrderInfo],
        order_index: &EngineOrderIndex,
        allow_standard_short_bypass: bool,
    ) -> Result<(), String> {
        if proposed_orders.is_empty() {
            return Ok(());
        }

        let margin_mode = self.get_margin_mode(deps, wallet)?;

        debug!(
            "Unified multi-order margin check: Starting for wallet {} ({} legs, mode: {:?})",
            wallet,
            proposed_orders.len(),
            margin_mode
        );

        if matches!(margin_mode, MarginMode::Standard) {
            return self.check_margin_standard_for_orders(
                deps,
                engine_positions,
                balance_ledger,
                wallet,
                proposed_orders,
                order_index,
                allow_standard_short_bypass,
            );
        }

        let hypothetical_account = self.build_hypothetical_account_for_orders(
            deps,
            engine_positions,
            balance_ledger,
            wallet,
            proposed_orders,
            order_index,
        )?;

        let margin_result = self.run_margin_on_account_with_deps(&hypothetical_account, deps)?;

        match margin_result {
            None => {
                info!(
                    "Multi-order margin check: PASSED for wallet {} ({} proposed legs) — no margin details returned",
                    wallet,
                    proposed_orders.len()
                );
                Ok(())
            }
            Some(details) => {
                let available_collateral = details.equity;
                let margin_required = details.initial_margin_required;
                let excess_margin = available_collateral - margin_required;

                debug!(
                    "Multi-order margin check: wallet={}, legs={}, margin_required={:.2}, available={:.2}, excess={:.2}",
                    wallet,
                    proposed_orders.len(),
                    margin_required,
                    available_collateral,
                    excess_margin
                );

                if excess_margin < Decimal::ZERO {
                    let error_msg = format!(
                        "Insufficient margin across {} legs: required={:.2}, available={:.2}, shortfall={:.2}",
                        proposed_orders.len(),
                        margin_required,
                        available_collateral,
                        -excess_margin
                    );
                    warn!(
                        "Multi-order margin check: FAILED for wallet {} - {}",
                        wallet, error_msg
                    );
                    Err(error_msg)
                } else {
                    info!(
                        "Multi-order margin check: PASSED for wallet {} ({} legs) - excess_margin={:.2}",
                        wallet,
                        proposed_orders.len(),
                        excess_margin
                    );
                    Ok(())
                }
            }
        }
    }

    /// Get the margin mode for a wallet.
    pub fn get_margin_mode(
        &self,
        deps: &EngineDeps,
        wallet: &WalletAddress,
    ) -> Result<MarginMode, String> {
        if let Some(margin_mode) = deps.wallet_margin_modes.get(wallet).copied() {
            return Ok(margin_mode);
        }

        let Some(tier_cache) = deps.tier_cache.as_ref() else {
            return Ok(MarginMode::Standard);
        };

        tier_cache
            .get_margin_mode_sync(wallet)
            .map_err(|error| error.to_string())
    }

    // ===== Account building helpers =====

    /// Build a risk-ready Account from engine balances and positions.
    pub fn get_risk_account(
        &self,
        deps: &EngineDeps,
        engine_positions: &EnginePositionMap,
        balance_ledger: &HashMap<WalletAddress, Decimal>,
        wallet: &WalletAddress,
    ) -> Result<Account, String> {
        let mut balance =
            engine_positions_to_portfolio_balance(engine_positions, wallet, &deps.reference_prices);

        // Merge HyperCore perp positions into the balance so PM sees
        // the full cross-margined portfolio.
        let wallet_lower = wallet.to_string().to_lowercase();
        for ((account, coin), perp) in &deps.perp_positions {
            if account == &wallet_lower {
                let symbol = format!("{}-PERP", coin);
                if !balance.positions.contains_key(&symbol) && perp.size != 0.0 {
                    use crate::portfolio::PositionData;
                    let entry_price = perp.entry_price.ok_or_else(|| {
                        format!(
                            "Missing HyperCore entry price for {} {} - cannot build risk account",
                            wallet, symbol
                        )
                    })?;
                    balance.positions.insert(
                        symbol.clone(),
                        PositionData {
                            symbol,
                            amount: Decimal::try_from(perp.size).map_err(|_| {
                                format!(
                                    "Invalid HyperCore perp size for {} {}: {}",
                                    wallet, coin, perp.size
                                )
                            })?,
                            entry_price: Decimal::try_from(entry_price).map_err(|_| {
                                format!(
                                    "Invalid HyperCore entry price for {} {}: {}",
                                    wallet, coin, entry_price
                                )
                            })?,
                            margin_posted: dec!(0),
                            realized_pnl: dec!(0),
                            unrealized_pnl: Decimal::try_from(perp.unrealized_pnl).map_err(
                                |_| {
                                    format!(
                                        "Invalid HyperCore unrealized PnL for {} {}: {}",
                                        wallet, coin, perp.unrealized_pnl
                                    )
                                },
                            )?,
                        },
                    );
                }
            }
        }

        let spot_prices = self.build_spot_prices_for_balance(deps, &balance);
        let mut account = build_account_from_balance(wallet, &balance, Some(*wallet), &spot_prices)
            .map_err(|e| format!("Cannot build risk account for {}: {}", wallet, e))?;

        // For PM users, prefer HyperCore account equity (which includes perp UPNL).
        // Fall back to balance_ledger if no HyperCore equity is observed (faucet mode).
        let margin_mode = self.get_margin_mode(deps, wallet).ok();
        let (cash, using_hypercore_equity) = if margin_mode == Some(MarginMode::Portfolio) {
            if let Some(&hc_equity) = deps.hypercore_account_equity.get(wallet) {
                (hc_equity, true)
            } else {
                (
                    balance_ledger.get(wallet).copied().unwrap_or(Decimal::ZERO),
                    false,
                )
            }
        } else {
            (
                balance_ledger.get(wallet).copied().unwrap_or(Decimal::ZERO),
                false,
            )
        };

        // When using HyperCore equity, perp UPNL is already included in account_value.
        // Zero out perp_unrealized_pnl on all positions so SPAN equity formula
        // (cash + option_upnl + perp_upnl) does not double-count.
        if using_hypercore_equity {
            for position in account.portfolio.values_mut() {
                position.perp_unrealized_pnl = Decimal::ZERO;
            }
        }

        account.cash = cash
            .to_f64()
            .ok_or_else(|| format!("Engine balance ledger {} not representable as f64", cash))?;
        tracing::trace!(
            wallet = %wallet,
            cash = %cash,
            using_hypercore_equity = using_hypercore_equity,
            balance_wallet_count = balance_ledger.len(),
            engine_position_count = engine_positions.len(),
            "Built risk account cash"
        );

        Ok(account)
    }

    /// Build a risk account including open orders when PM is enabled.
    pub fn build_account_for_risk(
        &self,
        deps: &EngineDeps,
        engine_positions: &EnginePositionMap,
        _balance_ledger: &HashMap<WalletAddress, Decimal>,
        wallet: &WalletAddress,
    ) -> Result<Account, String> {
        let balance =
            engine_positions_to_portfolio_balance(engine_positions, wallet, &deps.reference_prices);

        let spot_prices = self.build_spot_prices_for_balance(deps, &balance);

        build_account_from_balance(wallet, &balance, Some(*wallet), &spot_prices)
            .map_err(|e| format!("Cannot build risk account for {}: {}", wallet, e))
    }

    /// Get SPAN margin details for a wallet's executed state.
    pub fn get_span_margin_for_wallet(
        &self,
        deps: &EngineDeps,
        engine_positions: &EnginePositionMap,
        balance_ledger: &HashMap<WalletAddress, Decimal>,
        wallet: &WalletAddress,
    ) -> Result<Option<MarginDetails>, String> {
        let account = self.get_risk_account(deps, engine_positions, balance_ledger, wallet)?;
        self.run_margin_on_account(&account)
    }

    // ===== Internal helpers =====

    /// Build spot prices map for a portfolio balance.
    fn build_spot_prices_for_balance(
        &self,
        deps: &EngineDeps,
        balance: &PortfolioBalance,
    ) -> HashMap<String, f64> {
        let mut spot_prices = HashMap::new();

        for symbol in balance.positions.keys() {
            let underlying = if symbol.ends_with("-PERP") {
                symbol.trim_end_matches("-PERP").to_string()
            } else if let Ok(parsed) = ParsedSymbol::from_symbol(symbol) {
                parsed.underlying
            } else {
                continue;
            };
            if spot_prices.contains_key(&underlying) {
                continue;
            }
            if let Some(&price) = deps.reference_prices.get(&underlying) {
                spot_prices.insert(underlying, price);
            }
        }

        spot_prices
    }

    /// Get spot price for an underlying, returning an error if unavailable.
    pub fn get_spot_price_for_margin(
        &self,
        deps: &EngineDeps,
        underlying: &str,
    ) -> Result<f64, String> {
        if let Some(&price) = deps.reference_prices.get(underlying) {
            return Ok(price);
        }
        Err(format!(
            "No spot price available for {} - no PriceUpdate command received yet",
            underlying
        ))
    }

    /// Fetch all open orders for a wallet from the in-process order index.
    pub fn fetch_open_orders(
        &self,
        order_index: &EngineOrderIndex,
        wallet: &WalletAddress,
    ) -> Vec<ApiOrder> {
        let summaries = order_index.get_all_orders_for_wallet(wallet);

        let all_orders: Vec<ApiOrder> = summaries
            .into_iter()
            .map(|s| {
                let timestamp = get_timestamp_millis();
                ApiOrder {
                    order_id: s.order_id as i64,
                    wallet_address: *wallet,
                    symbol: s.symbol.clone(),
                    side: format!("{:?}", s.side),
                    price: s.price,
                    size: s.remaining_size,
                    tif: "gtc".to_string(),
                    status: Some("open".to_string()),
                    created_at: timestamp as i64,
                    updated_at: None,
                    filled_size: Some(s.original_size - s.remaining_size),
                    mmp_enabled: s.mmp_enabled,
                }
            })
            .collect();

        debug!(
            "Fetched {} open orders for wallet {}",
            all_orders.len(),
            wallet
        );

        all_orders
    }

    /// Create a simulated order from OrderInfo for margin checking.
    pub fn create_simulated_order(
        &self,
        order_info: &OrderInfo,
        wallet: &WalletAddress,
    ) -> ApiOrder {
        let timestamp = get_timestamp_millis();
        ApiOrder {
            order_id: 0,
            wallet_address: *wallet,
            symbol: order_info.symbol.clone(),
            side: format!("{:?}", order_info.side),
            price: order_info.price,
            size: to_human_readable_decimal(&order_info.symbol, order_info.size),
            tif: format!("{:?}", order_info.tif).to_lowercase(),
            status: Some("simulated".to_string()),
            created_at: timestamp as i64,
            updated_at: None,
            filled_size: Some(dec!(0)),
            mmp_enabled: order_info.mmp_enabled,
        }
    }

    // ===== Portfolio (SPAN) margin =====

    /// Portfolio margin check using SPAN scenarios.
    fn check_margin_portfolio(
        &self,
        deps: &EngineDeps,
        engine_positions: &EnginePositionMap,
        balance_ledger: &HashMap<WalletAddress, Decimal>,
        wallet: &WalletAddress,
        order_info: &OrderInfo,
        order_index: &EngineOrderIndex,
    ) -> Result<(), String> {
        let is_reduce_only = order_info.reduce_only == Some(true);
        let hypothetical_account = self.build_hypothetical_account_for_order(
            deps,
            engine_positions,
            balance_ledger,
            wallet,
            order_info,
            order_index,
        )?;

        let margin_result = self.run_margin_on_account_with_deps(&hypothetical_account, deps)?;

        match margin_result {
            None => {
                info!(
                    "Portfolio margin check: PASSED for wallet {} - no margin details returned",
                    wallet
                );
                Ok(())
            }
            Some(details) => {
                let available_collateral = details.equity;
                let margin_required = details.initial_margin_required;
                let expected_initial_margin =
                    details.scanning_risk.max(details.option_floor) + details.gamma_overlay;

                debug_assert!(
                    (details.initial_margin_required - expected_initial_margin).abs()
                        < dec!(0.000000001),
                    "IM ({}) should equal max(scanning_risk={}, option_floor={}) + gamma_overlay={}",
                    details.initial_margin_required,
                    details.scanning_risk,
                    details.option_floor,
                    details.gamma_overlay
                );
                debug!(
                    "Portfolio margin check: equity={}, cash={}, mtm={}",
                    details.equity, hypothetical_account.cash, details.net_option_value
                );

                let excess_margin = available_collateral - margin_required;

                debug!(
                    "Portfolio margin check: wallet={}, margin_required={:.2}, available={:.2}, excess={:.2}",
                    wallet, margin_required, available_collateral, excess_margin
                );

                let decision = decide_portfolio_margin(PortfolioMarginAdmissionInput {
                    is_reduce_only,
                    available_collateral,
                    margin_required,
                    settlement_context: None,
                });

                if matches!(decision, MarginAdmissionDecision::Accepted) && is_reduce_only {
                    info!(
                        "Portfolio margin check: PASSED for wallet {} - aggregate reduce-only order allowed",
                        wallet
                    );
                    return Ok(());
                }

                if let MarginAdmissionDecision::Rejected(error_msg) = decision {
                    warn!(
                        "Portfolio margin check: FAILED for wallet {} - {}",
                        wallet, error_msg
                    );
                    Err(error_msg)
                } else {
                    info!(
                        "Portfolio margin check: PASSED for wallet {} - excess_margin={:.2}",
                        wallet, excess_margin
                    );
                    Ok(())
                }
            }
        }
    }

    // ===== Standard margin =====

    /// Standard margin check using Deribit-style linear margin.
    fn check_margin_standard(
        &self,
        deps: &EngineDeps,
        engine_positions: &EnginePositionMap,
        balance_ledger: &HashMap<WalletAddress, Decimal>,
        wallet: &WalletAddress,
        order_info: &OrderInfo,
        order_index: &EngineOrderIndex,
    ) -> Result<(), String> {
        if !deps.config.allow_standard_margin_shorts {
            self.reject_standard_net_short_order(
                engine_positions,
                wallet,
                order_info,
                order_index,
            )?;
        }

        let mut account =
            match crate::standard_margin::StandardAccountBuilder::build_from_engine_state(
                wallet,
                balance_ledger,
                engine_positions,
                &deps.reference_prices,
            ) {
                Ok(a) => a,
                Err(e) => {
                    debug!(
                    "StandardAccountBuilder::build_from_engine_state failed for {}: {}, falling back to portfolio margin",
                    wallet, e
                );
                    return self.check_margin_portfolio(
                        deps,
                        engine_positions,
                        balance_ledger,
                        wallet,
                        order_info,
                        order_index,
                    );
                }
            };

        let wallet_lower = wallet.to_string().to_lowercase();
        for ((account_addr, coin), perp) in &deps.perp_positions {
            if account_addr != &wallet_lower || perp.size == 0.0 {
                continue;
            }
            let symbol = format!("{}-PERP", coin);
            if account.perp_positions.iter().any(|p| p.symbol == symbol) {
                continue;
            }
            let entry_price = perp.entry_price.ok_or_else(|| {
                format!(
                    "Missing HyperCore entry price for {} {} - cannot check standard margin",
                    wallet, symbol
                )
            })?;
            let size = Decimal::try_from(perp.size).map_err(|_| {
                format!(
                    "Invalid HyperCore perp size for {} {}: {}",
                    wallet, coin, perp.size
                )
            })?;
            let entry_price_decimal = Decimal::try_from(entry_price).map_err(|_| {
                format!(
                    "Invalid HyperCore entry price for {} {}: {}",
                    wallet, coin, entry_price
                )
            })?;
            let mark_price = Decimal::try_from(entry_price + perp.unrealized_pnl / perp.size)
                .map_err(|_| {
                    format!(
                        "Invalid HyperCore mark price for {} {} from entry={} pnl={} size={}",
                        wallet, coin, entry_price, perp.unrealized_pnl, perp.size
                    )
                })?;
            account
                .perp_positions
                .push(hypercall_margin::standard::PerpPosition {
                    symbol,
                    underlying: coin.clone(),
                    size,
                    mark_price,
                    entry_price: entry_price_decimal,
                });
        }

        let is_option = ParsedSymbol::from_symbol(&order_info.symbol).is_ok();
        let order_quantity = to_human_readable_decimal(&order_info.symbol, order_info.size);
        let is_risk_increasing = self.standard_margin_service.is_risk_increasing(
            &account,
            &order_info.symbol,
            matches!(order_info.side, Side::Buy),
            order_quantity,
            is_option,
        );
        let is_reduce_only = order_info.reduce_only == Some(true);
        let requested_premium = if is_option && matches!(order_info.side, Side::Buy) {
            order_info.price * order_quantity
        } else {
            dec!(0)
        };
        let proposed_premium = if is_reduce_only {
            dec!(0)
        } else if matches!(order_info.side, Side::Buy) {
            // Pro-rate: only reserve premium for the portion that exceeds
            // an existing short position on the same symbol.
            let short_qty = engine_positions
                .get(&(*wallet, order_info.symbol.clone()))
                .map(|p| {
                    if p.quantity < dec!(0) {
                        -p.quantity
                    } else {
                        dec!(0)
                    }
                })
                .unwrap_or(dec!(0));
            let opening_qty = (order_quantity - short_qty).max(dec!(0));
            order_info.price * opening_qty
        } else {
            requested_premium
        };

        let existing_reserved_premium =
            order_index.calculate_open_buy_premium(wallet, engine_positions);

        let total_reserved_premium = existing_reserved_premium + proposed_premium;

        let mut account_with_existing_open_orders = account.clone();
        account_with_existing_open_orders.usdc_balance -= existing_reserved_premium;

        self.add_open_sell_orders_to_standard_account(
            deps,
            &mut account_with_existing_open_orders,
            wallet,
            order_index,
        )?;

        let base_result = self.standard_margin_service.compute_margin(&account);
        let existing_open_orders_result = self
            .standard_margin_service
            .compute_margin(&account_with_existing_open_orders);
        let current_open_orders_im =
            (existing_open_orders_result.position_im - base_result.position_im).max(dec!(0));

        let mut post_trade_account = account_with_existing_open_orders.clone();
        post_trade_account.usdc_balance -= proposed_premium;

        if is_option && matches!(order_info.side, Side::Sell) {
            if let Ok(parsed) = ParsedSymbol::from_symbol(&order_info.symbol) {
                let qty = to_human_readable_decimal(&order_info.symbol, order_info.size);
                let spot_price_f64 = self
                    .get_spot_price_for_margin(deps, &parsed.underlying)
                    .map_err(|e| {
                        format!(
                            "Cannot check margin for sell order on {}: {}",
                            order_info.symbol, e
                        )
                    })?;
                let spot_price = Decimal::from_f64_retain(spot_price_f64).ok_or_else(|| {
                    format!(
                        "Invalid spot price for {}: {} - cannot convert to Decimal",
                        parsed.underlying, spot_price_f64
                    )
                })?;
                let expiry_ts = expiry_date_to_timestamp(&parsed.underlying, parsed.expiry) as i64;
                if expiry_ts <= 0 {
                    return Err(format!(
                        "invalid expiry in order symbol {} - cannot compute standard margin safely",
                        order_info.symbol
                    ));
                }

                let hypothetical_position = hypercall_margin::standard::OptionPosition {
                    symbol: order_info.symbol.clone(),
                    underlying: parsed.underlying.clone(),
                    expiry_ts,
                    strike: parsed.strike,
                    is_call: matches!(parsed.option_type, crate::types::OptionType::Call),
                    size: -qty,
                    mark_price: order_info.price,
                    entry_price: order_info.price,
                    spot_price,
                };
                post_trade_account
                    .option_positions
                    .push(hypothetical_position);
            }
        }

        if order_info.is_perp {
            let underlying = order_info
                .underlying
                .clone()
                .unwrap_or_else(|| order_info.symbol.replace("-PERP", ""));

            let size = to_human_readable_decimal(&order_info.symbol, order_info.size);
            let signed_size = if matches!(order_info.side, Side::Buy) {
                size
            } else {
                -size
            };

            let hypothetical_perp = hypercall_margin::standard::PerpPosition {
                symbol: order_info.symbol.clone(),
                underlying,
                size: signed_size,
                mark_price: order_info.price,
                entry_price: order_info.price,
            };
            post_trade_account.perp_positions.push(hypothetical_perp);
        }

        debug!(
            "Standard margin check: wallet={}, existing_reserved={:.2}, requested_premium={:.2}, reserved_proposed_premium={:.2}, adjusted_balance={:.2}, option_positions={}, perp_positions={}, reduce_only={}, risk_increasing={}",
            wallet,
            existing_reserved_premium,
            requested_premium,
            proposed_premium,
            post_trade_account.usdc_balance,
            post_trade_account.option_positions.len(),
            post_trade_account.perp_positions.len(),
            is_reduce_only,
            is_risk_increasing
        );

        let hypothetical_result = self
            .standard_margin_service
            .compute_margin(&post_trade_account);

        let post_accept_open_orders_im =
            (hypothetical_result.position_im - base_result.position_im).max(dec!(0));
        let incremental_open_orders_im = post_accept_open_orders_im - current_open_orders_im;

        let result = hypothetical_result;

        debug!(
            "Standard margin check: wallet={}, equity={}, position_im={}, current_open_orders_im={}, incremental_open_orders_im={}, post_accept_open_orders_im={}, total_im={}, reduce_only={}, risk_increasing={}",
            wallet,
            result.equity,
            base_result.position_im,
            current_open_orders_im,
            incremental_open_orders_im,
            post_accept_open_orders_im,
            result.position_im,
            is_reduce_only,
            is_risk_increasing
        );

        let is_closing_position = !is_risk_increasing
            && account
                .option_positions
                .iter()
                .any(|p| p.symbol == order_info.symbol && p.size.abs() > dec!(0))
            || !is_risk_increasing
                && account
                    .perp_positions
                    .iter()
                    .any(|p| p.symbol == order_info.symbol && p.size.abs() > dec!(0));

        let is_premium_debiting_buy = is_option && matches!(order_info.side, Side::Buy);
        let decision = decide_standard_margin(StandardMarginAdmissionInput {
            is_reduce_only,
            is_closing_position,
            is_premium_debiting_buy,
            equity: result.equity,
            post_balance: post_trade_account.usdc_balance,
            total_reserved_premium,
            initial_margin: result.initial_margin,
            position_im: base_result.position_im,
            current_open_orders_im,
            incremental_open_orders_im,
            post_accept_open_orders_im,
        });

        if matches!(decision, MarginAdmissionDecision::Accepted)
            && (is_reduce_only || is_closing_position)
        {
            info!(
                "Standard margin check: PASSED for wallet {} - {} (equity={:.2})",
                wallet,
                if is_reduce_only {
                    "reduce-only flag"
                } else {
                    "closing position"
                },
                result.equity
            );
            return Ok(());
        }

        if let MarginAdmissionDecision::Rejected(error_msg) = decision {
            warn!(
                "Standard margin check: FAILED for wallet {} - {}",
                wallet, error_msg
            );
            return Err(error_msg);
        }

        info!(
            "Standard margin check: PASSED for wallet {} - initial_margin={:.2}",
            wallet, result.initial_margin
        );
        Ok(())
    }

    fn check_margin_standard_for_orders(
        &self,
        deps: &EngineDeps,
        engine_positions: &EnginePositionMap,
        balance_ledger: &HashMap<WalletAddress, Decimal>,
        wallet: &WalletAddress,
        proposed_orders: &[OrderInfo],
        order_index: &EngineOrderIndex,
        allow_standard_short_bypass: bool,
    ) -> Result<(), String> {
        if !allow_standard_short_bypass && !deps.config.allow_standard_margin_shorts {
            self.reject_standard_net_short_orders(
                engine_positions,
                wallet,
                proposed_orders,
                order_index,
            )?;
        }

        let mut simulated_positions = engine_positions.clone();
        let mut simulated_cash = balance_ledger.clone();
        let mut wallet_cash = simulated_cash.get(wallet).copied().unwrap_or(Decimal::ZERO);
        let mut signed_premium = dec!(0);

        for order_info in proposed_orders {
            let order_quantity = to_human_readable_decimal(&order_info.symbol, order_info.size);
            if order_quantity <= dec!(0) {
                return Err(format!(
                    "Invalid RFQ margin quantity {} for {}",
                    order_quantity, order_info.symbol
                ));
            }

            let is_option = ParsedSymbol::from_symbol(&order_info.symbol).is_ok();
            let signed_size = if matches!(order_info.side, Side::Buy) {
                order_quantity
            } else {
                -order_quantity
            };

            crate::rsm::engine_deps::apply_fill_to_positions(
                &mut simulated_positions,
                *wallet,
                order_info.symbol.clone(),
                signed_size,
                order_info.price,
            );

            if is_option {
                let premium = order_info.price * order_quantity;
                if matches!(order_info.side, Side::Buy) {
                    wallet_cash -= premium;
                    signed_premium -= premium;
                } else {
                    wallet_cash += premium;
                    signed_premium += premium;
                }
            }
        }
        simulated_cash.insert(*wallet, wallet_cash);

        let account = crate::standard_margin::StandardAccountBuilder::build_from_engine_state(
            wallet,
            &simulated_cash,
            &simulated_positions,
            &deps.reference_prices,
        )
        .map_err(|e| {
            format!(
                "Cannot build standard margin account after RFQ fills for {}: {}",
                wallet, e
            )
        })?;

        let existing_reserved_premium =
            order_index.calculate_open_buy_premium(wallet, &simulated_positions);
        let mut account_with_open_orders = account.clone();
        account_with_open_orders.usdc_balance -= existing_reserved_premium;
        self.add_open_sell_orders_to_standard_account(
            deps,
            &mut account_with_open_orders,
            wallet,
            order_index,
        )?;

        let result = self
            .standard_margin_service
            .compute_margin(&account_with_open_orders);

        debug!(
            "Standard multi-order margin check: wallet={}, legs={}, signed_premium={:.2}, reserved_open_buy_premium={:.2}, post_cash={:.2}, equity={:.2}, position_im={:.2}, initial_margin={:.2}",
            wallet,
            proposed_orders.len(),
            signed_premium,
            existing_reserved_premium,
            account_with_open_orders.usdc_balance,
            result.equity,
            result.position_im,
            result.initial_margin
        );

        if result.equity < dec!(0) {
            let error_msg = format!(
                "Insufficient funds (Standard): post-trade equity is negative. \
                equity={:.2}, signed_premium={:.2}, shortfall={:.2}",
                result.equity, signed_premium, -result.equity
            );
            warn!(
                "Standard multi-order margin check: FAILED for wallet {} - {}",
                wallet, error_msg
            );
            return Err(error_msg);
        }

        if result.initial_margin < dec!(0) {
            let error_msg = format!(
                "Insufficient margin (Standard): equity={:.2}, position_im={:.2}, reserved_open_buy_premium={:.2}, shortfall={:.2}",
                result.equity,
                result.position_im,
                existing_reserved_premium,
                -result.initial_margin
            );
            warn!(
                "Standard multi-order margin check: FAILED for wallet {} - {}",
                wallet, error_msg
            );
            Err(error_msg)
        } else {
            info!(
                "Standard multi-order margin check: PASSED for wallet {} - initial_margin={:.2}",
                wallet, result.initial_margin
            );
            Ok(())
        }
    }

    fn reject_standard_net_short_order(
        &self,
        engine_positions: &EnginePositionMap,
        wallet: &WalletAddress,
        order_info: &OrderInfo,
        order_index: &EngineOrderIndex,
    ) -> Result<(), String> {
        self.reject_standard_net_short_orders(
            engine_positions,
            wallet,
            std::slice::from_ref(order_info),
            order_index,
        )
    }

    fn reject_standard_net_short_orders(
        &self,
        engine_positions: &EnginePositionMap,
        wallet: &WalletAddress,
        proposed_orders: &[OrderInfo],
        order_index: &EngineOrderIndex,
    ) -> Result<(), String> {
        let mut proposed_net_by_contract: HashMap<String, Decimal> = HashMap::new();

        for order_info in proposed_orders {
            let Some(key) = contract_key(&order_info.symbol) else {
                continue;
            };
            if order_info.is_perp {
                continue;
            }

            let quantity = to_human_readable_decimal(&order_info.symbol, order_info.size);
            if quantity <= dec!(0) {
                return Err(format!(
                    "Invalid Standard margin option quantity {} for {}",
                    quantity, order_info.symbol
                ));
            }

            let signed_quantity = if matches!(order_info.side, Side::Buy) {
                quantity
            } else {
                -quantity
            };
            *proposed_net_by_contract.entry(key).or_insert(dec!(0)) += signed_quantity;
        }

        for (contract, proposed_net) in proposed_net_by_contract {
            let current_position = engine_positions
                .iter()
                .filter(|((position_wallet, position_symbol), _)| {
                    position_wallet == wallet
                        && contract_key(position_symbol).as_deref() == Some(contract.as_str())
                })
                .map(|(_, position)| position.quantity)
                .sum::<Decimal>();
            let open_sell_quantity = order_index.get_open_sells_for_contract(wallet, &contract);
            let pre_order_available_long = current_position - open_sell_quantity;
            let post_order_available_long = pre_order_available_long + proposed_net;

            if post_order_available_long < dec!(0)
                && post_order_available_long < pre_order_available_long
            {
                return Err(format!(
                    "Standard margin accounts cannot increase net short options. symbol={}, current_position={}, proposed_net={}, open_sell_orders={}, shortfall={}",
                    contract,
                    current_position,
                    proposed_net,
                    open_sell_quantity,
                    -post_order_available_long
                ));
            }
        }

        Ok(())
    }

    fn add_open_sell_orders_to_standard_account(
        &self,
        deps: &EngineDeps,
        account: &mut hypercall_margin::standard::StandardAccount,
        wallet: &WalletAddress,
        order_index: &EngineOrderIndex,
    ) -> Result<(), String> {
        let open_sell_positions = order_index.get_open_sell_option_positions(wallet);
        for mut pos in open_sell_positions {
            if pos.position.spot_price == dec!(0) {
                let spot_f64 = self
                    .get_spot_price_for_margin(deps, &pos.position.underlying)
                    .map_err(|e| {
                        format!(
                            "Cannot check margin for open sell order on {}: {}",
                            pos.position.symbol, e
                        )
                    })?;
                pos.position.spot_price = Decimal::from_f64_retain(spot_f64).ok_or_else(|| {
                    format!(
                        "Invalid spot price for {}: {} - cannot convert to Decimal",
                        pos.position.underlying, spot_f64
                    )
                })?;
            }
            account.option_positions.push(pos.position);
        }
        Ok(())
    }

    // ===== Hypothetical account building =====

    /// Build a hypothetical Account representing the state if every
    /// `proposed_order` fills on top of the wallet's current executed
    /// state plus its existing open orders. Used by
    /// `check_margin_for_orders` to score multi-leg RFQ commands as a
    /// single portfolio snapshot.
    fn build_hypothetical_account_for_orders(
        &self,
        deps: &EngineDeps,
        engine_positions: &EnginePositionMap,
        balance_ledger: &HashMap<WalletAddress, Decimal>,
        wallet: &WalletAddress,
        proposed_orders: &[OrderInfo],
        order_index: &EngineOrderIndex,
    ) -> Result<Account, String> {
        let mut account = self.get_risk_account(deps, engine_positions, balance_ledger, wallet)?;

        let open_orders = self.fetch_open_orders(order_index, wallet);
        let mut all_orders = open_orders;
        for order_info in proposed_orders {
            all_orders.push(self.create_simulated_order(order_info, wallet));
        }

        let mut spot_prices: HashMap<String, f64> = HashMap::new();
        for order in &all_orders {
            let underlying = if let Ok(parsed) = ParsedSymbol::from_symbol(&order.symbol) {
                parsed.underlying.clone()
            } else {
                perp_underlying(&order.symbol)
                    .ok_or_else(|| {
                        format!(
                            "Unsupported non-option order symbol {} in hypothetical margin simulation",
                            order.symbol
                        )
                    })?
                    .to_string()
            };

            if !spot_prices.contains_key(&underlying) {
                let price = self.get_spot_price_for_margin(deps, &underlying)?;
                spot_prices.insert(underlying.clone(), price);
            }
        }

        debug!(
            "build_hypothetical_account_for_orders: wallet={}, executed_positions={}, \
             open_orders+proposed={}, proposed_legs={}, spot_prices={:?}",
            wallet,
            account.portfolio.len(),
            all_orders.len(),
            proposed_orders.len(),
            spot_prices
        );

        for order in &all_orders {
            self.apply_order_to_account(deps, &mut account, order, &spot_prices)?;
        }

        Ok(account)
    }

    /// Build a hypothetical Account representing the state if the proposed order fills.
    fn build_hypothetical_account_for_order(
        &self,
        deps: &EngineDeps,
        engine_positions: &EnginePositionMap,
        balance_ledger: &HashMap<WalletAddress, Decimal>,
        wallet: &WalletAddress,
        order_info: &OrderInfo,
        order_index: &EngineOrderIndex,
    ) -> Result<Account, String> {
        let mut account = self.get_risk_account(deps, engine_positions, balance_ledger, wallet)?;

        let open_orders = self.fetch_open_orders(order_index, wallet);
        let simulated_order = self.create_simulated_order(order_info, wallet);

        let mut all_orders = open_orders;
        all_orders.push(simulated_order);

        let mut spot_prices: HashMap<String, f64> = HashMap::new();
        for order in &all_orders {
            let underlying = if let Ok(parsed) = ParsedSymbol::from_symbol(&order.symbol) {
                parsed.underlying.clone()
            } else {
                perp_underlying(&order.symbol)
                    .ok_or_else(|| {
                        format!(
                            "Unsupported non-option order symbol {} in hypothetical margin simulation",
                            order.symbol
                        )
                    })?
                    .to_string()
            };

            if !spot_prices.contains_key(&underlying) {
                let price = self.get_spot_price_for_margin(deps, &underlying)?;
                spot_prices.insert(underlying.clone(), price);
            }
        }

        debug!(
            "build_hypothetical_account: wallet={}, executed_positions={}, open_orders={}, spot_prices={:?}",
            wallet,
            account.portfolio.len(),
            all_orders.len(),
            spot_prices
        );

        for order in &all_orders {
            self.apply_order_to_account(deps, &mut account, order, &spot_prices)?;
        }

        debug!(
            "build_hypothetical_account: final portfolio has {} positions, cash={}",
            account.portfolio.len(),
            account.cash
        );

        for (underlying, position) in &account.portfolio {
            debug!(
                "build_hypothetical_account: underlying={}, spot={}, delta={}, options={}",
                underlying,
                position.spot,
                position.delta,
                position.options.len()
            );
            for option in &position.options {
                debug!(
                    "  option: type={:?}, strike={}, expiry={:.4}, qty={}, entry={}",
                    option.option_type,
                    option.strike,
                    option.expiry,
                    option.quantity,
                    option.entry_price
                );
            }
        }

        Ok(account)
    }

    /// Apply an order as a hypothetical fill to an account's portfolio.
    fn apply_order_to_account(
        &self,
        deps: &EngineDeps,
        account: &mut Account,
        order: &ApiOrder,
        spot_prices: &HashMap<String, f64>,
    ) -> Result<(), String> {
        let remaining_size = order.size - order.filled_size.unwrap_or(dec!(0));
        if remaining_size <= dec!(0) {
            return Ok(());
        }
        let remaining_size_u64 = to_contract_units_decimal(&order.symbol, remaining_size);

        if let Ok(parsed) = ParsedSymbol::from_symbol(&order.symbol) {
            let spot_price = spot_prices
                .get(&parsed.underlying)
                .copied()
                .or_else(|| {
                    account
                        .portfolio
                        .get(&parsed.underlying)
                        .and_then(|position| position.spot.to_f64())
                })
                .or_else(|| deps.reference_prices.get(&parsed.underlying).copied());
            let spot_price = match spot_price {
                Some(spot_price) => spot_price,
                None => self
                    .get_spot_price_for_margin(deps, &parsed.underlying)
                    .map_err(|error| {
                        format!(
                            "Missing spot price for underlying {} (symbol: {}): {}",
                            parsed.underlying, order.symbol, error
                        )
                    })?,
            };

            let position = account
                .portfolio
                .entry(parsed.underlying.clone())
                .or_insert_with(|| Position {
                    spot: Decimal::from_f64_retain(spot_price).unwrap_or_else(|| {
                        panic!(
                            "STATE_CORRUPTION: validated option spot price {} for {} is not representable as Decimal",
                            spot_price, parsed.underlying
                        )
                    }),
                    delta: Decimal::ZERO,
                    perp_unrealized_pnl: Decimal::ZERO,
                    options: Vec::new(),
                });

            let size_in_units_decimal =
                to_human_readable_decimal(&order.symbol, remaining_size_u64);

            let quantity_change = match order.side.as_str() {
                "Buy" => size_in_units_decimal,
                "Sell" => -size_in_units_decimal,
                _ => {
                    panic!(
                        "STATE_CORRUPTION: Unknown order side '{}' for order on symbol {}. \
                         Invalid order state - margin calculation cannot proceed safely. Restart required.",
                        order.side, order.symbol
                    );
                }
            };

            let expiry_years = expiry_to_years(&parsed.underlying, parsed.expiry);
            let strike_f64 = parsed.strike.to_f64().ok_or_else(|| {
                format!(
                    "invalid strike in order symbol {} - cannot compute margin safely",
                    order.symbol
                )
            })?;
            let expiry_ts = expiry_date_to_timestamp(&parsed.underlying, parsed.expiry) as i64;
            if expiry_ts <= 0 {
                return Err(format!(
                    "invalid expiry in order symbol {} - cannot compute margin safely",
                    order.symbol
                ));
            }
            let theoretical_price = crate::rsm::black_scholes::black_scholes_with_moments(
                &parsed.option_type,
                spot_price,
                strike_f64,
                expiry_years,
                0.05,
                0.50,
                0.0,
                0.0,
            );

            position.options.push(OptionContract {
                option_type: parsed.option_type.clone(),
                strike: parsed.strike,
                expiry_ts,
                expiry: Decimal::from_f64_retain(expiry_years).unwrap_or_else(|| {
                    panic!(
                        "STATE_CORRUPTION: validated option expiry {} for {} is not representable as Decimal",
                        expiry_years, order.symbol
                    )
                }),
                quantity: quantity_change,
                entry_price: Decimal::from_f64_retain(theoretical_price).unwrap_or_else(|| {
                    panic!(
                        "STATE_CORRUPTION: theoretical option price {} for {} is not representable as Decimal",
                        theoretical_price, order.symbol
                    )
                }),
            });
        } else {
            let underlying = perp_underlying(&order.symbol)
                .ok_or_else(|| {
                    format!(
                        "Unsupported non-option order symbol {} in hypothetical margin simulation",
                        order.symbol
                    )
                })?
                .to_string();
            let spot_price = spot_prices
                .get(&underlying)
                .copied()
                .or_else(|| {
                    account
                        .portfolio
                        .get(&underlying)
                        .and_then(|position| position.spot.to_f64())
                })
                .or_else(|| deps.reference_prices.get(&underlying).copied());
            let spot_price = match spot_price {
                Some(spot_price) => spot_price,
                None => self
                    .get_spot_price_for_margin(deps, &underlying)
                    .map_err(|error| {
                        format!(
                            "Missing spot price for perp underlying {} (symbol: {}): {}",
                            underlying, order.symbol, error
                        )
                    })?,
            };

            let position = account
                .portfolio
                .entry(underlying.clone())
                .or_insert_with(|| Position {
                    spot: Decimal::from_f64_retain(spot_price).unwrap_or_else(|| {
                        panic!(
                            "STATE_CORRUPTION: validated perp spot price {} for {} is not representable as Decimal",
                            spot_price, underlying
                        )
                    }),
                    delta: Decimal::ZERO,
                    perp_unrealized_pnl: Decimal::ZERO,
                    options: Vec::new(),
                });

            let size_in_units_decimal =
                to_human_readable_decimal(&order.symbol, remaining_size_u64);
            let delta_change = match order.side.as_str() {
                "Buy" => size_in_units_decimal,
                "Sell" => -size_in_units_decimal,
                _ => {
                    panic!(
                        "STATE_CORRUPTION: Unknown order side '{}' for perp order on symbol {}. \
                         Invalid order state - margin calculation cannot proceed safely. Restart required.",
                        order.side, order.symbol
                    );
                }
            };

            position.delta += delta_change;
        }

        Ok(())
    }

    /// Run margin calculation on an Account using the MarginService.
    pub fn run_margin_on_account(
        &self,
        account: &Account,
    ) -> Result<Option<MarginDetails>, String> {
        self.run_margin_on_account_at(account, chrono::Utc::now().timestamp())
    }

    pub fn run_margin_on_account_with_deps(
        &self,
        account: &Account,
        deps: &EngineDeps,
    ) -> Result<Option<MarginDetails>, String> {
        self.run_margin_on_account_at(account, deps.margin_timestamp_s)
    }

    fn run_margin_on_account_at(
        &self,
        account: &Account,
        now_ts: i64,
    ) -> Result<Option<MarginDetails>, String> {
        let margin_details = self
            .span_margin_service
            .compute_margin_for_account_at(account, now_ts)
            .map_err(|e| e.to_string())?;

        debug!(
            "run_margin_on_account: account={}, equity={:.2}, IM={:.2}, scanning_risk={:.2}",
            account.id,
            margin_details.equity,
            margin_details.initial_margin_required,
            margin_details.scanning_risk
        );

        Ok(Some(margin_details))
    }

    /// Check tier restrictions (tier1 can only go long).
    pub fn check_tier_restrictions(
        &self,
        deps: &EngineDeps,
        engine_positions: &EnginePositionMap,
        balance_ledger: &HashMap<WalletAddress, Decimal>,
        wallet: &WalletAddress,
        order_info: &OrderInfo,
        order_index: &EngineOrderIndex,
    ) -> Result<(), String> {
        if order_info.is_perp {
            return Ok(());
        }

        let tier_owned = deps
            .wallet_tiers
            .get(wallet)
            .cloned()
            .unwrap_or_else(|| "tier2".to_string());
        let tier = tier_owned.as_str();

        if tier == "tier2" || tier == "market_maker" {
            return Ok(());
        }

        match order_info.side {
            Side::Buy => Ok(()),
            Side::Sell => {
                let parsed = ParsedSymbol::from_symbol(&order_info.symbol)
                    .map_err(|e| format!("Failed to parse symbol: {}", e))?;

                let account =
                    self.get_risk_account(deps, engine_positions, balance_ledger, wallet)?;
                let position = account.portfolio.get(&parsed.underlying);

                let mut filled_long_position = dec!(0);
                if let Some(pos) = position {
                    let target_expiry_ts = hypercall_types::expiry_date_to_timestamp(
                        &parsed.underlying,
                        parsed.expiry,
                    ) as i64;
                    if target_expiry_ts <= 0 {
                        return Err(format!(
                            "Invalid expiry in order symbol: {}",
                            order_info.symbol
                        ));
                    }
                    for option_contract in &pos.options {
                        if option_contract.option_type == parsed.option_type
                            && (option_contract.strike - parsed.strike).abs() < dec!(0.01)
                            && option_contract.expiry_ts == target_expiry_ts
                            && option_contract.quantity > Decimal::ZERO
                        {
                            filled_long_position += option_contract.quantity;
                        }
                    }
                }

                hypercall_engine::admission::validate_tier_sell_restriction(
                    tier,
                    wallet,
                    order_info,
                    filled_long_position,
                    order_index,
                )
            }
        }
    }
}

use crate::shared::order_types::perp_underlying;

/// Convert expiry date (YYYYMMDD format) to Unix timestamp.
///
/// This is a free function so that both `MarginManager` and `ExpiryManager`
/// can use it without circular dependencies.
pub fn expiry_date_to_timestamp(underlying: &str, expiry: u64) -> u64 {
    u64::try_from(hypercall_types::expiry_date_to_timestamp(
        underlying, expiry,
    ))
    .unwrap_or(0)
}