FX options

use chrono::NaiveDate;
use helixio_docs_sheets::{EUR_CLOSE, SOFR_CLOSE_DATE, USD_SOFR_CLOSE};
use helixrs::{
    AnyInstrument, CollateralSpec, Currency, CurrencyPair, DeltaConvention, DeltaQuote, FxOption,
    FxRates, FxVolSmile, FxVolSurface, MarketContext, OptionKind, PricingRiskFactors, QuoteSheet,
    Strike, YieldCurve,
};

type Outcome<T> = Result<T, Box<dyn std::error::Error>>;

fn date((year, month, day): (i32, u32, u32)) -> NaiveDate {
    NaiveDate::from_ymd_opt(year, month, day).expect("a real calendar date")
}

fn main() -> Outcome<()> {
    let close = date(SOFR_CLOSE_DATE);
    let spot = 1.1000;
    let (expiry, delivery) = (date((2027, 10, 1)), date((2027, 10, 5)));
    let notional = 1_000_000.0;
    let (eur, usd): (Currency, Currency) = ("EUR".parse()?, "USD".parse()?);

    // One smile per expiry, from the three quotes an FX desk sees: the at-the-money
    // vol, the 25-delta risk reversal and the 25-delta butterfly.
    let surface = FxVolSurface::new(
        CurrencyPair::new(eur, usd),
        DeltaConvention::Spot,
        close,
        vec![
            (date((2027, 1, 4)), FxVolSmile::from_quotes(0.075, -0.006, 0.0020)?),
            (date((2027, 4, 1)), FxVolSmile::from_quotes(0.078, -0.007, 0.0022)?),
            (expiry, FxVolSmile::from_quotes(0.082, -0.008, 0.0025)?),
        ],
    )?;
    let market = MarketContext::as_of(close)
        .with_recipe_quotes(&CollateralSpec::Currency(usd), &QuoteSheet::from_rows(USD_SOFR_CLOSE.iter().copied())?)?
        .with_recipe_quotes(&CollateralSpec::Currency(eur), &QuoteSheet::from_rows(EUR_CLOSE.iter().copied())?)?
        .with_fx_rates(FxRates::from_quotes(&[(CurrencyPair::new(eur, usd), spot)])?)
        .with_fx_vols(surface.clone());
    for at in [date((2027, 1, 4)), date((2027, 4, 1)), expiry] {
        println!(
            "{at}  25P {:.4}  ATM {:.4}",
            surface.view::<f64>().vol_at_quote(at, "25P".parse::<DeltaQuote>()?)?,
            surface.view::<f64>().vol_at_quote(at, DeltaQuote::Atm)?
        );
    }

    // A call and a put on a million euros at 1.13, one year out. Long the call and
    // short the put is a forward bought at the strike.
    let option = |kind, strike| FxOption::new(eur, usd, notional, kind, expiry, delivery, strike);
    let call = option(OptionKind::Call, Strike::Absolute(1.13));
    let put = option(OptionKind::Put, Strike::Absolute(1.13));
    let diagnostics = market.priced(&call.risk_factors()?, |v| call.diagnostics(v))?;
    let read = |key: &str| -> Outcome<f64> {
        let (curve, _) = market.curve(&key.parse()?).expect("a pinned curve");
        Ok(curve.view::<f64>().discount(delivery)?)
    };
    let (p_usd, p_eur) = (read("discount(USD)")?, read("discount(EUR)")?);
    let forward = spot * p_eur / p_usd;
    let call_npv = AnyInstrument::FxOption(call.clone()).npv(&market)?;
    let put_npv = AnyInstrument::FxOption(put).npv(&market)?;
    println!("forward     {:.6}", diagnostics.forward);
    println!("vol         {:.6}", diagnostics.vol);
    println!("call        {call_npv:.2}");
    let by_parity = (forward - 1.13) * notional * p_usd;
    println!("put         {put_npv:.2}");
    println!("call - put  {:.2}", call_npv - put_npv);
    println!("by parity   {by_parity:.2}");

    // A strike named by its delta: `delta=0.25` on a put is the 25-delta put, the
    // strike where the put's spot delta is -0.25 at the vol the smile reads there.
    // On a smile that quotes the 25-delta put, that is the 25P node: its strike
    // and its vol, to the tolerance the strike-vol fixed point is solved to.
    let wing_put = option(OptionKind::Put, Strike::AtDelta(0.25));
    let wing = market.priced(&wing_put.risk_factors()?, |v| wing_put.diagnostics(v))?;
    println!("strike      {:.6}", wing.strike);
    println!("vol         {:.6}", wing.vol);
    println!("delta       {:.6}", wing.delta);
    let put_node = surface.view::<f64>().vol_at_quote(expiry, "25P".parse::<DeltaQuote>()?)?;
    println!("25P node    {put_node:.6}");

    // The other way round: the vol the smile reads at a strike, with the nodes
    // placed at the option's forward and the euro discount factor to delivery.
    let at = surface.view::<f64>().vol_at_strike(expiry, 1.13, diagnostics.forward, p_eur)?;
    println!("vol at 1.13 {at:.6}");

    // From its expiry date an option is valued at zero; this one is out of the money.
    let expired = AnyInstrument::FxOption(FxOption::new(
        eur,
        usd,
        notional,
        OptionKind::Call,
        close,
        date((2026, 10, 5)),
        Strike::Absolute(1.30),
    ));
    println!("expired     {:.2}", expired.npv(&market)?);

    Ok(())
}

