Callable swap

use chrono::NaiveDate;
use helixio_docs_sheets::{SOFR_CLOSE_DATE, USD_SOFR_CLOSE};
use helixrs::instruments::swaptions::{CallableBy, CallableSwap};
use helixrs::{
    AnyInstrument, BermudanSwaption, CollateralSpec, MarketContext, OvernightIndexedSwap,
    QuoteSheet, Side, SwaptionKind, SwaptionUnderlying, Termination, template,
};

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

const RATE: f64 = 0.0480;

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

/// A five-year SOFR swap from spot at 4.80%.
fn swap(close: NaiveDate, side: Side) -> Outcome<OvernightIndexedSwap> {
    let AnyInstrument::Ois(swap) = template("USD-SOFR-OIS")?
        .swap(close)?
        .with_maturity("5Y".parse::<Termination>()?)?
        .with_notional(10_000_000.0)
        .with_fixed_rate(RATE)
        .with_side(side)
        .build()?
    else {
        unreachable!("a SOFR swap is an overnight indexed swap")
    };
    Ok(swap)
}

/// The cancellation right: a Bermudan on the same swap and dates, struck at its rate.
fn bermudan(close: NaiveDate, dates: &[NaiveDate], kind: SwaptionKind) -> Outcome<AnyInstrument> {
    let side = if kind == SwaptionKind::Payer {
        Side::Payer
    } else {
        Side::Receiver
    };
    let underlying = SwaptionUnderlying::Ois(swap(close, side)?);
    let option = BermudanSwaption::new(underlying, dates.to_vec(), RATE, kind)?;
    Ok(AnyInstrument::BermudanSwaption(Box::new(option)))
}

fn callable(close: NaiveDate, dates: &[NaiveDate], by: CallableBy) -> Outcome<AnyInstrument> {
    let underlying = SwaptionUnderlying::Ois(swap(close, Side::Payer)?);
    let swap = CallableSwap::new(underlying, dates.to_vec(), by)?;
    Ok(AnyInstrument::CallableSwap(Box::new(swap)))
}

fn main() -> Outcome<()> {
    let close = date(SOFR_CLOSE_DATE);
    let market = MarketContext::as_of(close)
        .with_recipe_quotes(
            &CollateralSpec::Currency("USD".parse()?),
            &QuoteSheet::from_rows(USD_SOFR_CLOSE.iter().copied())?,
        )?
        .with_hull_white("USD".parse()?, 0.03, 0.01);
    // Cancellable on each anniversary but the last.
    let dates: Vec<NaiveDate> = (0..4).map(|i| date((2027 + i, 10, 5))).collect();

    // Paying fixed, the holder cancels when rates fall: the right is a receiver
    // Bermudan, bought.
    let plain = AnyInstrument::Ois(swap(close, Side::Payer)?).npv(&market)?;
    let holder = callable(close, &dates, CallableBy::Holder)?.npv(&market)?;
    let holder_by_hand = plain + bermudan(close, &dates, SwaptionKind::Receiver)?.npv(&market)?;
    println!("swap          {plain:.2}");
    println!("callable      {holder:.2}");
    println!("by hand       {holder_by_hand:.2}");

    // Sold to the counterparty, the right is theirs: they cancel when rates rise,
    // into the swap's own direction, so the holder is short a payer Bermudan.
    let sold = callable(close, &dates, CallableBy::Counterparty)?.npv(&market)?;
    let sold_by_hand = plain - bermudan(close, &dates, SwaptionKind::Payer)?.npv(&market)?;
    println!("callable      {sold:.2}");
    println!("by hand       {sold_by_hand:.2}");

    Ok(())
}

import datetime as dt

import helixio as hlx
from desk_sheets import SOFR_CLOSE_DATE, USD_SOFR_CLOSE

market = (
    hlx.MarketContext(SOFR_CLOSE_DATE)
    .with_recipe_quotes("USD", USD_SOFR_CLOSE)
    .with_hull_white("USD", 0.03, 0.01)
)
sofr = hlx.templates.get("USD-SOFR-OIS")
RATE = 0.0480
# Cancellable on each anniversary but the last.
DATES = [dt.date(2027 + i, 10, 5) for i in range(4)]

def swap(side):
    """A five-year SOFR swap from spot at 4.80%."""
    return sofr.swap(SOFR_CLOSE_DATE).with_maturity("5Y").with_notional(10_000_000.0)\
        .with_fixed_rate(RATE).with_side(side).build()

def bermudan(kind):
    """The cancellation right: a Bermudan on the same swap and dates, struck at its rate."""
    return hlx.products.bermudan_swaption(swap("payer" if kind == "payer" else "receiver"), DATES, strike=RATE, kind=kind)

# Paying fixed, the holder cancels when rates fall: the right is a receiver
# Bermudan, bought.
plain = swap("payer").npv(market)
holder = hlx.products.callable_swap(swap("payer"), DATES, callable_by="holder").npv(market)
holder_by_hand = plain + bermudan("receiver").npv(market)
print(f"swap          {plain:.2f}")
print(f"callable      {holder:.2f}")
print(f"by hand       {holder_by_hand:.2f}")

# Sold to the counterparty, the right is theirs: they cancel when rates rise,
# into the swap's own direction, so the holder is short a payer Bermudan.
sold = hlx.products.callable_swap(swap("payer"), DATES, callable_by="counterparty").npv(market)
sold_by_hand = plain - bermudan("payer").npv(market)
print(f"callable      {sold:.2f}")
print(f"by hand       {sold_by_hand:.2f}")