← COMP5567 全部讲次
L04a-2 · 第 3 周

L04a-2 挖矿到底在算什么:区块头、nBits 与难度调整

先补哈希,再看区块头 6 个字段;把 4 字节的 nBits 解码成目标阈值 T,算出平均要试多少次,最后看难度为什么每 2016 块重算一次。

一句话版

矿工反复改区块头里的 Nonce,对区块头做哈希,直到结果小于等于目标阈值 T。T 写在区块头的 nBits 字段里,全网每 2016 块按实际出块快慢重算一次,让平均出块时间稳在 10 分钟。

上一页 L04a 讲了交易怎么写。这一页讲谁有权把交易写进下一块。

先认识这几个词

词 全称 / 读法 一句人话
哈希 hash,这里指 SHA-256 把任意数据压成一个固定长度的「指纹」
区块头 block header 一块的摘要,共 80 字节,挖矿只对它做哈希
nonce number used once 区块头里矿工可以随便改、反复试的那个数
T Target,目标阈值 区块头哈希必须 ≤ T 才算挖到
nBits 区块头里的 4 字节字段 T 的压缩写法
2²⁵⁶ 读「2 的 256 次方」 256 位哈希一共有这么多种可能的值
难度调整 difficulty retarget 每 2016 块重算一次 T

一个类比:全网一起刮彩票

全网矿工在刮同一种彩票。每张票是一个候选区块的区块头,票面上有上一张中奖票的编号、这一轮要记的账,还有一个可以随便改的号码 nonce。

刮开的结果是一串 256 位的数,就是区块头哈希。刮出来的数小于等于中奖线 T,就算中奖。中奖者把这页账记进全网的账本,拿走奖金。

中奖线越低越难中。nBits 是印在票面上的中奖线,它每两周调一次:大家刮得太快就把线压低,太慢就抬高。

类比在哪里失效:

  • 刮彩票不费力,挖矿每试一次都要真算一遍哈希,烧的是电。
  • 彩票的中奖号码事先定好,哈希的结果谁也预测不了,只能一张张试。
  • 彩票中奖当场兑现,比特币中奖的块若落在被抛弃的分支里就白挖了,这放在下一页讲。

从零讲起

1. 先补一块:哈希 SHA-256(补充)

它解决什么问题

挖矿需要一道题:做起来要花大量功夫,检查起来却一眼就行,还没法投机取巧。哈希函数正好提供这种题。

从哪来(补充)

SHA-256 属于 SHA-2 家族,由美国国家安全局(NSA)设计,2001 年由 NIST 作为美国联邦标准首次发布。它的输出固定是 256 位。

出处:Wikipedia: SHA-2

直觉

哈希像一台碎纸压块机。塞进去一本书也好,一句话也好,出来都是一块同样大小的压块。

压块上的花纹由内容决定,同样的内容永远压出同样的花纹。内容改一个字,花纹就全变了,而且看着花纹没法还原出原文。

一步一步看

目标:看输入只改一个字,SHA-256 的输出怎样整串变掉、长度却不变。

  1. 输入「Alice 付 Bob 10 BTC」,算 SHA-256,得到 64 个十六进制字符,以 43b480 开头。

  2. 只把 10 改成 11,再算一次,得到以 a72524 开头的另一串。

  3. 对比两串,找不出任何相似之处。

  4. 两次输出长度一样,都是 256 位,跟输入多长无关。

    SHA-256 雪崩效应两行对照:第一行输入「Alice 付 Bob 10 BTC」,经过 SHA-256 得到以 43b480 开头的 64 个十六进制字符;第二行只把 10 改成 11,输出变成以 a72524 开头的另一串,两串之间没有相似之处;输出长度固定 256 位,从输出推不回输入

怎么判断

一个函数能不能当挖矿用的哈希,看三点。输出长度固定;同一输入永远同一输出;想让输出落进某个范围,除了一个个试没有更快的办法。

第三点最要紧。正因为没法反推,矿工才只能暴力试 nonce,而别人检查只需算一次。

