使用 Go 语言打造区块链（二）

sheldonhuang (50)in #cn • 7 years ago (edited)

关于第一篇：参见笑来老师翻译的版本：
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开始。
获取数据+计数器组合的哈希值。
检查哈希值是否符合要求。
1. 如果满足要求，结束过程。
2. 如果不满足要求，增加计数器并重复步骤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。

big: https://golang.org/pkg/math/big/

在新的工作证明的函数中，我们初始化一个值为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.