Layer 2 Solutions Deep-Dive: Optimistic vs ZK Rollups Explained

Rollups

60 DAY WEB3 JOURNEY (Day 14)

Previous: Consensus Mechanisms Explained: How Blockchain Networks Agree Without a Boss

Tomorrow: Ethereum vs Solana: Consensus in Action (Day 16)

Introduction

Yesterday, you learned how consensus mechanisms work — how thousands of validators agree on the truth.

But there’s a problem: consensus is slow.

On Ethereum, every transaction needs validation from thousands of nodes. This takes time. It costs money. It doesn’t scale.

What if you didn’t need everyone to agree on every transaction?

That’s what Layer 2s solve. They process transactions off-chain, batch them, then settle once on Layer 1.

Result: 15 TPS → 1,000+ TPS. $5 per transaction → $0.10.

Today, you’ll learn two approaches to Layer 2s and why their differences matter.

The Problem: Why Ethereum Needs Scaling

Current Ethereum:

• 15 transactions per second
• $2–$10 per transaction
• 12-second block time

What users need:

• 1,000+ TPS (like Visa: 1,700 TPS)
• <$0.01 per transaction
• Instant confirmation

The fundamental issue:

Every validator processes every transaction. Increasing TPS means increasing hardware burden. Eventually, only rich entities can validate → centralization.

Solution: Don’t make everyone process everything.

How Layer 2s Work: The Batching Model

Layer 1 (current):

Alice sends tx → broadcast to 500,000 validators → all compute → consensus → finalized
Result: 15 TPS

Layer 2 (new):

Alice sends tx → sequencer executes instantly → bundles 1,000 txs → posts to L1 → verified
Result: 1,000+ TPS

Key insight: You’re not skipping verification. You’re batching it.

Two Approaches: Optimistic vs ZK Rollups

There are two ways to verify batches:

1. Optimistic — Assume valid, challenge if wrong (7-day finality)
2. ZK — Prove valid cryptographically before submitting (instant finality)

Optimistic Rollups: “Trust But Verify”

How It Works

Step 1: Execution (Off-Chain)

A sequencer collects 1,000 transactions and executes them locally in milliseconds.

Result: Instant confirmation for users.

Current sequencers:

• Arbitrum: Decentralized (multiple entities)
• Optimism: Single sequencer (roadmap: decentralized)

Step 2: Batch to Layer 1

Every ~1 hour, the sequencer bundles transactions and submits to Ethereum:

1,000 transactions (100KB) → compressed to 10KB → posted to Ethereum
Cost: $10 total ÷ 1,000 users = $0.01 each

What’s submitted:

• Compressed calldata
• State root (cryptographic fingerprint of new state)
• Sequencer signature

Step 3: Challenge Period (7 Days)

After posting, anyone can challenge the batch for 7 days:

Challenger: “That batch is fraudulent. Here’s proof.”
Arbitrum: “Okay, let’s recompute those transactions on Ethereum.”
Result: One transaction recomputed (not all 1,000)

If the challenger wins, they get rewarded. If no one challenges after 7 days, the batch is finalized.

Advantages:

✅ 99%+ EVM compatible (run Solidity unchanged)

✅ Proven & battle-tested ($5B+ locked)

✅ Simpler tech (fraud proofs easier than ZK)

✅ Instant execution (sequencer confirms immediately)

Disadvantages:

❌ 7-day withdrawal period to L1 (or use bridges for ~0.5% fee)

❌ Sequencer can delay/reorder transactions

❌ Requires validators to challenge bad batches

❌ Stores full calldata on-chain (less efficient)

Real-World: Arbitrum

Flow:

1. User sends tx to Arbitrum.
2. Sequencer processes instantly (confirmed in 2 sec)
3. Batched with 999 others
4. Submitted to Ethereum (~every hour)
5. 7-day challenge period
6. After 7 days: finalized

Current state:

• $5B+ TVL
• 40,000 TPS capacity
• 50+ dApps (GMX, Aave, Uniswap, etc.)
• Fees: $0.01–$0.10

ZK Rollups: “Prove It”

How It Works

Step 1: Execution (Off-Chain)

Sequencer executes 1,000 transactions locally (same as Optimistic).

Step 2: Generate Proof

The sequencer creates a zero-knowledge proof:

“I guarantee these 1,000 transactions are valid
and correctly produce the new state.

Proof can be verified in milliseconds without
recomputing anything.”

What is a zero-knowledge proof?

A cryptographic proof that proves something is true without revealing the details.

Analogy: Prove you’re over 21 without showing your ID or age.

Why can’t you fake it? Because it’s mathematically impossible (cryptographically secure).

Step 3: Submit to Layer 1 (Instant Finality)

Proof + compressed data → Ethereum
Ethereum verifies proof in 100ms
✓ Confirmed. Finalized. Can’t be reversed.

No 7-day wait. Finality achieved in ~20 minutes.

Types of Proofs

ProofUsed BySpeedSizeMaturitySNARKsLoopring5–30s288 bytesProvenSTARKsStarkNet30s-2min100KB+NewerPlonkPolygon zkEVM1–2min3–20KBProven

Trade-off: Smaller proofs = cheaper. Faster proofs = quicker finality.

Advantages:

✅ Instant finality (no 7-day wait)

✅ Higher throughput (up to 4,000 TPS)

