3903 字
20 分钟
Rust语言
2025-09-05
Web3
Web3
/
区块链
/
Rust
/
编程语言
/
系统编程

Rust语言#

概述#

Rust是Mozilla开发的开源系统编程语言，以其内存安全、并发安全和零成本抽象而闻名。在Web3和区块链开发中，Rust因其高性能、安全性和可靠性而成为重要选择。本章节详细介绍了Rust在区块链开发中的应用，包括基础语法、所有权系统、并发编程等核心概念。

1. Rust基础#

1.1 语言特性#

1.1.1 核心特点#

  • 内存安全：编译时防止内存泄漏和越界访问
  • 零成本抽象：高级抽象不带来运行时开销
  • 并发安全：编译时防止数据竞争
  • 类型安全：强类型系统防止类型错误
  • 性能：接近C/C++的性能

1.1.2 在区块链开发中的优势#

  • 安全性：防止常见的内存安全漏洞
  • 性能：适合高性能区块链节点
  • 并发：原生支持安全并发编程
  • 可靠性：编译时错误检查，减少运行时错误

1.2 基本语法#

1.2.1 变量和类型#

fn main() {
    // 变量声明（默认不可变）
    let x = 5;
    let y: i32 = 10;


    // 可变变量
    let mut z = 15;
    z = 20;


    // 常量
    const MAX_POINTS: u32 = 100_000;


    // 基本类型
    let boolean: bool = true;
    let integer: i32 = 42;
    let float: f64 = 3.14;
    let character: char = 'R';
    let string: String = String::from("Hello");
    let string_slice: &str = "World";


    // 复合类型
    let tuple: (i32, f64, char) = (1, 2.0, 'a');
    let array: [i32; 5] = [1, 2, 3, 4, 5];
    let vector: Vec<i32> = vec![1, 2, 3, 4, 5];
}

1.2.2 函数和结构体#

// 结构体定义
struct Person {
    name: String,
    age: u32,
}


// 实现方法
impl Person {
    fn new(name: String, age: u32) -> Person {
        Person { name, age }
    }


    fn greet(&self) -> String {
        format!("Hello, I'm {} and I'm {} years old", self.name, self.age)
    }
}


// 函数定义
fn add(a: i32, b: i32) -> i32 {
    a + b
}


fn main() {
    let person = Person::new(String::from("Alice"), 30);
    println!("{}", person.greet());


    let sum = add(5, 3);
    println!("Sum: {}", sum);
}

1.3 所有权系统#

1.3.1 所有权规则#

fn main() {
    // 所有权转移
    let s1 = String::from("hello");
    let s2 = s1; // s1的所有权转移到s2
    // println!("{}", s1); // 错误：s1不再有效


    // 克隆
    let s3 = String::from("world");
    let s4 = s3.clone(); // 深拷贝
    println!("{}", s3); // s3仍然有效
    println!("{}", s4);


    // 借用
    let s5 = String::from("borrow");
    let len = calculate_length(&s5); // 借用s5
    println!("The length of '{}' is {}", s5, len); // s5仍然有效
}


fn calculate_length(s: &String) -> usize {
    s.len()
}

1.3.2 在区块链开发中的应用#

use std::collections::HashMap;


// 交易结构体
#[derive(Debug, Clone)]
struct Transaction {
    id: String,
    from: String,
    to: String,
    amount: u64,
}


// 区块结构体
#[derive(Debug)]
struct Block {
    index: u32,
    timestamp: u64,
    transactions: Vec<Transaction>,
    previous_hash: String,
    hash: String,
}


impl Block {
    fn new(index: u32, transactions: Vec<Transaction>, previous_hash: String) -> Block {
        let timestamp = std::time::SystemTime::now()
            .duration_since(std::time::UNIX_EPOCH)
            .unwrap()
            .as_secs();


        let hash = Self::calculate_hash(index, &transactions, previous_hash.as_str(), timestamp);


        Block {
            index,
            timestamp,
            transactions,
            previous_hash,
            hash,
        }
    }


    fn calculate_hash(index: u32, transactions: &[Transaction], previous_hash: &str, timestamp: u64) -> String {
        use sha2::{Sha256, Digest};


        let mut hasher = Sha256::new();
        hasher.update(index.to_string());
        hasher.update(previous_hash);
        hasher.update(timestamp.to_string());


        for tx in transactions {
            hasher.update(&tx.id);
            hasher.update(&tx.from);
            hasher.update(&tx.to);
            hasher.update(tx.amount.to_string());
        }


        format!("{:x}", hasher.finalize())
    }
}


