Live Chain Verifier

Re-verify a real QBLEX chain in your browser, then try to break it.

This page downloads a finalized ledger and re-derives the whole thing on your device, from public keys alone: every block hash, every Merkle commitment, every post-quantum signature, the certificates that make each block final, and the resulting ledger state. Nothing here contacts our servers, and nothing here holds a secret.

The proving is heavy and happened once, on real quantum hardware. The checking is small, fast, and runs in front of you. That asymmetry is the entire point.

no serverno secretsreal FALCON-1024 + ML-DSA-87RFC-8785 + SHA-256open the console, it is all client-side

Two different questions

A chain can be built out of genuine blocks and still be wrong, if the order or the finality is wrong. So there are two proofs, and they are not the same proof.

Question one

Is this block real?

Recompute one block’s Bell statistic from the published measurements, check it against the classical bound, and bind it to its anchor. Nine real hardware runs, five pass, four reject.

Go to the block verifier →

Question two · this page

Is the whole chain ordered, final, and consistent?

Re-derive every block, confirm each one is made final by a quorum of validator signatures, confirm the order cannot be rearranged, and replay the log to reproduce the exact committed state.

You are here

What your browser actually checks

FINALIZED LOG, IN COMMITTED ORDERblock b0block_hash + Merkle rootquantum anchor + fence2-of-2 PQ signatureprevblock b1block_hash + Merkle rootquantum anchor + fence2-of-2 PQ signatureprevblock b2block_hash + Merkle rootquantum anchor + fence2-of-2 PQ signatureprevblock b3block_hash + Merkle rootquantum anchor + fence2-of-2 PQ signatureeach block bound to its height by a quorum of validators, each holding an independent post-quantum keypair (a reference committee)replayed in order → one final state root
01

Block validity

Recompute the block hash from canonical bytes and the Merkle root over its contents, check the chain link to the block before it, verify the 2-of-2 post-quantum signature, and confirm the attested measurement clears the classical bound.

02

Finality

Confirm the certificate carries at least a quorum of distinct, real validator signatures over the canonical commit record. Fewer than quorum is not final.

03

Ordering

Each certificate names this block at this height and links the previous commit, so the finalized prefix is a hash chain. Swap two heights and it breaks.

04

State

Replay the log in committed order. A conflicting or backdated record entry is rejected in committed order, and the recomputed state root must equal the one the bundle claims.

Re-verify this real chain

This runs automatically when the page loads. Every signature below is really checked; if a post-quantum primitive were missing, the check would fail closed rather than be assumed.

chain
committee
finalized blocks
verifier backend
starting…

Make the check earned

Anyone can put a green check on a page. So compare the two values yourself. This is the root the downloaded bundle claims:

7a2474d64d37e32e1dc50d20dbc0a0adf195bb7db997127efd93fad298793fae

The result panel below prints the root your own browser recomputed by replaying the log. They have to match character for character, and a single changed bit anywhere in any block would change it.

Per-block result

Attack it yourself

A verifier that only ever says yes proves nothing. Each button mutates a copy of the bundle in memory and re-runs the full verification. A correct verifier rejects every one of these and tells you exactly which stage caught it.

Provenance, third-party checkable

Each block’s anchor names a real Amazon Braket quantum task on a named QPU. Those records live in Amazon’s systems, so the provenance does not depend on trusting us.

Take the ledger with you

Do not take our page’s word for it either. Download the finalized bundle and verify it somewhere we do not control. It is plain JSON: public keys, block headers, finality certificates, and the committed log.

Download the ledger bundle (JSON)

What this does, and does not, claim

It proves, client-side: every block is well-formed and carries a real Amazon Braket quantum anchor; the post-quantum 2-of-2 signature over each block verifies against the published keys; each block is bound to its height by at least a quorum of independent validator signatures; the finalized log is a hash chain that cannot be reordered; and replaying it reproduces the exact committed state root, with a conflicting record entry rejected in committed order.

It does not claim that the committed measurement outcomes came from quantum hardware. That is the device attestation layer, evidenced by the Braket task ARNs above, not by this arithmetic.

This is not a live decentralized network. What you are verifying is a reference implementation of the ordering layer, plus a downloadable, independently verifiable finalized ledger. The validators here each hold their own post-quantum keypair, but they are a reference committee rather than independent hosts, so the live multi-host network (transport, leader election, view change) is the deployment layer being built next. What is real today is the safety-critical core: the cryptographic validity, the quorum certificate, and the deterministic state.

Source is published for inspection; all rights retained.