Decentralisation & Proof of Work

The Problem: One Computer Isn't Enough

In Module 3, you built a complete cryptocurrency — wallets, signed transactions, blocks, and chain validation. But all of it ran on a single machine. If that computer crashes, gets hacked, or its owner decides to cheat, the entire system dies. Centralisation is the bottleneck.

This is the Byzantine Generals' Problem applied to money. Some generals (nodes) may be traitors (malicious). The loyal generals must still reach agreement. Satoshi's answer: make lying more expensive than cooperating.

Peer-to-Peer Networks

In a traditional client-server model, you connect to a central server (think Google, Netflix). In a peer-to-peer (P2P) network, every participant is both a client and a server. There's no boss, no headquarters, no "main" computer.

The Gossip Protocol

How does a new transaction or block reach every node on the planet in seconds? Through gossip — the same way rumours spread in a school. A node hears something new, checks it, and tells all its friends. They tell their friends. Within seconds, the entire network knows.

Nakamoto Consensus

Every node has a copy of the blockchain. If two miners find valid blocks at nearly the same time, which block "wins"? Bitcoin's answer is elegantly simple — and it changed computer science forever.

Difficulty Adjustment

Bitcoin targets one block every ~10 minutes. But hashpower fluctuates as miners join and leave. How does the network adapt?

Forks & Resolution

Two miners in different parts of the world find valid blocks at nearly the same moment. Some nodes see Block A first, others see Block B. The chain has temporarily forked. This is normal and happens regularly.

Types of Forks

Attack Vectors

A decentralised network must withstand adversaries. Understanding attack vectors isn't just academic — it reveals why each design decision exists.

Other Attack Vectors

Code: Simulating a P2P Network

Let's build a simplified peer-to-peer network where multiple nodes share blocks and resolve forks. We'll use our Blockchain class from Module 3 and add networking logic on top.

Node.js: A Simple Node

class P2PNode {
  constructor(name, difficulty = 2) {
    this.name       = name;
    this.blockchain = new Blockchain(difficulty);
    this.peers      = [];      // connected nodes
    this.mempool    = [];      // pending transactions
  }

  // Connect two nodes (bidirectional)
  connect(peer) {
    if (!this.peers.includes(peer)) {
      this.peers.push(peer);
      peer.peers.push(this);
    }
  }

  // Gossip: broadcast a transaction to all peers
  broadcastTransaction(tx) {
    for (const peer of this.peers) {
      if (!peer.mempool.find(t => t === tx)) {
        peer.receiveTx(tx);
      }
    }
  }

  // Receive a transaction from a peer
  receiveTx(tx) {
    if (tx.isValid() && !this.mempool.includes(tx)) {
      this.mempool.push(tx);
      this.broadcastTransaction(tx); // gossip forward
    }
  }

  // Mine pending transactions and broadcast the new block
  mine(minerAddress) {
    this.blockchain.minePendingTransactions(minerAddress);
    const latest = this.blockchain.getLatestBlock();
    this.mempool = [];
    this.broadcastBlock(latest);
  }

  // Send new block to peers (they decide whether to accept)
  broadcastBlock(block) {
    for (const peer of this.peers) {
      peer.receiveBlock(block, this);
    }
  }

  // Longest chain rule: accept block only if it extends a valid longer chain
  receiveBlock(block, sender) {
    if (sender.blockchain.chain.length > this.blockchain.chain.length) {
      if (sender.blockchain.isValid()) {
        console.log(`${this.name}: Adopting longer chain from ${sender.name}`);
        this.blockchain.chain = [...sender.blockchain.chain];
      }
    }
  }
}

Node.js: Longest Chain Resolution

// Create three nodes
const tokyo  = new P2PNode('Tokyo');
const london = new P2PNode('London');
const nyc    = new P2PNode('NYC');

// Connect them in a triangle
tokyo.connect(london);
london.connect(nyc);
nyc.connect(tokyo);

// Tokyo mines two blocks
tokyo.mine('tokyo-address');
tokyo.mine('tokyo-address');

// London and NYC adopted Tokyo's longer chain
console.log('Tokyo blocks:',  tokyo.blockchain.chain.length);
console.log('London blocks:', london.blockchain.chain.length);
console.log('NYC blocks:',    nyc.blockchain.chain.length);
// All should be 3 (genesis + 2 mined)

Exercise: Network Simulation

Build a multi-node network and experiment with consensus, forks, and attacks. Work through the exercises in order — each one builds on the last.