@semaphore-protocol/proof 2.6.0 → 3.0.0-beta.5

package/dist/types/generateProof.d.ts

@@ -1,5 +1,6 @@
+import { BytesLike, Hexable } from "@ethersproject/bytes";
 import { Group } from "@semaphore-protocol/group";
 import type { Identity } from "@semaphore-protocol/identity";
 import { MerkleProof } from "@zk-kit/incremental-merkle-tree";
-import { BigNumberish, FullProof, SnarkArtifacts } from "./types";
-export default function generateProof({ trapdoor, nullifier, commitment }: Identity, groupOrMerkleProof: Group | MerkleProof, externalNullifier: BigNumberish, signal: string, snarkArtifacts?: SnarkArtifacts): Promise<FullProof>;
+import { FullProof, SnarkArtifacts } from "./types";
+export default function generateProof({ trapdoor, nullifier, commitment }: Identity, groupOrMerkleProof: Group | MerkleProof, externalNullifier: BytesLike | Hexable | number | bigint, signal: BytesLike | Hexable | number | bigint, snarkArtifacts?: SnarkArtifacts): Promise<FullProof>;

package/dist/types/hash.d.ts

@@ -0,0 +1,7 @@
+import { BytesLike, Hexable } from "@ethersproject/bytes";
+/**
+ * Creates a keccak256 hash of a message compatible with the SNARK scalar modulus.
+ * @param message The message to be hashed.
+ * @returns The message digest.
+ */
+export default function hash(message: BytesLike | Hexable | number | bigint): bigint;

package/dist/types/index.d.ts

@@ -1,7 +1,5 @@
-import generateNullifierHash from "./generateNullifierHash";
 import generateProof from "./generateProof";
 import verifyProof from "./verifyProof";
-import generateSignalHash from "./generateSignalHash";
 import packToSolidityProof from "./packToSolidityProof";
-export { generateNullifierHash, generateProof, verifyProof, generateSignalHash, packToSolidityProof };
+export { generateProof, verifyProof, packToSolidityProof };
 export * from "./types";

package/dist/types/types/index.d.ts