// 区块链结构体
struct Blockchain {
    blocks: Vec<Block>,
    pending_transactions: Vec<Transaction>,
}


impl Blockchain {
    fn new() -> Blockchain {
        let mut blockchain = Blockchain {
            blocks: Vec::new(),
            pending_transactions: Vec::new(),
        };


        // 创建创世区块
        let genesis_block = Block::new(0, Vec::new(), String::from("0"));
        blockchain.blocks.push(genesis_block);


        blockchain
    }


    fn add_transaction(&mut self, transaction: Transaction) {
        self.pending_transactions.push(transaction);
    }


    fn mine_block(&mut self) {
        let transactions = self.pending_transactions.clone();
        self.pending_transactions.clear();


        let previous_hash = self.blocks.last().unwrap().hash.clone();
        let index = self.blocks.len() as u32;


        let new_block = Block::new(index, transactions, previous_hash);
        self.blocks.push(new_block);
    }


    fn get_balance(&self, address: &str) -> u64 {
        let mut balance = 0;


        for block in &self.blocks {
            for tx in &block.transactions {
                if tx.from == address {
                    balance -= tx.amount;
                }
                if tx.to == address {
                    balance += tx.amount;
                }
            }
        }


        balance
    }
}


fn main() {
    let mut blockchain = Blockchain::new();


    // 添加交易
    blockchain.add_transaction(Transaction {
        id: String::from("tx1"),
        from: String::from("Alice"),
        to: String::from("Bob"),
        amount: 100,
    });


    blockchain.add_transaction(Transaction {
        id: String::from("tx2"),
        from: String::from("Bob"),
        to: String::from("Charlie"),
        amount: 50,
    });


    // 挖矿
    blockchain.mine_block();


    // 查询余额
    println!("Alice's balance: {}", blockchain.get_balance("Alice"));
    println!("Bob's balance: {}", blockchain.get_balance("Bob"));
    println!("Charlie's balance: {}", blockchain.get_balance("Charlie"));
}

2. 并发编程#

2.1 线程和通道#

2.1.1 基本并发#

use std::thread;
use std::time::Duration;


fn main() {
    // 创建线程
    let handle = thread::spawn(|| {
        for i in 1..10 {
            println!("Thread: {}", i);
            thread::sleep(Duration::from_millis(100));
        }
    });


    // 主线程
    for i in 1..5 {
        println!("Main: {}", i);
        thread::sleep(Duration::from_millis(100));
    }


    // 等待线程完成
    handle.join().unwrap();
}

2.1.2 通道通信#

use std::sync::mpsc;
use std::thread;


fn main() {
    let (tx, rx) = mpsc::channel();


    // 发送线程
    let tx_clone = tx.clone();
    thread::spawn(move || {
        let values = vec![
            String::from("Hello"),
            String::from("World"),
            String::from("Rust"),
        ];


        for val in values {
            tx_clone.send(val).unwrap();
            thread::sleep(Duration::from_millis(100));
        }
    });


    // 接收线程
    thread::spawn(move || {
        for received in rx {
            println!("Received: {}", received);
        }
    });


    thread::sleep(Duration::from_millis(1000));
}

2.2 在区块链开发中的应用#

2.2.1 并发挖矿#

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


struct Miner {
    id: u32,
    blockchain: Arc<Mutex<Blockchain>>,
}


impl Miner {
    fn new(id: u32, blockchain: Arc<Mutex<Blockchain>>) -> Miner {
        Miner { id, blockchain }
    }


    fn mine(&self) {
        loop {
            // 获取待处理交易
            let transactions = {
                let mut blockchain = self.blockchain.lock().unwrap();
                blockchain.pending_transactions.clone()
            };


            if !transactions.is_empty() {
                // 模拟挖矿过程
                thread::sleep(Duration::from_millis(100));


                // 添加新区块
                let mut blockchain = self.blockchain.lock().unwrap();
                blockchain.mine_block();
                println!("Miner {} mined a block", self.id);
            }


            thread::sleep(Duration::from_millis(50));
        }
    }
}