import datetime as dt

import helixio as hlx
from desk_sheets import EUR_CLOSE, SOFR_CLOSE_DATE, USD_SOFR_CLOSE

SPOT = 1.1000
EXPIRY, DELIVERY = dt.date(2027, 10, 1), dt.date(2027, 10, 5)
NOTIONAL = 1_000_000.0

# One smile per expiry, from the three quotes an FX desk sees: the at-the-money
# vol, the 25-delta risk reversal and the 25-delta butterfly.
surface = hlx.vols.FxVolSurface(
    "EUR",
    "USD",
    SOFR_CLOSE_DATE,
    [
        (dt.date(2027, 1, 4), 0.075, -0.006, 0.0020),
        (dt.date(2027, 4, 1), 0.078, -0.007, 0.0022),
        (EXPIRY, 0.082, -0.008, 0.0025),
    ],
)
market = (
    hlx.MarketContext(SOFR_CLOSE_DATE)
    .with_recipe_quotes("USD", USD_SOFR_CLOSE)
    .with_recipe_quotes("EUR", EUR_CLOSE)
    .with_fx_rates([("EUR", "USD", SPOT)])
    .with_fx_vols(surface)
)
for expiry in surface.expiries():
    print(f"{expiry}  25P {surface.vol_at_quote(expiry, '25P'):.4f}  ATM {surface.vol_at_quote(expiry, 'ATM'):.4f}")

# A call and a put on a million euros at 1.13, one year out. Long the call and
# short the put is a forward bought at the strike.
call = hlx.products.fx_option("EUR", "USD", notional_base=NOTIONAL, kind="call", expiry=EXPIRY, delivery=DELIVERY, strike=1.13)
put = hlx.products.fx_option("EUR", "USD", notional_base=NOTIONAL, kind="put", expiry=EXPIRY, delivery=DELIVERY, strike=1.13)
diagnostics = call.diagnostics(market)
p_usd = market.curve("discount(USD)").discount(DELIVERY)
p_eur = market.curve("discount(EUR)").discount(DELIVERY)
forward = SPOT * p_eur / p_usd
call_npv, put_npv = call.npv(market), put.npv(market)
by_parity = (forward - 1.13) * NOTIONAL * p_usd
print(f"forward     {diagnostics.forward():.6f}")
print(f"vol         {diagnostics.vol():.6f}")
print(f"call        {call_npv:.2f}")
print(f"put         {put_npv:.2f}")
print(f"call - put  {call_npv - put_npv:.2f}")
print(f"by parity   {by_parity:.2f}")

# A strike named by its delta: `delta=0.25` on a put is the 25-delta put, the
# strike where the put's spot delta is -0.25 at the vol the smile reads there.
# On a smile that quotes the 25-delta put, that is the 25P node: its strike and
# its vol, to the tolerance the strike-vol fixed point is solved to.
wing = hlx.products.fx_option("EUR", "USD", notional_base=NOTIONAL, kind="put", expiry=EXPIRY, delivery=DELIVERY, delta=0.25)
wing_diagnostics = wing.diagnostics(market)
print(f"strike      {wing_diagnostics.strike():.6f}")
print(f"vol         {wing_diagnostics.vol():.6f}")
print(f"delta       {wing_diagnostics.delta():.6f}")
print(f"25P node    {surface.vol_at_quote(EXPIRY, '25P'):.6f}")

# The other way round: the vol the smile reads at a strike, with the nodes
# placed at the option's forward and the euro discount factor to delivery.
at = surface.vol_at_strike(EXPIRY, 1.13, diagnostics.forward(), p_eur)
print(f"vol at 1.13 {at:.6f}")

# From its expiry date an option is valued at zero; this one is out of the money.
expired = hlx.products.fx_option(
    "EUR", "USD", notional_base=NOTIONAL, kind="call", expiry=SOFR_CLOSE_DATE, delivery=dt.date(2026, 10, 5), strike=1.30
)
print(f"expired     {expired.npv(market):.2f}")