catalog_manager/

strikes.rs

use crate::config::{ExtensionPolicyConfig, StrikeSelectionConfig};
use anyhow::{Context, Result};
use chrono::Utc;
use std::collections::HashSet;

#[derive(Debug, Clone)]
pub struct StrikeSet {
    pub strikes: Vec<f64>,
    pub original_targets: Vec<f64>,
    pub policy: StrikePolicyKind,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum StrikePolicyKind {
    DeribitTable,
    OccFallback,
}

#[derive(Debug, Clone)]
pub struct ExtensionPlan {
    pub needs_extension: bool,
    pub reason: Option<String>,
    pub new_strikes: Vec<f64>,
}

#[derive(Debug, Clone, Copy)]
pub struct ExtensionRequest<'a> {
    pub underlying: &'a str,
    pub current_spot: f64,
    pub ref_price_at_listing: f64,
    pub expiry_timestamp: i64,
    pub existing_strikes: &'a [f64],
    pub reference_timestamp_secs: i64,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum ExpiryTenor {
    Daily,
    Weekly,
    Monthly,
    Quarterly,
}

#[derive(Debug, Clone, Copy)]
struct IntervalPolicy {
    atm: f64,
    outer: f64,
    wings: Option<f64>,
}

pub fn generate_strike_set(
    underlying: &str,
    spot_price: f64,
    expiry_timestamp: i64,
    config: &StrikeSelectionConfig,
) -> Result<StrikeSet> {
    generate_strike_set_at_time(
        underlying,
        spot_price,
        expiry_timestamp,
        config,
        Utc::now().timestamp(),
    )
}

pub fn generate_strike_set_at_time(
    underlying: &str,
    spot_price: f64,
    expiry_timestamp: i64,
    config: &StrikeSelectionConfig,
    reference_timestamp_secs: i64,
) -> Result<StrikeSet> {
    validate_spot(spot_price, underlying)?;

    let normalized = underlying.to_ascii_uppercase();
    let (strikes, policy) = if uses_deribit_table(&normalized, config) {
        let tenor = classify_tenor_at(expiry_timestamp, reference_timestamp_secs);
        (
            generate_deribit_table_strikes(&normalized, spot_price, tenor, config)
                .with_context(|| format!("Failed to generate Deribit strikes for {normalized}"))?,
            StrikePolicyKind::DeribitTable,
        )
    } else {
        (
            generate_occ_fallback_strikes(spot_price, config.occ_fallback_side_count)?,
            StrikePolicyKind::OccFallback,
        )
    };

    if strikes.is_empty() {
        anyhow::bail!(
            "No strikes generated for {} at spot {} and expiry {}",
            underlying,
            spot_price,
            expiry_timestamp
        );
    }

    Ok(StrikeSet {
        original_targets: strikes.clone(),
        strikes,
        policy,
    })
}

pub fn plan_extension(
    underlying: &str,
    current_spot: f64,
    ref_price_at_listing: f64,
    expiry_timestamp: i64,
    existing_strikes: &[f64],
    strike_config: &StrikeSelectionConfig,
    extension_config: &ExtensionPolicyConfig,
) -> Result<ExtensionPlan> {
    plan_extension_at_time(
        ExtensionRequest {
            underlying,
            current_spot,
            ref_price_at_listing,
            expiry_timestamp,
            existing_strikes,
            reference_timestamp_secs: Utc::now().timestamp(),
        },
        strike_config,
        extension_config,
    )
}

pub fn plan_extension_at_time(
    request: ExtensionRequest<'_>,
    strike_config: &StrikeSelectionConfig,
    extension_config: &ExtensionPolicyConfig,
) -> Result<ExtensionPlan> {
    if !extension_config.enabled {
        return Ok(ExtensionPlan {
            needs_extension: false,
            reason: None,
            new_strikes: vec![],
        });
    }

    validate_spot(request.current_spot, request.underlying)?;
    validate_spot(request.ref_price_at_listing, request.underlying)?;

    let spot_move_pct =
        (request.current_spot - request.ref_price_at_listing).abs() / request.ref_price_at_listing;
    if spot_move_pct < extension_config.min_spot_move_pct {
        return Ok(ExtensionPlan {
            needs_extension: false,
            reason: Some(format!(
                "Spot move {:.2}% < threshold {:.2}%",
                spot_move_pct * 100.0,
                extension_config.min_spot_move_pct * 100.0
            )),
            new_strikes: vec![],
        });
    }

    if request.existing_strikes.len() >= extension_config.max_total_strikes_per_expiry {
        return Ok(ExtensionPlan {
            needs_extension: false,
            reason: Some(format!(
                "Already at max strikes: {}",
                extension_config.max_total_strikes_per_expiry
            )),
            new_strikes: vec![],
        });
    }

    let strikes_below = request
        .existing_strikes
        .iter()
        .copied()
        .filter(|strike| *strike < request.current_spot)
        .count();
    let strikes_above = request
        .existing_strikes
        .iter()
        .copied()
        .filter(|strike| *strike > request.current_spot)
        .count();

    let mut reasons = Vec::new();
    if strikes_below < extension_config.ensure_min_strikes_per_side {
        reasons.push(format!(
            "Only {} strikes below spot (need {})",
            strikes_below, extension_config.ensure_min_strikes_per_side
        ));
    }
    if strikes_above < extension_config.ensure_min_strikes_per_side {
        reasons.push(format!(
            "Only {} strikes above spot (need {})",
            strikes_above, extension_config.ensure_min_strikes_per_side
        ));
    }

    if let Some(nearest) = request.existing_strikes.iter().min_by(|a, b| {
        let da = (*a - request.current_spot).abs();
        let db = (*b - request.current_spot).abs();
        da.total_cmp(&db)
    }) {
        let distance_pct = (nearest - request.current_spot).abs() / request.current_spot;
        if distance_pct > extension_config.ensure_atm_within_pct {
            reasons.push(format!(
                "Nearest strike {:.2}% from spot (max {:.2}%)",
                distance_pct * 100.0,
                extension_config.ensure_atm_within_pct * 100.0
            ));
        }
    }

    if reasons.is_empty() {
        return Ok(ExtensionPlan {
            needs_extension: false,
            reason: None,
            new_strikes: vec![],
        });
    }

    let existing_keys: HashSet<u64> = request
        .existing_strikes
        .iter()
        .map(|strike| strike.to_bits())
        .collect();
    let mut new_strikes: Vec<f64> = generate_strike_set_at_time(
        request.underlying,
        request.current_spot,
        request.expiry_timestamp,
        strike_config,
        request.reference_timestamp_secs,
    )?
    .strikes
    .into_iter()
    .filter(|strike| !existing_keys.contains(&strike.to_bits()))
    .collect();

    let remaining_capacity = extension_config
        .max_total_strikes_per_expiry
        .saturating_sub(request.existing_strikes.len());
    new_strikes.truncate(remaining_capacity);

    Ok(ExtensionPlan {
        needs_extension: !new_strikes.is_empty(),
        reason: Some(reasons.join("; ")),
        new_strikes,
    })
}

fn generate_deribit_table_strikes(
    underlying: &str,
    spot_price: f64,
    tenor: ExpiryTenor,
    config: &StrikeSelectionConfig,
) -> Result<Vec<f64>> {
    let policy = deribit_interval_policy(underlying, tenor)
        .with_context(|| format!("No Deribit strike interval table for {underlying}"))?;
    validate_interval(policy.atm, "Deribit ATM interval")?;
    validate_interval(policy.outer, "Deribit outer interval")?;
    if let Some(wings) = policy.wings {
        validate_interval(wings, "Deribit wings interval")?;
    }

    let atm = round_to_interval(spot_price, policy.atm);
    if atm <= 0.0 {
        anyhow::bail!(
            "Rounded ATM strike {} is not positive for spot {}",
            atm,
            spot_price
        );
    }

    let mut strikes = vec![atm];
    add_region(
        &mut strikes,
        atm,
        policy.atm,
        config.deribit_region_steps.atm,
    );
    add_region(
        &mut strikes,
        atm,
        -policy.atm,
        config.deribit_region_steps.atm,
    );

    let outer_high_base = atm + policy.atm * config.deribit_region_steps.atm as f64;
    let outer_low_base = atm - policy.atm * config.deribit_region_steps.atm as f64;
    add_region(
        &mut strikes,
        outer_high_base,
        policy.outer,
        config.deribit_region_steps.outer,
    );
    add_region(
        &mut strikes,
        outer_low_base,
        -policy.outer,
        config.deribit_region_steps.outer,
    );

    if let Some(wings) = policy.wings {
        let wings_high_base =
            outer_high_base + policy.outer * config.deribit_region_steps.outer as f64;
        let wings_low_base =
            outer_low_base - policy.outer * config.deribit_region_steps.outer as f64;
        add_region(
            &mut strikes,
            wings_high_base,
            wings,
            config.deribit_region_steps.wings,
        );
        add_region(
            &mut strikes,
            wings_low_base,
            -wings,
            config.deribit_region_steps.wings,
        );
    }

    normalize_strikes(strikes)
}

fn generate_occ_fallback_strikes(spot_price: f64, side_count: usize) -> Result<Vec<f64>> {
    if side_count == 0 {
        anyhow::bail!("OCC fallback side count must be > 0");
    }

    let atm_interval = occ_interval_for_price(spot_price)?;
    let atm = round_to_interval(spot_price, atm_interval);
    if atm <= 0.0 {
        anyhow::bail!(
            "Rounded OCC ATM strike {} is not positive for spot {}",
            atm,
            spot_price
        );
    }

    let mut strikes = vec![atm];
    let mut up = atm;
    for _ in 0..side_count {
        up += occ_interval_for_price(up)?;
        strikes.push(up);
    }

    let mut down = atm;
    for _ in 0..side_count {
        let interval = occ_interval_for_price(down)?;
        down -= interval;
        if down > 0.0 {
            strikes.push(round_to_precision(down));
        }
    }

    normalize_strikes(strikes)
}

fn deribit_interval_policy(underlying: &str, tenor: ExpiryTenor) -> Option<IntervalPolicy> {
    // Source: Deribit Contract Introduction Policy, Dynamic Options Strike Intervals.
    match (underlying, tenor) {
        ("BTC", ExpiryTenor::Daily) => Some(policy(500.0, 500.0, Some(1_000.0))),
        ("BTC", ExpiryTenor::Weekly) | ("BTC", ExpiryTenor::Monthly) => {
            Some(policy(1_000.0, 2_000.0, Some(5_000.0)))
        }
        ("BTC", ExpiryTenor::Quarterly) => Some(policy(2_000.0, 5_000.0, Some(10_000.0))),
        ("ETH", ExpiryTenor::Daily) => Some(policy(25.0, 50.0, Some(100.0))),
        ("ETH", ExpiryTenor::Weekly) | ("ETH", ExpiryTenor::Monthly) => {
            Some(policy(50.0, 100.0, Some(200.0)))
        }
        ("ETH", ExpiryTenor::Quarterly) => Some(policy(100.0, 200.0, Some(500.0))),
        ("AVAX", ExpiryTenor::Daily) => Some(policy(0.1, 0.2, None)),
        ("AVAX", ExpiryTenor::Weekly) | ("AVAX", ExpiryTenor::Monthly) => {
            Some(policy(0.2, 0.5, Some(1.0)))
        }
        ("AVAX", ExpiryTenor::Quarterly) => Some(policy(1.0, 2.0, Some(5.0))),
        ("SOL", ExpiryTenor::Daily) => Some(policy(1.0, 2.0, None)),
        ("SOL", ExpiryTenor::Weekly) => Some(policy(4.0, 10.0, Some(20.0))),
        ("SOL", ExpiryTenor::Monthly) => Some(policy(5.0, 10.0, Some(20.0))),
        ("SOL", ExpiryTenor::Quarterly) => Some(policy(5.0, 10.0, Some(20.0))),
        // Deribit's published TRX daily table lists outer intervals tighter than ATM.
        ("TRX", ExpiryTenor::Daily) => Some(policy(0.025, 0.005, None)),
        ("TRX", ExpiryTenor::Weekly)
        | ("TRX", ExpiryTenor::Monthly)
        | ("TRX", ExpiryTenor::Quarterly) => Some(policy(0.005, 0.01, Some(0.02))),
        ("XRP", ExpiryTenor::Daily) | ("XRP", ExpiryTenor::Weekly) => {
            Some(policy(0.025, 0.05, Some(0.1)))
        }
        ("XRP", ExpiryTenor::Monthly) => Some(policy(0.05, 0.1, Some(0.2))),
        ("XRP", ExpiryTenor::Quarterly) => Some(policy(0.1, 0.2, Some(0.5))),
        _ => None,
    }
}

fn uses_deribit_table(underlying: &str, config: &StrikeSelectionConfig) -> bool {
    config
        .deribit_table_assets
        .iter()
        .any(|asset| asset.eq_ignore_ascii_case(underlying))
}

fn policy(atm: f64, outer: f64, wings: Option<f64>) -> IntervalPolicy {
    IntervalPolicy { atm, outer, wings }
}

fn classify_tenor_at(expiry_timestamp: i64, reference_timestamp_secs: i64) -> ExpiryTenor {
    let seconds = expiry_timestamp.saturating_sub(reference_timestamp_secs);
    let days = (seconds as f64 / 86_400.0).ceil();
    if days <= 4.0 {
        ExpiryTenor::Daily
    } else if days <= 14.0 {
        ExpiryTenor::Weekly
    } else if days <= 65.0 {
        ExpiryTenor::Monthly
    } else {
        ExpiryTenor::Quarterly
    }
}

fn occ_interval_for_price(price: f64) -> Result<f64> {
    // Source: OCC Equity Options Product Specifications, general strike price intervals.
    validate_spot(price, "OCC strike")?;
    if price < 25.0 {
        Ok(2.5)
    } else if price <= 200.0 {
        Ok(5.0)
    } else {
        Ok(10.0)
    }
}

fn add_region(strikes: &mut Vec<f64>, base: f64, step: f64, count: usize) {
    for i in 1..=count {
        let strike = base + step * i as f64;
        if strike > 0.0 {
            strikes.push(round_to_precision(strike));
        }
    }
}

fn normalize_strikes(mut strikes: Vec<f64>) -> Result<Vec<f64>> {
    strikes.retain(|strike| strike.is_finite() && *strike > 0.0);
    strikes.iter_mut().for_each(|strike| {
        *strike = round_to_precision(*strike);
    });
    strikes.sort_by(|a, b| a.total_cmp(b));
    strikes.dedup_by(|a, b| (*a - *b).abs() < 1e-9);
    if strikes.is_empty() {
        anyhow::bail!("Generated strike list is empty");
    }
    Ok(strikes)
}

fn validate_spot(spot_price: f64, underlying: &str) -> Result<()> {
    if !spot_price.is_finite() || spot_price <= 0.0 {
        anyhow::bail!(
            "Invalid spot price {} for {} - cannot generate strikes",
            spot_price,
            underlying
        );
    }
    Ok(())
}

fn validate_interval(interval: f64, label: &str) -> Result<()> {
    if !interval.is_finite() || interval <= 0.0 {
        anyhow::bail!("{} must be positive, got {}", label, interval);
    }
    Ok(())
}

fn round_to_interval(value: f64, interval: f64) -> f64 {
    round_to_precision((value / interval).round() * interval)
}

fn round_to_precision(value: f64) -> f64 {
    (value * 100_000_000.0).round() / 100_000_000.0
}

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