常见误解

以为哈希是一种加密,有密钥就能解回去

哈希没有密钥,也没有解密这回事。它是单向的,从输出推不回输入。

试一下

两笔交易只差一个数字,它们的哈希前几位会不会很像?

不会。输入改一点,输出整串都变,前几位相同只是巧合。

2. 区块头:挖矿时到底哈希的是什么

它解决什么问题

一块里可能有几千笔交易。每试一次 nonce 都把整块重新哈希,太慢。比特币只对一块的摘要做哈希,这份摘要就是区块头。

直觉

区块头只有 6 个字段,共 80 字节。三组用途:Prev Hash 把这一块挂在上一块后面;Merkle Root 是全部交易的总指纹,改任何一笔交易它都会变;Time、nBits、Nonce 三个管挖矿。

课件的区块结构表里还有 Magic Num 和 Block Size。它们是网络消息的外壳,不进哈希。

一步一步看

目标:看矿工从挑交易到算出区块哈希,每试一次 nonce 哈希的是哪 80 字节。

  1. 矿工从自己的交易池(mempool)里挑一批交易,再加一笔发给自己的 coinbase。

  2. 把这些交易算成一个 Merkle Root。

  3. 填好 Version、Prev Hash、Merkle Root、Time、nBits,Nonce 先从 0 开始。

  4. 对这 80 字节做两次 SHA-256,得到区块哈希。

  5. 哈希 ≤ T 就挖到了;否则 Nonce 加 1,回到第 4 步。

    区块头字段图:上方两个虚线框是 Magic Num 和 Block Size,标注为消息外壳不进哈希;中间一排是区块头 6 个字段,Version 4 字节、Prev Hash 32 字节、Merkle Root 32 字节、Time 4 字节、nBits 4 字节、Nonce 4 字节,合计 80 字节,Nonce 用青绿标出为矿工反复改的字段;下方写区块头做两次 SHA-256 得到区块哈希,要小于等于 T

怎么判断

Time 字段(nTime)由矿工按本地时钟填。网络没有全局时钟,所以接收方用两条规则检查它。

规则 防什么
必须大于前 11 块 nTime 的中位数 防止时间倒流;用中位数,单个矿工填错影响不了后续
不能超过本节点网络调整时间 2 小时以上 防止把时间填到未来

网络调整时间是本节点所连其他节点本地时钟的中位数。这两条只划了一个区间,所以相邻两块的 nTime 倒序也合法。

常见误解

把 Magic Num 和 Block Size 也算成区块头字段

它们是网络消息的外壳,不参与哈希。答「区块头有哪些字段」只写 6 个:Version、Prev Hash、Merkle Root、Time、nBits、Nonce。

以为交易本身直接进哈希

交易通过 Merkle Root 间接进哈希。改动任何一笔交易,Merkle Root 变,区块哈希也跟着变。

试一下

区块头 80 字节是怎么加出来的?

4 + 32 + 32 + 4 + 4 + 4 = 80。两个哈希各 32 字节,其余四个字段各 4 字节。

3. nBits:把 256 位的 T 塞进 4 个字节

它解决什么问题

T 是一个 256 位的大数,区块头只给它留了 4 字节。nBits 用 256 进制的科学计数法压缩它:一个字节当指数,三个字节当尾数。

直觉

十进制里 123,000,000 可以写成「1.23 × 10⁸」,只记尾数和指数。nBits 是同一个办法,底数换成 256,也就是一个字节。

首字节告诉你 T 一共占几个字节,后三字节是 T 最高的三个字节,其余位置都补零。

一步一步看

目标:看 4 字节的 nBits 怎样拆成指数和尾数,还原出 256 位的 T。

