Klima Protocol: Fee vs. Principal

Revenue and risk for a carbon-retirement intermediary

A carbon-retirement intermediary buys kVCM tokens and burns them on behalf of clients. It can charge clients in one of two ways. A fee is a markup on the token cost; it carries no inventory and no price exposure. A principal price is a fixed USD quote per tonne, with balance-sheet exposure to the spot price. Once the principal book is open, the shape of its loss tail is a design choice. The full derivations live on the Model page.

The intermediary retires \(\lambda\) tonnes per unit time over a horizon \(T\) and sources \(P\) kVCM per tonne at the spot price \(S_t\) (in USD per kVCM). We write \(N = \lambda T\) for the total tonnes retired and \(\Pi\) for a book’s terminal P&L in USD. The fee and back-to-back books share the same random driver: both are linear in the spot integral \(I_T = \int_0^T S_t \, dt\). At the break-even quote \(Q = Q^*\), the fixed USD-per-tonne quote that equalises the two books’ expected P&L \(\mathbb{E}[\Pi]\), the two means coincide. The fee book enters with a positive sign and its revenue is non-negative. The back-to-back book enters with a negative sign: upside is capped at the quote payout \(Q N\), and downside is unbounded. Equal moments are not equal distributions.

A fully matched treasury pre-buys \(k = N P\) kVCM at total USD basis \(C_{\mathrm{basis}} = N P S_0\), where \(S_0\) is the spot at inception. It cancels the \(I_T\) term path by path: treasury consumption contributes \(+ P \lambda I_T\) against the back-to-back book’s \(- P \lambda I_T\). The desk therefore collapses to the deterministic \(N(Q - P S_0)\). Partial coverage \(\alpha = \min(1, k / (N P))\) leaves the uncovered tail \(J_\alpha = \int_{\alpha T}^T S_t \, dt\). Quota-share syndication of the back-to-back book at cession fraction \(\beta \in [0, 1]\) scales the variance by \((1 - \beta)^2\). At the actuarially fair premium (counterparty risk load \(\theta = 0\)), the expected P&L of the retained book \(\mathbb{E}[\Pi_{\mathrm{ret}}]\) does not depend on \(\beta\).

Switching to fee pricing whenever \(S_t \ge H = h S_0\) caps every retirement done above the threshold at non-negative revenue. The threshold multiple \(h \ge 1\) controls how tight the cap is. The switch is symmetric: re-entries below \(H\) resume b2b exposure, so a volatile path near \(H\) can cross it several times. At the defaults with \(h = 1.25\), the 5 % tail-mean loss \(\mathrm{CVaR}_{95}\) falls well below the b2b reference and \(\mathbb{E}[\Pi]\) rises. Tightening \(h\) cuts the tail harder but invites more re-entries. The full symbol table sits in Setup and notation.

---

Specific scenarios

The paragraphs above average over every GBM future. Specific scenarios, such as a mid-year crash or a historical replay, read off a single realised path. The canvas below lets you draw one. Each book’s P&L on that drawn path is then recomputed and shown against its Monte Carlo mean.

NoteHow the drawn curve enters the books

A trapezoid rule over the drawn path yields \(I_T\), the uncovered tail \(J_\alpha\), the switching split against \(H = h S_0\), and the terminal spot \(S_T\). These feed every book on the Simulator. The GBM/Merton dynamics (drift \(\mu\), diffusion \(\sigma\), jumps \(\lambda_J, \mu_J, \sigma_J\)) drive only the overlaid comparison Monte Carlo, seeded by the PRNG slider.

The buttons along the top of the canvas load common shapes. The presets are a flat path at \(S_0\), a linear drift of ±50 %, a mid-horizon crash, a brief spike at \(\tfrac13 T\), a random walk, and a historical kVCM series read from data/kvcm-historical.json (the file is populated by npm run fetch:prices). Clicking and dragging on the canvas draws a freehand path that overrides the preset.

historicalPrices = {
  // Fetched at build by `npm run fetch:prices` (Alchemy Prices API).
  try {
    const r = await fetch("data/kvcm-historical.json");
    if (!r.ok) return { data: [] };
    return await r.json();
  } catch (e) {
    return { data: [] };
  }
}

// X-axis anchor: prefer the fetchedAt timestamp from
// kvcm-historical.json; fall back to the current date. Captured once
// per page load.
buildDate = {
  const iso = historicalPrices && historicalPrices.fetchedAt;
  if (iso) {
    const parsed = new Date(iso);
    if (!isNaN(parsed.getTime())) return parsed;
  }
  return new Date();
}

Price process

viewof pi0 = Inputs.range([0.1, 10000], { step: 0.01, value: 125, transform: Math.log, label: "π₀ (USD / tonne)" })

viewof P = Inputs.range([1, 100000], { step: 0.01, value: 1400, transform: Math.log, label: "P (kVCM / tonne)" })

viewof mu = Inputs.range([-2, 2], { step: 0.005, value: -0.1, label: "drift μ (annualised)" })

viewof sigma2 = Inputs.range([0, 10], {
  step: 0.001, value: 0.0625, label: "variance σ² (annualised)",
  transform: x => Math.log(x + 1e-3),
  invert: y => Math.max(0, Math.exp(y) - 1e-3),
})

