@semaphore-protocol/proof 4.0.0-beta.3 → 4.0.0-beta.5

package/dist/index.browser.js

@@ -1,6 +1,6 @@
 /**
  * @module @semaphore-protocol/proof
- * @version 4.0.0-beta.3
+ * @version 4.0.0-beta.5
  * @file A library to generate and verify Semaphore proofs.
  * @copyright Ethereum Foundation 2024
  * @license MIT
@@ -15,73 +15,19 @@ import { keccak256 } from 'ethers/crypto';
 import { toBeHex, toBigInt as toBigInt$1 } from 'ethers/utils';
 import { encodeBytes32String } from 'ethers/abi';
 
-var __assign = function() {
-    __assign = Object.assign || function __assign(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
-function __awaiter(thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-}
-function __generator(thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (g && (g = 0, op[0] && (_ = 0)), _) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } 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;
-};
-
+/* istanbul ignore file */
 /**
  * Returns the zero-knowledge artifact paths. Artifacts exist for each tree
  * depth supported by Semaphore, and they were generated in a trusted-setup.
  * @param treeDepth The depth of the tree.
  * @returns The zero-knowledge artifacts paths.
  */
-function getSnarkArtifacts(treeDepth) {
-    return __awaiter(this, void 0, void 0, function () {
-        return __generator(this, function (_a) {
-            requireNumber(treeDepth, "treeDepth");
-            return [2 /*return*/, {
-                    wasmFilePath: "https://semaphore.cedoor.dev/artifacts/".concat(treeDepth, "/semaphore.wasm"),
-                    zkeyFilePath: "https://semaphore.cedoor.dev/artifacts/".concat(treeDepth, "/semaphore.zkey")
-                }];
-        });
-    });
+async function getSnarkArtifacts(treeDepth) {
+    requireNumber(treeDepth, "treeDepth");
+    return {
+        wasmFilePath: `https://semaphore.cedoor.dev/artifacts/${treeDepth}/semaphore.wasm`,
+        zkeyFilePath: `https://semaphore.cedoor.dev/artifacts/${treeDepth}/semaphore.zkey`
+    };
 }
 
 /**
@@ -124,89 +70,80 @@ function toBigInt(value) {
  * or they will be automatically fetched.
  * @param identity The Semaphore identity.
  * @param groupOrMerkleProof The Semaphore group or its Merkle proof.
- * @param scope The Semaphore scope.
  * @param message The Semaphore message.
+ * @param scope The Semaphore scope.
  * @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:
-                    requireDefined(identity, "identity");
-                    requireDefined(groupOrMerkleProof, "groupOrMerkleProof");
-                    requireDefined(message, "message");
-                    requireDefined(scope, "scope");
-                    requireObject(identity, "identity");
-                    requireObject(groupOrMerkleProof, "groupOrMerkleProof");
-                    requireTypes(message, "message", ["string", "bigint", "number", "Uint8Array"]);
-                    requireTypes(scope, "scope", ["string", "bigint", "number", "Uint8Array"]);
-                    if (merkleTreeDepth) {
-                        requireNumber(merkleTreeDepth, "merkleTreeDepth");
-                    }
-                    if (snarkArtifacts) {
-                        requireObject(snarkArtifacts, "snarkArtifacts");
-                    }
-                    // Message and scope can be strings, numbers or buffers (i.e. Uint8Array).
-                    // They will be converted to bigints anyway.
-                    message = toBigInt(message);
-                    scope = toBigInt(scope);
-                    // The second parameter can be either a Merkle proof or a group.
-                    // If it is a group the Merkle proof will be calculated here.
-                    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 < MIN_DEPTH || merkleTreeDepth > MAX_DEPTH) {
-                            throw new TypeError("The tree depth must be a number between ".concat(MIN_DEPTH, " and ").concat(MAX_DEPTH));
-                        }
-                    }
-                    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: message.toString(),
-                            scope: scope.toString(),
-                            points: packGroth16Proof(proof)
-                        }];
-            }
-        });
-    });
+async function generateProof(identity, groupOrMerkleProof, message, scope, merkleTreeDepth, snarkArtifacts) {
+    requireDefined(identity, "identity");
+    requireDefined(groupOrMerkleProof, "groupOrMerkleProof");
+    requireDefined(message, "message");
+    requireDefined(scope, "scope");
+    requireObject(identity, "identity");
+    requireObject(groupOrMerkleProof, "groupOrMerkleProof");
+    requireTypes(message, "message", ["string", "bigint", "number", "Uint8Array"]);
+    requireTypes(scope, "scope", ["string", "bigint", "number", "Uint8Array"]);
+    if (merkleTreeDepth) {
+        requireNumber(merkleTreeDepth, "merkleTreeDepth");
+    }
+    if (snarkArtifacts) {
+        requireObject(snarkArtifacts, "snarkArtifacts");
+    }
+    // Message and scope can be strings, numbers or buffers (i.e. Uint8Array).
+    // They will be converted to bigints anyway.
+    message = toBigInt(message);
+    scope = toBigInt(scope);
+    let merkleProof;
+    // The second parameter can be either a Merkle proof or a group.
+    // If it is a group the Merkle proof will be calculated here.
+    if ("siblings" in groupOrMerkleProof) {
+        merkleProof = groupOrMerkleProof;
+    }
+    else {
+        const leafIndex = groupOrMerkleProof.indexOf(identity.commitment);
+        merkleProof = groupOrMerkleProof.generateMerkleProof(leafIndex);
+    }
+    const merkleProofLength = merkleProof.siblings.length;
+    if (merkleTreeDepth !== undefined) {
+        if (merkleTreeDepth < MIN_DEPTH || merkleTreeDepth > MAX_DEPTH) {
+            throw new TypeError(`The tree depth must be a number between ${MIN_DEPTH} and ${MAX_DEPTH}`);
+        }
+    }
+    else {
+        merkleTreeDepth = merkleProofLength;
+    }
+    // If the Snark artifacts are not defined they will be automatically downloaded.
+    if (!snarkArtifacts) {
+        snarkArtifacts = await getSnarkArtifacts(merkleTreeDepth);
+    }
+    // The index must be converted to a list of indices, 1 for each tree level.
+    // The missing siblings can be set to 0, as they won't be used in the circuit.
+    const merkleProofIndices = [];
+    const merkleProofSiblings = merkleProof.siblings;
+    for (let i = 0; i < merkleTreeDepth; i += 1) {
+        merkleProofIndices.push((merkleProof.index >> i) & 1);
+        if (merkleProofSiblings[i] === undefined) {
+            merkleProofSiblings[i] = "0";
+        }
+    }
+    const { proof, publicSignals } = await groth16.fullProve({
+        secret: identity.secretScalar,
+        merkleProofLength,
+        merkleProofIndices,
+        merkleProofSiblings,
+        scope: hash(scope),
+        message: hash(message)
+    }, snarkArtifacts.wasmFilePath, snarkArtifacts.zkeyFilePath);
+    return {
+        merkleTreeDepth,
+        merkleTreeRoot: publicSignals[0],
+        nullifier: publicSignals[1],
+        message: message.toString(),
+        scope: scope.toString(),
+        points: packGroth16Proof(proof)
+    };
 }
 
 var protocol = "groth16";
@@ -789,26 +726,25 @@ var verificationKeys = {
  * @param proof The Semaphore proof.
  * @returns True if the proof is valid, false otherwise.
  */
-function verifyProof(proof) {
-    return __awaiter(this, void 0, void 0, function () {
-        var merkleTreeDepth, merkleTreeRoot, nullifier, message, scope, points, verificationKey;
-        return __generator(this, function (_a) {
-            requireDefined(proof, "proof");
-            requireObject(proof, "proof");
-            merkleTreeDepth = proof.merkleTreeDepth, merkleTreeRoot = proof.merkleTreeRoot, nullifier = proof.nullifier, message = proof.message, scope = proof.scope, points = proof.points;
-            requireNumber(merkleTreeDepth, "proof.merkleTreeDepth");
-            requireString(merkleTreeRoot, "proof.merkleTreeRoot");
-            requireString(nullifier, "proof.nullifier");
-            requireString(message, "proof.message");
-            requireString(scope, "proof.scope");
-            requireArray(points, "proof.points");
-            if (merkleTreeDepth < MIN_DEPTH || merkleTreeDepth > MAX_DEPTH) {
-                throw new TypeError("The tree depth must be a number between ".concat(MIN_DEPTH, " and ").concat(MAX_DEPTH));
-            }
-            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)], unpackGroth16Proof(points))];
-        });
-    });
+async function verifyProof(proof) {
+    requireDefined(proof, "proof");
+    requireObject(proof, "proof");
+    const { merkleTreeDepth, merkleTreeRoot, nullifier, message, scope, points } = proof;
+    requireNumber(merkleTreeDepth, "proof.merkleTreeDepth");
+    requireString(merkleTreeRoot, "proof.merkleTreeRoot");
+    requireString(nullifier, "proof.nullifier");
+    requireString(message, "proof.message");
+    requireString(scope, "proof.scope");
+    requireArray(points, "proof.points");
+    if (merkleTreeDepth < MIN_DEPTH || merkleTreeDepth > MAX_DEPTH) {
+        throw new TypeError(`The tree depth must be a number between ${MIN_DEPTH} and ${MAX_DEPTH}`);
+    }
+    const verificationKey = {
+        ...verificationKeys,
+        vk_delta_2: verificationKeys.vk_delta_2[merkleTreeDepth - 1],
+        IC: verificationKeys.IC[merkleTreeDepth - 1]
+    };
+    return groth16.verify(verificationKey, [merkleTreeRoot, nullifier, hash(message), hash(scope)], unpackGroth16Proof(points));
 }
 
 export { generateProof, verifyProof };

