打造公链-造轮子（2）

工作量证明（Proof-of-Work）

要往区块链中写入一个新的区块，需要获得大部分节点的认同，也就是要取得共识，
有一种方式就是付出巨大的代价，完成一些非常困难的工作，这样获得记账（写入区块）
的权力，这样就是通过工作量证明的方式达成共识。

通过完成这样一系列困难的工作，保证区块链的安全和一致，完成这样的工作就会获得奖励（也就是挖矿）。
当然完成困难工作是需要自己证明这一点的，这就是（Proof-of-Work）。

哈希计算

在区块链中，哈希被用来保证一个块的一致性。哈希算法的输入数据包含了另一个块的哈希，因此使得不太可能
去修改链中的一个块，因此如果想作弊修改一个块的哈希，那么必须重新计算这个块以及后面所有快的哈希。
也就是说需要强行将别人的工作量证明推翻，也就是我们所说的51%攻击。

Hashcash

Hashcash，一个最初用来防止垃圾邮件的工作量证明算法。可以分解为以下步骤：

• 取一些公开的数据，比如比特币的区块头
• 给这公开数据添加一个计算器，默认从0开始
• 将数据和计算器组合，获得一个hash
• 检查哈希是否符合一定的条件：
  • 如果符合条件，结束
  • 如果不符合，增加计算器，重复3-4步

实现

首先，定义挖矿的难度值

const targetBits = 24
// 24指的是计算出来的哈希前24位必须是0，如果用16进制，前6位必须是0.
// 当然24是固定的，实际是可以调整的

然后，构造ProofOfWork结构

type ProofOfWork struct {
    block *Block
    target *big.Int
}
func NewProofOfWork(block *Block) *ProofOfWork {
    target := big.NewInt(1)
    target.Lsh(target,uint(256-targetBits))
    pow := &ProofOfWork{block,target}
    return pow
}
// ProofOfWork结构，存储了指向一个块（block）和一个目标（target）的指针。目标也就是必要条件，使用一个大整数，
// 将哈希和目标进行比较：先把哈希转成一个大整数，然后检测它是否小于目标
// 将bit.Int初始化为1，然后左移256-targetBits位

main.go

package main

import (
    "time"
    "math/big"
    "crypto/sha256"
    "fmt"
    "math"
    "bytes"
    "encoding/binary"
    "log"
    "strconv"
)

// 难度值，表示哈希的前24位必须是0，16进制表示前6位是0
const targetBits = 24
const maxNonce  = math.MaxInt64

type Block struct {
    Timestamp   int64
    PrevBlockHash   []byte
    Hash    []byte
    Data    []byte
    Nonce   int
}
type BlockChain struct {
    blocks []*Block
}

type ProofOfWork struct {
    block *Block
    target  *big.Int
}

// 将一个int64转化成一个字节数组（byte array）
func IntToHex(num int64) []byte{
    buff:=new(bytes.Buffer)
    err:=binary.Write(buff,binary.BigEndian,num)
    if err!=nil{
        log.Panic(err)
    }
    return buff.Bytes()
}

func NewProofOfWork(block *Block) *ProofOfWork{
    target := big.NewInt(1)
    target.Lsh(target,uint(256-targetBits))
    pow := &ProofOfWork{block,target}
    return pow
}

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
}

// PoW的核心就是寻找有效哈希
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)
    for nonce