quantbt-engine 1.0.7__py3-none-any.whl

quantbt/options/margin.py

@@ -0,0 +1,311 @@
+"""
+Option margin and liquidation approximations.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from enum import Enum
+from typing import Dict, Optional, Protocol, Tuple
+
+import pandas as pd
+
+from ..core.orders import Fill
+from ..core.schema import LiquiditySide, OrderSide
+from .ledger import OptionLedger
+from .schema import OptionInstrumentSpec
+
+
+class OptionMarginModel(str, Enum):
+    LONG_PREMIUM_ONLY = "long_premium_only"
+    STANDARD_VENUE_APPROX = "standard_venue_approx"
+    SCENARIO_PM_APPROX = "scenario_pm_approx"
+    NO_MARGIN_RESEARCH = "no_margin_research"
+    EXTERNAL_VALIDATOR = "external_validator"
+
+
+class ExternalOptionMarginValidator(Protocol):
+    def calculate_margin(
+        self,
+        ledger: OptionLedger,
+        instruments: Dict[str, OptionInstrumentSpec],
+        marks: Dict[str, float],
+        underlying_prices: Dict[str, float],
+        reporting_currency: str,
+        conversion_rates: Dict[str, float],
+    ) -> "OptionMarginRequirement":
+        ...
+
+
+@dataclass(frozen=True)
+class OptionMarginConfig:
+    model: OptionMarginModel = OptionMarginModel.STANDARD_VENUE_APPROX
+    maintenance_ratio: float = 0.20
+    long_option_margin_rate: float = 1.0
+    short_option_margin_rate: float = 0.15
+    scenario_shocks: Tuple[float, ...] = (-0.20, -0.10, 0.0, 0.10, 0.20)
+    liquidation_fee_rate: float = 0.0
+    metadata: Dict = field(default_factory=dict)
+
+    def __post_init__(self) -> None:
+        object.__setattr__(self, "model", _coerce_model(self.model))
+        if self.maintenance_ratio < 0.0:
+            raise ValueError("maintenance_ratio must be >= 0")
+        if self.long_option_margin_rate < 0.0 or self.short_option_margin_rate < 0.0:
+            raise ValueError("margin rates must be >= 0")
+        if self.liquidation_fee_rate < 0.0:
+            raise ValueError("liquidation_fee_rate must be >= 0")
+        if not self.scenario_shocks:
+            raise ValueError("scenario_shocks cannot be empty")
+
+
+@dataclass(frozen=True)
+class OptionMarginRequirement:
+    initial_margin: float
+    maintenance_margin: float
+    model: OptionMarginModel
+    venue_exact: bool
+    reporting_currency: str
+    detail_report: pd.DataFrame
+    metadata: Dict = field(default_factory=dict)
+
+
+@dataclass(frozen=True)
+class OptionLiquidationAudit:
+    breached: bool
+    breach_reason: str
+    equity_before: float
+    maintenance_margin: float
+    equity_after: float
+    final_cash: Dict[str, float]
+    final_positions: Dict[str, float]
+    liquidation_orders: pd.DataFrame
+    metadata: Dict = field(default_factory=dict)
+
+
+def calculate_option_margin(
+    ledger: OptionLedger,
+    instruments: Dict[str, OptionInstrumentSpec],
+    marks: Dict[str, float],
+    underlying_prices: Dict[str, float],
+    *,
+    config: Optional[OptionMarginConfig] = None,
+    reporting_currency: str = "USD",
+    conversion_rates: Optional[Dict[str, float]] = None,
+    external_validator: Optional[ExternalOptionMarginValidator] = None,
+) -> OptionMarginRequirement:
+    cfg = config or OptionMarginConfig()
+    rates = conversion_rates or {}
+    if cfg.model is OptionMarginModel.EXTERNAL_VALIDATOR:
+        if external_validator is None:
+            raise ValueError("external_validator is required for external margin model")
+        return external_validator.calculate_margin(ledger, instruments, marks, underlying_prices, reporting_currency, rates)
+    rows = []
+    total_initial = 0.0
+    for symbol, position in ledger.positions.items():
+        if position.is_flat:
+            continue
+        instrument = instruments.get(symbol)
+        if instrument is None:
+            raise ValueError(f"missing instrument for {symbol}")
+        mark = _positive_map_value(marks, symbol, "mark")
+        conversion = _conversion_rate(instrument.premium_currency, rates, reporting_currency)
+        qty = float(position.qty)
+        abs_qty = abs(qty)
+        long_value = max(qty, 0.0) * mark * instrument.multiplier * conversion
+        short_abs_value = max(-qty, 0.0) * mark * instrument.multiplier * conversion
+        underlying = _underlying_price(instrument, underlying_prices)
+        underlying_notional = abs_qty * underlying * instrument.multiplier * _conversion_rate(instrument.quote_currency, rates, reporting_currency)
+        if cfg.model is OptionMarginModel.NO_MARGIN_RESEARCH:
+            requirement = 0.0
+            reason = "research_no_margin"
+        elif cfg.model is OptionMarginModel.LONG_PREMIUM_ONLY:
+            requirement = long_value * cfg.long_option_margin_rate
+            reason = "long_premium_only"
+        elif cfg.model is OptionMarginModel.STANDARD_VENUE_APPROX:
+            requirement = long_value * cfg.long_option_margin_rate + max(short_abs_value, underlying_notional * cfg.short_option_margin_rate)
+            reason = "standard_short_notional_approx"
+        elif cfg.model is OptionMarginModel.SCENARIO_PM_APPROX:
+            requirement = _scenario_requirement(position_qty=qty, mark=mark, underlying=underlying, instrument=instrument, cfg=cfg, conversion=conversion)
+            reason = "scenario_pm_approx"
+        else:
+            raise ValueError(f"unsupported margin model: {cfg.model}")
+        total_initial += requirement
+        rows.append(
+            {
+                "symbol": symbol,
+                "qty": qty,
+                "mark": mark,
+                "underlying_price": underlying,
+                "premium_currency": instrument.premium_currency,
+                "requirement": float(requirement),
+                "reason": reason,
+                "venue_exact": False,
+            }
+        )
+    maintenance = total_initial * cfg.maintenance_ratio
+    ledger.margin_locked[str(reporting_currency).upper()] = float(total_initial)
+    return OptionMarginRequirement(
+        initial_margin=float(total_initial),
+        maintenance_margin=float(maintenance),
+        model=cfg.model,
+        venue_exact=False,
+        reporting_currency=str(reporting_currency).upper(),
+        detail_report=pd.DataFrame(rows),
+        metadata={"venue_exact": False, **cfg.metadata},
+    )
+
+
+def liquidate_option_positions(
+    ledger: OptionLedger,
+    instruments: Dict[str, OptionInstrumentSpec],
+    *,
+    bid_prices: Dict[str, float],
+    ask_prices: Dict[str, float],
+    margin_requirement: OptionMarginRequirement,
+    conversion_rates: Dict[str, float],
+    reporting_currency: str = "USD",
+    timestamp_ns: int,
+    fee_rate: float = 0.0,
+) -> OptionLiquidationAudit:
+    """Liquidate all option positions with adverse bid/ask prices if breached."""
+    equity_before = ledger.equity(
+        conversion_rates=conversion_rates,
+        marks=_marks_from_bbo(bid_prices, ask_prices),
+        instruments=instruments,
+        reporting_currency=reporting_currency,
+    )
+    if equity_before >= margin_requirement.maintenance_margin:
+        return OptionLiquidationAudit(
+            breached=False,
+            breach_reason="equity_above_maintenance",
+            equity_before=float(equity_before),
+            maintenance_margin=float(margin_requirement.maintenance_margin),
+            equity_after=float(equity_before),
+            final_cash=dict(ledger.cash),
+            final_positions={symbol: pos.qty for symbol, pos in ledger.positions.items() if not pos.is_flat},
+            liquidation_orders=pd.DataFrame(),
+            metadata={"venue_exact": margin_requirement.venue_exact},
+        )
+    rows = []
+    for symbol, position in list(ledger.positions.items()):
+        if position.is_flat:
+            continue
+        instrument = instruments.get(symbol)
+        if instrument is None:
+            raise ValueError(f"missing instrument for {symbol}")
+        if position.qty > 0.0:
+            side = OrderSide.SELL
+            price = _positive_map_value(bid_prices, symbol, "bid")
+        else:
+            side = OrderSide.BUY
+            price = _positive_map_value(ask_prices, symbol, "ask")
+        qty = abs(float(position.qty))
+        fee = qty * price * instrument.multiplier * float(fee_rate)
+        fill = Fill(
+            timestamp=int(timestamp_ns),
+            symbol=symbol,
+            side=side,
+            qty=qty,
+            price=price,
+            fee=fee,
+            liquidity=LiquiditySide.TAKER,
+            metadata={"liquidation": True, "adverse_bid_ask": True},
+        )
+        ledger.apply_fill(fill, instrument, timestamp_ns=timestamp_ns)
+        rows.append(
+            {
+                "timestamp_ns": int(timestamp_ns),
+                "symbol": symbol,
+                "side": side.value,
+                "qty": qty,
+                "price": price,
+                "fee": fee,
+                "reason": "maintenance_margin_breach",
+                "adverse_bid_ask": True,
+            }
+        )
+    equity_after = ledger.equity(
+        conversion_rates=conversion_rates,
+        marks=_marks_from_bbo(bid_prices, ask_prices),
+        instruments=instruments,
+        reporting_currency=reporting_currency,
+    )
+    return OptionLiquidationAudit(
+        breached=True,
+        breach_reason="maintenance_margin_breach",
+        equity_before=float(equity_before),
+        maintenance_margin=float(margin_requirement.maintenance_margin),
+        equity_after=float(equity_after),
+        final_cash=dict(ledger.cash),
+        final_positions={symbol: pos.qty for symbol, pos in ledger.positions.items() if not pos.is_flat},
+        liquidation_orders=pd.DataFrame(rows),
+        metadata={
+            "venue_exact": margin_requirement.venue_exact,
+            "liquidation_sequence": "all_positions_adverse_bid_ask",
+            "fee_rate": float(fee_rate),
+        },
+    )
+
+
+def _scenario_requirement(
+    *,
+    position_qty: float,
+    mark: float,
+    underlying: float,
+    instrument: OptionInstrumentSpec,
+    cfg: OptionMarginConfig,
+    conversion: float,
+) -> float:
+    if position_qty >= 0.0:
+        return abs(position_qty) * mark * instrument.multiplier * conversion * cfg.long_option_margin_rate
+    worst_loss = 0.0
+    base_value = mark
+    for shock in cfg.scenario_shocks:
+        shocked_mark = max(mark * (1.0 + abs(float(shock)) * underlying / max(underlying, 1e-12)), 0.0)
+        pnl = float(position_qty) * (shocked_mark - base_value) * instrument.multiplier * conversion
+        worst_loss = max(worst_loss, -pnl)
+    floor = abs(position_qty) * underlying * instrument.multiplier * conversion * cfg.short_option_margin_rate
+    return max(worst_loss, floor)
+
+
+def _underlying_price(instrument: OptionInstrumentSpec, underlying_prices: Dict[str, float]) -> float:
+    if instrument.underlying_id in underlying_prices:
+        return _positive_map_value(underlying_prices, instrument.underlying_id, "underlying")
+    return _positive_map_value(underlying_prices, instrument.symbol, "underlying")
+
+
+def _marks_from_bbo(bid_prices: Dict[str, float], ask_prices: Dict[str, float]) -> Dict[str, float]:
+    symbols = set(bid_prices).union(ask_prices)
+    return {symbol: 0.5 * (_positive_map_value(bid_prices, symbol, "bid") + _positive_map_value(ask_prices, symbol, "ask")) for symbol in symbols}
+
+
+def _positive_map_value(values: Dict[str, float], key: str, label: str) -> float:
+    if key not in values:
+        raise ValueError(f"missing {label} for {key}")
+    value = float(values[key])
+    if value <= 0.0:
+        raise ValueError(f"{label} for {key} must be > 0")
+    return value
+
+
+def _conversion_rate(currency: str, conversion_rates: Dict[str, float], reporting_currency: str) -> float:
+    ccy = str(currency).upper()
+    report = str(reporting_currency).upper()
+    if ccy == report:
+        return 1.0
+    if ccy not in conversion_rates:
+        raise ValueError(f"missing conversion rate for {ccy}->{report}")
+    rate = float(conversion_rates[ccy])
+    if rate <= 0.0:
+        raise ValueError(f"conversion rate for {ccy}->{report} must be > 0")
+    return rate
+
+
+def _coerce_model(value) -> OptionMarginModel:
+    if isinstance(value, OptionMarginModel):
+        return value
+    try:
+        return OptionMarginModel(str(value))
+    except ValueError as exc:
+        raise ValueError("invalid option margin model") from exc

quantbt/options/packages.py

@@ -0,0 +1,147 @@
+"""
+Option package intents and compiler.
+
+This layer turns option-domain package legs into QuantBT `OrderIntent` leaves.
+It does not execute orders or maintain a ledger.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from enum import Enum
+from typing import Dict, Optional, Sequence, Tuple, Union
+
+from ..core.orders import OrderIntent
+from ..core.schema import OrderSide, OrderType, TimeInForce
+
+
+class OptionPackageExecutionPolicy(str, Enum):
+    ATOMIC_ALL_OR_NONE = "atomic_all_or_none"
+    BEST_EFFORT = "best_effort"
+    SEQUENTIAL = "sequential"
+    HEDGE_AFTER_PRIMARY = "hedge_after_primary"
+    REBALANCE_ONLY = "rebalance_only"
+
+
+@dataclass(frozen=True)
+class OptionPackageLeg:
+    """
+    One option leg inside a package.
+
+    `side` owns direction. `ratio` is always positive and scales from package
+    quantity, so callers cannot hide direction in a negative ratio.
+    """
+
+    instrument_id: str
+    side: Union[OrderSide, str]
+    ratio: float
+    order_type: Union[OrderType, str] = OrderType.MARKET
+    limit_price: Optional[float] = None
+    tif: Union[TimeInForce, str] = TimeInForce.FOK
+    role: str = "leg"
+    tag: Optional[str] = None
+    metadata: Dict = field(default_factory=dict)
+
+    def __post_init__(self) -> None:
+        object.__setattr__(self, "side", _coerce_enum(OrderSide, self.side, "side"))
+        object.__setattr__(self, "order_type", _coerce_enum(OrderType, self.order_type, "order_type"))
+        object.__setattr__(self, "tif", _coerce_enum(TimeInForce, self.tif, "tif"))
+        if not self.instrument_id:
+            raise ValueError("instrument_id is required")
+        if self.ratio <= 0.0:
+            raise ValueError("ratio must be > 0; side owns direction")
+        if self.order_type not in (OrderType.MARKET, OrderType.LIMIT):
+            raise ValueError("Phase 4 option package legs support market and limit orders only")
+        if self.order_type in (OrderType.LIMIT, OrderType.STOP_LIMIT):
+            if self.limit_price is None or self.limit_price <= 0.0:
+                raise ValueError("limit option legs require limit_price > 0")
+        if not self.role:
+            raise ValueError("role is required")
+
+
+@dataclass(frozen=True)
+class OptionPackageIntent:
+    timestamp_ns: int
+    package_id: str
+    legs: Tuple[OptionPackageLeg, ...]
+    quantity: float = 1.0
+    execution_policy: Union[OptionPackageExecutionPolicy, str] = OptionPackageExecutionPolicy.ATOMIC_ALL_OR_NONE
+    max_debit: Optional[float] = None
+    min_credit: Optional[float] = None
+    tag: Optional[str] = None
+    metadata: Dict = field(default_factory=dict)
+
+    def __post_init__(self) -> None:
+        object.__setattr__(
+            self,
+            "execution_policy",
+            _coerce_enum(OptionPackageExecutionPolicy, self.execution_policy, "execution_policy"),
+        )
+        object.__setattr__(self, "timestamp_ns", int(self.timestamp_ns))
+        object.__setattr__(self, "legs", tuple(self.legs))
+        if self.timestamp_ns <= 0:
+            raise ValueError("timestamp_ns must be > 0")
+        if not self.package_id:
+            raise ValueError("package_id is required")
+        if len(self.legs) == 0:
+            raise ValueError("OptionPackageIntent requires at least one leg")
+        if self.quantity <= 0.0:
+            raise ValueError("quantity must be > 0")
+        if self.max_debit is not None and self.max_debit < 0.0:
+            raise ValueError("max_debit must be >= 0")
+        if self.min_credit is not None and self.min_credit < 0.0:
+            raise ValueError("min_credit must be >= 0")
+
+
+def compile_option_package_orders(package: OptionPackageIntent) -> Tuple[OrderIntent, ...]:
+    """Compile an option package to `OrderIntent` leaves with package metadata."""
+    orders = []
+    atomicity = _atomicity_label(package.execution_policy)
+    for leg_index, leg in enumerate(package.legs):
+        metadata = {
+            **leg.metadata,
+            "package_id": package.package_id,
+            "package_type": "option_package",
+            "option_package_id": package.package_id,
+            "option_leg_index": int(leg_index),
+            "option_leg_ratio": float(leg.ratio),
+            "option_leg_role": leg.role,
+            "option_execution_policy": package.execution_policy.value,
+            "atomicity": atomicity,
+            "exchange_combo": False,
+            "block_trade_style": False,
+            "simulated_atomicity": package.execution_policy is OptionPackageExecutionPolicy.ATOMIC_ALL_OR_NONE,
+        }
+        qty = float(package.quantity) * float(leg.ratio)
+        order = OrderIntent(
+            timestamp=package.timestamp_ns,
+            symbol=leg.instrument_id,
+            side=leg.side,
+            order_type=leg.order_type,
+            qty=qty,
+            price=leg.limit_price,
+            tif=leg.tif,
+            tag=leg.tag or package.tag,
+            metadata=metadata,
+        )
+        orders.append(order)
+    return tuple(orders)
+
+
+def _atomicity_label(policy: OptionPackageExecutionPolicy) -> str:
+    if policy is OptionPackageExecutionPolicy.ATOMIC_ALL_OR_NONE:
+        return "simulated_all_or_none"
+    if policy is OptionPackageExecutionPolicy.HEDGE_AFTER_PRIMARY:
+        return "simulated_primary_then_hedge"
+    if policy is OptionPackageExecutionPolicy.REBALANCE_ONLY:
+        return "simulated_rebalance_only"
+    return f"simulated_{policy.value}"
+
+
+def _coerce_enum(enum_cls, value, field_name: str):
+    if isinstance(value, enum_cls):
+        return value
+    try:
+        return enum_cls(str(value))
+    except ValueError as exc:
+        raise ValueError(f"{field_name} must be one of {[item.value for item in enum_cls]}") from exc

