@semaphore-protocol/cli 3.2.3 → 3.4.0

package/dist/index.js

@@ -2,14 +2,14 @@
 
 /**
  * @module @semaphore-protocol/cli
- * @version 3.2.3
+ * @version 3.4.0
  * @file A command line tool to set up your Semaphore project and get group data.
  * @copyright Ethereum Foundation 2022
  * @license MIT
  * @see [Github]{@link https://github.com/semaphore-protocol/semaphore/tree/main/packages/cli}
 */
 
-import { SemaphoreSubgraph } from '@semaphore-protocol/data';
+import { SemaphoreSubgraph, SemaphoreEthers } from '@semaphore-protocol/data';
 import chalk from 'chalk';
 import { program } from 'commander';
 import download from 'download';
@@ -72,7 +72,7 @@ class Spinner {
 
 const packagePath = `${dirname(fileURLToPath(import.meta.url))}/..`;
 const { description, version } = JSON.parse(readFileSync(`${packagePath}/package.json`, "utf8"));
-const supportedNetworks = ["goerli", "mumbai", "optimism-goerli", "arbitrum"];
+const supportedNetworks = ["sepolia", "goerli", "mumbai", "optimism-goerli", "arbitrum", "arbitrum-goerli"];
 program
     .name("semaphore")
     .description(description)
@@ -129,7 +129,7 @@ program
 });
 program
     .command("get-groups")
-    .description("Get the list of groups from a supported network (goerli or arbitrum).")
+    .description("Get the list of groups from a supported network (e.g. goerli or arbitrum).")
     .option("-n, --network <network-name>", "Supported Ethereum network.")
     .allowExcessArguments(false)
     .action(async ({ network }) => {
@@ -147,27 +147,36 @@ program
         console.info(`\n ${logSymbols.error}`, `error: the network '${network}' is not supported\n`);
         return;
     }
-    const subgraph = new SemaphoreSubgraph(network);
+    let groupIds;
     const spinner = new Spinner("Fetching groups");
     spinner.start();
     try {
-        const groupIds = await subgraph.getGroupIds();
+        const semaphoreSubgraph = new SemaphoreSubgraph(network);
+        groupIds = await semaphoreSubgraph.getGroupIds();
         spinner.stop();
-        if (groupIds.length === 0) {
-            console.info(`\n ${logSymbols.info}`, "info: there are no groups in this network\n");
+    }
+    catch {
+        try {
+            const semaphoreEthers = new SemaphoreEthers(network);
+            groupIds = await semaphoreEthers.getGroupIds();
+            spinner.stop();
+        }
+        catch {
+            spinner.stop();
+            console.info(`\n ${logSymbols.error}`, "error: unexpected error with the SemaphoreEthers package");
             return;
         }
-        const content = `\n${groupIds.map((id) => ` - ${id}`).join("\n")}`;
-        console.info(`${content}\n`);
     }
-    catch (error) {
-        spinner.stop();
-        console.info(`\n ${logSymbols.error}`, "error: unexpected error with the Semaphore subgraph");
+    if (groupIds.length === 0) {
+        console.info(`\n ${logSymbols.info}`, "info: there are no groups in this network\n");
+        return;
     }
+    const content = `\n${groupIds.map((id) => ` - ${id}`).join("\n")}`;
+    console.info(`${content}\n`);
 });
 program
     .command("get-group")
-    .description("Get the data of a group from a supported network (Goerli or Arbitrum).")
+    .description("Get the data of a group from a supported network (e.g. goerli or arbitrum).")
     .argument("[group-id]", "Identifier of the group.")
     .option("-n, --network <network-name>", "Supported Ethereum network.")
     .option("-m, --members", "Show group members.")
@@ -184,31 +193,42 @@ program
         });
         network = selectedNetwork;
     }
