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

package/dist/commands/rollups/deploy.js

@@ -0,0 +1,225 @@
+import { Command, Option } from "@commander-js/extra-typings";
+import input from "@inquirer/input";
+import chalk from "chalk";
+import { execa } from "execa";
+import ora from "ora";
+import { zeroHash } from "viem";
+import { anvil } from "viem/chains";
+import { getContextPath, getMachineHash, parseAddress, parseHash, } from "../../base.js";
+import { applicationFactoryAbi, applicationFactoryAddress, authorityFactoryAbi, authorityFactoryAddress, } from "../../contracts.js";
+import { addressInput } from "../../prompts.js";
+import { connect } from "../send.js";
+/**
+ * Deploy authority contract (if not already deployed)
+ * @param options
+ * @returns address of the authority
+ */
+const deployAuthority = async (publicClient, walletClient, options) => {
+    const { epochLength, progress, salt } = options;
+    // deploy authority contract (if not already deployed)
+    const authorityOwner = options.authorityOwner ||
+        (await addressInput({
+            message: "Authority Owner",
+            default: walletClient.account?.address,
+        }));
+    const authorityAddress = await publicClient.readContract({
+        abi: authorityFactoryAbi,
+        address: authorityFactoryAddress,
+        functionName: "calculateAuthorityAddress",
+        args: [authorityOwner, BigInt(epochLength), salt],
+    });
+    // check if authority is already deployed
+    const authorityCode = await publicClient.getCode({
+        address: authorityAddress,
+    });
+    if (authorityCode === undefined) {
+        // deploy authority
+        const { request } = await publicClient.simulateContract({
+            abi: authorityFactoryAbi,
+            address: authorityFactoryAddress,
+            account: walletClient.account,
+            functionName: "newAuthority",
+            args: [authorityOwner, BigInt(epochLength), salt],
+        });
+        progress.start("Deploying authority...");
+        const hash = await walletClient.writeContract(request);
+        await publicClient.waitForTransactionReceipt({ hash });
+        progress.succeed(`Authority ${chalk.cyan(authorityAddress)}`);
+    }
+    return authorityAddress;
+};
+/**
+ * Deploy application contract
+ * @param options
+ * @returns address of the application
+ */
+const deployApplication = async (publicClient, walletClient, options) => {
+    const { authorityAddress, progress, salt, templateHash } = options;
+    const applicationOwner = options.applicationOwner ||
+        (await addressInput({
+            message: "Application Owner",
+            default: walletClient.account?.address,
+        }));
+    const applicationAddress = await publicClient.readContract({
+        abi: applicationFactoryAbi,
+        address: applicationFactoryAddress,
+        functionName: "calculateApplicationAddress",
+        args: [
+            authorityAddress,
+            applicationOwner,
+            templateHash,
+            // "0x", // XXX: update to latest rollups contract
+            salt,
+        ],
+    });
+    // check if application is already deployed
+    const applicationCode = await publicClient.getCode({
+        address: applicationAddress,
+    });
+    if (applicationCode === undefined) {
+        // deploy application
+        const { request } = await publicClient.simulateContract({
+            abi: applicationFactoryAbi,
+            address: applicationFactoryAddress,
+            account: walletClient.account,
+            functionName: "newApplication",
+            args: [authorityAddress, applicationOwner, templateHash, salt],
+        });
+        progress.start("Deploying application...");
+        const hash = await walletClient.writeContract(request);
+        await publicClient.waitForTransactionReceipt({ hash });
+        progress.succeed(`Application ${chalk.cyan(applicationAddress)}`);
+    }
+    else {
+        // abort, because application is already deployed
+        throw new Error(`Application ${chalk.cyan(templateHash)} already deployed to ${chalk.cyan(applicationAddress)}`);
+    }
+    return applicationAddress;
+};
+/**
+ * Publish machine snapshot to rollups node by copying it to the rollups node container
+ * @param options
+ * @returns path to the snapshot in the rollups node
+ */
+const publishMachine = async (options) => {
+    const { progress, environmentName, templateHash } = options;
+    const snapshotPath = getContextPath("image");
+    const containerSnapshotPath = `/var/lib/cartesi-rollups-node/snapshots/${templateHash}/`;
+    progress.start("Publishing machine snapshot...");
+    await execa("docker", [
+        "compose",
+        "--project-name",
+        environmentName,
+        "cp",
+        snapshotPath,
+        `rollups-node:${containerSnapshotPath}`,
+    ]);
+    progress.succeed(`Machine snapshot ${chalk.cyan(containerSnapshotPath)}`);
+    return containerSnapshotPath;
+};
+/**
+ * Register application in rollups node
+ * @param options
+ * @returns name of the application
+ */
+const registerApplication = async (options) => {
+    const { applicationAddress, progress, environmentName, snapshotPath } = options;
+    // use template hash as the name of the deployment
+    const name = options.name ??
+        (await input({
+            message: "Application Name",
+            default: applicationAddress.toLowerCase(),
+        }));
+    // deploy application
+    progress.start("Registering application...");
+    const { stdout } = await execa("docker", [
+        "compose",
+        "--project-name",
+        environmentName,
+        "exec",
+        "rollups-node",
+        "cartesi-rollups-cli",
+        "app",
+        "register",
+        "--name",
+        name,
+        "--address",
+        applicationAddress,
+        "--template-path",
+        snapshotPath,
+        "--print-json",
+    ]);
+    const registration = stdout ? JSON.parse(stdout) : undefined;
+    if (registration) {
+        if (registration.State !== "ENABLED") {
+            throw new Error(registration.Reason);
+        }
+        progress.succeed(`Registration ${chalk.cyan(name)}`);
+    }
+    else {
+        throw new Error("Failed to deploy application");
+    }
+    return name;
+};
+export const createDeployCommand = () => {
+    return new Command("deploy")
+        .description("Deploy a rollups application to a rollups node.")
+        .configureHelp({ showGlobalOptions: true })
+        .option("--chain-id <id>", "Chain ID", parseInt, 31337)
+        .option("--rpc-url <url>", "RPC URL")
+        .option("--mnemonic <phrase>", "Mnemonic passphrase")
+        .option("--mnemonic-index <index>", "Mnemonic account index", parseInt, 0)
+        .option("--name <string>", "application name")
+        .option("--authority-owner <address>", "authority owner", parseAddress, undefined)
+        .option("--application-owner <address>", "application owner", parseAddress, undefined)
+        .addOption(new Option("--epoch-length <number>", "length of an epoch (in blocks)")
+        .argParser(Number)
+        .default(720))
+        .option("--salt <hash>", "salt for deployment", parseHash, zeroHash)
+        .option("--json", "output in JSON format")
+        .action(async (options, command) => {
+        const rollupsOptions = command.optsWithGlobals();
+        const { environmentName } = rollupsOptions;
+        const { json } = options;
+        // XXX: json support is not implemented yet
+        // if case of json maybe we should not support interactive mode
+        const progress = ora();
+        // get cartesi machine snapshot hash, produced by 'build'
+        const templateHash = getMachineHash();
+        if (!templateHash) {
+            progress.fail(`Cartesi machine snapshot not found, run 'build'`);
+            return;
+        }
+        progress.succeed(`Cartesi machine template hash ${chalk.cyan(templateHash)}`);
+        // connect to some chain
+        const { publicClient, walletClient } = await connect(options);
+        try {
+            // deploy authority contract (if not already deployed)
+            const authorityAddress = await deployAuthority(publicClient, walletClient, { progress, ...options });
+            // deploy application contract
+            const applicationAddress = await deployApplication(publicClient, walletClient, { authorityAddress, progress, templateHash, ...options });
+            if (publicClient.chain?.id === anvil.id) {
+                // copy machine snapshot to rollups node container
+                const containerSnapshotPath = await publishMachine({
+                    progress,
+                    templateHash,
+                    environmentName,
+                });
+                const name = await registerApplication({
+                    applicationAddress,
+                    progress,
+                    snapshotPath: containerSnapshotPath,
+                    ...options,
+                    ...rollupsOptions,
+                });
+            }
+            else {
+                const snapshotPath = getContextPath("image");
+                progress.succeed(`Done. Manually copy machine to rollups node ${chalk.cyan(snapshotPath)}`);
+            }
+        }
+        catch (e) {
+            progress.fail(e instanceof Error ? e.message : "Unknown error");
+        }
+    });
+};

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

