从零到一：用 Rust 实现一个简单的区块链

区块链技术自比特币诞生以来，已经走过了十多年的发展历程。虽然这项技术常与加密货币紧密相连，但其底层原理实际上是一套精巧的分布式数据存储系统。本文将抛开复杂的金融概念，从技术本质出发，带你用 Rust 语言一步步实现一个简化版的区块链系统。通过这个实践项目，你不仅能深入理解区块链的核心机制，还能掌握 Rust 在系统编程中的实际应用。

一、区块链的核心概念解析

在开始编码之前，我们需要明确几个关键概念：

1. 区块（Block）：区块链的基本组成单元，包含交易数据、时间戳和前一个区块的哈希值
2. 哈希（Hash）：将任意长度数据映射为固定长度字符串的数学函数，具有单向性和抗碰撞性
3. 工作量证明（Proof of Work）：防止恶意节点篡改数据的共识机制
4. 链式结构：每个区块都包含前一个区块的哈希，形成不可篡改的链条

二、环境准备与项目初始化

首先确保你已经安装了 Rust 开发环境。如果尚未安装，可以通过以下命令安装：

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

创建新项目：

cargo new simple_blockchain
cd simple_blockchain

在 Cargo.toml 中添加依赖：

[package]
name = "simple_blockchain"
version = "0.1.0"
edition = "2021"

[dependencies]
chrono = "0.4"
serde = { version = "1.0", features = ["derive"] }
serde_json = "1.0"
sha2 = "0.10"
hex = "0.4"

三、实现区块数据结构

让我们从最基本的区块结构开始。在 src/main.rs 中：

use chrono::{DateTime, Utc};
use serde::{Deserialize, Serialize};
use sha2::{Digest, Sha256};
use std::fmt;

// 定义区块结构
#[derive(Debug, Clone, Serialize, Deserialize)]
struct Block {
    index: u64,                    // 区块高度
    timestamp: DateTime<Utc>,      // 时间戳
    data: String,                  // 区块数据（实际应用中会是交易列表）
    previous_hash: String,         // 前一个区块的哈希
    hash: String,                  // 当前区块的哈希
    nonce: u64,                    // 随机数，用于工作量证明
}

impl Block {
    // 创建创世区块（第一个区块）
    fn genesis() -> Self {
        let timestamp = Utc::now();
        let data = "Genesis Block".to_string();
        let previous_hash = "0".repeat(64);  // 64个0，表示没有前驱区块
        
        let mut block = Block {
            index: 0,
            timestamp,
            data,
            previous_hash,
            hash: String::new(),
            nonce: 0,
        };
        
        // 计算哈希并设置
        block.hash = block.calculate_hash();
        block
    }
    
    // 创建新区块
    fn new(index: u64, data: String, previous_hash: String) -> Self {
        let timestamp = Utc::now();
        
        let mut block = Block {
            index,
            timestamp,
            data,
            previous_hash,
            hash: String::new(),
            nonce: 0,
        };
        
        block.hash = block.calculate_hash();
        block
    }
    
    // 计算区块哈希
    fn calculate_hash(&self) -> String {
        let input = format!(
            "{}{}{}{}{}",
            self.index,
            self.timestamp,
            self.data,
            self.previous_hash,
            self.nonce
        );
        
        let mut hasher = Sha256::new();
        hasher.update(input.as_bytes());
        let result = hasher.finalize();
        
        hex::encode(result)
    }
    
    // 工作量证明：寻找满足条件的哈希值
    fn mine_block(&mut self, difficulty: usize) {
        let prefix = "0".repeat(difficulty);
        
        while !self.hash.starts_with(&prefix) {
            self.nonce += 1;
            self.hash = self.calculate_hash();
        }
        
        println!("Block mined: {}", self.hash);
    }
}