fn main() {
    let blockchain = Arc::new(Mutex::new(Blockchain::new()));


    // 创建多个矿工
    let mut handles = vec![];


    for i in 0..3 {
        let blockchain_clone = Arc::clone(&blockchain);
        let miner = Miner::new(i, blockchain_clone);


        let handle = thread::spawn(move || {
            miner.mine();
        });


        handles.push(handle);
    }


    // 添加一些交易
    for i in 0..10 {
        let mut blockchain = blockchain.lock().unwrap();
        blockchain.add_transaction(Transaction {
            id: format!("tx{}", i),
            from: String::from("Alice"),
            to: String::from("Bob"),
            amount: 100,
        });
    }


    // 等待所有线程
    for handle in handles {
        handle.join().unwrap();
    }
}

3. 网络编程#

3.1 HTTP服务器#

3.1.1 基本HTTP服务器#

use std::io::prelude::*;
use std::net::TcpListener;
use std::net::TcpStream;


fn main() {
    let listener = TcpListener::bind("127.0.0.1:7878").unwrap();


    for stream in listener.incoming() {
        let stream = stream.unwrap();
        handle_connection(stream);
    }
}


fn handle_connection(mut stream: TcpStream) {
    let mut buffer = [0; 1024];
    stream.read(&mut buffer).unwrap();


    let response = "HTTP/1.1 200 OK\r\n\r\nHello, World!";
    stream.write(response.as_bytes()).unwrap();
    stream.flush().unwrap();
}

3.1.2 使用tokio的异步HTTP服务器#

use tokio::io::{AsyncReadExt, AsyncWriteExt};
use tokio::net::TcpListener;


#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let listener = TcpListener::bind("127.0.0.1:7878").await?;


    loop {
        let (mut socket, _) = listener.accept().await?;


        tokio::spawn(async move {
            let mut buffer = [0; 1024];


            match socket.read(&mut buffer).await {
                Ok(_) => {
                    let response = "HTTP/1.1 200 OK\r\n\r\nHello, World!";
                    let _ = socket.write_all(response.as_bytes()).await;
                }
                Err(e) => eprintln!("Failed to read from socket: {}", e),
            }
        });
    }
}

3.2 区块链API服务器#

3.2.1 使用warp框架#

use warp::Filter;
use serde::{Deserialize, Serialize};
use std::sync::{Arc, Mutex};


#[derive(Serialize, Deserialize)]
struct Transaction {
    id: String,
    from: String,
    to: String,
    amount: u64,
}


#[derive(Serialize, Deserialize)]
struct Block {
    index: u32,
    timestamp: u64,
    transactions: Vec<Transaction>,
    previous_hash: String,
    hash: String,
}


#[derive(Serialize, Deserialize)]
struct Blockchain {
    blocks: Vec<Block>,
    pending_transactions: Vec<Transaction>,
}


impl Blockchain {
    fn new() -> Blockchain {
        let mut blockchain = Blockchain {
            blocks: Vec::new(),
            pending_transactions: Vec::new(),
        };


        // 创建创世区块
        let genesis_block = Block {
            index: 0,
            timestamp: 0,
            transactions: Vec::new(),
            previous_hash: String::from("0"),
            hash: String::from("genesis_hash"),
        };


        blockchain.blocks.push(genesis_block);
        blockchain
    }


    fn add_transaction(&mut self, transaction: Transaction) {
        self.pending_transactions.push(transaction);
    }


    fn mine_block(&mut self) {
        let transactions = self.pending_transactions.clone();
        self.pending_transactions.clear();


        let previous_hash = self.blocks.last().unwrap().hash.clone();
        let index = self.blocks.len() as u32;
        let timestamp = std::time::SystemTime::now()
            .duration_since(std::time::UNIX_EPOCH)
            .unwrap()
            .as_secs();


        let hash = format!("block_{}_{}", index, timestamp);


        let new_block = Block {
            index,
            timestamp,
            transactions,
            previous_hash,
            hash,
        };


        self.blocks.push(new_block);
    }
}


type BlockchainState = Arc<Mutex<Blockchain>>;


