How to Use This Book

Book Structure

This book is organized into nine parts containing 40 chapters, plus 11 appendices.

Part I: Foundations — What Is This and Why Does It Exist? (Chapters 1-5) Builds the conceptual and technical foundations: cryptographic primitives, distributed systems theory, the economics of money, and a map of the current landscape. No blockchain-specific knowledge is assumed. You finish Part I understanding why blockchains were invented and what problems they claim to solve.

Part II: Bitcoin — The Original Protocol (Chapters 6-10) A deep technical treatment of Bitcoin: the UTXO transaction model, Proof of Work mining, the peer-to-peer network, Bitcoin Script and Taproot, and the economic model of a fixed-supply digital asset. You finish Part II able to read raw Bitcoin transactions, simulate mining, and evaluate the store-of-value thesis.

Part III: Ethereum and Smart Contracts (Chapters 11-16) The development core of the book. Ethereum's architecture, the EVM, Solidity programming (from first contract through production patterns and security auditing), and Proof of Stake consensus. You finish Part III able to write, test, deploy, and audit smart contracts.

Part IV: The Broader Blockchain Landscape (Chapters 17-20) Expands the view: alternative consensus mechanisms (DPoS, BFT variants, DAGs), Layer 2 scaling solutions (rollups, state channels), cross-chain interoperability (bridges, IBC), and enterprise/permissioned blockchains. You finish Part IV understanding the full design space.

Part V: Decentralized Finance — DeFi (Chapters 21-25) Covers DeFi with genuine depth: DEXs and automated market makers, lending and yield, stablecoins (including the Terra/Luna forensic analysis), and a systematic risk framework. You finish Part V able to evaluate any DeFi protocol critically.

Part VI: Tokens, NFTs, and Digital Ownership (Chapters 26-28) The application layer: token economics and incentive design, NFTs (the hype cycle and what survived), and DAOs (the experiment in decentralized governance). You finish Part VI understanding digital ownership and on-chain governance.

Part VII: Regulation, Law, and Society (Chapters 29-32) The non-technical dimensions: the global regulatory landscape, forensic history of failures (Mt. Gox through FTX), the privacy paradox of transparent money, and the environmental debate. You finish Part VII with the context that technology alone cannot provide.

Part VIII: Building and Analyzing (Chapters 33-36) Practical skills: building a full-stack dApp, on-chain analytics with Python, a critical thinking framework for evaluating any crypto project, and personal security (wallets, custody, key management). You finish Part VIII with hands-on capabilities.

Part IX: The Frontier and the Big Questions (Chapters 37-40) Cutting-edge and synthesis: zero-knowledge proofs, central bank digital currencies, the 10-year outlook, and — most importantly — the tools to form your own informed view about decentralized systems.

Three Learning Paths

Fast Track: "I'm a Developer Who Needs to Write Smart Contracts"

Time: 2-3 weeks at 2 hours/day Chapter sequence: 1. Ch 1 (skim — 30 min orientation) 2. Ch 2 (cryptographic foundations — essential) 3. Ch 5 (skim — landscape orientation) 4. Ch 11 (Ethereum architecture) 5. Ch 12 (EVM internals) 6. Ch 13 (Solidity programming) 7. Ch 14 (Advanced Solidity patterns) 8. Ch 15 (Smart contract security — do not skip this) 9. Ch 33 (Full-stack dApp development) 10. Ch 36 (Wallets, custody, and personal security)

This path gets you writing and deploying smart contracts as quickly as possible while covering the security knowledge that is non-negotiable for any developer deploying contracts that handle value.

After the Fast Track: Go back and read Ch 22 (AMMs) and Ch 25 (DeFi risk stack) if you are building DeFi applications. Read Ch 26 (tokenomics) if you are designing token systems. Read Ch 18 (Layer 2 scaling) if you are deploying to rollups.

Standard: Complete Sequential Reading

Time: One semester (15 weeks at 4-5 hours/week) or self-paced over 3-4 months Chapter sequence: Ch 1 through Ch 40, in order.

The book is designed to be read sequentially. Each chapter builds on concepts introduced in previous chapters, and the progressive project accumulates across the book. This is the recommended path for any reader who wants a comprehensive understanding.

Semester 1 split (if teaching over two semesters): Parts I-V (Ch 1-25). Covers foundations, Bitcoin, Ethereum, broader landscape, and DeFi. Semester 2 split: Parts VI-IX (Ch 26-40). Covers tokens, regulation, building, and frontier topics.

Deep Dive: The Complete Experience

Time: Two semesters or 6+ months self-paced Chapter sequence: All 40 chapters sequentially, plus: - All advanced sidebars (marked with > 🔵 **Deep Dive:**) - All code exercises in every chapter - The complete progressive project (all 10 milestones) - All case studies (2 per chapter) - All appendix deep dives - The "steelman both sides" debate exercises

This path is for readers who want to build genuine expertise. You will write thousands of lines of Python, Solidity, and JavaScript. You will audit smart contracts, evaluate real whitepapers, analyze on-chain data, and build a complete dApp from scratch. By the end, you will understand every layer of the blockchain stack.

Chapter Anatomy

