2. 程式人生 > >[譯]用go進行區塊鏈開發3:持久化與CLI

[譯]用go進行區塊鏈開發3:持久化與CLI

阿新 • • 發佈：2019-02-09

原地址

簡介

目前為止，我們做了帶有工作量證明系統的區塊鏈，因此它是可以挖礦的。我們的實現與全功能的區塊鏈越來越接近了，但還缺乏一些重要特性。今天我們將把區塊鏈存到一個數據庫中，並在那之後做個簡單的命令列工具來對它進行操作。本質上，區塊鏈是分散式資料庫。我們暫時忽略“分散式”部分專注於“資料庫”部分。

資料庫選擇

我們當前的實現中還沒有資料庫；而是在每次執行程式的時候建立區塊鏈並儲存在記憶體中。我們無法複用一個區塊鏈，也不能與他人分享，因此需要把它存在磁碟上。

我們需要哪個資料庫？事實上任意一個都可以。在比特幣白皮書中沒有提到具體資料庫的使用，因此使用什麼資料庫取決於開發者。現在普遍的比特幣實現參考是Satoshi Nakamoto最初發布的

Bitcoin Core，它用的LevelDB(儘管2012年才釋出)。我們將要用的是…

BoltDB

因為：

  1. 它是極簡的並易於使用。
  2. 用go實現。
  3. 不需要執行伺服器。
  4. 允許建立我們想要的資料結構。

Bolt is a pure Go key/value store inspired by Howard Chu’s LMDB project. The goal of the project is to provide a simple, fast, and reliable database for projects that don’t require a full database server such as Postgres or MySQL.

Since Bolt is meant to be used as such a low-level piece of functionality, simplicity is key. The API will be small and only focus on getting values and setting values. That’s it.

聽起來非常符合我們的需求。花一分鐘來仔細看一下。

BoltDB是一個鍵值對儲存的資料庫，這意味著它沒有SQL RDBMS（如MySQL,PostgreSql等）中的表，沒有行，沒有列。取而代之的是，資料以鍵值對（類似golang中的map）的形式儲存。鍵值對存放在桶中（bucket）,意在給類似的鍵值對分組（跟RDBMS中的表類似）。因此，獲取一個值需要知道它的key以及所在的桶。

關於BoltDB的一個重點是沒有資料型別：鍵和值都是位元組陣列。由於我們要儲存go的結構體（尤其是Block），需要對它進行序列化，例如實現一個把go結構體轉換成位元組陣列並能把它從位元組資料恢復的機制。對於這個我們將用

encoding/gob，不過JSON、XML、ProtocolBuffers等都是可以的。我們用encoding/gob是因為它簡單並且是go標準庫中的。

資料庫結構

在我們開始實現持久化邏輯之前，先定下來如何在資料庫中儲存資料。我們將參考Bitcoin Core的方式。

簡單地說，Bitcoin Core用了兩個“桶”來存資料：

  1. block 中存放描述鏈中所有區塊的元資料。
  2. chainstate 存放鏈的狀態，即當前所有未完成交易的輸出及一些元資料。

另外，區塊存放在磁碟上的獨立檔案中。這麼做是出於效能目的：讀取單個區塊不需要把所有（或多個）載入到記憶體中。我們將不實現這個。

block中有如下鍵值對：

  1. ‘b’ + 32位元組的區塊雜湊 -> 區塊索引記錄
  2. ‘f’ + 4位元組的檔案號 -> 檔案資訊記錄
  3. ‘l’ + 4位元組的檔案號 -> 最後一個區塊用的檔案號
  4. ‘R’ + 1位元組的布林值 -> 是否正在重建索引
  5. ‘F’ + 1位元組的標識名 + 標識名字串 -> 1位元組的布林值：可以置為開和關的各種標識
  6. ‘t’ + 32位元組的交易雜湊 -> 交易索引記錄

在chainstate中的鍵值對如下：

  1. ‘c’ + 32位元組的交易雜湊 -> 該交易未處理完的輸出記錄
  2. ‘B’ -> 32位元組的區塊雜湊:此雜湊取決於描述未處理完交易輸出的資料庫