Jumps (Merton)

viewof lambdaJ = Inputs.range([0, 100], {
  step: 0.01, value: 20, label: "jump intensity λ_J (/yr)",
  transform: x => Math.log(x + 1e-3),
  invert: y => Math.max(0, Math.exp(y) - 1e-3),
})

viewof muJ = Inputs.range([-0.5, 0.5], { step: 0.01, value: -0.05, label: "mean log-jump μ_J" })

viewof sigmaJ = Inputs.range([0, 1], { step: 0.01, value: 0.35, label: "log-jump SD σ_J" })

Demand & inventory

viewof lambdaDay = Inputs.range([0.001, 10000], { step: 0.001, value: 1, transform: Math.log, label: "retirements (tonnes / day)" })

viewof kPre = Inputs.range([0, 1000000], { step: 1000, value: 300000, label: "initial inventory (kVCM)" })

viewof cBasis = Inputs.range([0, 100000], { step: 100, value: 20000, label: "inventory basis (USD, total)" })

Contract

// Step = 1 avoids a range-input snap when setting value to
// history.length - 1.
viewof Tdays = {
  const hist = (historicalPrices && Array.isArray(historicalPrices.data))
    ? historicalPrices.data
    : [];
  const fallback = 365;
  const dflt = hist.length >= 2
    ? Math.max(30, Math.min(1095, hist.length - 1))
    : fallback;
  return Inputs.range([30, 1095], { step: 1, value: dflt, label: "horizon T (days)" });
}

viewof Q = Inputs.range([0.1, 10000], { step: 0.01, value: 175, transform: Math.log, label: "fixed quote Q (USD / tonne)" })

viewof fee = Inputs.range([0, 1], { step: 0.01, value: 0.4, label: "fee rate f" })

Syndication

viewof beta = Inputs.range([0, 1], { step: 0.01, value: 0, label: "cession β" })

viewof theta = Inputs.range([0, 1], { step: 0.01, value: 0, label: "counterparty load θ" })

viewof premiumMode = Inputs.radio(["sharpe", "cvar"], { value: "sharpe", label: "premium mode" })

Switching

viewof switchOn = Inputs.toggle({ label: "enable switching", value: false })

viewof barrierRatioSlider = Inputs.range([0, 10], {
  step: 0.01, value: 1.25, label: "threshold h = H/S₀",
  transform: x => Math.log(x + 1e-3),
  invert: y => Math.max(0, Math.exp(y) - 1e-3),
})

// Disabled switch ⇒ barrier Infinity.
barrierRatio = switchOn ? barrierRatioSlider : Infinity

viewof feePostSlider = Inputs.range([0, 1], { step: 0.01, value: 0.4, label: "fee-mode rate f_post" })

feePost = feePostSlider

Curve settings

viewof curveYMax = Inputs.range([0.01, 3], { step: 0.005, value: 0.2, label: "canvas y-max (USD / kVCM)" })

viewof seed = Inputs.range([1, 9999], { step: 1, value: 42, label: "PRNG seed" })

findingsResetButton = {
  const hist = (historicalPrices && Array.isArray(historicalPrices.data))
    ? historicalPrices.data
    : [];
  const defaultTdays = hist.length >= 2
    ? Math.max(30, Math.min(1095, hist.length - 1))
    : 365;
  const defaults = {
    pi0: 125, P: 1400,
    mu: -0.1, sigma2: 0.0625,
    lambdaJ: 20, muJ: -0.05, sigmaJ: 0.35,
    lambdaDay: 1, kPre: 300000, cBasis: 20000,
    Tdays: defaultTdays, Q: 175, fee: 0.4,
    beta: 0, theta: 0, premiumMode: "sharpe",
    switchOn: false, barrierRatioSlider: 1.25,
    feePostSlider: 0.4,
    curveYMax: 0.2, seed: 42,
  };
  const views = {
    pi0: viewof pi0, P: viewof P,
    mu: viewof mu, sigma2: viewof sigma2,
    lambdaJ: viewof lambdaJ, muJ: viewof muJ, sigmaJ: viewof sigmaJ,
    lambdaDay: viewof lambdaDay, kPre: viewof kPre, cBasis: viewof cBasis,
    Tdays: viewof Tdays, Q: viewof Q, fee: viewof fee,
    beta: viewof beta, theta: viewof theta, premiumMode: viewof premiumMode,
    switchOn: viewof switchOn, barrierRatioSlider: viewof barrierRatioSlider,
    feePostSlider: viewof feePostSlider,
    curveYMax: viewof curveYMax, seed: viewof seed,
  };
  const wrap = document.createElement("div");
  wrap.className = "pc-reset";
  const btn = document.createElement("button");
  btn.type = "button";
  btn.textContent = "Reset to defaults";
  btn.addEventListener("click", () => {
    for (const k of Object.keys(defaults)) {
      const el = views[k];
      el.value = defaults[k];
      el.dispatchEvent(new CustomEvent("input", { bubbles: true }));
    }
  });
  wrap.appendChild(btn);
  return wrap;
}

import {
  mulberry32, xTicksAnchoredRight, formatTickDate, formatTickCurrency,
  simulate, simulateSwitching, summarise, samplePath,
} from "./lib/compiled/src/core/index.js"

