Noir 隱私合約開發完整指南：從零知識證明到實際應用

概述

Noir 是由 Aztec Labs 開發的開源程式語言，專為編寫零知識證明（Zero-Knowledge Proof）電路而設計。作為以太坊隱私 Layer 2 解決方案 Aztec Network 的核心組成部分，Noir 提供了一種抽象化的方式，讓開發者能夠以傳統程式設計的思維編寫隱私保護應用，而無需深入理解複雜的密碼學底層實現。本文將全面介紹 Noir 的語言特性、开发環境、實際應用場景，以及如何構建一個完整的隱私合約應用。

一、零知識證明基礎理論

1.1 什麼是零知識證明

零知識證明是一種密碼學協議，允許一方（證明者）向另一方（驗證者）證明某個陳述是正確的，同時不透露任何除了陳述正確性之外的信息。這個概念最早由 Goldwasser、Micali 和 Rackoff 在 1985 年提出，其核心思想可以通過一個經典的「洞穴寓言」來說明：假設有一個環形洞穴，入口處有一扇魔法門，知道秘密口令的人可以從 A 通道進入並從 B 通道出來。 Peggy 想向 Victor 證明她知道這個秘密，但不透露秘密本身。她可以隨機選擇從 A 或 B 進入洞穴，如果她選擇從 A 進入並能從 B 出來，就證明她知道秘密，而 Victor 永遠不會知道秘密是什麼。

在區塊鏈語境中，零知識證明的價值更加突出。傳統區塊鏈要求所有交易數據公開可驗證，這與用戶隱私需求存在根本矛盾。零知識證明允許驗證交易有效性的同時，隱藏具體的交易金額、交易對手方餘額等敏感信息。這種技術使得區塊鏈可以在保持去中心化特性的同時，實現類似傳統金融系統的隱私保護水平。

1.2 zk-SNARKs 與 zk-STARKs 的比較

當前主流的零知識證明系統主要分為兩大類：zk-SNARKs（Zero-Knowledge Succinct Non-Interactive Arguments of Knowledge）和 zk-STARKs（Zero-Knowledge Scalable Transparent Arguments of Knowledge）。兩者在設計理念、性能特性和應用場景上存在顯著差異。

zk-SNARKs 的核心特點包括：首先，證明體積極小，通常只有幾百字節，這使得區塊鏈存儲和傳輸成本極低；其次，驗證速度極快，複雜陳述的驗證可在毫秒級完成；第三，需要可信設置（Trusted Setup）階段，生成初始公共參數，這些參數如果被泄露可能影響系統安全性；第四，基於橢圓曲線密碼學，假設離散對數問題的困難性。經典的 zk-SNARK 實現包括 Groth16、PLONK 和 Halo2 等，這些演算法在證明大小和驗證效率上有不同的權衡。

zk-STARKs 的核心特點包括：首先，不需要可信設置，解決了「信任初始化」的問題；其次，抵抗量子計算攻擊，基於哈希函數的假設；第三，證明體積較大，通常是 zk-SNARK 的數倍到數十倍；第四，計算成本較高，生成證明需要更多時間和計算資源。StarkWare 開發的 STARK 技術是這一類型的代表，廣泛應用於 StarkNet 等 Layer 2 解決方案。

Noir 語言的一個重要優勢是抽象了底層證明系統的差異。開發者使用 Noir 編寫的電路可以選擇編譯到不同的證明系統（目前主要支持 PLONK 和 UltraPLONK），無需重寫業務邏輯。這種設計使得應用可以在不同證明系統之間遷移，根據實際需求選擇最優的性能或安全特性。

1.3 約束系統與電路設計

零知識證明電路的核心是「約束系統」（Constraint System）。在傳統程式中，變數可以自由賦值和修改；而在零知識證明電路中，所有變數的關係必須通過數學約束來定義。這些約束確保了證明的正確性：如果所有約束都滿足，則證明者確實知道滿足陳述的 witness 值。

約束系統的基本類型包括：等式約束（a = b）、範圍約束（0 ≤ a < 2^n）、邏輯約束（if a then b else c）和多項式約束（a² + b² = c²）。複雜的證明陳述通常需要組合多種類型的約束。 Noir 語言提供了 высокоуровневый 的語法來表達這些約束，編譯器會自動生成對應的約束系統。