#[tokio::main]
async fn main() {
    let blockchain = Arc::new(Mutex::new(Blockchain::new()));


    // 获取区块链状态
    let blockchain_filter = warp::any().map(move || blockchain.clone());


    // 获取所有区块
    let get_blocks = warp::path("blocks")
        .and(blockchain_filter.clone())
        .and_then(get_blocks_handler);


    // 添加交易
    let add_transaction = warp::path("transactions")
        .and(warp::post())
        .and(warp::body::json())
        .and(blockchain_filter.clone())
        .and_then(add_transaction_handler);


    // 挖矿
    let mine = warp::path("mine")
        .and(blockchain_filter.clone())
        .and_then(mine_handler);


    let routes = get_blocks
        .or(add_transaction)
        .or(mine);


    warp::serve(routes)
        .run(([127, 0, 0, 1], 3030))
        .await;
}


async fn get_blocks_handler(
    blockchain: BlockchainState,
) -> Result<impl warp::Reply, warp::Rejection> {
    let blockchain = blockchain.lock().unwrap();
    Ok(warp::reply::json(&blockchain.blocks))
}


async fn add_transaction_handler(
    transaction: Transaction,
    blockchain: BlockchainState,
) -> Result<impl warp::Reply, warp::Rejection> {
    let mut blockchain = blockchain.lock().unwrap();
    blockchain.add_transaction(transaction);
    Ok(warp::reply::json(&"Transaction added"))
}


async fn mine_handler(
    blockchain: BlockchainState,
) -> Result<impl warp::Reply, warp::Rejection> {
    let mut blockchain = blockchain.lock().unwrap();
    blockchain.mine_block();
    Ok(warp::reply::json(&"Block mined"))
}

4. 加密和哈希#

4.1 哈希函数#

4.1.1 基本哈希#

use sha2::{Sha256, Digest};
use hex;


fn main() {
    let data = "Hello, World!";


    // SHA256
    let mut hasher = Sha256::new();
    hasher.update(data.as_bytes());
    let hash = hasher.finalize();
    println!("SHA256: {}", hex::encode(hash));


    // 多次哈希
    let mut hasher = Sha256::new();
    hasher.update(data.as_bytes());
    let hash1 = hasher.finalize();


    let mut hasher = Sha256::new();
    hasher.update(&hash1);
    let hash2 = hasher.finalize();
    println!("Double SHA256: {}", hex::encode(hash2));
}

4.1.2 在区块链中的应用#

use sha2::{Sha256, Digest};
use hex;


struct MerkleTree {
    root: String,
    leaves: Vec<String>,
}


impl MerkleTree {
    fn new(transactions: Vec<String>) -> MerkleTree {
        let mut leaves = transactions;


        // 确保叶子节点数量是2的幂
        while leaves.len() & (leaves.len() - 1) != 0 {
            leaves.push(leaves.last().unwrap().clone());
        }


        let root = Self::build_tree(&leaves);


        MerkleTree { root, leaves }
    }


    fn build_tree(leaves: &[String]) -> String {
        if leaves.len() == 1 {
            return leaves[0].clone();
        }


        let mut next_level = Vec::new();


        for i in (0..leaves.len()).step_by(2) {
            let left = &leaves[i];
            let right = if i + 1 < leaves.len() {
                &leaves[i + 1]
            } else {
                &leaves[i]
            };


            let combined = format!("{}{}", left, right);
            let hash = Self::hash(&combined);
            next_level.push(hash);
        }


        Self::build_tree(&next_level)
    }


    fn hash(data: &str) -> String {
        let mut hasher = Sha256::new();
        hasher.update(data.as_bytes());
        hex::encode(hasher.finalize())
    }


    fn get_root(&self) -> &str {
        &self.root
    }
}


fn main() {
    let transactions = vec![
        String::from("tx1"),
        String::from("tx2"),
        String::from("tx3"),
        String::from("tx4"),
    ];


    let merkle_tree = MerkleTree::new(transactions);
    println!("Merkle Root: {}", merkle_tree.get_root());
}

4.2 数字签名#

4.2.1 ECDSA签名#

use secp256k1::{Secp256k1, SecretKey, PublicKey, Message};
use secp256k1::ecdsa::Signature;
use rand::rngs::OsRng;


fn main() {
    let secp = Secp256k1::new();
    let mut rng = OsRng;


    // 生成密钥对
    let secret_key = SecretKey::new(&mut rng);
    let public_key = PublicKey::from_secret_key(&secp, &secret_key);


    // 创建消息
    let message = Message::from_slice(b"Hello, World!").unwrap();


    // 签名
    let signature = secp.sign_ecdsa(&message, &secret_key);


    // 验证签名
    let is_valid = secp.verify_ecdsa(&message, &signature, &public_key).is_ok();


    println!("Signature valid: {}", is_valid);
    println!("Public key: {}", public_key);
    println!("Signature: {}", signature);
}

