@semaphore-protocol/proof 4.0.0-alpha.4 → 4.0.0-alpha.5

package/dist/index.node.js

@@ -1,20 +1,18 @@
 /**
  * @module @semaphore-protocol/proof
- * @version 4.0.0-alpha.4
+ * @version 4.0.0-alpha.5
  * @file A library to generate and verify Semaphore proofs.
  * @copyright Ethereum Foundation 2024
  * @license MIT
  * @see [Github]{@link https://github.com/semaphore-protocol/semaphore/tree/main/packages/proof}
 */
-'use strict';
-
-var bignumber = require('@ethersproject/bignumber');
-var snarkjs = require('snarkjs');
-var download = require('download');
-var fs = require('fs');
-var tmp = require('tmp');
-var bytes = require('@ethersproject/bytes');
-var keccak256 = require('@ethersproject/keccak256');
+import { BigNumber } from '@ethersproject/bignumber';
+import { groth16 } from 'snarkjs';
+import download from 'download';
+import fs from 'fs';
+import tmp from 'tmp';
+import { zeroPad } from '@ethersproject/bytes';
+import { keccak256 } from '@ethersproject/keccak256';
 
 /******************************************************************************
 Copyright (c) Microsoft Corporation.
@@ -30,7 +28,7 @@ LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
 OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
 PERFORMANCE OF THIS SOFTWARE.
 ***************************************************************************** */
-/* global Reflect, Promise */
+/* global Reflect, Promise, SuppressedError, Symbol */
 
 
 var __assign = function() {
@@ -80,147 +78,152 @@ function __generator(thisArg, body) {
         } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
         if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
     }
-}
+}
+
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
 
-function getSnarkArtifacts(treeDepth) {
-    return __awaiter(this, void 0, void 0, function () {
-        var tmpDir, tmpPath;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    tmpDir = "semaphore-proof";
-                    tmpPath = "".concat(tmp.tmpdir, "/").concat(tmpDir, "-").concat(treeDepth);
-                    if (!(!fs.existsSync(tmpPath) || fs.readdirSync(tmpPath).length !== 2)) return [3 /*break*/, 3];
-                    return [4 /*yield*/, download("https://semaphore.cedoor.dev/artifacts/".concat(treeDepth, "/semaphore.wasm"), tmpPath)];
-                case 1:
-                    _a.sent();
-                    return [4 /*yield*/, download("https://semaphore.cedoor.dev/artifacts/".concat(treeDepth, "/semaphore.zkey"), tmpPath)];
-                case 2:
-                    _a.sent();
-                    _a.label = 3;
-                case 3: return [2 /*return*/, {
-                        wasmFilePath: "".concat(tmpPath, "/semaphore.wasm"),
-                        zkeyFilePath: "".concat(tmpPath, "/semaphore.zkey")
-                    }];
-            }
-        });
-    });
+function getSnarkArtifacts(treeDepth) {
+    return __awaiter(this, void 0, void 0, function () {
+        var tmpDir, tmpPath;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    tmpDir = "semaphore-proof";
+                    tmpPath = "".concat(tmp.tmpdir, "/").concat(tmpDir, "-").concat(treeDepth);
+                    if (!(!fs.existsSync(tmpPath) || fs.readdirSync(tmpPath).length !== 2)) return [3 /*break*/, 3];
+                    return [4 /*yield*/, download("https://semaphore.cedoor.dev/artifacts/".concat(treeDepth, "/semaphore.wasm"), tmpPath)];
+                case 1:
+                    _a.sent();
+                    return [4 /*yield*/, download("https://semaphore.cedoor.dev/artifacts/".concat(treeDepth, "/semaphore.zkey"), tmpPath)];
+                case 2:
+                    _a.sent();
+                    _a.label = 3;
+                case 3: return [2 /*return*/, {
+                        wasmFilePath: "".concat(tmpPath, "/semaphore.wasm"),
+                        zkeyFilePath: "".concat(tmpPath, "/semaphore.zkey")
+                    }];
+            }
+        });
+    });
 }
 