以 2017 年 1 月 1 日的 nBits = 0x180375ff 为例,0x 表示十六进制。

  1. 拆字节:首字节 0x18,后三字节 0x0375ff。

  2. 指数 0x18 = 24,说明 T 一共占 24 个字节。

  3. 尾数 0x0375ff 约等于 0x040000,也就是 2¹⁸。

  4. 尾数后面要补 24 − 3 = 21 个零字节,所以 T ≈ 2¹⁸ × 256²¹ = 2¹⁸ × 2¹⁶⁸ = 2¹⁸⁶。

    nBits 0x180375ff 拆成四个字节:首字节 0x18 是指数,后三字节 0x03、0x75、0xff 是尾数;0x18 等于 24,指数减 3 得 21;尾数 0x0375ff 约等于 0x040000 也就是 2 的 18 次方;于是目标阈值 T 等于 2 的 18 次方乘 256 的 21 次方,等于 2 的 186 次方,期望尝试次数为 2 的 256 次方除以 T 加 1,约 2 的 70 次方

怎么算

记 nBits = b₁b₂b₃b₄:

T = (b₂b₃b₄) × 256^(b₁ − 3)

意思是首字节当指数,后三字节当尾数,尾数乘上 256 的 (指数 − 3) 次方。减 3 是因为尾数本身已经占了 3 个字节。

指数小于 3 时反过来砍尾数的低位字节。真实实现里尾数最高位是符号位,所以合法尾数最大 0x7fffff,最大目标写成 0x1d00ffff。

常见误解

把指数直接当成 256 的幂次

要先减 3。0x18 对应 256²¹,不是 256²⁴。

以为任何 4 个字节都能解出合法的 T

尾数最高位 0x800000 是符号位,置位的值会被比特币节点当成负目标拒绝。考试按课件算可以,但要知道它在真实链上无效。

试一下

0x04123456 解码出的 T 是多少?

指数 4,尾数 0x123456,后面补 4 − 3 = 1 个零字节,T = 0x12345600。

4. 命中概率与难度调整

它解决什么问题

有了 T,还要知道两件事:平均要试多少次才能挖到;全网算力涨了或跌了,T 该怎么跟着变,才能让出块一直保持约 10 分钟一块。

直觉

把所有可能的哈希值排成一条线,从 0 到 2²⁵⁶ − 1。每试一次 nonce,哈希就随机落在线上某处。只有落进最左边 [0, T] 那一小段才算中。

命中区越窄越难中。全网矿工变多,一样宽的命中区会被更快撞中,出块就变快了。这时就得把 T 调小。

一步一步看

目标:从命中区的宽度算出单次命中概率,再算出平均要试多少次。

  1. 线上一共有 2²⁵⁶ 个点,命中区里有 T + 1 个。

  2. 每次尝试落点随机,所以单次命中概率是两者之比。

  3. 平均要试的次数是概率的倒数。

  4. 0x180375ff 的 T ≈ 2¹⁸⁶,平均要试 2²⁵⁶ ÷ 2¹⁸⁶ = 2⁷⁰ 次。

    哈希值数轴与命中区:一条从 0 到 2 的 256 次方减 1 的数轴代表所有可能的哈希值;最左边从 0 到 T 的一小段用青绿框标为命中区;灰点是落在命中区外的尝试;小于等于 T 的整数有 T 加 1 个,所以单次命中概率是 T 加 1 除以 2 的 256 次方

4 字节的 nonce 只有 2³² 种取值,约 43 亿,远小于 2⁷⁰。nonce 试完了,矿工就改 coinbase 里一段可以自由填的 extraNonce。它会改变 Merkle Root,换出一整批新的区块头接着试。

全网每 2016 块重算一次 T。下面这张表按实际用时看 T 怎么调,预期是 14 天:

这 2016 块实际用了 说明 T 乘以 挖矿变得
7 天 算力约翻倍 1/2 更难
14 天 正好 1 不变
28 天 算力约减半 2 更容易

怎么算

p = (T + 1) / 2²⁵⁶,期望尝试次数 = 2²⁵⁶ / (T + 1)

意思是命中区里的点数除以总点数,就是单次中奖的概率;倒过来就是平均要试几次。

600 · R = 2²⁵⁶ / (T + 1)

