The Ethereum Recompute: Coin Metrics Rewrote Its Own History, and Nobody Re-Ran the Backtests

Hook

On October 1, 2025, at 17:04 UTC, Coin Metrics published a completion notice. The Ethereum exchange flow history had been fully recomputed — every block, back to the genesis block. The announcement contained no revision magnitude. It contained no delta on any published metric. It said the work was finished.

The work had actually finished two days earlier, on September 30. The pre-announcement went out on September 28. Pre-announce, execute, notify. That sequence is not accidental. Someone understood that restating three years of history makes clients nervous, and that nervous clients ask questions the data cannot answer.

Here is what changed for the person staring at the chart. Nothing. The line still moves. The dashboard still renders. The exchange netflow figure still prints to eight significant digits.

Here is what actually changed. The addresses that produced the line were re-attributed. The clusters were rebuilt. The first-nonzero-balance dates were re-derived. The past was edited in place, and the display did not flinch.

This is the quietest category of bug in crypto. It does not liquidate anyone. It does not trigger a thread. It simply makes every backtest that touched this data slightly wrong, in a direction that flatters the strategy. I have spent years auditing systems, and the failures that cost the most are almost never the loud ones. They are the ones where the number stays the same and the meaning underneath it moves.

The chain remembers what the ledger forgets. The ledger just rewrote the chain's bookkeeping.

Context

For roughly six years, "exchange outflow" has been one of the most quoted signals in on-chain research. The logic is intuitive and it is everywhere. Coins leaving exchange wallets imply holders moving to self-custody. Self-custody implies conviction. Conviction implies less sell pressure. Analysts, ETF desks, and trading-signal vendors have built layers of narrative on top of this single inference.

That inference depends entirely on one upstream operation: address attribution. Someone must decide which wallet belongs to which exchange. That decision is not on-chain. It is a judgment, produced by a private clustering algorithm, maintained by a private label library, and sold as an objective input. The signal is only as good as the label library feeding it, and the label library is not audited by anyone outside the vendor.

Three providers dominate this layer. Coin Metrics, Glassnode, and CryptoQuant. All three publish exchange flow metrics. All three describe their methodology in partial public documentation. None of them expose the clustering logic itself.

The dependency chain is short and brittle. Blockchain nodes and RPC endpoints feed raw transactions. Address label libraries and entity-clustering algorithms convert those transactions into attributed flows. Providers package the attributed flows into metrics. Those metrics then flow downstream into quantitative funds, backtesting platforms, research desks, media coverage, and ETF flow analysis. Every layer downstream inherits the error rate of the layer above it. None of the layers publish that error rate.

Now add a second variable that almost nobody outside quantitative research tracks: data versioning. When a provider discovers a new exchange wallet — say, a fresh deposit address spun up last week — it must decide what to do with the past. Does the newly discovered address get retroactively applied to every historical block it touched? Or does it only begin contributing from the moment of discovery?

Those two policies produce two different datasets. They are not "before and after" versions of one number. They are two different knowledge rules, applied to the same raw chain.

Coin Metrics formalized this into a product split. Its Standard metrics use all currently known addresses, each backfilled to its first nonzero balance. Its Point-in-Time metrics use only addresses known at the historical moment, with no retroactive rewrite. Standard restates the past as knowledge grows. PIT freezes the past as it was known.

The recompute that landed on October 1 is the execution of that split. Coin Metrics rebuilt the entire Ethereum flow history under both rules and now publishes daily and hourly PIT counterparts alongside Standard. On paper, this is housekeeping. In practice, it is an admission that every historical exchange-flow chart built on the Standard endpoint was, and remains, a moving target.

Core

Let me be precise about the failure mode, because the imprecision around it is doing damage.

A backtest is only as honest as the data vintage it consumes. When you pull exchange-flow history from a restateable endpoint, you are not querying what the market knew on date X. You are querying what the provider knows today, projected backward onto date X. Every address discovered after date X gets smeared into the period before its discovery. The strategy then sees information that did not exist at decision time.

This is look-ahead bias. It is the oldest sin in quantitative finance, and crypto reintroduced it at industrial scale by treating on-chain data as if it were immutable. On-chain data is not immutable at the point of attribution. The chain is immutable. The interpretation of the chain is a living document.

The magnitude is not theoretical. Glassnode ran a controlled test on a Bitcoin exchange-balance strategy: $1,000 starting capital, 0.1% fees, with signal logic, parameters, dates, and costs held constant. The only variable swapped was the data version. Under the Standard, restated balances, the strategy looked better. Under PIT — the honest reconstruction — it performed worse.

Read that again, because the direction is counterintuitive. More complete data did not improve the backtest. It degraded it. The revision was systematically flattering the strategy, and correcting the data revealed the flattery. The cleaner the data, the worse the strategy looked. That is the shape of a contamination, not a refinement.

I want to flag the evidence quality honestly, because a cold read requires it. That Glassnode BTC backtest is labeled hypothetical and, in the source material I worked from, explicitly not reproduced. It is a directional indicator, not a proof. I treat it as a hypothesis with a plausible mechanism and one unverified data point. That is enough to change behavior. It is not enough to state as fact.

Now the second structural problem, which is worse than the first.

Attribution is the trust root of the entire on-chain data economy, and it is the least transparent component in it. The clustering rules, the entity labeling, the first-nonzero-balance determination — all of it is a black box. An external researcher cannot independently reproduce which wallet was assigned to which exchange, or when. You cannot audit the input. You can only audit the output, and the output changes.

This means that even when you obtain PIT data — the honest version — you are not obtaining an independently verifiable truth. You are obtaining a dataset that faithfully reflects one provider's private judgment, frozen at a point in time. The freeze is honest. The judgment underneath it is still opaque.

