DeltaRates: Signed forecasts, scored at maturity

What this page shows Once a day we read what the market expects a yield to be between now and a fixed date, and we sign it. Five markets, taken straight from the contract, at the same time every day.

Rate forecasts are quoted constantly and recorded almost nowhere, so nobody can be held to the ones they gave. A forecast signed and dated before the outcome is known can be scored when the date arrives, and a scored track record is worth more than a claim.

What we are doing

Pendle splits a yield-bearing asset into its principal and its yield, then lets people trade the two against each other. The resulting price is a forecast: the rate at which buyers and sellers agreed to swap a fixed return for a variable one, out to a maturity fixed on chain. Pendle calls it the implied APY, and it sits as a single number in the market contract's state.

We read that number once a day at a fixed UTC slot and sign it, together with the underlying's index at the same block, so the thing the forecast is about is captured too. One contract call each, on contracts anyone can call.

Why it matters

A forecast cannot be backdated

For a realized rate, our signature is a convenience: you could read the same index off the chain yourself, at any time, and get the same answer. What we add is the schedule and the audit trail.

A forecast is different. Anyone can say today what the market expected last March; nobody can prove they said it in March unless they committed to it then. That is the whole product here, and it is the one series on this site whose value rests on the signature rather than the calculation.

The answer arrives on its own

Each of these markets has a maturity date written into the contract. Once it passes, what the underlying actually delivered is a matter of record, and it can be compared against every day that was signed on the way there.

So this becomes a scoreable track record rather than a set of claims. Not "trust our numbers" but "here is what we committed to, here is what happened, check the two against each other."

The five markets

Loading the signed series…

What this does not claim

These are not our predictions. We record what a market priced, at a moment, verifiably, and leave the judgement to you.

The implied rate is signed; the percentage is arithmetic. The signed payload holds Pendle's raw log rate, and turning it into a percentage is one exponential, done in your browser and in our verifier from the same signed bytes. Repeat it yourself rather than taking the figure.

We refuse one calculation on purpose. For every other series we publish a residual: how much of the realized growth the quoted rate accounts for. Not here, because a forecast about next year explains no part of last night. Such a number would have the right units, a plausible size and no meaning, so the bundle reports it as unavailable with the reason attached.

Liquidity decides how much a quote means, and one of these five is thin, so its card says so. A rate from a shallow market is closer to one participant's opinion than to a consensus. You can judge that yourself from the same contract call we make, which reports the market's own principal and yield balances.

These series end. Every other series here runs indefinitely, but a market with a maturity stops being meaningful the day it settles and the principal redeems at par. Our scheduler does not know that yet.

How to check any of this

To confirm	Do this
The implied rate is really in the contract	Call `readState` on the market at any block and read word 8. It is `ln(1 + APY)` at 1e18.
Our signed row says what this page says	Fetch the series from the feed, base64 decode the payload, and read `rate_raw`. The page does exactly this.
The row was signed by us and not altered	Download the bundle and run its `replay.py`. It re-reads the market itself, at the same block, through an endpoint you choose.
We did not pick the moment after seeing it	Every round lands in one fixed UTC slot, and each row carries the block it was read at.

An archive node is required to read a past block. Public endpoints often refuse historical state, and a refusal is not a disagreement.