200行Go代码实现自己的区块链——区块生成与网络通信

Posted 5rjscn

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了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 <- Blockchain
            io.WriteString(conn, "\nEnter a new BPM:")
        }
    }()
    
    defer conn.Close()
}

我们创建一个 scanner,并通过 for scanner.Scan() 来持续接收连接中发来的数据。为了简化,我们把 BPM 数值转化成字符串。bcServer <- Blockchain 是表示我们将新的链写入 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秒后,可以从其他终端(节点)看到广播过来的最新的链。

http://www.aibbt.com/a/18709.html

下一步

到目前为止,我们为这个例子添加了简单的、本地模拟的网络能力。当然,肯定有读者觉得这不够有说服力。但本质上来说,这就是区块链的网络层。它能接受外部数据并改变内在数据的状态又能将内在数据的最新状态广播出去。

接下来你需要学习的是一些主流的共识算法,比如 PoW (Proof-of-Work) 和 PoS (Proof-of-Stake) 等。当然,我们会继续在后续的文章中将共识算法添加到这个例子中。






以上是关于200行Go代码实现自己的区块链——区块生成与网络通信的主要内容,如果未能解决你的问题,请参考以下文章

只用200行Go代码写一个自己的区块链!

只用200行Go代码写一个自己的区块链!

200行go语言代码自建一个区块链 体验挖矿乐趣

Go语言200行写区块链源代码分析

自己动手实现区块链

自己动手实现区块链