FX forwards

use chrono::NaiveDate;
use helixio_docs_sheets::{EUR_CLOSE, SOFR_CLOSE_DATE, USD_SOFR_CLOSE};
use helixrs::{
    AnyInstrument, CollateralSpec, Currency, CurrencyPair, FxForward, FxRates, 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 discount(market: &MarketContext, key: &str, on: NaiveDate) -> Outcome<f64> {
    let (curve, _) = market.curve(&key.parse()?).expect("a pinned curve");
    Ok(curve.view::<f64>().discount(on)?)
}

fn main() -> Outcome<()> {
    let close = date(SOFR_CLOSE_DATE);
    let spot = 1.1000;
    let value_date = date((2027, 10, 5));
    let notional = 1_000_000.0;
    let (eur, usd): (Currency, Currency) = ("EUR".parse()?, "USD".parse()?);

    // Each currency's curve from its recipe, and the spot: dollars per euro.
    let market = MarketContext::as_of(close)
        .with_recipe_quotes(&CollateralSpec::Currency(usd), &QuoteSheet::from_rows(USD_SOFR_CLOSE.iter().copied())?)?
        .with_recipe_quotes(&CollateralSpec::Currency(eur), &QuoteSheet::from_rows(EUR_CLOSE.iter().copied())?)?
        .with_fx_rates(FxRates::from_quotes(&[(CurrencyPair::new(eur, usd), spot)])?);

    // Covered interest parity: F = S × P_EUR / P_USD.
    let p_usd = discount(&market, "discount(USD)", value_date)?;
    let p_eur = discount(&market, "discount(EUR)", value_date)?;
    let forward = spot * p_eur / p_usd;
    println!("forward EUR/USD  {forward:.6}");

    // Buy a million euros at 1.12 dollars each: worth the difference to the
    // forward, on the euro notional, discounted in dollars.
    let trade = FxForward::new(eur, usd, notional, 1.12, value_date);
    let npv = AnyInstrument::FxForward(trade).npv(&market)?;
    let by_parity = (forward - 1.12) * notional * p_usd;
    println!("npv (USD)        {npv:.2}");
    println!("by parity        {by_parity:.2}");

    // Struck at the forward, the trade is worth nothing.
    let fair = AnyInstrument::FxForward(FxForward::new(eur, usd, notional, forward, value_date));
    println!("at the forward   {:.2}", fair.npv(&market)?.abs());

    // A forward whose value date is already past has exchanged its currencies.
    let settled = AnyInstrument::FxForward(FxForward::new(eur, usd, notional, 1.05, date((2026, 9, 30))));
    println!("settled npv      {:.2}", settled.npv(&market)?);

    Ok(())
}

import datetime as dt

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

SPOT = 1.1000
VALUE_DATE = dt.date(2027, 10, 5)
NOTIONAL = 1_000_000.0

# Each currency's curve from its recipe, and the spot: dollars per euro.
market = (
    hlx.MarketContext(SOFR_CLOSE_DATE)
    .with_recipe_quotes("USD", USD_SOFR_CLOSE)
    .with_recipe_quotes("EUR", EUR_CLOSE)
    .with_fx_rates([("EUR", "USD", SPOT)])
)

# Covered interest parity: F = S × P_EUR / P_USD.
p_usd = market.curve("discount(USD)").discount(VALUE_DATE)
p_eur = market.curve("discount(EUR)").discount(VALUE_DATE)
forward = SPOT * p_eur / p_usd
print(f"forward EUR/USD  {forward:.6f}")

# Buy a million euros at 1.12 dollars each: worth the difference to the
# forward, on the euro notional, discounted in dollars.
trade = hlx.products.fx_forward("EUR", "USD", base_amount=NOTIONAL, contract_rate=1.12, value_date=VALUE_DATE)
npv = trade.npv(market)
by_parity = (forward - 1.12) * NOTIONAL * p_usd
print(f"npv (USD)        {npv:.2f}")
print(f"by parity        {by_parity:.2f}")

# Struck at the forward, the trade is worth nothing.
fair = hlx.products.fx_forward("EUR", "USD", base_amount=NOTIONAL, contract_rate=forward, value_date=VALUE_DATE)
print(f"at the forward   {abs(fair.npv(market)):.2f}")

# A forward whose value date is already past has exchanged its currencies.
settled = hlx.products.fx_forward(
    "EUR", "USD", base_amount=NOTIONAL, contract_rate=1.05, value_date=dt.date(2026, 9, 30)
)
print(f"settled npv      {settled.npv(market):.2f}")