摘要：引言到目前為止，我們已經構建了一個有工作量證明機制的區塊鏈。在今天的內容中，我們會將區塊鏈持久化到一個數據庫中，然后會提供一個簡單的命令行接口，用來完成一些與區塊鏈的交互操作。這同樣也意味著，一個也就是區塊鏈的一種標識符。

翻譯的系列文章我已經放到了 GitHub 上：blockchain-tutorial，后續如有更新都會在 GitHub 上，可能就不在這里同步了。如果想直接運行代碼，也可以 clone GitHub 上的教程倉庫，進入 src 目錄執行 make 即可。

到目前為止，我們已經構建了一個有工作量證明機制的區塊鏈。有了工作量證明，挖礦也就有了著落。雖然目前的實現離一個有著完整功能的區塊鏈越來越近了，但是它仍然缺少了一些重要的特性。在今天的內容中，我們會將區塊鏈持久化到一個數據庫中，然后會提供一個簡單的命令行接口，用來完成一些與區塊鏈的交互操作。本質上，區塊鏈是一個分布式數據庫，不過，我們暫時先忽略 “分布式” 這個部分，僅專注于 “存儲” 這一點。

目前，我們的區塊鏈實現里面并沒有用到數據庫，而是在每次運行程序時，簡單地將區塊鏈存儲在內存中。那么一旦程序退出，所有的內容就都消失了。我們沒有辦法再次使用這條鏈，也沒有辦法與其他人共享，所以我們需要把它存儲到磁盤上。

那么，我們要用哪個數據庫呢？實際上，任何一個數據庫都可以。在 比特幣原始論文 中，并沒有提到要使用哪一個具體的數據庫，它完全取決于開發者如何選擇。?Bitcoin Core ，最初由中本聰發布，現在是比特幣的一個參考實現，它使用的是 ?LevelDB。而我們將要使用的是...

因為它：

非常簡單和簡約

用 Go 實現

不需要運行一個服務器

能夠允許我們構造想要的數據結構

BoltDB GitHub 上的 README 是這么說的：

Bolt 是一個純鍵值存儲的 Go 數據庫，啟發自 Howard Chu 的 LMDB. 它旨在為那些無須一個像 Postgres 和 MySQL 這樣有著完整數據庫服務器的項目，提供一個簡單，快速和可靠的數據庫。
由于 Bolt 意在用于提供一些底層功能，簡潔便成為其關鍵所在。它的
 API 并不多，并且僅關注值的獲取和設置。僅此而已。

聽起來跟我們的需求完美契合！來快速過一下：

Bolt 使用鍵值存儲，這意味著它沒有像 SQL RDBMS （MySQL，PostgreSQL 等等）的表，沒有行和列。相反，數據被存儲為鍵值對（key-value pair，就像 Golang 的 map）。鍵值對被存儲在 bucket 中，這是為了將相似的鍵值對進行分組（類似 RDBMS 中的表格）。因此，為了獲取一個值，你需要知道一個 bucket 和一個鍵（key）。

需要注意的一個事情是，Bolt 數據庫沒有數據類型：鍵和值都是字節數組（byte array）。鑒于需要在里面存儲 Go 的結構（準確來說，也就是存儲（塊）Block），我們需要對它們進行序列化，也就說，實現一個從 Go struct 轉換到一個 byte array 的機制，同時還可以從一個 byte array 再轉換回 Go struct。雖然我們將會使用 ?encoding/gob? 來完成這一目標，但實際上也可以選擇使用 JSON, XML, Protocol Buffers 等等。之所以選擇使用 encoding/gob, 是因為它很簡單，而且是 Go 標準庫的一部分。

在開始實現持久化的邏輯之前，我們首先需要決定到底要如何在數據庫中進行存儲。為此，我們可以參考 Bitcoin Core 的做法：

簡單來說，Bitcoin Core 使用兩個 “bucket” 來存儲數據：

其中一個 bucket 是 blocks，它存儲了描述一條鏈中所有塊的元數據

另一個 bucket 是 chainstate，存儲了一條鏈的狀態，也就是當前所有的未花費的交易輸出，和一些元數據

此外，出于性能的考慮，Bitcoin Core 將每個區塊（block）存儲為磁盤上的不同文件。如此一來，就不需要僅僅為了讀取一個單一的塊而將所有（或者部分）的塊都加載到內存中。但是，為了簡單起見，我們并不會實現這一點。

在 blocks 中，key -> value 為：

在 chainstate，key -> value 為：

詳情可見 這里:_Data_Storage)。

