Bitcoin Protocol

Part 0 Opening: Use the Source, Luke (5 min)

Why Read Bitcoin Core?

• The Ultimate Specification: In Bitcoin, the code is the spec. Documentation can be outdated; the consensus rules in the code are absolute.
• The “C++” of Money: Understanding the reference implementation gives you the foundation for all other Layer 1 and Layer 2 development.
• Navigating the Monolith: Bitcoin Core is a mature, highly optimized, and complex C++ codebase. Today we find the “North Star” in the code.

The Philosophy of the Core Codebase

• No Formal Spec: The behavior of Bitcoin Core is the protocol. If the code has a bug that the network accepts, that bug becomes the rule.
• C++ for a Reason: High performance, deterministic memory management, and historical continuity.
• The src/consensus/ directory is treated with extreme caution.
• grep is your friend.
• Developer notes: doc/developer-notes.md, doc/productivity.md, and CONTRIBUTING.

Part 1 Entry Point & Chain Params (10 min)

How it Starts: bitcoind & init

• Entry Point: src/bitcoind.cpp — The main daemon loop.
• Initialization Flow: src/init.cpp — Handling arguments, thread management, and sanity checks.
• The Global State: src/kernel/chainparams.cpp — Hardcoded constants for Mainnet, Testnet, and Regtest.
  • Look for: genesis.hashMerkleRoot and nDefaultPort.

Part 2 Transactions, Scripts, Serialization (20 min)

The Atomic Unit: CTransaction

• Primitives: src/primitives/transaction.h
  • COutPoint: A reference to a specific output (TXID + Index).
  • CTxIn: The “Input” containing the OutPoint and scriptSig.
  • CTxOut: The “Output” containing the value (satoshis) and scriptPubKey.

The Script Engine: src/script/

• src/script/script.h — The stack-based, non-Turing complete engine.
• interpreter.cpp: The EvalScript function — the massive switch statement for Opcodes (OP_CHECKSIG, OP_DUP, etc.).

Serialization

• src/serialize.h — The custom macros used to pack data for disk and wire.

Part 3 Blocks, Merkle Trees, PoW (15 min)

The Block Header

• src/primitives/block.h
• 80 bytes: nVersion, hashPrevBlock, hashMerkleRoot, nTime, nBits (difficulty), nNonce.

The Merkle Proof

• src/consensus/merkle.cpp — How thousands of transactions are condensed into a single hash.

Difficulty & PoW

• src/pow.cpp
  • CheckProofOfWork(): The core validation.
  • CalculateNextWorkRequired(): The 2,016-block adjustment logic (the “Difficulty Adjustment”).

Part 4 Validation & The UTXO Set (20 min)

Validation Pipeline: src/validation.cpp

• AcceptToMemoryPool: Logic for entering the mempool.
• CheckBlock: Context-free checks (Is the block size okay? Is PoW valid?).
• ConnectBlock: Context-heavy (Do the inputs exist? Are signatures valid?).

The Coins Database (UTXO): src/coins.h

• CCoinsViewCache: A high-performance, in-memory cache of the unspent outputs.
• Understanding “Chainstate”: The current global state of who owns what.

Soft Fork Logic

• How DeploymentEnabled checks for new rules (like Taproot or SegWit).

Part 5 P2P Network & Message Flow (15 min)

Lower-level Network: src/net.cpp

• Managing the CNode object — representing a peer.
• Thread handling for SocketHandler, DNSAddressSeed, and OpenConnections.

Higher-level Message Processing: src/net_processing.cpp

• ProcessMessage(): The massive dispatcher.

The Handshake

• VERSION and VERACK exchange logic.

Part 6 Mempool & Block Assembly (10 min)

The Mempool: src/txmempool.cpp

• How unconfirmed transactions are stored and sorted by fee density (total weight).

Mining Logic: src/node/miner.cpp

• BlockAssembler::CreateNewBlock: The algorithm that picks transactions from the mempool to build a candidate block.
• Reserved space for the Coinbase Transaction.

Part 7 Architecture Map & Next Steps (10 min)

Directory Overview

Next Steps

• Check doc/developer-notes.md for contributing guidelines.
• Use git grep to follow variable names.
• Try compiling with the various debugging options.

Bitcoin Core: The “Top 10” Source Files