Contract odds

// Contract Odds: one option contract of the chart's own chain held to its expiry, read as odds. A card at the bottom
// of the pane, in the terminal look, answers one question first: what are the odds this trade makes money, and how
// much of a bankroll would Kelly put on it? Under the answer: the probability of profit at expiry, the breakeven, the
// premium and where it came from, the most the position can make and lose per contract, the odds ratio and the Kelly
// fractions (full, half and quarter).
// The chart does not tell an indicator which contract it shows, so the settings name it: the strike (0 = the strike
// nearest the expiry's forward), the expiry (0 = the first expiry after today), call or put, long or short, and the
// premium (0 = the chart's close on the contract's own chart, else the model price from the contract's IV). The
// probability is lognormal from the contract's IV, with a risk-neutral drift at the rate on a stock (none on a futures
// or crypto forward). Kelly is p - (1 - p) / odds, odds the most it can make over the most it can lose: an unlimited
// gain reads p, an unlimited loss no edge; full Kelly here takes no volatility adjustment (1). The chain rides the
// live bar only: history bars draw nothing, and everything is measured on the last bar.

section("Contract");
param.price("strike", 0.0, { label: "Strike", description: "The contract's strike; 0 = the listed strike nearest the expiry's forward" });
param.time("expiry", 0, { label: "Expiry date", description: "The contract's expiry date; 0 = the first expiry after today" });
param.choice("type", ["call", "put"], "call", { label: "Type" });
param.choice("position", ["long", "short"], "long", { label: "Position", description: "long: bought, paying the premium; short: sold, collecting it" });
param.number("premium", 0, { min: 0, label: "Premium", description: "The price per unit paid or received; 0 = the chart's close on the contract's own chart, else the model price from its IV" });
param.number("rate_pct", 4, { min: 0, max: 20, step: 0.25, label: "Rate, percent", description: "The rate the model price and the stock's drift use; a crypto chain prices at 0" });
input("close", ohlcv.close); // the chart's own close: the premium on the contract's own chart, spot where a contract reports none
input("chain", options_chain.cells, { max_cells: 4000, venue: "auto", description: "The chart's own option chain: OPRA on a US stock or one of its contracts, CME on futures, Deribit on BTC and ETH" }); // [strike, expiry_ms, side, oi, gamma, delta, mark_iv, underlying, multiplier, vega] per contract
market.zone(); // the market's clock: 0 UTC (crypto), 1 New York (US stocks), 2 Chicago (CME): the calendar and the model
// The readings, data-only: the card's tiles read them and the Console can too. Each is NaN on history bars.
output("matched_strike", none, overlay, { description: "The matched contract's strike; live bar only" });
output("expiry_days", none, overlay, { description: "Days to the matched expiry on the market's own calendar, 0 on the expiry day" });
output("contract_iv", none, overlay, { description: "The matched contract's implied volatility, percent a year" });
output("premium_used", none, overlay, { description: "The premium per unit the readings use (see premium_source)" });
output("premium_source", none, overlay, { description: "Where the premium came from: 0 the Premium setting, 1 the chart's close, 2 the model price" });
output("breakeven", none, overlay, { description: "The underlying's price at expiry where the position breaks even: strike plus the premium on a call, minus it on a put" });
output("prob_profit", none, overlay, { description: "Probability of profit at expiry, percent: lognormal from the contract's IV" });
output("max_gain", none, overlay, { description: "The most one contract can make at expiry, dollars; NaN when unlimited" });
output("max_loss", none, overlay, { description: "The most one contract can lose at expiry, dollars; NaN when unlimited" });
output("odds_ratio", none, overlay, { description: "Max gain over max loss; NaN when either is unlimited" });
output("kelly_full", none, overlay, { description: "Full Kelly, percent of the bankroll: p - (1 - p) / odds, no volatility adjustment; NaN when the loss is unlimited" });
output("kelly_half", none, overlay, { description: "Half Kelly, percent" });
output("kelly_quarter", none, overlay, { description: "Quarter Kelly, percent" });
output("tone", none, overlay, { description: "The headline's colour: 0 no edge (Kelly at or below 0), 1 no reading, 2 an edge; live bar only" });
string("read", { max_bytes: 64 }); // the headline: the position, its odds and half Kelly, or why there is no reading
string("title", { max_bytes: 48 }); // the card's title: the contract, its expiry and the days to go
string("premium_text", { max_bytes: 40 }); // the premium and where it came from
string("gain_text", { max_bytes: 24 }); // dollars, or unlimited
string("loss_text", { max_bytes: 24 });

