> 作者：ReganYue
>
> 來源：[恆生LIGHT雲社群](https://developer.hs.net/thread/1902)

### **一、前言**

**前面我們簡單的介紹了一個基於PoS共識演算法的例子，今天我們來解析一個升級版的例子。如果喜歡博主的話，記得點贊，關注，收藏哦~**

### **二、本例中的一些資料結構**

```
type Block struct {
    Index     int
    TimeStamp string
    BPM       int
    HashCode  string
    PrevHash  string
    Validator string
}

var Blockchain []Block
var tempBlocks []Block

var candidateBlocks = make(chan Block)

var announcements = make(chan string)

var validators = make(map[string]int)
```

**首先是定義了一個區塊結構體Block，然後定義一條區塊鏈Blockchain，其實就是區塊陣列。這個tempBlocks是區塊緩衝區。candidateBlocks是候選區塊，任何一個節點提議一個新塊時，都會將它傳送到這個管道。announcements是來廣播的通道。validators是驗證者列表，存節點地址和他擁有的tokens。**

### **三、生成區塊和計算雜湊**

```
func generateBlock(oldBlock Block, BPM int, address string) Block {
    var newBlock Block
    newBlock.Index = oldBlock.Index + 1
    newBlock.TimeStamp = time.Now().String()
    newBlock.BPM = BPM
    newBlock.PrevHash = oldBlock.HashCode
    newBlock.Validator = address
    newBlock.HashCode = GenerateHashValue(newBlock)
    return newBlock
}

func GenerateHashValue(block Block) string {
    var hashcode = block.PrevHash +
        block.TimeStamp + block.Validator +
        strconv.Itoa(block.BPM) + strconv.Itoa(block.Index)
    return calculateHash(hashcode)
}

func calculateHash(s string) string {
    var sha = sha256.New()
    sha.Write([]byte(s))
    hashed := sha.Sum(nil)
    return hex.EncodeToString(hashed)
}
```

**這個真的前面每個例子都在講，這裡真的不想再講了，不理解的小夥伴可以看一看本專欄前面的例子。**

### **四、主邏輯**

```
func main() {
    err := godotenv.Load()
    if err != nil {
        log.Fatal(err)
    }

genesisBlock := Block{}
    genesisBlock = Block{0, time.Now().String(), 0,
        GenerateHashValue(genesisBlock), "", ""}
    spew.Dump(genesisBlock)

Blockchain = append(Blockchain, genesisBlock)

port := os.Getenv("PORT")

server, err := net.Listen("tcp", ":"+port)
    if err != nil {
        log.Fatal(err)
    }

log.Println("HTTP Server Listening on port :", port)

defer server.Close()

go func() {
        for cadidate := range candidateBlocks {

mutex.Lock()

tempBlocks = append(tempBlocks, cadidate)
            mutex.Unlock()
        }
    }()

go func() {
        for {

pickWinner()
        }
    }()

for {
        conn, err := server.Accept()
        if err != nil {
            log.Fatal(err)
        }
        go handleConn(conn)
    }
}
```

**我們先來看一看主邏輯，先是載入本地的.env檔案，這個檔案可以儲存很多引數，這裡我們儲存一個埠號9000.**

![image-20211117174759924](https://gitee.com/ByRegan/for_-pic/raw/master/202111171748476.png)

**然後是建立創世區塊，創世區塊注意它的高度為0.**

```
spew.Dump(genesisBlock)
```

**就是把創世區塊透過命令列格式化輸出。**

```
Blockchain = append(Blockchain, genesisBlock)
```

**這行程式碼是將創世區塊新增到區塊鏈。**

```
port := os.Getenv("PORT")
```

**前面說.env檔案中儲存了埠號，這裡就獲取這個檔案中的埠號到port變數中。**

**然後啟動服務程式監聽上面獲取的埠。**

```
defer server.Close()
```

**要養成啟動服務就書寫延遲關閉的習慣，不然後面任意忘記釋放資源。**

**然後是併發操作，迴圈讀取candidateBlocks，一旦這個管道有一個區塊進入，馬上把它讀取到緩衝區。接著併發判斷哪個節點應該去挖礦。**

**然後不斷接收驗證者節點的連線，連上就處理終端傳送過來的資訊。**

### **五、獲取記賬權的節點**

```
func pickWinner() {
    time.Sleep(30 * time.Second)
    mutex.Lock()
    temp := tempBlocks
    mutex.Unlock()

lotteryPool := []string{}
    if len(temp) > 0 {
    OUTER:
        for _, block := range temp {
            for _, node := range lotteryPool {
                if block.Validator == node {
                    continue OUTER
                }
            }

mutex.Lock()

setValidators := validators
            mutex.Unlock()

k, ok := setValidators[block.Validator]
            if ok {

for i := 0; i < k; i++ {
                    lotteryPool = append(lotteryPool, block.Validator)
                }
            }
        }

s := rand.NewSource(time.Now().Unix())
        r := rand.New(s)

lotteryWinner := lotteryPool[r.Intn(len(lotteryPool))]

for _, block := range temp {
            if block.Validator == lotteryWinner {
                mutex.Lock()
                Blockchain = append(Blockchain, block)
                mutex.Unlock()
                for _ = range validators {
                    announcements

一個基於PoS共識演算法的區塊鏈例項解析（升級版）

相關文章