Free through lesson 3

Blockchain Fundamentals Course

From hash functions to block chaining, mining, elliptic curves and signatures, UTXO transactions, distributed consensus, and the smart contract virtual machine. Over 30 lessons, you'll work up to building Bitcoin and Ethereum's internals with your own hands. You'll use nothing but Python's standard library — not a single external package.

Start from lesson 1 Unlock every course

Curriculum

The 30 lessons are split into 6 chapters. We recommend working through them in order starting from Chapter 1, but feel free to skip around to whatever interests you. * Short snippets that only use the standard library run right in your browser. For lessons that use the shared helper code (common/), run the sample code yourself with Python 3 (all output in this course was generated with Python 3.14.2).

Chapter 1 — Hashes and Blocks (lessons 1–6)

We start by pinning down exactly what problem an administrator-free ledger solves, then get hands-on with the hash functions that make it possible. You'll chain blocks together, bundle transactions with a Merkle tree, and finish by building proof-of-work and difficulty adjustment yourself.

1

The Three Problems Blockchain Solved

We start from the weaknesses of a ledger with an administrator. Decentralization, tamper resistance, and double-spend prevention — these three problems become the map for all 30 lessons.

Free
2

Three Properties of Hash Functions

You'll verify determinism, the avalanche effect, and one-wayness one by one with SHA-256 — the principle behind tamper detection, and the commitment scheme that foreshadows mining.

Free
3

Chaining Blocks Together

Chain blocks with prev_hash, and tampering with one spot breaks everything after it. You'll actually break it to see for yourself, then build the same 80-byte header Bitcoin uses.

Free
4

Merkle Trees and Inclusion Proofs

Pair up transactions two at a time until a single root remains. You'll see how sibling hashes alone can prove inclusion, and why just 20 of them suffice even for a million transactions.

🔒 Basic
5

Proof-of-Work and Mining

Mining is a lottery: keep drawing a nonce until you hit a winner. See how difficulty relates to the number of attempts, and why creating a block is hard but checking it is instant.

🔒 Basic
6

Difficulty Adjustment and Chain Verification

How the block interval stays constant even as computing power changes, and the three things a node checks for itself without trusting anyone. Chains are compared by work done, not by length.

🔒 Basic

Chapter 2 — Keys, Signatures, and Wallets (lessons 7–12)

This chapter brings "who" into the ledger. Starting from point addition on secp256k1, you'll build private and public keys, ECDSA signatures, and Bitcoin addresses by hand. You'll finish with 12-word mnemonics and HD wallets, growing an unlimited number of keys from a single seed.

7

Building secp256k1 from Point Addition

Add points on y² = x³ + 7. Scalar multiplication is fast to compute but hard to reverse — that discrete log problem becomes your key pair, as is.

🔒 Basic
8

A Private Key Is Just a Number, a Public Key Is Just a Point

A private key is an integer between 1 and N, and a public key is that integer times G. You'll see how to choose randomness when generating a key, down to the 33-byte compressed public key.

🔒 Basic
9

Proving Identity with ECDSA

Prove you signed something without ever revealing your private key. See how tampering gets rejected, how reusing nonce k leaks your private key directly, and RFC 6979's deterministic signatures.

🔒 Basic
10

Addresses and Base58Check

Shrink a public key to 20 bytes with hash160, then wrap it in Base58Check. You'll build a real address from private key 1 to check your work, down to how the checksum catches mistyped addresses.

🔒 Basic
11

How Mnemonics (BIP39) Are Made

Slice entropy into 11-bit chunks and map each to a word in a 2048-word dictionary. See what fraction of copying mistakes the checksum catches, and the official steps for deriving a seed with PBKDF2.

🔒 Basic
12

Growing Unlimited Keys with HD Wallets (BIP32)

Derive keys in a tree from a single seed. See why you get a different address each time, how an xpub lets you hand out addresses without sharing a private key, and hardened derivation's safety net.

🔒 Basic

Chapter 3 — Transactions and UTXOs (lessons 13–16)

You'll understand the UTXO model, where there's no such thing as a "balance" number, and build and sign transactions by hand. You'll actually try a double-spend — sending the same coin to two people — and see exactly where a node stops it, finishing with the UTXO selection and change calculation a wallet handles automatically.

13

The UTXO Model: There Is No Balance

Bitcoin has no number called a "balance." All that exists is a set of unspent outputs. Sending money means destroying old outputs and creating new ones.

🔒 Basic
14

Building and Signing a Transaction