電路設計的一個核心概念是「R1CS」（Rank-1 Constraint System）。在 R1CS 中，每個約束都是三個向量（a, b, c）的點積形式：a · w * b · w = c · w，其中 w 是所有變數組成的向量。這種表示方式使得約束系統可以被有效驗證和優化。Noir 的編譯器會將高層語言語句轉換為 R1CS 約束，這個過程對開發者是透明的。

二、Noir 語言核心特性

2.1 語法結構與資料類型

Noir 語言的語法設計借鑒了 Rust 的許多特性，強調記憶體安全性和表達能力。與 Solidity 不同，Noir 不是一種圖靈完整的語言，這是刻意的設計選擇：非圖靈完整性使得靜態分析更簡單，也更容易實現確定的執行行為。

基本資料類型包括：Field 類型（有限域元素，是 Noir 的核心算術類型）、整數類型（u8, u16, u32, u64, i8, i16, i32, i64）、布爾類型（bool）、位元組陣列（u8[]）和字串類型。Field 類型特別重要，因為所有零知識證明運算都基於有限域，Noir 中的大多數算術運算都直接作用於 Field 類型。

陣列和結構體是 Noir 中的複合類型。陣列需要編譯時已知的大小，這與 Rust 的陣列類似。結構體可以組合多個不同類型的欄位，適合表示複雜的業務數據。值得注意的是，Noir 不支持動態分配的資料結構，這是為了確保電路的確定性和可驗證性。

// Noir 語法示例

// 定義一個簡單的結構體
struct Point {
    x: Field,
    y: Field,
}

// 定義一個需要驗證的函數
fn verify_point_on_curve(p: Point) -> bool {
    // 使用約束表達橢圓曲線方程 y^2 = x^3 + ax + b
    // 在 Noir 中，這會轉換為 R1CS 約束
    let x_squared = p.x * p.x;
    let x_cubed = x_squared * p.x;
    let y_squared = p.y * p.y;

    // 橢圓曲線方程：y^2 = x^3 + 7 (比特幣曲線)
    y_squared == x_cubed + 7
}

// 使用範圍約束
fn verify_age(age: u8) {
    // 確保 age 在有效範圍內
    constrain age >= 18;
    constrain age <= 120;
}

2.2 函數與約束定義

Noir 中的函數是組織電路邏輯的基本單元。與傳統程式語言不同，Noir 函數的執行會生成約束，而不是直接產生輸出。這種「驗證式編程」的範式要求開發者從「如何計算」轉變為「如何證明計算正確」。

函數參數分為兩類：公開輸入（pub）和私有輸入。公開輸入在證明生成和驗證時都是可見的，用於傳遞需要在區塊鏈上驗證的數據；私有輸入僅在證明生成時使用，驗證者只知道約束滿足，而無法推導出具體值。這種區分是實現選擇性披露的關鍵。

// 函數示例：驗證秘密值大於閾值
fn verify_threshold(secret: Field, threshold: Field, pub hash: Field) -> Field {
    // 約束：secret > threshold
    // 這轉換為：secret - threshold - 1 >= 0
    // 使用 Field 的性質：a > b 等價於 a - b - 1 是某個平方的標誌
    let difference = secret - threshold - 1;

    // 這個約束確保 difference 是非負的
    // 但我們不能直接寫 "difference >= 0"
    // 需要使用 Noir 提供的範圍約束語法

    // 更簡潔的方式：使用標準庫函數
    assert(secret > threshold);

    // 假設 hash 是秘密值的承諾
    // 我們驗證秘密值確實對應這個承諾
    // 這是一個「零知識」約束：驗證正確但不透露 secret
    // (這裡使用簡化的承諾方案)
    let computed_hash = std::hash::pedersen([secret]);
    assert(computed_hash[0] == hash);

    // 返回某個值作為標識（可選）
    secret
}

2.3 標準庫與常用功能

Noir 標準庫提供了豐富的密碼學和數學函數，這些函數都經過優化，可以高效地轉換為約束系統。關鍵模組包括：

密碼學函數模組提供了常用的密碼學原語。Pedersen 承諾（Pedersen Commitment）允許對某個值創建承諾，既可以隱藏原值，又可以在後續驗證原值；Poseidon 哈希是一種 ZK 友好的哈希函數，專為零知識證明電路優化；Sha256 和 Blake2s 等標準哈希函數也可用於需要与传统加密系統兼容的場景。

// 使用標準庫進行密碼學操作