+    if (!supportedNetworks.includes(network)) {
+        console.info(`\n ${logSymbols.error}`, `error: the network '${network}' is not supported\n`);
+        return;
+    }
     if (!groupId) {
-        const subgraphGroups = new SemaphoreSubgraph(network);
+        let groupIds;
         const spinnerGroups = new Spinner("Fetching groups");
         spinnerGroups.start();
         try {
-            const groups = await subgraphGroups.getGroups();
+            const semaphoreSubgraphGroups = new SemaphoreSubgraph(network);
+            groupIds = await semaphoreSubgraphGroups.getGroupIds();
             spinnerGroups.stop();
-            if (groups.length === 0) {
-                console.info(`\n ${logSymbols.info}`, "info: there are no groups in this network\n");
+        }
+        catch {
+            try {
+                const semaphoreEthersGroups = new SemaphoreEthers(network);
+                groupIds = await semaphoreEthersGroups.getGroupIds();
+                spinnerGroups.stop();
+            }
+            catch {
+                spinnerGroups.stop();
+                console.info(`\n ${logSymbols.error}`, "error: unexpected error with the SemaphoreEthers package");
                 return;
             }
-            const groupIds = groups.map(({ id }) => id);
-            const { selectedGroupId } = await inquirer.prompt({
-                name: "selectedGroupId",
-                type: "list",
-                message: "Select one of the following existing group ids:",
-                choices: groupIds
-            });
-            groupId = selectedGroupId;
         }
-        catch (error) {
-            spinnerGroups.stop();
-            console.info(`\n ${logSymbols.error}`, "error: unexpected error with the Semaphore subgraph");
+        if (groupIds.length === 0) {
+            console.info(`\n ${logSymbols.info}`, "info: there are no groups in this network\n");
             return;
         }
+        const { selectedGroupId } = await inquirer.prompt({
+            name: "selectedGroupId",
+            type: "list",
+            message: "Select one of the following existing group ids:",
+            choices: groupIds
+        });
+        groupId = selectedGroupId;
     }
     if (!members && !signals) {
         const { showMembers } = await inquirer.prompt({
@@ -226,42 +246,50 @@ program
         });
         signals = showSignals;
     }
-    if (!supportedNetworks.includes(network)) {
-        console.info(`\n ${logSymbols.error}`, `error: the network '${network}' is not supported\n`);
-        return;
-    }
-    const subgraph = new SemaphoreSubgraph(network);
+    let group;
     const spinner = new Spinner(`Fetching group ${groupId}`);
     spinner.start();
     try {
-        const group = await subgraph.getGroup(groupId, { members, verifiedProofs: signals });
+        const semaphoreSubgraph = new SemaphoreSubgraph(network);
+        group = await semaphoreSubgraph.getGroup(groupId, { members, verifiedProofs: signals });
         spinner.stop();
-        if (!group) {
+    }
+    catch {
+        try {
+            const semaphoreEthers = new SemaphoreEthers(network);
+            group = await semaphoreEthers.getGroup(groupId);
+            if (members) {
+                group.members = await semaphoreEthers.getGroupMembers(groupId);
+            }
+            if (signals) {
+                group.verifiedProofs = await semaphoreEthers.getGroupVerifiedProofs(groupId);
+            }
+            group.admin = await semaphoreEthers.getGroupAdmin(groupId);
+            spinner.stop();
+        }
+        catch {
+            spinner.stop();
             console.info(`\n ${logSymbols.error}`, "error: the group does not exist\n");
             return;
         }
-        let content = ` ${chalk.bold("Id")}: ${group.id}\n`;
-        content += ` ${chalk.bold("Admin")}: ${group.admin}\n`;
-        content += ` ${chalk.bold("Merkle tree")}:\n`;
-        content += `   Root: ${group.merkleTree.root}\n`;
-        content += `   Depth: ${group.merkleTree.depth}\n`;
-        content += `   Zero value: ${group.merkleTree.zeroValue}\n`;
-        content += `   Number of leaves: ${group.merkleTree.numberOfLeaves}`;
-        if (members) {
-            content += `\n\n ${chalk.bold("Members")}: \n${group.members
-                .map((member, i) => `   ${i}. ${member}`)
-                .join("\n")}`;
-        }
-        if (signals) {
-            content += `\n\n ${chalk.bold("Signals")}: \n${group.verifiedProofs
-                .map(({ signal }) => `   - ${signal}`)
-                .join("\n")}`;
-        }
-        console.info(`\n${content}\n`);
     }
-    catch (error) {
-        spinner.stop();
-        console.info(`\n ${logSymbols.error}`, "error: unexpected error with the Semaphore subgraph");
+    let content = ` ${chalk.bold("Id")}: ${group.id}\n`;
+    content += ` ${chalk.bold("Admin")}: ${group.admin}\n`;
+    content += ` ${chalk.bold("Merkle tree")}:\n`;
+    content += `   Root: ${group.merkleTree.root}\n`;
+    content += `   Depth: ${group.merkleTree.depth}\n`;
+    content += `   Zero value: ${group.merkleTree.zeroValue}\n`;
+    content += `   Number of leaves: ${group.merkleTree.numberOfLeaves}`;
+    if (members) {
+        content += `\n\n ${chalk.bold("Members")}: \n${group.members
+            .map((member, i) => `   ${i}. ${member}`)
+            .join("\n")}`;
+    }
+    if (signals) {
+        content += `\n\n ${chalk.bold("Signals")}: \n${group.verifiedProofs
+            .map(({ signal }) => `   - ${signal}`)
+            .join("\n")}`;
     }
+    console.info(`\n${content}\n`);
 });
 program.parse(process.argv);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@semaphore-protocol/cli",
   "type": "module",
-  "version": "3.2.3",
+  "version": "3.4.0",
   "description": "A command line tool to set up your Semaphore project and get group data.",
   "license": "MIT",
   "bin": {
@@ -41,7 +41,7 @@
     "typedoc": "^0.22.11"
   },
   "dependencies": {
-    "@semaphore-protocol/data": "3.2.3",
+    "@semaphore-protocol/data": "3.4.0",
     "axios": "^1.3.2",
     "boxen": "^7.0.1",
     "chalk": "^5.1.2",

package/src/index.ts

@@ -1,4 +1,4 @@
-import { SemaphoreSubgraph } from "@semaphore-protocol/data"
+import { SemaphoreSubgraph, SemaphoreEthers, GroupResponse } from "@semaphore-protocol/data"
 import chalk from "chalk"
 import { program } from "commander"
 import download from "download"
@@ -14,7 +14,7 @@ import Spinner from "./spinner.js"
 const packagePath = `${dirname(fileURLToPath(import.meta.url))}/..`
 const { description, version } = JSON.parse(readFileSync(`${packagePath}/package.json`, "utf8"))
 
-const supportedNetworks = ["goerli", "mumbai", "optimism-goerli", "arbitrum"]
+const supportedNetworks = ["sepolia", "goerli", "mumbai", "optimism-goerli", "arbitrum", "arbitrum-goerli"]
 
 program
     .name("semaphore")
@@ -53,6 +53,7 @@ program
 
         if (existsSync(projectDirectory)) {
             console.info(`\n ${logSymbols.error}`, `error: the '${projectDirectory}' folder already exists\n`)
+
             return
         }
 
@@ -88,7 +89,7 @@ program
 
 program
     .command("get-groups")
-    .description("Get the list of groups from a supported network (goerli or arbitrum).")
+    .description("Get the list of groups from a supported network (e.g. goerli or arbitrum).")
     .option("-n, --network <network-name>", "Supported Ethereum network.")
     .allowExcessArguments(false)
     .action(async ({ network }) => {
@@ -105,37 +106,51 @@ program
 
         if (!supportedNetworks.includes(network)) {
             console.info(`\n ${logSymbols.error}`, `error: the network '${network}' is not supported\n`)
+
             return
         }
 
-        const subgraph = new SemaphoreSubgraph(network)
+        let groupIds: string[]
+
         const spinner = new Spinner("Fetching groups")
 
         spinner.start()
 
         try {
-            const groupIds = await subgraph.getGroupIds()
+            const semaphoreSubgraph = new SemaphoreSubgraph(network)
+
+            groupIds = await semaphoreSubgraph.getGroupIds()
 
             spinner.stop()
+        } catch {
+            try {
+                const semaphoreEthers = new SemaphoreEthers(network)
+
+                groupIds = await semaphoreEthers.getGroupIds()
+
+                spinner.stop()
+            } catch {
+                spinner.stop()
+
+                console.info(`\n ${logSymbols.error}`, "error: unexpected error with the SemaphoreEthers package")
 
-            if (groupIds.length === 0) {
-                console.info(`\n ${logSymbols.info}`, "info: there are no groups in this network\n")
                 return
             }
+        }
+        if (groupIds.length === 0) {
+            console.info(`\n ${logSymbols.info}`, "info: there are no groups in this network\n")
 
-            const content = `\n${groupIds.map((id: any) => ` - ${id}`).join("\n")}`
+            return
+        }
 
-            console.info(`${content}\n`)
-        } catch (error) {
-            spinner.stop()
+        const content = `\n${groupIds.map((id: any) => ` - ${id}`).join("\n")}`
 
-            console.info(`\n ${logSymbols.error}`, "error: unexpected error with the Semaphore subgraph")
-        }
+        console.info(`${content}\n`)
     })
 
 program
     .command("get-group")
-    .description("Get the data of a group from a supported network (Goerli or Arbitrum).")
+    .description("Get the data of a group from a supported network (e.g. goerli or arbitrum).")
     .argument("[group-id]", "Identifier of the group.")
     .option("-n, --network <network-name>", "Supported Ethereum network.")
     .option("-m, --members", "Show group members.")
@@ -150,37 +165,59 @@ program
                 default: supportedNetworks[0],
                 choices: supportedNetworks
             })
+
             network = selectedNetwork
         }
 
