⚖️ 第03课：共识机制——如何让分布式节点达成一致

区块链基础 阶段一 ✅ 验证通过

📖 一、为什么需要共识？

1.1 拜占庭将军问题

分布式系统的核心难题：如何在可能存在叛徒（恶意节点）的情况下，让忠诚的将军们达成一致决策？

📖 二、工作量证明（PoW）

2.1 核心原理

PoW是Nakamoto共识的核心：通过消耗算力来竞争记账权，算力越大，获得记账权的概率越高。

2.2 难度与安全

💻 三、代码实战：PoW挖矿模拟

// pow-simulation.js — PoW挖矿模拟 ✅验证通过
const crypto = require('crypto');

class PoWMiner {
  constructor(difficulty = 4) {
    this.difficulty = difficulty;
    this.target = '0'.repeat(difficulty);
  }

  mine(blockData) {
    let nonce = 0;
    let hash = '';
    const startTime = Date.now();

    console.log(`⛏ 开始挖矿 (难度=${this.difficulty}, 目标前缀=${this.target})...`);

    while (true) {
      const input = blockData + nonce.toString();
      hash = crypto.createHash('sha256').update(input).digest('hex');

      if (hash.startsWith(this.target)) {
        const elapsed = Date.now() - startTime;
        console.log(`✅ 挖矿成功！`);
        console.log(`   Nonce: ${nonce}`);
        console.log(`   Hash: ${hash}`);
        console.log(`   耗时: ${elapsed}ms, 尝试: ${nonce + 1}次`);
        return { nonce, hash, elapsed, attempts: nonce + 1 };
      }
      nonce++;
    }
  }

  validate(blockData, nonce, expectedHash) {
    const input = blockData + nonce.toString();
    const hash = crypto.createHash('sha256').update(input).digest('hex');
    return hash === expectedHash && hash.startsWith(this.target);
  }
}

// ✅ 运行测试
console.log("=== PoW挖矿模拟 ===\n");

// 不同难度对比
[2, 3, 4].forEach(diff => {
  const miner = new PoWMiner(diff);
  const result = miner.mine("BlockData: Alice→Bob 5ETH");
  console.log(`   验证: ${miner.validate("BlockData: Alice→Bob 5ETH", result.nonce, result.hash) ? '✅' : '❌'}\n`);
});

// 最长链规则模拟
console.log("=== 最长链规则 ===");
const chainA = ["Block0", "Block1A", "Block2A", "Block3A"]; // 长度4
const chainB = ["Block0", "Block1B", "Block2B"]; // 长度3(分叉)
console.log(`Chain A (长度${chainA.length}) vs Chain B (长度${chainB.length})`);
console.log(`→ 选择最长链: Chain A ✅`);

📖 四、权益证明（PoS）

4.1 核心原理

PoS用"质押的代币"替代"算力"作为选择验证者的依据。持币越多、质押越久，被选为验证者的概率越高。

4.2 以太坊PoS架构

💻 五、代码实战：PoS验证者选择模拟

// pos-simulation.js — PoS验证者选择 ✅验证通过

class PoSValidator {
  constructor(name, stake) {
    this.name = name;
    this.stake = stake;
    this.isActive = true;
  }
}

class PoSBlockchain {
  constructor() {
    this.validators = [];
    this.totalStake = 0;
    this.blocks = [];
  }

  addValidator(name, stake) {
    const v = new PoSValidator(name, stake);
    this.validators.push(v);
    this.totalStake += stake;
    console.log(`➕ 验证者 ${name} 质押 ${stake} ETH`);
  }

  // 加权随机选择验证者
  selectProposer(seed) {
    let rand = this._pseudoRandom(seed) % this.totalStake;
    let cumulative = 0;
    for (const v of this.validators) {
      if (!v.isActive) continue;
      cumulative += v.stake;
      if (rand < cumulative) return v;
    }
  }

  _pseudoRandom(seed) {
    let hash = 0;
    for (let i = 0; i < seed.length; i++) {
      hash = ((hash << 5) - hash) + seed.charCodeAt(i);
      hash |= 0;
    }
    return Math.abs(hash);
  }

  // Slashing惩罚
  slashValidator(name, reason) {
    const v = this.validators.find(v => v.name === name);
    if (v) {
      const penalty = v.stake; // 全部罚没
      this.totalStake -= penalty;
      v.stake = 0;
      v.isActive = false;
      console.log(`⚠️ Slashing: ${name} 被罚没 ${penalty} ETH (原因: ${reason})`);
    }
  }

  simulateEpoch(epochNum) {
    console.log(`\n=== Epoch ${epochNum} ===`);
    for (let slot = 0; slot < 4; slot++) {
      const proposer = this.selectProposer(`epoch${epochNum}slot${slot}`);
      console.log(`  Slot ${slot}: ${proposer.name} (质押${proposer.stake}ETH) 提议区块`);
    }
  }

  showStakeDistribution() {
    console.log("\n📊 质押分布:");
    this.validators.forEach(v => {
      const pct = this.totalStake > 0
        ? ((v.stake / this.totalStake) * 100).toFixed(1) : 0;
      const bar = '█'.repeat(Math.round(pct / 5));
      console.log(`  ${v.name}: ${v.stake}ETH (${pct}%) ${bar}`);
    });
  }
}

// ✅ 运行测试
const pos = new PoSBlockchain();
pos.addValidator("Alice", 100);
pos.addValidator("Bob", 50);
pos.addValidator("Carol", 30);
pos.addValidator("Dave", 20);
pos.showStakeDistribution();
pos.simulateEpoch(1);
pos.slashValidator("Dave", "双签攻击");
pos.showStakeDistribution();
pos.simulateEpoch(2);

📖 六、其他共识机制

6.1 DPoS（委托权益证明）

6.2 PBFT（实用拜占庭容错）

6.3 共识机制对比总览

📖 七、The Merge：以太坊的历史性时刻

📝 八、练习题

🏆 成就解锁