quantbt/options/pricing.py

@@ -0,0 +1,191 @@
+"""
+Option pricing primitives.
+
+Phase 2 intentionally keeps pricing deterministic and scalar. Execution,
+margin, expiry, and ledger accounting are added in later phases.
+"""
+
+from __future__ import annotations
+
+import math
+from typing import Union
+
+from .schema import OptionKind
+
+
+Number = Union[int, float]
+
+
+def black76_price(
+    forward: Number,
+    strike: Number,
+    time_to_expiry: Number,
+    volatility: Number,
+    option_kind: Union[OptionKind, str],
+    *,
+    discount: Number = 1.0,
+) -> float:
+    """Return linear Black-76 option value in quote currency per 1 underlying."""
+    kind = _coerce_kind(option_kind)
+    fwd, strike_, tau, vol, df = _validate_inputs(forward, strike, time_to_expiry, volatility, discount)
+    intrinsic = black76_intrinsic(fwd, strike_, kind, discount=df)
+    if tau <= 0.0 or vol <= 0.0:
+        return intrinsic
+    d1, d2 = black76_d1_d2(fwd, strike_, tau, vol)
+    if kind is OptionKind.CALL:
+        return df * (fwd * normal_cdf(d1) - strike_ * normal_cdf(d2))
+    return df * (strike_ * normal_cdf(-d2) - fwd * normal_cdf(-d1))
+
+
+def black76_intrinsic(
+    forward: Number,
+    strike: Number,
+    option_kind: Union[OptionKind, str],
+    *,
+    discount: Number = 1.0,
+) -> float:
+    """Return discounted intrinsic value in quote currency."""
+    kind = _coerce_kind(option_kind)
+    fwd = _positive_float(forward, "forward")
+    strike_ = _positive_float(strike, "strike")
+    df = _positive_float(discount, "discount")
+    if kind is OptionKind.CALL:
+        return df * max(fwd - strike_, 0.0)
+    return df * max(strike_ - fwd, 0.0)
+
+
+def black76_parity_value(forward: Number, strike: Number, *, discount: Number = 1.0) -> float:
+    """Return theoretical linear call-put parity value: C - P."""
+    fwd = _positive_float(forward, "forward")
+    strike_ = _positive_float(strike, "strike")
+    df = _positive_float(discount, "discount")
+    return df * (fwd - strike_)
+
+
+def black76_parity_residual(
+    call_price: Number,
+    put_price: Number,
+    forward: Number,
+    strike: Number,
+    *,
+    discount: Number = 1.0,
+) -> float:
+    """Return residual of linear Black-76 put-call parity."""
+    return float(call_price) - float(put_price) - black76_parity_value(forward, strike, discount=discount)
+
+
+def inverse_black76_price_base(
+    forward: Number,
+    strike: Number,
+    time_to_expiry: Number,
+    volatility: Number,
+    option_kind: Union[OptionKind, str],
+    *,
+    discount: Number = 1.0,
+) -> float:
+    """
+    Return inverse option value in base settlement currency.
+
+    The Phase 2 convention prices inverse BTC/ETH options as the corresponding
+    forward Black-76 quote-currency option divided by forward. This gives the
+    expiry payoff shape `max(S-K, 0) / S` for calls and `max(K-S, 0) / S` for
+    puts, and locks inverse parity to `DF * (1 - K/F)`.
+    """
+    fwd = _positive_float(forward, "forward")
+    return black76_price(fwd, strike, time_to_expiry, volatility, option_kind, discount=discount) / fwd
+
+
+def inverse_black76_intrinsic_base(
+    forward: Number,
+    strike: Number,
+    option_kind: Union[OptionKind, str],
+    *,
+    discount: Number = 1.0,
+) -> float:
+    """Return inverse intrinsic value in base settlement currency."""
+    fwd = _positive_float(forward, "forward")
+    return black76_intrinsic(fwd, strike, option_kind, discount=discount) / fwd
+
+
+def inverse_black76_parity_value_base(forward: Number, strike: Number, *, discount: Number = 1.0) -> float:
+    """Return inverse call-put parity value in base settlement currency."""
+    fwd = _positive_float(forward, "forward")
+    strike_ = _positive_float(strike, "strike")
+    df = _positive_float(discount, "discount")
+    return df * (1.0 - strike_ / fwd)
+
+
+def inverse_black76_parity_residual_base(
+    call_price_base: Number,
+    put_price_base: Number,
+    forward: Number,
+    strike: Number,
+    *,
+    discount: Number = 1.0,
+) -> float:
+    """Return residual of inverse put-call parity in base settlement currency."""
+    return (
+        float(call_price_base)
+        - float(put_price_base)
+        - inverse_black76_parity_value_base(forward, strike, discount=discount)
+    )
+
+
+def black76_d1_d2(forward: Number, strike: Number, time_to_expiry: Number, volatility: Number) -> tuple[float, float]:
+    fwd = _positive_float(forward, "forward")
+    strike_ = _positive_float(strike, "strike")
+    tau = _non_negative_float(time_to_expiry, "time_to_expiry")
+    vol = _non_negative_float(volatility, "volatility")
+    if tau <= 0.0 or vol <= 0.0:
+        raise ValueError("d1/d2 require time_to_expiry > 0 and volatility > 0")
+    vol_sqrt_t = vol * math.sqrt(tau)
+    d1 = (math.log(fwd / strike_) + 0.5 * vol * vol * tau) / vol_sqrt_t
+    return d1, d1 - vol_sqrt_t
+
+
+def normal_pdf(x: Number) -> float:
+    value = float(x)
+    return math.exp(-0.5 * value * value) / math.sqrt(2.0 * math.pi)
+
+
+def normal_cdf(x: Number) -> float:
+    return 0.5 * (1.0 + math.erf(float(x) / math.sqrt(2.0)))
+
+
+def _coerce_kind(option_kind: Union[OptionKind, str]) -> OptionKind:
+    if isinstance(option_kind, OptionKind):
+        return option_kind
+    try:
+        return OptionKind(str(option_kind).lower())
+    except ValueError as exc:
+        raise ValueError("option_kind must be call or put") from exc
+
+
+def _validate_inputs(
+    forward: Number,
+    strike: Number,
+    time_to_expiry: Number,
+    volatility: Number,
+    discount: Number,
+) -> tuple[float, float, float, float, float]:
+    return (
+        _positive_float(forward, "forward"),
+        _positive_float(strike, "strike"),
+        _non_negative_float(time_to_expiry, "time_to_expiry"),
+        _non_negative_float(volatility, "volatility"),
+        _positive_float(discount, "discount"),
+    )
+
+
+def _positive_float(value: Number, name: str) -> float:
+    out = float(value)
+    if not math.isfinite(out) or out <= 0.0:
+        raise ValueError(f"{name} must be finite and > 0")
+    return out
+
+
+def _non_negative_float(value: Number, name: str) -> float:
+    out = float(value)
+    if not math.isfinite(out) or out < 0.0:
+        raise ValueError(f"{name} must be finite and >= 0")
+    return out