RFC: Intraday Funding for Select US Stock Perps

Date: 2026-06-25 (rev. 2026-07-03) Status: Draft — for review Author: (you)

Replace the single once-daily funding settlement on a hand-picked subset of US stock perps with 13 intraday fundings — every 30 minutes from 10:00 to 16:00 US/Eastern inclusive. Each funding is 1/slot_count (1/13 on a full day) of the usual premium formula, computed from a 30-minute full-interval TWAP of our perp mark against a 30-minute TWAP of the Databento consolidated feed, and capped at ±8 bps per interval. Ship a daily funding bar in the GUI plus an API surface that exposes the day's 13 slots (realized + projected). Goal: make funding predictable and tractable — small, frequent, bounded increments instead of one opaque end-of-day charge.

This is an experiment, scoped to a designated set of instruments, fully reversible by flipping those instruments back to the existing daily schedule.

US equity perps settle funding once per day at 16:00 ET. The mechanics (mapped in detail during research):

• Schedule is per-instrument via instruments.funding_schedule (JSONB, FundingRateSchedule), rs/sdk/src/types/funding_rate_schedule.rs:11. The struct already holds a Vec<FundingTime> and next_funding_time() already iterates all of a day's times — multiple fundings per day is a config change, not a new primitive.
• Settlement is driven by EquitiesRunner (rs/settlement-engine/src/equities.rs:59), cron "0 15 16 * * Mon-Fri (America/New_York)" — fires at 16:15 ET once Databento publishes the official close, settles at the 16:00 ET mark.
• Formula (rs/sdk-internal/funding-and-settlement/src/funding.rs:66): funding_amount = clamp(settlement_price − benchmark_price, [min_cap, max_cap]), funding_rate = funding_amount / benchmark_price, where caps come from instruments.funding_rate_cap_upper_pct / funding_rate_cap_lower_pct.
  • settlement_price = mark = simple mean of per-minute marks over a trailing 5-min MarkWindow (compute_settlement_price, common.rs:149; rs/sdk-internal/funding-and-settlement/src/mark_window.rs). Each per-minute mark (ChMarketSnapshotRow::mark_price, from the 1-min market_snapshots written by marketdata-publisher) is a 0.3 × book mid + 0.7 × that-minute trade VWAP blend when both exist; mid alone if the minute had no trades; trade VWAP alone if the book is one-sided; previous minute's mark carried forward if neither. The trade-heavy blend is deliberate manipulation resistance — moving the mark requires printing real volume, not just posting quotes.
  • benchmark_price = Databento EQUS.SUMMARY daily close (rs/settlement-engine/src/equities.rs:63 SOURCE = "DATABENTO").