    fn config() -> StrikeSelectionConfig {
        StrikeSelectionConfig {
            deribit_table_assets: vec![
                "BTC".to_string(),
                "ETH".to_string(),
                "SOL".to_string(),
                "AVAX".to_string(),
                "XRP".to_string(),
                "TRX".to_string(),
            ],
            deribit_region_steps: crate::config::DeribitRegionStepsConfig {
                atm: 2,
                outer: 2,
                wings: 1,
            },
            occ_fallback_side_count: 3,
        }
    }

    fn expiry_in_days(days: i64) -> i64 {
        Utc::now().timestamp() + days * 86_400
    }

    #[test]
    fn deribit_btc_uses_daily_intervals() {
        let set = generate_strike_set("BTC", 100_000.0, expiry_in_days(2), &config()).unwrap();
        assert_eq!(
            set.strikes,
            vec![
                97_000.0, 98_000.0, 98_500.0, 99_000.0, 99_500.0, 100_000.0, 100_500.0, 101_000.0,
                101_500.0, 102_000.0, 103_000.0
            ]
        );
        assert_eq!(set.policy, StrikePolicyKind::DeribitTable);
    }

    #[test]
    fn deribit_tenor_can_be_anchored_to_listing_time() {
        let now = Utc::now().timestamp();
        let expiry = now + 2 * 86_400;
        let listed_at = now - 30 * 86_400;

        let set =
            generate_strike_set_at_time("BTC", 100_000.0, expiry, &config(), listed_at).unwrap();
        assert_eq!(
            set.strikes,
            vec![
                89_000.0, 94_000.0, 96_000.0, 98_000.0, 99_000.0, 100_000.0, 101_000.0, 102_000.0,
                104_000.0, 106_000.0, 111_000.0,
            ]
        );
        assert_eq!(set.policy, StrikePolicyKind::DeribitTable);
    }

