区块链第七版：网络

undefined前言

本版本区块链不会实现一个P2P网络，但会实现基于网络的、bitcoin的一个最常见的场景：

中心节点创建一个区块链。
一个其他（钱包）节点连接到中心节点并下载区块链。
另一个（矿工）节点连接到中心节点并下载区块链。
钱包节点创建一笔交易。
矿工节点接收交易，并将交易保存到内存池中。
当内存池中有足够的交易时，矿工开始挖一个新块。
当挖出一个新块后，将其发送到中心节点。
钱包节点与中心节点进行同步。
钱包节点的用户检查他们的支付是否成功。

这就是比特币中的一般流程，也是比特币最常见最重要的用户场景。

undefined节点角色

尽管节点具有完备成熟的属性，但是它们也可以在网络中扮演不同角色。比如：

矿工这样的节点运行于强大或专用的硬件（比如 ASIC）之上，它们唯一的目标是，尽可能快地挖出新块。矿工是区块链中唯一可能会用到工作量证明的角色，因为挖矿实际上意味着解决 PoW 难题。在权益证明 PoS 的区块链中，没有挖矿。
全节点这些节点验证矿工挖出来的块的有效性，并对交易进行确认。为此，他们必须拥有区块链的完整拷贝。同时，全节点执行路由操作，帮助其他节点发现彼此。对于网络来说，非常重要的一段就是要有足够多的全节点。因为正是这些节点执行了决策功能：他们决定了一个块或一笔交易的有效性。
SPV SPV 表示 Simplified Payment Verification，简单支付验证。这些节点并不存储整个区块链副本，但是仍然能够对交易进行验证（不过不是验证全部交易，而是一个交易子集，比如，发送到某个指定地址的交易）。一个 SPV 节点依赖一个全节点来获取数据，可能有多个 SPV 节点连接到一个全节点。SPV 使得钱包应用成为可能：一个人不需要下载整个区块链，但是仍能够验证他的交易。

undefined网络简化

我们将使用端口号作为节点标识符，而不是使用 IP 地址，比如将会有这样地址的节点：127.0.0.1:3000，127.0.0.1:3001，127.0.0.1:3002等等。我们叫它端口节点（port node） ID，并使用环境变量NODE_ID对它们进行设置。故而，你可以打开多个终端窗口，设置不同的NODE_ID运行不同的节点。

这个方法也需要有不同的区块链和钱包文件。它们现在必须依赖于节点 ID 进行命名，比如 blockchain_3000.db, blockchain_30001.db和wallet_3000.db, wallet_30001.db 等等。

undefined实现

在 Bitcoin Core 中，硬编码了DNS seeds。虽然这些并不是节点，但是 DNS 服务器知道一些节点的地址。当你启动一个全新的 Bitcoin Core 时，它会连接到一个种子节点，获取全节点列表，随后从这些节点中下载区块链。

不过在我们目前的实现中，无法做到完全的去中心化，因为会出现中心化的特点。我们会有三个节点：

一个中心节点。所有其他节点都会连接到这个节点，这个节点会在其他节点之间发送数据。
一个矿工节点。这个节点会在内存池中存储新的交易，当有足够的交易时，它就会打包挖出一个新块。
一个钱包节点。这个节点会被用作在钱包之间发送币。但是与 SPV 节点不同，它存储了区块链的一个完整副本。

节点通过消息（message）进行交流：整个通讯就是：请求—回复—请求—回复…这么一个模式进行，第一个请求可能需要经过请求节点与被请求节点之间多次往返消息（一般为多个成对消息）才能完成。

当一个新的节点开始运行时，它会从一个 DNS 种子获取几个节点，给它们发送version消息，在我们的实现看起来就像是这样：

type version struct {
    Version    int//区块链版本号
    BestHeight int//存储区块链中节点的高度。
    AddrFrom   string//存储发送消息者的地址
}

接收到version消息的节点应该做什么呢？它会响应自己的version消息。这是一种握手🤝：如果没有事先互相问候，就不可能有其他交流。version用于找到一个更长的区块链。当一个节点接收到version消息，它会检查本节点的区块链是否比BestHeight的值更大。如果不是，节点就会请求并下载缺失的块。

为了接收消息，我们需要一个服务器（每个节点都是服务器）：

