从零构建零知识证明DApp：Circom电路进阶与Go语言实战

引言：当ZKP遇见全栈开发

在上一篇文章中，我们用Circom实现了一个基础的年龄证明电路，并成功在本地生成了零知识证明。但真实的应用场景远不止“证明年龄>18”——你需要处理多条件组合、将验证逻辑部署到区块链，并用后端语言集成整个流程。

本文将带你完成三项实战任务：

1. 电路进阶：修改AgeCheck电路，支持复杂的多条件AND/OR逻辑

2. 合约部署：在Goerli测试网部署Verifier智能合约

3. Go后端集成：用Go语言编写前端交互（ethers.js + Snarkjs）的后端服务

更重要的是，我们将讨论如何将Snarkjs与Go生态打通——这是一个在中文社区鲜少被完整讨论的话题。

读完本文，你将拥有一个完整的、可运行的零知识证明DApp技术栈。

第一部分：基础回顾——信号、约束与隐私

在开始进阶之前，快速回顾Circom的核心概念。如果你已经熟悉，可以跳过这一节。

1.1 信号：电路的输入/输出

Circom中的信号（Signal）类似于电路中的导线，有严格的隐私属性：

• 私有信号（private input）：只有证明者知道，验证者无法获取-1

• 公共信号（input/output）：双方都知道，通常用于输出验证结果

// 私有信号：不泄露 signal private input userAge; // 公共输入：验证者知道 signal input currentYear; // 公共输出：验证结果 signal output isValid;

1.2 约束：用数学定义“真相”

约束是电路的核心，形式为a === b，表示a - b = 0-1。注意Circom不支持直接写不等式（如x > 18），需要借助辅助变量转换。

// ✅ 合法：线性等式 x === y + z; // ❌ 非法：不能直接写不等式 // x > 18 === 1; // ✅ 正确：用辅助变量实现 x > 18 // x === 18 + k, 其中 k >= 1

第二部分：电路进阶——多条件AND/OR逻辑

2.1 需求分析

假设我们需要证明一个用户同时满足以下三个条件：

1. 年龄 ≥ 18岁

2. 年收入 ≥ 50,000

3. 居住城市为"北京"或"上海"（OR逻辑）

用户需要向验证者证明自己符合资格，但不透露具体的年龄、收入、城市。

2.2 设计思路

将三个条件转化为约束：

OR逻辑的实现技巧：Circom没有原生OR操作符，但可以通过IsEqual组件的输出相加实现——如果两个IsEqual输出之和 ≥ 1，则条件满足。

2.3 完整电路代码

创建advancedCheck.circom：

pragma circom 2.1.6; // 数值比较组件（复用上一篇文章） template LessThan(n) { assert(n <= 252); signal input in[2]; signal output out; component n2b = Num2Bits(n+1); n2b.in <== in[0] + (1 << n) - in[1]; out <== 1 - n2b.out[n]; } template Num2Bits(n) { signal input in; signal output out[n]; var acc = 0; for (var i = 0; i < n; i++) { out[i] <-- (in >> i) & 1; out[i] * (out[i] - 1) === 0; acc += out[i] * (1 << i); } acc === in; } // 等于比较组件 template IsEqual() { signal input in[2]; signal output out; // 如果 in[0] == in[1]，则 diff = 0，out = 1 // 否则 diff != 0，out = 0 signal diff; diff <-- in[0] - in[1]; diff * diff === 0; // 强制 diff == 0 out <== 1; } template AdvancedCheck() { // 秘密输入 signal private input age; signal private input annualIncome; signal private input cityCode; // 1:北京, 2:上海, 其他:不符合 // 公开输入 signal input minAge; signal input minIncome; // 辅助变量 signal ageDiff; signal incomeDiff; // 输出 signal output isValid; // 临时信号：各条件是否满足 signal ageOk; signal incomeOk; signal cityOk; // 约束1: age >= minAge // age = minAge + ageDiff, ageDiff >= 0 ageOk <== 1; age === minAge + ageDiff; component ageCompare = LessThan(32); ageCompare.in[0] <== minAge; ageCompare.in[1] <== age; ageOk <== 1 - ageCompare.out; // 约束2: annualIncome >= minIncome incomeOk <== 1; annualIncome === minIncome + incomeDiff; component incomeCompare = LessThan(64); // 更大位数 incomeCompare.in[0] <== minIncome; incomeCompare.in[1] <== annualIncome; incomeOk <== 1 - incomeCompare.out; // 约束3: 城市是北京(1)或上海(2) // OR逻辑: 两个IsEqual组件输出相加 component isBeijing = IsEqual(); component isShanghai = IsEqual(); isBeijing.in[0] <== cityCode; isBeijing.in[1] <== 1; isShanghai.in[0] <== cityCode; isShanghai.in[1] <== 2; cityOk <== isBeijing.out + isShanghai.out; // 最终输出: AND逻辑 = 三个条件都满足 isValid <== ageOk * incomeOk * cityOk; } component main {public [minAge, minIncome]} = AdvancedCheck();

