# Learning path This is the guided route through the vault — five phases, each building on the last. At the end of each phase there's a gate: a handful of questions you should be able to answer at a whiteboard before moving on. There's no prize for speed here; the gates exist because each phase quietly assumes you've internalized the previous one. If you haven't seen the overall map yet, start at [[Blockchain Home]]. ## Phase 1 — The protocol skeleton *About one week. Modules: [[01 Replicated State Machines]] → [[02 Cryptographic Primitives]] → [[03 Blocks, Hashes, and History]] → [[04 Consensus]]* This phase answers the founding question: how do machines that don't trust each other agree on anything at all? You'll find most of your distributed-systems knowledge transfers — and the places where it doesn't are exactly the interesting parts. Read alongside: the Bitcoin whitepaper, Stanford CS251 intro lectures, and the Ethereum.org docs on accounts, transactions, blocks, and consensus. Build alongside: Project 1 in [[Projects to Build]] — the toy blockchain. **The gate.** Before moving on, check that you could comfortably: - Explain Bitcoin and Ethereum as replicated adversarial state machines, including where Raft's assumptions stop holding. - Walk someone through how proof-of-work prevents double spending, without hand-waving at "mining." - Distinguish fork choice from [[Finality]], and probabilistic from economic finality. - Say what a [[Merkle Trees|Merkle root]] commits to and how an inclusion proof works. ## Phase 2 — The execution machine *About two weeks. Modules: [[05 Execution and Smart Contracts]] → [[06 Transaction Lifecycle and MEV]]* Now that blocks exist and get agreed on, what do they actually *do*? This phase covers the EVM, gas, tokens — and then follows a single transaction through its surprisingly eventful journey from wallet to block. Read alongside: Mastering Ethereum (EVM and contracts chapters), Ethereum.org smart contract docs. Build alongside: a minimal ERC-20 interaction on a testnet; start Ethernaut. **The gate.** - Trace a token swap from wallet signature to contract state change, naming each system it crosses. - Explain why the EVM forbids I/O, clocks, and randomness — and why one reason covers all three. - Explain [[Gas and Blockspace|gas]] as both DoS defense and resource pricing. - Describe a sandwich attack and why [[MEV]] is structural rather than incidental. ## Phase 3 — Wallets and infrastructure *About two weeks. Modules: [[07 Wallets and Account Abstraction]] → [[08 Nodes, RPCs, and Indexers]]* This is where protocol meets product: who holds keys, what signing really authorizes, and the very ordinary infrastructure (RPCs, indexers, databases) that every "decentralized" app actually runs on. Read alongside: ERC-4337 docs, WalletConnect docs, WebAuthn material. Build alongside: Projects 2 and 3 in [[Projects to Build]] — the indexer and the signing simulator. If wallet infrastructure is your destination, also read [[Wallet Infrastructure Roles (Privy)]] now. **The gate.** - Explain why a wallet holds no assets, and rank wallet types by what an attacker must compromise. - Walk the ERC-4337 flow and say what each component (bundler, EntryPoint, paymaster) adds. - Explain why calling an RPC is not the same as verifying the chain ([[Trust Assumptions]]). - Design a [[Reorgs|reorg]]-safe indexer schema from memory. ## Phase 4 — Scaling and the multi-chain world *About two weeks. Modules: [[09 Scaling - Rollups and Data Availability]] → [[10 Bridges and Interoperability]] → [[11 DeFi, Stablecoins, and Governance]]* One chain, finite blockspace, growing demand — so the machine fragments into layers and the layers need to talk. This phase covers rollups, data availability, bridges, and then the financial protocols that live on top of all of it. Read alongside: Ethereum.org rollup and DA docs, EIP-4844 explainers, OP Stack docs, Arbitrum docs, Celestia docs, Uniswap and MakerDAO docs. Build alongside: Project 5 — the toy rollup. **The gate.** - Explain optimistic vs ZK rollups as detect-and-recover vs prevent-by-construction, including what each one trusts. - Explain the data-withholding attack and why [[Data Availability]] earned its own layer. - Enumerate the finality stages of one rollup transaction, and say which stage a bridge should wait for — and why. - Derive slippage and impermanent loss from `x * y = k`. ## Phase 5 — Security, ongoing *No end date. Module: [[12 Security and Incentive Design]]* The last phase never really finishes. Everything you've learned has a failure mode, and the practitioners who are genuinely good at this are the ones who've collected them. Do, in order: Ethernaut (finish it), Damn Vulnerable DeFi, selected Paradigm CTF writeups. Read post-mortems as they happen — each one is a trust assumption someone found the hard way. **The gate — the standing one.** - Given any protocol, run the ten threat-model questions and produce its real trust model, not its whitepaper's. - Trace one historical exploit end to end and name the assumption (not the bug) that failed. - Answer, for anything you build: what, exactly, does the user have to trust? When that last question becomes a reflex, the path has done its work. What remains is [[Projects to Build|building]]. --- Resources, annotated and mapped: [[Resources]] · The map: [[Blockchain Home]]