Tenor basis swap

use chrono::NaiveDate;
use helixio_docs_sheets::{EUR_CLOSE, SOFR_CLOSE_DATE};
use helixrs::{
    AnyInstrument, AnyTemplate, CollateralSpec, MarketContext, QuoteSheet, TenorBasisSwap,
    template,
};

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 swap(spread: f64) -> Outcome<AnyInstrument> {
    let AnyTemplate::TenorBasis(basis) = template("EUR-ESTR-EURIBOR-BASIS")? else {
        unreachable!("a tenor basis template")
    };
    let swap = TenorBasisSwap::from_template(
        &basis,
        date((2026, 10, 5)),
        date((2031, 10, 6)),
        10_000_000.0,
        spread,
    )?;
    Ok(AnyInstrument::TenorBasis(Box::new(swap)))
}

fn main() -> Outcome<()> {
    let close = date(SOFR_CLOSE_DATE);
    let market = MarketContext::as_of(close).with_recipe_quotes(
        &CollateralSpec::Currency("EUR".parse()?),
        &QuoteSheet::from_rows(EUR_CLOSE.iter().copied())?,
    )?;

    // The spread that makes the five-year swap fair is the market's basis between
    // the two curves.
    let flat = swap(0.0)?;
    let spread = flat.par_spread(&market)?;
    println!("npv at zero spread  {:.2}", flat.npv(&market)?);
    println!("par spread          {spread:.8}");

    // Each basis point of spread is worth the spread leg's annuity, at any spread.
    let value = |s: f64| -> Outcome<f64> { Ok(swap(s)?.npv(&market)?) };
    let one = value(0.0001)? - value(0.0)?;
    println!("value of 1bp spread {one:.2}");

    // The spread sits on the template's spread index, the €STR leg here, received
    // against EURIBOR 3M flat. Naming the other index with spread_leg= moves it:
    // EURIBOR 3M plus the spread is received against €STR flat. EURIBOR fixes above
    // €STR, so the par spread is positive on the €STR leg and negative on the other.
    // In Rust the move is the template's two legs passed the other way round.
    let AnyTemplate::TenorBasis(basis) = template("EUR-ESTR-EURIBOR-BASIS")? else {
        unreachable!("a tenor basis template")
    };
    let on_estr = swap(0.0)?.par_spread(&market)?;
    let moved = TenorBasisSwap::from_legs(
        &basis.base,
        &basis.spread,
        date((2026, 10, 5)),
        date((2031, 10, 6)),
        10_000_000.0,
        0.0,
    )?;
    let on_euribor = AnyInstrument::TenorBasis(Box::new(moved)).par_spread(&market)?;
    println!("par spread on the ESTR leg      {:.6} bp", on_estr * 10_000.0);
    println!("par spread on the EURIBOR leg   {:.6} bp", on_euribor * 10_000.0);

    Ok(())
}

import datetime as dt

import helixio as hlx
from desk_sheets import EUR_CLOSE, SOFR_CLOSE_DATE

market = hlx.MarketContext(SOFR_CLOSE_DATE).with_recipe_quotes("EUR", EUR_CLOSE)
basis = hlx.templates.get("EUR-ESTR-EURIBOR-BASIS")
START, END = dt.date(2026, 10, 5), dt.date(2031, 10, 6)

def swap(spread):
    return basis.tenor_basis_swap(START, END, notional=10_000_000.0, spread=spread)

# The spread that makes the five-year swap fair is the market's basis between
# the two curves.
flat = swap(0.0)
spread = flat.par_spread(market)
print(f"npv at zero spread  {flat.npv(market):.2f}")
print(f"par spread          {spread:.8f}")

# Each basis point of spread is worth the spread leg's annuity, at any spread.
one = swap(0.0001).npv(market) - swap(0.0).npv(market)
print(f"value of 1bp spread {one:.2f}")

# The spread sits on the template's spread index, the €STR leg here, received
# against EURIBOR 3M flat. Naming the other index with spread_leg= moves it:
# EURIBOR 3M plus the spread is received against €STR flat. EURIBOR fixes above
# €STR, so the par spread is positive on the €STR leg and negative on the other.
on_estr = basis.tenor_basis_swap(START, END, notional=10_000_000.0, spread=0.0).par_spread(market)
on_euribor = basis.tenor_basis_swap(START, END, notional=10_000_000.0, spread=0.0, spread_leg="EUR-EURIBOR-3M")
on_euribor = on_euribor.par_spread(market)
print(f"par spread on the ESTR leg      {on_estr * 10_000:.6f} bp")
print(f"par spread on the EURIBOR leg   {on_euribor * 10_000:.6f} bp")