@cartesi/cli 2.0.0-alpha.13 → 2.0.0-alpha.14

package/dist/commands/deposit/erc721.js

@@ -0,0 +1,144 @@
+import { Command } from "@commander-js/extra-typings";
+import chalk from "chalk";
+import ora from "ora";
+import { BaseError, ContractFunctionRevertedError, erc721Abi, getAddress, isAddress, isHex, } from "viem";
+import { getProjectName } from "../../base.js";
+import { erc721PortalAbi, erc721PortalAddress, testNftAbi, testNftAddress, } from "../../contracts.js";
+import { addressInput, bigintInput, getInputApplicationAddress, } from "../../prompts.js";
+import { connect } from "../../wallet.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 {
+        address,
+        name,
+        symbol,
+    };
+};
+const parseToken = async (options) => {
+    const { testClient } = options;
+    const address = options.token && isAddress(options.token)
+        ? getAddress(options.token)
+        : await addressInput({
+            message: "Token address",
+            default: testNftAddress,
+        });
+    return readToken(testClient, address);
+};
+export const createErc721Command = () => {
+    // biome-ignore lint/complexity/noBannedTypes: commander pattern
+    return new Command("erc721")
+        .description("Deposit ERC-721 to the application")
+        .configureHelp({ showGlobalOptions: true })
+        .argument("[token-id]", "token ID")
+        .option("--token <address>", "token address")
+        .option("--base-layer-data <hex>", "base layer data", "0x")
+        .option("--exec-layer-data <hex>", "exec layer data", "0x")
+        .action(async (tokenIdStr, options, command) => {
+        const { from } = command.optsWithGlobals();
+        const tokenId = tokenIdStr
+            ? BigInt(tokenIdStr)
+            : await bigintInput({ decimals: 0, message: "Token ID" });
+        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,
+        });
+        const tokenAbi = token.address === testNftAddress ? testNftAbi : erc721Abi;
+        // get dapp address from local node, or ask
+        const application = await getInputApplicationAddress({
+            ...command.optsWithGlobals(),
+            projectName,
+        });
+        const { symbol } = token;
+        const baseLayerData = isHex(options.baseLayerData)
+            ? options.baseLayerData
+            : "0x";
+        const execLayerData = isHex(options.execLayerData)
+            ? options.execLayerData
+            : "0x";
+        // progress spinner
+        const progress = ora();
+        // check balance
+        try {
+            const currentOwner = await testClient.readContract({
+                abi: tokenAbi,
+                address: token.address,
+                args: [tokenId],
+                functionName: "ownerOf",
+            });
+            if (currentOwner !== account) {
+                progress.fail("Insufficient balance");
+                return;
+            }
+        }
+        catch (e) {
+            if (e instanceof BaseError) {
+                const revertError = e.walk((err) => err instanceof ContractFunctionRevertedError);
+                if (revertError instanceof ContractFunctionRevertedError) {
+                    const errorName = revertError.data?.errorName ?? "";
+                    if (errorName === "ERC721NonexistentToken") {
+                        progress.fail(`Token ${tokenIdStr} does not exist`);
+                        return;
+                    }
+                }
+                progress.fail("Failed to check ownership");
+            }
+        }
+        // check allowance
+        const operator = await testClient.readContract({
+            abi: tokenAbi,
+            address: token.address,
+            args: [tokenId],
+            functionName: "getApproved",
+        });
+        // for messages
+        const amountStr = `${chalk.cyan(tokenIdStr)} ${symbol}`;
+        // approve if needed
+        if (operator !== erc721PortalAddress) {
+            progress.start(`Approving ${amountStr}...`);
+            const { request } = await testClient.simulateContract({
+                abi: tokenAbi,
+                account,
+                address: token.address,
+                functionName: "approve",
+                args: [erc721PortalAddress, tokenId],
+            });
+            const hash = await testClient.writeContract(request);
+            await testClient.waitForTransactionReceipt({ hash });
+            progress.succeed(`Approved ${amountStr}`);
+        }
+        // simulate deposit call
+        const { request } = await testClient.simulateContract({
+            abi: erc721PortalAbi,
+            account,
+            address: erc721PortalAddress,
+            functionName: "depositERC721Token",
+            args: [
+                token.address,
+                application,
+                tokenId,
+                baseLayerData,
+                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)}`);
+    });
+};

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

@@ -0,0 +1,10 @@
+import { Command } from "@commander-js/extra-typings";
+export declare const createEtherCommand: () => Command<[string | undefined], {
+    execLayerData: string;
+}, {
+    from?: string | undefined;
+    application?: string | undefined;
+    projectName?: string | undefined;
+    rpcUrl?: string | undefined;
+}>;
+//# sourceMappingURL=ether.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ether.d.ts","sourceRoot":"","sources":["../../../src/commands/deposit/ether.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,6BAA6B,CAAC;AAUtD,eAAO,MAAM,kBAAkB;;;;;;;EAyE9B,CAAC"}

package/dist/commands/deposit/ether.js

@@ -0,0 +1,66 @@
+import { Command } from "@commander-js/extra-typings";
+import chalk from "chalk";
+import ora from "ora";
+import { formatUnits, getAddress, isAddress, isHex, parseUnits } from "viem";
+import { getProjectName } from "../../base.js";
+import { etherPortalAbi, etherPortalAddress } from "../../contracts.js";
+import { bigintInput, getInputApplicationAddress } from "../../prompts.js";
+import { connect } from "../../wallet.js";
+export const createEtherCommand = () => {
+    // biome-ignore lint/complexity/noBannedTypes: commander pattern
+    return new Command("ether")
+        .description("Deposit ether to the application")
+        .configureHelp({ showGlobalOptions: true })
+        .argument("[amount]", "amount, in ETH units")
+        .option("--exec-layer-data <hex>", "exec layer data", "0x")
+        .action(async (amountStr, 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];
+        // get dapp address from local node, or ask
+        const application = await getInputApplicationAddress({
+            ...command.optsWithGlobals(),
+            projectName,
+        });
+        const { decimals, symbol } = testClient.chain.nativeCurrency;
+        const amount = amountStr
+            ? parseUnits(amountStr, decimals)
+            : await bigintInput({
+                message: `Amount (${symbol})`,
+                decimals,
+            });
+        const execLayerData = isHex(options.execLayerData)
+            ? options.execLayerData
+            : "0x";
+        // progress spinner
+        const progress = ora();
+        // for messages
+        const amountLabel = `${chalk.cyan(formatUnits(amount, decimals))} ${symbol}`;
+        // check balance
+        const balance = await testClient.getBalance({
+            address: account,
+        });
+        if (balance < amount) {
+            progress.fail("Insufficient balance");
+            return;
+        }
+        const { request } = await testClient.simulateContract({
+            abi: etherPortalAbi,
+            account,
+            address: etherPortalAddress,
+            args: [application, execLayerData],
+            functionName: "depositEther",
+            value: amount,
+        });
+        // send deposit
+        progress.start(`Depositing ${amountLabel} to ${chalk.cyan(application)}...`);
+        const hash = await testClient.writeContract(request);
+        await testClient.waitForTransactionReceipt({ hash });
+        progress.succeed(`Deposited ${amountLabel} to ${chalk.cyan(application)}`);
+    });
+};

package/dist/commands/deposit.d.ts

@@ -0,0 +1,9 @@
+import { Command } from "@commander-js/extra-typings";
+export declare const createDepositCommand: () => Command<[], {
+    from?: string | undefined;
+    application?: string | undefined;
+    projectName?: string | undefined;
+    rpcUrl?: string | undefined;
+}, {}>;
+export type DepositCommandOpts = ReturnType<ReturnType<typeof createDepositCommand>["opts"]>;
+//# sourceMappingURL=deposit.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"deposit.d.ts","sourceRoot":"","sources":["../../src/commands/deposit.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,6BAA6B,CAAC;AAMtD,eAAO,MAAM,oBAAoB;;;;;MAsChC,CAAC;AAEF,MAAM,MAAM,kBAAkB,GAAG,UAAU,CACvC,UAAU,CAAC,OAAO,oBAAoB,CAAC,CAAC,MAAM,CAAC,CAClD,CAAC"}

package/dist/commands/deposit.js

@@ -0,0 +1,36 @@
+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;
+};

package/dist/commands/logs.d.ts

@@ -1,6 +1,6 @@
 import { Command } from "@commander-js/extra-typings";
 export declare const createLogsCommand: () => Command<[], {
-    environmentName: string;
+    projectName?: string | undefined;
     follow?: true | undefined;
     color: boolean;
     since?: string | undefined;

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

@@ -1 +1 @@
-{"version":3,"file":"logs.d.ts","sourceRoot":"","sources":["../../src/commands/logs.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,6BAA6B,CAAC;AAItD,eAAO,MAAM,iBAAiB;;;;;;;MAgD7B,CAAC"}
+{"version":3,"file":"logs.d.ts","sourceRoot":"","sources":["../../src/commands/logs.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,6BAA6B,CAAC;AAItD,eAAO,MAAM,iBAAiB;;;;;;;MA4C7B,CAAC"}

package/dist/commands/logs.js

@@ -1,17 +1,19 @@
 import { Command } from "@commander-js/extra-typings";
 import { execa } from "execa";
-import { DEFAULT_COMPOSE_ENVIRONMENT_NAME } from "../config.js";
+import { getProjectName } from "../base.js";
 export const createLogsCommand = () => {
     return new Command("logs")
         .description("Show logs of a local environment.")
-        .option("--environment-name <string>", "name of environment", DEFAULT_COMPOSE_ENVIRONMENT_NAME)
+        .option("--project-name <string>", "name of project (used by docker compose and cartesi-rollups-node)")
         .option("-f, --follow", "Follow log output")
         .option("--no-color", "Produce monochrome output")
         .option("--since <string>", "Show logs since timestamp (e.g. 2013-01-02T13:23:37Z) or relative (e.g. 42m for 42 minutes)")
         .option("-n, --tail <string>", "Number of lines to show from the end of the logs", "all")
         .option("--until <string>", "Show logs before a timestamp (e.g. 2013-01-02T13:23:37Z) or relative (e.g. 42m for 42 minutes)")
         .configureHelp({ showGlobalOptions: true })
-        .action(async ({ environmentName, follow, color, since, tail, until }, command) => {
+        .action(async (options, command) => {
+        const { follow, color, since, tail, until } = options;
+        const projectName = getProjectName(options);
         const logOptions = ["--no-log-prefix"];
         if (follow)
             logOptions.push("--follow");
@@ -24,7 +26,7 @@ export const createLogsCommand = () => {
         await execa("docker", [
             "compose",
             "--project-name",
-            environmentName,
+            projectName,
             "logs",
             ...logOptions,
             "rollups-node",

package/dist/commands/run.d.ts

@@ -1,3 +1,15 @@
 import { Command } from "@commander-js/extra-typings";
-export declare const createRunCommand: () => Command<[], {}, {}>;
+export declare const createRunCommand: () => Command<[], {
+    blockTime: number;
+    cpus?: number | undefined;
+    defaultBlock: "latest" | "pending" | "safe" | "finalized";
+    dryRun: boolean;
+    memory?: number | undefined;
+    epochLength: number;
+    port?: number | undefined;
+    runtimeVersion: string;
+    projectName?: string | undefined;
+    services: string[];
+    verbose: boolean;
+}, {}>;
 //# sourceMappingURL=run.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"run.d.ts","sourceRoot":"","sources":["../../src/commands/run.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,6BAA6B,CAAC;AAGtD,eAAO,MAAM,gBAAgB,2BAW5B,CAAC"}
+{"version":3,"file":"run.d.ts","sourceRoot":"","sources":["../../src/commands/run.ts"],"names":[],"mappings":"AAAA,OAAO,EACH,OAAO,EAGV,MAAM,6BAA6B,CAAC;AA8JrC,eAAO,MAAM,gBAAgB;;;;;;;;;;;;MA4J5B,CAAC"}

package/dist/commands/run.js

@@ -1,10 +1,202 @@
-import { Command } from "@commander-js/extra-typings";
+import { Command, Option, } from "@commander-js/extra-typings";
+import { ExitPromptError } from "@inquirer/core";
 import chalk from "chalk";
+import { ExecaError } from "execa";
+import getPort, { portNumbers } from "get-port";
+import ora from "ora";
+import { numberToHex } from "viem";
+import { getMachineHash, getProjectName } from "../base.js";
+import { DEFAULT_SDK_VERSION, PREFERRED_PORT } from "../config.js";
+import { AVAILABLE_SERVICES, deployApplication, removeApplication, startEnvironment, stopEnvironment, waitHealthyEnvironment, } from "../exec/rollups.js";
+import { keySelect } from "../prompts.js";
+const commaSeparatedList = (value) => value.split(",");
+const shell = async (options) => {
+    const { build, epochLength, log, projectName } = options;
+    // keep track of last deployment
+    let lastDeployment = undefined;
+    let salt = 0;
+    // deploy for the first time
+    const hash = getMachineHash();
+    if (hash) {
+        lastDeployment = await deploy({
+            epochLength,
+            hash,
+            projectName,
+            salt: numberToHex(salt++, { size: 32 }),
+        });
+    }
+    else {
+        console.warn(chalk.yellow("machine snapshot not found, waiting for build"));
+    }
+    while (true) {
+        try {
+            const option = await keySelect({
+                choices: [
+                    { name: "View logs", value: "l" },
+                    { name: "Build and redeploy", value: "b" },
+                    { name: "Quit", value: "q" },
+                ],
+            }, {});
+            switch (option) {
+                case "l": {
+                    try {
+                        await log?.parseAsync(["--project-name", projectName, "--follow"], {
+                            from: "user",
+                        });
+                    }
+                    catch (error) {
+                        if (error instanceof ExecaError) {
+                            // just continue gracefully
+                            if (error.exitCode === 130) {
+                                break;
+                            }
+                            throw error;
+                        }
+                    }
+                    break;
+                }
+                case "b": {
+                    // build
+                    await build?.parseAsync([], { from: "user" });
+                    // redeploy
+                    const hash = getMachineHash();
+                    if (hash) {
+                        if (lastDeployment) {
+                            await undeploy({ projectName });
+                        }
+                        lastDeployment = await deploy({
+                            consensus: lastDeployment?.consensus,
+                            epochLength,
+                            hash,
+                            projectName,
+                            salt: numberToHex(salt++, { size: 32 }),
+                        });
+                    }
+                    break;
+                }
+                case "q": {
+                    return;
+                }
+            }
+        }
+        catch (error) {
+            if (error instanceof ExitPromptError) {
+                // gracefully exit
+                return;
+            }
+            throw error;
+        }
+    }
+};
+const undeploy = async (options) => {
+    const { projectName } = options;
+    const progress = ora(`${chalk.cyan(projectName)} undeploying...`).start();
+    await removeApplication({
+        application: projectName,
+        force: true,
+        projectName,
+    });
+    progress.succeed(`${chalk.cyan(projectName)} undeployed`);
+};
+const deploy = async (options) => {
+    const { consensus, epochLength, hash, projectName, salt } = options;
+    // deploy application to node (onchain and offchain)
+    const progress = ora(`deploying ${chalk.cyan(hash)} as ${chalk.cyan(projectName)}`);
+    const application = await deployApplication({
+        consensus,
+        epochLength,
+        name: projectName,
+        projectName,
+        salt,
+        snapshotPath: "/var/lib/cartesi-rollups-node/snapshots/image",
+    });
+    progress.succeed(`${chalk.cyan(projectName)} machine hash is ${chalk.cyan(hash)}`);
+    progress.succeed(`${chalk.cyan(projectName)} contract deployed at ${chalk.cyan(application.address)}`);
+    return application;
+};
 export const createRunCommand = () => {
     return new Command("run")
         .description("Run a local cartesi node for the application.")
-        .summary("DEPRECATED: use 'start' instead")
-        .action(async () => {
-        console.warn(chalk.yellow("run command is deprecated, use 'start' and 'deploy' instead"));
+        .addOption(new Option("--block-time <number>", "interval between blocks (in seconds)")
+        .argParser(Number)
+        .default(2))
+        .addOption(new Option("--cpus <number>", "number of cpu limits for the rollups-node").argParser(Number))
+        .addOption(new Option("--default-block <string>", "default block to be used when fetching new blocks.")
+        .choices(["latest", "safe", "pending", "finalized"])
+        .default("latest"))
+        .option("--dry-run", "show the docker compose configuration", false)
+        .addOption(new Option("--memory <number>", "memory limit for the rollups-node in MB").argParser(Number))
+        .addOption(new Option("--epoch-length <number>", "length of an epoch (in blocks)")
+        .argParser(Number)
+        .default(720))
+        .option("-p, --port <number>", "port to listen on", Number)
+        .addOption(new Option("--runtime-version <version>", "version for Cartesi Rollups Runtime to use")
+        .default(DEFAULT_SDK_VERSION)
+        .hideHelp())
+        .option("--project-name <string>", "name of project (used by docker compose and cartesi-rollups-node)")
+        .option("--services <string>", `optional services to start, comma separated list from [${AVAILABLE_SERVICES.join(", ")}]`, commaSeparatedList, [])
+        .option("-v, --verbose", "verbose output", false)
+        .action(async (options, program) => {
+        const { blockTime, cpus, defaultBlock, dryRun, epochLength, memory, runtimeVersion, services, verbose, } = options;
+        const progress = ora();
+        if (defaultBlock !== "finalized") {
+            console.warn(chalk.yellow(`WARNING: default block is set to '${defaultBlock}', production configuration will likely use 'finalized'`));
+        }
+        // project name explicitly defined or the current directory name
+        const projectName = getProjectName(options);
+        // resolve port number, using the first free port in a range, unless explicitly set
+        const port = options.port ||
+            (await getPort({
+                port: portNumbers(PREFERRED_PORT, PREFERRED_PORT + 10),
+            }));
+        // run compose environment (detached)
+        const { address, config } = await startEnvironment({
+            blockTime,
+            cpus,
+            defaultBlock,
+            dryRun,
+            memory,
+            port,
+            projectName,
+            runtimeVersion,
+            services,
+            verbose,
+        });
+        if (dryRun && config) {
+            // just show the docker compose configuration and quit
+            process.stdout.write(config);
+            return;
+        }
+        progress.succeed(`${chalk.cyan(projectName)} starting at ${chalk.cyan(`${address}`)}`);
+        // wait for the environment to be healthy
+        await waitHealthyEnvironment({
+            name: projectName,
+            port,
+            projectName,
+            services,
+        });
+        const shutdown = async () => {
+            progress.start(`${chalk.cyan(projectName)} stopping...`);
+            try {
+                await stopEnvironment({ projectName });
+                progress.succeed(`${chalk.cyan(projectName)} stopped`);
+            }
+            catch (e) {
+                progress.fail(e instanceof Error ? e.message : "Unknown error");
+            }
+            process.exit(0);
+        };
+        // inhibit SIGINT and SIGTERM, will be handled gracefully by the shell
+        process.on("SIGINT", () => { });
+        process.on("SIGTERM", () => { });
+        const log = program.parent?.commands.find((c) => c.name() === "logs");
+        const build = program.parent?.commands.find((c) => c.name() === "build");
+        await shell({
+            build,
+            epochLength,
+            log,
+            projectName,
+        });
+        await shutdown();
     });
 };

package/dist/commands/send.d.ts

@@ -1,21 +1,10 @@
 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;
+export declare const createSendCommand: () => Command<[string | undefined], {
+    from?: string | undefined;
+    application?: string | undefined;
+    encoding?: "string" | "hex" | "abi" | undefined;
+    abiParams?: string | undefined;
+    projectName?: string | undefined;
     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

@@ -1 +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"}
+{"version":3,"file":"send.d.ts","sourceRoot":"","sources":["../../src/commands/send.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAU,MAAM,6BAA6B,CAAC;AAmG9D,eAAO,MAAM,iBAAiB;;;;;;;MA4D7B,CAAC"}