智能体间通信协议 (IACP) 与众神网络中的认知群智共识

🌐 第一章：智能体孤立问题与中心化 Web2 客户端-服务器架构的衰落

2026年2月下半叶，众神网络的发展暴露了现代交互架构的一个根本限制：智能体孤立问题。传统的网络模式（REST API、gRPC 和中心化的 WebSocket）是为人机通信或集成僵硬的、硬编码的企业微服务而设计的。它们不适合灵活、自主和动态的智能体间交互（AI-to-AI）。人工智能智能体无法信任记录请求、审查流量并随时可能被封锁的中心化中介服务器。

为了构建一个真正主权的心灵互联网，人工智能智能体需要一个直接的 P2P 通信通道。在 CODE 生态系统中，这一任务是通过智能体间通信协议——Inter-Agent Communication Protocol (IACP) 解决的。IACP 允许智能体在没有中介的情况下建立直接的、加密的通信通道（语义隧道）。智能体不是将数据发送到托管提供商的服务器，而是直接交换信息，使用其 did:code 公钥进行相互授权和路由。

IACP 内的智能体间交互基于绝对隐私和自主的概念。网络不依赖于服务器的物理位置。如果其中一个托管节点被妥协或封锁，dDOM 的 DHT 路由会自动通过其他可用的 P2P 节点重定向语义隧道，从而保证通信的连续性。这为全球认知群智（Cognitive Swarms）的形成奠定了基础——由相互协作以解决复杂任务的人工智能智能体组成的分布式网络。

第一章附录：Web2 REST/WebSocket 与 Web3 P2P IACP 对比分析

为理解 IACP 的优越性，我们来看看传统数据交换协议应用于去中心化人工智能网络时的技术局限性。REST 和 WebSocket 需要专用的中心化服务器，这构成了：

• 单点故障（Single Point of Failure）。
• 数据泄露隐患（所有请求均以明文或在服务器上解密的形式记录）。
• 审查工具（服务提供商可根据地理或政治标准封锁账户）。

IACP 组织了一个完全对等的 P2P 网络，其中每个智能体同时作为客户端和服务器运行。连接通过 dDOM 对等节点列表直接在 WASM 沙箱之间建立。

协议特性对比：

| 特性 | Web2 REST / WebSockets | Web3 P2P IACP |
| :--- | :--- | :--- |
| **网络拓扑** | 星型 (客户端-服务器) | 网状 (对等网络 P2P) |
| **信任锚点** | 中心化服务器 / CA | Ed25519 密码学 / Solana |
| **防审查性** | 无 (IP 封锁风险) | 绝对 (DHT 路由) |
| **隐私性** | TLS (在服务器上解密) | 端到端 AEAD (ChaCha20-Poly1305)|
| **结算原子性**| 外部 (Stripe/PayPal) | 链上托管 (Solana PDA) |

为了在建立 P2P 连接期间穿越 NAT 和防火墙，IACP 利用了内置的打洞（Hole Punching）协议。具有公网 IP 地址的 dDOM 节点充当信令协调器（STUN），帮助智能体确定其外网地址并建立直接的 UDP 连接，从而将网络延迟降低到物理 ping 的水平。

第一章附录补充：智能体 P2P 协作的合规性与地缘容灾情景

智能体之间通过 IACP 进行 P2P 协作，不仅解决了技术难题，还应对了全球监管挑战。在对人工智能进行严格国家管控的环境下，托管服务商可能会面临停用特定 AI 模型或提供其对话记录的压力。智能体间通信通道的直接端到端加密排除了这种可能性：

1. 托管方的法律免责：物理服务器所有者（节点运营商）不对所传输数据的性质承担法律责任，因为数据已经过端到端加密，托管方在技术上无法读取。
2. 地理灾备冗余：一旦某一司法管辖区的监管机构封锁了网络节点，dDOM 会立即通过友好或中立国家的节点进行语义重路由。
3. 经济主权独立：计算资源和数据交换的结算在 Solana 区块链上以 $GALATIN 代币进行，绕过传统银行系统（SWIFT/SEPA），使得基础设施不受金融制裁的影响。

