Aztec Network 技術深度解析：zk-zk Rollup 隱私架構與 Noir 程式設計完整指南

概述

Aztec Network 是以太坊生態系統中最具創新性的隱私保護基礎設施之一。作為第一個在以太坊上實現 zk-zk Rollup 的隱私協議，Aztec 採用了革命性的「雙層零知識證明」架構，不僅驗證交易的正確性，還保護交易的隱私特性。本文深入解析 Aztec 的技術架構、密碼學基礎、Noir 程式語言、以及實際應用場景，為開發者提供完整的技術參考。

一、Aztec 核心概念與設計理念

1.1 什麼是 zk-zk Rollup

傳統的 zk Rollup 專注於擴展性，透過將大量交易打包成一個批次，並生成簡潔的零知識證明來驗證這些交易的正確性。然而，這些交易內容在 L1 上仍然是公開可見的。Aztec 的創新之處在於引入了第二層隱私保護，形成「zk-zk Rollup」架構：

第一層 zk（擴展性）：

• 批次驗證：將數百筆交易聚合為單一證明
• 狀態壓縮：只需在 L1 存儲狀態根，而非完整交易歷史
• 計算驗證：證明批次中的所有計算都是正確執行的

第二層 zk（隱私性）：

• 交易金額隱藏：外部觀察者無法得知具體交易金額
• 交易雙方隱藏：無法確定資金的發送者和接收者
• 交易內容加密：即使查看 L2 數據也無法解讀交易內容

這種雙層架構的數學基礎基於兩種不同類型的零知識證明系統的結合：PLONK 用於電路證明，Bulletproofs 用於範圍證明。

1.2 設計目標

Aztec 的設計目標包含以下幾個核心要點：

隱私優先：用戶的財務信息應該受到保護，這是基本人權。Aztec 旨在為用戶提供與傳統金融相同的隱私保護水平。

可編程性：不同於簡單的混幣服務，Aztec 支持用戶編寫完整的私人智慧合約。這使得複雜的 DeFi 應用可以在保護隱私的前提下運行。

相容性：Aztec 需要與現有的以太坊生態系統無縫整合。用戶應該能夠使用熟悉的工具和錢包，同時享受隱私保護。

可驗證性：即使交易內容被隱藏，網路仍然可以驗證交易的正確性。這是區塊鏈信任模型的基礎。

1.3 技術架構總覽

Aztec 的整體架構可分為以下幾個層次：

Aztec 技術架構層次：

┌─────────────────────────────────────────────────────────────────┐
│                        用戶界面層                                │
│   (錢包、DApp、SDK)                                             │
└─────────────────────────────────────────────────────────────────┘
                              │
                              ▼
┌─────────────────────────────────────────────────────────────────┐
│                       客戶端層                                   │
│   ┌──────────────┐  ┌──────────────┐  ┌──────────────┐        │
│   │ 瀏覽器客戶端 │  │  CLI 工具    │  │  SDK        │        │
│   └──────────────┘  └──────────────┘  └──────────────┘        │
└─────────────────────────────────────────────────────────────────┘
                              │
                              ▼
┌─────────────────────────────────────────────────────────────────┐
│                       證明系統層                                 │
│   ┌──────────────┐  ┌──────────────┐  ┌──────────────┐        │
│   │ 交易證明     │  │  卷積證明     │  │  合約電路    │        │
│   │ (TX Proof)  │  │  (Rollup)    │  │ (Circuit)    │        │
│   └────────餘──────┘  └──────────────┘  └──────────────┘        │
└─────────────────────────────────────────────────────────────────┘
                              │
                              ▼
┌─────────────────────────────────────────────────────────────────┐
│                      排序器網路                                 │
│   ┌──────────────┐  ┌──────────────┐  ┌──────────────┐        │
│   │  交易排序    │  │  批次聚合    │  │  證明協調    │        │
│   └──────────────┘  └──────────────┘  └──────────────┘        │
└─────────────────────────────────────────────────────────────────┘
                              │
                              ▼
┌─────────────────────────────────────────────────────────────────┐
│                       以太坊 L1                                 │
│   ┌──────────────┐  ┌──────────────┐  ┌──────────────┐        │
│   │  Rollup 合約 │  │  驗證合約    │  │  橋接合約    │        │
│   └──────────────┘  └──────────────┘  └──────────────┘        │
└─────────────────────────────────────────────────────────────────┘

二、密碼學基礎

2.1 承諾方案

Aztec 使用多種密碼學承諾方案來實現隱私保護。

Pedersen 承諾：

Pedersen 承諾是 Aztec 隱私架構的核心組件。其數學形式為：

C = g^m * h^r (mod p)

其中：
├── m = 消息/金額
├── r = 隨機盲因子
├── g, h = 預定義的生成元（獨立生成）
└── p = 大質數

特性：
├── 隱藏性：無法從 C 推斷 m
└── 綁定性：無法將 C 打開為兩個不同的值

在 Aztec 中，每筆記錄都使用 Pedersen 承諾來隱藏其內容：

// Noir 中的承諾計算
use dep::std::hash::pedersen_hash;

fn compute_commitment(amount: u32, secret: field, nonce: field) -> field {
    // 將多個值組合成向量
    let mut inputs = [0 as field; 3];
    inputs[0] = amount as field;
    inputs[1] = secret;
    inputs[2] = nonce;
    
    // 計算 Pedersen 承諾
    pedersen_hash(inputs)
}

承諾的绑定性质：

承諾方案的绑定性质確保了安全性。如果攻擊者嘗試打開同一個承諾為兩個不同的值，將會產生矛盾。這種性質對於防止雙重支付至關重要。

2.2 範圍證明

範圍證明用於證明某個隱藏值在特定範圍內，而不透露具體值。這對於防止負餘額攻擊至關重要。

Bulletproofs：

Aztec 使用 Bulletproofs 實現範圍證明：

範圍證明語義：
證明者聲明：已知 v, r 使得 C = g^v * h^r 且 0 ≤ v < 2^n

其中 n 是位元寬度（通常為 64 或 128）

Bulletproofs 的特點：

• 簡潔證明大小：O(log n) 而非 O(n)
• 無需可信設置：基於離散對數假設
• 聚合友好：多個範圍證明可合併為單一證明

// Noir 中的範圍證明使用示例
use dep::std::range::assert_normalizes;