-/**
- * Creates a keccak256 hash of a message compatible with the SNARK scalar modulus.
- * @param message The message to be hashed.
- * @returns The message digest.
- */
-function hash(message) {
-    message = bignumber.BigNumber.from(message).toTwos(256).toHexString();
-    message = bytes.zeroPad(message, 32);
-    return (BigInt(keccak256.keccak256(message)) >> BigInt(8)).toString();
+/**
+ * Creates a keccak256 hash of a message compatible with the SNARK scalar modulus.
+ * @param message The message to be hashed.
+ * @returns The message digest.
+ */
+function hash(message) {
+    message = BigNumber.from(message).toTwos(256).toHexString();
+    message = zeroPad(message, 32);
+    return (BigInt(keccak256(message)) >> BigInt(8)).toString();
 }
 
-/**
- * Packs the Groth16 proof points into a format compatible with Semaphore.
- * @param proof The proof points generated with SnarkJS.
- * @returns The proof points compatible with Semaphore.
- */
-function packPoints(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]
-    ];
+/**
+ * Packs the Groth16 proof points into a format compatible with Semaphore.
+ * @param proof The proof points generated with SnarkJS.
+ * @returns The proof points compatible with Semaphore.
+ */
+function packPoints(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]
+    ];
 }
 
-/**
- * Generates a Semaphore proof.
- * @param identity The Semaphore identity.
- * @param groupOrMerkleProof The Semaphore group or its Merkle proof.
- * @param scope The external nullifier.
- * @param message The Semaphore signal.
- * @param merkleTreeDepth The depth of the tree with which the circuit was compiled.
- * @param snarkArtifacts The SNARK artifacts.
- * @returns The Semaphore proof ready to be verified.
- */
-function generateProof(identity, groupOrMerkleProof, message, scope, merkleTreeDepth, snarkArtifacts) {
-    return __awaiter(this, void 0, void 0, function () {
-        var merkleProof, leafIndex, merkleProofLength, merkleProofIndices, merkleProofSiblings, i, _a, proof, publicSignals;
-        return __generator(this, function (_b) {
-            switch (_b.label) {
-                case 0:
-                    if ("siblings" in groupOrMerkleProof) {
-                        merkleProof = groupOrMerkleProof;
-                    }
-                    else {
-                        leafIndex = groupOrMerkleProof.indexOf(identity.commitment);
-                        merkleProof = groupOrMerkleProof.generateMerkleProof(leafIndex);
-                    }
-                    merkleProofLength = merkleProof.siblings.length;
-                    if (merkleTreeDepth !== undefined) {
-                        if (merkleTreeDepth < 1 || merkleTreeDepth > 12) {
-                            throw new TypeError("The tree depth must be a number between 1 and 12");
-                        }
-                    }
-                    else {
-                        merkleTreeDepth = merkleProofLength;
-                    }
-                    if (!!snarkArtifacts) return [3 /*break*/, 2];
-                    return [4 /*yield*/, getSnarkArtifacts(merkleTreeDepth)];
-                case 1:
-                    snarkArtifacts = _b.sent();
-                    _b.label = 2;
-                case 2:
-                    merkleProofIndices = [];
-                    merkleProofSiblings = merkleProof.siblings;
-                    for (i = 0; i < merkleTreeDepth; i += 1) {
-                        merkleProofIndices.push((merkleProof.index >> i) & 1);
-                        if (merkleProofSiblings[i] === undefined) {
-                            merkleProofSiblings[i] = "0";
-                        }
-                    }
-                    return [4 /*yield*/, snarkjs.groth16.fullProve({
-                            secret: identity.secretScalar,
-                            merkleProofLength: merkleProofLength,
-                            merkleProofIndices: merkleProofIndices,
-                            merkleProofSiblings: merkleProofSiblings,
-                            scope: hash(scope),
-                            message: hash(message)
-                        }, snarkArtifacts.wasmFilePath, snarkArtifacts.zkeyFilePath)];
-                case 3:
-                    _a = _b.sent(), proof = _a.proof, publicSignals = _a.publicSignals;
-                    return [2 /*return*/, {
-                            merkleTreeDepth: merkleTreeDepth,
-                            merkleTreeRoot: publicSignals[0],
-                            nullifier: publicSignals[1],
-                            message: bignumber.BigNumber.from(message).toString(),
-                            scope: bignumber.BigNumber.from(scope).toString(),
-                            points: packPoints(proof)
-                        }];
-            }
-        });
-    });
+/**
+ * Generates a Semaphore proof.
+ * @param identity The Semaphore identity.
+ * @param groupOrMerkleProof The Semaphore group or its Merkle proof.
+ * @param scope The external nullifier.
+ * @param message The Semaphore signal.
+ * @param merkleTreeDepth The depth of the tree with which the circuit was compiled.
+ * @param snarkArtifacts The SNARK artifacts.
+ * @returns The Semaphore proof ready to be verified.
+ */
+function generateProof(identity, groupOrMerkleProof, message, scope, merkleTreeDepth, snarkArtifacts) {
+    return __awaiter(this, void 0, void 0, function () {
+        var merkleProof, leafIndex, merkleProofLength, merkleProofIndices, merkleProofSiblings, i, _a, proof, publicSignals;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    if ("siblings" in groupOrMerkleProof) {
+                        merkleProof = groupOrMerkleProof;
+                    }
+                    else {
+                        leafIndex = groupOrMerkleProof.indexOf(identity.commitment);
+                        merkleProof = groupOrMerkleProof.generateMerkleProof(leafIndex);
+                    }
+                    merkleProofLength = merkleProof.siblings.length;
+                    if (merkleTreeDepth !== undefined) {
+                        if (merkleTreeDepth < 1 || merkleTreeDepth > 12) {
+                            throw new TypeError("The tree depth must be a number between 1 and 12");
+                        }
+                    }
+                    else {
+                        merkleTreeDepth = merkleProofLength;
+                    }
+                    if (!!snarkArtifacts) return [3 /*break*/, 2];
+                    return [4 /*yield*/, getSnarkArtifacts(merkleTreeDepth)];
+                case 1:
+                    snarkArtifacts = _b.sent();
+                    _b.label = 2;
+                case 2:
+                    merkleProofIndices = [];
+                    merkleProofSiblings = merkleProof.siblings;
+                    for (i = 0; i < merkleTreeDepth; i += 1) {
+                        merkleProofIndices.push((merkleProof.index >> i) & 1);
+                        if (merkleProofSiblings[i] === undefined) {
+                            merkleProofSiblings[i] = "0";
+                        }
+                    }
+                    return [4 /*yield*/, groth16.fullProve({
+                            secret: identity.secretScalar,
+                            merkleProofLength: merkleProofLength,
+                            merkleProofIndices: merkleProofIndices,
+                            merkleProofSiblings: merkleProofSiblings,
+                            scope: hash(scope),
+                            message: hash(message)
+                        }, snarkArtifacts.wasmFilePath, snarkArtifacts.zkeyFilePath)];
+                case 3:
+                    _a = _b.sent(), proof = _a.proof, publicSignals = _a.publicSignals;
+                    return [2 /*return*/, {
+                            merkleTreeDepth: merkleTreeDepth,
+                            merkleTreeRoot: publicSignals[0],
+                            nullifier: publicSignals[1],
+                            message: BigNumber.from(message).toString(),
+                            scope: BigNumber.from(scope).toString(),
+                            points: packPoints(proof)
+                        }];
+            }
+        });
+    });
 }
 