derived = {
  const S0 = P > 0 ? pi0 / P : 0;
  const T = Tdays / 365;
  const lambda = lambdaDay * 365;
  const N = lambda * T;
  const sigma = Math.sqrt(sigma2);
  return { S0, T, lambda, N, sigma };
}

// Comparison MC for the drawn-curve table. Params from sidebar;
// nPaths / nSteps pinned at Simulator defaults.
run = {
  const inputs = {
    S0: derived.S0, mu, sigma: derived.sigma, P,
    lambda: derived.lambda, T: derived.T,
    Q, fee, kPre, cBasis,
    beta, premiumLoad: theta, premiumMode,
    lambdaJ, muJ, sigmaJ,
    nPaths: 5000, nSteps: 100, seed,
  };
  const raw = simulate(inputs);
  const customDeskSamples = new Float64Array(raw.b2bSamples.length);
  for (let i = 0; i < customDeskSamples.length; i++) {
    customDeskSamples[i] = raw.b2bSamples[i] + raw.treasurySamples[i];
  }
  return {
    inputs,
    ...raw,
    customDeskSamples,
    fee: summarise(raw.feeSamples),
    retained: summarise(raw.retainedSamples),
    b2b: summarise(raw.b2bSamples),
    treasury: summarise(raw.treasurySamples),
    customDesk: summarise(customDeskSamples),
  };
}

// Shares `seed` with `run`; switching + treasury composition deferred
// to Validation.
switchRun = {
  const inputs = {
    S0: derived.S0, mu, sigma: derived.sigma, P,
    lambda: derived.lambda, T: derived.T,
    Q, fee,
    barrierRatio, feePost,
    lambdaJ, muJ, sigmaJ,
    nPaths: 5000, nSteps: 100, seed,
  };
  const raw = simulateSwitching(inputs);
  return { inputs, ...raw, summary: summarise(raw.pnlSamples) };
}

Price path