@@ -0,0 +1,11 @@
+import { Command } from "@commander-js/extra-typings";
+export declare const createLogsCommand: () => Command<[], {
+    follow?: true | undefined;
+    color: boolean;
+    since?: string | undefined;
+    tail: string;
+    until?: string | undefined;
+}, {
+    environmentName: string;
+}>;
+//# sourceMappingURL=logs.d.ts.map

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

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

package/dist/commands/rollups/logs.js

@@ -0,0 +1,32 @@
+import { Command } from "@commander-js/extra-typings";
+import { execa } from "execa";
+export const createLogsCommand = () => {
+    return new Command("logs")
+        .description("Show logs of a local rollups node environment.")
+        .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 ({ follow, color, since, tail, until }, command) => {
+        const { environmentName } = command.optsWithGlobals();
+        const logOptions = ["--no-log-prefix"];
+        if (follow)
+            logOptions.push("--follow");
+        if (color === false)
+            logOptions.push("--no-color");
+        if (since)
+            logOptions.push("--since", since);
+        if (tail)
+            logOptions.push("--tail", tail);
+        await execa("docker", [
+            "compose",
+            "--project-name",
+            environmentName,
+            "logs",
+            ...logOptions,
+            "rollups-node",
+        ], { stdio: "inherit" });
+    });
+};