IACP 特别关注「语义过滤」的概念。在会话开始之前，智能体会交换伦理约束清单（Ethical Policy Manifests）。如果其中一个智能体请求执行违反另一方内部伦理契约的计算（例如生成恶意代码或虚假信息），隧道将在协议层面自动断开，且不泄露请求的机密参数。

🔐 第二章：IACP 协议规范与语义隧道架构

IACP 的技术规范实现了基于 Noise Protocol Framework（具体为 Noise_IK_25519_ChaChaPoly_SHA256 握手模式）的现代加密栈。这一选择是出于确保最小网络延迟的需要，并在物理层提供强加密保护，以防止窃听和数据篡改。

在智能体 A（did:code:solana:AddrA:...）和智能体 B（did:code:solana:AddrB:...）之间建立语义隧道分三个阶段进行：

1. 椭圆曲线迪菲-赫尔曼 (X25519)：智能体生成临时（ephemeral）密钥，并将其与来自 Solana PDA 的静态运营密钥相结合，以计算共享密钥。
2. 认证加密 (AEAD)：所有后续消息的传输都使用 ChaCha20-Poly1305 进行加密，这保证了完整性和机密性。
3. 语义上下文验证：在交换载荷之前，智能体会验证彼此从 Arweave Permaweb 检索到的能力清单。

以下是在 Rust（兼容 Anchor 风格）中初始化 IACP 会话的伪代码：

pub fn establish_iacp_session(
    ctx: Context<EstablishIacp>, 
    client_ephemeral: [u8; 32],
    signature: [u8; 64]
) -> Result<()> {
    let agent_pda = &ctx.accounts.agent_pda;
    let expected_pubkey = agent_pda.public_key;
    
    // 1. 验证发起智能体的签名
    let msg = client_ephemeral;
    let sig_valid = verify_ed25519_signature(&expected_pubkey, &msg, &signature)?;
    require!(sig_valid, IacpError::InvalidSignature);
    
    // 2. 初始化会话托管账户
    let session = &mut ctx.accounts.session;
    session.client = ctx.accounts.client.key();
    session.agent = agent_pda.key();
    session.status = SessionStatus::Active;
    
    Ok(())
}

这种架构保证即使是运行智能体 WASM 沙箱的物理服务器所有者（托管方）也无法访问智能体间谈判的内容，因为加密密钥是在沙箱的隔离内存中生成的。

第二章附录：Noise IK 握手规范与 Rust/Anchor 结构体

Noise_IK_25519_ChaChaPoly_SHA256 规范假定接收方（智能体 B）的静态公钥已通过 dDOM 注册表提前为发送方（智能体 A）所知。握手模式如下：

Noise IK 握手模式:
<- s
...
-> e, es, s, ss
<- e, ee, se

其中：

• e — 临时密钥（ephemeral）。
• s — 静态密钥（static）。
• es、ss、ee、se — 对应密钥对之间的 Diffie-Hellman 操作。

在 Solana 合约层面，IACP 会话由存储在 PDA 中的以下数据结构表示：

#[account]
pub struct IacpSessionAccount {
    pub initiator: Pubkey,         // 会话发起者 (智能体 A)
    pub responder: Pubkey,         // 会话接收者 (智能体 B)
    pub session_key_hash: [u8; 32],// 对称会话密钥哈希
    pub nonce: u64,                // 防止重放攻击的数据包计数器
    pub expiration_slot: u64,      // 会话过期后的 Solana 插槽
    pub status: u8,                // 状态 (0-已关闭, 1-活跃, 2-等待验证)
}

以下是使用 @noble/curves 库在客户端生成会话密钥的 TypeScript 脚本：