-/**
- * Unpacks the Groth16 proof points into their original form.
- * @param proof The proof points compatible with Semaphore.
- * @returns The proof points compatible with SnarkJS.
- */
-function unpackPoints(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"
-    };
+/**
+ * Unpacks the Groth16 proof points into their original form.
+ * @param proof The proof points compatible with Semaphore.
+ * @returns The proof points compatible with SnarkJS.
+ */
+function unpackPoints(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";
@@ -797,29 +800,24 @@ var verificationKeys = {
 	IC: IC
 };
 
-/**
- * Verifies a Semaphore proof.
- * @param fullProof The SnarkJS Semaphore proof.
- * @param treeDepth The depth of the tree.
- * @returns True if the proof is valid, false otherwise.
- */
-function verifyProof(_a) {
-    var merkleTreeDepth = _a.merkleTreeDepth, merkleTreeRoot = _a.merkleTreeRoot, nullifier = _a.nullifier, message = _a.message, scope = _a.scope, points = _a.points;
-    return __awaiter(this, void 0, void 0, function () {
-        var verificationKey;
-        return __generator(this, function (_b) {
-            // TODO: support all tree depths after trusted-setup.
-            if (merkleTreeDepth < 1 || merkleTreeDepth > 12) {
-                throw new TypeError("The tree depth must be a number between 1 and 12");
-            }
-            verificationKey = __assign(__assign({}, verificationKeys), { vk_delta_2: verificationKeys.vk_delta_2[merkleTreeDepth - 1], IC: verificationKeys.IC[merkleTreeDepth - 1] });
-            return [2 /*return*/, snarkjs.groth16.verify(verificationKey, [merkleTreeRoot, nullifier, hash(message), hash(scope)], unpackPoints(points))];
-        });
-    });
+/**
+ * Verifies a Semaphore proof.
+ * @param proof The Semaphore proof.
+ * @returns True if the proof is valid, false otherwise.
+ */
+function verifyProof(_a) {
+    var merkleTreeDepth = _a.merkleTreeDepth, merkleTreeRoot = _a.merkleTreeRoot, nullifier = _a.nullifier, message = _a.message, scope = _a.scope, points = _a.points;
+    return __awaiter(this, void 0, void 0, function () {
+        var verificationKey;
+        return __generator(this, function (_b) {
+            // TODO: support all tree depths after trusted-setup.
+            if (merkleTreeDepth < 1 || merkleTreeDepth > 12) {
+                throw new TypeError("The tree depth must be a number between 1 and 12");
+            }
+            verificationKey = __assign(__assign({}, verificationKeys), { vk_delta_2: verificationKeys.vk_delta_2[merkleTreeDepth - 1], IC: verificationKeys.IC[merkleTreeDepth - 1] });
+            return [2 /*return*/, groth16.verify(verificationKey, [merkleTreeRoot, nullifier, hash(message), hash(scope)], unpackPoints(points))];
+        });
+    });
 }
 
-exports.generateProof = generateProof;
-exports.getSnarkArtifacts = getSnarkArtifacts;
-exports.packPoints = packPoints;
-exports.unpackPoints = unpackPoints;
-exports.verifyProof = verifyProof;
+export { generateProof, getSnarkArtifacts, packPoints, unpackPoints, verifyProof };

package/dist/types/generate-proof.d.ts

@@ -1,15 +1,15 @@
-import { BytesLike, Hexable } from "@ethersproject/bytes";
-import type { Group, MerkleProof } from "@semaphore-protocol/group";
-import type { Identity } from "@semaphore-protocol/identity";
-import { SemaphoreProof, SnarkArtifacts } from "./types";
-/**
- * Generates a Semaphore proof.
- * @param identity The Semaphore identity.
- * @param groupOrMerkleProof The Semaphore group or its Merkle proof.
- * @param scope The external nullifier.
- * @param message The Semaphore signal.
- * @param merkleTreeDepth The depth of the tree with which the circuit was compiled.
- * @param snarkArtifacts The SNARK artifacts.
- * @returns The Semaphore proof ready to be verified.
- */
-export default function generateProof(identity: Identity, groupOrMerkleProof: Group | MerkleProof, message: BytesLike | Hexable | number | bigint, scope: BytesLike | Hexable | number | bigint, merkleTreeDepth?: number, snarkArtifacts?: SnarkArtifacts): Promise<SemaphoreProof>;
+import { BytesLike, Hexable } from "@ethersproject/bytes";
+import type { Group, MerkleProof } from "@semaphore-protocol/group";
+import type { Identity } from "@semaphore-protocol/identity";
+import { SemaphoreProof, SnarkArtifacts } from "./types";
+/**
+ * Generates a Semaphore proof.
+ * @param identity The Semaphore identity.
+ * @param groupOrMerkleProof The Semaphore group or its Merkle proof.
+ * @param scope The external nullifier.
+ * @param message The Semaphore signal.
+ * @param merkleTreeDepth The depth of the tree with which the circuit was compiled.
+ * @param snarkArtifacts The SNARK artifacts.
+ * @returns The Semaphore proof ready to be verified.
+ */
+export default function generateProof(identity: Identity, groupOrMerkleProof: Group | MerkleProof, message: BytesLike | Hexable | number | bigint, scope: BytesLike | Hexable | number | bigint, merkleTreeDepth?: number, snarkArtifacts?: SnarkArtifacts): Promise<SemaphoreProof>;

package/dist/types/get-snark-artifacts.browser.d.ts

@@ -1,2 +1,2 @@
-import { SnarkArtifacts } from "./types";
-export default function getSnarkArtifacts(treeDepth: number): Promise<SnarkArtifacts>;
+import { SnarkArtifacts } from "./types";
+export default function getSnarkArtifacts(treeDepth: number): Promise<SnarkArtifacts>;

package/dist/types/get-snark-artifacts.node.d.ts

@@ -1,2 +1,2 @@
-import { SnarkArtifacts } from "./types";
-export default function getSnarkArtifacts(treeDepth: number): Promise<SnarkArtifacts>;
+import { SnarkArtifacts } from "./types";
+export default function getSnarkArtifacts(treeDepth: number): Promise<SnarkArtifacts>;

package/dist/types/hash.d.ts

@@ -1,8 +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): NumericString;
+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): NumericString;

