Cashflow records

use chrono::NaiveDate;
use helixio_docs_sheets::{SOFR_CLOSE_DATE, USD_SOFR_CLOSE, USD_SOFR_PRINTS};
use helixrs::{
    CollateralSpec, FixingKey, FixingStore, MarketContext, QuoteSheet, Termination, 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 main() -> Outcome<()> {
    let close = date(SOFR_CLOSE_DATE);
    let sheet = QuoteSheet::from_rows(USD_SOFR_CLOSE.iter().copied())?;
    let prints: Vec<(FixingKey, NaiveDate, f64)> = USD_SOFR_PRINTS
        .iter()
        .map(|(index, day, value)| (FixingKey::Typed((*index).to_owned()), date(*day), *value))
        .collect();
    let market = MarketContext::as_of(close)
        .with_fixings(FixingStore::from_observations_checked(&prints)?)
        .with_recipe_quotes(&CollateralSpec::Currency("USD".parse()?), &sheet)?;
    // A two-year SOFR swap traded a week before the close, receiving fixed.
    let swap_at = |fixed_rate: f64| -> Outcome<_> {
        Ok(template("USD-SOFR-OIS")?
            .swap(date((2026, 9, 24)))?
            .with_maturity("2Y".parse::<Termination>()?)?
            .with_notional(10_000_000.0)
            .with_fixed_rate(fixed_rate)
            .build()?)
    };
    let swap = swap_at(0.0450)?;

    let table = swap.cashflow_records(&market)?;
    let columns: Vec<&str> = table.columns().collect();
    println!("{}", columns.join(", "));

    let text = |name: &str| table[name].text().expect("text");
    let numbers = |name: &str| table[name].numbers().expect("numbers");
    let dates = |name: &str| table[name].dates().expect("dates");
    let (kind, side, pay) = (text("kind"), text("direction"), dates("payment_date"));
    let (rate, amount, pv) = (numbers("rate"), numbers("amount"), numbers("pv"));
    for i in 0..table.len() {
        println!(
            "{:<9} {:<7} {}  {:.6}  {:12.2}  {:12.2}",
            kind[i],
            side[i],
            pay[i].expect("a payment date"),
            rate[i],
            amount[i],
            pv[i]
        );
    }

    // The rows add up to the value.
    let total: f64 = pv.iter().sum();
    let npv = swap.npv(&market)?;
    println!("sum of pv  {total:.2}");
    println!("npv        {npv:.2}");

    // What one basis point on each row's rate is worth, for the fixed leg. The leg is
    // linear in its rate, so its flows add up to the swap restruck a basis point
    // higher, less the swap.
    let usd = CollateralSpec::Currency("USD".parse()?);
    let bps = swap.legs().expect("a swap's legs")[0].bps_by_flow(&market, &usd)?;
    let one_bp = swap_at(0.0451)?.npv(&market)? - npv;
    let shown: Vec<String> = bps.iter().map(|b| format!("{b:.4}")).collect();
    println!("bps by flow  {}", shown.join("  "));
    println!("sum          {:.4}", bps.iter().sum::<f64>());
    println!("restruck     {one_bp:.4}");

    Ok(())
}

import datetime as dt

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

market = (
    hlx.MarketContext(SOFR_CLOSE_DATE)
    .with_fixings(USD_SOFR_PRINTS)
    .with_recipe_quotes("USD", USD_SOFR_CLOSE)
)

def swap_at(fixed_rate):
    """A two-year SOFR swap traded a week before the close, receiving fixed."""
    return (
        hlx.templates.get("USD-SOFR-OIS")
        .swap(dt.date(2026, 9, 24))
        .with_maturity("2Y")
        .with_notional(10_000_000.0)
        .with_fixed_rate(fixed_rate)
        .build()
    )

swap = swap_at(0.0450)

table = swap.cashflow_records(market)
print(", ".join(table.columns))

rows = table.to_dict()
for kind, side, pay, rate, amount, pv in zip(
    rows["kind"], rows["direction"], rows["payment_date"], rows["rate"], rows["amount"], rows["pv"]
):
    print(f"{kind:<9} {side:<7} {pay}  {rate:.6f}  {amount:12.2f}  {pv:12.2f}")

# The rows add up to the value, summed in row order.
total = 0.0
for pv in rows["pv"]:
    total += pv
npv = swap.npv(market)
print(f"sum of pv  {total:.2f}")
print(f"npv        {npv:.2f}")

# What one basis point on each row's rate is worth, for the fixed leg. The leg is
# linear in its rate, so its flows add up to the swap restruck a basis point
# higher, less the swap.
bps = swap.legs()[0].bps_by_flow(market)
one_bp = swap_at(0.0451).npv(market) - npv
print("bps by flow  " + "  ".join(f"{b:.4f}" for b in bps))
print(f"sum          {sum(bps):.4f}")
print(f"restruck     {one_bp:.4f}")