意思是全网每秒试 R 次,平均出块时间就是期望次数除以 R,令它等于 600 秒。算力翻倍,T 就要减半。

T_new = T_old × 实测时长 / (2016 × 600)

意思是算力测不到,就看上一轮 2016 块实际花了多久。实测时长取两块 nTime 之差。2016 × 600 秒正好 14 天,就是「约两周」的来历。

常见误解

以为难度可以一次任意跳变

真实实现把单次调整钳在 1/4 到 4 倍之间。实测时长靠矿工自填的 nTime,所以 nTime 的两条规则也是难度机制的防线,操纵它的攻击叫 timejacking。

写公式时漏掉 T + 1 里的 1

小于等于 T 的整数有 T + 1 个,从 0 数起。近似计算可以忽略这个 1,写公式时不能漏。

试一下

过去 2016 块用了 21 天,T 应乘以多少?挖矿变难还是变容易?

21 ÷ 14 = 1.5,T 乘以 1.5,命中区变宽,挖矿变容易。

把它们串起来

挖矿就是对区块头反复做哈希。区块头 80 字节里,Prev Hash 挂住上一块,Merkle Root 锁住全部交易,Nonce 是矿工唯一能随手改的数。

哈希的结果没法预测,只能一次次试,直到它落进 [0, T]。T 压在 nBits 这 4 个字节里,用「指数 + 尾数」的写法解出来。

T 决定命中概率,命中概率决定平均要试几次,全网算力决定平均要几秒。三者连起来就是 600R = 2²⁵⁶/(T+1)。算力测不到,所以每 2016 块回头看一眼实际用时,按比例修正 T。

还剩一个问题:两个矿工几乎同时挖到,链听谁的?下一页讲分叉。

课件里的坑

  • [课件有误] 课件 Exercise-3 题面写「refer to slide 9」→ 第 9 页是区块体截图,nBits 的例子在 p.23 和 p.26,是旧版课件的页码没更新(p.59)
  • [读图提醒] p.19 的蓝色括号已经把 Magic Num、Block Size 排除在区块头外。真正进哈希的头部是 6 个字段、80 字节,不要因为它们画在同一张表里就加进去(p.19)
  • [补充核验] Exercise-3 第二问给的 0x15c31b18 设置了符号位,真实节点会拒绝它,只能当忽略符号位的算术练习(p.59)

课后 10 分钟:考点复习

这 10 分钟怎么用:合上页面,先默写区块头 6 个字段和各自字节数,再默写 T = 尾数 × 256^(指数−3) 和难度调整公式;然后把下面的变式题做一遍;最后回查两个最容易错的地方:把指数直接当成 256 的幂次、把 Magic Num 算进区块头。

必背

  1. SHA-256 把任意输入压成 256 位输出;输入改一点输出全变,从输出推不回输入。
  2. 区块头 6 字段共 80 字节:Version / Prev Hash / Merkle Root / Time / nBits / Nonce;Magic Num 与 Block Size 不进哈希。
  3. nTime 两条规则:大于前 11 块 nTime 的中位数;不超过网络调整时间 2 小时。
  4. 正目标 T 按 compact 指数与有效尾数解码,并检查符号位;p = (T+1)/2²⁵⁶,期望尝试次数 = 2²⁵⁶/(T+1)。
  5. 600R = 2²⁵⁶/(T+1);T_new = T_old × 实测时长 / (2016 × 600),实测时长取两块 nTime 之差。
  6. 32 位 nonce 不够用时,改 coinbase 里的 extraNonce 换出新的 Merkle Root。

课件例题

例 1(课件 p.23):四个 nBits 解码成目标阈值 T

题面:尾数都是 0x123456,指数分别取 3、2、5、8,即 0x03123456、0x02123456、0x05123456、0x08123456,写出各自的 T。

提示

指数就是 T 的总字节数。指数大于 3 补零字节,小于 3 砍掉尾数低位字节。

解答