// Pedersen 承諾示例
fn create_commitment(secret: Field, blinding: Field) -> Field {
    // Pedersen 承諾：C = g^secret * h^blinding
    // 在 Noir 中，這是一個內置函數
    std::hash::pedersen([secret, blinding])[0]
}

// 驗證範圍證明
fn verify_range(secret: u32, pub lower: u32, pub upper: u32) {
    // 確保 secret 在 [lower, upper] 範圍內
    assert(secret >= lower);
    assert(secret <= upper);
}

// 使用位元運算
fn verify_bits(value: u8, expected_parity: bool) {
    // 計算位元總和的奇偶性
    let mut bit_sum = 0u8;
    for i in 0..8 {
        bit_sum += (value >> i) & 1;
    }

    // 約束：奇偶性必須匹配
    assert(bit_sum % 2 == if expected_parity { 1 } else { 0 });
}

數學函數模組提供了基本的算術運算和比較操作。值得注意的是，Noir 中的比較操作（如 >, <, ==）實際上會生成約束，而非簡單的布爾比較。這是因為在零知識證明語境中，「比較」的結果必須是可驗證的。

三、開發環境設置

3.1 安裝與配置

Noir 的開發環境配置相對簡單，主要依賴 Rust 工具鏈。首先需要確保系統中已安裝 Rust 和 Cargo，然後通過 cargo 安裝 noir-lang 工具集。完整的安裝步驟如下：首先運行 cargo install --locked noir-lang 來安裝 nargo（Noir 的編譯器和工具鏈管理器）；然後通過 nargo --version 驗證安裝是否成功。

專案初始化使用 nargo new 命令，這會創建標准的專案結構，包括 src 目錄（存放 Noir 源代碼）和 Nargo.toml（專案配置檔）。對於需要與以太坊交互的應用，還需要設置 Solidity 智能合約來處理證明驗證和資產管理。

VS Code 提供了 Noir 語言的擴展插件，安裝後可以獲得語法高亮、錯誤提示和自動完成等功能。這個擴展會讀取 Nargo.toml 中的配置，為大型專案提供準確的類型推斷和代碼導航。

3.2 專案結構與配置

典型的 Noir 專案結構如下：

my_noir_project/
├── Nargo.toml           # 專案配置
├── src/
│   ├── main.nr          # 入口點
│   ├── lib.nr          # 庫模組
│   └── circuits/        # 電路定義
│       ├── main.nr
│       └── foo.nr
└── contracts/          # 可選：Solidity 驗證合約
    └── Verifier.sol

Nargo.toml 配置檔包含編譯器選項、依賴項和構建目標。關鍵配置項包括：合約目標（生成 Solidity 驗證合約）和 proving-backend（選擇使用的證明系統）。

[package]
name = "my-privacy-app"
version = "0.1.0"
edition = "0.1"

[dependencies]
# 添加依賴（如果有）
# noir_stdlib = { tag = "v0.1", git = "https://github.com/noir-lang/noir_stdlib" }

[contract]
# 生成 Solidity 驗證合約
name = "TurboVerifier"

3.3 編譯與測試流程

Noir 專案的開發流程包括：編譯（nargo check 或 nargo build）用於檢查代碼語法和類型錯誤；執行（nargo execute）用於在本地執行電路邏輯（用於調試但不生成證明）；證明生成（nargo prove）用於生成零知識證明；驗證（nargo verify）用於驗證證明的正確性。

# 編譯檢查
nargo check

# 執行（調試用）
nargo execute main

# 生成證明
nargo prove -n my_proof

# 驗證證明
nargo verify -n my_proof

# 生成 Solidity 驗證合約
nargo contract

調試 Noir 電路的一個重要技巧是使用「未知數」（witness）打印。通過在關鍵點輸出變數值，可以追蹤電路的執行流程。這些輸出不會出現在最終的約束中，因此對證明大小沒有影響。

四、實際應用開發

4.1 隱私投票系統

讓我們通過一個完整的例子來展示 Noir 的實際應用：構建一個隱私投票系統。在這個系統中，選民可以投票而不暴露自己的選擇，只有最終的計票結果是公開的。

// 隱私投票電路

// 投票選項數量
const NUM_OPTIONS = 3;

// 投票記錄結構
struct Vote {
    // 選民創建的承諾
    commitment: Field,
    // 投票選項（私有）
    choice: u8,
    // 隨機數（用於承諾）
    randomness: Field,
}