（詳細資訊在這裡）

由於我們還沒有交易，現在只用一個blocks桶。另外，如剛才所說，我們將把整個資料庫存到單個檔案中而不是把每個區塊存到獨立檔案中。因此與檔案號相關的內容都不需要了。現在我們用的key->value對是這些：

  1. 32位元組的區塊雜湊 -> 區塊結構體(序列化後的)
  2. ‘l’ -> 鏈中最後一個區塊的雜湊值

這就是我們實現持久化機制需要的所有東西。

序列化

如之前所說，在BoltDB中只能用位元組陣列，我們要往資料庫中儲存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()
}

這段程式碼很直觀：先宣告一個緩衝區用來存放序列化後的資料；然後初始化一個gob編碼器並對區塊進行編碼；結果以位元組陣列的形式返回。

接下來，我們需要一個接收位元組陣列並返回一個Block的反序列化方法。這不是方法而是一個獨立的函式：

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

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

    return &block
}

這就是序列化部分。

持久化

我們從NewBlockchain方法開始看。目前它是建立一個Blockchain例項並加上創世區塊。我們想要的是這樣：

  1. 開啟一個數據庫檔案。
  2. 檢查裡面是否存了區塊鏈。
  3. 如果裡面有：
    1. 建立一個新的Blockchain例項。
    2. 把Blockchain例項的末端設為資料庫中儲存的最後一個區塊
  4. 如果沒有區塊鏈：
    1. 建立創世區塊
    2. 存入資料庫
    3. 把創世區塊的雜湊存作為最後區塊雜湊儲存
    4. 建立一個尾部指向創世區塊的Blockchain例項

程式碼如下：

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中，對資料庫的操作在事務中進行。事務分兩種：只讀的和讀寫的。因為我們希望吧創世區塊存入資料庫，這裡我們開啟了一個讀寫事務（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"))
}

上面的程式碼是這個函式的核心。我們獲取到存放區塊的桶：如果存在就讀取鍵l；如果不存在就生成創世區塊，建立桶，並把創世區塊存進去，然後更新存放鏈中最後區塊雜湊值的l鍵。

另外，注意我們建立Blockchain的新方式：

bc := Blockchain{tip, db}

我們不再把所有區塊存進去了，而是隻存已儲存區塊鏈的末端。另外還儲存了一個數據庫連結，因為我們希望一旦開啟它就讓它隨著程式的執行一直處於開啟的狀態。因此現在的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

挖到新區塊後，我們把序列化後的資料存放到資料庫並更新l鍵存的雜湊值。

完成！並不難，不是嗎

檢查區塊鏈

現在所有區塊都存在了資料庫中，因此我們可以重新開啟一條區塊鏈並給它新增新區塊。但是實現這個之後我們失去了一個不錯的特性：由於我們不再把區塊存到陣列中，不能列印區塊資訊了。我們來修復這個瑕疵!

BoltDB允許迭代一個桶中的所有鍵，但是鍵是以位元組順序儲存，我們想以區塊在區塊鏈中的順序來列印。另外，由於我們不想把所有區塊載入到記憶體（我們的區塊鏈資料庫可能很大…我們假裝它很大），我們將逐個讀取區塊。為此，需要一個區塊鏈迭代器：

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

我們想迭代區塊鏈中所有區塊時會建立一個迭代器，它儲存當前迭代到的區塊雜湊和一個數據庫連結。鑑於後者，一個迭代器在邏輯上依附於一個區塊鏈（儲存一個數據庫連結的Blockchain例項），因此，它在一個Blockchain的方法中建立:

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

    return bci
}

注意，迭代器初始指向區塊鏈的末端，因此區塊是從上而下、從新到舊的順序獲取。事實上選擇末端意味著為一條區塊鏈“投票”。一條區塊鏈可以有多個分支，其中最長的認為是主分支。取得一個末端後（可以是區塊鏈中任意一個區塊）我們可以重建整條區塊鏈並得到它的長度以及建造它需要的工作。這也意味著一個末端是一條區塊鏈的識別符號。

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
}

