Lecture 15: Ethereum's Rollup-Centric Scaling: Architecture, Security, and Performance Trade-offs
Instructor: Yu Feng, UCSB
CS190: Blockchain Programming and Applications
Lecture 15 — This lecture introduces Ethereum's rollup-centric scaling roadmap and explains why scalability has become the central constraint for public blockchains. We quantify the performance and fee limits of Layer 1, then motivate modular designs that keep consensus and data availability on L1 while offloading execution to Layer 2 rollups.
The Performance Ceiling of Layer 1
The core promise of blockchain technology is creating a trustless, decentralized global settlement layer. However, architectural decisions required for decentralization impose severe performance penalties. Ethereum operates under constraints designed to ensure a consumer-grade laptop can run a node—non-negotiable for maintaining censorship resistance.
Ethereum Throughput
15-30 transactions per second under current L1 constraints
Visa Network
24,000 TPS capability represents three orders of magnitude difference
Financial Markets
Millions of orders per second on Nasdaq and NYSE
In a standard Layer 1 blockchain, every full node must re-execute every transaction to verify the state transition. While this provides robust security through redundancy, it is inherently inefficient. For DeFi to become viable, supporting complex interactions like algorithmic trading and micropayments, throughput must increase exponentially.
The Economic Consequences of Congestion
The bottleneck at Layer 1 is fundamentally a matter of cost. Ethereum blocks have finite gas space. When demand exceeds supply, the network relies on a fee market where users bid higher gas fees to prioritize their transactions.
This mechanism creates extreme volatility. During "DeFi Summer" of 2020 or the NFT boom of 2021, gas fees spiked to exorbitant levels—simple Uniswap token swaps cost $50 to $100 in fees. This creates a regressive economic structure where "public" blockchains become gated communities accessible only to the wealthy.
$50
Peak Gas Fee
Cost for simple token swaps during congestion
0.005%
Whale Fee Impact
$50 fee on $1M transaction

For financial inclusion objectives, a system requiring $40 to move $20 represents a fundamental failure. Recent 2025 data shows Layer 1 fees stabilized somewhat, but complex smart contract interactions still cost significantly more during network congestion.
The Scaling Solution Space
On-Chain vs. Off-Chain Approaches
On-Chain Scaling
Larger Blocks: Increase block size or gas limit to fit more transactions, but this increases hardware requirements and centralizes the network.
Sharding: Split blockchain into parallel chains handling subsets of state. Ethereum pivoted from execution sharding to "Danksharding" which shards data availability rather than execution.
Off-Chain Scaling
Layer 1 (Ethereum): Acts as settlement layer providing security, consensus, and data availability—the ultimate arbiter of truth.
Layer 2 (Rollups): Handles execution, processes transactions, maintains application state, performs computational heavy lifting off-chain, then reports results to L1.
The industry has overwhelmingly converged on off-chain scaling through modularity. Instead of forcing Layer 1 to handle consensus, data availability, and execution, we unbundle these functions. This lecture focuses on Rollups, the dominant Layer 2 architecture.
Defining the Rollup
At a conceptual level, a rollup is an off-chain execution environment that bundles hundreds or thousands of transactions into a single batch, then posts a compressed summary and resulting state root back to Layer 1.
Off-Chain Execution
Actual computation happens on high-performance servers off-chain, not on congested Ethereum
Data Compression
Standard transaction requires ~110 bytes; rollups compress to ~12 bytes by stripping signatures and using short indices

