@cartesi/cli 0.14.0

package/dist/commands/clean.d.ts

@@ -0,0 +1,8 @@
+import { BaseCommand } from "../baseCommand.js";
+export default class Clean extends BaseCommand<typeof Clean> {
+    static summary: string;
+    static description: string;
+    static examples: string[];
+    run(): Promise<void>;
+}
+//# sourceMappingURL=clean.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"clean.d.ts","sourceRoot":"","sources":["../../src/commands/clean.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAEhD,MAAM,CAAC,OAAO,OAAO,KAAM,SAAQ,WAAW,CAAC,OAAO,KAAK,CAAC;IACxD,MAAM,CAAC,OAAO,SAA2C;IAEzD,MAAM,CAAC,WAAW,SAAwD;IAE1E,MAAM,CAAC,QAAQ,WAA2C;IAE7C,GAAG,IAAI,OAAO,CAAC,IAAI,CAAC;CAGpC"}

package/dist/commands/clean.js

@@ -0,0 +1,11 @@
+import fs from "fs-extra";
+import { BaseCommand } from "../baseCommand.js";
+class Clean extends BaseCommand {
+    async run() {
+        await fs.emptyDir(this.getContextPath());
+    }
+}
+Clean.summary = "Clean build artifacts of application.";
+Clean.description = "Deletes all cached build artifacts of application.";
+Clean.examples = ["<%= config.bin %> <%= command.id %>"];
+export default Clean;

package/dist/commands/create.d.ts

@@ -0,0 +1,16 @@
+import { BaseCommand } from "../baseCommand.js";
+export declare const DEFAULT_TEMPLATES_BRANCH = "sdk-0.6";
+export default class CreateCommand extends BaseCommand<typeof CreateCommand> {
+    static description: string;
+    static examples: string[];
+    static args: {
+        name: import("@oclif/core/lib/interfaces/parser.js").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        template: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        branch: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+    };
+    private download;
+    run(): Promise<void>;
+}
+//# sourceMappingURL=create.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"create.d.ts","sourceRoot":"","sources":["../../src/commands/create.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAEhD,eAAO,MAAM,wBAAwB,YAAY,CAAC;AAElD,MAAM,CAAC,OAAO,OAAO,aAAc,SAAQ,WAAW,CAAC,OAAO,aAAa,CAAC;IACxE,MAAM,CAAC,WAAW,SAAwB;IAE1C,MAAM,CAAC,QAAQ,WAA2C;IAE1D,MAAM,CAAC,IAAI;;MAKT;IAEF,MAAM,CAAC,KAAK;;;MAoBV;YAEY,QAAQ;IAqBT,GAAG,IAAI,OAAO,CAAC,IAAI,CAAC;CAkBpC"}

package/dist/commands/create.js

@@ -0,0 +1,66 @@
+import { Args, Flags } from "@oclif/core";
+import chalk from "chalk";
+import { downloadTemplate } from "giget";
+import ora from "ora";
+import { BaseCommand } from "../baseCommand.js";
+export const DEFAULT_TEMPLATES_BRANCH = "sdk-0.6";
+class CreateCommand extends BaseCommand {
+    async download(template, branch, out) {
+        const cartesiProvider = async (input) => {
+            return {
+                name: "cartesi",
+                subdir: input,
+                url: "https://github.com/cartesi/application-templates",
+                tar: `https://codeload.github.com/cartesi/application-templates/tar.gz/refs/heads/${branch}`,
+            };
+        };
+        const input = `cartesi:${template}`;
+        return downloadTemplate(input, {
+            dir: out,
+            providers: { cartesi: cartesiProvider },
+        });
+    }
+    async run() {
+        const { args, flags } = await this.parse(CreateCommand);
+        const spinner = ora("Creating application...").start();
+        try {
+            const { dir } = await this.download(flags.template, flags.branch, args.name);
+            spinner.succeed(`Application created at ${chalk.cyan(dir)}`);
+        }
+        catch (e) {
+            spinner.fail(e instanceof Error
+                ? `Error creating application: ${chalk.red(e.message)}`
+                : String(e));
+        }
+    }
+}
+CreateCommand.description = "Create application";
+CreateCommand.examples = ["<%= config.bin %> <%= command.id %>"];
+CreateCommand.args = {
+    name: Args.string({
+        description: "application and directory name",
+        required: true,
+    }),
+};
+CreateCommand.flags = {
+    template: Flags.string({
+        description: "template name to use",
+        required: true,
+        options: [
+            "cpp",
+            "cpp-low-level",
+            "go",
+            "javascript",
+            "lua",
+            "python",
+            "ruby",
+            "rust",
+            "typescript",
+        ],
+    }),
+    branch: Flags.string({
+        description: `cartesi/application-templates repository branch name to use`,
+        default: DEFAULT_TEMPLATES_BRANCH,
+    }),
+};
+export default CreateCommand;

