hypercall/read_cache/

greeks.rs

use anyhow::Result;
use rust_decimal::prelude::ToPrimitive;
use std::collections::HashMap;
use std::sync::Arc;
use tokio::sync::RwLock;
use tracing::{debug, error, info, warn};

use crate::messaging::EventBusTrait;
use crate::price_oracle::hyperliquid_oracle::HyperliquidMarkPriceOracle;
use crate::shared::black_scholes_utils::{calculate_greeks, calculate_implied_volatility};
use crate::shared::order_types::perp_underlying;
use crate::shared::traits::MarkPriceOracle;
use crate::snapshot::SyncStatus;
use crate::types::OptionType;
use crate::valuation_utils::{intrinsic_option_price, now_unix_timestamp_secs};
use crate::vol_oracle::risk_oracle::SharedVolOracle;
use hypercall_runtime_api::QuoteProvider;
use hypercall_types::{
    expiry_date_to_timestamp, EngineMessage, Greeks, Market, MarketUpdateMessage,
    MarketUpdateStatus, OptionType as MessageOptionType,
};

#[derive(Debug, Clone)]
struct PricingContext {
    underlying: String,
    expiry_timestamp: u64,
    strike_f64: f64,
    option_type: OptionType,
    spot_price: Option<f64>,
    forward_price: f64,
    risk_free_rate: f64,
}

#[derive(Debug, Clone, Copy)]
struct TheoreticalIv {
    iv: f64,
    source: &'static str,
}

pub struct GreeksCache {
    // symbol -> market info (reusing Market struct from hypercall-types)
    instruments: Arc<RwLock<HashMap<String, Market>>>,
    // underlying -> mark price oracle (from Hyperliquid REST API polling)
    oracles: HashMap<String, Arc<HyperliquidMarkPriceOracle>>,
    // Risk-free rate (could be made configurable)
    risk_free_rate: f64,
    // Quote provider for lock-free mid price reads
    quote_provider: Arc<dyn QuoteProvider>,
    // Readiness status
    sync_status: Arc<SyncStatus>,
    // symbol -> theoretical IV override for deterministic repricing (testnet/testing)
    theoretical_iv_overrides: Arc<RwLock<HashMap<String, f64>>>,
    // Canonical theoretical IV source for API-side greeks and pricing.
    vol_oracle: RwLock<Option<SharedVolOracle>>,
}

impl GreeksCache {
    /// Underlying symbols with configured mark-price oracles.
    pub fn configured_underlyings(&self) -> Vec<String> {
        self.oracles.keys().cloned().collect()
    }

    /// Get the configured risk-free rate used for API-side option repricing.
    pub fn risk_free_rate(&self) -> f64 {
        self.risk_free_rate
    }

    fn normalize_expiry_timestamp(underlying: &str, raw_expiry: i64) -> Result<u64> {
        // Instruments persisted from catalog-manager use YYYYMMDD (e.g. 20260331),
        // while some tests may already store Unix seconds.
        if (19_000_000..=30_000_000).contains(&raw_expiry) {
            let expiry_timestamp = expiry_date_to_timestamp(underlying, raw_expiry as u64);
            return u64::try_from(expiry_timestamp).map_err(|_| {
                anyhow::anyhow!(
                    "Invalid converted expiry timestamp {} from code {}",
                    expiry_timestamp,
                    raw_expiry
                )
            });
        }

        u64::try_from(raw_expiry)
            .map_err(|_| anyhow::anyhow!("Invalid negative expiry timestamp: {}", raw_expiry))
    }

