如何使用Rust從零開發(fā)區(qū)塊鏈

在這一系列的文章中，我將向你展示如何使用 Rust 語言從零開始編寫一個區(qū)塊鏈。這些文章并不是為了想學習智能合約編程的人，而是為了理解區(qū)塊鏈的底層知識 - 區(qū)塊、鏈、鍵值數(shù)據(jù)庫、網(wǎng)絡(luò)、共識機制等的人而準備的。如果你想學習區(qū)塊鏈的底層知識，這就是你要找的地方。

我已經(jīng)在區(qū)塊鏈領(lǐng)域工作了幾年，從一開始就計劃寫這一系列的文章來學習區(qū)塊鏈。但直到現(xiàn)在，我才有足夠的時間來做這件事。我主要熟悉 Substrate 框架，從其文檔站點學到了很多知識，從核心概念到如何使用它來開發(fā)應(yīng)用。所以我建議你如果有時間的話，去閱讀那些文檔，他們官方還有關(guān)于它的課程，你可以在這里找到信息：Polkadot Academy。國內(nèi)的話，OneBlock+社區(qū)在做免費的Substrate培訓課程，你可以在這里找到最新一期（2023.12）報名鏈接。

Substrate 是一個功能齊全的區(qū)塊鏈框架，它非常強大。但它也很復(fù)雜，難以深入理解，所以我開設(shè)這個系列，幫助那些想要深入了解區(qū)塊鏈內(nèi)部的開發(fā)者。

Rust 無疑是編寫區(qū)塊鏈的首選，它也是我最喜歡的編程語言。如果你還沒有接觸過它，你應(yīng)該去試試。

好的，讓我們開始吧。

塊

什么是區(qū)塊？它是區(qū)塊鏈的基本單位。在我們的例子中，它只是一個 Rust 結(jié)構(gòu)體。我們可以這樣定義它：

structBlock{
header:BlockHeader,
body:BlockBody,
}

區(qū)塊由兩部分組成：BlockHeader 和 BlockBody。每種類型的定義如下：

BlockHeader

structBlockHeader{
hash:String,
height:u64,
prev_hash:String,
timestamp:u64,
}

BlockBody

typeBlockBody=Vec;

區(qū)塊的Body部分是一個普通的字符串向量，而頭部看起來更有趣。在所有的字段中，prev_hash 是最有趣的，它存儲了前一個區(qū)塊的哈希字段值，我們將在這篇文章后面的鏈部分討論它。

height 字段表示這個區(qū)塊的序列號，新的區(qū)塊被添加到區(qū)塊鏈中時，高度會遞增。

timestamp 字段表示創(chuàng)建這個區(qū)塊時的 Unix 時間戳。所以它與你正在使用的本地機器有關(guān)。

而 hash 字段存儲了這個區(qū)塊的哈希值。我們會問：如何計算這個區(qū)塊的哈希值？因為哈希字段是這個結(jié)構(gòu)體的一部分，所以簡單地序列化這個結(jié)構(gòu)體是行不通的。我們需要在做計算時從其他字段中排除這個字段。所以算法看起來像這樣：

fncalc_block_hash(height:u64,prev_hash:&str,timestamp:u64,body:&Vec)->String{

letconcated_str=vec![
height.to_string(),
prev_hash.to_string(),
timestamp.to_string(),
body.concat(),
]
.concat();

letmuthasher=Sha256::new();
hasher.update(concated_str.as_bytes());
hex::encode(hasher.finalize().as_slice())
}

我們不會教授如何編寫 Rust 代碼的細節(jié)，相反，我們主要會描述如何設(shè)計它的思路流程。

在這里，我們按照 height, prev_hash, timestamp, body 的順序連接這個區(qū)塊的元素。由于 body 是一個向量，我們應(yīng)該首先連接它。一旦字符串連接完成，我們使用 Sha256 對其進行哈希計算。這一步創(chuàng)建了一個 32 字節(jié)的 u8 數(shù)組：[u8; 32]。然后我們使用 hex 將其編碼為長度為 64 的字符串，這代表了這個區(qū)塊的哈希。

