# 第10章 挖矿
## 10.1 简介
“挖矿”这个词有点误导。一般意义的挖矿类似贵金属的提炼，于是人们将更多的注意力集中到挖矿的回报，也就是每个区块创造的新比特币。虽然挖矿行为会被这种奖励所激励，但挖矿的主要目的不是这个奖励或者产生新币。如果你只把挖矿看作是创比特币的过程，那么你就会误把这个过程中的手段（作为激励）作为目标。挖矿是一种去中心化的交易清算机制，通过这种机制，交易得到验证和清算。挖矿是使得比特币与众不同的发明，是一种去中心化的安全机制，是点对点数字现金的基础。
挖矿*确保了比特币系统安全*，并且在全网范围实现了*没有中央权威机构的共识*。挖出新币以及交易费的奖励是一种激励机制，它将矿工的行为与网络的安全性结合起来，同时实施货币供应。
>**提示**：挖矿的目的不是创造新的比特币。这是激励机制。 挖矿是一种使比特币的*安全security去中心化decentralized*的机制。
矿工验证新交易并将其记录在全球分类账簿上。每10分钟就会有一个新的区块被“挖掘”出来，这个新区块里包含着从上一个区块产生到目前这段时间内发生的交易，这样这些交易就被添加到区块链中了。我们把包含在区块内且被添加到区块链上的交易称为“已确认confirmed”交易，交易经过“确认”之后，新的拥有者才能够花费他在交易中收到的比特币。
矿工们在挖矿过程中会得到两种类型的奖励：创建新区块的新币奖励，以及区块中所含交易的交易费。为了得到这些奖励，矿工们争相完成一种基于加密哈希算法的数学难题，这些难题的解决方案，称为“工作量证明”，包括在新区块中，作为矿工花费大量计算工作的证明。解决工作证明算法在区块链上获得奖励的竞争以及获胜者有权在区块链上记录交易，这二者是比特币安全模型的基石。
这个过程被称为挖矿，是因为奖励机制（新比特币产生）被设计为模拟收益递减模式，类似于贵重金属的挖矿过程。比特币的货币是通过挖矿发行的，类似于央行通过印刷钞票来发行货币。矿工通过创造一个新区块得到的比特币数量大约每四年（或准确说是每210,000个区块）减少一半。开始时为2009年1月每个区块奖励50个比特币，然后到2012年11月减半为每个区块奖励25个比特币。之后在2016年7月 再次减半为每个新区块奖励12.5个比特币。基于这个公式，比特币挖矿奖励以指数方式递减，直到2140年。届时所有的比特币（20,999,999,980）全部发行完毕。换句话说在2140年之后，不会再有新的比特币产生。
矿工们同时也会获取交易费。每笔交易都可能包含一笔交易费，交易费是每笔交易记录的输入和输出的差额。在挖矿过程中成功“挖出”新区块的矿工可以得到该区块中包含的所有交易“小费”。目前，这笔费用占矿工收入的0.5%或更少，大部分收益仍来自挖矿所得的新比特币奖励。然而随着挖矿奖励的递减，以及每个区块中包含的交易数量增加，交易费在矿工收益中所占的比重将会逐渐增加。在2140年之后，所有的矿工收益都将由交易费构成。
在本章中，我们先来审视比特币的货币发行机制，然后再来了解挖矿的最重要的功能：支撑比特币安全的去中心化的共识机制。
为了了解挖矿和共识，我们将跟随Alice的交易，是如何被矿工Jing的挖矿设备接收并被添加到区块中的。 然后，我们将继续跟踪区块被挖矿，加入区块链，并通过自发共识被比特币网络接受。
### 10.1.1 比特币经济学和货币创造
比特币是在每一个区块的创建过程中以固定和递减的速度被“铸造出来”的。大约每十分钟产生一个新区块，每一个新区块都伴随着一定数量的全新比特币，它是从无到有的。每开采210,000个区块，或者大约每4年，货币发行速率降低50%。在比特币运行的第一个四年中，每个区块创造出50个新比特币。
2012年11月，比特币的新发行速度降低到每区块25个比特币。2016年7月，降低到12.5比特币/区块。2020年的某个时候，也就是在区块630,000，它将再次下降至6.25比特币。新币的发行速度会以指数级进行32次“等分”，直到第6,720,000块（大约会在2137年挖出），达到比特币的最小货币单位1聪。最终，在经过693万个区块之后，所有的共 2,099,999,997,690,000聪，或者说接近 2,100万比特币将全部发行完毕。在那之后，新的区块不再包含比特币奖励，矿工的收益全部来自交易费。图10-1展示了在发行速度不断降低的情况下，比特币总流通量与时间的关系。
图10-1 基于发行率几何下降的比特币供应量和时间的关系
>**注意**：比特币挖矿发行的最大数量也就成为挖矿奖励的*上限*。 在实践中，矿工可能故意挖那些低于全额奖励的区块。已经有这些区块被挖出来了，未来就会有更多被开采，这样导致货币发行总量的下降。
在例10-1的代码中，我们计算了比特币的总发行量
例10-1 比特币发行总量的计算脚本
```
# Original block reward for miners was 50 BTC = 50 0000 0000 Satoshis
start_block_reward = 50 * 10**8
# 210000 is around every 4 years with a 10 minute block interval
reward_interval = 210000
def max_money():
current_reward = start_block_reward
total = 0
while current_reward > 0:
total += reward_interval * current_reward
current_reward /= 2
return total
print("Total BTC to ever be created:", max_money(), "Satoshis")
```
例10-2显示了运行脚本的输出结果
例10-2 运行上述脚本的输出结果
```
$ python max_money.py
Total BTC to ever be created: 2099999997690000 Satoshis
```
总量有限并且发行量递减创造了一个固定的货币供应量来抵御通货膨胀。法币可被央行无限制地印刷出来，而比特币却永远不会因超额印发而出现通胀。
**通货紧缩**
发行总量固定并且递减的最重要和有争议的后果是，货币往往会趋向于内在*通货紧缩性deflationary*。通缩是一种由于货币的供应和需求不匹配导致的货币价值（和汇率）上涨的现象。与通货膨胀相反，价格通缩意味着随着时间的推移，货币拥有更多的购买力。
许多经济学家认为，通缩经济是一场灾难，应该不惜一切代价避免。这是因为在快速通货紧缩时期，人们预期商品价格会下跌，倾向于囤积货币而不是消费。这种现象在日本“失落的十年”期间出现，需求崩溃将日元推入通缩漩涡。
比特币专家们认为通缩本身并不坏。相反，通货紧缩与需求崩溃联系在一起，因为这是我们必须研究的通货紧缩的唯一例子。对于存在无限印刷可能的法定货币，除非需求完全崩溃，不愿意印刷货币，否则很难进入通缩漩涡。比特币的通缩不是由需求崩溃造成的，而是由可预见的供应受限造成的。
当然，通货紧缩的积极方面是，它与通货膨胀相反。通货膨胀导致货币的缓慢但不可避免的贬值，造成了一种隐藏的税收形式，惩罚储蓄者，解救了债务人（包括政府这个最大的债务人）。政府控制下的货币遭受轻易发债的道德风险，这种风险后来可能会以牺牲储蓄者为代价，通过贬值来抹去债务。
货币的通缩，如果不是由经济快速收缩所推动，那么这是一个问题，还是一个优势，仍有待观察，因为防止通胀和贬值远远大于通缩带来的风险。
## 10.2 去中心化共识
在上一章中我们研究了区块链，即所有交易的全球公共分类账（列表），比特币网络中的每个人都接受它，把它作为所有权的权威记录。
但在不考虑相信任何人的情况下，网络中的所有人如何就谁拥有什么这一普遍的“真相”达成一致呢？所有传统的支付系统都依赖于一个信任模型，该模型由一个中央机构提供清算服务，验证和清算所有交易。比特币没有中央权威机构，但是所有的全节点都有一份完整的公共账本副本，可以作为权威记录来信任。区块链不是由中央机构创建的，而是由网络中的每个节点独立组装的。网络中的所有节点，依靠着节点间的不安全的网络连接所传输的信息，最终得出同样的结果并共同维护了同一个公共总帐。本章探讨比特币网络在没有中央权威的情况下达成全球共识的过程。
中本聪的主要发明就是这种去中心化的*自发共识emergent consensus*机制。自发，是指共识没有明确的完成点，没有选举和共识达成的固定时刻。换句话说，共识是数以千计的独立节点遵守了简单的规则通过异步交互自发形成的产物。所有的比特币属性，包括货币、交易、支付以及不依靠中心机构和信任的安全模型等都依赖于这个发明。
比特币的去中心化共识由所有网络节点的4种独立过程相互作用而产生：
* 每个全节点依据一个详尽的标准列表对每个交易进行独立验证
* 挖矿节点将交易记录独立打包进新区块，通过工作证明算法进行证明计算
* 每个节点独立的对新区块进行校验并组装进区块链
* 每个节点对区块链进行独立选择，在工作量证明机制下选择累计工作量最大的区块链
在接下来的几节中，我们将研究这些过程，了解它们之间如何相互作用并达成全网的自发共识，从而使任意节点组合出它自己的权威、可信、公开的全局总帐副本。
## 10.3 交易的独立验证
在[【第6章交易】](https://github.com/tianmingyun/MasterBitcoin2CN/blob/master/ch06.md)中，我们知道了钱包软件通过收集UTXO、提供正确的解锁脚本、构造一个给新所有者的新输出来创建交易。产生的交易随后将被发送到比特币网络临近的节点，从而使得该交易能够在整个比特币网络中传播。
然而，在交易传递到临近的节点前，每一个收到交易的比特币节点都会首先验证该交易，这将确保只有有效的交易才会在网络中传播，而无效的交易将会被遇到的第一个节点废弃掉。
每一个节点在校验每一笔交易时，都需要对照一个长长的标准列表：
▷交易的语法和数据结构必须正确。
▷输入与输出列表都不能为空。
▷交易的字节数小于 MAX\_BLOCK\_SIZE 。
▷每一个输出值，以及总量，必须在规定值的范围内 （小于2,100万个币，大于dust参数设置的阈值）。
▷没有哈希等于0，N等于-1的输入（coinbase交易不应当被传递）。
▷nLockTime是小于或等于 INT\_MAX 的。或者nLocktime and nSequence的值满足MedianTimePast（译者注：MedianTime是这个块的前面11个块按照block time排序后的中间时间）
▷交易的字节大小是大于或等于100的。
▷交易中的签名数量\(SIGOPS\)应小于签名操作数量上限。
▷解锁脚本（ scriptSig ）只能够将数字压入栈中，并且锁定脚本（ scriptPubkey ）必须要符合isStandard的格式 （该格式将会拒绝非标准交易）。
▷池中或位于主分支区块中的一个匹配交易必须是存在的。
▷对于每一个输入，引用的输出是必须存在的，并且没有被花费。
▷对于每一个输入，如果引用的输出存在于池中任何别的交易中（译者注：这笔输入引用的输出有人家自己的输入，不是你），该交易将被拒绝。
▷对于每一个输入，在主分支和交易池中寻找引用的输出交易。如果输出交易缺少任何一个输入，该交易将成为一个孤 立的交易。如果与其匹配的交易还没有出现在池中，那么将被加入到孤立交易池中。
▷对于每一个输入，如果引用的输出交易是一个coinbase输出，该输入必须至少获得 COINBASE\_MATURITY\(100\)个确认。
▷使用引用的输出交易获得输入值，并检查每一个输入值和总值是否在规定值的范围内 （小于2100万个币，大于0）。
▷如果输入值的总和小于输出值的总和，交易将被中止。
▷如果交易费用太低以至于无法进入一个空的区块，交易将被拒绝。
▷每一个输入的解锁脚本必须依据相应输出的锁定脚本来验证。
这些条件能够在比特币标准客户端下的 AcceptToMemoryPool 、 CheckTransaction 和 CheckInputs 函数中获得更详细的阐述。 请注意，这些条件会随着时间发生变化，为了处理新型拒绝服务攻击，有时候也为交易类型多样化而放宽规则。
在收到交易后，每一个节点都会在全网广播前对这些交易进行独立校验，并以接收时的相应顺序，为有效的新交易建立一个验证池（还未确认），这个池可以叫做交易池，或者memory pool或者mempool。
## 10.4 挖矿节点
在比特币网络中，一些节点被称为专业节点“矿工”。第1章中，我们介绍了Jing，在中国上海的计算机工程专业学生，他 就是一位矿工。Jing通过矿机挖矿获得比特币，矿机是专门设计用于挖比特币的计算机硬件系统。Jing的这台专业挖矿设备连接着一个运行完整比特币节点的服务器。与Jing不同，一些矿工是在没有完整节点的条件下进行挖矿，正如我们 在“矿池”一节中所述的。与其他任一完整节点相同，Jing的节点在比特币网络中进行接收和传播未确认交易记录。然而，Jing的节点也能够把这些交易记录打包进入一个新区块。
同其他节点一样，Jing的节点时刻监听着传播到比特币网络的新区块。而这些新加入的区块对挖矿节点有着特殊的意 义。矿工间的竞争以新区块的传播而结束，如同宣布谁是最后的赢家。对于矿工们来说，收到一个新区块进行验证意味着别人已经赢了，而自己则输了这场竞争。然而，一轮竞争的结束也代表着下一轮竞争的开始。新区块并不仅仅是象征着竞赛结束的方格旗；它也是下一个区块竞赛的发令枪。
## 10.5 打包交易至区块
验证交易后，比特币节点会将这些交易添加到自己的内存池中。内存池也称作交易池，用来暂存尚未被加入到区块的交 易记录。与其他节点一样，Jing的节点会收集、验证并传递新的交易。而与其他节点不同的是，Jing的节点会把这些交 易整合到一个候选区块中。
让我们继续跟进，看下Alice从Bob咖啡店购买咖啡时产生的那个区块。Alice的交易在区块 277,316。为了演示本章中提到的概念，我们假设这个区块是由Jing的挖矿系统挖出的，并且继续跟进Alice的交易，因 为这个交易已经成为了新区块的一部分。
Jing的挖矿节点维护了一个区块链的本地副本。当Alice买咖啡 的时候，Jing节点的区块链已经收集到了区块277,314，并继续监听着网络上的交易，在尝试挖掘新区块的同时，也监 听着由其他节点发现的区块。当Jing的节点在挖矿时，它从比特币网络收到了区块277,315。这个区块的到来标志着终 结了产出区块277,315竞赛，与此同时也是产出区块277,316竞赛的开始。
在上一个10分钟内，当Jing的节点正在寻找区块277,315的解的同时，它也在收集交易记录为下一个区块做准备。目前 它已经收到了几百笔交易记录，并将它们放进了内存池。直到接收并验证区块277,315后，Jing的节点会检查内存池中 的全部交易，并移除已经在区块277,315中出现过的交易记录，确保任何留在内存池中的交易都是未确认的，等待被记 录到新区块中。
Jing的节点立刻构建一个新的空区块，做为区块277,316的候选区块。称作候选区块是因为它还没有包含有效的工作量证明，不是一个有效的区块，而只有在矿工成功找到一个工作量证明解之后，这个区块才生效。
现在，Jing的节点从内存池中整合到了全部的交易，新的候选区块包含有418笔交易，总的矿工费为0.09094925个比特 币。你可以通过比特币核心客户端命令行来查看这个区块，如例10-3所示：
例10-3 使用命令行检索区块277,316
```
$ bitcoin-cli get blockhash 277316
0000000000000001b6b9a13b095e96db41c4a928b97ef2d944a9b31b2cc7bdc4
$ bitcoin-cli getblock 0000000000000001b6b9a13b095e96db41c4a928b97ef2d9\44a9b31b2cc7bdc4
```
```
{
"hash" : "0000000000000001b6b9a13b095e96db41c4a928b97ef2d944a9b31b2cc7bdc4",
"confirmations" : 35561,
"size" : 218629,
"height" : 277316,
"version" : 2,
"merkleroot" : "c91c008c26e50763e9f548bb8b2fc323735f73577effbc55502c51eb4cc7cf2e",
"tx" : [
"d5ada064c6417ca25c4308bd158c34b77e1c0eca2a73cda16c737e7424afba2f",
"b268b45c59b39d759614757718b9918caf0ba9d97c56f3b91956ff877c503fbe",
... 417 more transactions ...//这一行显示交易数量
],
"time" : 1388185914,
"nonce" : 924591752,
"bits" : "1903a30c",
"difficulty" : 1180923195.25802612,
"chainwork" : "000000000000000000000000000000000000000000000934695e92aaf53afa1a",
"previousblockhash" : "0000000000000002a7bbd25a417c0374cc55261021e8a9ca74442b01284f0569"
}
```
### 10.5.1 创币交易
区块中的第一笔交易是笔特殊交易，称为创币交易或者coinbase交易。这个交易是由Jing的节点构造并用来奖励矿工们所做的贡献的。
**注意**:当块277,316开采时，每个块的奖励是25比特币。 此后，已经过了一个“减半”时期。 2016年七月份的奖励为12.5比特币，2020年达到210000区块时，将再次减半。
Jing的节点会创建“向Jing的地址支付25.09094928个比特币”这样一个交易，把生成交易的奖励发送到自己的钱包。Jing挖出区块获得的奖励金额是coinbase奖励（25个全新的比特币）和区块中全部交易矿工费的总和。
如 例10-4所示：coinbase交易
```
$ bitcoin-cli getrawtransaction d5ada064c6417ca25c4308bd158c34b77e1c0eca2a73cda16c737e7424afba2f 1
```
```
{
"hex" : "01000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0f03443b0403858402062f503253482fffffffff0110c08d9500000000232102aa970c592640d19de03ff6f329d6fd2eecb023263b9ba5d1b81c29b523da8b21ac00000000",
"txid" : "d5ada064c6417ca25c4308bd158c34b77e1c0eca2a73cda16c737e7424afba2f",
"version" : 1,
"locktime" : 0,
"vin" : [
{
"coinbase" : "03443b0403858402062f503253482f",
"sequence" : 4294967295
}
],
"vout" : [
{
"value" : 25.09094928,
"n" : 0,
"scriptPubKey" : {
"asm" : "02aa970c592640d19de03ff6f329d6fd2eecb023263b9ba5d1b81c29b523da8b21OP_CHECKSIG",
"hex" : "2102aa970c592640d19de03ff6f329d6fd2eecb023263b9ba5d1b81c29b523da8b21ac",
"reqSigs" : 1,
"type" : "pubkey",
"addresses" : ["1MxTkeEP2PmHSMze5tUZ1hAV3YTKu2Gh1N"
]
}
}
]
}
```
与常规交易不同，创币交易没有输入，不消耗UTXO。它只包含一个被称作coinbase的输入，仅仅用来创建新的比特 币。创币交易有一个输出，支付到这个矿工的比特币地址。创币交易的输出将这25.09094928个比特币发送到矿工的比 特币地址，如本例所示的1MxTkeEP2PmHSMze5tUZ1hAV3YTKu2Gh1N。
### 10.5.2 Coinbase奖励与矿工费
为了构造创币交易，Jing的节点需要计算矿工费的总额，将这418个已添加到区块交易的输入和输出分别进行求和，然 后用输入总额减去输出总额得到矿工费总额，公式如下：
```
Total Fees = Sum(Inputs) - Sum(Outputs)
```
在区块277,316中，矿工费的总额是0.09094925个比特币。
紧接着，Jing的节点计算出这个新区块正确的奖励额。奖励额的计算是基于区块高度的，以每个区块50个比特币为开始，每产生210,000个区块减半一次。这个区块高度是277,316，所以正确的奖励额是25个比特币。
详细的计算过程可以参看比特币核心客户端中的GetBlockValue函数，如例10-5所示：
例10-5 计算区块奖励—函数GetBlockValue, Bitcoin Core Client, main.cpp
```
CAmount GetBlockSubsidy(int nHeight, const Consensus::Params
&
consensusParams){
int halvings = nHeight / consensusParams.nSubsidyHalvingInterval;
// Force block reward to zero when right shift is undefined.
if (halvings
>
= 64)
return 0;
CAmount nSubsidy = 50 * COIN;
// Subsidy is cut in half every 210,000 blocks which will occur approximately every 4 years.
nSubsidy
>
>
= halvings;
return nSubsidy;
}
```
变量Subsidy表示初始奖励额，值为 COIN 常量（100,000,000聪\)与50的乘积，也就是说初始奖励额为50亿聪。
紧接着，这个函数用当前区块高度除以减半间隔\(SubsidyHalvingInterval 函数\)得到减半次数（变量 halvings ）。每 210,000个区块为一个减半间隔，对应本例中的区块277316，所以减半次数为1。
变量 halvings 最大值64，如果超出这个值，代码算得的奖励额为0。
然后，这个函数会使用二进制右移操作将奖励额\(变量 nSubsidy\)右移一位（等同与除以2），每一轮减半右移一次。在这个例子中，对于区块277,316只需要将值为50亿聪的奖励额右移一次，得到25亿聪，也就是25个比特币的奖励额。之所以采用二进制右移操作，是因为相比于整数或浮点数除法，右移操作的效率更高。
最后，将coinbase奖励额（变量 nSubsidy ）与矿工费\(nFee\)总额求和，并返回这个值。
**注意**: 如果Jing的挖矿节点把coinbase交易写入区块，那么如何防止Jing奖励自己100甚至1000比特币？ 答案是，不正确的奖励将被其他人视为无效，浪费了Jing用于工作证明的投入。 只有这个区块被大家认可，Jing才能得到报酬。
### 10.5.3创币交易的结构
经过计算，Jing的节点构造了一个创币交易，支付给自己25.09094928枚比特币。
例10-4所示，创币交易的结构比较特殊，与一般交易输入需要指定一个先前的UTXO不同，它包含一个“coinbase“输 入。在之前的章节中，我们已经给出了交易输入的结构。现在让我们来比较一下常规交易输入与创币交易输入。表10-1给出了常规交易输入的结构，表10-2给出的是创币交易输入的结构。
表10-1 常规交易输入结构
表10-2，coinbase交易输入结构
在Coinbase交易中，“交易哈希”字段32个字节全部填充0，“交易输出索引”字段全部填充0xFF\(十进制的255\)，这两个字段的值表示不引用UTXO。“解锁脚本”由coinbase数据代替，数据可以由矿工自定义。
### 10.5.4 Coinbase数据
创币交易不包含“解锁脚本“\(又称作 scriptSig\)字段，这个字段被coinbase数据替代，长度最小2字节，最大100字节。除 了开始的几个字节外，矿工可以任意使用coinbase的其他部分，随意填充任何数据。
以创世块为例，中本聪在coinbase中填入了这样的数据“The Times 03/Jan/ 2009 Chancellor on brink of second bailout for banks“\(泰晤士报 2009年1月3日 财政大臣将再次对银行施以援手\)，表示对日期的证明，同时也表达了对银行系统的不信任。现在，矿工使用coinbase数据实现extra nonce功能，并嵌入字符串来标识挖出它的矿池，这部分内容会在后面的小节描述。
coinbase前几个字节也曾是可以任意填写的，不过在后来的第34号比特币改进提议\(BIP34\)中 规定了版本2的区块（版本字段为2的区块），这个区块的高度必须跟在脚本操作“push“之后，填充在coinbase字段的起始处。
我们以例10-4中的区块277,316为例，coinbase就是交易输入的“解锁脚本“（或scriptSig）字段，这个字段的十六进制值 为03443b0403858402062f503253482f。下面让我们来解码这段数据。
第一个字节是03，脚本执行引擎执行这个指令将后面3个字节压入脚本栈,紧接着的3个字节——0x443b04， 是以小端格式\(最低有效字节在先\)编码的区块高度。翻转字节序得到0x043b44，表示为十进制是277,316。
紧接着的几个十六进制数（03858402062）用于编码extra nonce\(参见"10.11.1 随机值升位方案"\)，或者一个随机值，从而求解一个适当的工作量证明。
coinbase数据结尾部分\(2f503253482f\)是ASCII编码字符 /P2SH/，表示挖出这个区块的挖矿节点支持BIP0016所定义的 pay-to-script-hash\(P2SH\)改进方案。在P2SH功能引入到比特币的时候，曾经有过一场对P2SH不同实现方式的投票， 候选者是BIP0016和BIP0017。支持BIP0016的矿工将/P2SH/放入coinbase数据中，支持BIP0017的矿工将 p2sh/CHV 放入他们的coinbase数据中。最后，BIP0016在选举中胜出，直到现在依然有很多矿工在他们的coinbase中填 入/P2SH/以表示支持这个功能。
10-6使用了libbitcoin库（在之前“其他替代客户端、资料库、工具包”中提到）从创世块中提取coinbase数据，并显示 出中本聪留下的信息。libbitcoin库中自带了一份创世块的静态拷贝，所以这段示例代码可以直接取自库中的创世块数 据。
例10-6 从创世区块中提取coinbase数据
```
code/satoshi-words.cpp\[\]
```
例8-7中，我们使用GNU C++编译器编译源代码并运行得到的可执行文件,
例8-7 编译并运行satoshi-words示例代码
```
$ # Compile the code
$ g++ -o satoshi-words satoshi-words.cpp $(pkg-config --cflags --libs libbitcoin)
$ # Run the executable
$ ./satoshi-words
^D��
<
GS
>
^A^DEThe Times 03/Jan/2009 Chancellor on brink of second bailout for banks
```
## 10.6 构造区块头
为了构造区块头，挖矿节点需要填充六个字段，如表10-3中所示。
表10-3 区块头结构
在区块277,316被挖出的时候，区块结构中用来表示版本号的字段值为2，长度为4字节，以小端格式编码值为 0x20000000。
接着，挖矿节点需要填充“前区块哈希”，在本例中，这个值为Jing的节点从网络上接收到的区块277,315 的区块头哈希值，它是区块277316候选区块的父区块。区块277,315的区块头哈希值为：
```
0000000000000002a7bbd25a417c0374cc55261021e8a9ca74442b01284f0569
```
**提示**：通过选择候选块头中的先前块哈希字段指定的特定父区块，Jing正在通过确认挖矿能力来扩展区块链。 从本质上讲，这是用他的采矿权为最长难度的有效链进行的“投票”。
为了向区块头填充merkle根字段，要将全部的交易组成一个merkle树。创币交易作为区块中的首个交易，后将余下的 418笔交易添至其后，这样区块中的交易一共有419笔。在之前，我们已经见到过“Merkle树”，树中必须有偶数个叶子 节点，所以需要复制最后一个交易作为第420个叶子节点，每个叶子节点是对应交易的哈希值。这些交易的哈希值逐层地、成对地组合，直到最终组合并成一个根节点。merkle数的根节点将全部交易数据摘要为一个32字节长度的值，例10-3中 merkel根的值如下：
```
c91c008c26e50763e9f548bb8b2fc323735f73577effbc55502c51eb4cc7cf2e
```
挖矿节点会继续添加一个4字节的时间戳，以Unix纪元时间编码，即自1970年1月1日0点到当下总共流逝的秒数。本例 中的1388185914对应的时间是2013年12月27日，星期五，UTC/GMT。
接下来，Jing的节点需要填充Target字段（难度目标值），为了使得该区块有效，这个字段定义了所需满足的工作量证明的难度。难度在区块中以“尾数-指数”的格式，编码并存储，这种格式称作target bits（难度位）。这种编码的首字节表示指数，后面的3字节表示尾数\(系 数\)。以区块277316为例，难度位的值为0x1903a30c，0x19是指数的十六进制格式，后半部0x03a30c是系数。这部分的概念在后面的“难度目标与难度调整”和“难度表示”有详细的解释。
最后一个字段是nonce，初始值为0。
区块头完成全部的字段填充后，挖矿就可以开始进行了。挖矿的目标是找到一个使区块头哈希值小于难度目标的 nonce。挖矿节点通常需要尝试数十亿甚至数万亿个不同的nonce取值，直到找到一个满足条件的nonce值。
## 10.7 构建区块
既然Jing的节点已经构建了一个候选区块，那么就轮到Jing的矿机对这个新区块进行“挖掘”，求解工作量证明算法以使这个区块有效。从本书中我们已经学习了比特币系统中不同地方用到的哈希加密函数。比特币挖矿过程使用的是 SHA256哈希函数。
用最简单的术语来说，挖矿就是重复计算区块头的哈希值，不断修改该参数，直到与哈希值匹配的一个过程。哈希函数 的结果无法提前得知，也没有能得到一个特定哈希值的模式。哈希函数的这个特性意味着：得到哈希值的唯一方法是不断的尝试，每次随机修改输入，直到出现适当的哈希值。
### 10.7.1 工作量证明算法
哈希函数输入一个任意长度的数据，输出一个长度固定且绝不雷同的值，可将其视为输入的数字指纹。对于特定输入，哈希的结果每次都一样，任何人都可以用相同的哈希函数，计算和验证哈希结果。一个加密哈希函数的主要特征就是不同的 输入几乎不可能出现相同的数字指纹。因此，有意的选择一个输入去生成一个想要的哈希值值是几乎不可能的，更别提用随机的方式生成想要的哈希值了。
无论输入的大小是多少，SHA256函数的输出的长度总是256bit。在例10-8中，我们将使用Python解释器来计算语句 "I am Satoshi Nakamoto" 的SHA256的哈希值。
例10-8 SHA256示例
```
$ python
Python 2.7.1
>
>
>
import hashlib
>
>
>
print hashlib.sha256("I am Satoshi Nakamoto").hexdigest()
5d7c7ba21cbbcd75d14800b100252d5b428e5b1213d27c385bc141ca6b47989e
```
在例10-8中， 5d7c7ba21cbbcd75d14800b100252d5b428e5b1213d27c385bc141ca6b47989e 是"I am Satoshi Nakamoto"的哈希值。改变原句中的任何一个字母、标点、或增加字母都会产生不同的哈希值。
如果我们改变原句，得到的应该是完全不同的哈希值。 例如，我们在句子末尾加上一个数字，运行例10-9中的Python脚本。例10-9 通过反复修改 nonce 来生成不同哈希值的脚本（SHA256）
```
code/hash\_example.py\[\]
```
执行这个脚本就能生成这些只是末尾数字不同的语句的哈希值。例10-10 中显示了我们只是增加了这个数字，却得到了非 常不同的哈希值。
例10-10 通过反复修改nonce 来生成不同哈希值的脚本的输出
```
$ python hash_example.py
I am Satoshi Nakamoto0 =
>
a80a81401765c8eddee25df36728d732...
I am Satoshi Nakamoto1 =
>
f7bc9a6304a4647bb41241a677b5345f...
I am Satoshi Nakamoto2 =
>
ea758a8134b115298a1583ffb80ae629...
I am Satoshi Nakamoto3 =
>
bfa9779618ff072c903d773de30c99bd...
I am Satoshi Nakamoto4 =
>
bce8564de9a83c18c31944a66bde992f...
I am Satoshi Nakamoto5 =
>
eb362c3cf3479be0a97a20163589038e...
I am Satoshi Nakamoto6 =
>
4a2fd48e3be420d0d28e202360cfbaba...
I am Satoshi Nakamoto7 =
>
790b5a1349a5f2b909bf74d0d166b17a...
I am Satoshi Nakamoto8 =
>
702c45e5b15aa54b625d68dd947f1597...
I am Satoshi Nakamoto9 =
>
7007cf7dd40f5e933cd89fff5b791ff0...
I am Satoshi Nakamoto10 =
>
c2f38c81992f4614206a21537bd634a...
I am Satoshi Nakamoto11 =
>
7045da6ed8a914690f087690e1e8d66...
I am Satoshi Nakamoto12 =
>
60f01db30c1a0d4cbce2b4b22e88b9b...
I am Satoshi Nakamoto13 =
>
0ebc56d59a34f5082aaef3d66b37a66...
I am Satoshi Nakamoto14 =
>
27ead1ca85da66981fd9da01a8c6816...
I am Satoshi Nakamoto15 =
>
394809fb809c5f83ce97ab554a2812c...
I am Satoshi Nakamoto16 =
>
8fa4992219df33f50834465d3047429...
I am Satoshi Nakamoto17 =
>
dca9b8b4f8d8e1521fa4eaa46f4f0cd...
I am Satoshi Nakamoto18 =
>
9989a401b2a3a318b01e9ca9a22b0f3...
I am Satoshi Nakamoto19 =
>
cda56022ecb5b67b2bc93a2d764e75f...
```
每个语句都生成了一个完全不同的哈希值。它们看起来是完全随机的，但你在任何计算机上用Python执行上面的脚本都 能重现这些完全相同的哈希值。
类似这样在语句末尾的变化的数字叫做nonce（随机数）。Nonce是用来改变加密函数输出的，在这个示例中改变了这个语句的 SHA256指纹。
为了使这个哈希算法变得富有挑战，我们来设定一个具有任意性的目标：找到一个语句，使之哈希值的十六进制表示以 0开头。幸运的是，这很容易！在例10-10中语句 "I am Satoshi Nakamoto13" 的哈希值是 0ebc56d59a34f5082aaef3d66b37a661696c2b618e62432727216ba9531041a5 ，刚好满足条件。我们得到它用了13次。用概率的角度 来看，如果哈希函数的输出是平均分布的，我们可以期望每16次得到一个以0开头的哈希值（十六进制个位数字为0到 F）。从数字的角度来看，我们要找的是小于 0x1000000000000000000000000000000000000000000000000000000000000000 的哈希值。
我们称这个为Target目标阈值，我们的目的是找到一个小于这个目标的哈希值。如果我们减小这个目标值，那找到一个小于它的哈希值会越来越难。
简单打个比方，想象人们不断扔一对骰子以得到小于一个特定点数的游戏。第一局，目标是12。只要你不扔出两个6， 你就会赢。然后下一局目标为11。玩家只能扔10或更小的点数才能赢，不过也很简单。假如几局之后目标降低为了5。
现在有一半机率以上扔出来的骰子加起来点数会超过5，因此无效。随着目标越来越小，要想赢的话，扔骰子的次数会 指数级的上升。最终当目标为2时（最小可能点数），只有一个人平均扔36次或2%扔的次数中，他才能赢。从一个知道骰子游戏目标为2的观察者的角度来看，如果有人要成功中奖，假设他平均尝试了36次。
换句话说，可以估计从实现目标难度取得成功所需的工作量。 当算法是基于诸如SHA256的确定性函数时，输入本身就成为证据，必须要一定的工作量才能产生低于目标的结果。 因此，称之为工作量证明。
**提示**：尽管每次尝试产生一个随机的结果，但是任何可能的结果的概率可以预先计算。 因此，指定特定难度的结果构成了具体的工作量证明。
在例10-10中，成功的nonce为13，且这个结果能被所有人独立确认。任何人将13加到语句 "I am Satoshi Nakamoto" 后面再计算哈希值都能确认它比目标值要小。这个正确的结果同时也是工作量证明（Proof of Work），因为它证明我们的确花时间找到了这个nonce。验证这个哈希值只需要一次计算，而我们找到它却花了13次。如果目标值更小（难度更大），那我们需要多得多的哈希计算才能找到合适的nonce，但其他人验证它时只需要一次哈希计算。此外，知道目标值后，任何人都可以用统计学来估算其难度，因此就能知道找到这个nonce需要多少工作。
**提示**：工作证明必须产生小于目标的哈希值。 更高的目标意味着找到低于目标的哈希是不太困难的。 较低的目标意味着在目标下方找到哈希更难。 目标和难度是成反比。
比特币的工作量证明和例10-10中的挑战非常类似。矿工用一些交易构建一个候选区块。接下来，这个矿工计算这个区块头信息的哈希值，看其是否小于当前目标值。如果这个哈希值不小于目标值，矿工就会修改这个nonce（通常将之加 1）然后再试一次。按当前比特币系统的难度，矿工得试10^15次（10的15次方）才能找到一个合适的nonce使区块头信息哈希值足够小。
例10-11是一个简化很多的工作量证明算法的实现。
例10-11 简化的工作量证明算法
```
code/proof-of-work-example.py\[]
```
你可以任意调整难度值（按二进制bit数来设定，即哈希值开头多少个bit必须是0）。然后执行代码，看看在你的计算机 上求解需要多久。在例10-12中，你可以看到该程序在一个普通笔记本电脑上的执行情况。
例10-12 多种难度值的工作量证明算法的运行输出
```
$ python proof-of-work-example.py*
```
```
Difficulty: 1 (0 bits)
[...]
Difficulty: 8 (3 bits)
Starting search...
Success with nonce 9
Hash is 1c1c105e65b47142f028a8f93ddf3dabb9260491bc64474738133ce5256cb3c1
Elapsed Time: 0.0004 seconds
Hashing Power: 25065 hashes per second
Difficulty: 16 (4 bits)
Starting search...
Success with nonce 25
Hash is 0f7becfd3bcd1a82e06663c97176add89e7cae0268de46f94e7e11bc3863e148
Elapsed Time: 0.0005 seconds
Hashing Power: 52507 hashes per second
Difficulty: 32 (5 bits)
Starting search...
Success with nonce 36
Hash is 029ae6e5004302a120630adcbb808452346ab1cf0b94c5189ba8bac1d47e7903
Elapsed Time: 0.0006 seconds
Hashing Power: 58164 hashes per second
[...]
Difficulty: 4194304 (22 bits)
Starting search...
Success with nonce 1759164
Hash is 0000008bb8f0e731f0496b8e530da984e85fb3cd2bd81882fe8ba3610b6cefc3
Elapsed Time: 13.3201 seconds
Hashing Power: 132068 hashes per second
Difficulty: 8388608 (23 bits)
Starting search...
Success with nonce 14214729
Hash is 000001408cf12dbd20fcba6372a223e098d58786c6ff93488a9f74f5df4df0a3
Elapsed Time: 110.1507 seconds
Hashing Power: 129048 hashes per second
Difficulty: 16777216 (24 bits)
Starting search...
Success with nonce 24586379
Hash is 0000002c3d6b370fccd699708d1b7cb4a94388595171366b944d68b2acce8b95
Elapsed Time: 195.2991 seconds
Hashing Power: 125890 hashes per second
[...]
Difficulty: 67108864 (26 bits)
Starting search...
Success with nonce 84561291
Hash is 0000001f0ea21e676b6dde5ad429b9d131a9f2b000802ab2f169cbca22b1e21a
Elapsed Time: 665.0949 seconds
Hashing Power: 127141 hashes per second
```
你可以看出，随着难度位一位一位地增加，查找正确结果的时间会呈指数级增长。如果你考虑整个256bit数字空间，每次要求多一个0，你就把哈希查找空间缩减了一半。在例10-12中，为寻找一个nonce使得哈希值开头的26位值为0，一共尝试了8千多万次。即使家用笔记本每秒可以达270,000多次哈希计算，这个查找依然需要10分钟。
在写这本书的时候，比特币网络要寻找区块头信息哈希值小于
```
0000000000000000029AB9000000000000000000000000000000000000000000
```
可以看出，这个目标哈希值开头的0多了很多。这意味 着可接受的哈希值范围大幅缩减，因而找到正确的哈希值更加困难。生成下一个区块需要网络每秒计算1.8 septa-hashes（\(thousand billion billion次哈希）。这看起来像是不可能的任务，但幸运的是比特币网络已经拥有3EH/sec的处理能力，平均每10分钟就可以找到一个新区块。
### 10.7.2 难度表示
在例10-3中，我们在区块中看到难度目标，其被标为"难度位"或简称"bits"。在区块277,316中，它的值为 0x1903a30c。 这个标记的值被存为系数/指数格式，前两位十六进制数字为幂（exponent），接下来得六位为系数（coefficient）。在这个区块里，0x19为幂，而 0x03a30c为系数。
计算难度目标的公式为：
```
target = coefficient \* 2^\(8 \* \(exponent – 3\)\)
```
由此公式及难度位的值 0x1903a30c，可得：
```
target = 0x03a30c * 2^(0x08 * (0x19 - 0x03))^
=
>
target = 0x03a30c * 2^(0x08 * 0x16)^
=
>
target = 0x03a30c * 2^0xB0^
```
按十进制计算为：
```
=
>
target = 238,348 * 2^176^
=
>
target = 22,829,202,948,393,929,850,749,706,076,701,368,331,072,452,018,388,575,715,328
```
转化为十六进制后为：
```
=
>
target = 0x0000000000000003A30C00000000000000000000000000000000000000000000
```
也就是说高度为277,316的有效区块的头信息哈希值是小于这个目标值的。这个数字的二进制表示中前60位都是0。在 这个难度上，一个每秒可以处理1万亿个哈希计算的矿工（1 tera-hash per second 或 1 TH/sec）平均每8,496个区块才能找到一个正确结果，换句话说，平均每59天，才能为某一个区块找到正确的哈希值。
### 10.7.3 难度目标与难度调整
如前所述，目标决定了难度，进而影响求解工作量证明算法所需要的时间。那么问题来了：为什么这个难度值是可调整 的？由谁来调整？如何调整？
比特币的区块平均每10分钟生成一个。这就是比特币的心跳，是货币发行速率和交易达成速度的基础。不仅是在短期内，而是在几十年内它都必须要保持恒定。在此期间，计算机性能将飞速提升。此外，参与挖矿的人和计算机也会不断 变化。为了能让新区块的保持10分钟一个的产生速率，挖矿的难度必须根据这些变化进行调整。事实上，难度是一个动 态的参数，会定期调整以达到每10分钟一个新区块的目标。简单地说，难度被设定在，无论挖矿能力如何，新区块产生 速率都保持在10分钟一个。
那么，在一个完全去中心化的网络中，这样的调整是如何做到的呢？难度的调整是在每个完整节点中独立自动发生的。 每2,016个区块中的所有节点都会调整难度。难度的调整公式是由最新2,016个区块的花费时长与20,160分钟（即 这些区块以10分钟一个速率所期望花费的时长）比较得出的。难度是根据实际时长与期望时长的比值进行相应调整的 （或变难或变易）。简单来说，如果网络发现区块产生速率比10分钟要快时会增加难度。如果发现比10分钟慢时则降低难度。
这个公式可以总结为如下形式：
```
New Difficulty = Old Difficulty \* \(Actual Time of Last 2016 Blocks / 20160 minutes\)
```
例10-13展示了比特币核心客户端中的难度调整代码。
例10-13 工作量证明的难度调整 源文件**\( pow.cpp文件钟的CalculateNextWorkRequired\(\) 函数\)**
第43行函数 GetNextWorkRequired\(\)// Limit adjustment step
```
// Limit adjustment step
int64_t nActualTimespan = pindexLast-
>
GetBlockTime() - nFirstBlockTime;
LogPrintf(" nActualTimespan = %d before bounds\n", nActualTimespan);
if (nActualTimespan
<
params.nPowTargetTimespan/4)
nActualTimespan = params.nPowTargetTimespan/4;
if (nActualTimespan
>
params.nPowTargetTimespan*4)
nActualTimespan = params.nPowTargetTimespan*4;
// Retarget
const arith_uint256 bnPowLimit = UintToArith256(params.powLimit);
arith_uint256 bnNew;
arith_uint256 bnOld;
bnNew.SetCompact(pindexLast-
>
nBits);
bnOld = bnNew;
bnNew *= nActualTimespan;
bnNew /= params.nPowTargetTimespan;
if (bnNew
>
bnPowLimit)
bnNew = bnPowLimit;
```
**注意**：虽然目标校准每2,016个块发生，但是由于Bitcoin Core客户端的一个错误，它是基于之前的2,015个块的总时间（不应该是2,016个），导致重定向偏差向较高难度提高0.05％。
参数Interval\(2,016区块\)和TargetTimespan\(1,209,600秒即两周\)的定义在文件chainparams.cpp中。
为了防止难度的变化过快，每个周期的调整幅度必须小于一个因子（值为4）。如果要调整的幅度大于4倍，则按4倍调 整。由于在下一个2,016区块的周期不平衡的情况会继续存在，所以进一步的难度调整会在下一周期进行。因此平衡哈 希计算能力和难度的巨大差异有可能需要花费几个2,016区块周期才会完成。
**提示**：寻找一个比特币区块需要整个网络花费10分钟来处理，每发现2,016个区块时会根据前2,016个区块完成的时间对难度进行调整。
值得注意的是目标难度与交易的数量和金额无关。这意味着哈希算力的强弱，即让比特币更安全的电力投入量，与交易 的数量完全无关。换句话说，当比特币的规模变得更大，使用它的人数更多时，即使哈希算力保持当前的水平，比特币 的安全性也不会受到影响。哈希算力的增加表明更多的人为得到比特币回报而加入了挖矿队伍。只要为了回报，公平正 当地从事挖矿的矿工群体保持足够的哈希算力，"接管"攻击就不会得逞，让比特币的安全无虞。
目标难度和挖矿电力消耗与将比特币兑换成现金以支付这些电力之间的关系密切相关。高性能挖矿系统就是要用当前硅 芯片以最高效的方式将电力转化为哈希算力。挖矿市场的关键因素就是每度电转换为比特币后的价格。因为这决定着挖 矿活动的营利性，也因此刺激着人们选择进入或退出挖矿市场。
## 10.8 成功构建区块
前面已经看到，Jing的节点创建了一个候选区块，准备拿它来挖矿。Jing有几个安装了ASIC（专用集成电路）的矿机， 上面有成千上万个集成电路可以超高速地并行运行SHA256算法。这些定制的硬件通过USB连接到他的挖矿节点上。接 下来，运行在Jing的桌面电脑上的挖矿节点将区块头信息传送给这些硬件，让它们以每秒亿万次的速度进行nonce测 试。
在对区块277,316的挖矿工作开始大概11分钟后，这些硬件里的其中一个求得了解并发回挖矿节点。当把这个结果放进 区块头时，nonce 4,215,469,401 就会产生一个区块哈希值：
```
0000000000000002a7bbd25a417c0374cc55261021e8a9ca74442b01284f0569
```
而这个值小于难度目标值：
```
0000000000000003A30C00000000000000000000000000000000000000000000
```
Jing的挖矿节点立刻将这个区块发给它的所有相邻节点。这些节点在接收并验证这个新区块后，也会继续传播此区块。当这个新区块在网络中扩散时，每个节点都会将它作为区块277,316加到自身节点的区块链副本中。当挖矿节点收到并验证了这个新区块后，它们会放弃之前对构建这个相 同高度区块的计算，并立即开始计算区块链中下一个区块的工作。
下节将介绍节点进行区块验证、最长链选择、达成共识，并以此形成一个去中心化区块链的过程。
## 10.9 校验新区块
比特币共识机制的第三步是通过网络中的每个节点独立校验每个新区块。当新区块在网络中传播时，每一个节点在将它转发到其节点之前，会进行一系列的测试去验证它。这确保了只有有效的区块会在网络中传播。独立校验还确保了诚实 的矿工生成的区块可以被纳入到区块链中，从而获得奖励。行为不诚实的矿工所产生的区块将被拒绝，这不但使他们失 去了奖励，而且也浪费了本来可以去寻找工作量证明解的机会，因而导致其电费亏损。
当一个节点接收到一个新的区块，它将对照一个长长的标准清单对该区块进行验证，若没有通过验证，这个区块将被拒绝。这些标准可以在比特币核心客户端的CheckBlock函数和CheckBlockHead函数中获得，
它包括：
▷ 区块的数据结构语法上有效
▷ 区块头的哈希值小于目标难度（确认包含足够的工作量证明）
▷ 区块时间戳早于验证时刻未来两个小时（允许时间错误）
▷ 区块大小在长度限制之内
▷ 第一个交易（且只有第一个）是coinbase交易
▷ 使用检查清单验证区块内的交易并确保它们的有效性
参见之前章节 “交易的独立校验”一节已经讨论过这个清单。每一个节点对每一个新区块的独立校验，确保了矿工无法欺诈。在前面的章节中，我们看到了矿工们如何去记录一笔交 易，以获得在此区块中创造的新比特币和交易费。为什么矿工不为他们自己记录一笔交易去获得数以千计的比特币？这是因为每一个节点根据相同的规则对区块进行校验。一个无效的coinbase交易将使整个区块无效，这将导致该区块被拒 绝，因此，该交易就不会成为总账的一部分。矿工们必须构建一个完美的区块，基于所有节点共享的规则，并且根据正 确工作量证明的解决方案进行挖矿，他们要花费大量的电力挖矿才能做到这一点。如果他们作弊，所有的电力和努力都 会浪费。这就是为什么独立校验是去中心化共识的重要组成部分。
## 10.10 区块链的组装与选择
比特币去中心化的共识机制的最后一步是将区块集合至有最大工作量证明的链中。一旦一个节点验证了一个新的区块， 它将尝试将新的区块连接到到现存的区块链，将它们组装起来。
节点维护三种区块：第一种是连接到主链上的，第二种是从主链上产生分支的（备用链），最后一种是在已知链中没有 找到已知父区块的。在验证过程中，一旦发现有不符合标准的地方，验证就会失败，这样区块会被节点拒绝，所以也不 会加入到任何一条链中。
任何时候，主链都是累计了最多难度的区块链。在一般情况下，主链也是包含最多区块的那个链，除非有两个等长的链 并且其中一个有更多的工作量证明。主链也会有一些分支，这些分支中的区块与主链上的区块互为“兄弟”区块。这些区 块是有效的，但不是主链的一部分。 保留这些分支的目的是如果在未来的某个时刻它们中的一个延长了并在难度值上超 过了主链，那么后续的区块就会引用它们。在“10.10.1 区块链分叉”，我们将会看到在同样的区块高度，几乎同时挖出区 块时，候选链是如何产生的。
当节点接收到新区块，它会尝试将这个区块插入到现有区块链中。节点会看一下这个区块的“previous block hash”字 段，这个字段是该区块对其父区块的引用。同时，新的节点将尝试在已存在的区块链中找出这个父区块。大多数情况 下，父区块是主块链的“顶点”，这就意味着这个新的区块延长了主链。举个例子，一个新的区块——区块277,316引用 了它的父区块——区块277,315。收到277316区块的大部分节点都已经将277315最为主链的顶端，因此，连接这个新区块并延长区块链。
有时候，新区块所延长的区块链并不是主链，这一点我们将在“10.10.1 区块链分叉”中看到。在这种情况下，节点将新的区块添加到备用链，同时比较备用链与主链的难度。如果备用链比主链积累了更多的难度，节点将收敛于备用链，意味 着节点将选择备用链作为其新的主链，而之前那个老的主链则成为了备用链。如果节点是一个矿工，它将开始构造新的 区块，来延长这个更新更长的区块链。
如果节点收到了一个有效的区块，而在现有的区块链中却未找到它的父区块，那么这个区块被认为是“孤块”。孤块会被 保存在孤块池中，直到它们的父区块被节点收到。一旦收到了父区块并且将其连接到现有区块链上，节点就会将孤块从 孤块池中取出，并且连接到它的父区块，让它作为区块链的一部分。当两个区块在很短的时间间隔内被挖出来，节点有 可能会以相反的顺序接收到它们，这个时候孤块现象就会出现。
选择了最大难度的区块链后，所有的节点最终在全网范围内达成共识。随着更多的工作量证明被添加到链中，链的暂时 性差异最终会得到解决。挖矿节点通过“投票”来选择它们想要延长的区块链，当它们挖出一个新块并且延长了一个链， 新块本身就代表它们的投票。
相互竞争的链之间是存在差异的，下节我们将看到节点是怎样通过独立选择最长难度链来解决这种差异的。
### 10.10.1 区块链分叉
因为区块链是去中心化的数据结构，所以不同副本之间不能总是保持一致。区块有可能在不同时间到达不同节点，导致节点有不同的区块链全貌。解决的办法是，每一个节点总是选择并尝试延长代表累计了最大工作量证明的区块链，也就 是最长的或最大累计工作的链（greatest cumulative work chain）。节点通过累加链上的每个区块的工作量，得到建立这个链所要付出的工作量证明的总量。只要所有的节点选择最长累计工作的区块链，整个比特币网络最终会收敛到一致的状态。分叉即在不同区块链间发生的临时差异，当更多的区块添加到了某个分叉中，这个问题便会迎刃而解。
**提示**由于全球网络中的传输延迟，本节中描述的区块链分叉自动会发生。 我们也将在本章稍后再看看故意引起的分叉。
在接下来的几个图表中，我们将通过网络跟踪“fork”事件的进展。 该图是比特币网络的简化表示。 为了便于描述，不同的区块被显示为不同的形状（星形，三角形，倒置三角形，菱形），遍布网络。 网络中的每个圆表示一个节点。
每个节点都有自己的全局区块链视图。 当每个节点从其邻居接收区块时，它会更新其自己的区块链副本，选择最大累积工作链。 为便于描述，每个节点包含一个图形形状，表示它相信的区块处于主链的顶端。 因此，如果在节点里面看到星形，那就意味着该节点认为星形区块处于主链的顶端。
在第一张图（图10-2）中，网络有一个统一的区块链视角，以星形区块为主链的“顶点”。
图10-2
当有两个候选区块同时想要延长最长区块链时，分叉事件就会发生。正常情况下，分叉发生在两名矿工在较短的时间 内，各自都算得了工作量证明解的时候。两个矿工在各自的候选区块一发现解，便立即传播自己的“获胜”区块到网络 中，先是传播给邻近的节点而后传播到整个网络。每个收到有效区块的节点都会将其并入并延长区块链。如果该节点在 随后又收到了另一个候选区块，而这个区块又拥有同样父区块，那么节点会将这个区块连接到候选链上。其结果是，一 些节点收到了一个候选区块，而另一些节点收到了另一个候选区块，这时两个不同版本的区块链就出现了。在图10-3中，我们看到两个矿工（NodeX和NodeY）几乎同时挖到了两个不同的区块。这两个区块是顶点区块——星形区块的子区块，可以 延长这个区块链。为了方便查看，我们把节点X产生的区块标记为三角形，把节点Y生产的区块标记为倒三角形。
图10-3
例如，我们假设矿工节点X找到扩展区块链工作量证明的解，即三角形区块，构建在星形父区块的顶端。与此同时，同样进行星形区块扩展的节点Y也找到了扩展区块链工作量证明的解，即倒三角形区块作为候选区块。现在有两个可能的块，节点X的三角形区块和节点Y的倒三角形区块，这两个区块都是有效的，均包含有效的工作量证明解并延长同一 个父区块。这个两个区块可能包含了几乎相同的交易，只是在交易的排序上有些许不同。
当两个区块开始在网络传播时，一些节点首先接收到三角形区块，另外一些节点首先接收倒三角形区块。如下图10-4所示，比特币网络上的节点对于区块链的顶点产生了分歧，一派以三角形区块为顶点，而另一派以倒三角形区块为顶点。
图10-4
在图中，假设节点X首先接收到三角形块，并用它扩展星形链。节点X选择三角形区块为主链。之后，节点X也收到倒三角区块。由于是第二次收到，因此它判定这个倒三角形区块是竞争失败的产物，认为是无效区块。然而，倒三角形的区块不会被丢弃。它被链接到星形链的父区块，并形成备用链。虽然节点X认为自己已经正确选择了获胜链，但是它还会保存“丢失”链，使得“丢失”链如果可能最终“获胜”，它还具有重新打包的所需的信息。
在网络的另一端，节点Y根据自己的视角构建一个区块链。首先获得倒三角形区块，并选择这条链作为“赢家”。当它稍后收到三角形区块时，它也将三角形区块连接到星形链的父区块作为备用链。
双方都是“正确的”或“不正确的”。两者都是自己关于区块链的有效立场。只有事后，才能理解这两个竞争链如何通过额外的工作得到延伸。
节点X阵营的其他节点将立即开始挖掘候选区块，以“三角形”作为扩展区块链的顶端。通过将三角形作为候选区块的父区块，它们用自己的哈希算力进行投票。它们的投票标明支持自己选择的链为主链。
同样，节点Y阵营的其他节点，将开始构建一个以倒三角形作为其父节点的候选节点，扩展它们认为是主链的链。比赛再次开始。分叉问题几乎总是在一个区块内就被解决了。网络中的一部分算力专注于“三角形”区块为父区块，在其之上建立新的区 块；另一部分算力则专注在“倒三角形”区块上。即便算力在这两个阵营中平均分配，也总有一个阵营抢在另一个阵营前发现工作量证明解并将其传播出去。在这个例子中我们可以打个比方，假如工作在“三角形”区块上的矿工找到了一个“菱形”区块 延长了区块链\(星形-三角形-菱形\)，他们会立刻传播这个新区块，整个网络会都会认为这个区块是有效的，如下图10-5所示。
图10-5
选择“三角形”作为上一轮中胜出者的所有节点将简单地将区块链扩展一个块。然而，选择“倒三角”的节点现在将看到两个链：星形-三角形-菱形和星型-到三角形。星形-三角形-菱形这条链现在比其他链条更长（更多累积的工作）。因此，这些节点将星形-三角形-菱形设置为主链，并将星型-倒三角形链变为备用链，如图10-6所示。这是一个链的重新共识，因为这些节点被迫修改他们对块链的立场，把自己纳入更长的链。任何从事延伸星形-倒三角形的矿工现在都将停止这项工作，因为他们的候选人是“孤儿”，因为他们的父母“倒三角形”不再是最长的连锁。 “倒三角形”内的交易重新插入到内存池中用来包含在下一个块中，因为它们所在的块不再位于主链中。整个网络重新回到单一链状态，星形-三角形-菱形，“菱形”成为链中的最后一个块。所有矿工立即开始研究以“菱形”为父区块的候选块，以扩展这条星形-三角形-菱形链。
图10-6
从理论上来说，两个区块的分叉是有可能的，这种情况发生在因先前分叉而相互对立起来的矿工，又几乎同时发现了两 个不同区块的解。然而，这种情况发生的几率是很低的。单区块分叉每周都会发生，而双块分叉则非常罕见。比特币将区块间隔设计为10分钟，是在更快速的交易确认和更低的分叉概率间作出的妥协。更短的区块产生间隔会让交 易清算更快地完成，也会导致更加频繁地区块链分叉。与之相对地，更长的间隔会减少分叉数量，却会导致更长的清算时间。
## 10.11 挖矿和算力竞赛
比特币挖矿是一个极富竞争性的行业。自从比特币存在开始，每年比特币算力都成指数增长。一些年份的增长