    /// Create a new GreeksCache that reads mid prices from the engine snapshot.
    ///
    /// Only subscribes to market-updates for instrument add/remove events.
    /// Sets readiness to Ready once all oracles have spot prices.
    pub async fn new(
        diesel_db: &dyn hypercall_db::BootstrapReader,
        event_bus: Arc<dyn EventBusTrait>,
        oracles: HashMap<String, Arc<HyperliquidMarkPriceOracle>>,
        shutdown_rx: tokio::sync::broadcast::Receiver<()>,
        quote_provider: Arc<dyn QuoteProvider>,
    ) -> Result<Arc<Self>> {
        info!(
            "Creating GreeksCache with oracles for: {:?}",
            oracles.keys().collect::<Vec<_>>()
        );

        let sync_status = Arc::new(SyncStatus::new());
        let cache = Arc::new(Self {
            instruments: Arc::new(RwLock::new(HashMap::new())),
            oracles,
            risk_free_rate: 0.04,
            quote_provider,
            sync_status: sync_status.clone(),
            theoretical_iv_overrides: Arc::new(RwLock::new(HashMap::new())),
            vol_oracle: RwLock::new(None),
        });

        cache.load_instruments_from_db(diesel_db).await?;

        // Only subscribe to market-updates for instrument add/remove events
        cache
            .clone()
            .start_market_updates_listener(event_bus, shutdown_rx)
            .await?;

        // Check if all oracles already have spot prices (they should — oracles are
        // initialized with new_with_init() which blocks until a price is fetched)
        let mut all_ready = true;
        for (underlying, oracle) in &cache.oracles {
            if oracle.get_spot_price().await.is_none() {
                warn!(
                    "GreeksCache: oracle for {} does not have a spot price yet",
                    underlying
                );
                all_ready = false;
            }
        }
        if all_ready {
            sync_status.set_ready();
            info!("GreeksCache ready: all oracles have spot prices");
        } else {
            warn!("GreeksCache: not all oracles have spot prices at construction time");
        }

        Ok(cache)
    }

    /// Set the canonical vol surface oracle used for theoretical IV lookups.
    pub async fn set_vol_oracle(&self, oracle: SharedVolOracle) {
        *self.vol_oracle.write().await = Some(oracle);
    }

    /// Get the sync status for readiness checks.
    pub fn sync_status(&self) -> Arc<SyncStatus> {
        self.sync_status.clone()
    }

    async fn load_instruments_from_db(
        &self,
        diesel_db: &dyn hypercall_db::BootstrapReader,
    ) -> Result<()> {
        use hypercall_types::OptionType;

        info!("Loading active instruments from database");

        let instruments = diesel_db.get_all_active_instruments().await?;

        let mut instruments_map = self.instruments.write().await;
        for instrument in instruments {
            let option_type = match instrument.option_type {
                OptionType::Call => MessageOptionType::Call,
                OptionType::Put => MessageOptionType::Put,
            };

            let expiry =
                match Self::normalize_expiry_timestamp(&instrument.underlying, instrument.expiry) {
                    Ok(expiry) => expiry,
                    Err(e) => {
                        error!(
                            "Invalid expiry {} for instrument {}: {}",
                            instrument.expiry, instrument.id, e
                        );
                        continue;
                    }
                };

            instruments_map.insert(
                instrument.id.clone(),
                Market {
                    symbol: instrument.id.clone(),
                    underlying: instrument.underlying.clone(),
                    strike: instrument.strike,
                    expiry,
                    option_type,
                },
            );
        }

        info!("Loaded {} instruments", instruments_map.len());
        Ok(())
    }

    /// Subscribe to market-updates only (for instrument add/remove events).
    async fn start_market_updates_listener(
        self: Arc<Self>,
        event_bus: Arc<dyn EventBusTrait>,
        mut shutdown_rx: tokio::sync::broadcast::Receiver<()>,
    ) -> Result<()> {
        use crate::shared::topics::TOPIC_MARKET_UPDATES;

        let topics = vec![TOPIC_MARKET_UPDATES.to_string()];
        let mut receiver = event_bus
            .subscribe(topics)
            .await
            .map_err(|e| anyhow::anyhow!("Failed to subscribe to market-updates: {}", e))?;

        let cache = self.clone();
        tokio::spawn(async move {
            info!("GreeksCache market-updates listener started");
            loop {
                tokio::select! {
                    _ = shutdown_rx.recv() => {
                        info!("GreeksCache listener stopping");
                        break;
                    }
                    maybe_message = receiver.recv() => {
                        match maybe_message {
                            Some(EngineMessage::MarketUpdate(market_msg)) => {
                                cache.handle_market_update(market_msg).await;
                            }
                            Some(_) => {} // Ignore other message types
                            None => break,
                        }
                    }
                }
            }
        });

        Ok(())
    }