fn prove_amount_valid(amount: u64, secret: field) {
    // 確保金額在有效範圍內
    // 這在底層生成 Bulletproofs 證明
    assert(amount < 1000000, "Amount too large");
    
    // 其他業務邏輯...
}

2.3 零知識證明系統

PLONK 電路證明：

Aztec 使用 PLONK 作為主要的 zk-SNARK 系統：

PLONK 特性：
├── 可信設置：需要單一 Trusted Setup Ceremony
├── 電路靈活性：支持自定義電路設計
├── 證明效率：證明大小適中，驗證速度快
└── 通用性：支持任何可計算函數

PLONK 的核心組件包括：

• 編碼電路：將計算轉換為約束系統
• 多項式承諾：用於驗證計算正確性
• 隨機性挑戰：用於確保證明的安全性

// 簡化的 Noir PLONK 電路示例
fn main(
    // 公開輸入
    recipient: pub address,
    amount: pub u32,
    
    // 私人輸入
    secret: field,
    note_hash: field
) {
    // 約束 1：金額有效
    constrain amount > 0;
    constrain amount < 1000000;
    
    // 約束 2：note_hash 正確計算
    let computed_hash = std::hash::pedersen([secret, recipient as field]);
    constrain computed_hash == note_hash;
}

2.4 加密方案

共享密鑰加密：

Aztec 使用_diffie-hellman 密鑰交換實現端到端加密：

密鑰交換協議：

1. 發送方生成臨時密鑰對 (a, A = g^a)
2. 接收方生成密鑰對 (b, B = g^b)
3. 雙方計算共享密鑰：
   ├── 發送方：K = B^a = g^(ab)
   └── 接收方：K = A^b = g^(ab)
4. 使用 K 加密交易數據

三、狀態模型與數據結構

3.1 註釋樹

Aztec 使用 Merkle 樹的變體來組織用戶的「註釋」（Notes）：

Aztec 註釋樹結構：

                    樹根 (Root)
                   /         \
             內部節點        內部節點
              /    \         /    \
          葉子     葉子    葉子    葉子
            │       │       │       │
         Note 0   Note 1  Note 2  Note 3
        
每個葉子節點代表一個「註釋」
註釋包含：金額、所有者公鑰、隨機數等

註釋結構：

// Aztec 註釋定義
struct Note {
    address owner,      // 所有者地址
    u32 amount,         // 金額（加密存儲）
    field secret,       // 秘密值（用於承諾）
    field nonce,        // 隨機數（防止重放）
    field creator_pubkey,  // 創建者公鑰
}

3.2 內存池設計

Aztec 的內存池（Private Mempool）與以太坊的公開內存池有本質區別：

私密內存池特性：

私密內存池 vs 公開內存池：

公開內存池（以太坊）：
├── 所有交易可見
├── 按 Gas 費用排序
├── 交易內容完全透明
└── 易受 MEV 攻擊

私密內存池（Aztec）：
├── 交易加密存儲
├── 排序器無法查看內容
├── 零知識證明驗證有效性
└── 防止搶先交易

3.3 批次處理

Aztec 將多筆交易聚合為批次（Rollup）：

批次結構：

Rollup {
    // 批次元數據
    uint64 batch_size,      // 交易數量
    bytes32 previous_root,  // 前一棵樹根
    bytes32 new_root,       // 新樹根
    
    // 證明數據
    bytes proof,           // 零知識證明
    bytes32[2] public_inputs,  // 公開輸入
    
    // 聚合數據
    uint256 fee,           // 匯總費用
    address fee_recipient,  // 費用接收者
}

四、Noir 程式語言

4.1 Noir 語言概述

Noir 是 Aztec 專門為編寫零知識證明電路設計的程式語言。其設計目標是：

易用性：語法類似 Rust，降低學習曲線

安全性：編譯時進行電路特定的安全檢查

可移植性：電路可編譯為多種 zk-SNARK 後端

表現力：支持複雜的計算邏輯

// 簡單的 Noir 程序示例
fn main(x: field) -> field {
    x * x
}

4.2 數據類型

Noir 支持多種數據類型：

// 基本類型
fn types_example() {
    let a: field = 1;          // 有限域元素
    let b: u8 = 255;            // 無符號整數
    let c: i32 = -1;            // 有符號整數
    let d: bool = true;         // 布爾值
    let e: () = ();             // 單元類型
    
    // 數組
    let arr: [field; 3] = [1, 2, 3];
    
    // 元組
    let tuple: (u32, bool) = (42, true);
    
    // 結構體
    struct Point { x: field, y: field }
    let p = Point { x: 1, y: 2 };
}

4.3 約束系統

Noir 的核心是約束（Constraints）：

// 約束示例
fn constraint_examples(x: field, y: field) {
    // 等式約束
    constrain x == y;
    
    // 範圍約束
    let value: u32 = 100;
    constrain value < 1000;
    
    // 布爾約束
    let flag: bool = true;
    constrain flag == true;
    
    // 多項式約束
    let z = x + y;
    constrain z == 10;
}

4.4 函數與模組

// 函數定義
fn add(a: field, b: field) -> field {
    a + b
}

// 條件函數
fn max(a: field, b: field) -> field {
    if a > b { a } else { b }
}

// 遞迴函數（注意：Noir 中需謹慎使用）
fn factorial(n: u32) -> u32 {
    if n == 0 { 1 } else { n * factorial(n - 1) }
}

// 模組系統
mod utils {
    fn helper(x: field) -> field {
        x * 2
    }
}

fn use_module() {
    let result = utils::helper(5);
}

4.5 完整示例：私人轉帳合約

以下是一個完整的 Noir 私人轉帳合約示例：

// 私人轉帳合約
// 文件名：private_transfer.nr

use dep::std::hash::pedersen;
use dep::std::range::assert_lt;

// 合約配置
mod config {
    global MAX_AMOUNT: u32 = 1000000;
    global MIN_AMOUNT: u32 = 1;
}

struct Note {
    owner: field,        // 所有者公鑰
    amount: field,        // 金額（加密）
    secret: field,        // 秘密值
    nonce: field,        // 隨機數
    creator: field,      // 創建者
}

struct TransferInput {
    // 消費的 note（新 note 的母 note）
    input_note: Note,
    input_note_membership_proof: [field; 32],
    input_note_path_index: field,
    
    // 新創建的 note
    output_note: Note,
    
    // 公開數據
    recipient: field,
    amount: u32,
    