4.2.2 在区块链中的应用#

use secp256k1::{Secp256k1, SecretKey, PublicKey, Message};
use secp256k1::ecdsa::Signature;
use rand::rngs::OsRng;
use std::collections::HashMap;


struct Wallet {
    secret_key: SecretKey,
    public_key: PublicKey,
    address: String,
}


impl Wallet {
    fn new() -> Wallet {
        let secp = Secp256k1::new();
        let mut rng = OsRng;


        let secret_key = SecretKey::new(&mut rng);
        let public_key = PublicKey::from_secret_key(&secp, &secret_key);
        let address = format!("{:?}", public_key);


        Wallet {
            secret_key,
            public_key,
            address,
        }
    }


    fn sign_transaction(&self, transaction: &Transaction) -> Signature {
        let secp = Secp256k1::new();
        let message = Message::from_slice(transaction.hash().as_bytes()).unwrap();
        secp.sign_ecdsa(&message, &self.secret_key)
    }


    fn get_address(&self) -> &str {
        &self.address
    }
}


struct Transaction {
    from: String,
    to: String,
    amount: u64,
    nonce: u64,
    signature: Option<Signature>,
}


impl Transaction {
    fn new(from: String, to: String, amount: u64, nonce: u64) -> Transaction {
        Transaction {
            from,
            to,
            amount,
            nonce,
            signature: None,
        }
    }


    fn hash(&self) -> String {
        let data = format!("{}{}{}{}", self.from, self.to, self.amount, self.nonce);
        use sha2::{Sha256, Digest};
        let mut hasher = Sha256::new();
        hasher.update(data.as_bytes());
        format!("{:x}", hasher.finalize())
    }


    fn sign(&mut self, wallet: &Wallet) {
        self.signature = Some(wallet.sign_transaction(self));
    }


    fn verify(&self, public_key: &PublicKey) -> bool {
        if let Some(signature) = &self.signature {
            let secp = Secp256k1::new();
            let message = Message::from_slice(self.hash().as_bytes()).unwrap();
            secp.verify_ecdsa(&message, signature, public_key).is_ok()
        } else {
            false
        }
    }
}


fn main() {
    // 创建钱包
    let wallet = Wallet::new();
    println!("Wallet address: {}", wallet.get_address());


    // 创建交易
    let mut transaction = Transaction::new(
        wallet.get_address().to_string(),
        "recipient_address".to_string(),
        100,
        1,
    );


    // 签名交易
    transaction.sign(&wallet);


    // 验证交易
    let is_valid = transaction.verify(&wallet.public_key);
    println!("Transaction valid: {}", is_valid);
}

5. 数据库操作#

5.1 SQLite数据库#

5.1.1 基本操作#

use rusqlite::{Connection, Result};
use serde::{Deserialize, Serialize};


#[derive(Debug, Serialize, Deserialize)]
struct Transaction {
    id: String,
    from: String,
    to: String,
    amount: u64,
    timestamp: u64,
}


fn main() -> Result<()> {
    let conn = Connection::open("blockchain.db")?;


    // 创建表
    conn.execute(
        "CREATE TABLE IF NOT EXISTS transactions (
            id TEXT PRIMARY KEY,
            from_address TEXT NOT NULL,
            to_address TEXT NOT NULL,
            amount INTEGER NOT NULL,
            timestamp INTEGER NOT NULL
        )",
        [],
    )?;


    // 插入数据
    let tx = Transaction {
        id: "tx1".to_string(),
        from: "Alice".to_string(),
        to: "Bob".to_string(),
        amount: 100,
        timestamp: 1234567890,
    };


    conn.execute(
        "INSERT INTO transactions (id, from_address, to_address, amount, timestamp) VALUES (?1, ?2, ?3, ?4, ?5)",
        [&tx.id, &tx.from, &tx.to, &tx.amount.to_string(), &tx.timestamp.to_string()],
    )?;


    // 查询数据
    let mut stmt = conn.prepare("SELECT id, from_address, to_address, amount, timestamp FROM transactions")?;
    let transaction_iter = stmt.query_map([], |row| {
        Ok(Transaction {
            id: row.get(0)?,
            from: row.get(1)?,
            to: row.get(2)?,
            amount: row.get(3)?,
            timestamp: row.get(4)?,
        })
    })?;


    for transaction in transaction_iter {
        println!("Found transaction: {:?}", transaction?);
    }


    Ok(())
}

