@semaphore-protocol/proof 0.2.1 → 0.3.1

package/README.md

@@ -2,7 +2,7 @@
     <h1 align="center">
         Semaphore proof
     </h1>
-    <p align="center">A library for generating and verifying Semaphore proofs.</p>
+    <p align="center">A library to generate and verify Semaphore proofs.</p>
 </p>
 
 <p align="center">
@@ -58,44 +58,20 @@ yarn add @semaphore-protocol/proof
 
 ## 📜 Usage
 
-\# **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 { createMerkleProof } from "@semaphore-protocol/proof"
-
-const depth = 20
-const zeroValue = BigInt(0)
-
-const identity = new Identity()
-
-const leaf = identity.genIdentityCommitment()
-const leaves = [BigInt(1), identityCommitment, BigInt(2)]
-
-const merkleProof = createMerkleProof(treeDepth, zeroValue, leaves, leaf)
-```
-
-\# **generateProof**(identity: _Identity_, merkleProof: _MerkleProof_, externalNullifier: _BigNumberish_, signal: _string_, snarkArtifacts: _SnarkArtifacts_): Promise\<_SemaphoreFullProof_>
+\# **generateProof**(identity: _Identity_, group: _Group_, externalNullifier: _BigNumberish_, signal: _string_, snarkArtifacts: _SnarkArtifacts_): Promise\<_SemaphoreFullProof_>
 
 ```typescript
 import { Identity } from "@semaphore-protocol/identity"
+import { Group } from "@semaphore-protocol/group"
 import { generateProof } from "@semaphore-protocol/proof"
 
+const identity = new Identity()
+const group = new Group()
 const externalNullifier = BigInt(1)
 const signal = "Hello world"
 
