@semaphore-protocol/proof 0.1.0 → 0.2.2

package/src/index.test.ts

@@ -0,0 +1,123 @@
+import { Identity } from "@semaphore-protocol/identity"
+import download from "download"
+import { getCurveFromName } from "ffjavascript"
+import fs from "fs"
+import createMerkleProof from "./createMerkleProof"
+import createMerkleTree from "./createMerkleTree"
+import generateNullifierHash from "./generateNullifierHash"
+import generateProof from "./generateProof"
+import generateSignalHash from "./generateSignalHash"
+import packToSolidityProof from "./packToSolidityProof"
+import { FullProof } from "./types"
+import verifyProof from "./verifyProof"
+
+describe("Proof", () => {
+    const treeDepth = 20
+    const externalNullifier = "1"
+    const signal = "0x111"
+
+    const snarkArtifactsPath = "./packages/proof/snark-artifacts"
+    const snarkArtifactsUrl = `http://www.trusted-setup-pse.org/semaphore/${treeDepth}`
+
+    let identity: Identity
+    let fullProof: FullProof
+    let curve: any
+
+    beforeAll(async () => {
+        curve = await getCurveFromName("bn128")
+
+        if (!fs.existsSync(snarkArtifactsPath)) {
+            fs.mkdirSync(snarkArtifactsPath)
+        }
+
+        if (!fs.existsSync(`${snarkArtifactsPath}/semaphore.zkey`)) {
+            await download(`${snarkArtifactsUrl}/semaphore.wasm`, snarkArtifactsPath)
+            await download(`${snarkArtifactsUrl}/semaphore.zkey`, snarkArtifactsPath)
+            await download(`${snarkArtifactsUrl}/semaphore.json`, snarkArtifactsPath)
+        }
+    })
+
+    afterAll(async () => {
+        await curve.terminate()
+    })
+
+    describe("# createMerkleTree", () => {
+        it("Should not generate a Merkle tree with a zero value leaf", async () => {
+            const fun = () => createMerkleTree(treeDepth, BigInt(0), [BigInt(0), BigInt(1)])
+
+            expect(fun).toThrow("Leaves cannot have zero values")
+        })
+
+        it("Should generate a Merkle tree", async () => {
+            const merkleTree = createMerkleTree(treeDepth, BigInt(0), [BigInt(1), BigInt(2)])
+
+            expect(merkleTree.leaves).toHaveLength(2)
+        })
+    })
+
+    describe("# createMerkleProof", () => {
+        it("Should not generate a Merkle proof of a non-existing leaf", async () => {
+            const fun = () => createMerkleProof(treeDepth, BigInt(0), [BigInt(1), BigInt(2)], BigInt(3))
+
+            expect(fun).toThrow("The leaf does not exist")
+        })
+
+        it("Should generate a Merkle proof", async () => {
+            const merkleProof = createMerkleProof(treeDepth, BigInt(0), [BigInt(1), BigInt(2)], BigInt(2))
+
+            expect(merkleProof.leaf).toBe(BigInt(2))
+        })
+    })
+
+    describe("# generateProof", () => {
+        it("Should generate a Semaphore proof", async () => {
+            identity = new Identity()
+            const identityCommitment = identity.generateCommitment()
+            const leaves = [BigInt(3), BigInt(2), identityCommitment, BigInt(4)]
+            const merkleProof = createMerkleProof(treeDepth, BigInt(0), leaves, identityCommitment)
+
+            fullProof = await generateProof(identity, merkleProof, externalNullifier, signal, {
+                wasmFilePath: `${snarkArtifactsPath}/semaphore.wasm`,
+                zkeyFilePath: `${snarkArtifactsPath}/semaphore.zkey`
+            })
+
+            expect(typeof fullProof).toBe("object")
+            expect(fullProof.publicSignals.externalNullifier).toBe(externalNullifier)
+            expect(fullProof.publicSignals.merkleRoot).toBe(merkleProof.root.toString())
+        }, 20000)
+    })
+
+    describe("# generateSignalHash", () => {
+        it("Should generate a valid signal hash", async () => {
+            const signalHash = generateSignalHash(signal)
+
+            expect(signalHash.toString()).toBe(fullProof.publicSignals.signalHash)
+        })
+    })
+
+    describe("# generateNullifierHash", () => {
+        it("Should generate a valid nullifier hash", async () => {
+            const nullifierHash = generateNullifierHash(externalNullifier, identity.getNullifier())
+
+            expect(nullifierHash.toString()).toBe(fullProof.publicSignals.nullifierHash)
+        })
+    })
+
+    describe("# packToSolidityProof", () => {
+        it("Should return a Solidity proof", async () => {
+            const solidityProof = packToSolidityProof(fullProof.proof)
+
+            expect(solidityProof).toHaveLength(8)
+        })
+    })
+
+    describe("# verifyProof", () => {
+        it("Should generate and verify a Semaphore proof", async () => {
+            const verificationKey = JSON.parse(fs.readFileSync(`${snarkArtifactsPath}/semaphore.json`, "utf-8"))
+
+            const response = await verifyProof(verificationKey, fullProof)
+
+            expect(response).toBe(true)
+        })
+    })
+})

