hypercall_api/caches/

options_summary.rs

use anyhow::{anyhow, Context, Result};
use arc_swap::ArcSwap;
use axum::body::Bytes;
use chrono::Utc;
use rust_decimal::prelude::ToPrimitive;
use rust_decimal_macros::dec;
use serde::Serialize;
use std::collections::{BTreeMap, HashMap};
use std::sync::Arc;
use std::time::{Duration, Instant, SystemTime};
use tracing::error;

use crate::boundary::market_inputs::GreeksCacheReader;
use crate::boundary::market_inputs::InstrumentsCacheReader;
use crate::handlers::market_data::OptionSummary;
use crate::models::Instrument;
use crate::rfq::indicative_quote_cache::{AggregatedIndicativeQuote, IndicativeQuoteCache};
use hypercall_db::{AnalyticsReader, BboReferenceData, HistoricalTheoPoint};
use hypercall_runtime_api::valuation::get_symbol_theoretical_price;
use hypercall_runtime_api::{QuoteProvider, SnapshotBookQuote};
use hypercall_types::{CONTRACT_UNIT_MULTIPLIER, HISTORICAL_THEO_INTERVAL_1H_MS};

const DEFAULT_REFRESH_INTERVAL_MS: u64 = 1_000;
const OPTIONS_SUMMARY_SNAPSHOT_ENVELOPE_SCHEMA_VERSION: u32 = 2;

struct OptionsSummarySnapshotData {
    by_underlying: BTreeMap<String, Vec<OptionSummary>>,
    published_response: Bytes,
    built_at: SystemTime,
}

pub struct OptionsSummarySnapshotCache {
    instruments_cache: Arc<dyn InstrumentsCacheReader>,
    greeks_cache: Arc<dyn GreeksCacheReader>,
    quote_provider: Arc<dyn QuoteProvider>,
    bbo_snapshot_reader: Arc<dyn BboReferenceAskReader>,
    indicative_cache: Option<Arc<IndicativeQuoteCache>>,
    db: Arc<dyn AnalyticsReader>,
    snapshot: ArcSwap<OptionsSummarySnapshotData>,
    refresh_interval: Duration,
}

#[async_trait::async_trait]
pub trait BboReferenceAskReader: Send + Sync {
    async fn get_reference_asks(
        &self,
        symbols: &[String],
        cutoff_ts: i64,
    ) -> HashMap<String, BboReferenceData>;
}

impl OptionsSummarySnapshotCache {
    pub fn new(
        instruments_cache: Arc<dyn InstrumentsCacheReader>,
        greeks_cache: Arc<dyn GreeksCacheReader>,
        quote_provider: Arc<dyn QuoteProvider>,
        bbo_snapshot_reader: Arc<dyn BboReferenceAskReader>,
        indicative_cache: Option<Arc<IndicativeQuoteCache>>,
        db: Arc<dyn AnalyticsReader>,
    ) -> Self {
        Self {
            instruments_cache,
            greeks_cache,
            quote_provider,
            bbo_snapshot_reader,
            indicative_cache,
            db,
            snapshot: ArcSwap::from_pointee(OptionsSummarySnapshotData {
                by_underlying: BTreeMap::new(),
                published_response: Bytes::from_static(
                    br#"{"schema_version":1,"built_at_ms":0,"payload":{}}"#,
                ),
                built_at: SystemTime::UNIX_EPOCH,
            }),
            refresh_interval: Duration::from_millis(DEFAULT_REFRESH_INTERVAL_MS),
        }
    }

    pub fn with_refresh_interval(mut self, refresh_interval: Duration) -> Self {
        self.refresh_interval = refresh_interval;
        self
    }