• Application (rs/settlement-engine/src/common.rs:45): amount = −(funding_amount × signed_position), bundled into per-account NewTransactions, written via TransactionEngine::insert_transactions(), recorded in ClickHouse funding_rates and transactions (transaction_type = 'funding', reference_id = settlement://{symbol}/{ts_ns}).
• Zero-sum is enforced at settlement (common.rs:345) and continuously by recon-engine (rs/recon-engine/src/checks/funding_is_zero_sum.rs).
• Estimated funding (rs/settlement-engine/src/estimated_funding.rs) publishes a live rate to Redis ~every 60s using a time-weighted EWMA (5-min half-life) of mark and Pyth index.

1. Daily close can't anchor 13 intraday fundings. Today's benchmark is a single 16:00 print. Intraday funding needs a live intraday benchmark.
2. No intraday Databento ingestion exists — RESOLVED (#2872, A-3257). underlying-publisher now runs a Databento EQUS.MINI live source (rs/underlying-publisher/src/databento.rs): consolidated ohlcv-1m bars for every equities / energy_etfs perp, written to ClickHouse underlying_prices with source = "DATABENTO", calendar-gated to the tape's sessions (04:00–20:00 ET), with per-source staleness health. See Dependencies for the one delta vs. this RFC's original sketch (bar closes vs. BBO mid).
3. No funding visualization or schedule API. Clients can read realized funding_rates and the single estimated rate, but there's nothing that presents "here are today's 13 fundings, here's the running total."

Goals

• Funding that is predictable (fixed 30-min cadence, known cap, simple TWAP that a client can reproduce) and tractable (13 small bounded increments).
• Per-interval bound aligned to today's daily bound (see caps below) — no surprise in aggregate risk.
• A daily funding bar + API so the schedule and realized/projected rates are first-class, consumable surfaces.
• Fully opt-in per instrument and reversible.

Non-goals

• Changing funding for any market not explicitly enrolled.
• Changing the settlement/transaction/zero-sum machinery — we reuse generate_settlement_instructions() unchanged, just call it 13×/day.
• Replacing the estimated-funding publisher (it stays; we reconcile against it).

Per enrolled instrument, set funding_schedule to 13 times in America/New_York:

next_funding_time() already returns the earliest future time across all entries, so no schedule-engine change is required. Half-days collapse to fewer entries via FundingException.times.

For funding interval i (closing at time tᵢ, opening at tᵢ₋₁ = tᵢ − 30m):

Application sign convention is unchanged (common.rs:58): long pays on positive funding, short receives, etc. Both sides of the basis are means of up-to-30 per-minute observations over the same interval — symmetric and fully reproducible from public data (our published book/trades and vendor 1-min bars).

Why 1/N. premium_i is an instantaneous-style basis, not time-integrated. Charging the full basis N×/day would be ~N× today's once-daily charge. Scaling by 1/slot_count makes the day's fundings sum to ≈ one basis charge on every day, including half-days, preserving current economics while spreading it into small steps.

Why the cap rarely binds. With the 1/13 scale, the ±8 bps cap only activates when |premium_i| > 104 bps on a single 30-min interval — a genuine dislocation. In normal conditions each interval is a few bps or less, and the day's total lands within ≈ ±104 bps, matching the existing ±1%/day envelope. The cap is a tail guard, not a normal-state clamp.

• idxTWAP = 100.00, markTWAP = 100.50 → premium = +0.50% (perp rich).
• funding_rate = clamp(0.005 / 13, ±0.0008) = clamp(0.0003846, …) = +3.85 bps.
• A long of 200 units pays 0.0003846 × 100 × 200 = $7.69 this interval; short receives it.
• 13 such intervals ⇒ ≈ +50 bps for the day (the basis), in 13 visible steps.

Enrollment must be explicit, queryable, and reversible. Options considered:

• (A) Reuse funding_schedule shape only — an instrument is "intraday" iff its schedule has 13 times. Rejected: implicit/brittle; the runner can't cheaply distinguish, and it overloads a field that's also the benchmark timezone source.
• (B) New nullable column instruments.funding_variant (enum: daily_close default | intraday_twap). Recommended. Explicit, indexable, drives runner selection and the API variant field, trivially reversible (UPDATE … SET funding_variant = 'daily_close').
• (C) JSONB flag in additional_product_specs — works but unindexed and easy to typo.

Decision: (B). Add funding_variant to the instruments table (db/postgres/1.sql) and DbInstrument (rs/sdk-internal/db/src/entities.rs). Enrollment is a one-row update per symbol; the experiment's instrument set is whatever has funding_variant = 'intraday_twap'.

Dataset: EQUS.MINI. Databento's consolidated, real-time US equities feed, blended from direct prop feeds across NMS exchanges + ATSs (not the SIP). Critically it ships with zero license fees, free redistribution rights, and full exchange compliance / no per-user fees, which is what makes it safe to surface as a client-visible benchmark on the funding bar and API.

What landed (rs/underlying-publisher/src/databento.rs):

• Schema: ohlcv-1m — consolidated 1-minute bars; the bar close is written as a point into ClickHouse underlying_prices (source = "DATABENTO", ChUnderlyingPriceSource::Databento), stamped at bar close. This differs from this RFC's original sketch (mbp-1 BBO-mid samples). Decision: accept bar-close TWAP as the benchmark. idxTWAP_i = simple mean of the (up to 30) 1-min closes in the interval. This is more client-reproducible than a BBO-mid TWAP — 1-min bars are a commodity any client can fetch from any vendor, whereas replaying our mid sampling is not — at the cost of print-gappiness in thin names (bars are only emitted for minutes with trades), which the skip rule below already handles.
• Coverage: every instrument with settlement_category ∈ {equities, energy_etfs}, Databento raw symbol derived by the -PERP strip; one live subscription covers all. Calendar-gated to the tape's sessions (pre/regular/post, 04:00–20:00 ET on trading days) via the shared equities holiday calendar — comfortably covers all 13 slots.
• Coverage caveat (unchanged): EQUS.MINI is direct-feed lit venues — it does not carry FINRA TRF / off-exchange prints. Deliberate, cleaner "lit-venue" benchmark; state it in client docs so the definition is unambiguous.
• Staleness / gap handling (halts, illiquid names): if an interval has too few bars (proposed floor: ≥ 20 of 30 minutes present), skip that interval's funding for that symbol (don't settle cash on a stale benchmark) and surface the skip on the bar/API. The feed already tracks per-source staleness health with a 600 s threshold.

What was the long pole is now done; remaining feed work is nil unless we reverse the bar-close decision (Open Questions).

• New SettlementRunner (sibling of EquitiesRunner, equities.rs:59) for funding_variant = 'intraday_twap' symbols.
• Cron fires at each of the 13 slots (or a single cron every 30m 10:00–16:00 ET that resolves the current slot), with a small lag (e.g. fire at :01/:31) so the interval's final 1-min bar has landed in underlying_prices — same reason the daily runner fires at 16:15, scaled down. Each fire:
  1. Build the 30-min MarkWindow (tᵢ − 30m, tᵢ] — generalize MarkWindow / FundingWindowShape to a 30-min trailing window for this category instead of the fixed 5-min equities window (funding.rs:20, mark_window.rs).
  2. Compute markTWAP_i via the existing realized path — get_market_snapshots + compute_settlement_price (common.rs:116,149), a simple mean of per-minute blended marks (not the estimator's EWMA) — and idxTWAP_i (mean of the interval's underlying_prices rows, source = "DATABENTO", via ChUnderlyingPrice::query_for_symbol; skip the slot if < 20 bars).
  3. Apply premium × 1/slot_count (from the day's resolved schedule), clamp ±8 bps.
  4. Call the unchanged generate_settlement_instructions() (common.rs:381) → transactions, funding_rates row, zero-sum check.
• The existing EquitiesRunner continues to serve funding_variant = 'daily_close' symbols untouched.
• Caps: drive the ±8 bps clamp from funding_rate_cap_*_pct set to ±0.08 on enrolled instruments, so no new cap field is needed — reuse existing plumbing.

EstimatedFundingPublisher stays on Pyth for v1 (decided 2026-07-03) — no benchmark switch for enrolled symbols yet. Consequence: "projected" bar cells are driven by a Pyth-based estimate while realized slots settle against the Databento TWAP, so small projected-vs-realized discrepancies are expected; acceptable for the experiment. A later iteration can switch the read at estimated_funding.rs:503 (currently hardcoded ChUnderlyingPriceSource::Pyth) to Databento for enrolled symbols and align the window.

Scaling gap (identified during PR 4, 2026-07-06): the publisher computes clamp(full premium, caps) with no 1/slot_count scaling. Enrollment sets the caps to the per-slot ±8 bps, so for an enrolled symbol /estimated-funding-rate (REST and the order-gateway WS request) would report the unscaled premium clamped to the per-slot cap — neither the next-slot rate nor the daily total, pinned at the cap whenever the premium exceeds 8 bps. /funding-slots is immune (it recomputes per-slot from the estimate's raw prices), but the publisher must be made slot-aware — scale by the day's resolved slot_count before clamping, for enrolled symbols only — before any symbol enrolls. Natural home: the same estimated_funding.rs change as the benchmark switch above (SoW PR 6).

Per the multiple-order-gateways / multiple-settlement constraint: 13 fires/day × N instances must not double-settle. Each slot settlement must be idempotent on (symbol, settlement_time) — a CAS/unique-key insert on the funding_rates / settlement reference so a second instance for the same slot no-ops. (Today's once-daily runner already keys on settlement_time; preserve that guarantee at 30-min granularity.) Test client disconnect, runner restart mid-day, and replay of a missed slot.

New REST endpoint (api-gateway, alongside get_funding_rates / get_estimated_funding_rate in rs/api-gateway/src/auth_routes.rs):

(Flat kebab-case path with the symbol as a query param, matching the rest of the API — no /v1 prefix or path params.)

• Realized slots read from ClickHouse funding_rates.
• Projected slots = current estimated funding rate applied to each remaining slot.
• Add a streaming variant later (WS push on each slot close) if clients want live updates; v1 is poll.

For the daily_close variant the same endpoint returns a single slot — one surface for both, with interval_count distinguishing them.

A compact horizontal bar of 13 cells near the instrument header:

• One cell per slot, left→right = 10:00→16:00.
• Sign by color (green = shorts pay / negative funding to longs; red = longs pay / positive) and magnitude by fill height/intensity; a marker when a slot is capped.
• Realized cells solid; projected cells hatched/faded; skipped cells greyed with a tooltip reason.
• A cumulative line / running total label (realized_sum_bps, projected_eod_bps).
• Hover tooltip per cell: time, mark TWAP, underlying TWAP, premium, rate, capped flag.

Check @architect-xyz/ui-components for an existing bar/sparkline primitive before building (per GUI code-style note); feed it from the endpoint above.

• Timezone span — RESOLVED: the window is 10:00–16:00 US/Eastern (an earlier draft said Central in error). All 13 slots fall inside the regular session: the first window (09:30, 10:00] opens at the bell, the last closes at the 16:00 close. No post-market slots.
• Half-days / holidays: reuse the equities holiday calendar via FundingException; fewer slots that day → interval_count < 13 in the API; bar renders fewer cells. Scaling is 1/slot_count re-derived from the day's resolved schedule (decided 2026-07-03), so a 7-slot half-day charges premium × 1/7 per slot and the day still sums to ≈ one basis charge.
• Insufficient benchmark/mark samples in an interval (halt, thin name — 1-min bars only print for minutes with trades): skip that slot's settlement (status: "skipped"), don't settle on stale data; zero-sum trivially holds (no txns).
• Empty order book interval: reuse existing empty-book mark handling; if no valid mark samples, skip the slot.
• Mid-day onboarding / position opened between slots: position is whatever is held at slot close (snapshot semantics unchanged); a position opened at 10:05 first pays at 10:30.
• Restart / crash / replay: idempotent per (symbol, slot_time); a runner that missed 11:30 can backfill that one slot from historical TWAP without disturbing later slots. Test server-initiated disconnect and reconnect across slot boundaries.
• Corporate actions: existing corp-action handling unchanged (benchmark is now a live feed, not a close, but splits/dividends still apply to the underlying).

1. Land funding_variant column + IntradayEquitiesRunner behind it; no instrument enrolled → zero behavior change.
2. Stand up Databento consolidated ingestion — merged (#2872). Deploy prerequisite: apply the a-3665 rename migration (index_prices → underlying_prices) — as of 2026-07-03 prod ClickHouse still has index_prices only, so the feed's writes would fail there. Then validate 30-min bar-close TWAPs vs known prints in underlying_prices for a week (no settlements).
3. Ship API endpoint + GUI bar reading from realized funding_rates (works for daily variant immediately — derisks the surface before intraday goes live).
4. Enroll 1–2 liquid names in demo, run intraday fundings in dry-run (compute + record funding_rates, don't post transactions), reconcile sums.
5. Flip those names to live intraday settlement in prod; monitor zero-sum recon and the bar; expand the enrolled set.
6. Reversal at any point: funding_variant = 'daily_close' → back to 16:00 daily.

1. Timezone — RESOLVED: 10:00–16:00 US/Eastern (America/New_York); the Central reading in the earlier draft was a mistake. Last slot = the 16:00 close.
2. Databento dataset/schema + licensing — RESOLVED: EQUS.MINI, zero license fees / free redistribution, so client-visible is fine. The merged feed (#2872) uses ohlcv-1m bar closes, not the originally-sketched mbp-1 mid; this RFC now adopts bar-close TWAP as the benchmark. Confirm: (a) OK with lit-venue-only coverage (no TRF off-exchange prints); (b) OK with bar-close TWAP vs. BBO-mid TWAP (reproducibility argues for bars; thin-name gappiness is handled by the skip rule).
3. 1/13 on short days — RESOLVED (2026-07-03): scale by 1/slot_count so half-days also sum to ≈ one basis charge.
4. Cap symmetry: ±8 bps symmetric confirmed? (funding_rate_cap_lower_pct must be ≤ 0 — fine.)
5. First slot (10:00 ET) — RESOLVED (2026-07-03): include the (09:30, 10:00] opening window; auction noise is damped by the 30-min mean and trade-heavy mark blend.
6. Estimated-funding benchmark — RESOLVED (2026-07-03): keep Pyth for v1; revisit switching enrolled symbols to the Databento benchmark later (see §3).

• db/postgres/1.sql — instruments.funding_variant enum column.
• rs/sdk-internal/db/src/entities.rs — DbInstrument.funding_variant.
• rs/sdk-internal/funding-and-settlement/src/{funding.rs,mark_window.rs} — 30-min full-interval window shape + × 1/slot_count scaling.
• rs/settlement-engine/src/intraday_equities.rs — new IntradayEquitiesRunner.
• rs/settlement-engine/src/estimated_funding.rs — consolidated-feed benchmark for enrolled symbols (swap ChUnderlyingPriceSource::Pyth → Databento at :503) + 1/slot_count scaling before the clamp (see the estimated-funding scaling gap above; required before enrollment — the endpoint has API consumers, REST and WS, beyond the GUI widget).
• consolidated intraday ingestion — done: rs/underlying-publisher/src/databento.rs (#2872).
• ClickHouse benchmark storage — done: reuses underlying_prices (source = "DATABENTO").
• rs/api-gateway/src/auth_routes.rs — GET /funding-slots.
• gui/ — daily funding bar component.
• rs/recon-engine/src/checks/funding_is_zero_sum.rs — verify still holds at 30-min cadence (no logic change expected).