用 Go 語言構建區塊鏈

2020-02-25 19:28:53

字體：大中小

來源：轉載

供稿：網友

1. 介紹

在上一篇文章中，我們構建了一個非常簡單的數據結構，這是區塊鏈數據庫的本質。而且我們可以用它們之間的鏈接向它添加區塊：每個區塊與前一個鏈接。唉，然而在現實中添加一個區塊添加到鏈是需要高成本的工作。

2. 工作證明

區塊鏈的一個關鍵思想是，必須通過工作證明才能將數據放入其中。這是一個艱巨的工作，使塊鏈安全和一致。此外，這筆辛苦的工作也得到了獎勵（這是人們獲得采礦硬幣的方式）。

這種機制與現實生活中的機制非常相似：人們必須工作獲酬勞勵并維持生命。在網絡中，網絡的一些參與者（礦工）努力維持網絡，為其添加新的塊，并為他們的工作獲得獎勵。作為其工作的結果，塊以安全的方式并入到塊鏈中，這保持了整個塊鏈數據庫的穩定性。值得注意的是，完成工作的人必須證明這一點。

這個整體“努力工作和證明工作價值”機制被稱為工作證明。這很難因為它需要很多的計算能力：即使是高性能的計算機也不能很快的完成。此外，這項工作的難度不時增加，以保持新的塊率每小時大約6個塊。在比特幣，這樣的工作的目標是找到一個塊的哈希，滿足一些要求。這是散列，作為證明。因此，找到證據是實際工作。

最后要注意的事情。工作證明算法必須滿足要求：工作不易，證明容易。證明通常交給非工作者，所以對他們來說，驗證它不應該花太多的時間。

3. 哈希算法

在本文中，我們將討論哈希算法。如果你熟悉這個概念，你可以跳過這個部分。

哈希是獲取指定數據的哈希值的過程。哈希值是對其計算的數據的唯一表示。哈希函數是一個獲取任意大小的數據并產生固定大小的哈希的函數。以下是哈希的一些主要功能：

原始數據無法從哈希值恢復。因此，哈希過程不是加密。
數據只能有一個與之對應的哈希值，因此哈希是唯一的。
更改輸入數據中的一個字節將導致完全不同的散列。

Hashing functions are widely used to check the consistency of data. Some software providers publish checksums in addition to a software package. After downloading a file you can feed it to a hashing function and compare produced hash with the one provided by the software developer.

In blockchain, hashing is used to guarantee the consistency of a block. The input data for a hashing algorithm contains the hash of the previous block, thus making it impossible (or, at least, quite difficult) to modify a block in the chain: one has to recalculate its hash and hashes of all the blocks after it.

哈希函數被廣泛用于檢查數據的一致性。在區塊鏈中，使用哈希來保證塊的一致性。哈希算法的輸入數據包含前一個塊的哈希值，從而使得已經生成的鏈難以修改之前產生的區塊（或至少相當困難）：篡改一個區塊必須重新計算其前的所有塊的哈希值。

哈希現金

比特幣使用Hashcash，哈希現金的發明最初是為防止電子郵件垃圾郵件而開發的。它可以分為以下幾個步驟：

獲取公開的數據（在電子郵件的情況下，它是接收者的電子郵件地址;在比特幣的情況下，它是塊標題）。
添加一個計數器。計數器從0開始。
獲取數據+計數器組合的哈希值。
檢查哈希值是否符合要求。
1. 如果滿足要求，結束過程。
2. 如果不滿足要求，增加計數器并重復步驟3和4。

因此，這是一個強力brute force算法：

1. 計算一個新的哈希2. 檢查該哈希值3. 增加計數器

現在讓我們看看一個哈希必須滿足的要求。在原來的Hashcash實現中“哈希的前20位必須是零”。然而在比特幣中，哈希要求是不時進行調整的，因為盡管計算能力隨著時間的推移而增加，越來越多的礦工加入網絡，因此設計必須每10分鐘生成一個塊。

4. 編寫代碼

程序員小提醒：go和python都是不用加分號的語言

好的，我們完成了理論，讓我們編寫代碼！首先，我們來定義挖掘難度：

const targetBits = 24

4.1 目標位

在比特幣中，“目標位（target bit）”是存儲塊被挖掘的困難的頭部數據。我們現在不會實現目標調整算法，所以我們可以將難度定義為全局常數。

24是一個任意數字，我們的目標是在內存中占用少于256位的目標。而且我們希望差異足夠大，但不要太大，因為差異越大，找到合適的哈希越難。

// 工作證明type ProofOfWork struct {    block  *Block     target *big.Int //定義目標位}// 新的工作證明func NewProofOfWork(b *Block) *ProofOfWork {    target := big.NewInt(1)    target.Lsh(target, uint(256-targetBits))   //用于隨機產生target，目標數值?。?！這里從數學上保證了  // Lsh: local sensitivity hashing  //左移256個 target bits位    pow := &ProofOfWork{b, target}    return pow}