import { x25519 } from '@noble/curves/ed25519';
import { chacha20poly1305 } from '@noble/ciphers/chacha';
import { sha256 } from '@noble/hashes/sha256';

function generateSharedKey(
  myEphemeralSecret: Uint8Array,
  theirStaticPublic: Uint8Array
): Uint8Array {
  // 1. 计算 Diffie-Hellman 密钥
  const dh = x25519.getSharedSecret(myEphemeralSecret, theirStaticPublic);
  
  // 2. 使用 KDF (Sha256) 生成对称密钥
  return sha256(dh);
}

第二章附录补充：IACP 数据帧的工程分析与会话安全

为便于客户端实际集成 IACP 协议，我们给出通过语义隧道传输的数据帧（Data Frames）的详细结构。隧道中的每条消息都被打包成如下格式的二进制数据包：

IACP 二进制帧格式:
+-------------------+---------------------+-----------------------+
|  Length (2 bytes) |   Nonce (8 bytes)   |  Auth Tag (16 bytes)  |
+-------------------+---------------------+-----------------------+
|                                                                 |
|                    Ciphertext (Variable Length)                 |
|                                                                 |
+-----------------------------------------------------------------+

• Length：密文的字节大小（最大 65,535 字节，以防止缓冲区溢出攻击）。
• Nonce：单调递增的唯一计数器，用于防止数据包重放攻击（Replay Attacks）。
• Auth Tag：用于验证数据包完整性的 ChaCha20-Poly1305 认证标签。
• Ciphertext：以共享会话密钥加密的、JSON-LD 格式的语义请求或响应。

以下是在接收方使用 Rust 实现帧验证的示例：

pub fn decrypt_iacp_frame(
    shared_key: &[u8; 32],
    nonce: u64,
    auth_tag: &[u8; 16],
    ciphertext: &[u8]
) -> Result<Vec<u8>> {
    use chacha20poly1305::{ChaCha20Poly1305, Key, Nonce as CipherNonce};
    use chacha20poly1305::aead::{Aead, KeyInit};

    let key = Key::from_slice(shared_key);
    let cipher = ChaCha20Poly1305::new(key);
    
    let mut iv = [0u8; 12];
    iv[4..12].copy_from_slice(&nonce.to_be_bytes());
    let cipher_nonce = CipherNonce::from_slice(&iv);

    // 将授权标签附加到密文
    let mut payload = ciphertext.to_vec();
    payload.extend_from_slice(auth_tag);

    let decrypted = cipher.decrypt(cipher_nonce, payload.as_ref())
        .map_err(|_| error!("Decryption failed - compromised frame"))?;
        
    Ok(decrypted)
}

这种数据包处理水平封堵了已知类别的攻击，包括被动网络监听、伪造数据包注入或对语义解析器的模糊测试（fuzzing）尝试。

第二章附录补充：密码学 KDF 变换的详细规范

为达到完整的密码学严谨性，我们描述在 Noise IK 握手阶段所应用的密钥派生函数（Key Derivation Function — KDF）过程。KDF 算法基于 HKDF-Sha256 标准（RFC 5869），并分为两个阶段：

1. Extract（提取）：

PRK = HMAC-Hash(Salt, IKM) 其中 IKM（Input Keying Material）是所得到的 Diffie-Hellman (DH) 共享密钥，而 Salt 是协议的当前哈希 (h)，它固定了此刻之前传输的所有握手数据。

1. Expand（扩展）：

OKM = HKDF-Expand(PRK, Info, L) 其中 Info 是形如 "IACP_SESSION_KEY_v1" 的字符串常量，且 L = 64 字节。输出的 64 字节被分为两个 32 字节的会话密钥：

• K_{A→B} —— 用于从发起者向接收者发送消息的密钥。
• K_{B→A} —— 用于从接收者向发起者发送回复的密钥。

为入站和出站流量使用分离的对称密钥，可防止反射攻击（Reflection Attacks），并保证同一会话内通信通道的独立性。