    pub async fn refresh_once(&self) -> Result<()> {
        let load_start = Instant::now();
        let mut instruments: Vec<Instrument> = self
            .instruments_cache
            .get_all()
            .await
            .into_iter()
            .filter(|instrument| instrument.status.is_active())
            .collect();
        instruments.sort_by(|a, b| {
            (
                a.underlying.as_str(),
                a.expiry,
                a.strike,
                a.option_type.as_str(),
                a.id.as_str(),
            )
                .cmp(&(
                    b.underlying.as_str(),
                    b.expiry,
                    b.strike,
                    b.option_type.as_str(),
                    b.id.as_str(),
                ))
        });
        let option_symbols: Vec<String> = instruments.iter().map(|opt| opt.id.clone()).collect();
        let bulk_mark_ivs = self.greeks_cache.get_bulk_iv(&option_symbols).await;
        let reference_asks = self
            .bbo_snapshot_reader
            .get_reference_asks(&option_symbols, Utc::now().timestamp() - 86_400)
            .await;
        let all_spot_prices = self.greeks_cache.get_all_spot_prices_snapshot().await;
        let reference_theos = self
            .db
            .get_historical_theos_batch(&option_symbols, HISTORICAL_THEO_INTERVAL_1H_MS, 25)
            .await
            .unwrap_or_default();
        metrics::histogram!("ht_options_summary_snapshot_load_seconds")
            .record(load_start.elapsed().as_secs_f64());

        let build_start = Instant::now();
        let cutoff_ms = Utc::now().timestamp_millis() - 86_400_000;
        let mut grouped = BTreeMap::<String, Vec<OptionSummary>>::new();
        for instrument in instruments {
            let summary = build_option_summary(
                &instrument,
                &all_spot_prices,
                &bulk_mark_ivs,
                &reference_asks,
                &reference_theos,
                cutoff_ms,
                self.greeks_cache.as_ref(),
                self.quote_provider.as_ref(),
                self.indicative_cache.as_deref(),
            )
            .await
            .with_context(|| {
                format!(
                    "refresh_once failed while rebuilding options summary for {}",
                    instrument.id
                )
            })?;
            grouped
                .entry(instrument.underlying.to_uppercase())
                .or_default()
                .push(summary);
        }
        metrics::histogram!("ht_options_summary_snapshot_build_seconds")
            .record(build_start.elapsed().as_secs_f64());

        let serialize_start = Instant::now();
        let built_at = SystemTime::now();
        let published_response = Bytes::from(
            serde_json::to_vec(&PublishedOptionsSummarySnapshotRef {
                schema_version: OPTIONS_SUMMARY_SNAPSHOT_ENVELOPE_SCHEMA_VERSION,
                built_at_ms: system_time_to_millis(built_at)?,
                payload: &grouped,
            })
            .map_err(|e| anyhow!("Failed to serialize options-summary snapshot: {}", e))?,
        );
        metrics::histogram!("ht_options_summary_snapshot_serialize_seconds")
            .record(serialize_start.elapsed().as_secs_f64());

        self.snapshot.store(Arc::new(OptionsSummarySnapshotData {
            by_underlying: grouped,
            published_response,
            built_at,
        }));
        metrics::counter!("ht_options_summary_snapshot_refresh_total", "status" => "success")
            .increment(1);
        Ok(())
    }

    pub async fn initialize(&self) {
        if let Err(error) = self.refresh_once().await {
            metrics::counter!("ht_options_summary_snapshot_refresh_total", "status" => "error")
                .increment(1);
            error!(
                error = %error,
                "Initial /options-summary snapshot build failed; serving cold-start payload"
            );
        }
    }

    pub fn start_with_shutdown(
        self: Arc<Self>,
        mut shutdown_rx: tokio::sync::broadcast::Receiver<()>,
    ) -> tokio::task::JoinHandle<()> {
        tokio::spawn(async move {
            let mut interval = tokio::time::interval(self.refresh_interval);
            loop {
                tokio::select! {
                    _ = shutdown_rx.recv() => {
                        break;
                    }
                    _ = interval.tick() => {
                        if let Err(error) = self.refresh_once().await {
                            metrics::counter!("ht_options_summary_snapshot_refresh_total", "status" => "error")
                                .increment(1);
                            error!(
                                error = %error,
                                "Failed to refresh /options-summary snapshot; keeping last-good"
                            );
                        }
                    }
                }
            }
        })
    }

    pub fn available_underlyings(&self) -> Vec<String> {
        self.snapshot.load().by_underlying.keys().cloned().collect()
    }

    pub fn get_for_underlyings(
        &self,
        requested_underlyings: &[String],
    ) -> (Vec<OptionSummary>, SystemTime) {
        let snapshot = self.snapshot.load();
        let mut result = Vec::new();
        for underlying in requested_underlyings {
            if let Some(entries) = snapshot.by_underlying.get(&underlying.to_uppercase()) {
                result.extend(entries.iter().cloned());
            }
        }
        (result, snapshot.built_at)
    }

