3. 核心技术架构

3.1 智能合约设计

3.1.1 核心数据结构

struct DepositInfo {
    uint256 amount;      // 存款金额
    address owner;       // 存款者地址
    bool used;          // 是否已使用
}

mapping(uint256 => DepositInfo) public deposits;           // 存款记录
mapping(bytes32 => bool) public usedProofs;               // 已使用的证明
mapping(bytes32 => bool) public validCommitments;         // 有效的承诺
uint256 public nextDepositId;                             // 下一个存款ID

3.1.2 核心函数

存款函数:

function deposit() external payable returns (uint256) {
    uint256 depositId = nextDepositId++;
    deposits[depositId] = DepositInfo({
        amount: msg.value,
        owner: msg.sender,
        used: false
    });
    return depositId;
}

提交承诺函数:

function submitCommitment(
    bytes32 commitment,
    uint256 depositId,
    uint256 totalAmount,
    bytes calldata sp1Proof
) external {
    // 验证存款有效性和所有权
    require(deposits[depositId].owner == msg.sender, "Not owner");
    require(!deposits[depositId].used, "Already used");

    // 验证零知识证明
    require(sp1Verifier.verifyProof(...), "Invalid proof");

    // 验证金额约束
    require(totalAmount <= deposits[depositId].amount, "Amount exceeds");

    // 更新状态
    deposits[depositId].used = true;
    validCommitments[commitment] = true;

    // 更新哈希树
    _updateMerkleTree(commitment);
}

提取函数:

function withdraw(
    address recipient,
    uint256 amount,
    bytes calldata finalProof
) external {
    // 防重放检查
    bytes32 proofHash = keccak256(finalProof);
    require(!usedProofs[proofHash], "Proof used");

    // 验证零知识证明
    require(sp1Verifier.verifyProof(...), "Invalid proof");

    // 标记证明已使用
    usedProofs[proofHash] = true;

    // 执行转账
    payable(recipient).transfer(amount);
}

3.2 零知识证明电路设计

3.2.1 SP1 电路实现

EnclaveProtocol 使用 SP1 zkVM 作为零知识证明系统，主要包含两类证明：

提交证明电路:

fn prove_commitment_submission() {
    // 私有输入
    let allocations = sp1_zkvm::io::read::<Vec<Allocation>>();
    let secret = sp1_zkvm::io::read::<[u8; 32]>();

    // 公有输入
    let commitment = sp1_zkvm::io::read::<[u8; 32]>();
    let deposit_id = sp1_zkvm::io::read::<u64>();
    let total_amount = sp1_zkvm::io::read::<u64>();

    // 约束验证
    let computed_commitment = hash_commitment(&allocations, &secret, &deposit_id);
    assert_eq!(commitment, computed_commitment);

    let total_allocated: u64 = allocations.iter().map(|a| a.amount).sum();
    assert!(total_allocated <= total_amount);

    // 输出公开值
    sp1_zkvm::io::commit(&commitment);
    sp1_zkvm::io::commit(&deposit_id);
    sp1_zkvm::io::commit(&total_amount);
}

提取证明电路:

fn prove_individual_withdrawal() {
    // 私有输入
    let allocations = sp1_zkvm::io::read::<Vec<Allocation>>();
    let secret = sp1_zkvm::io::read::<[u8; 32]>();
    let deposit_id = sp1_zkvm::io::read::<u64>();

    // 公有输入
    let recipient = sp1_zkvm::io::read::<[u8; 20]>();
    let amount = sp1_zkvm::io::read::<u64>();

    // 验证用户在分配中
    let user_found = allocations.iter()
        .any(|a| a.address == recipient && a.amount == amount);
    assert!(user_found, "User not found in allocations");

    // 验证 commitment
    let commitment = hash_commitment(&allocations, &secret, &deposit_id);

    // 输出验证结果
    sp1_zkvm::io::commit(&recipient);
    sp1_zkvm::io::commit(&amount);
}

3.3 三重防双花机制

EnclaveProtocol 实现了三层防双花保护：

                    提取请求输入
                         │
                         ▼
              ┌─────────────────────────┐
              │      第一层检查          │
              │      Deposit ID         │
              │   deposits[id].used     │
              │   == false ?           │
              └───────────┬─────────────┘
                          │ Pass
                          ▼
              ┌─────────────────────────┐
              │      第二层检查          │
              │      Proof Hash         │
              │   usedProofs[hash]       │
              │   == false ?            │
              └───────────┬─────────────┘
                          │ Pass
                          ▼
              ┌─────────────────────────┐
              │      第三层检查          │
              │      Commitment         │
              │   validCommitments[c]   │
              │   == true ?            │
              └───────────┬─────────────┘
                          │ Pass
                          ▼
                  执行转账操作

三层保护说明：

1. Deposit ID 层面: 确保每个存款只能使用一次，防止资金来源重复
2. Proof 层面: 确保每个零知识证明只能使用一次，防止证明重放攻击
3. Commitment 层面: 确保只有有效的承诺才能被提取，防止伪造攻击

3.4 分布式证明者网络

3.4.1 网络架构

EnclaveProtocol 支持分布式证明者网络，任何人都可以成为证明生成者：

用户层 (Users)
    ↓
负载均衡器 (Load Balancer)
    ↓
证明者池 (Prover Pool)
    ↓
质量监控 (Quality Monitor)

3.4.2 激励机制

费用分配模型:

总手续费 = 基础费用 + 证明者费用 + 网络费用
- 基础费用：50% (协议维护)
- 证明者费用：40% (证明生成激励)
- 网络费用：10% (Gas 费用)

证明者准入机制:

• 最小质押要求：1000 代币
• 硬件要求：4 核 CPU + 8GB RAM
• 网络要求：稳定的互联网连接
• 声誉要求：无恶意行为记录

质量保证机制:

• 证明正确性验证：错误证明将扣除质押
• 响应时间要求：超时将影响声誉评分
• 可用性监控：离线时间过长将降低委托权重

---

[← 上一章：EnclaveProtocol：为区块链增加隐私能力](./02-EnclaveProtocol为区块链增加隐私能力) | [下一章：技术创新点 →](./04-技术创新点)