@semaphore-protocol/proof 0.1.0 → 0.2.0

package/README.md

@@ -58,30 +58,80 @@ yarn add @semaphore-protocol/proof
 
 ## 📜 Usage
 
-### Generating Merkle proofs
+\# **createMerkleTree**(depth: _number_, zeroValue: _BigNumberish_, leaves: _BigNumberish\[]_): _MerkleProof_
+
+```typescript
+import { createMerkleTree } from "@semaphore-protocol/proof"
+
+const depth = 20
+const zeroValue = BigInt(0)
+const leaves = [BigInt(1), BigInt(2)]
+
+const merkleTree = createMerkleTree(treeDepth, zeroValue, leaves)
+```
+
+\# **createMerkleProof**(depth: _number_, zeroValue: _BigNumberish_, leaves: _BigNumberish\[]_, leaf: _BigNumberish_): _MerkleProof_
 
 ```typescript
 import { Identity } from "@semaphore-protocol/identity"
-import { generateMerkleProof } from "@semaphore-protocol/proof"
+import { createMerkleProof } from "@semaphore-protocol/proof"
 
 const depth = 20
 const zeroValue = BigInt(0)
+
 const identity = new Identity()
-const identityCommitment = identity.genIdentityCommitment()
-const identityCommitments = [BigInt(1), identityCommitment, BigInt(2)]
 
-const merkleProof = generateMerkleProof(depth, zeroValue, identityCommitments, 1)
+const leaf = identity.genIdentityCommitment()
+const leaves = [BigInt(1), identityCommitment, BigInt(2)]
+
+const merkleProof = createMerkleProof(treeDepth, zeroValue, leaves, leaf)
 ```
 
-### Creating Semaphore proofs
+\# **generateProof**(identity: _Identity_, merkleProof: _MerkleProof_, externalNullifier: _BigNumberish_, signal: _string_, snarkArtifacts: _SnarkArtifacts_): Promise\<_SemaphoreFullProof_>
 
 ```typescript
-import { Semaphore } from "@semaphore-protocol/protocols"
+import { Identity } from "@semaphore-protocol/identity"
+import { generateProof } from "@semaphore-protocol/proof"
 
-const signal = "Hello world"
 const externalNullifier = BigInt(1)
-const witness = Semaphore.genWitness(identity, merkleProof, externalNullifier, signal)
+const signal = "Hello world"
+
+const fullProof = await generateProof(identity, merkleProof, externalNullifier, signal, {
+    zkeyFilePath: "./semaphore.zkey",
+    wasmFilePath: "./semaphore.wasm"
+})
+```
+
+\# **verifyProof**(verificationKey: _any_, fullProof: _FullProof_): Promise\<_boolean_>
+
+```typescript
+import { verifyProof } from "@semaphore-protocol/proof"
+
+const verificationKey = JSON.parse(fs.readFileSync("/semaphore.json", "utf-8"))
+
+await verifyProof(verificationKey, fullProof)
+```
+
+\# **packToSolidityProof**(proof: _Proof_): _SolidityProof_
+
+```typescript
+import { packToSolidityProof } from "@semaphore-protocol/proof"
+
+const solidityProof = packToSolidityProof(fullProof.proof)
+```
+
+\# **generateNullifierHash**(externalNullifier: _BigNumberish_, identityNullifier: _BigNumberish_): _bigint_
+
+```typescript
+import { generateNullifierHash } from "@semaphore-protocol/proof"
+
+const nullifierHash = generateNullifierHash(externalNullifier, identity.getNullifier())
+```
+
+\# **generateSignalHash**(signal: _string_): _bigint_
+
+```typescript
+import { generateSignalHash } from "@semaphore-protocol/proof"
 
-const { proof, publicSignals } = await Semaphore.genProof(witness, "./semaphore.wasm", "./semaphore.zkey")
-const solidityProof = Semaphore.packToSolidityProof(proof)
+const signalHash = generateSignalHash(signal)
 ```

package/dist/index.mjs