Definition: A Rollup is a scaling solution where transaction execution occurs outside the main chain (Layer 1), but transaction data and state commitments are posted to the main chain. This ensures Layer 1 guarantees data availability and state correctness.
Core Architectural Components
01
L1 Rollup Contract
Smart contract deployed on Ethereum mainnet serving as the system anchor. Acts as lockbox for deposited funds and stores sequential history of State Roots—cryptographic hashes representing entire rollup state at specific block heights.
02
Off-Chain State (Layer 2)
Database of accounts and balances existing on rollup servers. Structurally similar to Ethereum's state (typically a Merkle Tree) but lives on independent infrastructure, tracking ownership inside the rollup ecosystem.
03
The Sequencer
Specialized node operating the rollup. Currently centralized in most implementations (Arbitrum One, Base, Optimism) though decentralization plans are active. Receives transactions, orders them, executes to update L2 state, compresses data and submits to L1 contract.
The Lifecycle of Funds
Phase 1: Deposit (L1 → L2)
Initiation & Locking
Alice sends Ethereum transaction to L1 Rollup Contract with 2 ETH attached. The L1 contract receives and locks the funds in custody, emitting a Deposit event in Ethereum logs containing Alice's address and amount.
Minting & State Update
Sequencer monitors L1 for deposit events. Upon detection, creates special "minting" transaction on Layer 2. Credits Alice's L2 address with 2 ETH—wrapped tokens fully backed by physical ETH locked in L1 contract.
Alice now possesses 2 ETH on the rollup and can execute trades, lend assets, or transfer funds. These subsequent L2 transactions occur instantly and cost fractions of a cent because they only involve the Sequencer updating its local database.
Phases 2&3: Execution and Settlement
1
L2 Transfer
Alice signs transfer(Bob, 1 ETH) and sends to Sequencer
2
Instant Finality
Sequencer confirms balance, updates state in milliseconds—Web2-like experience
3
Batch Collection
Sequencer collects thousands of transactions and compresses batch
4
L1 Submission
Submits compressed data and new state roots to L1 in single transaction
The Sequencer doesn't immediately submit each transaction to Layer 1. It waits to collect thousands of transactions, compresses them, then submits in a single Ethereum transaction. This amortizes heavy L1 gas costs across all users, resulting in massive fee reductions observed on Layer 2.
Phase 4: Withdrawal (L2 → L1)
Initiation
Alice submits withdrawal
L2 Burning
Sequencer burns L2 ETH
L1 Commitment
Withdrawal in L1 batch
Verification Gap
L1 needs withdrawal proof

Critical Question: The L1 contract can't blindly trust Sequencer withdrawal claims. Proof is required to prevent fraudulent withdrawals (e.g., fake 1,000 ETH). This mechanism differs significantly between Optimistic and zk-Rollups.
Categorizing Rollups
Two Dominant Architectural Approaches
1
Optimistic Rollups
Examples: Arbitrum, Optimism, Base
Philosophy: "Innocent until proven guilty" approach. Assumes all transaction batches posted by Sequencer are valid by default. L1 contract only intervenes if watcher detects fraud and submits proof within challenge window (typically 7 days).
2
Zero-Knowledge Rollups
Examples: zkSync, Starknet, Linea, Scroll
Philosophy: "Don't trust, verify" approach. Requires Sequencer to generate cryptographic proof (Validity Proof) for every batch. L1 contract verifies proof mathematically before accepting state update, ensuring immediate finality without challenge period.
The defining characteristic of a rollup is not how it executes transactions, but how it proves to Layer 1 that those transactions were correct. This "verification gap" has led to fundamentally different security models with distinct trade-offs.
Optimistic Rollups: "Innocent Until Proven Guilty"
Optimistic Rollups assume transactions and state roots from the Sequencer are correct. The L1 contract accepts updates without immediate verification.
Challenge Window
Batches enter a Challenge Window (typically 7 days) where state is pending, not final.
Verifier Network
Relies on a network of "Verifiers" or "Watchtowers" to monitor Sequencer honesty, forming a "1-of-N" security assumption.
This provisional trust relies on the L1 contract acting as a supreme court for reported disputes, using game theory and economic incentives for security.
Security Model: The Fraud Proof Game
Observation
Verifiers download Sequencer data, re-execute transactions locally, check if their state root matches published one
Challenge
If discrepancy detected, Verifier issues challenge to L1 contract, locking disputed state
Bisection Game
Sequencer and Verifier engage in interactive protocol to narrow disagreement to single instruction
One-Step Proof
L1 contract executes just that single step on-chain, compares results with claims
Slashing
Fraud proven: Sequencer slashed. False alarm: Verifier loses bond