+group.addMembers([...identityCommitments, identity.generateCommitment()])
+
 const fullProof = await generateProof(identity, merkleProof, externalNullifier, signal, {
     zkeyFilePath: "./semaphore.zkey",
     wasmFilePath: "./semaphore.wasm"

package/dist/index.mjs

@@ -1,55 +1,16 @@
 /**
  * @module @semaphore-protocol/proof
- * @version 0.2.1
- * @file A library for generating and verifying Semaphore proofs.
+ * @version 0.3.1
+ * @file A library to generate and verify Semaphore proofs.
  * @copyright Ethereum Foundation 2022
  * @license MIT
  * @see [Github]{@link https://github.com/semaphore-protocol/semaphore.js/tree/main/packages/proof}
 */
-import { IncrementalMerkleTree } from '@zk-kit/incremental-merkle-tree';
 import { poseidon } from 'circomlibjs';
 import { groth16 } from 'snarkjs';
 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.
@@ -122,19 +83,26 @@ function genSignalHash(signal) {
     return BigInt(keccak256(["bytes32"], [formatBytes32String(signal)])) >> BigInt(8);
 }
 
-function generateProof(identity, merkleProof, externalNullifier, signal, snarkArtifacts) {
+function generateProof(identity, group, externalNullifier, signal, snarkArtifacts) {
     return __awaiter(this, void 0, void 0, function () {
-        var _a, proof, publicSignals;
+        var commitment, index, merkleProof, _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 0:
+                    commitment = identity.generateCommitment();
+                    index = group.indexOf(commitment);
+                    if (index === -1) {
+                        throw new Error("The identity is not part of the group");
+                    }
+                    merkleProof = group.generateProofOfMembership(index);
+                    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*/, {
@@ -185,4 +153,4 @@ function packToSolidityProof(proof) {
     ];
 }
 
-export { createMerkleProof, createMerkleTree, generateNullifierHash, generateProof, genSignalHash as generateSignalHash, packToSolidityProof, verifyProof };
+export { generateNullifierHash, generateProof, genSignalHash as generateSignalHash, packToSolidityProof, verifyProof };

package/dist/index.node.js

@@ -1,7 +1,7 @@
 /**
  * @module @semaphore-protocol/proof
- * @version 0.2.1
- * @file A library for generating and verifying Semaphore proofs.
+ * @version 0.3.1
+ * @file A library to generate and verify Semaphore proofs.
  * @copyright Ethereum Foundation 2022
  * @license MIT
  * @see [Github]{@link https://github.com/semaphore-protocol/semaphore.js/tree/main/packages/proof}
@@ -10,50 +10,11 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var incrementalMerkleTree = require('@zk-kit/incremental-merkle-tree');
 var circomlibjs = require('circomlibjs');
 var snarkjs = require('snarkjs');
 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.
@@ -126,19 +87,26 @@ function genSignalHash(signal) {
     return BigInt(solidity.keccak256(["bytes32"], [strings.formatBytes32String(signal)])) >> BigInt(8);
 }
 
-function generateProof(identity, merkleProof, externalNullifier, signal, snarkArtifacts) {
+function generateProof(identity, group, externalNullifier, signal, snarkArtifacts) {
     return __awaiter(this, void 0, void 0, function () {
-        var _a, proof, publicSignals;
+        var commitment, index, merkleProof, _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 0:
+                    commitment = identity.generateCommitment();
+                    index = group.indexOf(commitment);
+                    if (index === -1) {
+                        throw new Error("The identity is not part of the group");
+                    }
+                    merkleProof = group.generateProofOfMembership(index);
+                    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*/, {
@@ -189,8 +157,6 @@ function packToSolidityProof(proof) {
     ];
 }
 
-exports.createMerkleProof = createMerkleProof;
-exports.createMerkleTree = createMerkleTree;
 exports.generateNullifierHash = generateNullifierHash;
 exports.generateProof = generateProof;
 exports.generateSignalHash = genSignalHash;

package/dist/types/generateProof.d.ts

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

package/dist/types/index.d.ts

@@ -1,10 +1,7 @@
-import { MerkleProof } from "@zk-kit/incremental-merkle-tree";
-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 { generateNullifierHash, generateProof, verifyProof, generateSignalHash, packToSolidityProof };
 export * from "./types";

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@semaphore-protocol/proof",
-    "version": "0.2.1",
-    "description": "A library for generating and verifying Semaphore proofs.",
+    "version": "0.3.1",
+    "description": "A library to generate and verify Semaphore proofs.",
     "license": "MIT",
     "main": "dist/index.node.js",
     "exports": {
@@ -37,8 +37,8 @@
         "@ethersproject/bytes": "^5.5.0",
         "@ethersproject/solidity": "^5.5.0",
         "@ethersproject/strings": "^5.5.0",
-        "@semaphore-protocol/identity": "0.2.1",
-        "@zk-kit/incremental-merkle-tree": "^0.4.3",
+        "@semaphore-protocol/group": "0.1.1",
+        "@semaphore-protocol/identity": "0.2.2",
         "circomlibjs": "0.0.8",
         "snarkjs": "^0.4.13"
     }

package/src/generateProof.ts

@@ -1,16 +1,25 @@
 import type { Identity } from "@semaphore-protocol/identity"
-import { MerkleProof } from "@zk-kit/incremental-merkle-tree"
+import { Group } from "@semaphore-protocol/group"
 import { groth16 } from "snarkjs"
 import generateSignalHash from "./generateSignalHash"
 import { BigNumberish, FullProof, SnarkArtifacts } from "./types"
 
 export default async function generateProof(
     identity: Identity,
-    merkleProof: MerkleProof,
+    group: Group,
     externalNullifier: BigNumberish,
     signal: string,
     snarkArtifacts: SnarkArtifacts
 ): Promise<FullProof> {
+    const commitment = identity.generateCommitment()
+    const index = group.indexOf(commitment)
+
+    if (index === -1) {
+        throw new Error("The identity is not part of the group")
+    }
+
+    const merkleProof = group.generateProofOfMembership(index)
+
     const { proof, publicSignals } = await groth16.fullProve(
         {
             identityTrapdoor: identity.getTrapdoor(),

package/src/index.test.ts

@@ -1,9 +1,8 @@
+import { Group } from "@semaphore-protocol/group"
 import { Identity } from "@semaphore-protocol/identity"
 import download from "download"
 import { getCurveFromName } from "ffjavascript"
 import fs from "fs"
-import createMerkleProof from "./createMerkleProof"
-import createMerkleTree from "./createMerkleTree"
 import generateNullifierHash from "./generateNullifierHash"
 import generateProof from "./generateProof"
 import generateSignalHash from "./generateSignalHash"
@@ -13,13 +12,16 @@ import verifyProof from "./verifyProof"
 
 describe("Proof", () => {
     const treeDepth = 20
+
     const externalNullifier = "1"
     const signal = "0x111"
 
     const snarkArtifactsPath = "./packages/proof/snark-artifacts"
     const snarkArtifactsUrl = `http://www.trusted-setup-pse.org/semaphore/${treeDepth}`
 
-    let identity: Identity
+    const identity = new Identity()
+    const identityCommitment = identity.generateCommitment()
+
     let fullProof: FullProof
     let curve: any
 
@@ -35,55 +37,40 @@ describe("Proof", () => {
             await download(`${snarkArtifactsUrl}/semaphore.zkey`, snarkArtifactsPath)
             await download(`${snarkArtifactsUrl}/semaphore.json`, snarkArtifactsPath)
         }
-    })
+    }, 10000)
 
     afterAll(async () => {
         await curve.terminate()
     })
 
-    describe("# createMerkleTree", () => {
-        it("Should not generate a Merkle tree with a zero value leaf", async () => {
-            const fun = () => createMerkleTree(treeDepth, BigInt(0), [BigInt(0), BigInt(1)])
-
-            expect(fun).toThrow("Leaves cannot have zero values")
-        })
-
-        it("Should generate a Merkle tree", async () => {
-            const merkleTree = createMerkleTree(treeDepth, BigInt(0), [BigInt(1), BigInt(2)])
-
-            expect(merkleTree.leaves).toHaveLength(2)
-        })
-    })
-
-    describe("# createMerkleProof", () => {
-        it("Should not generate a Merkle proof of a non-existing leaf", async () => {
-            const fun = () => createMerkleProof(treeDepth, BigInt(0), [BigInt(1), BigInt(2)], BigInt(3))
+    describe("# generateProof", () => {
+        it("Should not generate Semaphore proofs if the identity is not part of the group", async () => {
+            const group = new Group(treeDepth)
 
-            expect(fun).toThrow("The leaf does not exist")
-        })
+            group.addMembers([BigInt(1), BigInt(2)])
 
-        it("Should generate a Merkle proof", async () => {
-            const merkleProof = createMerkleProof(treeDepth, BigInt(0), [BigInt(1), BigInt(2)], BigInt(2))
+            const fun = () =>
+                generateProof(identity, group, externalNullifier, signal, {
+                    wasmFilePath: `${snarkArtifactsPath}/semaphore.wasm`,
+                    zkeyFilePath: `${snarkArtifactsPath}/semaphore.zkey`
+                })
 
-            expect(merkleProof.leaf).toBe(BigInt(2))
+            await expect(fun).rejects.toThrow("The identity is not part of the group")
         })
-    })
 
-    describe("# generateProof", () => {
         it("Should generate a Semaphore proof", async () => {
-            identity = new Identity()
-            const identityCommitment = identity.generateCommitment()
-            const leaves = [BigInt(3), BigInt(2), identityCommitment, BigInt(4)]
-            const merkleProof = createMerkleProof(treeDepth, BigInt(0), leaves, identityCommitment)
+            const group = new Group(treeDepth)
+
+            group.addMembers([BigInt(1), BigInt(2), identityCommitment])
 
-            fullProof = await generateProof(identity, merkleProof, externalNullifier, signal, {
+            fullProof = await generateProof(identity, group, externalNullifier, signal, {
                 wasmFilePath: `${snarkArtifactsPath}/semaphore.wasm`,
                 zkeyFilePath: `${snarkArtifactsPath}/semaphore.zkey`
             })
 
             expect(typeof fullProof).toBe("object")
             expect(fullProof.publicSignals.externalNullifier).toBe(externalNullifier)
-            expect(fullProof.publicSignals.merkleRoot).toBe(merkleProof.root.toString())
+            expect(fullProof.publicSignals.merkleRoot).toBe(group.root.toString())
         }, 20000)
     })
 

package/src/index.ts

@@ -1,20 +1,8 @@
-import { MerkleProof } from "@zk-kit/incremental-merkle-tree"
-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 { generateNullifierHash, generateProof, verifyProof, generateSignalHash, packToSolidityProof }
 export * from "./types"

package/dist/types/createMerkleProof.d.ts

@@ -1,11 +0,0 @@
-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

@@ -1,10 +0,0 @@
-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/src/createMerkleProof.ts

@@ -1,32 +0,0 @@
-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

@@ -1,28 +0,0 @@
-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
-}