RFC: Equity Reference Price — 15:55–16:00 ET 5-min TWAP

Date: 2026-06-25 Status: Draft — for review Author: (you)

Summary

Change the reference (benchmark) price for US equity perps from the official closing print to the 15:55–16:00 ET 5-minute TWAP of the underlying. Keep one funding per day at the 16:00 ET close — same cadence, same caps, same settlement machinery. The only change is how the benchmark price is sourced, stated in the product spec as a window definition.

This is the low-lift alternative to the intraday-funding experiment (A-3876, docs/rfc/intraday-funding-us-stock-perps.md). It fixes a real artifact in today's funding without a pricing-policy or schedule change, and is a natural stepping stone: it validates the consolidated-feed TWAP plumbing that the intraday design also needs.

Background — the window mismatch

Today's funding compares two prices measured over different windows:

Mark (perp side): a trailing 5-minute TWAP ending at 16:00 ET — the equities MarkWindow is (16:00 − 5m, 16:00] (rs/sdk-internal/funding-and-settlement/src/funding.rs:20, mark_window.rs), reduced to a time-average of per-snapshot book marks (rs/settlement-engine/src/common.rs:147).
Benchmark (underlying side): the official closing print — Databento EQUS.SUMMARY ClosePrice statistic, a single auction cross at 16:00, fetched at 16:15 ET (rs/settlement-engine/src/equities.rs:63, rs/settlement-engine/src/downloaders/databento.rs:25 DATASET = "EQUS.SUMMARY").

So premium = mark − benchmark subtracts a 5-minute average from a point-in-time auction price. On a volatile close (where the closing cross prints meaningfully away from the preceding 5-minute average), this injects funding that reflects the window mismatch, not the true perp basis. Traders can't cleanly reason about it because the two legs aren't measured the same way.

Proposal

Define the benchmark as the time-weighted average of the underlying over (16:00 − 5m, 16:00] ET — the same window as the perp mark.

markTWAP   = time-weighted mean of our order-book mark over (15:55, 16:00] ET   (unchanged)
refTWAP    = time-weighted mean of the underlying over    (15:55, 16:00] ET   (NEW: was the close print)

funding_amount = clamp(markTWAP − refTWAP, [min_cap, max_cap])    (unchanged formula)
funding_rate   = funding_amount / refTWAP                          (unchanged)

Everything else is unchanged: one settlement/day, 16:00 ET, cron at 16:15 (EquitiesRunner), funding_rate_cap_*_pct, the generate_settlement_instructions() path, zero-sum recon. No schedule edit, no new column, no per-instrument variant flag.

Why this is the right minimal change

Apples-to-apples basis. Both legs are the same 5-minute TWAP over the same clock window → funding measures the genuine perp-vs-underlying premium.
More manipulation-resistant than the close print: pushing a 5-minute average costs far more than influencing a single closing cross.
Estimated funding finally converges (see below): a TWAP reference is knowable before 16:00, so the live estimate can track — and ultimately equal — the realized rate. The close print can't, since it doesn't exist until the auction fires.
No policy change. Cadence, caps, and economics are identical; only the reference-price definition in the product spec changes.

Resolved design decisions

Question	Decision	Rationale
Window	`(15:55, 16:00] ET`, 5 min	Exactly mirrors the existing equities `MarkWindow`.
Averaging	Simple time-weighted TWAP of the BBO mid	Symmetric with the mark's time-average; mid is continuous and robust in thin names.
Source	Databento `EQUS.MINI` (consolidated, intraday)	Same vendor as today's close (provenance unchanged), but an intraday dataset since `EQUS.SUMMARY` is daily-only. Zero license fees / free redistribution → safe to publish as the contract reference.
Cadence	Unchanged — 1 funding/day at 16:00 ET	Per the proposal; no behavior change.
Caps / settlement	Unchanged	Reuse `funding_rate_cap_*_pct` and existing settlement path.

Component changes (small)