    pub fn published_response(&self) -> (Bytes, SystemTime) {
        let snapshot = self.snapshot.load();
        (snapshot.published_response.clone(), snapshot.built_at)
    }
}

async fn build_option_summary(
    instrument: &Instrument,
    all_spot_prices: &HashMap<String, f64>,
    bulk_mark_ivs: &HashMap<String, f64>,
    reference_asks: &HashMap<String, BboReferenceData>,
    reference_theos: &HashMap<String, Vec<HistoricalTheoPoint>>,
    cutoff_ms: i64,
    greeks_cache: &dyn GreeksCacheReader,
    quote_provider: &dyn QuoteProvider,
    indicative_cache: Option<&IndicativeQuoteCache>,
) -> Result<OptionSummary> {
    let symbol = instrument.id.clone();
    let underlying = instrument.underlying.to_uppercase();
    let underlying_price = resolve_underlying_price(all_spot_prices, &underlying)
        .with_context(|| format!("resolve_underlying_price failed for {}", underlying))?;
    let mut theoretical_price = get_symbol_theoretical_price(greeks_cache, &symbol)
        .await
        .ok();

    let quote = quote_provider.get_quote(&symbol);
    let indicative_quote = indicative_cache.and_then(|cache| cache.get_aggregate(&symbol));
    let resolved_quotes = resolve_option_summary_quotes(quote.as_ref(), indicative_quote.as_ref());

    let mut price_change = None;
    if let Some(reference) = reference_asks.get(&symbol) {
        metrics::counter!("ht_options_summary_reference_lookup_total", "status" => "hit")
            .increment(1);
        if reference.used_earliest_fallback {
            metrics::counter!(
                "ht_options_summary_reference_lookup_total",
                "status" => "fallback_earliest"
            )
            .increment(1);
        }

        if resolved_quotes.orderbook_bid_price > 0.0 && reference.reference_ask > dec!(0) {
            if let Some(reference_ask) = reference.reference_ask.to_f64() {
                price_change = Some(
                    ((resolved_quotes.orderbook_bid_price - reference_ask) / reference_ask) * 100.0,
                );
            }
        }
    } else {
        metrics::counter!("ht_options_summary_reference_lookup_total", "status" => "miss")
            .increment(1);
    }

    const THEO_FLOOR: f64 = 0.50;
    if price_change.is_none() {
        if let Some(current_theo) = theoretical_price {
            if current_theo >= THEO_FLOOR {
                let ref_theo = reference_theos
                    .get(&symbol)
                    .and_then(|series| {
                        series
                            .iter()
                            .rfind(|p| p.timestamp_ms <= cutoff_ms)
                            .and_then(|p| p.theoretical_price.to_f64())
                    })
                    .unwrap_or(0.0);
                if ref_theo >= THEO_FLOOR {
                    price_change = Some(((current_theo - ref_theo) / ref_theo) * 100.0);
                    metrics::counter!(
                        "ht_options_summary_reference_lookup_total",
                        "status" => "theo_fallback"
                    )
                    .increment(1);
                }
            }
        }
    }

    let last_price = if resolved_quotes.mid_price > 0.0 {
        Some(resolved_quotes.mid_price)
    } else {
        None
    };

    let volume = instrument.volume_24h.to_f64().unwrap_or(0.0);
    let volume_usd = volume
        * if resolved_quotes.mark_price > 0.0 {
            resolved_quotes.mark_price
        } else {
            underlying_price
        };

    let (dynamic_mark_iv, greeks) = match greeks_cache.get_greeks(&symbol).await {
        Ok(greeks) => {
            theoretical_price = theoretical_price.or(Some(greeks.theoretical_price));
            (
                bulk_mark_ivs
                    .get(&symbol)
                    .copied()
                    .or(Some(greeks.implied_vol)),
                Some(hypercall_types::OrderBookGreeks {
                    delta: greeks.delta,
                    gamma: greeks.gamma,
                    vega: greeks.vega,
                    theta: greeks.theta,
                    rho: greeks.rho,
                }),
            )
        }
        Err(_) => (bulk_mark_ivs.get(&symbol).copied(), None),
    };
    let (bid_iv, ask_iv) = greeks_cache
        .get_quote_side_ivs_from_prices(
            &symbol,
            resolved_quotes.bid_quote_price,
            resolved_quotes.ask_quote_price,
        )
        .await
        .unwrap_or((None, None));

    Ok(OptionSummary {
        instrument_id: instrument.instrument_id,
        instrument_name: symbol,
        option_token_address: instrument.option_token_address,
        expiration_timestamp: (instrument.expiry * 1000) as i64,
        bid_price: resolved_quotes.orderbook_bid_price,
        ask_price: resolved_quotes.orderbook_ask_price,
        best_bid_size: resolved_quotes.orderbook_bid_size,
        best_ask_size: resolved_quotes.orderbook_ask_size,
        indicative_bid_price: resolved_quotes.indicative_bid_price,
        indicative_ask_price: resolved_quotes.indicative_ask_price,
        indicative_bid_size: resolved_quotes.indicative_bid_size,
        indicative_ask_size: resolved_quotes.indicative_ask_size,
        mark_price: resolved_quotes.mark_price,
        theoretical_price,
        mark_iv: dynamic_mark_iv,
        ask_iv,
        bid_iv,
        underlying_price,
        underlying_index: format!("{}_USD", underlying),
        open_interest: instrument.open_interest.to_f64().unwrap_or(0.0),
        volume,
        volume_usd,
        high: None,
        low: None,
        last: last_price,
        price_change,
        interest_rate: 0.0,
        estimated_delivery_price: if resolved_quotes.mark_price > 0.0 {
            resolved_quotes.mark_price
        } else {
            underlying_price
        },
        creation_timestamp: instrument.updated_at.timestamp_millis(),
        base_currency: underlying.clone(),
        quote_currency: "USD".to_string(),
        mid_price: resolved_quotes.mid_price,
        greeks,
    })
}

