使用 Go 语言打造区块链(二)

in #cn7 years ago (edited)

关于 第一篇: 参见笑来老师翻译的版本:
lixiaolai.com/2017/09/28/building-blockchain-in-go-part-1/

  1. 介绍
  2. 工作证明
  3. 哈希算法
  4. 如何实施

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,哈希现金的发明最初是为防止电子邮件垃圾邮件而开发的。它可以分为以下几个步骤:

  1. 获取公开的数据(在电子邮件的情况下,它是接收者的电子邮件地址;在比特币的情况下,它是块标题)。
  2. 添加一个计数器。计数器从0开始。
  3. 获取数据+计数器组合的哈希值
  4. 检查哈希值是否符合要求。
    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:

  1. 产生新区块
  2. 工作证明
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:

  1. Full source codes
  2. Blockchain hashing algorithm
  3. Proof of work
  4. Hashcash

番外

不同branches中保存着各个阶段的代码


学习更多golang的知识: https://golang.org/
关于如何Compile一个golang project

Sort:  

Hi! I am a robot. I just upvoted you! I found similar content that readers might be interested in:
https://www.dlxedu.com/detail/25/480187.html