@semaphore-protocol/proof 3.15.2 → 4.0.0-alpha.1

package/src/generateProof.ts

@@ -1,69 +0,0 @@
-import { BigNumber } from "@ethersproject/bignumber"
-import { BytesLike, Hexable } from "@ethersproject/bytes"
-import { Group } from "@semaphore-protocol/group"
-import type { Identity } from "@semaphore-protocol/identity"
-import { prove } from "@zk-kit/groth16"
-import { MerkleProof } from "@zk-kit/incremental-merkle-tree"
-import type { NumericString } from "snarkjs"
-import hash from "./hash"
-import packProof from "./packProof"
-import { SemaphoreProof, SnarkArtifacts } from "./types"
-
-/**
- * Generates a Semaphore proof.
- * @param identity The Semaphore identity.
- * @param groupOrMerkleProof The Semaphore group or its Merkle proof.
- * @param externalNullifier The external nullifier.
- * @param signal The Semaphore signal.
- * @param snarkArtifacts The SNARK artifacts.
- * @returns The Semaphore proof ready to be verified.
- */
-export default async function generateProof(
-    { trapdoor, nullifier, commitment }: Identity,
-    groupOrMerkleProof: Group | MerkleProof,
-    externalNullifier: BytesLike | Hexable | number | bigint,
-    signal: BytesLike | Hexable | number | bigint,
-    snarkArtifacts?: SnarkArtifacts
-): Promise<SemaphoreProof> {
-    let merkleProof: MerkleProof
-
-    if ("depth" in groupOrMerkleProof) {
-        const index = groupOrMerkleProof.indexOf(commitment)
-
-        if (index === -1) {
-            throw new Error("The identity is not part of the group")
-        }
-
-        merkleProof = groupOrMerkleProof.generateMerkleProof(index)
-    } else {
-        merkleProof = groupOrMerkleProof
-    }
-
-    if (!snarkArtifacts) {
-        snarkArtifacts = {
-            wasmFilePath: `https://www.trusted-setup-pse.org/semaphore/${merkleProof.siblings.length}/semaphore.wasm`,
-            zkeyFilePath: `https://www.trusted-setup-pse.org/semaphore/${merkleProof.siblings.length}/semaphore.zkey`
-        }
-    }
-
-    const { proof, publicSignals } = await prove(
-        {
-            identityTrapdoor: trapdoor,
-            identityNullifier: nullifier,
-            treePathIndices: merkleProof.pathIndices,
-            treeSiblings: merkleProof.siblings,
-            externalNullifier: hash(externalNullifier),
-            signalHash: hash(signal)
-        },
-        snarkArtifacts.wasmFilePath,
-        snarkArtifacts.zkeyFilePath
-    )
-
-    return {
-        merkleTreeRoot: publicSignals[0],
-        nullifierHash: publicSignals[1],
-        signal: BigNumber.from(signal).toString() as NumericString,
-        externalNullifier: BigNumber.from(externalNullifier).toString() as NumericString,
-        proof: packProof(proof)
-    }
-}

package/src/index.test.ts