// The card, in the terminal look: the odds lead as the headline, coloured by Kelly's sign (bear red for no edge, slate
// for no reading, bull green for an edge); the title names the contract. A tile's label is fixed text, so the premium's
// source and an unlimited gain or loss ride string slots.
render.hud("odds", {
  position: "bottom_center",
  look: "terminal",
  title: "{{title}}",
  columns: 2,
  tiles: [
    tile.pill("Odds", "read", { headline: true, color_by: "tone", colors: ["#ff003c", "#94a3b8", "#10b981"] }),
    tile.value("Probability of profit", "prob_profit", { format: "%" }),
    tile.value("Breakeven", "breakeven", { format: "price" }),
    tile.rows([
      ["1) Premium", "premium_text"],
      ["2) Max gain", "gain_text"],
      ["3) Max loss", "loss_text"],
      ["4) Odds ratio", "odds_ratio", "0.00"],
      ["5) Full Kelly", "kelly_full", "%"],
      ["6) Half Kelly", "kelly_half", "%"],
      ["7) Quarter Kelly", "kelly_quarter", "%"],
      ["Implied volatility", "contract_iv", "%"],
    ]),
  ],
});

const TUPLE = 10; // f64s per contract: strike, expiry_ms, side, oi, gamma, delta, mark_iv, underlying, multiplier, vega
const MIN_T_MS = 900000.0; // 15 minutes: a contract closer to its expiry prices no time left, as the chart's greeks do
const MONTHS: String[] = ["JAN", "FEB", "MAR", "APR", "MAY", "JUN", "JUL", "AUG", "SEP", "OCT", "NOV", "DEC"];
const greeks = new Greeks(); // the model price; allocated once
const dateClock = new Clock("UTC"); // reads a date from its day number

let pickStrike = 0.0; // settings, read in onStart()
let pickDay: f64 = NaN; // the picked expiry's date, days since 1970-01-01; NaN = the first expiry after today
let isCall = true;
let isLong = true;
let pickPremium = 0.0;
let rate = 0.04;
let zone = 0;
let close: f64 = NaN; // this bar
let t: f64 = NaN;
let why = ""; // the no-reading line, set by measure()
let matched = false; // a contract was matched on the live bar
let strike: f64 = NaN; // the readings, measured on the live bar
let expiryMs: f64 = NaN;
let days: f64 = NaN;
let ivPoints: f64 = NaN;
let premium: f64 = NaN;
let source = 0;
let breakeven: f64 = NaN;
let prob: f64 = NaN;
let gain: f64 = NaN; // dollars; Infinity when unlimited
let loss: f64 = NaN;
let kelly: f64 = NaN; // raw Kelly as a fraction; -Infinity when the loss is unlimited

function onStart(): void {
  pickStrike = p_strike();
  pickDay = p_expiry() > 0.0 ? Math.floor(p_expiry() / 86400.0) : NaN; // the picker's UTC date
  isCall = p_type() == 0.0;
  isLong = p_position() == 0.0;
  pickPremium = p_premium();
  zone = i32(p_market_zone());
  rate = zone == 0 ? 0.0 : p_rate_pct() / 100.0; // crypto chains are quoted at a rate of 0
}

function fin(v: f64): f64 { // an output never carries an infinity: NaN stands for "unlimited" and "none"
  return isFinite(v) ? v : NaN;
}

// ── The contract: the expiry, then the strike on the picked side ──
function pickExpiry(cells: StaticArray<f64>, n: i32, nowMs: f64, todayKey: f64): f64 { // the expiry the settings name; NaN when the chain lists none
  let best = Infinity;
  for (let i = 0; i + TUPLE - 1 < n; i += TUPLE) {
    const e = cells[i + 1];
    if (!(cells[i] > 0.0) || !(e > nowMs) || e >= best) continue;
    const day = optionsTradeDay(e, zone); // a calendar question: the expiry's trade date on the market's own clock
    if (isNaN(pickDay) ? day > todayKey : day == pickDay) best = e;
  }
  return best == Infinity ? NaN : best;
}
function pickContract(cells: StaticArray<f64>, n: i32, expiry: f64, nowMs: f64): i32 { // the cell index of the contract; -1 when the side lists none
  let at = -1;
  let gap = Infinity;
  for (let i = 0; i + TUPLE - 1 < n; i += TUPLE) {
    if (cells[i + 1] != expiry || !(cells[i] > 0.0) || (cells[i + 2] > 0.0) != isCall) continue;
    let target = pickStrike;
    if (!(target > 0.0)) { // the strike nearest the expiry's forward: spot carried at the rate on a stock, the underlying itself elsewhere
      const under = cells[i + 7] > 0.0 ? cells[i + 7] : close;
      target = zone == 1 ? under * Math.exp((rate * (expiry - nowMs)) / OPTIONS_YEAR_MS) : under;
    }
    const d = Math.abs(cells[i] - target);
    if (d < gap || (d == gap && at >= 0 && cells[i] < cells[at])) {
      gap = d;
      at = i;
    }
  }
  return at;
}