套 T = 尾数 × 256^(指数 − 3):

  1. 0x03123456:256⁰,T = 0x123456。
  2. 0x02123456:256⁻¹,右移一个字节,T = 0x1234,末字节 0x56 丢掉。
  3. 0x05123456:256²,T = 0x1234560000。
  4. 0x08123456:256⁵,T = 0x1234560000000000。

例 2(课件 p.26):2017 年 1 月 1 日的 nBits 0x180375ff,平均要试几次

题面:求指数、尾数、T 和期望尝试次数。

提示

尾数先近似成 2 的整数次幂,再把 256 换成 2⁸。

解答
  1. 指数 0x18 = 24;尾数 0x0375ff ≈ 0x040000 = 2¹⁸。
  2. T ≈ 2¹⁸ × 256²¹ = 2¹⁸⁶。
  3. 期望尝试次数 = 2²⁵⁶ / T ≈ 2⁷⁰。
  4. 不取整时 0x0375ff = 226,815 ≈ 2^17.79,期望次数 ≈ 2^70.21,课件的近似合理。

例 3(课件 p.8):用真实区块 #544858 验证难度

题面:该区块 Bits = 388350353,截图上的 Difficulty 是 7,454,968,648,263.24。换算成十六进制,解码 T,算相对难度,看是否一致。

提示

相对难度 = 最大目标 / T,最大目标是 0x1d00ffff 解出来的 0xffff × 256²⁶。

解答
  1. 388350353 = 0x1725c191,指数 0x17 = 23,尾数 0x25c191。
  2. T = 0x25c191 × 256²⁰ ≈ 2^181.2。
  3. 难度 = (0xffff × 256²⁶) / T ≈ 7.45 × 10¹²,和截图一致。

例 4(课件 p.59,Exercise-3):由期望尝试次数反推 nBits,由 nBits 求难度

见下方完整例题。

完整例题

Exercise-3 两问是同一套公式的正反两个方向。

(1) 要让期望尝试次数约为 2⁹⁰,nBits 该设多少?

  1. 期望次数 = 2²⁵⁶/(T+1) ≈ 2⁹⁰,反解得 T ≈ 2²⁵⁶⁻⁹⁰ = 2¹⁶⁶。
  2. 把 2¹⁶⁶ 写成「尾数 × 256^(指数−3)」:166 = 22 + 8 × 18,所以 2¹⁶⁶ = 2²² × 256¹⁸ = 0x400000 × 256¹⁸。
  3. 尾数 0x400000 最高位没碰到符号位 0x800000,合法;指数 = 18 + 3 = 21 = 0x15。
  4. 规范 nBits = 0x15400000。验算:2²² × 2¹⁴⁴ = 2¹⁶⁶。
  5. 0x17000040、0x16004000 在简化算式下也解码为同一个 T,但不是规范写法,不能当作可随意替换的区块字段。

(2) 课件给 nBits = 0x15c31b18,难度是多少?

补充核验:这个值设置了 0x00800000 符号位,真实节点会拒绝它,没有合法的正目标难度。下面只复现课件忽略符号位的算术。

  1. 拆字节:指数 = 0x15 = 21,尾数 = 0xc31b18 = 12,786,456 ≈ 2^23.6。
  2. T = 0xc31b18 × 256¹⁸ ≈ 2^23.6 × 2^144 = 2^167.6。
  3. 单次命中概率 p = (T+1)/2²⁵⁶ ≈ 2^−88.4。
  4. 期望尝试次数 ≈ 2²⁵⁶/T ≈ 2^88.4(约 4 × 10²⁶ 次)。
  5. 若按相对最大目标 0x1d00ffff 的定义:difficulty = (0xffff × 256²⁶)/(0xc31b18 × 256¹⁸) ≈ 2^56.4 ≈ 9.5 × 10¹⁶。
  6. 题目问 hashing difficulty,课件语境指期望尝试次数 2^88.4,和 p.26「约 2⁷⁰ 次」同一口径;把相对难度也写上并注明定义,两种理解都覆盖。对照 (1):这里的 T 比 2¹⁶⁶ 大约 3 倍,期望次数比 2⁹⁰ 少约 3 倍,数量级对得上。

