Credit-linked swap

use std::sync::Arc;

use chrono::NaiveDate;
use helixio_docs_sheets::{SOFR_CLOSE_DATE, USD_SOFR_CLOSE};
use helixrs::{
    AccrualOnDefault, AnyInstrument, CollateralSpec, CreditLinkedSwap, Currency, DayCountFraction,
    DefaultPaymentTime, Direction, FlatHazard, LegRole, LegTerms, MarketContext, PaymentRule,
    QuoteSheet, RoleLeg, Schedule, Survival, fixed_rate_leg,
};

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

const ENTITY: &str = "ACME/SeniorUnSec/XR14/USD";

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 usd: Currency = "USD".parse()?;
    let rates = MarketContext::as_of(close).with_recipe_quotes(
        &CollateralSpec::Currency(usd),
        &QuoteSheet::from_rows(USD_SOFR_CLOSE.iter().copied())?,
    )?;
    // The SOFR market with ACME on a flat hazard curve, recovering 40%.
    let credit = |hazard: f64| -> Outcome<MarketContext> {
        let curve = Survival::FlatHazard(FlatHazard::new(close, hazard, DayCountFraction::Act365Fixed)?);
        Ok(rates
            .clone()
            .with_credit_curve(ENTITY.parse()?, Arc::new(curve), Some(0.40)))
    };
    // Five annual 5% coupons on ten million, received.
    let schedule = Schedule::from_dates((0..6).map(|i| date((2026 + i, 10, 5))).collect())?;
    let terms = LegTerms {
        notional: 10_000_000.0,
        day_count: DayCountFraction::Thirty360,
        currency: usd,
        direction: Direction::Receive,
        payment: PaymentRule::none(),
    };
    let coupons = fixed_rate_leg(&schedule, &terms, 0.05);
    // The coupons as one leg of a credit-linked swap on ACME, in `role`.
    let swap = |role: LegRole, accrual: AccrualOnDefault| -> Outcome<AnyInstrument> {
        Ok(AnyInstrument::CreditLinkedSwap(Box::new(CreditLinkedSwap::new(
            ENTITY.parse()?,
            usd,
            CollateralSpec::Currency(usd),
            vec![RoleLeg::new(coupons.clone(), role, CollateralSpec::Currency(usd))],
            accrual,
            None,
            DefaultPaymentTime::AtDefault,
        )?)))
    };

    // On a 2% hazard, the independent leg is worth what it is without credit, and
    // the contingent leg less: each coupon is weighted by the chance ACME survives.
    let (risky, riskless) = (credit(0.02)?, credit(0.0)?);
    let independent = swap(LegRole::Independent, AccrualOnDefault::Halfway)?.npv(&risky)?;
    let contingent = swap(LegRole::Contingent, AccrualOnDefault::Halfway)?.npv(&risky)?;
    println!("independent  {independent:.2}");
    println!("contingent   {contingent:.2}");

    // Where default cannot happen, the contingent leg is the independent one.
    let certain = swap(LegRole::Contingent, AccrualOnDefault::Halfway)?.npv(&riskless)?;
    println!("contingent   {certain:.2}");

    // Settling a coupon's accrual to the default date, by the halfway rule, pays
    // part of the coupon a default interrupts; settling none pays nothing of it.
    let halfway = swap(LegRole::Contingent, AccrualOnDefault::Halfway)?.npv(&risky)?;
    let none = swap(LegRole::Contingent, AccrualOnDefault::None)?.npv(&risky)?;
    println!("halfway      {halfway:.2}");
    println!("none         {none:.2}");
    let worth = halfway - none;
    println!("accrual worth {worth:.2}");

    Ok(())
}

import datetime as dt

import helixio as hlx
from desk_sheets import SOFR_CLOSE_DATE, USD_SOFR_CLOSE

ENTITY = "ACME/SeniorUnSec/XR14/USD"
rates = hlx.MarketContext(SOFR_CLOSE_DATE).with_recipe_quotes("USD", USD_SOFR_CLOSE)

def credit(hazard):
    """The SOFR market with ACME on a flat hazard curve, recovering 40%."""
    return rates.with_credit_curve(ENTITY, hlx.curves.SurvivalCurve.flat_hazard(SOFR_CLOSE_DATE, hazard), 0.40)

# Five annual 5% coupons on ten million, received.
schedule = hlx.dates.Schedule.from_dates([dt.date(2026 + i, 10, 5) for i in range(6)])
coupons = hlx.legs.fixed_rate_leg(
    schedule, schedule.dates()[1:], "USD", notional=10_000_000.0, fixed_rate=0.05, day_count="30/360"
)

def swap(role, **kw):
    """The coupons as one leg of a credit-linked swap on ACME, in `role`."""
    return hlx.products.credit_linked_swap(ENTITY, "USD", [(hlx.Leg(coupons, "Receive", "USD"), role)], **kw)

# On a 2% hazard, the independent leg is worth what it is without credit, and
# the contingent leg less: each coupon is weighted by the chance ACME survives.
risky, riskless = credit(0.02), credit(0.0)
independent = swap("independent").npv(risky)
contingent = swap("contingent").npv(risky)
print(f"independent  {independent:.2f}")
print(f"contingent   {contingent:.2f}")

# Where default cannot happen, the contingent leg is the independent one.
certain = swap("contingent").npv(riskless)
print(f"contingent   {certain:.2f}")

# Settling a coupon's accrual to the default date, by the halfway rule, pays
# part of the coupon a default interrupts; settling none pays nothing of it.
halfway = swap("contingent", settles_accrual=True).npv(risky)
none = swap("contingent", settles_accrual=False).npv(risky)
print(f"halfway      {halfway:.2f}")
print(f"none         {none:.2f}")
worth = halfway - none
print(f"accrual worth {worth:.2f}")