因為目前還沒有交易，所以我們只需要 blocks bucket。另外，正如上面提到的，我們會將整個數據庫存儲為單個文件，而不是將區塊存儲在不同的文件中。所以，我們也不會需要文件編號（file number）相關的東西。最終，我們會用到的鍵值對有：

32 字節的 block-hash -> block 結構

l -> 鏈中最后一個塊的 hash

這就是實現持久化機制所有需要了解的內容了。

上面提到，在 BoltDB 中，值只能是 []byte 類型，但是我們想要存儲 Block 結構。所以，我們需要使用 encoding/gob 來對這些結構進行序列化。

讓我們來實現 Block 的 Serialize 方法（為了簡潔起見，此處略去了錯誤處理）：

func (b *Block) Serialize() []byte {
    var result bytes.Buffer
    encoder := gob.NewEncoder(&result)

    err := encoder.Encode(b)

    return result.Bytes()
}

這個部分比較直觀：首先，我們定義一個 buffer 存儲序列化之后的數據。然后，我們初始化一個 gob encoder 并對 block 進行編碼，結果作為一個字節數組返回。

接下來，我們需要一個解序列化的函數，它會接受一個字節數組作為輸入，并返回一個 Block. 它不是一個方法（method），而是一個多帶帶的函數（function）：

func DeserializeBlock(d []byte) *Block {
    var block Block

    decoder := gob.NewDecoder(bytes.NewReader(d))
    err := decoder.Decode(&block)

    return &block
}

這就是序列化部分的內容了。

讓我們從 NewBlockchain 函數開始。在之前的實現中，它會創建一個新的
Blockchain 實例，并向其中加入創世塊。而現在，我們希望它做的事情有：

打開一個數據庫文件

檢查文件里面是否已經存儲了一個區塊鏈

如果已經存儲了一個區塊鏈：

創建一個新的 Blockchain 實例

設置 Blockchain 實例的 tip 為數據庫中存儲的最后一個塊的哈希

如果沒有區塊鏈：

創建創世塊

存儲到數據庫

將創世塊哈希保存為最后一個塊的哈希

創建一個新的 Blockchain 實例，其 tip 指向創世塊（tip 有尾部，尖端的意思，在這里 tip 存儲的是最后一個塊的哈希）

代碼大概是這樣：

func NewBlockchain() *Blockchain {
    var tip []byte
    db, err := bolt.Open(dbFile, 0600, nil)

    err = db.Update(func(tx *bolt.Tx) error {
        b := tx.Bucket([]byte(blocksBucket))

        if b == nil {
            genesis := NewGenesisBlock()
            b, err := tx.CreateBucket([]byte(blocksBucket))
            err = b.Put(genesis.Hash, genesis.Serialize())
            err = b.Put([]byte("l"), genesis.Hash)
            tip = genesis.Hash
        } else {
            tip = b.Get([]byte("l"))
        }

        return nil
    })

    bc := Blockchain{tip, db}

    return &bc
}

來一段一段地看下代碼：

db, err := bolt.Open(dbFile, 0600, nil)

這是打開一個 BoltDB 文件的標準做法。注意，即使不存在這樣的文件，它也不會返回錯誤。

err = db.Update(func(tx *bolt.Tx) error {
...
})

在 BoltDB 中，數據庫操作通過一個事務（transaction）進行操作。有兩種類型的事務：只讀（read-only）和讀寫（read-write）。這里，打開的是一個讀寫事務（db.Update(...)），因為我們可能會向數據庫中添加創世塊。

b := tx.Bucket([]byte(blocksBucket))

if b == nil {
    genesis := NewGenesisBlock()
    b, err := tx.CreateBucket([]byte(blocksBucket))
    err = b.Put(genesis.Hash, genesis.Serialize())
    err = b.Put([]byte("l"), genesis.Hash)
    tip = genesis.Hash
} else {
    tip = b.Get([]byte("l"))
}

這里是函數的核心。在這里，我們先獲取了存儲區塊的 bucket：如果存在，就從中讀取 l 鍵；如果不存在，就生成創世塊，創建 bucket，并將區塊保存到里面，然后更新 l 鍵以存儲鏈中最后一個塊的哈希。

另外，注意創建 Blockchain 一個新的方式：

bc := Blockchain{tip, db}

這次，我們不在里面存儲所有的區塊了，而是僅存儲區塊鏈的 tip。另外，我們存儲了一個數據庫連接。因為我們想要一旦打開它的話，就讓它一直運行，直到程序運行結束。因此，Blockchain 的結構現在看起來是這樣：

type Blockchain struct {
    tip []byte
    db  *bolt.DB
}

接下來我們想要更新的是 AddBlock 方法：現在向鏈中加入區塊，就不是像之前向一個數組中加入一個元素那么簡單了。從現在開始，我們會將區塊存儲在數據庫里面：