package/dist/index.node.cjs

@@ -1,6 +1,6 @@
 /**
  * @module @semaphore-protocol/proof
- * @version 4.0.0-beta.3
+ * @version 4.0.0-beta.5
  * @file A library to generate and verify Semaphore proofs.
  * @copyright Ethereum Foundation 2024
  * @license MIT
@@ -13,94 +13,31 @@ var constants = require('@semaphore-protocol/utils/constants');
 var errorHandlers = require('@zk-kit/utils/error-handlers');
 var snarkjs = require('snarkjs');
 var node_fs = require('node:fs');
-var promises$1 = require('node:fs/promises');
+var promises = require('node:fs/promises');
 var os = require('node:os');
 var node_path = require('node:path');
 var node_stream = require('node:stream');
-var promises = require('node:stream/promises');
+var promises$1 = require('node:stream/promises');
 var crypto = require('ethers/crypto');
 var utils = require('ethers/utils');
 var abi = require('ethers/abi');
 
-var __assign = function() {
-    __assign = Object.assign || function __assign(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
-function __awaiter(thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-}
-function __generator(thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (g && (g = 0, op[0] && (_ = 0)), _) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } 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;
-};
-
+/* istanbul ignore file */
 /**
  * A utility function to download the zero-knowledge artifacts from an external server.
  * @param url The URL from which to download the artifacts.
  * @param outputPath The path in which to save the artifacts.
  */