// ── The odds, measured on the live bar ──
function measure(n: i32): void {
  const cells = in_chain_view(); // the live chain in place: the first n values of the build's own buffer
  const nowMs = chainPricedAtMs(cells, n, t * 1000.0); // when the chart priced the chain
  const todayKey = optionsTradeDay(nowMs, zone);
  matched = false;
  let live = false;
  for (let i = 0; i + TUPLE - 1 < n; i += TUPLE) if (cells[i] > 0.0 && cells[i + 1] > nowMs) live = true;
  if (!live) {
    why = "No live expiry in the chain";
    return;
  }
  expiryMs = pickExpiry(cells, n, nowMs, todayKey);
  if (isNaN(expiryMs)) {
    why = isNaN(pickDay) ? "No expiry after today in the chain" : "No expiry on the picked date";
    return;
  }
  const at = pickContract(cells, n, expiryMs, nowMs);
  if (at < 0) {
    why = isCall ? "No call listed at that expiry" : "No put listed at that expiry";
    return;
  }
  matched = true;
  strike = cells[at];
  days = optionsTradeDay(expiryMs, zone) - todayKey;
  ivPoints = cells[at + 6] > 0.0 ? cells[at + 6] : NaN; // mark IV rides the chain in percentage points
  const spot = cells[at + 7] > 0.0 ? cells[at + 7] : close;
  const multiplier = cells[at + 8] > 0.0 ? cells[at + 8] : 1.0;
  const left = expiryMs - nowMs;
  const years = left < MIN_T_MS ? 0.0 : left / OPTIONS_YEAR_MS;
  const sigma = ivPoints / 100.0;
  const side = isCall ? 1.0 : -1.0;
  // The premium: the setting, else the chart's close on the contract's own chart (a close far from the underlying is
  // the option's own price), else the model price from the contract's IV.
  if (pickPremium > 0.0) {
    premium = pickPremium;
    source = 0;
  } else if (close > 0.0 && Math.abs(close / spot - 1.0) > 0.2) {
    premium = close;
    source = 1;
  } else {
    premium = zone == 1 ? greeks.spot(side, spot, strike, years, sigma, rate) : greeks.forward(side, spot, strike, years, sigma, rate);
    source = 2;
  }
  breakeven = isCall ? strike + premium : strike - premium;
  // The probability the underlying ends past the breakeven: lognormal at the IV, drifting at the rate on a stock's spot,
  // not at all on a forward; at expiry the answer is spot's own side of it.
  const drift = zone == 1 ? rate : 0.0;
  let above: f64 = NaN; // P(underlying at expiry > breakeven)
  if (isNaN(breakeven)) above = NaN; // no premium (a contract without IV on the underlying's chart): unavailable
  else if (breakeven <= 0.0) above = 1.0;
  else if (years == 0.0) above = spot > breakeven ? 1.0 : 0.0;
  else if (sigma > 0.0) above = normCdf((Math.log(spot / breakeven) + (drift - 0.5 * sigma * sigma) * years) / (sigma * Math.sqrt(years)));
  const longWins = isCall ? above : 1.0 - above;
  prob = isLong ? longWins : 1.0 - longWins;
  // Per contract at expiry: a long pays the premium and a short collects it; a call's upside has no ceiling, a put's
  // stops at the strike less the premium.
  const capped = (strike - premium) * multiplier; // a put held to a worthless underlying
  const paid = premium * multiplier;
  if (isLong) {
    gain = isCall ? Infinity : capped;
    loss = paid;
  } else {
    gain = paid;
    loss = isCall ? Infinity : capped;
  }
  const odds = gain / loss;
  if (isNaN(prob) || isNaN(odds)) kelly = NaN;
  else if (odds == Infinity) kelly = prob; // nothing to lose against an unlimited gain: Kelly reads p
  else if (!(odds > 0.0)) kelly = -Infinity; // nothing to win, or an unlimited loss: no edge
  else kelly = prob - (1.0 - prob) / odds;
}

