Cross-currency calibration

use chrono::NaiveDate;
use helixio_docs_sheets::{SOFR_CLOSE_DATE, USD_SOFR_CLOSE};
use helixrs::{
    CollateralSpec, CurrencyPair, FixingStore, FxRates, Interpolation, Locator, MarketContext,
    Period, QuoteSheet, Tolerance, YieldCurve, calibrate_cross_currency, cross_currency_rungs,
};

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 eurusd = 1.17;

    // Both currencies marked from their sheets, and the spot. Each rung is a
    // EUR/USD basis swap at its quoted basis, its euro notional set at the spot.
    let usd_sheet = QuoteSheet::from_rows(USD_SOFR_CLOSE.iter().copied())?;
    let mut eur_sheet = QuoteSheet::new();
    for (tenor, quote) in [("1Y", 0.0195), ("2Y", 0.0205), ("5Y", 0.0230), ("10Y", 0.0262)] {
        eur_sheet = eur_sheet.with("EUR-ESTR-OIS", Locator::parse(tenor)?, quote);
    }
    let fx = FxRates::from_quotes(&[("EUR/USD".parse::<CurrencyPair>()?, eurusd)])?;
    let market = MarketContext::as_of(close)
        .with_recipe_quotes(&CollateralSpec::Currency("USD".parse()?), &usd_sheet)?
        .with_recipe_quotes(&CollateralSpec::Currency("EUR".parse()?), &eur_sheet)?
        .with_fx_rates(fx.clone());
    let tenors = ["1Y", "2Y", "5Y", "10Y"].iter().map(|t| t.parse::<Period>()).collect::<Result<Vec<_>, _>>()?;
    let bases = [-0.0010, -0.0012, -0.0014, -0.0015];
    let rungs = cross_currency_rungs("EUR-USD-ESTR-SOFR-BASIS", close, &tenors, &bases, 1.0, eurusd)?;
    for rung in &rungs {
        println!("{}  {}  basis {:.4}", rung.pillar, rung.instrument.product_name(), rung.quote);
    }

    // The euro curve under dollar collateral, solved against the dollar discount
    // and SOFR projection on the pay leg and the €STR projection on the receive
    // leg, then filed under the key a euro leg of a dollar-collateralised swap
    // declares.
    let (usd, _) = market.curve(&"discount(USD)".parse()?).expect("the USD curve");
    let (estr, _) = market.curve(&"projection(EUR-ESTR)".parse()?).expect("the ESTR projection");
    let solved = calibrate_cross_currency(
        close,
        &usd,
        &usd,
        Some(&estr),
        &rungs,
        &FixingStore::new(),
        &fx,
        Tolerance::default(),
        Interpolation::LogLinear,
    )?;
    let collateralised = market
        .clone()
        .with_discount(CollateralSpec::under_csa("EUR".parse()?, "USD".parse()?), solved.clone());
    for (role, key) in collateralised.contents() {
        if key.contains("CSA") {
            println!("filed as {role} {key}");
        }
    }
    let mut worst: f64 = 0.0;
    for rung in &rungs {
        worst = worst.max(rung.instrument.npv(&collateralised)?.abs());
    }
    println!("pillars {}, largest basis swap value {worst:.2}", solved.curve_value().parameter_count());

    // The basis moves euro discounting away from €STR's own: the two curves
    // differ, by an amount of the order of the basis over the horizon.
    let ten_years = date((2036, 10, 1));
    let (eur, _) = market.curve(&"discount(EUR)".parse()?).expect("the EUR curve");
    let own = eur.view::<f64>().discount(ten_years)?;
    let under_usd = solved.curve_value().view::<f64>().discount(ten_years)?;
    println!("10Y EUR discount, EUR collateral {own:.8}");
    println!("10Y EUR discount, USD collateral {under_usd:.8}");

    Ok(())
}

import datetime as dt

import helixio as hlx
from desk_sheets import SOFR_CLOSE_DATE, USD_SOFR_CLOSE

calibration = hlx.calibration
EUR_ESTR = {"EUR-ESTR-OIS": {"1Y": 0.0195, "2Y": 0.0205, "5Y": 0.0230, "10Y": 0.0262}}
EURUSD = 1.17

# Both currencies marked from their sheets, and the spot. Each rung is a
# EUR/USD basis swap at its quoted basis, its euro notional set at the spot.
market = (
    hlx.MarketContext(SOFR_CLOSE_DATE)
    .with_recipe_quotes("USD", USD_SOFR_CLOSE)
    .with_recipe_quotes("EUR", EUR_ESTR)
    .with_fx_rates([("EUR", "USD", EURUSD)])
)
tenors, bases = ["1Y", "2Y", "5Y", "10Y"], [-0.0010, -0.0012, -0.0014, -0.0015]
rungs = calibration.cross_currency_rungs("EUR-USD-ESTR-SOFR-BASIS", SOFR_CLOSE_DATE, tenors, bases, 1.0, EURUSD)
for pillar, swap, basis in rungs:
    print(f"{pillar}  {swap.product()}  basis {basis:.4f}")

# The euro curve under dollar collateral, solved against the dollar discount
# and SOFR projection on the pay leg and the €STR projection on the receive
# leg, then filed under the key a euro leg of a dollar-collateralised swap
# declares.
usd = market.curve("discount(USD)")
solved = calibration.cross_currency(
    SOFR_CLOSE_DATE, usd, usd, market.curve("projection(EUR-ESTR)"), rungs, market=market
)
collateralised = market.with_discount("EUR", solved.curve(), collateral="USD")
for role, key in collateralised.contents():
    if "CSA" in key:
        print(f"filed as {role} {key}")
worst = max(abs(swap.npv(collateralised)) for _, swap, _ in rungs)
print(f"pillars {solved.curve().parameter_count()}, largest basis swap value {worst:.2f}")

# The basis moves euro discounting away from €STR's own: the two curves
# differ, by an amount of the order of the basis over the horizon.
ten_years = dt.date(2036, 10, 1)
own = market.curve("discount(EUR)").discount(ten_years)
under_usd = solved.curve().discount(ten_years)
print(f"10Y EUR discount, EUR collateral {own:.8f}")
print(f"10Y EUR discount, USD collateral {under_usd:.8f}")