區塊鏈開發者面試必備：6種常見共識演算法全解析

// POW挖礦核心邏輯
func mine(blockData []byte, difficulty int) (uint64, []byte) {
    target := make([]byte, 32)
    // 設定目標值：前difficulty位為0

    var nonce uint64
    for {
        data := append(blockData, uint64ToBytes(nonce)...)
        hash := sha256.Sum256(data)

        if bytes.Compare(hash[:], target) < 0 {
            return nonce, hash[:]
        }
        nonce++
    }
}

// POS驗證者選擇演算法
type Validator struct {
    Address string
    Stake   uint64
}

func selectValidator(validators []Validator, seed []byte)string {
    totalStake := uint64(0)
    for _, v := range validators {
        totalStake += v.Stake
    }

    // 基於質押權重和隨機數選擇
    target := binary.BigEndian.Uint64(seed) % totalStake
    current := uint64(0)

    for _, v := range validators {
        current += v.Stake
        if current >= target {
            return v.Address
        }
    }
    return""
}

type BlockProducer struct {
    Name  string
    Votes uint64
}

func electProducers(candidates []BlockProducer, count int) []BlockProducer {
    // 按得票數排序
    sort.Slice(candidates, func(i, j int)bool {
        return candidates[i].Votes > candidates[j].Votes
    })

    iflen(candidates) < count {
        return candidates
    }
    return candidates[:count]
}

// PoH條目結構：每個條目包含雜湊值和計數
type PoHEntry struct {
    Hash  []byte// 當前的雜湊值，作為時間證明
    Count uint64// 計數器，表示執行了多少次雜湊運算
}

// 生成PoH序列的核心函數
func generatePoH(initialHash []byte)chan PoHEntry {
    // 建立一個緩衝通道，用於傳遞PoH條目
    entries := make(chan PoHEntry, 1000)

    // 啟動一個goroutine持續生成PoH序列
    gofunc() {
        hash := initialHash // 從初始雜湊值開始
        count := uint64(0)  // 計數器初始化為0

        for {
            // 關鍵步驟：對當前雜湊值進行SHA256運算
            // 這個過程必須序列執行，無法平行加速
            hash = sha256Hash(hash)
            count++ // 每次雜湊運算後計數器加1

            // 將新的PoH條目傳送到通道
            // 每個條目都包含當前雜湊值和計數
            entries <- PoHEntry{
                Hash:  hash,  // 雜湊值作為時間戳的證明
                Count: count, // 計數表示從開始到現在的"時間"
            }

            // 這個循環會持續運行，不斷生成時間證明
            // 就像時鐘的滴答聲，為網路提供時間基準
        }
    }()

    return entries
}

// 驗證PoH序列的函數
func verifyPoH(entries []PoHEntry, initialHash []byte)bool {
    currentHash := initialHash

    for i, entry := range entries {
        // 重新計算雜湊值
        currentHash = sha256Hash(currentHash)

        // 驗證雜湊值是否匹配
        if !bytes.Equal(currentHash, entry.Hash) {
            returnfalse
        }

        // 驗證計數是否正確
        if entry.Count != uint64(i+1) {
            returnfalse
        }
    }
    returntrue
}

type PBFTMessage struct {
    Phase     string// "pre-prepare", "prepare", "commit"
    View      int
    Sequence  int
    Digest    []byte
    NodeID    string
}

func (n *Node) handlePBFT(msg PBFTMessage) {
    switch msg.Phase {
    case"pre-prepare":
        // 驗證提案，傳送prepare消息
        n.sendPrepare(msg)
    case"prepare":
        // 收集prepare消息，超過2f+1個則傳送commit
        if n.prepareCount >= 2*n.faultCount+1 {
            n.sendCommit(msg)
        }
    case"commit":
        // 收集commit消息，超過2f+1個則執行
        if n.commitCount >= 2*n.faultCount+1 {
            n.executeRequest(msg)
        }
    }
}

type RaftNode struct {
    state     string// "follower", "candidate", "leader"
    term      int
    votedFor  string
    log       []LogEntry
    commitIndex int
}

func (n *RaftNode) requestVote() bool {
    n.term++
    n.state = "candidate"
    n.votedFor = n.id

    votes := 1// 自己的票
    for _, peer := range n.peers {
        if peer.vote(n.term, n.id) {
            votes++
        }
    }

    if votes > len(n.peers)/2 {
        n.state = "leader"
        returntrue
    }
    returnfalse
}