2.4 电路亮点解读

1. OR逻辑实现：通过IsEqual组件分别判断是否等于北京或上海，然后cityOk <== isBeijing.out + isShanghai.out。由于两个IsEqual的输出只能是0或1，相加结果≥1即满足OR条件。

2. AND逻辑实现：isValid <== ageOk * incomeOk * cityOk——只有当三个条件都为1时，乘积才为1。

3. 辅助变量自动满足非负：Circom中的信号默认为非负整数，由zk-SNARKs的数学性质保证，无需额外约束-1。

2.5 编译与本地测试

# 编译电路 circom advancedCheck.circom --r1cs --wasm --sym # 查看约束数量 snarkjs r1cs info advancedCheck.r1cs # 预期输出: # of Constraints: ~78 # 准备见证数据 (input.json) cat > input.json << EOF { "age": 25, "annualIncome": 80000, "cityCode": 1, "minAge": 18, "minIncome": 50000 } EOF # 生成witness和证明 node advancedCheck_js/generate_witness.js advancedCheck_js/advancedCheck.wasm input.json witness.wtns snarkjs groth16 prove circuit_final.zkey witness.wtns proof.json public.json # 验证 snarkjs groth16 verify verification_key.json public.json proof.json # OK

第三部分：部署Verifier到Goerli测试网

3.1 生成Solidity验证器

# 从zkey导出Solidity验证器 snarkjs zkey export solidityverifier circuit_final.zkey verifier.sol

生成的verifier.sol包含一个Verifier合约，核心函数是verifyProof：

