区块链原理 / 系统课时

编写 PoW 累计工作量选链器

编写 PoW 累计工作量选链器

当区块链出现竞争分支时,简单选择区块数量最多的链可能得到错误结果。本课使用 Python 实现一个简化的 PoW 选链器,完成哈希目标验证、父块关联、累计工作量计算和最佳链选择,并通过竞争分支及篡改区块验证选链行为。

学习目标

  • 理解哈希目标、单块工作量与累计工作量之间的关系。
  • 实现区块有效性检查、父块查找和累计工作量选链逻辑。
  • 构造长度不同的竞争分支,验证链重组及异常区块拒绝行为。

将哈希目标转换为工作量

PoW 要求区块头哈希的整数值不大于目标值 target。目标越小,随机哈希落入有效区间的概率越低,找到有效区块通常需要更多尝试。

对于均匀分布的 256 位哈希,使用下面的公式计算单块工作量:

W(T)=⌊2256T+1⌋W(T)=\left\lfloor\frac{2^{256}}{T+1}\right\rfloor

其中,TT 是目标值,W(T)W(T) 是该区块对应的整数工作量。教学程序采用两个固定目标:

参数 目标值 单块工作量 单次哈希成功概率
EASY 2254−12^{254}-1 4 1/41/4
HARD 2253−12^{253}-1 8 1/81/8

这些数值是教学配置,不代表真实区块链的难度参数。程序使用单次 SHA-256 计算简化区块头哈希,不实现比特币的 80 字节区块头及双 SHA-256。

对于任意非创世区块,累计工作量等于父块累计工作量加上当前区块工作量:

CW(B)=CW(parent(B))+W(target(B))CW(B)=CW(parent(B))+W(target(B))

创世块没有父块,其累计工作量就是自身工作量。比较竞争链时,应比较候选链头的累计工作量,而不是区块高度。

实现区块验证与选链器

使用 Python 3.10 或更新版本,无需安装第三方依赖。创建 pow_selector.py,将下面的完整程序保存到文件中。

区块结构包含父块哈希、高度、目标值、Nonce 和区块哈希。Selector 使用两个字典分别保存已验证区块及累计工作量,通过父块哈希建立分支关系。

python
from dataclasses import dataclass, replace
from hashlib import sha256

ZERO = '0' * 64
EASY = (1 << 254) - 1
HARD = (1 << 253) - 1


@dataclass(frozen=True)
class Block:
    parent: str
    height: int
    target: int
    nonce: int
    digest: str


def block_hash(parent, height, target, nonce):
    # 使用确定性的简化区块头编码,便于重复实验
    header = f'{parent}|{height}|{target}|{nonce}'.encode('ascii')
    return sha256(header).hexdigest()


def mine(parent, height, target):
    for nonce in range(100_000):
        digest = block_hash(parent, height, target, nonce)
        if int(digest, 16) <= target:
            return Block(parent, height, target, nonce, digest)
    raise RuntimeError('未在搜索范围内找到有效 nonce')


def proof(target):
    # 目标越小,对应的工作量越大
    return (1 << 256) // (target + 1)


class Selector:
    def __init__(self):
        self.blocks = {}
        self.total = {}

    def add(self, block):
        if block.target not in (EASY, HARD):
            raise ValueError('不允许的目标值')
        if block.digest != block_hash(
            block.parent, block.height, block.target, block.nonce
        ):
            raise ValueError('哈希不匹配')
        if int(block.digest, 16) > block.target:
            raise ValueError('未达到目标值')
        if block.digest in self.blocks:
            raise ValueError('重复区块')

        if block.height == 0:
            if block.parent != ZERO or self.blocks:
                raise ValueError('非法创世块')
            parent_work = 0
        else:
            # 必须从已经验证的父块继承累计工作量
            parent = self.blocks.get(block.parent)
            if parent is None:
                raise ValueError('父块不存在')
            if block.height != parent.height + 1:
                raise ValueError('高度不连续')
            parent_work = self.total[block.parent]

        self.blocks[block.digest] = block
        self.total[block.digest] = parent_work + proof(block.target)

    def best(self):
        # 工作量相等时,本示例保留先接收到的区块
        return max(self.blocks, key=self.total.get)