-function download(url, outputPath) {
-    return __awaiter(this, void 0, void 0, function () {
-        var response, dir, fileStream;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0: return [4 /*yield*/, fetch(url)];
-                case 1:
-                    response = _a.sent();
-                    if (!response.ok) {
-                        throw new Error("Failed to fetch ".concat(url, ": ").concat(response.statusText));
-                    }
-                    dir = node_path.dirname(outputPath);
-                    return [4 /*yield*/, promises$1.mkdir(dir, { recursive: true })];
-                case 2:
-                    _a.sent();
-                    fileStream = node_fs.createWriteStream(outputPath);
-                    return [4 /*yield*/, promises.finished(node_stream.Readable.fromWeb(response.body).pipe(fileStream))];
-                case 3:
-                    _a.sent();
-                    return [2 /*return*/];
-            }
-        });
-    });
+async function download(url, outputPath) {
+    const response = await fetch(url);
+    if (!response.ok) {
+        throw new Error(`Failed to fetch ${url}: ${response.statusText}`);
+    }
+    // Ensure the directory exists.
+    const dir = node_path.dirname(outputPath);
+    await promises.mkdir(dir, { recursive: true });
+    const fileStream = node_fs.createWriteStream(outputPath);
+    await promises$1.finished(node_stream.Readable.fromWeb(response.body).pipe(fileStream));
 }
 /**
  * Downloads the zero-knowledge artifacts and returns their paths.
@@ -109,30 +46,18 @@ function download(url, outputPath) {
  * @param treeDepth The depth of the tree.
  * @returns The zero-knowledge artifacts paths.
  */