    // 承諾驗證
    input_note_commitment: field,
    output_note_commitment: field,
}

struct TransferOutput {
    new_input_note_commitment: field,
    new_output_note_commitment: field,
    nullifier: field,
}

// 計算 note 承諾
fn compute_note_commitment(note: Note) -> field {
    pedersen([note.owner, note.amount, note.secret, note.nonce])
}

// 計算廢止標記
fn compute_nullifier(note: Note, sender_public_key: field) -> field {
    pedersen([note.secret, sender_public_key, note.nonce])
}

// 驗證 Merkle 證明
fn verify_merkle_proof(
    leaf: field,
    path: [field; 32],
    index: field,
    root: field
) -> bool {
    let mut current = leaf;
    
    for i in 0..32 {
        let bit = (index >> i) & 1;
        if bit == 0 {
            current = pedersen([current, path[i]]);
        } else {
            current = pedersen([path[i], current]);
        }
    }
    
    current == root
}

// 主轉帳函數
fn main(
    // 公開輸入
    public_owner: field,
    public_amount: u32,
    tree_root: field,
    
    // 私人輸入
    input: TransferInput,
) -> TransferOutput {
    // 1. 驗證金額範圍
    assert_lt(public_amount, config::MAX_AMOUNT);
    assert_lt(config::MIN_AMOUNT, public_amount);
    
    // 2. 驗證輸入 note 的承諾
    let input_commitment = compute_note_commitment(input.input_note);
    constrain input_commitment == input.input_note_commitment;
    
    // 3. 驗證 Merkle 證明
    let is_valid_merkle = verify_merkle_proof(
        input.input_note_commitment,
        input.input_note_membership_proof,
        input.input_note_path_index,
        tree_root
    );
    constrain is_valid_merkle == true;
    
    // 4. 驗證輸出 note 承諾
    let output_commitment = compute_note_commitment(input.output_note);
    constrain output_commitment == input.output_note_commitment;
    
    // 5. 計算廢止標記（防止雙重花費）
    let nullifier = compute_nullifier(input.input_note, public_owner);
    
    // 6. 驗證金額守恆
    let input_amount = input.input_note.amount as u32;
    let output_amount = input.output_note.amount as u32;
    constrain input_amount >= public_amount;
    constrain output_amount == input_amount - public_amount;
    
    TransferOutput {
        new_input_note_commitment: input.input_note_commitment,
        new_output_note_commitment: output_commitment,
        nullifier,
    }
}

五、實際應用場景

5.1 私人借貸

Aztec 支持在完全隱私的情況下進行借貸操作：

// 私人借貸合約示例
contract PrivateLending {
    // 存儲用戶的私人餘額（加密）
    mapping(field => field) private balances;
    mapping(field => field) private debt;
    
    // 抵押率要求
    uint256 public constant COLLATERAL_RATIO = 150; // 150%
    
    // 私人存款
    fn deposit(
        amount: u32,
        note_hash: field,
        secret: field,
        owner_pubkey: field
    ) {
        // 驗證存款證明
        // （底層生成範圍證明確保 amount > 0）
        
        // 更新私人餘額
        let current_balance = balances[owner_pubkey];
        let new_balance = current_balance + amount as field;
        balances[owner_pubkey] = new_balance;
        
        // 記錄 note
        emit DepositNote(note_hash, owner_pubkey);
    }
    
    // 私人借款
    fn borrow(
        amount: u32,
        collateral_note_hash: field,
        recipient: address
    ) {
        let borrower = msg.sender();
        
        // 驗證抵押品充足
        let collateral = balances[collateral_note_hash];
        let required_collateral = (amount * COLLATERAL_RATIO) / 100;
        
        require(
            collateral >= required_collateral as field,
            "Insufficient collateral"
        );
        
        // 更新借款餘額
        let current_debt = debt[borrower];
        debt[borrower] = current_debt + amount as field;
        
        // 生成借款 note
        let borrow_note = create_note(recipient, amount);
        
        // 轉移資金（通過 Aztec 私人轉帳）
        // 外部只能看到：Lending → Aztec
    }
    
    // 私人還款
    fn repay(amount: u32, debt_note_hash: field) {
        let borrower = msg.sender();
        
        // 驗證還款金額不超過借款
        let current_debt = debt[borrower];
        require(amount as field <= current_debt, "Excess repayment");
        
        // 更新借款餘額
        debt[borrower] = current_debt - amount as field;
        
        // 記錄還款
        emit Repay(borrower, amount);
    }
    
    // 私人清算
    fn liquidate(user: address) {
        // 驗證健康因子
        let collateral = balances[user];
        let user_debt = debt[user];
        
        let health_factor = (collateral * 100) / user_debt;
        require(health_factor < COLLATERAL_RATIO, "Not liquidatable");
        
        // 執行清算
        // 清算人獲得抵押品
        // 所有操作都是私密的
    }
}

5.2 私人交易

在 DEX 上進行隱私交易：

// Aztec AMM 合約
contract PrivateAMM {
    // 代幣儲備（加密）
    field private reserve_x;
    field private reserve_y;
    
    // .constant product: k = x * y
    fn swap(
        dx: u32,                    // 輸入金額
        min_dy: u32,                // 最小輸出
        recipient: field,          // 接收者
        input_note_hash: field,    // 輸入 note
        output_note_commitment: field  // 輸出 note 承諾
    ) {
        // 1. 計算輸出金額（使用 AMM 公式）
        let dx_field = dx as field;
        let dy = calculate_output(dx_field, reserve_x, reserve_y);
        
        // 2. 驗證滑點
        require(dy >= min_dy as field, "Insufficient output");
        
        // 3. 驗證輸入 note
        // （驗證用戶確實擁有輸入資金）
        
        // 4. 生成輸出 note
        let output_note = create_note(recipient, dy as u32);
        let output_hash = compute_note_commitment(output_note);
        
        require(output_hash == output_note_commitment, "Invalid output");
        
        // 5. 更新儲備
        reserve_x = reserve_x + dx_field;
        reserve_y = reserve_y - dy;
        
        // 6. 發出事件（加密）
        emit Swap(input_note_hash, output_note_commitment, dy);
    }
    
    fn calculate_output(
        dx: field,
        x: field,
        y: field
    ) -> field {
        // 恆定乘積公式
        let k = x * y;
        let new_x = x + dx;
        let new_y = k / new_x;
        y - new_y
    }
}

