IoTeX (IOTX) — the revision ledger

Generated 2026-09-02T19:58:22Z from live ClickHouse queries against this estate's ledger. Point-in-time archive held for IoTeX: 7,940 observations · 43 distinct series · 8 upstream sources · first row 2026-08-09 17:15:20 · newest row 2026-09-02 19:49:20 · every one of the 7,940 rows carries a verify_url · 43 series refreshed in the last 24h (788 fresh rows). Nothing on this page is cached, estimated, or remembered.

Provenance — where IoTeX's archive comes from

8 source families feed this network's ledger. Every row they wrote carries its own source, as_of and verify_url; this table is the live rollup of that. IOTX (the catalog name here is IoTeX, category sensor; the token trades on base and ethereum under the ERC-20 contract 0x6fb3e0a217407efff7ca062d46c26e5d60a14d69) publishes no first-party stats API of its own in this catalog — the network-side series held for IOTX come from this estate's own depin_first_party collectors (the DL_FEES_* / DL_REV_* fee and revenue families), IoTeX's own public RPC (babel-api.mainnet.iotex.io — block height and gas price), Blockscout's address counters on the token contract (eth.blockscout.com — transfer, transaction and gas counters), GitHub repo telemetry (iotexproject/iotex-core), with DefiLlama's fees/dexs/chains/stablecoins series and CoinGecko's market series alongside.

Revision ledger — 0 backward revision(s) recorded for IOTX

The ledger query ran during generation and returned 0 rows for IOTX. Zero here is the live query result, not a gap — the ledger itself is at /v1/revisions?symbol=IOTX (the same query this page ran, served live), and a restatement would appear on this page the day the detector records one. /v1/revisions?symbol=IOTX cross-check passed: the served API reports 0 row(s), matching the ledger count rendered on this page.

Why zero is the interesting answer. The detector does not skip IOTX — below, the live intersection shows the 6 cumulative-by-construction series the archive holds for this network, each fully diffed across its whole snapshot window (where it has more than one observation), and each rendered here end to end so the monotone runs are visible raw. Nothing moved backward. That is the structural zero: the detector was watching, the counters were fully exposed to it, and upstream did not rewrite history for this network in the window this estate holds. Publishing an empty ledger as a live query result — instead of padding it with gauge noise — is the same retention discipline the ledger exists to sell.

What the detector watches for IoTeX — the intersection, measured

The detector diffs every daily snapshot of every cumulative-by-construction series. Below is the live intersection of the estate detector's cumulative watchlist — imported directly from propintel/revision_ledger.py (75 declared names, so this page can never drift from the detector) — with what the daily archive holds for IOTX. The fee counters here come from the first-party collector family and DefiLlama; the block-height series is IoTeX's own RPC read; the transfer/transaction/gas counters are Blockscout reads on the token contract.

The trails behind the ledger — watched counters, end to end

These are the actual counter trails the detector diffed for IOTX, rendered live from the archive. Each is a series that cannot decrease unless upstream rewrote history — and the monotonicity verdict beside each table is computed in this process from the same rows shown, so the summary cannot drift from the data. The raw runs are the evidence; the reader does not have to trust the summary.

DL_FEES_ALLTIME_USD — the cumulative all-time fees series for IoTeX collected by this estate's first-party pipeline (depin_first_party) across all 24 snapshot days. Live verdict from the rows below: flat across its entire held window — every snapshot holds the identical value.

fees_alltime_usd — the same quantity, independently captured from DefiLlama's fees series for iotex — 10 snapshot days, and on every day the two families overlap they agree (see the cross-source check below). Live verdict from the rows below: flat across its entire held window — every snapshot holds the identical value.

block_height — IoTeX's own chain, read from the network's public RPC (babel-api.mainnet.iotex.io) and held for 2 snapshot day(s) so far (the iotex_rpc collector began writing the daily archive on 2026-09-01, with a 2026-08-25 snapshot day retained). Live verdict from the rows below: monotone non-decreasing across its entire held window — the counter only moved forward — the chain grew, which is exactly what a live chain should do to this counter.

contract_gas_used_total — Blockscout's address counters for the IOTX token contract (eth.blockscout.com), 10 snapshot days. Live verdict from the rows below: monotone non-decreasing across its entire held window — the counter only moved forward.

contract_transactions_total — Blockscout's address counters for the IOTX token contract (eth.blockscout.com), 10 snapshot days. Live verdict from the rows below: monotone non-decreasing across its entire held window — the counter only moved forward.

token_transfers_total — Blockscout's address counters for the IOTX token contract (eth.blockscout.com), 11 snapshot days. Live verdict from the rows below: monotone non-decreasing across its entire held window — the counter only moved forward.

Cross-source agreement — two independent pipelines, one number

On the snapshot days where both the first-party DL_FEES_ALLTIME_USD collector and DefiLlama's fees_alltime_usd series hold a value, the two independent captures agree exactly — a live-computed check, not an assertion: 10 agreeing days, 0 divergent.

Gauges that moved backward — deliberately NOT revisions

These series fall outside the detector's cumulative-by-construction class (NOT_TRULY_CUMULATIVE and plain gauges in propintel/revision_ledger.py): a drop there is a real market or window change, not upstream rewriting history. The rolling fee and revenue windows (24h/7d/30d/1y), price, market-cap and rank classes dominate this table for IOTX — a smaller trailing sum is a smaller window, not a rewrite. Publishing them as "revisions" would be exactly the fake-metric behaviour this product exists to eliminate.