5.2 在区块链开发中的应用#

5.2.1 区块链数据库#

use rusqlite::{Connection, Result};
use serde::{Deserialize, Serialize};
use std::collections::HashMap;


#[derive(Debug, Serialize, Deserialize)]
struct Block {
    index: u32,
    timestamp: u64,
    transactions: Vec<Transaction>,
    previous_hash: String,
    hash: String,
}


#[derive(Debug, Serialize, Deserialize)]
struct Transaction {
    id: String,
    from: String,
    to: String,
    amount: u64,
}


struct BlockchainDB {
    conn: Connection,
}


impl BlockchainDB {
    fn new() -> Result<BlockchainDB> {
        let conn = Connection::open("blockchain.db")?;


        // 创建表
        conn.execute(
            "CREATE TABLE IF NOT EXISTS blocks (
                index INTEGER PRIMARY KEY,
                timestamp INTEGER NOT NULL,
                previous_hash TEXT NOT NULL,
                hash TEXT NOT NULL
            )",
            [],
        )?;


        conn.execute(
            "CREATE TABLE IF NOT EXISTS transactions (
                id TEXT PRIMARY KEY,
                block_index INTEGER NOT NULL,
                from_address TEXT NOT NULL,
                to_address TEXT NOT NULL,
                amount INTEGER NOT NULL,
                FOREIGN KEY (block_index) REFERENCES blocks (index)
            )",
            [],
        )?;


        Ok(BlockchainDB { conn })
    }


    fn add_block(&self, block: &Block) -> Result<()> {
        // 插入区块
        self.conn.execute(
            "INSERT INTO blocks (index, timestamp, previous_hash, hash) VALUES (?1, ?2, ?3, ?4)",
            [&block.index.to_string(), &block.timestamp.to_string(), &block.previous_hash, &block.hash],
        )?;


        // 插入交易
        for tx in &block.transactions {
            self.conn.execute(
                "INSERT INTO transactions (id, block_index, from_address, to_address, amount) VALUES (?1, ?2, ?3, ?4, ?5)",
                [&tx.id, &block.index.to_string(), &tx.from, &tx.to, &tx.amount.to_string()],
            )?;
        }


        Ok(())
    }


    fn get_blocks(&self) -> Result<Vec<Block>> {
        let mut stmt = self.conn.prepare(
            "SELECT index, timestamp, previous_hash, hash FROM blocks ORDER BY index"
        )?;


        let block_iter = stmt.query_map([], |row| {
            Ok(Block {
                index: row.get(0)?,
                timestamp: row.get(1)?,
                previous_hash: row.get(2)?,
                hash: row.get(3)?,
                transactions: Vec::new(), // 需要单独查询交易
            })
        })?;


        let mut blocks = Vec::new();
        for block in block_iter {
            let mut block = block?;
            block.transactions = self.get_transactions_for_block(block.index)?;
            blocks.push(block);
        }


        Ok(blocks)
    }


    fn get_transactions_for_block(&self, block_index: u32) -> Result<Vec<Transaction>> {
        let mut stmt = self.conn.prepare(
            "SELECT id, from_address, to_address, amount FROM transactions WHERE block_index = ?1"
        )?;


        let tx_iter = stmt.query_map([block_index.to_string()], |row| {
            Ok(Transaction {
                id: row.get(0)?,
                from: row.get(1)?,
                to: row.get(2)?,
                amount: row.get(3)?,
            })
        })?;


        let mut transactions = Vec::new();
        for tx in tx_iter {
            transactions.push(tx?);
        }


        Ok(transactions)
    }


    fn get_balance(&self, address: &str) -> Result<i64> {
        let mut stmt = self.conn.prepare(
            "SELECT SUM(amount) FROM transactions WHERE to_address = ?1"
        )?;
        let received: i64 = stmt.query_row([address], |row| row.get(0))?;


        let mut stmt = self.conn.prepare(
            "SELECT SUM(amount) FROM transactions WHERE from_address = ?1"
        )?;
        let sent: i64 = stmt.query_row([address], |row| row.get(0))?;


        Ok(received - sent)
    }
}


