Empty Propagation: Diagnosing Silent Failures in On-Chain Data Pipelines

The Zero That Wasn't

At 04:17 UTC, the subgraph for a mid-capitalization decentralized exchange returned an empty array for its daily volume entity. The dashboard above it did not crash. It rendered. The number it displayed was 0.00. For eleven hours and twenty-three minutes, no alert fired, no engineer was paged, and the protocol's community channel continued to cite "stable volume." The anomaly was not the zero. The anomaly was the silence around it.

I have seen this failure mode before, and it is not a dashboard problem. It is a pipeline problem. An empty result set at the ingestion layer does not remain empty as it moves downstream — it becomes a confident zero by the time it reaches a human being. I call this empty propagation. It is the most under-reported failure class in on-chain analytics, and it is the reason I no longer trust any metric I have not personally traced from the RPC response to the rendered pixel.

An anomaly is just a story waiting to be read. This one begins not with a hack, not with a depeg, not with a governance attack — but with a null value that learned to wear a costume.

The Four-Layer Pipeline and the Physics of Emptiness

On-chain data does not arrive formatted. It arrives as a raw JSON-RPC response — a JSON object with a result field, a hex string, a block number, and nothing resembling a chart. Between that hex string and the number a trader reads on a dashboard, there are four distinct layers, and each of them can fail silently.

The first layer is ingestion. A node answers a query. The node might be an archive node, a full node, or a pruned node. It might be rate-limited, geographically throttled, or behind a load balancer that returns a 403 to anything that looks like a bot. Ingestion is where the raw material is either captured or lost.

The second layer is decoding. Raw logs contain topics and data blobs. To turn them into meaning, you need an Application Binary Interface — an ABI — that maps the byte layout back to named events and parameters. If the ABI does not match the contract that actually emitted the log, the decoder returns nothing. Not an error. Nothing.

The third layer is indexing. Decoded events are aggregated into entities: a wallet, a pool, a daily volume figure. This is where classification happens — where an address is labeled as a market maker or a retail wallet, where a transfer is tagged as a swap or a bridge. If classification does not run, the aggregation still runs, but it runs on unlabeled data, and unlabeled data defaults to a category that is almost always wrong.

The fourth layer is serving. A template renders the indexed data into a human-readable form. This is the layer everyone trusts, and it is the layer that lies most fluently, because a template that receives an empty object does not usually throw an exception. It renders the empty object's default. In JavaScript, Number(null) is 0. In SQL, COALESCE(NULL, 0) is 0. In a templating engine, an undefined variable renders as an empty string or a zero, depending on the type coercion rules the developer chose six months ago and never revisited.

Empty propagation is the study of how a null at layer one becomes a plausible, non-alarming, human-readable value at layer four. The danger is not that the value is wrong. The danger is that the value is reasonable. A null is loud. A zero is quiet. A zero looks like a slow day. A zero looks like a market that finally calmed down. A zero looks like the thing everyone has been waiting for in a sideways market — and that is precisely why it goes unnoticed.

I have spent eleven years watching this pattern. I have watched it in NFT volume, in stablecoin redemption, in ETF flow dashboards, and in the compliance tooling that institutional capital now depends on. The mechanics are always the same. The costume changes. The null always learns to dress up.

Layer One: The 403, the Pruned Node, and the Header Without a Body

Ingestion failures are the most physical failures in the pipeline. They are also the easiest to dismiss, because they look like infrastructure problems rather than data problems. They are both.

Consider the most common ingestion failure: a scraper or an RPC client that is blocked. When a data provider hits a 403 or a 429, the well-behaved client backs off and retries. The badly-behaved client — and there are many in production — logs the failure, returns an empty list, and lets the pipeline continue. Downstream, that empty list is indistinguishable from "there was nothing to fetch." The two conditions are semantically opposite and operationally identical. That is the seed of empty propagation.

The on-chain equivalent of "only capturing the tag" is capturing the block header without the block body. A header tells you that block 21,455,832 exists. It tells you the parent hash, the timestamp, the state root. It does not tell you what happened inside it. A pipeline that ingests headers but fails to ingest bodies will report a perfectly healthy chain height while reporting zero activity. The chain is alive. The data is dead. The dashboard shows neither.

There is a subtler variant: the pruned node. Full nodes discard historical state after a certain depth to save disk. If a query asks for a state that has been pruned, the node does not return an error in every client implementation — some return a null result that a naive decoder will treat as an empty account. An empty account looks like a wallet that never existed. In a compliance context, a wallet that "never existed" is a wallet that never transacted, which is a wallet that never triggered a threshold, which is a wallet that passes every automated check. The pruned node is not a data-integrity problem until it becomes a regulatory one.