5.3 私人治理投票

// 私人治理合約
contract PrivateGovernance {
    // 投票權重（加密）
    mapping(field => field) private voting_power;
    
    // 投票記錄（加密）
    mapping(bytes32 => field) private votes;
    
    // 提議結構
    struct Proposal {
        field recipient,      // 目標合約
        u32 value,           // 調用金額
        bytes data,          // 調用數據
        u32 voting_start,   // 投票開始時間
        u32 voting_end,      // 投票結束時間
        u32 quorum,          // 法定人數
    }
    
    // 私人投票
    fn vote(
        proposal_id: bytes32,
        support: bool,
        amount: u32,
        note_hash: field,
        voting_power_proof: [field; 32]
    ) {
        let voter = msg.sender();
        
        // 1. 驗證投票權重
        let power = voting_power[note_hash];
        require(power >= amount as field, "Insufficient voting power");
        
        // 2. 驗證投票權證明
        // （確保 note 確實屬於投票者）
        
        // 3. 記錄投票
        let current_votes = votes[proposal_id];
        
        if support {
            votes[proposal_id] = current_votes + amount as field;
        } else {
            votes[proposal_id] = current_votes - amount as field;
        }
        
        // 4. 發出加密事件
        emit Vote(proposal_id, note_hash, support);
    }
    
    // 執行提案
    fn execute(proposal_id: bytes32) {
        let votes_for = votes[proposal_id];
        
        // 驗證投票通過
        require(votes_for >= quorum, "Proposal failed");
        
        // 執行提案邏輯
        // ...
    }
}

六、Gas 優化與效能

6.1 電路優化技術

減少約束數量：

// 低效實現：過多約束
fn inefficient_example(x: field, y: field) -> field {
    let a = x * y;
    let b = a * x;
    let c = b * y;
    c
}

// 優化實現：減少乘法次數
fn optimized_example(x: field, y: field) -> field {
    // 合併計算
    x * y * x * y  // 實際可優化為 x^2 * y^2
}

使用查找表：

// 預計算常量
mod constants {
    global LOOKUP_TABLE: [field; 256] = // 預計算表
}

// 使用查找表
fn lookup(index: u8) -> field {
    constants::LOOKUP_TABLE[index as field]
}

6.2 聚合策略

批量驗證：

// 批量驗證多個承諾
fn batch_verify_commitments(
    commitments: [field; N],
    proofs: [field; M],
    root: field
) -> bool {
    // 一次性驗證整個批次
    // 減少每筆交易的 Gas 成本
}

6.3 效能基準

Aztec 交易成本估算（2026年 Q1）：

| 操作類型          | Gas 成本      | 預估費用     |
|-------------------|--------------|-------------|
| 私人轉帳         | ~300k Gas   | $15-30     |
| 私人 AMM 交換    | ~500k Gas   | $25-50     |
| 私人借貸存款     | ~400k Gas   | $20-40     |
| 私人投票         | ~200k Gas   | $10-20     |

注意：費用隨網路擁堵程度變化

七、安全考量

7.1 信任模型

Aztec 的安全基於以下假設：

密碼學假設：

• 離散對數問題的困難性
• 隨機預言機模型的適用性
• 底層 zk-SNARK 系統的安全性

經濟假設：

• 攻擊者沒有足夠的經濟動機發動 51% 攻擊
• 驗證者是理性的，會遵守協議

7.2 潛在風險

電路漏洞：

// 潛在漏洞：整數溢位
fn vulnerable_add(a: u32, b: u32) -> u32 {
    a + b  // 可能發生溢位
}

// 修正：使用 SafeMath 模式
fn safe_add(a: u32, b: u32) -> u32 {
    let c = a as u64 + b as u64;
    require(c < 2^32, "Overflow");
    c as u32
}

側信道攻擊：

時間攻擊和功率分析可能泄露秘密信息。Noir 提供了恆定時間操作來緩解此類攻擊。

7.3 最佳實踐

安全檢查清單：

□ 驗證所有輸入範圍
□ 使用 SafeMath 模式
□ 避免側信道泄露
□ 定期審計電路代碼
□ 使用形式化驗證工具
□ 遵循最小權限原則

八、與其他隱私方案的比較

8.1 Aztec vs Railgun：隱私機制深度差異分析

Aztec Network 和 Railgun 是當前以太坊生態系統中兩個最先進的隱私保護協議，但它們採用了截然不同的技術路徑，適用於不同的應用場景。深入理解這兩者的差異對於開發者和投資者選擇合適的隱私解決方案至關重要。

架構設計差異：

Aztec vs Railgun 架構比較：

┌─────────────────────────────────────────────────────────────────────┐
│                         Aztec Network                               │
├─────────────────────────────────────────────────────────────────────┤
│  技術類型：zk-zk Rollup（雙層零知識證明）                            │
│  執行環境：專用隱私 Rollup 網路                                     │
│  交易類型：完全私密交易（金額、發送者、接收者完全隱藏）            │
│  可編程性：完全可編程（透過 Noir 語言）                            │
│  數據可用性：L2 私密數據（需特殊客戶端訪問）                       │
│  Gas 效率：較高（批次驗證）                                        │
│  開發語言：Noir（自研 DSL）                                        │
└─────────────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────────────┐
│                           Railgun                                   │
├─────────────────────────────────────────────────────────────────────┤
│  技術類型：zk-Address + 私密合約                                    │
│  執行環境：任何 EVM 兼容網路                                       │
│  交易類型：DeFi 私密交易（保護地址和金額）                         │
│  可編程性：有限（透過 Relayer 網路）                               │
│  數據可用性：完全公開（使用加密和承諾）                            │
│  Gas 效率：中等（每筆交易獨立驗證）                                │
│  開發語言：Solidity（標準以太坊合約）                              │
└─────────────────────────────────────────────────────────────────────┘

密碼學實現差異：

Aztec 和 Railgun 在密碼學實現上存在根本性的差異。Aztec 使用了更為複雜的承諾方案和範圍證明來實現完全的交易隱私，而 Railgun 採用了更簡潔的 zk-Address 機制來保護地址隱私。

密碼學層面比較：

