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

package/README.md

@@ -93,13 +93,13 @@ const message = utils.formatBytes32String("Hello world")
 
 group.addMembers([...identityCommitments, identity.generateCommitment()])
 
-const fullProof1 = await generateProof(identity, group, message, scope)
+const proof1 = await generateProof(identity, group, message, scope)
 
 // You can also specify the maximum tree depth supported by the proof.
-const fullProof2 = await generateProof(identity, group, message, scope, 20)
+const proof2 = await generateProof(identity, group, message, scope, 20)
 
 // You can also specify the default zkey/wasm files.
-const fullProof3 = await generateProof(identity, group, message, scope, 20, {
+const proof3 = await generateProof(identity, group, message, scope, 20, {
     wasmFilePath: "./semaphore.wasm",
     zkeyFilePath: "./semaphore.zkey"
 })
@@ -110,5 +110,5 @@ const fullProof3 = await generateProof(identity, group, message, scope, 20, {
 ```typescript
 import { verifyProof } from "@semaphore-protocol/proof"
 
-await verifyProof(fullProof)
+await verifyProof(proof1)
 ```

package/dist/{index.browser.mjs → index.browser.js}

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