Every chapter follows a consistent structure:

index.md (8,000-12,000 words)

The main chapter text. Opens with a concrete scenario or question. Introduces concepts with real examples. Includes code demonstrations (in technical chapters). Develops ideas progressively. Ends with a bridge to the next chapter.

exercises.md (~4,000 words)

Practice problems at three difficulty levels: - Foundational (knowledge and comprehension) - Applied (analysis and application) - Challenge (synthesis and evaluation)

Coding exercises include starter code, expected output, and hints.

quiz.md

Multiple-choice and short-answer questions for self-assessment. Answers provided with explanations.

case-study-01.md and case-study-02.md

Two case studies per chapter. Each presents a real-world scenario, asks the reader to apply concepts from the chapter, and includes discussion questions. Designed for classroom use or self-study.

key-takeaways.md

A concise summary of the chapter's main points. Useful for review and reference.

further-reading.md

An annotated bibliography of papers, books, blog posts, and documentation related to the chapter's topics. Each entry includes a brief description of what it covers and why it is worth reading.

code/ directory (technical chapters only)

Runnable source files. Python files include requirements and expected output. Solidity files include Hardhat test configurations. All code is tested with current library versions as of 2025.

The Progressive Project: Decentralized Voting dApp

Across the book, you build a complete decentralized application from scratch — a decentralized voting and proposal system. The project is deliberately modest in scope. We are not building a production DeFi protocol or a new blockchain. We are building something simple enough that you can understand every layer, from the cryptographic primitives to the user interface.

The project has 10 milestones spread across the book:

Each milestone includes complete code, tests, and instructions. You can skip milestones if you are not following the progressive project, but we recommend completing at least milestones 1, 4, and 9 for any reader on the Standard path.

Callout Blocks

Throughout the text, you will encounter colored callout blocks that serve specific functions:

💡 Key Insight: Important conceptual points that illuminate the "why" behind the "what." These are the ideas worth remembering even if you forget the details.

📊 By the Numbers: Quantitative data, statistics, and real-world measurements. We cite sources for all data.

⚠️ Warning: Common mistakes, security risks, and pitfalls. Pay attention to these — in blockchain development, mistakes can be expensive and irreversible.

✅ Best Practice: Recommended approaches and industry-standard patterns.

🔗 Cross-Reference: Pointers to related content in other chapters. Useful for seeing how concepts connect across the book.

🔴 Critical: Safety-critical or security-critical information. In smart contract development, these are the things that, if ignored, lead to exploits and lost funds.

🔵 Deep Dive: Advanced material that can be safely skipped on a first reading without losing the chapter's main thread. Deep Dive readers should read these; Fast Track and Standard readers can skip them.

⚖️ Both Sides: Balanced presentation of contested claims. When reasonable people disagree, this callout presents the strongest version of each side's argument. This is how we handle topics like Bitcoin's environmental impact, DeFi's value proposition, and the right level of regulation.

🧪 Try It: Hands-on exercises embedded in the text. These are short activities (5-15 minutes) that reinforce the concept just discussed. They are distinct from the exercises.md problems, which are more substantial.

Code Setup Requirements

To run all code examples and complete the progressive project, you will need:

Python (Parts I-II, Part VIII)

• Python 3.10 or later
• pip packages: hashlib (standard library), ecdsa, web3, requests, matplotlib, pandas
• Installation: pip install ecdsa web3 requests matplotlib pandas

Node.js and Hardhat (Parts III, V-VI, VIII)

• Node.js 18 or later
• npm packages: hardhat, @nomicfoundation/hardhat-toolbox, @openzeppelin/contracts, ethers
• Installation: npx hardhat init (follow prompts for TypeScript or JavaScript project)

Solidity (Parts III, V-VI, VIII)

• Solidity 0.8.20+ (installed automatically by Hardhat)
• No separate installation required

Optional: Foundry (Alternative to Hardhat)

• Forge and Cast for Solidity development and testing
• Installation: curl -L https://foundry.paradigm.xyz | bash && foundryup
• The book uses Hardhat as the primary tool but notes Foundry equivalents where relevant

Wallet and Testnet

• MetaMask browser extension (free)
• Sepolia testnet ETH from a public faucet (free)
• No real cryptocurrency is needed at any point in this book

Detailed setup instructions with troubleshooting are in Appendix A: Development Environment Setup.

A Note on the "Both Sides" Approach

This book is unusual in blockchain education because it does not have a position. Most resources are written by people who are either financially invested in crypto (and therefore structurally incentivized to be optimistic) or ideologically opposed to it (and therefore structurally incentivized to be dismissive). We are neither.

When you see the ⚖️ Both Sides callout, you are reading the strongest version of competing arguments. We do this not because we think both sides are always equally correct — sometimes the evidence clearly favors one side — but because we believe that understanding the strongest version of an argument you disagree with is the foundation of clear thinking.

By the end of this book, you should be able to explain to a Bitcoin maximalist exactly what the strongest criticisms of Bitcoin are, and explain to a blockchain skeptic exactly what the strongest technical innovations are. Whether you end up closer to one position or the other is entirely your decision. We just want you to make that decision with your eyes open.