func (bc *Blockchain) AddBlock(data string) {
    var lastHash []byte

    err := bc.db.View(func(tx *bolt.Tx) error {
        b := tx.Bucket([]byte(blocksBucket))
        lastHash = b.Get([]byte("l"))

        return nil
    })

    newBlock := NewBlock(data, lastHash)

    err = bc.db.Update(func(tx *bolt.Tx) error {
        b := tx.Bucket([]byte(blocksBucket))
        err := b.Put(newBlock.Hash, newBlock.Serialize())
        err = b.Put([]byte("l"), newBlock.Hash)
        bc.tip = newBlock.Hash

        return nil
    })
}

繼續來一段一段分解開來：

err := bc.db.View(func(tx *bolt.Tx) error {
    b := tx.Bucket([]byte(blocksBucket))
    lastHash = b.Get([]byte("l"))

    return nil
})

這是 BoltDB 事務的另一個類型（只讀）。在這里，我們會從數據庫中獲取最后一個塊的哈希，然后用它來挖出一個新的塊的哈希：

newBlock := NewBlock(data, lastHash)
b := tx.Bucket([]byte(blocksBucket))
err := b.Put(newBlock.Hash, newBlock.Serialize())
err = b.Put([]byte("l"), newBlock.Hash)
bc.tip = newBlock.Hash

現在，產生的所有塊都會被保存到一個數據庫里面，所以我們可以重新打開一個鏈，然后向里面加入新塊。但是在實現這一點后，我們失去了之前一個非常好的特性：我們再也無法打印區塊鏈的區塊了，因為現在不是將區塊存儲在一個數組，而是放到了數據庫里面。讓我們來解決這個問題！

BoltDB 允許對一個 bucket 里面的所有 key 進行迭代，但是所有的 key 都以字節序進行存儲，而且我們想要以區塊能夠進入區塊鏈中的順序進行打印。此外，因為我們不想將所有的塊都加載到內存中（因為我們的區塊鏈數據庫可能很大！或者現在可以假裝它可能很大），我們將會一個一個地讀取它們。故而，我們需要一個區塊鏈迭代器（BlockchainIterator）：

type BlockchainIterator struct {
    currentHash []byte
    db          *bolt.DB
}

每當要對鏈中的塊進行迭代時，我們就會創建一個迭代器，里面存儲了當前迭代的塊哈希（currentHash）和數據庫的連接（db）。通過 db，迭代器邏輯上被附屬到一個區塊鏈上（這里的區塊鏈指的是存儲了一個數據庫連接的 Blockchain 實例），并且通過 Blockchain 方法進行創建：

func (bc *Blockchain) Iterator() *BlockchainIterator {
    bci := &BlockchainIterator{bc.tip, bc.db}

    return bci
}

注意，迭代器的初始狀態為鏈中的 tip，因此區塊將從頭到尾，也就是從最新的到最舊的進行獲取。實際上，選擇一個 tip 就是意味著給一條鏈“投票”。一條鏈可能有多個分支，最長的那條鏈會被認為是主分支。在獲得一個 tip （可以是鏈中的任意一個塊）之后，我們就可以重新構造整條鏈，找到它的長度和需要構建它的工作。這同樣也意味著，一個 tip 也就是區塊鏈的一種標識符。

BlockchainIterator 只會做一件事情：返回鏈中的下一個塊。

func (i *BlockchainIterator) Next() *Block {
    var block *Block

    err := i.db.View(func(tx *bolt.Tx) error {
        b := tx.Bucket([]byte(blocksBucket))
        encodedBlock := b.Get(i.currentHash)
        block = DeserializeBlock(encodedBlock)

        return nil
    })

    i.currentHash = block.PrevBlockHash

    return block
}

這就是數據庫部分的內容了！

到目前為止，我們的實現還沒有提供一個與程序交互的接口：目前只是在 main 函數中簡單執行了 NewBlockchain 和 bc.AddBlock 。是時候改變了！現在我們想要擁有這些命令：

blockchain_go addblock "Pay 0.031337 for a coffee"
blockchain_go printchain

所有命令行相關的操作都會通過 CLI 結構進行處理：

type CLI struct {
    bc *Blockchain
}

它的 “入口” 是 Run 函數：