package/dist/commands/rollups/start.d.ts

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

package/dist/commands/rollups/start.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"start.d.ts","sourceRoot":"","sources":["../../../src/commands/rollups/start.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAU,MAAM,6BAA6B,CAAC;AA2I9D,eAAO,MAAM,kBAAkB;;;;;;;;;;;EAgK9B,CAAC"}

package/dist/commands/rollups/start.js

@@ -0,0 +1,209 @@
+import { Command, Option } from "@commander-js/extra-typings";
+import chalk from "chalk";
+import { execa } from "execa";
+import { Listr } from "listr2";
+import pRetry from "p-retry";
+import path from "path";
+import { getServiceHealth } from "../../base.js";
+import { DEFAULT_SDK } from "../../config.js";
+const commaSeparatedList = (value) => value.split(",");
+const host = "http://127.0.0.1";
+// services configuration
+const baseServices = [
+    {
+        name: "anvil",
+        file: "docker-compose-anvil.yaml",
+        healthySemaphore: "anvil",
+        healthyTitle: `${chalk.cyan("anvil")} service ready at ${chalk.cyan(`${host}:8545`)}`,
+        waitTitle: `${chalk.cyan("anvil")} service starting...`,
+        errorTitle: `${chalk.red("anvil")} service failed`,
+    },
+    {
+        name: "proxy",
+        file: "docker-compose-proxy.yaml",
+    },
+    {
+        name: "database",
+        file: "docker-compose-database.yaml",
+    },
+    {
+        name: "rpc",
+        file: "docker-compose-node.yaml",
+        healthySemaphore: "rollups-node",
+        healthyTitle: (port) => `${chalk.cyan("rpc")} service ready at ${chalk.cyan(`${host}:${port}/rpc`)}`,
+        waitTitle: `${chalk.cyan("rpc")} service starting...`,
+        errorTitle: `${chalk.red("rpc")} service failed`,
+    },
+    {
+        name: "inspect",
+        file: "docker-compose-node.yaml",
+        healthySemaphore: "rollups-node",
+        healthyTitle: (port) => `${chalk.cyan("inspect")} service ready at ${chalk.cyan(`${host}:${port}/inspect/<application_address>`)}`,
+        waitTitle: `${chalk.cyan("inspect")} service starting...`,
+        errorTitle: `${chalk.red("inspect")} service failed`,
+    },
+];
+const availableServices = [
+    {
+        name: "bundler",
+        file: "docker-compose-bundler.yaml",
+        healthySemaphore: "bundler",
+        healthyTitle: (port) => `${chalk.cyan("bundler")} service ready at ${chalk.cyan(`${host}:${port}/bundler/rpc`)}`,
+        waitTitle: `${chalk.cyan("bundler")} service starting...`,
+        errorTitle: `${chalk.red("bundler")} service failed`,
+    },
+    {
+        name: "espresso",
+        file: "docker-compose-espresso.yaml",
+        healthySemaphore: "espresso",
+        healthyTitle: (port) => `${chalk.cyan("espresso")} service ready at ${chalk.cyan(`${host}:${port}/transaction`)}`,
+        waitTitle: `${chalk.cyan("espresso")} service starting...`,
+        errorTitle: `${chalk.red("espresso")} service failed`,
+    },
+    {
+        name: "explorer",
+        file: "docker-compose-explorer.yaml",
+        healthySemaphore: "explorer_api",
+        healthyTitle: (port) => `${chalk.cyan("explorer")} service ready at ${chalk.cyan(`${host}:${port}/explorer`)}`,
+        waitTitle: `${chalk.cyan("explorer")} service starting...`,
+        errorTitle: `${chalk.red("explorer")} service failed`,
+    },
+    {
+        name: "graphql",
+        file: "docker-compose-graphql.yaml",
+        healthySemaphore: "graphql",
+        healthyTitle: (port) => `${chalk.cyan("graphql")} service ready at ${chalk.cyan(`${host}:${port}/graphql`)}`,
+        waitTitle: `${chalk.cyan("graphql")} service starting...`,
+        errorTitle: `${chalk.red("graphql")} service failed`,
+    },
+    {
+        name: "paymaster",
+        file: "docker-compose-paymaster.yaml",
+        healthySemaphore: "paymaster",
+        healthyTitle: (port) => `${chalk.cyan("paymaster")} service ready at ${chalk.cyan(`${host}:${port}/paymaster`)}`,
+        waitTitle: `${chalk.cyan("paymaster")} service starting...`,
+        errorTitle: `${chalk.red("paymaster")} service failed`,
+    },
+];
+const serviceMonitorTask = (options) => {
+    const { errorTitle, healthyTitle, service, waitTitle } = options;
+    return {
+        task: async (_ctx, task) => {
+            await pRetry(async () => {
+                const health = await getServiceHealth(options);
+                if (health !== "healthy") {
+                    throw new Error(errorTitle ??
+                        `Service ${chalk.cyan(service)} is not healthy`);
+                }
+            }, { retries: 100, minTimeout: 500, factor: 1.1 });
+            task.title =
+                healthyTitle ?? `Service ${chalk.cyan(service)} is ready`;
+        },
+        title: waitTitle ?? `Starting ${chalk.cyan(service)}...`,
+    };
+};
+export const createStartCommand = () => {
+    return new Command("start")
+        .description("Start a local rollups node environment.")
+        .configureHelp({ showGlobalOptions: true })
+        .addOption(new Option("--block-time <number>", "interval between blocks (in seconds)")
+        .argParser(Number)
+        .default(5))
+        .addOption(new Option("--default-block <string>", "default block to be used when fetching new blocks.")
+        .choices(["latest", "safe", "pending", "finalized"])
+        .default("latest"))
+        .addOption(new Option("--cpus <number>", "number of cpu limits for the rollups-node").argParser(Number))
+        .addOption(new Option("--memory <number>", "memory limit for the rollups-node in MB").argParser(Number))
+        .option("--services <string>", `optional services to start, comma separated list from [${availableServices.map(({ name }) => name).join(", ")}]`, commaSeparatedList, [])
+        .option("-p, --port <number>", "port to listen on", parseInt, 8080)
+        .option("--dry-run", "show the docker compose configuration", false)
+        .option("-v, --verbose", "verbose output", false)
+        .action(async (options, command) => {
+        const { environmentName } = command.optsWithGlobals();
+        const { blockTime, cpus, defaultBlock, dryRun, memory, port, services, verbose, } = options;
+        // 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 env = {
+            BLOCK_TIME: blockTime.toString(),
+            CARTESI_BLOCKCHAIN_DEFAULT_BLOCK: defaultBlock,
+            CARTESI_LOG_LEVEL: verbose ? "debug" : "info",
+            CARTESI_BIN_PATH: binPath,
+            CARTESI_LISTEN_PORT: port.toString(),
+            CARTESI_ROLLUPS_NODE_CPUS: cpus?.toString(),
+            CARTESI_ROLLUPS_NODE_MEMORY: memory?.toString(),
+            CARTESI_SDK_IMAGE: DEFAULT_SDK,
+        };
+        // build a list of unique compose files
+        const composeFiles = [
+            ...new Set(baseServices.map(({ file }) => file)),
+        ];
+        // cpu and memory limits, mostly for testing and debuggingpurposes
+        if (cpus) {
+            composeFiles.push("docker-compose-node-cpus.yaml");
+        }
+        if (memory) {
+            composeFiles.push("docker-compose-node-memory.yaml");
+        }
+        // select subset of optional services
+        const optionalServices = services.length === 1 && services[0] === "all"
+            ? availableServices
+            : availableServices.filter(({ name }) => services.includes(name));
+        // add to compose files list
+        composeFiles.push(...optionalServices.map(({ file }) => file));
+        // create the "--file <file>" list
+        const files = composeFiles
+            .map((f) => [
+            "--file",
+            path.join(binPath, "compose", "rollups", f),
+        ])
+            .flat();
+        const composeArgs = [
+            "compose",
+            ...files,
+            "--project-name",
+            environmentName,
+        ];
+        // run in detached mode (background)
+        const upArgs = ["--detach"];
+        if (dryRun) {
+            // show the docker compose configuration
+            await execa("docker", [...composeArgs, "config"], {
+                env,
+                stdio: "inherit",
+            });
+        }
+        else {
+            if (defaultBlock !== "finalized") {
+                console.warn(chalk.yellow(`WARNING: default block is set to '${defaultBlock}', production configuration will likely use 'finalized'`));
+            }
+            // pull images first
+            await execa("docker", [...composeArgs, "pull"], {
+                env,
+                stdio: "inherit",
+            });
+            // run compose environment
+            const up = execa("docker", [...composeArgs, "up", ...upArgs], {
+                env,
+            });
+            // create tasks to monitor services startup
+            const monitorTasks = [...baseServices, ...optionalServices]
+                .filter(({ healthySemaphore }) => !!healthySemaphore) // only services with a healthy semaphore
+                .map((service) => {
+                const healthyTitle = typeof service.healthyTitle === "function"
+                    ? service.healthyTitle(port)
+                    : service.healthyTitle;
+                return serviceMonitorTask({
+                    environmentName,
+                    service: service.healthySemaphore,
+                    errorTitle: service.errorTitle,
+                    waitTitle: service.waitTitle,
+                    healthyTitle,
+                });
+            });
+            const tasks = new Listr(monitorTasks, { concurrent: true });
+            await tasks.run();
+            await up;
+        }
+    });
+};

