@cartesi/cli 2.0.0-alpha.3 → 2.0.0-alpha.5

package/dist/commands/send/erc20.js

@@ -1,50 +1,58 @@
 import input from "@inquirer/input";
-import { erc20Abi, isAddress, parseEther, } from "viem";
+import ora from "ora";
+import { erc20Abi, getAddress, isAddress, parseEther, } from "viem";
 import { erc20PortalAbi, erc20PortalAddress } from "../../contracts.js";
-import * as CustomFlags from "../../flags.js";
-import { SendBaseCommand } from "./index.js";
-class SendERC20 extends SendBaseCommand {
-    async readToken(publicClient, address) {
-        const args = { abi: erc20Abi, address };
-        const symbol = await publicClient.readContract({
-            ...args,
-            functionName: "symbol",
-        });
-        const name = await publicClient.readContract({
-            ...args,
-            functionName: "name",
-        });
-        const decimals = await publicClient.readContract({
-            ...args,
-            functionName: "decimals",
-        });
-        return {
-            name,
-            symbol,
-            decimals,
-        };
+import { addCommonOptions, connect, getInputApplicationAddress, } from "../send.js";
+const readToken = async (publicClient, address) => {
+    const args = { abi: erc20Abi, address };
+    const symbol = await publicClient.readContract({
+        ...args,
+        functionName: "symbol",
+    });
+    const name = await publicClient.readContract({
+        ...args,
+        functionName: "name",
+    });
+    const decimals = await publicClient.readContract({
+        ...args,
+        functionName: "decimals",
+    });
+    return {
+        name,
+        symbol,
+        decimals,
+    };
+};
+const ercValidator = (publicClient) => async (value) => {
+    if (!isAddress(value)) {
+        return "Invalid address";
     }
-    async send(publicClient, walletClient) {
+    try {
+        await readToken(publicClient, value);
+    }
+    catch (e) {
+        return "Invalid token";
+    }
+    return true;
+};
+export const registerErc20Command = (program) => {
+    addCommonOptions(program
+        .command("erc20")
+        .description("Sends ERC-20 deposits to the application, optionally in interactive mode."))
+        .option("--token <address>", "token address")
+        .option("--amount <number>", "amount to send")
+        .action(async (options) => {
+        // connect to RPC provider
+        const { publicClient, walletClient } = await connect(options);
         // 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 tokenAddress = this.flags.token ||
-            (await input({
+        const applicationAddress = await getInputApplicationAddress();
+        const tokenAddress = options.token && isAddress(options.token)
+            ? getAddress(options.token)
+            : (await input({
                 message: "Token address",
-                validate: ercValidator,
+                validate: ercValidator(publicClient),
             }));
-        const amount = this.flags.amount || (await input({ message: "Amount" }));
+        const amount = options.amount || (await input({ message: "Amount" }));
         const { request } = await publicClient.simulateContract({
             address: erc20PortalAddress,
             abi: erc20PortalAbi,
@@ -52,19 +60,14 @@ class SendERC20 extends SendBaseCommand {
             args: [
                 tokenAddress,
                 applicationAddress,
-                parseEther(amount),
+                parseEther(amount), // XXX: we need to use the token decimals here!
                 "0x",
             ],
             account: walletClient.account,
         });
-        return walletClient.writeContract(request);
-    }
-}
-SendERC20.summary = "Send ERC-20 deposit to the application.";
-SendERC20.description = "Sends ERC-20 deposits to the application, optionally in interactive mode.";
-SendERC20.flags = {
-    token: CustomFlags.address({ description: "token address" }),
-    amount: CustomFlags.number({ description: "amount" }),
+        const hash = await walletClient.writeContract(request);
+        const progress = ora("Sending input...").start();
+        await publicClient.waitForTransactionReceipt({ hash });
+        progress.succeed(`Input sent: ${hash}`);
+    });
 };
-SendERC20.examples = ["<%= config.bin %> <%= command.id %>"];
-export default SendERC20;

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

@@ -1,14 +1,3 @@
-import { Address, PublicClient, WalletClient } from "viem";
-import { SendBaseCommand } from "./index.js";
-export default class SendERC721 extends SendBaseCommand<typeof SendERC721> {
-    static summary: string;
-    static description: string;
-    static flags: {
-        token: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<`0x${string}` | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
-        tokenId: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<bigint | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
-    };
-    static examples: string[];
-    private readToken;
-    send(publicClient: PublicClient, walletClient: WalletClient): Promise<Address>;
-}
+import { Command } from "@commander-js/extra-typings";
+export declare const registerErc721Command: (program: Command) => void;
 //# sourceMappingURL=erc721.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"erc721.d.ts","sourceRoot":"","sources":["../../../src/commands/send/erc721.ts"],"names":[],"mappings":"AACA,OAAO,EACH,OAAO,EAGP,YAAY,EACZ,YAAY,EACf,MAAM,MAAM,CAAC;AAId,OAAO,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAO7C,MAAM,CAAC,OAAO,OAAO,UAAW,SAAQ,eAAe,CAAC,OAAO,UAAU,CAAC;IACtE,MAAM,CAAC,OAAO,SAA8C;IAE5D,MAAM,CAAC,WAAW,SAC+D;IAEjF,MAAM,CAAC,KAAK;;;MAGV;IAEF,MAAM,CAAC,QAAQ,WAA2C;YAE5C,SAAS;IAmBV,IAAI,CACb,YAAY,EAAE,YAAY,EAC1B,YAAY,EAAE,YAAY,GAC3B,OAAO,CAAC,OAAO,CAAC;CAkDtB"}
+{"version":3,"file":"erc721.d.ts","sourceRoot":"","sources":["../../../src/commands/send/erc721.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,6BAA6B,CAAC;AAiDtD,eAAO,MAAM,qBAAqB,YAAa,OAAO,SAqDrD,CAAC"}

package/dist/commands/send/erc721.js

@@ -1,45 +1,53 @@
 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 { addCommonOptions, 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 registerErc721Command = (program) => {
+    addCommonOptions(program
+        .command("erc721")
+        .description("Sends ERC-721 deposits to the application, optionally in interactive mode."))
+        .option("--token <address>", "token address")
+        .option("--token-id <number>", "token ID")
+        .action(async (options) => {
+        // connect to RPC provider
+        const { publicClient, walletClient } = await connect(options);
         // 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();
+        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 +68,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,3 @@
-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 registerEtherCommand: (program: Command) => void;
 //# 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,oBAAoB,YAAa,OAAO,SAqCpD,CAAC"}

package/dist/commands/send/ether.js

@@ -1,32 +1,34 @@
 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 { addCommonOptions, connect, getInputApplicationAddress, } from "../send.js";
+export const registerEtherCommand = (program) => {
+    addCommonOptions(program
+        .command("ether")
+        .description("Sends ether deposits to the application, optionally in interactive mode."))
+        .option("--amount <number>", "amount, in ETH units")
+        .option("--exec-layer-data <hex>", "exec layer data", "0x")
+        .action(async (options) => {
+        // connect to RPC provider
+        const { publicClient, walletClient } = await connect(options);
         // 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();
+        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,3 @@
-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 registerGenericCommand: (program: Command) => void;
 //# 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;AAoG9D,eAAO,MAAM,sBAAsB,YAAa,OAAO,SAuCtD,CAAC"}

package/dist/commands/send/generic.js

@@ -1,93 +1,103 @@
-import { Flags } from "@oclif/core";
+import { 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 { addCommonOptions, connect, getInputApplicationAddress, } from "../send.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;
+        }
+        else if (encoding === "string") {
+            // encode UTF-8 string as hex
+            return stringToHex(input);
+        }
+        else 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}'`);
+                        }
+                        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}`);
                 }
-                return encodeAbiParameters(abiParameters, values);
+            });
+            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 {
-                if (isHex(input)) {
-                    return input;
-                }
-                else {
-                    // encode UTF-8 string as hex
-                    return stringToHex(input);
-                }
+                // encode UTF-8 string as hex
+                return stringToHex(input);
             }
         }
-        return undefined;
     }
-    async send(publicClient, walletClient) {
+    return undefined;
+};
+export const registerGenericCommand = (program) => {
+    addCommonOptions(program
+        .command("generic")
+        .description("Sends generics inputs to the application, optionally in interactive mode."))
+        .option("--input <input>", "input payload")
+        .addOption(new Option("--input-encoding <input-encoding>", "input encoding").choices(["hex", "string", "abi"]))
+        .option("--input-abi-params <input-abi-params>", "input abi params")
+        .action(async (options) => {
+        // connect to RPC provider
+        const { publicClient, walletClient } = await connect(options);
         // 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();
+        const payload = (await getInput(options)) ||
+            (await bytesInput({ message: "Input" }));
         const { request } = await publicClient.simulateContract({
             address: inputBoxAddress,
             abi: inputBoxAbi,
@@ -95,25 +105,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 { Address, PublicClient, 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 addCommonOptions: (command: Command) => Command<[], {
+    dapp?: string | undefined;
+    chainId?: number | undefined;
+    rpcUrl?: string | undefined;
+    mnemonic?: string | undefined;
+    mnemonicIndex: number;
+}, {}>;
+export declare const registerSendCommand: (program: Command) => void;
+//# 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,EAAE,OAAO,EAAa,YAAY,EAAE,YAAY,EAAE,MAAM,MAAM,CAAC;AAQtE,eAAO,MAAM,OAAO,YAAa;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,UAC5B,MAAM,KACd,OAAO,CAAC,OAAO,CAiBjB,CAAC;AAEF,eAAO,MAAM,gBAAgB,YAAa,OAAO;;;;;;MAYhD,CAAC;AAEF,eAAO,MAAM,mBAAmB,YAAa,OAAO,SA+BnD,CAAC"}