@@ -1,26 +1,26 @@
-export declare type BigNumberish = string | bigint;
-export declare type SnarkArtifacts = {
+export type BigNumberish = string | bigint;
+export type SnarkArtifacts = {
     wasmFilePath: string;
     zkeyFilePath: string;
 };
-export declare type Proof = {
+export type Proof = {
     pi_a: BigNumberish[];
     pi_b: BigNumberish[][];
     pi_c: BigNumberish[];
     protocol: string;
     curve: string;
 };
-export declare type FullProof = {
+export type FullProof = {
     proof: Proof;
     publicSignals: PublicSignals;
 };
-export declare type PublicSignals = {
-    merkleRoot: BigNumberish;
+export type PublicSignals = {
+    merkleTreeRoot: BigNumberish;
     nullifierHash: BigNumberish;
     signalHash: BigNumberish;
     externalNullifier: BigNumberish;
 };
-export declare type SolidityProof = [
+export type SolidityProof = [
     BigNumberish,
     BigNumberish,
     BigNumberish,

package/dist/types/verifyProof.d.ts

@@ -1,8 +1,8 @@
 import { FullProof } from "./types";
 /**
  * Verifies a SnarkJS proof.
- * @param verificationKey The zero-knowledge verification key.
  * @param fullProof The SnarkJS full proof.
+ * @param treeDepth The Merkle tree depth.
  * @returns True if the proof is valid, false otherwise.
  */
-export default function verifyProof(verificationKey: any, { proof, publicSignals }: FullProof): Promise<boolean>;
+export default function verifyProof({ proof, publicSignals }: FullProof, treeDepth: number): Promise<boolean>;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@semaphore-protocol/proof",
-    "version": "2.6.0",
+    "version": "3.0.0-beta.5",
     "description": "A library to generate and verify Semaphore proofs.",
     "license": "MIT",
     "main": "dist/index.node.js",
@@ -30,21 +30,22 @@
         "access": "public"
     },
     "devDependencies": {
+        "@rollup/plugin-json": "^5.0.1",
         "ffjavascript": "^0.2.54",
         "rollup-plugin-cleanup": "^3.2.1",
         "rollup-plugin-typescript2": "^0.31.2",
         "typedoc": "^0.22.11"
     },
     "peerDependencies": {
-        "@semaphore-protocol/group": "2.6.0",
-        "@semaphore-protocol/identity": "2.6.0"
+        "@semaphore-protocol/group": "3.0.0-beta.5",
+        "@semaphore-protocol/identity": "3.0.0-beta.5"
     },
     "dependencies": {
+        "@ethersproject/bignumber": "^5.5.0",
         "@ethersproject/bytes": "^5.7.0",
-        "@ethersproject/solidity": "^5.5.0",
+        "@ethersproject/keccak256": "^5.7.0",
         "@ethersproject/strings": "^5.5.0",
         "@zk-kit/incremental-merkle-tree": "0.4.3",
-        "circomlibjs": "0.0.8",
         "snarkjs": "^0.4.13"
     }
 }

package/src/generateProof.ts

@@ -1,15 +1,16 @@
+import { BytesLike, Hexable } from "@ethersproject/bytes"
 import { Group } from "@semaphore-protocol/group"
 import type { Identity } from "@semaphore-protocol/identity"
 import { MerkleProof } from "@zk-kit/incremental-merkle-tree"
 import { groth16 } from "snarkjs"
-import generateSignalHash from "./generateSignalHash"
-import { BigNumberish, FullProof, SnarkArtifacts } from "./types"
+import hash from "./hash"
+import { FullProof, SnarkArtifacts } from "./types"
 
 export default async function generateProof(
     { trapdoor, nullifier, commitment }: Identity,
     groupOrMerkleProof: Group | MerkleProof,
-    externalNullifier: BigNumberish,
-    signal: string,
+    externalNullifier: BytesLike | Hexable | number | bigint,
+    signal: BytesLike | Hexable | number | bigint,
     snarkArtifacts?: SnarkArtifacts
 ): Promise<FullProof> {
     let merkleProof: MerkleProof
@@ -21,7 +22,7 @@ export default async function generateProof(
             throw new Error("The identity is not part of the group")
         }
 
-        merkleProof = groupOrMerkleProof.generateProofOfMembership(index)
+        merkleProof = groupOrMerkleProof.generateMerkleProof(index)
     } else {
         merkleProof = groupOrMerkleProof
     }
@@ -39,8 +40,8 @@ export default async function generateProof(
             identityNullifier: nullifier,
             treePathIndices: merkleProof.pathIndices,
             treeSiblings: merkleProof.siblings,
-            externalNullifier,
-            signalHash: generateSignalHash(signal)
+            externalNullifier: hash(externalNullifier),
+            signalHash: hash(signal)
         },
         snarkArtifacts.wasmFilePath,
         snarkArtifacts.zkeyFilePath
@@ -49,7 +50,7 @@ export default async function generateProof(
     return {
         proof,
         publicSignals: {
-            merkleRoot: publicSignals[0],
+            merkleTreeRoot: publicSignals[0],
             nullifierHash: publicSignals[1],
             signalHash: publicSignals[2],
             externalNullifier: publicSignals[3]

package/src/hash.ts

@@ -0,0 +1,15 @@
+import { BigNumber } from "@ethersproject/bignumber"
+import { BytesLike, Hexable, zeroPad } from "@ethersproject/bytes"
+import { keccak256 } from "@ethersproject/keccak256"
+
+/**
+ * Creates a keccak256 hash of a message compatible with the SNARK scalar modulus.
+ * @param message The message to be hashed.
+ * @returns The message digest.
+ */
+export default function hash(message: BytesLike | Hexable | number | bigint): bigint {
+    message = BigNumber.from(message).toTwos(256).toHexString()
+    message = zeroPad(message, 32)
+
+    return BigInt(keccak256(message)) >> BigInt(8)
+}

package/src/index.test.ts

@@ -1,11 +1,8 @@
-import { formatBytes32String } from "@ethersproject/strings"
 import { Group } from "@semaphore-protocol/group"
 import { Identity } from "@semaphore-protocol/identity"
 import { getCurveFromName } from "ffjavascript"
-import fs from "fs"
-import generateNullifierHash from "./generateNullifierHash"
 import generateProof from "./generateProof"
-import generateSignalHash from "./generateSignalHash"
+import hash from "./hash"
 import packToSolidityProof from "./packToSolidityProof"
 import { FullProof } from "./types"
 import verifyProof from "./verifyProof"
@@ -13,12 +10,11 @@ import verifyProof from "./verifyProof"
 describe("Proof", () => {
     const treeDepth = Number(process.env.TREE_DEPTH) || 20
 
-    const externalNullifier = "1"
-    const signal = "0x111"
+    const externalNullifier = 1
+    const signal = 2
 
-    const wasmFilePath = `./snark-artifacts/semaphore.wasm`
-    const zkeyFilePath = `./snark-artifacts/semaphore.zkey`
-    const verificationKeyPath = `./snark-artifacts/semaphore.json`
+    const wasmFilePath = `./snark-artifacts/${treeDepth}/semaphore.wasm`
+    const zkeyFilePath = `./snark-artifacts/${treeDepth}/semaphore.zkey`
 
     const identity = new Identity()
 
@@ -69,45 +65,79 @@ describe("Proof", () => {
             })
 
             expect(typeof fullProof).toBe("object")
-            expect(fullProof.publicSignals.externalNullifier).toBe(externalNullifier)
-            expect(fullProof.publicSignals.merkleRoot).toBe(group.root.toString())
+            expect(fullProof.publicSignals.merkleTreeRoot).toBe(group.root.toString())
         }, 20000)
 
-        it("Should generate a Semaphore proof passing a Merkle proof as parametr", async () => {
+        it("Should generate a Semaphore proof passing a Merkle proof as parameter", async () => {
             const group = new Group(treeDepth)
 
             group.addMembers([BigInt(1), BigInt(2), identity.commitment])
 
-            fullProof = await generateProof(identity, group.generateProofOfMembership(2), externalNullifier, signal, {
+            fullProof = await generateProof(identity, group.generateMerkleProof(2), externalNullifier, signal, {
                 wasmFilePath,
                 zkeyFilePath
             })
 
             expect(typeof fullProof).toBe("object")
-            expect(fullProof.publicSignals.externalNullifier).toBe(externalNullifier)
-            expect(fullProof.publicSignals.merkleRoot).toBe(group.root.toString())
+            expect(fullProof.publicSignals.merkleTreeRoot).toBe(group.root.toString())
         }, 20000)
     })
 
-    describe("# generateSignalHash", () => {
-        it("Should generate a valid signal hash", async () => {
-            const signalHash = generateSignalHash(signal)
+    describe("# verifyProof", () => {
+        it("Should not verify a proof if the tree depth is wrong", () => {
+            const fun = () => verifyProof(fullProof, 3)
 
-            expect(signalHash.toString()).toBe(fullProof.publicSignals.signalHash)
+            expect(fun).toThrow("The tree depth must be a number between 16 and 32")
         })
 
-        it("Should generate a valid signal hash by passing a valid hex string", async () => {
-            const signalHash = generateSignalHash(formatBytes32String(signal))
+        it("Should verify a Semaphore proof", async () => {
+            const response = await verifyProof(fullProof, treeDepth)
 
-            expect(signalHash.toString()).toBe(fullProof.publicSignals.signalHash)
+            expect(response).toBe(true)
         })
     })
 
-    describe("# generateNullifierHash", () => {
-        it("Should generate a valid nullifier hash", async () => {
-            const nullifierHash = generateNullifierHash(externalNullifier, identity.getNullifier())
+    describe("# hash", () => {
+        it("Should hash the signal value correctly", async () => {
+            const signalHash = hash(signal)
 
-            expect(nullifierHash.toString()).toBe(fullProof.publicSignals.nullifierHash)
+            expect(signalHash.toString()).toBe(fullProof.publicSignals.signalHash)
+        })
+
+        it("Should hash the external nullifier value correctly", async () => {
+            const externalNullifierHash = hash(externalNullifier)
+
+            expect(externalNullifierHash.toString()).toBe(fullProof.publicSignals.externalNullifier)
+        })
+
+        it("Should hash a number", async () => {
+            expect(hash(2).toString()).toBe(
+                "113682330006535319932160121224458771213356533826860247409332700812532759386"
+            )
+        })
+
+        it("Should hash a big number", async () => {
+            expect(hash(BigInt(2)).toString()).toBe(
+                "113682330006535319932160121224458771213356533826860247409332700812532759386"
+            )
+        })
+
+        it("Should hash an hex number", async () => {
+            expect(hash("0x2").toString()).toBe(
+                "113682330006535319932160121224458771213356533826860247409332700812532759386"
+            )
+        })
+
+        it("Should hash an string number", async () => {
+            expect(hash("2").toString()).toBe(
+                "113682330006535319932160121224458771213356533826860247409332700812532759386"
+            )
+        })
+
+        it("Should hash an array", async () => {
+            expect(hash([2]).toString()).toBe(
+                "113682330006535319932160121224458771213356533826860247409332700812532759386"
+            )
         })
     })
 
@@ -118,14 +148,4 @@ describe("Proof", () => {
             expect(solidityProof).toHaveLength(8)
         })
     })
-
-    describe("# verifyProof", () => {
-        it("Should generate and verify a Semaphore proof", async () => {
-            const verificationKey = JSON.parse(fs.readFileSync(verificationKeyPath, "utf-8"))
-
-            const response = await verifyProof(verificationKey, fullProof)
-
-            expect(response).toBe(true)
-        })
-    })
 })

package/src/index.ts

@@ -1,8 +1,6 @@
-import generateNullifierHash from "./generateNullifierHash"
 import generateProof from "./generateProof"
 import verifyProof from "./verifyProof"
-import generateSignalHash from "./generateSignalHash"
 import packToSolidityProof from "./packToSolidityProof"
 
-export { generateNullifierHash, generateProof, verifyProof, generateSignalHash, packToSolidityProof }
+export { generateProof, verifyProof, packToSolidityProof }
 export * from "./types"

package/src/types/index.ts

@@ -19,7 +19,7 @@ export type FullProof = {
 }
 
 export type PublicSignals = {
-    merkleRoot: BigNumberish
+    merkleTreeRoot: BigNumberish
     nullifierHash: BigNumberish
     signalHash: BigNumberish
     externalNullifier: BigNumberish