Loading…
Loading…
Everything this demo cannot run yet is missing from L1, not from the rollup. Each mock stands in for one L1 feature and goes away when that feature ships.
| Part | Status | What stands in | Goes away with |
|---|---|---|---|
| L1 chain with frame transactions and blobs | Real | A local copy of frames-devnet-0 with Nethermind and Reth | |
| L2 execution | Real | execution-specs' Amsterdam rules with EIP-8141, as on the L1 | |
| Stateless validation program | Real | Run as ordinary code instead of inside a zkVM | |
| Block data in blobs | Real | EIP-8142's encoding, on real L1 blobs | |
| Rollup contract, L2 messenger, message proofs | Real | ||
| This explorer's L2 data | Real | Rebuilt from L1 alone by an independent follower, which re-executes every block | |
| Proof | Mock | A trusted key signs blocks that the real program accepted | A zkVM proof of the same program |
| Proof check on L1 (EIP-8288) | Mock | A frame that calls a contract checking the signature | EIP-8288, which lets L1's own proof cover it |
| Verification key registry (EIP-8357) | Mock | An admin registers a placeholder key hash instead of a fork, since the proofs are signatures | EIP-8357 |
| Blob check in the program (EIP-8142) | Mock | The node checks that the blobs encode the block | EIP-8142 in the L1 program |
| Operator and users | Real | One operator runs the L2 node as the rollup's sequencer, the only account the rollup contract takes blocks from, in the book's preconfirmations customization. Users sign their own transactions, deposit claims included, and send them to the node's RPC, which this demo keeps local | |
| Preconfirmations | Real | The sequencer builds a block every 4 seconds, empty if no transaction waits, signs its hash at once, and posts it once a fixed wait, standing in for proving time, has passed. A bond in the rollup contract backs every signature: anyone who shows a broken one has it burned | |
| Claims for others | Real | Messages carry a fee for whoever claims them. A relayer on L2 and a claimer on L1 claim those whose recipients cannot, as anyone could, and recipients claim their own for free | |
| Activity | Real | Besides the story, spamoor sends ERC-20 transfers, Uniswap swaps, EIP-7702 delegations, EIP-8141 frame transactions and messages in both directions |
The prover key is the only trusted part. The follower checks it: it re-executes every block from L1 data alone and compares the result with what the contract accepted.
Problems and optimizations the demo surfaced, each now part of the design.
Ethereum's rules accept a block at the maximum timestamp, after which no block can follow. The contract now keeps L2 time behind L1 time.
With no ETH on L2, no one could claim the first deposit. With frame transactions, a deposit pays for its own claim.
The L2's genesis names the L1 contract, which stores the genesis hash. The genesis is built for the address the contract will have.
Keeping every L2 state root created a slot per block. Keeping the last 8,191 halves the cost of each block.
A Merkle tree of messages halves the L1 cost, and claims in the same block share one proof, leaving about 450 bytes each.
Without events, a node would scan every L1 transaction to find messages and blocks. The contract now announces both.
The rollup contract gets every block's hash, so a broken preconfirmation is two different hashes, and L1 can slash it.
Block-in-Blobs gives every block its own blobs. Blocks of a few KB fill a small part of theirs, while rollups today share blobs across many blocks.
Ethereum's validation program does not implement Block-in-Blobs yet. The design depends on it, and the demo checks the blobs in the node instead.