var nodeAddress string
var knownNodes = []string{"localhost:3000"}//中心节点的地址数组
func StartServer(nodeID, minerAddress string) {//nodeID为当前节点
    nodeAddress = fmt.Sprintf("localhost:%s", nodeID)
    miningAddress = minerAddress//接收挖矿奖励的地址
    ln, err := net.Listen(protocol, nodeAddress)//当前节点开启监听
    defer ln.Close()
    bc := NewBlockchain(nodeID)//将区块链读取到内存
    if nodeAddress != knownNodes[0] {//如果当前节点不是中心节点
        sendVersion(knownNodes[0], bc)//非中心节点必须向中心节点发送`version`消息来查询是否自己的区块链已过时
    }
    //优雅的Go语言
    for {//开启无限循环
        conn, err := ln.Accept()//等待连接
        go handleConnection(conn, bc)//异步，处理连接
    }
}

非中心节点向中心节点发送消息，查询自己的区块链是否已经过时：

func sendVersion(addr string, bc *Blockchain) {
    bestHeight := bc.GetBestHeight()
    payload := gobEncode(version{nodeVersion, bestHeight, nodeAddress})
    request := append(commandToBytes("version"), payload...)//“version”是命令，payload是gob编码的消息结构
    sendData(addr, request)
}

commandToBytes看起来是这样：

//创建一个 12 字节的缓冲区，并用命令名进行填充，将剩下的字节置为空
func commandToBytes(command string) []byte {//命令字符串转为数组切片
    var bytes [commandLength]byte//commandLength为12个字节
    for i, c := range command {
        bytes[i] = byte(c)
    }
    return bytes[:]//返回切片
}

解析命令的函数如下：

func bytesToCommand(bytes []byte) string {
    var command []byte
    for _, b := range bytes {
        if b != 0x0 {
            command = append(command, b)
        }
    }
    return fmt.Sprintf("%s", command)
}

当一个节点接收到一个命令，它会运行bytesToCommand来提取命令名，并选择正确的处理器处理命令主体：

func handleConnection(conn net.Conn, bc *Blockchain) {
    request, err := ioutil.ReadAll(conn)
    command := bytesToCommand(request[:commandLength])
    fmt.Printf("接收到 %s 命令\n", command)
    switch command {
    ...
    case "version":
        handleVersion(request, bc)
    default:
        fmt.Println("Unknown command!")
    }
    conn.Close()
}

下面是version命令的处理函数：

func handleVersion(request []byte, bc *Blockchain) {
    var buff bytes.Buffer
    var payload verzion
    buff.Write(request[commandLength:])
    dec := gob.NewDecoder(&buff)
    err := dec.Decode(&payload)
    myBestHeight := bc.GetBestHeight()//本地区块链高度
    foreignerBestHeight := payload.BestHeight//收到的区块链高度
    if myBestHeight < foreignerBestHeight {//本地区块链高度小于收到的区块链高度
        sendGetBlocks(payload.AddrFrom)//发送getblocks消息
    } else if myBestHeight > foreignerBestHeight {
        sendVersion(payload.AddrFrom, bc)//回复version消息
    }
    if !nodeIsKnown(payload.AddrFrom) {//如果中心节点不包含本地地址
        knownNodes = append(knownNodes, payload.AddrFrom)//将本地地址加入到中心节点地址数组中
    }
}

首先，我们需要对请求进行解码，提取有效信息。所有的处理器在这部分都类似。

然后节点将从消息中提取的BestHeight与自身进行比较。如果自身节点的区块链更长，它会回复version消息；否则，它会发送getblocks消息。

undefinedgetblocks

type getblocks struct {
    AddrFrom string
}

getblocks意为 “给我看一下你有什么区块”（在比特币中，这会更加复杂）。注意，它并没有说“把你全部的区块给我”，而是请求了一个块哈希的列表。这是为了减轻网络负载，因为区块可以从不同的节点下载，并且我们不想从一个单一节点下载数十 GB 的数据。

处理命令十分简单：

func handleGetBlocks(request []byte, bc *Blockchain) {
    ...
    blocks := bc.GetBlockHashes()//接收到getblocks命令的节点获得本地的区块哈希列表
    sendInv(payload.AddrFrom, "block", blocks)//然后将本地的区块哈希列表回复给请求者
}

在我们简化版的实现中，它会返回所有块哈希。

undefinedinv

type inv struct {
    AddrFrom string
    Type     string//payload的类型：block或tx
    Items    [][]byte//当前节点的所有块的哈希或交易的哈希
}

比特币使用inv来向其他节点展示当前节点有什么块和交易。再次提醒，它没有包含完整的区块链和交易，仅仅是哈希而已。Type字段表明了这是块还是交易。

处理inv稍显复杂：

