@semaphore-protocol/group 3.15.2 → 4.0.0-alpha.1

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2022 Ethereum Foundation
+Copyright (c) 2024 Ethereum Foundation
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -49,8 +49,8 @@
     </h4>
 </div>
 
-| This library is an abstraction of [`@zk-kit/incremental-merkle-tree`](https://github.com/privacy-scaling-explorations/zk-kit/tree/main/packages/incremental-merkle-tree). The main goal is to make it easier to create offchain groups, which are also used to generate Semaphore proofs. Semaphore groups are actually incremental Merkle trees, and the group members are tree leaves. Since the Merkle tree implementation we are using is a binary tree, the maximum number of members of a group is equal to `2^treeDepth`. |
-| -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| This library is an abstraction of the LeanIMT data structure (part of [`@zk-kit/imt`](https://github.com/privacy-scaling-explorations/zk-kit/tree/main/packages/imt)). The main goal is to make it easier to create offchain groups, which are also used to generate Semaphore proofs. Semaphore groups are actually Merkle trees, and the group members are tree leaves. |
+| ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
 
 ## 🛠 Install
 
@@ -70,54 +70,102 @@ yarn add @semaphore-protocol/group
 
 ## 📜 Usage
 
-\# **new Group**(groupId: _Member_, treeDepth = 20): _Group_
+\# **new Group**(members: _BigNumberish[]_ = []): _Group_
 
 ```typescript
 import { Group } from "@semaphore-protocol/group"
 import { Identity } from "@semaphore-protocol/identity"
 
-// Group with max 1048576 members (20^²).
-const group1 = new Group(1)
+const group1 = new Group()
 
-// Group with max 65536 members (16^²).
-const group2 = new Group(1, 16)
-
-// Group with max 16777216 members (24^²).
-const group3 = new Group(1, 24)
-
-// Group with a list of predefined members.
 const identity1 = new Identity()
 const identity2 = new Identity()
-const identity3 = new Identity()
 
-const group3 = new Group(1, 16, [identity1.commitment, identity2.commitment, identity3.commitment])
+const group2 = new Group([identity1.commitment, identity2.commitment])
 ```
 
-\# **addMember**(identityCommitment: _Member_)
+\# **addMember**(member: _BigNumberish_)
 
 ```typescript
+import { Group } from "@semaphore-protocol/group"
 import { Identity } from "@semaphore-protocol/identity"
 
-const identity = new Identity()
-const commitment = identity.generateCommitment()
+const group = new Group()
+
+const { commitment } = new Identity()
 
 group.addMember(commitment)
+
+// "12989101133047504182892154686643420754368236204022364847543591045056549053997"
+console.log(group.members[0])
+```
+
+\# **addMembers**(members: _BigNumberish[]_)
+
+```typescript
+import { Group } from "@semaphore-protocol/group"
+import { Identity } from "@semaphore-protocol/identity"
+
+const group = new Group()
+
+const identity1 = new Identity()
+const identity2 = new Identity()
+
+group.addMembers([identity1.commitment, identity2.commitment])
+```
+
+\# **updateMember**(index: _number_, member: _BigNumberish_)
+
+```typescript
+import { Group } from "@semaphore-protocol/group"
+
+const group = new Group([1, 3])
+
+group.updateMember(0, 2)
+
+console.log(group.members[0]) // "2"
 ```
 
 \# **removeMember**(index: _number_)
 
 ```typescript
+import { Group } from "@semaphore-protocol/group"
+
+const group = new Group([1, 3])
+
 group.removeMember(0)
+
+console.log(group.members[0]) // "0"
 ```
 
-\# **indexOf**(member: _Member_): _number_
+\# **indexOf**(member: _BigNumberish_): _number_
 
 ```typescript
-group.indexOf(commitment) // 0
+import { Group } from "@semaphore-protocol/group"
+
+const group = new Group([1])
+
+const index = group.indexOf(1)
+
+console.log(index) // 0
 ```
 
 \# **generateMerkleProof**(index: _number_): _MerkleProof_
 
 ```typescript
+import { Group } from "@semaphore-protocol/group"
+
+const group = new Group([1, 3])
+
 const proof = group.generateMerkleProof(0)
+
+console.log(proof)
+/*
+{
+    index: 0,
+    leaf: '1',
+    root: '21106761926285267690763443010820487107972411248208546226053195422384279971821',
+    siblings: [ '3' ]
+}
+*/
 ```

package/dist/index.mjs

@@ -1,15 +1,12 @@
 /**
  * @module @semaphore-protocol/group
- * @version 3.15.2
+ * @version 4.0.0-alpha.1
  * @file A library to create and manage Semaphore groups.
- * @copyright Ethereum Foundation 2022
+ * @copyright Ethereum Foundation 2024
  * @license MIT
  * @see [Github]{@link https://github.com/semaphore-protocol/semaphore/tree/main/packages/group}
 */
-import { IncrementalMerkleTree } from '@zk-kit/incremental-merkle-tree';
-import { BigNumber } from '@ethersproject/bignumber';
-import { zeroPad } from '@ethersproject/bytes';
-import { keccak256 } from '@ethersproject/keccak256';
+import { LeanIMT } from '@zk-kit/imt';
 
 var poseidon2$1 = {};
 
@@ -107,51 +104,23 @@ function poseidon2(inputs) {
   return (0, _poseidon.default)(inputs, c);
 }
 
-/**
- * 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);
-}
-
 var Group = /** @class */ (function () {
     /**
      * Initializes the group with the group id and the tree depth.
-     * @param id Group identifier.
-     * @param treeDepth Tree depth.
      * @param members List of group members.
      */
-    function Group(id, treeDepth, members) {
-        if (treeDepth === void 0) { treeDepth = 20; }
+    function Group(members) {
         if (members === void 0) { members = []; }
-        if (treeDepth < 16 || treeDepth > 32) {
-            throw new Error("The tree depth must be between 16 and 32");
-        }
-        this._id = id;
-        this.merkleTree = new IncrementalMerkleTree(poseidon2_2, treeDepth, hash(id), 2, members.map(BigInt));
+        this.leanIMT = new LeanIMT(function (a, b) { return poseidon2_2([a, b]); }, members.map(BigInt));
     }
-    Object.defineProperty(Group.prototype, "id", {
-        /**
-         * Returns the id of the group.
-         * @returns Group id.
-         */
-        get: function () {
-            return this._id;
-        },
-        enumerable: false,
-        configurable: true
-    });
     Object.defineProperty(Group.prototype, "root", {
         /**
          * Returns the root hash of the tree.
          * @returns Root hash.
          */
         get: function () {
-            return this.merkleTree.root;
+            var _a;
+            return (_a = this.leanIMT.root) === null || _a === void 0 ? void 0 : _a.toString();
         },
         enumerable: false,
         configurable: true
@@ -162,18 +131,18 @@ var Group = /** @class */ (function () {
          * @returns Tree depth.
          */
         get: function () {
-            return this.merkleTree.depth;
+            return this.leanIMT.depth;
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(Group.prototype, "zeroValue", {
+    Object.defineProperty(Group.prototype, "size", {
         /**
-         * Returns the zero value of the tree.
-         * @returns Tree zero value.
+         * Returns the size of the tree (i.e. number of leaves).
+         * @returns Tree depth.
          */
         get: function () {
-            return this.merkleTree.zeroes[0];
+            return this.leanIMT.size;
         },
         enumerable: false,
         configurable: true
@@ -184,7 +153,7 @@ var Group = /** @class */ (function () {
          * @returns List of members.
          */
         get: function () {
-            return this.merkleTree.leaves;
+            return this.leanIMT.leaves.map(String);
         },
         enumerable: false,
         configurable: true
@@ -195,25 +164,21 @@ var Group = /** @class */ (function () {
      * @returns Index of the member.
      */
     Group.prototype.indexOf = function (member) {
-        return this.merkleTree.indexOf(member);
+        return this.leanIMT.indexOf(BigInt(member));
     };
     /**
      * Adds a new member to the group.
      * @param member New member.
      */
     Group.prototype.addMember = function (member) {
-        this.merkleTree.insert(BigInt(member));
+        this.leanIMT.insert(BigInt(member));
     };
     /**
      * Adds new members to the group.
      * @param members New members.
-     * @deprecated Use the new class parameter to add a list of members.
      */
     Group.prototype.addMembers = function (members) {
-        for (var _i = 0, members_1 = members; _i < members_1.length; _i++) {
-            var member = members_1[_i];
-            this.addMember(member);
-        }
+        this.leanIMT.insertMany(members.map(BigInt));
     };
     /**
      * Updates a member in the group.
@@ -221,24 +186,28 @@ var Group = /** @class */ (function () {
      * @param member New member value.
      */
     Group.prototype.updateMember = function (index, member) {
-        this.merkleTree.update(index, member);
+        this.leanIMT.update(index, BigInt(member));
     };
     /**
      * Removes a member from the group.
      * @param index Index of the member to be removed.
      */
     Group.prototype.removeMember = function (index) {
-        this.merkleTree.delete(index);
+        this.leanIMT.update(index, BigInt(0));
     };
     /**
      * Creates a proof of membership.
      * @param index Index of the proof's member.
      * @returns Proof object.
      */
-    Group.prototype.generateMerkleProof = function (index) {
-        var merkleProof = this.merkleTree.createProof(index);
-        merkleProof.siblings = merkleProof.siblings.map(function (s) { return s[0]; });
-        return merkleProof;
+    Group.prototype.generateMerkleProof = function (_index) {
+        var _a = this.leanIMT.generateProof(_index), index = _a.index, leaf = _a.leaf, root = _a.root, siblings = _a.siblings;
+        return {
+            index: index,
+            leaf: leaf.toString(),
+            root: root.toString(),
+            siblings: siblings.map(String)
+        };
     };
     return Group;
 }());

package/dist/index.node.js

@@ -1,8 +1,8 @@
 /**
  * @module @semaphore-protocol/group
- * @version 3.15.2
+ * @version 4.0.0-alpha.1
  * @file A library to create and manage Semaphore groups.
- * @copyright Ethereum Foundation 2022
+ * @copyright Ethereum Foundation 2024
  * @license MIT
  * @see [Github]{@link https://github.com/semaphore-protocol/semaphore/tree/main/packages/group}
 */
@@ -10,10 +10,7 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var incrementalMerkleTree = require('@zk-kit/incremental-merkle-tree');
-var bignumber = require('@ethersproject/bignumber');
-var bytes = require('@ethersproject/bytes');
-var keccak256 = require('@ethersproject/keccak256');
+var imt = require('@zk-kit/imt');
 
 var poseidon2$1 = {};
 
@@ -111,51 +108,23 @@ function poseidon2(inputs) {
   return (0, _poseidon.default)(inputs, c);
 }
 
-/**
- * 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.BigNumber.from(message).toTwos(256).toHexString();
-    message = bytes.zeroPad(message, 32);
-    return BigInt(keccak256.keccak256(message)) >> BigInt(8);
-}
-
 var Group = /** @class */ (function () {
     /**
      * Initializes the group with the group id and the tree depth.
-     * @param id Group identifier.
-     * @param treeDepth Tree depth.
      * @param members List of group members.
      */
-    function Group(id, treeDepth, members) {
-        if (treeDepth === void 0) { treeDepth = 20; }
+    function Group(members) {
         if (members === void 0) { members = []; }
-        if (treeDepth < 16 || treeDepth > 32) {
-            throw new Error("The tree depth must be between 16 and 32");
-        }
-        this._id = id;
-        this.merkleTree = new incrementalMerkleTree.IncrementalMerkleTree(poseidon2_2, treeDepth, hash(id), 2, members.map(BigInt));
+        this.leanIMT = new imt.LeanIMT(function (a, b) { return poseidon2_2([a, b]); }, members.map(BigInt));
     }
-    Object.defineProperty(Group.prototype, "id", {
-        /**
-         * Returns the id of the group.
-         * @returns Group id.
-         */
-        get: function () {
-            return this._id;
-        },
-        enumerable: false,
-        configurable: true
-    });
     Object.defineProperty(Group.prototype, "root", {
         /**
          * Returns the root hash of the tree.
          * @returns Root hash.
          */
         get: function () {
-            return this.merkleTree.root;
+            var _a;
+            return (_a = this.leanIMT.root) === null || _a === void 0 ? void 0 : _a.toString();
         },
         enumerable: false,
         configurable: true
@@ -166,18 +135,18 @@ var Group = /** @class */ (function () {
          * @returns Tree depth.
          */
         get: function () {
-            return this.merkleTree.depth;
+            return this.leanIMT.depth;
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(Group.prototype, "zeroValue", {
+    Object.defineProperty(Group.prototype, "size", {
         /**
-         * Returns the zero value of the tree.
-         * @returns Tree zero value.
+         * Returns the size of the tree (i.e. number of leaves).
+         * @returns Tree depth.
          */
         get: function () {
-            return this.merkleTree.zeroes[0];
+            return this.leanIMT.size;
         },
         enumerable: false,
         configurable: true
@@ -188,7 +157,7 @@ var Group = /** @class */ (function () {
          * @returns List of members.
          */
         get: function () {
-            return this.merkleTree.leaves;
+            return this.leanIMT.leaves.map(String);
         },
         enumerable: false,
         configurable: true
@@ -199,25 +168,21 @@ var Group = /** @class */ (function () {
      * @returns Index of the member.
      */
     Group.prototype.indexOf = function (member) {
-        return this.merkleTree.indexOf(member);
+        return this.leanIMT.indexOf(BigInt(member));
     };
     /**
      * Adds a new member to the group.
      * @param member New member.
      */
     Group.prototype.addMember = function (member) {
-        this.merkleTree.insert(BigInt(member));
+        this.leanIMT.insert(BigInt(member));
     };
     /**
      * Adds new members to the group.
      * @param members New members.
-     * @deprecated Use the new class parameter to add a list of members.
      */
     Group.prototype.addMembers = function (members) {
-        for (var _i = 0, members_1 = members; _i < members_1.length; _i++) {
-            var member = members_1[_i];
-            this.addMember(member);
-        }
+        this.leanIMT.insertMany(members.map(BigInt));
     };
     /**
      * Updates a member in the group.
@@ -225,24 +190,28 @@ var Group = /** @class */ (function () {
      * @param member New member value.
      */
     Group.prototype.updateMember = function (index, member) {
-        this.merkleTree.update(index, member);
+        this.leanIMT.update(index, BigInt(member));
     };
     /**
      * Removes a member from the group.
      * @param index Index of the member to be removed.
      */
     Group.prototype.removeMember = function (index) {
-        this.merkleTree.delete(index);
+        this.leanIMT.update(index, BigInt(0));
     };
     /**
      * Creates a proof of membership.
      * @param index Index of the proof's member.
      * @returns Proof object.
      */
-    Group.prototype.generateMerkleProof = function (index) {
-        var merkleProof = this.merkleTree.createProof(index);
-        merkleProof.siblings = merkleProof.siblings.map(function (s) { return s[0]; });
-        return merkleProof;
+    Group.prototype.generateMerkleProof = function (_index) {
+        var _a = this.leanIMT.generateProof(_index), index = _a.index, leaf = _a.leaf, root = _a.root, siblings = _a.siblings;
+        return {
+            index: index,
+            leaf: leaf.toString(),
+            root: root.toString(),
+            siblings: siblings.map(String)
+        };
     };
     return Group;
 }());

package/dist/types/group.d.ts

@@ -1,40 +1,32 @@
-import { IncrementalMerkleTree, MerkleProof } from "@zk-kit/incremental-merkle-tree";
-import { BigNumberish } from "./types";
+import { LeanIMT } from "@zk-kit/imt";
+import { BigNumberish, MerkleProof } from "./types";
 export default class Group {
-    private _id;
-    merkleTree: IncrementalMerkleTree;
+    leanIMT: LeanIMT;
     /**
      * Initializes the group with the group id and the tree depth.
-     * @param id Group identifier.
-     * @param treeDepth Tree depth.
      * @param members List of group members.
      */
-    constructor(id: BigNumberish, treeDepth?: number, members?: BigNumberish[]);
-    /**
-     * Returns the id of the group.
-     * @returns Group id.
-     */
-    get id(): BigNumberish;
+    constructor(members?: BigNumberish[]);
     /**
      * Returns the root hash of the tree.
      * @returns Root hash.
      */
-    get root(): BigNumberish;
+    get root(): string | undefined;
     /**
      * Returns the depth of the tree.
      * @returns Tree depth.
      */
     get depth(): number;
     /**
-     * Returns the zero value of the tree.
-     * @returns Tree zero value.
+     * Returns the size of the tree (i.e. number of leaves).
+     * @returns Tree depth.
      */
-    get zeroValue(): BigNumberish;
+    get size(): number;
     /**
      * Returns the members (i.e. identity commitments) of the group.
      * @returns List of members.
      */
-    get members(): BigNumberish[];
+    get members(): string[];
     /**
      * Returns the index of a member. If the member does not exist it returns -1.
      * @param member Group member.
@@ -49,7 +41,6 @@ export default class Group {
     /**
      * Adds new members to the group.
      * @param members New members.
-     * @deprecated Use the new class parameter to add a list of members.
      */
     addMembers(members: BigNumberish[]): void;
     /**
@@ -68,5 +59,5 @@ export default class Group {
      * @param index Index of the proof's member.
      * @returns Proof object.
      */
-    generateMerkleProof(index: number): MerkleProof;
+    generateMerkleProof(_index: number): MerkleProof;
 }

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

@@ -1 +1,3 @@
+import { LeanIMTMerkleProof } from "@zk-kit/imt";
 export type BigNumberish = string | number | bigint;
+export type MerkleProof = LeanIMTMerkleProof<string>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@semaphore-protocol/group",
-  "version": "3.15.2",
+  "version": "4.0.0-alpha.1",
   "description": "A library to create and manage Semaphore groups.",
   "license": "MIT",
   "main": "dist/index.node.js",
@@ -37,9 +37,6 @@
     "rollup-plugin-typescript2": "^0.31.2"
   },
   "dependencies": {
-    "@ethersproject/bignumber": "^5.7.0",
-    "@ethersproject/bytes": "^5.7.0",
-    "@ethersproject/keccak256": "^5.7.0",
-    "@zk-kit/incremental-merkle-tree": "1.1.0"
+    "@zk-kit/imt": "^2.0.0-beta"
   }
 }

package/src/group.ts

@@ -1,42 +1,24 @@
-import { IncrementalMerkleTree, MerkleProof } from "@zk-kit/incremental-merkle-tree"
+import { LeanIMT } from "@zk-kit/imt"
 import { poseidon2 } from "poseidon-lite/poseidon2"
-import hash from "./hash"
-import { BigNumberish } from "./types"
+import { BigNumberish, MerkleProof } from "./types"
 
 export default class Group {
-    private _id: BigNumberish
-
-    merkleTree: IncrementalMerkleTree
+    leanIMT: LeanIMT
 
     /**
      * Initializes the group with the group id and the tree depth.
-     * @param id Group identifier.
-     * @param treeDepth Tree depth.
      * @param members List of group members.
      */
-    constructor(id: BigNumberish, treeDepth = 20, members: BigNumberish[] = []) {
-        if (treeDepth < 16 || treeDepth > 32) {
-            throw new Error("The tree depth must be between 16 and 32")
-        }
-
-        this._id = id
-        this.merkleTree = new IncrementalMerkleTree(poseidon2, treeDepth, hash(id), 2, members.map(BigInt))
-    }
-
-    /**
-     * Returns the id of the group.
-     * @returns Group id.
-     */
-    get id(): BigNumberish {
-        return this._id
+    constructor(members: BigNumberish[] = []) {
+        this.leanIMT = new LeanIMT((a, b) => poseidon2([a, b]), members.map(BigInt))
     }
 
     /**
      * Returns the root hash of the tree.
      * @returns Root hash.
      */
-    get root(): BigNumberish {
-        return this.merkleTree.root
+    get root(): string | undefined {
+        return this.leanIMT.root?.toString()
     }
 
     /**
@@ -44,23 +26,23 @@ export default class Group {
      * @returns Tree depth.
      */
     get depth(): number {
-        return this.merkleTree.depth
+        return this.leanIMT.depth
     }
 
     /**
-     * Returns the zero value of the tree.
-     * @returns Tree zero value.
+     * Returns the size of the tree (i.e. number of leaves).
+     * @returns Tree depth.
      */
-    get zeroValue(): BigNumberish {
-        return this.merkleTree.zeroes[0]
+    get size(): number {
+        return this.leanIMT.size
     }
 
     /**
      * Returns the members (i.e. identity commitments) of the group.
      * @returns List of members.
      */
-    get members(): BigNumberish[] {
-        return this.merkleTree.leaves
+    get members(): string[] {
+        return this.leanIMT.leaves.map(String)
     }
 
     /**
@@ -69,7 +51,7 @@ export default class Group {
      * @returns Index of the member.
      */
     indexOf(member: BigNumberish): number {
-        return this.merkleTree.indexOf(member)
+        return this.leanIMT.indexOf(BigInt(member))
     }
 
     /**
@@ -77,18 +59,15 @@ export default class Group {
      * @param member New member.
      */
     addMember(member: BigNumberish) {
-        this.merkleTree.insert(BigInt(member))
+        this.leanIMT.insert(BigInt(member))
     }
 
     /**
      * Adds new members to the group.
      * @param members New members.
-     * @deprecated Use the new class parameter to add a list of members.
      */
     addMembers(members: BigNumberish[]) {
-        for (const member of members) {
-            this.addMember(member)
-        }
+        this.leanIMT.insertMany(members.map(BigInt))
     }
 
     /**
@@ -97,7 +76,7 @@ export default class Group {
      * @param member New member value.
      */
     updateMember(index: number, member: BigNumberish) {
-        this.merkleTree.update(index, member)
+        this.leanIMT.update(index, BigInt(member))
     }
 
     /**
@@ -105,7 +84,7 @@ export default class Group {
      * @param index Index of the member to be removed.
      */
     removeMember(index: number) {
-        this.merkleTree.delete(index)
+        this.leanIMT.update(index, BigInt(0))
     }
 
     /**
@@ -113,11 +92,14 @@ export default class Group {
      * @param index Index of the proof's member.
      * @returns Proof object.
      */
-    generateMerkleProof(index: number): MerkleProof {
-        const merkleProof = this.merkleTree.createProof(index)
-
-        merkleProof.siblings = merkleProof.siblings.map((s) => s[0])
-
-        return merkleProof
+    generateMerkleProof(_index: number): MerkleProof {
+        const { index, leaf, root, siblings } = this.leanIMT.generateProof(_index)
+
+        return {
+            index,
+            leaf: leaf.toString(),
+            root: root.toString(),
+            siblings: siblings.map(String)
+        }
     }
 }

package/src/types/index.ts

@@ -1 +1,4 @@
+import { LeanIMTMerkleProof } from "@zk-kit/imt"
+
 export type BigNumberish = string | number | bigint
+export type MerkleProof = LeanIMTMerkleProof<string>

package/dist/types/group.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/types/hash.d.ts

@@ -1,7 +0,0 @@
-import { BytesLike, Hexable } from "@ethersproject/bytes";
-/**
- * Creates a keccak256 hash of a message compatible with the SNARK scalar modulus.
- * @param message The message to be hashed.
- * @returns The message digest.
- */
-export default function hash(message: BytesLike | Hexable | number | bigint): bigint;

package/src/group.test.ts

@@ -1,112 +0,0 @@
-import Group from "./group"
-import hash from "./hash"
-
-describe("Group", () => {
-    describe("# Group", () => {
-        it("Should create a group", () => {
-            const group = new Group(1)
-
-            expect(group.id).toBe(1)
-            expect(group.root.toString()).toContain("103543")
-            expect(group.depth).toBe(20)
-            expect(group.zeroValue).toBe(hash(1))
-            expect(group.members).toHaveLength(0)
-        })
-
-        it("Should not create a group with a wrong tree depth", () => {
-            const fun = () => new Group(1, 33)
-
-            expect(fun).toThrow("The tree depth must be between 16 and 32")
-        })
-
-        it("Should create a group with a different tree depth", () => {
-            const group = new Group(1, 32)
-
-            expect(group.root.toString()).toContain("460373")
-            expect(group.depth).toBe(32)
-            expect(group.zeroValue).toBe(hash(1))
-            expect(group.members).toHaveLength(0)
-        })
-
-        it("Should create a group with a list of members", () => {
-            const group = new Group(2, 20, [1, 2, 3])
-
-            const group2 = new Group(2, 20)
-
-            group2.addMember(1)
-            group2.addMember(2)
-            group2.addMember(3)
-
-            expect(group.root.toString()).toContain(group2.root.toString())
-            expect(group.depth).toBe(20)
-            expect(group.zeroValue).toBe(hash(2))
-            expect(group.members).toHaveLength(3)
-        })
-    })
-
-    describe("# addMember", () => {
-        it("Should add a member to a group", () => {
-            const group = new Group(1)
-
-            group.addMember(BigInt(3))
-
-            expect(group.members).toHaveLength(1)
-        })
-    })
-
-    describe("# addMembers", () => {
-        it("Should add many members to a group", () => {
-            const group = new Group(1)
-
-            group.addMembers([BigInt(1), BigInt(3)])
-
-            expect(group.members).toHaveLength(2)
-        })
-    })
-
-    describe("# indexOf", () => {
-        it("Should return the index of a member in a group", () => {
-            const group = new Group(1)
-            group.addMembers([BigInt(1), BigInt(3)])
-
-            const index = group.indexOf(BigInt(3))
-
-            expect(index).toBe(1)
-        })
-    })
-
-    describe("# updateMember", () => {
-        it("Should update a member in a group", () => {
-            const group = new Group(1)
-            group.addMembers([BigInt(1), BigInt(3)])
-
-            group.updateMember(0, BigInt(1))
-
-            expect(group.members).toHaveLength(2)
-            expect(group.members[0]).toBe(BigInt(1))
-        })
-    })
-
-    describe("# removeMember", () => {
-        it("Should remove a member from a group", () => {
-            const group = new Group(1)
-            group.addMembers([BigInt(1), BigInt(3)])
-
-            group.removeMember(0)
-
-            expect(group.members).toHaveLength(2)
-            expect(group.members[0]).toBe(group.zeroValue)
-        })
-    })
-
-    describe("# generateMerkleProof", () => {
-        it("Should generate a proof of membership", () => {
-            const group = new Group(1)
-            group.addMembers([BigInt(1), BigInt(3)])
-
-            const proof = group.generateMerkleProof(0)
-
-            expect(proof.leaf).toBe(BigInt(1))
-        })
-    })
-})

package/src/hash.ts

@@ -1,15 +0,0 @@
-import { BigNumber } from "@ethersproject/bignumber"
-import { BytesLike, Hexable, zeroPad } from "@ethersproject/bytes"
-import { keccak256 } from "@ethersproject/keccak256"
-
-/**
- * Creates a keccak256 hash of a message compatible with the SNARK scalar modulus.
- * @param message The message to be hashed.
- * @returns The message digest.
- */
-export default function hash(message: BytesLike | Hexable | number | bigint): bigint {
-    message = BigNumber.from(message).toTwos(256).toHexString()
-    message = zeroPad(message, 32)
-
-    return BigInt(keccak256(message)) >> BigInt(8)
-}