package/dist/commands/deploy/build.d.ts

@@ -0,0 +1,12 @@
+import { BaseCommand } from "../../baseCommand.js";
+export default class DeployBuild extends BaseCommand<typeof DeployBuild> {
+    static summary: string;
+    static description: string;
+    static examples: string[];
+    static flags: {
+        platform: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+    };
+    private buildRollupsImage;
+    run(): Promise<string>;
+}
+//# sourceMappingURL=build.d.ts.map

package/dist/commands/deploy/build.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"build.d.ts","sourceRoot":"","sources":["../../../src/commands/deploy/build.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAEnD,MAAM,CAAC,OAAO,OAAO,WAAY,SAAQ,WAAW,CAAC,OAAO,WAAW,CAAC;IACpE,MAAM,CAAC,OAAO,SAAmD;IAEjE,MAAM,CAAC,WAAW,SACoD;IAEtE,MAAM,CAAC,QAAQ,WAA2C;IAE1D,MAAM,CAAC,KAAK;;MAOV;YAEY,iBAAiB;IA6BlB,GAAG,IAAI,OAAO,CAAC,MAAM,CAAC;CAwBtC"}

package/dist/commands/deploy/build.js

@@ -0,0 +1,61 @@
+import { Flags } from "@oclif/core";
+import { execa } from "execa";
+import fs from "fs-extra";
+import path from "path";
+import { tmpNameSync } from "tmp";
+import { URL } from "url";
+import { BaseCommand } from "../../baseCommand.js";
+class DeployBuild extends BaseCommand {
+    async buildRollupsImage(platform) {
+        const buildResult = tmpNameSync();
+        const imagePath = this.getContextPath("image");
+        const binPath = path.join(path.dirname(new URL(import.meta.url).pathname), "..", "..");
+        const dockerfile = path.join(binPath, "node", "DockerfileDeploy.txt");
+        const args = [
+            "buildx",
+            "build",
+            "-f",
+            dockerfile,
+            "--load",
+            "--iidfile",
+            buildResult,
+            imagePath,
+        ];
+        // optional platform, default to not defining, which will build for the host platform
+        if (platform) {
+            args.push("--platform", platform);
+        }
+        await execa("docker", args, { stdio: "inherit" });
+        return fs.readFileSync(buildResult, "utf8");
+    }
+    async run() {
+        const { flags } = await this.parse(DeployBuild);
+        // print machine hash
+        const templateHash = this.getMachineHash();
+        if (!templateHash) {
+            this.error(`Cartesi machine snapshot not found, run '${this.config.bin} build'`);
+        }
+        this.logPrompt({
+            title: "Cartesi machine templateHash",
+            value: templateHash,
+        });
+        this.log("Building application node Docker image...");
+        const image = await this.buildRollupsImage(flags.platform);
+        this.logPrompt({
+            title: "Application node Docker image",
+            value: image,
+        });
+        return image;
+    }
+}
+DeployBuild.summary = "Build deployment Docker image of application.";
+DeployBuild.description = "Package the application in a Docker image ready to be deployed.";
+DeployBuild.examples = ["<%= config.bin %> <%= command.id %>"];
+DeployBuild.flags = {
+    platform: Flags.string({
+        options: ["linux/amd64", "linux/arm64"],
+        summary: "Docker image target platform",
+        description: "Select the target platform for the produced Docker image. It depends on the platform where the application node will be deployed.",
+    }),
+};
+export default DeployBuild;