@@ -1,18 +1,66 @@
 /**
  * @module @semaphore-protocol/proof
- * @version 0.1.0
+ * @version 0.2.0
  * @file A library for generating and verifying Semaphore proofs.
  * @copyright Ethereum Foundation 2022
  * @license MIT
  * @see [Github]{@link https://github.com/semaphore-protocol/semaphore.js/tree/main/packages/proof}
 */
-import { keccak256 } from '@ethersproject/solidity';
-import { formatBytes32String } from '@ethersproject/strings';
+import { IncrementalMerkleTree } from '@zk-kit/incremental-merkle-tree';
 import { poseidon } from 'circomlibjs';
 import { groth16 } from 'snarkjs';
-import { IncrementalMerkleTree } from '@zk-kit/incremental-merkle-tree';
+import { keccak256 } from '@ethersproject/solidity';
+import { formatBytes32String } from '@ethersproject/strings';
+
+/**
+ * Creates a Merkle tree.
+ * @param depth The depth of the tree.
+ * @param zeroValue The zero value of the tree.
+ * @param leaves The list of the leaves of the tree.
+ * @returns The Merkle tree.
+ */
+function createMerkleTree(depth, zeroValue, leaves) {
+    var tree = new IncrementalMerkleTree(poseidon, depth, zeroValue, 2);
+    for (var _i = 0, leaves_1 = leaves; _i < leaves_1.length; _i++) {
+        var leaf = leaves_1[_i];
+        if (leaf === zeroValue) {
+            throw new Error("Leaves cannot have zero values");
+        }
+        tree.insert(BigInt(leaf));
+    }
+    return tree;
+}
+
+/**
+ * Creates a Merkle proof.
+ * @param depth The depth of the tree.
+ * @param zeroValue The zero value of the tree.
+ * @param leaves The list of the leaves of the tree.
+ * @param leaf The leaf for which Merkle proof should be created.
+ * @returns The Merkle proof.
+ */
+function createMerkleProof(depth, zeroValue, leaves, leaf) {
+    var tree = createMerkleTree(depth, zeroValue, leaves);
+    var leafIndex = tree.leaves.indexOf(BigInt(leaf));
+    if (leafIndex === -1) {
+        throw new Error("The leaf does not exist");
+    }
+    var merkleProof = tree.createProof(leafIndex);
+    merkleProof.siblings = merkleProof.siblings.map(function (s) { return s[0]; });
+    return merkleProof;
+}
 
