@semaphore-protocol/proof 3.11.1 → 3.12.1

package/dist/index.mjs

@@ -1,6 +1,6 @@
 /**
  * @module @semaphore-protocol/proof
- * @version 3.11.1
+ * @version 3.12.1
  * @file A library to generate and verify Semaphore proofs.
  * @copyright Ethereum Foundation 2022
  * @license MIT
@@ -120,7 +120,7 @@ function poseidon2(inputs) {
 function hash(message) {
     message = BigNumber.from(message).toTwos(256).toHexString();
     message = zeroPad(message, 32);
-    return BigInt(keccak256(message)) >> BigInt(8);
+    return (BigInt(keccak256(message)) >> BigInt(8)).toString();
 }
 
 /**
@@ -199,19 +199,19 @@ function __generator(thisArg, body) {
 
 /**
  * Packs a proof into a format compatible with Semaphore.
- * @param originalProof The proof generated with SnarkJS.
+ * @param proof The Groth16 proof generated with SnarkJS.
  * @returns The proof compatible with Semaphore.
  */
-function packProof(originalProof) {
+function packProof(proof) {
     return [
-        originalProof.pi_a[0],
-        originalProof.pi_a[1],
-        originalProof.pi_b[0][1],
-        originalProof.pi_b[0][0],
-        originalProof.pi_b[1][1],
-        originalProof.pi_b[1][0],
-        originalProof.pi_c[0],
-        originalProof.pi_c[1]
+        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/dist/index.node.js

@@ -1,6 +1,6 @@
 /**
  * @module @semaphore-protocol/proof
- * @version 3.11.1
+ * @version 3.12.1
  * @file A library to generate and verify Semaphore proofs.
  * @copyright Ethereum Foundation 2022
  * @license MIT
@@ -124,7 +124,7 @@ function poseidon2(inputs) {
 function hash(message) {
     message = bignumber.BigNumber.from(message).toTwos(256).toHexString();
     message = bytes.zeroPad(message, 32);
-    return BigInt(keccak256.keccak256(message)) >> BigInt(8);
+    return (BigInt(keccak256.keccak256(message)) >> BigInt(8)).toString();
 }
 
 /**
@@ -203,19 +203,19 @@ function __generator(thisArg, body) {
 
 /**
  * Packs a proof into a format compatible with Semaphore.
- * @param originalProof The proof generated with SnarkJS.
+ * @param proof The Groth16 proof generated with SnarkJS.
  * @returns The proof compatible with Semaphore.
  */
-function packProof(originalProof) {
+function packProof(proof) {
     return [
-        originalProof.pi_a[0],
-        originalProof.pi_a[1],
-        originalProof.pi_b[0][1],
-        originalProof.pi_b[0][0],
-        originalProof.pi_b[1][1],
-        originalProof.pi_b[1][0],
-        originalProof.pi_c[0],
-        originalProof.pi_c[1]
+        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/dist/types/generateProof.d.ts

@@ -2,7 +2,7 @@ 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 { FullProof, SnarkArtifacts } from "./types";
+import { SemaphoreProof, SnarkArtifacts } from "./types";
 /**
  * Generates a Semaphore proof.
  * @param identity The Semaphore identity.
@@ -12,4 +12,4 @@ import { FullProof, SnarkArtifacts } from "./types";
  * @param snarkArtifacts The SNARK artifacts.
  * @returns The Semaphore proof ready to be verified.
  */
-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>;
+export default function generateProof({ trapdoor, nullifier, commitment }: Identity, groupOrMerkleProof: Group | MerkleProof, externalNullifier: BytesLike | Hexable | number | bigint, signal: BytesLike | Hexable | number | bigint, snarkArtifacts?: SnarkArtifacts): Promise<SemaphoreProof>;

package/dist/types/hash.d.ts

@@ -1,7 +1,8 @@
 import { BytesLike, Hexable } from "@ethersproject/bytes";
+import { NumericString } from "snarkjs";
 /**
  * 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;
+export default function hash(message: BytesLike | Hexable | number | bigint): NumericString;

package/dist/types/packProof.d.ts

@@ -1,7 +1,8 @@
-import { SnarkJSProof, Proof } from "./types";
+import { Groth16Proof } from "snarkjs";
+import { PackedProof } from "./types";
 /**
  * Packs a proof into a format compatible with Semaphore.
- * @param originalProof The proof generated with SnarkJS.
+ * @param proof The Groth16 proof generated with SnarkJS.
  * @returns The proof compatible with Semaphore.
  */
-export default function packProof(originalProof: SnarkJSProof): Proof;
+export default function packProof(proof: Groth16Proof): PackedProof;

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

@@ -1,29 +1,22 @@
-export type BigNumberish = string | bigint;
+import type { NumericString } from "snarkjs";
 export type SnarkArtifacts = {
     wasmFilePath: string;
     zkeyFilePath: string;
 };
-export type SnarkJSProof = {
-    pi_a: BigNumberish[];
-    pi_b: BigNumberish[][];
-    pi_c: BigNumberish[];
-    protocol: string;
-    curve: string;
+export type SemaphoreProof = {
+    merkleTreeRoot: NumericString;
+    signal: NumericString;
+    nullifierHash: NumericString;
+    externalNullifier: NumericString;
+    proof: PackedProof;
 };
-export type FullProof = {
-    merkleTreeRoot: BigNumberish;
-    signal: BigNumberish;
-    nullifierHash: BigNumberish;
-    externalNullifier: BigNumberish;
-    proof: Proof;
-};
-export type Proof = [
-    BigNumberish,
-    BigNumberish,
-    BigNumberish,
-    BigNumberish,
-    BigNumberish,
-    BigNumberish,
-    BigNumberish,
-    BigNumberish
+export type PackedProof = [
+    NumericString,
+    NumericString,
+    NumericString,
+    NumericString,
+    NumericString,
+    NumericString,
+    NumericString,
+    NumericString
 ];

package/dist/types/unpackProof.d.ts

@@ -1,7 +1,8 @@
-import { SnarkJSProof, Proof } from "./types";
+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: Proof): SnarkJSProof;
+export default function unpackProof(proof: PackedProof): Groth16Proof;

package/dist/types/verifyProof.d.ts

@@ -1,8 +1,8 @@
-import { FullProof } from "./types";
+import { SemaphoreProof } from "./types";
 /**
  * Verifies a Semaphore proof.
  * @param fullProof The SnarkJS Semaphore proof.
  * @param treeDepth The Merkle tree depth.
  * @returns True if the proof is valid, false otherwise.
  */
-export default function verifyProof({ merkleTreeRoot, nullifierHash, externalNullifier, signal, proof }: FullProof, treeDepth: number): Promise<boolean>;
+export default function verifyProof({ merkleTreeRoot, nullifierHash, externalNullifier, signal, proof }: SemaphoreProof, treeDepth: number): Promise<boolean>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@semaphore-protocol/proof",
-  "version": "3.11.1",
+  "version": "3.12.1",
   "description": "A library to generate and verify Semaphore proofs.",
   "license": "MIT",
   "main": "dist/index.node.js",
@@ -23,8 +23,7 @@
   "scripts": {
     "build:watch": "rollup -c rollup.config.ts -w --configPlugin typescript",
     "build": "rimraf dist && rollup -c rollup.config.ts --configPlugin typescript",
-    "prepublishOnly": "yarn build",
-    "docs": "typedoc src/index.ts --out ../../docs/proof"
+    "prepublishOnly": "yarn build"
   },
   "publishConfig": {
     "access": "public"
@@ -36,12 +35,11 @@
     "ffjavascript": "^0.2.54",
     "poseidon-lite": "^0.2.0",
     "rollup-plugin-cleanup": "^3.2.1",
-    "rollup-plugin-typescript2": "^0.31.2",
-    "typedoc": "^0.22.11"
+    "rollup-plugin-typescript2": "^0.31.2"
   },
   "peerDependencies": {
-    "@semaphore-protocol/group": "3.11.1",
-    "@semaphore-protocol/identity": "3.11.1"
+    "@semaphore-protocol/group": "3.12.1",
+    "@semaphore-protocol/identity": "3.12.1"
   },
   "dependencies": {
     "@ethersproject/bignumber": "^5.5.0",
@@ -49,6 +47,6 @@
     "@ethersproject/keccak256": "^5.7.0",
     "@ethersproject/strings": "^5.5.0",
     "@zk-kit/incremental-merkle-tree": "0.4.3",
-    "snarkjs": "0.4.16"
+    "snarkjs": "0.7.1"
   }
 }

package/src/generateProof.ts

@@ -3,10 +3,10 @@ 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 { groth16, NumericString } from "snarkjs"
 import hash from "./hash"
 import packProof from "./packProof"
-import { FullProof, SnarkArtifacts } from "./types"
+import { SemaphoreProof, SnarkArtifacts } from "./types"
 
 /**
  * Generates a Semaphore proof.
@@ -23,7 +23,7 @@ export default async function generateProof(
     externalNullifier: BytesLike | Hexable | number | bigint,
     signal: BytesLike | Hexable | number | bigint,
     snarkArtifacts?: SnarkArtifacts
-): Promise<FullProof> {
+): Promise<SemaphoreProof> {
     let merkleProof: MerkleProof
 
     if ("depth" in groupOrMerkleProof) {
@@ -61,8 +61,8 @@ export default async function generateProof(
     return {
         merkleTreeRoot: publicSignals[0],
         nullifierHash: publicSignals[1],
-        signal: BigNumber.from(signal).toString(),
-        externalNullifier: BigNumber.from(externalNullifier).toString(),
+        signal: BigNumber.from(signal).toString() as NumericString,
+        externalNullifier: BigNumber.from(externalNullifier).toString() as NumericString,
         proof: packProof(proof)
     }
 }

package/src/hash.ts

@@ -1,15 +1,16 @@
 import { BigNumber } from "@ethersproject/bignumber"
 import { BytesLike, Hexable, zeroPad } from "@ethersproject/bytes"
 import { keccak256 } from "@ethersproject/keccak256"
+import { NumericString } from "snarkjs"
 
 /**
  * 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 {
+export default function hash(message: BytesLike | Hexable | number | bigint): NumericString {
     message = BigNumber.from(message).toTwos(256).toHexString()
     message = zeroPad(message, 32)
 
-    return BigInt(keccak256(message)) >> BigInt(8)
+    return (BigInt(keccak256(message)) >> BigInt(8)).toString() as NumericString
 }

package/src/index.test.ts

@@ -6,7 +6,7 @@ import calculateNullifierHash from "./calculateNullifierHash"
 import generateProof from "./generateProof"
 import hash from "./hash"
 import packProof from "./packProof"
-import { FullProof } from "./types"
+import { SemaphoreProof } from "./types"
 import unpackProof from "./unpackProof"
 import verifyProof from "./verifyProof"
 
@@ -21,7 +21,7 @@ describe("Proof", () => {
 
     const identity = new Identity()
 
-    let fullProof: FullProof
+    let fullProof: SemaphoreProof
     let curve: any
 
     beforeAll(async () => {
@@ -34,9 +34,7 @@ describe("Proof", () => {
 
     describe("# generateProof", () => {
         it("Should not generate Semaphore proofs if the identity is not part of the group", async () => {
-            const group = new Group(treeDepth)
-
-            group.addMembers([BigInt(1), BigInt(2)])
+            const group = new Group(treeDepth, 20, [BigInt(1), BigInt(2)])
 
             const fun = () =>
                 generateProof(identity, group, externalNullifier, signal, {
@@ -48,9 +46,7 @@ describe("Proof", () => {
         })
 
         it("Should not generate a Semaphore proof with default snark artifacts with Node.js", async () => {
-            const group = new Group(treeDepth)
-
-            group.addMembers([BigInt(1), BigInt(2), identity.commitment])
+            const group = new Group(treeDepth, 20, [BigInt(1), BigInt(2), identity.commitment])
 
             const fun = () => generateProof(identity, group, externalNullifier, signal)
 
@@ -58,9 +54,7 @@ describe("Proof", () => {
         })
 
         it("Should generate a Semaphore proof passing a group as parameter", async () => {
-            const group = new Group(treeDepth)
-
-            group.addMembers([BigInt(1), BigInt(2), identity.commitment])
+            const group = new Group(treeDepth, 20, [BigInt(1), BigInt(2), identity.commitment])
 
             fullProof = await generateProof(identity, group, externalNullifier, signal, {
                 wasmFilePath,
@@ -72,9 +66,7 @@ describe("Proof", () => {
         }, 20000)
 
         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])
+            const group = new Group(treeDepth, 20, [BigInt(1), BigInt(2), identity.commitment])
 
             fullProof = await generateProof(identity, group.generateMerkleProof(2), externalNullifier, signal, {
                 wasmFilePath,
@@ -104,47 +96,35 @@ describe("Proof", () => {
         it("Should hash the signal value correctly", async () => {
             const signalHash = hash(signal)
 
-            expect(signalHash.toString()).toBe(
-                "8665846418922331996225934941481656421248110469944536651334918563951783029"
-            )
+            expect(signalHash).toBe("8665846418922331996225934941481656421248110469944536651334918563951783029")
         })
 
         it("Should hash the external nullifier value correctly", async () => {
             const externalNullifierHash = hash(externalNullifier)
 
-            expect(externalNullifierHash.toString()).toBe(
+            expect(externalNullifierHash).toBe(
                 "244178201824278269437519042830883072613014992408751798420801126401127326826"
             )
         })
 
         it("Should hash a number", async () => {
-            expect(hash(2).toString()).toBe(
-                "113682330006535319932160121224458771213356533826860247409332700812532759386"
-            )
+            expect(hash(2)).toBe("113682330006535319932160121224458771213356533826860247409332700812532759386")
         })
 
         it("Should hash a big number", async () => {
-            expect(hash(BigInt(2)).toString()).toBe(
-                "113682330006535319932160121224458771213356533826860247409332700812532759386"
-            )
+            expect(hash(BigInt(2))).toBe("113682330006535319932160121224458771213356533826860247409332700812532759386")
         })
 
         it("Should hash an hex number", async () => {
-            expect(hash("0x2").toString()).toBe(
-                "113682330006535319932160121224458771213356533826860247409332700812532759386"
-            )
+            expect(hash("0x2")).toBe("113682330006535319932160121224458771213356533826860247409332700812532759386")
         })
 
         it("Should hash an string number", async () => {
-            expect(hash("2").toString()).toBe(
-                "113682330006535319932160121224458771213356533826860247409332700812532759386"
-            )
+            expect(hash("2")).toBe("113682330006535319932160121224458771213356533826860247409332700812532759386")
         })
 
         it("Should hash an array", async () => {
-            expect(hash([2]).toString()).toBe(
-                "113682330006535319932160121224458771213356533826860247409332700812532759386"
-            )
+            expect(hash([2])).toBe("113682330006535319932160121224458771213356533826860247409332700812532759386")
         })
     })
 

package/src/packProof.ts

@@ -1,19 +1,20 @@
-import { SnarkJSProof, Proof } from "./types"
+import { Groth16Proof } from "snarkjs"
+import { PackedProof } from "./types"
 
 /**
  * Packs a proof into a format compatible with Semaphore.
- * @param originalProof The proof generated with SnarkJS.
+ * @param proof The Groth16 proof generated with SnarkJS.
  * @returns The proof compatible with Semaphore.
  */
-export default function packProof(originalProof: SnarkJSProof): Proof {
+export default function packProof(proof: Groth16Proof): PackedProof {
     return [
-        originalProof.pi_a[0],
-        originalProof.pi_a[1],
-        originalProof.pi_b[0][1],
-        originalProof.pi_b[0][0],
-        originalProof.pi_b[1][1],
-        originalProof.pi_b[1][0],
-        originalProof.pi_c[0],
-        originalProof.pi_c[1]
+        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,33 +1,25 @@
-export type BigNumberish = string | bigint
+import type { NumericString } from "snarkjs"
 
 export type SnarkArtifacts = {
     wasmFilePath: string
     zkeyFilePath: string
 }
 
-export type SnarkJSProof = {
-    pi_a: BigNumberish[]
-    pi_b: BigNumberish[][]
-    pi_c: BigNumberish[]
-    protocol: string
-    curve: string
+export type SemaphoreProof = {
+    merkleTreeRoot: NumericString
+    signal: NumericString
+    nullifierHash: NumericString
+    externalNullifier: NumericString
+    proof: PackedProof
 }
 
-export type FullProof = {
-    merkleTreeRoot: BigNumberish
-    signal: BigNumberish
-    nullifierHash: BigNumberish
-    externalNullifier: BigNumberish
-    proof: Proof
-}
-
-export type Proof = [
-    BigNumberish,
-    BigNumberish,
-    BigNumberish,
-    BigNumberish,
-    BigNumberish,
-    BigNumberish,
-    BigNumberish,
-    BigNumberish
+export type PackedProof = [
+    NumericString,
+    NumericString,
+    NumericString,
+    NumericString,
+    NumericString,
+    NumericString,
+    NumericString,
+    NumericString
 ]

package/src/unpackProof.ts

@@ -1,11 +1,12 @@
-import { SnarkJSProof, Proof } from "./types"
+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: Proof): SnarkJSProof {
+export default function unpackProof(proof: PackedProof): Groth16Proof {
     return {
         pi_a: [proof[0], proof[1]],
         pi_b: [

package/src/verifyProof.ts

@@ -1,6 +1,6 @@
 import { groth16 } from "snarkjs"
 import hash from "./hash"
-import { FullProof } from "./types"
+import { SemaphoreProof } from "./types"
 import unpackProof from "./unpackProof"
 import verificationKeys from "./verificationKeys.json"
 
@@ -11,7 +11,7 @@ import verificationKeys from "./verificationKeys.json"
  * @returns True if the proof is valid, false otherwise.
  */
 export default function verifyProof(
-    { merkleTreeRoot, nullifierHash, externalNullifier, signal, proof }: FullProof,
+    { merkleTreeRoot, nullifierHash, externalNullifier, signal, proof }: SemaphoreProof,
     treeDepth: number
 ): Promise<boolean> {
     if (treeDepth < 16 || treeDepth > 32) {