package/dist/commands/deploy/index.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="node" />
+import { BaseCommand } from "../../baseCommand.js";
+export default class Deploy extends BaseCommand<typeof Deploy> {
+    static summary: string;
+    static description: string;
+    static examples: string[];
+    static flags: {
+        hosting: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        webapp: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<import("url").URL, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+    };
+    run(): Promise<void>;
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/commands/deploy/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/commands/deploy/index.ts"],"names":[],"mappings":";AAMA,OAAO,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAEnD,MAAM,CAAC,OAAO,OAAO,MAAO,SAAQ,WAAW,CAAC,OAAO,MAAM,CAAC;IAC1D,MAAM,CAAC,OAAO,SAA2C;IAEzD,MAAM,CAAC,WAAW,SACoD;IAEtE,MAAM,CAAC,QAAQ,WAA2C;IAE1D,MAAM,CAAC,KAAK;;;MAWV;IAEW,GAAG,IAAI,OAAO,CAAC,IAAI,CAAC;CAiEpC"}

package/dist/commands/deploy/index.js

@@ -0,0 +1,78 @@
+import confirm from "@inquirer/confirm";
+import select from "@inquirer/select";
+import { Flags } from "@oclif/core";
+import chalk from "chalk";
+import open, { apps } from "open";
+import { BaseCommand } from "../../baseCommand.js";
+class Deploy extends BaseCommand {
+    async run() {
+        const { flags } = await this.parse(Deploy);
+        // print machine hash
+        const templateHash = this.getMachineHash();
+        if (!templateHash) {
+            this.error(`Cartesi machine snapshot not found, run '${this.config.bin} build'`);
+        }
+        this.logPrompt({
+            title: "Cartesi machine templateHash",
+            value: templateHash,
+        });
+        // ask for deployment type
+        const hosting = flags.hosting ||
+            (await select({
+                message: "Select hosting type",
+                choices: [
+                    {
+                        name: "Self-hosting",
+                        description: `Select this option if you want to run the node for your application.
+You will need the following infrastructure:
+
+- a cloud server for the application node
+- a postgres database
+- a web3 node provider
+- a funded wallet
+`,
+                        value: "self-hosted",
+                    },
+                    {
+                        name: "Use third-party provider",
+                        description: "Select this option to use a third-party service provider to run a node for your application.",
+                        value: "third-party",
+                        disabled: "(coming soon)",
+                    },
+                ],
+            }));
+        let queryString = "";
+        switch (hosting) {
+            case "self-hosted": {
+                // build docker image
+                await this.config.runCommand("deploy:build");
+                queryString = `?templateHash=${templateHash}`;
+                break;
+            }
+            case "third-party": {
+                this.error("Third-party provider deployment not supported yet");
+            }
+        }
+        // prompt user to open webapp for onchain deployment
+        const deployUrl = `${flags.webapp}${queryString}`;
+        if (await confirm({ message: `Open ${chalk.cyan(deployUrl)}?` })) {
+            open(deployUrl, { app: { name: apps.chrome } });
+        }
+        return;
+    }
+}
+Deploy.summary = "Deploy application to a live network.";
+Deploy.description = "Package and deploy the application to a supported live network.";
+Deploy.examples = ["<%= config.bin %> <%= command.id %>"];
+Deploy.flags = {
+    hosting: Flags.string({
+        options: ["self-hosted", "third-party"],
+        summary: "hosting type",
+        description: "Select wheather the user will host an application node himself, or use a third-party node provider",
+    }),
+    webapp: Flags.url({
+        description: "address of deploy webapp",
+        required: true,
+    }),
+};
+export default Deploy;

package/dist/commands/doctor.d.ts

@@ -0,0 +1,13 @@
+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>;
+}
+//# sourceMappingURL=doctor.d.ts.map

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

@@ -0,0 +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"}

package/dist/commands/doctor.js

@@ -0,0 +1,106 @@
+import { execa } from "execa";
+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}.`);
+            }
+        }
+        catch (e) {
+            if (e instanceof Error &&
+                e.code === "ENOENT") {
+                throw new Error("Docker not found");
+            }
+            else {
+                throw e;
+            }
+        }
+        return true;
+    }
+    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}.`);
+            }
+        }
+        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;
+            }
+        }
+        return true;
+    }
+    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.");
+            }
+        }
+        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;
+            }
+        }
+        return true;
+    }
+    async run() {
+        try {
+            if (await this.checkDocker()) {
+                await this.checkCompose();
+                await this.checkBuildx();
+            }
+        }
+        catch (e) {
+            this.error(e);
+        }
+        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

@@ -0,0 +1,10 @@
+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>;
+}
+//# sourceMappingURL=hash.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"hash.d.ts","sourceRoot":"","sources":["../../src/commands/hash.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAEhD,MAAM,CAAC,OAAO,OAAO,WAAY,SAAQ,WAAW,CAAC,OAAO,WAAW,CAAC;IACpE,MAAM,CAAC,OAAO,SAA0D;IAExE,MAAM,CAAC,WAAW,SAC2F;IAE7G,OAAc,cAAc,UAAQ;IAEvB,GAAG;;;CAgBnB"}

package/dist/commands/hash.js