1. 承諾方案
   ├── Aztec：多 Pedersen 承諾 + Bulletproofs 範圍證明
   │   ├── 承諾：C = g^m * h^r (mod p)
   │   ├── 範圍證明：0 ≤ v < 2^n（64-128 位元）
   │   └── 特性：完全隱藏，但計算成本較高
   │
   └── Railgun：單一 hash 承諾 + 簡化範圍證明
       ├── 承諾：H = sha256(address || amount || salt)
       ├── 範圍證明：簡化版本（32 位元）
       └── 特性：部分隱藏，但計算效率高

2. 地址保護
   ├── Aztec：完全匿名（外部無法確定任何地址關聯）
   │   ├── 使用加密的 note 系統
   │   ├── 所有地址都是臨時計算得出
   │   └── 無法通過區塊瀏覽器追蹤
   │
   └── Railgun：zk-Address（保護隱私但可選擇披露）
       ├── 使用隱私地址對（ viewing key + spending key）
       ├── 可選擇向特定方披露交易細節
       └── 適合需要合規的機構使用

3. 交易驗證
   ├── Aztec：雙層驗證
   │   ├── 第一層：交易有效性（zk-SNARK）
   │   ├── 第二層：批次正確性（Rollup 證明）
   │   └── 特性：極高安全性，但延遲較高
   │
   └── Railgun：單層驗證
       ├── 每筆交易獨立生成零知識證明
       └── 特性：驗證速度快，但隱私性較弱

隱私保障程度差異：

隱私保障比較矩陣：

| 隱私維度           | Aztec        | Railgun      |
|-------------------|--------------|--------------|
| 金額隱藏          | 完全隱藏     | 完全隱藏     |
| 發送者地址隱藏    | 完全隱藏     | 完全隱藏     |
| 接收者地址隱藏    | 完全隱藏     | 完全隱藏     |
| 交易時間模式       | 完全隱藏     | 部分隱藏     |
| 交易金額模式       | 完全隱藏     | 完全隱藏     |
| 合約交互隱藏       | 完全隱藏     | 不隱藏      |
| 可選擇性披露       | 不支持       | 支持         |
| 合規友好度         | 較低         | 較高         |

Gas 成本與效能比較：

Gas 成本估算（2026 年第一季度）：

| 操作類型          | Aztec        | Railgun      |
|-------------------|--------------|--------------|
| 簡單轉帳          | ~300k Gas   | ~200k Gas   |
| ERC-20 轉帳       | ~350k Gas   | ~250k Gas   |
| DEX 交換          | ~500k Gas   | ~400k Gas   |
| 借貸存款          | ~400k Gas   | ~350k Gas   |
| 複雜合約交互       | ~800k Gas   | 不支持      |

注意：
- Aztec 的 Gas 成本較高是因為雙層零知識證明
- Railgun 成本較低但功能受限
- 實際費用會隨網路擁堵程度變化

應用場景選擇：

場景推薦：

選擇 Aztec 的場景：
├── 需要完全隱私的金融交易
├── 構建私人 DeFi 應用
├── 企業級隱私需求
├── 需要可編程性的複雜邏輯
└── 對隱私安全有最高要求

選擇 Railgun 的場景：
├── 簡單的 DeFi 操作
├── 需要合規披露能力
├── 與現有 EVM 生態兼容
├── 開發資源有限
└── 對 Gas 成本敏感

技術成熟度與生態系統：

生態系統比較：

Aztec：
├── 網路狀態：主網運行中（2024 年上線）
├── TVL：~$100M（2026 Q1）
├── 整合協議：私人 AMM、借貸協議
├── 開發工具：Noir IDE、SDK、文檔
├── 社區規模：中等
└── 資金支持：a16z、Paradigm 等頂級 VC

Railgun：
├── 網路狀態：主網運行中（2021 年上線）
├── TVL：~$50M（2026 Q1）
├── 整合協議：20+ DeFi 協議
├── 開發工具：Relay SDK、文檔
├── 社區規模：較大
└── 資金支持：Multiple VC 回合融資

8.2 三方隱私協議綜合比較

| 特性          | Aztec       | Tornado Cash | Railgun   |
|---------------|-------------|--------------|-----------|
| 隱私類型      | 完全隱私    | 轉帳隱私     | DeFi 隱私 |
| 可編程性      | 完全        | 無           | 有限      |
| Gas 效率      | 中等        | 較低         | 中等      |
| 開發語言      | Noir        | Circom       | Solidity  |
| 適合場景      | 複雜應用    | 簡單轉帳     | DeFi 操作 |
| 合規友好      | 較低        | 低           | 中等      |
| EVM 相容性    | 需專用網路  | 是           | 是        |

九、zkMoney 完整實作教學：主流隱私協議實務應用

9.1 zkMoney 概述與技術架構

zkMoney 是以太坊生態系統中最具代表性的隱私保護應用之一，專注於為用戶提供簡單易用的隱私轉帳服務。與 Aztec Network 的完整智慧合約平台不同，zkMoney 採用更輕量化的設計，專注於解決一個核心問題：如何讓用戶能夠隱藏其交易金額和交易對象，同時保持與以太坊生態系統的完全兼容性。

zkMoney 的技術架構建立在以下幾個核心組件之上：

隱私池（Privacy Pool）機制：zkMoney 使用「承諾方案」（Commitment Scheme）來實現交易隱私。用戶將 ETH 或 ERC-20 代幣存入一個智能合約，合約會生成一個「承諾」（Commitment），這個承諾是加密的，無法從中推斷出存款金額或存款人身份。當用戶需要提款時，只需提供一個「零知識證明」來證明自己曾經存過款，而無需透露具體是哪筆存款。

Merkle 樹結構：所有存款承諾都存儲在一個 Merkle 樹中，這種數據結構允許高效地驗證某個承諾是否屬於整個集合，同時保護其他存款人的隱私。當用戶提款時，只需提供一個 Merkle 證明來證明其存款在樹中，而無需透露具體是哪個葉子節點。

零知識證明驗證：zkMoney 使用 zk-SNARK（Zero-Knowledge Succinct Non-Interactive Arguments of Knowledge）來生成提款證明。這些證明允許驗證者確認提款者是合法的存款人，同時不透露任何關於存款本身的信息。

9.2 zkMoney 智能合約實作

以下是 zkMoney 核心智能合約的完整實現，展示其隱私保護機制的技術細節：

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;

/**
 * @title ZkMoneyPrivacyPool
 * @dev 基於零知識證明的隱私池實現
 */
