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

package/dist/index.browser.js

@@ -1,88 +1,69 @@
 /**
  * @module @semaphore-protocol/proof
- * @version 4.0.0-beta.1
+ * @version 4.0.0-beta.3
  * @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}
 */
-import { packGroth16Proof, unpackGroth16Proof } from '@zk-kit/utils';
-export { packGroth16Proof, unpackGroth16Proof } from '@zk-kit/utils';
-import { requireNumber, requireDefined, requireObject, requireTypes, requireString, requireArray } from '@semaphore-protocol/utils/errors';
+import { packGroth16Proof, unpackGroth16Proof } from '@zk-kit/utils/proof-packing';
+export { packGroth16Proof, unpackGroth16Proof } from '@zk-kit/utils/proof-packing';
+import { MIN_DEPTH, MAX_DEPTH } from '@semaphore-protocol/utils/constants';
+import { requireNumber, requireDefined, requireObject, requireTypes, requireString, requireArray } from '@zk-kit/utils/error-handlers';
 import { groth16 } from 'snarkjs';
 import { keccak256 } from 'ethers/crypto';
 import { toBeHex, toBigInt as toBigInt$1 } from 'ethers/utils';
 import { encodeBytes32String } from 'ethers/abi';
 
-/******************************************************************************
-Copyright (c) Microsoft Corporation.
-
-Permission to use, copy, modify, and/or distribute this software for any
-purpose with or without fee is hereby granted.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-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, SuppressedError, Symbol */
-
-
-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;
+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;
 };
 
 /**
@@ -113,7 +94,7 @@ function hash(message) {
 }
 
 /**
- * Converts a bignumberish to a bigint.
+ * Converts a bignumberish or a text to a bigint.
  * @param value The value to be converted to bigint.
  * @return The value converted to bigint.
  */
@@ -161,8 +142,8 @@ function generateProof(identity, groupOrMerkleProof, message, scope, merkleTreeD
                     requireDefined(scope, "scope");
                     requireObject(identity, "identity");
                     requireObject(groupOrMerkleProof, "groupOrMerkleProof");
-                    requireTypes(message, "message", ["string", "bigint", "number", "uint8array"]);
-                    requireTypes(scope, "scope", ["string", "bigint", "number", "uint8array"]);
+                    requireTypes(message, "message", ["string", "bigint", "number", "Uint8Array"]);
+                    requireTypes(scope, "scope", ["string", "bigint", "number", "Uint8Array"]);
                     if (merkleTreeDepth) {
                         requireNumber(merkleTreeDepth, "merkleTreeDepth");
                     }
@@ -184,8 +165,8 @@ function generateProof(identity, groupOrMerkleProof, message, scope, merkleTreeD
                     }
                     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");
+                        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 {
@@ -821,9 +802,8 @@ function verifyProof(proof) {
             requireString(message, "proof.message");
             requireString(scope, "proof.scope");
             requireArray(points, "proof.points");
-            // 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");
+            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))];

package/dist/index.node.cjs

@@ -1,6 +1,6 @@
 /**
  * @module @semaphore-protocol/proof
- * @version 4.0.0-beta.1
+ * @version 4.0.0-beta.3
  * @file A library to generate and verify Semaphore proofs.
  * @copyright Ethereum Foundation 2024
  * @license MIT
@@ -8,8 +8,9 @@
 */
 'use strict';
 
-var utils = require('@zk-kit/utils');
-var errors = require('@semaphore-protocol/utils/errors');
+var proofPacking = require('@zk-kit/utils/proof-packing');
+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');
@@ -18,78 +19,58 @@ var node_path = require('node:path');
 var node_stream = require('node:stream');
 var promises = require('node:stream/promises');
 var crypto = require('ethers/crypto');
-var utils$1 = require('ethers/utils');
+var utils = require('ethers/utils');
 var abi = require('ethers/abi');
 
