Binary options

Cash-or-nothing binary options. The call pays 1 if spot > strike at expiry, otherwise 0; the put is symmetric. Greek functions return both call and put values in a single call.

Contract: Binary.sol

Functions

Function	Gas	Description
binaryCallPrice	2,018	Cash-or-nothing call: e^(−r·τ) · Φ(d₂)
binaryPutPrice	2,023	Cash-or-nothing put
binaryDelta	1,822	First derivative w.r.t. spot — returns (Δcall, Δput)
binaryGamma	1,964	Second derivative w.r.t. spot — returns (Γcall, Γput)
binaryTheta	3,350	Time decay, per day — returns (Θcall, Θput)
binaryVega	1,910	Sensitivity per 1% vol — returns (νcall, νput)

npm install defimath-lib

Conventions

spot, strike — uint128, 18-decimal fixed-point (1e18 = 1.0).
timeToExp — uint32, seconds to expiration.
volatility — uint64, annualized vol as 18-decimal fixed-point (e.g. 50% → 5e17).
rate — uint64, annualized risk-free rate as 18-decimal fixed-point.
Unit payout. All results assume a payout of 1. Multiply the result externally for an arbitrary payout Q.
All functions are internal pure.

Quick example

solidity

import "defimath-lib/contracts/derivatives/Binary.sol";

uint256 binCall = DeFiMathBinary.binaryCallPrice(spot, strike, timeToExp, vol, rate);
uint256 binPut  = DeFiMathBinary.binaryPutPrice (spot, strike, timeToExp, vol, rate);

// All binary Greeks return (call, put) tuples.
(int128 dC, int128 dP) = DeFiMathBinary.binaryDelta(spot, strike, timeToExp, vol, rate);

Important notes

All four Greeks return tuples. Unlike vanilla options (where gamma and vega are equal for call and put under put-call parity), binary call and put have different second-order sensitivities — so all of binaryDelta, binaryGamma, binaryTheta, and binaryVega return (call, put).
Unit payout — scale externally. To price a digital with payout Q, compute the unit-payout price and multiply by Q on the call site.
binaryTheta is per day. The result is the price change for a one-day decrease in time to expiration.
binaryVega is per 1% vol. The result is the price change for a 1-percentage-point change in volatility.
When to use binary vs. vanilla. Use binaries when the payout is discrete (prediction markets, depeg coverage, threshold hedges). For continuous payoff structures, reach for the Options module.

Every function reverts on out-of-bounds inputs with a named error — see the per-function pages for limits and error specifics.

Testing

Hardhat correctness layer. 109 tests across 6 function groups (binary call, put, delta, gamma, theta, vega). Validated against a JavaScript reference derived from the closed-form cash-or-nothing pricing equations over 5×5×3×3 strike/time/vol/rate matrices. Limits-and-near-limits sweeps probe all four parameter boundaries; failure tests cover every documented revert path.

Foundry property-fuzz layer. 13 mathematical properties × 32,000 random runs each = 416,000 random executions per CI run.

Category	Count	What they check
Monotonicity	4	binary call ↑ in spot, put ↓ in spot, call ↓ in strike, put ↑ in strike
Identities	3	binary put-call parity (`BC + BP = e^−rT`), `δ_call + δ_put = 0`, `θ_call + θ_put = r·e^−rT/365`
Output bounds	4	`BC ∈ [0, 1]`, `BP ∈ [0, 1]`, `δ_call ≥ 0`, `δ_put ≤ 0`
Symmetries	2	`γ_call = −γ_put`, `ν_call = −ν_put` (unique to binary — BC+BP is constant in spot and vol)

Sources: test/Binary.test.mjs · test/foundry/Binary.t.sol