// 驗證投票正確性
fn verify_vote(
    vote: Vote,
    // 公開輸入
    pub vote_hash: Field,
    pub nullifier_hash: Field,
    pub merkle_root: Field,
    // 私有輸入
    secret: Field,
) {
    // 1. 驗證投票承諾
    // commitment = hash(choice, randomness)
    let computed_commitment = std::hash::pedersen([vote.choice as Field, vote.randomness]);
    assert(computed_commitment[0] == vote.commitment);

    // 2. 驗證選擇在有效範圍內
    assert(vote.choice < NUM_OPTIONS);

    // 3. 驗證投票者身份（使用 Nullifier）
    // nullifier = hash(secret, voting_round)
    let computed_nullifier = std::hash::pedersen([secret]);
    assert(computed_nullifier[0] == nullifier_hash);

    // 注意：我們不驗證 Merkle 證明
    // 在實際應用中，需要提供從葉節點到根的路徑
    // 這需要更複雜的電路邏輯
}

// 計票電路
struct TallyResult {
    pub results: [u32; NUM_OPTIONS],
}

fn tally_votes(
    // 所有投票的加密值
    encrypted_votes: [Field; 10],
    // 投票選項的隨機因子（用於解密）
    randomness: [Field; NUM_OPTIONS],
    // 公開：每個選項的「最終計數」
    pub claimed_results: [u32; NUM_OPTIONS],
) -> TallyResult {
    // 這是一個簡化的版本
    // 實際應用中需要使用更複雜的加密方案，如同態加密

    let mut counts = [0; NUM_OPTIONS];

    // 假設每個加密值對應一個投票選項
    // 在實際應用中，這需要同態加法
    for i in 0..10 {
        // 這裡是簡化的邏輯
        // 實際上需要對加密值進行解密和計數
        // 由於篇幅限制，這裡僅提供概念框架
    }

    // 驗證結果正確性
    for i in 0..NUM_OPTIONS {
        assert(counts[i] == claimed_results[i]);
    }

    TallyResult { results: counts }
}

4.2 範圍證明與餘額驗證

範圍證明是零知識證明最常見的應用之一，用於證明某個值在特定範圍內，同時不透露具體值。這在金融應用中特別重要，例如證明資產淨值高於某個閾值而不暴露實際餘額。

// 範圍證明實現

// 使用位元分解進行範圍證明
fn prove_range(secret: Field, bits: u32) -> [u1; 100] {
    // 將 secret 分解為二進制位
    // 這生成 bits 個約束，每個約束驗證一個位

    let mut bits_out = [0u1; 100];
    let mut power_of_2 = 1Field;

    for i in 0..100 {
        // 提取第 i 位
        let bit = (secret / power_of_2) as u1 & 1u1;

        // 約束：bit 是二進制的（0 或 1）
        assert(bit * (1u1 - bit) == 0u1);

        bits_out[i] = bit;

        power_of_2 = power_of_2 * 2;
    }

    bits_out
}

// 餘額範圍證明
struct BalanceProof {
    pub commitment: Field,
    pub range_proof: [u1; 256],
}

fn prove_balance_above_threshold(
    secret_balance: Field,
    threshold: Field,
    randomness: Field,
) -> BalanceProof {
    // 驗證餘額 >= 閾值
    // 等價於：secret_balance - threshold >= 0

    // 計算差值
    let difference = secret_balance - threshold;

    // 對差值進行範圍證明
    // 如果 difference >= 0，則它可以表示為 256 個二進制位的和
    // 我們需要確保差值是非負的，這通過範圍證明實現

    // 分解差值為位元
    let bits = prove_range(difference, 256);

    // 計算承諾
    let commitment = std::hash::pedersen([secret_balance, randomness]);

    BalanceProof {
        commitment: commitment[0],
        range_proof: bits,
    }
}

4.3 與以太坊智能合約整合

Noir 電路編譯後可以生成 Solidity 驗證合約，部署到以太坊區塊鏈上。這個驗證合約接收零知識證明作為輸入，並在鏈上執行驗證邏輯。

// 自動生成的驗證合約示例（Simplified）

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

import "./interfaces/IVerifier.sol";

