@semaphore-protocol/group 4.0.0-beta.6 → 4.0.0-beta.8

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.6
+ * @version 4.0.0-beta.8
  * @file A library to create and manage Semaphore groups.
  * @copyright Ethereum Foundation 2024
  * @license MIT
@@ -136,7 +136,7 @@ class Group {
      * @returns The root hash as a string.
      */
     get root() {
-        return this.leanIMT.root ? this.leanIMT.root.toString() : "0";
+        return this.leanIMT.root ? this.leanIMT.root : 0n;
     }
     /**
      * Returns the depth of the tree.
@@ -157,7 +157,7 @@ class Group {
      * @returns The list of members of the group.
      */
     get members() {
-        return this.leanIMT.leaves.map(String);
+        return this.leanIMT.leaves;
     }
     /**
      * Returns the index of a member. If the member does not exist it returns -1.
@@ -172,6 +172,9 @@ class Group {
      * @param member The new member to be added.
      */
     addMember(member) {
+        if (member === 0n || member === "0") {
+            throw new Error("Failed to add member: value cannot be 0");
+        }
         this.leanIMT.insert(BigInt(member));
     }
     /**
@@ -179,6 +182,11 @@ class Group {
      * @param members New 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));
     }
     /**
@@ -187,6 +195,9 @@ class Group {
      * @param member New member value.
      */
     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));
     }
     /**
@@ -194,21 +205,18 @@ class Group {
      * @param index The index of the member to be removed.
      */
     removeMember(index) {
-        this.leanIMT.update(index, BigInt(0));
+        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.
      */
-    generateMerkleProof(_index) {
-        const { index, leaf, root, siblings } = this.leanIMT.generateProof(_index);
-        return {
-            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
@@ -226,9 +234,9 @@ class Group {
      * @param nodes The stringified JSON of the group.
      * @returns The {@link Group} instance.
      */
-    static import(exportedGroup) {
+    static import(nodes) {
         const group = new Group();
-        group.leanIMT.import(exportedGroup);
+        group.leanIMT.import(nodes);
         return group;
     }
 }

package/dist/index.js

@@ -1,6 +1,6 @@
 /**
  * @module @semaphore-protocol/group
- * @version 4.0.0-beta.6
+ * @version 4.0.0-beta.8
  * @file A library to create and manage Semaphore groups.
  * @copyright Ethereum Foundation 2024
  * @license MIT
@@ -134,7 +134,7 @@ class Group {
      * @returns The root hash as a string.
      */
     get root() {
-        return this.leanIMT.root ? this.leanIMT.root.toString() : "0";
+        return this.leanIMT.root ? this.leanIMT.root : 0n;
     }
     /**
      * Returns the depth of the tree.
@@ -155,7 +155,7 @@ class Group {
      * @returns The list of members of the group.
      */
     get members() {
-        return this.leanIMT.leaves.map(String);
+        return this.leanIMT.leaves;
     }
     /**
      * Returns the index of a member. If the member does not exist it returns -1.
@@ -170,6 +170,9 @@ class Group {
      * @param member The new member to be added.
      */
     addMember(member) {
+        if (member === 0n || member === "0") {
+            throw new Error("Failed to add member: value cannot be 0");
+        }
         this.leanIMT.insert(BigInt(member));
     }
     /**
@@ -177,6 +180,11 @@ class Group {
      * @param members New 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));
     }
     /**
@@ -185,6 +193,9 @@ class Group {
      * @param member New member value.
      */
     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));
     }
     /**
@@ -192,21 +203,18 @@ class Group {
      * @param index The index of the member to be removed.
      */
     removeMember(index) {
-        this.leanIMT.update(index, BigInt(0));
+        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.
      */
-    generateMerkleProof(_index) {
-        const { index, leaf, root, siblings } = this.leanIMT.generateProof(_index);
-        return {
-            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
@@ -224,9 +232,9 @@ class Group {
      * @param nodes The stringified JSON of the group.
      * @returns The {@link Group} instance.
      */
-    static import(exportedGroup) {
+    static import(nodes) {
         const group = new Group();
-        group.leanIMT.import(exportedGroup);
+        group.leanIMT.import(nodes);
         return 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/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.6",
+  "version": "4.0.0-beta.8",
   "description": "A library to create and manage Semaphore groups.",
   "type": "module",
   "license": "MIT",
@@ -39,6 +39,7 @@
     "rollup-plugin-cleanup": "^3.2.1"
   },
   "dependencies": {
-    "@zk-kit/imt": "2.0.0-beta.2"
+    "@zk-kit/imt": "2.0.0-beta.2",
+    "@zk-kit/utils": "1.0.0-beta"
   }
 }

package/src/index.ts

@@ -1,4 +1,156 @@
-import Group from "./group"
+import { LeanIMT, LeanIMTMerkleProof } from "@zk-kit/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[] = []) {
+        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>