    #[test]
    fn deribit_eth_uses_quarterly_intervals() {
        let set = generate_strike_set("ETH", 3_550.0, expiry_in_days(120), &config()).unwrap();
        assert!(set.strikes.contains(&3_600.0));
        assert!(set.strikes.contains(&4_700.0));
        assert_eq!(set.policy, StrikePolicyKind::DeribitTable);
    }

    #[test]
    fn deribit_linear_assets_have_table_coverage() {
        for asset in ["SOL", "AVAX", "XRP", "TRX"] {
            for days in [2, 10, 40, 120] {
                let set =
                    generate_strike_set(asset, 100.0, expiry_in_days(days), &config()).unwrap();
                assert!(!set.strikes.is_empty(), "{asset} {days}");
                assert_eq!(set.policy, StrikePolicyKind::DeribitTable);
            }
        }
    }

    #[test]
    fn occ_fallback_uses_price_bands() {
        let low = generate_strike_set("HYPE", 20.0, expiry_in_days(30), &config()).unwrap();
        assert_eq!(low.strikes, vec![12.5, 15.0, 17.5, 20.0, 22.5, 25.0, 30.0]);

        let mid = generate_strike_set("USOIL", 100.0, expiry_in_days(30), &config()).unwrap();
        assert_eq!(
            mid.strikes,
            vec![85.0, 90.0, 95.0, 100.0, 105.0, 110.0, 115.0]
        );

        let high = generate_strike_set("US500", 5_000.0, expiry_in_days(30), &config()).unwrap();
        assert_eq!(
            high.strikes,
            vec![4_970.0, 4_980.0, 4_990.0, 5_000.0, 5_010.0, 5_020.0, 5_030.0]
        );
        assert_eq!(high.policy, StrikePolicyKind::OccFallback);
    }