func handleInv(request []byte, bc *Blockchain) {//请求区块者收到回复节点返回的blocks后进行处理
    ...
    fmt.Printf("Recevied inventory with %d %s\n", len(payload.Items), payload.Type)
    if payload.Type == "block" {//块哈希
        blocksInTransit = payload.Items
        blockHash := payload.Items[0]
        //给回复节点发送getdata命令，请求该块：哦，你有这么一个块，麻烦给我
       //注意，每次只能请求一个block，所以这次请求的是payload里面的第0个
        sendGetData(payload.AddrFrom, "block", blockHash)
        newInTransit := [][]byte{}
        for _, b := range blocksInTransit {//迭代收到的区块哈希列表
            //如果b不等于收到的第0个哈希值（第0个块在上面getdata命令中已经请求下载），加入到新的newInTransit（尚未下载该块）
            if bytes.Compare(b, blockHash) != 0 {//第0个已经请求下载了啦，所以需要排除，下次不要再请求其他节点下载
                newInTransit = append(newInTransit, b)
            }
        }
        //更新blocksInTransit，blocksInTransit用来跟踪已下载的块，以后会根据此表请求下载其他的区块，直到全部下载完毕
        blocksInTransit = newInTransit
    }
    if payload.Type == "tx" {
        txID := payload.Items[0]
        if mempool[hex.EncodeToString(txID)].ID == nil {//如果本地内存池中不存在这么一个交易
            sendGetData(payload.AddrFrom, "tx", txID)//收到回复节点返回的tx，请求该交易：哦，你有这么一个交易，麻烦给我
        }
    }
}

undefinedgetdata

type getdata struct {
    AddrFrom string
    Type     string
    ID       []byte
}

getdata用于某个块或交易的请求，它可以仅包含一个块或交易的 ID。

func handleGetData(request []byte, bc *Blockchain) {
    ...
    if payload.Type == "block" {
        block, err := bc.GetBlock([]byte(payload.ID))
        sendBlock(payload.AddrFrom, &block)
    }
    if payload.Type == "tx" {
        txID := hex.EncodeToString(payload.ID)
        tx := mempool[txID]//从本地内存池中取这个交易
        sendTx(payload.AddrFrom, &tx)
    }
}

这个处理器比较地直观：如果它们请求一个块，则返回块；如果它们请求一笔交易，则返回交易。注意，我们并没有检查实际上是否已经有了这个块或交易。这是一个缺陷 :)，需要修复。

undefinedblock 和 tx

type block struct {
    AddrFrom string
    Block    []byte
}
type tx struct {
    AddFrom     string
    Transaction []byte
}

实际完成数据转移的正是这些消息。

处理block消息十分简单：

func handleBlock(request []byte, bc *Blockchain) {
    ...
    blockData := payload.Block
    block := DeserializeBlock(blockData)
    fmt.Println("Recevied a new block!")
    bc.AddBlock(block)//加入下载的区块到本地区块链
    fmt.Printf("Added block %x\n", block.Hash)
    if len(blocksInTransit) > 0 {//迭代需要下载的区块哈希列表
        blockHash := blocksInTransit[0]
        sendGetData(payload.AddrFrom, "block", blockHash)//这里是从回复哈希列表的节点处，请求其一一给下区块
        blocksInTransit = blocksInTransit[1:]//排除第一个，更新待下载区块列表
    } else {//区块下载完毕
        UTXOSet := UTXOSet{bc}
        UTXOSet.Reindex()//最好不要调用Reindex，而是迭代下载的blocks，使用 UTXOSet.Update(block)更新数据库的UTXO表
    }
}

当接收到一个新块时，我们把它放到区块链里面。如果还有更多的区块需要下载，我们继续从上一个下载的块的那个节点继续请求。当最后把所有块都下载完后，对 UTXO 集进行重新索引。

TODO：并非无条件信任，我们应该在将每个块加入到区块链之前对它们进行验证。
TODO: 并非运行 UTXOSet.Reindex()，而是应该使用 UTXOSet.Update(block)，因为如果区块链很大，它将需要很多时间来对整个 UTXO 集重新索引。
处理tx消息是最困难的部分：