你會注意到，我們將 prev_hash 值作為這個區(qū)塊的哈希的來源之一。這非常重要，你可能會想知道我們?yōu)槭裁匆@么做。

我們可以按照以下方式測試這個算法：

#[test]
fntest_block_hash(){
letblock1=Block::new(10,"aaabbbcccdddeeefff".to_string(),vec![]);
letblock2=Block::new(10,"aaabbbcccdddeeefff".to_string(),vec![]);
assert_eq!(block1.header.height,block2.header.height);
assert_eq!(block1.header.prev_hash,block2.header.prev_hash);
//XXX:havelittleprobabilitytofail
assert_eq!(block1.header.timestamp,block2.header.timestamp);
//XXX:havelittleprobabilitytofail
assert_eq!(block1.header.hash,block2.header.hash);

assert_eq!(block1.body,block2.body);
}

鏈

什么是鏈？你可以想象一條項鏈或者一條鐵鏈。在我們的例子中，鏈是一個抽象的概念，每個區(qū)塊都存儲了前一個區(qū)塊的哈希字段值。就這樣，你看，沒有復(fù)雜的地方。

在這個鏈中，每個區(qū)塊只關(guān)心前一個區(qū)塊，而不關(guān)心其他區(qū)塊。所以它是一個相對簡單的結(jié)構(gòu)。

但我們即將遇到一個問題：第一個區(qū)塊怎么辦？它之前沒有區(qū)塊。

是的，對于這個邊緣情況，我們需要為 hash 字段設(shè)置一個預(yù)定義的值。由于這個特殊情況，區(qū)塊鏈的第一個區(qū)塊通常被稱為 創(chuàng)世(Genesis) 區(qū)塊。

這就是整個區(qū)塊鏈的樣子：

隨著時間的推移，這個結(jié)構(gòu)將無限擴展（或增長）。

區(qū)塊鏈管理器

我們需要一個管理器來管理區(qū)塊鏈。現(xiàn)在它非常簡單，只包含一個區(qū)塊的向量。

#[derive(Debug)]
structBlockChain{
blocks:Vec,
}

并在其上實現(xiàn)一些方法：

implBlockChain{
fnnew()->Self{
BlockChain{blocks:vec![]}
}

fngenesis()->Block{
lettxs=vec!["Thebigbrotheriswatchingyou.".to_string()];
Block::new(0,"1984,GeorgeOrwell".to_string(),txs)
}

fnadd_block(&mutself,block:Block){
self.blocks.push(block);
}
}

現(xiàn)在我們可以使用這個管理器來構(gòu)建一個區(qū)塊鏈：

fnmain(){

letmutblockchain=BlockChain::new();
letgenesis_block=BlockChain::genesis();
letprev_hash=genesis_block.header.hash.clone();
blockchain.add_block(genesis_block);

letb1=Block::new(1,prev_hash,vec![]);
letprev_hash=b1.header.hash.clone();
blockchain.add_block(b1);

letb2=Block::new(2,prev_hash,vec![]);
letprev_hash=b2.header.hash.clone();
blockchain.add_block(b2);

letb3=Block::new(3,prev_hash,vec![]);
letprev_hash=b3.header.hash.clone();
blockchain.add_block(b3);

letb4=Block::new(4,prev_hash,vec![]);
letprev_hash=b4.header.hash.clone();
blockchain.add_block(b4);

letb5=Block::new(5,prev_hash,vec![]);
//letprev_hash=b5.header.hash.clone();
blockchain.add_block(b5);

println!("{:#?}",blockchain);
}

它將打印出來類似下面的東西：

