歡迎光臨
每天分享高質量文章

200行Go代碼實現自己的區塊鏈——區塊生成與網絡通信

在第一篇文章[1]中,我們向大家展示瞭如何通過精煉的Go代碼實現一個簡單的區塊鏈。如何計算每個塊的 Hash 值,如何驗證塊資料,如何讓塊鏈接起來等等,但是所有這些都是跑在一個節點上的。文章發佈後,讀者反響熱烈,紛紛留言讓我快點填坑(網絡部分),於是就誕生了這第二篇文章。

這篇文章在之前的基礎上,解決多個節點網絡內,如何生成塊、如何通信、如何廣播訊息等。

流程


  • 第一個節點創建“創始區塊”,同時啟動 TCP server並監聽一個端口,等待其他節點連接。


Step 1

  • 啟動其他節點,並與第一個節點建立TCP連接(這裡我們通過不同的終端來模擬其他節點)

  • 創建新的塊


Step 2

  • 第一個節點驗證新生成塊

  • 驗證之後廣播(鏈的新狀態)給其他節點


Step 3

  • 所有的節點都同步了最新的鏈的狀態

之後你可以重覆上面的步驟,使得每個節點都創建TCP server並監聽(不同的)端口以便其他節點來連接。通過這樣的流程你將建立一個簡化的模擬的(本地的)P2P網絡,當然你也可以將節點的代碼編譯後,將二進製程式部署到雲端。

開始coding吧


設置與匯入依賴

參考之前第一篇文章,我們使用相同的計算 hash 的函式、驗證塊資料的函式等。

設置
在工程的根目錄創建一個 .env 檔案,並添加配置:

ADDR=9000

通過 go-spew 包將鏈資料輸出到控制台,方便我們閱讀:

go get github.com/davecgh/go-spew/spew

通過 godotenv 包來加載配置檔案:

go get github.com/joho/godotenv

之後創建 main.go 檔案。

匯入
接著我們匯入所有的依賴:

package main

import (
"bufio"
"crypto/sha256"
"encoding/hex"
"encoding/json"
"io"
"log"
"net"
"os"
"strconv"
"time"

"github.com/davecgh/go-spew/spew"
"github.com/joho/godotenv"
)

回顧
讓我們再快速回顧下之前的重點,我們創建一個 Block 結構體,並宣告一個Block 型別的 slice,Blockchain

// Block represents each 'item' in the blockchain
type Block struct {
Index int
Timestamp string
BPM int
Hash string
PrevHash string
}

// Blockchain is a series of validated Blocks
var Blockchain []Block

創建塊時計算hash值的函式:

// SHA256 hashing
func calculateHash(block Block) string {
record := string(block.Index) +
block.Timestamp + string(block.BPM) + block.PrevHash
h := sha256.New()
h.Write([]byte(record))
hashed := h.Sum(nil)
return hex.EncodeToString(hashed)
}

創建塊的函式:

// create a new block using previous block's hash
func generateBlock(oldBlock Block, BPM int) (Block, error) {

var newBlock Block

t := time.Now()

newBlock.Index = oldBlock.Index + 1
newBlock.Timestamp = t.String()
newBlock.BPM = BPM
newBlock.PrevHash = oldBlock.Hash
newBlock.Hash = calculateHash(newBlock)

return newBlock, nil
}

驗證塊資料的函式:

// make sure block is valid by checking index,
// and comparing the hash of the previous block
func isBlockValid(newBlock, oldBlock Block) bool {
if oldBlock.Index+1 != newBlock.Index {
return false
}

if oldBlock.Hash != newBlock.PrevHash {
return false
}

if calculateHash(newBlock) != newBlock.Hash {
return false
}

return true
}

確保各個節點都以最長的鏈為準:

// make sure the chain we're checking is longer than 
// the current blockchain
func replaceChain(newBlocks []Block) {
if len(newBlocks) > len(Blockchain) {
Blockchain = newBlocks
}
}

網絡通信

接著我們來建立各個節點間的網絡,用來傳遞塊、同步鏈狀態等。

我們先來宣告一個全域性變數 bcServer ,以 channel(譯者註:channel 類似其他語言中的 Queue,代碼中宣告的是一個 Block 陣列的 channel)的形式來接受塊。

// bcServer handles incoming concurrent Blocks
var bcServer chan []Block


註:Channel 是 Go 語言中很重要的特性之一,它使得我們以流的方式讀寫資料,特別是用於併發編程。通過這裡[2]可以更深入地學習 Channel。


接下來我們宣告 main 函式,從 .env 加載配置,也就是端口號,然後實體化 bcServer


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

bcServer = make(chan []Block)

// create genesis block
t := time.Now()
genesisBlock := Block{0, t.String(), 0, "", ""}
spew.Dump(genesisBlock)
Blockchain = append(Blockchain, genesisBlock)
}

接著創建 TCP server 並監聽端口:

// start TCP and serve TCP server
server, err := net.Listen("tcp", ":"+os.Getenv("ADDR"))
if err != nil {
log.Fatal(err)
}
defer server.Close()

