@semaphore-protocol/cli 3.5.0 → 3.6.0-1

package/dist/index.js

@@ -2,7 +2,7 @@
 
 /**
  * @module @semaphore-protocol/cli
- * @version 3.5.0
+ * @version 3.6.0-1
  * @file A command line tool to set up your Semaphore project and get group data.
  * @copyright Ethereum Foundation 2022
  * @license MIT
@@ -12,11 +12,10 @@
 import { SemaphoreSubgraph, SemaphoreEthers } from '@semaphore-protocol/data';
 import chalk from 'chalk';
 import { program } from 'commander';
-import download from 'download';
 import figlet from 'figlet';
-import { readFileSync, existsSync, renameSync } from 'fs';
-import inquirer from 'inquirer';
+import { readFileSync, existsSync } from 'fs';
 import logSymbols from 'log-symbols';
+import pacote from 'pacote';
 import { dirname } from 'path';
 import { fileURLToPath } from 'url';
 import axios from 'axios';
@@ -24,6 +23,7 @@ import boxen from 'boxen';
 import { execSync } from 'child_process';
 import { lt } from 'semver';
 import ora from 'ora';
+import inquirer from 'inquirer';
 
 const cliRegistryURL = "https://registry.npmjs.org/-/package/@semaphore-protocol/cli/dist-tags";
 /**
@@ -70,9 +70,98 @@ class Spinner {
     }
 }
 
+/**
+ * Gets all group ids on the specified network
+ * @param network The specified network
+ */
+async function getGroupIds(network) {
+    let groupIds;
+    const spinner = new Spinner("Fetching groups");
+    spinner.start();
+    try {
+        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");
+            return null;
+        }
+    }
+    if (groupIds.length === 0) {
+        console.info(`\n ${logSymbols.info}`, "info: there are no groups in this network\n");
+        return null;
+    }
+    return groupIds;
+}
+
+async function getProjectName() {
+    const { projectName } = await inquirer.prompt({
+        name: "projectName",
+        type: "input",
+        message: "What is your project name?",
+        default: "my-app"
+    });
+    return projectName;
+}
+async function getSupportedTemplate(supportedTemplates) {
+    const { selectedTemplate } = await inquirer.prompt({
+        name: "selectedTemplate",
+        type: "list",
+        message: "Select one of the supported templates:",
+        default: 0,
+        choices: supportedTemplates.map((template) => ({
+            value: template.value,
+            name: `${template.value} (${template.name})`
+        }))
+    });
+    return selectedTemplate;
+}
+async function getSupportedNetwork(supportedNetworks) {
+    const { selectedNetwork } = await inquirer.prompt({
+        name: "selectedNetwork",
+        type: "list",
+        message: "Select one of the supported networks:",
+        default: 0,
+        choices: supportedNetworks
+    });
+    return selectedNetwork;
+}
+async function getGroupId(groupIds) {
+    const { selectedGroupId } = await inquirer.prompt({
+        name: "selectedGroupId",
+        type: "list",
+        message: "Select one of the following existing group ids:",
+        default: 0,
+        choices: groupIds
+    });
+    return selectedGroupId;
+}
+
 const packagePath = `${dirname(fileURLToPath(import.meta.url))}/..`;
 const { description, version } = JSON.parse(readFileSync(`${packagePath}/package.json`, "utf8"));
 const supportedNetworks = ["sepolia", "goerli", "mumbai", "optimism-goerli", "arbitrum", "arbitrum-goerli"];
+const supportedTemplates = [
+    {
+        value: "contracts-hardhat",
+        name: "Hardhat"
+    },
+    {
+        value: "monorepo-ethers",
+        name: "Hardhat + Next.js + SemaphoreEthers"
+    },
+    {
+        value: "monorepo-subgraph",
+        name: "Hardhat + Next.js + SemaphoreSubgraph"
+    }
+];
 program
     .name("semaphore")
     .description(description)
@@ -90,29 +179,28 @@ program
     .command("create")
     .description("Create a Semaphore project with a supported template.")
     .argument("[project-directory]", "Directory of the project.")
-    // .option("-t, --template <template-name>", "Supported Semaphore template.", "hardhat")
+    .option("-t, --template <template-name>", "Supported Semaphore template.")
     .allowExcessArguments(false)