mike@alberta:~/works/blockchainworks/vintage$cargorun
Compilingvintagev0.1.0(/home/mike/works/blockchainworks/vintage)
Finisheddev[unoptimized+debuginfo]target(s)in0.22s
Running`target/debug/vintage`
BlockChain{
blocks:[
Block{
header:BlockHeader{
hash:"96cf34aa91e070ddf95eb9e0e8616b24e2f326c80d5fa9746e8dd8f0bec730d6",
height:0,
prev_hash:"1984,GeorgeOrwell",
timestamp:1705649594,
},
body:[
"Thebigbrotheriswatchingyou.",
],
},
Block{
header:BlockHeader{
hash:"0dd52ac54a9d621c47688f7920cd9eaee18ffe0cca3c83e124b8f78cef8999e5",
height:1,
prev_hash:"96cf34aa91e070ddf95eb9e0e8616b24e2f326c80d5fa9746e8dd8f0bec730d6",
timestamp:1705649594,
},
body:[],
},
Block{
header:BlockHeader{
hash:"61e95ab151cfa41c2a74cb076c33511ddf71f45dab0571f5f2db89df7ebc64cf",
height:2,
prev_hash:"0dd52ac54a9d621c47688f7920cd9eaee18ffe0cca3c83e124b8f78cef8999e5",
timestamp:1705649594,
},
body:[],
},
Block{
header:BlockHeader{
hash:"dde009c56c1b02d41fec8271e5f990e9b33c84a2cf044de6fc33e96605f90458",
height:3,
prev_hash:"61e95ab151cfa41c2a74cb076c33511ddf71f45dab0571f5f2db89df7ebc64cf",
timestamp:1705649594,
},
body:[],
},
Block{
header:BlockHeader{
hash:"f8cd3ab5f6ccc864515635878498e2e26b63b4fbf4dbc60ea3649e859b4a7d27",
height:4,
prev_hash:"dde009c56c1b02d41fec8271e5f990e9b33c84a2cf044de6fc33e96605f90458",
timestamp:1705649594,
},
body:[],
},
Block{
header:BlockHeader{
hash:"4415f4993729459f5ff07c7c963890f1d9210d5241f5203b9179c8d3db6e9dac",
height:5,
prev_hash:"f8cd3ab5f6ccc864515635878498e2e26b63b4fbf4dbc60ea3649e859b4a7d27",
timestamp:1705649594,
},
body:[],
},
],
}

我們做到了，它已經(jīng)是一個區(qū)塊鏈了。

如何持久化

到目前為止，我們只是將區(qū)塊鏈保存在計算機的內(nèi)存中，所以如果我們現(xiàn)在關(guān)閉計算機，區(qū)塊鏈將一無所有。我們最好將整個鏈存儲在我們的計算機上。

一般來說，人們會使用鍵值數(shù)據(jù)庫（kv db）來存儲區(qū)塊鏈。為什么使用 kv db 而不是文件或 SQL db 呢？因為它簡單且高效。

在我們的例子中，我們將使用 redb 作為我們的存儲后端。根據(jù)其官方網(wǎng)站，Redb 是一個簡單、便攜、高性能、ACID、嵌入式鍵值存儲，完全用 Rust 編寫，并受到 lmdb 的啟發(fā)。

接下來，我們需要設(shè)計一個存儲模式。有以下幾點：

使用兩個表：blocks 表用于開發(fā)/生產(chǎn)模式，blocks_fortest 表用于測試模式；

每個區(qū)塊都作為 redb 中的一個鍵值元素存儲，其中鍵是區(qū)塊的哈希字段值，值是區(qū)塊的完全序列化字符串。

我們需要一個指針指向最后一個區(qū)塊。'指向'實際上意味著持有區(qū)塊的哈希值。我們可以使用這個指針從數(shù)據(jù)庫中重構(gòu)整個鏈（內(nèi)存表示）。

我們還保持了 height 和區(qū)塊的 hash 之間的映射關(guān)系。

然后我們需要將一個 db 實例注入到 BlockChain 管理器結(jié)構(gòu)中。

#[derive(Debug)]
structBlockChain{
blocks:Vec,
db:Db,
}

基于這個管理器實例，我們可以按照以下方式實現(xiàn)一個持久化方法：

fnpersist_block_to_table(

&mutself,
table:TableDefinition<&str,?&str>,
block:&Block,
)->Result<()>{
letheight=&block.header.height;
lethash=&block.header.hash;
letcontent=serde_json::to_string(&block)?;

//storehash->blockpair
self.db.write_block_table(table,&hash,&content)?;
//storeheight->hashpair
self.db
.write_block_table(table,&height.to_string(),&hash)?;
//storethelbp->hashpair(lastblockpointertohash)
self.db
.write_block_table(table,LAST_BLOCK_POINTER,&hash)?;

Ok(())
}

