Bond future options

use chrono::NaiveDate;
use helixio_docs_sheets::{SOFR_CLOSE_DATE, USD_SOFR_CLOSE};
use helixrs::{
    AnyInstrument, BondFutureOption, CollateralSpec, Currency, ExerciseStyle,
    FutureOptionVolSurface, ListedFutureId, MarketContext, OptionKind, PremiumStyle, QuoteSheet,
    VolConvention, black76, bond_future_option_diagnostics, bond_future_option_from_template,
};

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

const CONTRACT: &str = "CBOT-ZN-2026-12";
const STRIKE: f64 = 112.0;

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 contract: ListedFutureId = CONTRACT.parse()?;

    // The rates curves come from the close; the future's price and its option vol
    // surface join with the market's own verbs.
    let sheet = QuoteSheet::from_rows(USD_SOFR_CLOSE.iter().copied())?;
    let market = MarketContext::as_of(close)
        .with_recipe_quotes(&CollateralSpec::Currency("USD".parse()?), &sheet)?
        .with_future_price(contract.clone(), 112.5)?
        .with_future_option_vols(
            contract.clone(),
            FutureOptionVolSurface::flat(close, 0.06, VolConvention::Lognormal)?,
        );
    let call = AnyInstrument::BondFutureOption(Box::new(bond_future_option_from_template(
        "CBOT-OZN",
        2026,
        12,
        STRIKE,
        OptionKind::Call,
    )?));
    let put = AnyInstrument::BondFutureOption(Box::new(bond_future_option_from_template(
        "CBOT-OZN",
        2026,
        12,
        STRIKE,
        OptionKind::Put,
    )?));
    println!(
        "future   {CONTRACT} at {:.4}",
        market.future_price(&contract).expect("pinned")
    );
    println!("options  CBOT-OZN December 2026, struck at {STRIKE:.2}");

    // The European value is Black-76 on the futures price, discounted to expiry:
    // a paid premium is cash today for a payoff at expiry.
    let seen = bond_future_option_diagnostics(&call, &market)?;
    println!("futures price     {:.4}", seen.futures_price);
    println!("years to expiry   {:.6}", seen.time);
    println!("discount          {:.6}", seen.discount);
    println!("european per 100  {:.6}", seen.european);

    // On the futures price, a call less a put is the discounted forward less the
    // discounted strike. American exercise adds a premium that is never negative,
    // and the value is per contract: a point is 1,000 dollars.
    let other = bond_future_option_diagnostics(&put, &market)?;
    let parity = seen.european - other.european;
    let value = call.npv(&market)?;
    println!("call - put        {parity:.6}");
    println!("early exercise    {:.6}", seen.early_exercise);
    println!("value, 1 contract {value:.2}");

    // The same option margined like its future: nothing is paid up front, so it is
    // valued undiscounted, and exercising early gains nothing.
    let margined = AnyInstrument::BondFutureOption(Box::new(BondFutureOption::new(
        contract,
        date((2026, 11, 20)),
        STRIKE,
        OptionKind::Call,
        PremiumStyle::FuturesStyle,
        ExerciseStyle::American,
        Currency::new("USD")?,
    )?));
    let style = bond_future_option_diagnostics(&margined, &market)?;
    println!("discount          {:.6}", style.discount);
    println!("european per 100  {:.6}", style.european);

    Ok(())
}

import datetime as dt

import helixio as hlx
from desk_sheets import SOFR_CLOSE_DATE, USD_SOFR_CLOSE

CONTRACT = "CBOT-ZN-2026-12"
STRIKE = 112.0

# The rates curves come from the close; the future's price and its option vol
# surface join with the market's own verbs.
market = (
    hlx.MarketContext(SOFR_CLOSE_DATE)
    .with_recipe_quotes("USD", USD_SOFR_CLOSE)
    .with_future_price(CONTRACT, 112.5)
    .with_future_option_vols(CONTRACT, hlx.vols.FutureOptionVolSurface.flat(SOFR_CLOSE_DATE, 0.06))
)
call = hlx.products.bond_future_option_from_template("CBOT-OZN", 2026, 12, strike=STRIKE)
put = hlx.products.bond_future_option_from_template("CBOT-OZN", 2026, 12, strike=STRIKE, kind="put")
print(f"future   {CONTRACT} at {market.future_price(CONTRACT):.4f}")
print(f"options  CBOT-OZN December 2026, struck at {STRIKE:.2f}")

# The European value is Black-76 on the futures price, discounted to expiry:
# a paid premium is cash today for a payoff at expiry.
seen = call.diagnostics(market)
print(f"futures price     {seen.futures_price():.4f}")
print(f"years to expiry   {seen.time():.6f}")
print(f"discount          {seen.discount():.6f}")
print(f"european per 100  {seen.european():.6f}")

# On the futures price, a call less a put is the discounted forward less the
# discounted strike. American exercise adds a premium that is never negative,
# and the value is per contract: a point is 1,000 dollars.
other = put.diagnostics(market)
parity = seen.european() - other.european()
value = call.npv(market)
print(f"call - put        {parity:.6f}")
print(f"early exercise    {seen.early_exercise():.6f}")
print(f"value, 1 contract {value:.2f}")

# The same option margined like its future: nothing is paid up front, so it is
# valued undiscounted, and exercising early gains nothing.
margined = hlx.products.bond_future_option(
    CONTRACT, dt.date(2026, 11, 20), strike=STRIKE, currency="USD", premium_style="futures_style"
)
style = margined.diagnostics(market)
print(f"discount          {style.discount():.6f}")
print(f"european per 100  {style.european():.6f}")