1-of-N Trust Assumption: As long as there is at least one honest verifier monitoring the chain, fraud will be detected and prevented. The system does not require a majority of honest participants, only a single whistleblower.
Analogy: The Exam Appeals Process
Imagine a university course with 500 students. The professor (Layer 1) is too busy to grade every exam question immediately. A Teaching Assistant (Sequencer) grades all exams and posts scores on a public bulletin board.
1
Optimistic Phase
University assumes TA is honest. Grades considered valid but not yet official
2
Challenge Window
For one week, students (Verifiers) can review their exams for errors
3
Fraud Proof
Student points to specific question. Professor reviews only that question. TA fired if wrong
If no one complains for a week, the grades become permanent on transcripts. This mirrors how Optimistic Rollups achieve security through economic incentives and reactive verification.
Optimistic Rollup User Experience
Low Cost Operation
L1 contract doesn't perform heavy computation by default—only verifies signatures and stores data. Cost dominated by data storage fees on L1 (calldata or blobs), making operations very economical.
7-Day Withdrawal Delay
Most significant downside: withdrawal latency. Alice must wait for Challenge Window to elapse to ensure state update isn't fraudulent. Third-party Liquidity Bridges mitigate this for regular users at small fee cost.
EVM Equivalence
Structurally very similar to Ethereum. Can run EVM almost exactly as is without complex cryptographic proofs. Makes it incredibly easy for developers to deploy existing dApps without code changes.
Zero-Knowledge Rollups: "Don't Trust, Verify"
Zero-Knowledge Rollups reject the "innocent until proven guilty" paradigm. They operate on a principle of cryptographic certainty. The L1 contract does not trust the Sequencer for even a second.
Every time the Sequencer proposes a new batch of transactions, it must provide a Validity Proof—a cryptographic certificate that mathematically proves the correctness of the execution.
This mechanism relies on advanced cryptography known as Zero-Knowledge Proofs, specifically SNARKs (Succinct Non-Interactive Arguments of Knowledge) or STARKs (Scalable Transparent Arguments of Knowledge).
zkSync Era
Starknet
Linea
Scroll
Security Model: Validity Proofs
1
Execution and Proving
Sequencer or specialized Prover node executes batch off-chain, then performs computationally intensive task of generating mathematical proof asserting: "Started with State Root A, applied transactions T1-T1000 according to EVM rules, result is State Root B."
2
Submission
Sequencer submits transaction data, new State Root, and Validity Proof to L1 smart contract
3
On-Chain Verification
L1 contract contains "Verifier Circuit" that runs computation to verify proof. Crucially, verifying a proof is exponentially cheaper and faster than generating it—takes constant time regardless of batch size
4
Immediate Finality
Contract outputs binary result: True (state transition accepted, immediately final) or False (transaction rejected outright). Cryptographically impossible to generate valid proof for invalid transaction
Analogy: The Locked Box and The Calculator
Returning to our exam analogy for zk approach: The TA (Sequencer) grades the exams. Before submitting grades to the Professor (Layer 1), the TA must feed exams into a "Magical Glass Box" (the zk-Circuit).
Inside the box is a calculator that checks every step of the grading process
If the grading is perfect, box prints a "Certificate of Correctness" with green seal
TA hands grades and Certificate to Professor
Professor doesn't look at exams—simply checks the green seal
If the seal is valid, grades are accepted immediately. The Professor knows with 100% certainty that grades are correct without ever reading them.
The Challenge of the zkEVM
Generating zero-knowledge proofs for the complex EVM is challenging because its opcode structure isn't natively compatible with ZKP requirements. This has led to a spectrum of zkEVM types, each balancing compatibility with proof efficiency.
Type 1
Fully Ethereum-Equivalent: Max compatibility, slow proving.
Type 2
EVM-Equivalent: Minor modifications for easier proving, full app compatibility.
Type 2.5
Gas-Optimized: EVM-equivalent with increased gas for hard ops, balancing performance.
Type 3
Almost EVM-Equivalent: Removes hard-to-prove features; most apps work.
Type 4
High-Level Language Equivalent: ZK-friendly VM bytecode, max performance, less EVM compatible.
The Challenge of the zkEVM
zk-Rollup User Experience
Fast Finality
Once proof is submitted and verified on L1 (15 minutes to 1 hour), transaction is final. No 7-day challenge window required for settlement.
Fast Withdrawals
L1 contract verifies validity proof immediately, confirming withdrawal legitimacy. Alice can withdraw funds in roughly the time to generate and verify proof (typically under an hour vs. one week). Critical for institutional traders.
High Computational Cost
Generating validity proofs requires immense computational power. Prover nodes often require server farms with high-end GPUs or FPGAs. Higher "fixed cost" than Optimistic Rollups, though amortized as volume grows.
Superior Data Compression
Can be cheaper than Optimistic Rollups in L1 data costs. Can omit signatures and intermediate data because Validity Proof certifies signatures were checked off-chain. Enables higher compression ratios.
Market Status and Key Takeaways
November 2025 Market Leadership
$16.6B
Arbitrum One TVL
51% market share dominance
$10-12B
Base TVL
Coinbase-backed growth
$6B
Optimism TVL
$1B
Starknet TVL
Leading zk-Rollup
Critical Insights
Scaling is Existential: Ethereum's 15-30 TPS insufficient for global finance. High fees exclude users and stifle innovation.
Modular Architecture: Rollups decouple execution from security, achieving high throughput without sacrificing base layer guarantees.
Optimistic Current Leader: "1-of-N" trust model with Fraud Proofs. Easier to build, currently dominant, but 7-day withdrawal degrades capital efficiency.
zk Future Challenger: Validity Proofs provide immediate cryptographic certainty. Fast finality and better compression but higher computational costs and engineering complexity.
Technology is not the only driver of adoption. Optimistic rollups launched earlier with better developer tooling, capturing network effects. zk-Rollups are playing catch-up, but their superior security properties make them the likely endgame for the network.
REFERENCES
  1. Buterin, V. (2021). An Incomplete Guide to Rollups. Retrieved from https://vitalik.eth.limo/general/2021/01/05/rollup.html. Accessed: 2025-11-24.
  1. Buterin, V. (2022). The different types of ZK-EVMs. Retrieved from https://vitalik.eth.limo/general/2022/08/04/zkevm.html. Accessed: 2025-11-24.
  1. Arbitrum Foundation. (2025). Arbitrum Docs: Customizable challenge period. Retrieved from https://docs.arbitrum.io/launch-arbitrumchain/configure-your-chain/common-configurations/customizable-challenge-period. Accessed: 2025-11-24.
  1. Ethereum Foundation. (2024). Danksharding | ethereum.org. Retrieved from https://ethereum.org/en/roadmap/danksharding/. Accessed: 2025-11-24.
  1. Visa Inc. (2019). Visa Fact Sheet. Retrieved from https://usa.visa.com/dam/VCOM/global/about-visa/documents/visa-fact-sheet-july-2019.pdf. Accessed: 2025-11-24.
  1. L2Beat. (2025). L2Beat: Ethereum Layer 2 Total Value Locked. Retrieved from https://l2beat.com/scaling/tvl. Accessed: 2025-11-24.
  1. L2Fees. (2025). L2Fees: Ethereum Layer 2 Fee Tracker. Retrieved from https://l2fees.info/. Accessed: 2025-11-24.