-function getSnarkArtifacts(treeDepth) {
-    return __awaiter(this, void 0, void 0, function () {
-        var tmpDir, tmpPath;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    errorHandlers.requireNumber(treeDepth, "treeDepth");
-                    tmpDir = "semaphore-proof";
-                    tmpPath = "".concat(os.tmpdir(), "/").concat(tmpDir, "-").concat(treeDepth);
-                    if (!(!node_fs.existsSync(tmpPath) || node_fs.readdirSync(tmpPath).length !== 2)) return [3 /*break*/, 3];
-                    return [4 /*yield*/, download("https://semaphore.cedoor.dev/artifacts/".concat(treeDepth, "/semaphore.wasm"), "".concat(tmpPath, "/semaphore.wasm"))];
-                case 1:
-                    _a.sent();
-                    return [4 /*yield*/, download("https://semaphore.cedoor.dev/artifacts/".concat(treeDepth, "/semaphore.zkey"), "".concat(tmpPath, "/semaphore.zkey"))];
-                case 2:
-                    _a.sent();
-                    _a.label = 3;
-                case 3: return [2 /*return*/, {
-                        wasmFilePath: "".concat(tmpPath, "/semaphore.wasm"),
-                        zkeyFilePath: "".concat(tmpPath, "/semaphore.zkey")
-                    }];
-            }
-        });
-    });
+async function getSnarkArtifacts(treeDepth) {
+    errorHandlers.requireNumber(treeDepth, "treeDepth");
+    const tmpDir = "semaphore-proof";
+    const tmpPath = `${os.tmpdir()}/${tmpDir}-${treeDepth}`;
+    if (!node_fs.existsSync(tmpPath) || node_fs.readdirSync(tmpPath).length !== 2) {
+        await download(`https://semaphore.cedoor.dev/artifacts/${treeDepth}/semaphore.wasm`, `${tmpPath}/semaphore.wasm`);
+        await download(`https://semaphore.cedoor.dev/artifacts/${treeDepth}/semaphore.zkey`, `${tmpPath}/semaphore.zkey`);
+    }
+    return {
+        wasmFilePath: `${tmpPath}/semaphore.wasm`,
+        zkeyFilePath: `${tmpPath}/semaphore.zkey`
+    };
 }
 
 /**
@@ -175,89 +100,80 @@ function toBigInt(value) {
  * or they will be automatically fetched.
  * @param identity The Semaphore identity.
  * @param groupOrMerkleProof The Semaphore group or its Merkle proof.
- * @param scope The Semaphore scope.
  * @param message The Semaphore message.
+ * @param scope The Semaphore scope.
  * @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:
-                    errorHandlers.requireDefined(identity, "identity");
-                    errorHandlers.requireDefined(groupOrMerkleProof, "groupOrMerkleProof");
-                    errorHandlers.requireDefined(message, "message");
-                    errorHandlers.requireDefined(scope, "scope");
-                    errorHandlers.requireObject(identity, "identity");
-                    errorHandlers.requireObject(groupOrMerkleProof, "groupOrMerkleProof");
-                    errorHandlers.requireTypes(message, "message", ["string", "bigint", "number", "Uint8Array"]);
-                    errorHandlers.requireTypes(scope, "scope", ["string", "bigint", "number", "Uint8Array"]);
-                    if (merkleTreeDepth) {
-                        errorHandlers.requireNumber(merkleTreeDepth, "merkleTreeDepth");
-                    }
-                    if (snarkArtifacts) {
-                        errorHandlers.requireObject(snarkArtifacts, "snarkArtifacts");
-                    }
-                    // Message and scope can be strings, numbers or buffers (i.e. Uint8Array).
-                    // They will be converted to bigints anyway.
-                    message = toBigInt(message);
-                    scope = toBigInt(scope);
-                    // The second parameter can be either a Merkle proof or a group.
-                    // If it is a group the Merkle proof will be calculated here.
-                    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 < constants.MIN_DEPTH || merkleTreeDepth > constants.MAX_DEPTH) {
-                            throw new TypeError("The tree depth must be a number between ".concat(constants.MIN_DEPTH, " and ").concat(constants.MAX_DEPTH));
-                        }
-                    }
-                    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: message.toString(),
-                            scope: scope.toString(),
-                            points: proofPacking.packGroth16Proof(proof)
-                        }];
-            }
-        });
-    });
+async function generateProof(identity, groupOrMerkleProof, message, scope, merkleTreeDepth, snarkArtifacts) {
+    errorHandlers.requireDefined(identity, "identity");
+    errorHandlers.requireDefined(groupOrMerkleProof, "groupOrMerkleProof");
+    errorHandlers.requireDefined(message, "message");
+    errorHandlers.requireDefined(scope, "scope");
+    errorHandlers.requireObject(identity, "identity");
+    errorHandlers.requireObject(groupOrMerkleProof, "groupOrMerkleProof");
+    errorHandlers.requireTypes(message, "message", ["string", "bigint", "number", "Uint8Array"]);
+    errorHandlers.requireTypes(scope, "scope", ["string", "bigint", "number", "Uint8Array"]);
+    if (merkleTreeDepth) {
+        errorHandlers.requireNumber(merkleTreeDepth, "merkleTreeDepth");
+    }
+    if (snarkArtifacts) {
+        errorHandlers.requireObject(snarkArtifacts, "snarkArtifacts");
+    }
+    // Message and scope can be strings, numbers or buffers (i.e. Uint8Array).
+    // They will be converted to bigints anyway.
+    message = toBigInt(message);
+    scope = toBigInt(scope);
+    let merkleProof;
+    // The second parameter can be either a Merkle proof or a group.
+    // If it is a group the Merkle proof will be calculated here.
+    if ("siblings" in groupOrMerkleProof) {
+        merkleProof = groupOrMerkleProof;
+    }
+    else {
+        const leafIndex = groupOrMerkleProof.indexOf(identity.commitment);
+        merkleProof = groupOrMerkleProof.generateMerkleProof(leafIndex);
+    }
+    const merkleProofLength = merkleProof.siblings.length;
+    if (merkleTreeDepth !== undefined) {
+        if (merkleTreeDepth < constants.MIN_DEPTH || merkleTreeDepth > constants.MAX_DEPTH) {
+            throw new TypeError(`The tree depth must be a number between ${constants.MIN_DEPTH} and ${constants.MAX_DEPTH}`);
+        }
+    }
+    else {
+        merkleTreeDepth = merkleProofLength;
+    }
+    // If the Snark artifacts are not defined they will be automatically downloaded.
+    if (!snarkArtifacts) {
+        snarkArtifacts = await getSnarkArtifacts(merkleTreeDepth);
+    }
+    // The index must be converted to a list of indices, 1 for each tree level.
+    // The missing siblings can be set to 0, as they won't be used in the circuit.
+    const merkleProofIndices = [];
+    const merkleProofSiblings = merkleProof.siblings;
+    for (let i = 0; i < merkleTreeDepth; i += 1) {
+        merkleProofIndices.push((merkleProof.index >> i) & 1);
+        if (merkleProofSiblings[i] === undefined) {
+            merkleProofSiblings[i] = "0";
+        }
+    }
+    const { proof, publicSignals } = await snarkjs.groth16.fullProve({
+        secret: identity.secretScalar,
+        merkleProofLength,
+        merkleProofIndices,
+        merkleProofSiblings,
+        scope: hash(scope),
+        message: hash(message)
+    }, snarkArtifacts.wasmFilePath, snarkArtifacts.zkeyFilePath);
+    return {
+        merkleTreeDepth,
+        merkleTreeRoot: publicSignals[0],
+        nullifier: publicSignals[1],
+        message: message.toString(),
+        scope: scope.toString(),
+        points: proofPacking.packGroth16Proof(proof)
+    };
 }
 
 var protocol = "groth16";
@@ -840,26 +756,25 @@ var verificationKeys = {
  * @param proof The Semaphore proof.
  * @returns True if the proof is valid, false otherwise.
  */