I learned the cost of ingestion blind spots the hard way. In May 2022, after the collapse of TerraUSD, I spent three weeks dissecting the $61 billion exit-liquidity flow. I did not begin with the price. I began with the redemption mechanics, block by block. I pulled every relevant log from the relevant nodes and mapped whale withdrawals against protocol liquidity pools with second-level resolution. The finding that mattered was not that the system was fragile — everyone knows algorithmic stablecoins are fragile in retrospect. The finding that mattered was the timing: 78% of the outflows occurred in the first 15 minutes, preceding any public news. The public narrative arrived after the liquidity had already left the building.

But here is the part I did not publish in the first draft, because it was a data-integrity finding, not a market finding: three of my initial queries returned empty arrays. I nearly accepted them. An empty array of redemptions would have implied a calm pool, which would have contradicted everything else I was seeing. I re-ran the queries against a second, independent archive node and the redemptions appeared. The first node had been partially pruned and was answering my historical state queries with silent nulls. Had I trusted the first pass, I would have published a report claiming the exit was orderly. It was not. Every transaction leaves a scar; I map the wound — but only if my instruments are actually pointed at the body.

That experience produced a rule I now apply to every ingestion layer: never accept an empty result from a single source. If the result is empty, the first question is not "what does this mean for the market?" The first question is "is this node telling me the truth, or is it telling me nothing?"

Layer Two: Schema Drift and the Proxy Upgrade

If ingestion failures are physical, decoding failures are structural. They are the equivalent of a field-name mismatch — the classic title versus article_title problem — except on-chain, the mismatch is enforced by cryptography and therefore fails more politely and more completely.

An ABI is a contract's Rosetta Stone. It declares that a log with topic0 equal to a particular keccak256 hash contains a Transfer event with parameters from, to, and value. When a contract is upgraded — and most production DeFi contracts are upgradeable behind an EIP-1967 proxy — the implementation can change the event signature, or add a new event, or stop emitting an old one. The proxy address stays the same. The topic0 hash changes. An indexer that has cached the old ABI will decode the new logs into nothing. It will not throw. It will return an empty decoded event list.

This is schema drift, and it is invisible because the contract address is stable. A monitoring system keyed on address sees nothing wrong. A monitoring system keyed on the ABI — which almost nobody builds — would see the signature change immediately. The most dangerous upgrades are the ones that keep every public identifier constant and change only the meaning underneath.

I have audited enough protocols to know that most teams test their new implementation against their new ABI, and almost none test their existing downstream consumers against it. The integration test passes because the test is scoped to the upgrade, not to the pipeline. The pipeline is where the drift lives.

The decoding layer is also where classification usually begins, which means decoding failures and classification failures frequently travel together. In late 2021, I aggregated wallet transaction data across 500,000 unique NFT addresses to study what the marketplace was actually doing. I found that 14% of "organic" trading volume was generated by 0.5% of high-frequency wallets running wash-trading bots. The headline was manipulation. The methodology lesson was decoding.

Those wash-trading wallets were detectable because their decoded event sequences were too regular. They bought and sold to themselves at intervals that no human trader produces, and their gas patterns — the priority fees they were willing to pay — revealed bot behavior that their trade sizes alone did not. I verified every claim against gas before I published, because a decoded event without a gas signature is a story, and a decoded event with a gas signature is evidence. The decoding layer is not just about reading the log; it is about reading the cost of the log. A trade that costs almost nothing to execute is a trade that probably wasn't a trade.

When I say I never publish unverified volume claims, I mean it literally. I have a private script that re-derives every volume figure I cite from raw logs, and it fails loudly if the re-derived number differs from the published number by more than a tolerance. That script has caught more decoding bugs than any monitoring tool I have ever bought.

Layer Three: Classification — The Classifier That Never Ran

There is a class of failure that produces no null at all, and it is therefore the most dangerous of all: the classifier that silently skips a step. The data flows. The numbers appear. The labels are just wrong.

In an on-chain context, classification means wallet clustering and entity labeling. Is this address a market maker, a bridge, a retail user, an exchange hot wallet, or a smart contract? The answer determines how every downstream metric is interpreted. If 40% of a pool's liquidity comes from a single labeled market maker, the pool is fragile. If the same 40% is unlabeled, the pool looks diversified.