fn main() -> Result<()> {
    let db = BlockchainDB::new()?;


    // 创建示例区块
    let block = Block {
        index: 0,
        timestamp: 1234567890,
        transactions: vec![
            Transaction {
                id: "tx1".to_string(),
                from: "Alice".to_string(),
                to: "Bob".to_string(),
                amount: 100,
            },
        ],
        previous_hash: "0".to_string(),
        hash: "genesis_hash".to_string(),
    };


    // 添加区块
    db.add_block(&block)?;


    // 查询余额
    let balance = db.get_balance("Bob")?;
    println!("Bob's balance: {}", balance);


    Ok(())
}

6. 在区块链项目中的应用#

6.1 以太坊客户端#

6.1.1 使用ethers-rs#

use ethers::prelude::*;
use std::str::FromStr;


#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // 连接到以太坊节点
    let provider = Provider::<Http>::try_from("https://mainnet.infura.io/v3/YOUR_PROJECT_ID")?;


    // 获取最新区块
    let block_number = provider.get_block_number().await?;
    println!("Latest block number: {}", block_number);


    // 获取区块信息
    let block = provider.get_block(block_number).await?;
    if let Some(block) = block {
        println!("Block hash: {:?}", block.hash);
        println!("Block number: {}", block.number.unwrap());
        println!("Block timestamp: {}", block.timestamp);
        println!("Block transactions: {}", block.transactions.len());
    }


    // 获取账户余额
    let address = Address::from_str("0x742d35Cc6634C0532925a3b8D4C9db96C4b4d8b6")?;
    let balance = provider.get_balance(address, None).await?;
    println!("Balance: {} ETH", format_ether(balance));


    Ok(())
}

6.2 智能合约交互#

6.2.1 合约调用#

use ethers::prelude::*;
use std::str::FromStr;


#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // 连接到以太坊节点
    let provider = Provider::<Http>::try_from("https://mainnet.infura.io/v3/YOUR_PROJECT_ID")?;


    // 创建钱包
    let wallet = LocalWallet::new(&mut rand::thread_rng());
    let client = SignerMiddleware::new(provider, wallet);


    // 合约地址和ABI
    let contract_address = Address::from_str("0x...")?;
    // let contract = Contract::new(contract_address, abi, client);


    // 调用只读方法
    // let result: U256 = contract.method("getValue", ())?.call().await?;
    // println!("Contract value: {}", result);


    // 调用写入方法
    // let tx = contract.method("setValue", (U256::from(100)))?.send().await?;
    // println!("Transaction hash: {:?}", tx.tx_hash());


    Ok(())
}

7. 性能优化#

7.1 内存优化#

7.1.1 使用Arc和Mutex#

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


struct SharedData {
    counter: u32,
    data: Vec<String>,
}


fn main() {
    let shared_data = Arc::new(Mutex::new(SharedData {
        counter: 0,
        data: Vec::new(),
    }));


    let mut handles = vec![];


    for i in 0..10 {
        let data = Arc::clone(&shared_data);


        let handle = thread::spawn(move || {
            let mut data = data.lock().unwrap();
            data.counter += 1;
            data.data.push(format!("Thread {}", i));
        });


        handles.push(handle);
    }


    for handle in handles {
        handle.join().unwrap();
    }


    let data = shared_data.lock().unwrap();
    println!("Counter: {}", data.counter);
    println!("Data: {:?}", data.data);
}

7.1.2 使用RwLock#

use std::sync::{Arc, RwLock};
use std::thread;


struct SharedData {
    counter: u32,
    data: Vec<String>,
}


fn main() {
    let shared_data = Arc::new(RwLock::new(SharedData {
        counter: 0,
        data: Vec::new(),
    }));


    let mut handles = vec![];


    // 写入线程
    for i in 0..5 {
        let data = Arc::clone(&shared_data);


        let handle = thread::spawn(move || {
            let mut data = data.write().unwrap();
            data.counter += 1;
            data.data.push(format!("Writer {}", i));
        });


        handles.push(handle);
    }


    // 读取线程
    for i in 0..5 {
        let data = Arc::clone(&shared_data);


        let handle = thread::spawn(move || {
            let data = data.read().unwrap();
            println!("Reader {}: counter = {}", i, data.counter);
        });


        handles.push(handle);
    }


    for handle in handles {
        handle.join().unwrap();
    }
}

7.2 并发优化#