// 为区块实现Display trait，方便打印
impl fmt::Display for Block {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(
            f,
            "Block #{} [Hash: {}, Previous: {}, Data: {}, Nonce: {}]",
            self.index, self.hash, self.previous_hash, self.data, self.nonce
        )
    }
}

四、实现区块链结构

区块链本质上是一个区块的集合，需要维护链的完整性和有效性：

struct Blockchain {
    chain: Vec<Block>,
    difficulty: usize,
}

impl Blockchain {
    // 创建新区块链
    fn new(difficulty: usize) -> Self {
        let mut blockchain = Blockchain {
            chain: Vec::new(),
            difficulty,
        };
        
        // 添加创世区块
        blockchain.chain.push(Block::genesis());
        blockchain
    }
    
    // 获取最后一个区块
    fn get_last_block(&self) -> &Block {
        self.chain.last().unwrap()
    }
    
    // 添加新区块
    fn add_block(&mut self, data: String) -> Result<(), String> {
        let last_block = self.get_last_block();
        let new_index = last_block.index + 1;
        
        let mut new_block = Block::new(
            new_index,
            data,
            last_block.hash.clone(),
        );
        
        // 执行工作量证明
        new_block.mine_block(self.difficulty);
        
        // 验证区块有效性
        if self.is_valid_block(&new_block, last_block) {
            self.chain.push(new_block);
            Ok(())
        } else {
            Err("Invalid block".to_string())
        }
    }
    
    // 验证单个区块的有效性
    fn is_valid_block(&self, new_block: &Block, previous_block: &Block) -> bool {
        // 检查索引是否连续
        if new_block.index != previous_block.index + 1 {
            return false;
        }
        
        // 检查前一个哈希是否正确
        if new_block.previous_hash != previous_block.hash {
            return false;
        }
        
        // 检查哈希计算是否正确
        if new_block.hash != new_block.calculate_hash() {
            return false;
        }
        
        // 检查工作量证明
        let prefix = "0".repeat(self.difficulty);
        if !new_block.hash.starts_with(&prefix) {
            return false;
        }
        
        true
    }
    
    // 验证整个链的有效性
    fn is_chain_valid(&self) -> bool {
        for i in 1..self.chain.len() {
            let current = &self.chain[i];
            let previous = &self.chain[i - 1];
            
            if !self.is_valid_block(current, previous) {
                return false;
            }
        }
        
        true
    }
    
    // 打印整个区块链
    fn print_chain(&self) {
        println!("\n=== Blockchain ===");
        for block in &self.chain {
            println!("{}", block);
        }
        println!("==================\n");
    }
}

五、实现简单的P2P网络模拟

为了更真实地模拟区块链的分布式特性，我们添加一个简单的网络层：

use std::sync::{Arc, Mutex};
use std::thread;
use std::time::Duration;

// 网络节点
struct Node {
    id: String,
    blockchain: Arc<Mutex<Blockchain>>,
}

impl Node {
    fn new(id: &str, difficulty: usize) -> Self {
        Node {
            id: id.to_string(),
            blockchain: Arc::new(Mutex::new(Blockchain::new(difficulty))),
        }
    }
    
    // 模拟挖矿过程
    fn mine(&self, data: String) {
        let blockchain = Arc::clone(&self.blockchain);
        let node_id = self.id.clone();
        
        thread::spawn(move || {
            thread::sleep(Duration::from_millis(100)); // 模拟网络延迟
            
            let mut chain = blockchain.lock().unwrap();
            match chain.add_block(data) {
                Ok(_) => println!("[Node {}] Successfully mined a new block", node_id),
                Err(e) => println!("[Node {}] Mining failed: {}", node_id, e),
            }
        });
    }
    
    // 验证区块链
    fn validate_chain(&self) -> bool {
        let chain = self.blockchain.lock().unwrap();
        chain.is_chain_valid()
    }
    
    // 打印区块链状态
    fn print_status(&self) {
        let chain = self.blockchain.lock().unwrap();
        println!("\n[Node {}] Blockchain Status:", self.id);