-function verifyProof(proof) {
-    return __awaiter(this, void 0, void 0, function () {
-        var merkleTreeDepth, merkleTreeRoot, nullifier, message, scope, points, verificationKey;
-        return __generator(this, function (_a) {
-            errorHandlers.requireDefined(proof, "proof");
-            errorHandlers.requireObject(proof, "proof");
-            merkleTreeDepth = proof.merkleTreeDepth, merkleTreeRoot = proof.merkleTreeRoot, nullifier = proof.nullifier, message = proof.message, scope = proof.scope, points = proof.points;
-            errorHandlers.requireNumber(merkleTreeDepth, "proof.merkleTreeDepth");
-            errorHandlers.requireString(merkleTreeRoot, "proof.merkleTreeRoot");
-            errorHandlers.requireString(nullifier, "proof.nullifier");
-            errorHandlers.requireString(message, "proof.message");
-            errorHandlers.requireString(scope, "proof.scope");
-            errorHandlers.requireArray(points, "proof.points");
-            if (merkleTreeDepth < constants.MIN_DEPTH || merkleTreeDepth > constants.MAX_DEPTH) {
-                throw new TypeError("The tree depth must be a number between ".concat(constants.MIN_DEPTH, " and ").concat(constants.MAX_DEPTH));
-            }
-            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)], proofPacking.unpackGroth16Proof(points))];
-        });
-    });
+async function verifyProof(proof) {
+    errorHandlers.requireDefined(proof, "proof");
+    errorHandlers.requireObject(proof, "proof");
+    const { merkleTreeDepth, merkleTreeRoot, nullifier, message, scope, points } = proof;
+    errorHandlers.requireNumber(merkleTreeDepth, "proof.merkleTreeDepth");
+    errorHandlers.requireString(merkleTreeRoot, "proof.merkleTreeRoot");
+    errorHandlers.requireString(nullifier, "proof.nullifier");
+    errorHandlers.requireString(message, "proof.message");
+    errorHandlers.requireString(scope, "proof.scope");
+    errorHandlers.requireArray(points, "proof.points");
+    if (merkleTreeDepth < constants.MIN_DEPTH || merkleTreeDepth > constants.MAX_DEPTH) {
+        throw new TypeError(`The tree depth must be a number between ${constants.MIN_DEPTH} and ${constants.MAX_DEPTH}`);
+    }
+    const verificationKey = {
+        ...verificationKeys,
+        vk_delta_2: verificationKeys.vk_delta_2[merkleTreeDepth - 1],
+        IC: verificationKeys.IC[merkleTreeDepth - 1]
+    };
+    return snarkjs.groth16.verify(verificationKey, [merkleTreeRoot, nullifier, hash(message), hash(scope)], proofPacking.unpackGroth16Proof(points));
 }
 
 Object.defineProperty(exports, "packGroth16Proof", {

package/dist/index.node.js

@@ -1,6 +1,6 @@
 /**
  * @module @semaphore-protocol/proof
- * @version 4.0.0-beta.3
+ * @version 4.0.0-beta.5
  * @file A library to generate and verify Semaphore proofs.
  * @copyright Ethereum Foundation 2024
  * @license MIT
@@ -21,85 +21,22 @@ import { keccak256 } from 'ethers/crypto';
 import { toBeHex, toBigInt as toBigInt$1 } from 'ethers/utils';
 import { encodeBytes32String } from 'ethers/abi';
 
-var __assign = function() {
-    __assign = Object.assign || function __assign(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
-function __awaiter(thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-}
-function __generator(thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (g && (g = 0, op[0] && (_ = 0)), _) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } 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;
-};
-
+/* istanbul ignore file */
 /**
  * A utility function to download the zero-knowledge artifacts from an external server.
  * @param url The URL from which to download the artifacts.
  * @param outputPath The path in which to save the artifacts.
  */
-function download(url, outputPath) {
-    return __awaiter(this, void 0, void 0, function () {
-        var response, dir, fileStream;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0: return [4 /*yield*/, fetch(url)];
-                case 1:
-                    response = _a.sent();
-                    if (!response.ok) {
-                        throw new Error("Failed to fetch ".concat(url, ": ").concat(response.statusText));
-                    }
-                    dir = dirname(outputPath);
-                    return [4 /*yield*/, mkdir(dir, { recursive: true })];
-                case 2:
-                    _a.sent();
-                    fileStream = createWriteStream(outputPath);
-                    return [4 /*yield*/, finished(Readable.fromWeb(response.body).pipe(fileStream))];
-                case 3:
-                    _a.sent();
-                    return [2 /*return*/];
-            }
-        });
-    });
+async function download(url, outputPath) {
+    const response = await fetch(url);
+    if (!response.ok) {
+        throw new Error(`Failed to fetch ${url}: ${response.statusText}`);
+    }
+    // Ensure the directory exists.
+    const dir = dirname(outputPath);
+    await mkdir(dir, { recursive: true });
+    const fileStream = createWriteStream(outputPath);
+    await finished(Readable.fromWeb(response.body).pipe(fileStream));
 }
 /**
  * Downloads the zero-knowledge artifacts and returns their paths.
@@ -108,30 +45,18 @@ function download(url, outputPath) {
  * @param treeDepth The depth of the tree.
  * @returns The zero-knowledge artifacts paths.
  */