✅ Smaller data footprint (cheaper long-term)

✅ Sequencer can’t cheat (proof proves correctness)

✅ Better for privacy

Disadvantages:

❌ Limited EVM compatibility (70–95%, need to rewrite some code)

❌ Immature tech (newer, less battle-tested)

❌ Slower proof generation (10–20 minutes)

❌ Requires cryptography expertise to build

❌ Hardware intensive

Real-World: zkSync

Flow:

1. User sends tx to zkSync
2. Sequencer processes instantly
3. Generates ZK proof (~10 seconds)
4. Submits to Ethereum
5. Ethereum verifies proof (~20 minutes)

✓ Finalized. Can withdraw instantly.

Current state:

• $500M TVL
• 10,000 TPS capacity
• 100+ dApps (Balancer, Curve, Aave)
• Fees: $0.05–$0.20

Head-to-Head: Optimistic vs ZK

Optimistic Rollups achieve finality in 7 days but offer instant execution. They handle 1,000–4,000 transactions per second at $0.01–$0.10 per transaction. They’re 99%+ EVM compatible, making them ideal for developers. The sequencer poses medium risk (can delay), but the tech is battle-tested with over 2 years of proven security. Examples include Arbitrum, Optimism, and Base.

ZK Rollups achieve faster finality in 10–20 minutes. They handle similar throughput (2,000–4,000 TPS) but cost slightly more ($0.05–$0.20 per transaction). EVM compatibility is lower (70–95%), requiring code rewrites. However, sequencer risk is minimal since proofs prevent cheating. The tech is newer (1–2 years) but rapidly maturing. Examples include zkSync, Polygon zkEVM, and StarkNet.

Which Should You Use?

Use Optimistic if:

• You want maximum app choices (most DeFi is on Arbitrum/Optimism)
• You’re comfortable with 7-day withdrawal (or using bridges)
• You want proven, secure tech

Use ZK if:

• You need instant finality (no 7-day wait)
• You’re doing simple transactions (transfers, swaps)
• You want cutting-edge tech

Reality:

Both exist because neither is objectively “better.” They make different tradeoffs:

• Optimistic: More compatible, more mature, but slower finality
• ZK: More efficient, instant finality, but newer and less compatible

It’s like choosing between a proven car and a faster electric prototype.

Other Layer 2 Approaches (Brief)

Validiums — Like Optimistic, but data stored off-chain (cheaper, less secure)

Sidechains — Separate blockchain (very fast, but doesn’t inherit L1 security)

Plasma — Old approach, mostly abandoned for Rollups

State Channels — Payment channels, only settle when needed (instant, limited to payments)

Why This Matters for You

Users:

• Layer 2s are 100x cheaper and 100x faster than Ethereum L1
• You can move between L2s using bridges (Stargate, Across)
• No choice needed; most transactions benefit from L2s

Developers:

• Want compatibility? Build on Arbitrum/Optimism
• Want future-proof? Build on zkSync/StarkNet
• Want ecosystem? Arbitrum has $5B TVL and hundreds of dApps

Investors:

• Optimistic plays: Arbitrum ($ARB token), Optimism ($OP)
• ZK plays: Polygon ($MATIC), StarkWare (not yet public)
• Risk: Optimistic = lower (proven), ZK = higher (newer)

Key Takeaways

• Layer 2s batch transactions to reduce consensus load
• Optimistic Rollups assume validity; challenge if wrong (7-day finality)
• ZK Rollups prove validity cryptographically before submitting (instant)
• Both reduce costs 100x and increase speed 100x
• No perfect solution — different tradeoffs for different needs
• Future: Ethereum L1 for security, L2s for speed, L3s for privacy/specialization
• Reality: Most Web3 traffic will eventually move to L2s

Questions to Explore

1. If ZK is more efficient, why aren’t all transactions on ZK rollups?
2. What could go wrong if a Layer 2 sequencer goes offline?
3. Why do some people distrust ZK proofs compared to fraud proofs?
4. Could a Layer 2 be hacked if Ethereum Layer 1 is secure?
5. What’s the relationship between consensus mechanisms (Day 14) and Layer 2s?

RESOURCES & FURTHER READING

Official Documentation:

L2Beat: https://l2beat.com/ — Real-time comparison of all Layer 2 solutions with fees, TVL, and security analysis
Ethereum Layer 2 Hub: https://ethereum.org/en/developers/docs/scaling/layer-2-rollups/ — Official Ethereum resource on rollups
Arbitrum Docs: https://docs.arbitrum.io/ — Technical guide for the leading Optimistic Rollup
zkSync Docs: https://docs.zksync.io/ — Technical guide for the leading ZK Rollup

Practical Tools:

Stargate Finance: https://stargate.finance/ — Bridge assets between Layer 2s instantly

Community:

Join Web3 for Humans Telegram: https://t.me/Web3ForHumans — Daily Web3 content and community discussions.

What’s Next?

Tomorrow (Day 15): Ethereum vs Solana — Two blockchains making radically different design choices.

You’ll see:

• How Ethereum’s PoS + Rollups compare to Solana’s PoH
• Why different consensus = different scalability
• Which tradeoffs each made and why

Layer 2 Solutions Deep-Dive: Optimistic vs ZK Rollups Explained was originally published in Coinmonks on Medium, where people are continuing the conversation by highlighting and responding to this story.