feat(cli): simplified send and deposit commands

Author: tuler

.changeset/all-carpets-poke.md

@@ -0,0 +1,5 @@
+---
+"@cartesi/cli": patch
+---
+
+replaced `cartesi send erc20` by `cartesi deposit erc20`

.changeset/big-carrots-knock.md

@@ -0,0 +1,5 @@
+---
+"@cartesi/cli": patch
+---
+
+replaced `cartesi send generic` by `cartesi send`

.changeset/dull-ways-sin.md

@@ -0,0 +1,5 @@
+---
+"@cartesi/cli": patch
+---
+
+replaced `cartesi send erc721` by `cartesi deposit erc721`

.changeset/nice-knives-refuse.md

@@ -0,0 +1,5 @@
+---
+"@cartesi/cli": patch
+---
+
+replaced `cartesi send ether` by `cartesi deposit ether`

apps/cli/src/base.ts

@@ -56,8 +56,10 @@ export const getProjectName = (options: { projectName?: string }) => {
 
 export type AddressBook = Record<string, Address>;
 
-export const getAddressBook = async (): Promise<AddressBook> => {
-    const applicationAddress = await getApplicationAddress();
+export const getAddressBook = async (options: {
+    projectName?: string;
+}): Promise<AddressBook> => {
+    const applicationAddress = await getApplicationAddress(options);
 
     // build rollups contracts address book
     const contracts: AddressBook = {

apps/cli/src/commands/address-book.ts

@@ -1,15 +1,21 @@
 import { Command } from "@commander-js/extra-typings";
 import Table from "cli-table3";
-import { getAddressBook } from "../base.js";
+import { getAddressBook, getProjectName } from "../base.js";
 
 export const createAddressBookCommand = () => {
     return new Command("address-book")
         .description(
             "Prints the addresses of all smart contracts deployed to the runtime environment of the application.",
         )
         .option("--json", "Format output as json.")
-        .action(async ({ json }) => {
-            const addressBook = await getAddressBook();
+        .option(
+            "--project-name <string>",
+            "name of project (used by docker compose and cartesi-rollups-node)",
+        )
+        .action(async (options) => {
+            const { json } = options;
+            const projectName = getProjectName(options);
+            const addressBook = await getAddressBook({ projectName });
             if (!json) {
                 // print as a table
                 const table = new Table({

apps/cli/src/commands/deposit.ts

@@ -0,0 +1,49 @@
+import { Command } from "@commander-js/extra-typings";
+import select from "@inquirer/select";
+import { createErc20Command } from "./deposit/erc20.js";
+import { createErc721Command } from "./deposit/erc721.js";
+import { createEtherCommand } from "./deposit/ether.js";
+
+export const createDepositCommand = () => {
+    const command = new Command("deposit")
+        .description("Deposits an asset to the application")
+        .configureHelp({ showGlobalOptions: true })
+        .option("--from <address>", "input sender address")
+        .option("--application <address>", "application address")
+        .option(
+            "--project-name <string>",
+            "name of project (used by docker compose and cartesi-rollups-node)",
+        )
+        .option("--rpc-url <url>", "RPC URL of the Cartesi Devnet")
+        .action(async (options, command) => {
+            // get registered subcommands
+            const commands = command.commands;
+
+            // create choices for the selected prompt based on registered subcommands
+            const choices = commands.map((cmd) => ({
+                name: cmd.name(),
+                value: cmd,
+                description: cmd.description(),
+            }));
+
+            const subcommand = await select({
+                choices,
+                message: "Select type of asset to deposit",
+            });
+
+            // execute selected subcommand
+            subcommand.parseAsync(command.args);
+        });
+
+    command.addCommand(createEtherCommand());
+    command.addCommand(createErc20Command());
+    command.addCommand(createErc721Command());
+    // command.addCommand(createErc1155BatchCommand());
+    // command.addCommand(createErc1155SingleCommand());
+
+    return command;
+};
+
+export type DepositCommandOpts = ReturnType<
+    ReturnType<typeof createDepositCommand>["opts"]
+>;

apps/cli/src/commands/deposit/erc20.ts

@@ -0,0 +1,182 @@
+import { Command } from "@commander-js/extra-typings";
+import chalk from "chalk";
+import ora from "ora";
+import {
+    type Address,
+    type PublicClient,
+    erc20Abi,
+    formatUnits,
+    getAddress,
+    isAddress,
+    isHex,
+    parseUnits,
+} from "viem";
+import { getProjectName } from "../../base.js";
+import {
+    erc20PortalAbi,
+    erc20PortalAddress,
+    testTokenAddress,
+} from "../../contracts.js";
+import {
+    addressInput,
+    bigintInput,
+    getInputApplicationAddress,
+} from "../../prompts.js";
+import { connect } from "../../wallet.js";
+import type { DepositCommandOpts } from "../deposit.js";
+
+type ERC20Token = {
+    address: Address;
+    name: string;
+    symbol: string;
+    decimals: number;
+};
+
+const readToken = async (
+    publicClient: PublicClient,
+    address: Address,
+): Promise<ERC20Token> => {
+    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 {
+        address,
+        name,
+        symbol,
+        decimals,
+    };
+};
+
+const parseToken = async (options: {
+    testClient: PublicClient;
+    token?: string;
+}): Promise<ERC20Token> => {
+    const { testClient } = options;
+
+    const address =
+        options.token && isAddress(options.token)
+            ? getAddress(options.token)
+            : await addressInput({
+                  message: "Token address",
+                  default: testTokenAddress,
+              });
+
+    return readToken(testClient, address);
+};
+
+export const createErc20Command = () => {
+    // biome-ignore lint/complexity/noBannedTypes: commander pattern
+    return new Command<[], {}, DepositCommandOpts>("erc20")
+        .description("Deposit ERC-20 to the application")
+        .configureHelp({ showGlobalOptions: true })
+        .option("--token <address>", "token address")
+        .option("--amount <number>", "amount to send")
+        .option("--exec-layer-data <hex>", "exec layer data", "0x")
+        .action(async (options, command) => {
+            const { from } = command.optsWithGlobals();
+
+            const projectName = getProjectName(command.optsWithGlobals());
+
+            // connect to anvil
+            const testClient = await connect(command.optsWithGlobals());
+
+            // the input sender, impersonated
+            const account =
+                from && isAddress(from)
+                    ? getAddress(from)
+                    : (await testClient.getAddresses())[0];
+
+            const token = await parseToken({
+                testClient,
+                token: options.token,
+            });
+
+            // get dapp address from local node, or ask
+            const application = await getInputApplicationAddress({
+                ...command.optsWithGlobals(),
+                projectName,
+            });
+
+            const { decimals, symbol } = token;
+            const amount = options.amount
+                ? parseUnits(options.amount, decimals)
+                : await bigintInput({
+                      message: `Amount (${symbol})`,
+                      decimals,
+                  });
+
+            const execLayerData = isHex(options.execLayerData)
+                ? options.execLayerData
+                : "0x";
+
+            // progress spinner
+            const progress = ora();
+
+            // check balance
+            const balance = await testClient.readContract({
+                abi: erc20Abi,
+                address: token.address,
+                functionName: "balanceOf",
+                args: [account],
+            });
+            if (balance < amount) {
+                progress.fail("Insufficient balance");
+                return;
+            }
+
+            // check allowance
+            const allowance = await testClient.readContract({
+                abi: erc20Abi,
+                address: token.address,
+                functionName: "allowance",
+                args: [account, erc20PortalAddress],
+            });
+
+            // for messages
+            const amountStr = `${chalk.cyan(formatUnits(amount, decimals))} ${symbol}`;
+
+            // approve if needed
+            if (allowance < amount) {
+                progress.start(`Approving ${amountStr}...`);
+                const { request } = await testClient.simulateContract({
+                    abi: erc20Abi,
+                    account,
+                    address: token.address,
+                    functionName: "approve",
+                    args: [erc20PortalAddress, amount],
+                });
+                const hash = await testClient.writeContract(request);
+                await testClient.waitForTransactionReceipt({ hash });
+                progress.succeed(`Approved ${amountStr}`);
+            }
+
+            // simulate deposit call
+            const { request } = await testClient.simulateContract({
+                abi: erc20PortalAbi,
+                account,
+                address: erc20PortalAddress,
+                functionName: "depositERC20Tokens",
+                args: [token.address, application, amount, execLayerData],
+            });
+
+            // send deposit
+            progress.start(
+                `Depositing ${amountStr} to ${chalk.cyan(application)}...`,
+            );
+            const hash = await testClient.writeContract(request);
+            await testClient.waitForTransactionReceipt({ hash });
+            progress.succeed(
+                `Deposited ${amountStr} to ${chalk.cyan(application)}`,
+            );
+        });
+};