By early 2025, as the EU's Markets in Crypto-Assets regulation moved into full implementation, I conducted an audit of 50 major DeFi protocols to assess their transaction-monitoring readiness. I found that 60% of high-volume decentralized exchanges lacked robust wallet-clustering algorithms. That is a compliance finding on its face. It is an empty-propagation finding underneath.

Here is the mechanism. A DEX without clustering does not return null labels. It returns default labels. The default label for an unclassified address is usually the least alarming one available — "retail," "unknown external," or an empty string that the aggregation layer coerces into the same bucket as genuine retail flow. So the protocol reports a healthy distribution of retail users, and the distribution is an artifact of a classifier that never ran. The classifier did not fail; it was never asked to succeed.

I compiled a dataset of 12,000 unmarked transactions from decentralized exchanges while doing this work. The point was not to shame anyone. The point was to build a rule-based framework that would let a compliance officer distinguish between "we have no risky transactions" and "we have no way of knowing whether our transactions are risky." Those two statements sound identical to a regulator reading a dashboard. They are not identical. One is a finding. The other is a void wearing the mask of a finding.

The classification layer is where empty propagation becomes strategically expensive, because it is the layer where institutional capital makes allocation decisions. An institution that reads a distribution of retail flow will price a pool differently from an institution that reads a distribution of concentrated market-maker flow. The difference between those two readings can be tens of millions of dollars of positioning — and the difference is not in the market. It is in whether a classifier executed.

Layer Four: Serving — The Template That Rendered Successfully

The serving layer is the one everybody trusts and the one that lies best. This is the layer where a template receives an empty object and renders a clean, complete, plausible page. The render succeeds. The success is the bug.

Think about the anatomy of a template. It has a variable, dailyVolume. It has a formatting rule, formatCurrency(dailyVolume). The formatting rule was written by a developer who assumed dailyVolume would always be a number. When dailyVolume is null, the rule does not throw in most JavaScript environments — it coerces. Number(null) is 0. formatCurrency(0) is $0.00. The page renders. The server returns HTTP 200. The uptime monitor, which checks for HTTP 200, reports full health.

A pipeline can be 100% "up" by every conventional measure and 100% wrong by every substantive measure. This is the single most important sentence in this article, and it is the sentence that most analytics teams never write down.

The serving layer is also where I learned to add confidence intervals to my conclusions. In January 2024, coinciding with the approval of spot Bitcoin ETFs, I built a dashboard tracking daily net inflows across BlackRock's IBIT, Fidelity's FBTC, and Grayscale's GBTC. I correlated those inflows with off-chain order-book depth on Coinbase and Binance. The finding that contradicted the mainstream narrative was this: during the first 30 days, there was a statistically significant inverse correlation between GBTC outflows and spot price stability. I quantified that GBTC sell pressure absorbed roughly 40% of the new institutional buying power, delaying the price surge that the media had already declared inevitable.

The market takeaway was interesting. The methodology takeaway was more important to me. As I built that dashboard, I discovered that the inflow figure and the outflow figure were being served by different systems with different update cadences and different null-handling rules. On a slow data day, one system would report zero inflow while the other reported normal outflow — and the net would render as a large negative number that looked like a real market event. It was not. It was two serving layers disagreeing about what an empty result means.

That is why I began publishing data confidence intervals alongside every directional claim. A confidence interval is an admission that the serving layer can be wrong in a bounded way. If you cannot state the bounds of your uncertainty, you are not publishing analysis; you are publishing the output of a template.

The Diagnostic Table

When a pipeline returns an empty or suspicious result, the failure is usually in one of four places. The diagnostic logic maps cleanly onto on-chain infrastructure.

| Symptom | Likely Cause | How to Verify | |---|---|---| | Metric reads zero with no error | Serving-layer coercion of a null (?? 0, COALESCE, Number(null)) | Query the API directly and inspect the raw JSON for null versus 0 | | Entity exists but has no attributes | Decoding-layer ABI mismatch after a proxy upgrade | Compare topic0 hashes in the raw logs against the current implementation ABI | | Activity present in one source, absent in another | Ingestion-layer node divergence (pruning, rate limiting, reorg) | Re-run the identical query against a second, independent archive node | | Distribution looks plausible but unverifiable | Classification layer never executed; defaults substituted for labels | Check whether the clustering job's last successful run timestamp is recent |

The table is not a troubleshooting guide in the ordinary sense. It is a provenance test. Every row asks the same underlying question: can I trace this number backward to the raw event that produced it? If the answer is no, the number is not a number. It is a rendering.

The Remediation Path

When I find an empty or hollow result, I follow a fixed order of operations. The order matters, because checking the wrong layer first wastes time and, worse, can produce a false sense of resolution.

