区块链网络实现详解

网络架构

区块链网络采用P2P（点对点）拓扑扁平结构，每个节点同时具备服务器和客户端的双重身份。这种去中心化的架构确保了网络的健壮性和可扩展性。

节点类型

  1. 矿工节点

    • 负责打包交易
    • 进行工作量证明
    • 广播新区块

  2. 全节点

    • 存储完整的区块链数据
    • 提供网络路由功能
    • 验证交易和区块

  3. SPV节点（简单支付验证）

    • 只存储区块头
    • 维护特定交易子集
    • 轻量级客户端实现

网络通信流程

1. 版本验证

1
2
3
4
5
6
// Version消息结构
struct Version {
    version: i32,
    best_height: i32,
    addr_from: String,
}

2. 区块同步

1
2
3
4
5
6
7
8
9
10
11
// GetBlocks消息结构
struct GetBlocks {
    addr_from: String,
}

// Inv消息结构
struct Inv {
    addr_from: String,
    type_: String,  // "block" 或 "tx"
    items: Vec<String>,
}

3. 数据请求

1
2
3
4
5
6
// GetData消息结构
struct GetData {
    addr_from: String,
    type_: String,
    id: String,
}

核心组件实现

1. 服务器启动

1
2
3
4
5
6
7
8
9
10
11
12
13
fn start_server(&mut self) {
    let listener = TcpListener::bind(&self.node_addr)?;
    
    // 非中心节点需要同步
    if !self.is_central_node {
        self.send_version(CENTRAL_NODE_ADDR);
    }
    
    // 主循环处理连接
    for stream in listener.incoming() {
        self.handle_connection(stream?);
    }
}

2. 连接处理

1
2
3
4
5
6
7
8
9
10
11
12
fn handle_connection(&mut self, mut stream: TcpStream) {
    let command = self.read_command(&mut stream)?;
    match command.as_str() {
        "version" => self.handle_version(&mut stream),
        "getblocks" => self.handle_get_blocks(&mut stream),
        "inv" => self.handle_inv(&mut stream),
        "getdata" => self.handle_get_data(&mut stream),
        "block" => self.handle_block(&mut stream),
        "tx" => self.handle_tx(&mut stream),
        _ => println!("Unknown command"),
    }
}

3. 版本处理

1
2
3
4
5
6
7
8
fn handle_version(&mut self, stream: &mut TcpStream) {
    let version: Version = deserialize(stream)?;
    
    // 检查区块高度
    if self.blockchain.get_best_height() < version.best_height {
        self.send_get_blocks(version.addr_from);
    }
}

4. 区块请求处理

1
2
3
4
5
fn handle_get_blocks(&mut self, stream: &mut TcpStream) {
    let payload: GetBlocks = deserialize(stream)?;
    let blocks = self.blockchain.get_block_hashes();
    self.send_inv(payload.addr_from, "block", blocks);
}

5. 清单处理

1
2
3
4
5
6
7
fn handle_inv(&mut self, stream: &mut TcpStream) {
    let inv: Inv = deserialize(stream)?;
    if inv.type_ == "block" {
        self.blocks_in_transit = inv.items;
        self.send_get_data(inv.addr_from, "block", self.blocks_in_transit[0]);
    }
}

6. 数据请求处理

1
2
3
4
5
6
7
fn handle_get_data(&mut self, stream: &mut TcpStream) {
    let request: GetData = deserialize(stream)?;
    if request.type_ == "block" {
        let block = self.blockchain.get_block(&request.id)?;
        self.send_block(request.addr_from, block);
    }
}

7. 区块处理

1
2
3
4
5
6
7
8
9
10
11
12
13
fn handle_block(&mut self, stream: &mut TcpStream) {
    let block: Block = deserialize(stream)?;
    self.blockchain.add_block(block)?;
    
    // 继续请求其他区块
    if !self.blocks_in_transit.is_empty() {
        self.blocks_in_transit.remove(0);
        if !self.blocks_in_transit.is_empty() {
            let next_hash = self.blocks_in_transit[0];
            self.send_get_data(stream.peer_addr()?, "block", next_hash);
        }
    }
}

8. 交易处理

1
2
3
4
5
6
7
8
9
10
fn handle_tx(&mut self, stream: &mut TcpStream) {
    let tx: Transaction = deserialize(stream)?;
    self.mempool.insert(tx.id.clone(), tx);
    
    // 作为矿工节点，收集足够交易后开始挖矿
    if self.is_miner && self.mempool.len() >= MINING_THRESHOLD {
        let txs: Vec<Transaction> = self.mempool.values().cloned().collect();
        self.mine_block(txs);
    }
}