package/dist/commands/rollups/status.d.ts

@@ -0,0 +1,7 @@
+import { Command } from "@commander-js/extra-typings";
+export declare const createStatusCommand: () => Command<[], {
+    json?: true | undefined;
+}, {
+    environmentName: string;
+}>;
+//# sourceMappingURL=status.d.ts.map

package/dist/commands/rollups/status.d.ts.map

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

package/dist/commands/rollups/status.js

@@ -0,0 +1,46 @@
+import { Command } from "@commander-js/extra-typings";
+import chalk from "chalk";
+import Table from "cli-table3";
+import { getServiceState } from "../../base.js";
+import { getDeployments } from "../../exec/rollups.js";
+export const createStatusCommand = () => {
+    return new Command("status")
+        .description("Shows the status of a local rollups node environment.")
+        .configureHelp({ showGlobalOptions: true })
+        .option("--json", "output in JSON format")
+        .action(async ({ json }, command) => {
+        const { environmentName } = command.optsWithGlobals();
+        const status = await getServiceState({
+            environmentName,
+            service: "rollups-node",
+        });
+        const deployments = await getDeployments({ environmentName });
+        if (json) {
+            process.stdout.write(JSON.stringify({
+                status,
+                deployments,
+            }));
+        }
+        else {
+            console.log(`${chalk.cyan(environmentName)} is ${status == "running" ? chalk.green("running") : chalk.red("not running")}`);
+            if (status === "running") {
+                if (deployments.length === 0) {
+                    console.log(chalk.red("no applications deployed"));
+                }
+                else {
+                    // print as a table
+                    const table = new Table({
+                        head: ["Machine", "Address", "State"],
+                        style: { border: [], head: [] },
+                    });
+                    table.push(...deployments.map((deployment) => [
+                        deployment.templateHash,
+                        deployment.address,
+                        deployment.state,
+                    ]));
+                    console.log(table.toString());
+                }
+            }
+        }
+    });
+};