-    .action(async (projectDirectory) => {
+    .action(async (projectDirectory, { template }) => {
     if (!projectDirectory) {
-        const { projectName } = await inquirer.prompt({
-            name: "projectName",
-            type: "input",
-            message: "What is your project name?",
-            default: "my-app"
-        });
-        projectDirectory = projectName;
+        projectDirectory = await getProjectName();
+    }
+    if (!template) {
+        template = await getSupportedTemplate(supportedTemplates);
+    }
+    if (!supportedTemplates.some((t) => t.value === template)) {
+        console.info(`\n ${logSymbols.error}`, `error: the template '${template}' is not supported\n`);
+        return;
     }
     const currentDirectory = process.cwd();
     const spinner = new Spinner(`Creating your project in ${chalk.green(`./${projectDirectory}`)}`);
-    const templateURL = `https://registry.npmjs.org/@semaphore-protocol/cli-template-hardhat/-/cli-template-hardhat-${version}.tgz`;
     if (existsSync(projectDirectory)) {
         console.info(`\n ${logSymbols.error}`, `error: the '${projectDirectory}' folder already exists\n`);
         return;
     }
     spinner.start();
     await checkLatestVersion(version);
-    await download(templateURL, currentDirectory, { extract: true });
-    renameSync(`${currentDirectory}/package`, `${currentDirectory}/${projectDirectory}`);
+    await pacote.extract(`@semaphore-protocol/cli-template-${template}@${version}`, `${currentDirectory}/${projectDirectory}`);
     spinner.stop();
     console.info(`\n ${logSymbols.success}`, `Your project is ready!\n`);
     console.info(` Please, install your dependencies by running:\n`);
@@ -134,137 +222,153 @@ program
     .allowExcessArguments(false)
     .action(async ({ network }) => {
     if (!network) {
-        const { selectedNetwork } = await inquirer.prompt({
-            name: "selectedNetwork",
-            type: "list",
-            message: "Select one of our supported networks:",
-            default: supportedNetworks[0],
-            choices: supportedNetworks
-        });
-        network = selectedNetwork;
+        network = await getSupportedNetwork(supportedNetworks);
     }
     if (!supportedNetworks.includes(network)) {
         console.info(`\n ${logSymbols.error}`, `error: the network '${network}' is not supported\n`);
         return;
     }
-    let groupIds;
-    const spinner = new Spinner("Fetching groups");
+    const groupIds = await getGroupIds(network);
+    if (groupIds === null)
+        return;
+    const content = `${chalk.bold("Groups")} (${groupIds.length}): \n${groupIds
+        .map((id) => ` - ${id}`)
+        .join("\n")}`;
+    console.info(`\n${content}\n`);
+});
+program
+    .command("get-group")
+    .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.")
+    .allowExcessArguments(false)
+    .action(async (groupId, { network }) => {
+    if (!network) {
+        network = await getSupportedNetwork(supportedNetworks);
+    }
+    if (!supportedNetworks.includes(network)) {
+        console.info(`\n ${logSymbols.error}`, `error: the network '${network}' is not supported\n`);
+        return;
+    }
+    if (!groupId) {
+        const groupIds = await getGroupIds(network);
+        if (groupIds === null)
+            return;
+        groupId = await getGroupId(groupIds);
+    }
+    let group;
+    const spinner = new Spinner(`Fetching group ${groupId}`);
     spinner.start();
     try {
         const semaphoreSubgraph = new SemaphoreSubgraph(network);
-        groupIds = await semaphoreSubgraph.getGroupIds();
+        group = await semaphoreSubgraph.getGroup(groupId);
         spinner.stop();
     }
     catch {
         try {
             const semaphoreEthers = new SemaphoreEthers(network);
-            groupIds = await semaphoreEthers.getGroupIds();
+            group = await semaphoreEthers.getGroup(groupId);
+            group.admin = await semaphoreEthers.getGroupAdmin(groupId);
             spinner.stop();
         }
         catch {
             spinner.stop();
-            console.info(`\n ${logSymbols.error}`, "error: unexpected error with the SemaphoreEthers package");
+            console.info(`\n ${logSymbols.error}`, "error: the group does not exist\n");
             return;
         }
     }
-    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`);
+    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}`;
+    console.info(`\n${content}\n`);
 });
 program
-    .command("get-group")
-    .description("Get the data of a group from a supported network (e.g. goerli or arbitrum).")
+    .command("get-members")
+    .description("Get the members 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.")
-    .option("-s, --signals", "Show group signals.")
     .allowExcessArguments(false)
-    .action(async (groupId, { network, members, signals }) => {
+    .action(async (groupId, { network }) => {
     if (!network) {
-        const { selectedNetwork } = await inquirer.prompt({
-            name: "selectedNetwork",
-            type: "list",
-            message: "Select one of our supported networks:",
-            default: supportedNetworks[0],
-            choices: supportedNetworks
-        });
-        network = selectedNetwork;
+        network = await getSupportedNetwork(supportedNetworks);
     }
     if (!supportedNetworks.includes(network)) {
         console.info(`\n ${logSymbols.error}`, `error: the network '${network}' is not supported\n`);
         return;
     }
     if (!groupId) {
-        let groupIds;
-        const spinnerGroups = new Spinner("Fetching groups");
-        spinnerGroups.start();
+        const groupIds = await getGroupIds(network);
+        if (groupIds === null)
+            return;
+        groupId = await getGroupId(groupIds);
+    }
+    let groupMembers;
+    const spinner = new Spinner(`Fetching members of group ${groupId}`);
+    spinner.start();
+    try {
+        const semaphoreSubgraph = new SemaphoreSubgraph(network);
+        const group = await semaphoreSubgraph.getGroup(groupId, { members: true });
+        groupMembers = group.members;
+        spinner.stop();
+    }
+    catch {
         try {
-            const semaphoreSubgraphGroups = new SemaphoreSubgraph(network);
-            groupIds = await semaphoreSubgraphGroups.getGroupIds();
-            spinnerGroups.stop();
+            const semaphoreEthers = new SemaphoreEthers(network);
+            groupMembers = await semaphoreEthers.getGroupMembers(groupId);
+            spinner.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");
-                return;
-            }
-        }
-        if (groupIds.length === 0) {
-            console.info(`\n ${logSymbols.info}`, "info: there are no groups in this network\n");
+            spinner.stop();
+            console.info(`\n ${logSymbols.error}`, "error: the group does not exist\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({
-            name: "showMembers",
-            type: "confirm",
-            message: "Do you want to show members?",
-            default: false
-        });
-        members = showMembers;
-        const { showSignals } = await inquirer.prompt({
-            name: "showSignals",
-            type: "confirm",
-            message: "Do you want to show signals?",
-            default: false
-        });
-        signals = showSignals;
     }
-    let group;
-    const spinner = new Spinner(`Fetching group ${groupId}`);
+    if (groupMembers.length === 0) {
+        console.info(`\n ${logSymbols.info}`, "info: there are no members in this group\n");
+        return;
+    }
+    const content = `${chalk.bold("Members")} (${groupMembers.length}): \n${groupMembers
+        .map((member, i) => `   ${i}. ${member}`)
+        .join("\n")}`;
+    console.info(`\n${content}\n`);
+});
+program
+    .command("get-proofs")
+    .description("Get the proofs from a supported network (e.g. goerli or arbitrum).")
+    .argument("[group-id]", "Identifier of the group.")
+    .option("-n, --network <network-name>", "Supported Ethereum network.")
+    .allowExcessArguments(false)
+    .action(async (groupId, { network }) => {
+    if (!network) {
+        network = await getSupportedNetwork(supportedNetworks);
+    }
+    if (!supportedNetworks.includes(network)) {
+        console.info(`\n ${logSymbols.error}`, `error: the network '${network}' is not supported\n`);
+        return;
+    }
+    if (!groupId) {
+        const groupIds = await getGroupIds(network);
+        if (groupIds === null)
+            return;
+        groupId = await getGroupId(groupIds);
+    }
+    let verifiedProofs;
+    const spinner = new Spinner(`Fetching proofs of group ${groupId}`);
     spinner.start();
     try {
         const semaphoreSubgraph = new SemaphoreSubgraph(network);
-        group = await semaphoreSubgraph.getGroup(groupId, { members, verifiedProofs: signals });
+        const group = await semaphoreSubgraph.getGroup(groupId, { verifiedProofs: true });
+        verifiedProofs = group.verifiedProofs;
         spinner.stop();
     }
     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);
+            verifiedProofs = await semaphoreEthers.getGroupVerifiedProofs(groupId);
             spinner.stop();
         }
         catch {
@@ -273,23 +377,13 @@ program
             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")}`;
+    if (verifiedProofs.length === 0) {
+        console.info(`\n ${logSymbols.info}`, "info: there are no proofs in this group\n");
+        return;
     }
+    const content = `${chalk.bold("Proofs")} (${verifiedProofs.length}): \n${verifiedProofs
+        .map(({ signal, merkleTreeRoot, externalNullifier, nullifierHash }, i) => `   ${i}. signal: ${signal} \n      merkleTreeRoot: ${merkleTreeRoot} \n      externalNullifier: ${externalNullifier} \n      nullifierHash: ${nullifierHash}`)
+        .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.5.0",
+  "version": "3.6.0-1",
   "description": "A command line tool to set up your Semaphore project and get group data.",
   "license": "MIT",
   "bin": {
@@ -34,6 +34,8 @@
   "devDependencies": {
     "@types/clear": "^0.1.2",
     "@types/figlet": "^1.5.5",
+    "@types/inquirer": "^9.0.3",
+    "@types/pacote": "^11.1.5",
     "@types/semver": "^7.3.13",
     "rollup-plugin-cleanup": "^3.2.1",
     "rollup-plugin-typescript2": "^0.31.2",
@@ -41,16 +43,17 @@
     "typedoc": "^0.22.11"
   },
   "dependencies": {
-    "@semaphore-protocol/data": "3.5.0",
+    "@semaphore-protocol/data": "3.6.0-1",
     "axios": "^1.3.2",
     "boxen": "^7.0.1",
     "chalk": "^5.1.2",
     "commander": "^9.4.1",
-    "download": "^8.0.0",
     "figlet": "^1.5.2",
     "inquirer": "^9.1.4",
     "log-symbols": "^5.1.0",
     "ora": "^6.1.2",
+    "pacote": "^15.1.1",
     "semver": "^7.3.8"
-  }
+  },
+  "stableVersion": "3.5.0"
 }

package/src/getGroupIds.ts

@@ -0,0 +1,42 @@
+import { SemaphoreSubgraph, SemaphoreEthers } from "@semaphore-protocol/data"
+import logSymbols from "log-symbols"
+import Spinner from "./spinner.js"
+
+/**
+ * Gets all group ids on the specified network
+ * @param network The specified network
+ */
+export default async function getGroupIds(network): Promise<string[]> {
+    let groupIds: string[]
+
+    const spinner = new Spinner("Fetching groups")
+
+    spinner.start()
+
+    try {
+        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")
+
+            return null
+        }
+    }
+    if (groupIds.length === 0) {
+        console.info(`\n ${logSymbols.info}`, "info: there are no groups in this network\n")
+        return null
+    }
+    return groupIds
+}

package/src/index.ts

@@ -1,14 +1,15 @@
-import { SemaphoreSubgraph, SemaphoreEthers, GroupResponse } from "@semaphore-protocol/data"
+import { GroupResponse, SemaphoreEthers, SemaphoreSubgraph } from "@semaphore-protocol/data"
 import chalk from "chalk"
 import { program } from "commander"
-import download from "download"
 import figlet from "figlet"
-import { existsSync, readFileSync, renameSync } from "fs"
-import inquirer from "inquirer"
+import { existsSync, readFileSync } from "fs"
 import logSymbols from "log-symbols"
+import pacote from "pacote"
 import { dirname } from "path"
 import { fileURLToPath } from "url"
 import checkLatestVersion from "./checkLatestVersion.js"
+import getGroupIds from "./getGroupIds.js"
+import { getGroupId, getProjectName, getSupportedNetwork, getSupportedTemplate } from "./inquirerPrompts.js"
 import Spinner from "./spinner.js"
 
 const packagePath = `${dirname(fileURLToPath(import.meta.url))}/..`
@@ -16,6 +17,21 @@ const { description, version } = JSON.parse(readFileSync(`${packagePath}/package
 
 const supportedNetworks = ["sepolia", "goerli", "mumbai", "optimism-goerli", "arbitrum", "arbitrum-goerli"]
 
+const supportedTemplates = [
+    {
+        value: "contracts-hardhat",
+        name: "Hardhat"
+    },
+    {
+        value: "monorepo-ethers",
+        name: "Hardhat + Next.js + SemaphoreEthers"
+    },
+    {
+        value: "monorepo-subgraph",
+        name: "Hardhat + Next.js + SemaphoreSubgraph"
+    }
+]
+
 program
     .name("semaphore")
     .description(description)
@@ -34,26 +50,27 @@ program
     .command("create")
     .description("Create a Semaphore project with a supported template.")
     .argument("[project-directory]", "Directory of the project.")
-    // .option("-t, --template <template-name>", "Supported Semaphore template.", "hardhat")
+    .option("-t, --template <template-name>", "Supported Semaphore template.")
     .allowExcessArguments(false)
-    .action(async (projectDirectory) => {
+    .action(async (projectDirectory, { template }) => {
         if (!projectDirectory) {
-            const { projectName } = await inquirer.prompt({
-                name: "projectName",
-                type: "input",
-                message: "What is your project name?",
-                default: "my-app"
-            })
-            projectDirectory = projectName
+            projectDirectory = await getProjectName()
+        }
+
+        if (!template) {
+            template = await getSupportedTemplate(supportedTemplates)
+        }
+
+        if (!supportedTemplates.some((t) => t.value === template)) {
+            console.info(`\n ${logSymbols.error}`, `error: the template '${template}' is not supported\n`)
+            return
         }
 
         const currentDirectory = process.cwd()
         const spinner = new Spinner(`Creating your project in ${chalk.green(`./${projectDirectory}`)}`)
-        const templateURL = `https://registry.npmjs.org/@semaphore-protocol/cli-template-hardhat/-/cli-template-hardhat-${version}.tgz`
 
         if (existsSync(projectDirectory)) {
             console.info(`\n ${logSymbols.error}`, `error: the '${projectDirectory}' folder already exists\n`)
-
             return
         }
 
@@ -61,9 +78,10 @@ program
 
         await checkLatestVersion(version)
 
-        await download(templateURL, currentDirectory, { extract: true })
-
-        renameSync(`${currentDirectory}/package`, `${currentDirectory}/${projectDirectory}`)
+        await pacote.extract(
+            `@semaphore-protocol/cli-template-${template}@${version}`,
+            `${currentDirectory}/${projectDirectory}`
+        )
 
         spinner.stop()
 
@@ -94,209 +112,213 @@ program
     .allowExcessArguments(false)
     .action(async ({ network }) => {
         if (!network) {
-            const { selectedNetwork } = await inquirer.prompt({
-                name: "selectedNetwork",
-                type: "list",
-                message: "Select one of our supported networks:",
-                default: supportedNetworks[0],
-                choices: supportedNetworks
-            })
-            network = selectedNetwork
+            network = await getSupportedNetwork(supportedNetworks)
         }
 
         if (!supportedNetworks.includes(network)) {
             console.info(`\n ${logSymbols.error}`, `error: the network '${network}' is not supported\n`)
+            return
+        }
+
+        const groupIds = await getGroupIds(network)
 
+        if (groupIds === null) return
+
+        const content = `${chalk.bold("Groups")} (${groupIds.length}): \n${groupIds
+            .map((id: any) => ` - ${id}`)
+            .join("\n")}`
+
+        console.info(`\n${content}\n`)
+    })
+
+program
+    .command("get-group")
+    .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.")
+    .allowExcessArguments(false)
+    .action(async (groupId, { network }) => {
+        if (!network) {
+            network = await getSupportedNetwork(supportedNetworks)
+        }
+
+        if (!supportedNetworks.includes(network)) {
+            console.info(`\n ${logSymbols.error}`, `error: the network '${network}' is not supported\n`)
             return
         }
 
-        let groupIds: string[]
+        if (!groupId) {
+            const groupIds = await getGroupIds(network)
+
+            if (groupIds === null) return
+
+            groupId = await getGroupId(groupIds)
+        }
 
-        const spinner = new Spinner("Fetching groups")
+        let group: GroupResponse
+
+        const spinner = new Spinner(`Fetching group ${groupId}`)
 
         spinner.start()
 
         try {
             const semaphoreSubgraph = new SemaphoreSubgraph(network)
 
-            groupIds = await semaphoreSubgraph.getGroupIds()
+            group = await semaphoreSubgraph.getGroup(groupId)
 
             spinner.stop()
         } catch {
             try {
                 const semaphoreEthers = new SemaphoreEthers(network)
 
-                groupIds = await semaphoreEthers.getGroupIds()
+                group = await semaphoreEthers.getGroup(groupId)
+
+                group.admin = await semaphoreEthers.getGroupAdmin(groupId)
 
                 spinner.stop()
             } catch {
                 spinner.stop()
-
-                console.info(`\n ${logSymbols.error}`, "error: unexpected error with the SemaphoreEthers package")
-
+                console.info(`\n ${logSymbols.error}`, "error: the group does not exist\n")
                 return
             }
         }
-        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: any) => ` - ${id}`).join("\n")}`
+        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}`
 
-        console.info(`${content}\n`)
+        console.info(`\n${content}\n`)
     })
 
 program
-    .command("get-group")
-    .description("Get the data of a group from a supported network (e.g. goerli or arbitrum).")
+    .command("get-members")
+    .description("Get the members 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.")
-    .option("-s, --signals", "Show group signals.")
     .allowExcessArguments(false)
-    .action(async (groupId, { network, members, signals }) => {
+    .action(async (groupId, { network }) => {
         if (!network) {
-            const { selectedNetwork } = await inquirer.prompt({
-                name: "selectedNetwork",
-                type: "list",
-                message: "Select one of our supported networks:",
-                default: supportedNetworks[0],
-                choices: supportedNetworks
-            })
-
-            network = selectedNetwork
+            network = await getSupportedNetwork(supportedNetworks)
         }
 
         if (!supportedNetworks.includes(network)) {
             console.info(`\n ${logSymbols.error}`, `error: the network '${network}' is not supported\n`)
-
             return
         }
 
         if (!groupId) {
-            let groupIds: string[]
+            const groupIds = await getGroupIds(network)
 
-            const spinnerGroups = new Spinner("Fetching groups")
+            if (groupIds === null) return
 
-            spinnerGroups.start()
-
-            try {
-                const semaphoreSubgraphGroups = new SemaphoreSubgraph(network)
+            groupId = await getGroupId(groupIds)
+        }
 
-                groupIds = await semaphoreSubgraphGroups.getGroupIds()
+        let groupMembers: string[]
 
-                spinnerGroups.stop()
-            } catch {
-                try {
-                    const semaphoreEthersGroups = new SemaphoreEthers(network)
+        const spinner = new Spinner(`Fetching members of group ${groupId}`)
 
-                    groupIds = await semaphoreEthersGroups.getGroupIds()
+        spinner.start()
 
-                    spinnerGroups.stop()
-                } catch {
-                    spinnerGroups.stop()
+        try {
+            const semaphoreSubgraph = new SemaphoreSubgraph(network)
 
-                    console.info(`\n ${logSymbols.error}`, "error: unexpected error with the SemaphoreEthers package")
+            const group = await semaphoreSubgraph.getGroup(groupId, { members: true })
+            groupMembers = group.members
 
-                    return
-                }
-            }
+            spinner.stop()
+        } catch {
+            try {
+                const semaphoreEthers = new SemaphoreEthers(network)
 
-            if (groupIds.length === 0) {
-                console.info(`\n ${logSymbols.info}`, "info: there are no groups in this network\n")
+                groupMembers = await semaphoreEthers.getGroupMembers(groupId)
 
+                spinner.stop()
+            } catch {
+                spinner.stop()
+                console.info(`\n ${logSymbols.error}`, "error: the group does not exist\n")
                 return
             }
+        }
 
-            const { selectedGroupId } = await inquirer.prompt({
-                name: "selectedGroupId",
-                type: "list",
-                message: "Select one of the following existing group ids:",
-                choices: groupIds
-            })
+        if (groupMembers.length === 0) {
+            console.info(`\n ${logSymbols.info}`, "info: there are no members in this group\n")
+            return
+        }
+
+        const content = `${chalk.bold("Members")} (${groupMembers.length}): \n${groupMembers
+            .map((member: string, i: number) => `   ${i}. ${member}`)
+            .join("\n")}`
 
-            groupId = selectedGroupId
+        console.info(`\n${content}\n`)
+    })
+
+program
+    .command("get-proofs")
+    .description("Get the proofs from a supported network (e.g. goerli or arbitrum).")
+    .argument("[group-id]", "Identifier of the group.")
+    .option("-n, --network <network-name>", "Supported Ethereum network.")
+    .allowExcessArguments(false)
+    .action(async (groupId, { network }) => {
+        if (!network) {
+            network = await getSupportedNetwork(supportedNetworks)
         }
 
-        if (!members && !signals) {
-            const { showMembers } = await inquirer.prompt({
-                name: "showMembers",
-                type: "confirm",
-                message: "Do you want to show members?",
-                default: false
-            })
+        if (!supportedNetworks.includes(network)) {
+            console.info(`\n ${logSymbols.error}`, `error: the network '${network}' is not supported\n`)
+            return
+        }
 
-            members = showMembers
+        if (!groupId) {
+            const groupIds = await getGroupIds(network)
 
-            const { showSignals } = await inquirer.prompt({
-                name: "showSignals",
-                type: "confirm",
-                message: "Do you want to show signals?",
-                default: false
-            })
+            if (groupIds === null) return
 
-            signals = showSignals
+            groupId = await getGroupId(groupIds)
         }
 
-        let group: GroupResponse
+        let verifiedProofs: any[]
 
-        const spinner = new Spinner(`Fetching group ${groupId}`)
+        const spinner = new Spinner(`Fetching proofs of group ${groupId}`)
 
         spinner.start()
 
         try {
             const semaphoreSubgraph = new SemaphoreSubgraph(network)
 
-            group = await semaphoreSubgraph.getGroup(groupId, { members, verifiedProofs: signals })
+            const group = await semaphoreSubgraph.getGroup(groupId, { verifiedProofs: true })
+            verifiedProofs = group.verifiedProofs
 
             spinner.stop()
         } 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)
+                verifiedProofs = await semaphoreEthers.getGroupVerifiedProofs(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: string, i: number) => `   ${i}. ${member}`)
-                .join("\n")}`
+        if (verifiedProofs.length === 0) {
+            console.info(`\n ${logSymbols.info}`, "info: there are no proofs in this group\n")
+            return
         }
 
-        if (signals) {
-            content += `\n\n ${chalk.bold("Signals")}: \n${group.verifiedProofs
-                .map(({ signal }: any) => `   - ${signal}`)
-                .join("\n")}`
-        }
+        const content = `${chalk.bold("Proofs")} (${verifiedProofs.length}): \n${verifiedProofs
+            .map(
+                ({ signal, merkleTreeRoot, externalNullifier, nullifierHash }: any, i: number) =>
+                    `   ${i}. signal: ${signal} \n      merkleTreeRoot: ${merkleTreeRoot} \n      externalNullifier: ${externalNullifier} \n      nullifierHash: ${nullifierHash}`
+            )
+            .join("\n")}`
 
         console.info(`\n${content}\n`)
     })

package/src/inquirerPrompts.ts

@@ -0,0 +1,48 @@
+import inquirer from "inquirer"
+
+export async function getProjectName() {
+    const { projectName } = await inquirer.prompt({
+        name: "projectName",
+        type: "input",
+        message: "What is your project name?",
+        default: "my-app"
+    })
+    return projectName
+}
+
+export async function getSupportedTemplate(supportedTemplates: { value: string; name: string }[]) {
+    const { selectedTemplate } = await inquirer.prompt({
+        name: "selectedTemplate",
+        type: "list",
+        message: "Select one of the supported templates:",
+        default: 0,
+        choices: supportedTemplates.map((template) => ({
+            value: template.value,
+            name: `${template.value} (${template.name})`
+        }))
+    })
+    return selectedTemplate
+}
+
+export async function getSupportedNetwork(supportedNetworks: string[]) {
+    const { selectedNetwork } = await inquirer.prompt({
+        name: "selectedNetwork",
+        type: "list",
+        message: "Select one of the supported networks:",
+        default: 0,
+        choices: supportedNetworks
+    })
+    return selectedNetwork
+}
+
+export async function getGroupId(groupIds: string[]) {
+    const { selectedGroupId } = await inquirer.prompt({
+        name: "selectedGroupId",
+        type: "list",
+        message: "Select one of the following existing group ids:",
+        default: 0,
+        choices: groupIds
+    })
+
+    return selectedGroupId
+}