+        if (!supportedNetworks.includes(network)) {
+            console.info(`\n ${logSymbols.error}`, `error: the network '${network}' is not supported\n`)
+
+            return
+        }
+
         if (!groupId) {
-            const subgraphGroups = new SemaphoreSubgraph(network)
+            let groupIds: string[]
+
             const spinnerGroups = new Spinner("Fetching groups")
+
             spinnerGroups.start()
+
             try {
-                const groups = await subgraphGroups.getGroups()
+                const semaphoreSubgraphGroups = new SemaphoreSubgraph(network)
+
+                groupIds = await semaphoreSubgraphGroups.getGroupIds()
 
                 spinnerGroups.stop()
+            } catch {
+                try {
+                    const semaphoreEthersGroups = new SemaphoreEthers(network)
+
+                    groupIds = await semaphoreEthersGroups.getGroupIds()
+
+                    spinnerGroups.stop()
+                } catch {
+                    spinnerGroups.stop()
+
+                    console.info(`\n ${logSymbols.error}`, "error: unexpected error with the SemaphoreEthers package")
 
-                if (groups.length === 0) {
-                    console.info(`\n ${logSymbols.info}`, "info: there are no groups in this network\n")
                     return
                 }
+            }
 
-                const groupIds = groups.map(({ id }: any) => id)
+            if (groupIds.length === 0) {
+                console.info(`\n ${logSymbols.info}`, "info: there are no groups in this network\n")
 
-                const { selectedGroupId } = await inquirer.prompt({
-                    name: "selectedGroupId",
-                    type: "list",
-                    message: "Select one of the following existing group ids:",
-                    choices: groupIds
-                })
-                groupId = selectedGroupId
-            } catch (error) {
-                spinnerGroups.stop()
-                console.info(`\n ${logSymbols.error}`, "error: unexpected error with the Semaphore subgraph")
                 return
             }
+
+            const { selectedGroupId } = await inquirer.prompt({
+                name: "selectedGroupId",
+                type: "list",
+                message: "Select one of the following existing group ids:",
+                choices: groupIds
+            })
+
+            groupId = selectedGroupId
         }
 
         if (!members && !signals) {
@@ -203,53 +240,65 @@ program
             signals = showSignals
         }
 
-        if (!supportedNetworks.includes(network)) {
-            console.info(`\n ${logSymbols.error}`, `error: the network '${network}' is not supported\n`)
-            return
-        }
+        let group: GroupResponse
 
-        const subgraph = new SemaphoreSubgraph(network)
         const spinner = new Spinner(`Fetching group ${groupId}`)
 
         spinner.start()
 
         try {
-            const group = await subgraph.getGroup(groupId, { members, verifiedProofs: signals })
+            const semaphoreSubgraph = new SemaphoreSubgraph(network)
+
+            group = await semaphoreSubgraph.getGroup(groupId, { members, verifiedProofs: signals })
 
             spinner.stop()
+        } catch {
+            try {
+                const semaphoreEthers = new SemaphoreEthers(network)
 
-            if (!group) {
-                console.info(`\n ${logSymbols.error}`, "error: the group does not exist\n")
+                group = await semaphoreEthers.getGroup(groupId)
 
-                return
-            }
+                if (members) {
+                    group.members = await semaphoreEthers.getGroupMembers(groupId)
+                }
 
-            let content = ` ${chalk.bold("Id")}: ${group.id}\n`
-            content += ` ${chalk.bold("Admin")}: ${group.admin}\n`
-            content += ` ${chalk.bold("Merkle tree")}:\n`
-            content += `   Root: ${group.merkleTree.root}\n`
-            content += `   Depth: ${group.merkleTree.depth}\n`
-            content += `   Zero value: ${group.merkleTree.zeroValue}\n`
-            content += `   Number of leaves: ${group.merkleTree.numberOfLeaves}`
-
-            if (members) {
-                content += `\n\n ${chalk.bold("Members")}: \n${group.members
-                    .map((member: string, i: number) => `   ${i}. ${member}`)
-                    .join("\n")}`
-            }
+                if (signals) {
+                    group.verifiedProofs = await semaphoreEthers.getGroupVerifiedProofs(groupId)
+                }
+
+                group.admin = await semaphoreEthers.getGroupAdmin(groupId)
+
+                spinner.stop()
+            } catch {
+                spinner.stop()
 
-            if (signals) {
-                content += `\n\n ${chalk.bold("Signals")}: \n${group.verifiedProofs
-                    .map(({ signal }: any) => `   - ${signal}`)
-                    .join("\n")}`
+                console.info(`\n ${logSymbols.error}`, "error: the group does not exist\n")
+
+                return
             }
+        }
 
-            console.info(`\n${content}\n`)
-        } catch (error) {
-            spinner.stop()
+        let content = ` ${chalk.bold("Id")}: ${group.id}\n`
+        content += ` ${chalk.bold("Admin")}: ${group.admin}\n`
+        content += ` ${chalk.bold("Merkle tree")}:\n`
+        content += `   Root: ${group.merkleTree.root}\n`
+        content += `   Depth: ${group.merkleTree.depth}\n`
+        content += `   Zero value: ${group.merkleTree.zeroValue}\n`
+        content += `   Number of leaves: ${group.merkleTree.numberOfLeaves}`
+
+        if (members) {
+            content += `\n\n ${chalk.bold("Members")}: \n${group.members
+                .map((member: string, i: number) => `   ${i}. ${member}`)
+                .join("\n")}`
+        }
 
-            console.info(`\n ${logSymbols.error}`, "error: unexpected error with the Semaphore subgraph")
+        if (signals) {
+            content += `\n\n ${chalk.bold("Signals")}: \n${group.verifiedProofs
+                .map(({ signal }: any) => `   - ${signal}`)
+                .join("\n")}`
         }
+
+        console.info(`\n${content}\n`)
     })
 
 program.parse(process.argv)