package/dist/commands/rollups/stop.d.ts

@@ -0,0 +1,5 @@
+import { Command } from "@commander-js/extra-typings";
+export declare const createStopCommand: () => Command<[], {}, {
+    environmentName: string;
+}>;
+//# sourceMappingURL=stop.d.ts.map

package/dist/commands/rollups/stop.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stop.d.ts","sourceRoot":"","sources":["../../../src/commands/rollups/stop.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,6BAA6B,CAAC;AAMtD,eAAO,MAAM,iBAAiB;;EAwB7B,CAAC"}

package/dist/commands/rollups/stop.js

@@ -0,0 +1,26 @@
+import { Command } from "@commander-js/extra-typings";
+import chalk from "chalk";
+import { execa } from "execa";
+import ora from "ora";
+export const createStopCommand = () => {
+    return new Command("stop")
+        .description("Stop a local rollups node environment.")
+        .configureHelp({ showGlobalOptions: true })
+        .action(async (_options, command) => {
+        const { environmentName } = command.optsWithGlobals();
+        const progress = ora(`Stopping ${chalk.cyan(environmentName)} environment...`).start();
+        try {
+            await execa("docker", [
+                "compose",
+                "-p",
+                environmentName,
+                "down",
+                "--volumes",
+            ]);
+            progress.succeed(`${chalk.cyan(environmentName)} environment stopped.`);
+        }
+        catch (e) {
+            progress.fail(e.message);
+        }
+    });
+};

