[[387336]]

本文轉載自微信公眾號「區塊鏈研究實驗室」，作者鏈三豐。轉載本文請聯系區塊鏈研究實驗室公眾號。

什么是區塊鏈?建造一個難嗎?從哪里開始?使用哪種編程語言?

相信我，在遇到對區塊鏈技術感興趣的人時，我經常會遇到這些問題，您也可能遇到其中的一些問題。

 

在線上有大量的區塊鏈資源，但是將它們理解為這項蓬勃發展的技術的新手，這讓人感到不知所措。

在這篇文章中，我將step by step給你展示，你就會明白blockchain以及如何的基本概念，采用方案一的Python，Javascript，或Golang 。

我選擇這些語言是因為大多數人都熟悉它們，尤其是Javascript和Python。但是出于速度，耐用性和安全性的考慮，大多數區塊鏈核心引擎都是內置的c / c ++(比特幣，EOS)，Go(超級賬本結構，以太坊)，Java(以太坊)，Rust，Haskell和/或Ruby(以太坊)然后提供與其他易于使用的編程語言。

此外，一些區塊鏈引擎結合了多種編程語言，以實現健壯性并易于開發人員使用，以太坊是最佳用例。

先決條件：

• 網絡
• 密碼學
• 數據結構與算法
• 分布式系統
• Javascript / Go / Python

您只需要基本概念即可對拳頭區塊鏈原型進行編程。

什么是區塊鏈?

讓我們先了解一下，區塊鏈不是比特幣，區塊鏈不是數字貨幣， 區塊鏈是一套已經存在的不同技術。

讓我們通過舉一個例子來簡化事情，因為工程師對數字的理解會更好。讓我們來看一個存儲一些信息的MySQL數據庫。

 

使用上述數據庫，我們可以：

• 做一些CRUD(創建，檢索，更新和刪除)操作，
• 將相同的信息存儲兩次，
• 刪除整個數據庫，
• 我們不能與他人共享敏感信息，
• 數據庫可以集中化(單點故障，安全問題)，
• 無法信任存儲在其中的所有內容。
• 一些數據庫可以允許表之間的關系(例如RDBMS)，而另一些數據庫則不能容忍這種關系(例如NoSQL數據庫)，
• 惡意的人可能會炸毀數據庫
• 需要一名數據庫管理員(他/她可以更改或泄露信息)
• 用戶無法控制自己的數據
• 等等…

那么，為什么我們需要不同的東西，可靠的東西，獨立于人的東西，自動的東西，不可變的東西呢?那就是區塊鏈開始的地方。

區塊鏈是一個安全，可信的去中心化數據庫和網絡。

“Truth can only be found in one place: the code. ”

區塊鏈是一連串的區塊，區塊類似于數據庫中的表，但是它們不能被刪除或更新，區塊包含稱為交易的信息和其他附加數據。這些區塊經過密碼驗證并鏈接形成一個不變的區塊鏈，稱為區塊鏈或分類賬。

 

然后，同一條鏈通過P2P網絡分布到整個網絡中的所有節點。

 

因此，代替集中式數據庫，跨節點共享的所有事務(數據)都包含在塊中，這些塊鏈接在一起以創建分類帳。該分類賬代表區塊鏈中的所有數據。分類賬中的所有數據均通過加密哈希和數字簽名進行保護，并通過共識算法進行驗證。網絡上的節點參與以確保跨網絡分布的所有數據副本都是相同的。

在區塊鏈生態系統中要記住的5個關鍵概念：

• 加密哈希和數字簽名
• 不變的分類帳
• P2P網絡
• 共識算法(PoW，PoS，PBFT，ETc…)
• 塊驗證(采礦，鍛造等)

我們將繼續詳細解釋這些概念。

使用區塊鏈的好處：

• 刪除中介組織
• 不變的分類帳
• 透明度
• 安全

何時使用區塊鏈?

區塊鏈不是靈丹妙藥，因此在以下情況下使用它：

• 存儲的數據無需修改(存在證明)
• 數據不能被其所有者拒絕(不可否認)
• 你想權力下放
• 你想要一個真理的源頭
• 您想要高安全性
• 您不必擔心速度(例如，比特幣平均需要10分鐘才能驗證一筆交易)。

但是某些區塊鏈速度更快，因為它們使用除PoW之外的不同共識算法

我們稍后再討論。

區塊鏈用例

區塊鏈應用領域

