peaq (PEAQ) — the revision ledger

Generated 2026-09-02T19:05:43Z from live ClickHouse queries against this estate's ledger. Point-in-time archive held for peaq: 8,938 observations · 42 distinct series · 8 upstream sources · first row 2026-08-09 23:24:18 · newest row 2026-09-02 18:58:01 · every one of the 8,938 rows carries a verify_url · 36 series refreshed in the last 24h (840 fresh rows). Nothing on this page is cached, estimated, or remembered.

Provenance — where PEAQ'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. The first-party family is peaq's own substrate RPC via OnFinality's public endpoint (https://peaq.api.onfinality.io/public) — chain-health peers and finalized block height from the chain itself — with DefiLlama's fees, DEX-volume, TVL and stablecoin families (the origins of the watched fees_alltime_usd / DL_FEES_ALLTIME_USD counters), the CoinGecko market reference, and peaqnetwork/peaq-network-node GitHub activity alongside.

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

The ledger query ran during generation and returned 0 rows for PEAQ — and the reason is on this page, measured live: the detector files cumulative-by-construction series (counters that cannot decrease unless upstream rewrote them), and PEAQ's daily archive holds exactly three watched series of that class — BLOCK_HEIGHT and DL_FEES_ALLTIME_USD (24 snapshots each, via the substrate first-party path) and fees_alltime_usd (10 snapshots, DefiLlama). All three full trails are tabled below: strictly monotonic across every snapshot the estate holds (2026-08-06 → 2026-09-01), so the detector has never had a rewrite to file. Zero here is the live query result plus the measured counter trails, not a gap — the ledger itself is at /v1/revisions?symbol=PEAQ (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=PEAQ cross-check passed: the served API reports 0 row(s), matching the ledger count rendered on this page.

The detector class, measured — PEAQ's watched counters

The detector diffs every daily snapshot of every cumulative-by-construction series. Below is the live intersection of the estate's cumulative watchlist with what the daily archive holds for PEAQ — three real hits, one more than Livepeer's ledger page holds and two more than gauge-only networks: BLOCK_HEIGHT, DL_FEES_ALLTIME_USD and fees_alltime_usd. The trails that follow are every snapshot the archive holds of each, straight from the ledger.

BLOCK_HEIGHT — the peaq chain's block-height counter, every snapshot held, with its source. Strictly increasing across the whole archive: no date's value was ever replaced.

DL_FEES_ALLTIME_USD — the firehose's name for the DefiLlama alltime-fees series (same upstream as fees_alltime_usd), every snapshot the archive holds. Monotonic across the trail; two flat day-pairs are equal values, not replacements.

fees_alltime_usd — the DefiLlama-direct spelling of the same watched counter, every snapshot held, with its source. Also monotonic: no date's value was ever replaced, so there is nothing for the detector to file. These measured trails ARE the zero above.

Gauges that moved backward — deliberately NOT revisions

These series fall outside the detector's cumulative-by-construction class (NOT_TRULY_CUMULATIVE in propintel/revision_ledger.py): a drop there is a real population or market change, not upstream rewriting history. Publishing them as "revisions" would be exactly the fake-metric behaviour this product exists to eliminate.

The sharpest PEAQ case: chain_health_peers — the live peer population from peaq's own substrate RPC (via OnFinality's public endpoint) — swings across the archive as validators and full nodes join and leave. A naive monotonicity detector would file every drop as a restatement; the detector correctly classifies it as a population gauge. The full hourly trail below is the worked example.

The intraday cumulative-class series: finalized_block_height from peaq's own substrate RPC, observed hourly. Strictly increasing across the archive — the same no-rewrite story as the daily watched counters, at hourly resolution.

Same-timestamp conflicting values on record for PEAQ: 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 PEAQ 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 (peer sets, node counts, prices, capacity) legitimately move both ways and are deliberately excluded — a drop there is a real population change, not a rewrite; the chain_health_peers case 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.

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

Served by /v1/network/PEAQ — 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 peaq's own substrate RPC via OnFinality's public endpoint and command 4 DefiLlama's fees series, the origins of the watched counters; command 5 is the estate's graded network row; command 6 is the frozen daily snapshot of the ledger. One polite call per endpoint, no hammering.

# 1) The served revision feed for PEAQ — the same rows this page queried, live:
curl -s "https://kairossignal.com/v1/revisions?symbol=PEAQ" | 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) peaq's own substrate RPC via OnFinality's public endpoint (peers, finalized block height):
curl -s -H "User-Agent: kairos-check" "https://peaq.api.onfinality.io/public" | head -40
# 4) DefiLlama's fees summary for peaq (the fees_alltime_usd origin):
curl -s -H "User-Agent: kairos-check" "https://api.llama.fi/summary/fees/peaq" | python3 -m json.tool | head -40
# 5) This estate's public API row for PEAQ (grades + provenance):
curl -s "https://kairossignal.com/v1/network/PEAQ" | python3 -m json.tool | head -60
# 6) 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_peaq.py and the hourly claim_drift_check.py run grades its claims against the live API like every other published surface. The PEAQ revision count is the live result of SELECT count() FROM default.depin_revision_ledger WHERE network='PEAQ'; the page refuses to ship if the served /v1/revisions?symbol=PEAQ 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 daily-snapshot ledger for PEAQ is genuinely empty today — the three watched cumulative series the archive holds (BLOCK_HEIGHT, DL_FEES_ALLTIME_USD, fees_alltime_usd) each have a strictly monotonic trail, measured live in the tables above — and this page says so instead of inventing restatements. The same-stamp conflict check is likewise the honest live answer: 0 groups in both tables. Upstream probes ran serially by this generator immediately before rendering: peaq substrate RPC via OnFinality public endpoint (first-party upstream) HTTP 405; DefiLlama fees summary for peaq (fees_alltime_usd origin) HTTP 200; DefiLlama DEX overview for peaq HTTP 200; DefiLlama chains list (PEAQ TVL series origin) HTTP 200; DefiLlama stablecoin chains (PEAQ stablecoin series origin) HTTP 200; estate /v1/revisions?symbol=PEAQ HTTP 200; estate /v1/network/PEAQ HTTP 200; CoinGecko peaq page (browser-verified origin; 403 here is its bot wall) HTTP 403; GitHub API peaqnetwork/peaq-network-node (dev-velocity series origin) HTTP 200.