What is a Rollup?
A rollup is a Layer 2 scaling solution that executes transactions outside of a Layer 1 blockchain (off-chain) but posts transaction data back to the L1 to inherit its security and decentralization guarantees. Rollups are the centerpiece of Ethereum’s rollup-centric roadmap, which envisions L1 primarily as a settlement and data availability layer while L2 rollups handle the vast majority of transaction execution. As of early 2025, rollups process significantly more transactions than Ethereum L1 itself—Arbitrum, Optimism, Base, and zkSync collectively handle over 5 million transactions per day.
The core insight behind rollups is simple: computation is cheap, but consensus and data availability are expensive. By moving execution off-chain, rollups can process thousands of transactions per second while paying only the cost of posting compressed data to L1. The security guarantee comes from the fact that anyone can reconstruct the rollup’s state from the posted data and verify its correctness—either through fraud proofs (optimistic rollups) or validity proofs (zero-knowledge rollups).
Rollups are fundamentally different from sidechains and Plasma. Sidechains (like Polygon PoS) have their own consensus mechanism and validator set, meaning they do not inherit L1 security— if a sidechain’s validators collude, they can steal user funds. Plasma was an earlier scaling approach that moved computation and data off-chain but had critical limitations around data availability challenges and the inability to support general-purpose smart contracts. Rollups solve Plasma’s problems by posting transaction data on-chain, which ensures that even if the rollup operator goes offline or acts maliciously, users can always recover their funds by reconstructing the state from L1 data.
How It Works
The Rollup Pipeline
Every rollup follows the same high-level architecture:
- Transaction submission: Users sign transactions and submit them to the rollup’s sequencer (or directly to the L1 inbox contract).
- Sequencing and execution: The sequencer orders transactions, executes them against the rollup’s current state, and produces a state diff (the difference between the old and new state roots).
- Data posting: The sequencer compresses the transaction data (typically using calldata compression, reducing size by 5–10×) and posts it to L1. After EIP-4844 (March 2024), this data can be posted as “blobs” instead of calldata, reducing costs by an additional 10–100×.
- State root publishing: The sequencer publishes the new state root to an L1 contract, along with the L2 block number and any necessary proof data.
- Verification: Depending on the rollup type:
- Optimistic rollups: A 7-day challenge window allows anyone to submit a fraud proof if the state transition is invalid.
- ZK rollups: A validity proof (SNARK or STARK) is generated for each batch and verified on-chain, providing immediate finality.
Compression Techniques
Rollups achieve their cost efficiency through aggressive compression. Typical compression ratios include:
| Data Type | Uncompressed | Compressed | Technique |
|---|---|---|---|
| Signature | 65 bytes | 1 byte | Replaced with signature hash |
| Sender address | 20 bytes | 4 bytes | Index into sender table |
| Recipient | 20 bytes | 4 bytes | Index into address table |
| Gas price | 32 bytes | 1 byte | Symbol index |
| Value | 32 bytes | 4 bytes | Symbol + exponent |
| Call data | Variable | ~50% reduction | RLP + dictionary compression |
These compression techniques reduce the average Ethereum transaction from ~110 bytes to ~10–15 bytes on the rollup, directly reducing the L1 data posting cost.
Optimistic vs. ZK Rollups
The two major rollup paradigms differ in how they ensure correctness:
Optimistic Rollups (Arbitrum, Optimism/OP Stack, Base):
- Assume transactions are valid by default (hence “optimistic”)
- 7-day challenge period during which anyone can dispute a state transition
- Fraud proofs must be submitted on L1 if a dispute is raised
- Pros: Mature technology, EVM equivalence, lower on-chain proof cost
- Cons: 7-day withdrawal delay, requires active challengers for security
Zero-Knowledge Rollups (zkSync Era, StarkNet, Polygon zkEVM, Scroll, StarkEx):
- Generate mathematical proofs (SNARKs or STARKs) that prove the state transition is correct
- Proofs are verified on L1, providing immediate finality (no challenge period)
- Pros: Fast withdrawals, strong cryptographic security, no liveness assumptions
- Cons: Expensive proof generation, limited EVM support (STARKs require a different VM), larger on-chain footprint per batch (though improving)
Data Availability: The Critical Link
Rollups are only as secure as their data availability. If the transaction data posted to L1 is not actually retrievable, users cannot reconstruct the rollup state or exit their funds. This is why the rollup ecosystem has invested heavily in DA improvements:
- EIP-4844 (Proto-danksharding): Introduced blob-carrying transactions with a separate fee market. Blobs are cheaper than calldata (~0.001 ETH per blob vs ~0.01–0.05 ETH for equivalent calldata) but are pruned after ~18 days.
- Full danksharding: Future upgrade that will add ~100× more blob space through data availability sampling (DAS).
- External DA: Celestia and EigenDA offer alternative DA layers that can replace or supplement Ethereum’s blob space, potentially reducing costs further.
Real-World Examples
Arbitrum One is the largest rollup by TVL (~$18 billion in early 2025). Its Nitro tech stack uses WASM-based execution for high performance and a multi-round interactive fraud proof system (BOLD). Arbitrum has over 900 deployed protocols including GMX (perpetuals), Pendle (yield trading), and Radiant Capital (lending).
Optimism (OP Mainnet) pioneered the Optimistic rollup design and created the OP Stack, a modular, open-source rollup framework that other teams can deploy. Base (by Coinbase) is built on the OP Stack and has become the second-largest rollup by daily active addresses, driven by social applications and Coinbase’s on-ramp integration.
zkSync Era (by Matter Labs) is the most prominent EVM-compatible ZK rollup. It compiles Solidity to a custom zkVM based on LLVM. Notable applications include SyncSwap (DEX), Orbiter Finance (bridge), and EraLend (lending).
StarkNet (by StarkWare) takes a different approach. Instead of EVM equivalence, it uses Cairo as its native smart contract language and STARK proofs for verification. STARKs are quantum-resistant and don’t require a trusted setup, but they require a fundamentally different developer experience. StarkNet hosts major DeFi protocols including Ekubo (DEX), Nostra (lending), and MySwap.
Key Risks / Considerations
- Sequencer centralization: Most rollups run a single sequencer, creating a single point of failure and potential censorship vector. If the sequencer goes offline, users can still submit transactions directly to L1, but at higher cost and latency.
- Bridge security: Moving assets between L1 and a rollup requires bridging smart contracts. These contracts hold the actual L1 tokens and are high-value targets. The bridge is only as secure as the L2’s security model.
- Governance risk: Rollup governance can change protocol parameters, upgrade contracts, or even change the sequencer set. Multisig-controlled upgrades have been controversial (e.g., the Optimism Bedrock upgrade was initially criticized for centralized governance).
- Interoperability: Cross-rollup transactions (e.g., Arbitrum → Optimism) are inefficient, often requiring two separate L1-to-L2 transfers. Solutions like the OP Superchain and Arbitrum Orbit aim to address this.
Comparison Table
| Feature | Optimistic Rollup | ZK Rollup |
|---|---|---|
| Finality time | 7 days (challenge period) | Minutes to hours (proof generation) |
| L1 verification cost | Low (only on dispute) | Higher (every batch needs proof) |
| EVM equivalence | Full (Arbitrum, OP Stack) | Partial (zkSync) to none (StarkNet) |
| Proving hardware | Standard server | Expensive prover machines |
| Throughput | ~2,000–4,000 TPS | ~2,000+ TPS (limited by proof gen) |
| Maturity | Production since 2021 | Maturing rapidly (2023–2025) |
Frequently Asked Questions
Q: Are rollups as secure as Ethereum L1? A: Optimistic rollups inherit L1 security for data availability, but their execution security depends on at least one honest actor being available to submit fraud proofs during the challenge window. ZK rollups have stronger security guarantees—validity proofs are mathematically verified on L1 with no liveness assumptions.
Q: What happens if a rollup operator disappears? A: If the transaction data was posted to L1 (which it must be for a valid rollup), anyone can reconstruct the rollup’s state from that data. Users can force-exit their funds by submitting exit proofs to the L1 bridge contract using the posted data. This is why data availability is the most critical property of a rollup.
Q: Why not just use sidechains? A: Sidechains have their own consensus mechanism and validator set. If sidechain validators collude or are compromised, user funds can be stolen with no recourse. Rollups post all transaction data to L1, so even a completely malicious rollup operator cannot prevent users from recovering their funds.
Q: What is the difference between a rollup and a validium? A: A rollup posts all transaction data to L1. A validium posts only the state root and hashes, storing full transaction data off-chain (with a Data Availability Committee). Validiums are cheaper but have weaker security guarantees—if the DA committee goes down or acts maliciously, users may not be able to exit.