• 房地產：土地所有權
• 醫療保健：安全記錄患者的數據
• 財務：減少稅收和中介機構，反洗錢，跨境支付
• 供應鏈：跟蹤從供應商到客戶的商品(真實性，原創內容的創建)
• 網絡安全：DDOS攻擊
• 將權力交還給用戶：擁有數據并與所需的人安全地共享(DID)
• 加密貨幣兌換
• 投票機制

區塊鏈平臺和應用

• 比特幣
• 以太坊
• 織物
• EOS
• 鏈環
• 卡爾達諾
• 等等…

區塊鏈類型

• 私有：僅在內部使用，并且在我們更了解用戶的情況下使用(例如Hyperledger Fabric)
• 公開：每個人都可以看到正在發生的事情(比特幣，以太坊)
• 混合：合并前兩個。

“Talk is cheap. Show me the code.”

有兩種方法可以構建區塊鏈：

• 一種簡單的方法是使用現有的預先構建的區塊鏈開源資源，例如以太坊，Fabric，EOS等…
• 如果它們都不符合您的要求，那么請從頭開始構建

在本系列中，我們將從頭開始構建一個，以便您可以徹底了解區塊鏈的狀態機。

如何建立區塊鏈?

好的，現在讓我們用三種不同的編程語言Go，Python和Javascript創建第一個小區塊鏈demo。這些原型可以幫助您理解我們前面介紹的概念。

首先，我們將創建一個塊，第二，我們將添加數據(標題和正文)給它，第三，我們將散列塊，和最后但并非最不重要，我們將鏈中的所有塊了。

一個塊包含前面提到的信息，但是為了簡化起見，我們將刪除一些信息。讓我們深入研究細節!

希望您像我之前提到的那樣熟悉Go編程，如果不嘗試學習基礎知識：函數，方法，數據類型，結構，流控制，迭代等…

創建一個文件夾并向其中添加2個文件， main.go and block.go

資料夾結構：

go // the folder 
  main.go // file 1 
  block.go // file 2 

main.go

// use the main package 
package main 
//import the fmt package 
import ( 
"fmt" 
) 
func main(){ 
fmt.Println("I am building my first blockchain") // print this 
CreateBlock("The hearder will be shown here", "the body will be shown here") // call the function that will create the block and pass some parameters in it. 
} 

如果您運行此程序，則由于該CreateBlock函數尚未定義，因此將顯示錯誤消息，因此請繼續在其中創建它block.go：

block.go

package main 
import ( 
"fmt" // this will help us to print on the screen 
) 
func CreateBlock(Header, Body string){ 
fmt.Println(Header ,"\n", Body) // Show me the block content 
} 

Go的優點在于您不必導入或導出函數，只需使用大寫字母聲明它們，Go就會為您找到它們。現在打開終端并移至您創建的文件夾，run go build然后.\go在Windows，./goLinux和Macbook上運行。

 

我們剛剛創建了一個簡單的Go程序，該程序調用一個函數并傳遞一些字符串數據。讓我們繼續做更多美好的事情。讓我們添加2個文件，blockchain.go而structures.go現在我們有4個文件：main.go, block.go, structures.go, and blockchain.go

我將在代碼的每一行中添加一些注釋，以使您了解我在做什么。

structures.go

package main //Import the main package 
// Create the Block data structure 
// A block contains this info: 
type Block struct { 
  Timestamp         int64  // the time when the block was created 
  PreviousBlockHash []byte // the hash of the previous block 
  MyBlockHash       []byte // the hash of the current block 
  AllData           []byte // the data or transactions (body info) 
} 
 
// Prepare the Blockchain data structure : 
type Blockchain struct { 
  Blocks []*Block // remember a blockchain is a series of blocks 
} 

block.go

package main 
 
import ( 
  // We will need these libraries: 
  "bytes"         // need to convert data into byte in order to be sent on the network, computer understands better the byte(8bits)language 
  "crypto/sha256" //crypto library to hash the data 
  "strconv"       // for conversion 
  "time"          // the time for our timestamp 
) 
 
// Now let's create a method for generating a hash of the block 
// We will just concatenate all the data and hash it to obtain the block hash 
func (block *Block) SetHash() { 
  timestamp := []byte(strconv.FormatInt(block.Timestamp, 10))                                  // get the time and convert it into a unique series of digits 
  headers := bytes.Join([][]byte{timestamp, block.PreviousBlockHash, block.AllData}, []byte{}) // concatenate all the block data 
  hash := sha256.Sum256(headers)                                                               // hash the whole thing 
  block.MyBlockHash = hash[:]                                                                  // now set the hash of the block 
} 
 