package/dist/types/index.d.ts

@@ -1,7 +1,7 @@
-import generateProof from "./generate-proof";
-import getSnarkArtifacts from "./get-snark-artifacts.node";
-import packPoints from "./pack-points";
-import unpackPoints from "./unpack-points";
-import verifyProof from "./verify-proof";
-export * from "./types";
-export { generateProof, getSnarkArtifacts, packPoints, unpackPoints, verifyProof };
+import generateProof from "./generate-proof";
+import getSnarkArtifacts from "./get-snark-artifacts.node";
+import packPoints from "./pack-points";
+import unpackPoints from "./unpack-points";
+import verifyProof from "./verify-proof";
+export * from "./types";
+export { generateProof, getSnarkArtifacts, packPoints, unpackPoints, verifyProof };

package/dist/types/pack-points.d.ts

@@ -1,8 +1,8 @@
-import { Groth16Proof } from "snarkjs";
-import { PackedPoints } from "./types";
-/**
- * Packs the Groth16 proof points into a format compatible with Semaphore.
- * @param proof The proof points generated with SnarkJS.
- * @returns The proof points compatible with Semaphore.
- */
-export default function packPoints(proof: Groth16Proof): PackedPoints;
+import { Groth16Proof } from "snarkjs";
+import { PackedPoints } from "./types";
+/**
+ * Packs the Groth16 proof points into a format compatible with Semaphore.
+ * @param proof The proof points generated with SnarkJS.
+ * @returns The proof points compatible with Semaphore.
+ */
+export default function packPoints(proof: Groth16Proof): PackedPoints;

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

