Introduction

“Blockchain” has been one of the most hyped-and misunderstood-technologies of the past decade. It’s been called everything from “the next internet” to “a solution looking for a problem.”

The truth lies somewhere in between. Blockchain is a real technology solving real problems-but understanding what problems it solves (and which it doesn’t) requires going beyond the hype to the actual mechanics.

By the end of this lesson, you’ll understand:

• What a blockchain actually is (hint: it’s simpler than you think)
• The cryptographic building blocks that make it secure
• How consensus works without a central authority
• The fundamental trade-offs in blockchain design
• When blockchain makes sense (and when it doesn’t)

Let’s start from first principles.

---

What Is a Blockchain?

At its core, a blockchain is a linked list of blocks, where each block is cryptographically secured and distributed across many computers.

Let’s break that down:

The Chain of Blocks

Each block contains:

1. Data (transactions, records, whatever we’re storing)
2. A hash of the previous block (the cryptographic link)
3. A timestamp
4. A nonce (for proof-of-work systems)

The critical insight: Each block contains a hash of the previous block. This creates an immutable chain-if you change any block, all subsequent hashes become invalid.

Why “Blockchain”?

Traditional Database	Blockchain
Centralized	Distributed across many nodes
Mutable (can edit/delete)	Append-only (history preserved)
One authority	Consensus among participants
Trust the operator	Trust the cryptography

---

The Cryptographic Foundation

Blockchain security rests on two cryptographic primitives: hash functions and digital signatures.

Hash Functions

A hash function takes any input and produces a fixed-size output (the “hash” or “digest”):

import hashlib

message = "Hello, blockchain!"
hash_result = hashlib.sha256(message.encode()).hexdigest()
print(hash_result)
# Output: 7f83b1657ff1fc53b92dc18148a1d65dfc2d4b1fa3d677284addd200126d9069

Properties of cryptographic hashes:

Property	Meaning
Deterministic	Same input → same output, always
Fixed size	Any input → 256-bit output (for SHA-256)
One-way	Can’t reverse the hash to get the input
Collision-resistant	Infeasible to find two inputs with same hash
Avalanche effect	Tiny input change → completely different hash

The avalanche effect is crucial:

print(hashlib.sha256(b"hello").hexdigest()[:16])  # 2cf24dba...
print(hashlib.sha256(b"hellp").hexdigest()[:16])  # d764b3a9... (completely different!)

Digital Signatures

Digital signatures prove that a message came from a specific sender and hasn’t been tampered with.

How they work:

1. Key generation: Create a private key (secret) and public key (shared)
2. Signing: Use private key to sign a message
3. Verification: Anyone with the public key can verify the signature

from cryptography.hazmat.primitives import hashes
from cryptography.hazmat.primitives.asymmetric import ec

# Generate keys
private_key = ec.generate_private_key(ec.SECP256K1())
public_key = private_key.public_key()

# Sign a message
message = b"Send 10 BTC to Alice"
signature = private_key.sign(message, ec.ECDSA(hashes.SHA256()))

# Verify (anyone can do this with the public key)
public_key.verify(signature, message, ec.ECDSA(hashes.SHA256()))
# No exception = signature is valid

Why These Matter for Blockchain

• Hashes link blocks together-changing any block breaks the chain
• Signatures prove transaction authenticity without revealing private keys
• Together, they create trustless verification-you don’t need to trust anyone, just verify the math

---

How Blocks Are Created

Let’s trace the lifecycle of a block:

Step 1: Transactions Are Created

Users sign transactions with their private keys:

{
  "from": "0xAlice...",
  "to": "0xBob...",
  "value": "1.5 ETH",
  "signature": "0x7f83b..."
}

Step 2: Transactions Enter the Mempool

Unconfirmed transactions wait in the mempool (memory pool):

Step 3: Block Producer Creates a Block

A block producer (miner in PoW, validator in PoS) selects transactions and creates a block:

Block #12345
├── Previous Hash: 0x9a8b7c...
├── Timestamp: 2025-12-17 12:00:00
├── Transactions:
│   ├── TX1: Alice → Bob, 1.5 ETH
│   ├── TX2: Carol → Dave, 0.3 ETH
│   └── TX3: Eve → Frank, 2.0 ETH
├── State Root: 0x3d4e5f...
└── Block Hash: 0x1f2e3d... (hash of all above)

Step 4: Block Is Broadcast and Verified

Other nodes:

1. Receive the block
2. Verify all transaction signatures
3. Verify the hash chain
4. Verify consensus rules were followed
5. Add the block to their chain

---

Consensus: Agreement Without Authority

The hardest problem blockchain solves is consensus-how do thousands of computers agree on the truth without a central coordinator?

The Byzantine Generals Problem

Imagine generals surrounding a city. They must all attack OR all retreat. But:

• They can only communicate by messenger
• Some generals might be traitors (sending wrong signals)
• Messages might be delayed or lost

How do they coordinate?

Blockchain solves this for digital systems.

Proof of Work (PoW)

Bitcoin’s solution: make creating a valid block computationally expensive.

How it works:

1. To create a valid block, find a number (nonce) such that: hash(block + nonce) < target_difficulty
2. This requires ~10^18 guesses (adjusted to take ~10 minutes)
3. Once found, verification is instant (just check one hash)

The magic: Creating a block is hard, verifying is easy. An attacker would need more computing power than the entire network.

# Simplified proof-of-work
def mine_block(transactions, previous_hash, difficulty):
    nonce = 0
    while True:
        block_data = f"{transactions}{previous_hash}{nonce}"
        block_hash = hashlib.sha256(block_data.encode()).hexdigest()
        if block_hash.startswith("0" * difficulty):  # e.g., "0000..."
            return nonce, block_hash
        nonce += 1