viewof customCurve = {
  // One sample per day. Rightmost point = build-time anchor; leftmost
  // = Tdays ago.
  const TDaysVal = Tdays;
  const nPoints = TDaysVal + 1;
  const width = 820;
  const height = 320;
  const margin = { top: 10, right: 12, bottom: 32, left: 80 };
  const plotW = width - margin.left - margin.right;
  const plotH = height - margin.top - margin.bottom;
  const yMax = curveYMax;
  const S0Val = derived.S0;
  const history = (historicalPrices && Array.isArray(historicalPrices.data))
    ? historicalPrices.data
    : [];
  const seedVal = seed;
  const muVal = mu;
  const lambdaJVal = lambdaJ;
  const muJVal = muJ;
  const sigmaJVal = sigmaJ;

  // Persist drawn curve by days-ago (0 = build-time anchor). NaN =
  // "never drawn" so π₀/P changes refresh the fill via derived S₀.
  const MAX_TDAYS = 1095;
  const masterKey = "__findingsCustomCurveByDaysAgo";
  let master = window[masterKey];
  if (!(master instanceof Float64Array) || master.length !== MAX_TDAYS + 1) {
    master = new Float64Array(MAX_TDAYS + 1);
    master.fill(NaN);
    window[masterKey] = master;
  }

  // "random": slider nudges regenerate path + cloud. Otherwise the
  // curve stays put when jump sliders move. Persisted in `window` so
  // the flag survives cell re-runs.
  const modeKey = "__findingsCustomCurveMode";
  if (typeof window[modeKey] !== "string") window[modeKey] = "custom";

  // Seed the canvas with the historical series on first load.
  const seededKey = "__findingsCustomCurveSeeded";
  if (!window[seededKey]) {
    window[seededKey] = true;
    if (history.length >= 2) {
      const fillCount = Math.min(history.length, MAX_TDAYS + 1);
      for (let daysAgo = 0; daysAgo < fillCount; daysAgo++) {
        master[daysAgo] = history[history.length - 1 - daysAgo].value;
      }
    }
  }

  const values = new Float64Array(nPoints);
  for (let i = 0; i < nPoints; i++) {
    const daysAgo = nPoints - 1 - i;
    const stored = master[daysAgo];
    values[i] = isNaN(stored) ? S0Val : stored;
  }

  // Mirrors simulator's mulberry32(seed) + samplePath; same
  // (seed, μ, σ, λ_J, μ_J, σ_J, T, S₀) yield identical clouds on
  // both pages. Path 0 is promoted to the drawn curve by "Random".
  const N_CLOUD = 20;
  const cloudRng = mulberry32(seedVal);
  const cloud = new Array(N_CLOUD);
  for (let j = 0; j < N_CLOUD; j++) {
    const { S } = samplePath(cloudRng, {
      S0: S0Val,
      mu: muVal,
      sigma: derived.sigma,
      T: derived.T,
      nSteps: nPoints - 1,
      lambdaJ: lambdaJVal, muJ: muJVal, sigmaJ: sigmaJVal,
    });
    cloud[j] = S;
  }

  if (window[modeKey] === "random") {
    for (let i = 0; i < nPoints; i++) values[i] = cloud[0][i];
    for (let i = 0; i < nPoints; i++) master[nPoints - 1 - i] = values[i];
  }

  const container = document.createElement("div");
  container.className = "pc-curve-box";

  const toolbar = document.createElement("div");
  toolbar.className = "pc-curve-toolbar";
  const hint = document.createElement("span");
  hint.className = "hint";
  hint.textContent = "Click and drag on the canvas to draw a price path.";

  const canvas = document.createElement("canvas");
  canvas.className = "pc-curve-canvas";
  canvas.width = width;
  canvas.height = height;
  const ctx = canvas.getContext("2d");

  const indexToX = (i) => margin.left + (i / (nPoints - 1)) * plotW;
  const priceToY = (p) => margin.top + (1 - p / yMax) * plotH;
  const xToIndex = (x) =>
    Math.max(0, Math.min(nPoints - 1, Math.round(((x - margin.left) / plotW) * (nPoints - 1))));
  const yToPrice = (y) =>
    Math.max(0, Math.min(yMax, yMax - ((y - margin.top) / plotH) * yMax));

  const DAY_MS = 86400000;
  const anchor = buildDate;
  const dateForDay = (d) => new Date(anchor.getTime() - (TDaysVal - d) * DAY_MS);
  const xTicks = xTicksAnchoredRight(TDaysVal);
  const showCloud = lambdaJVal > 0 || derived.sigma > 0;
  function redraw() {
    ctx.clearRect(0, 0, width, height);
    ctx.strokeStyle = "#e5e5e5";
    ctx.lineWidth = 1;
    ctx.beginPath();
    for (let g = 1; g < 5; g++) {
      const y = margin.top + (g * plotH) / 5;
      ctx.moveTo(margin.left, y);
      ctx.lineTo(margin.left + plotW, y);
    }
    for (const d of xTicks) {
      if (d <= 0 || d >= TDaysVal) continue;
      const x = margin.left + (d / TDaysVal) * plotW;
      ctx.moveTo(x, margin.top);
      ctx.lineTo(x, margin.top + plotH);
    }
    ctx.stroke();

    ctx.strokeStyle = "#333";
    ctx.strokeRect(margin.left, margin.top, plotW, plotH);

    ctx.fillStyle = "#333";
    ctx.font = "11px ui-monospace, monospace";
    ctx.textAlign = "right";
    ctx.textBaseline = "middle";
    for (let g = 0; g <= 5; g++) {
      const priceVal = yMax * (1 - g / 5);
      const y = margin.top + (g * plotH) / 5;
      ctx.fillText("$" + priceVal.toFixed(3), margin.left - 6, y);
    }
    ctx.textBaseline = "top";
    for (const d of xTicks) {
      const x = margin.left + (d / TDaysVal) * plotW;
      const isRight = d === TDaysVal;
      const isLeft = d === 0;
      ctx.textAlign = isRight ? "right" : isLeft ? "left" : "center";
      ctx.fillText(formatTickDate(dateForDay(d), TDaysVal), x, margin.top + plotH + 6);
    }

    ctx.font = "12px sans-serif";
    ctx.save();
    ctx.translate(14, margin.top + plotH / 2);
    ctx.rotate(-Math.PI / 2);
    ctx.textAlign = "center";
    ctx.fillText("S_t (USD / kVCM)", 0, 0);
    ctx.restore();
    ctx.textAlign = "center";
    ctx.fillText("date", margin.left + plotW / 2, height - 2);

    if (S0Val > 0 && S0Val <= yMax) {
      ctx.strokeStyle = "#2a7";
      ctx.setLineDash([4, 3]);
      ctx.lineWidth = 1;
      ctx.beginPath();
      ctx.moveTo(margin.left, priceToY(S0Val));
      ctx.lineTo(margin.left + plotW, priceToY(S0Val));
      ctx.stroke();
      ctx.setLineDash([]);
      ctx.fillStyle = "#2a7";
      ctx.textAlign = "left";
      ctx.textBaseline = "bottom";
      ctx.font = "11px ui-monospace, monospace";
      ctx.fillText("S₀", margin.left + 4, priceToY(S0Val) - 2);
    }

    if (showCloud) {
      ctx.strokeStyle = "#888";
      ctx.globalAlpha = 0.35;
      ctx.lineWidth = 1;
      ctx.lineJoin = "round";
      for (let j = 0; j < cloud.length; j++) {
        const S = cloud[j];
        ctx.beginPath();
        ctx.moveTo(indexToX(0), priceToY(Math.min(yMax, Math.max(0, S[0]))));
        for (let i = 1; i < nPoints; i++) {
          ctx.lineTo(indexToX(i), priceToY(Math.min(yMax, Math.max(0, S[i]))));
        }
        ctx.stroke();
      }
      ctx.globalAlpha = 1;
    }

    ctx.strokeStyle = "#c94";
    ctx.lineWidth = 2;
    ctx.lineJoin = "round";
    ctx.beginPath();
    ctx.moveTo(indexToX(0), priceToY(values[0]));
    for (let i = 1; i < nPoints; i++) ctx.lineTo(indexToX(i), priceToY(values[i]));
    ctx.stroke();
  }

  function emit() {
    for (let i = 0; i < nPoints; i++) {
      master[nPoints - 1 - i] = values[i];
    }
    container.value = {
      values: Float64Array.from(values),
      nPoints,
    };
    container.dispatchEvent(new CustomEvent("input", { bubbles: true }));
  }

  let lastIdx = null;
  let drawing = false;

  function apply(ev) {
    const rect = canvas.getBoundingClientRect();
    const x = ((ev.clientX - rect.left) * canvas.width) / rect.width;
    const y = ((ev.clientY - rect.top) * canvas.height) / rect.height;
    const idx = xToIndex(x);
    const price = yToPrice(y);
    if (lastIdx === null || lastIdx === idx) {
      values[idx] = price;
    } else {
      const lo = Math.min(idx, lastIdx);
      const hi = Math.max(idx, lastIdx);
      const loP = lastIdx <= idx ? values[lastIdx] : price;
      const hiP = lastIdx <= idx ? price : values[lastIdx];
      for (let k = lo; k <= hi; k++) {
        const frac = (k - lo) / (hi - lo);
        values[k] = loP * (1 - frac) + hiP * frac;
      }
    }
    lastIdx = idx;
  }

  canvas.addEventListener("pointerdown", (ev) => {
    window[modeKey] = "custom";
    ev.preventDefault();
    drawing = true;
    lastIdx = null;
    canvas.setPointerCapture?.(ev.pointerId);
    apply(ev);
    redraw();
    emit();
  });
  canvas.addEventListener("pointermove", (ev) => {
    if (!drawing) return;
    ev.preventDefault();
    apply(ev);
    redraw();
    emit();
  });
  const endStroke = (ev) => {
    drawing = false;
    lastIdx = null;
    if (canvas.hasPointerCapture?.(ev.pointerId)) canvas.releasePointerCapture(ev.pointerId);
  };
  canvas.addEventListener("pointerup", endStroke);
  canvas.addEventListener("pointercancel", endStroke);

  function setPreset(fn) {
    window[modeKey] = "custom";
    for (let i = 0; i < nPoints; i++) values[i] = fn(i / (nPoints - 1));
    redraw();
    emit();
  }
  function addButton(label, fn) {
    const b = document.createElement("button");
    b.type = "button";
    b.textContent = label;
    b.addEventListener("click", fn);
    toolbar.appendChild(b);
  }
  addButton("Flat @ S₀", () => setPreset(() => S0Val));
  addButton("Linear +50%", () => setPreset((u) => S0Val * (1 + 0.5 * u)));
  addButton("Linear −50%", () => setPreset((u) => S0Val * (1 - 0.5 * u)));
  addButton("Crash @ ½T", () =>
    setPreset((u) => (u < 0.5 ? S0Val : S0Val * Math.max(0.05, 1 - 1.6 * (u - 0.5))))
  );
  addButton("Spike @ ⅓T", () => {
    const peak = S0Val * 2.5;
    setPreset((u) => {
      const d = u - 1 / 3;
      return S0Val + (peak - S0Val) * Math.exp(-80 * d * d);
    });
  });
  addButton("Random", () => {
    // Set mode before seed dispatch so the re-run reads modeKey at init.
    window[modeKey] = "random";
    const newSeed = 1 + Math.floor(Math.random() * 9999);
    const seedView = viewof seed;
    seedView.value = newSeed;
    seedView.dispatchEvent(new CustomEvent("input", { bubbles: true }));
  });
  const historicalBtn = document.createElement("button");
  historicalBtn.type = "button";
  historicalBtn.textContent = history.length >= 2 ? "Historical" : "Historical (unavailable)";
  historicalBtn.disabled = history.length < 2;
  historicalBtn.addEventListener("click", () => {
    // Flag before Tdays dispatch; right-align the daily series.
    window[modeKey] = "custom";
    const dayCount = history.length;
    const targetTdays = Math.max(30, Math.min(MAX_TDAYS, dayCount - 1));
    const tdaysView = viewof Tdays;

    if (Number(tdaysView.value) !== targetTdays) {
      // Stash into master before triggering the Tdays re-run.
      for (let daysAgo = 0; daysAgo <= targetTdays; daysAgo++) {
        master[daysAgo] = history[dayCount - 1 - daysAgo].value;
      }
      tdaysView.value = targetTdays;
      tdaysView.dispatchEvent(new CustomEvent("input", { bubbles: true }));
      return;
    }

    // Re-click at current Tdays: redraw in place.
    for (let i = 0; i < nPoints; i++) {
      const daysAgo = nPoints - 1 - i;
      values[i] = history[dayCount - 1 - daysAgo].value;
    }
    redraw();
    emit();
  });
  toolbar.appendChild(historicalBtn);
  toolbar.appendChild(hint);

  const legend = Plot.legend({
    color: {
      type: "ordinal",
      domain: [
        "drawn",
        ...(showCloud ? ["GBM samples"] : []),
        "S₀",
      ],
      range: [
        "#c94",
        ...(showCloud ? ["#888"] : []),
        "#2a7",
      ],
    },
  });

  container.appendChild(toolbar);
  container.appendChild(legend);
  container.appendChild(canvas);

  redraw();
  container.value = {
    values: Float64Array.from(values),
    nPoints,
  };
  return container;
}