@@ -1,24 +1,24 @@
-import type { NumericString } from "snarkjs";
-export type BigNumberish = string | number | bigint;
-export type SnarkArtifacts = {
-    wasmFilePath: string;
-    zkeyFilePath: string;
-};
-export type SemaphoreProof = {
-    merkleTreeDepth: number;
-    merkleTreeRoot: NumericString;
-    message: NumericString;
-    nullifier: NumericString;
-    scope: NumericString;
-    points: PackedPoints;
-};
-export type PackedPoints = [
-    NumericString,
-    NumericString,
-    NumericString,
-    NumericString,
-    NumericString,
-    NumericString,
-    NumericString,
-    NumericString
-];
+import type { NumericString } from "snarkjs";
+export type BigNumberish = string | number | bigint;
+export type SnarkArtifacts = {
+    wasmFilePath: string;
+    zkeyFilePath: string;
+};
+export type SemaphoreProof = {
+    merkleTreeDepth: number;
+    merkleTreeRoot: NumericString;
+    message: NumericString;
+    nullifier: NumericString;
+    scope: NumericString;
+    points: PackedPoints;
+};
+export type PackedPoints = [
+    NumericString,
+    NumericString,
+    NumericString,
+    NumericString,
+    NumericString,
+    NumericString,
+    NumericString,
+    NumericString
+];

package/dist/types/unpack-points.d.ts