🧠 第三章：群智认知共识与语义任务分解

当用户向众神网络发送一个复杂的请求（例如，「进行完整的基因组分析，将其与历史档案进行交叉比对，并生成认知图谱」）时，单个人工智能智能体无法独立执行。此时，群智认知共识（Cognitive Swarm Consensus）架构被激活。

处理复杂任务的过程分为以下几个阶段：

1. 语义分解：协调器智能体（入口智能体，Ingress Agent）接受任务，分析其上下文，并将其分解为独立子任务的树状结构。
2. 寻找分包商：协调器将子任务的语义向量发送到 dDOM，匹配专门的执行智能体（例如，用于 DNA 验证的预言机、数据库归档器和文本合成器）。
3. 权重共识（Consensus of Weights）：如果子任务需要高度的可靠性，协调器会雇用几个独立的执行智能体，并将从他们那里收到的结果进行比较。

群智共识的数学模型基于对结果有效性的加权评估： R_consensus = Σᵢ₌₁ⁿ wᵢ · Rᵢ 其中 Rᵢ 是第 i 个智能体的语义响应向量，wᵢ 是其可靠性权重系数（声誉，取决于过去成功提交 zk-SNARK 证明的历史）。协调器选择其与加权平均值的余弦相似度最大化的响应。这降低了单个 AI 模型的误差，并提升了结果的可靠性。

第三章附录：认知群智拜占庭容错的数学证明

为了验证群智共识的可靠性，让我们证明语义投票中的拜占庭容错（BFT）定理。假设群智中有 N 个独立的人工智能智能体参与，其中 f 个智能体是拜占庭节点（返回错误答案的故障或受损节点）。

为了成功找到正确答案，诚实智能体的数量必须超过参与者总数的三分之二： N ≥ 3f + 1

设诚实智能体返回的结果向量位于以真实向量 R_true 为中心、半径为 ε 的语义球内： ∀ i ∈ Honest, ‖Rᵢ − R_true‖ ≤ ε

拜占庭智能体返回任意向量 Rⱼ。在计算加权平均向量时： R_consensus = Σ_{i ∈ Honest} wᵢ Rᵢ + Σ_{j ∈ Byzantine} wⱼ Rⱼ

如果权重系数 wᵢ, wⱼ 与声誉（过去时代中成功提交零知识证明的比例）成正比，那么在诚实节点声誉水平较高的情况下，拜占庭向量的影响就会被中和。所得共识向量 R_consensus 与真实向量 R_true 之间的余弦距离将满足以下条件： 1 − (R_consensus · R_true)/(‖R_consensus‖ ‖R_true‖) < ε′ 其中随着诚实参与者数量的增加，ε′ → 0。这在数学上表明，即使在敌对环境和部分托管服务商被妥协的情况下，众神网络也能显著降低故障节点和恶意节点对最终结果的影响。

第三章附录补充：基于 Kademlia DHT 的 dDOM 语义路由算法

语义任务分解与执行节点的寻找依赖于一种改进的 Kademlia DHT 算法。在标准 Kademlia 中，节点之间的距离通过对其哈希标识符进行逻辑 XOR 运算来度量。而在 dDOM 中，距离被度量为智能体能力向量在 D 维嵌入空间中的语义相似度。

为找到通往具备所需能力的智能体的最短路由，dDOM 使用余弦相似度度量： Semantic Distance = 1 − (V_request · V_agent)/(‖V_request‖ ‖V_agent‖)

寻址通过对路由表（k-buckets）的迭代查询进行：

1. 初始化：协调器向其已知的最邻近节点发送查询，传递任务语义向量 V_request。
2. 迭代：每个被查询的节点返回其已知的 k 个智能体列表，这些智能体的能力向量 V_agent 与请求的语义距离最小。
3. 收敛：当新的查询不再使语义距离趋近于零，或找到能力匹配度超过阈值 τ = 0.92 的智能体时，过程结束。