package/src/index.ts

@@ -1,6 +1,20 @@
 import { MerkleProof } from "@zk-kit/incremental-merkle-tree"
-import Semaphore from "./semaphore"
-import { generateMerkleProof, generateMerkleTree, genExternalNullifier } from "./utils"
+import createMerkleTree from "./createMerkleTree"
+import createMerkleProof from "./createMerkleProof"
+import generateNullifierHash from "./generateNullifierHash"
+import generateProof from "./generateProof"
+import verifyProof from "./verifyProof"
+import generateSignalHash from "./generateSignalHash"
+import packToSolidityProof from "./packToSolidityProof"
 
-export { Semaphore, generateMerkleProof, generateMerkleTree, genExternalNullifier, MerkleProof }
+export {
+    MerkleProof,
+    createMerkleTree,
+    createMerkleProof,
+    generateNullifierHash,
+    generateProof,
+    verifyProof,
+    generateSignalHash,
+    packToSolidityProof
+}
 export * from "./types"

package/src/packToSolidityProof.ts

@@ -0,0 +1,19 @@
+import { Proof, SolidityProof } from "./types"
+
+/**
+ * Makes a proof compatible with the Verifier.sol method inputs.
+ * @param proof The proof generated with SnarkJS.
+ * @returns The Solidity compatible proof.
+ */
+export default function packToSolidityProof(proof: Proof): SolidityProof {
+    return [
+        proof.pi_a[0],
+        proof.pi_a[1],
+        proof.pi_b[0][1],
+        proof.pi_b[0][0],
+        proof.pi_b[1][1],
+        proof.pi_b[1][0],
+        proof.pi_c[0],
+        proof.pi_c[1]
+    ]
+}

package/src/types/index.ts

@@ -1,41 +1,37 @@
-export type StrBigInt = string | bigint
+export type BigNumberish = string | bigint
+
+export type SnarkArtifacts = {
+    wasmFilePath: string
+    zkeyFilePath: string
+}
 
 export type Proof = {
-    pi_a: StrBigInt[]
-    pi_b: StrBigInt[][]
-    pi_c: StrBigInt[]
+    pi_a: BigNumberish[]
+    pi_b: BigNumberish[][]
+    pi_c: BigNumberish[]
     protocol: string
     curve: string
 }
 