7.2.1 使用tokio异步#

use tokio::time::{sleep, Duration};


async fn async_function(id: u32) {
    println!("Starting async function {}", id);
    sleep(Duration::from_millis(100)).await;
    println!("Finished async function {}", id);
}


#[tokio::main]
async fn main() {
    let mut handles = vec![];


    for i in 0..10 {
        let handle = tokio::spawn(async move {
            async_function(i).await;
        });
        handles.push(handle);
    }


    for handle in handles {
        handle.await.unwrap();
    }
}

8. 测试#

8.1 单元测试#

8.1.1 基本测试#

#[cfg(test)]
mod tests {
    use super::*;


    #[test]
    fn test_add() {
        assert_eq!(add(2, 3), 5);
    }


    #[test]
    fn test_divide() {
        assert_eq!(divide(10, 2), Ok(5));
        assert!(divide(10, 0).is_err());
    }


    #[test]
    fn test_blockchain() {
        let mut blockchain = Blockchain::new();
        assert_eq!(blockchain.blocks.len(), 1); // 创世区块


        blockchain.add_transaction(Transaction {
            id: "tx1".to_string(),
            from: "Alice".to_string(),
            to: "Bob".to_string(),
            amount: 100,
        });


        blockchain.mine_block();
        assert_eq!(blockchain.blocks.len(), 2);
    }
}


fn add(a: i32, b: i32) -> i32 {
    a + b
}


fn divide(a: i32, b: i32) -> Result<i32, String> {
    if b == 0 {
        Err("Division by zero".to_string())
    } else {
        Ok(a / b)
    }
}

8.2 集成测试#

8.2.1 区块链测试#

#[cfg(test)]
mod integration_tests {
    use super::*;


    #[test]
    fn test_blockchain_integration() {
        let mut blockchain = Blockchain::new();


        // 添加多个交易
        for i in 0..10 {
            blockchain.add_transaction(Transaction {
                id: format!("tx{}", i),
                from: "Alice".to_string(),
                to: "Bob".to_string(),
                amount: 100,
            });
        }


        // 挖矿
        blockchain.mine_block();


        // 验证
        assert_eq!(blockchain.blocks.len(), 2);
        assert_eq!(blockchain.blocks[1].transactions.len(), 10);
        assert_eq!(blockchain.pending_transactions.len(), 0);


        // 验证余额
        let alice_balance = blockchain.get_balance("Alice");
        let bob_balance = blockchain.get_balance("Bob");


        assert_eq!(alice_balance, -1000);
        assert_eq!(bob_balance, 1000);
    }
}

9. 学习建议#

9.1 理论学习#

  1. Rust基础：掌握基本语法和所有权系统
  2. 并发编程：理解线程、通道和异步编程
  3. 网络编程：学习HTTP和gRPC
  4. 加密技术：掌握哈希和数字签名

9.2 实践练习#

  1. 简单项目：从基础项目开始
  2. 区块链项目：参与开源区块链项目
  3. 性能优化：学习性能优化技巧
  4. 测试实践：编写全面的测试

9.3 源码阅读#

  1. Rust标准库：阅读标准库源码
  2. 区块链项目：学习Substrate、Solana等项目
  3. 开源项目：参与开源项目开发

10. 总结#

Rust语言在Web3和区块链开发中发挥着重要作用。通过深入理解Rust的特性和在区块链开发中的应用，我们可以构建安全、高性能的区块链应用。

在实际开发中，需要注意：

  1. 内存安全：利用Rust的所有权系统避免内存错误
  2. 并发安全：使用Arc、Mutex等同步原语
  3. 性能优化：合理使用异步编程和优化算法
  4. 错误处理：建立完善的错误处理机制
  5. 测试覆盖：编写全面的测试用例

通过持续学习和实践，我们可以更好地掌握Rust技术，构建更优秀的Web3应用。

本文档基于playground-web3仓库中的Rust语言模块整理，结合Web3技术特点进行了扩展和补充。

Rust语言
https://website-truelovings-projects.vercel.app/posts/web3/08-rust语言/
作者
欢迎来到StarSky的网站！
发布于
2025-09-05
许可协议
CC BY-NC-SA 4.0
Go语言
Layer2扩容技术
© 2025 欢迎来到StarSky的网站！. All Rights Reserved. / RSS / Sitemap
Powered by Astro & Fuwari