contract ZkMoneyPrivacyPool {
    // 常量定義
    uint256 public constant TREE_DEPTH = 20;
    uint256 public constant FIELD_SIZE = 21888242871839275222246405745257275088548364400416034343698204186575808495617;
    
    // Merkle 樹根
    bytes32 public currentRoot;
    bytes32 public previousRoot;
    
    // 承諾映射：追蹤已使用的承諾
    mapping(bytes32 => bool) public commitments;
    mapping(bytes32 => bool) public nullifierHashes;
    
    // 存款事件
    event Deposit(bytes32 indexed commitment, uint256 leafIndex, uint256 timestamp);
    // 提款事件（僅顯示接收者和金額範圍，不透露具體金額）
    event Withdrawal(address indexed recipient, bytes32 nullifierHash, address indexed relayer, uint256 fee);
    
    // 零知識證明驗證器（預編譯合約）
    IVerifier public verifier;
    
    // 驗證費用
    uint256 public denomination;
    mapping(address => bool) public allowedTokens;
    
    /**
     * @dev 初始化隱私池
     * @param _verifier zk-SNARK 驗證合約地址
     * @param _denomination 單筆存款/提款金額
     * @param _token 代幣地址（address(0) 為 ETH）
     */
    constructor(
        address _verifier,
        uint256 _denomination,
        address _token
    ) {
        verifier = IVerifier(_verifier);
        denomination = _denomination;
        allowedTokens[_token] = true;
        
        // 初始化 Merkle 樹根（零值）
        currentRoot = bytes32(0);
        previousRoot = bytes32(0);
    }
    
    /**
     * @dev 存款函數
     * @param _commitment 加密的存款承諾
     */
    function deposit(bytes32 _commitment) external payable {
        require(!commitments[_commitment], "Commitment already exists");
        require(msg.value == denomination, "Incorrect deposit amount");
        
        // 記錄承諾
        commitments[_commitment] = true;
        
        // 發送存款事件（承諾是加密的，無法從中推斷存款人）
        emit Deposit(_commitment, 0, block.timestamp);
        
        // 這裡應該更新 Merkle 樹（簡化版本略）
    }
    
    /**
     * @dev 提款函數
     * @param _proof zk-SNARK 證明
     * @param _root Merkle 樹根
     * @param _nullifierHash 空值哈希（用於防止雙重提款）
     * @param _recipient 接收者地址
     * @param _relayer 中繼者地址（可選）
     * @param _fee 中繼費用
     */
    function withdraw(
        bytes calldata _proof,
        bytes32 _root,
        bytes32 _nullifierHash,
        address payable _recipient,
        address payable _relayer,
        uint256 _fee
    ) external {
        require(_fee <= denomination / 10, "Fee too high");
        require(!nullifierHashes[_nullifierHash], "Already withdrawn");
        require(_root == currentRoot || _root == previousRoot, "Invalid root");
        
        // 驗證零知識證明
        require(verifyProof(_proof, _root, _nullifierHash, _recipient, _relayer, _fee), "Invalid proof");
        
        // 記錄空值哈希以防止雙重提款
        nullifierHashes[_nullifierHash] = true;
        
        // 轉移資金
        if (_fee > 0) {
            require(address(this).balance >= denomination, "Insufficient balance");
            (bool success, ) = _relayer.call{value: _fee}("");
            require(success, "Fee transfer failed");
        }
        
        (bool success, ) = _recipient.call{value: denomination - _fee}("");
        require(success, "Transfer to recipient failed");
        
        emit Withdrawal(_recipient, _nullifierHash, _relayer, _fee);
    }
    
    /**
     * @dev 驗證零知識證明
     */
    function verifyProof(
        bytes calldata _proof,
        bytes32 _root,
        bytes32 _nullifierHash,
        address _recipient,
        address _relayer,
        uint256 _fee
    ) internal view returns (bool) {
        // 驗證 zk-SNARK 證明
        // 輸入格式：[_root, _nullifierHash, _recipient, _relayer, _fee]
        return verifier.verify(
            _proof,
            [uint256(_root), uint256(_nullifierHash), uint256(uint160(_recipient)), uint256(uint160(_relayer)), _fee]
        );
    }
    
    /**
     * @dev 獲取合約餘額
     */
    function getBalance() external view returns (uint256) {
        return address(this).balance;
    }
}

/**
 * @dev zk-SNARK 驗證器接口
 */
interface IVerifier {
    function verify(bytes calldata proof, uint256[5] memory input) external view returns (bool);
}

9.3 zkMoney 零知識電路設計

zkMoney 的零知識電路是實現隱私保護的核心組件。以下是使用 circom 語言編寫的電路示例，展示了如何實現隱私提款的密碼學證明：

/*
 * zkMoney 提款電路
 * 證明提款者知道一個有效的存款承諾和對應的密鑰
 */

include "circomlib/poseidon.circom";
include "circomlib/bitify.circom";
include "circomlib/switcher.circom";

template Main() {
    // 公開輸入
    signal input root;
    signal input nullifierHash;
    signal input recipient;
    signal input relayer;
    signal input fee;
    
    // 私人輸入
    signal input secret;
    signal input nullifier;
    signal input pathElements[TREE_DEPTH];
    signal input pathIndices[TREE_DEPTH];
    
    // 組件
    component commitmentHasher = Poseidon(2);
    component nullifierHasher = Poseidon(2);
    component receiverHasher = Poseidon(1);
    component relayerHasher = Poseidon(1);
    
    // 1. 計算存款承諾
    // commitment = hash(secret, nullifier)
    commitmentHasher.inputs[0] <== secret;
    commitmentHasher.inputs[1] <== nullifier;
    signal commitment <== commitmentHasher.out;
    
    // 2. 計算空值哈希
    // nullifierHash = hash(nullifier)
    nullifierHasher.inputs[0] <== nullifier;
    nullifierHasher.inputs[1] <== 0;
    nullifierHash === nullifierHasher.out;
    
    // 3. 驗證 Merkle 證明
    // 計算從葉子到根的路徑
    signal computedRoot <== commitment;
    signal currentHash <== commitment;
    
    for (var i = 0; i < TREE_DEPTH; i++) {
        // 根據路徑索引確定左右位置
        signal left <== switcher.out[0];
        signal right <== switcher.out[1];
        
        component levelHasher = Poseidon(2);
        levelHasher.inputs[0] <== left;
        levelHasher.inputs[1] <== right;
        
        currentHash <== levelHasher.out;
    }
    
    // 4. 驗證計算出的根與輸入的根匹配
    computedRoot === root;
    
    // 5. 驗證接收者地址正確（防止重定向攻擊）
    receiverHasher.inputs[0] <== recipient;
    signal recipientHash <== receiverHasher.out;
    
    // 6. 驗證費用有效性（fee < denomination）
    // 這個約束確保攻擊者無法通過設置過高費用盜竊資金
    signal feeValid <== fee * (1 - fee / DENOMINATION);
    feeValid === 0;
}