function verifyProof( uint[2] memory a, uint[2][2] memory b, uint[2] memory c, uint[2] memory input // 公开输入 ) public view returns (bool r);

3.2 编写业务合约

创建一个AgeVerification.sol，封装验证逻辑：

// SPDX-License-Identifier: MIT pragma solidity ^0.8.0; import "./verifier.sol"; contract AgeVerification is Verifier { // 记录已使用的证明（防止重放攻击） mapping(bytes32 => bool) public usedProofs; // 验证通过事件 event Verified(address indexed user, bool success); function verifyAge( uint[2] memory a, uint[2][2] memory b, uint[2] memory c, uint[2] memory input // [minAge, minIncome] ) external returns (bool) { // 生成唯一证明ID（防止重放） bytes32 proofId = keccak256(abi.encodePacked(a, b, c, input)); require(!usedProofs[proofId], "Proof already used"); // 调用父合约验证 bool isValid = verifyProof(a, b, c, input); if (isValid) { usedProofs[proofId] = true; emit Verified(msg.sender, true); } return isValid; } }

3.3 部署到Goerli

准备工作：

• 安装MetaMask，切换到Goerli测试网

• 从水龙头获取测试ETH（推荐：https://goerlifaucet.com/）

• 安装Hardhat或Remix

使用Remix部署（最快方式）-2：

1. 打开Remix IDE（https://remix.ethereum.org/）

2. 创建verifier.sol和AgeVerification.sol

3. 选择"Injected Web3"环境（确保MetaMask已连接Goerli）

4. 编译合约 → 部署AgeVerification

5. 记录合约地址，后续Go代码将用到

使用Hardhat部署（推荐生产环境）：

mkdir zk-dapp && cd zk-dapp npm init -y npm install --save-dev hardhat @nomiclabs/hardhat-ethers ethers npx hardhat # 创建部署脚本 scripts/deploy.js

// scripts/deploy.js const hre = require("hardhat"); async function main() { const AgeVerification = await hre.ethers.getContractFactory("AgeVerification"); const contract = await AgeVerification.deploy(); await contract.deployed(); console.log("AgeVerification deployed to:", contract.address); } main().catch(console.error);

部署成功后，你会看到类似输出：

AgeVerification deployed to: 0x1234...5678

第四部分：Go语言集成——后端服务实战

4.1 核心挑战

Snarkjs是Node.js工具，而我们的后端是Go。如何让Go生成并提交ZK证明？

三种解决方案：

本文采用方案A（前端生成） + Go后端验证与转发——这是最务实的生产架构。

4.2 Go后端服务架构

[前端] ↓ 输入数据（年龄、收入、城市） ↓ 调用Snarkjs本地生成证明 ↓ 发送 proof.json + public.json [Go后端] ↓ 验证证明格式 ↓ 调用以太坊合约 ↓ 返回验证结果 [Goerli区块链]

4.3 创建Go项目

mkdir zk-go-backend && cd zk-go-backend go mod init github.com/yourname/zk-go-backend go get github.com/ethereum/go-ethereum go get github.com/gin-gonic/gin

4.4 定义数据模型

// models/proof.go package models type ProofRequest struct { A [2]string `json:"a"` // G1点 B [2][2]string `json:"b"` // G2点 C [2]string `json:"c"` // G1点 Input [2]string `json:"input"` // 公开输入 [minAge, minIncome] UserAddr string `json:"userAddr"` // 用户钱包地址 } type VerifyResponse struct { Success bool `json:"success"` TxHash string `json:"txHash,omitempty"` Error string `json:"error,omitempty"` }

4.5 以太坊交互核心代码

// service/verifier.go package service import ( "context" "fmt" "log" "math/big" "strings" "github.com/ethereum/go-ethereum" "github.com/ethereum/go-ethereum/accounts/abi" "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/core/types" "github.com/ethereum/go-ethereum/crypto" "github.com/ethereum/go-ethereum/ethclient" ) type VerifierService struct { client *ethclient.Client contractAddr common.Address contractABI abi.ABI privateKey *ecdsa.PrivateKey } func NewVerifierService(rpcURL, contractAddress, privateKeyHex string) (*VerifierService, error) { // 连接Goerli client, err := ethclient.Dial(rpcURL) if err != nil { return nil, err } // 解析合约ABI contractABI, err := abi.JSON(strings.NewReader(VerifierABI)) if err != nil { return nil, err } // 解析私钥 privateKey, err := crypto.HexToECDSA(privateKeyHex) if err != nil { return nil, err } return &VerifierService{ client: client, contractAddr: common.HexToAddress(contractAddress), contractABI: contractABI, privateKey: privateKey, }, nil } // 调用合约验证证明 func (s *VerifierService) VerifyProofOnChain( a [2]*big.Int, b [2][2]*big.Int, c [2]*big.Int, input [2]*big.Int, fromAddress common.Address, ) (string, error) { // 编码合约调用 data, err := s.contractABI.Pack("verifyAge", a, b, c, input) if err != nil { return "", err } // 构建交易 gasPrice, _ := s.client.SuggestGasPrice(context.Background()) nonce, _ := s.client.PendingNonceAt(context.Background(), fromAddress) tx := types.NewTx(&types.LegacyTx{ Nonce: nonce, To: &s.contractAddr, Value: big.NewInt(0), Gas: 300000, // ZK验证消耗约30万Gas GasPrice: gasPrice, Data: data, }) // 签名 chainID, _ := s.client.NetworkID(context.Background()) signedTx, err := types.SignTx(tx, types.NewEIP155Signer(chainID), s.privateKey) if err != nil { return "", err } // 发送 err = s.client.SendTransaction(context.Background(), signedTx) if err != nil { return "", err } return signedTx.Hash().Hex(), nil } // 仅本地验证（不消耗Gas） func (s *VerifierService) VerifyProofLocally( a [2]*big.Int, b [2][2]*big.Int, c [2]*big.Int, input [2]*big.Int, ) (bool, error) { // 调用合约的静态验证函数 data, err := s.contractABI.Pack("verifyProof", a, b, c, input) if err != nil { return false, err } // 静态调用（不产生交易） result, err := s.client.CallContract(context.Background(), ethereum.CallMsg{ To: &s.contractAddr, Data: data, }, nil) if err != nil { return false, err } // 解析返回值 unpacked, err := s.contractABI.Unpack("verifyProof", result) if err != nil || len(unpacked) == 0 { return false, err } return unpacked[0].(bool), nil }

4.6 HTTP API服务

// main.go package main import ( "encoding/json" "log" "math/big" "net/http" "strconv" "strings" "github.com/gin-gonic/gin" "github.com/yourname/zk-go-backend/service" ) func main() { // 初始化Verifier服务 verifier, err := service.NewVerifierService( "https://goerli.infura.io/v3/YOUR_INFURA_KEY", "0x你的合约地址", "你的私钥（注意：生产环境用环境变量）", ) if err != nil { log.Fatal(err) } r := gin.Default() // 健康检查 r.GET("/health", func(c *gin.Context) { c.JSON(200, gin.H{"status": "ok"}) }) // 验证证明接口 r.POST("/api/verify", func(c *gin.Context) { var req struct { Proof string `json:"proof"` // proof.json内容 Public string `json:"public"` // public.json内容 UserAddr string `json:"userAddr"` } if err := c.BindJSON(&req); err != nil { c.JSON(400, gin.H{"error": "invalid request"}) return } // 解析证明（简化：实际需要解析JSON结构） proof, public := parseProof(req.Proof, req.Public) // 调用链上验证 txHash, err := verifier.VerifyProofOnChain(proof, public, common.HexToAddress(req.UserAddr)) if err != nil { c.JSON(500, gin.H{"error": err.Error()}) return } c.JSON(200, gin.H{ "success": true, "txHash": txHash, }) }) r.Run(":8080") } func parseProof(proofJSON, publicJSON string) ([2]*big.Int, [2][2]*big.Int, [2]*big.Int, [2]*big.Int) { // 解析proof和public的JSON结构 // 具体实现参照Snarkjs输出格式 // ... return a, b, c, input }

4.7 前端配合（简要示例）

前端使用ethers.js + snarkjs生成证明并提交：

// 前端代码 import * as snarkjs from "snarkjs"; async function generateAndSubmit() { // 1. 生成证明 const { proof, publicSignals } = await snarkjs.groth16.fullProve( { age: 25, annualIncome: 80000, cityCode: 1, minAge: 18, minIncome: 50000 }, "advancedCheck.wasm", "circuit_final.zkey" ); // 2. 提交到Go后端 const response = await fetch("http://localhost:8080/api/verify", { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ proof: JSON.stringify(proof), public: JSON.stringify(publicSignals), userAddr: ethereum.selectedAddress }) }); const result = await response.json(); console.log("Verification tx:", result.txHash); }

第五部分：Go生态中的ZK工具

如果你希望完全用Go实现ZK证明生成（而不依赖前端Snarkjs），以下库值得关注：

5.1 mpc-tss：多方计算的ZK证明

github.com/Caqil/mpc-tss是一个生产级的Go语言多方计算库，支持椭圆曲线数字签名算法的阈值签名，内置了Schnorr零知识证明来保证协议正确性-4。

import "github.com/Caqil/mpc-tss" // 支持多种曲线 // - secp256k1 (Bitcoin/Ethereum) // - P-256 (NIST标准)

5.2 dkg：分布式密钥生成

github.com/0xBridge/dkg实现了Pedersen分布式密钥生成协议，使用零知识证明防御拜占庭参与者的恶意攻击-9。该库特别适合需要无信任第三方的ZK应用场景。

import "github.com/0xBridge/dkg" // 2轮消息交互完成DKG // 输出：密钥分片 + 群组公钥

5.3 Mist Cash SDK：Go WASM支持

@mistcash/sdk虽然是一个npm包，但值得注意的是它提供了Go WASM支持，允许在Go环境中调用编译为WebAssembly的ZK证明生成函数-7。这是一个有趣的跨语言方案。

第六部分：常见问题与调试技巧

6.1 约束爆炸问题

现象：电路编译后约束数量远超预期，证明生成变慢。

原因：Circom中<==和<--的混用可能导致意外约束。

解决：

• 使用<==（赋值+约束）而非<--（仅赋值）

• 用Num2Bits处理位操作时，确保位数足够

6.2 Goerli Gas估算失败

现象：调用verifyProof时返回out of gas。

原因：ZK验证在EVM上消耗约30万Gas，默认限制可能不足。

解决：显式设置Gas上限：

tx := types.NewTransaction(nonce, to, value, 400000, gasPrice, data)

6.3 证明格式转换问题

现象：Go端解析Snarkjs生成的proof.json时类型不匹配。

原因：Snarkjs输出的是十进制字符串，而Go的*big.Int需要特殊解析。

解决：

func stringToBigInt(s string) *big.Int { n := new(big.Int) n, _ = n.SetString(s, 10) return n }

6.4 合约验证失败

现象：本地snarkjs验证通过，但链上verifyProof返回false。

原因：通常是因为公开输入顺序与Solidity接口不匹配。

解决：检查public.json的输出顺序，确保与合约中verifyProof的input参数顺序一致。

结语：Go + ZKP = 企业级隐私计算的未来

本文从电路进阶（多条件AND/OR）到链上部署（Goerli测试网），再到Go后端集成，完整覆盖了一个生产级ZKP DApp的核心技术栈。

你会发现，零知识证明不再是密码学家的专利——现代工具链（Circom、Snarkjs、go-ethereum）让普通开发者也能构建隐私保护应用。而Go语言凭借其高性能和成熟的以太坊生态，成为ZK后端服务的理想选择。

下一步建议：

• 尝试将电路中的IsEqual替换为更高效的Poseidon哈希（适用于大集合成员证明）

• 在Go服务中加入Redis缓存，避免重复验证同一证明

• 探索gnark——一个纯Go实现的ZK框架（无需依赖Snarkjs）

ZK的浪潮才刚刚开始。希望这篇文章能帮助你在Go语言的世界里，率先掌握这项“重构信任”的技术。

参考资料

1. Circom电路开发实践，CSDN，2025 -1

2. Remix部署Goerli合约指南，腾讯云，2024 -2

3. 零知识证明DApp构建指南，2025 -3

4. mpc-tss Go库文档，Go Packages，2025 -4

5. Zero Party Data - ETHGlobal黑客松项目，2022 -6

6. @mistcash/sdk NPM包（含Go WASM支持），2026 -7

7. dkg Go库文档，Go Packages，2025