变式题(先自己做)

改编自课件 p.59:同一套公式,换两个数正反各走一遍。

(1) 要让期望尝试次数约为 2⁸⁰,nBits 该设多少? (2) nBits = 0x1a01ffff,期望尝试次数约是多少?

提示

第一问先反解 T,再写成规范编码:取最高有效字节,注意符号位。第二问先拆字节,尾数近似成 2 的整数次幂。

判分点与答案

(1) T ≈ 2²⁵⁶⁻⁸⁰ = 2¹⁷⁶。规范写法:2¹⁷⁶ = 0x010000 × 256²⁰;指数 = 20 + 3 = 23 = 0x17,故 nBits = 0x17010000。0x18000100 也能解出同值,但不是规范编码。

(2) 指数 = 0x1a = 26,尾数 = 0x01ffff = 131,071 ≈ 2¹⁷。T ≈ 2¹⁷ × 256²³ = 2²⁰¹。期望尝试次数 ≈ 2²⁵⁶ / T = 2⁵⁵ ≈ 3.6 × 10¹⁶。若换相对难度的口径:T_max ≈ 2²²⁴,difficulty ≈ 2²³ ≈ 8.4 × 10⁶。两个数差得很远却都没错,因为定义不同,答题时把口径写出来。

判分点:反解写成 T ≈ 2^(256 − 期望指数);编码落回规范的「有效尾数 + 指数」并检查符号位;正向题说清用的是哪种难度口径。

闪卡自测

1. SHA-256 的输出多长?输入改一个字会怎样?

固定 256 位。输入改一点,输出整串都变,而且从输出推不回输入(补充)。

2. 区块头有哪 6 个字段?共多少字节?

Version、Prev Hash、Merkle Root、Time、nBits、Nonce,共 80 字节。Magic Num 和 Block Size 不进哈希(p.19)。

3. nTime 的两条校验规则是什么?第一条为什么用中位数?

必须大于前 11 块 nTime 的中位数;不能超过网络调整时间 2 小时以上。用中位数是为了让单个矿工填错的时间戳影响不了后续(p.21)。

4. 把 0x02123456 和 0x08123456 各自解码成 T。

0x02123456:T = 0x1234,末字节 0x56 丢掉。0x08123456:T = 0x1234560000000000(p.23)。

5. 写出单次命中概率和期望尝试次数,用 0x180375ff 算一遍。

p = (T+1)/2²⁵⁶,期望次数 = 2²⁵⁶/(T+1)。0x180375ff 的 T ≈ 2¹⁸⁶,期望约 2⁷⁰ 次(p.25、p.26)。

6. 推导 600R = 2²⁵⁶/(T+1)。算力翻倍时 T 怎么变?

期望次数除以每秒尝试次数 R 就是期望出块时间,令它等于 600 秒即得。算力翻倍,T 减半(p.28)。

7. 写出难度调整公式。过去 2016 块只用了 7 天,T 应乘以多少?

T_new = T_old × 实测时长 / (2016 × 600)。预期 14 天,实测 7 天,T 乘以 1/2(p.29)。

8. 32 位 nonce 只有约 43 亿个取值,矿工试完了怎么办?

改 coinbase 里的 extraNonce,它会改变 Merkle Root,换出一整批新的区块头;nTime 在允许区间内微调也常用(p.24 补充)。

9. 为什么最大目标写成 0x1d00ffff 而不是 0x1cffff00?

尾数最高位是符号位,0xffff00 会碰到它,所以往右挪一个字节写成 0x00ffff、指数加 1(p.23 补充)。

下一讲

下一页 L04b 讲挖到之后的事:两个块同时冒出来时链听谁的,同一枚币为什么花不了两次,以及算力过半的攻击者能做到哪一步。

下一讲 →
L04b L04b 链听谁的:分叉、双花与 51% 攻击

个人整理的学习笔记,不是官方材料;数字与结论以课件和讲师为准。