    async fn handle_market_update(&self, market_msg: MarketUpdateMessage) {
        debug!(
            "Handling market update for symbol: {}",
            market_msg.market.symbol
        );

        match market_msg.status {
            MarketUpdateStatus::MarketCreated | MarketUpdateStatus::MarketAlreadyExists => {
                info!("New market created: {}", market_msg.market.symbol);
                let mut market = market_msg.market.clone();
                let raw_expiry = market.expiry as i64;
                let expiry = match Self::normalize_expiry_timestamp(&market.underlying, raw_expiry)
                {
                    Ok(expiry) => expiry,
                    Err(e) => {
                        error!(
                            "Invalid expiry {} for market update {}: {}",
                            raw_expiry, market.symbol, e
                        );
                        return;
                    }
                };
                market.expiry = expiry;

                self.instruments
                    .write()
                    .await
                    .insert(market.symbol.clone(), market);
            }
            MarketUpdateStatus::MarketDeleted
            | MarketUpdateStatus::MarketExpired
            | MarketUpdateStatus::MarketPendingSettlement => {
                info!("Market removed: {}", market_msg.market.symbol);
                self.instruments
                    .write()
                    .await
                    .remove(&market_msg.market.symbol);
            }
            MarketUpdateStatus::MarketCreationFailed | MarketUpdateStatus::MarketDeletionFailed => {
                // Market lifecycle update failed, cache remains unchanged.
                debug!(
                    "Market lifecycle update failed for {}: not mutating cache",
                    market_msg.market.symbol
                );
            }
        }
    }

    /// Extract pricing context for an option symbol: expiry, strike, option type,
    /// spot price, forward price, and risk-free rate.
    async fn get_pricing_context(&self, symbol: &str) -> Result<PricingContext> {
        let (underlying, expiry, strike, option_type_message) = {
            let instruments = self.instruments.read().await;
            let instrument = instruments
                .get(symbol)
                .ok_or_else(|| anyhow::anyhow!("Symbol not found: {}", symbol))?;
            (
                instrument.underlying.clone(),
                instrument.expiry as i64,
                instrument.strike,
                instrument.option_type,
            )
        };

        let normalized_expiry = Self::normalize_expiry_timestamp(&underlying, expiry)?;
        let oracle = self.oracles.get(&underlying).cloned().ok_or_else(|| {
            anyhow::anyhow!(
                "No mark price oracle configured for underlying: {}",
                underlying
            )
        })?;

        let spot_price = oracle.get_spot_price().await;

        let expiry_i64 = i64::try_from(normalized_expiry).map_err(|_| {
            anyhow::anyhow!(
                "Invalid normalized expiry timestamp for {}: {}",
                symbol,
                normalized_expiry
            )
        })?;
        let forward_price = oracle.get_mark_price(expiry_i64).await.map_err(|e| {
            anyhow::anyhow!(
                "Failed to get forward price for {} at expiry {}: {}",
                underlying,
                normalized_expiry,
                e
            )
        })?;

        let strike_f64 = strike
            .to_f64()
            .ok_or_else(|| anyhow::anyhow!("Invalid strike for {}: {}", symbol, strike))?;

        let option_type = match option_type_message {
            MessageOptionType::Call => OptionType::Call,
            MessageOptionType::Put => OptionType::Put,
        };

        Ok(PricingContext {
            underlying,
            expiry_timestamp: normalized_expiry,
            strike_f64,
            option_type,
            spot_price,
            forward_price,
            risk_free_rate: self.risk_free_rate,
        })
    }

    fn time_to_expiry_years(expiry_timestamp: u64) -> Result<f64> {
        let now = std::time::SystemTime::now()
            .duration_since(std::time::UNIX_EPOCH)
            .unwrap()
            .as_secs() as i64;
        let time_to_expiry = ((expiry_timestamp as i64 - now) as f64) / (365.25 * 24.0 * 3600.0);

        if time_to_expiry <= 0.0 {
            return Err(anyhow::anyhow!("Option has expired"));
        }

        Ok(time_to_expiry)
    }

    async fn resolve_theoretical_iv(
        &self,
        symbol: &str,
        context: &PricingContext,
    ) -> Result<TheoreticalIv> {
        if let Some(iv) = self
            .theoretical_iv_overrides
            .read()
            .await
            .get(symbol)
            .copied()
        {
            return Ok(TheoreticalIv {
                iv,
                source: "override",
            });
        }

        let vol_oracle_guard = self.vol_oracle.read().await;
        let vol_oracle = vol_oracle_guard.as_ref().ok_or_else(|| {
            anyhow::anyhow!(
                "Vol oracle not available for theoretical pricing of {} (still initializing)",
                symbol
            )
        })?;
        let expiry_i64 = i64::try_from(context.expiry_timestamp).map_err(|_| {
            anyhow::anyhow!("Invalid expiry timestamp: {}", context.expiry_timestamp)
        })?;
        let iv = vol_oracle
            .get_iv(&context.underlying, context.strike_f64, expiry_i64)
            .map_err(|e| anyhow::anyhow!("Vol oracle IV unavailable for {}: {}", symbol, e))?;
        drop(vol_oracle_guard);

        Ok(TheoreticalIv {
            iv,
            source: "vol_oracle",
        })
    }

