在上一篇分享中，我们定义了一个非常简单的数据结构，虽然简单但是我们已经可以看出区块链数据库的雏形。通过代码实现了创建区块链以及如何将区块添加到区块链中，区块链中每个区块都通过 hash 指针连接到前一个区块。这样将区块一个一个连接起来。但是实际上我们都知道区块链出块并没有那么容易。
区块链设计的一个巧妙之处，人们必须进行一些工作才能将区块添加到区块链中。正是这些艰苦的工作，也就是我们熟知的挖矿，才为区块链安全性和一致性提供保证。而且这项具有一定难度的挖矿工作也会得到回报（通过挖矿奖励矿工会得到一定额度的比特币）。
因为有了挖矿具有一定难度，这样将出块时间限制在 10 分钟左右，为什么这样做可以保证区块链的安全性。如果出块太快，这样就很容易造成区块链具有多个分叉。在区块链中认为大部分算力是掌握在大多数诚实可靠的矿工，但是出现大量分支就削弱了大多数矿工的算力，恶意节点就有机会。
这一机制设计与现实生活中的非常相似：一个人必须通过努力工作才能获得回报，过上好日子。在区块链中，网络中的一些节点（矿工）努力维持网络，为区块链添加新的区块，因此获得奖励，这种奖励同时也是区块链法币方式。由于他们的工作，一个区块以安全的方式并入区块链，从而保持整个区块链数据库的稳定性。值得注意的是，完成这项工作的人必须证明这一点。
工作量证明也是 hash 密切相关的，所以在开始之前我们回顾一下 hash 一些特征。hash 运算是计算给定数据的 hash 值的过程。hash 运算可以将任意大小的数据通过 hash 函数生成一个固定大小 hash 值。以下是 hash 的一些特性：
- hash 值无法进行逆运算反推出原始值
- hash 值具有唯一性
- 原始数据一点点改动都会导致计算出 hash 值面目全非
hash 函数主要用于检查数据的一致性。除了软件包外，下载文件，可以通过对比 hash 值可以坚持下载文件是否和源文件一致。
比特币使用 Hashcash，这是一种工作证明算法，最初是为了防止电子邮件垃圾邮件而开发的。可以分为以下步骤：
- 获取一些公开的数据（对于电子邮件，这些公开数据是收件人的电子邮件地址，而对于比特币，是区块头）
- 在上面加一个计数器(随机数)，计数器从 0 开始，就是在公开数据添加一个随机数
- 计算这个公开数据+计数器组合的 hash 值
- 然后检查 hash 是否满足某些要求。
- 如果满足这些要求，任务就结束否则增加随机数来重新计算 hash 值也就是
如果没有，增加计数器并重复步骤3和4。
因为 hash 具有以上我们提及特性，所以这是一个蛮力算法，没有捷径，需要一次一次调整随机数然后计算 hash 值，所以需要计算一定成本。
那么在区块链是中如何计算 hash 来满足的什么样的需求呢? 通过调整随机数然后计算出一个在一定范围内的 hash 值。
目标值
就不断地尝试给出不同 nonce 值，使得 hash 小于等于给定阈值(target)。
target 就是阈值，target 越小挖矿难度就越大。其实调整挖矿难度就是调整目标空间在整个输出空间所占的比例。比特币采用hash 算法是 SHA-256，那么输出空间就是。是通过 hash 值中前多少位为 0 来控制目标空间的大小。所以要计算出小于目标值，就需要保证计算出hash 值前几位为 0。
挖矿难度与目标之的关系
- frac{difficulty 1 target:表示挖矿难度等于 1 时所对应的目标阈值，挖矿难度最小就是 1 ，所以为 1 时对应挖矿难度是非常大的数。
- 所谓挖矿难度与目标阈值成反比
挖矿难度必要性
在比特币系统通过调整挖矿难度来保证出块的时间，出块的间隔为 10 分钟一个区块。出块时间间隔过短就很容易出现分叉。
比特币系统假设大部分算力是掌握在诚实矿工手上。系统算力越强安全性就越好，这是因为想要发动 51% 以上攻击就需要算力越大。也就是恶意节点
const Difficulty = 12
在比特币中，Difficult(target) 是保存在区块头中，存储块被挖掘的难度。我们暂时不会实现目标调整算法，所以我们可以将难度定义为全局常数。
定义工作量证明结构
type ProofOfWork struct {
Block *Block
Target *big.Int
}
- Block 区块
- Target 目标阈值
定义创建工作量证明方法
func NewProof(b *Block) *ProofOfWork {
target := big.NewInt(1)
target.Lsh(target, uint(256-Difficulty))
pow := &ProofOfWork{b, target}
return pow
}
这里 Difficulty 是暂时随意定义数值 12，目标值是有一个在内存中占用少于 256 位的 target。我们希望 Difficutly 足够大因为要控制 10 分钟出一个快，但 Difficulty 又不能太大，就越难找到合适的 hash 值。
现在创建一个 ProofOfWork 结构体，在结构体中会包含一个区块的指针和一个指向 Difficult (类型为 big.Int)的指针。Diffuclty 是前面前一段所述要求的另一个名称。我们使用大整数是因为我们将 hash 与目标(目标值)进行比较的方式：我们将哈希转换为大整数，并检查它是否小于目标值。
在 NewProofOfWork 函数中，初始化类型为 big.Int 值为 1 的变量，并将其左移 256 - targetBits 位。256 是 SHA-256 哈希的长度（以bit为单位），将使用 SHA-256 hash 算法。Diffculty 的十六进制(hexadecimal )表示为：
func main() {
Difficulty := 200
target := big.NewInt(1)
target.Lsh(target, uint(256-Difficulty))
fmt.Printf("target: %d", target)
}
target: 72057594037927936
7205-7594-0379-27936
func (pow *ProofOfWork) InitData(nonce int) []byte {
data := bytes.Join(
[][]byte{
pow.Block.PrevHash,
pow.Block.Data,
},
[]byte{},
)
return data
}
func ToHex(num int64) []byte {
buff := new(bytes.Buffer)
err := binary.Write(buff, binary.BigEndian, num)
if err != nil {
log.Panic(err)
}
return buff.Bytes()
}
func (pow *ProofOfWork) Run() (int, []byte) {
var intHash big.Int
var hash [32]byte
nonce := 0
for nonce < math.MaxInt64 {
data := pow.InitData(nonce)
hash = sha256.Sum256(data)
fmt.Printf("\r%x", hash)
intHash.SetBytes(hash[:])
if intHash.Cmp(pow.Target) == -1 {
break
} else {
nonce++
}
}
fmt.Println()
return nonce, hash[:]
}
type Block struct {
Hash []byte
Data []byte
PrevHash []byte
Nonce int
}
func CreateBlock(data string, prevHash []byte) *Block {
block := &Block{[]byte{}, []byte(data), prevHash, 0}
block.DeriveHash()
return block
}
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
return isValid
}