// Create a function for new block generation and return that block 
func NewBlock(data string, prevBlockHash []byte) *Block { 
  block := &Block{time.Now().Unix(), prevBlockHash, []byte{}, []byte(data)} // the block is received 
  block.SetHash()                                                           // the block is hashed 
  return block                                                              // the block is returned with all the information in it 
} 
 
/* let's now create the genesis block function that will return the first block. The genesis block is the first block on the chain */ 
func NewGenesisBlock() *Block { 
  return NewBlock("Genesis Block", []byte{}) // the genesis block is made with some data in it 
} 

blockchain.go

package main 
 
// create the method that adds a new block to a blockchain 
func (blockchain *Blockchain) AddBlock(data string) { 
  PreviousBlock := blockchain.Blocks[len(blockchain.Blocks)-1] // the previous block is needed, so let's get it 
  newBlock := NewBlock(data, PreviousBlock.MyBlockHash)        // create a new block containing the data and the hash of the previous block 
  blockchain.Blocks = append(blockchain.Blocks, newBlock)      // add that block to the chain to create a chain of blocks 
} 
 
/* Create the function that returns the whole blockchain and add the genesis to it first. the genesis block is the first ever mined block, so let's create a function that will return it since it does not exist yet */ 
func NewBlockchain() *Blockchain { // the function is created 
  return &Blockchain{[]*Block{NewGenesisBlock()}} // the genesis block is added first to the chain 
} 

main.go

//Time to put everything together and test 
package main 
import ( 
  "fmt" // just for printing something on the screen 
) 
func main() { 
  newblockchain := NewBlockchain() // Initialize the blockchain 
  // create 2 blocks and add 2 transactions 
  newblockchain.AddBlock("first transaction")  // first block containing one tx 
  newblockchain.AddBlock("Second transaction") // second block containing one tx 
  // Now print all the blocks and their contents 
  for _, block := range newblockchain.Blocks { // iterate on each block 
    fmt.Printf("Hash of the block %x\n", block.MyBlockHash)                 // print the hash of the block 
    fmt.Printf("Hash of the previous Block: %x\n", block.PreviousBlockHash) // print the hash of the previous block 
    fmt.Printf("All the transactions: %s\n", block.AllData)                 // print the transactions 
  } // our blockchain will be printed 
} 

讓我們現在運行它，go build然后.\go

 

我們在區塊鏈中的區塊沒有任何ID和時間戳，因此讓我們通過修改main.go文件來添加該信息，并在中添加這兩行for loop：

fmt.Printf("Block ID : %d \n", i)                                         
fmt.Printf("Timestamp : %d \n", block.Timestamp+int64(i)) 

//Time to put everything together and test 
package main 
 
import ( 
  "fmt" // just for printing something on the screen 
) 
 
func main() { 
  newblockchain := NewBlockchain() // Initialize the blockchain 
  // create 2 blocks and add 2 transactions 
  newblockchain.AddBlock("first transaction")  // first block containing one tx 
  newblockchain.AddBlock("Second transaction") // second block containing one tx 
  // Now print all the blocks and their contents 
  for i, block := range newblockchain.Blocks { // iterate on each block 
    fmt.Printf("Block ID : %d \n", i)                                        // print the block ID 
    fmt.Printf("Timestamp : %d \n", block.Timestamp+int64(i))                // print the timestamp of the block, to make them different, we just add a value i 
    fmt.Printf("Hash of the block : %x\n", block.MyBlockHash)                // print the hash of the block 
    fmt.Printf("Hash of the previous Block : %x\n", block.PreviousBlockHash) // print the hash of the previous block 
    fmt.Printf("All the transactions : %s\n", block.AllData)                 // print the transactions 
  } // our blockchain will be printed 
} 

讓我們保存代碼，go build然后再次運行它，然后./go

 

如您所見，區塊鏈結構良好。除創世塊外，每個塊均包含其哈希值和上一個塊的哈希值，這使其不可變，如果更改了該塊中的數據，則哈希值將自動更改，并且該塊將被丟棄。創世塊沒有任何先前的哈希，因為它是第一個哈希，沒有先前的塊。

 

全部完成!恭喜，您剛剛在Go created中創建了自己的區塊鏈DEMO!