@semaphore-protocol/group 4.0.0-alpha.5 → 4.0.0-alpha.7

package/README.md

@@ -169,3 +169,32 @@ console.log(proof)
 }
 */
 ```
+
+\# **export**(): _string_
+
+```typescript
+import { Group } from "@semaphore-protocol/group"
+
+const group = new Group([1, 2, 3])
+
+const exportedGroup = group.export()
+
+console.log(exportedGroup)
+/*
+[["1","2","3"],["7853200120776062878684798364095072458815029376092732009249414926327459813530","3"],["13816780880028945690020260331303642730075999758909899334839547418969502592169"]]
+*/
+```
+
+\# **import**(exportedGroup: _string_): _Group_
+
+```typescript
+import { Group } from "@semaphore-protocol/group"
+
+const group1 = new Group([1, 2, 3])
+
+const exportedGroup = group.export()
+
+const group2 = Group.import(exportedGroup)
+
+assert(group1.root === group2.root)
+```

package/dist/index.cjs

@@ -1,6 +1,6 @@
 /**
  * @module @semaphore-protocol/group
- * @version 4.0.0-alpha.5
+ * @version 4.0.0-alpha.7
  * @file A library to create and manage Semaphore groups.
  * @copyright Ethereum Foundation 2024
  * @license MIT
@@ -126,8 +126,7 @@ var Group = /** @class */ (function () {
          * @returns Root hash.
          */
         get: function () {
-            var _a;
-            return (_a = this.leanIMT.root) === null || _a === void 0 ? void 0 : _a.toString();
+            return this.leanIMT.root ? this.leanIMT.root.toString() : "0";
         },
         enumerable: false,
         configurable: true
@@ -216,6 +215,27 @@ var Group = /** @class */ (function () {
             siblings: siblings.map(String)
         };
     };
+    /**
+     * It 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 () {
+        return this.leanIMT.export();
+    };
+    /**
+     * It 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 group instance.
+     */
+    Group.import = function (exportedGroup) {
+        var group = new Group();
+        group.leanIMT.import(exportedGroup);
+        return group;
+    };
     return Group;
 }());
 

package/dist/index.js

@@ -1,6 +1,6 @@
 /**
  * @module @semaphore-protocol/group
- * @version 4.0.0-alpha.5
+ * @version 4.0.0-alpha.7
  * @file A library to create and manage Semaphore groups.
  * @copyright Ethereum Foundation 2024
  * @license MIT
@@ -124,8 +124,7 @@ var Group = /** @class */ (function () {
          * @returns Root hash.
          */
         get: function () {
-            var _a;
-            return (_a = this.leanIMT.root) === null || _a === void 0 ? void 0 : _a.toString();
+            return this.leanIMT.root ? this.leanIMT.root.toString() : "0";
         },
         enumerable: false,
         configurable: true
@@ -214,6 +213,27 @@ var Group = /** @class */ (function () {
             siblings: siblings.map(String)
         };
     };
+    /**
+     * It 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 () {
+        return this.leanIMT.export();
+    };
+    /**
+     * It 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 group instance.
+     */
+    Group.import = function (exportedGroup) {
+        var group = new Group();
+        group.leanIMT.import(exportedGroup);
+        return group;
+    };
     return Group;
 }());
 

package/dist/types/group.d.ts

@@ -11,7 +11,7 @@ export default class Group {
      * Returns the root hash of the tree.
      * @returns Root hash.
      */
-    get root(): string | undefined;
+    get root(): string;
     /**
      * Returns the depth of the tree.
      * @returns Tree depth.
@@ -60,4 +60,19 @@ export default class Group {
      * @returns Proof object.
      */
     generateMerkleProof(_index: number): MerkleProof;
+    /**
+     * It 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;
+    /**
+     * It 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 group instance.
+     */
+    static import(exportedGroup: string): Group;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@semaphore-protocol/group",
-  "version": "4.0.0-alpha.5",
+  "version": "4.0.0-alpha.7",
   "description": "A library to create and manage Semaphore groups.",
   "type": "module",
   "license": "MIT",
@@ -37,6 +37,6 @@
     "rollup-plugin-typescript2": "^0.36.0"
   },
   "dependencies": {
-    "@zk-kit/imt": "^2.0.0-beta"
+    "@zk-kit/imt": "^2.0.0-beta.1"
   }
 }

package/src/group.ts

@@ -17,8 +17,8 @@ export default class Group {
      * Returns the root hash of the tree.
      * @returns Root hash.
      */
-    get root(): string | undefined {
-        return this.leanIMT.root?.toString()
+    get root(): string {
+        return this.leanIMT.root ? this.leanIMT.root.toString() : "0"
     }
 
     /**
@@ -102,4 +102,29 @@ export default class Group {
             siblings: siblings.map(String)
         }
     }
+
+    /**
+     * It 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 {
+        return this.leanIMT.export()
+    }
+
+    /**
+     * It 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 group instance.
+     */
+    static import(exportedGroup: string): Group {
+        const group = new Group()
+
+        group.leanIMT.import(exportedGroup)
+
+        return group
+    }
 }