Pros:

• Simple, battle-tested
• Sybil-resistant (can’t fake computing power)

Cons:

• Enormous energy consumption
• Slow finality (~60 minutes for Bitcoin)

Proof of Stake (PoS)

Ethereum’s solution: instead of proving work, stake assets as collateral.

How it works:

1. Validators deposit ETH as stake
2. Algorithm randomly selects a validator to propose each block
3. Other validators attest (vote) on validity
4. Misbehavior = stake is slashed (confiscated)

The magic: Economic security-attack requires acquiring 33-51% of staked value.

Pros:

• 99.9% less energy than PoW
• Faster finality

Cons:

• More complex
• “Rich get richer” concerns

Comparison

Aspect	Proof of Work	Proof of Stake
Security	Computing power	Staked capital
Energy	Very high	Very low
Hardware	Specialized (ASICs)	Standard servers
Finality	Probabilistic (slow)	Deterministic (fast)
Barrier to entry	Buy hardware	Buy tokens

---

State and the World Computer

Simpler blockchains (Bitcoin) just record transactions. More advanced ones (Ethereum) maintain state.

The State Machine Model

Ethereum is a state machine:

State_n + Transaction → State_n+1

State includes:

• Account balances
• Smart contract code
• Smart contract storage

Smart Contracts

Smart contracts are programs stored on the blockchain:

// Simple Solidity contract
contract SimpleStorage {
    uint256 public value;
    
    function set(uint256 newValue) public {
        value = newValue;
    }
}

When you call set(42):

1. Transaction is signed and broadcast
2. Included in a block
3. Every node executes the code
4. State is updated on all nodes
5. Result is permanent and verifiable

---

The Trade-offs: Blockchain Isn’t Free

Blockchain involves fundamental trade-offs. Understanding them prevents misuse.

The Blockchain Trilemma

You can optimize for two of three:

       Decentralization
           /\
          /  \
         /    \
  Security - - Scalability

Priority	What You Sacrifice
Decentralization + Security	Scalability (slow, expensive)
Security + Scalability	Decentralization (fewer validators)
Scalability + Decentralization	Security (easier attacks)

When Blockchain Makes Sense

✅ Use blockchain when:

• Multiple parties need to agree without trusting each other
• Immutability is critical (audit trails)
• Censorship resistance matters
• You need programmable, trustless execution

❌ Don’t use blockchain when:

• A single trusted party can maintain the database
• Speed is critical (blockchain is slow)
• Data privacy is paramount (blockchain is public)
• You don’t need consensus or immutability

---

Practice Exercises

Exercise 1: Verify a Hash Chain (Beginner)

Given these blocks, verify the chain is valid:

Block 1: Data="Genesis", Hash=sha256("Genesis|0")
Block 2: Data="Alice→Bob", Hash=sha256("Alice→Bob|" + Hash1)
Block 3: Data="Bob→Carol", Hash=sha256("Bob→Carol|" + Hash2)

Questions:

1. Calculate Hash1, Hash2, Hash3
2. If Block 2’s data changed to “Alice→Eve”, what happens to Hash2 and Hash3?

Exercise 2: Simple PoW (Intermediate)

Write a Python function that mines a block:

• Find a nonce where sha256(data + nonce) starts with “00”
• Count how many attempts it took

def simple_pow(data, difficulty=2):
    # Your code here
    pass

Exercise 3: Research (Advanced)

Compare three blockchains:

1. Bitcoin (PoW, UTXO model)
2. Ethereum (PoS, Account model)
3. Solana (PoS + PoH, high throughput)

Create a table comparing: TPS, finality time, consensus, and trade-offs.

---

Knowledge Check

1. What makes blocks in a blockchain “chained” together?

2. Why is proof-of-work secure against attacks?

3. What’s the difference between PoW and PoS?

4. Can you delete data from a blockchain? Why or why not?

5. Your company wants to use blockchain for an internal employee database. Is this a good idea?

Click to reveal answers

1. Each block contains the cryptographic hash of the previous block. Changing any block invalidates all subsequent hashes, making tampering evident.

2. Creating valid blocks requires immense computing power. To rewrite history, an attacker needs more power than the honest network combined (51% attack). Economically infeasible for major chains.

3. PoW proves work was done (computing power spent). PoS proves stake is risked (assets locked as collateral). Same goal-Sybil resistance-different mechanisms.

4. No. The chain is append-only. You can add a “correction” transaction, but the original data remains visible in history. This is a feature for auditability, not a bug.

5. No. A single trusted party (the company) exists. A normal database is faster, cheaper, and more private. Blockchain adds complexity without benefit here.

---

Summary

Concept	Key Point
Blockchain	Distributed, immutable ledger using cryptographic hashes
Hash Functions	One-way functions that link blocks together
Digital Signatures	Prove transaction authenticity
Consensus	Agreement mechanism (PoW, PoS)
Trade-offs	Security, decentralization, scalability-pick two

Key takeaways:

1. Blockchain = chain of hashed blocks + consensus + distribution
2. Immutability comes from cryptographic linking
3. Consensus removes the need for central authority
4. Not every problem needs a blockchain

---

What’s Next?

🎯 Continue learning:

• Blockchain Transactions - The lifecycle of a transaction
• Consensus Mechanisms - Deep dive into PoW and PoS

🔬 Expert level: See The 100ms Tax for MEV and block building.

---

You now understand how blockchains actually work. Not the hype, the engineering. ⛓️