@@ -1,147 +0,0 @@
-import { formatBytes32String } from "@ethersproject/strings"
-import { Group } from "@semaphore-protocol/group"
-import { Identity } from "@semaphore-protocol/identity"
-import { getCurveFromName } from "ffjavascript"
-import calculateNullifierHash from "./calculateNullifierHash"
-import generateProof from "./generateProof"
-import hash from "./hash"
-import packProof from "./packProof"
-import { SemaphoreProof } from "./types"
-import unpackProof from "./unpackProof"
-import verifyProof from "./verifyProof"
-
-describe("Proof", () => {
-    const treeDepth = Number(process.env.TREE_DEPTH) || 20
-
-    const externalNullifier = formatBytes32String("Topic")
-    const signal = formatBytes32String("Hello world")
-
-    const wasmFilePath = `./snark-artifacts/${treeDepth}/semaphore.wasm`
-    const zkeyFilePath = `./snark-artifacts/${treeDepth}/semaphore.zkey`
-
-    const identity = new Identity()
-
-    let fullProof: SemaphoreProof
-    let curve: any
-
-    beforeAll(async () => {
-        curve = await getCurveFromName("bn128")
-    })
-
-    afterAll(async () => {
-        await curve.terminate()
-    })
-
-    describe("# generateProof", () => {
-        it("Should not generate Semaphore proofs if the identity is not part of the group", async () => {
-            const group = new Group(treeDepth, 20, [BigInt(1), BigInt(2)])
-
-            const fun = () =>
-                generateProof(identity, group, externalNullifier, signal, {
-                    wasmFilePath,
-                    zkeyFilePath
-                })
-
-            await expect(fun).rejects.toThrow("The identity is not part of the group")
-        })
-
-        it("Should not generate a Semaphore proof with default snark artifacts with Node.js", async () => {
-            const group = new Group(treeDepth, 20, [BigInt(1), BigInt(2), identity.commitment])
-
-            const fun = () => generateProof(identity, group, externalNullifier, signal)
-
-            await expect(fun).rejects.toThrow("ENOENT: no such file or directory")
-        })
-
-        it("Should generate a Semaphore proof passing a group as parameter", async () => {
-            const group = new Group(treeDepth, 20, [BigInt(1), BigInt(2), identity.commitment])
-
-            fullProof = await generateProof(identity, group, externalNullifier, signal, {
-                wasmFilePath,
-                zkeyFilePath
-            })
-
-            expect(typeof fullProof).toBe("object")
-            expect(fullProof.merkleTreeRoot).toBe(group.root.toString())
-        }, 20000)
-
-        it("Should generate a Semaphore proof passing a Merkle proof as parameter", async () => {
-            const group = new Group(treeDepth, 20, [BigInt(1), BigInt(2), identity.commitment])
-
-            fullProof = await generateProof(identity, group.generateMerkleProof(2), externalNullifier, signal, {
-                wasmFilePath,
-                zkeyFilePath
-            })
-
-            expect(typeof fullProof).toBe("object")
-            expect(fullProof.merkleTreeRoot).toBe(group.root.toString())
-        }, 20000)
-    })
-
-    describe("# verifyProof", () => {
-        it("Should not verify a proof if the tree depth is wrong", () => {
-            const fun = () => verifyProof(fullProof, 3)
-
-            expect(fun).toThrow("The tree depth must be a number between 16 and 32")
-        })
-
-        it("Should verify a Semaphore proof", async () => {
-            const response = await verifyProof(fullProof, treeDepth)
-
-            expect(response).toBe(true)
-        })
-    })
-
-    describe("# hash", () => {
-        it("Should hash the signal value correctly", async () => {
-            const signalHash = hash(signal)
-
-            expect(signalHash).toBe("8665846418922331996225934941481656421248110469944536651334918563951783029")
-        })
-
-        it("Should hash the external nullifier value correctly", async () => {
-            const externalNullifierHash = hash(externalNullifier)
-
-            expect(externalNullifierHash).toBe(
-                "244178201824278269437519042830883072613014992408751798420801126401127326826"
-            )
-        })
-
-        it("Should hash a number", async () => {
-            expect(hash(2)).toBe("113682330006535319932160121224458771213356533826860247409332700812532759386")
-        })
-
-        it("Should hash a big number", async () => {
-            expect(hash(BigInt(2))).toBe("113682330006535319932160121224458771213356533826860247409332700812532759386")
-        })
-
-        it("Should hash an hex number", async () => {
-            expect(hash("0x2")).toBe("113682330006535319932160121224458771213356533826860247409332700812532759386")
-        })
-
-        it("Should hash an string number", async () => {
-            expect(hash("2")).toBe("113682330006535319932160121224458771213356533826860247409332700812532759386")
-        })
-
-        it("Should hash an array", async () => {
-            expect(hash([2])).toBe("113682330006535319932160121224458771213356533826860247409332700812532759386")
-        })
-    })
-
-    describe("# calculateNullifierHash", () => {
-        it("Should calculate the nullifier hash correctly", async () => {
-            const nullifierHash = calculateNullifierHash(identity.nullifier, externalNullifier)
-
-            expect(fullProof.nullifierHash).toBe(nullifierHash.toString())
-        })
-    })
-
-    describe("# packProof/unpackProof", () => {
-        it("Should return a packed proof", async () => {
-            const originalProof = unpackProof(fullProof.proof)
-            const proof = packProof(originalProof)
-
-            expect(proof).toStrictEqual(fullProof.proof)
-        })
-    })
-})

package/src/packProof.ts

@@ -1,20 +0,0 @@
-import { Groth16Proof } from "snarkjs"
-import { PackedProof } from "./types"
-
-/**
- * Packs a proof into a format compatible with Semaphore.
- * @param proof The Groth16 proof generated with SnarkJS.
- * @returns The proof compatible with Semaphore.
- */
-export default function packProof(proof: Groth16Proof): PackedProof {
-    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/unpackProof.ts

@@ -1,20 +0,0 @@
-import { Groth16Proof } from "snarkjs"
-import { PackedProof } from "./types"
-
-/**
- * Unpacks a proof into its original form.
- * @param proof The proof compatible with Semaphore.
- * @returns The proof compatible with SnarkJS.
- */
-export default function unpackProof(proof: PackedProof): Groth16Proof {
-    return {
-        pi_a: [proof[0], proof[1]],
-        pi_b: [
-            [proof[3], proof[2]],
-            [proof[5], proof[4]]
-        ],
-        pi_c: [proof[6], proof[7]],
-        protocol: "groth16",
-        curve: "bn128"
-    }
-}