@semaphore-protocol/group 4.0.0-beta.1 → 4.0.0-beta.11

package/README.md

@@ -98,7 +98,7 @@ const { commitment } = new Identity()
 
 group.addMember(commitment)
 
-// "12989101133047504182892154686643420754368236204022364847543591045056549053997"
+// 12989101133047504182892154686643420754368236204022364847543591045056549053997n
 console.log(group.members[0])
 ```
 
@@ -121,11 +121,11 @@ group.addMembers([identity1.commitment, identity2.commitment])
 ```typescript
 import { Group } from "@semaphore-protocol/group"
 
-const group = new Group([1, 3])
+const group = new Group([1n, 3n])
 
 group.updateMember(0, 2)
 
-console.log(group.members[0]) // "2"
+console.log(group.members[0]) // "2n"
 ```
 
 \# **removeMember**(index: _number_)
@@ -133,11 +133,11 @@ console.log(group.members[0]) // "2"
 ```typescript
 import { Group } from "@semaphore-protocol/group"
 
-const group = new Group([1, 3])
+const group = new Group([1n, 3n])
 
 group.removeMember(0)
 
-console.log(group.members[0]) // "0"
+console.log(group.members[0]) // 0n
 ```
 
 \# **indexOf**(member: _BigNumberish_): _number_
@@ -145,7 +145,7 @@ console.log(group.members[0]) // "0"
 ```typescript
 import { Group } from "@semaphore-protocol/group"
 
-const group = new Group([1])
+const group = new Group([1n])
 
 const index = group.indexOf(1)
 
@@ -157,7 +157,7 @@ console.log(index) // 0
 ```typescript
 import { Group } from "@semaphore-protocol/group"
 
-const group = new Group([1, 3])
+const group = new Group([1n, 3n])
 
 const proof = group.generateMerkleProof(0)
 
@@ -177,7 +177,7 @@ console.log(proof)
 ```typescript
 import { Group } from "@semaphore-protocol/group"
 
-const group = new Group([1, 2, 3])
+const group = new Group([1n, 2n, 3n])
 
 const exportedGroup = group.export()
 