component main {public [root, nullifierHash, recipient, relayer, fee]} = Main();

9.4 zkMoney 前端整合實作

zkMoney 的前端應用需要與智能合約進行交互，同時生成零知識證明。以下是使用 TypeScript 和 ethers.js 實現的前端整合示例：

import { ethers, BigNumber } from 'ethers';
import { Groth16 } from 'snarkjs';

// 類型定義
interface ZkMoneyConfig {
    contractAddress: string;
    verifierAddress: string;
    denomination: BigNumber;
    rpcUrl: string;
}

interface DepositResult {
    commitment: string;
    secret: string;
    nullifier: string;
    leafIndex: number;
}

interface WithdrawResult {
    proof: string[];
    nullifierHash: string;
    recipient: string;
    relayer: string;
    fee: BigNumber;
}

class ZkMoneyClient {
    private provider: ethers.providers.JsonRpcProvider;
    private wallet: ethers.Wallet;
    private contract: ethers.Contract;
    private verifier: ethers.Contract;
    private config: ZkMoneyConfig;
    
    // Merkle 樹客戶端（簡化）
    private merkleTree: any;
    
    constructor(config: ZkMoneyConfig, privateKey: string) {
        this.config = config;
        this.provider = new ethers.providers.JsonRpcProvider(config.rpcUrl);
        this.wallet = new ethers.Wallet(privateKey, this.provider);
        
        // 加載智能合約
        this.contract = new ethers.Contract(
            config.contractAddress,
            ['function deposit(bytes32) external payable',
             'function withdraw(bytes,bytes32,bytes32,address,address,uint256) external',
             'function currentRoot() view returns (bytes32)'],
            this.wallet
        );
        
        this.verifier = new ethers.Contract(
            config.verifierAddress,
            ['function verify(bytes,uint256[5]) view returns (bool)'],
            this.provider
        );
    }
    
    /**
     * 生成隨機承諾和密鑰
     */
    private generateCommitment(): { commitment: string, secret: string, nullifier: string } {
        // 生成隨機秘密和空值
        const secret = this.randomFieldElement();
        const nullifier = this.randomFieldElement();
        
        // 計算承諾
        const commitment = this.poseidonHash([secret, nullifier]);
        
        return { commitment, secret, nullifier };
    }
    
    /**
     * 執行存款
     */
    async deposit(): Promise<DepositResult> {
        const { commitment, secret, nullifier } = this.generateCommitment();
        
        // 發送存款交易
        const tx = await this.contract.deposit(commitmission, {
            value: this.config.denomination
        });
        
        await tx.wait();
        
        // 計算葉子索引（在實際實現中需要從 Merkle 樹獲取）
        const leafIndex = await this.getNextLeafIndex();
        
        return {
            commitment,
            secret,
            nullifier,
            leafIndex
        };
    }
    
    /**
     * 生成提款零知識證明
     */
    async generateWithdrawProof(
        deposit: DepositResult,
        recipientAddress: string,
        relayerAddress: string = ethers.constants.AddressZero,
        fee: BigNumber = BigNumber.from(0)
    ): Promise<WithdrawResult> {
        // 獲取當前 Merkle 根
        const root = await this.contract.currentRoot();
        
        // 生成 Merkle 證明
        const merkleProof = await this.merkleTree.proof(deposit.leafIndex);
        
        // 準備電路輸入
        const input = {
            // 公開輸入
            root: BigNumber.from(root).toString(),
            nullifierHash: this.poseidonHash([deposit.nullifier, 0]).toString(),
            recipient: BigNumber.from(recipientAddress).toString(),
            relayer: BigNumber.from(relayerAddress).toString(),
            fee: fee.toString(),
            
            // 私人輸入
            secret: deposit.secret,
            nullifier: deposit.nullifier,
            pathElements: merkleProof.pathElements,
            pathIndices: merkleProof.pathIndices
        };
        
        // 生成 zk-SNARK 證明
        const { proof } = await Groth16.fullProve(
            input,
            '/circuits/withdraw.wasm',
            '/circuits/withdraw_0001.zkey'
        );
        
        // 格式化證明
        const formattedProof = this.formatProof(proof);
        
        // 計算空值哈希
        const nullifierHash = this.poseidonHash([deposit.nullifier, 0]);
        
        return {
            proof: formattedProof,
            nullifierHash: nullifierHash.toString(),
            recipient: recipientAddress,
            relayer: relayerAddress,
            fee
        };
    }
    
    /**
     * 執行提款
     */
    async withdraw(
        deposit: DepositResult,
        recipient: string,
        relayer: string = ethers.constants.AddressZero,
        fee: BigNumber = BigNumber.from(0)
    ): Promise<ethers.Transaction> {
        // 生成提款證明
        const withdrawData = await this.generateWithdrawProof(
            deposit,
            recipient,
            relayer,
            fee
        );
        
        // 發送提款交易
        const tx = await this.contract.withdraw(
            withdrawData.proof,
            this.config.denomination, // 這裡應該傳入電路的公開輸入
            withdrawData.nullifierHash,
            recipient,
            relayer,
            fee
        );
        
        return await tx.wait();
    }
    
    /**
     * 輔助函數：隨機字段元素
     */
    private randomFieldElement(): string {
        const random = ethers.utils.randomBytes(32);
        // 確保在 Field 範圍內
        return BigNumber.from(random).mod(
            BigNumber.from("21888242871839275222246405745257275088548364400416034343698204186575808495617")
        ).toString();
    }
    
    /**
     * 輔助函數：Poseidon 哈希
     */
    private poseidonHash(inputs: string[]): BigNumber {
        // 實際實現需要調用 poseidon 庫
        // 這裡是簡化版本
        return BigNumber.from(ethers.utils.keccak256(
            ethers.utils.solidityPack(inputs.map(() => 'uint256'), inputs)
        ));
    }
    
