Mastering the Lightning Network (Andreas Antonopoulos)（Z-Library）

【One-Line Pitch】 A developer-oriented guide to Bitcoin's second layer: how payment channels, routing, and onion messaging combine into a scalable, trust-minimized payment network. Best for engineers and technically curious Bitcoin users who want to build on or operate Lightning rather than just use a wallet. 【Book Arc】 - **Opening (~0%–20%)**: Orients you in the problem Lightning solves — Bitcoin's throughput and confirmation limits — then introduces the mental model of off-chain payment channels as the base primitive. - **Early (~20%–40%)**: Builds the channel lifecycle: funding, commitment transactions, revocation, and penalty mechanisms that make cheating unprofitable. - **Middle (~40%–60%)**: Moves from single channels to a network — multi-hop payments, routing, pathfinding, and the gossip protocol that lets nodes discover the topology. - **Late (~60%–80%)**: Covers the messaging and privacy layer: onion routing, invoices, and the protocol machinery that keeps sender and receiver details hidden from intermediaries. - **Ending (~80%–100%)**: Turns to operations and practice — node software, channel management, liquidity, backups, and the trade-offs of running infrastructure in production. 【Key Takeaways】 - **Lightning is a second-layer scaling answer, not a replacement for Bitcoin** (Opening): it moves small payments off-chain while periodically settling to the base chain, trading throughput for new operational complexity. - **Payment channels are the atomic unit of the system** (Early): everything above — routing, invoices, liquidity — is built from the funding/commitment/revocation cycle, so this is the part worth slowing down for. - **Revocation and penalty logic is what makes channels safe** (Early): the design assumes participants may try to cheat, and the protocol punishes stale state rather than trusting good behavior. - **Routing is the hard engineering problem** (Middle): finding a path with enough liquidity across unknown channels is a search and economics problem, not just a networking one. - **Onion routing buys privacy by default** (Late): intermediaries forward payments without learning the full path, which shapes both the protocol design and its failure modes. - **Running a node is an ongoing operational commitment** (Ending): liquidity, uptime, fees, and backups are recurring concerns — not a one-time setup. - **The book is implementation-facing** (throughout): it targets readers who will write code, run nodes, or debug channels, rather than readers seeking a light conceptual overview. 【Reading Tips】 - Deep-read the channel mechanics and revocation sections; they are the conceptual load-bearing walls for everything later. - Skim the protocol message and gossip details on a first pass, then return when you actually build or debug a node. - Keep a node or testnet environment nearby — routing and liquidity concepts land much better when you can watch them fail in practice. - Treat the operations chapters as a checklist you revisit after your first channel, not as front-to-back reading. - Note that this edition is a machine translation; where phrasing feels awkward, cross-check terminology against upstream Lightning specifications. 【Coverage Limits】 The available excerpts are essentially empty — only the title, author, and repeated machine-translation markers appear, with no chapter content. This guide therefore describes the book's well-known subject matter and structure at a general level; specific chapters, examples, code, and figures are not covered by the excerpts and should be verified against the actual text.