使用 Go 语言打造区块链（二）
关于 第一篇： 参见笑来老师翻译的版本：
lixiaolai.com/2017/09/28/building-blockchain-in-go-part-1/
- 作者：Ivan Kuznetsov
- 中文翻译：晓顿
- 原文链接：https://jeiwan.cc/posts/building-blockchain-in-go-part-2/
- 介绍
- 工作证明
- 哈希算法
- 如何实施
1. 介绍
在上一篇文章中，我们构建了一个非常简单的数据结构，这是区块链数据库的本质。 而且我们可以用它们之间的链接向它添加区块：每个区块与前一个链接。 唉，然而在现实中添加一个区块添加到链是需要高成本的工作。
2. 工作证明
区块链的一个关键思想是，必须通过工作证明才能将数据放入其中。这是一个艰巨的工作，使块链安全和一致。此外，这笔辛苦的工作也得到了奖励（这是人们获得采矿硬币的方式）。
这种机制与现实生活中的机制非常相似：人们必须工作获酬劳励并维持生命。在网络中，网络的一些参与者（矿工）努力维持网络，为其添加新的块，并为他们的工作获得奖励。作为其工作的结果，块以安全的方式并入到块链中，这保持了整个块链数据库的稳定性。值得注意的是，完成工作的人必须证明这一点。
这个整体“努力工作和证明工作价值”机制被称为工作证明。这很难因为它需要很多的计算能力：即使是高性能的计算机也不能很快的完成。此外，这项工作的难度不时增加，以保持新的块率每小时大约6个块。在比特币，这样的工作的目标是找到一个块的哈希，满足一些要求。这是散列，作为证明。因此，找到证据是实际工作。
最后要注意的事情。工作证明算法必须满足要求：工作不易，证明容易。证明通常交给非工作者，所以对他们来说，验证它不应该花太多的时间。
3. 哈希算法
在本文中，我们将讨论哈希算法。 如果你熟悉这个概念，你可以跳过这个部分。
哈希是获取指定数据的哈希值的过程。 哈希值是对其计算的数据的唯一表示。 哈希函数是一个获取任意大小的数据并产生固定大小的哈希的函数。 以下是哈希的一些主要功能：
- 原始数据无法从哈希值恢复。 因此，哈希过程不是加密。
- 数据只能有一个与之对应的哈希值，因此哈希是唯一的。
- 更改输入数据中的一个字节将导致完全不同的散列。
Hashing functions are widely used to check the consistency of data. Some software providers publish checksums in addition to a software package. After downloading a file you can feed it to a hashing function and compare produced hash with the one provided by the software developer.
In blockchain, hashing is used to guarantee the consistency of a block. The input data for a hashing algorithm contains the hash of the previous block, thus making it impossible (or, at least, quite difficult) to modify a block in the chain: one has to recalculate its hash and hashes of all the blocks after it.
哈希函数被广泛用于检查数据的一致性。在区块链中，使用哈希来保证块的一致性。 哈希算法的输入数据包含前一个块的哈希值，从而使得已经生成的链难以修改之前产生的区块（或至少相当困难）：篡改一个区块必须重新计算其前的所有块的哈希值。
译者注： genesis block的previous block是空
哈希现金
比特币使用Hashcash，哈希现金的发明最初是为防止电子邮件垃圾邮件而开发的。它可以分为以下几个步骤：
- 获取公开的数据（在电子邮件的情况下，它是接收者的电子邮件地址;在比特币的情况下，它是块标题）。
- 添加一个计数器。计数器从0开始。
- 获取
数据+计数器组合的哈希值。 - 检查哈希值是否符合要求。
- 如果满足要求，结束过程。
- 如果不满足要求，增加计数器并重复步骤3和4。
因此，这是一个强力brute force算法：
1. 计算一个新的哈希
2. 检查该哈希值
3. 增加计数器
现在让我们看看一个哈希必须满足的要求。在原来的Hashcash实现中“哈希的前20位必须是零”。然而在比特币中，哈希要求是不时进行调整的，因为尽管计算能力随着时间的推移而增加，越来越多的矿工加入网络，因此设计必须每10分钟生成一个块。
4. 编写代码
程序员小提醒：go和python都是不用加分号的语言
好的，我们完成了理论，让我们编写代码！ 首先，我们来定义挖掘难度：
const targetBits = 24
4.1 目标位
在比特币中，“目标位（target bit）”是存储块被挖掘的困难的头部数据。 我们现在不会实现目标调整算法，所以我们可以将难度定义为全局常数。
24是一个任意数字，我们的目标是在内存中占用少于256位的目标。 而且我们希望差异足够大，但不要太大，因为差异越大，找到合适的哈希越难。
// 工作证明
type ProofOfWork struct {
block *Block
target *big.Int //定义目标位
}
// 新的工作证明
func NewProofOfWork(b *Block) *ProofOfWork {
target := big.NewInt(1)
target.Lsh(target, uint(256-targetBits)) //用于随机产生target，目标数值！！！这里从数学上保证了
// Lsh: local sensitivity hashing
//左移256个 target bits位
pow := &ProofOfWork{b, target}
return pow
}
译者注：这里从数学上保证了miner必须使用brute force的方式最终发现target：https://github.com/ekzhu/lsh
这里创建工作证明结构中保存指向区块的指针的和指向target的指针。 “target”是上一段所述要求的另一个名称。 我们使用一个大整数，因为我们将哈希与目标进行比较：我们将哈希转换为一个大整数，并检查它是否小于target。
在新的工作证明的函数中，我们初始化一个值为1的big.Int，并将其左移256个 - targetBits位。 256是SHA-256哈希的长度，以比特为单位，它是我们要使用的SHA-256散列算法。 目标的十六进制表示为：
0x10000000000000000000000000000000000000000000000000000000000
它在内存中占用29个字节。 这是与以前的例子中的哈希的比较：
0fac49161af82ed938add1d8725835cc123a1a87b1b196488360e58d4bfb51e3
0000010000000000000000000000000000000000000000000000000000000000
0000008b0f41ec78bab747864db66bcb9fb89920ee75f43fdaaeb5544f7f76ca
第一个哈希（以“我喜欢甜甜圈”计算）大于目标，因此它不是有效的工作证明。 第二个哈希（以“我喜欢甜甜圈ca07ca”计算）小于目标，因此这是一个有效的证明。
您可以将目标视为范围的上限：如果数字（哈希）低于边界，则它是有效的，反之亦然。 降低边界将导致有效数量减少，因此找到有效数量所需的工作更加困难。
4.2 准备数据
//准备数据，加入targetBits和nonce
func (pow *ProofOfWork) prepareData(nonce int) []byte {
data := bytes.Join(
[][]byte{
pow.block.PrevBlockHash,
pow.block.Data,
IntToHex(pow.block.Timestamp),
IntToHex(int64(targetBits)),
IntToHex(int64(nonce)),
},
[]byte{},
)
return data
}
4.3 工作证明
func (pow *ProofOfWork) Run() (int, []byte) {
var hashInt big.Int
var hash [32]byte
nonce := 0
fmt.Printf("Mining the block containing \"%s\"\n", pow.block.Data)
// nounce 是counter
for nonce < maxNonce { // maxNounce被设置成math.MaxInt64，防止溢出
data := pow.prepareData(nonce) // 1. prepare data
hash = sha256.Sum256(data) // 2. sha256 hash：https://golang.org/pkg/crypto/sha256/#Sum256
fmt.Printf("\r%x", hash)
hashInt.SetBytes(hash[:]) // 3. 从hexidecimal 转换成 big INT
//执行这个for loop直到找到hashInt和target相等
if hashInt.Cmp(pow.target) == -1 { // 4. Compare integer with the target
break
} else {
nonce++
}
}
fmt.Print("\n\n")
return nonce, hash[:]
}
4.4. 给NewBlock() 加入nounce和工作证明
移除SetHash，并更改NewBlock：
- 产生新区块
- 工作证明
func NewBlock(data string, prevBlockHash []byte) *Block {
block := &Block{time.Now().Unix(), []byte(data), prevBlockHash, []byte{}, 0}
// 工作证明
pow := NewProofOfWork(block)
nonce, hash := pow.Run()
block.Hash = hash[:]
block.Nonce = nonce
return block
}
nonce被加入到Block结构中
type Block struct {
Timestamp int64
Data []byte
PrevBlockHash []byte
Hash []byte
Nonce int // 用于验证
}
4.5. 验证工作证明 validate()
func (pow *ProofOfWork) Validate() bool {
var hashInt big.Int
data := pow.prepareData(pow.block.Nonce) // 验证
hash := sha256.Sum256(data)
hashInt.SetBytes(hash[:])
isValid := hashInt.Cmp(pow.target) == -1 //检查产生的Big Int hashInt是否和target相当
return isValid
}
func main() {
...
for _, block := range bc.blocks {
...
pow := NewProofOfWork(block)
fmt.Printf("PoW: %s\n", strconv.FormatBool(pow.Validate())) //验证工作证明
fmt.Println()
}
}
Output:
...
Prev. hash:
Data: Genesis Block
Hash: 00000093253acb814afb942e652a84a8f245069a67b5eaa709df8ac612075038
PoW: true
Prev. hash: 00000093253acb814afb942e652a84a8f245069a67b5eaa709df8ac612075038
Data: Send 1 BTC to Ivan
Hash: 0000003eeb3743ee42020e4a15262fd110a72823d804ce8e49643b5fd9d1062b
PoW: true
Prev. hash: 0000003eeb3743ee42020e4a15262fd110a72823d804ce8e49643b5fd9d1062b
Data: Send 2 more BTC to Ivan
Hash: 000000e42afddf57a3daa11b43b2e0923f23e894f96d1f24bfd9b8d2d494c57a
PoW: true
5. 总结
我们的块链是一个更接近其实际架构的一步：添加块现在需要工作证明，因此mining是可能的。但是它仍然缺乏一些关键的特征：块链数据库不是持久性数据，没有钱包，地址，交易，没有共识机制。所有这些我们将在以后的文章中实现。
persistence refers to the characteristic of state that outlives the process that created it. This is achieved in practice by storing the state as data in computer data storage.
Links:
番外
不同branches中保存着各个阶段的代码
学习更多golang的知识: https://golang.org/
关于如何Compile一个golang project