customScenario = {
  const { values: base, nPoints } = customCurve;
  const T = derived.T;
  const lam = derived.lambda;
  const N = derived.N;
  const dt = T / (nPoints - 1);

  let IT = 0;
  for (let k = 0; k < nPoints; k++) {
    const w = (k === 0 || k === nPoints - 1) ? 0.5 : 1;
    IT += w * base[k];
  }
  IT *= dt;

  const tauFrac = (lam > 0 && P > 0)
    ? Math.min(1, kPre / (lam * P * T))
    : 1;
  const tailStartRaw = Math.ceil(tauFrac * (nPoints - 1));
  const tailStartIdx = tailStartRaw >= nPoints - 1 ? nPoints : tailStartRaw;
  let tailInt = 0;
  for (let k = tailStartIdx; k < nPoints; k++) {
    const w = (k === tailStartIdx || k === nPoints - 1) ? 0.5 : 1;
    tailInt += w * base[k];
  }
  tailInt *= dt;
  const consumptionInt = IT - tailInt;

  const ST = base[nPoints - 1];
  const tokensLeftover = Math.max(0, kPre - lam * T * P);
  const feeRev = fee * P * lam * IT;
  const b2bOp = Q * N - P * lam * IT;
  const treasury = P * lam * consumptionInt + tokensLeftover * ST - cBasis;
  const customDesk = b2bOp + treasury;

  const retainedOp = (1 - beta) * b2bOp + run.premium;

  const H = barrierRatio * derived.S0;
  let everCrossed = base[0] >= H;
  let crossed = everCrossed;
  let firstCrossTime = everCrossed ? 0 : T;
  let Ib2b = 0;
  let Ifee = 0;
  let tB2b = 0;
  let tFee = 0;
  for (let k = 1; k < nPoints; k++) {
    const sprev = base[k - 1];
    const piece = 0.5 * (sprev + base[k]) * dt;
    const prevAbove = sprev >= H;
    if (prevAbove) { Ifee += piece; tFee += dt; }
    else           { Ib2b += piece; tB2b += dt; }
    const currAbove = base[k] >= H;
    if (currAbove && !everCrossed) {
      firstCrossTime = k * dt;
      everCrossed = true;
      crossed = true;
    }
  }
  const fPost = feePost ?? fee;
  const switchingOp = Q * lam * tB2b - P * lam * Ib2b + fPost * P * lam * Ifee;

  let maxS = -Infinity, minS = Infinity;
  for (let k = 0; k < nPoints; k++) {
    if (base[k] > maxS) maxS = base[k];
    if (base[k] < minS) minS = base[k];
  }
  const meanS = IT / T;

  return {
    base, nPoints, IT, tailInt, ST, tauFrac, tokensLeftover,
    feeRev, b2bOp, treasury, customDesk, retainedOp, switchingOp,
    crossed, firstCrossTime, tB2b, tFee, Ib2b, Ifee,
    maxS, minS, meanS,
  };
}

