前言
在前一篇“golang-区块链学习01”的基础上，增加我们区块链的工作量证明。
知识点
1、区块链ProofOfWork（工作量证明）概念，因为所有人都想生成区块来获取奖励，为了公平起见，我们规定要想成功生成一个区块必须完成指定难度的任务才行。也就是谁先完成指定难度的任务就将成功生成一个区块。先预留个彩蛋，结合实例的工作量证明将在文末总结。
golang实现简单的工作量证明
1、定义一个工作量难度。比如要求生产的区块的hash值前面五位必须为0。即hash类似：00000xxxxxxxxxxx的样式。
2、在Block的结构中增加一个Nonce变量，通过不断修改Nonce的值，不断计算整个区的hash值，直到满足上面的要求即可。
3、代码实例
创建一个proofofwork.go文件。定义一个工作量证明的结构体
type ProofOfWork struct {
block *Block // 即将生成的区块对象
target *big.Int //生成区块的难度
}
创建实例化工作量证明结构体.
const targetBits = 20
func NewProofOfWork(b *Block) *ProofOfWork {
target := big.NewInt(1)
//难度：target=10的18次方（即要求计算出的hash值小于这个target）
target.Lsh(target, uint(256-targetBits))
pow := &ProofOfWork{b, target}
return pow
}
计算hash值的算法
func (pow *ProofOfWork) Run() (int, []byte) {
var hashInt big.Int
var hash [32]byte
nonce := 0// 从0自增
fmt.Printf("Mining the block containing \"%s\"\n", pow.block.Data)
// 循环从nonce=0一直计算到nonce=2的64次方的值，知道算出符合要求的hash值
for nonce < maxNonce {
// 准备计算hash的数据
data := pow.prepareData(nonce)
hash = sha256.Sum256(data)// 计算hash
fmt.Printf("\r%x", hash)
hashInt.SetBytes(hash[:])
// 难度证明
if hashInt.Cmp(pow.target) == -1 {
break// 符合
} else {
nonce++// 不符合继续计算
}
}
fmt.Printf("\n\n")
return nonce, hash[:]
}
准备数据
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
}
附件
惯例上码。所有的代码文件清单。
/lession02/src/coin/main.go
package main
import (
"fmt"
"core"
"strconv"
)
func main() {
fmt.Printf("%d\n",uint(256-20))
bc := core.NewBlockChain()
bc.AddBlock("send 1 btc to Ivan")
bc.AddBlock("send 2 btc to Ivan")
for _, block := range bc.Blocks {
fmt.Printf("PrevBlockHash:%x\n", block.PrevBlockHash)
fmt.Printf("Data:%s\n", block.Data)
fmt.Printf("Hash:%x\n", block.Hash)
fmt.Printf("TimeStamp:%d\n", block.TimeStamp)
fmt.Printf("Nonce:%d\n", block.Nonce)
pow := core.NewProofOfWork(block)
fmt.Printf("Pow is %s\n", strconv.FormatBool(pow.Validate()))
println()
}
}
/lession02/src/core/block.go
package core
import (
"time"
"strconv"
"bytes"
"crypto/sha256"
)
type Block struct {
TimeStamp int64
Data []byte
PrevBlockHash []byte
Hash []byte
Nonce int
}
func NewBlock(data string, prevBlockHash []byte) *Block {
block := &Block{time.Now().Unix(), []byte(data), prevBlockHash, []byte{}, 0}
pow := NewProofOfWork(block)
block.Nonce, block.Hash = pow.Run()
return block
}
func (b *Block) SetHash() {
strTimeStamp := []byte(strconv.FormatInt(b.TimeStamp, 10))
headers := bytes.Join([][]byte{b.PrevBlockHash, b.Data, strTimeStamp}, []byte{})
hash := sha256.Sum256(headers)
b.Hash = hash[:]
}
func NewGenesisBlock() *Block {
return NewBlock("Genesis Block", []byte{})
}
/lession02/src/core/blockchain.go
package core
type BlockChain struct {
Blocks []*Block
}
func (bc *BlockChain) AddBlock(data string) {
preBlock := bc.Blocks[len(bc.Blocks)-1]
newBlock := NewBlock(data, preBlock.Hash)
bc.Blocks = append(bc.Blocks, newBlock)
}
func NewBlockChain() *BlockChain {
return &BlockChain{[]*Block{NewGenesisBlock()}}
}
/lession02/src/core/proofofwork.go
package core
import (
"math"
"math/big"
"fmt"
"crypto/sha256"
"bytes"
)
var (
maxNonce = math.MaxInt64
)
const targetBits = 20
type ProofOfWork struct {
block *Block
target *big.Int
}
func NewProofOfWork(b *Block) *ProofOfWork {
target := big.NewInt(1)
target.Lsh(target, uint(256-targetBits))
pow := &ProofOfWork{b, 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
}
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 < maxNonce {
data := pow.prepareData(nonce)
hash = sha256.Sum256(data)
fmt.Printf("\r%x", hash)
hashInt.SetBytes(hash[:])
if hashInt.Cmp(pow.target) == -1 {
break
} else {
nonce++
}
}
fmt.Printf("\n\n")
return nonce, hash[:]
}
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
}
/lession02/src/core/utils.go
package core
import (
"bytes"
"encoding/binary"
"log"
"crypto/sha256"
)
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 DataToHash(data []byte) []byte {
hash := sha256.Sum256(data)
return hash[:]
}