    /**
     * 輔助函數：格式化證明
     */
    private formatProof(proof: any): string[] {
        return [
            proof.pi_a[0], proof.pi_a[1],
            proof.pi_b[0][0], proof.pi_b[0][1],
            proof.pi_b[1][0], proof.pi_b[1][1],
            proof.pi_c[0], proof.pi_c[1]
        ];
    }
    
    /**
     * 獲取下一個葉子索引
     */
    private async getNextLeafIndex(): Promise<number> {
        // 實際實現需要查詢事件或維護本地 Merkle 樹
        return 0;
    }
}

9.5 zkMoney 與 Aztec Network 的比較實務

zkMoney 和 Aztec Network 都是以太坊生態中重要的隱私解決方案，但它們在設計理念、功能範圍和適用場景上有顯著差異。以下從多個維度進行詳細比較：

架構設計差異：

zkMoney 採用「簡單專注」的設計理念，其智能合約相對簡單，只實現存款、提款和基本驗證功能。這種設計的優勢在於攻擊面小、易於審計、Gas 成本相對較低。然而，這也意味著 zkMoney 不支持複雜的智慧合約邏輯，用戶無法在隱私池中執行 DeFi 操作。

Aztec Network 则采用「可编程隐私」的理念，提供完整的智慧合約平台。用戶可以在 Aztec 上構建私人借貸協議、私人 DEX、私人治理系統等複雜應用。這種設計的优势在於灵活性高，可以支持各种用例；缺点是电路复杂度高、Gas 成本较高、审计难度大。

隱私保護機制比較：

zkMoney 使用「承諾-揭露」機制，用戶存款時生成一個加密承諾，提款時使用零知識證明來證明自己知道對應的秘密。這種機制可以有效隱藏交易金額和交易對象，但缺點是無法隱藏存款和提款之間的關聯（如果用戶使用同一個地址進行存款和提款，外部觀察者可以通過追踪資金流向推斷關聯）。

Aztec Network 使用更複雜的「隱藏狀態」機制，所有狀態都以加密形式存儲在 Merkle 樹中。這種機制可以實現更強的隱私保護，包括隱藏交易金額、交易對象、甚至是合約狀態。然而，這種機制的計算開銷也更大。

Gas 成本分析：

以 ETH 轉帳為例，比較兩種方案的 Gas 成本：

需要注意的是，隨著以太坊網路擁堵程度不同，實際花費的 ETH 金額會有很大差異。在網路擁堵時，較高 Gas 消耗的隱私轉帳可能比普通轉帳實際花費更多。

使用場景建議：

選擇 zkMoney 的場景：

• 簡單的 ETH 或 ERC-20 代幣隱私轉帳
• 對 Gas 成本敏感的应用
• 與現有 DeFi 協議的集成需求較少
• 對代碼審計和安全性有高要求

選擇 Aztec Network 的場景：

• 需要構建複雜的私人智慧合約
• 需要在隱私保護下進行 DeFi 操作
• 需要完整的可編程性和靈活性
• 願意接受較高的 Gas 成本換取更強的隱私保護

9.6 zkMoney 實際操作指南

以下是用戶如何使用 zkMoney 進行隱私轉帳的完整步驟：

存款操作：

用戶首先訪問 zkMoney 的 Web 介面，連接自己的以太坊錢包（如 MetaMask）。選擇要存款的代幣類型和數量，點擊「Deposit」按鈕。錢包會彈出交易確認視窗，顯示 Gas 費用。確認後，交易被發送到網路。存款成功後，用戶會看到一個「註釋」（note），這是一個加密字串，相當於存款的「密鑰」。用戶必須妥善保存這個註釋，如果遺失，將無法提取對應的資金。

提款操作：

提款時，用戶需要輸入之前獲得的註釋。系統會使用這個註釋生成零知識證明，證明用戶確實有有效的存款。用戶還需要指定接收者地址和可選的中繼者（relayer）。如果使用中繼者，用戶可以將 Gas 費用支付給中繼者，讓中繼者代替用戶支付網路費用並發送交易。這種設計特別有用於當用戶的錢包中沒有 ETH 支付 Gas 費用的情況。

隱私級別選擇：

zkMoney 提供多個「隱私級別」選項，允許用戶在隱私程度和成本之間進行權衡：

標準隱私模式使用單一的 Merkle 樹，所有存款混合在一起。外部觀察者可以知道某筆存款來自隱私池，但無法知道具體是誰存的。增強隱私模式使用多個 Merkle 樹，用戶可以選擇將存款放入不同的「桶」中，進一步增加追蹤難度。

常見問題處理：

存款後無法提款可能是以下原因：註釋輸入錯誤（仔細檢查每個字符）、存款尚未被確認（等待區塊確認）、或存款已被提走（每個註釋只能使用一次）。交易失敗的常見原因包括：Gas 費用設置過低（增加 Gas 費用重試）、節點同步問題（更換 RPC 提供者）或智能合約錯誤（聯繫 zkMoney 團隊）。

十、未來發展

9.1 技術路線圖

短期目標（2026）：

• 提高證明生成效率
• 降低 Gas 成本
• 擴展語言功能

中期目標（2027-2028）：

• 支持更多 zk-SNARK 後端
• 實現完全去中心化排序器
• 跨鏈隱私橋

長期目標（2028+）：

• 量子抵抗遷移
• 硬體加速支持
• 標準化隱私接口

9.2 生態系統發展

生態系統預測：

應用層：
├── 私人借貸協議
├── 私人 DEX
├── 私人穩定幣
├── 私人治理系統
└── 私人遊戲

基礎設施：
├── 隱私錢包
├── 隱私 API
├── 隱私區塊瀏覽器
└── 隱私分析工具

結論

Aztec Network 代表了區塊鏈隱私保護的最新技術水平。通過 zk-zk Rollup 架構和 Noir 程式語言的創新組合，Aztec 為開發者提供了構建完全私密應用的能力。雖然目前仍面臨效能和成本的挑戰，但隨著技術的持續進步，Aztec 有望成為以太坊生態隱私保護的標準解決方案。

開發者在使用 Aztec 時應注意：

1. 深入理解密碼學假設
2. 遵循安全編碼最佳實踐
3. 進行專業的安全審計
4. 持續關注技術更新

參考資源

1. Aztec Network Official Documentation
2. Noir Language Specification
3. PLONK Paper
4. Bulletproofs Paper
5. Aztec Network GitHub Repository