// ── Text helpers ──
function sbGrouped(n: i64): void { // 84210 -> 84,210
  if (n >= 1000) {
    sbGrouped(n / 1000);
    sb_text(",");
    const r = n % 1000;
    if (r < 100) sb_text("0");
    if (r < 10) sb_text("0");
    sb_int(r);
  } else sb_int(n);
}
function sbPrice(v: f64): void { // decimals follow the price's size: 67,000 / 660.50 / 4.125
  if (v >= 1000.0) sbGrouped(i64(Math.round(v)));
  else if (v >= 100.0) sb_f64(v, 2);
  else sb_f64(v, 3);
}
function sbDollars(v: f64): void { // $65,590, or unlimited
  if (!isFinite(v)) {
    sb_text("unlimited");
    return;
  }
  if (v < 0.0) {
    sb_text("-");
    v = -v;
  }
  sb_text("$");
  sbGrouped(i64(Math.round(v)));
}
function sbContract(): void { // 660 call, 662.50 put
  if (strike == Math.floor(strike)) sbGrouped(i64(strike));
  else sbPrice(strike);
  sb_text(isCall ? " call" : " put");
}
function writeWords(): void {
  sb_clear();
  sb_text(isLong ? "Long " : "Short ");
  sbContract();
  if (isNaN(prob)) sb_text(": no implied volatility");
  else {
    sb_text(": ");
    sb_f64(prob * 100.0, 1);
    sb_text("% to profit, ");
    if (kelly > 0.0) {
      sb_text("half Kelly ");
      sb_f64(kelly * 50.0, 1);
      sb_text("%");
    } else sb_text("no edge");
  }
  str_read_sb();
  sb_clear();
  dateClock.update(optionsTradeDay(expiryMs, zone) * 86400.0); // the expiry's trade date, read as a date
  if (dateClock.dayOfMonth() < 10) sb_text("0");
  sb_int(dateClock.dayOfMonth());
  sb_text(MONTHS[dateClock.month() - 1]);
  sb_text(" ");
  sbContract();
  sb_text(", ");
  sb_int(i64(days));
  sb_text("d");
  str_title_sb();
  sb_clear();
  if (isNaN(premium)) sb_text("no price");
  else {
    sbPrice(premium);
    sb_text(source == 0 ? ", your premium" : source == 1 ? ", the chart's close" : ", the model price");
  }
  str_premium_text_sb();
  sb_clear();
  if (isNaN(gain)) sb_text("-");
  else sbDollars(gain);
  str_gain_text_sb();
  sb_clear();
  if (isNaN(loss)) sb_text("-");
  else sbDollars(loss);
  str_loss_text_sb();
}

// onBar() runs once per bar: history rows carry an empty block and cost one read; the live bar matches the contract and
// measures its odds, then writes the readings (NaN on history rows) and the card's words.
function onBar(): void {
  close = bar.close();
  t = bar.time();
  let chainCells = -1;
  matched = false;
  if (bar.isLast()) {
    chainCells = in_chain_cells();
    if (chainCells >= TUPLE && !isNaN(t)) measure(chainCells);
    else why = "Waiting for the options chain";
  }
  const full = kelly * 100.0; // percent of the bankroll; the volatility adjustment is 1
  out_matched_strike(matched ? strike : NaN);
  out_expiry_days(matched ? days : NaN);
  out_contract_iv(matched ? ivPoints : NaN);
  out_premium_used(matched ? fin(premium) : NaN);
  out_premium_source(matched && !isNaN(premium) ? f64(source) : NaN);
  out_breakeven(matched ? fin(breakeven) : NaN);
  out_prob_profit(matched ? fin(prob * 100.0) : NaN);
  out_max_gain(matched ? fin(gain) : NaN);
  out_max_loss(matched ? fin(loss) : NaN);
  out_odds_ratio(matched ? fin(gain / loss) : NaN);
  out_kelly_full(matched ? fin(full) : NaN);
  out_kelly_half(matched ? fin(full * 0.5) : NaN);
  out_kelly_quarter(matched ? fin(full * 0.25) : NaN);
  out_tone(matched && !isNaN(kelly) ? (kelly > 0.0 ? 2.0 : 0.0) : bar.isLast() ? 1.0 : NaN);
  if (matched) writeWords();
  else if (bar.isLast()) {
    // Nothing to read: the headline says why, so the card is never a row of blanks.
    sb_clear();
    sb_text(why);
    str_read_sb();
    sb_clear();
    sb_text("no contract read");
    str_title_sb();
  }
}