@cartesi/cli 2.0.0-alpha.1 → 2.0.0-alpha.12

package/dist/commands/send/erc721.js

@@ -1,45 +1,55 @@
+import { Command } from "@commander-js/extra-typings";
 import input from "@inquirer/input";
-import { erc721Abi, isAddress, } from "viem";
+import ora from "ora";
+import { erc721Abi, getAddress, isAddress, } from "viem";
 import { erc721PortalAbi, erc721PortalAddress } from "../../contracts.js";
-import * as CustomFlags from "../../flags.js";
-import { SendBaseCommand } from "./index.js";
-class SendERC721 extends SendBaseCommand {
-    async readToken(publicClient, address) {
-        const args = { abi: erc721Abi, address };
-        const symbol = await publicClient.readContract({
-            ...args,
-            functionName: "symbol",
-        });
-        const name = await publicClient.readContract({
-            ...args,
-            functionName: "name",
-        });
-        return {
-            name,
-            symbol,
-        };
+import { connect, getInputApplicationAddress, } from "../send.js";
+const readToken = async (publicClient, address) => {
+    const args = { abi: erc721Abi, address };
+    const symbol = await publicClient.readContract({
+        ...args,
+        functionName: "symbol",
+    });
+    const name = await publicClient.readContract({
+        ...args,
+        functionName: "name",
+    });
+    return {
+        name,
+        symbol,
+    };
+};
+const ercValidator = (publicClient) => async (value) => {
+    if (!isAddress(value)) {
+        return "Invalid address";
+    }
+    try {
+        await readToken(publicClient, value);
     }
-    async send(publicClient, walletClient) {
+    catch (e) {
+        return "Invalid token";
+    }
+    return true;
+};
+export const createErc721Command = () => {
+    return new Command("erc721")
+        .description("Sends ERC-721 deposits to the application, optionally in interactive mode.")
+        .configureHelp({ showGlobalOptions: true })
+        .option("--token <address>", "token address")
+        .option("--token-id <number>", "token ID")
+        .action(async (options, command) => {
+        const sendOptions = command.optsWithGlobals();
+        // connect to RPC provider
+        const { publicClient, walletClient } = await connect(sendOptions);
         // get dapp address from local node, or ask
-        const applicationAddress = await super.getApplicationAddress();
-        const ercValidator = async (value) => {
-            if (!isAddress(value)) {
-                return "Invalid address";
-            }
-            try {
-                await this.readToken(publicClient, value);
-            }
-            catch (e) {
-                return "Invalid token";
-            }
-            return true;
-        };
-        const token = this.flags.token ||
-            (await input({
+        const applicationAddress = await getInputApplicationAddress(sendOptions.dapp);
+        const token = options.token && isAddress(options.token)
+            ? getAddress(options.token)
+            : (await input({
                 message: "Token address",
-                validate: ercValidator,
+                validate: ercValidator(publicClient),
             }));
-        const tokenId = this.flags.tokenId ||
+        const tokenId = options.tokenId ||
             (await input({
                 message: "Token ID",
                 validate: (value) => {
@@ -60,14 +70,9 @@ class SendERC721 extends SendBaseCommand {
             account: walletClient.account,
         });
         // XXX: add support for baseLayerData and execLayerData
-        return walletClient.writeContract(request);
-    }
-}
-SendERC721.summary = "Send ERC-721 deposit to the application.";
-SendERC721.description = "Sends ERC-721 deposits to the application, optionally in interactive mode.";
-SendERC721.flags = {
-    token: CustomFlags.address({ description: "token address" }),
-    tokenId: CustomFlags.bigint({ description: "token ID" }),
+        const hash = await walletClient.writeContract(request);
+        const progress = ora("Sending input...").start();
+        await publicClient.waitForTransactionReceipt({ hash });
+        progress.succeed(`Input sent: ${hash}`);
+    });
 };
-SendERC721.examples = ["<%= config.bin %> <%= command.id %>"];
-export default SendERC721;

package/dist/commands/send/ether.d.ts

@@ -1,13 +1,12 @@
-import { Address, PublicClient, WalletClient } from "viem";
-import { SendBaseCommand } from "./index.js";
-export default class SendEther extends SendBaseCommand<typeof SendEther> {
-    static summary: string;
-    static description: string;
-    static flags: {
-        amount: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<`${number}` | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
-        execLayerData: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<`0x${string}`, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
-    };
-    static examples: string[];
-    send(publicClient: PublicClient, walletClient: WalletClient): Promise<Address>;
-}
+import { Command } from "@commander-js/extra-typings";
+export declare const createEtherCommand: () => Command<[], {
+    amount?: string | undefined;
+    execLayerData: string;
+}, {
+    chainId: number;
+    rpcUrl?: string | undefined;
+    mnemonic?: string | undefined;
+    mnemonicIndex: number;
+    dapp?: `0x${string}` | undefined;
+}>;
 //# sourceMappingURL=ether.d.ts.map

package/dist/commands/send/ether.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ether.d.ts","sourceRoot":"","sources":["../../../src/commands/send/ether.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,OAAO,EAAc,YAAY,EAAE,YAAY,EAAE,MAAM,MAAM,CAAC;AAIvE,OAAO,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAE7C,MAAM,CAAC,OAAO,OAAO,SAAU,SAAQ,eAAe,CAAC,OAAO,SAAS,CAAC;IACpE,MAAM,CAAC,OAAO,SAA4C;IAE1D,MAAM,CAAC,WAAW,SAC6D;IAE/E,MAAM,CAAC,KAAK;;;MAMV;IAEF,MAAM,CAAC,QAAQ,WAA2C;IAE7C,IAAI,CACb,YAAY,EAAE,YAAY,EAC1B,YAAY,EAAE,YAAY,GAC3B,OAAO,CAAC,OAAO,CAAC;CAkBtB"}
+{"version":3,"file":"ether.d.ts","sourceRoot":"","sources":["../../../src/commands/send/ether.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,6BAA6B,CAAC;AAWtD,eAAO,MAAM,kBAAkB;;;;;;;;;EAuC9B,CAAC"}

package/dist/commands/send/ether.js

@@ -1,32 +1,36 @@
+import { Command } from "@commander-js/extra-typings";
 import input from "@inquirer/input";
-import { parseEther } from "viem";
+import ora from "ora";
+import { isHex, parseEther } from "viem";
 import { etherPortalAbi, etherPortalAddress } from "../../contracts.js";
-import * as CustomFlags from "../../flags.js";
-import { SendBaseCommand } from "./index.js";
-class SendEther extends SendBaseCommand {
-    async send(publicClient, walletClient) {
+import { connect, getInputApplicationAddress, } from "../send.js";
+export const createEtherCommand = () => {
+    return new Command("ether")
+        .description("Sends ether deposits to the application, optionally in interactive mode.")
+        .configureHelp({ showGlobalOptions: true })
+        .option("--amount <number>", "amount, in ETH units")
+        .option("--exec-layer-data <hex>", "exec layer data", "0x")
+        .action(async (options, command) => {
+        const sendOptions = command.optsWithGlobals();
+        // connect to RPC provider
+        const { publicClient, walletClient } = await connect(sendOptions);
         // get dapp address from local node, or ask
-        const applicationAddress = await super.getApplicationAddress();
-        const amount = this.flags.amount || (await input({ message: "Amount" }));
+        const applicationAddress = await getInputApplicationAddress(sendOptions.dapp);
+        const amount = options.amount || (await input({ message: "Amount" }));
         const { request } = await publicClient.simulateContract({
             address: etherPortalAddress,
             abi: etherPortalAbi,
             functionName: "depositEther",
-            args: [applicationAddress, this.flags.execLayerData],
+            args: [
+                applicationAddress,
+                isHex(options.execLayerData) ? options.execLayerData : "0x", // XXX: validate before this
+            ],
             value: parseEther(amount),
             account: walletClient.account,
         });
-        return walletClient.writeContract(request);
-    }
-}
-SendEther.summary = "Send ether deposit to the application.";
-SendEther.description = "Sends ether deposits to the application, optionally in interactive mode.";
-SendEther.flags = {
-    amount: CustomFlags.number({ description: "amount, in ETH units" }),
-    execLayerData: CustomFlags.hex({
-        description: "exec layer data",
-        default: "0x",
-    }),
+        const hash = await walletClient.writeContract(request);
+        const progress = ora("Sending input...").start();
+        await publicClient.waitForTransactionReceipt({ hash });
+        progress.succeed(`Input sent: ${hash}`);
+    });
 };
-SendEther.examples = ["<%= config.bin %> <%= command.id %>"];
-export default SendEther;

package/dist/commands/send/generic.d.ts

@@ -1,15 +1,15 @@
-import { Address, PublicClient, WalletClient } from "viem";
-import { SendBaseCommand } from "./index.js";
-export default class SendGeneric extends SendBaseCommand<typeof SendGeneric> {
-    static summary: string;
-    static description: string;
-    static examples: string[];
-    static flags: {
-        input: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
-        "input-encoding": import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
-        "input-abi-params": import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
-    };
-    protected getInput(): Promise<`0x${string}` | undefined>;
-    send(publicClient: PublicClient, walletClient: WalletClient): Promise<Address>;
-}
+import { Command } from "@commander-js/extra-typings";
+export declare const createGenericCommand: () => Command<[], {
+    input?: string | undefined;
+    inputEncoding?: "string" | "hex" | "abi" | undefined;
+    type: "evm" | "eip712";
+    eip712TxUrl: string;
+    inputAbiParams?: string | undefined;
+}, {
+    chainId: number;
+    rpcUrl?: string | undefined;
+    mnemonic?: string | undefined;
+    mnemonicIndex: number;
+    dapp?: `0x${string}` | undefined;
+}>;
 //# sourceMappingURL=generic.d.ts.map

package/dist/commands/send/generic.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"generic.d.ts","sourceRoot":"","sources":["../../../src/commands/send/generic.ts"],"names":[],"mappings":"AACA,OAAO,EACH,OAAO,EACP,YAAY,EACZ,YAAY,EAOf,MAAM,MAAM,CAAC;AAId,OAAO,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAE7C,MAAM,CAAC,OAAO,OAAO,WAAY,SAAQ,eAAe,CAAC,OAAO,WAAW,CAAC;IACxE,MAAM,CAAC,OAAO,SAA4C;IAE1D,MAAM,CAAC,WAAW,SAC8D;IAEhF,MAAM,CAAC,QAAQ,WAA2C;IAE1D,MAAM,CAAC,KAAK;;;;MAgBV;cAEc,QAAQ,IAAI,OAAO,CAAC,KAAK,MAAM,EAAE,GAAG,SAAS,CAAC;IA8EjD,IAAI,CACb,YAAY,EAAE,YAAY,EAC1B,YAAY,EAAE,YAAY,GAC3B,OAAO,CAAC,OAAO,CAAC;CAgBtB"}
+{"version":3,"file":"generic.d.ts","sourceRoot":"","sources":["../../../src/commands/send/generic.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAU,MAAM,6BAA6B,CAAC;AAqG9D,eAAO,MAAM,oBAAoB;;;;;;;;;;;;EA8DhC,CAAC"}

package/dist/commands/send/generic.js

@@ -1,93 +1,112 @@
-import { Flags } from "@oclif/core";
+import { Command, Option } from "@commander-js/extra-typings";
+import ora from "ora";
 import { encodeAbiParameters, getAddress, isAddress, isHex, parseAbiParameters, stringToHex, } from "viem";
 import { inputBoxAbi, inputBoxAddress } from "../../contracts.js";
 import { bytesInput } from "../../prompts.js";
-import { SendBaseCommand } from "./index.js";
-class SendGeneric extends SendBaseCommand {
-    async getInput() {
-        const input = this.flags.input;
-        const encoding = this.flags["input-encoding"];
-        if (input) {
-            if (encoding === "hex") {
-                // validate if is a hex value
-                if (!isHex(input)) {
-                    throw new Error("input encoded as hex must start with 0x");
-                }
-                return input;
+import { connect, getInputApplicationAddress, } from "../send.js";
+import { DEFAULT_SEND_CONFIG, sendEip712 } from "./eip712.js";
+const getInput = async (options) => {
+    const input = options.input;
+    const encoding = options.inputEncoding;
+    if (input) {
+        if (encoding === "hex") {
+            // validate if is a hex value
+            if (!isHex(input)) {
+                throw new Error("input encoded as hex must start with 0x");
             }
-            else if (encoding === "string") {
-                // encode UTF-8 string as hex
-                return stringToHex(input);
+            return input;
+        }
+        if (encoding === "string") {
+            // encode UTF-8 string as hex
+            return stringToHex(input);
+        }
+        if (encoding === "abi") {
+            const abiParams = options.inputAbiParams;
+            if (!abiParams) {
+                throw new Error("Undefined input-abi-params");
             }
-            else if (encoding === "abi") {
-                const abiParams = this.flags["input-abi-params"];
-                if (!abiParams) {
-                    throw new Error("Undefined input-abi-params");
+            const abiParameters = parseAbiParameters(abiParams);
+            // TODO: decode values
+            const values = input.split(",").map((v, index) => {
+                if (index >= abiParameters.length) {
+                    throw new Error(`Too many values, expected ${abiParameters.length} values based on --input-abi-params '${abiParams}', parsing value at index ${index} from input '${input}'`);
                 }
-                const abiParameters = parseAbiParameters(abiParams);
-                // TODO: decode values
-                const values = input.split(",").map((v, index) => {
-                    if (index >= abiParameters.length) {
-                        throw new Error(`Too many values, expected ${abiParameters.length} values based on --input-abi-params '${abiParams}', parsing value at index ${index} from input '${input}'`);
-                    }
-                    const param = abiParameters[index];
-                    switch (param.type) {
-                        case "string":
+                const param = abiParameters[index];
+                switch (param.type) {
+                    case "string":
+                        return v;
+                    case "bool":
+                        if (v === "true")
+                            return true;
+                        if (v === "false")
+                            return false;
+                        throw new Error(`Invalid boolean value: ${v}`);
+                    case "uint":
+                    case "uint8":
+                    case "uint16":
+                    case "uint32":
+                    case "uint64":
+                    case "uint128":
+                    case "uint256":
+                        try {
+                            return BigInt(v);
+                        }
+                        catch (e) {
+                            throw new Error(`Invalid uint value: ${v}`);
+                        }
+                    case "bytes":
+                        if (isHex(v)) {
                             return v;
-                        case "bool":
-                            if (v === "true")
-                                return true;
-                            if (v === "false")
-                                return false;
-                            throw new Error(`Invalid boolean value: ${v}`);
-                        case "uint":
-                        case "uint8":
-                        case "uint16":
-                        case "uint32":
-                        case "uint64":
-                        case "uint128":
-                        case "uint256":
-                            try {
-                                return BigInt(v);
-                            }
-                            catch (e) {
-                                throw new Error(`Invalid uint value: ${v}`);
-                            }
-                        case "bytes":
-                            if (isHex(v)) {
-                                return v;
-                            }
-                            throw new Error(`Invalid bytes value: ${v}`);
-                        case "address":
-                            if (isAddress(v)) {
-                                return getAddress(v);
-                            }
-                            throw new Error(`Invalid address value: ${v}`);
-                        default:
-                            throw new Error(`Unsupported type ${param.type}`);
-                    }
-                });
-                if (values.length !== abiParameters.length) {
-                    throw new Error(`Not enough values, expected ${abiParameters.length} values based on --input-abi-params '${abiParams}', parsed ${values.length} values from input '${input}'`);
-                }
-                return encodeAbiParameters(abiParameters, values);
-            }
-            else {
-                if (isHex(input)) {
-                    return input;
-                }
-                else {
-                    // encode UTF-8 string as hex
-                    return stringToHex(input);
+                        }
+                        throw new Error(`Invalid bytes value: ${v}`);
+                    case "address":
+                        if (isAddress(v)) {
+                            return getAddress(v);
+                        }
+                        throw new Error(`Invalid address value: ${v}`);
+                    default:
+                        throw new Error(`Unsupported type ${param.type}`);
                 }
+            });
+            if (values.length !== abiParameters.length) {
+                throw new Error(`Not enough values, expected ${abiParameters.length} values based on --input-abi-params '${abiParams}', parsed ${values.length} values from input '${input}'`);
             }
+            return encodeAbiParameters(abiParameters, values);
+        }
+        if (isHex(input)) {
+            return input;
         }
-        return undefined;
+        // encode UTF-8 string as hex
+        return stringToHex(input);
     }
-    async send(publicClient, walletClient) {
+    return undefined;
+};
+export const createGenericCommand = () => {
+    return new Command("generic")
+        .description("Sends generics inputs to the application, optionally in interactive mode.")
+        .configureHelp({ showGlobalOptions: true })
+        .option("--input <input>", "input payload")
+        .addOption(new Option("--input-encoding <input-encoding>", "input encoding").choices(["hex", "string", "abi"]))
+        .addOption(new Option("--type <type>", "Transaction type").choices(["evm", "eip712"])
+        .default("evm"))
+        .addOption(new Option("--eip712-tx-url <url>", "EIP-712 base url").default(DEFAULT_SEND_CONFIG.eip712TxUrl))
+        .option("--input-abi-params <input-abi-params>", "input abi params")
+        .action(async (options, command) => {
+        const sendOptions = command.optsWithGlobals();
+        // connect to RPC provider
+        const { publicClient, walletClient } = await connect(sendOptions);
         // get dapp address from local node, or ask
-        const applicationAddress = await super.getApplicationAddress();
-        const payload = (await this.getInput()) || (await bytesInput({ message: "Input" }));
+        const applicationAddress = await getInputApplicationAddress(sendOptions.dapp);
+        const payload = (await getInput(options)) ||
+            (await bytesInput({ message: "Input" }));
+        if (options.type === 'eip712') {
+            const progress = ora("Sending input...").start();
+            const hash = await sendEip712(walletClient, applicationAddress, payload, {
+                eip712TxUrl: options.eip712TxUrl,
+            });
+            progress.succeed(`Input sent: ${hash}`);
+            return;
+        }
         const { request } = await publicClient.simulateContract({
             address: inputBoxAddress,
             abi: inputBoxAbi,
@@ -95,25 +114,9 @@ class SendGeneric extends SendBaseCommand {
             args: [applicationAddress, payload],
             account: walletClient.account,
         });
-        return walletClient.writeContract(request);
-    }
-}
-SendGeneric.summary = "Send generic input to the application.";
-SendGeneric.description = "Sends generics inputs to the application, optionally in interactive mode.";
-SendGeneric.examples = ["<%= config.bin %> <%= command.id %>"];
-SendGeneric.flags = {
-    input: Flags.string({
-        description: "input payload",
-        summary: "see input-encoding for definition on how input is parsed",
-    }),
-    "input-encoding": Flags.string({
-        description: "input encoding",
-        summary: "if input-encoding is undefined, the input is parsed as a hex-string if it starts with 0x or else is parsed as a UTF-8 encoding",
-        options: ["hex", "string", "abi"],
-    }),
-    "input-abi-params": Flags.string({
-        description: "input abi params",
-        summary: "ABI params definition for input, following human-readable format specified at https://abitype.dev/api/human.html#parseabiparameters",
-    }),
+        const hash = await walletClient.writeContract(request);
+        const progress = ora("Sending input...").start();
+        await publicClient.waitForTransactionReceipt({ hash });
+        progress.succeed(`Input sent: ${hash}`);
+    });
 };
-export default SendGeneric;

package/dist/commands/send.d.ts

@@ -0,0 +1,21 @@
+import { Command } from "@commander-js/extra-typings";
+import { type Address, type PublicClient, type WalletClient } from "viem";
+export declare const connect: (options: {
+    chainId?: number;
+    rpcUrl?: string;
+    mnemonic?: string;
+    mnemonicIndex: number;
+}) => Promise<{
+    publicClient: PublicClient;
+    walletClient: WalletClient;
+}>;
+export declare const getInputApplicationAddress: (dapp?: string) => Promise<Address>;
+export declare const createSendCommand: () => Command<[], {
+    chainId: number;
+    rpcUrl?: string | undefined;
+    mnemonic?: string | undefined;
+    mnemonicIndex: number;
+    dapp?: `0x${string}` | undefined;
+}, {}>;
+export type SendCommandOpts = ReturnType<ReturnType<typeof createSendCommand>["opts"]>;
+//# sourceMappingURL=send.d.ts.map

package/dist/commands/send.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"send.d.ts","sourceRoot":"","sources":["../../src/commands/send.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,6BAA6B,CAAC;AAGtD,OAAO,EACH,KAAK,OAAO,EACZ,KAAK,YAAY,EACjB,KAAK,YAAY,EAEpB,MAAM,MAAM,CAAC;AASd,eAAO,MAAM,OAAO,GAAI,SAAS;IAC7B,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,aAAa,EAAE,MAAM,CAAC;CACzB,KAAG,OAAO,CAAC;IACR,YAAY,EAAE,YAAY,CAAC;IAC3B,YAAY,EAAE,YAAY,CAAC;CAC9B,CAYA,CAAC;AAEF,eAAO,MAAM,0BAA0B,GACnC,OAAO,MAAM,KACd,OAAO,CAAC,OAAO,CAiBjB,CAAC;AAEF,eAAO,MAAM,iBAAiB;;;;;;MA6C7B,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG,UAAU,CACpC,UAAU,CAAC,OAAO,iBAAiB,CAAC,CAAC,MAAM,CAAC,CAC/C,CAAC"}

package/dist/commands/send.js

@@ -0,0 +1,67 @@
+import { Command } from "@commander-js/extra-typings";
+import input from "@inquirer/input";
+import select from "@inquirer/select";
+import { isAddress, } from "viem";
+import { parseAddress } from "../base.js";
+import { getApplicationAddress } from "../exec/rollups.js";
+import createClients, { supportedChains } from "../wallet.js";
+import { createErc20Command } from "./send/erc20.js";
+import { createErc721Command } from "./send/erc721.js";
+import { createEtherCommand } from "./send/ether.js";
+import { createGenericCommand } from "./send/generic.js";
+export const connect = (options) => {
+    const { chainId, rpcUrl, mnemonic, mnemonicIndex } = options;
+    // create viem clients
+    return createClients({
+        chain: supportedChains({ includeDevnet: true }).find((c) => c.id === chainId),
+        rpcUrl,
+        mnemonicPassphrase: mnemonic,
+        mnemonicIndex,
+    });
+};
+export const getInputApplicationAddress = async (dapp) => {
+    if (dapp && isAddress(dapp)) {
+        // honor the flag
+        return dapp;
+    }
+    // get the running container dapp address
+    const nodeAddress = await getApplicationAddress();
+    // query for the address
+    const applicationAddress = await input({
+        message: "Application address",
+        validate: (value) => isAddress(value) || "Invalid address",
+        default: nodeAddress,
+    });
+    return applicationAddress;
+};
+export const createSendCommand = () => {
+    const command = new Command("send")
+        .description("Sends different kinds of input to the application in interactive mode.")
+        .option("--chain-id <id>", "Chain ID", Number.parseInt, 13370)
+        .option("--rpc-url <url>", "RPC URL")
+        .option("--mnemonic <phrase>", "Mnemonic passphrase")
+        .option("--mnemonic-index <index>", "Mnemonic account index", Number.parseInt, 0)
+        .option("--dapp <address>", "Application address", parseAddress, undefined)
+        .action(async (options, program) => {
+        // Get the registered subcommands from the program
+        const commands = program.commands;
+        // Create choices for the select prompt based on registered commands
+        const choices = commands.map((cmd) => ({
+            name: cmd.name(),
+            value: cmd,
+            description: cmd.description(),
+        }));
+        // Present the list of subcommands using @inquirer/select
+        const subcommand = await select({
+            message: "Select the type of input to send",
+            choices,
+        });
+        // Execute the selected subcommand
+        subcommand.parseAsync(program.args);
+    });
+    command.addCommand(createGenericCommand());
+    command.addCommand(createErc20Command());
+    command.addCommand(createErc721Command());
+    command.addCommand(createEtherCommand());
+    return command;
+};

package/dist/commands/shell.d.ts

@@ -1,15 +1,7 @@
-import { BaseCommand } from "../baseCommand.js";
-export default class Shell extends BaseCommand<typeof Shell> {
-    static description: string;
-    static examples: string[];
-    static args: {
-        image: import("@oclif/core/lib/interfaces/parser.js").Arg<string | undefined, Record<string, unknown>>;
-    };
-    static flags: {
-        command: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
-        config: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
-        "run-as-root": import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
-    };
-    run(): Promise<void>;
-}
+import { Command } from "@commander-js/extra-typings";
+export declare const createShellCommand: () => Command<[string | undefined], {
+    command: string;
+    config: string;
+    runAsRoot: boolean;
+}, {}>;
 //# sourceMappingURL=shell.d.ts.map

package/dist/commands/shell.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shell.d.ts","sourceRoot":"","sources":["../../src/commands/shell.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAIhD,MAAM,CAAC,OAAO,OAAO,KAAM,SAAQ,WAAW,CAAC,OAAO,KAAK,CAAC;IACxD,MAAM,CAAC,WAAW,SAAqD;IAEvE,MAAM,CAAC,QAAQ,WAA2C;IAE1D,MAAM,CAAC,IAAI;;MAKT;IAEF,MAAM,CAAC,KAAK;;;;MAgBV;IAEW,GAAG,IAAI,OAAO,CAAC,IAAI,CAAC;CA2CpC"}
+{"version":3,"file":"shell.d.ts","sourceRoot":"","sources":["../../src/commands/shell.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,6BAA6B,CAAC;AAOtD,eAAO,MAAM,kBAAkB;;;;MAiD9B,CAAC"}