-/******************************************************************************
-Copyright (c) Microsoft Corporation.
-
-Permission to use, copy, modify, and/or distribute this software for any
-purpose with or without fee is hereby granted.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-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, SuppressedError, Symbol */
-
-
-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;
+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;
 };
 
 /**
@@ -134,7 +115,7 @@ function getSnarkArtifacts(treeDepth) {
         return __generator(this, function (_a) {
             switch (_a.label) {
                 case 0:
-                    errors.requireNumber(treeDepth, "treeDepth");
+                    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];
@@ -160,21 +141,21 @@ function getSnarkArtifacts(treeDepth) {
  * @returns The message digest.
  */
 function hash(message) {
-    return (BigInt(crypto.keccak256(utils$1.toBeHex(message, 32))) >> BigInt(8)).toString();
+    return (BigInt(crypto.keccak256(utils.toBeHex(message, 32))) >> BigInt(8)).toString();
 }
 
 /**
- * Converts a bignumberish to a bigint.
+ * Converts a bignumberish or a text to a bigint.
  * @param value The value to be converted to bigint.
  * @return The value converted to bigint.
  */
 function toBigInt(value) {
     try {
-        return utils$1.toBigInt(value);
+        return utils.toBigInt(value);
     }
     catch (error) {
         if (typeof value === "string") {
-            return utils$1.toBigInt(abi.encodeBytes32String(value));
+            return utils.toBigInt(abi.encodeBytes32String(value));
         }
         throw TypeError(error.message);
     }
@@ -206,19 +187,19 @@ function generateProof(identity, groupOrMerkleProof, message, scope, merkleTreeD
         return __generator(this, function (_b) {
             switch (_b.label) {
                 case 0:
-                    errors.requireDefined(identity, "identity");
-                    errors.requireDefined(groupOrMerkleProof, "groupOrMerkleProof");
-                    errors.requireDefined(message, "message");
-                    errors.requireDefined(scope, "scope");
-                    errors.requireObject(identity, "identity");
-                    errors.requireObject(groupOrMerkleProof, "groupOrMerkleProof");
-                    errors.requireTypes(message, "message", ["string", "bigint", "number", "uint8array"]);
-                    errors.requireTypes(scope, "scope", ["string", "bigint", "number", "uint8array"]);
+                    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) {
-                        errors.requireNumber(merkleTreeDepth, "merkleTreeDepth");
+                        errorHandlers.requireNumber(merkleTreeDepth, "merkleTreeDepth");
                     }
                     if (snarkArtifacts) {
-                        errors.requireObject(snarkArtifacts, "snarkArtifacts");
+                        errorHandlers.requireObject(snarkArtifacts, "snarkArtifacts");
                     }
                     // Message and scope can be strings, numbers or buffers (i.e. Uint8Array).
                     // They will be converted to bigints anyway.
@@ -235,8 +216,8 @@ function generateProof(identity, groupOrMerkleProof, message, scope, merkleTreeD
                     }
                     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");
+                        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 {
@@ -272,7 +253,7 @@ function generateProof(identity, groupOrMerkleProof, message, scope, merkleTreeD
                             nullifier: publicSignals[1],
                             message: message.toString(),
                             scope: scope.toString(),
-                            points: utils.packGroth16Proof(proof)
+                            points: proofPacking.packGroth16Proof(proof)
                         }];
             }
         });
@@ -863,32 +844,31 @@ function verifyProof(proof) {
     return __awaiter(this, void 0, void 0, function () {
         var merkleTreeDepth, merkleTreeRoot, nullifier, message, scope, points, verificationKey;
         return __generator(this, function (_a) {
-            errors.requireDefined(proof, "proof");
-            errors.requireObject(proof, "proof");
+            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;
-            errors.requireNumber(merkleTreeDepth, "proof.merkleTreeDepth");
-            errors.requireString(merkleTreeRoot, "proof.merkleTreeRoot");
-            errors.requireString(nullifier, "proof.nullifier");
-            errors.requireString(message, "proof.message");
-            errors.requireString(scope, "proof.scope");
-            errors.requireArray(points, "proof.points");
-            // 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");
+            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)], utils.unpackGroth16Proof(points))];
+            return [2 /*return*/, snarkjs.groth16.verify(verificationKey, [merkleTreeRoot, nullifier, hash(message), hash(scope)], proofPacking.unpackGroth16Proof(points))];
         });
     });
 }
 
 Object.defineProperty(exports, "packGroth16Proof", {
     enumerable: true,
-    get: function () { return utils.packGroth16Proof; }
+    get: function () { return proofPacking.packGroth16Proof; }
 });
 Object.defineProperty(exports, "unpackGroth16Proof", {
     enumerable: true,
-    get: function () { return utils.unpackGroth16Proof; }
+    get: function () { return proofPacking.unpackGroth16Proof; }
 });
 exports.generateProof = generateProof;
 exports.verifyProof = verifyProof;