    #[test]
    fn invalid_spot_fails() {
        assert!(generate_strike_set("BTC", 0.0, expiry_in_days(2), &config()).is_err());
    }

    #[test]
    fn extension_adds_only_missing_strikes() {
        let extension = ExtensionPolicyConfig {
            enabled: true,
            ensure_min_strikes_per_side: 2,
            ensure_atm_within_pct: 0.02,
            cooldown_secs: 3600,
            max_total_strikes_per_expiry: 30,
            min_spot_move_pct: 0.05,
        };
        let plan = plan_extension(
            "BTC",
            110_000.0,
            100_000.0,
            expiry_in_days(2),
            &[99_000.0, 100_000.0, 101_000.0],
            &config(),
            &extension,
        )
        .unwrap();
        assert!(plan.needs_extension);
        assert!(plan.new_strikes.iter().any(|strike| *strike > 110_000.0));
    }

    #[test]
    fn extension_uses_anchored_listing_tenor() {
        let extension = ExtensionPolicyConfig {
            enabled: true,
            ensure_min_strikes_per_side: 2,
            ensure_atm_within_pct: 0.02,
            cooldown_secs: 3600,
            max_total_strikes_per_expiry: 30,
            min_spot_move_pct: 0.05,
        };
        let now = Utc::now().timestamp();
        let expiry = now + 2 * 86_400;
        let existing = generate_strike_set("BTC", 100_000.0, expiry, &config())
            .unwrap()
            .strikes;

        let plan = plan_extension_at_time(
            ExtensionRequest {
                underlying: "BTC",
                current_spot: 110_000.0,
                ref_price_at_listing: 100_000.0,
                expiry_timestamp: expiry,
                existing_strikes: &existing,
                reference_timestamp_secs: now - 30 * 86_400,
            },
            &config(),
            &extension,
        )
        .unwrap();

        assert!(plan.needs_extension);
        assert!(plan.new_strikes.contains(&121_000.0));
    }