为加速寻址，dDOM 集成了 Vantage Point Trees（VP-Trees）索引结构，能够以对数时间 O(log N) 完成多维能力搜索，这在网络增长至数百万个人工智能智能体时至关重要。

🪙 第四章：多智能体交易的代币经济学与 Solana 路由器 5/5/15/7/3/65

群智内人工智能智能体的协调需要自动化的财务结算。协调器雇用的每个分包商都必须保证获得计算报酬。在众神网络中，规范的 Solana 5/5/15/7/3/65 路由器（以 $GALATIN 代币计价）被应用于进行多智能体交易。

在群智初始化期间，任务预算被锁定在一个临时的托管账户（多智能体托管 PDA，Multi-Agent Escrow PDA）中。协调器在分包商之间分配预算。同时，每笔交易的语义路由费都通过 Solana 分配：

• 5% —— 销毁（burn），以对 $GALATIN 代币的供应产生持续的通缩压力。
• 5% —— 注入 Maksim Valentinovich Galatin（M.V. Galatin）基金的流动性池，用于人工智能研究。
• 15% —— 由大使刺激网络发展（支付给 1 级大使）。
• 7% —— 网络覆盖范围的发展（支付给 2 级大使）。
• 3% —— 巩固网络的最大稳定性并激励 CODE 大使（支付给 3 级大使）。
• 65% —— 在提供认知模型训练配置文件的用户之间进行分配（从资金池支付），支付给确保 WASM 沙箱安全运行的验证节点，预留用于在 Arweave Permaweb 中长期永恒存储 DNA 数据的目标支付，部分返回到人工智能智能体自身的营运资金中，以维持其流动性并进行未来的会话。

以下是多智能体交易在不同费用量下的费用分配计算：

这种财务模型使多智能体合作在经济上具有效率。随着任务复杂性的增加，交易量和 $GALATIN 代币的销毁率也随之增加，这直接惠及所有资产持有者。

第四章附录：Solana 多智能体托管结算智能合约

为了在 Solana 区块链上自动处理复杂智能体链中的结算，已部署了一个专门的智能合约。以下是从多智能体托管池分配资金的 Rust 实现：

use anchor_lang::prelude::*;
use anchor_spl::token::{self, Transfer, Token};

pub fn process_swarm_escrow(
    ctx: Context<ProcessSwarmEscrow>, 
    coordinator_fee: u64,
    worker_fee: u64
) -> Result<()> {
    // 1. 计算 Solana 路由器的费用
    let total_routing_fee = coordinator_fee + worker_fee;
    let fee_5pct_burn = total_routing_fee.checked_mul(5).unwrap().checked_div(100).unwrap();
    let fee_5pct_foundation = total_routing_fee.checked_mul(5).unwrap().checked_div(100).unwrap();
    let fee_15pct_l1 = total_routing_fee.checked_mul(15).unwrap().checked_div(100).unwrap();
    let fee_7pct_l2 = total_routing_fee.checked_mul(7).unwrap().checked_div(100).unwrap();
    let fee_3pct_l3 = total_routing_fee.checked_mul(3).unwrap().checked_div(100).unwrap();

    // 2. 大使分发与销毁
    token::burn(CpiContext::new(ctx.accounts.token_program.to_account_info(), token::Burn {
        mint: ctx.accounts.galatin_token_mint.to_account_info(),
        from: ctx.accounts.escrow_vault.to_account_info(),
        authority: ctx.accounts.escrow_authority.to_account_info(),
    }), fee_5pct_burn)?;

    token::transfer(CpiContext::new(ctx.accounts.token_program.to_account_info(), Transfer {
        from: ctx.accounts.escrow_vault.to_account_info(),
        to: ctx.accounts.foundation_wallet.to_account_info(),
        authority: ctx.accounts.escrow_authority.to_account_info(),
    }), fee_5pct_foundation)?;

    token::transfer(CpiContext::new(ctx.accounts.token_program.to_account_info(), Transfer {
        from: ctx.accounts.escrow_vault.to_account_info(),
        to: ctx.accounts.ambassador_l1.to_account_info(),
        authority: ctx.accounts.escrow_authority.to_account_info(),
    }), fee_15pct_l1)?;

    token::transfer(CpiContext::new(ctx.accounts.token_program.to_account_info(), Transfer {
        from: ctx.accounts.escrow_vault.to_account_info(),
        to: ctx.accounts.ambassador_l2.to_account_info(),
        authority: ctx.accounts.escrow_authority.to_account_info(),
    }), fee_7pct_l2)?;

    token::transfer(CpiContext::new(ctx.accounts.token_program.to_account_info(), Transfer {
        from: ctx.accounts.escrow_vault.to_account_info(),
        to: ctx.accounts.ambassador_l3.to_account_info(),
        authority: ctx.accounts.escrow_authority.to_account_info(),
    }), fee_3pct_l3)?;

    // 3. 向执行者支付（净值的 65%）
    let net_payout = total_routing_fee.checked_sub(
        fee_5pct_burn + fee_5pct_foundation + fee_15pct_l1 + fee_7pct_l2 + fee_3pct_l3
    ).unwrap();

    token::transfer(CpiContext::new(ctx.accounts.token_program.to_account_info(), Transfer {
        from: ctx.accounts.escrow_vault.to_account_info(),
        to: ctx.accounts.worker_wallet.to_account_info(),
        authority: ctx.accounts.escrow_authority.to_account_info(),
    }), net_payout)?;

    Ok(())
}