First, I trace the source. Before I touch any downstream system, I pull the raw RPC response or the raw log. If the raw material is empty, the problem is at ingestion. If the raw material is present and the decoded material is empty, the problem is at decoding. The raw response is the ground truth, and everything else is interpretation.

Second, I check the node layer. Is the node an archive node? Is it pruned? Is it rate-limited? A single 403 can produce a cascade that looks like a market event by the time it reaches a dashboard. I keep at least two independent node providers configured for exactly this reason.

Third, I validate the field and ABI mapping. Schema drift is the silent killer of long-lived pipelines. I diff the current event signatures against the cached ones on a schedule, not on demand, because by the time you are debugging on demand, the drift has already propagated.

Fourth, I establish a minimum viable query. If I can get one eth_getLogs call to return one real event, I can start. A single verified event is worth more than a thousand unverified aggregates. This is the same principle as a minimum viable input: one sentence of true text beats a page of placeholder fields.

The 2026 Wrinkle: When AI Agents Read the Zero

In mid-2026, I analyzed 100,000 transactions generated by autonomous AI agents on Ethereum. The behavioral signature was distinct: the agents exhibited lower slippage tolerance and faster reaction times to liquidity changes than human traders. At peak hours, AI-driven trades accounted for roughly 22% of total ETH volume.

That number has a direct consequence for empty propagation, and it is not reassuring. A human trader reading a $0.00 volume figure will usually pause and ask a colleague. An AI agent reading the same figure will not pause. It will treat the zero as a signal — an absence of liquidity, an absence of competition, an absence of demand — and it will act on it within milliseconds. Empty propagation used to corrupt human judgment on a human timescale. It now corrupts machine judgment on a machine timescale.

The 22% figure means that nearly a quarter of peak volume is now generated by systems that cannot distinguish a genuine zero from a coerced null. When a serving layer lies to a human, the human loses money slowly. When a serving layer lies to an agent, the agent loses money fast and, worse, feeds the corrupted signal back into the market as a real trade. The zero becomes self-fulfilling. The null becomes a price.

I proposed a metric for this — an "AI Market Efficiency" ratio — precisely to give traders a way to separate organic demand from automated demand. But the deeper use of that metric is diagnostic. If automated demand spikes at the exact moment a data feed goes quiet, you are not watching a market. You are watching a pipeline failure being amplified by machines that trust it.

Contrarian: Sometimes Zero Is True

Here is where I have to be careful, because the obvious conclusion of this article — "anomalies are bad, zeros are lies" — is wrong, and it is the kind of wrong that gets people fired.

Not every zero is a failure. Sometimes zero is the truth, and the discipline is distinguishing an empty result from an absent event. A dormant wallet genuinely has no transactions. A pool that has been abandoned genuinely has no volume. A protocol that nobody uses genuinely reports nothing. If you treat every zero as a bug, you will eventually "fix" a true zero into a false positive, which is a worse error than the one you set out to correct.

The distinction is provenance, not magnitude. A true zero comes with a traceable chain: the node answered, the ABI matched, the classifier ran, and the aggregate of real (empty) events is zero. A false zero comes with a broken chain somewhere upstream. The number on the screen is identical. The epistemics are opposite.

This is also where correlation and causation part ways. The empty array and the dashboard zero are correlated — one produces the other. But the dashboard zero did not cause the outage, and the outage did not cause the zero. The coercion caused the zero. If you fix the outage without fixing the coercion, the next outage produces the same zero, and you will have learned nothing. The pattern emerges only after the dust settles, and the dust settles on the mechanism, not the symptom.

There is one more contrarian note, and it is the one I find hardest to explain to non-analysts. Sometimes the empty result is the signal — a protocol that stops emitting logs is itself an event worth investigating. But a broken indexer also stops emitting logs, and it looks identical from the outside. The entire discipline of on-chain forensics reduces to telling those two apart. Silence is not a signal. Silence is a question, and the answer depends entirely on whether your instruments were listening.

Takeaway: The Delta Between Two Indexers

The forward-looking signal I am watching in this sideways market is not a price level. It is the delta between two independent indexers. When one indexer reports activity and another reports zero for the same contract over the same window, you have not found a market opportunity. You have found a pipeline, and one of its layers is lying. That delta is the earliest warning available, and it fires before any price moves, because data integrity failures always precede the trades that react to them.

I do not predict the future; I trace the past. And the past, traced carefully enough, is where the next zero is already forming — quietly, plausibly, and in a font that looks exactly like the truth.