-function getSnarkArtifacts(treeDepth) {
-    return __awaiter(this, void 0, void 0, function () {
-        var tmpDir, tmpPath;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    requireNumber(treeDepth, "treeDepth");
-                    tmpDir = "semaphore-proof";
-                    tmpPath = "".concat(os.tmpdir(), "/").concat(tmpDir, "-").concat(treeDepth);
-                    if (!(!existsSync(tmpPath) || readdirSync(tmpPath).length !== 2)) return [3 /*break*/, 3];
-                    return [4 /*yield*/, download("https://semaphore.cedoor.dev/artifacts/".concat(treeDepth, "/semaphore.wasm"), "".concat(tmpPath, "/semaphore.wasm"))];
-                case 1:
-                    _a.sent();
-                    return [4 /*yield*/, download("https://semaphore.cedoor.dev/artifacts/".concat(treeDepth, "/semaphore.zkey"), "".concat(tmpPath, "/semaphore.zkey"))];
-                case 2:
-                    _a.sent();
-                    _a.label = 3;
-                case 3: return [2 /*return*/, {
-                        wasmFilePath: "".concat(tmpPath, "/semaphore.wasm"),
-                        zkeyFilePath: "".concat(tmpPath, "/semaphore.zkey")
-                    }];
-            }
-        });
-    });
+async function getSnarkArtifacts(treeDepth) {
+    requireNumber(treeDepth, "treeDepth");
+    const tmpDir = "semaphore-proof";
+    const tmpPath = `${os.tmpdir()}/${tmpDir}-${treeDepth}`;
+    if (!existsSync(tmpPath) || readdirSync(tmpPath).length !== 2) {
+        await download(`https://semaphore.cedoor.dev/artifacts/${treeDepth}/semaphore.wasm`, `${tmpPath}/semaphore.wasm`);
+        await download(`https://semaphore.cedoor.dev/artifacts/${treeDepth}/semaphore.zkey`, `${tmpPath}/semaphore.zkey`);
+    }
+    return {
+        wasmFilePath: `${tmpPath}/semaphore.wasm`,
+        zkeyFilePath: `${tmpPath}/semaphore.zkey`
+    };
 }
 
 /**
@@ -174,89 +99,80 @@ function toBigInt(value) {
  * or they will be automatically fetched.
  * @param identity The Semaphore identity.
  * @param groupOrMerkleProof The Semaphore group or its Merkle proof.
- * @param scope The Semaphore scope.
  * @param message The Semaphore message.
+ * @param scope The Semaphore scope.
  * @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:
-                    requireDefined(identity, "identity");
-                    requireDefined(groupOrMerkleProof, "groupOrMerkleProof");
-                    requireDefined(message, "message");
-                    requireDefined(scope, "scope");
-                    requireObject(identity, "identity");
-                    requireObject(groupOrMerkleProof, "groupOrMerkleProof");
-                    requireTypes(message, "message", ["string", "bigint", "number", "Uint8Array"]);
-                    requireTypes(scope, "scope", ["string", "bigint", "number", "Uint8Array"]);
-                    if (merkleTreeDepth) {
-                        requireNumber(merkleTreeDepth, "merkleTreeDepth");
-                    }
-                    if (snarkArtifacts) {
-                        requireObject(snarkArtifacts, "snarkArtifacts");
-                    }
-                    // Message and scope can be strings, numbers or buffers (i.e. Uint8Array).
-                    // They will be converted to bigints anyway.
-                    message = toBigInt(message);
-                    scope = toBigInt(scope);
-                    // The second parameter can be either a Merkle proof or a group.
-                    // If it is a group the Merkle proof will be calculated here.
-                    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 < MIN_DEPTH || merkleTreeDepth > MAX_DEPTH) {
-                            throw new TypeError("The tree depth must be a number between ".concat(MIN_DEPTH, " and ").concat(MAX_DEPTH));
-                        }
-                    }
-                    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: message.toString(),
-                            scope: scope.toString(),
-                            points: packGroth16Proof(proof)
-                        }];
-            }
-        });
-    });
+async function generateProof(identity, groupOrMerkleProof, message, scope, merkleTreeDepth, snarkArtifacts) {
+    requireDefined(identity, "identity");
+    requireDefined(groupOrMerkleProof, "groupOrMerkleProof");
+    requireDefined(message, "message");
+    requireDefined(scope, "scope");
+    requireObject(identity, "identity");
+    requireObject(groupOrMerkleProof, "groupOrMerkleProof");
+    requireTypes(message, "message", ["string", "bigint", "number", "Uint8Array"]);
+    requireTypes(scope, "scope", ["string", "bigint", "number", "Uint8Array"]);
+    if (merkleTreeDepth) {
+        requireNumber(merkleTreeDepth, "merkleTreeDepth");
+    }
+    if (snarkArtifacts) {
+        requireObject(snarkArtifacts, "snarkArtifacts");
+    }
+    // Message and scope can be strings, numbers or buffers (i.e. Uint8Array).
+    // They will be converted to bigints anyway.
+    message = toBigInt(message);
+    scope = toBigInt(scope);
+    let merkleProof;
+    // The second parameter can be either a Merkle proof or a group.
+    // If it is a group the Merkle proof will be calculated here.
+    if ("siblings" in groupOrMerkleProof) {
+        merkleProof = groupOrMerkleProof;
+    }
+    else {
+        const leafIndex = groupOrMerkleProof.indexOf(identity.commitment);
+        merkleProof = groupOrMerkleProof.generateMerkleProof(leafIndex);
+    }
+    const merkleProofLength = merkleProof.siblings.length;
+    if (merkleTreeDepth !== undefined) {
+        if (merkleTreeDepth < MIN_DEPTH || merkleTreeDepth > MAX_DEPTH) {
+            throw new TypeError(`The tree depth must be a number between ${MIN_DEPTH} and ${MAX_DEPTH}`);
+        }
+    }
+    else {
+        merkleTreeDepth = merkleProofLength;
+    }
+    // If the Snark artifacts are not defined they will be automatically downloaded.
+    if (!snarkArtifacts) {
+        snarkArtifacts = await getSnarkArtifacts(merkleTreeDepth);
+    }
+    // The index must be converted to a list of indices, 1 for each tree level.
+    // The missing siblings can be set to 0, as they won't be used in the circuit.
+    const merkleProofIndices = [];
+    const merkleProofSiblings = merkleProof.siblings;
+    for (let i = 0; i < merkleTreeDepth; i += 1) {
+        merkleProofIndices.push((merkleProof.index >> i) & 1);
+        if (merkleProofSiblings[i] === undefined) {
+            merkleProofSiblings[i] = "0";
+        }
+    }
+    const { proof, publicSignals } = await groth16.fullProve({
+        secret: identity.secretScalar,
+        merkleProofLength,
+        merkleProofIndices,
+        merkleProofSiblings,
+        scope: hash(scope),
+        message: hash(message)
+    }, snarkArtifacts.wasmFilePath, snarkArtifacts.zkeyFilePath);
+    return {
+        merkleTreeDepth,
+        merkleTreeRoot: publicSignals[0],
+        nullifier: publicSignals[1],
+        message: message.toString(),
+        scope: scope.toString(),
+        points: packGroth16Proof(proof)
+    };
 }
 
 var protocol = "groth16";
@@ -839,26 +755,25 @@ var verificationKeys = {
  * @param proof The Semaphore proof.
  * @returns True if the proof is valid, false otherwise.
  */