-/*! *****************************************************************************
+/**
+ * Generates a nullifier by hashing the external and the identity nullifiers.
+ * @param externalNullifier The external nullifier.
+ * @param identityNullifier The identity nullifier.
+ * @returns The nullifier hash.
+ */
+function generateNullifierHash(externalNullifier, identityNullifier) {
+    return poseidon([BigInt(externalNullifier), BigInt(identityNullifier)]);
+}
+
+/******************************************************************************
 Copyright (c) Microsoft Corporation.
 
 Permission to use, copy, modify, and/or distribute this software for any
@@ -65,154 +113,76 @@ function __generator(thisArg, body) {
     }
 }
 
-var Semaphore = /** @class */ (function () {
-    function Semaphore() {
-    }
-    /**
-     * Generates a SnarkJS full proof with Groth16.
-     * @param witness The parameters for creating the proof.
-     * @param wasmFilePath The WASM file path.
-     * @param finalZkeyPath The ZKey file path.
-     * @returns The full SnarkJS proof.
-     */
-    /* istanbul ignore next */
-    Semaphore.genProof = function (witness, wasmFilePath, finalZkeyPath) {
-        return __awaiter(this, void 0, void 0, function () {
-            var _a, proof, publicSignals;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0: return [4 /*yield*/, groth16.fullProve(witness, wasmFilePath, finalZkeyPath, null)];
-                    case 1:
-                        _a = _b.sent(), proof = _a.proof, publicSignals = _a.publicSignals;
-                        return [2 /*return*/, {
-                                proof: proof,
-                                publicSignals: {
-                                    merkleRoot: publicSignals[0],
-                                    nullifierHash: publicSignals[1],
-                                    signalHash: publicSignals[2],
-                                    externalNullifier: publicSignals[3]
-                                }
-                            }];
-                }
-            });
+/**
+ * Hashes a signal string with Keccak256.
+ * @param signal The Semaphore signal.
+ * @returns The signal hash.
+ */
+function genSignalHash(signal) {
+    return BigInt(keccak256(["bytes32"], [formatBytes32String(signal)])) >> BigInt(8);
+}
+
+function generateProof(identity, merkleProof, externalNullifier, signal, snarkArtifacts) {
+    return __awaiter(this, void 0, void 0, function () {
+        var _a, proof, publicSignals;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0: return [4 /*yield*/, groth16.fullProve({
+                        identityTrapdoor: identity.getTrapdoor(),
+                        identityNullifier: identity.getNullifier(),
+                        treePathIndices: merkleProof.pathIndices,
+                        treeSiblings: merkleProof.siblings,
+                        externalNullifier: externalNullifier,
+                        signalHash: genSignalHash(signal)
+                    }, snarkArtifacts.wasmFilePath, snarkArtifacts.zkeyFilePath)];
+                case 1:
+                    _a = _b.sent(), proof = _a.proof, publicSignals = _a.publicSignals;
+                    return [2 /*return*/, {
+                            proof: proof,
+                            publicSignals: {
+                                merkleRoot: publicSignals[0],
+                                nullifierHash: publicSignals[1],
+                                signalHash: publicSignals[2],
+                                externalNullifier: publicSignals[3]
+                            }
+                        }];
+            }
         });
-    };
-    /**
-     * Verifies a zero-knowledge SnarkJS proof.
-     * @param verificationKey The zero-knowledge verification key.
-     * @param fullProof The SnarkJS full proof.
-     * @returns True if the proof is valid, false otherwise.
-     */
-    /* istanbul ignore next */
-    Semaphore.verifyProof = function (verificationKey, _a) {
-        var proof = _a.proof, publicSignals = _a.publicSignals;
-        return groth16.verify(verificationKey, [
-            publicSignals.merkleRoot,
-            publicSignals.nullifierHash,
-            publicSignals.signalHash,
-            publicSignals.externalNullifier
-        ], proof);
-    };
-    /**
-     * Creates a Semaphore witness for the Semaphore ZK proof.
-     * @param identityTrapdoor The identity trapdoor.
-     * @param identityNullifier The identity nullifier.
-     * @param merkleProof The Merkle proof that identity exists in Semaphore tree.
-     * @param externalNullifier The topic on which vote should be broadcasted.
-     * @param signal The signal that should be broadcasted.
-     * @returns The Semaphore witness.
-     */
-    Semaphore.genWitness = function (identityTrapdoor, identityNullifier, merkleProof, externalNullifier, signal) {
-        return {
-            identityNullifier: identityNullifier,
-            identityTrapdoor: identityTrapdoor,
-            treePathIndices: merkleProof.pathIndices,
-            treeSiblings: merkleProof.siblings,
-            externalNullifier: externalNullifier,
-            signalHash: Semaphore.genSignalHash(signal)
-        };
-    };
-    /**
-     * Generates a nullifier by hashing the external and the identity nullifiers.
-     * @param externalNullifier The external nullifier.
-     * @param identityNullifier The identity nullifier.
-     * @returns The nullifier hash.
-     */
-    Semaphore.genNullifierHash = function (externalNullifier, identityNullifier) {
-        return poseidon([BigInt(externalNullifier), BigInt(identityNullifier)]);
-    };
-    /**
-     * Hashes a signal string with Keccak256.
-     * @param signal The Semaphore signal.
-     * @returns The signal hash.
-     */
-    Semaphore.genSignalHash = function (signal) {
-        return BigInt(keccak256(["bytes32"], [formatBytes32String(signal)])) >> BigInt(8);
-    };
-    /**
-     * Converts a full proof in a proof compatible with the Verifier.sol method inputs.
-     * @param proof The proof generated with SnarkJS.
-     * @returns The Solidity compatible proof.
-     */
-    /* istanbul ignore next */
-    Semaphore.packToSolidityProof = function (proof) {
-        return [
-            proof.pi_a[0],
-            proof.pi_a[1],
-            proof.pi_b[0][1],
-            proof.pi_b[0][0],
-            proof.pi_b[1][1],
-            proof.pi_b[1][0],
-            proof.pi_c[0],
-            proof.pi_c[1]
-        ];
-    };
-    return Semaphore;
-}());
+    });
+}
 