Carbon price

The chart below shows the drawn path rescaled to carbon-price units \(\pi_t = S_t \cdot P\) (USD per tonne). The orange line is the drawn curve, the grey lines are 20 GBM sample paths at the current parameters, the dashed green rule marks the inventory-exhaustion time \(\alpha T\), and, when switching is on, the dashed red rule marks the fee-mode threshold \(\pi_H = h S_0 P\). The drawn curve is the common input to all books below; the grey cloud shows where GBM alone would have taken the price.

carbonPriceRecords = {
  const { values, nPoints } = customCurve;
  const hasCloud = (lambdaJ > 0) || (derived.sigma > 0);
  const dtDays = Tdays / (nPoints - 1);
  const toTonne = (s) => s * P;

  const baseRows = new Array(nPoints);
  for (let i = 0; i < nPoints; i++) {
    baseRows[i] = { tDays: i * dtDays, price: toTonne(values[i]), series: "drawn (rescaled by P)" };
  }

  const cloudRows = [];
  if (hasCloud) {
    const N_CLOUD = 20;
    const cloudRng = mulberry32(seed);
    for (let j = 0; j < N_CLOUD; j++) {
      const { S } = samplePath(cloudRng, {
        S0: derived.S0,
        mu,
        sigma: derived.sigma,
        T: derived.T,
        nSteps: nPoints - 1,
        lambdaJ, muJ, sigmaJ,
      });
      const id = "cloud-" + j;
      for (let i = 0; i < nPoints; i++) {
        cloudRows.push({ tDays: i * dtDays, price: toTonne(S[i]), id, series: "GBM samples" });
      }
    }
  }

  return { baseRows, cloudRows, hasCloud };
}