-function verifyProof(proof) {
-    return __awaiter(this, void 0, void 0, function () {
-        var merkleTreeDepth, merkleTreeRoot, nullifier, message, scope, points, verificationKey;
-        return __generator(this, function (_a) {
-            requireDefined(proof, "proof");
-            requireObject(proof, "proof");
-            merkleTreeDepth = proof.merkleTreeDepth, merkleTreeRoot = proof.merkleTreeRoot, nullifier = proof.nullifier, message = proof.message, scope = proof.scope, points = proof.points;
-            requireNumber(merkleTreeDepth, "proof.merkleTreeDepth");
-            requireString(merkleTreeRoot, "proof.merkleTreeRoot");
-            requireString(nullifier, "proof.nullifier");
-            requireString(message, "proof.message");
-            requireString(scope, "proof.scope");
-            requireArray(points, "proof.points");
-            if (merkleTreeDepth < MIN_DEPTH || merkleTreeDepth > MAX_DEPTH) {
-                throw new TypeError("The tree depth must be a number between ".concat(MIN_DEPTH, " and ").concat(MAX_DEPTH));
-            }
-            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)], unpackGroth16Proof(points))];
-        });
-    });
+async function verifyProof(proof) {
+    requireDefined(proof, "proof");
+    requireObject(proof, "proof");
+    const { merkleTreeDepth, merkleTreeRoot, nullifier, message, scope, points } = proof;
+    requireNumber(merkleTreeDepth, "proof.merkleTreeDepth");
+    requireString(merkleTreeRoot, "proof.merkleTreeRoot");
+    requireString(nullifier, "proof.nullifier");
+    requireString(message, "proof.message");
+    requireString(scope, "proof.scope");
+    requireArray(points, "proof.points");
+    if (merkleTreeDepth < MIN_DEPTH || merkleTreeDepth > MAX_DEPTH) {
+        throw new TypeError(`The tree depth must be a number between ${MIN_DEPTH} and ${MAX_DEPTH}`);
+    }
+    const verificationKey = {
+        ...verificationKeys,
+        vk_delta_2: verificationKeys.vk_delta_2[merkleTreeDepth - 1],
+        IC: verificationKeys.IC[merkleTreeDepth - 1]
+    };
+    return groth16.verify(verificationKey, [merkleTreeRoot, nullifier, hash(message), hash(scope)], unpackGroth16Proof(points));
 }
 
 export { generateProof, verifyProof };

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