需要註意這裡的 defer server.Close(),它用來之後關閉鏈接,可以從這裡[3]瞭解更多 defer 的用法。

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

通過這個無限迴圈,我們可以接受其他節點的 TCP 鏈接,同時通過 go handleConn(conn) 啟動一個新的 go routine(譯者註:Rob Pike 不認為go routine 是協程,因此沒有譯為協程)來處理請求。

接下來是“處理請求”這個重要函式,其他節點可以創建新的塊並通過 TCP 連接發送出來。在這裡我們依然像第一篇文章一樣,以 BPM 來作為示例資料。

  • 客戶端通過 stdin 輸入 BPM

  • 以 BPM 的值來創建塊,這裡會用到前面的函式:generateBlockisBlockValid,和 replaceChain

  • 將新的鏈放在 channel 中,並廣播到整個網絡

func handleConn(conn net.Conn) {
io.WriteString(conn, "Enter a new BPM:")

scanner := bufio.NewScanner(conn)

// take in BPM from stdin and add it to blockchain after
// conducting necessary validation
go func() {
for scanner.Scan() {
bpm, err := strconv.Atoi(scanner.Text())
if err != nil {
log.Printf("%v not a number: %v", scanner.Text(), err)
continue
}
newBlock, err := generateBlock(
Blockchain[len(Blockchain)-1], bpm)
if err != nil {
log.Println(err)
continue
}
if isBlockValid(newBlock, Blockchain[len(Blockchain)-1]) {
newBlockchain := append(Blockchain, newBlock)
replaceChain(newBlockchain)
}

bcServer io.WriteString(conn, "\nEnter a new BPM:")
}
}()

defer conn.Close()
}

我們創建一個 scanner,並通過 for scanner.Scan() 來持續接收連接中發來的資料。為了簡化,我們把 BPM 數值轉化成字串。bcServer 是表示我們將新的鏈寫入 channel 中。

通過 TCP 鏈接將最新的鏈廣播出去時,我們需要:

  • 將資料序列化成 JSON 格式

  • 通過 timer 來定時廣播

  • 在控制臺中打印出來,方便我們查看鏈的最新狀態

// simulate receiving broadcast
go func() {
for {
time.Sleep(30 * time.Second)
output, err := json.Marshal(Blockchain)
if err != nil {
log.Fatal(err)
}
io.WriteString(conn, string(output))
}
}()

for _ = range bcServer {
spew.Dump(Blockchain)
}

整個 handleConn 函式差不多就完成了,通過這裡[4]可以獲得完整的代碼。

有意思的地方


現在讓我們來啟動整個程式,
go run main.go


就像我們預期的,首先創建了“創世塊”,接著啟動了 TCP server 並監聽9000端口。

接著我們打開一個新的終端,連接到那個端口。(我們用不同顏色來區分)
nc localhost 9000

接下來我們輸入一個BPM值:

接著我們從第一個終端(節點)中能看到(依據輸入的BPM)創建了新的塊。

我們等待30秒後,可以從其他終端(節點)看到廣播過來的最新的鏈。


下一步

到目前為止,我們為這個例子添加了簡單的、本地模擬的網絡能力。當然,肯定有讀者覺得這不夠有說服力。但本質上來說,這就是區塊鏈的網絡層。它能接受外部資料並改變內在資料的狀態又能將內在資料的最新狀態廣播出去。

接下來你需要學習的是一些主流的共識演算法,比如 PoW (Proof-of-Work) 和 PoS (Proof-of-Stake) 等。當然,我們會繼續在後續的文章中將共識演算法添加到這個例子中。

下一篇文章再見!


參考鏈接

[1] https://mp.weixin.qq.com/s?__biz=MzAwMDU1MTE1OQ==∣=2653549361&idx;=1&sn;=019f54713891cf33ef3bef3b24773a96&chksm;=813a62a9b64debbfdd24a8507bb974048a4456e5b0a2d5f685fb3bdf40366a25764c5df8afec&scene;=21

[2] https://golangbot.com/channels/

[3] https://blog.golang.org/defer-panic-and-recover

[4] https://github.com/mycoralhealth/blockchain-tutorial/blob/master/networking/main.go


相關閱讀:


只用200行Go代碼寫一個自己的區塊鏈!


特別推薦:


比特幣、以太坊、ERC20、PoW、PoS、智慧合約、閃電網絡……

想深入瞭解及討論這些話題?高可用架構在知識星球(小密圈)創建了區塊鏈學習小組,共同學習區塊鏈包括數字貨幣前沿技術,歡迎點擊鏈接加入。


區塊鏈學習小組


文作者 Coral Health,由魏佳翻譯。轉載譯文請註明出處,技術原創及架構實踐文章,歡迎通過公眾號選單「聯繫我們」進行投稿。


高可用架構

改變互聯網的構建方式

長按二維碼 關註「高可用架構」公眾號

赞(0)

分享創造快樂