    fn compute_quote_iv_from_market_price(
        context: &PricingContext,
        time_to_expiry: f64,
        market_price: f64,
        initial_vol: Option<f64>,
    ) -> Option<f64> {
        calculate_implied_volatility(
            &context.option_type,
            context.forward_price,
            context.strike_f64,
            time_to_expiry,
            context.risk_free_rate,
            market_price,
            initial_vol,
        )
    }

    async fn compute_theoretical_greeks(&self, symbol: &str) -> Result<Greeks> {
        let context = self.get_pricing_context(symbol).await?;
        let time_to_expiry = Self::time_to_expiry_years(context.expiry_timestamp)?;
        let iv = self.resolve_theoretical_iv(symbol, &context).await?;

        let mut greeks = calculate_greeks(
            &context.option_type,
            context.forward_price,
            context.strike_f64,
            time_to_expiry,
            context.risk_free_rate,
            iv.iv,
        );
        greeks.market_mid_price = self.quote_provider.get_quote(symbol).and_then(|q| q.mid);

        debug!(
            symbol,
            underlying = context.underlying,
            ?context.option_type,
            expiry_timestamp = context.expiry_timestamp,
            strike = context.strike_f64,
            spot_price = context.spot_price,
            forward_price = context.forward_price,
            risk_free_rate = context.risk_free_rate,
            time_to_expiry,
            iv = iv.iv,
            theoretical_price = greeks.theoretical_price,
            iv_source = iv.source,
            "Computed theoretical greeks"
        );

        Ok(greeks)
    }

    /// Calculate Greeks for an option using forward price from mark price oracle.
    ///
    /// Uses forward price = spot × e^(rt) instead of spot price, which accounts
    /// for the cost of carry to expiry.
    pub async fn get_greeks(&self, symbol: &str) -> Result<Greeks> {
        self.compute_theoretical_greeks(symbol).await
    }

    /// Reprice a single option using the current forward price and theoretical IV.
    pub async fn get_theoretical_price(&self, symbol: &str) -> Result<f64> {
        Ok(self.get_greeks(symbol).await?.theoretical_price)
    }

    /// Resolve the canonical theoretical mark for an option, perp, or underlying symbol.
    pub async fn get_theoretical_mark(&self, symbol: &str) -> Result<f64> {
        let option_market = { self.instruments.read().await.get(symbol).cloned() };
        if let Some(option_market) = option_market {
            let expiry_timestamp = Self::normalize_expiry_timestamp(
                &option_market.underlying,
                option_market.expiry as i64,
            )?;
            let now = now_unix_timestamp_secs()?;
            if i64::try_from(expiry_timestamp)
                .map(|expiry| expiry <= now)
                .unwrap_or(false)
            {
                let expiry_i64 = i64::try_from(expiry_timestamp).map_err(|_| {
                    anyhow::anyhow!(
                        "Invalid normalized expiry timestamp for {}: {}",
                        symbol,
                        expiry_timestamp
                    )
                })?;
                let settlement_price = self
                    .get_settlement_price(&option_market.underlying, expiry_i64)
                    .await
                    .ok_or_else(|| {
                        anyhow::anyhow!(
                            "Missing settlement price for {} at expiry {}",
                            option_market.underlying,
                            expiry_i64
                        )
                    })?;
                let strike = option_market.strike.to_f64().ok_or_else(|| {
                    anyhow::anyhow!("Invalid strike for {}: {}", symbol, option_market.strike)
                })?;
                let option_type = match option_market.option_type {
                    MessageOptionType::Call => OptionType::Call,
                    MessageOptionType::Put => OptionType::Put,
                };
                return Ok(intrinsic_option_price(
                    settlement_price,
                    strike,
                    &option_type,
                ));
            }
            return self.get_theoretical_price(symbol).await;
        }

        if let Some(underlying) = perp_underlying(symbol) {
            return self.get_spot_price(underlying).await.ok_or_else(|| {
                anyhow::anyhow!(
                    "Missing spot price for {} while resolving theoretical mark",
                    underlying
                )
            });
        }

        self.get_spot_price(symbol)
            .await
            .ok_or_else(|| anyhow::anyhow!("Missing spot price for {}", symbol))
    }