@@ -16,8 +16,8 @@ import { SemaphoreProof, SnarkArtifacts } from "./types";
  * or they will be automatically fetched.
  * @param identity The Semaphore identity.
  * @param groupOrMerkleProof The Semaphore group or its Merkle proof.
- * @param scope The Semaphore scope.
  * @param message The Semaphore message.
+ * @param scope The Semaphore scope.
  * @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.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@semaphore-protocol/proof",
-  "version": "4.0.0-beta.3",
+  "version": "4.0.0-beta.5",
   "description": "A library to generate and verify Semaphore proofs.",
   "type": "module",
   "license": "MIT",
@@ -48,16 +48,13 @@
     "rollup-plugin-cleanup": "^3.2.1"
   },
   "peerDependencies": {
-    "@semaphore-protocol/group": "4.0.0-beta.3",
-    "@semaphore-protocol/identity": "4.0.0-beta.3"
+    "@semaphore-protocol/group": "4.0.0-beta.5",
+    "@semaphore-protocol/identity": "4.0.0-beta.5"
   },
   "dependencies": {
-    "@semaphore-protocol/utils": "4.0.0-beta.3",
+    "@semaphore-protocol/utils": "4.0.0-beta.5",
     "@zk-kit/utils": "0.8.1",
     "ethers": "6.10.0",
     "snarkjs": "0.7.3"
-  },
-  "resolutions": {
-    "web-worker": "1.2.0"
   }
 }

package/src/generate-proof.ts

@@ -24,8 +24,8 @@ import { SemaphoreProof, SnarkArtifacts } from "./types"
  * or they will be automatically fetched.
  * @param identity The Semaphore identity.
  * @param groupOrMerkleProof The Semaphore group or its Merkle proof.
- * @param scope The Semaphore scope.
  * @param message The Semaphore message.
+ * @param scope The Semaphore scope.
  * @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.