I have run this exact class of review. In 2022 I was hired by a mid-tier exchange to reconcile on-chain reserves against internal SQL ledgers. Three weeks of cross-referencing, and the finding that mattered was never a single missing transaction. It was the attribution layer — which wallet belonged to whom — because every downstream conclusion inherited the error rate of that layer, and none of the conclusions carried a caveat about it. The report I produced was sterile. Columns of discrepancies, no adjectives. That is the only format that survives contact with a legal team, and it is the only format that survives contact with a data provider's marketing.

The third problem is reproduction. The common practice in research is to save the query date alongside a result — pulled on 2025-09-15. That is insufficient. If the endpoint is restateable, the same query on the same conceptual date returns a different dataset later. Preserving the query date does not preserve the query result. You must snapshot the data content itself: the values, the version tag, and the provider's computed_at timestamp. Glassnode documents computed_at and openly admits that API publication lags computation by hours. That self-exposure is the most rigorous disclosure among the three providers, and it is also a confession that even PIT data carries a secondary staleness. A high-frequency strategy that consumes PIT data still eats a lag measured in hours.

The fourth problem is coverage. Glassnode's PIT history only exists from the date each metric began being tracked. Before roughly July 2025, coverage is thin. This means strict PIT backtesting across a full market cycle is, for most metrics, simply not possible. The industry cannot reconstruct its own honest history because it did not start keeping one until recently. That is a structural defect, not a bug to be patched.

The fifth problem is scope. Coin Metrics did not recompute Ethereum flows in isolation. It rebuilt roughly nineteen months of ETF wallet data in the same effort. That matters because the current market narrative leans heavily on ETF flows — one recent reading showed Ethereum ETF inflows at $365 million in a single period, outpacing Bitcoin. That headline was built on wallet attribution that has now been revised. If the ETF flow story rests on restateable wallet data, then the story has a version number, and the version number changed.

Map the three providers and the tiering becomes visible. Coin Metrics offers daily and hourly PIT counterparts, rebuilt from genesis — the most complete. Glassnode offers PIT with a start-date limitation and honest timestamps. CryptoQuant's public documentation states its endpoint does not support PIT precision — meaning its historical values can be retroactively revised with no frozen alternative.

Two things follow. First, every quantitative strategy built on exchange-flow signals from a non-PIT endpoint has an unknown, unmeasured, and probably positive bias in its backtest. Second, that bias is invisible. The observation date is unchanged. The metric name is unchanged. Only the information used to build it has moved.

Code does not lie, but it does hide. Attribution code hides best of all, because its output looks like a fact.

There is a regulatory edge here that nobody is pricing. If ETF flow data — or any restateable on-chain metric — is quoted in marketing material for a regulated product, and that metric is later revised, the disclosure may no longer match the revised number. A prospectus that cites a flow figure is citing a value that can change after publication. That is a live disclosure risk, and it sits at the intersection of data vendors and regulated issuers. It will surface in a contract clause before it surfaces in a fine: expect data-version warranties to appear in vendor agreements.

Contrarian

The reflexive take is that Coin Metrics damaged its own credibility by admitting the past needed rebuilding. I think that reading is backwards, and the methodologists are right about something the skeptics are missing.

The full recompute from genesis, rather than incremental patching, tells you the accumulated attribution error was large enough to justify the expensive option. A provider does not rebuild three years of history to fix a rounding error. It rebuilds when the error is structural. Choosing the expensive, embarrassing, transparent path over the cheap, quiet one is the correct behavior. Optimization is just risk wearing a disguise, and this recompute removed a disguise rather than adding one.

Consider the alternative. Coin Metrics could have silently patched forward, kept one number, and let the version drift accumulate unlabeled. That is what the industry did for years. The recompute is the first time a major provider said, in public, that its historical data had two legitimate readings and that clients needed to know which one they were consuming. That is not a scandal. That is an audit finding, voluntarily published.

The tiering itself is also a signal. Three providers, three levels of PIT capability, all converging toward reproducibility and auditability. That convergence is competitive pressure doing exactly what it should. When one provider ships full PIT, the ones without it face a methodology disadvantage they cannot argue away with a transparency statement. CryptoQuant's public admission that its endpoint lacks PIT precision reads, to me, as defensive disclosure — a pre-emptive answer to a question institutional clients are about to start asking.

And here is the genuinely counterintuitive part, the one the market has not internalized. Better data does not produce better backtests. It produces more honest ones, which are usually worse. The industry has spent years assuming that more complete history equals more reliable research. The Glassnode result inverts that assumption. Completeness, in a restateable system, is contamination. The PIT dataset is smaller, uglier, and more limited — and it is the only one that tells you what a strategy would actually have done.

The bulls are right that on-chain data is becoming more auditable. They are wrong if they think that process will validate their historical returns. It will do the opposite. And the migration lock-in makes it worse: a research desk that built a backtest library on one provider's Standard endpoint cannot simply switch. Switching means re-running everything, and re-running everything means watching returns fall. The lock-in is not contractual. It is computational, and that is the strongest kind.

Takeaway

The next time a chart tells you exchange outflows are rising, ask one question before you act on it. Which version of the data built this chart?

If the answer is the provider's current dataset, you are looking at a number that can change without changing. If the answer is "I don't know," you are running a strategy on a surface that has already been edited underneath you.

The fix is procedural and unglamorous. Snapshot data content, not query dates. Version-stamp every metric you cite. Re-run exchange-flow backtests on PIT data, or label them as version-unknown. Treat attribution as a dependency with a failure rate, because that is what it is. Trust is a variable, not a constant — and in on-chain data, it is a variable that gets quietly restated while everyone watches the line.

Coin Metrics rewrote the past in October and disclosed almost none of the magnitude. The number on the screen did not move. The only open question is whether your model did.