NEAR's Supply Still Outruns Intents Revenue
Every day a pinned worker running inside an Intel TDX enclave reads NEAR mainnet at the first block of the UTC day and writes what it finds to the nearbooks.near contract. This page reads those entries from the chain and re-checks each one in your browser while you read.
NEAR Intents earns real and growing revenue, but it does not shrink NEAR's supply, and at today's volume it is far from offsetting dilution. Holding NEAR today is a bet on Intents growing several times over, not on scarcity.
What would prove it wrong:
- The revenue wallets take in half of new supply in two 28-day windows in a row.
- Total supply shrinks.
- Issuance is cut before 2027.
Six predictions on chain score it, two of them before judging. Read the full thesis
This page contains the following sections:
- The Latest EntryWhat did the enclave record, and does it check out?
- Public Claims, CheckedWhich widely shared numbers hold up against the chain?
- Open PredictionsWhat does the contract expect, and when is each claim decided?
- How to Check ItWhat does "verified" prove, and what doesn't it?
- History, Rebuilt From the ChainDoes the on-chain rebuild agree with DefiLlama?
- What Would Make Supply ShrinkWhich inputs would change the answer?
Main claims:
- Reading the latest attested entry.
The Latest Entry
Each entry compares the first block of a UTC day with the first block 28 days earlier. There is one entry per day; the first valid one wins and it is never edited.
The seven checks
An entry counts as verified only if all seven hold. Your browser runs them against the contract, OutLayer's attestation API and an archival node:
Every entry so far
| Date | First block | Worker | Checks | Evidence |
|---|
The TDX quote and Intel's signature are not checked here. verify_attestation.py checks them; see section 4.
Public Claims, Checked
NEAR's buybacks and issuance are argued about in public, and the published numbers seem to disagree. These are the most widely shared claims, as published, each graded against the same data this page verifies. Most hold once their dates and inputs are lined up.
- Reading the graded claims.
The three break-even figures ($177M, $795M and $1.13B a day) use the same arithmetic, the NEAR minted per day times the NEAR price over the take rate. They differ mainly in the price used, and put on the same price they land within about 25% of each other. All three describe a burn that is not happening: the NEAR bought back is held, so under today's policy total supply grows at any volume.
Claims are kept in pipeline/claims.json with their source and date, and graded by pipeline/verify.py; make verify fails if a verdict stops following from the data. The same table in the repository.
Open Predictions
Each claim was written to the contract with a resolve date and can't be edited. Only the attested entry for that exact date decides it: confirmed, refuted, or void if the entry lacks the metric. Anyone can call resolve_prediction once the date has an entry.
How to Check It
Three parties touch each number, and each step leaves something you can check without trusting this page.
- The enclave reads mainnet. A worker whose sha256 is pinned in the contract runs inside OutLayer's Intel TDX enclave. It reads total supply, the three Intents revenue wallets and a reserves check on
intents.near, and prints JSON. - The contract stores it.
nearbooks.nearaccepts output only from the configured OutLayer contract, for the pinned build, answering a request it made. Changing the pin waits out a timelock and never touches a date that has already begun. - Your browser re-checks it. This page runs the seven checks in section 1. The Python script below also checks the TDX quote, and with
--dcapIntel's signature chain.
What "verified" tells you
The numbers came from the build this repository publishes, and the contract had pinned that build for the date. OutLayer attests that it ran on exactly that input and produced exactly these bytes. The run was requested through nearbooks.near rather than handed in by someone else.
What it doesn't tell you
It doesn't tell you that Intel TDX and OutLayer are honest: this page trusts their attestation, and only the script checks the quote itself. Nor does it tell you that the RPC answers were true mainnet state. The worker reads over JSON-RPC without state proofs, though the evidence hash commits to the raw responses. And it says nothing about whether the predictions are right; they are claims waiting for a date.
Re-run it on your machine
The first command rebuilds every historical finding offline. The second checks an attested entry and its TDX quote; --dcap adds Intel's signature chain and needs dcap-qvl (cargo install dcap-qvl-cli).
git clone https://github.com/IhorMuliar/nearbooks cd nearbooks && make verify
python3 -I contract/scripts/verify_attestation.py nearbooks.near --dcap "$(command -v dcap-qvl)"
The contract
History, Rebuilt From the Chain
Nothing in this section is attested. pipeline/compute.py computes it from raw data committed to the repository, and make verify re-checks every finding offline. It changes only when the data is re-pulled.
| Item | On-chain | DefiLlama | Difference |
|---|
Month by month
| Month | On-chain | DefiLlama | Difference |
|---|
What Would Make Supply Shrink
Total supply shrinks only if the NEAR bought back each day is burned and exceeds the NEAR minted each day. The sentence below starts from today's measured values; change the underlined numbers with the sliders under it.