PoW简介

package main

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

// 定义区块，包含区块头、数据和工作量证明相关字段。
type Block struct {
    Timestamp    int64
    Data         []byte
    PrevBlockHash []byte
    Hash         []byte
    Nonce        int
}

// 定义PoW结构，包括目标难度和区块信息
type ProofOfWork struct {
    Block  *Block
    Target *big.Int
}

// 创建新的工作量证明对象，设置目标难度。目标难度越高，挖矿难度越大。
const targetBits = 24

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
}

func IntToHex(n int64) []byte {
    buff := new(bytes.Buffer)
    err := binary.Write(buff, binary.BigEndian, n)
    if err != nil {
        fmt.Println("binary.Write failed:", err)
    }
    return buff.Bytes()
}

// 挖矿 
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 < math.MaxInt64 {
        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.Print("\n\n")

    return nonce, hash[:]
}