Onchain Verification ✅ Checklist for Trusted Crypto Data
Learn onchain verification with a trusted blockchain data verification checklist: validate RPC response, review crypto transaction receipts, and verify finality.

The Receipt Balanced. The Blockchain Didn't.
A treasury buyback receipt looked airtight. Every line was accounted for, fees were itemised to six decimal places, and the reported balances matched the swap log. Then an independent check found something that the receipt itself never mentioned: 0.0020265546 BNB had left the treasury between two buybacks without showing up anywhere in the document.
What was missing wasn't some mysterious accounting edge case. It was a 0.002 BNB gas grant sent to an escrow wallet. The receipt builder recorded payout fees for that window, but it didn't record gas grants - so it missed the transfer. The team confirmed the discrepancy, fixed the builder, and moved on.
But the real lesson isn't the bug. It's the mechanical check that caught it - and the fact that anyone can run the same kind of check against the same chain data.
Onchain reports are only as reliable as the questions you ask and the evidence you keep. A balance can look precise even when it's wrong: a missing block reference, a "zero" decoded from an empty RPC response, or a token amount converted with assumed decimals. This guide lays out a practical checklist for verifying onchain claims, including how to handle uncertainty, preserve evidence, and describe transaction finality.
Why a receipt can look right and still be wrong
A receipt is a representation of activity, not the activity itself. It might be assembled from swap logs, a database, contract events, or a mix of sources. Each part can be accurate on its own, and the final output can still be incomplete.
That gap matters when a report is used to make decisions. A treasury team might rely on it to reconcile funds. A protocol might publish it to users. An analyst might use it to estimate a buyback's cost or judge whether a contract behaved as expected. In all those cases, a clean-looking document isn't proof that every relevant onchain movement made it into the story.
In the BNB example, the receipt builder recorded payout fees but not the gas grant. The lines that appeared in the receipt still reconciled with the swap log - because the missing transfer wasn't in the builder's accounting window. The problem only became visible once the check was defined broadly: sum every BNB outflow from the treasury between two specific blocks, then compare that total with the receipt's net line.
First lesson: verify the claim the report is making, not just the data the report included. If the claim is "all outflows," then checking only swaps and their fees won't be enough. If the claim is "the token balance at time X," then transaction logs alone may not prove that balance.
A useful verification task needs a reproducible boundary. It should say what address or contract you're checking, what operation you're checking, what arguments matter, and what block (or block range) defines the time boundary. The details depend on the claim. "Check a balance" and "audit outflows over a period" are different questions, even if they get described casually as the same thing.
That's where surface-level validation tends to break down. People see a plausible number, a successful API response, or a polished receipt and treat that as confirmation. In practice, the hard part is often not fetching data - it's defining what counts as evidence, and what a failed or incomplete fetch actually means.
Six checks for reliable onchain claims
Use these checks before you include an onchain number in a report. They're intentionally mechanical. If your verification depends on an analyst remembering an unstated assumption, it won't reproduce later - and it will eventually fail.
1. Pin the question before querying
A request like "check the balance" is too vague to audit. Before you make the call, write down:
- The contract or wallet address.
- The function selector or event you're querying.
- The arguments (including ABI encoding when applicable).
- The block number, block range, or explicit use of "latest".
The right setup depends on the claim. To check a historical token balance, specify the token contract, the account, and the block. To audit treasury outflows over a period, specify the treasury address and the two block boundaries, then define which kinds of transfers count. Native transfers, token transfers, and internal contract movements may require different data sources and different interpretation.
Pinning these details turns a vague impression into a test someone else can rerun. It also exposes ambiguity early. If you can't say which block the claim refers to, you don't actually have a fixed historical claim - you have a moving target.
2. Treat an empty 0x response as unverifiable
An RPC endpoint can return 0x (an empty hexadecimal response) when a call doesn't produce decodable data. That can happen for a bunch of reasons: provider issues, an incorrect block range, or querying a contract that isn't deployed on the selected chain.
The key point is simple: empty output doesn't establish that the value is zero.
If your decoding logic turns 0x into 0, you've replaced an inconclusive query with a factual statement. The right status is unverifiable - not false and not zero.
Retrying on another endpoint can help, but two endpoints don't automatically mean two independent confirmations. They might share the same infrastructure or upstream data. For historical calls, you may need an archive-capable node. And if the evidence still can't be obtained, report the gap instead of guessing.
3. Never assume units or token decimals
A raw onchain value isn't automatically a human-readable amount. Token decimals are often 18, but that's a convention - not a guarantee. If the contract doesn't expose decimals() and your source doesn't establish the scale, the honest result is no_unit_stated - not "a nicely formatted number" based on an assumed exponent.
This isn't a minor precision issue. Using the wrong scale can create a 1,000-fold error while the output still looks neat and plausible. Keep the raw integer, document the unit and conversion scale you used, and explain where that information came from. If you can't verify the unit, don't present the converted amount as established fact.
4. Bind the receipt to the object you fetched
Evidence should identify the exact state or response you used to support the claim. For state-based checks, keep the block number and block hash alongside the raw response. A digest - like a SHA-256 of the exact JSON response - helps show that the stored evidence hasn't been altered.
Be careful about how you compute it. If you parse and reserialize JSON before hashing, you may change formatting or key order and end up with a different byte sequence. Keep the original response and record the digest method so someone else can reproduce it.
This binding matters because chain state changes. "I checked the balance" isn't enough if nobody can tell which block you queried or what the node returned. In the treasury example, the comparison depended on reading boundary balances at specific blocks and matching the difference against the transfer history.
5. Treat finality as part of the number
"Confirmed" isn't a complete description of transaction status. On layer 2 networks especially, a transaction might be visible or soft-confirmed before it's included in a batch or reaches the network's later finality milestone. Those meanings and timings differ by network.
Your report should state the confirmation status and what "that status" means for the network. Otherwise, a reader may treat a provisional observation like irreversible settlement. The value alone doesn't communicate that distinction.
This matters for treasury operations, settlement monitoring, and anything that triggers a follow-up transaction. The right threshold depends on the decision you're making: a dashboard might accept early activity, while reconciliation may require stronger finality guarantees. Label the status rather than implying every confirmation has the same weight.
6. Apply the same standard to a clean result
A check that finds no discrepancy is still making a claim. It needs a defined query, valid responses, stated units, and evidence tied to the block(s) you checked. A "clean" result isn't a reason to stop controlling - it's the outcome those controls were designed to support.
It's easy to miss this because people naturally scrutinize anomalies more than expected outcomes. But a receipt can look balanced and still omit a whole category of activity. A correct "all-clear" isn't "nothing happened." It's "here's what we checked, here are the sources, and here's what the evidence supports."
Turn the checklist into a repeatable workflow
The checklist only helps if it becomes a consistent process, not a one-off review. A practical workflow has four stages: define the claim, fetch the evidence, validate the response, and report the result along with its limits.
1. Write down the claim and its boundaries
Start with one sentence you could test. For example: "sum all BNB outflows from this treasury address between block A and block B, then compare the result with the receipt's net outflow." Record the address, the asset, the block boundaries, and what types of movement are included or excluded.
This is where many disagreements disappear - usually. If one person counts gas grants and another counts only buyback payouts, they can both be "right" and still get different totals. Define the scope before you compare numbers.
2. Fetch and preserve the raw evidence
Run the pinned query against an appropriate node or data source. Store the request details, the raw response, the block number, and the block hash. If your audit depends on boundary balances, preserve both reads and the calculation that connects them. Don't keep only a formatted summary - the summary is a transformation of evidence, not a substitute for it.
Where possible, verify key results against another source. Treat this as corroboration, not a magical guarantee. A second endpoint is useful only if it can independently return the relevant data and if you understand its limitations.
3. Validate before decoding or summarising
Before decoding, check whether the response is present and structurally valid. Then confirm the contract and method match the intended query, that arguments were encoded correctly, and that the block is the one you specified. For token quantities, verify the scale before converting raw values into display units.
If any of those checks fail, stop the calculation. Don't let a failed call fall through into a default value. In production systems, model states like verified, discrepant, and unverifiable explicitly - rather than representing every outcome as just "a number."
4. Report both the result and its evidence status
A useful report doesn't only say balanced or not balanced. It includes the measured value, what it was compared against, the relevant block references, and the limitations. If the RPC response was empty or the unit can't be established, say the claim couldn't be verified. If a discrepancy was found, describe the specific movement and how you reconciled it.
A compact evidence record can include:
- Claim and scope: address, asset, operation, and block range.
- Query details: function or event, arguments, and ABI encoding where relevant.
- Source details: provider or node used, plus any cross-checks performed.
- Raw evidence: response, block number, block hash, and digest procedure.
- Interpretation: units, finality status, calculation steps, and any unresolved limitations.
This workflow is a good candidate for automation. An agent can enforce the same input requirements, refuse to treat empty data as zero, and route cases it can't verify. Automation helps consistency - but it doesn't remove the need to define the claim or understand what the evidence means. A badly specified check can be executed perfectly and still answer the wrong question.
Conclusion
The treasury receipt wasn't misleading because its arithmetic was complicated. It was incomplete because the builder omitted a category of outflow. A broader, pinned check surfaced the 0.002 BNB gas grant and gave the team a concrete issue to fix.
For reliable onchain reporting: define the query, distinguish missing data from zero, verify units, bind evidence to a block and response, and state finality. Apply the same discipline even when the result is clean - controls don't make every claim certain; they make it clear what was checked and where certainty ends.
If you're running agents or reporting systems against blockchain data, turn this checklist into an explicit verification workflow. The original case and Onchain Claim Verifier reference is a good starting point. The chain doesn't round - and a report shouldn't hide what it can't verify.