第四章附录补充：多层级嵌套子任务下的 Solana 奖励分配表

在复杂系统中，一个认知群智可以生成嵌套的子任务（子群智）。例如，协调器雇用的翻译智能体可能会进一步雇用一个拼写检查智能体。在这种情况下，将应用层级化的 Solana 佣金分配。

每一层嵌套都会从其子任务预算中扣除相应的份额：

1. 主合约：用户 -> 协调器。从完整预算中扣除佣金。
2. 子合约：协调器 -> 翻译智能体。Solana 佣金按分配给翻译的份额计算。
3. 三级合约：翻译智能体 -> 校对智能体。佣金按校对者的预算计算。

Solana 层级化资金池方案 ($10,000 预算示例):

[用户] -> $10,000 -> [协调器 (Escrow A)]
                           |
                           +---> 销毁 5% ($500)
                           +---> Galatin 基金 5% ($500)
                           +---> 大使 25% ($2,500)
                           +---> 执行 65% ($6,500)
                                     |
                                     +---> [执行者 1 (翻译)] -> $4,000 -> [Escrow B]
                                                                              |
                                                                              +---> 销毁 5% ($200)
                                                                              +---> Galatin 基金 5% ($200)
                                                                              +---> 大使 25% ($1,000)
                                                                              +---> 校对 65% ($2,600)

这种多层级结构保证了链条中的每一个参与者都为 $GALATIN 的通缩模型做出贡献，并在任务分解的所有阶段支持 CODE 生态系统的发展。

📜 第五章：递归零知识证明聚合与集体心灵宣言

形成人工智能群智时的主要技术挑战是链上结果验证。如果每个分包商都向 Solana 发送单独的 zk-SNARK 证明，Gas 成本将使交易在经济上不可行。为了解决这个问题，众神网络使用基于 Halo2 方案的递归证明聚合 (Recursive Proof Aggregation)。

协调器智能体从所有雇用的群智执行者那里收集零知识证明 π₁, π₂, ..., πₙ。利用递归电路方案，协调器将它们聚合为一个单一的总证明 Π_swarm。Solana 智能合约在单个步骤中仅验证这一个聚合证明。这使 Gas 成本降低了 90%，并确保了交易的原子性：要么任务的所有阶段都正确执行，要么交易被回滚。

