golang-区块链学习02工作量证明

embedsky · · 553 次点击 · · 开始浏览    
这是一个创建于 的文章,其中的信息可能已经有所发展或是发生改变。

前言

在前一篇“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[:]
}


有疑问加站长微信联系(非本文作者)

本文来自:简书

感谢作者:embedsky

查看原文:golang-区块链学习02工作量证明

入群交流(和以上内容无关):加入Go大咖交流群,或添加微信:liuxiaoyan-s 备注:入群;或加QQ群:692541889

553 次点击  
加入收藏 微博
1 回复  |  直到 2018-08-09 09:22:43
暂无回复
添加一条新回复 (您需要 登录 后才能回复 没有账号 ?)
  • 请尽量让自己的回复能够对别人有帮助
  • 支持 Markdown 格式, **粗体**、~~删除线~~、`单行代码`
  • 支持 @ 本站用户;支持表情(输入 : 提示),见 Emoji cheat sheet
  • 图片支持拖拽、截图粘贴等方式上传