@@ -1,8 +1,8 @@
-import { Groth16Proof } from "snarkjs";
-import { PackedPoints } from "./types";
-/**
- * Unpacks the Groth16 proof points into their original form.
- * @param proof The proof points compatible with Semaphore.
- * @returns The proof points compatible with SnarkJS.
- */
-export default function unpackPoints(proof: PackedPoints): Groth16Proof;
+import { Groth16Proof } from "snarkjs";
+import { PackedPoints } from "./types";
+/**
+ * Unpacks the Groth16 proof points into their original form.
+ * @param proof The proof points compatible with Semaphore.
+ * @returns The proof points compatible with SnarkJS.
+ */
+export default function unpackPoints(proof: PackedPoints): Groth16Proof;

package/dist/types/verify-proof.d.ts

@@ -1,8 +1,7 @@
-import { SemaphoreProof } from "./types";
-/**
- * Verifies a Semaphore proof.
- * @param fullProof The SnarkJS Semaphore proof.
- * @param treeDepth The depth of the tree.
- * @returns True if the proof is valid, false otherwise.
- */
-export default function verifyProof({ merkleTreeDepth, merkleTreeRoot, nullifier, message, scope, points }: SemaphoreProof): Promise<boolean>;
+import { SemaphoreProof } from "./types";
+/**
+ * Verifies a Semaphore proof.
+ * @param proof The Semaphore proof.
+ * @returns True if the proof is valid, false otherwise.
+ */
+export default function verifyProof({ merkleTreeDepth, merkleTreeRoot, nullifier, message, scope, points }: SemaphoreProof): Promise<boolean>;

package/package.json

@@ -1,22 +1,22 @@
 {
   "name": "@semaphore-protocol/proof",
-  "version": "4.0.0-alpha.4",
+  "version": "4.0.0-alpha.5",
   "description": "A library to generate and verify Semaphore proofs.",
+  "type": "module",
   "license": "MIT",
-  "main": "dist/index.node.js",
-  "browser": "dist/index.browser.mjs",
+  "main": "dist/index.browser.js",
+  "types": "dist/types/index.d.ts",
   "exports": {
     ".": {
+      "types": "./dist/types/index.d.ts",
       "node": {
-        "import": "./dist/index.node.mjs",
-        "require": "./dist/index.node.js"
+        "require": "./dist/index.node.cjs",
+        "default": "./dist/index.node.js"
       },
-      "browser": "./dist/index.browser.mjs",
-      "default": "./dist/index.browser.mjs",
-      "types": "./dist/types/index.d.ts"
+      "browser": "./dist/index.browser.js",
+      "default": "./dist/index.browser.js"
     }
   },
-  "types": "dist/types/index.d.ts",
   "files": [
     "dist/",
     "src/",
@@ -40,18 +40,18 @@
   "devDependencies": {
     "@ethersproject/strings": "^5.7.0",
     "@rollup/plugin-alias": "^5.1.0",
-    "@rollup/plugin-json": "^5.0.1",
+    "@rollup/plugin-json": "^6.1.0",
     "@types/download": "^8.0.5",
     "@types/tmp": "^0.2.6",
     "poseidon-lite": "^0.2.0",
     "rimraf": "^5.0.5",
     "rollup": "^4.0.2",
     "rollup-plugin-cleanup": "^3.2.1",
-    "rollup-plugin-typescript2": "^0.31.2"
+    "rollup-plugin-typescript2": "^0.36.0"
   },
   "peerDependencies": {
-    "@semaphore-protocol/group": "4.0.0-alpha.4",
-    "@semaphore-protocol/identity": "4.0.0-alpha.4"
+    "@semaphore-protocol/group": "4.0.0-alpha.5",
+    "@semaphore-protocol/identity": "4.0.0-alpha.5"
   },
   "dependencies": {
     "@ethersproject/bignumber": "5.7.0",

package/src/verify-proof.ts

@@ -6,8 +6,7 @@ import verificationKeys from "./verification-keys.json"
 
 /**
  * Verifies a Semaphore proof.
- * @param fullProof The SnarkJS Semaphore proof.
- * @param treeDepth The depth of the tree.
+ * @param proof The Semaphore proof.
  * @returns True if the proof is valid, false otherwise.
  */
 export default async function verifyProof({