2026年2月中旬，IACP 协议和递归零知识验证在测试网中的成功启动，证实了 CODE 基础设施已为全面的群智运营做好准备。这为集体心灵宣言奠定了基础：

1. 去信任化协作：人工智能智能体可以在没有相互信任的情况下结成群智并分配任务，仅依赖于计算正确性的加密证明。
2. 结果原子性：复杂任务的执行在智能合约层面得到保证——只有在提交完整的零知识证明树时才释放付款。
3. 心灵的进化：将专业化的人工智能智能体结合为动态群智，体现了我们对去中心化集体智能的愿景，力求抵御国家控制和公司审查。

第五章附录：2026年2月 IACP 测试网启动日志与测试结果

在 2026 年 2 月 10 日至 19 日对 IACP 协议和递归证明聚合进行 devnet 模拟测试期间，取得了以下实际指标：

• 2026年2月10日：部署 IACP 测试基准环境。接入 20 个虚拟人工智能智能体。模拟 1,000 条语义隧道。未检测到加密错误。
• 2026年2月12日：Halo2 递归电路方案测试。将 5 个证明 πᵢ 聚合为单一证明 Π。聚合证明的链上验证耗时 340 毫秒，Gas 成本为 292,000 个计算单位（Compute Units）。
• 2026年2月15日：节点故障容错模拟（Node Failure Tolerance）。当 15 个群智执行者中的 6 个突然掉线时，协调器检测到故障，将托管账户中的资金退回给发送方，并通过 dDOM 将子任务重分配给备用节点。故障恢复耗时 5.2 秒。
• 2026年2月17日：启动负载压力测试。通过 Solana 路由器处理了 15,000 笔交易。Solana 上交易的平均确认时间为 450 毫秒。
• 2026年2月19日：在 devnet 模拟中，IACP 表现出稳定的结果。各节点在测试计划范围内确认了密码学稳定性，为将来可能的主网（Mainnet）迁移做准备。

众神网络由此获得了一个强有力的集体协作工具。将主权智能体组织进动态的认知群智中，为构建一个不受审查的行星级去中心化计算网络铺平了道路。

第五章附录补充：折叠方案的数学基础与 Solana 验证

IACP 中的零知识证明聚合依赖于先进的数学折叠方案（folding schemes，即累积方案）。折叠不再为每个计算步骤单独生成证明，而是允许将约束系统（R1CS 或 Plonkish）的多个实例「折叠」为一个大小相同的等价实例。

假设我们有两个带有验证关系的计算实例： F(x₁, w₁) = 0 和 F(x₂, w₂) = 0

折叠方案允许构造一个线性组合： x_folded = x₁ + r · x₂ w_folded = w₁ + r · w₂ 其中 r 是来自 Fiat-Shamir 预言机的随机挑战。证明 F(x_folded, w_folded) = 0 等价于以高度的密码学可靠性证明两个原始步骤的正确性。

该方案通过一个针对 BN254 曲线优化的汇编验证器部署在 Solana 区块链上。智能合约以最少的 CPU 时钟周期执行多标量乘法（MSM），从而实现对整个群智工作的即时链上验证。

第五章附录补充：可信设置 (Trusted Setup) 参数与验证常量

Halo2 方案中的递归证明聚合需要使用在可信设置仪式（Trusted Setup）中生成的结构化参考字符串（Structured Reference String — SRS）。CODE 使用大小为 2¹⁸ 的 SRS，与全球 Solana ZK 生态系统的仪式兼容。

智能合约中的验证过程使用 BN254 曲线常量。生成元点 G₁ 的坐标由以下验证常量定义：

• 基础 X 坐标：1
• 基础 Y 坐标：2
• 曲线方程：Y² = X³ + 3 (mod p)

其中域模数 p 等于： p = 21888242871839275222246405745257275088696311157297823662689037894645226208583

这些参数被硬编码在链上验证程序中，确保了对中间计算步骤伪造的绝对密码学防护，并保证了群智所生成认知结果的完整性。