Proof Generation

your-project/
├── scripts/
│   ├── generateVoteSubmissionProof.ts
│   └── proofUtils.ts
├── circuits/
│   └── target/
│       └── circuits.json          # Compiled Noir circuit artifact
└── contracts/

import { buildMembershipTree } from "./scripts/proofUtils";
 
// Collect identity secrets from all DAO members
const memberSecrets = [
  "0x1234...abcd",  // Member 0's identity secret
  "0x5678...efgh",  // Member 1's identity secret
  "0x9abc...ijkl",  // Member 2's identity secret
  // ... all members
];
 
const tree = await buildMembershipTree(memberSecrets);
 
// tree.membershipRoot — use this when creating proposals on-chain
// tree.proofs[i]      — membership proof for member at index i

import { generateVoteSubmissionProof } from "./scripts/generateVoteSubmissionProof";
import type { VoteSubmissionProofRequest } from "./scripts/generateVoteSubmissionProof";
 
const request: VoteSubmissionProofRequest = {
  proposalId: 1,
  ballotSize: 3,                    // 0: Against, 1: For, 2: Abstain
  vote: 1,                          // Voting "For"
  memberIdentitySecrets: memberSecrets,  // All member secrets (to rebuild tree)
  voterIndex: 0,                    // This voter's index in the member list
  circuitPath: "./circuits/target/circuits.json",  // Optional, defaults to relative path
};
 
const payload = await generateVoteSubmissionProof(request);
 
// Use these values when calling submitEncryptedVote on-chain:
// payload.proof         — the serialized Honk proof (hex)
// payload.publicInputs  — array of 32-byte field elements
// payload.nullifierHash — the nullifier to pass on-chain

const response = await fetch("https://api.privacyprotocol.io/api/cipher/proof", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({
    proposalId: 1,
    ballotSize: 3,
    vote: 1,
    memberIdentitySecrets: memberSecrets,
    voterIndex: 0,
  }),
});
 
const { proof, publicInputs, nullifierHash } = await response.json();

// app/api/proof/route.ts
import { NextResponse } from "next/server";
import { exec } from "child_process";
import { promisify } from "util";
 
const execAsync = promisify(exec);
 
export async function POST(request: Request) {
  const body = await request.json();
  const encoded = Buffer.from(JSON.stringify(body)).toString("base64");
 
  const { stdout } = await execAsync(
    `npx tsx scripts/generateVoteSubmissionProof.ts ${encoded}`
  );
 
  const payload = JSON.parse(stdout);
 
  // ABI-encode the proof for on-chain submission
  return NextResponse.json({
    proof: payload.proof,
    publicInputs: payload.publicInputs,
    nullifierHash: payload.nullifierHash,
    membershipRoot: payload.membershipRoot,
  });
}

import { ethers } from "ethers";
import { generateVoteSubmissionProof } from "./scripts/generateVoteSubmissionProof";
import { buildMembershipTree, toBytes32 } from "./scripts/proofUtils";
 
// 1. Derive identity secret from wallet
async function deriveIdentitySecret(signer: ethers.Signer): Promise<bigint> {
  const message = "Privacy Protocol Cipher: Identity Secret Derivation v1";
  const signature = await signer.signMessage(message);
  const hash = ethers.keccak256(signature);
  const BN254_MODULUS = 21888242871839275222246405745257275088548364400416034343698204186575808495617n;
  return BigInt(hash) % BN254_MODULUS;
}
 
// 2. Collect all member secrets and build the tree
const allMemberSecrets = [
  await deriveIdentitySecret(member0Signer),
  await deriveIdentitySecret(member1Signer),
  await deriveIdentitySecret(member2Signer),
];
 
const tree = await buildMembershipTree(allMemberSecrets);
 
// 3. Create proposal on-chain (done once by the proposer)
const membershipRoot = toBytes32(tree.membershipRoot);
const tx1 = await daoContract.createProposal(proposalId, membershipRoot);
await tx1.wait();
 
// 4. Generate proof for a specific voter
const proof = await generateVoteSubmissionProof({
  proposalId: 1,
  ballotSize: 3,
  vote: 1,             // Voting "For"
  memberIdentitySecrets: allMemberSecrets,
  voterIndex: 0,       // Voter is member 0
});
 
// 5. Submit vote on-chain
const tx2 = await daoContract.vote(
  proposalId,
  proof.nullifierHash,
  proof.proof,
  voteData             // ABI-encoded FHE-encrypted vote
);
await tx2.wait();