其中，我們使用 serde 框架并使用 serde_json 將整個 block 結(jié)構(gòu)體序列化為字符串（json 格式）。如你所見，我們存儲了 3 對鍵值對：

hash -> 序列化的區(qū)塊字符串

height -> 區(qū)塊哈希

lbp (最后一個區(qū)塊的指針) -> 區(qū)塊哈希

我們可以像這樣從數(shù)據(jù)庫中檢索一個 Block：

fnretrieve_block_by_hash_from_table(

&self,
table:TableDefinition<&str,?&str>,
hash:&str,
)->Result>{
letcontent=self.db.read_block_table(table,hash)?;
info!("{:?}",content);
ifletSome(content)=content{
letb:Block=serde_json::from_str(&content)?;
Ok(Some(b))
}else{
Ok(None)
}
}

我們使用 serde_json::from_str() 來反序列化原始字符串。

接下來，我們需要弄清楚如何從數(shù)據(jù)庫中重新構(gòu)建一個正確的區(qū)塊鏈。我們可以使用一個迭代來做這個，首先獲取最后一個區(qū)塊，然后獲取最后一個區(qū)塊的前一個區(qū)塊，依此類推。我們可以看看代碼：

fnpopulate_from_db_table(&mutself,table:TableDefinition<&str,?&str>)->Result<()>{

//findlastblockhashfromdb
letlast_block_hash=self.db.read_block_table(table,LAST_BLOCK_POINTER)?;
iflast_block_hash.is_none(){
returnOk(());
}
letlast_block_hash=last_block_hash.unwrap();

//retrievelastblock
letblock=self.retrieve_block_by_hash_from_table(table,&last_block_hash)?;
ifblock.is_none(){
returnOk(());
}
letblock=block.unwrap();
letmutprev_hash=block.header.prev_hash.clone();

letmutblocks:Vec=vec![block];
//iteratetooldblockesbyprev_hash
whileprev_hash!=GENESIS_PREV_HASH{
letblock=self.retrieve_block_by_hash_from_table(table,&prev_hash)?;
ifblock.is_none(){
returnOk(());
}
letblock=block.unwrap();
prev_hash=block.header.prev_hash.clone();

blocks.insert(0,block);
}

//contructaninstanceofblockchain
self.blocks=blocks;

Ok(())
}

我們可以像這樣使用這個 API：

letmutblockchain=BlockChain::new();

blockchain
.populate_from_db()
.expect("errorwhenpopulatefromdb");

然后可以測試它：

#[test]
fntest_store_block_and_restore_block(){
letmutblockchain=BlockChain::new_to_table(TABLE_BLOCKS_FORTEST);

//initialization
letgenesis_block=BlockChain::genesis();
letprev_hash=genesis_block.header.hash.clone();
blockchain.add_block_to_table(TABLE_BLOCKS_FORTEST,genesis_block);

letb1=Block::new(1,prev_hash,vec![]);
letprev_hash=b1.header.hash.clone();
blockchain.add_block_to_table(TABLE_BLOCKS_FORTEST,b1);

letb2=Block::new(2,prev_hash,vec![]);
blockchain.add_block_to_table(TABLE_BLOCKS_FORTEST,b2);

letblock_vec=blockchain.blocks.clone();

blockchain
.populate_from_db_table(TABLE_BLOCKS_FORTEST)
.expect("errorwhenpopulatefromdb");

_=blockchain.db.drop_table(TABLE_BLOCKS_FORTEST);

for(i,block)inblock_vec.into_iter().enumerate(){
letblock_tmp=blockchain.blocks[i].clone();
assert_eq!(block,block_tmp);
}
}

在我們的代碼中，使用 anyhow 來幫助管理各種錯誤，感謝這個漂亮的 crate，它使我們的生活更加輕松。

到目前為止，我們的區(qū)塊鏈已經(jīng)具有了持久化的能力，不再擔心會丟失數(shù)據(jù)。我們已經(jīng)到達了偉大征程的第一個里程碑。

審核編輯：黃飛