#[derive(Debug, PartialEq)]
struct ResolvedOptionSummaryQuotes {
    orderbook_bid_price: f64,
    orderbook_ask_price: f64,
    orderbook_bid_size: Option<f64>,
    orderbook_ask_size: Option<f64>,
    indicative_bid_price: Option<f64>,
    indicative_ask_price: Option<f64>,
    indicative_bid_size: Option<f64>,
    indicative_ask_size: Option<f64>,
    bid_quote_price: Option<f64>,
    ask_quote_price: Option<f64>,
    reference_bid_price: f64,
    mark_price: f64,
    mid_price: f64,
}

fn resolve_option_summary_quotes(
    orderbook_quote: Option<&SnapshotBookQuote>,
    indicative_quote: Option<&AggregatedIndicativeQuote>,
) -> ResolvedOptionSummaryQuotes {
    let orderbook_bid_price = orderbook_quote
        .and_then(|quote| quote.best_bid)
        .filter(|&value| value > 0.0)
        .unwrap_or(0.0);
    let orderbook_ask_price = orderbook_quote
        .and_then(|quote| quote.best_ask)
        .filter(|&value| value > 0.0)
        .unwrap_or(0.0);
    let orderbook_mid_price = orderbook_quote
        .and_then(|quote| quote.mid)
        .filter(|&value| value > 0.0);
    let orderbook_bid_size = orderbook_quote
        .and_then(|quote| quote.best_bid_size)
        .and_then(raw_contract_units_to_human_contracts);
    let orderbook_ask_size = orderbook_quote
        .and_then(|quote| quote.best_ask_size)
        .and_then(raw_contract_units_to_human_contracts);

    let indicative_bid_price = indicative_quote
        .and_then(|quote| quote.best_bid.to_f64())
        .filter(|&value| value > 0.0);
    let indicative_ask_price = indicative_quote
        .and_then(|quote| quote.best_ask.to_f64())
        .filter(|&value| value > 0.0);
    let indicative_bid_size = indicative_quote
        .and_then(|quote| quote.indicative_bid_size.to_f64())
        .and_then(raw_contract_units_to_human_contracts);
    let indicative_ask_size = indicative_quote
        .and_then(|quote| quote.indicative_ask_size.to_f64())
        .and_then(raw_contract_units_to_human_contracts);

    let mut bid_quote_price = if orderbook_bid_price > 0.0 {
        Some(orderbook_bid_price)
    } else {
        indicative_bid_price
    };
    let mut ask_quote_price = if orderbook_ask_price > 0.0 {
        Some(orderbook_ask_price)
    } else {
        indicative_ask_price
    };

    // Mixing orderbook and indicative sources can produce a crossed market
    // (e.g. stale orderbook bid above indicative ask). Fall back to
    // indicative-only pricing when that happens so downstream IV
    // calculations respect the bid_iv <= ask_iv invariant.
    if let (Some(bid), Some(ask)) = (bid_quote_price, ask_quote_price) {
        if bid > ask {
            bid_quote_price = indicative_bid_price;
            ask_quote_price = indicative_ask_price;
        }
    }
    let mark_price = orderbook_mid_price
        .or_else(|| midpoint(orderbook_bid_price, orderbook_ask_price))
        .or_else(|| midpoint_from_options(indicative_bid_price, indicative_ask_price))
        .or_else(|| positive_value(orderbook_bid_price))
        .or_else(|| positive_value(orderbook_ask_price))
        .or(indicative_bid_price)
        .or(indicative_ask_price)
        .unwrap_or(0.0);
    let mid_price = orderbook_mid_price
        .or_else(|| midpoint(orderbook_bid_price, orderbook_ask_price))
        .or_else(|| midpoint_from_options(indicative_bid_price, indicative_ask_price))
        .unwrap_or(mark_price);
    let reference_bid_price = positive_value(orderbook_bid_price)
        .or(indicative_bid_price)
        .unwrap_or(0.0);

    ResolvedOptionSummaryQuotes {
        orderbook_bid_price,
        orderbook_ask_price,
        orderbook_bid_size,
        orderbook_ask_size,
        indicative_bid_price,
        indicative_ask_price,
        indicative_bid_size,
        indicative_ask_size,
        bid_quote_price,
        ask_quote_price,
        reference_bid_price,
        mark_price,
        mid_price,
    }
}

