Introduction

Imagine you’re building an application that needs to read Ethereum data.

You could connect directly to an Ethereum node, but that means trusting the node you picked, paying high verification costs, and handling all the complexity of syncing a massive chain.

Now, what if you could have a mirror of Ethereum, which is basically a verified reflection of its history and state, stored somewhere else, where every block and transition is checked, recorded, and cryptographically guaranteed?

That’s the idea behind our block (blockchain) verification explorer. It gives you a way to work with blockchain data that’s verifiable, transparent, and portable, without running the chain yourself.

And we’ve done this––twice actually. And in this blog, we'll show you how. But first, let’s start with the basics.

What is blockchain verification?

At its core, blockchain verification is about proving that every block and state transition on a chain is valid and recording those proofs in a way anyone can check. Instead of simply mirroring the chain, the block verification explorer creates a verified record of its history and state, backed by cryptographic certificates.

You can think of it as a trusted lens into Ethereum (or any other chain): the same data you’d get from running a node, but packaged with guarantees that each block was independently verified before being recorded.

Instead of relying on a single blockchain node as the source of truth, a verifier does the following:

• Replays and verifies blocks so you know every state transition is valid.
• Keeps a complete history of what happened on the original chain.
• Records signed proofs that can be checked independently at any time.

But, why exactly does all this matter?

Blockchain verification is important because it allows developers and applications to interact with blockchain data in a trust-minimized way. You don’t have to trust that a random node is giving you the right answer; you can rely on cryptographically signed claims that prove the chain’s history is consistent.And the impact goes beyond just querying data.

For Layer 2 blockchains that use optimistic rollups, our block verification approach can dramatically shorten finality times. Instead of waiting through long challenge windows, sometimes up to seven days, verified claims can confirm blocks in milliseconds, with global finality achieved in under 100ms.

In other words, this verifiability doesn’t just make data trustworthy. It makes entire ecosystems faster, more secure, and easier to build on.

In practice, a blockchain verifier becomes a gateway:

• For developers, it’s a reliable way to query history and state.
• For cross-chain systems, it’s a trusted source to verify events before moving assets.
• For the ecosystem, it’s a step toward making blockchains more transparent and portable.

Our first attempt: blockchain mirroring (V1)

Our journey started with what we called blockchain mirroring, which was basically a demo built on the Verifiable Settlement Layer (VSL). The goal was simple: show that you could take live blockchain data from Ethereum or Bitcoin and turn it into verifiable claims that could be checked, stored, and explored.

V1 worked by connecting to full nodes:

• Ethereum via Geth or Reth
• Bitcoin via Bitcoin Core

Each mirroring service would pull block data, run a stateless execution check, and wrap the results into a claim. Those claims were then submitted to the VSL, validated, and displayed through a frontend dashboard.

The demo gave developers a hands-on way to:

• Mirror Ethereum and Bitcoin blocks locally.
• See claims generated and validated in real time.
• Explore blockchain state through a browser interface.

In short, V1 proved that blockchain mirroring could work in practice. But it also had limitations:

• Verification was tied closely to single execution clients (like Geth or Reth) instead of a broader verifier market.
• Computation and state history were handled together, which limited flexibility.
• It was a demo environment which was powerful for showing the concept, but not yet designed for scaling or cross-chain production use cases.

These learnings paved the way for V2, where we rethought the architecture from the ground up.

Enter blockchain verification V2

With V2, we reimagined blockchain verification to make it more robust, more flexible, and closer to production-ready. Instead of being a demo tied to specific clients, V2 is a FastSet application designed to verify blockchains with stronger guarantees.

Here’s what makes V2 different:

• Multi-verifier model with quorum
  • Instead of relying on a single verifier, V2 uses a set of independent verifiers.
  • Each new block generates a computational claim, which multiple verifiers check and sign. A claim is only accepted once it meets the required quorum of signatures, meaning the majority of verifiers must agree on the same result. This prevents a few dishonest verifiers from pushing through an invalid claim. 
  • On top of this, the model also opens the door for incentives: independent verification services can be rewarded for fast, honest work. Over time, this creates a healthy market for verifiers, where accuracy and efficiency are both valuable.
• Separation of computational and state update claims
  • V2 introduces a special claim type for state updates.
  • This means computational claims (validating blocks) and state updates (advancing the verified chain) are handled independently.
  • The result: more flexibility, and support for blockchains that use eventual consistency models, like Solana.
• Settlement on FastSet
  • All claims are settled on FastSet, ensuring they’re validated, recorded, and available as cryptographic certificates.
  • This creates a transparent, auditable history of how the verified blockchain advanced over time.

In short, V2 isn’t just a demo, it’s a full architecture for building reliable blockchain verifiers, with markets for stronger settlement guarantees and the ability to expand beyond Ethereum.

Most of these terms are explained in great detail in section 4.16 of our whitepaper. You can find it here.

Well, what’s next?

With V2, blockchain verification has moved from demo to deployable architecture, but this is only the beginning.

Here’s what’s ahead:

• Expanding beyond Ethereum: The same architecture can be applied to other chains, including those with eventual-consistency models like Solana.
• Building a verifier ecosystem: By introducing a multi-verifier model with quorum, we’re laying the groundwork for a market where independent FastSet accounts can offer verification services and be rewarded for honest work.
• Deeper integrations: Applications can use settled claim certificates from verified blockchains to enable safer, more transparent cross-chain transfers.
• Developer-first tools: We’re working on documentation and interfaces that make it easier for developers to explore, query, and build on top of verified chains.

A new chapter for blockchain verification

Our journey started with blockchain mirroring; an experiment to see if we could reflect Ethereum and Bitcoin execution. That demo showed the concept was possible, but it was limited in scope.

Now, with the block verification explorer, it has evolved into a full architecture, one that makes blockchain data easier to trust, query, and build on. Instead of only mirroring a blockchain, this new application can serve as a verification layer for any blockchain!

By separating computation from state, introducing quorum-based verification, and settling everything on FastSet, the Explorer brings stronger guarantees and greater flexibility than ever before.

But this blog only scratches the surface. If you want to dive deeper into the technical details, check out our documentation, where we break down the claim structures, verifier setup, and architecture in more depth.

But most importantly, if you’re ready to see blockchain verification in action, head over to the verification explorer V2 interface and view a live verified copy of the Ethereum Mainnet!