    /// Get theoretical implied volatility for a symbol.
    pub async fn get_iv(&self, symbol: &str) -> Result<f64> {
        let context = self.get_pricing_context(symbol).await?;
        Ok(self.resolve_theoretical_iv(symbol, &context).await?.iv)
    }

    /// Bulk implied volatility lookup for option chains.
    ///
    /// Returns IV values for symbols that can be computed successfully.
    pub async fn get_bulk_iv(&self, symbols: &[String]) -> HashMap<String, f64> {
        let mut result = HashMap::with_capacity(symbols.len());
        for symbol in symbols {
            match self.get_iv(symbol).await {
                Ok(iv) => {
                    result.insert(symbol.clone(), iv);
                }
                Err(e) => {
                    debug!("Failed to get IV for {}: {}", symbol, e);
                }
            }
        }
        result
    }

    /// Snapshot of all theoretical implied volatilities keyed by symbol.
    pub async fn get_all_iv_snapshot(&self) -> HashMap<String, f64> {
        let symbols = self.get_cached_symbols().await;
        let mut result = HashMap::with_capacity(symbols.len());
        for symbol in symbols {
            match self.get_iv(&symbol).await {
                Ok(iv) => {
                    result.insert(symbol, iv);
                }
                Err(e) => {
                    debug!("Failed to get IV for {}: {}", symbol, e);
                }
            }
        }
        result
    }

    /// Compute quote-side IVs from explicit bid and ask prices, when those sides exist.
    pub async fn get_quote_side_ivs_from_prices(
        &self,
        symbol: &str,
        best_bid: Option<f64>,
        best_ask: Option<f64>,
    ) -> Result<(Option<f64>, Option<f64>)> {
        let context = self.get_pricing_context(symbol).await?;
        let time_to_expiry = Self::time_to_expiry_years(context.expiry_timestamp)?;
        let initial_iv = self
            .resolve_theoretical_iv(symbol, &context)
            .await
            .ok()
            .map(|iv| iv.iv);

        let bid_iv = best_bid.filter(|price| *price > 0.0).and_then(|price| {
            Self::compute_quote_iv_from_market_price(&context, time_to_expiry, price, initial_iv)
        });
        let ask_iv = best_ask.filter(|price| *price > 0.0).and_then(|price| {
            Self::compute_quote_iv_from_market_price(&context, time_to_expiry, price, initial_iv)
        });

        Ok((bid_iv, ask_iv))
    }

    /// Compute quote-side IVs from the live bid and ask, when those sides exist.
    pub async fn get_quote_side_ivs(&self, symbol: &str) -> Result<(Option<f64>, Option<f64>)> {
        let Some(quote) = self.quote_provider.get_quote(symbol) else {
            return Ok((None, None));
        };

        self.get_quote_side_ivs_from_prices(symbol, quote.best_bid, quote.best_ask)
            .await
    }

    /// Snapshot of current spot prices for configured underlyings.
    pub async fn get_all_spot_prices_snapshot(&self) -> HashMap<String, f64> {
        let mut result = HashMap::with_capacity(self.oracles.len());
        for (underlying, oracle) in &self.oracles {
            if let Some(price) = oracle.get_spot_price().await {
                result.insert(underlying.clone(), price);
            }
        }
        result
    }

    /// Snapshot of previous day prices for configured underlyings.
    pub async fn get_all_prev_day_prices_snapshot(&self) -> HashMap<String, f64> {
        let mut result = HashMap::with_capacity(self.oracles.len());
        for (underlying, oracle) in &self.oracles {
            if let Some(price) = oracle.get_prev_day_price().await {
                result.insert(underlying.clone(), price);
            }
        }
        result
    }

    /// Get current spot price for an underlying from the oracle.
    pub async fn get_spot_price(&self, underlying: &str) -> Option<f64> {
        if let Some(oracle) = self.oracles.get(underlying) {
            oracle.get_spot_price().await
        } else {
            warn!("No oracle configured for underlying: {}", underlying);
            None
        }
    }

    /// Get forward price and risk-free rate for an underlying at a specific expiry.
    pub async fn get_forward_price_quote(
        &self,
        underlying: &str,
        expiry_timestamp: i64,
    ) -> Option<(f64, f64)> {
        if let Some(oracle) = self.oracles.get(underlying) {
            let risk_free_rate = oracle.risk_free_rate();
            match oracle.get_mark_price(expiry_timestamp).await {
                Ok(price) => Some((price, risk_free_rate)),
                Err(e) => {
                    warn!(
                        "Failed to get forward price for {} at expiry {}: {}",
                        underlying, expiry_timestamp, e
                    );
                    None
                }
            }
        } else {
            warn!("No oracle configured for underlying: {}", underlying);
            None
        }
    }

