How a market is built

use chrono::NaiveDate;
use helixio_docs_sheets::{SOFR_CLOSE_DATE, USD_SOFR_LADDER};
use helixrs::{CollateralSpec, MarketContext, QuoteSheet, YieldCurve};

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 usd = CollateralSpec::Currency("USD".parse()?);
    let ladder = QuoteSheet::from_rows(USD_SOFR_LADDER.iter().copied())?;

    // The recipe binds each quote to the instrument it quotes, unsolved.
    let base = MarketContext::as_of(close);
    let rungs = base.recipe_rungs(&usd, &ladder)?;
    for rung in &rungs {
        println!("{}  {}", rung.pillar, rung.instrument.product_name());
    }

    // Solving the rungs pins the same curves, under the same roles.
    let by_hand = base.with_curve_helpers(&rungs)?;
    let short_way = base.with_recipe_quotes(&usd, &ladder)?;
    let read = |market: &MarketContext| -> Outcome<f64> {
        let (curve, _) = market.curve(&"discount(USD)".parse()?).expect("the USD curve");
        Ok(curve.view::<f64>().discount(date((2031, 10, 1)))?)
    };
    let discount_5y = read(&by_hand)?;
    println!("5Y discount factor {discount_5y:.12}");
    println!(
        "same market as with_recipe_quotes  {}",
        if by_hand == short_way { "yes" } else { "no" }
    );

    Ok(())
}

import helixio as hlx
from desk_sheets import SOFR_CLOSE_DATE, USD_SOFR_LADDER

# The recipe binds each quote to the instrument it quotes, unsolved.
base = hlx.MarketContext(SOFR_CLOSE_DATE)
rungs = base.recipe_rungs("USD", USD_SOFR_LADDER)
for rung in rungs:
    print(f"{rung.pillar()}  {rung.instrument().product()}")

# Solving the rungs pins the same curves, under the same roles.
by_hand = base.with_curve_helpers(rungs)
short_way = base.with_recipe_quotes("USD", USD_SOFR_LADDER)
discount_5y = by_hand.curve("discount(USD)").discount(SOFR_CLOSE_DATE.replace(year=2031))
print(f"5Y discount factor {discount_5y:.12f}")
print(f"same market as with_recipe_quotes  {'yes' if by_hand == short_way else 'no'}")