@@ -192,7 +192,7 @@ console.log(exportedGroup)
 ```typescript
 import { Group } from "@semaphore-protocol/group"
 
-const group1 = new Group([1, 2, 3])
+const group1 = new Group([1n, 2n, 3n])
 
 const exportedGroup = group.export()
 

package/dist/index.cjs

@@ -1,6 +1,6 @@
 /**
  * @module @semaphore-protocol/group
- * @version 4.0.0-beta.1
+ * @version 4.0.0-beta.11
  * @file A library to create and manage Semaphore groups.
  * @copyright Ethereum Foundation 2024
  * @license MIT
@@ -8,7 +8,7 @@
 */
 'use strict';
 
-var imt = require('@zk-kit/imt');
+var leanImt = require('@zk-kit/lean-imt');
 
 function getDefaultExportFromCjs (x) {
 	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
@@ -121,121 +121,117 @@ function poseidon2(inputs) {
  * This class supports operations such as member addition, update, removal and Merkle proof
  * generation and verification. Groups can also be exported or imported.
  */
-var Group = /** @class */ (function () {
+class Group {
     /**
      * Creates a new instance of the Group. Optionally, a list of identity commitments can
      * be passed as a parameter. Adding members in chunks is more efficient than adding
      * them one by one with the `addMember` function.
      * @param members A list of identity commitments.
      */
-    function Group(members) {
-        if (members === void 0) { members = []; }
-        this.leanIMT = new imt.LeanIMT(function (a, b) { return poseidon2_2([a, b]); }, members.map(BigInt));
-    }
-    Object.defineProperty(Group.prototype, "root", {
-        /**
-         * Returns the root hash of the tree.
-         * @returns The root hash as a string.
-         */
-        get: function () {
-            return this.leanIMT.root ? this.leanIMT.root.toString() : "0";
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(Group.prototype, "depth", {
-        /**
-         * Returns the depth of the tree.
-         * @returns The tree depth as a number.
-         */
-        get: function () {
-            return this.leanIMT.depth;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(Group.prototype, "size", {
-        /**
-         * Returns the size of the tree (i.e. number of leaves).
-         * @returns The tree size as a number.
-         */
-        get: function () {
-            return this.leanIMT.size;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(Group.prototype, "members", {
-        /**
-         * Returns the members (i.e. identity commitments) of the group.
-         * @returns The list of members of the group.
-         */
-        get: function () {
-            return this.leanIMT.leaves.map(String);
-        },
-        enumerable: false,
-        configurable: true
-    });
+    constructor(members = []) {
+        for (const member of members) {
+            if (member === 0n || member === "0") {
+                throw new Error("Failed to add member: value cannot be 0");
+            }
+        }
+        this.leanIMT = new leanImt.LeanIMT((a, b) => poseidon2_2([a, b]), members.map(BigInt));
+    }
+    /**
+     * Returns the root hash of the tree.
+     * @returns The root hash as a string.
+     */
+    get root() {
+        return this.leanIMT.root ? this.leanIMT.root : 0n;
+    }
+    /**
+     * Returns the depth of the tree.
+     * @returns The tree depth as a number.
+     */
+    get depth() {
+        return this.leanIMT.depth;
+    }
+    /**
+     * Returns the size of the tree (i.e. number of leaves).
+     * @returns The tree size as a number.
+     */
+    get size() {
+        return this.leanIMT.size;
+    }
+    /**
+     * Returns the members (i.e. identity commitments) of the group.
+     * @returns The list of members of the group.
+     */
+    get members() {
+        return this.leanIMT.leaves;
+    }
     /**
      * Returns the index of a member. If the member does not exist it returns -1.
      * @param member A member of the group.
      * @returns The index of the member, or -1 if it does not exist.
      */
-    Group.prototype.indexOf = function (member) {
+    indexOf(member) {
         return this.leanIMT.indexOf(BigInt(member));
-    };
+    }
     /**
      * Adds a new member to the group.
      * @param member The new member to be added.
      */
-    Group.prototype.addMember = function (member) {
+    addMember(member) {
+        if (member === 0n || member === "0") {
+            throw new Error("Failed to add member: value cannot be 0");
+        }
         this.leanIMT.insert(BigInt(member));
-    };
+    }
     /**
      * Adds new members to the group.
      * @param members New members.
      */
-    Group.prototype.addMembers = function (members) {
+    addMembers(members) {
+        for (const member of members) {
+            if (member === 0n || member === "0") {
+                throw new Error("Failed to add member: value cannot be 0");
+            }
+        }
         this.leanIMT.insertMany(members.map(BigInt));
-    };
+    }
     /**
      * Updates a member in the group.
      * @param index Index of the member to be updated.
      * @param member New member value.
      */
-    Group.prototype.updateMember = function (index, member) {
+    updateMember(index, member) {
+        if (this.members[index] === 0n) {
+            throw new Error("Failed to update member: it has been removed");
+        }
         this.leanIMT.update(index, BigInt(member));
-    };
+    }
     /**
      * Removes a member from the group.
      * @param index The index of the member to be removed.
      */
-    Group.prototype.removeMember = function (index) {
-        this.leanIMT.update(index, BigInt(0));
-    };
+    removeMember(index) {
+        if (this.members[index] === 0n) {
+            throw new Error("Failed to remove member: it has already been removed");
+        }
+        this.leanIMT.update(index, 0n);
+    }
     /**
      * Creates a proof of membership for a member of the group.
      * @param index The index of the member.
      * @returns The {@link MerkleProof} object.
      */
-    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)
-        };
-    };
+    generateMerkleProof(index) {
+        return this.leanIMT.generateProof(index);
+    }
     /**
      * Enables the conversion of the group into a JSON string that
      * can be re-used for future imports. This approach is beneficial for
      * large groups, as it avoids re-calculating the tree hashes.
      * @returns The stringified JSON of the group.
      */
-    Group.prototype.export = function () {
+    export() {
         return this.leanIMT.export();
-    };
+    }
     /**
      * Imports an entire group by initializing the tree without calculating
      * any hashes. Note that it is crucial to ensure the integrity of the
@@ -243,12 +239,11 @@ var Group = /** @class */ (function () {
      * @param nodes The stringified JSON of the group.
      * @returns The {@link Group} instance.
      */
-    Group.import = function (exportedGroup) {
-        var group = new Group();
-        group.leanIMT.import(exportedGroup);
+    static import(nodes) {
+        const group = new Group();
+        group.leanIMT.import(nodes);
         return group;
-    };
-    return Group;
-}());
+    }
+}
 
 exports.Group = Group;

package/dist/index.js

@@ -1,12 +1,12 @@
 /**
  * @module @semaphore-protocol/group
- * @version 4.0.0-beta.1
+ * @version 4.0.0-beta.11
  * @file A library to create and manage Semaphore groups.
  * @copyright Ethereum Foundation 2024
  * @license MIT
  * @see [Github]{@link https://github.com/semaphore-protocol/semaphore/tree/main/packages/group}
 */
-import { LeanIMT } from '@zk-kit/imt';
+import { LeanIMT } from '@zk-kit/lean-imt';
 
 function getDefaultExportFromCjs (x) {
 	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
@@ -119,121 +119,117 @@ function poseidon2(inputs) {
  * This class supports operations such as member addition, update, removal and Merkle proof
  * generation and verification. Groups can also be exported or imported.
  */
-var Group = /** @class */ (function () {
+class Group {
     /**
      * Creates a new instance of the Group. Optionally, a list of identity commitments can
      * be passed as a parameter. Adding members in chunks is more efficient than adding
      * them one by one with the `addMember` function.
      * @param members A list of identity commitments.
      */
-    function Group(members) {
-        if (members === void 0) { members = []; }
-        this.leanIMT = new LeanIMT(function (a, b) { return poseidon2_2([a, b]); }, members.map(BigInt));
-    }
-    Object.defineProperty(Group.prototype, "root", {
-        /**
-         * Returns the root hash of the tree.
-         * @returns The root hash as a string.
-         */
-        get: function () {
-            return this.leanIMT.root ? this.leanIMT.root.toString() : "0";
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(Group.prototype, "depth", {
-        /**
-         * Returns the depth of the tree.
-         * @returns The tree depth as a number.
-         */
-        get: function () {
-            return this.leanIMT.depth;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(Group.prototype, "size", {
-        /**
-         * Returns the size of the tree (i.e. number of leaves).
-         * @returns The tree size as a number.
-         */
-        get: function () {
-            return this.leanIMT.size;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(Group.prototype, "members", {
-        /**
-         * Returns the members (i.e. identity commitments) of the group.
-         * @returns The list of members of the group.
-         */
-        get: function () {
-            return this.leanIMT.leaves.map(String);
-        },
-        enumerable: false,
-        configurable: true
-    });
+    constructor(members = []) {
+        for (const member of members) {
+            if (member === 0n || member === "0") {
+                throw new Error("Failed to add member: value cannot be 0");
+            }
+        }
+        this.leanIMT = new LeanIMT((a, b) => poseidon2_2([a, b]), members.map(BigInt));
+    }
+    /**
+     * Returns the root hash of the tree.
+     * @returns The root hash as a string.
+     */
+    get root() {
+        return this.leanIMT.root ? this.leanIMT.root : 0n;
+    }
+    /**
+     * Returns the depth of the tree.
+     * @returns The tree depth as a number.
+     */
+    get depth() {
+        return this.leanIMT.depth;
+    }
+    /**
+     * Returns the size of the tree (i.e. number of leaves).
+     * @returns The tree size as a number.
+     */
+    get size() {
+        return this.leanIMT.size;
+    }
+    /**
+     * Returns the members (i.e. identity commitments) of the group.
+     * @returns The list of members of the group.
+     */
+    get members() {
+        return this.leanIMT.leaves;
+    }
     /**
      * Returns the index of a member. If the member does not exist it returns -1.
      * @param member A member of the group.
      * @returns The index of the member, or -1 if it does not exist.
      */
-    Group.prototype.indexOf = function (member) {
+    indexOf(member) {
         return this.leanIMT.indexOf(BigInt(member));
-    };
+    }
     /**
      * Adds a new member to the group.
      * @param member The new member to be added.
      */
-    Group.prototype.addMember = function (member) {
+    addMember(member) {
+        if (member === 0n || member === "0") {
+            throw new Error("Failed to add member: value cannot be 0");
+        }
         this.leanIMT.insert(BigInt(member));
-    };
+    }
     /**
      * Adds new members to the group.
      * @param members New members.
      */
-    Group.prototype.addMembers = function (members) {
+    addMembers(members) {
+        for (const member of members) {
+            if (member === 0n || member === "0") {
+                throw new Error("Failed to add member: value cannot be 0");
+            }
+        }
         this.leanIMT.insertMany(members.map(BigInt));
-    };
+    }
     /**
      * Updates a member in the group.
      * @param index Index of the member to be updated.
      * @param member New member value.
      */
-    Group.prototype.updateMember = function (index, member) {
+    updateMember(index, member) {
+        if (this.members[index] === 0n) {
+            throw new Error("Failed to update member: it has been removed");
+        }
         this.leanIMT.update(index, BigInt(member));
-    };
+    }
     /**
      * Removes a member from the group.
      * @param index The index of the member to be removed.
      */
-    Group.prototype.removeMember = function (index) {
-        this.leanIMT.update(index, BigInt(0));
-    };
+    removeMember(index) {
+        if (this.members[index] === 0n) {
+            throw new Error("Failed to remove member: it has already been removed");
+        }
+        this.leanIMT.update(index, 0n);
+    }
     /**
      * Creates a proof of membership for a member of the group.
      * @param index The index of the member.
      * @returns The {@link MerkleProof} object.
      */
-    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)
-        };
-    };
+    generateMerkleProof(index) {
+        return this.leanIMT.generateProof(index);
+    }
     /**
      * Enables the conversion of the group into a JSON string that
      * can be re-used for future imports. This approach is beneficial for
      * large groups, as it avoids re-calculating the tree hashes.
      * @returns The stringified JSON of the group.
      */
-    Group.prototype.export = function () {
+    export() {
         return this.leanIMT.export();
-    };
+    }
     /**
      * Imports an entire group by initializing the tree without calculating
      * any hashes. Note that it is crucial to ensure the integrity of the
@@ -241,12 +237,11 @@ var Group = /** @class */ (function () {
      * @param nodes The stringified JSON of the group.
      * @returns The {@link Group} instance.
      */
-    Group.import = function (exportedGroup) {
-        var group = new Group();
-        group.leanIMT.import(exportedGroup);
+    static import(nodes) {
+        const group = new Group();
+        group.leanIMT.import(nodes);
         return group;
-    };
-    return Group;
-}());
+    }
+}
 
 export { Group };

package/dist/types/index.d.ts

@@ -1,3 +1,91 @@
-import Group from "./group";
-export { Group };
-export * from "./types";
+import { LeanIMT, LeanIMTMerkleProof } from "@zk-kit/lean-imt";
+import type { BigNumber } from "@zk-kit/utils";
+/**
+ * The Semaphore group is a {@link https://zkkit.pse.dev/classes/_zk_kit_imt.LeanIMT.html | LeanIMT}
+ * (Lean Incremental Merkle Tree), i.e. an optimized version of the incremental binary Merkle tree
+ * used by Semaphore V3. The new tree does not use zero hashes, and its depth is dynamic.
+ * The members of a Semaphore group, or the leaves of a tree, are the identity commitments.
+ * Thanks to the properties of Merkle trees, it can be efficiently demonstrated that a group
+ * member belongs to the group.
+ * This class supports operations such as member addition, update, removal and Merkle proof
+ * generation and verification. Groups can also be exported or imported.
+ */
+export declare class Group {
+    leanIMT: LeanIMT;
+    /**
+     * Creates a new instance of the Group. Optionally, a list of identity commitments can
+     * be passed as a parameter. Adding members in chunks is more efficient than adding
+     * them one by one with the `addMember` function.
+     * @param members A list of identity commitments.
+     */
+    constructor(members?: BigNumber[]);
+    /**
+     * Returns the root hash of the tree.
+     * @returns The root hash as a string.
+     */
+    get root(): bigint;
+    /**
+     * Returns the depth of the tree.
+     * @returns The tree depth as a number.
+     */
+    get depth(): number;
+    /**
+     * Returns the size of the tree (i.e. number of leaves).
+     * @returns The tree size as a number.
+     */
+    get size(): number;
+    /**
+     * Returns the members (i.e. identity commitments) of the group.
+     * @returns The list of members of the group.
+     */
+    get members(): bigint[];
+    /**
+     * Returns the index of a member. If the member does not exist it returns -1.
+     * @param member A member of the group.
+     * @returns The index of the member, or -1 if it does not exist.
+     */
+    indexOf(member: BigNumber): number;
+    /**
+     * Adds a new member to the group.
+     * @param member The new member to be added.
+     */
+    addMember(member: BigNumber): void;
+    /**
+     * Adds new members to the group.
+     * @param members New members.
+     */
+    addMembers(members: BigNumber[]): void;
+    /**
+     * Updates a member in the group.
+     * @param index Index of the member to be updated.
+     * @param member New member value.
+     */
+    updateMember(index: number, member: BigNumber): void;
+    /**
+     * Removes a member from the group.
+     * @param index The index of the member to be removed.
+     */
+    removeMember(index: number): void;
+    /**
+     * Creates a proof of membership for a member of the group.
+     * @param index The index of the member.
+     * @returns The {@link MerkleProof} object.
+     */
+    generateMerkleProof(index: number): LeanIMTMerkleProof;
+    /**
+     * Enables the conversion of the group into a JSON string that
+     * can be re-used for future imports. This approach is beneficial for
+     * large groups, as it avoids re-calculating the tree hashes.
+     * @returns The stringified JSON of the group.
+     */
+    export(): string;
+    /**
+     * Imports an entire group by initializing the tree without calculating
+     * any hashes. Note that it is crucial to ensure the integrity of the
+     * exported group.
+     * @param nodes The stringified JSON of the group.
+     * @returns The {@link Group} instance.
+     */
+    static import(nodes: string): Group;
+}
+export { LeanIMTMerkleProof as MerkleProof };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@semaphore-protocol/group",
-  "version": "4.0.0-beta.1",
+  "version": "4.0.0-beta.11",
   "description": "A library to create and manage Semaphore groups.",
   "type": "module",
   "license": "MIT",
@@ -32,11 +32,14 @@
   "devDependencies": {
     "@rollup/plugin-commonjs": "^25.0.7",
     "@rollup/plugin-node-resolve": "^15.2.3",
+    "@rollup/plugin-typescript": "^11.1.6",
     "poseidon-lite": "^0.2.0",
-    "rollup-plugin-cleanup": "^3.2.1",
-    "rollup-plugin-typescript2": "^0.36.0"
+    "rimraf": "^5.0.5",
+    "rollup": "^4.12.0",
+    "rollup-plugin-cleanup": "^3.2.1"
   },
   "dependencies": {
-    "@zk-kit/imt": "2.0.0-beta.2"
+    "@zk-kit/lean-imt": "2.0.1",
+    "@zk-kit/utils": "1.0.0"
   }
 }

package/src/index.ts

@@ -1,4 +1,162 @@
-import Group from "./group"
+import { LeanIMT, LeanIMTMerkleProof } from "@zk-kit/lean-imt"
+import type { BigNumber } from "@zk-kit/utils"
+import { poseidon2 } from "poseidon-lite/poseidon2"
 
-export { Group }
-export * from "./types"
+/**
+ * The Semaphore group is a {@link https://zkkit.pse.dev/classes/_zk_kit_imt.LeanIMT.html | LeanIMT}
+ * (Lean Incremental Merkle Tree), i.e. an optimized version of the incremental binary Merkle tree
+ * used by Semaphore V3. The new tree does not use zero hashes, and its depth is dynamic.
+ * The members of a Semaphore group, or the leaves of a tree, are the identity commitments.
+ * Thanks to the properties of Merkle trees, it can be efficiently demonstrated that a group
+ * member belongs to the group.
+ * This class supports operations such as member addition, update, removal and Merkle proof
+ * generation and verification. Groups can also be exported or imported.
+ */
+export class Group {
+    // The {@link https://zkkit.pse.dev/classes/_zk_kit_imt.LeanIMT.html | LeanIMT} instance.
+    public leanIMT: LeanIMT
+
+    /**
+     * Creates a new instance of the Group. Optionally, a list of identity commitments can
+     * be passed as a parameter. Adding members in chunks is more efficient than adding
+     * them one by one with the `addMember` function.
+     * @param members A list of identity commitments.
+     */
+    constructor(members: BigNumber[] = []) {
+        for (const member of members) {
+            if (member === 0n || member === "0") {
+                throw new Error("Failed to add member: value cannot be 0")
+            }
+        }
+
+        this.leanIMT = new LeanIMT((a, b) => poseidon2([a, b]), members.map(BigInt))
+    }
+
+    /**
+     * Returns the root hash of the tree.
+     * @returns The root hash as a string.
+     */
+    public get root(): bigint {
+        return this.leanIMT.root ? this.leanIMT.root : 0n
+    }
+
+    /**
+     * Returns the depth of the tree.
+     * @returns The tree depth as a number.
+     */
+    public get depth(): number {
+        return this.leanIMT.depth
+    }
+
+    /**
+     * Returns the size of the tree (i.e. number of leaves).
+     * @returns The tree size as a number.
+     */
+    public get size(): number {
+        return this.leanIMT.size
+    }
+
+    /**
+     * Returns the members (i.e. identity commitments) of the group.
+     * @returns The list of members of the group.
+     */
+    public get members(): bigint[] {
+        return this.leanIMT.leaves
+    }
+
+    /**
+     * Returns the index of a member. If the member does not exist it returns -1.
+     * @param member A member of the group.
+     * @returns The index of the member, or -1 if it does not exist.
+     */
+    public indexOf(member: BigNumber): number {
+        return this.leanIMT.indexOf(BigInt(member))
+    }
+
+    /**
+     * Adds a new member to the group.
+     * @param member The new member to be added.
+     */
+    public addMember(member: BigNumber) {
+        if (member === 0n || member === "0") {
+            throw new Error("Failed to add member: value cannot be 0")
+        }
+
+        this.leanIMT.insert(BigInt(member))
+    }
+
+    /**
+     * Adds new members to the group.
+     * @param members New members.
+     */
+    public addMembers(members: BigNumber[]) {
+        for (const member of members) {
+            if (member === 0n || member === "0") {
+                throw new Error("Failed to add member: value cannot be 0")
+            }
+        }
+
+        this.leanIMT.insertMany(members.map(BigInt))
+    }
+
+    /**
+     * Updates a member in the group.
+     * @param index Index of the member to be updated.
+     * @param member New member value.
+     */
+    public updateMember(index: number, member: BigNumber) {
+        if (this.members[index] === 0n) {
+            throw new Error("Failed to update member: it has been removed")
+        }
+
+        this.leanIMT.update(index, BigInt(member))
+    }
+
+    /**
+     * Removes a member from the group.
+     * @param index The index of the member to be removed.
+     */
+    public removeMember(index: number) {
+        if (this.members[index] === 0n) {
+            throw new Error("Failed to remove member: it has already been removed")
+        }
+
+        this.leanIMT.update(index, 0n)
+    }
+
+    /**
+     * Creates a proof of membership for a member of the group.
+     * @param index The index of the member.
+     * @returns The {@link MerkleProof} object.
+     */
+    public generateMerkleProof(index: number): LeanIMTMerkleProof {
+        return this.leanIMT.generateProof(index)
+    }
+
+    /**
+     * Enables the conversion of the group into a JSON string that
+     * can be re-used for future imports. This approach is beneficial for
+     * large groups, as it avoids re-calculating the tree hashes.
+     * @returns The stringified JSON of the group.
+     */
+    public export(): string {
+        return this.leanIMT.export()
+    }
+
+    /**
+     * Imports an entire group by initializing the tree without calculating
+     * any hashes. Note that it is crucial to ensure the integrity of the
+     * exported group.
+     * @param nodes The stringified JSON of the group.
+     * @returns The {@link Group} instance.
+     */
+    static import(nodes: string): Group {
+        const group = new Group()
+
+        group.leanIMT.import(nodes)
+
+        return group
+    }
+}
+
+export { LeanIMTMerkleProof as MerkleProof }

package/dist/types/group.d.ts

@@ -1,90 +0,0 @@
-import { LeanIMT } from "@zk-kit/imt";
-import { BigNumberish, MerkleProof } from "./types";
-/**
- * The Semaphore group is a {@link https://zkkit.pse.dev/classes/_zk_kit_imt.LeanIMT.html | LeanIMT}
- * (Lean Incremental Merkle Tree), i.e. an optimized version of the incremental binary Merkle tree
- * used by Semaphore V3. The new tree does not use zero hashes, and its depth is dynamic.
- * The members of a Semaphore group, or the leaves of a tree, are the identity commitments.
- * Thanks to the properties of Merkle trees, it can be efficiently demonstrated that a group
- * member belongs to the group.
- * This class supports operations such as member addition, update, removal and Merkle proof
- * generation and verification. Groups can also be exported or imported.
- */
-export default class Group {
-    leanIMT: LeanIMT;
-    /**
-     * Creates a new instance of the Group. Optionally, a list of identity commitments can
-     * be passed as a parameter. Adding members in chunks is more efficient than adding
-     * them one by one with the `addMember` function.
-     * @param members A list of identity commitments.
-     */
-    constructor(members?: BigNumberish[]);
-    /**
-     * Returns the root hash of the tree.
-     * @returns The root hash as a string.
-     */
-    get root(): string;
-    /**
-     * Returns the depth of the tree.
-     * @returns The tree depth as a number.
-     */
-    get depth(): number;
-    /**
-     * Returns the size of the tree (i.e. number of leaves).
-     * @returns The tree size as a number.
-     */
-    get size(): number;
-    /**
-     * Returns the members (i.e. identity commitments) of the group.
-     * @returns The list of members of the group.
-     */
-    get members(): string[];
-    /**
-     * Returns the index of a member. If the member does not exist it returns -1.
-     * @param member A member of the group.
-     * @returns The index of the member, or -1 if it does not exist.
-     */
-    indexOf(member: BigNumberish): number;
-    /**
-     * Adds a new member to the group.
-     * @param member The new member to be added.
-     */
-    addMember(member: BigNumberish): void;
-    /**
-     * Adds new members to the group.
-     * @param members New members.
-     */
-    addMembers(members: BigNumberish[]): void;
-    /**
-     * Updates a member in the group.
-     * @param index Index of the member to be updated.
-     * @param member New member value.
-     */
-    updateMember(index: number, member: BigNumberish): void;
-    /**
-     * Removes a member from the group.
-     * @param index The index of the member to be removed.
-     */
-    removeMember(index: number): void;
-    /**
-     * Creates a proof of membership for a member of the group.
-     * @param index The index of the member.
-     * @returns The {@link MerkleProof} object.
-     */
-    generateMerkleProof(_index: number): MerkleProof;
-    /**
-     * Enables the conversion of the group into a JSON string that
-     * can be re-used for future imports. This approach is beneficial for
-     * large groups, as it avoids re-calculating the tree hashes.
-     * @returns The stringified JSON of the group.
-     */
-    export(): string;
-    /**
-     * Imports an entire group by initializing the tree without calculating
-     * any hashes. Note that it is crucial to ensure the integrity of the
-     * exported group.
-     * @param nodes The stringified JSON of the group.
-     * @returns The {@link Group} instance.
-     */
-    static import(exportedGroup: string): Group;
-}

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

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

package/src/group.ts

@@ -1,143 +0,0 @@
-import { LeanIMT } from "@zk-kit/imt"
-import { poseidon2 } from "poseidon-lite/poseidon2"
-import { BigNumberish, MerkleProof } from "./types"
-
-/**
- * The Semaphore group is a {@link https://zkkit.pse.dev/classes/_zk_kit_imt.LeanIMT.html | LeanIMT}
- * (Lean Incremental Merkle Tree), i.e. an optimized version of the incremental binary Merkle tree
- * used by Semaphore V3. The new tree does not use zero hashes, and its depth is dynamic.
- * The members of a Semaphore group, or the leaves of a tree, are the identity commitments.
- * Thanks to the properties of Merkle trees, it can be efficiently demonstrated that a group
- * member belongs to the group.
- * This class supports operations such as member addition, update, removal and Merkle proof
- * generation and verification. Groups can also be exported or imported.
- */
-export default class Group {
-    // The {@link https://zkkit.pse.dev/classes/_zk_kit_imt.LeanIMT.html | LeanIMT} instance.
-    public leanIMT: LeanIMT
-
-    /**
-     * Creates a new instance of the Group. Optionally, a list of identity commitments can
-     * be passed as a parameter. Adding members in chunks is more efficient than adding
-     * them one by one with the `addMember` function.
-     * @param members A list of identity commitments.
-     */
-    constructor(members: BigNumberish[] = []) {
-        this.leanIMT = new LeanIMT((a, b) => poseidon2([a, b]), members.map(BigInt))
-    }
-
-    /**
-     * Returns the root hash of the tree.
-     * @returns The root hash as a string.
-     */
-    public get root(): string {
-        return this.leanIMT.root ? this.leanIMT.root.toString() : "0"
-    }
-
-    /**
-     * Returns the depth of the tree.
-     * @returns The tree depth as a number.
-     */
-    public get depth(): number {
-        return this.leanIMT.depth
-    }
-
-    /**
-     * Returns the size of the tree (i.e. number of leaves).
-     * @returns The tree size as a number.
-     */
-    public get size(): number {
-        return this.leanIMT.size
-    }
-
-    /**
-     * Returns the members (i.e. identity commitments) of the group.
-     * @returns The list of members of the group.
-     */
-    public get members(): string[] {
-        return this.leanIMT.leaves.map(String)
-    }
-
-    /**
-     * Returns the index of a member. If the member does not exist it returns -1.
-     * @param member A member of the group.
-     * @returns The index of the member, or -1 if it does not exist.
-     */
-    public indexOf(member: BigNumberish): number {
-        return this.leanIMT.indexOf(BigInt(member))
-    }
-
-    /**
-     * Adds a new member to the group.
-     * @param member The new member to be added.
-     */
-    public addMember(member: BigNumberish) {
-        this.leanIMT.insert(BigInt(member))
-    }
-
-    /**
-     * Adds new members to the group.
-     * @param members New members.
-     */
-    public addMembers(members: BigNumberish[]) {
-        this.leanIMT.insertMany(members.map(BigInt))
-    }
-
-    /**
-     * Updates a member in the group.
-     * @param index Index of the member to be updated.
-     * @param member New member value.
-     */
-    public updateMember(index: number, member: BigNumberish) {
-        this.leanIMT.update(index, BigInt(member))
-    }
-
-    /**
-     * Removes a member from the group.
-     * @param index The index of the member to be removed.
-     */
-    public removeMember(index: number) {
-        this.leanIMT.update(index, BigInt(0))
-    }
-
-    /**
-     * Creates a proof of membership for a member of the group.
-     * @param index The index of the member.
-     * @returns The {@link MerkleProof} object.
-     */
-    public 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)
-        }
-    }
-
-    /**
-     * Enables the conversion of the group into a JSON string that
-     * can be re-used for future imports. This approach is beneficial for
-     * large groups, as it avoids re-calculating the tree hashes.
-     * @returns The stringified JSON of the group.
-     */
-    public export(): string {
-        return this.leanIMT.export()
-    }
-
-    /**
-     * Imports an entire group by initializing the tree without calculating
-     * any hashes. Note that it is crucial to ensure the integrity of the
-     * exported group.
-     * @param nodes The stringified JSON of the group.
-     * @returns The {@link Group} instance.
-     */
-    static import(exportedGroup: string): Group {
-        const group = new Group()
-
-        group.leanIMT.import(exportedGroup)
-
-        return group
-    }
-}

package/src/types/index.ts

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