contract TurboVerifier is IVerifier {
    // 驗證函數
    // proof: 零知識證明
    // public_inputs: 公開輸入（作為數組傳遞）
    function verifyProof(
        bytes memory proof,
        uint256[] memory public_inputs
    ) public view returns (bool) {
        // 調用底層驗證邏輯
        // 這通常是一個 Pedersen 哈希驗證 + Groth16/PLONK 驗證
        // 由於計算密集，通常需要預編譯合約或使用條紋

        // 這裡是簡化的邏輯框架
        return _verify(proof, public_inputs);
    }

    // 內部驗證邏輯（實際由 Noir 編譯器生成）
    function _verify(
        bytes memory proof,
        uint256[] memory public_inputs
    ) internal view returns (bool) {
        // 實現細節取決於使用的證明系統
        // 通常涉及：
        // 1. 解析證明字節
        // 2. 驗證配對（pairing）
        // 3. 驗證 public_inputs 匹配

        // 返回驗證結果
        return true;
    }
}

// 前端調用示例（JavaScript/Ethers.js）
async function submitProof() {
    // 1. 在客戶端生成證明
    const { proof, publicInputs } = await noirprove({
        // Noir 電路輸入
        secret: "12345",
        threshold: "10000",
    });

    // 2. 將證明和公開輸入發送到智能合約
    const tx = await verifierContract.verifyProof(
        proof,
        publicInputs
    );

    await tx.wait();
}

五、進階主題

5.1 電路優化技術

優化 Noir 電路是提升性能和降低成本的關鍵。常見的優化技術包括：

約束數量最小化是最重要的優化方向。每個約束都會增加證明生成時間和驗證成本。優化策略包括：合併相似的約束條件、使用查找表（Lookup Tables）避免重複計算、選擇合適的資料類型（例如使用 u8 而非 Field 進行位元操作）。

// 優化示例：合併約束

// 未優化版本
fn unoptimized(x: Field, y: Field) {
    let a = x * x;
    let b = y * y;
    let c = x * y;

    // 三個獨立的乘法約束
    constrain a == x * x;
    constrain b == y * y;
    constrain c == x * y;
}

// 優化版本：減少乘法數量
fn optimized(x: Field, y: Field) {
    // 使用恆等式：(x + y)^2 = x^2 + 2xy + y^2
    // 我們可以通過計算 (x + y)^2 和 (x - y)^2
    // 來推導出所需的值

    let sum = x + y;
    let diff = x - y;

    let sum_sq = sum * sum;
    let diff_sq = diff * diff;

    // x^2 = (sum^2 + diff^2) / 2
    let x_sq = (sum_sq + diff_sq) / 2;

    // y^2 = (sum^2 - diff^2) / 2
    let y_sq = (sum_sq - diff_sq) / 2;

    // xy = (sum^2 - diff^2) / 4
    // 通過避免直接乘法來節省約束
}

5.2 遞歸證明

遞歸證明允許將多個證明組合成單一證明，這對於分片驗證、跨鏈橋接和批量處理特別有用。Noir 支持使用「遞歸約束」實現這一功能。

// 遞歸證明框架

// 內部電路
fn inner_circuit(input: Field) -> Field {
    // 某個計算
    input * input + 5
}

// 外部電路驗證內部電路的證明
fn outer_circuit(
    // 內部電路的公開輸出
    pub inner_output: Field,
    // 內部電路的證明（壓縮形式）
    inner_proof_hash: Field,
) {
    // 驗證 inner_proof_hash 確實是內部電路輸出的承諾
    // 這創建了一個「證明的證明」

    let computed = inner_circuit(inner_output);
    assert(computed == inner_output);

    // 我們可以使用內部證明作為條件約束
    // 這實現了「如果內部證明有效，則執行外部邏輯」
}

5.3 預編譯合約與性能優化

在以太坊上驗證零知識證明的成本較高，因為 EVM 不原生支持相關的密碼學操作。解決方案包括：使用預編譯合約（如 EIP-196 和 EIP-197 提供的橢圓曲線運算）、使用條紋化驗證（將驗證計算外包給專業服務器）、硬體加速（使用 GPU 或 ASIC）。

Noir 編譯器生成的 Solidity 驗證合約可以選擇不同的優化級別。-O1 優化會減少約束數量但增加合約大小；-O2 優化會平衡約束數量和大小的權衡。

六、安全考量與最佳實踐

6.1 常見安全陷阱

開發零知識證明應用時，開發者需要注意幾類常見的安全問題。首先是「約束不足」問題：如果約束不夠嚴格，攻擊者可能構造滿足約束但不正確的 witness。這通常發生在範圍證明不完整或缺少必要的一致性檢查時。