Plot.plot({
  width: 820,
  height: 320,
  marginLeft: 70,
  marginBottom: 50,
  grid: true,
  x: {
    label: "date",
    domain: [0, Tdays],
    ticks: xTicksAnchoredRight(Tdays),
    tickFormat: d => formatTickDate(
      new Date(buildDate.getTime() - (Tdays - d) * 86400000), Tdays),
  },
  y: { label: "carbon price (USD / tonne)", zero: true, tickFormat: formatTickCurrency },
  color: {
    legend: true,
    domain: [
      "drawn (rescaled by P)",
      ...(carbonPriceRecords.hasCloud ? ["GBM samples"] : []),
      "αT",
      ...(switchOn ? ["fee-mode threshold π_H (fee above)"] : []),
    ],
    range: [
      "#c94",
      ...(carbonPriceRecords.hasCloud ? ["#888"] : []),
      "#2a7",
      ...(switchOn ? ["#a36"] : []),
    ],
  },
  marks: [
    Plot.ruleY([0]),
    ...(carbonPriceRecords.hasCloud
      ? [Plot.line(carbonPriceRecords.cloudRows,
          { x: "tDays", y: "price", z: "id", stroke: "series", strokeOpacity: 0.25 })]
      : []),
    Plot.line(carbonPriceRecords.baseRows,
      { x: "tDays", y: "price", stroke: "series", strokeWidth: 2 }),
    Plot.ruleX([{ t: run.tauFrac * Tdays, kind: "αT" }],
      { x: "t", stroke: "kind", strokeDasharray: "4 3", strokeWidth: 2 }),
    ...(switchOn
      ? [Plot.ruleY([{ y: barrierRatio * derived.S0 * P, kind: "fee-mode threshold π_H (fee above)" }],
          { y: "y", stroke: "kind", strokeDasharray: "6 3", strokeWidth: 2 })]
      : []),
  ],
})

P&L along the path

The chart below plots cumulative P&L per book, in USD, against calendar date. Each coloured line is one book evaluated on the drawn path up to that date; the dashed green rule marks the inventory-exhaustion time \(\alpha T\). The custom desk kinks at \(\alpha T\) when inventory runs out, and the switching book kinks at each crossing of \(H\).

pnlOverTime = {
  const { values: realised, nPoints } = customCurve;
  const T = derived.T;
  const lam = derived.lambda;
  const dt = T / (nPoints - 1);
  const dtDays = Tdays / (nPoints - 1);
  const N = derived.N;

  // Same αT breakpoint as customScenario so the terminal desk matches.
  const tauFrac = (lam > 0 && P > 0)
    ? Math.min(1, kPre / (lam * P * T))
    : 1;
  const tailStartRaw = Math.ceil(tauFrac * (nPoints - 1));
  const tailStartIdx = tailStartRaw >= nPoints - 1 ? nPoints : tailStartRaw;

  const H = barrierRatio * derived.S0;
  const includeSwitch = switchOn;
  const switchLabel = `switching (h=${barrierRatio.toFixed(2)})`;
  const switchPlusTreasuryLabel = `switching + treasury (h=${barrierRatio.toFixed(2)})`;
  const fPost = feePost ?? fee;

  let I = 0;
  let Ib2b = 0;
  let Ifee = 0;
  let tB2b = 0;
  let tFee = 0;

  const treasuryOpen = kPre * derived.S0 - cBasis;

  const rows = [];
  for (let k = 0; k < nPoints; k++) {
    if (k > 0) {
      const sprev = realised[k - 1];
      const piece = 0.5 * (sprev + realised[k]) * dt;
      I += piece;
      if (sprev >= H) { Ifee += piece; tFee += dt; }
      else            { Ib2b += piece; tB2b += dt; }
    }

    // Edge-weighted tail integral on [tailStartIdx, k]; O(nPoints²)
    // but nPoints ≤ 1096.
    let tailIk = 0;
    if (k > tailStartIdx && tailStartIdx < nPoints) {
      for (let j = tailStartIdx; j <= k; j++) {
        const w = (j === tailStartIdx || j === k) ? 0.5 : 1;
        tailIk += w * realised[j];
      }
      tailIk *= dt;
    }

    const tK = k * dt;
    const heldTokens = Math.max(0, kPre - lam * P * tK);
    const consumptionIk = I - tailIk;
    const feePnl = fee * P * lam * I;
    const b2bPnl = Q * lam * tK - P * lam * I;
    const retainedPnl = (1 - beta) * b2bPnl + run.premium * (tK / T);
    const treasuryPnl = P * lam * consumptionIk + heldTokens * realised[k] - cBasis;
    const customDeskPnl = b2bPnl + treasuryPnl;

    const tDays = k * dtDays;
    rows.push({ tDays, book: "fee", pnl: feePnl });
    rows.push({ tDays, book: "b2b", pnl: b2bPnl });
    rows.push({ tDays, book: "retained (syndicated-on-b2b)", pnl: retainedPnl });
    rows.push({ tDays, book: "treasury", pnl: treasuryPnl });
    rows.push({ tDays, book: "custom desk = b2b + treasury", pnl: customDeskPnl });
    if (includeSwitch) {
      const switchPnl = Q * lam * tB2b - P * lam * Ib2b + fPost * P * lam * Ifee;
      rows.push({ tDays, book: switchLabel, pnl: switchPnl });
      rows.push({ tDays, book: switchPlusTreasuryLabel, pnl: switchPnl + treasuryPnl });
    }
  }

  return { rows, includeSwitch, switchLabel, switchPlusTreasuryLabel, treasuryOpen };
}