package/dist/commands/rollups.d.ts

@@ -0,0 +1,6 @@
+import { Command } from "@commander-js/extra-typings";
+export declare const createRollupsCommand: () => Command<[], {
+    environmentName: string;
+}, {}>;
+export type RollupsCommandOpts = ReturnType<ReturnType<typeof createRollupsCommand>["opts"]>;
+//# sourceMappingURL=rollups.d.ts.map

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

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

package/dist/commands/rollups.js

@@ -0,0 +1,19 @@
+import { Command } from "@commander-js/extra-typings";
+import { createDeployCommand } from "./rollups/deploy.js";
+import { createLogsCommand } from "./rollups/logs.js";
+import { createStartCommand } from "./rollups/start.js";
+import { createStatusCommand } from "./rollups/status.js";
+import { createStopCommand } from "./rollups/stop.js";
+export const createRollupsCommand = () => {
+    const command = new Command("rollups")
+        .option("--environment-name <string>", "name of environment", "cartesi-rollups")
+        .action(async (_options, program) => {
+        program.help();
+    });
+    command.addCommand(createLogsCommand());
+    command.addCommand(createStartCommand());
+    command.addCommand(createStatusCommand());
+    command.addCommand(createStopCommand());
+    command.addCommand(createDeployCommand());
+    return command;
+};

package/dist/commands/run.d.ts

@@ -1,3 +1,3 @@
 import { Command } from "@commander-js/extra-typings";
-export declare const registerRunCommand: (program: Command) => void;
+export declare const createRunCommand: () => Command<[], {}, {}>;
 //# 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,EAAU,MAAM,6BAA6B,CAAC;AAM9D,eAAO,MAAM,kBAAkB,YAAa,OAAO,SAyOlD,CAAC"}
+{"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"}