区块链技术——工作量证明

谁借莪１个温暖的怀抱￠ 2022-09-15 15:00 236阅读 0赞

# 什么是工作量证明 #

Proof Of Work，简称POW，即对工作量的证明。

# 为什么要做工作量证明 #

**挖矿（计算or工作）**的结果会作为数据加入区块链成为一个区块，完成这个**工作**的人也会获得奖励（即挖矿获得比特币）。
    所以**挖矿**的过程是一种多劳多得的按劳分配模式，算力高，花费的时间多，获得的数字货币也就越多。
    所以必须要证明矿工们为了得到答案确实进行了**计算**。

# 怎么样做工作量证明 #

哈希算法  
SHA256：一种将任意长度的消息压缩到某一固定长度的消息摘要的函数

##### 为什么选择哈希算法 #####

①哈希算法不是加密算法，也就是没有密码，根据一个哈希值看不出或者说得不到原始数据，非常安全。  
②一个唯一的原始数据，只能有唯一一个哈希，而且在已知原始数据和算法的前提下，可以较快计算出一个哈希值。

# 工作量证明代码 #

### ①pay attention to “//新加” ###

#### 需要注意的是“ \{ ”不能单独放在一行，但是为了清晰，下面的代码都手动做了处理！ ####

### ②main.go文件 ###

package main
    
    import (
    	"../core"
    	"fmt"
    	"strconv"
    )
    
    func main()  
    {
        
    bc :=core.NewBlockchain()
    	bc.AddBlock("Send 1 BTC to Ivan")
    	bc.AddBlock("Send 2 createblockchain -address hanshuhuan more BTC to Ivan")
    	
    	for _,block :=range bc.Blocks
    	{
        
    		fmt.Printf( "Prev. hash: %x\n",block.PrevBlockHash)
    		fmt.Printf( "Data: %s\n",block.Data)
    		fmt.Printf( "Hash: %x\n",block.Hash)
    	
    		//新加：证明某个block的工作量
    		pow :=core.NewProofOfWork(block)
    		//新加：校验算法
    		fmt.Printf("PoW:%s\n",strconv.FormatBool(pow.Validate()))
    		fmt.Println()
    	}
    }

### ③block.go文件 ###

package core
    
    import (
    	"bytes"
    	"crypto/sha256"
    	"encoding/gob"
    	"log"
    	"time"
    )
    type Block struct 
    {
        
    	Timestamp     int64
    	Transactions  []*Transaction
    	PrevBlockHash []byte
    	Hash          []byte
    	//新加
    	Nonce         int
    }
    
    func NewBlock(transactions []*Transaction, prevBlockHash []byte) *Block 
    {
        
    	block := &Block
    	{
        
    		Timestamp:     time.Now().Unix(),
    		Transactions:  transactions,
    		PrevBlockHash: prevBlockHash,
    		Hash:          []byte{
        },
    		//新加
    		Nonce:         0
    	}
    	//新加:创建一个工作量证明
    	pow := NewProofOfWork(block)
    	//进行工作量证明
    	nonce, hash := pow.Run()
    
    	block.Hash = hash[:]
    	//新加
    	block.Nonce = nonce
    
    	return block
    }
    func (b *Block) SetHash() 
    {
        
    	timestamp :=[]byte(strconv.FormatInt(b.Timestamp,10))
    	headers :=bytes.Join([][]byte{
        b.PrevBlockHash,b.Data,timestamp},[]byte{
        })
    	hash :=sha256.Sum256(headers)
    	b.Hash=hash[:]
    }
    func NewGenesisBlock() *Block
    {
        
    	return NewBlock( "Genesis Block",[]byte{
        })
    }

### ④proofofwork.go文件 ###

package core；l
    
    import (
    	"bytes"
    	"crypto/sha256"
    	"fmt"
    	"math"
    	"math/big"
    )
    
    var
    (
    	maxNonce=math.MaxInt64
    )
    //决定了挖矿的难度
    const targetBits = 20
    //ProofOfWork represents a proof-of-work对这个区块计算要满足目标
    type ProofOfWork struct 
    {
        
    	block *Block
    	target *big.Int
    }
    //NewProofOfWork builds and returns a ProofOfWork
    func NewProofOfWork(b *Block) *ProofOfWork 
    {
        
    	//首先确定一个固定的整数1
    	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 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 (pow *ProofOfWork) Run()(int,[]byte) 
    {
        
    	var hashInt big.Int
    	var hash    [32]byte
    	nonce :=0
    	//开始计算
    	fmt.Printf("Mining the blockcontaining \"%s\"\n",pow.block.Data)
    	//一个一个对比
    	for nonce < maxNonce
    	{
        
    		//由四项不可变数据+一个可变数字nonce组成
    		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[:]
    }
    // 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
    
    	return isValid
    }

### ⑤blockchain.go文件 ###

没有改动

### ⑥util.go文件 ###

package core
    
    import 
    (
    	"bytes"
    	"encoding/binary"
    	"log"
    )
    
    // IntToHex Convert an int64 to a 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()
    }

# 运行结果展示 #

![运行结果][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA54SVSEFO_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center]

# 运行结果解释 #

# 从main文件开始，创建了一个区块链，返回了一个创世纪块，然后又新加了两个区块（这三个区块都经历了newblock（）这个方法，所以都会进行工作量证明），然后遍历这个区块链（数组），输出每一个区块的“前一个哈希值、本身的数据、后一个区块的哈希值”，然后去证明每个区块的工作量（详情请见注释），并输出最后证明的结果。 #

# 总结 #

通过一个“看似没有用的算法”，得到一个“看似没有用，但是又很麻烦的数”，因为这个计算的过程非常耗费时间（其实费电），所以这个工作量就有了价值。
    首先得到这个结果的人把答案发布到网上，其他人都可以去证明（校验算法），都承认这个结果正确之后，那个首先拿到答案的人就有了比特币。
    随着时间的推移，比特币全网算力不断增加,算法运行需要消耗的CPU越来越多,导致设备所需算力提高,比特币挖矿变得越发困难，所以比特币越来越难拿到，但是它本身数量有限，所以比特币越来越值钱。

[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA54SVSEFO_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center]: /images/20220828/27bb0e2f9af348b0b6431890ab559eef.png