    /// Get forward price for an underlying at a specific expiry.
    pub async fn get_forward_price(&self, underlying: &str, expiry_timestamp: i64) -> Option<f64> {
        self.get_forward_price_quote(underlying, expiry_timestamp)
            .await
            .map(|(forward_price, _)| forward_price)
    }

    /// Get finalized settlement price for an underlying at a specific expiry.
    pub async fn get_settlement_price(
        &self,
        underlying: &str,
        expiry_timestamp: i64,
    ) -> Option<f64> {
        if let Some(oracle) = self.oracles.get(underlying) {
            oracle.get_settlement_price(expiry_timestamp).await
        } else {
            warn!("No oracle configured for underlying: {}", underlying);
            None
        }
    }

    /// Get all cached active option symbols.
    pub async fn get_cached_symbols(&self) -> Vec<String> {
        self.instruments.read().await.keys().cloned().collect()
    }

    /// Check if a symbol is cached.
    pub async fn has_symbol(&self, symbol: &str) -> bool {
        self.instruments.read().await.contains_key(symbol)
    }

    /// Get all configured underlying symbols.
    pub fn get_configured_underlyings(&self) -> Vec<String> {
        self.oracles.keys().cloned().collect()
    }

    /// Get staleness of spot prices for all configured underlyings.
    /// Returns a map of underlying -> staleness in seconds.
    /// If an oracle hasn't fetched yet, it returns None for that underlying.
    pub async fn get_spot_price_staleness(&self) -> HashMap<String, Option<f64>> {
        let mut result = HashMap::new();
        for (underlying, oracle) in &self.oracles {
            result.insert(underlying.clone(), oracle.get_staleness_seconds().await);
        }
        result
    }

    /// Check if any spot price oracle is unhealthy.
    pub async fn get_unhealthy_oracles(&self) -> Vec<String> {
        let mut unhealthy = Vec::new();
        for (underlying, oracle) in &self.oracles {
            if !oracle.is_healthy().await {
                unhealthy.push(underlying.clone());
            }
        }
        unhealthy
    }

    /// Create an empty GreeksCache for tests that do not need real instrument data.
    /// Skips the DB bootstrap and event bus subscription.
    #[cfg(any(test, feature = "test-utils"))]
    pub fn new_empty_for_testing(quote_provider: Arc<dyn QuoteProvider>) -> Arc<Self> {
        Arc::new(Self {
            instruments: Arc::new(RwLock::new(HashMap::new())),
            oracles: HashMap::new(),
            risk_free_rate: 0.04,
            quote_provider,
            sync_status: Arc::new(SyncStatus::new()),
            theoretical_iv_overrides: Arc::new(RwLock::new(HashMap::new())),
            vol_oracle: RwLock::new(None),
        })
    }

    /// Set spot price for an underlying (for testing only).
    ///
    /// This method allows tests to inject spot prices without making network requests.
    /// ONLY use this in testnet mode.
    #[cfg(any(test, feature = "test-utils"))]
    pub async fn set_spot_price_for_testing(&self, underlying: &str, price: f64) -> bool {
        if let Some(oracle) = self.oracles.get(underlying) {
            oracle.set_spot_price_for_testing(price).await;
            true
        } else {
            warn!(
                "Cannot set spot price for {}: no oracle configured",
                underlying
            );
            false
        }
    }

    /// Set theoretical IV override for an option symbol (for testing only).
    ///
    /// This allows test environments to decouple theoretical repricing from orderbook quotes.
    #[cfg(any(test, feature = "test-utils"))]
    pub async fn set_theoretical_iv_for_testing(&self, symbol: &str, iv: f64) {
        self.theoretical_iv_overrides
            .write()
            .await
            .insert(symbol.to_string(), iv);
    }
}

// Implement SpotPriceSource trait for RiskAccountBuilder compatibility
use crate::rsm::portfolio_margin::risk_account_builder::SpotPriceSource;
use async_trait::async_trait;

#[async_trait]
impl SpotPriceSource for GreeksCache {
    async fn get_spot_price(&self, underlying: &str) -> Option<f64> {
        // Delegate to the inherent method
        GreeksCache::get_spot_price(self, underlying).await
    }
}