Explore the rollup stack

NODE0xA17F EPOCH248,193 ROLLUPSOPTIMISTIC // ZK
BEGIN DESCENT
LAYER 01 // SETTLEMENT

The Base Layer

Ethereum mainnet anchors every rollup. State roots and proofs commit here, where consensus is heaviest and finality is absolute.

01

Consensus Anchor

The rollup posts its compressed batch to Layer 1 every ~12s slot. The mainnet's validators reach finality on the data; the rollup inherits its security.

02

Data Posting

Calldata and blob-carrying transactions deliver the rollup's transaction batch. Blob space reduces costs by 10-100x versus calldata.

03

State Commitment

A 32-byte state root summarizes the entire rollup. Disputes resolve by reference to this commitment; honest validators can always reconstruct.

// Layer 1 settlement contract
function submitBatch(
    bytes32 stateRoot,
    bytes calldata batch,
    bytes calldata blobCommitment
) external {
    require(verifyProposer(msg.sender));
    pendingRoots.push(stateRoot);
    emit BatchPosted(block.number, stateRoot);
}
LAYER 02 // EXECUTION

Where Computation Happens

Inside the rollup's execution environment, transactions run cheap and fast. Thousands of operations per second, settled later in batched form.

OPTIMISTIC

Assume Valid, Verify Later

Transactions execute optimistically. A challenge window of 7 days allows verifiers to submit fraud proofs against any invalid state transition.

  • Throughput: 2,000-4,000 TPS
  • Finality: ~7 days (challenge period)
  • EVM-equivalent execution
ZERO-KNOWLEDGE

Prove Correct on Submission

Each batch ships with a succinct cryptographic proof. The L1 verifier checks the proof in milliseconds; finality is mathematical, not optimistic.

  • Throughput: 500-2,000 TPS
  • Finality: minutes (proof verification)
  • zkEVM or custom VM
LAYER 03 // SEQUENCING

Ordering the Stream

The sequencer accepts transactions, orders them, and commits to the order. Centralized today, progressively decentralized tomorrow.

01 MEMPOOL Pending txs queued by gas-price priority and nonce.
02 ORDER FCFS or PBS auctioning for inclusion + ordering rights.
03 EXECUTE Sequencer applies txs against latest state; emits soft-confirms.
04 BATCH Compress & sign batch; queue for L1 publication.
SEQUENCER LOAD68%
TPS // 2,847 QUEUE // 12,340 LATENCY // 93ms
LAYER 04 // PROOF SYSTEMS

Mathematics of Trust

Proofs replace re-execution. Whether fraud-based or zero-knowledge, the cryptographic guarantee is the same: invalid state cannot be finalized.

FRAUD PROOFS

Interactive Disputes

Verifiers bisect the disputed execution down to a single instruction, then play it on-chain. The loser is slashed. Optimistic rollups rely on this honest-minority assumption.

ZK PROOFS

Validity Guarantees

SNARK or STARK circuits encode the state transition function. The proof is a few KB; verification costs 200-500k gas; correctness is unconditional.

// Verifying a SNARK on Layer 1
function verifyProof(
    uint256[2] memory a,
    uint256[2][2] memory b,
    uint256[2] memory c,
    uint256[] memory publicInputs
) public view returns (bool) {
    return pairing(a, b, c, publicInputs);
}
LAYER 05 // DATA AVAILABILITY

The Data Must Survive

A proof is worthless without the data it proves. Rollups guarantee that the underlying transaction data is published — either fully on L1, or on a dedicated DA layer.

ROLLUP MODE

FULL DATA ON L1

All transaction data is posted as calldata or blobs. Maximum security — anyone can rebuild the rollup from L1 alone.

TIER 1
VALIDIUM MODE

OFF-CHAIN COMMITTEE

Data is held by a permissioned DAC. Cheaper transactions, but data availability assumes committee honesty.

TIER 2
VOLITION MODE

USER OPT-IN

Each transaction selects its DA mode. Sensitive ops use rollup mode; high-volume ops use validium for cost.

TIER 3
LAYER 06 // COMPRESSED PAYLOAD

The Final Form

Thousands of transactions, distilled into a single batch. A few kilobytes carrying the work of an entire rollup epoch.

FINALIZED BLOCK #21,488,902
BATCH ID
0x9F4E.A7B1.C2D8.0034
TX COUNT
4,128
RAW SIZE
1,847,230 bytes
COMPRESSED
128,944 bytes (14.4x)
STATE ROOT
0x6A11.F5C9.B0E2.3F7D.A88C.4015.2BB7.9D62
PROOF
SNARK // 1,128 bytes // verified
END OF DESCENT // STACK COMPLETE