    #[test]
    fn testnet_catalog_generates_expected_strikes() {
        let catalog = crate::config::with_secret_placeholder_mode(
            crate::config::SecretPlaceholderMode::AllowUnresolved,
            || {
                crate::config::parse_catalog_config(include_str!(concat!(
                    env!("CARGO_MANIFEST_DIR"),
                    "/../../market_catalog_testnet.yaml"
                )))
            },
        )
        .unwrap();

        let btc = generate_strike_set(
            "BTC",
            100_000.0,
            expiry_in_days(2),
            &catalog.strike_selection,
        )
        .unwrap();
        assert_eq!(btc.policy, StrikePolicyKind::DeribitTable);
        assert_eq!(
            btc.strikes,
            vec![
                93_500.0, 94_500.0, 95_500.0, 96_500.0, 97_000.0, 97_500.0, 98_000.0, 98_500.0,
                99_000.0, 99_500.0, 100_000.0, 100_500.0, 101_000.0, 101_500.0, 102_000.0,
                102_500.0, 103_000.0, 103_500.0, 104_500.0, 105_500.0, 106_500.0,
            ]
        );

        let hype = generate_strike_set("HYPE", 20.0, expiry_in_days(30), &catalog.strike_selection)
            .unwrap();
        assert_eq!(hype.policy, StrikePolicyKind::OccFallback);
        assert_eq!(
            hype.strikes,
            vec![
                2.5, 5.0, 7.5, 10.0, 12.5, 15.0, 17.5, 20.0, 22.5, 25.0, 30.0, 35.0, 40.0, 45.0,
                50.0, 55.0,
            ]
        );
    }
}