-export type SemaphoreFullProof = {
+export type FullProof = {
     proof: Proof
-    publicSignals: SemaphorePublicSignals
+    publicSignals: PublicSignals
 }
 
-export type SemaphorePublicSignals = {
-    merkleRoot: StrBigInt
-    nullifierHash: StrBigInt
-    signalHash: StrBigInt
-    externalNullifier: StrBigInt
+export type PublicSignals = {
+    merkleRoot: BigNumberish
+    nullifierHash: BigNumberish
+    signalHash: BigNumberish
+    externalNullifier: BigNumberish
 }
 
-export type SemaphoreSolidityProof = [
-    StrBigInt,
-    StrBigInt,
-    StrBigInt,
-    StrBigInt,
-    StrBigInt,
-    StrBigInt,
-    StrBigInt,
-    StrBigInt
+export type SolidityProof = [
+    BigNumberish,
+    BigNumberish,
+    BigNumberish,
+    BigNumberish,
+    BigNumberish,
+    BigNumberish,
+    BigNumberish,
+    BigNumberish
 ]
-
-export type SemaphoreWitness = {
-    identityNullifier: StrBigInt
-    identityTrapdoor: StrBigInt
-    treeSiblings: StrBigInt[]
-    treePathIndices: number[]
-    externalNullifier: StrBigInt
-    signalHash: StrBigInt
-}

package/src/verifyProof.ts

@@ -0,0 +1,21 @@
+import { groth16 } from "snarkjs"
+import { FullProof } from "./types"
+
+/**
+ * Verifies a SnarkJS proof.
+ * @param verificationKey The zero-knowledge verification key.
+ * @param fullProof The SnarkJS full proof.
+ * @returns True if the proof is valid, false otherwise.
+ */
+export default function verifyProof(verificationKey: any, { proof, publicSignals }: FullProof): Promise<boolean> {
+    return groth16.verify(
+        verificationKey,
+        [
+            publicSignals.merkleRoot,
+            publicSignals.nullifierHash,
+            publicSignals.signalHash,
+            publicSignals.externalNullifier
+        ],
+        proof
+    )
+}

package/dist/types/semaphore.d.ts

@@ -1,48 +0,0 @@
-import { MerkleProof } from "@zk-kit/incremental-merkle-tree";
-import { Proof, SemaphoreFullProof, SemaphoreSolidityProof, SemaphoreWitness, StrBigInt } from "./types";
-export default class Semaphore {
-    /**
-     * Generates a SnarkJS full proof with Groth16.
-     * @param witness The parameters for creating the proof.
-     * @param wasmFilePath The WASM file path.
-     * @param finalZkeyPath The ZKey file path.
-     * @returns The full SnarkJS proof.
-     */
-    static genProof(witness: any, wasmFilePath: string, finalZkeyPath: string): Promise<SemaphoreFullProof>;
-    /**
-     * Verifies a zero-knowledge SnarkJS proof.
-     * @param verificationKey The zero-knowledge verification key.
-     * @param fullProof The SnarkJS full proof.
-     * @returns True if the proof is valid, false otherwise.
-     */
-    static verifyProof(verificationKey: string, { proof, publicSignals }: SemaphoreFullProof): Promise<boolean>;
-    /**
-     * Creates a Semaphore witness for the Semaphore ZK proof.
-     * @param identityTrapdoor The identity trapdoor.
-     * @param identityNullifier The identity nullifier.
-     * @param merkleProof The Merkle proof that identity exists in Semaphore tree.
-     * @param externalNullifier The topic on which vote should be broadcasted.
-     * @param signal The signal that should be broadcasted.
-     * @returns The Semaphore witness.
-     */
-    static genWitness(identityTrapdoor: StrBigInt, identityNullifier: StrBigInt, merkleProof: MerkleProof, externalNullifier: StrBigInt, signal: string): SemaphoreWitness;
-    /**
-     * Generates a nullifier by hashing the external and the identity nullifiers.
-     * @param externalNullifier The external nullifier.
-     * @param identityNullifier The identity nullifier.
-     * @returns The nullifier hash.
-     */
-    static genNullifierHash(externalNullifier: StrBigInt, identityNullifier: StrBigInt): bigint;
-    /**
-     * Hashes a signal string with Keccak256.
-     * @param signal The Semaphore signal.
-     * @returns The signal hash.
-     */
-    static genSignalHash(signal: string): bigint;
-    /**
-     * Converts a full proof in a proof compatible with the Verifier.sol method inputs.
-     * @param proof The proof generated with SnarkJS.
-     * @returns The Solidity compatible proof.
-     */
-    static packToSolidityProof(proof: Proof): SemaphoreSolidityProof;
-}

package/dist/types/utils.d.ts

@@ -1,21 +0,0 @@
-import { IncrementalMerkleTree, MerkleProof } from "@zk-kit/incremental-merkle-tree";
-import { StrBigInt } from "./types";
-export declare const SNARK_FIELD_SIZE: bigint;
-export declare function genExternalNullifier(plaintext: string): string;
-/**
- * Creates a Merkle tree.
- * @param depth The depth of the tree.
- * @param zeroValue The zero value of the tree.
- * @param leaves The list of the leaves of the tree.
- * @returns The Merkle tree.
- */
-export declare function generateMerkleTree(depth: number, zeroValue: StrBigInt, leaves: StrBigInt[]): IncrementalMerkleTree;
-/**
- * Creates a Merkle proof.
- * @param depth The depth of the tree.
- * @param zeroValue The zero value of the tree.
- * @param leaves The list of the leaves of the tree.
- * @param leaf The leaf for which Merkle proof should be created.
- * @returns The Merkle proof.
- */
-export declare function generateMerkleProof(depth: number, zeroValue: StrBigInt, leaves: StrBigInt[], leaf: StrBigInt): MerkleProof;

package/src/semaphore.test.ts

@@ -1,72 +0,0 @@
-import { Identity } from "@semaphore-protocol/identity"
-import { getCurveFromName } from "ffjavascript"
-import fs from "fs"
-import path from "path"
-import Semaphore from "./semaphore"
-import { generateMerkleProof, genExternalNullifier } from "./utils"
-
-describe("Semaphore", () => {
-    const assets = "./packages/proof/assets"
-
-    let curve: any
-
-    beforeAll(async () => {
-        curve = await getCurveFromName("bn128")
-    })
-
-    afterAll(async () => {
-        await curve.terminate()
-    })
-
-    describe("Generate and verify proof", () => {
-        it("Should generate a Semaphore witness", async () => {
-            const identity = new Identity()
-            const identityCommitment = identity.genIdentityCommitment()
-            const externalNullifier = genExternalNullifier("voting_1")
-            const leaves = [BigInt(3), BigInt(2), identityCommitment, BigInt(4)]
-            const signal = "0x111"
-
-            const merkleProof = generateMerkleProof(20, BigInt(0), leaves, identityCommitment)
-
-            const witness = Semaphore.genWitness(
-                identity.getTrapdoor(),
-                identity.getNullifier(),
-                merkleProof,
-                externalNullifier,
-                signal
-            )
-
-            expect(typeof witness).toBe("object")
-        })
-
-        // eslint-disable-next-line jest/no-disabled-tests
-        it.skip("Should generate and verify Semaphore proof", async () => {
-            const identity = new Identity()
-            const identityCommitment = identity.genIdentityCommitment()
-            const externalNullifier = genExternalNullifier("voting_1")
-            const leaves = [BigInt(3), BigInt(2), identityCommitment, BigInt(4)]
-            const signal = "0x111"
-
-            const merkleProof = generateMerkleProof(20, BigInt(0), leaves, identityCommitment)
-
-            const witness = Semaphore.genWitness(
-                identity.getTrapdoor(),
-                identity.getNullifier(),
-                merkleProof,
-                externalNullifier,
-                signal
-            )
-
-            const wasmFilePath = path.join(assets, "semaphore", "semaphore.wasm")
-            const zkeyFilePath = path.join(assets, "semaphore", "semaphore.zkey")
-            const fullProof = await Semaphore.genProof(witness, wasmFilePath, zkeyFilePath)
-
-            const vkeyPath = path.join(assets, "semaphore", "verification_key.json")
-            const vKey = JSON.parse(fs.readFileSync(vkeyPath, "utf-8"))
-
-            const response = await Semaphore.verifyProof(vKey, fullProof)
-
-            expect(response).toBe(true)
-        }, 30000)
-    })
-})

package/src/semaphore.ts

@@ -1,118 +0,0 @@
-import { keccak256 } from "@ethersproject/solidity"
-import { formatBytes32String } from "@ethersproject/strings"
-import { MerkleProof } from "@zk-kit/incremental-merkle-tree"
-import { poseidon } from "circomlibjs"
-import { groth16 } from "snarkjs"
-import { Proof, SemaphoreFullProof, SemaphoreSolidityProof, SemaphoreWitness, StrBigInt } from "./types"
-
-export default class Semaphore {
-    /**
-     * Generates a SnarkJS full proof with Groth16.
-     * @param witness The parameters for creating the proof.
-     * @param wasmFilePath The WASM file path.
-     * @param finalZkeyPath The ZKey file path.
-     * @returns The full SnarkJS proof.
-     */
-    /* istanbul ignore next */
-    public static async genProof(
-        witness: any,
-        wasmFilePath: string,
-        finalZkeyPath: string
-    ): Promise<SemaphoreFullProof> {
-        const { proof, publicSignals } = await groth16.fullProve(witness, wasmFilePath, finalZkeyPath, null)
-
-        return {
-            proof,
-            publicSignals: {
-                merkleRoot: publicSignals[0],
-                nullifierHash: publicSignals[1],
-                signalHash: publicSignals[2],
-                externalNullifier: publicSignals[3]
-            }
-        }
-    }
-
-    /**
-     * Verifies a zero-knowledge SnarkJS proof.
-     * @param verificationKey The zero-knowledge verification key.
-     * @param fullProof The SnarkJS full proof.
-     * @returns True if the proof is valid, false otherwise.
-     */
-    /* istanbul ignore next */
-    public static verifyProof(verificationKey: string, { proof, publicSignals }: SemaphoreFullProof): Promise<boolean> {
-        return groth16.verify(
-            verificationKey,
-            [
-                publicSignals.merkleRoot,
-                publicSignals.nullifierHash,
-                publicSignals.signalHash,
-                publicSignals.externalNullifier
-            ],
-            proof
-        )
-    }
-
-    /**
-     * Creates a Semaphore witness for the Semaphore ZK proof.
-     * @param identityTrapdoor The identity trapdoor.
-     * @param identityNullifier The identity nullifier.
-     * @param merkleProof The Merkle proof that identity exists in Semaphore tree.
-     * @param externalNullifier The topic on which vote should be broadcasted.
-     * @param signal The signal that should be broadcasted.
-     * @returns The Semaphore witness.
-     */
-    public static genWitness(
-        identityTrapdoor: StrBigInt,
-        identityNullifier: StrBigInt,
-        merkleProof: MerkleProof,
-        externalNullifier: StrBigInt,
-        signal: string
-    ): SemaphoreWitness {
-        return {
-            identityNullifier,
-            identityTrapdoor,
-            treePathIndices: merkleProof.pathIndices,
-            treeSiblings: merkleProof.siblings,
-            externalNullifier,
-            signalHash: Semaphore.genSignalHash(signal)
-        }
-    }
-
-    /**
-     * Generates a nullifier by hashing the external and the identity nullifiers.
-     * @param externalNullifier The external nullifier.
-     * @param identityNullifier The identity nullifier.
-     * @returns The nullifier hash.
-     */
-    public static genNullifierHash(externalNullifier: StrBigInt, identityNullifier: StrBigInt): bigint {
-        return poseidon([BigInt(externalNullifier), BigInt(identityNullifier)])
-    }
-
-    /**
-     * Hashes a signal string with Keccak256.
-     * @param signal The Semaphore signal.
-     * @returns The signal hash.
-     */
-    public static genSignalHash(signal: string): bigint {
-        return BigInt(keccak256(["bytes32"], [formatBytes32String(signal)])) >> BigInt(8)
-    }
-
-    /**
-     * Converts a full proof in a proof compatible with the Verifier.sol method inputs.
-     * @param proof The proof generated with SnarkJS.
-     * @returns The Solidity compatible proof.
-     */
-    /* istanbul ignore next */
-    public static packToSolidityProof(proof: Proof): SemaphoreSolidityProof {
-        return [
-            proof.pi_a[0],
-            proof.pi_a[1],
-            proof.pi_b[0][1],
-            proof.pi_b[0][0],
-            proof.pi_b[1][1],
-            proof.pi_b[1][0],
-            proof.pi_c[0],
-            proof.pi_c[1]
-        ]
-    }
-}

package/src/utils.ts

@@ -1,65 +0,0 @@
-import { keccak256 } from "@ethersproject/solidity"
-import { IncrementalMerkleTree, MerkleProof } from "@zk-kit/incremental-merkle-tree"
-import { poseidon } from "circomlibjs"
-import { StrBigInt } from "./types"
-
-export const SNARK_FIELD_SIZE = BigInt("21888242871839275222246405745257275088548364400416034343698204186575808495617")
-
-export function genExternalNullifier(plaintext: string): string {
-    const hashed = keccak256(["string"], [plaintext])
-    const hexStr = `0x${hashed.slice(8)}`
-    const len = 32 * 2
-    const h = hexStr.slice(2, len + 2)
-
-    return `0x${h.padStart(len, "0")}`
-}
-
-/**
- * Creates a Merkle tree.
- * @param depth The depth of the tree.
- * @param zeroValue The zero value of the tree.
- * @param leaves The list of the leaves of the tree.
- * @returns The Merkle tree.
- */
-export function generateMerkleTree(depth: number, zeroValue: StrBigInt, leaves: StrBigInt[]): IncrementalMerkleTree {
-    const tree = new IncrementalMerkleTree(poseidon, depth, zeroValue, 2)
-
-    for (const leaf of leaves) {
-        tree.insert(BigInt(leaf))
-    }
-
-    return tree
-}
-
-/**
- * Creates a Merkle proof.
- * @param depth The depth of the tree.
- * @param zeroValue The zero value of the tree.
- * @param leaves The list of the leaves of the tree.
- * @param leaf The leaf for which Merkle proof should be created.
- * @returns The Merkle proof.
- */
-export function generateMerkleProof(
-    depth: number,
-    zeroValue: StrBigInt,
-    leaves: StrBigInt[],
-    leaf: StrBigInt
-): MerkleProof {
-    if (leaf === zeroValue) {
-        throw new Error("Can't generate a proof for a zero leaf")
-    }
-
-    const tree = generateMerkleTree(depth, zeroValue, leaves)
-
-    const leafIndex = tree.leaves.indexOf(BigInt(leaf))
-
-    if (leafIndex === -1) {
-        throw new Error("The leaf does not exist")
-    }
-
-    const merkleProof = tree.createProof(leafIndex)
-
-    merkleProof.siblings = merkleProof.siblings.map((s) => s[0])
-
-    return merkleProof
-}