fn positive_value(value: f64) -> Option<f64> {
    (value > 0.0).then_some(value)
}

fn midpoint(bid: f64, ask: f64) -> Option<f64> {
    if bid > 0.0 && ask > 0.0 {
        Some((bid + ask) / 2.0)
    } else {
        None
    }
}

fn midpoint_from_options(bid: Option<f64>, ask: Option<f64>) -> Option<f64> {
    match (bid, ask) {
        (Some(bid), Some(ask)) if bid > 0.0 && ask > 0.0 => Some((bid + ask) / 2.0),
        _ => None,
    }
}

fn raw_contract_units_to_human_contracts(size_contract_units_raw: f64) -> Option<f64> {
    (size_contract_units_raw > 0.0).then_some(size_contract_units_raw / CONTRACT_UNIT_MULTIPLIER)
}

fn resolve_underlying_price(
    all_spot_prices: &HashMap<String, f64>,
    underlying: &str,
) -> Result<f64> {
    all_spot_prices
        .get(underlying)
        .copied()
        .or_else(|| {
            all_spot_prices
                .get(&format!("{}-PERP", underlying))
                .copied()
        })
        .ok_or_else(|| anyhow!("Missing spot price for underlying {}", underlying))
}

fn system_time_to_millis(value: SystemTime) -> Result<u64> {
    Ok(value
        .duration_since(SystemTime::UNIX_EPOCH)
        .map_err(|e| anyhow!("Invalid snapshot build time: {}", e))?
        .as_millis() as u64)
}