@@ -0,0 +1,22 @@
+import chalk from "chalk";
+import { BaseCommand } from "../baseCommand.js";
+class HashCommand extends BaseCommand {
+    async run() {
+        const hash = this.getMachineHash();
+        if (hash) {
+            if (!this.jsonEnabled()) {
+                process.stdout.write(`${chalk.green("?")} Cartesi machine templateHash ${chalk.cyan(hash)}\n`);
+            }
+            else {
+                return { hash };
+            }
+        }
+        else {
+            this.error(`Cartesi machine snapshot not found, run '${this.config.bin} build'`);
+        }
+    }
+}
+HashCommand.summary = "Prints out image hash generated by the build command";
+HashCommand.description = "Converts the binary generated by the build command to hexadecimal and prints out the result to console";
+HashCommand.enableJsonFlag = true;
+export default HashCommand;

package/dist/commands/run.d.ts

@@ -0,0 +1,15 @@
+import { BaseCommand } from "../baseCommand.js";
+export default class Run extends BaseCommand<typeof Run> {
+    static summary: string;
+    static description: string;
+    static examples: string[];
+    static flags: {
+        "block-time": import("@oclif/core/lib/interfaces/parser.js").OptionFlag<number, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        "epoch-duration": import("@oclif/core/lib/interfaces/parser.js").OptionFlag<number, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        "no-backend": import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        verbose: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        "listen-port": import("@oclif/core/lib/interfaces/parser.js").OptionFlag<number, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+    };
+    run(): Promise<void>;
+}
+//# sourceMappingURL=run.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"run.d.ts","sourceRoot":"","sources":["../../src/commands/run.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAEhD,MAAM,CAAC,OAAO,OAAO,GAAI,SAAQ,WAAW,CAAC,OAAO,GAAG,CAAC;IACpD,MAAM,CAAC,OAAO,SAA2B;IAEzC,MAAM,CAAC,WAAW,SAAmD;IAErE,MAAM,CAAC,QAAQ,WAA2C;IAE1D,MAAM,CAAC,KAAK;;;;;;MAwBV;IAEW,GAAG,IAAI,OAAO,CAAC,IAAI,CAAC;CAwHpC"}

package/dist/commands/run.js

@@ -0,0 +1,137 @@
+import { Flags } from "@oclif/core";
+import { execa } from "execa";
+import fs from "fs-extra";
+import path from "path";
+import { BaseCommand } from "../baseCommand.js";
+class Run extends BaseCommand {
+    async run() {
+        const { flags } = await this.parse(Run);
+        let projectName;
+        if (flags["no-backend"]) {
+            projectName = "cartesi-node";
+        }
+        else {
+            // get machine hash
+            const hash = this.getMachineHash();
+            // Check if snapshot exists
+            if (!hash) {
+                throw new Error(`Cartesi machine snapshot not found, run '${this.config.bin} build'`);
+            }
+            projectName = hash.substring(2, 10);
+        }
+        // path of the tool instalation
+        const binPath = path.join(path.dirname(new URL(import.meta.url).pathname), "..");
+        // setup the environment variable used in docker compose
+        const blockInterval = flags["block-time"];
+        const epochDuration = flags["epoch-duration"];
+        const listenPort = flags["listen-port"];
+        const env = {
+            ANVIL_VERBOSITY: flags.verbose ? "--steps-tracing" : "--silent",
+            BLOCK_TIME: blockInterval.toString(),
+            BLOCK_TIMEOUT: (blockInterval + 3).toString(),
+            CARTESI_EPOCH_DURATION: epochDuration.toString(),
+            CARTESI_EXPERIMENTAL_DISABLE_CONFIG_LOG: flags.verbose
+                ? "false"
+                : "true",
+            CARTESI_EXPERIMENTAL_SERVER_MANAGER_BYPASS_LOG: flags.verbose
+                ? "false"
+                : "true",
+            CARTESI_LOG_LEVEL: flags.verbose ? "info" : "error",
+            CARTESI_SNAPSHOT_DIR: "/usr/share/rollups-node/snapshot",
+            CARTESI_BIN_PATH: binPath,
+            CARTESI_LISTEN_PORT: listenPort.toString(),
+        };
+        // validator
+        const composeFiles = ["docker-compose-validator.yaml"];
+        // prompt
+        composeFiles.push("docker-compose-prompt.yaml");
+        // database
+        composeFiles.push("docker-compose-database.yaml");
+        // proxy
+        composeFiles.push("docker-compose-proxy.yaml");
+        // anvil
+        composeFiles.push("docker-compose-anvil.yaml");
+        // explorer
+        composeFiles.push("docker-compose-explorer.yaml");
+        // load the no-backend compose file
+        if (flags["no-backend"]) {
+            composeFiles.push("docker-compose-host.yaml");
+        }
+        else {
+            // snapshot volume
+            composeFiles.push("docker-compose-snapshot-volume.yaml");
+        }
+        // add project env file loading
+        if (fs.existsSync("./.cartesi.env")) {
+            composeFiles.push("docker-compose-envfile.yaml");
+        }
+        // create the "--file <file>" list
+        const files = composeFiles
+            .map((f) => ["--file", path.join(binPath, "node", f)])
+            .flat();
+        const compose_args = [
+            "compose",
+            ...files,
+            "--project-directory",
+            ".",
+            "--project-name",
+            projectName,
+        ];
+        const up_args = [];
+        if (!flags.verbose) {
+            compose_args.push("--progress", "quiet");
+            up_args.push("--attach", "validator");
+            up_args.push("--attach", "prompt");
+        }
+        // XXX: need this handler, so SIGINT can still call the finally block below
+        process.on("SIGINT", () => { });
+        try {
+            // run compose environment
+            await execa("docker", [...compose_args, "up", ...up_args], {
+                env,
+                stdio: "inherit",
+            });
+        }
+        catch (e) {
+            // 130 is a graceful shutdown, so we can swallow it
+            if (e.exitCode !== 130) {
+                throw e;
+            }
+        }
+        finally {
+            // shut it down, including volumes
+            await execa("docker", [...compose_args, "down", "--volumes"], {
+                env,
+                stdio: "inherit",
+            });
+        }
+    }
+}
+Run.summary = "Run application node.";
+Run.description = "Run a local cartesi node for the application.";
+Run.examples = ["<%= config.bin %> <%= command.id %>"];
+Run.flags = {
+    "block-time": Flags.integer({
+        description: "interval between blocks (in seconds)",
+        default: 5,
+    }),
+    "epoch-duration": Flags.integer({
+        description: "duration of an epoch (in seconds)",
+        default: 3600,
+    }),
+    "no-backend": Flags.boolean({
+        description: "Run a node without the application code. Application must be executed by the developer on the host machine, fetching inputs from the node running at http://localhost:5004",
+        summary: "run a node without the application code",
+        default: false,
+    }),
+    verbose: Flags.boolean({
+        description: "verbose output",
+        default: false,
+        char: "v",
+    }),
+    "listen-port": Flags.integer({
+        description: "port to listen for incoming connections",
+        default: 8080,
+    }),
+};
+export default Run;

