@semaphore-protocol/proof 3.0.0-beta.6 → 3.0.0-beta.8

package/README.md

@@ -73,12 +73,12 @@ yarn add @semaphore-protocol/identity @semaphore-protocol/group @semaphore-proto
 import { Identity } from "@semaphore-protocol/identity"
 import { Group } from "@semaphore-protocol/group"
 import { generateProof } from "@semaphore-protocol/proof"
-import { formatBytes32String } from "ethers/lib/utils"
+import { utils } from "ethers"
 
 const identity = new Identity()
 const group = new Group()
-const externalNullifier = 1
-const signal = formatBytes32String("Hello world")
+const externalNullifier = utils.formatBytes32String("Topic")
+const signal = utils.formatBytes32String("Hello world")
 
 group.addMembers([...identityCommitments, identity.generateCommitment()])
 
@@ -98,27 +98,3 @@ import { verifyProof } from "@semaphore-protocol/proof"
 
 await verifyProof(fullProof, 20)
 ```
-
-\# **packToSolidityProof**(proof: _Proof_): _SolidityProof_
-
-```typescript
-import { packToSolidityProof } from "@semaphore-protocol/proof"
-
-const solidityProof = packToSolidityProof(fullProof.proof)
-```
-
-\# **generateNullifierHash**(externalNullifier: _BigNumberish_, identityNullifier: _BigNumberish_): _bigint_
-
-```typescript
-import { generateNullifierHash } from "@semaphore-protocol/proof"
-
-const nullifierHash = generateNullifierHash(externalNullifier, identity.getNullifier())
-```
-
-\# **generateSignalHash**(signal: _string_): _bigint_
-
-```typescript
-import { generateSignalHash } from "@semaphore-protocol/proof"
-
-const signalHash = generateSignalHash(signal)
-```

package/dist/index.mjs

@@ -1,13 +1,13 @@
 /**
  * @module @semaphore-protocol/proof
- * @version 3.0.0-beta.6
+ * @version 3.0.0-beta.8
  * @file A library to generate and verify Semaphore proofs.
  * @copyright Ethereum Foundation 2022
  * @license MIT
  * @see [Github]{@link https://github.com/semaphore-protocol/semaphore/tree/main/packages/proof}
 */
-import { groth16 } from 'snarkjs';
 import { BigNumber } from '@ethersproject/bignumber';
+import { groth16 } from 'snarkjs';
 import { zeroPad } from '@ethersproject/bytes';
 import { keccak256 } from '@ethersproject/keccak256';
 
@@ -86,6 +86,33 @@ function hash(message) {
     return BigInt(keccak256(message)) >> BigInt(8);
 }
 
+/**
+ * Packs a proof into a format compatible with Semaphore.
+ * @param originalProof The proof generated with SnarkJS.
+ * @returns The proof compatible with Semaphore.
+ */
+function packProof(originalProof) {
+    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]
+    ];
+}
+
+/**
+ * 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.
+ */
 function generateProof(_a, groupOrMerkleProof, externalNullifier, signal, snarkArtifacts) {
     var trapdoor = _a.trapdoor, nullifier = _a.nullifier, commitment = _a.commitment;
     return __awaiter(this, void 0, void 0, function () {
@@ -120,19 +147,35 @@ function generateProof(_a, groupOrMerkleProof, externalNullifier, signal, snarkA
                 case 1:
                     _b = _c.sent(), proof = _b.proof, publicSignals = _b.publicSignals;
                     return [2 /*return*/, {
-                            proof: proof,
-                            publicSignals: {
-                                merkleTreeRoot: publicSignals[0],
-                                nullifierHash: publicSignals[1],
-                                signalHash: publicSignals[2],
-                                externalNullifier: publicSignals[3]
-                            }
+                            merkleTreeRoot: publicSignals[0],
+                            nullifierHash: publicSignals[1],
+                            signal: BigNumber.from(signal).toString(),
+                            externalNullifier: BigNumber.from(externalNullifier).toString(),
+                            proof: packProof(proof)
                         }];
             }
         });
     });
 }
 
+/**
+ * Unpacks a proof into its original form.
+ * @param proof The proof compatible with Semaphore.
+ * @returns The proof compatible with SnarkJS.
+ */
+function unpackProof(proof) {
+    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"
+    };
+}
+
 var protocol = "groth16";
 var curve = "bn128";
 var nPublic = 4;
@@ -913,41 +956,18 @@ var verificationKeys = {
 };
 
 /**
- * Verifies a SnarkJS proof.
- * @param fullProof The SnarkJS full proof.
+ * 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.
  */
 function verifyProof(_a, treeDepth) {
-    var proof = _a.proof, publicSignals = _a.publicSignals;
+    var merkleTreeRoot = _a.merkleTreeRoot, nullifierHash = _a.nullifierHash, externalNullifier = _a.externalNullifier, signal = _a.signal, proof = _a.proof;
     if (treeDepth < 16 || treeDepth > 32) {
         throw new TypeError("The tree depth must be a number between 16 and 32");
     }
     var verificationKey = __assign(__assign({}, verificationKeys), { vk_delta_2: verificationKeys.vk_delta_2[treeDepth - 16], IC: verificationKeys.IC[treeDepth - 16] });
-    return groth16.verify(verificationKey, [
-        publicSignals.merkleTreeRoot,
-        publicSignals.nullifierHash,
-        publicSignals.signalHash,
-        publicSignals.externalNullifier
-    ], proof);
-}
-
-/**
- * Makes a proof compatible with the Verifier.sol method inputs.
- * @param proof The proof generated with SnarkJS.
- * @returns The Solidity compatible proof.
- */
-function packToSolidityProof(proof) {
-    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]
-    ];
+    return groth16.verify(verificationKey, [merkleTreeRoot, nullifierHash, hash(signal), hash(externalNullifier)], unpackProof(proof));
 }
 
-export { generateProof, packToSolidityProof, verifyProof };
+export { generateProof, verifyProof };

package/dist/index.node.js

@@ -1,6 +1,6 @@
 /**
  * @module @semaphore-protocol/proof
- * @version 3.0.0-beta.6
+ * @version 3.0.0-beta.8
  * @file A library to generate and verify Semaphore proofs.
  * @copyright Ethereum Foundation 2022
  * @license MIT
@@ -10,8 +10,8 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var snarkjs = require('snarkjs');
 var bignumber = require('@ethersproject/bignumber');
+var snarkjs = require('snarkjs');
 var bytes = require('@ethersproject/bytes');
 var keccak256 = require('@ethersproject/keccak256');
 
@@ -90,6 +90,33 @@ function hash(message) {
     return BigInt(keccak256.keccak256(message)) >> BigInt(8);
 }
 
+/**
+ * Packs a proof into a format compatible with Semaphore.
+ * @param originalProof The proof generated with SnarkJS.
+ * @returns The proof compatible with Semaphore.
+ */
+function packProof(originalProof) {
+    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]
+    ];
+}
+
+/**
+ * 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.
+ */
 function generateProof(_a, groupOrMerkleProof, externalNullifier, signal, snarkArtifacts) {
     var trapdoor = _a.trapdoor, nullifier = _a.nullifier, commitment = _a.commitment;
     return __awaiter(this, void 0, void 0, function () {
@@ -124,19 +151,35 @@ function generateProof(_a, groupOrMerkleProof, externalNullifier, signal, snarkA
                 case 1:
                     _b = _c.sent(), proof = _b.proof, publicSignals = _b.publicSignals;
                     return [2 /*return*/, {
-                            proof: proof,
-                            publicSignals: {
-                                merkleTreeRoot: publicSignals[0],
-                                nullifierHash: publicSignals[1],
-                                signalHash: publicSignals[2],
-                                externalNullifier: publicSignals[3]
-                            }
+                            merkleTreeRoot: publicSignals[0],
+                            nullifierHash: publicSignals[1],
+                            signal: bignumber.BigNumber.from(signal).toString(),
+                            externalNullifier: bignumber.BigNumber.from(externalNullifier).toString(),
+                            proof: packProof(proof)
                         }];
             }
         });
     });
 }
 
+/**
+ * Unpacks a proof into its original form.
+ * @param proof The proof compatible with Semaphore.
+ * @returns The proof compatible with SnarkJS.
+ */
+function unpackProof(proof) {
+    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"
+    };
+}
+
 var protocol = "groth16";
 var curve = "bn128";
 var nPublic = 4;
@@ -917,43 +960,19 @@ var verificationKeys = {
 };
 
 /**
- * Verifies a SnarkJS proof.
- * @param fullProof The SnarkJS full proof.
+ * 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.
  */
 function verifyProof(_a, treeDepth) {
-    var proof = _a.proof, publicSignals = _a.publicSignals;
+    var merkleTreeRoot = _a.merkleTreeRoot, nullifierHash = _a.nullifierHash, externalNullifier = _a.externalNullifier, signal = _a.signal, proof = _a.proof;
     if (treeDepth < 16 || treeDepth > 32) {
         throw new TypeError("The tree depth must be a number between 16 and 32");
     }
     var verificationKey = __assign(__assign({}, verificationKeys), { vk_delta_2: verificationKeys.vk_delta_2[treeDepth - 16], IC: verificationKeys.IC[treeDepth - 16] });
-    return snarkjs.groth16.verify(verificationKey, [
-        publicSignals.merkleTreeRoot,
-        publicSignals.nullifierHash,
-        publicSignals.signalHash,
-        publicSignals.externalNullifier
-    ], proof);
-}
-
-/**
- * Makes a proof compatible with the Verifier.sol method inputs.
- * @param proof The proof generated with SnarkJS.
- * @returns The Solidity compatible proof.
- */
-function packToSolidityProof(proof) {
-    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]
-    ];
+    return snarkjs.groth16.verify(verificationKey, [merkleTreeRoot, nullifierHash, hash(signal), hash(externalNullifier)], unpackProof(proof));
 }
 
 exports.generateProof = generateProof;
-exports.packToSolidityProof = packToSolidityProof;
 exports.verifyProof = verifyProof;

package/dist/types/generateProof.d.ts

@@ -3,4 +3,13 @@ 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";
+/**
+ * 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 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/index.d.ts

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

package/dist/types/packProof.d.ts

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

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

@@ -3,7 +3,7 @@ export type SnarkArtifacts = {
     wasmFilePath: string;
     zkeyFilePath: string;
 };
-export type Proof = {
+export type SnarkJSProof = {
     pi_a: BigNumberish[];
     pi_b: BigNumberish[][];
     pi_c: BigNumberish[];
@@ -11,16 +11,13 @@ export type Proof = {
     curve: string;
 };
 export type FullProof = {
-    proof: Proof;
-    publicSignals: PublicSignals;
-};
-export type PublicSignals = {
     merkleTreeRoot: BigNumberish;
+    signal: BigNumberish;
     nullifierHash: BigNumberish;
-    signalHash: BigNumberish;
     externalNullifier: BigNumberish;
+    proof: Proof;
 };
-export type SolidityProof = [
+export type Proof = [
     BigNumberish,
     BigNumberish,
     BigNumberish,

package/dist/types/unpackProof.d.ts

@@ -0,0 +1,7 @@
+import { SnarkJSProof, Proof } 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;

package/dist/types/verifyProof.d.ts

@@ -1,8 +1,8 @@
 import { FullProof } from "./types";
 /**
- * Verifies a SnarkJS proof.
- * @param fullProof The SnarkJS full proof.
+ * 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({ proof, publicSignals }: FullProof, treeDepth: number): Promise<boolean>;
+export default function verifyProof({ merkleTreeRoot, nullifierHash, externalNullifier, signal, proof }: FullProof, treeDepth: number): Promise<boolean>;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@semaphore-protocol/proof",
-    "version": "3.0.0-beta.6",
+    "version": "3.0.0-beta.8",
     "description": "A library to generate and verify Semaphore proofs.",
     "license": "MIT",
     "main": "dist/index.node.js",
@@ -37,8 +37,8 @@
         "typedoc": "^0.22.11"
     },
     "peerDependencies": {
-        "@semaphore-protocol/group": "3.0.0-beta.6",
-        "@semaphore-protocol/identity": "3.0.0-beta.6"
+        "@semaphore-protocol/group": "3.0.0-beta.8",
+        "@semaphore-protocol/identity": "3.0.0-beta.8"
     },
     "dependencies": {
         "@ethersproject/bignumber": "^5.5.0",
@@ -46,6 +46,6 @@
         "@ethersproject/keccak256": "^5.7.0",
         "@ethersproject/strings": "^5.5.0",
         "@zk-kit/incremental-merkle-tree": "0.4.3",
-        "snarkjs": "^0.4.13"
+        "snarkjs": "0.4.13"
     }
 }

package/src/generateProof.ts

@@ -1,11 +1,22 @@
+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 { MerkleProof } from "@zk-kit/incremental-merkle-tree"
 import { groth16 } from "snarkjs"
 import hash from "./hash"
+import packProof from "./packProof"
 import { FullProof, 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,
@@ -48,12 +59,10 @@ export default async function generateProof(
     )
 
     return {
-        proof,
-        publicSignals: {
-            merkleTreeRoot: publicSignals[0],
-            nullifierHash: publicSignals[1],
-            signalHash: publicSignals[2],
-            externalNullifier: publicSignals[3]
-        }
+        merkleTreeRoot: publicSignals[0],
+        nullifierHash: publicSignals[1],
+        signal: BigNumber.from(signal).toString(),
+        externalNullifier: BigNumber.from(externalNullifier).toString(),
+        proof: packProof(proof)
     }
 }

package/src/index.test.ts

@@ -1,17 +1,19 @@
+import { formatBytes32String } from "@ethersproject/strings"
 import { Group } from "@semaphore-protocol/group"
 import { Identity } from "@semaphore-protocol/identity"
 import { getCurveFromName } from "ffjavascript"
 import generateProof from "./generateProof"
 import hash from "./hash"
-import packToSolidityProof from "./packToSolidityProof"
+import packProof from "./packProof"
 import { FullProof } from "./types"
+import unpackProof from "./unpackProof"
 import verifyProof from "./verifyProof"
 
 describe("Proof", () => {
     const treeDepth = Number(process.env.TREE_DEPTH) || 20
 
-    const externalNullifier = 1
-    const signal = 2
+    const externalNullifier = formatBytes32String("Topic")
+    const signal = formatBytes32String("Hello world")
 
     const wasmFilePath = `./snark-artifacts/${treeDepth}/semaphore.wasm`
     const zkeyFilePath = `./snark-artifacts/${treeDepth}/semaphore.zkey`
@@ -65,7 +67,7 @@ describe("Proof", () => {
             })
 
             expect(typeof fullProof).toBe("object")
-            expect(fullProof.publicSignals.merkleTreeRoot).toBe(group.root.toString())
+            expect(fullProof.merkleTreeRoot).toBe(group.root.toString())
         }, 20000)
 
         it("Should generate a Semaphore proof passing a Merkle proof as parameter", async () => {
@@ -79,7 +81,7 @@ describe("Proof", () => {
             })
 
             expect(typeof fullProof).toBe("object")
-            expect(fullProof.publicSignals.merkleTreeRoot).toBe(group.root.toString())
+            expect(fullProof.merkleTreeRoot).toBe(group.root.toString())
         }, 20000)
     })
 
@@ -101,13 +103,17 @@ describe("Proof", () => {
         it("Should hash the signal value correctly", async () => {
             const signalHash = hash(signal)
 
-            expect(signalHash.toString()).toBe(fullProof.publicSignals.signalHash)
+            expect(signalHash.toString()).toBe(
+                "8665846418922331996225934941481656421248110469944536651334918563951783029"
+            )
         })
 
         it("Should hash the external nullifier value correctly", async () => {
             const externalNullifierHash = hash(externalNullifier)
 
-            expect(externalNullifierHash.toString()).toBe(fullProof.publicSignals.externalNullifier)
+            expect(externalNullifierHash.toString()).toBe(
+                "244178201824278269437519042830883072613014992408751798420801126401127326826"
+            )
         })
 
         it("Should hash a number", async () => {
@@ -141,11 +147,12 @@ describe("Proof", () => {
         })
     })
 
-    describe("# packToSolidityProof", () => {
-        it("Should return a Solidity proof", async () => {
-            const solidityProof = packToSolidityProof(fullProof.proof)
+    describe("# packProof/unpackProof", () => {
+        it("Should return a packed proof", async () => {
+            const originalProof = unpackProof(fullProof.proof)
+            const proof = packProof(originalProof)
 
-            expect(solidityProof).toHaveLength(8)
+            expect(proof).toStrictEqual(fullProof.proof)
         })
     })
 })

package/src/index.ts

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

package/src/packProof.ts

@@ -0,0 +1,19 @@
+import { SnarkJSProof, Proof } from "./types"
+
+/**
+ * Packs a proof into a format compatible with Semaphore.
+ * @param originalProof The proof generated with SnarkJS.
+ * @returns The proof compatible with Semaphore.
+ */
+export default function packProof(originalProof: SnarkJSProof): 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]
+    ]
+}

package/src/types/index.ts

@@ -5,7 +5,7 @@ export type SnarkArtifacts = {
     zkeyFilePath: string
 }
 
-export type Proof = {
+export type SnarkJSProof = {
     pi_a: BigNumberish[]
     pi_b: BigNumberish[][]
     pi_c: BigNumberish[]
@@ -14,18 +14,14 @@ export type Proof = {
 }
 
 export type FullProof = {
-    proof: Proof
-    publicSignals: PublicSignals
-}
-
-export type PublicSignals = {
     merkleTreeRoot: BigNumberish
+    signal: BigNumberish
     nullifierHash: BigNumberish
-    signalHash: BigNumberish
     externalNullifier: BigNumberish
+    proof: Proof
 }
 
-export type SolidityProof = [
+export type Proof = [
     BigNumberish,
     BigNumberish,
     BigNumberish,

package/src/unpackProof.ts

@@ -0,0 +1,19 @@
+import { SnarkJSProof, Proof } 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 {
+    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"
+    }
+}

package/src/verifyProof.ts

@@ -1,14 +1,19 @@
 import { groth16 } from "snarkjs"
+import hash from "./hash"
 import { FullProof } from "./types"
+import unpackProof from "./unpackProof"
 import verificationKeys from "./verificationKeys.json"
 
 /**
- * Verifies a SnarkJS proof.
- * @param fullProof The SnarkJS full proof.
+ * 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({ proof, publicSignals }: FullProof, treeDepth: number): Promise<boolean> {
+export default function verifyProof(
+    { merkleTreeRoot, nullifierHash, externalNullifier, signal, proof }: FullProof,
+    treeDepth: number
+): Promise<boolean> {
     if (treeDepth < 16 || treeDepth > 32) {
         throw new TypeError("The tree depth must be a number between 16 and 32")
     }
@@ -21,12 +26,7 @@ export default function verifyProof({ proof, publicSignals }: FullProof, treeDep
 
     return groth16.verify(
         verificationKey,
-        [
-            publicSignals.merkleTreeRoot,
-            publicSignals.nullifierHash,
-            publicSignals.signalHash,
-            publicSignals.externalNullifier
-        ],
-        proof
+        [merkleTreeRoot, nullifierHash, hash(signal), hash(externalNullifier)],
+        unpackProof(proof)
     )
 }

package/dist/types/packToSolidityProof.d.ts

@@ -1,7 +0,0 @@
-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;

package/src/packToSolidityProof.ts

@@ -1,19 +0,0 @@
-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]
-    ]
-}