Same-timestamp conflicting values on record for IOTX: none

The task-level conflict check, run live: any (metric, timestamp) family where this estate recorded two or more different values. The query ran at generation and returned 0 groups in both depin_onchain and depin_daily — every (metric, timestamp) pair the estate holds for IOTX carries exactly one value. Zero here is the live query result, not a gap; the archive kept every write it made, and none of them disagree.

The ledger, live — every restatement recorded estate-wide (18 deduped events)

Deduped on revision identity exactly as /v1/revisions dedupes it. This is the same feed a subscriber polls; it is rendered live from ClickHouse at generation, not copied from a snapshot. Each row is an upstream source replacing the value of a (network, metric, date) it had already published — after this estate recorded the original. The superseded value is retained, never deleted; that retention is the only reason a rewrite is detectable, and it is the part every overwriting vendor discards.

How detection works — and what it cannot see

The detector (propintel/revision_ledger.py) diffs every daily snapshot this estate holds of every cumulative-by-construction series — counters that cannot decrease unless upstream rewrote them (block heights, transaction and transfer counters, lifetime fees). A row enters default.depin_revision_ledger iff two snapshots disagree for an already-observed date; zero human judgement. Resolution rule: latest observation wins for current-state reads, the superseded value is retained, never deleted. Population gauges (provider sets, node counts, prices, capacity, rolling windows) legitimately move both ways and are deliberately excluded — a drop there is a real change, not a rewrite; the gauge table on this page is the worked example. Honest boundary: this catches value-history rewrites ex-post; identical-schema semantic drift with plausible values is what the hash-pinned derivation_replay layer is for. The detector's full classification is inspectable at /v1/revisions and frozen daily at /revision-ledger/REVISIONS_20260902.json.

The snapshot archive the detection runs over

IOTX's slice of depin_daily: 459 rows over 24 snapshot days (2026-08-09 → 2026-09-01), from 5 source families. Each snapshot is a same-day capture of every series the collectors touched; the detector diffs consecutive snapshots of cumulative series across this window. This is the substrate the zero above is measured over — not an assumption, a measured archive.

Estate grades for IOTX (graded 2026-08-20 13:54:15.000)

Served by /v1/network/IOTX — the same grades a paying agent receives. Scores are the engines' own 0–100 outputs, published exactly as the engines emitted them, unflattering parts included.

Verify any cell yourself — the exact commands

No account, no key, no trust required. Commands 1–2 hit this estate's public API (the same rows this page queried — every row carries source / as_of / verify_url); command 3 hits the DefiLlama upstream family the fee rows came from; command 4 is IoTeX's own RPC; command 5 is the CoinGecko origin page; command 6 is the estate's graded network row; command 7 is the frozen daily snapshot of the ledger. One polite call per endpoint, no hammering.

# 1) The served revision feed for IOTX — the same rows this page queried, live:
curl -s "https://kairossignal.com/v1/revisions?symbol=IOTX" | python3 -m json.tool
# 2) The estate-wide feed (every network, both sides of every diff):
curl -s "https://kairossignal.com/v1/revisions" | python3 -m json.tool | head -80
# 3) DefiLlama fees series for iotex (the fees_alltime_usd origin):
curl -s -H "User-Agent: kairos-check" "https://api.llama.fi/summary/fees/iotex" | python3 -m json.tool | head -30
# 4) IoTeX's own public RPC (the iotex_rpc origin — reachability):
curl -s -o /dev/null -w "%{http_code}\n" "https://babel-api.mainnet.iotex.io"
# 5) CoinGecko IOTX page (the market-series origin; browser-verified, bot-walled to curl):
curl -s -o /dev/null -w "%{http_code}\n" "https://www.coingecko.com/en/coins/iotex"
# 6) This estate's public API row for IOTX (grades + provenance):
curl -s "https://kairossignal.com/v1/network/IOTX" | python3 -m json.tool | head -60
# 7) The public daily snapshot of the ledger (frozen copy):
curl -s -o /dev/null -w "%{http_code}\n" "https://kairossignal.com/revision-ledger/REVISIONS_20260902.json"

Method & honesty notes. All counts are queries against the live ledger at generation time, not restamped copy — this page is regenerated by gen_revision_page_iotx.py and the hourly claim_drift_check.py run grades its claims against the live API like every other published surface. The IOTX revision count is the live result of SELECT count() FROM default.depin_revision_ledger WHERE network='IOTX'; the page refuses to ship if the served /v1/revisions?symbol=IOTX disagrees with it. The 18 estate-wide events shown are deduped on revision identity (deterministic hash of network, metric, current_date, prior_date) exactly as the API dedupes them; detected_at is the first detection and never moves. Series absent from a section are absent, not zero. The same-stamp conflict check is the honest live answer: 0 groups in depin_onchain and 0 in depin_daily. Upstream probes ran serially by this generator immediately before rendering: CoinGecko IOTX page (browser-verified origin; 403 here is its bot wall) HTTP 403; DefiLlama fees API for iotex (the DefiLlama upstream family) HTTP 200; IoTeX's own public RPC babel-api.mainnet.iotex.io (the iotex_rpc origin) HTTP 200; estate /v1/revisions?symbol=IOTX HTTP 429; estate /v1/network/IOTX HTTP 429.