func handleTx(request []byte, bc *Blockchain) {
    ...
    txData := payload.Transaction
    tx := DeserializeTransaction(txData)
    mempool[hex.EncodeToString(tx.ID)] = tx//将收到的新交易放到交易内存池之中（这里最好在放到内存池之前，对交易进行验证）
    if nodeAddress == knownNodes[0] {//如果当前节点是中心节点（这里中心节点不挖矿）
        for _, node := range knownNodes {
            if node != nodeAddress && node != payload.AddFrom {//本地节点和发送此交易的节点已经有了此交易
                sendInv(node, "tx", [][]byte{tx.ID})//告知其他所有节点，中心节点处新增了此交易
            }
        }
    } else {
        if len(mempool) >= 2 && len(miningAddress) > 0 {//如果交易池中的交易大于或者等于2笔，并且当前是矿工节点
        MineTransactions:
            var txs []*Transaction
            for id := range mempool {
                tx := mempool[id]
                if bc.VerifyTransaction(&tx) {//首先验证交易
                    txs = append(txs, &tx)//加入到待挖矿的交易列表中
                }
            }
            if len(txs) == 0 {
                fmt.Println("所有交易均非法，正在等待新的交易到来...")
                return
            }
            cbTx := NewCoinbaseTX(miningAddress, "")//coninbase交易，挖矿奖励
            txs = append(txs, cbTx)
            newBlock := bc.MineBlock(txs)//挖矿
            UTXOSet := UTXOSet{bc}
            UTXOSet.Reindex()//最好不要重新索引，而是执行update
            fmt.Println("已挖到新区块!")
            for _, tx := range txs {
                txID := hex.EncodeToString(tx.ID)
                delete(mempool, txID)//从内存池中清除已完成挖矿的交易
            }
            for _, node := range knownNodes {
                if node != nodeAddress {
                    sendInv(node, "block", [][]byte{newBlock.Hash})//告知其他节点，已经有了新的区块
                }
            }
            if len(mempool) > 0 {//如果交易池还存在未处理交易，继续处理
                goto MineTransactions
            }
        }
    }
}

undefined场景检验

undefined创建中心节点

在第一个终端窗口中将NODE_ID设置为 3000，作为中心节点，3001为钱包节点，3002为矿工节点：

让我们来回顾一下上面定义的场景。

首先，在第一个终端窗口中将NODE_ID设置为 3000（export NODE_ID=3000）。为了让你知道什么节点执行什么操作，我会使用像NODE 3000或NODE 3001进行标识。

undefinedNODE 3000

创建一个钱包和一个新的区块链：

$ main createblockchain -address CENTREAL_NODE

（为了简洁起见，我会使用假地址。）

然后，会生成一个仅包含创世块的区块链。我们需要保存块，并在其他节点使用。创世块承担了一条链标识符的角色（在 Bitcoin Core 中，创世块是硬编码的）

$ cp blockchain_3000.db blockchain_genesis.db

undefinedNODE 3001

接下来，打开一个新的终端窗口，将 node ID 设置为 3001。这会作为一个钱包节点。通过blockchain_go createwallet生成一些地址，我们把这些地址叫做 WALLET_1, WALLET_2, WALLET_3.

undefinedNODE 3000

向钱包地址发送一些币：

$ main send -from CENTREAL_NODE -to WALLET_1 -amount 10 -mine
$ main send -from CENTREAL_NODE -to WALLET_2 -amount 10 -mine

-mine标志指的是块会立刻被同一节点挖出来。我们必须要有这个标志，因为初始状态时，网络中没有矿工节点。

启动节点：

$ main startnode

这个节点会持续运行，直到本文定义的场景结束。

undefinedNODE 3001

启动上面保存创世块节点的区块链：

$ cp blockchain_genesis.db blockchain_3001.db

运行节点：

$ main startnode

它会从中心节点下载所有区块。为了检查一切正常，暂停节点运行并检查余额：

$ main getbalance -address WALLET_1
Balance of 'WALLET_1': 10
$ main getbalance -address WALLET_2
Balance of 'WALLET_2': 10

你还可以检查CENTRAL_NODE地址的余额，因为 node 3001 现在有它自己的区块链：

$ main getbalance -address CENTRAL_NODE
Balance of 'CENTRAL_NODE': 10

undefinedNODE 3002

打开一个新的终端窗口，将它的 ID 设置为 3002，然后生成一个钱包。这会是一个矿工节点。初始化区块链：

$ cp blockchain_genesis.db blockchain_3002.db

启动节点：

$ main startnode -miner MINER_WALLET

undefinedNODE 3001

发送一些币：

$ main send -from WALLET_1 -to WALLET_3 -amount 1
$ main send -from WALLET_2 -to WALLET_4 -amount 1

undefinedNODE 3002

迅速切换到矿工节点，你会看到挖出了一个新块！同时，检查中心节点的输出。

undefinedNODE 3001

切换到钱包节点并启动：

$ main startnode

它会下载最近挖出来的块！