Databento downloader — add a 5-min TWAP fetch. Alongside fetch_historical_close_prices (databento.rs), add a method that pulls the (15:55, 16:00] ET window for each symbol from EQUS.MINI (mbp-1/bbo-1m, or ohlcv-1m over the 5 bars) and computes the time-weighted mid TWAP. This is a single bounded query per symbol per day at settlement time — not a live streamer. The runner already does a same-day Databento fetch at 16:15 (LIVE_DEADLINE_SECS), so the infra and timing are in place; this swaps/extends the statistic it asks for.
Benchmark source tag. Write the resulting price to benchmark_prices with source = "DATABENTO_EQUS_MINI_TWAP" (vs today's "DATABENTO" close), so the two regimes are distinguishable in ClickHouse funding_rates / audit.
Product spec text. Change the contract reference price definition from "official closing price" to "15:55–16:00 ET 5-minute time-weighted average of the consolidated US equity price," and the funding_schedule_*_description strings to match. Surface the same wording wherever the spec is shown to clients.
Estimated funding alignment — convergence (see next section). Switch estimated_funding.rs's benchmark input from Pyth to the same EQUS.MINI mid so the live estimate is computed from the same source the settlement will use.

The settlement path needs nothing else; no funding_schedule edit, no new instruments column. The estimated-funding and GUI items below are small, high-leverage add-ons that this change enables — strictly optional to the core fix, but the main reason to do it.

Estimated funding becomes a converging estimate

EstimatedFundingPublisher (rs/settlement-engine/src/estimated_funding.rs) publishes a live rate to Redis ~every 60s using an EWMA of mark and Pyth index. Today it is a loose preview: the realized benchmark is the 16:00 auction close, which (a) comes from a different source than the estimate's Pyth input and (b) does not exist until 16:00, so the estimate can never provably converge to what settles.

With a 15:55–16:00 ET TWAP reference, the realized benchmark is knowable as the window fills:

Before 15:55 the estimate is a pure forecast (as today, just sourced from EQUS.MINI).
Inside the window, the realized reference is partly determined: at 15:59, 4 of the 5 minutes are already locked in. The estimate becomes (TWAP-so-far) + (forecast of the remaining minutes), a quantity that monotonically converges to the realized rate and equals it at 16:00 (up to caps).

Concretely: keep the all-day EWMA preview, but once inside the settlement window switch the benchmark term to the exact running window-TWAP so the last few minutes converge to the settled value instead of lagging. Publish a convergence fraction (elapsed window / window length, 0→1) alongside the rate so consumers know how "locked in" the estimate is. This is the payload the GUI device below renders.

GUI: funding convergence device (the "settling into" indicator)

A small widget that shows, in the run-up to the close, what funding is settling into as the 5-minute TWAP fills — making the otherwise-opaque close concrete and predictable.

Outside the window: shows the live estimate as a forecast (faded / "estimated").
15:55–16:00: a progress meter (0→100% as the window fills) with the current converging rate and a tightening band for the still-unknown remainder; the band collapses to a point at 16:00. Sign-colored (long pays / short receives), cap markers at the ±bound.
At 16:00: snaps to the realized funding — the estimate the user watched converge is literally the number they're charged.
Fed by the estimated-funding-rate:{symbol} payload extended with convergence and window_twap_so_far. Reuse a gauge/meter primitive from @architect-xyz/ui-components rather than building one.

This is the natural home for the "what is funding going to zero into" question: it visualizes convergence directly, and it only becomes truthful because the reference is a pre-close TWAP rather than the auction print.

Edge cases

Half-days / early close (13:00 ET): the window must track the actual session close → (12:55, 13:00] ET, not a dead 15:55–16:00 window with no trading. The EquitiesRunner::settlement_time / funding-schedule exception path already encodes the early-close time; the TWAP window must be derived from that settlement time, not hard-coded to 16:00. (This is a correctness requirement, not optional.)
Auction divergence: the 5-min TWAP intentionally excludes the closing-auction cross. This is the point (manipulation resistance), but it means our reference can differ from the "official" 4pm print other venues settle against — call this out in the spec so it's a deliberate, disclosed choice.
Thin names / sparse prints 15:55–16:00: mid TWAP from mbp-1 degrades gracefully where a trade-VWAP would be gappy. If a symbol has too few samples in the window, fall back to the official close for that symbol/day (don't settle on a stale or empty TWAP), and log the fallback.
Same-day data availability at 16:15: confirm EQUS.MINI intraday for the closing 5 minutes is queryable by 16:15 ET (the runner's existing deadline). If not, subscribe live to the window instead (the runner already holds a live Databento client).
Restart/replay: unchanged — still a single idempotent settlement keyed on (symbol, 16:00 ET).

Relationship to the intraday RFC (A-3876)

	This RFC (reference-price TWAP)	Intraday funding (A-3876)
Fundings/day	1 (unchanged)	13
Schedule / caps / policy	unchanged	new
Data lift	single daily `EQUS.MINI` historical pull	live `EQUS.MINI` streamer all day
Per-instrument opt-in	none (applies to equity perps)	new `funding_variant` flag
GUI / API	none	funding bar + API
Risk	low; reversible by reverting the spec	experiment

They are complementary, not exclusive. This RFC can ship first as a clean win and de-risks the shared EQUS.MINI TWAP math before the intraday experiment builds the live-streaming, 13×/day version on top.

Open questions

TWAP definition: BBO-mid TWAP (recommended) vs consolidated trade VWAP over the 5 minutes? Mid is more robust; trade-VWAP is closer to "where it traded."
~~Source~~ — RESOLVED: EQUS.MINI 5-min TWAP, for clean provenance (same vendor as today's close; consolidated direct-feed; zero-license redistribution). The lower-lift Pyth-ax.index_prices option was considered and declined.
Roll-out scope: all equity (and EnergyEtfs) perps at once, or a small set first to compare old-close vs new-TWAP funding side-by-side for a week before flipping?
Auction disclosure: confirm product/legal are comfortable that the contract reference deliberately excludes the official closing cross.

Appendix — anticipated touch list

rs/settlement-engine/src/downloaders/databento.rs — 5-min EQUS.MINI TWAP fetch.
rs/settlement-engine/src/equities.rs — derive TWAP window from settlement_time; fallback-to-close on insufficient samples; new SOURCE tag.
rs/settlement-engine/src/common.rs — (none expected; formula path unchanged).
Product-spec / funding_schedule_*_description content + client-facing reference definition.
rs/settlement-engine/src/estimated_funding.rs — EQUS.MINI benchmark input; exact window-TWAP inside the settlement window; publish convergence + window_twap_so_far on the estimated-funding-rate:{symbol} payload.
gui/ — funding convergence ("settling into") device, fed by the extended payload.