def main():
    g = mine(ZERO, 0, EASY)
    a1 = mine(g.digest, 1, EASY)
    a2 = mine(a1.digest, 2, EASY)
    a3 = mine(a2.digest, 3, EASY)
    b1 = mine(g.digest, 1, HARD)
    b2 = mine(b1.digest, 2, HARD)

    arrivals = [('G', g), ('A1', a1), ('A2', a2),
                ('A3', a3), ('B1', b1), ('B2', b2)]
    names = {block.digest: name for name, block in arrivals}
    selector = Selector()

    for name, block in arrivals:
        selector.add(block)
        if name in ('A3', 'B1', 'B2'):
            tip = selector.best()
            print(f'收到{name}: 最佳链头={names[tip]}, '
                  f'高度={selector.blocks[tip].height}, '
                  f'累计工作量={selector.total[tip]}')

    # 修改已经挖出的区块,验证哈希完整性检查
    try:
        selector.add(replace(b2, nonce=b2.nonce + 1))
    except ValueError as error:
        print(f'篡改拒绝: {error}')


if __name__ == '__main__':
    main()

保存后运行 python pow_selector.py。预期输出:

text
收到A3: 最佳链头=A3, 高度=3, 累计工作量=16
收到B1: 最佳链头=A3, 高度=3, 累计工作量=16
收到B2: 最佳链头=B2, 高度=2, 累计工作量=20
篡改拒绝: 哈希不匹配

add() 先验证区块头哈希与目标值,再检查父块关系,最后计算并保存累计工作量。这样,工作量只能通过已验证的父链逐块累加,不能由外部直接提交一个声称的累计工作量。

这里的目标值检查仅允许 EASY 和 HARD 两种教学参数,并未实现真实共识协议中的难度调整验证。真实节点还必须根据链历史和协议规则判断区块声明的目标值是否合法。

注入竞争分支并验证链重组

程序构造两条共享创世块 G 的分支。A 分支包含三个 EASY 区块,B 分支包含两个 HARD 区块。两条分支的累计工作量分别如下。

分支 区块组成 链头高度 累计工作量
A G、A1、A2、A3 3 4+4+4+4=164+4+4+4=16
B G、B1、B2 2 4+8+8=204+8+8=20

PoW 竞争分支的区块高度与累计工作量选链对比

按照程序中的区块接收顺序,选择过程分为三个关键时刻:

  1. 收到 A3 后,A 分支累计工作量达到 16,成为当前最佳链。
  2. 收到 B1 后,B 分支累计工作量为 12,仍低于 A 分支,最佳链不变。
  3. 收到 B2 后,B 分支累计工作量达到 20,超过 A 分支,最佳链切换到 B2。

第三步发生链重组:共同祖先是 G,旧最佳链上的 A1、A2、A3 不再属于新最佳链,新最佳链使用 B1、B2。

需要特别区分选链与执行状态回滚。当前程序只计算并选择链头,没有实现交易状态、UTXO 或账户状态,因此不会真的撤销 A 分支上的交易。生产节点在切换分支时,还需要回退旧分支的状态变化并应用新分支的区块。

检查无效区块与实现边界

故障注入时,应验证选链器不仅能够选出正确分支,还能拒绝不能连接到有效父链的区块。可以围绕现有程序执行以下检查:

故障注入 修改方式 应有行为
篡改区块 修改 B2 的 Nonce,不重新计算哈希 拒绝,提示哈希不匹配
父块缺失 将 B2 的接收顺序移动到 B1 前面 拒绝,提示父块不存在
高度错误 使用 mine(a1.digest, 9, EASY) 创建区块并提交 拒绝,提示高度不连续
重复提交 对同一个已接收区块再次调用 add() 拒绝,提示重复区块
未达到目标 提交哈希大于目标值的区块 拒绝,提示未达到目标值

高度检查必须使用父块实际高度加一,而不能只相信区块头声明的高度。哈希校验也必须重新计算区块头,不能直接信任提交者提供的 digest。

当前实现还有三个明确限制。首先,父块必须先于子块到达;真实 P2P 节点通常会暂存尚未连接的区块并请求缺失的父块。其次,相等累计工作量时使用接收顺序打破平局,这只是本地演示策略,不是所有 PoW 协议强制规定的全网平局规则。最后,程序没有实现难度调整、时间戳约束、交易验证与网络同步,不能用于真实资金网络。

如果将 A3 错误地判定为最终最佳链,说明实现可能按区块高度而非累计工作量排序。如果篡改后的 B2 仍被接受,则应重点检查哈希重新计算、目标值比较和父块验证顺序。通过这两项检查,可以直接验证本课选链器最关键的安全边界。

按自己的节奏,确认真正理解。

目录与阅读设置

阅读设置

17

记录一个想法

编写 PoW 累计工作量选链器

0 / 10000 · 笔记保存到账号。未提交的修改会在关闭、离开或刷新后丢失。

登录哪都通