@semaphore-protocol/proof 0.1.0 → 0.2.2

package/dist/index.node.js

@@ -1,6 +1,6 @@
 /**
  * @module @semaphore-protocol/proof
- * @version 0.1.0
+ * @version 0.2.2
  * @file A library for generating and verifying Semaphore proofs.
  * @copyright Ethereum Foundation 2022
  * @license MIT
@@ -10,13 +10,61 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var solidity = require('@ethersproject/solidity');
-var strings = require('@ethersproject/strings');
+var incrementalMerkleTree = require('@zk-kit/incremental-merkle-tree');
 var circomlibjs = require('circomlibjs');
 var snarkjs = require('snarkjs');
-var incrementalMerkleTree = require('@zk-kit/incremental-merkle-tree');
+var solidity = require('@ethersproject/solidity');
+var strings = require('@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.IncrementalMerkleTree(circomlibjs.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 circomlibjs.poseidon([BigInt(externalNullifier), BigInt(identityNullifier)]);
+}
+
+/******************************************************************************
 Copyright (c) Microsoft Corporation.
 
 Permission to use, copy, modify, and/or distribute this software for any
@@ -69,157 +117,82 @@ 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*/, snarkjs.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(solidity.keccak256(["bytes32"], [strings.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*/, snarkjs.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 snarkjs.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 circomlibjs.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(solidity.keccak256(["bytes32"], [strings.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 = solidity.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.IncrementalMerkleTree(circomlibjs.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 snarkjs.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]
+    ];
 }
 
-exports.Semaphore = Semaphore;
-exports.genExternalNullifier = genExternalNullifier;
-exports.generateMerkleProof = generateMerkleProof;
-exports.generateMerkleTree = generateMerkleTree;
+exports.createMerkleProof = createMerkleProof;
+exports.createMerkleTree = createMerkleTree;
+exports.generateNullifierHash = generateNullifierHash;
+exports.generateProof = generateProof;
+exports.generateSignalHash = genSignalHash;
+exports.packToSolidityProof = packToSolidityProof;
+exports.verifyProof = verifyProof;

package/dist/types/createMerkleProof.d.ts

@@ -0,0 +1,11 @@
+import { MerkleProof } from "@zk-kit/incremental-merkle-tree";
+import { BigNumberish } from "./types";
+/**
+ * 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.
+ */
+export default function createMerkleProof(depth: number, zeroValue: BigNumberish, leaves: BigNumberish[], leaf: BigNumberish): MerkleProof;

package/dist/types/createMerkleTree.d.ts

@@ -0,0 +1,10 @@
+import { IncrementalMerkleTree } from "@zk-kit/incremental-merkle-tree";
+import { BigNumberish } from "./types";
+/**
+ * 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.
+ */
+export default function createMerkleTree(depth: number, zeroValue: BigNumberish, leaves: BigNumberish[]): IncrementalMerkleTree;

package/dist/types/generateNullifierHash.d.ts

@@ -0,0 +1,8 @@
+import { BigNumberish } from "./types";
+/**
+ * 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.
+ */
+export default function generateNullifierHash(externalNullifier: BigNumberish, identityNullifier: BigNumberish): bigint;

package/dist/types/generateProof.d.ts

@@ -0,0 +1,4 @@
+import type { Identity } from "@semaphore-protocol/identity";
+import { MerkleProof } from "@zk-kit/incremental-merkle-tree";
+import { BigNumberish, FullProof, SnarkArtifacts } from "./types";
+export default function generateProof(identity: Identity, merkleProof: MerkleProof, externalNullifier: BigNumberish, signal: string, snarkArtifacts: SnarkArtifacts): Promise<FullProof>;

package/dist/types/generateSignalHash.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Hashes a signal string with Keccak256.
+ * @param signal The Semaphore signal.
+ * @returns The signal hash.
+ */
+export default function genSignalHash(signal: string): bigint;

package/dist/types/index.d.ts

@@ -1,5 +1,10 @@
 import { MerkleProof } from "@zk-kit/incremental-merkle-tree";
-import Semaphore from "./semaphore";
-import { generateMerkleProof, generateMerkleTree, genExternalNullifier } from "./utils";
-export { Semaphore, generateMerkleProof, generateMerkleTree, genExternalNullifier, MerkleProof };
+import createMerkleTree from "./createMerkleTree";
+import createMerkleProof from "./createMerkleProof";
+import generateNullifierHash from "./generateNullifierHash";
+import generateProof from "./generateProof";
+import verifyProof from "./verifyProof";
+import generateSignalHash from "./generateSignalHash";
+import packToSolidityProof from "./packToSolidityProof";
+export { MerkleProof, createMerkleTree, createMerkleProof, generateNullifierHash, generateProof, verifyProof, generateSignalHash, packToSolidityProof };
 export * from "./types";

package/dist/types/packToSolidityProof.d.ts

@@ -0,0 +1,7 @@
+import { Proof, SolidityProof } from "./types";
+/**
+ * Makes a proof compatible with the Verifier.sol method inputs.
+ * @param proof The proof generated with SnarkJS.
+ * @returns The Solidity compatible proof.
+ */
+export default function packToSolidityProof(proof: Proof): SolidityProof;

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

@@ -1,36 +1,32 @@
-export declare type StrBigInt = string | bigint;
+export declare type BigNumberish = string | bigint;
+export declare type SnarkArtifacts = {
+    wasmFilePath: string;
+    zkeyFilePath: string;
+};
 export declare type Proof = {
-    pi_a: StrBigInt[];
-    pi_b: StrBigInt[][];
-    pi_c: StrBigInt[];
+    pi_a: BigNumberish[];
+    pi_b: BigNumberish[][];
+    pi_c: BigNumberish[];
     protocol: string;
     curve: string;
 };
-export declare type SemaphoreFullProof = {
+export declare type FullProof = {
     proof: Proof;
-    publicSignals: SemaphorePublicSignals;
+    publicSignals: PublicSignals;
 };
-export declare type SemaphorePublicSignals = {
-    merkleRoot: StrBigInt;
-    nullifierHash: StrBigInt;
-    signalHash: StrBigInt;
-    externalNullifier: StrBigInt;
+export declare type PublicSignals = {
+    merkleRoot: BigNumberish;
+    nullifierHash: BigNumberish;
+    signalHash: BigNumberish;
+    externalNullifier: BigNumberish;
 };
-export declare type SemaphoreSolidityProof = [
-    StrBigInt,
-    StrBigInt,
-    StrBigInt,
-    StrBigInt,
-    StrBigInt,
-    StrBigInt,
-    StrBigInt,
-    StrBigInt
+export declare type SolidityProof = [
+    BigNumberish,
+    BigNumberish,
+    BigNumberish,
+    BigNumberish,
+    BigNumberish,
+    BigNumberish,
+    BigNumberish,
+    BigNumberish
 ];
-export declare type SemaphoreWitness = {
-    identityNullifier: StrBigInt;
-    identityTrapdoor: StrBigInt;
-    treeSiblings: StrBigInt[];
-    treePathIndices: number[];
-    externalNullifier: StrBigInt;
-    signalHash: StrBigInt;
-};

package/dist/types/verifyProof.d.ts

@@ -0,0 +1,8 @@
+import { FullProof } from "./types";
+/**
+ * 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.
+ */
+export default function verifyProof(verificationKey: any, { proof, publicSignals }: FullProof): Promise<boolean>;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@semaphore-protocol/proof",
-    "version": "0.1.0",
+    "version": "0.2.2",
     "description": "A library for generating and verifying Semaphore proofs.",
     "license": "MIT",
     "main": "dist/index.node.js",
@@ -21,12 +21,13 @@
         "build:watch": "rollup -c rollup.config.ts -w --configPlugin typescript",
         "build": "rimraf dist && rollup -c rollup.config.ts --configPlugin typescript",
         "prepublishOnly": "yarn build",
-        "docs": "typedoc src/index.ts --out ../../docs/protocols"
+        "docs": "typedoc src/index.ts --out ../../docs/proof"
     },
     "publishConfig": {
         "access": "public"
     },
     "devDependencies": {
+        "download": "^8.0.0",
         "ffjavascript": "^0.2.54",
         "rollup-plugin-cleanup": "^3.2.1",
         "rollup-plugin-typescript2": "^0.31.2",
@@ -36,9 +37,9 @@
         "@ethersproject/bytes": "^5.5.0",
         "@ethersproject/solidity": "^5.5.0",
         "@ethersproject/strings": "^5.5.0",
+        "@semaphore-protocol/identity": "0.2.2",
         "@zk-kit/incremental-merkle-tree": "^0.4.3",
         "circomlibjs": "0.0.8",
         "snarkjs": "^0.4.13"
-    },
-    "gitHead": "6c1b469a4b5ffaac562f478fc2bbc78731734e81"
+    }
 }

package/src/createMerkleProof.ts

@@ -0,0 +1,32 @@
+import { MerkleProof } from "@zk-kit/incremental-merkle-tree"
+import createMerkleTree from "./createMerkleTree"
+import { BigNumberish } from "./types"
+
+/**
+ * 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.
+ */
+export default function createMerkleProof(
+    depth: number,
+    zeroValue: BigNumberish,
+    leaves: BigNumberish[],
+    leaf: BigNumberish
+): MerkleProof {
+    const tree = createMerkleTree(depth, zeroValue, leaves)
+
+    const leafIndex = tree.leaves.indexOf(BigInt(leaf))
+
+    if (leafIndex === -1) {
+        throw new Error("The leaf does not exist")
+    }
+
+    const merkleProof = tree.createProof(leafIndex)
+
+    merkleProof.siblings = merkleProof.siblings.map((s) => s[0])
+
+    return merkleProof
+}

package/src/createMerkleTree.ts

@@ -0,0 +1,28 @@
+import { IncrementalMerkleTree } from "@zk-kit/incremental-merkle-tree"
+import { poseidon } from "circomlibjs"
+import { BigNumberish } from "./types"
+
+/**
+ * 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.
+ */
+export default function createMerkleTree(
+    depth: number,
+    zeroValue: BigNumberish,
+    leaves: BigNumberish[]
+): IncrementalMerkleTree {
+    const tree = new IncrementalMerkleTree(poseidon, depth, zeroValue, 2)
+
+    for (const leaf of leaves) {
+        if (leaf === zeroValue) {
+            throw new Error("Leaves cannot have zero values")
+        }
+
+        tree.insert(BigInt(leaf))
+    }
+
+    return tree
+}

package/src/generateNullifierHash.ts

@@ -0,0 +1,15 @@
+import { poseidon } from "circomlibjs"
+import { BigNumberish } from "./types"
+
+/**
+ * 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.
+ */
+export default function generateNullifierHash(
+    externalNullifier: BigNumberish,
+    identityNullifier: BigNumberish
+): bigint {
+    return poseidon([BigInt(externalNullifier), BigInt(identityNullifier)])
+}

package/src/generateProof.ts

@@ -0,0 +1,36 @@
+import type { Identity } from "@semaphore-protocol/identity"
+import { MerkleProof } from "@zk-kit/incremental-merkle-tree"
+import { groth16 } from "snarkjs"
+import generateSignalHash from "./generateSignalHash"
+import { BigNumberish, FullProof, SnarkArtifacts } from "./types"
+
+export default async function generateProof(
+    identity: Identity,
+    merkleProof: MerkleProof,
+    externalNullifier: BigNumberish,
+    signal: string,
+    snarkArtifacts: SnarkArtifacts
+): Promise<FullProof> {
+    const { proof, publicSignals } = await groth16.fullProve(
+        {
+            identityTrapdoor: identity.getTrapdoor(),
+            identityNullifier: identity.getNullifier(),
+            treePathIndices: merkleProof.pathIndices,
+            treeSiblings: merkleProof.siblings,
+            externalNullifier,
+            signalHash: generateSignalHash(signal)
+        },
+        snarkArtifacts.wasmFilePath,
+        snarkArtifacts.zkeyFilePath
+    )
+
+    return {
+        proof,
+        publicSignals: {
+            merkleRoot: publicSignals[0],
+            nullifierHash: publicSignals[1],
+            signalHash: publicSignals[2],
+            externalNullifier: publicSignals[3]
+        }
+    }
+}

package/src/generateSignalHash.ts

@@ -0,0 +1,11 @@
+import { keccak256 } from "@ethersproject/solidity"
+import { formatBytes32String } from "@ethersproject/strings"
+
+/**
+ * Hashes a signal string with Keccak256.
+ * @param signal The Semaphore signal.
+ * @returns The signal hash.
+ */
+export default function genSignalHash(signal: string): bigint {
+    return BigInt(keccak256(["bytes32"], [formatBytes32String(signal)])) >> BigInt(8)
+}