-BigInt("21888242871839275222246405745257275088548364400416034343698204186575808495617");
-function genExternalNullifier(plaintext) {
-    var hashed = keccak256(["string"], [plaintext]);
-    var hexStr = "0x".concat(hashed.slice(8));
-    var len = 32 * 2;
-    var h = hexStr.slice(2, len + 2);
-    return "0x".concat(h.padStart(len, "0"));
-}
 /**
- * Creates a Merkle tree.
- * @param depth The depth of the tree.
- * @param zeroValue The zero value of the tree.
- * @param leaves The list of the leaves of the tree.
- * @returns The Merkle tree.
+ * Verifies a SnarkJS proof.
+ * @param verificationKey The zero-knowledge verification key.
+ * @param fullProof The SnarkJS full proof.
+ * @returns True if the proof is valid, false otherwise.
  */
-function generateMerkleTree(depth, zeroValue, leaves) {
-    var tree = new IncrementalMerkleTree(poseidon, depth, zeroValue, 2);
-    for (var _i = 0, leaves_1 = leaves; _i < leaves_1.length; _i++) {
-        var leaf = leaves_1[_i];
-        tree.insert(BigInt(leaf));
-    }
-    return tree;
-}
+function verifyProof(verificationKey, _a) {
+    var proof = _a.proof, publicSignals = _a.publicSignals;
+    return groth16.verify(verificationKey, [
+        publicSignals.merkleRoot,
+        publicSignals.nullifierHash,
+        publicSignals.signalHash,
+        publicSignals.externalNullifier
+    ], proof);
+}
+
 /**
- * Creates a Merkle proof.
- * @param depth The depth of the tree.
- * @param zeroValue The zero value of the tree.
- * @param leaves The list of the leaves of the tree.
- * @param leaf The leaf for which Merkle proof should be created.
- * @returns The Merkle proof.
+ * Makes a proof compatible with the Verifier.sol method inputs.
+ * @param proof The proof generated with SnarkJS.
+ * @returns The Solidity compatible proof.
  */
-function generateMerkleProof(depth, zeroValue, leaves, leaf) {
-    if (leaf === zeroValue) {
-        throw new Error("Can't generate a proof for a zero leaf");
-    }
-    var tree = generateMerkleTree(depth, zeroValue, leaves);
-    var leafIndex = tree.leaves.indexOf(BigInt(leaf));
-    if (leafIndex === -1) {
-        throw new Error("The leaf does not exist");
-    }
-    var merkleProof = tree.createProof(leafIndex);
-    merkleProof.siblings = merkleProof.siblings.map(function (s) { return s[0]; });
-    return merkleProof;
+function packToSolidityProof(proof) {
+    return [
+        proof.pi_a[0],
+        proof.pi_a[1],
+        proof.pi_b[0][1],
+        proof.pi_b[0][0],
+        proof.pi_b[1][1],
+        proof.pi_b[1][0],
+        proof.pi_c[0],
+        proof.pi_c[1]
+    ];
 }
 
-export { Semaphore, genExternalNullifier, generateMerkleProof, generateMerkleTree };
+export { createMerkleProof, createMerkleTree, generateNullifierHash, generateProof, genSignalHash as generateSignalHash, packToSolidityProof, verifyProof };