Equity total return swap

use chrono::NaiveDate;
use helixio_docs_sheets::{SOFR_CLOSE_DATE, USD_SOFR_CLOSE};
use helixrs::{
    AnyInstrument, CollateralSpec, Currency, EquityTotalReturnSwap, FixingStore, MarketContext,
    QuoteSheet,
};

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

const FUNDING: f64 = 0.045;

fn date((year, month, day): (i32, u32, u32)) -> NaiveDate {
    NaiveDate::from_ymd_opt(year, month, day).expect("a real calendar date")
}

/// Fixed funding at `FUNDING`: zero gearing on the index, the rate as margin.
fn funded(mut swap: EquityTotalReturnSwap, paying: bool) -> AnyInstrument {
    swap.funding_margin = FUNDING;
    swap.funding_gearing = 0.0;
    swap.pay_total_return = paying;
    AnyInstrument::EquityTotalReturnSwap(Box::new(swap))
}

fn main() -> Outcome<()> {
    let close = date(SOFR_CLOSE_DATE);
    let usd: Currency = "USD".parse()?;
    let market = MarketContext::as_of(close)
        .with_recipe_quotes(
            &CollateralSpec::Currency(usd),
            &QuoteSheet::from_rows(USD_SOFR_CLOSE.iter().copied())?,
        )?
        .with_equity_spot("ACME", 120.0)?
        .with_equity_spot("BETA", 45.0)?;
    // Semi-annual resets; the first period started in July, before the close.
    let resets = vec![date((2026, 7, 1)), date((2027, 1, 4)), date((2027, 7, 1))];
    #[allow(clippy::cast_precision_loss)] // days into the period
    let elapsed = (close - resets[0]).num_days() as f64 / 360.0;
    // The total return on 1,000 ACME shares from 110, against 4.5% fixed funding.
    let acme = |paying: bool| -> Outcome<AnyInstrument> {
        Ok(funded(
            EquityTotalReturnSwap::new("ACME", usd, 1000.0, 110.0, resets.clone())?,
            paying,
        ))
    };

    // Receiving the total return: the shares' gain since the period began, less
    // the funding accrued on the notional they started at, on ACT/360.
    let receiver = acme(false)?.npv(&market)?;
    let by_formula = 1000.0 * (120.0 - 110.0) - 1000.0 * 110.0 * FUNDING * elapsed;
    println!("receiver    {receiver:.2}");
    println!("by formula  {by_formula:.2}");

    // Paying the total return is the same swap from the other side.
    let payer = acme(true)?.npv(&market)?;
    println!("payer       {payer:.2}");

    // A dividend gone ex during the period is part of the return: 0.80 a share.
    let with_dividend = market.clone().with_fixings(FixingStore::from_observations(&[(
        "DIV-ACME",
        date((2026, 8, 14)),
        0.80,
    )])?);
    let paid_out = acme(false)?.npv(&with_dividend)?;
    println!("with div    {paid_out:.2}");

    // On a basket, each name returns on its own spot, and the funding accrues on
    // the sum of quantity times initial price.
    let basket = funded(
        EquityTotalReturnSwap::basket(
            vec![
                ("ACME".to_owned(), 1000.0, 110.0),
                ("BETA".to_owned(), 2000.0, 50.0),
            ],
            usd,
            resets.clone(),
        )?,
        false,
    );
    let gains = 1000.0 * (120.0 - 110.0) + 2000.0 * (45.0 - 50.0);
    let funding = (1000.0 * 110.0 + 2000.0 * 50.0) * FUNDING * elapsed;
    println!("basket      {:.2}", basket.npv(&market)?);
    println!("by formula  {:.2}", gains - funding);

    Ok(())
}

import datetime as dt

import helixio as hlx
from desk_sheets import SOFR_CLOSE_DATE, USD_SOFR_CLOSE

market = (
    hlx.MarketContext(SOFR_CLOSE_DATE)
    .with_recipe_quotes("USD", USD_SOFR_CLOSE)
    .with_equity_spot("ACME", 120.0)
    .with_equity_spot("BETA", 45.0)
)
# Semi-annual resets; the first period started in July, before the close.
RESETS = [dt.date(2026, 7, 1), dt.date(2027, 1, 4), dt.date(2027, 7, 1)]
FUNDING = 0.045
ELAPSED = (SOFR_CLOSE_DATE - RESETS[0]).days / 360.0

def acme(**kw):
    """The total return on 1,000 ACME shares from 110, against 4.5% fixed funding."""
    return hlx.products.equity_total_return_swap(
        "ACME", "USD", quantity=1000.0, initial_price=110.0, reset_schedule=RESETS, funding_rate=FUNDING, **kw
    )

# Receiving the total return: the shares' gain since the period began, less
# the funding accrued on the notional they started at, on ACT/360.
receiver = acme().npv(market)
by_formula = 1000.0 * (120.0 - 110.0) - 1000.0 * 110.0 * FUNDING * ELAPSED
print(f"receiver    {receiver:.2f}")
print(f"by formula  {by_formula:.2f}")

# Paying the total return is the same swap from the other side.
payer = acme(paying_total_return=True).npv(market)
print(f"payer       {payer:.2f}")

# A dividend gone ex during the period is part of the return: 0.80 a share.
with_dividend = market.with_fixings([("DIV-ACME", dt.date(2026, 8, 14), 0.80)])
paid_out = acme().npv(with_dividend)
print(f"with div    {paid_out:.2f}")

# On a basket, each name returns on its own spot, and the funding accrues on
# the sum of quantity times initial price.
basket = hlx.products.equity_basket_total_return_swap(
    [("ACME", 1000.0, 110.0), ("BETA", 2000.0, 50.0)], "USD", reset_schedule=RESETS, funding_rate=FUNDING
)
gains = 1000.0 * (120.0 - 110.0) + 2000.0 * (45.0 - 50.0)
funding = (1000.0 * 110.0 + 2000.0 * 50.0) * FUNDING * ELAPSED
print(f"basket      {basket.npv(market):.2f}")
print(f"by formula  {gains - funding:.2f}")