FLock.io (FLOCK) — the revision ledger

Generated 2026-10-17T05:19:20Z from live ClickHouse queries against this estate's ledger. Point-in-time archive held for FLock.io: 38,140 observations · 46 distinct series · 6 upstream sources · first row 2026-08-09 17:15:20 · newest row 2026-10-17 04:58:01 · every one of the 38,140 rows carries a verify_url · 36 series refreshed in the last 24h (693 fresh rows). Nothing on this page is cached, estimated, or remembered.

Provenance — where FLock.io's archive comes from

6 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. FLOCK publishes no first-party stats API of its own — the network-side families here are DefiLlama's fees and protocol endpoints for flock.io (the all-time fee counter this page's revision comes from), plus public chain infrastructure (base_rpc supply and burn-address reads and Base Blockscout counters for base:0x5ab3d4c385b400f3abb49e80de2faf6a88a7b691), with CoinGecko's market series and FLock-io GitHub activity alongside.

Revision ledger — 1 backward revision(s) recorded for FLOCK

Backward revisions are values upstream later replaced for a date this estate had already archived. The before-value is retained alongside the replacement — both snapshot dates, both numbers — which is what no overwriting vendor keeps. /v1/revisions?symbol=FLOCK cross-check passed: the served API reports 1 row(s), matching the ledger count rendered on this page.

Reading this row honestly. It is real — DefiLlama's all-time fees for flock.io were archived at 1,170,614.60 for 2026-08-09 and the next snapshot replaced that date's value with 1,170,544.16, a −70.44 backward move on a counter that only ever grows. It was also the first event the estate-wide detector ever recorded (2026-08-13 15:35:15, four days after the archive opened). The sub_noise kind and the defillama_fees source spelling are the detector generation of that day: the current classifier emits only counter_reset / backward_revision, and its current noise floor (0.01%) would not record a −0.006017% pair at all. The ledger is append-only, so this estate does not silently rewrite its own detection history either — the row ships exactly as it was written, with its vocabulary and all. That is the same retention discipline this product sells, applied to the detector itself.

What the detector watches for FLock.io — 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 (11 declared names, so this page can never drift from the detector) — with what the daily archive holds for FLOCK. Three watched series are held. Two of them are the DefiLlama all-time fee spellings — one of which produced the restatement above — and the third is the Blockscout transfer counter, monotonic end to end. That is the structural content of the ledger above: watchable counters exist, they were fully diffed, and one of them moved backward.

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

These are the actual counter trails the detector diffed for FLOCK, rendered live from the archive. Each is a series that cannot decrease unless upstream rewrote history — which is exactly why the 08-09 → 08-10 pair in the first trail is the restatement, visible in the raw archive and not just in the ledger row.

DL_FEES_ALLTIME_USD — the all-time fees counter for flock.io (DefiLlama), the series the recorded revision comes from. The restated pair is highlighted:

fees_alltime_usd — the sibling DefiLlama spelling, which enters the archive 2026-08-23 (after the restatement) and is monotonic over its held window; its values line up with the restated DL_* line:

token_transfers_total — the lifetime transfer counter for the FLOCK token contract on Base (Base Blockscout), the series class that produced real restatements for OVPP, AUKI, R1 and SOGNI elsewhere in the estate — monotonic here:

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 population or market change, not upstream rewriting history. Publishing them as "revisions" would be exactly the fake-metric behaviour this product exists to eliminate.

Same-timestamp conflicting values on record for FLOCK: 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 FLOCK 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 revision above is a cross-snapshot rewrite of one date's value — prior 08-09 vs replacement recorded in the 08-10 snapshot — which is a different, detected-by-design phenomenon.)

The ledger, live — every restatement recorded estate-wide (39 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 overwritten; 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 overwritten. Population gauges (provider 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 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.

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); commands 3–4 hit the upstream families the network-side rows came from; 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 FLOCK — the same rows this page queried, live:
curl -s "https://kairossignal.com/v1/revisions?symbol=FLOCK" | 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 API for flock.io (the restated counter's origin):
curl -s -H "User-Agent: kairos-check" "https://api.llama.fi/summary/fees/flock.io" | python3 -m json.tool | head -40
# 4) Base Blockscout token endpoint for the FLOCK contract (transfer counters' origin):
curl -s -H "User-Agent: kairos-check" "https://base.blockscout.com/api/v2/tokens/0x5ab3d4c385b400f3abb49e80de2faf6a88a7b691" | python3 -m json.tool | head -30
# 5) This estate's public API row for FLOCK (grades + provenance):
curl -s "https://kairossignal.com/v1/network/FLOCK" | 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_flock.py and the hourly claim_drift_check.py run grades its claims against the live API like every other published surface. The FLOCK revision count is the live result of SELECT count() FROM default.depin_revision_ledger WHERE network='FLOCK'; the page refuses to ship if the served /v1/revisions?symbol=FLOCK disagrees with it. The 39 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. The single FLOCK ledger row predates the current detector vocabulary: kind=sub_noise and source=defillama_fees are historical spellings, published as written — the ledger is append-only and this estate does not rewrite its own detection history. 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 FLOCK page, flock-2 (browser-verified origin; 403 here is its bot wall) HTTP 403; DefiLlama fees API for flock.io (the DL_* / fees_* alltime upstream) HTTP 200; DefiLlama protocol page for flock.io (the TVL/staking upstream family) HTTP 403; Base Blockscout token endpoint for the FLOCK contract (the blockscout upstream family) HTTP 403; Basescan token page (the base_rpc burn-address family's public reference) HTTP 200; GitHub API FLock-io/llm-loss-validator (the github upstream family) HTTP 200; estate /v1/revisions?symbol=FLOCK HTTP 200; estate /v1/network/FLOCK HTTP 200.