Blockchain: Wallets, Merkle Trees, Nonce & Random

Section 01

Wallet Address Generation — From Randomness To An Address

📖 Real World Analogy

The Unbreakable Padlock You Build Yourself

Imagine you roll a die 256 times to create a truly random number so enormous that no one on Earth could ever guess it. That number is your private key. From it, a special one-way machine stamps out a matching public key, and from that, a short address — like a mailbox number anyone can drop coins into, but only your secret number can open.

The magic is that the machine only runs forward. Given the mailbox number, no one can ever work backward to your secret. This is why a Bitcoin address can be printed on a poster in Times Square and still be perfectly safe — the address reveals nothing about the key that controls it.

A blockchain wallet is not a place that stores coins. Coins live on the chain. A wallet simply stores your private key and derives everything else from it. Understanding how an address is generated — step by step, from raw randomness to a shareable string — is the foundation of self-custody.

Animated Diagram — The Full Address Generation Pipeline

Six deterministic steps transform 256 random bits into a shareable Bitcoin address. Every step flows one-way — you can never run it backward.

💳 Step-By-Step — Generating A Real Bitcoin Address

Step 1

Generate a cryptographically random 256-bit number. This is the private key. There are 2²⁵⁶ possibilities — more than atoms in the observable universe.

Step 2

Apply elliptic curve multiplication (secp256k1) to derive the public key. One-way: private → public is trivial, public → private is impossible.

Step 3

Hash the public key with SHA-256, then hash that result with RIPEMD-160 to get a compact 160-bit fingerprint.

Step 4

Add a version byte (network prefix) and a 4-byte checksum (double SHA-256 of the payload) to catch typos.

Step 5

Encode everything in Base58Check — an alphabet that removes confusing characters (no 0, O, I, l). The result is your address.

✅

The Checksum — Why You Can't Send To A Typo

Those last 4 bytes are a checksum. If you mistype even one character of an address, the checksum won't match and your wallet refuses to send. This is why you almost never lose coins to a simple typo — the math catches it before broadcast. (You can still lose coins by sending to a valid-but-wrong address, so always double-check.)

Address Type	Prefix	Encoding	Example Start
Bitcoin Legacy (P2PKH)	1	Base58Check	1A1zP1...
Bitcoin SegWit (P2SH)	3	Base58Check	3J98t1...
Bitcoin Native SegWit	bc1	Bech32	bc1qw5...
Ethereum	0x	Keccak-256 (last 20 bytes)	0x71C7...

Section 02

Merkle Trees — Verifying Millions With A Few Hashes

A Merkle tree (named after Ralph Merkle, 1979) is a way to summarize a huge set of data into a single hash, while still being able to prove any individual item belongs to the set — without downloading the whole set. It is the data structure that lets a phone verify a Bitcoin transaction without storing the entire 500+ GB blockchain.

Animated Diagram — A Merkle Tree Of 4 Transactions

Transactions are hashed in pairs, then those hashes are paired and hashed again, repeatedly, until a single root remains. Four transactions collapse into one root hash.

🌲

How A Merkle Tree Is Built — Bottom Up

Start with your data at the leaves. Hash each item. Then pair up adjacent hashes and hash each pair together, halving the count each round. Keep going until only one hash remains at the top. That final hash is the Merkle root — a single fingerprint representing every leaf. If any leaf changes, the root changes.

Section 03

Merkle Root — One Hash To Rule Them All

The Merkle root is the single hash at the top of the tree. In Bitcoin, it lives in the block header — a tiny 80-byte structure. Even though a block might contain 3,000 transactions, the header only needs to store this one 32-byte root. Change any transaction, and the root instantly changes, breaking the block's hash.

Animated Diagram — Merkle Proof (Verify Tx C Without The Whole Tree)

To prove Tx C is in a block of thousands, you only need Tx C plus 2 sibling hashes — not the whole tree. This is a "Merkle proof," and it scales logarithmically.

📱

Real Example — SPV Wallets On Your Phone

Your phone's Bitcoin wallet cannot store 500+ GB. Instead it uses Simplified Payment Verification (SPV): it downloads only the 80-byte block headers and requests a Merkle proof when it needs to confirm a payment. To verify a transaction in a block of 3,000, it needs only about 12 hashes (log₂ of 3000), not all 3,000. Merkle trees are why lightweight wallets exist at all.

Transactions In Block	Full Download	Merkle Proof Hashes
4	All 4	2
1,024	All 1,024	10
1,048,576	All ~1M	20

Section 04

The Nonce — The Number Miners Hunt For

A nonce ("number used once") is a value miners repeatedly change while searching for a valid block hash. It is the only freely-adjustable field in the block header. Miners keep incrementing the nonce, re-hashing the header each time, until the resulting hash falls below the network's difficulty target — a hash with enough leading zeros.

Animated Diagram — The Nonce Search (Proof-Of-Work)