#[derive(Serialize)]
struct PublishedOptionsSummarySnapshotRef<'a> {
    schema_version: u32,
    built_at_ms: u64,
    payload: &'a BTreeMap<String, Vec<OptionSummary>>,
}

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

    #[test]
    fn resolve_option_summary_quotes_keeps_orderbook_and_indicative_separate() {
        let orderbook = SnapshotBookQuote {
            best_bid: Some(100.0),
            best_bid_size: Some(2_000_000.0),
            best_ask: Some(110.0),
            best_ask_size: Some(3_000_000.0),
            mid: Some(105.0),
            bids: Vec::new(),
            asks: Vec::new(),
        };
        let indicative = AggregatedIndicativeQuote {
            instrument: "BTC-20260424-75000-C".to_string(),
            best_bid: dec!(120),
            best_ask: dec!(130),
            indicative_bid_size: dec!(4000000),
            indicative_ask_size: dec!(5000000),
            num_providers: 2,
            updated_at: 0,
        };

        let resolved = resolve_option_summary_quotes(Some(&orderbook), Some(&indicative));

        assert_eq!(resolved.orderbook_bid_price, 100.0);
        assert_eq!(resolved.orderbook_ask_price, 110.0);
        assert_eq!(resolved.orderbook_bid_size, Some(2.0));
        assert_eq!(resolved.orderbook_ask_size, Some(3.0));
        assert_eq!(resolved.indicative_bid_price, Some(120.0));
        assert_eq!(resolved.indicative_ask_price, Some(130.0));
        assert_eq!(resolved.indicative_bid_size, Some(4.0));
        assert_eq!(resolved.indicative_ask_size, Some(5.0));
        assert_eq!(resolved.reference_bid_price, 100.0);
        assert_eq!(resolved.bid_quote_price, Some(100.0));
        assert_eq!(resolved.ask_quote_price, Some(110.0));
        assert_eq!(resolved.mark_price, 105.0);
        assert_eq!(resolved.mid_price, 105.0);
    }

    #[test]
    fn resolve_option_summary_quotes_uncrosses_mixed_source_market() {
        let orderbook = SnapshotBookQuote {
            best_bid: Some(2343.8),
            best_bid_size: Some(1_000_000.0),
            best_ask: None,
            best_ask_size: None,
            mid: None,
            bids: Vec::new(),
            asks: Vec::new(),
        };
        let indicative = AggregatedIndicativeQuote {
            instrument: "BTC-20260529-79000-C".to_string(),
            best_bid: dec!(660),
            best_ask: dec!(732),
            indicative_bid_size: dec!(2000000),
            indicative_ask_size: dec!(3000000),
            num_providers: 1,
            updated_at: 0,
        };

        let resolved = resolve_option_summary_quotes(Some(&orderbook), Some(&indicative));

        assert!(
            resolved.bid_quote_price.unwrap() <= resolved.ask_quote_price.unwrap(),
            "bid_quote_price ({:?}) must not exceed ask_quote_price ({:?})",
            resolved.bid_quote_price,
            resolved.ask_quote_price,
        );
        assert_eq!(resolved.bid_quote_price, Some(660.0));
        assert_eq!(resolved.ask_quote_price, Some(732.0));
    }

    #[test]
    fn resolve_option_summary_quotes_falls_back_to_indicative_when_book_missing() {
        let indicative = AggregatedIndicativeQuote {
            instrument: "BTC-20260424-75000-C".to_string(),
            best_bid: dec!(98),
            best_ask: dec!(102),
            indicative_bid_size: dec!(2000000),
            indicative_ask_size: dec!(3000000),
            num_providers: 1,
            updated_at: 0,
        };

        let resolved = resolve_option_summary_quotes(None, Some(&indicative));

        assert_eq!(resolved.orderbook_bid_price, 0.0);
        assert_eq!(resolved.orderbook_ask_price, 0.0);
        assert_eq!(resolved.indicative_bid_price, Some(98.0));
        assert_eq!(resolved.indicative_ask_price, Some(102.0));
        assert_eq!(resolved.bid_quote_price, Some(98.0));
        assert_eq!(resolved.ask_quote_price, Some(102.0));
        assert_eq!(resolved.reference_bid_price, 98.0);
        assert_eq!(resolved.mark_price, 100.0);
        assert_eq!(resolved.mid_price, 100.0);
    }
}

#[cfg(test)]
mod underlying_price_tests {
    use super::resolve_underlying_price;
    use std::collections::HashMap;

    #[test]
    fn resolve_underlying_price_prefers_spot_symbol() {
        let prices = HashMap::from([
            ("BTC".to_string(), 101_000.0),
            ("BTC-PERP".to_string(), 99_000.0),
        ]);

        let price = resolve_underlying_price(&prices, "BTC").unwrap();

        assert_eq!(price, 101_000.0);
    }

    #[test]
    fn resolve_underlying_price_falls_back_to_perp_symbol() {
        let prices = HashMap::from([("ETH-PERP".to_string(), 2_000.0)]);

        let price = resolve_underlying_price(&prices, "ETH").unwrap();

        assert_eq!(price, 2_000.0);
    }

    #[test]
    fn resolve_underlying_price_errors_when_missing() {
        let prices = HashMap::new();

        let error = resolve_underlying_price(&prices, "SOL").unwrap_err();

        assert!(error
            .to_string()
            .contains("Missing spot price for underlying SOL"));
    }
}