以上就是資料庫部分！

CLI

到現在為止我們的實現沒有提供任何與程式互動的介面：我們只是在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，然後為前者新增-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\n", block.PrevBlockHash)
        fmt.Printf("Data: %s\n", block.Data)
        fmt.Printf("Hash: %x\n", block.Hash)
        pow := NewProofOfWork(block)
        fmt.Printf("PoW: %s\n", 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。

就這麼多了！檢查一下是否一切正常：

$ 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

（此處有開啤酒的聲音）

結語

下次我們將實現地址、錢包、交易（可能）。所以請繼續關注！

連結：

相關推薦

[譯]用go進行區塊鏈開發3:持久化與CLI

原地址 簡介 目前為止，我們做了帶有工作量證明系統的區塊鏈，因此它是可以挖礦的。我們的實現與全功能的區塊鏈越來越接近了，但還缺乏一些重要特性。今天我們將把區塊鏈存到一個數據庫中，並在那之後做個簡單的命令列工具來對它進行操作。本質上，區塊鏈是分散式資料庫。

用go編寫區塊鏈系列之3--持久化與命令列

在上一篇文章中我們構建了一個帶PoW挖礦功能的區塊鏈。我們這個區塊鏈已經很接近一個全功能的區塊鏈，但是它還缺少一些很重要的特性。這一章中我們將將實現將區塊鏈資料存入資料庫，並且編寫一個簡單的命令列介面去與區塊鏈進行互動。本質上區塊鏈是一個分散式資料庫，在這裡我們忽略“分散式”而只關注資料庫。 本

用go編寫區塊鏈系列之7--網路

1 區塊鏈中的網路 區塊鏈是一個分散式資料庫，所謂的分散式就是分散在多臺電腦上面，所以需要具有網路通訊功能。區塊鏈是一個分散式系統，意味著其中沒有客戶端和伺服器，所有的網路節點都是平等的。一個節點兼具伺服器和客戶端倆種角色，這與傳統的網路應用非常不同。 區塊鏈網路使用P2P網路，即網路中的節

用go編寫區塊鏈系列之6--交易2

0 概述 在這個系列的前面幾篇文章我們說區塊鏈是一個分散式資料庫，但是在實踐中，我們選擇忽略了“分散式”而只關注“資料庫”。目前為止我們我們實現了區塊鏈作為資料庫的所有特性。這篇文章中我們將實現前面幾篇中我們忽略的一些機制，下篇文章我們將實現分散式特性。 1 挖礦獎勵 我們忽略的一件事情

用go編寫區塊鏈系列之5--地址與數字簽名

0 介紹 在上一篇文章我們實現了交易。你被灌輸了這樣一種觀念：在比特幣中沒有賬戶，個人資訊資料不需要也不會被儲存。但是仍然需要一些東西去證明你是一筆交易的輸出的所有者。這是比特幣需要地址的原因。之前我們使用字串去代表使用者地址，現在我們需要引入地址了。 1 地址密碼學 比特幣地址

用go編寫區塊鏈系列之4--交易1

0 介紹 比特幣區塊鏈的核心就是交易，區塊鏈唯一的目的就是用一種安全可信的方式去儲存交易，交易一經建立就無法更改。這章中我們將在區塊鏈中引入交易。 1 比特幣中的交易 如果你是開發網路應用的程式設計師，若讓你開發一個線上支付交易，你多半會在資料庫中建立倆張表：賬戶表和交易表。賬戶表中將會

用go編寫區塊鏈系列之2---PoW

在前一篇文章中，我們構建了一個最簡單的額區塊鏈，本文中我們將改進這個區塊鏈，加入PoW機制，使得這個區塊鏈變成一個可以挖礦的區塊鏈。原文見https://jeiwan.cc/posts/building-blockchain-in-go-part-2/ 1 Proof-of-Work(PoW)

用go編寫區塊鏈系列之1---基本協議

本文將要用go語言實現一個最簡單的區塊鏈，更多內容請參考https://jeiwan.cc/posts/building-blockchain-in-go-part-1/。 1 區塊 區塊是區塊鏈組成單元，區塊鏈就是由一個一個區塊串聯而成。區塊鏈是一個不斷向後延伸的區塊的連結串列。這裡定義一

為什麽要用golang語言進行區塊鏈編程開發？

currency tools obj ogr graph 學習曲線 靈活 開發 cond Go語言現在常常被用來做去中心化系統（decentralised system）。其他類型的公司也都把Go用在產品的核心模塊中，並且它在網站開發中也占據了一席之地。 我們在決定做Kar

區塊鏈開發零基礎必備技能之GO語言從入門到高階視訊教程

一、    以太坊和區塊鏈的關係      從區塊鏈歷史上來說，先誕生了比特幣，當時並沒有區塊鏈這個技術和名詞，然後業界從比特幣中提取了技術架構和體系，稱之為區塊鏈技術。從比特幣提取的區塊鏈技術稱之為區塊鏈1.0時代，那個時候的應用主要以電子貨幣和

區塊鏈開發筆記——對getBlock中所得區塊的各個欄位進行解釋

一.定義 getBlock函式的返回值為區塊物件，其中包含一下多個欄位： Number - 區塊號。當這個區塊處於pending將會返回null。 hash - 字串，區塊的雜湊串。當這個區塊處於pending將會返回null。 parentHash - 字串

go實現區塊鏈[3]-遍歷區塊鏈與資料庫持久化

新建blockchain.go 1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666

區塊鏈開發語言之go語言學習線路指導

問題導讀1.為什麼學習go語言？2.你認為該如何入門go語言？3.你認為go語言需要哪些學習過程

以太坊區塊鏈開發（3.以太坊客戶端命令列選項彙總）

轉自 https://blog.csdn.net/wo541075754/article/details/53096808本篇部落格的內容可通過以下命令在客戶端中進行檢視：geth --help1也可以訪問github上的wiki文件檢視，地址為：https://github

區塊鏈學習(3)--以太坊Dapp開發

c函數 ali cati 意思 定制 區塊鏈學習 網絡 開發 功能 DApp是Decentralized Application的縮寫，譯為:分散式的應用程序。App我們都知道，我們在智能手機上安裝的應用程序也就是App。而DApp比App多了一個‘D’，‘D’的意思是分散

教程首發：用區塊鏈開發小程式！（程式設計師入門區塊鏈系列）

2018年，區塊鏈技術可謂是最熱的寵兒。在國務院釋出的檔案中，區塊鏈技術被定義為戰略性前沿技術超

區塊鏈開發：以太坊網絡

創建 bash net ner 系統 extra c99 分開 opera 區塊鏈開發：以太坊網絡 一、geth Geth 又名Go Ethereum. 是以太坊協議的三種實現之一，由Go語言開發，完全開源的項目。Geth 可以被安裝在很多操作系統上，包括Windows、L

區塊鏈開發、以太坊開發的技術資料資源匯總

以太坊 以太坊開發 ethereum truffle solidity 以太坊入門 區塊鏈入門 區塊鏈 區塊鏈開發 blockchain 一個適合區塊鏈新手的以太坊DApp開發教程： http://xc.hubwiz.com/course/5a952991adb

區塊鏈開發區塊鏈開發前景分析

區塊鏈開發區塊鏈開發技術正以驚人速度發展，大量應用加速鋪開。預計在2020年內，區塊鏈開發產業將產生800-1100億美元的收益，而站在最前方的互聯網金融有望率先獲益。我國對於引領變革的區塊鏈同樣高度重視，產業發展勢頭迅猛，創業熱情持續高漲。目前，我國擁有區塊鏈企業105家，僅次於美國，位列全球第二。隨著國內

區塊鏈開發公司閑談相關知識總結

14. ger 資源 互聯 1.0 政府 用戶 概念 請求 說起區塊鏈要先從btc（比特幣）說起 區塊鏈有1.0 2.0 3.0 而BTC的概念最初由中本聰提出的去中心化的幣。區塊鏈技術卻受到各界一致的看好，區塊鏈技術有去中心化 不可復制 不可篡改 可追溯 可編程 自治性