Build a transaction out of vin and vout, then sign the hash of the whole transaction (the sighash) with the signature field blank. Confirm that changing the amount by one coin breaks the signature.

🔒 Basic
15

Where a Double-Spend Gets Stopped

Actually try the attack of sending the same coin to two people. You'll see it get caught at two stages — the mempool and block inclusion — and the four checks a node runs.

🔒 Basic
16

A Wallet's Job: Selecting UTXOs and Making Change

In a world with no balance number, a wallet quietly handles three jobs for you: coin selection, generating change, and detecting insufficient funds.

🔒 Basic

Chapter 4 — Network and Consensus (lessons 17–20)

You'll build the waiting room transactions sit in before they make it into a block, the fee market around it, and how new coins are created along with the halving schedule. From there you'll move into a world with multiple miners, seeing how forks get resolved and actually reproducing a 51% attack that exploits that very rule.

17

The Mempool and the Fee Market

Transactions pile up in a waiting room, and miners pack in the ones with the highest fee rate first. No one sets the price, yet fees still fluctuate — here's how.

🔒 Basic
18

Coin Issuance and the Halving

New coins are only ever created through an input-less coinbase transaction. The reward keeps halving, and that's exactly why total issuance converges to a fixed cap.

🔒 Basic
19

Forks and the Greatest-Work Rule

Simultaneous mining splitting the chain is normal. Whichever branch gets the next block becomes heavier and wins, leaving the loser orphaned — exactly why you wait for confirmations.

🔒 Basic
20

51% Attacks and Finality

Actually reproduce an attack that rolls back a payment you thought was final. You'll see how the greatest-work rule gets turned against itself, and why confirmations are the countermeasure.

🔒 Basic

Chapter 5 — How the EVM Works (lessons 21–25)

The stage shifts from Bitcoin to Ethereum, where you'll get a handle on the account model's way of seeing the world. From there you'll build the EVM yourself as a stack machine, understanding storage, gas, and calldata — the three pillars of smart contracts — down at the level of individual instructions.

21

UTXO vs. Account: Two Ways of Seeing the World

Ethereum keeps a balance number directly for each address. You'll see how a nonce prevents double-spending, and why this model was chosen for the sake of contracts.

🔒 Basic
22

Mini EVM: Building a Stack Machine

The EVM is a reverse-Polish-notation calculator. Turn (2+3)*4 into bytecode and trace how the stack moves with every single instruction — using the exact same opcode numbers as the real thing.

🔒 Basic
23

Storage and State

Use SLOAD and SSTORE to remember values across calls. You'll see how it differs from memory, and why writing to it costs roughly 7000 times more than writing to memory.

🔒 Basic
24

Gas and the Finiteness of Computation

Write a contract with an infinite loop and confirm it halts when it runs out of gas. See the atomicity that rolls back state on failure, and the difference between gas amount and gas price.

🔒 Basic
25

Calldata and payable

A call's arguments arrive as calldata and get read with CALLDATALOAD. You'll see CALLVALUE, used when a call sends money along with it, and what Solidity's payable really is.

🔒 Basic

Chapter 6 — Writing Contracts (lessons 26–30)

You'll build if and while out of nothing but JUMP, notify the outside world with events, and call contracts from other contracts. You'll finish by building an ERC-20 token and running every piece from all 30 lessons through a single chain from start to finish.

26

Building Control Structures Out of Nothing but JUMP

The EVM has no if, no while. Build branching and loops out of nothing but JUMP and JUMPI, and compute 1+2+...+100. You'll finish with JUMPDEST, the safety net that makes it all work.

🔒 Basic
27

Events and Logs

The record a contract leaves for the outside world. Cheaper than storage, unreadable from inside the contract, yet searchable outside by topic — the real mechanism behind a "deposit received" alert.

🔒 Basic
28

CALL and "Failure Rolls Everything Back"

Contracts become building blocks by calling other contracts. You'll see the atomicity that rolls back every write when the callee REVERTs, and the trap known as reentrancy.

🔒 Basic
29

Building an ERC-20 Token

A balance is nothing more than one entry in the contract storage's dictionary. You'll see how a mapping's slot is placed at sha3(address ‖ slot number), and the Transfer event.

🔒 Basic
30

Wiring It All Together into One Chain

Run every piece from all 30 lessons as one system. You'll get all the way to a separate node re-verifying the entire chain without trusting anyone, and see where to go from here.

🔒 Basic

Once you've finished all 30 lessons, head over to Python Fundamentals to strengthen your foundations, or Python Security Fundamentals to add an attack-and-defense perspective. A membership unlocks every course.