Plot.plot({
  width: 820,
  height: 360,
  marginLeft: 80,
  marginBottom: 50,
  grid: true,
  x: {
    label: "date",
    domain: [0, Tdays],
    ticks: xTicksAnchoredRight(Tdays),
    tickFormat: d => formatTickDate(
      new Date(buildDate.getTime() - (Tdays - d) * 86400000), Tdays),
  },
  y: { label: "partial P&L (USD)", tickFormat: formatTickCurrency },
  color: {
    legend: true,
    domain: [
      "fee",
      "b2b",
      "retained (syndicated-on-b2b)",
      "treasury",
      "custom desk = b2b + treasury",
      ...(pnlOverTime.includeSwitch
        ? [pnlOverTime.switchLabel, pnlOverTime.switchPlusTreasuryLabel]
        : []),
      "αT",
    ],
    range: [
      "#4e79a7",
      "#f28e2c",
      "#e15759",
      "#76b7b2",
      "#59a14f",
      ...(pnlOverTime.includeSwitch ? ["#edc949", "#b07aa1"] : []),
      "#2a7",
    ],
  },
  marks: [
    Plot.ruleY([0]),
    Plot.ruleX([{ t: run.tauFrac * Tdays, kind: "αT" }],
      { x: "t", stroke: "kind", strokeDasharray: "4 3", strokeWidth: 2 }),
    Plot.line(pnlOverTime.rows,
      { x: "tDays", y: "pnl", stroke: "book", z: "book", strokeWidth: 1.75 }),
  ],
})

Operating books start at 0; treasury opens at MTM \(k S_0 - C_{\mathrm{basis}}\). Switching slope alternates at each \(H = h S_0\) crossing.

Terminal P&L

The table below reports one-point statistics for each book. The drawn column is the book’s P&L on the sketched path at time \(T\). The E[Π] (MC) column is the Monte Carlo mean over 5,000 GBM sample paths at the current parameters. The diff column is the former minus the latter.

html`<div class="derived-stats">
  <div class="card"><div class="label">min / max drawn S</div><div class="value">${"$" + customScenario.minS.toFixed(4)} / ${"$" + customScenario.maxS.toFixed(4)}</div></div>
  <div class="card"><div class="label">mean drawn S (I_T / T)</div><div class="value">${"$" + customScenario.meanS.toFixed(4)}</div></div>
  <div class="card"><div class="label">terminal S_T</div><div class="value">${"$" + customScenario.ST.toFixed(4)}</div></div>
  <div class="card"><div class="label">tail integral ∫_{αT}^{T} S_t dt</div><div class="value">${customScenario.tailInt.toFixed(4)}</div></div>
</div>`

customRows = [
  { book: "fee",                          pnl: customScenario.feeRev,     mcMean: run.fee.mean,        diff: customScenario.feeRev     - run.fee.mean },
  { book: "b2b",                          pnl: customScenario.b2bOp,      mcMean: run.b2b.mean,        diff: customScenario.b2bOp      - run.b2b.mean },
  { book: "retained (syndicated-on-b2b)", pnl: customScenario.retainedOp, mcMean: run.retained.mean,   diff: customScenario.retainedOp - run.retained.mean },
  { book: "treasury",                     pnl: customScenario.treasury,   mcMean: run.treasury.mean,   diff: customScenario.treasury   - run.treasury.mean },
  { book: "custom desk = b2b + treasury", pnl: customScenario.customDesk, mcMean: run.customDesk.mean, diff: customScenario.customDesk - run.customDesk.mean },
  ...(switchOn
    ? [
        {
          book: `switching (h=${barrierRatio.toFixed(2)})`,
          pnl: customScenario.switchingOp,
          mcMean: switchRun.summary.mean,
          diff: customScenario.switchingOp - switchRun.summary.mean,
        },
        {
          book: `switching + treasury (h=${barrierRatio.toFixed(2)})`,
          pnl: customScenario.switchingOp + customScenario.treasury,
          mcMean: switchRun.summary.mean + run.treasury.mean,
          diff: (customScenario.switchingOp + customScenario.treasury)
                - (switchRun.summary.mean + run.treasury.mean),
        },
      ]
    : []),
]

Inputs.table(customRows, {
  columns: ["book", "pnl", "mcMean", "diff"],
  header: {
    book: "book",
    pnl: "P&L on drawn curve",
    mcMean: "E[Π] (MC)",
    diff: "drawn − MC mean",
  },
  format: {
    pnl: x => (x >= 0 ? "$" : "−$") + Math.abs(x).toFixed(2),
    mcMean: x => (x >= 0 ? "$" : "−$") + Math.abs(x).toFixed(2),
    diff: x => (x >= 0 ? "+$" : "−$") + Math.abs(x).toFixed(2),
  },
})

drawn: P&L on the sketched path. MC mean: \(\mathbb{E}[\Pi]\) at defaults (\(\mu = -0.1\), \(\sigma^2 = 0.0625\), \(\lambda_J = 20\), 5,000 paths). diff = drawn − MC mean.

A negative diff on the custom desk row means the drawn token was pricier over \([\alpha T, T]\) than GBM expects on average. At full coverage the desk is path-insensitive and the diff collapses to zero.

Scope

The model is a GBM baseline with optional Merton jumps and deterministic demand; see baselines this note assumes. The outputs are illustrative, not forecasts.