package/dist/index.node.js

@@ -1,14 +1,15 @@
 /**
  * @module @semaphore-protocol/proof
- * @version 4.0.0-beta.1
+ * @version 4.0.0-beta.3
  * @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}
 */
-import { packGroth16Proof, unpackGroth16Proof } from '@zk-kit/utils';
-export { packGroth16Proof, unpackGroth16Proof } from '@zk-kit/utils';
-import { requireNumber, requireDefined, requireObject, requireTypes, requireString, requireArray } from '@semaphore-protocol/utils/errors';
+import { packGroth16Proof, unpackGroth16Proof } from '@zk-kit/utils/proof-packing';
+export { packGroth16Proof, unpackGroth16Proof } from '@zk-kit/utils/proof-packing';
+import { MIN_DEPTH, MAX_DEPTH } from '@semaphore-protocol/utils/constants';
+import { requireNumber, requireDefined, requireObject, requireTypes, requireString, requireArray } from '@zk-kit/utils/error-handlers';
 import { groth16 } from 'snarkjs';
 import { existsSync, readdirSync, createWriteStream } from 'node:fs';
 import { mkdir } from 'node:fs/promises';
@@ -20,75 +21,55 @@ import { keccak256 } from 'ethers/crypto';
 import { toBeHex, toBigInt as toBigInt$1 } from 'ethers/utils';
 import { encodeBytes32String } from 'ethers/abi';
 
-/******************************************************************************
-Copyright (c) Microsoft Corporation.
-
-Permission to use, copy, modify, and/or distribute this software for any
-purpose with or without fee is hereby granted.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-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, SuppressedError, Symbol */
-
-
-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;
+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;
 };
 
 /**
@@ -163,7 +144,7 @@ function hash(message) {
 }
 
 /**
- * Converts a bignumberish to a bigint.
+ * Converts a bignumberish or a text to a bigint.
  * @param value The value to be converted to bigint.
  * @return The value converted to bigint.
  */
@@ -211,8 +192,8 @@ function generateProof(identity, groupOrMerkleProof, message, scope, merkleTreeD
                     requireDefined(scope, "scope");
                     requireObject(identity, "identity");
                     requireObject(groupOrMerkleProof, "groupOrMerkleProof");
-                    requireTypes(message, "message", ["string", "bigint", "number", "uint8array"]);
-                    requireTypes(scope, "scope", ["string", "bigint", "number", "uint8array"]);
+                    requireTypes(message, "message", ["string", "bigint", "number", "Uint8Array"]);
+                    requireTypes(scope, "scope", ["string", "bigint", "number", "Uint8Array"]);
                     if (merkleTreeDepth) {
                         requireNumber(merkleTreeDepth, "merkleTreeDepth");
                     }
@@ -234,8 +215,8 @@ function generateProof(identity, groupOrMerkleProof, message, scope, merkleTreeD
                     }
                     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");
+                        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 {
@@ -871,9 +852,8 @@ function verifyProof(proof) {
             requireString(message, "proof.message");
             requireString(scope, "proof.scope");
             requireArray(points, "proof.points");
-            // 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");
+            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))];

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

@@ -1,6 +1,7 @@
 import type { Group, MerkleProof } from "@semaphore-protocol/group";
 import type { Identity } from "@semaphore-protocol/identity";
-import { BigNumberish, SemaphoreProof, SnarkArtifacts } from "./types";
+import type { BigNumberish } from "ethers";
+import { SemaphoreProof, SnarkArtifacts } from "./types";
 /**
  * It generates a Semaphore proof, i.e. a zero-knowledge proof that an identity that
  * is part of a group has shared an anonymous message.

package/dist/types/hash.d.ts

@@ -1,5 +1,5 @@
+import type { BigNumberish } from "ethers";
 import { NumericString } from "snarkjs";
-import { BigNumberish } from "./types";
 /**
  * Creates a keccak256 hash of a message compatible with the SNARK scalar modulus.
  * @param message The message to be hashed.

package/dist/types/index.d.ts

@@ -1,4 +1,4 @@
-import { packGroth16Proof, unpackGroth16Proof } from "@zk-kit/utils";
+import { packGroth16Proof, unpackGroth16Proof } from "@zk-kit/utils/proof-packing";
 import generateProof from "./generate-proof";
 import verifyProof from "./verify-proof";
 export * from "./types";

package/dist/types/to-bigint.d.ts

@@ -1,6 +1,6 @@
-import { BigNumberish } from "./types";
+import type { BigNumberish } from "ethers";
 /**
- * Converts a bignumberish to a bigint.
+ * Converts a bignumberish or a text to a bigint.
  * @param value The value to be converted to bigint.
  * @return The value converted to bigint.
  */

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

