TrustlessConcepts

Consensus Verification

Consensus verification is a technique for checking that a message has been confirmed by a chain's consensus, i.e., that it sits in a finalized block. It runs in two steps: block verification and block inclusion verification.

consensus-verification-flow

Block verification

A consensus engine is the set of interdependent rules that keep a blockchain alive and sound: block finalization, incentives, slashing, and more. Ultimately it's the protocol that lets a chain continuously produce and finalize blocks whose data is valid with respect to the execution layer, under real network conditions.

Block production. A consensus engine is stateful: its state changes constantly as blocks are produced, and that consensus state is usually committed into the finalized blocks themselves.

consensus-block-production

That's how blocks are produced — but we don't need to produce blocks, only to verify them.

Chain of verification. Block production gives us a recipe for verification. Starting from a single initial trusted consensus state, we can verify a chain of consecutive finalized blocks:

consensus-verification-chain

  • The previous consensus state, together with the finality rules, tells us whether a block is finalized.
  • If the block is finalized, the consensus state committed inside it is finalized too, so we extract that state and adopt it as the new trusted checkpoint for verifying the next block.
  • From one valid initial consensus state, we can therefore verify every following block in sequence.

Jump-skip verification. Walking the chain block by block is wasteful — and usually unnecessary. From a checkpoint at block n we can jump straight to a far-future block m and verify it directly, skipping everything in between, as long as the checkpoint is compatible with m.

To see why this is sound, look at what checking finality actually consumes: proof that a supermajority of the right validator set signed the block. The blocks between n and m matter for one reason only: they record how the validator set changed; they are how we would learn the set that signs m. So whenever the checkpoint's set still vouches for m (it hasn't rotated out), the intermediate blocks teach us nothing we don't already know, and we can skip them outright.

jump-skip-verification

Compatibility, then, is the condition under which our checkpoint's validator set can still vouch for the target block. It holds when all of the following are true (the exact thresholds are set by the source chain's consensus rules):

  • Validator set still vouches. The checkpoint's validator set (or sync committee) is the one that finalizes the target block, or overlaps it enough that finality is still provable in one step. Once the set has rotated past that overlap, the checkpoint is incompatible: an intermediate consensus-state update is required first, advancing to a newer checkpoint that can vouch.
  • Not in the future. The checkpoint sits at a height at or before the target. Trust in this scheme flows forward only: a checkpoint vouches for blocks ahead of it, and verifying one of them yields a newer checkpoint — never an older one. A block behind your newest checkpoint must therefore be verified from an older stored checkpoint that precedes it, which is exactly why the light client keeps checkpoints at multiple heights instead of only the latest.
  • Same fork. The checkpoint lies on the same canonical fork as the target.

What counts as "enough overlap" is protocol-specific:

  • Tendermint / CometBFT. A target header is verifiable from a trusted one if validators holding more than ⅓ of the trusted set's voting power also signed the target (and both fall within the unbonding period). That ⅓ overlap guarantees at least one honest validator carries over.
  • Ethereum (Casper FFG + Altair). The sync committee rotates roughly every 27 hours; a checkpoint holding period P's committee can verify any block in period P, and can hop one period forward per update.

So instead of a chain of consecutive blocks, verification becomes a series of hops between checkpoints, requiring only that each adjacent pair is compatible. How often we plant new checkpoints is a tunable tradeoff between verification cost and security. See Consensus state update.

Message

A message is any data item committed in a finalized block — an event/log, a transaction, or a slice of state — uniquely located by an identifier (MessageID). Consensus verification proves the block is final; block inclusion verification proves the message lives inside it.

Block inclusion verification

Block verification tells us a block is final, but an application usually cares about one specific item inside it (a single transaction, event, or piece of state), not the whole block. Block inclusion verification proves that item is part of the verified block.

This is possible because a block doesn't just list its contents; it commits to them. Each set of items (transactions, receipts, state) is hashed into a Merkle tree, and only the tree's root is stored in the block header. Block verification has already established that header (and therefore those roots) as trusted, so they can serve as the anchor: anything provably under a trusted root is itself trusted. And a Merkle root has exactly the property we need: a single leaf can be proven to belong under it without revealing the rest of the tree.

A simple example. Say a block contains four transactions, [A, B, C, D], committed under a transactions root in the header:

merkle-proof-example

To prove C is in the block, the prover supplies just two values (C's sibling D and the neighboring branch h(AB)) as the Merkle proof. The verifier recomputes h(CD) = hash(C, D), then root = hash(h(AB), h(CD)), and checks the result equals the trusted root in the header. If it matches, C must be in the block; if anything about C were altered, the recomputed root wouldn't match. The cost is one small proof (≈ log₂(n) hashes for n items), not the whole block.

The same idea covers any committed data: swap the transactions root for the receipts root to prove an event, or the state root to prove an account balance. This is precisely what a MessageID encodes: which tree to look in (root), which leaf to walk to (commitment_path), and how to read the target item out of that leaf (descriptor).

See light-client § VerifyMessage for a full worked example (a USDT Transfer event proven against Ethereum's receiptsRoot).

On this page