A from-scratch tour of Bitcoin in Python

In one sentence

To truly understand Bitcoin, you must move beyond high-level abstractions and implement its core primitives—from elliptic curve math to script execution—from the ground up.

Why read this (and who it's for)

This book solves the "black box" problem of cryptocurrency. Many people can use a wallet, but few understand the underlying machinery that makes a decentralized ledger possible. It is designed for engineers and developers who want to move from "user" to "architect." After reading this, you will be able to write the code that generates keys, hashes blocks, and validates transactions without relying on external libraries.

The big idea

The central thesis is that Blockchain is "Open Source + State." While traditional open source allows for the sharing of logic, blockchain allows for the sharing of a "running computer"—a persistent, permissionless state that anyone can interact with.

Karpathy argues that the only way to internalize this complexity is through the principle: "What I cannot create, I do not understand." By stripping away dependencies and implementing Bitcoin in pure Python, the reader is forced to confront the mathematical reality of the protocol. The logic follows a bottom-up path: first, you build the identity (Cryptography); then, you build the proof (Hashing/PoW); finally, you build the economy (Transactions/Scripting).

Key ideas

Blockchain as Open Source + State

• What it is: The extension of software development to include a shared, persistent state that is accessible to everyone.
• Why it matters: It shifts the paradigm from "sharing code" to "sharing a running machine" that anyone can use without permission.
• In the book: The author frames the entire project as a way to understand this "running computer" by building it from scratch.

Elliptic Curve Cryptography (ECC) Identity

• What it is: A system where a private key (a random integer) generates a public key (a point on a curve) using the secp256k1 curve.
• Why it matters: It provides the mathematical foundation for ownership. Your private key is the "password" to your funds; the public key is your identity.
• In the book: The author explains the curve parameters ($a=0, b=7$) and the "random walk" of the Generator Point ($G$) to derive public keys.

The Properties of SHA-256

• What it is: A cryptographic hash function that produces a fixed-size, non-invertible, and unique-looking digest of any input.
• Why it matters: It is the "engine" of Proof of Work. Because it is computationally impossible to find a specific hash without brute force, it allows for a verifiable "cost" to be attached to block production.
• In the book: The author details the specific padding, chunking, and message scheduling required to implement SHA-256 from scratch.

The "Change" Model of Transactions

• What it is: A system where every input must be fully spent, and the difference between the input value and the output values is treated as "change" or a "fee."
• Why it matters: This prevents the "minting" of money. It creates a market where miners are incentivized to include transactions by competing for the "change" left behind by users.
• In the book: The author explains the Coinbase transaction as the unique exception where a miner can create new output from a null input.

Bitcoin Script (Pkscript)

• What it is: A stack-based, Turing-incomplete scripting language used to define the conditions under which an output can be spent.
• Why it matters: It allows for complex spending conditions (like multi-sig or timelocks) while keeping the transaction validation logic simple and predictable.
• In the book: The author breaks down the standard OP_DUP, OP_HASH160, and OP_CHECKSIG pattern used to verify a spender's identity.

Frameworks & tools

The Public Key Generation Framework

To generate a Bitcoin identity, follow these mathematical steps:

1. Select the Curve: Use secp256k1 (where $a=0$ and $b=7$).
2. Select a Private Key: Choose a random integer $k$ such that $1 \le k < n$ (where $n$ is the order of the curve).
3. Perform Scalar Multiplication: Calculate the public key by adding the Generator Point ($G$) to itself $k$ times.
4. Formula: $\text{public_key} = \text{secret_key} \cdot G$.

The Transaction Validation Framework (The "Bitcoin VM")

To validate a transaction, the system executes a stack-based script:

1. Concatenate: Join the script_pubkey (locking script) and script_sig (unlocking script).
2. Push to Stack: Push the signature and the public key onto the stack.
3. Verify Hash: Use OP_DUP and OP_HASH160 to ensure the public key matches the expected hash.
4. Verify Signature: Execute OP_CHECKSIG to ensure the signature is valid for that public key.

Memorable examples & stories

The "Random Walk" of the Generator Point

The author describes the public key as a "random walk" on the curve's cycle. This helps visualize how a simple starting point ($G$) can reach a seemingly random point on the curve when multiplied by a secret integer. Lesson: Cryptography is built on the difficulty of predicting where a walk ends.

The "Change" as a Fee

The author explains how the difference between input and output values isn't "lost" money but is the mechanism for miner incentives. Lesson: Economic incentives are hard-coded into the transaction data structure.

The Privacy of Hash160

The author explains how using a hash of a public key (p2pkh) instead of the raw public key hides the owner's identity until they decide to spend the funds. Lesson: Privacy is a default property of the data structure, not just an added feature.

Key quotes

"What I cannot create, I do not understand." Why it matters: This is the core pedagogical philosophy of the book—learning through implementation.

"Blockchain extends open source software development to include 'open source + state'." Why it matters: It defines the unique value proposition of blockchain technology.

"The sum of all outputs must be lower than the sum of all inputs (prevents minting money)." (Paraphrased) Why it matters: This is the fundamental rule of the Bitcoin "economy."

How to apply it

This week

• Implement a Hash: Write a Python script to implement the SHA-256 padding and chunking logic.
• Generate a Keypair: Write a script that uses the secp256k1 parameters to generate a private/public key pair.
• Trace a Transaction: Take a transaction ID from a block explorer and manually map out the TxIn and TxOut values.

Ongoing

• Think in UTXOs: When thinking about payments, visualize them as a "DAG of UTXOs" (Unspent Transaction Outputs) rather than a simple balance.
• Audit the Script: Whenever you see a "smart contract" or a "script," ask: "What is the stack state at this point?"

Common pitfalls

• Assuming RSA: Many beginners assume Bitcoin uses RSA; the book clarifies it uses Elliptic Curve Cryptography (ECC).
• Single-Hash Security: Beginners often forget that Bitcoin uses a double-hash (sha256(sha256(...))) to protect against specific SHA-1 vulnerabilities.
• Ignoring the "Change" Model: Many people think a transaction is a simple "A sends to B" move. In Bitcoin, it is "A spends Input X to create Output Y and Output Z (Change)."

Connects to

• Mastering Bitcoin by Andreas Antonopoulos: Provides a broader conceptual overview of the protocol's history and philosophy.
• The Bitcoin Whitepaper: The foundational document that describes the high-level "Proof of Work" and "Timestamp Server" concepts.

If you remember only three things

• Blockchain = Open Source + State: It is a running, shared computer.
• ECC Identity: Your identity is a point on a curve ($G \cdot \text{secret_key}$).
• UTXO Model: Transactions are not balances; they are the consumption of previous outputs to create new ones.

Internalize it

• Reflection questions

  • If you had to explain the "Change" model to a non-technical person, how would you describe why the "change" is necessary for the network to function?
  • How does the "What I cannot create, I do not understand" principle apply to other complex systems you are currently learning?
  • Why is it important that the Bitcoin Script is "stack-based" and "Turing-incomplete"?

• Flashcards Q: What specific curve does Bitcoin use for its cryptographic identity? A: The secp256k1 curve. Q: What is the "Change" model in Bitcoin transactions? A: Every input must be fully spent; the difference between input and output values is the "change" or fee. Q: Why does Bitcoin use a double-hash (SHA256 of a SHA256)? A: To mitigate shortcomings of single-round SHA256 and protect against attacks discovered on SHA-1. Q: What is the purpose of the OP_CHECKSIG operation in a script? A: To verify that a digital signature is valid for a specific public key. Q: What is the "Running Computer" analogy for blockchain? A: It refers to "Open Source + State," where the software is open and the state is shared and persistent.

Fidelity note

This summary is grounded in the provided notes covering sections 1 through 4. It accurately reflects Karpathy's "build-to-understand" methodology and the technical specifics of ECC, SHA-256, and the UTXO model. The summary does not include information on mining difficulty adjustments, Layer 2 solutions, or specific privacy coins, as those were not present in the provided material.