SOLID STATE PRESS
← Back to catalog
Rollups: Optimistic and Zero-Knowledge cover
Coming soon
Coming soon to Amazon
This title is in our publishing queue.
Browse available titles
Cryptocurrency & Blockchain

Rollups: Optimistic and Zero-Knowledge

Fraud Proofs, Validity Proofs, and How Ethereum Scales — A TLDR Primer

Ethereum is powerful — and painfully slow when it gets busy. If you've ever paid $40 in gas fees to swap a token, or watched a transaction sit pending for minutes, you've felt the scaling problem firsthand. Understanding *why* that happens, and how rollups fix it, is quickly becoming essential knowledge for anyone studying blockchain technology, computer science, or decentralized finance.

**Rollups: Optimistic and Zero-Knowledge** is a focused, no-fluff primer that walks you from the root cause of Ethereum's congestion all the way through the two dominant Layer 2 solutions competing to solve it. You'll learn exactly what a rollup is — off-chain execution with on-chain data — and why that design lets protocols like Arbitrum, Optimism, and zkSync inherit Ethereum's security without inheriting its bottlenecks.

The book covers fraud proofs and challenge windows (the optimistic model), validity proofs using SNARKs and STARKs (the zero-knowledge model), and an honest side-by-side comparison of finality, withdrawal times, EVM compatibility, and real-world adoption. The final section looks ahead to danksharding, EIP-4844 blobs, and the open question of decentralizing sequencers.

This guide is written for high school and early college students who want a clear mental model of how ethereum layer 2 rollups work — whether you're prepping for a course, a hackathon, or just trying to make sense of the space. It's short by design: read it in an afternoon, walk away oriented.

If you've been searching for an optimistic vs zero knowledge rollup guide that doesn't assume a PhD, this is it.

What you'll learn
  • Explain why Layer 1 blockchains like Ethereum hit scaling limits and what a Layer 2 is
  • Describe how a rollup batches transactions, posts data to L1, and inherits L1 security
  • Contrast optimistic rollups (fraud proofs, challenge windows) with ZK rollups (validity proofs)
  • Recognize real-world rollups (Arbitrum, Optimism, zkSync, StarkNet) and their tradeoffs
  • Understand withdrawal delays, sequencers, and the data availability problem
What's inside
  1. 1. Why Ethereum Needs Rollups
    Sets up the scaling problem: block size limits, gas fees, and why naive solutions like bigger blocks fail the decentralization test.
  2. 2. What a Rollup Actually Is
    Defines a rollup as off-chain execution plus on-chain data, walking through batching, calldata posting, and how security is inherited from L1.
  3. 3. Optimistic Rollups: Trust, but Verify Later
    Explains the optimistic model — assume batches are valid, allow a challenge window with fraud proofs — using Arbitrum and Optimism as concrete examples.
  4. 4. Zero-Knowledge Rollups: Prove It Up Front
    Introduces validity proofs (SNARKs and STARKs) at an intuitive level, showing how ZK rollups settle instantly with cryptographic certainty.
  5. 5. Optimistic vs. ZK: The Real Tradeoffs
    Side-by-side comparison of cost, finality, withdrawal time, EVM compatibility, and where each design is winning in practice.
  6. 6. Where Rollups Are Headed
    Covers the rollup-centric roadmap, danksharding and blobs (EIP-4844), the data availability layer, and open questions about decentralizing sequencers.
Published by Solid State Press
Rollups: Optimistic and Zero-Knowledge cover
TLDR STUDY GUIDES

Rollups: Optimistic and Zero-Knowledge

Fraud Proofs, Validity Proofs, and How Ethereum Scales — A TLDR Primer
Solid State Press

Rollups: Optimistic and Zero-Knowledge

Fraud Proofs, Validity Proofs, and How Ethereum Scales — A TLDR Primer

Copyright © 2026 Solid State Press.

Published by Solid State Press.

All rights reserved. No part of this book may be reproduced or transmitted in any form without prior written permission, except for brief quotations in critical reviews and educational use.

Part of the TLDR Study Guides series.

Contents

  1. 1 Why Ethereum Needs Rollups
  2. 2 What a Rollup Actually Is
  3. 3 Optimistic Rollups: Trust, but Verify Later
  4. 4 Zero-Knowledge Rollups: Prove It Up Front
  5. 5 Optimistic vs. ZK: The Real Tradeoffs
  6. 6 Where Rollups Are Headed
Chapter 1

Why Ethereum Needs Rollups

Ethereum processes every transaction on thousands of computers simultaneously. That redundancy is the source of its security — no single party controls the ledger, and corrupting it would require overpowering a globally distributed network. But that same redundancy is exactly why Ethereum is slow.

Layer 1 (L1) refers to the base blockchain itself — Ethereum's own network of nodes that agree on every transaction and store the full history. Every node must download, execute, and validate every block. That constraint puts a hard ceiling on how much work the network can do per second.

Block space is the resource at the center of this problem. Each Ethereum block has a target size of roughly 15 million gas units (with a hard cap around 30 million). Gas is Ethereum's unit of computational work: a simple ETH transfer costs 21,000 gas, while a complex DeFi interaction might cost 200,000 or more. A block appears roughly every 12 seconds. Do the arithmetic and you get Ethereum's raw throughput — the total transactions it can process per unit of time — at somewhere between 15 and 30 TPS (transactions per second) under normal conditions.

Example. Suppose an Ethereum block has a gas limit of 30,000,000 and every transaction in it is a simple ETH transfer costing 21,000 gas. How many transactions fit in one block, and what is the approximate TPS?

Solution. Transactions per block: $\frac{30{,}000{,}000}{21{,}000} \approx 1{,}428$

Blocks appear every 12 seconds, so: $\text{TPS} = \frac{1{,}428}{12} \approx 119 \text{ TPS}$

In practice, blocks also contain heavier contract interactions that consume far more gas per transaction, which pulls the real-world average well below this ceiling — closer to 15–30 TPS on a typical day.

For comparison, Visa processes an average of roughly 1,700 TPS and can burst to tens of thousands. Ethereum's throughput is not in the same neighborhood.

About This Book

If you are a college student who just hit the DeFi and Layer 2 section of a blockchain course and felt lost, a high schooler curious about why Ethereum gas fees exist and what scaling solutions actually do, or a tutor prepping a session on crypto technology for a student, this book is for you. Self-taught developers trying to get up to speed before a technical interview will find it equally useful.

This is a focused optimistic vs. zero-knowledge rollup guide that walks through how Ethereum Layer 2 rollups work, explained from first principles. You will encounter fraud proofs, validity proofs, SNARKs, and STARKs — each concept unpacked in plain language before the math appears. Think of it as a blockchain scaling primer for beginners and early engineers alike, covering the core ideas without padding. Short by design, with ruthless cuts.

Read straight through in order, work every numbered example as it appears, then use the problem set at the end to confirm you can apply what you have learned.

Keep reading

You've read the first half of Chapter 1. The complete book covers 6 chapters in roughly fifteen pages — readable in one sitting.

Coming soon to Amazon