The miner tries nonce after nonce, re-hashing each time. Most hashes are "too big." Only when the hash starts with enough zeros (below the target) is the block valid.

⛏️ What The Nonce Actually Does

Purpose

The nonce is the "dial" a miner spins. Everything else in the header is fixed for a given block, so the nonce is the only way to get a different hash.

Range

A 32-bit nonce has only ~4.3 billion values. Modern miners exhaust it in under a second, so they also vary the timestamp and coinbase "extra nonce" to keep searching.

Difficulty

The network adjusts the target every 2,016 blocks (~2 weeks) so a block is found every ~10 minutes on average, regardless of how much mining power joins.

Winner

The first miner to find a valid nonce broadcasts the block and claims the reward. Everyone else stops and starts on the next block.

💡

Nonce In Ethereum Means Something Different

Watch out for terminology overload. In mining, the nonce is the number miners hunt for. But in an Ethereum account, "nonce" means the count of transactions that account has sent — used to prevent replay attacks and enforce transaction order. Same word, completely different job. Context tells you which nonce is meant.

Section 05

Random Number Generation — Where Security Begins

Every private key starts as a random number. If that randomness is weak or predictable, an attacker can guess your key and steal everything. Random number generation is the silent, invisible foundation of all blockchain security — and one of the most common places where real-world wallets have been catastrophically broken.

Animated Diagram — CSPRNG: Gathering Entropy

A secure generator gathers unpredictable "entropy" from many physical sources, mixes it in a pool, and feeds a CSPRNG that outputs your key. More entropy sources = harder to predict.

🎲

TRNG

True Random

Draws from real physical noise — thermal, electrical, quantum. Unpredictable by nature but slow. Hardware wallets include dedicated TRNG chips.

🔢

PRNG

Pseudo Random

A deterministic algorithm that looks random from a seed. Fast, but never use a plain PRNG for keys — if the seed leaks, every key is predictable.

🔐

CSPRNG

Cryptographically Secure

A PRNG hardened so that even knowing past outputs, you cannot predict the next. This is what wallets must use. Examples: /dev/urandom, Web Crypto.

⚠️

Real Disaster — The Android Bitcoin Wallet Bug (2013)

In August 2013, a flaw in Android's SecureRandom produced predictable "random" numbers. Bitcoin wallets generated on affected devices created signatures that leaked their private keys, and thieves swept the funds. The lesson is permanent: weak randomness is not a theoretical worry — it has directly cost people real money. Always rely on audited CSPRNGs, never home-grown randomness.

🎲

Why Dice And Coins Still Work

Paranoid about software randomness? You can generate a Bitcoin key by rolling a casino die 99 times or flipping a coin 256 times, recording each result as a bit. Physical randomness is genuinely unpredictable and completely offline. Many cold-storage setups do exactly this to remove any trust in a computer's RNG.

Section 06

How It All Connects — One Block, Every Concept

Random Number Creates The Key

A CSPRNG gathers entropy and outputs a 256-bit private key. This single random number is the root of a user's entire wallet.

Key Derives The Address

ECC + SHA-256 + RIPEMD-160 + Base58Check transform the key into a shareable wallet address where funds are received.

Transactions Fill A Block

Users sign transactions and broadcast them. Miners collect thousands into a candidate block.

Merkle Tree Summarizes Them

All transactions are hashed pairwise up to a single Merkle root, stored compactly in the 80-byte block header.

Nonce Seals The Block

The miner hunts for a nonce that makes the header hash meet the target. When found, the block is sealed and added to the chain forever.

🏆

Five Concepts, One Living System

Random generation births the key, address generation makes it spendable, the Merkle tree and Merkle root compress the transactions, and the nonce locks the block with proof-of-work. Every Bitcoin block ever mined is the product of these five ideas working in concert.

Section 07

Golden Rules — Keys, Trees & Nonces

🔑 Non-Negotiable Truths

An address is derived from a key, never the reverse. Private → Public → Address is one-way. Publishing your address reveals nothing about your private key.

The checksum protects you from typos. A mistyped address fails the checksum and your wallet refuses to send — but a valid-but-wrong address will still send, so always verify.

A Merkle tree turns millions of items into one root hash. Change any leaf and the root changes — this is what makes a block's contents tamper-evident.

Merkle proofs scale logarithmically. Verifying one transaction in a million needs only ~20 hashes, not a million. This is why lightweight (SPV) wallets can run on a phone.

The nonce is the miner's only free dial. Everything else in the header is fixed, so miners spin the nonce (and extra-nonce) billions of times per second hunting for a valid hash.

"Nonce" means two different things. A mining nonce secures proof-of-work; an Ethereum account nonce counts transactions. Always check the context.

Weak randomness is a real, money-losing bug. Only ever use a CSPRNG for keys. Plain PRNGs and predictable seeds have drained wallets in the real world.

Your whole wallet rests on one random number. If that 256-bit value is truly unpredictable, your funds are safe; if it is guessable, nothing else in the stack can save you.