以下是根据提供的内容整理的完整示例demo，展示了zksync_protobuf库的完整使用流程：

完整示例demo

1. 项目结构

zkprotobuf-demo/
├── Cargo.toml
├── build.rs
├── src/
│   ├── proto/
│   │   └── example.proto
│   └── main.rs

2. Cargo.toml配置

[package]
name = "zkprotobuf-demo"
version = "0.1.0"
edition = "2021"

[dependencies]
zksync_protobuf = "0.1"
prost = "0.11"
tokio = { version = "1.0", features = ["full"] }
tonic = "0.8"

[build-dependencies]
prost-build = "0.11"

3. Protobuf定义 (src/proto/example.proto)

syntax = "proto3";

package zksync.example;

message Transaction {
    bytes sender = 1;
    bytes receiver = 2;
    uint64 amount = 3;
    uint64 fee = 4;
    uint64 nonce = 5;
}

message TransactionRequest {
    Transaction transaction = 1;
}

message BatchTransactionRequest {
    repeated Transaction transactions = 1;
}

4. 构建脚本 (build.rs)

fn main() {
    std::fs::create_dir_all("src/proto").unwrap();
    prost_build::Config::new()
        .out_dir("src/proto")
        .compile_protos(&["src/proto/example.proto"], &["src/"])
        .unwrap();
}

5. 主程序 (src/main.rs)

use zksync_protobuf::{serialize, deserialize};
use tonic::transport::Channel;

mod proto {
    tonic::include_proto!("zksync.example");
}
use proto::{Transaction, TransactionRequest, BatchTransactionRequest};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // 1. 创建交易对象
    let tx1 = Transaction {
        sender: vec![0x01, 0x02, 0x03],
        receiver: vec![0x04, 0x05, 0x06],
        amount: 1000,
        fee: 10,
        nonce: 1,
    };

    let tx2 = Transaction {
        sender: vec![0x07, 0x08, 0x09],
        receiver: vec![0x0A, 0x0B, 0x0C],
        amount: 2000,
        fee: 20,
        nonce: 2,
    };

    // 2. 序列化/反序列化示例
    let encoded = serialize(&tx1).expect("Serialization failed");
    let decoded: Transaction = deserialize(&encoded).expect("Deserialization failed");
    assert_eq!(tx1.amount, decoded.amount);

    // 3. 模拟与zkSync节点交互
    let mut client = MockZkSyncClient::new();
    
    // 发送单笔交易
    send_transaction(&mut client, tx1).await?;
    
    // 发送批量交易
    let transactions = vec![tx1, tx2];
    send_batch_transactions(&mut client, transactions).await?;

    Ok(())
}

// 模拟zkSync客户端
struct MockZkSyncClient;

impl MockZkSyncClient {
    fn new() -> Self {
        Self
    }
    
    async fn submit_transaction(&mut self, request: TransactionRequest) -> Result<(), Box<dyn std::error::Error>> {
        println!("模拟提交交易: {:?}", request);
        Ok(())
    }
    
    async fn submit_batch(&mut self, request: BatchTransactionRequest) -> Result<(), Box<dyn std::error::Error>> {
        println!("模拟提交批量交易: {:?}", request);
        Ok(())
    }
}

async fn send_transaction(
    client: &mut MockZkSyncClient,
    tx: Transaction
) -> Result<(), Box<dyn std::error::Error>> {
    let request = TransactionRequest { transaction: Some(tx) };
    client.submit_transaction(request).await
}

async fn send_batch_transactions(
    client: &mut MockZkSyncClient,
    transactions: Vec<Transaction>
) -> Result<(), Box<dyn std::error::Error>> {
    let request = BatchTransactionRequest { transactions };
    client.submit_batch(request).await
}

6. 运行示例

1. 创建项目：cargo new zkprotobuf-demo
2. 添加上述文件到项目
3. 构建并运行：cargo run

7. 示例输出

模拟提交交易: TransactionRequest { transaction: Some(Transaction { sender: [1, 2, 3], receiver: [4, 5, 6], amount: 1000, fee: 10, nonce: 1 }) }
模拟提交批量交易: BatchTransactionRequest { transactions: [Transaction { sender: [1, 2, 3], receiver: [4, 5, 6], amount: 1000, fee: 10, nonce: 1 }, Transaction { sender: [7, 8, 9], receiver: [10, 11, 12], amount: 2000, fee: 20, nonce: 2 }] }

这个完整示例展示了从定义Protobuf消息到实际使用zksync_protobuf库的全过程，包括：

• Protobuf消息定义
• Rust代码生成
• 序列化/反序列化操作
• 模拟与zkSync节点的交互
• 单笔和批量交易处理