// 不安全的實現示例
fn unsafe_compare(a: Field, b: Field) -> bool {
    // 這個實現只檢查 a == b
    // 沒有處理 a > b 或 a < b 的情況
    a == b
}

// 安全的實現
fn safe_compare(a: Field, b: Field) -> u8 {
    // 返回 1 if a > b, 0 if a == b, 2 if a < b
    // 這需要完整的範圍證明

    let diff = a - b;

    // 使用條件邏輯
    if diff == 0 {
        0
    } else if diff > 0 {
        1
    } else {
        2
    }
}

6.2 審計與驗證

由於零知識證明電路的複雜性，專業的安全審計是必要的。審計的重點包括：約束系統的完整性驗證、隨機數生成的安全性、輸入驗證的嚴格性，以及與外部系統交互的安全性。

形式化驗證工具可以自動分析電路的正確性。Noir 社區正在開發基於 Coq 和 Lean 的形式化驗證框架，這將為關鍵應用提供數學級別的安全性保證。

6.3 開發最佳實踐

以下是在生產環境中使用 Noir 的最佳實踐：

模組化設計是關鍵。將複雜電路分解為較小的、可獨立測試的模組。這不僅便於調試，也使得約束優化更加精確。每個模組應該有清晰的接口定義，包括輸入輸出類型和預期行為。

測試驅動開發適用於 Noir 開發。使用 nargo execute 在生成證明之前調試電路邏輯。這種方法的優點是迭代速度快，可以快速定位邏輯錯誤。

版本控制和升級策略也很重要。Noir 語言仍在快速發展中，語法和標準庫可能會有破壞性變更。建議使用明確的版本依賴，並為重大升級預留測試時間。

七、未來發展方向

7.1 Noir 語言演進

Noir 語言正在多個方向持續演進。語法糖的增加將使代碼更加簡潔，例如更自然的數組操作和結構體模式匹配。性能優化方面，編譯器正在改進約束生成算法，預計可以實現 20-30% 的性能提升。

新的標準庫功能也在規劃中，包括：更豐富的密碼學原語（支持更多簽名方案和加密算法）、硬體加速接口（支持 GPU 和 FPGA 加速）、以及與外部數據源的安全集成。

7.2 與 Aztech Network 的整合

作為 Aztec Network 的官方語言，Noir 與隱私 Layer 2 的整合將更加緊密。未來版本將支持直接部署到 Aztec 網路，自動處理隱私交易的複雜邏輯。這將大大簡化隱私應用的開發流程。

Aztec 的「私立」概念（Private State）將通過 Noir 更好地表達。開發者可以定義哪些狀態是私有的，哪些是公開的，編譯器會自動處理正確的加密和驗證邏輯。

7.3 生態系統展望

Noir 生態系統正在快速成長。多個主流 DeFi 協議正在探索基於 Noir 的隱私解決方案，包括：隱私借貸（借款而不暴露餘額）、隱私拍賣（出價而不暴露金額）、以及隱私治理投票（投票而不暴露選擇）。

基礎設施方面錢包支持、區塊鏈瀏覽器和開發工具正在逐步完善。這些進步將推動 Noir 從一個專業的密碼學工具轉變為主流的應用開發語言。

結論

Noir 代表了零知識證明技術民主化的重要一步。通過提供 высокоуровневый 的程式設計抽象，Noir 使得開發者可以專注於應用邏輯而非密碼學實現細節。本文介紹了 Noir 的核心概念、開發環境、實際應用案例和安全考量，這些知識為讀者提供了構建隱私保護區塊鏈應用的堅實基礎。

隨著區塊鏈隱私需求的增長和零知識證明技術的成熟，Noir 有望成為 Web3 開發者的必備技能。建議讀者從簡單的電路開始，逐步掌握語言特性，最終構建功能完整的隱私應用。

參考資料

1. Noir 官方文檔。 https://noir-lang.org
2. Aztec Network 白皮書。 https://aztec.network
3. Zero Knowledge Proofs 理論基礎。 https://zkp.science
4. PLONK 論文。 https://eprint.iacr.org/2019/953
5. Noir 標準庫源碼。 https://github.com/noir-lang/noir_stdlib
6. 零知識證明在區塊鏈中的應用案例。 https://learn.0xparc.org