AI.Cruz - Learn AI Through Interactive Visualizations

BLOCKCHAIN

What is a Blockchain?

A distributed ledger where each block contains data, a hash, and the previous block's hash — making the chain tamper-evident by design.

1The Distributed Ledger Problem

In a traditional database, one entity controls the records. If that entity is compromised, corrupted, or simply dishonest, the data changes without anyone knowing. Blockchain solves this with distributed consensus: the same ledger is held by thousands of participants, and no single party can alter history without rewriting every subsequent entry and outpacing the entire network.

A blockchain is a linked list of blocks where each block cryptographically commits to its predecessor. Changing any past block invalidates every block that follows, because the hashes no longer match. An attacker would have to redo the cryptographic work for every subsequent block — a task that becomes computationally infeasible on large networks.

✓ What blockchain adds

✓ Immutable audit trail — no record can be silently erased
✓ Decentralisation — no single point of failure or control
✓ Transparency — anyone can audit the entire history
✓ Censorship resistance — transactions cannot be blocked

✗ What it costs

✗ Low throughput — Bitcoin does ~7 TPS vs Visa's ~24,000
✗ Energy cost (PoW) — Bitcoin uses ~150 TWh/year
✗ Irreversibility — a mistake cannot be undone
✗ Storage growth — every node keeps the full history

2Anatomy of a Block

Every block in the chain contains four essential fields: an index, a timestamp, the data (e.g. a list of transactions), and a hash that uniquely fingerprints all of this content plus the previous block's hash. That last dependency is what chains the blocks together.

Index & Timestamp
Position in the chain plus creation time. These anchor the block in the timeline.

Data
Payload — usually a Merkle tree of transactions. The hash commits to every byte of this field.

Previous Hash
The fingerprint of the last block. This field creates the chain: change one block, break all successors.

3Immutability via Cryptographic Hashing

SHA-256 maps any input to a 256-bit fingerprint. Two properties make it perfect for blockchains: determinism (same input → same hash, always) and avalanche effect (change one bit of input → ~50% of output bits flip). This means you cannot quietly edit a block's data — the hash changes, which cascades through every subsequent block.

To tamper with block #1, an attacker must: (1) recompute block #1's hash with new data, (2) update block #2's prev_hash and recompute block #2's hash, (3) continue through every subsequent block, and (4) do all of this faster than the honest network adds new blocks — an impossibility once the chain is long.

2²⁵⁶ outputs
SHA-256's output space. Finding two different inputs that hash to the same value is computationally infeasible.

6 confirmations
After 6 blocks are built on top of yours, reverting it requires controlling 51% of network hash rate — prohibitively expensive.

51% attack
An attacker with majority hash power could rewrite recent history — the fundamental security assumption blockchain relies on.

4Nodes, Peers, and Consensus

A blockchain is run by a peer-to-peer network of nodes. Each node stores a full copy of the chain. When a new block is proposed, nodes verify it independently and add it only if it satisfies the consensus rules. No central coordinator exists — agreement emerges from the protocol itself.

✓ Full nodes do

✓ Store the complete chain from genesis
✓ Validate every transaction independently
✓ Relay valid blocks and transactions to peers
✓ Enforce consensus rules — reject invalid blocks

✗ Common misconceptions

✗ "Blockchain = Bitcoin" — blockchain is the data structure; Bitcoin is one application
✗ "Decentralised = anonymous" — Bitcoin is pseudonymous, not anonymous
✗ "Immutable = perfect" — bugs in smart contracts are permanent too
✗ "All blockchains are permissionless" — enterprise blockchains (Hyperledger) are permissioned

Merkle Tree
Transactions in a block are hashed in pairs up to a single Merkle root — efficient verification without downloading all transactions.

Genesis Block
Block #0. Hard-coded into every Bitcoin client. Its prev_hash is all zeros — there is no predecessor.

Fork
When two valid blocks compete for the same position. Resolved by the longest-chain rule: nodes adopt whichever branch accumulates more work.

Build a mini blockchain in Python

import hashlib, time, json

class Block:
    def __init__(self, index, data, prev_hash=""):
        self.index = index
        self.timestamp = time.strftime("%Y-%m-%d %H:%M:%S")
        self.data = data
        self.prev_hash = prev_hash
        self.hash = self.compute_hash()

    def compute_hash(self):
        content = json.dumps({
            "index": self.index,
            "timestamp": self.timestamp,
            "data": self.data,
            "prev_hash": self.prev_hash,
        }, sort_keys=True)
        return hashlib.sha256(content.encode()).hexdigest()

class Blockchain:
    def __init__(self):
        genesis = Block(0, "Genesis block", "0" * 64)
        self.chain = [genesis]

    def add_block(self, data):
        prev = self.chain[-1]
        block = Block(len(self.chain), data, prev.hash)
        self.chain.append(block)

    def is_valid(self):
        for i in range(1, len(self.chain)):
            cur, prev = self.chain[i], self.chain[i - 1]
            if cur.hash != cur.compute_hash():
                return False, f"Block {i}: hash mismatch"
            if cur.prev_hash != prev.hash:
                return False, f"Block {i}: broken link"
        return True, "Chain is valid"

bc = Blockchain()
bc.add_block("Alice -> Bob: 1 BTC")
bc.add_block("Bob -> Carol: 0.5 BTC")
bc.add_block("Carol -> Dave: 0.2 BTC")

print("--- Chain ---")
for b in bc.chain:
    print(f"[{b.index}] {b.hash[:12]}...  data: {b.data}")

valid, msg = bc.is_valid()
print("\nValidity:", msg)

# Tamper with block 1
print("\n--- Tampering block 1 ---")
bc.chain[1].data = "Alice -> Bob: 100 BTC"
valid, msg = bc.is_valid()
print("Validity after tamper:", msg)