@cartesi/cli 2.0.0-alpha.2 → 2.0.0-alpha.20

package/dist/commands/deposit/erc20.js

@@ -0,0 +1,125 @@
+import { Command } from "@commander-js/extra-typings";
+import chalk from "chalk";
+import ora from "ora";
+import { 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";
+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 {
+        address,
+        name,
+        symbol,
+        decimals,
+    };
+};
+const parseToken = async (options) => {
+    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 = () => {
+    return new Command("erc20")
+        .description("Deposit ERC-20 to the application")
+        .configureHelp({ showGlobalOptions: true })
+        .argument("[amount]", "amount to send")
+        .option("--token <address>", "token address")
+        .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];
+        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 = amountStr
+            ? parseUnits(amountStr, 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 amountLabel = `${chalk.cyan(formatUnits(amount, decimals))} ${symbol}`;
+        // approve if needed
+        if (allowance < amount) {
+            progress.start(`Approving ${amountLabel}...`);
+            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 ${amountLabel}`);
+        }
+        // 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 ${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/erc721.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"erc721.d.ts","sourceRoot":"","sources":["../../../src/commands/deposit/erc721.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,6BAA6B,CAAC;AAuEtD,eAAO,MAAM,mBAAmB;;;;;;;EAmI/B,CAAC"}

package/dist/commands/deposit/erc721.js

@@ -0,0 +1,143 @@
+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 = () => {
+    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], {
+    [x: string]: never;
+}, {
+    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;;;;;;;EAwE9B,CAAC"}

package/dist/commands/deposit/ether.js

@@ -0,0 +1,65 @@
+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 = () => {
+    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;AAUtD,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,37 @@
+import { Command } from "@commander-js/extra-typings";
+import select from "@inquirer/select";
+import { createErc1155BatchCommand, createErc1155SingleCommand, } from "./deposit/erc1155.js";
+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(createErc1155SingleCommand());
+    command.addCommand(createErc1155BatchCommand());
+    return command;
+};

package/dist/commands/doctor.d.ts

@@ -1,13 +1,3 @@
-import { BaseCommand } from "../baseCommand.js";
-export default class DoctorCommand extends BaseCommand<typeof DoctorCommand> {
-    static description: string;
-    static examples: string[];
-    private static MINIMUM_DOCKER_VERSION;
-    private static MINIMUM_DOCKER_COMPOSE_VERSION;
-    private static MINIMUM_BUILDX_VERSION;
-    private checkDocker;
-    private checkCompose;
-    private checkBuildx;
-    run(): Promise<void>;
-}
+import { Command } from "@commander-js/extra-typings";
+export declare const createDoctorCommand: () => Command<[], {}, {}>;
 //# sourceMappingURL=doctor.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"doctor.d.ts","sourceRoot":"","sources":["../../src/commands/doctor.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAEhD,MAAM,CAAC,OAAO,OAAO,aAAc,SAAQ,WAAW,CAAC,OAAO,aAAa,CAAC;IACxE,MAAM,CAAC,WAAW,SAA2C;IAE7D,MAAM,CAAC,QAAQ,WAA2C;IAE1D,OAAO,CAAC,MAAM,CAAC,sBAAsB,CAAY;IACjD,OAAO,CAAC,MAAM,CAAC,8BAA8B,CAAY;IACzD,OAAO,CAAC,MAAM,CAAC,sBAAsB,CAAY;YAEnC,WAAW;YA+BX,YAAY;YAiCZ,WAAW;IAiDZ,GAAG,IAAI,OAAO,CAAC,IAAI,CAAC;CAYpC"}
+{"version":3,"file":"doctor.d.ts","sourceRoot":"","sources":["../../src/commands/doctor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,6BAA6B,CAAC;AAyHtD,eAAO,MAAM,mBAAmB,2BAa/B,CAAC"}

package/dist/commands/doctor.js

@@ -1,106 +1,105 @@
+import { Command } from "@commander-js/extra-typings";
+import chalk from "chalk";
 import { execa } from "execa";
+import ora from "ora";
 import semver from "semver";
-import { BaseCommand } from "../baseCommand.js";
-class DoctorCommand extends BaseCommand {
-    async checkDocker() {
-        try {
-            const { stdout: dockerVersion } = await execa("docker", [
-                "version",
-                "--format",
-                "{{json .Client.Version}}",
-            ]);
-            const v = semver.coerce(dockerVersion);
-            if (v !== null &&
-                !semver.gte(v, DoctorCommand.MINIMUM_DOCKER_VERSION)) {
-                throw new Error(`Unsupported Docker version. Minimum required version is ${DoctorCommand.MINIMUM_DOCKER_VERSION}. Installed version is ${v}.`);
-            }
+const MINIMUM_DOCKER_VERSION = "23.0.0"; // Replace with our minimum required Docker version
+const MINIMUM_DOCKER_COMPOSE_VERSION = "2.21.0"; // Replace with our minimum required Docker Compose version
+const MINIMUM_BUILDX_VERSION = "0.13.0"; // Replace with our minimum required Buildx version
+const checkDocker = async (progress) => {
+    try {
+        progress.start("Checking Docker Engine version...");
+        const { stdout: dockerVersion } = await execa("docker", [
+            "version",
+            "--format",
+            "{{json .Client.Version}}",
+        ]);
+        const v = semver.coerce(dockerVersion);
+        if (v !== null && !semver.gte(v, MINIMUM_DOCKER_VERSION)) {
+            throw new Error(`Unsupported Docker version. Minimum required version is ${MINIMUM_DOCKER_VERSION}. Installed version is ${v}.`);
         }
-        catch (e) {
-            if (e instanceof Error &&
-                e.code === "ENOENT") {
-                throw new Error("Docker not found");
-            }
-            else {
-                throw e;
-            }
+        progress.succeed(`Docker Engine ${chalk.cyan(v)}`);
+    }
+    catch (e) {
+        if (e instanceof Error &&
+            e.code === "ENOENT") {
+            throw new Error("Docker not found");
         }
-        return true;
+        throw e;
     }
-    async checkCompose() {
-        try {
-            const { stdout: dockerComposeVersion } = await execa("docker", [
-                "compose",
-                "version",
-                "--short",
-            ]);
-            const v = semver.coerce(dockerComposeVersion);
-            if (v !== null &&
-                !semver.gte(v, DoctorCommand.MINIMUM_DOCKER_COMPOSE_VERSION)) {
-                throw new Error(`Unsupported Docker Compose version. Minimum required version is ${DoctorCommand.MINIMUM_DOCKER_COMPOSE_VERSION}. Installed version is ${v}.`);
-            }
+    return true;
+};
+const checkCompose = async (progress) => {
+    try {
+        progress.start("Checking Docker Compose version...");
+        const { stdout: dockerComposeVersion } = await execa("docker", [
+            "compose",
+            "version",
+            "--short",
+        ]);
+        const v = semver.coerce(dockerComposeVersion);
+        if (v !== null && !semver.gte(v, MINIMUM_DOCKER_COMPOSE_VERSION)) {
+            throw new Error(`Unsupported Docker Compose version. Minimum required version is ${MINIMUM_DOCKER_COMPOSE_VERSION}. Installed version is ${v}.`);
         }
-        catch (e) {
-            if (e instanceof Error &&
-                e.exitCode === 125) {
-                throw new Error("Docker Compose is required but not installed or the command execution failed. Please refer to the Docker Compose documentation for installation instructions: https://docs.docker.com/compose/install/");
-            }
-            else {
-                throw e;
-            }
+        progress.succeed(`Docker Compose ${chalk.cyan(dockerComposeVersion)}`);
+    }
+    catch (e) {
+        if (e instanceof Error &&
+            e.exitCode === 125) {
+            throw new Error("Docker Compose is required but not installed or the command execution failed. Please refer to the Docker Compose documentation for installation instructions: https://docs.docker.com/compose/install/");
         }
-        return true;
+        throw e;
     }
-    async checkBuildx() {
-        try {
-            const { stdout: buildxOutput } = await execa("docker", [
-                "buildx",
-                "version",
-            ]);
-            const v = semver.coerce(buildxOutput);
-            if (v !== null &&
-                !semver.gte(v, DoctorCommand.MINIMUM_BUILDX_VERSION)) {
-                throw new Error(`Unsupported Docker Buildx version. Minimum required version is ${DoctorCommand.MINIMUM_BUILDX_VERSION}. Installed version is ${v}.`);
-            }
-            const { stdout: platformsOutput } = await execa("docker", [
-                "buildx",
-                "ls",
-                "--format",
-                "{{.Platforms}}",
-            ]);
-            const buildxPlatforms = platformsOutput
-                .split(",")
-                .map((platform) => platform.trim());
-            if (!buildxPlatforms.includes("linux/riscv64")) {
-                throw new Error("Your system does not support riscv64 architecture. Run `docker run --privileged --rm tonistiigi/binfmt:riscv` to enable riscv64 support.");
-            }
+    return true;
+};
+const checkBuildx = async (progress) => {
+    try {
+        progress.start("Checking Docker Buildx version...");
+        const { stdout: buildxOutput } = await execa("docker", [
+            "buildx",
+            "version",
+        ]);
+        const v = semver.coerce(buildxOutput);
+        if (v !== null && !semver.gte(v, MINIMUM_BUILDX_VERSION)) {
+            throw new Error(`Unsupported Docker Buildx version. Minimum required version is ${MINIMUM_BUILDX_VERSION}. Installed version is ${v}.`);
         }
-        catch (e) {
-            if (e instanceof Error &&
-                e.exitCode === 125) {
-                throw new Error("Docker Buildx is required but not installed. Please refer to the Docker Desktop documentation for installation instructions: https://docs.docker.com/desktop/");
-            }
-            else {
-                throw e;
-            }
+        progress.succeed(`Docker Buildx ${chalk.cyan(v)}`);
+        progress.start("Checking Docker RISC-V support...");
+        const { stdout: platformsOutput } = await execa("docker", [
+            "buildx",
+            "ls",
+            "--format",
+            "{{.Platforms}}",
+        ]);
+        const buildxPlatforms = platformsOutput
+            .split(",")
+            .map((platform) => platform.trim());
+        if (!buildxPlatforms.includes("linux/riscv64")) {
+            throw new Error("Your system does not support riscv64 architecture. Run `docker run --privileged --rm tonistiigi/binfmt:riscv` to enable riscv64 support.");
         }
-        return true;
+        progress.succeed(`Docker RISC-V support ${chalk.cyan("linux/riscv64")}`);
     }
-    async run() {
+    catch (e) {
+        if (e instanceof Error &&
+            e.exitCode === 125) {
+            throw new Error("Docker Buildx is required but not installed. Please refer to the Docker Desktop documentation for installation instructions: https://docs.docker.com/desktop/");
+        }
+        throw e;
+    }
+    return true;
+};
+export const createDoctorCommand = () => {
+    return new Command("doctor").action(async () => {
+        const progress = ora();
         try {
-            if (await this.checkDocker()) {
-                await this.checkCompose();
-                await this.checkBuildx();
-            }
+            await checkDocker(progress);
+            await checkCompose(progress);
+            await checkBuildx(progress);
+            progress.succeed("Your system is ready.");
         }
         catch (e) {
-            this.error(e);
+            progress.fail(e.message);
+            process.exit(1);
         }
-        this.log("Your system is ready.");
-    }
-}
-DoctorCommand.description = "Verify the minimal sytem requirements";
-DoctorCommand.examples = ["<%= config.bin %> <%= command.id %>"];
-DoctorCommand.MINIMUM_DOCKER_VERSION = "23.0.0"; // Replace with our minimum required Docker version
-DoctorCommand.MINIMUM_DOCKER_COMPOSE_VERSION = "2.21.0"; // Replace with our minimum required Docker Compose version
-DoctorCommand.MINIMUM_BUILDX_VERSION = "0.13.0"; // Replace with our minimum required Buildx version
-export default DoctorCommand;
+    });
+};

package/dist/commands/hash.d.ts

@@ -1,10 +1,5 @@
-import { BaseCommand } from "../baseCommand.js";
-export default class HashCommand extends BaseCommand<typeof HashCommand> {
-    static summary: string;
-    static description: string;
-    static enableJsonFlag: boolean;
-    run(): Promise<{
-        hash: `0x${string}`;
-    } | undefined>;
-}
+import { Command } from "@commander-js/extra-typings";
+export declare const createHashCommand: () => Command<[], {
+    json?: true | undefined;
+}, {}>;
 //# sourceMappingURL=hash.d.ts.map