func (cli *CLI) Run() {
    cli.validateArgs()

    addBlockCmd := flag.NewFlagSet("addblock", flag.ExitOnError)
    printChainCmd := flag.NewFlagSet("printchain", flag.ExitOnError)

    addBlockData := addBlockCmd.String("data", "", "Block data")

    switch os.Args[1] {
    case "addblock":
        err := addBlockCmd.Parse(os.Args[2:])
    case "printchain":
        err := printChainCmd.Parse(os.Args[2:])
    default:
        cli.printUsage()
        os.Exit(1)
    }

    if addBlockCmd.Parsed() {
        if *addBlockData == "" {
            addBlockCmd.Usage()
            os.Exit(1)
        }
        cli.addBlock(*addBlockData)
    }

    if printChainCmd.Parsed() {
        cli.printChain()
    }
}

我們會使用標準庫里面的 flag 包來解析命令行參數：

addBlockCmd := flag.NewFlagSet("addblock", flag.ExitOnError)
printChainCmd := flag.NewFlagSet("printchain", flag.ExitOnError)
addBlockData := addBlockCmd.String("data", "", "Block data")

首先，我們創建兩個子命令: addblock 和 printchain, 然后給 addblock 添加 -data 標志。printchain 沒有任何標志。

switch os.Args[1] {
case "addblock":
    err := addBlockCmd.Parse(os.Args[2:])
case "printchain":
    err := printChainCmd.Parse(os.Args[2:])
default:
    cli.printUsage()
    os.Exit(1)
}

然后，我們檢查用戶提供的命令，解析相關的 flag 子命令：

if addBlockCmd.Parsed() {
    if *addBlockData == "" {
        addBlockCmd.Usage()
        os.Exit(1)
    }
    cli.addBlock(*addBlockData)
}

if printChainCmd.Parsed() {
    cli.printChain()
}

接著檢查解析是哪一個子命令，并調用相關函數：

func (cli *CLI) addBlock(data string) {
    cli.bc.AddBlock(data)
    fmt.Println("Success!")
}

func (cli *CLI) printChain() {
    bci := cli.bc.Iterator()

    for {
        block := bci.Next()

        fmt.Printf("Prev. hash: %x
", block.PrevBlockHash)
        fmt.Printf("Data: %s
", block.Data)
        fmt.Printf("Hash: %x
", block.Hash)
        pow := NewProofOfWork(block)
        fmt.Printf("PoW: %s
", strconv.FormatBool(pow.Validate()))
        fmt.Println()

        if len(block.PrevBlockHash) == 0 {
            break
        }
    }
}

這部分內容跟之前的很像，唯一的區別是我們現在使用的是 BlockchainIterator 對區塊鏈中的區塊進行迭代：

記得不要忘了對 main 函數作出相應的修改：

func main() {
    bc := NewBlockchain()
    defer bc.db.Close()

    cli := CLI{bc}
    cli.Run()
}

注意，無論提供什么命令行參數，都會創建一個新的鏈。

這就是今天的所有內容了! 來看一下是不是如期工作：

$ blockchain_go printchain
No existing blockchain found. Creating a new one...
Mining the block containing "Genesis Block"
000000edc4a82659cebf087adee1ea353bd57fcd59927662cd5ff1c4f618109b

Prev. hash:
Data: Genesis Block
Hash: 000000edc4a82659cebf087adee1ea353bd57fcd59927662cd5ff1c4f618109b
PoW: true

$ blockchain_go addblock -data "Send 1 BTC to Ivan"
Mining the block containing "Send 1 BTC to Ivan"
000000d7b0c76e1001cdc1fc866b95a481d23f3027d86901eaeb77ae6d002b13

Success!

$ blockchain_go addblock -data "Pay 0.31337 BTC for a coffee"
Mining the block containing "Pay 0.31337 BTC for a coffee"
000000aa0748da7367dec6b9de5027f4fae0963df89ff39d8f20fd7299307148

Success!

$ blockchain_go printchain
Prev. hash: 000000d7b0c76e1001cdc1fc866b95a481d23f3027d86901eaeb77ae6d002b13
Data: Pay 0.31337 BTC for a coffee
Hash: 000000aa0748da7367dec6b9de5027f4fae0963df89ff39d8f20fd7299307148
PoW: true

Prev. hash: 000000edc4a82659cebf087adee1ea353bd57fcd59927662cd5ff1c4f618109b
Data: Send 1 BTC to Ivan
Hash: 000000d7b0c76e1001cdc1fc866b95a481d23f3027d86901eaeb77ae6d002b13
PoW: true

Prev. hash:
Data: Genesis Block
Hash: 000000edc4a82659cebf087adee1ea353bd57fcd59927662cd5ff1c4f618109b
PoW: true

在下篇文章中，我們將會實現地址，錢包，（可能實現）交易。盡請收聽！

鏈接

Full source codes

Bitcoin Core Data Storage:_Data_Storage)

boltdb

encoding/gob

flag

本文源碼：part_3

原文：Building Blockchain in Go. Part 3: Persistence and CLI