Repo

use chrono::NaiveDate;
use helixio_docs_sheets::{SOFR_CLOSE_DATE, USD_SOFR_CLOSE, USD_SOFR_PRINTS};
use helixrs::{
    AnyInstrument, AnyTemplate, CollateralSpec, CouponTreatment, Curve, DayCountFraction,
    FixedRateBond, FixingKey, FixingStore, Frequency, MarketContext, QuoteSheet, Repo, RepoRate,
    RepoSide, RepoSpread, RepoTerms, package_value, 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 start = date((2026, 10, 2));

    // Rates from the sheet, and general collateral 10bp under SOFR, pinned as a
    // repo spread curve over the USD discount curve.
    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 gc = RepoSpread::new(close, &[(date((2027, 10, 1)), -0.0010)], DayCountFraction::Act360)?;
    let market = MarketContext::as_of(close)
        .with_fixings(FixingStore::from_observations_checked(&prints)?)
        .with_recipe_quotes(&CollateralSpec::Currency("USD".parse()?), &sheet)?
        .with_repo_spread("USD", Curve::RepoSpread(gc), "discount(USD)".parse()?);
    let usd = "USD".parse()?;
    let bond = FixedRateBond::bullet(
        usd,
        date((2025, 8, 15)),
        date((2035, 8, 15)),
        0.0425,
        Frequency::SemiAnnual,
        DayCountFraction::ActActIcma,
        100.0,
    )?;

    // Six months on the USD GC template at 4.00%, on 10 million of the bond at 99.5.
    let AnyTemplate::Repo(gc_repo) = template("USD-GC-REPO")? else {
        unreachable!("a repo template")
    };
    let repo = |side, coupons, margin_ratio| -> Outcome<AnyInstrument> {
        let end = gc_repo.end_after(start, "6M".parse()?);
        let terms = RepoTerms::from_template(&gc_repo, side, start, end, RepoRate::Fixed(0.0400), margin_ratio)?;
        let built = Repo::from_collateral(terms, bond.clone(), 10_000_000.0, 99.5)?.with_coupons(coupons);
        Ok(AnyInstrument::Repo(Box::new(built)))
    };
    let borrow = repo(RepoSide::Repo, CouponTreatment::Classic, 1.0)?;
    let lend = repo(RepoSide::ReverseRepo, CouponTreatment::Classic, 1.0)?;
    println!("repo     {:.2}", borrow.npv(&market)?);
    println!("reverse  {:.2}", lend.npv(&market)?);

    // The bond pays a coupon inside the term. A classic repo manufactures it back
    // to the seller; a buy/sell-back folds it into the repurchase price. The cash
    // legs differ by just under the coupon; the packages, each with its collateral,
    // differ by far less.
    let classic = borrow.clone();
    let sell_back = repo(RepoSide::Repo, CouponTreatment::BuySellBack, 1.0)?;
    let coupon = 10_000_000.0 * 0.0425 / 2.0;
    let gap = sell_back.npv(&market)? - classic.npv(&market)?;
    println!("one coupon           {coupon:.2}");
    println!("cash legs differ by  {gap:.2}");
    println!(
        "packages             {:.2}  {:.2}",
        package_value(&classic, &market)?,
        package_value(&sell_back, &market)?
    );

    Ok(())
}

import datetime as dt

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

START = dt.date(2026, 10, 2)

# Rates from the sheet, and general collateral 10bp under SOFR, pinned as a
# repo spread curve over the USD discount curve.
gc = hlx.curves.RepoSpreadCurve(SOFR_CLOSE_DATE, [(dt.date(2027, 10, 1), -0.0010)])
market = (
    hlx.MarketContext(SOFR_CLOSE_DATE)
    .with_fixings(USD_SOFR_PRINTS)
    .with_recipe_quotes("USD", USD_SOFR_CLOSE)
    .with_repo_spread("USD", gc, "discount(USD)")
)
bond = hlx.products.fixed_rate_bond(
    "USD", dt.date(2025, 8, 15), dt.date(2035, 8, 15),
    coupon=0.0425, frequency="Semiannual", day_count="ACT/ACT.ICMA",
)

# Six months on the USD GC template at 4.00%, on 10 million of the bond at 99.5.
def repo(side, coupons="classic", margin_ratio=1.0):
    return hlx.templates.get("USD-GC-REPO").repo(
        START, "6M", side=side, collateral=bond, price=99.5,
        rate=0.0400, nominal=10_000_000.0, coupons=coupons, margin_ratio=margin_ratio,
    )

borrow, lend = repo("repo"), repo("reverse")
print(f"repo     {borrow.npv(market):.2f}")
print(f"reverse  {lend.npv(market):.2f}")

# The bond pays a coupon inside the term. A classic repo manufactures it back
# to the seller; a buy/sell-back folds it into the repurchase price. The cash
# legs differ by just under the coupon; the packages, each with its collateral,
# differ by far less.
classic, sell_back = borrow, repo("repo", coupons="buy_sell_back")
coupon = 10_000_000.0 * 0.0425 / 2.0
gap = sell_back.npv(market) - classic.npv(market)
print(f"one coupon           {coupon:.2f}")
print(f"cash legs differ by  {gap:.2f}")
print(f"packages             {hlx.bonds.package_value(classic, market):.2f}  {hlx.bonds.package_value(sell_back, market):.2f}")