package/dist/commands/send/dapp-address.d.ts

@@ -0,0 +1,9 @@
+import { Address, PublicClient, WalletClient } from "viem";
+import { SendBaseCommand } from "./index.js";
+export default class SendAddress extends SendBaseCommand<typeof SendAddress> {
+    static summary: string;
+    static description: string;
+    static examples: string[];
+    send(publicClient: PublicClient, walletClient: WalletClient): Promise<Address>;
+}
+//# sourceMappingURL=dapp-address.d.ts.map

package/dist/commands/send/dapp-address.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dapp-address.d.ts","sourceRoot":"","sources":["../../../src/commands/send/dapp-address.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,MAAM,CAAC;AAM3D,OAAO,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAE7C,MAAM,CAAC,OAAO,OAAO,WAAY,SAAQ,eAAe,CAAC,OAAO,WAAW,CAAC;IACxE,MAAM,CAAC,OAAO,SAAiD;IAE/D,MAAM,CAAC,WAAW,SAC4C;IAE9D,MAAM,CAAC,QAAQ,WAA2C;IAE7C,IAAI,CACb,YAAY,EAAE,YAAY,EAC1B,YAAY,EAAE,YAAY,GAC3B,OAAO,CAAC,OAAO,CAAC;CActB"}

package/dist/commands/send/dapp-address.js

@@ -0,0 +1,20 @@
+import { dAppAddressRelayAbi, dAppAddressRelayAddress, } from "../../contracts.js";
+import { SendBaseCommand } from "./index.js";
+class SendAddress extends SendBaseCommand {
+    async send(publicClient, walletClient) {
+        // get dapp address from local node, or ask
+        const address = await super.getApplicationAddress();
+        const { request } = await publicClient.simulateContract({
+            address: dAppAddressRelayAddress,
+            abi: dAppAddressRelayAbi,
+            functionName: "relayDAppAddress",
+            args: [address],
+            account: walletClient.account,
+        });
+        return walletClient.writeContract(request);
+    }
+}
+SendAddress.summary = "Send DApp address input to the application.";
+SendAddress.description = "Sends an input to the application with its own address.";
+SendAddress.examples = ["<%= config.bin %> <%= command.id %>"];
+export default SendAddress;