What Are Rollups? Optimistic vs ZK Rollups Explained
Ethereum is slow. Not slow in a “this website takes 3 seconds to load” way — slow in a “this costs $40 in fees and takes two minutes to confirm a swap” way. At peak congestion, the base layer can only handle around 15 transactions per second. Visa processes 24,000. Something had to give.
Rollups are the answer the ecosystem landed on. They’re not a hack or a workaround — they’re a genuine engineering solution that lets Ethereum scale without sacrificing the thing that makes it valuable in the first place: decentralization and security.
Here’s exactly how they work, where they differ, and why it matters which kind you’re using.
The Core Problem: Why Ethereum Can’t Just “Go Faster”
You can’t just crank up Ethereum’s throughput without trade-offs. The reason the base layer is limited is actually by design — every validator node needs to process every transaction to verify the chain. Add more transactions, and you either need more powerful hardware (which prices out smaller validators and centralizes the network) or you accept slower confirmation times.
The blockchain trilemma frames this neatly: decentralization, security, and scalability — pick two. For years, Ethereum picked the first two and left scalability on the table.
Rollups break out of this trilemma by changing the game entirely. Instead of processing everything on Ethereum, they batch transactions off-chain and post compressed proofs back to the mainnet. You get the speed and cost benefits of a separate chain, but you inherit Ethereum’s security guarantees.
How Rollups Actually Work
The basic mechanic is elegant:
- Users submit transactions to a rollup operator (called a sequencer)
- The sequencer batches hundreds or thousands of transactions together
- That batch gets compressed and posted to Ethereum Layer 1 as calldata
- The rollup’s state — who owns what — is settled on Ethereum
The key insight: Ethereum doesn’t need to re-execute every transaction in the batch. It just needs to be convinced that the batch is valid. That’s where optimistic and ZK rollups diverge sharply.
Optimistic Rollups: Trust, But Verify (Eventually)
Optimistic rollups take the, well, optimistic approach: they assume all transactions in a batch are valid by default. The sequencer posts the batch, and it’s considered final — unless someone objects.
This “innocent until proven guilty” model relies on a challenge period, typically 7 days. During this window, anyone can submit a fraud proof — essentially a mathematical argument showing that a specific transaction in the batch was invalid. If a valid fraud proof is submitted, the bad transaction gets rolled back and the sequencer gets slashed.
If nobody challenges the batch within the window, it’s finalized.
Why this matters for you: That 7-day window is not just a technical detail. It means your funds take 7 days to bridge back to Ethereum mainnet unless you use a third-party liquidity provider who fronts the ETH for a fee. You can transact on the rollup freely, but exiting to L1 takes time. Most bridge UIs abstract this away with liquidity pools, but you’re paying for that convenience.
Arbitrum
Arbitrum, built by Offchain Labs, is the largest optimistic rollup by TVL (total value locked). It uses a multi-round interactive fraud proof system — instead of re-executing the entire disputed transaction on L1, it narrows down the disagreement to a single computational step. This makes fraud proofs cheaper and faster to settle.
Arbitrum has its own execution environment (AVM, now Stylus) which is highly compatible with the Ethereum Virtual Machine. Deploying a Solidity contract on Arbitrum is almost identical to deploying on mainnet.
Optimism (OP Mainnet)
Optimism takes a slightly different approach with single-round fraud proofs and has made its codebase available as the OP Stack — a modular framework for launching custom L2 chains. Coinbase’s Base, Worldchain, and dozens of other chains run on OP Stack. Optimism is playing the long game as ecosystem infrastructure, not just a single chain.
The OP Stack approach has created the Superchain concept — a network of interoperable chains all sharing security and communication layers. It’s ambitious. Whether it delivers is still being proven.
ZK Rollups: Prove It Upfront
Zero-knowledge rollups flip the model. Instead of assuming validity and waiting for challenges, ZK rollups generate a cryptographic validity proof alongside every batch. This proof mathematically guarantees that every transaction in the batch is correct — without revealing the underlying transaction details.
Ethereum verifies the proof on-chain. If the proof checks out (and it’s computationally infeasible to fake one), the batch is immediately finalized. No waiting period. Withdrawals can be fast.
The trade-off: generating these proofs is computationally expensive. ZK proofs require specialized mathematics (SNARKs or STARKs) and significant processing power. This has historically made ZK rollups harder to build and more expensive to operate — though that gap is closing fast.
EVM compatibility has also been a sticking point. Ethereum’s execution environment wasn’t designed with ZK proofs in mind, so making an EVM-compatible ZK rollup required serious engineering effort. The teams building these have spent years solving that problem.
zkSync Era
Built by Matter Labs, zkSync Era is a ZK-EVM rollup that aims for near-full EVM compatibility. They use a custom proving system (Boojum, a STARK-based prover) and have been aggressive about pushing down proof generation costs.
zkSync has its own abstraction features built at the protocol level — account abstraction is native, not bolted on. This makes user experience features like gasless transactions and smart contract wallets much easier to implement. The ZK Stack (analogous to OP Stack) lets developers launch custom ZK chains called “Hyperchains.”
StarkNet
StarkNet, built by StarkWare, takes a different philosophical stance. Instead of targeting EVM compatibility, they built their own virtual machine (Cairo VM) and their own programming language (Cairo). Cairo is designed from the ground up to be ZK-provable, which makes StarkNet’s proving system significantly more efficient.
The trade-off is a steeper learning curve — existing Solidity contracts don’t port directly. But StarkWare has years of production experience; their StarkEx product has been running ZK-proofs for dYdX and Immutable since 2020.
StarkNet uses STARKs (not SNARKs), which are transparent — no trusted setup required. That’s a meaningful security property that the zero-knowledge community cares about.
Optimistic vs ZK: The Real Comparison
| Optimistic Rollups | ZK Rollups | |
|---|---|---|
| Finality | 7-day challenge window | Near-instant (proof verified on L1) |
| Withdrawals | Slow (7 days native, fast via bridges) | Fast |
| EVM Compatibility | Near-perfect | Getting there (varies by implementation) |
| Proof Cost | Cheap (no upfront proving) | Expensive (proof generation) |
| Security Model | Fraud proofs (need at least 1 honest watcher) | Validity proofs (cryptographic guarantee) |
| Maturity | More battle-tested | Catching up fast |
The security model difference is subtle but important. Optimistic rollups require at least one honest, active participant watching for fraud and capable of submitting a fraud proof in time. ZK rollups don’t — the math does the work. In practice, both are considered very secure, but ZK rollups have a cleaner theoretical security story.
Are Rollups Centralized?
Here’s the part people gloss over: most rollup sequencers are currently centralized. Arbitrum, Optimism, zkSync — they all run sequencers controlled by their respective teams. This means the sequencer can theoretically censor transactions, reorder them (MEV extraction), or go offline.
The “escape hatch” exists — users can always force-include transactions directly on L1 if the sequencer goes down — but it’s not seamless. Decentralizing the sequencer layer is an active area of work across every major rollup team. Most have roadmaps that include sequencer decentralization, but none have fully shipped it yet.
This doesn’t make rollups unsafe — it just means they’re not as decentralized as Ethereum mainnet. Yet.
Which Rollup Should You Use?
If you’re just a user: use whatever has the liquidity for what you’re doing. Arbitrum has the deepest DeFi ecosystem. Base (OP Stack) has Coinbase backing and a growing user base. zkSync and StarkNet have lower fees in many cases and better UX features.
If you’re a developer: Arbitrum and OP Stack are easiest to get started with given EVM compatibility. ZK rollups are worth learning if you’re building new applications and want the long-term benefits of cryptographic finality.
If you’re a researcher or long-term investor in the ecosystem: ZK rollups are where the technology is heading. The computational overhead is dropping every year, EVM compatibility is improving, and the security model is stronger by design. Optimistic rollups were the right solution for 2021-2023. ZK rollups are being built for the decade ahead.
The Bigger Picture
Rollups don’t fragment Ethereum — they extend it. The security and settlement happen on mainnet; the rollup is just a more efficient execution environment. As cross-rollup bridging and shared sequencing improve (projects like Espresso, Astria, and EigenLayer’s AVS infrastructure are working on this), the user experience of moving between rollups will continue to get better.
The Ethereum roadmap explicitly centers on rollup-centric scaling. This isn’t a temporary patch — it’s the architecture.
FAQ
What’s the difference between a rollup and a sidechain? A sidechain (like Polygon PoS, pre-migration) has its own validator set and its own security. If those validators collude or get compromised, your assets are at risk regardless of what Ethereum does. A rollup posts data and proofs to Ethereum — its security is derived from Ethereum’s. Big difference.
Can I lose money using a rollup? The rollup itself is generally safe if you’re using a major, audited one. The bigger risks come from bridges (bridge hacks have cost billions), from smart contract bugs in the DeFi protocols you’re using on the rollup, and from centralized sequencer risk. The rollup protocol itself hasn’t been the failure point in major exploits.
Why do some ZK rollup withdrawals still take hours? Proof generation takes time. Even though there’s no 7-day challenge period, the ZK prover still needs to generate a validity proof for your batch, which can take anywhere from minutes to a few hours depending on the rollup and network load. Instant withdrawals via liquidity providers exist here too.
What is a “validity proof” vs a “fraud proof”? A validity proof proves something is correct before it’s accepted. A fraud proof proves something was incorrect after it’s been accepted. ZK rollups use validity proofs (you prove it’s right upfront). Optimistic rollups use fraud proofs (you prove it’s wrong during the challenge window). Both achieve the same end goal — ensuring only valid state transitions are finalized — through opposite mechanisms.
Is Polygon zkEVM a ZK rollup? Yes. Polygon zkEVM is a ZK rollup that aims for EVM equivalence. It’s separate from Polygon PoS (which is a sidechain). Polygon has been aggressively transitioning their ecosystem toward ZK technology through the AggLayer and various ZK-based chains.
What happens if the sequencer goes offline? Users can force-include their transactions through Ethereum L1 directly using an “escape hatch” mechanism that most rollups implement. It’s clunky and not something regular users would know how to do easily, but it exists as a last resort. Your funds are never permanently stuck.
Are rollup fees always cheaper than Ethereum mainnet? Generally yes, often dramatically so. But fees vary based on L1 gas prices (since rollups still post data to Ethereum) and rollup-specific congestion. During Ethereum network spikes, rollup fees go up too — just not as dramatically. EIP-4844 (blob transactions, introduced in March 2024) significantly reduced the cost of posting rollup data to L1.