這里創建工作證明結構中保存指向區塊的指針的和指向target的指針。 “target”是上一段所述要求的另一個名稱。我們使用一個大整數，因為我們將哈希與目標進行比較：我們將哈希轉換為一個大整數，并檢查它是否小于target。

在新的工作證明的函數中，我們初始化一個值為1的big.Int，并將其左移256個 - targetBits位。 256是SHA-256哈希的長度，以比特為單位，它是我們要使用的SHA-256散列算法。目標的十六進制表示為：

0x10000000000000000000000000000000000000000000000000000000000

它在內存中占用29個字節。這是與以前的例子中的哈希的比較：

0fac49161af82ed938add1d8725835cc123a1a87b1b196488360e58d4bfb51e300000100000000000000000000000000000000000000000000000000000000000000008b0f41ec78bab747864db66bcb9fb89920ee75f43fdaaeb5544f7f76ca

第一個哈希（以“我喜歡甜甜圈”計算）大于目標，因此它不是有效的工作證明。第二個哈希（以“我喜歡甜甜圈ca07ca”計算）小于目標，因此這是一個有效的證明。

您可以將目標視為范圍的上限：如果數字（哈希）低于邊界，則它是有效的，反之亦然。降低邊界將導致有效數量減少，因此找到有效數量所需的工作更加困難。

4.2 準備數據

//準備數據，加入targetBits和noncefunc (pow *ProofOfWork) prepareData(nonce int) []byte {     data := bytes.Join(        [][]byte{            pow.block.PrevBlockHash,            pow.block.Data,            IntToHex(pow.block.Timestamp),            IntToHex(int64(targetBits)),             IntToHex(int64(nonce)),        },        []byte{},    )    return data}

4.3 工作證明

func (pow *ProofOfWork) Run() (int, []byte) {    var hashInt big.Int    var hash [32]byte    nonce := 0    fmt.Printf("Mining the block containing /"%s/"/n", pow.block.Data)   // nounce  是counter    for nonce < maxNonce { // maxNounce被設置成math.MaxInt64，防止溢出        data := pow.prepareData(nonce) // 1. prepare data        hash = sha256.Sum256(data) // 2. sha256 hash：https://golang.org/pkg/crypto/sha256/#Sum256        fmt.Printf("/r%x", hash)          hashInt.SetBytes(hash[:]) // 3. 從hexidecimal 轉換成  big INT        //執行這個for loop直到找到hashInt和target相等        if hashInt.Cmp(pow.target) == -1 { // 4. Compare integer with the target            break        } else {            nonce++        }    }    fmt.Print("/n/n")    return nonce, hash[:]}

4.4. 給`NewBlock()` 加入nounce和工作證明

移除SetHash，并更改NewBlock：

產生新區塊
工作證明

func NewBlock(data string, prevBlockHash []byte) *Block {    block := &Block{time.Now().Unix(), []byte(data), prevBlockHash, []byte{}, 0}    // 工作證明    pow := NewProofOfWork(block)    nonce, hash := pow.Run()     block.Hash = hash[:]    block.Nonce = nonce    return block}

nonce被加入到Block結構中

type Block struct {    Timestamp     int64    Data          []byte    PrevBlockHash []byte    Hash          []byte    Nonce         int // 用于驗證}

4.5. 驗證工作證明 validate()

func (pow *ProofOfWork) Validate() bool {    var hashInt big.Int    data := pow.prepareData(pow.block.Nonce) // 驗證    hash := sha256.Sum256(data)    hashInt.SetBytes(hash[:])    isValid := hashInt.Cmp(pow.target) == -1 //檢查產生的Big Int hashInt是否和target相當    return isValid}

func main() {    ...    for _, block := range bc.blocks {        ...        pow := NewProofOfWork(block)        fmt.Printf("PoW: %s/n", strconv.FormatBool(pow.Validate())) //驗證工作證明        fmt.Println()    }}

Output:

...Prev. hash:Data: Genesis BlockHash: 00000093253acb814afb942e652a84a8f245069a67b5eaa709df8ac612075038PoW: truePrev. hash: 00000093253acb814afb942e652a84a8f245069a67b5eaa709df8ac612075038Data: Send 1 BTC to IvanHash: 0000003eeb3743ee42020e4a15262fd110a72823d804ce8e49643b5fd9d1062bPoW: truePrev. hash: 0000003eeb3743ee42020e4a15262fd110a72823d804ce8e49643b5fd9d1062bData: Send 2 more BTC to IvanHash: 000000e42afddf57a3daa11b43b2e0923f23e894f96d1f24bfd9b8d2d494c57aPoW: true

5. 總結

我們的塊鏈是一個更接近其實際架構的一步：添加塊現在需要工作證明，因此mining是可能的。但是它仍然缺乏一些關鍵的特征：塊鏈數據庫不是持久性數據，沒有錢包，地址，交易，沒有共識機制。所有這些我們將在以后的文章中實現。

persistence refers to the characteristic of state that outlives the process that created it. This is achieved in practice by storing the state as data in computer data storage .