use chrono::NaiveDate;
use helixio_docs_sheets::{SOFR_CLOSE_DATE, Sheet, USD_SOFR_LADDER, USD_SOFR_PRINTS};
use helixrs::{
    Book, CollateralSpec, FixingKey, FixingStore, Locator, MarketContext, MarketData, QuoteSheet,
    StripQuotes, 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 strip(sheet: Sheet, template: &str) -> Outcome<Vec<(Locator, f64)>> {
    sheet
        .iter()
        .filter(|(t, _, _)| *t == template)
        .map(|(_, locator, quote)| Ok((Locator::parse(locator)?, *quote)))
        .collect()
}

fn main() -> Outcome<()> {
    let close = date(SOFR_CLOSE_DATE);
    let seasoned = template("USD-SOFR-OIS")?
        .swap(date((2026, 9, 24)))?
        .with_maturity("5Y".parse::<Termination>()?)?
        .with_notional(50_000_000.0)
        .with_fixed_rate(0.0466)
        .build()?;
    let book = Book::new().add("SOFR-5Y", seasoned.clone(), 1.0);

    // An offline market still says what the book would need.
    let offline = MarketContext::as_of(close);
    let demand = offline.demand(&book)?;
    println!("strips {}, fixings {}", demand.strips.len(), demand.fixings.len());

    // The answer, built from the desk's sheet: every pillar of every strip named,
    // and the prints.
    let mut strips = Vec::new();
    for asked in &demand.strips {
        strips.push(StripQuotes {
            template: asked.template.clone(),
            observed: close,
            entries: strip(USD_SOFR_LADDER, &asked.template)?,
        });
    }
    let fixings = USD_SOFR_PRINTS
        .iter()
        .map(|(series, day, value)| ((*series).to_owned(), date(*day), *value))
        .collect();
    let data = MarketData {
        strips,
        fixings,
        fx: Vec::new(),
    };

    // Installing the answer solves the curves the recipe names and pins the prints.
    let market = offline.with_market_data(&demand, &data)?;
    let npv = seasoned.npv(&market)?;
    println!("npv    {npv:.2}");
    // The same answer through `with_recipe_quotes` and pinned prints is the same
    // market, so the value agrees bit for bit.
    let sheet = QuoteSheet::from_rows(USD_SOFR_LADDER.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 direct = MarketContext::as_of(close)
        .with_fixings(FixingStore::from_observations_checked(&prints)?)
        .with_recipe_quotes(&CollateralSpec::Currency("USD".parse()?), &sheet)?;
    println!("direct {:.2}", seasoned.npv(&direct)?);

    Ok(())
}

import datetime as dt

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

seasoned = (
    hlx.templates.get("USD-SOFR-OIS")
    .swap(dt.date(2026, 9, 24))
    .with_maturity("5Y")
    .with_notional(50_000_000.0)
    .with_fixed_rate(0.0466)
    .build()
)
book = hlx.Book().add("SOFR-5Y", seasoned, 1.0)

# An offline market still says what the book would need.
offline = hlx.MarketContext(SOFR_CLOSE_DATE)
demand = offline.demand(book)
print(f"strips {len(demand.strips.to_dict()['template'])}, fixings {len(demand.fixings.to_dict()['date'])}")

# The answer, built from the desk's sheet: every pillar of every strip named,
# and the prints.
data = hlx.MarketData(
    strips=[
        (template, SOFR_CLOSE_DATE, list(USD_SOFR_LADDER[template].items()))
        for template in demand.strips.to_dict()["template"]
    ],
    fixings=list(USD_SOFR_PRINTS),
)

# Installing the answer solves the curves the recipe names and pins the prints.
market = offline.with_market_data(demand, data)
npv = seasoned.npv(market)
print(f"npv    {npv:.2f}")
# The same answer through `with_recipe_quotes` and pinned prints is the same
# market, so the value agrees bit for bit.
direct = (
    hlx.MarketContext(SOFR_CLOSE_DATE)
    .with_fixings(USD_SOFR_PRINTS)
    .with_recipe_quotes("USD", USD_SOFR_LADDER)
)
print(f"direct {seasoned.npv(direct):.2f}")

use chrono::NaiveDate;
use helixio_docs_sheets::{SOFR_CLOSE_DATE, USD_SOFR_CLOSE, USD_SOFR_PRINTS};
use helixrs::{
    Book, CollateralSpec, FixingKey, FixingStore, MarketContext, QuoteSheet, Side,
    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 sofr = template("USD-SOFR-OIS")?;
    let seasoned = sofr
        .swap(date((2026, 9, 24)))?
        .with_maturity("5Y".parse::<Termination>()?)?
        .with_notional(50e6)
        .with_fixed_rate(0.0466)
        .build()?;
    let fresh = sofr
        .swap(close)?
        .with_maturity("2Y".parse::<Termination>()?)?
        .with_notional(25e6)
        .with_side(Side::Payer)
        .with_fixed_rate(0.0455)
        .build()?;
    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)?;
    let book = Book::new()
        .add("SOFR-5Y-RCV", seasoned, 1.0)
        .add("SOFR-2Y-PAY", fresh, 1.0)
        .attach_market(market.clone());

    // Each trade against the date's snapshot, times its quantity.
    let snapshot = market.on(close);
    let mut total = 0.0;
    for trade in book.trades() {
        let value = trade.instrument.npv(&snapshot)? * trade.quantity;
        println!("{:<12} {value:.2}", trade.id);
        total += value;
    }
    println!("{:<12} {total:.2}", "sum");
    println!("{:<12} {:.2}", "book npv", book.npv(close)?);

    Ok(())
}

import datetime as dt

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

sofr = hlx.templates.get("USD-SOFR-OIS")
seasoned = sofr.swap(dt.date(2026, 9, 24)).with_maturity("5Y").with_notional(50e6).with_fixed_rate(0.0466).build()
fresh = sofr.swap(SOFR_CLOSE_DATE).with_maturity("2Y").with_notional(25e6).with_side("payer").with_fixed_rate(0.0455).build()
market = hlx.MarketContext(SOFR_CLOSE_DATE).with_fixings(USD_SOFR_PRINTS).with_recipe_quotes("USD", USD_SOFR_CLOSE)
book = hlx.Book().add("SOFR-5Y-RCV", seasoned, 1.0).add("SOFR-2Y-PAY", fresh, 1.0)
book.attach_market(market)

# Each trade against the date's snapshot, times its quantity.
snapshot = market.on(SOFR_CLOSE_DATE)
total = 0.0
for trade_id, instrument, quantity in book.trades():
    value = instrument.npv(snapshot) * quantity
    print(f"{trade_id:<12} {value:.2f}")
    total += value
print(f"{'sum':<12} {total:.2f}")
print(f"{'book npv':<12} {book.npv(as_of=SOFR_CLOSE_DATE):.2f}")