Structured notes

use chrono::NaiveDate;
use helixio_docs_sheets::{EUR_CLOSE, SOFR_CLOSE_DATE};
use helixrs::{
    AnyIndex, AnyInstrument, CollateralSpec, CreditCurveId, Curve, Direction, FlatHazard,
    FlatSpread, LegTerms, MarketContext, PaymentRule, QuoteSheet, RiskFactors, Schedule,
    StructuredNote, Survival, YieldCurve, calendar, ibor_leg_on_index, index, note_dirty_price,
    note_z_spread,
};

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

const FACE: f64 = 10_000_000.0;
const ISSUER: &str = "ACME/SeniorUnSec/MM14/EUR";

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 eur = CollateralSpec::Currency("EUR".parse()?);

    // The coupons are an ordinary leg; the note receives it and redeems the face
    // on the last payment date.
    let sheet = QuoteSheet::from_rows(EUR_CLOSE.iter().copied())?;
    let market = MarketContext::as_of(close).with_recipe_quotes(&eur, &sheet)?;
    let target = calendar("EUTA")?;
    let quarterly = Schedule::generate(
        date((2026, 10, 5)),
        date((2028, 10, 5)),
        "3M".parse()?,
        target.as_ref(),
        "ModFollowing".parse()?,
        "None".parse()?,
        "ShortInitial".parse()?,
        false,
        None,
        None,
    )?;
    let terms = LegTerms {
        notional: FACE,
        day_count: "ACT/360".parse()?,
        currency: "EUR".parse()?,
        direction: Direction::Receive,
        payment: PaymentRule::none(),
    };
    let Some(AnyIndex::Ibor(euribor)) = index("EUR-EURIBOR-3M") else {
        panic!("a registered term index");
    };
    let leg = ibor_leg_on_index(&quarterly, &terms, &euribor, 1.0, 0.0);
    let lifted = market.lift::<f64>();
    let view = market.view(&lifted)?;
    let resolved = view.resolve(&RiskFactors::discounted_by(&eur).projecting("EUR-EURIBOR-3M"))?;
    let coupons: f64 = leg.npv::<f64, _>(&resolved.disc, &resolved, &resolved.fixings)?;
    let note = StructuredNote::new(&leg, FACE, eur.clone())?;
    let plain = AnyInstrument::StructuredNote(Box::new(note.clone()));
    let value = plain.npv(&market)?;
    let last_payment = leg
        .coupons()
        .iter()
        .map(|coupon| coupon.payment_date())
        .max()
        .expect("a coupon");
    let face_today = FACE * resolved.disc.discount(last_payment)?;
    let dirty = note_dirty_price(&plain, &market)?;
    println!("coupons           {coupons:.2}");
    println!("face, discounted  {face_today:.2}");
    println!("note              {value:.2}");
    println!("per 100           {dirty:.6}");

    // A quote below the risk-free value implies a spread on the issuer's
    // discounting. Pinned under the note's key, that spread gives the quote back.
    let quote = 97.0;
    let z = note_z_spread(&plain, &market, quote)?;
    let pinned = market
        .clone()
        .with_security_spread("ACME-NOTE", Curve::FlatSpread(FlatSpread::new(close, z)?));
    let marked = AnyInstrument::StructuredNote(Box::new(note.clone().spread_by("ACME-NOTE")));
    println!("quoted per 100    {quote:.2}");
    println!("z-spread          {:.4} bp", z * 10_000.0);
    println!("repriced per 100  {:.6}", note_dirty_price(&marked, &pinned)?);

    // Tagged to its issuer, the note is weighted by the issuer's survival and
    // recovers part of its face on default. With no default risk it is the plain
    // note; with some, it is worth less.
    let issuer: CreditCurveId = ISSUER.parse()?;
    let with_hazard = |hazard: f64| -> Outcome<MarketContext> {
        let curve = Survival::FlatHazard(FlatHazard::new(close, hazard, "ACT/365.FIXED".parse()?)?);
        Ok(market.clone().with_credit_curve(issuer.clone(), curve, Some(0.4)))
    };
    let tagged = AnyInstrument::StructuredNote(Box::new(note.issued_by(issuer.clone())));
    let riskless = tagged.npv(&with_hazard(0.0)?)?;
    let risky = tagged.npv(&with_hazard(0.02)?)?;
    println!("no default risk   {riskless:.2}");
    println!("hazard 2%         {risky:.2}");

    Ok(())
}

import datetime as dt

import helixio as hlx
from desk_sheets import EUR_CLOSE, SOFR_CLOSE_DATE

FACE = 10_000_000.0
ISSUER = "ACME/SeniorUnSec/MM14/EUR"

# The coupons are an ordinary leg; the note receives it and redeems the face
# on the last payment date.
market = hlx.MarketContext(SOFR_CLOSE_DATE).with_recipe_quotes("EUR", EUR_CLOSE)
target = hlx.Calendar("EUTA")
quarterly = hlx.dates.schedule(dt.date(2026, 10, 5), dt.date(2028, 10, 5), "3M", target)
paying = quarterly.paying(0, target)
leg = hlx.Leg(
    hlx.legs.ibor_leg(quarterly, paying, "EUR", notional=FACE, index="EUR-EURIBOR-3M", day_count="ACT/360"),
    "Receive",
    "EUR",
)
note = hlx.products.structured_note(leg, face=FACE)
value = note.npv(market)
face_today = FACE * market.curve("discount(EUR)").discount(paying[-1])
dirty = hlx.bonds.note_dirty_price(note, market)
print(f"coupons           {leg.npv(market):.2f}")
print(f"face, discounted  {face_today:.2f}")
print(f"note              {value:.2f}")
print(f"per 100           {dirty:.6f}")

# A quote below the risk-free value implies a spread on the issuer's
# discounting. Pinned under the note's key, that spread gives the quote back.
quote = 97.0
z = hlx.bonds.note_z_spread(note, market, quote)
pinned = market.with_security_spread("ACME-NOTE", hlx.curves.SpreadCurve.flat(SOFR_CLOSE_DATE, z))
marked = hlx.products.structured_note(leg, face=FACE, security_spread="ACME-NOTE")
print(f"quoted per 100    {quote:.2f}")
print(f"z-spread          {z * 10_000:.4f} bp")
print(f"repriced per 100  {hlx.bonds.note_dirty_price(marked, pinned):.6f}")

# Tagged to its issuer, the note is weighted by the issuer's survival and
# recovers part of its face on default. With no default risk it is the plain
# note; with some, it is worth less.
def with_hazard(hazard):
    curve = hlx.curves.SurvivalCurve.flat_hazard(SOFR_CLOSE_DATE, hazard)
    return market.with_credit_curve(ISSUER, curve, 0.4)

tagged = hlx.products.structured_note(leg, face=FACE, issuer=ISSUER)
riskless = tagged.npv(with_hazard(0.0))
risky = tagged.npv(with_hazard(0.02))
print(f"no default risk   {riskless:.2f}")
print(f"hazard 2%         {risky:.2f}")