@@ -1,5 +1,5 @@
 import type { NumericString } from "snarkjs";
-export type BigNumberish = string | number | bigint;
+import type { PackedGroth16Proof } from "@zk-kit/utils";
 export type SnarkArtifacts = {
     wasmFilePath: string;
     zkeyFilePath: string;
@@ -10,15 +10,5 @@ export type SemaphoreProof = {
     message: NumericString;
     nullifier: NumericString;
     scope: NumericString;
-    points: PackedPoints;
+    points: PackedGroth16Proof;
 };
-export type PackedPoints = [
-    NumericString,
-    NumericString,
-    NumericString,
-    NumericString,
-    NumericString,
-    NumericString,
-    NumericString,
-    NumericString
-];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@semaphore-protocol/proof",
-  "version": "4.0.0-beta.1",
+  "version": "4.0.0-beta.3",
   "description": "A library to generate and verify Semaphore proofs.",
   "type": "module",
   "license": "MIT",
@@ -40,23 +40,24 @@
   "devDependencies": {
     "@rollup/plugin-alias": "^5.1.0",
     "@rollup/plugin-json": "^6.1.0",
-    "@types/download": "^8.0.5",
-    "@types/snarkjs": "0.7.8",
-    "@types/tmp": "^0.2.6",
+    "@rollup/plugin-typescript": "^11.1.6",
+    "@types/snarkjs": "^0",
     "poseidon-lite": "^0.2.0",
     "rimraf": "^5.0.5",
-    "rollup": "^4.9.6",
-    "rollup-plugin-cleanup": "^3.2.1",
-    "rollup-plugin-typescript2": "^0.36.0"
+    "rollup": "^4.12.0",
+    "rollup-plugin-cleanup": "^3.2.1"
   },
   "peerDependencies": {
-    "@semaphore-protocol/group": "4.0.0-beta.1",
-    "@semaphore-protocol/identity": "4.0.0-beta.1"
+    "@semaphore-protocol/group": "4.0.0-beta.3",
+    "@semaphore-protocol/identity": "4.0.0-beta.3"
   },
   "dependencies": {
-    "@semaphore-protocol/utils": "4.0.0-beta.1",
-    "@zk-kit/utils": "0.3.0",
+    "@semaphore-protocol/utils": "4.0.0-beta.3",
+    "@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

@@ -1,12 +1,14 @@
 import type { Group, MerkleProof } from "@semaphore-protocol/group"
 import type { Identity } from "@semaphore-protocol/identity"
-import { requireDefined, requireNumber, requireObject, requireTypes } from "@semaphore-protocol/utils/errors"
+import { MAX_DEPTH, MIN_DEPTH } from "@semaphore-protocol/utils/constants"
+import { requireDefined, requireNumber, requireObject, requireTypes } from "@zk-kit/utils/error-handlers"
+import { packGroth16Proof } from "@zk-kit/utils/proof-packing"
+import type { BigNumberish } from "ethers"
 import { NumericString, groth16 } from "snarkjs"
-import { packGroth16Proof } from "@zk-kit/utils"
 import getSnarkArtifacts from "./get-snark-artifacts.node"
 import hash from "./hash"
 import toBigInt from "./to-bigint"
-import { BigNumberish, SemaphoreProof, SnarkArtifacts } from "./types"
+import { SemaphoreProof, SnarkArtifacts } from "./types"
 
 /**
  * It generates a Semaphore proof, i.e. a zero-knowledge proof that an identity that
@@ -43,8 +45,8 @@ export default async function generateProof(
 
     requireObject(identity, "identity")
     requireObject(groupOrMerkleProof, "groupOrMerkleProof")
-    requireTypes(message, "message", ["string", "bigint", "number", "uint8array"])
-    requireTypes(scope, "scope", ["string", "bigint", "number", "uint8array"])
+    requireTypes(message, "message", ["string", "bigint", "number", "Uint8Array"])
+    requireTypes(scope, "scope", ["string", "bigint", "number", "Uint8Array"])
 
     if (merkleTreeDepth) {
         requireNumber(merkleTreeDepth, "merkleTreeDepth")
@@ -73,8 +75,8 @@ export default async function generateProof(
     const 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")
+        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

package/src/get-snark-artifacts.browser.ts

@@ -1,5 +1,5 @@
 /* istanbul ignore file */
-import { requireNumber } from "@semaphore-protocol/utils/errors"
+import { requireNumber } from "@zk-kit/utils/error-handlers"
 import { SnarkArtifacts } from "./types"
 
 /**

package/src/get-snark-artifacts.node.ts

@@ -1,5 +1,5 @@
 /* istanbul ignore file */
-import { requireNumber } from "@semaphore-protocol/utils/errors"
+import { requireNumber } from "@zk-kit/utils/error-handlers"
 import { createWriteStream, existsSync, readdirSync } from "node:fs"
 import { mkdir } from "node:fs/promises"
 import os from "node:os"

package/src/hash.ts

@@ -1,7 +1,7 @@
+import type { BigNumberish } from "ethers"
 import { keccak256 } from "ethers/crypto"
 import { toBeHex } from "ethers/utils"
 import { NumericString } from "snarkjs"
-import { BigNumberish } from "./types"
 
 /**
  * Creates a keccak256 hash of a message compatible with the SNARK scalar modulus.

package/src/index.ts

@@ -1,4 +1,4 @@
-import { packGroth16Proof, unpackGroth16Proof } from "@zk-kit/utils"
+import { packGroth16Proof, unpackGroth16Proof } from "@zk-kit/utils/proof-packing"
 import generateProof from "./generate-proof"
 import verifyProof from "./verify-proof"
 

package/src/to-bigint.ts

@@ -1,9 +1,9 @@
+import type { BigNumberish } from "ethers"
 import { encodeBytes32String } from "ethers/abi"
 import { toBigInt as _toBigInt } from "ethers/utils"
-import { BigNumberish } from "./types"
 
 /**
- * Converts a bignumberish to a bigint.
+ * Converts a bignumberish or a text to a bigint.
  * @param value The value to be converted to bigint.
  * @return The value converted to bigint.
  */

package/src/types/index.ts

@@ -1,6 +1,5 @@
 import type { NumericString } from "snarkjs"
-
-export type BigNumberish = string | number | bigint
+import type { PackedGroth16Proof } from "@zk-kit/utils"
 
 export type SnarkArtifacts = {
     wasmFilePath: string
@@ -13,16 +12,5 @@ export type SemaphoreProof = {
     message: NumericString
     nullifier: NumericString
     scope: NumericString
-    points: PackedPoints
+    points: PackedGroth16Proof
 }
-
-export type PackedPoints = [
-    NumericString,
-    NumericString,
-    NumericString,
-    NumericString,
-    NumericString,
-    NumericString,
-    NumericString,
-    NumericString
-]

package/src/verify-proof.ts

@@ -1,12 +1,7 @@
-import {
-    requireArray,
-    requireDefined,
-    requireNumber,
-    requireObject,
-    requireString
-} from "@semaphore-protocol/utils/errors"
+import { MAX_DEPTH, MIN_DEPTH } from "@semaphore-protocol/utils/constants"
+import { requireArray, requireDefined, requireNumber, requireObject, requireString } from "@zk-kit/utils/error-handlers"
+import { unpackGroth16Proof } from "@zk-kit/utils/proof-packing"
 import { groth16 } from "snarkjs"
-import { unpackGroth16Proof } from "@zk-kit/utils"
 import hash from "./hash"
 import { SemaphoreProof } from "./types"
 import verificationKeys from "./verification-keys.json"
@@ -30,9 +25,8 @@ export default async function verifyProof(proof: SemaphoreProof): Promise<boolea
     requireString(scope, "proof.scope")
     requireArray(points, "proof.points")
 
-    // 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")
+    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 = {