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

package/dist/wallet.js

@@ -5,21 +5,17 @@ import { mnemonicToAccount, privateKeyToAccount } from "viem/accounts";
 import { arbitrum, arbitrumSepolia, base, baseSepolia, cannon, mainnet, optimism, optimismSepolia, sepolia, } from "viem/chains";
 import { hexInput, selectAuto } from "./prompts.js";
 export const supportedChains = (options) => {
-    options = options || {
-        includeDevnet: false, // default is not to show devnet
-        includeMainnets: true,
-        includeTestnets: true,
-    };
-    options.includeTestnets = options.includeTestnets ?? true; // default is true if not specified
-    options.includeMainnets = options.includeMainnets ?? true; // default is true if not specified
+    const includeDevnet = options?.includeDevnet ?? false; // default is not to show devnet
+    const includeMainnets = options?.includeMainnets ?? true; // default is true if not specified
+    const includeTestnets = options?.includeTestnets ?? true; // default is true if not specified
     const chains = [];
-    if (options.includeDevnet) {
+    if (includeDevnet) {
         chains.push(cannon);
     }
-    if (options.includeTestnets) {
+    if (includeTestnets) {
         chains.push(arbitrumSepolia, baseSepolia, optimismSepolia, sepolia);
     }
-    if (options.includeMainnets) {
+    if (includeMainnets) {
         chains.push(arbitrum, base, mainnet, optimism);
     }
     return chains;
@@ -75,44 +71,40 @@ const selectChain = async (options) => {
         }
         throw new Error(`Unsupported chainId ${options.chain.id}`);
     }
-    else {
-        // allow user to select from list
-        const choices = chains.map((chain) => ({
-            name: chain.name,
-            value: chain,
-        }));
-        return await selectAuto({
-            message: "Chain",
-            choices,
-            pageSize: choices.length,
-            discardDisabled: true,
-        });
-    }
+    // allow user to select from list
+    const choices = chains.map((chain) => ({
+        name: chain.name,
+        value: chain,
+    }));
+    return await selectAuto({
+        message: "Chain",
+        choices,
+        pageSize: choices.length,
+        discardDisabled: true,
+    });
 };
 const selectTransport = async (options, chain) => {
     // use user provided url (in args) or try to use default one from chain, or ask for one
     if (options.rpcUrl) {
         return http(options.rpcUrl);
     }
-    else {
-        const defaultUrl = chain.rpcUrls.default.http[0];
-        // if the chain is cannon and URL is valid, use it without asking the user
-        if (chain.id === cannon.id) {
-            const port = 8080; // XXX: how to get environment port?
-            const url = `http://127.0.0.1:${port}/anvil`;
-            if (await testChainUrl(chain, url)) {
-                return http(url);
-            }
-            if (await testDefaultPublicClient(chain)) {
-                return http(defaultUrl);
-            }
+    const defaultUrl = chain.rpcUrls.default.http[0];
+    // if the chain is cannon and URL is valid, use it without asking the user
+    if (chain.id === cannon.id) {
+        const port = 6751; // XXX: how to get environment port?
+        const url = `http://127.0.0.1:${port}/anvil`;
+        if (await testChainUrl(chain, url)) {
+            return http(url);
+        }
+        if (await testDefaultPublicClient(chain)) {
+            return http(defaultUrl);
         }
-        const url = await input({
-            message: "RPC URL",
-            default: defaultUrl,
-        });
-        return http(url);
     }
+    const url = await input({
+        message: "RPC URL",
+        default: defaultUrl,
+    });
+    return http(url);
 };
 const createPublicClient = async (chain, transport) => {
     const publicClient = viemCreatePublicClient({ transport, chain });
@@ -144,9 +136,7 @@ const addressBalanceLabel = async (address, publicClient) => {
         }
         return `${address} ${balanceLabel}`;
     }
-    else {
-        return address;
-    }
+    return address;
 };
 const createWalletClient = async (options, chain, publicClient, publicTransport) => {
     if (options.privateKey) {
@@ -158,7 +148,7 @@ const createWalletClient = async (options, chain, publicClient, publicTransport)
             chain,
         });
     }
-    else if (options.mnemonicPassphrase) {
+    if (options.mnemonicPassphrase) {
         // mnemonic specified
         const account = mnemonicToAccount(options.mnemonicPassphrase, {
             addressIndex: options.mnemonicIndex,
@@ -170,62 +160,56 @@ const createWalletClient = async (options, chain, publicClient, publicTransport)
             chain,
         });
     }
-    else {
-        const wallets = walletChoices(chain);
-        const wallet = await selectAuto({
-            message: "Wallet",
-            choices: wallets,
-            discardDisabled: true,
+    const wallets = walletChoices(chain);
+    const wallet = await selectAuto({
+        message: "Wallet",
+        choices: wallets,
+        discardDisabled: true,
+    });
+    if (wallet === "mnemonic") {
+        // use the publicClient transport
+        const mnemonic = await input({
+            message: "Mnemonic",
+            default: chain.id === cannon.id ? DEFAULT_DEVNET_MNEMONIC : undefined,
         });
-        if (wallet === "mnemonic") {
-            // use the publicClient transport
-            const mnemonic = await input({
-                message: "Mnemonic",
-                default: chain.id === cannon.id
-                    ? DEFAULT_DEVNET_MNEMONIC
-                    : undefined,
-            });
-            // select account from mnemonic
-            if (options.mnemonicIndex) {
-                return viemCreateWalletClient({
-                    transport: publicTransport,
-                    chain,
-                    account: mnemonicToAccount(mnemonic, {
-                        addressIndex: options.mnemonicIndex,
-                    }),
-                });
-            }
-            else {
-                const choices = await Promise.all([...Array(10)].map(async (_, addressIndex) => {
-                    const account = mnemonicToAccount(mnemonic, {
-                        addressIndex,
-                    });
-                    const name = await addressBalanceLabel(account.address, publicClient);
-                    return { name, value: account };
-                }));
-                const account = await selectAuto({
-                    message: "Account",
-                    choices,
-                    pageSize: choices.length,
-                });
-                return viemCreateWalletClient({
-                    transport: publicTransport,
-                    chain,
-                    account,
-                });
-            }
-        }
-        else if (wallet === "private-key") {
-            const privateKey = await hexInput({ message: "Private Key" });
-            const account = privateKeyToAccount(privateKey);
+        // select account from mnemonic
+        if (options.mnemonicIndex) {
             return viemCreateWalletClient({
                 transport: publicTransport,
                 chain,
-                account,
+                account: mnemonicToAccount(mnemonic, {
+                    addressIndex: options.mnemonicIndex,
+                }),
             });
         }
-        throw new Error(`Unsupported wallet ${wallet}`);
+        const choices = await Promise.all([...Array(10)].map(async (_, addressIndex) => {
+            const account = mnemonicToAccount(mnemonic, {
+                addressIndex,
+            });
+            const name = await addressBalanceLabel(account.address, publicClient);
+            return { name, value: account };
+        }));
+        const account = await selectAuto({
+            message: "Account",
+            choices,
+            pageSize: choices.length,
+        });
+        return viemCreateWalletClient({
+            transport: publicTransport,
+            chain,
+            account,
+        });
+    }
+    if (wallet === "private-key") {
+        const privateKey = await hexInput({ message: "Private Key" });
+        const account = privateKeyToAccount(privateKey);
+        return viemCreateWalletClient({
+            transport: publicTransport,
+            chain,
+            account,
+        });
     }
+    throw new Error(`Unsupported wallet ${wallet}`);
 };
 const createClients = async (options) => {
     // select chain

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cartesi/cli",
-  "version": "2.0.0-alpha.11",
+  "version": "2.0.0-alpha.13",
   "description": "Cartesi CLI",
   "author": "Danilo Tuler <tuler@pobox.com>",
   "bin": {
@@ -42,8 +42,9 @@
     "viem": "^2.23.6"
   },
   "devDependencies": {
-    "@cartesi/devnet": "2.0.0-alpha.5",
-    "@cartesi/rollups": "2.0.0-rc.17",
+    "@biomejs/biome": "^1.9.4",
+    "@cartesi/devnet": "2.0.0-alpha.7",
+    "@cartesi/rollups": "2.0.0",
     "@types/bytes": "^3.1.5",
     "@types/fs-extra": "^11.0.4",
     "@types/inquirer": "^9.0.7",
@@ -56,14 +57,12 @@
     "@vitest/coverage-istanbul": "^2.1.3",
     "@wagmi/cli": "^2.2.0",
     "copyfiles": "^2.4.1",
-    "eslint": "^8.57.0",
     "npm-run-all": "^4.1.5",
     "rimraf": "^6.0.1",
     "ts-node": "^10.9.2",
     "tslib": "^2.8.1",
     "typescript": "^5.8.2",
     "vitest": "^2.1.3",
-    "@cartesi/eslint-config": "0.0.0",
     "tsconfig": "0.0.0"
   },
   "engines": {
@@ -79,7 +78,7 @@
     "compile": "tsc -p tsconfig.build.json",
     "postcompile": "chmod +x dist/index.js",
     "copy-files": "copyfiles -u 1 \"src/**/*.yaml\" \"src/**/*.env\" \"src/**/*.txt\" dist",
-    "lint": "eslint \"src/**/*.ts*\"",
+    "lint": "biome lint",
     "posttest": "pnpm lint",
     "test": "vitest"
   }

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

@@ -1,7 +0,0 @@
-import { Command } from "@commander-js/extra-typings";
-export declare const DEFAULT_TEMPLATES_BRANCH = "prerelease/sdk-12";
-export declare const createCreateCommand: () => Command<[string], {
-    template: "cpp" | "cpp-low-level" | "go" | "javascript" | "lua" | "python" | "ruby" | "rust" | "typescript";
-    branch: string;
-}, {}>;
-//# sourceMappingURL=create.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"create.d.ts","sourceRoot":"","sources":["../../../src/commands/rollups/create.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAU,MAAM,6BAA6B,CAAC;AAK9D,eAAO,MAAM,wBAAwB,sBAAsB,CAAC;AAc5D,eAAO,MAAM,mBAAmB;;;MA+B/B,CAAC"}

package/dist/commands/rollups/create.js

@@ -1,36 +0,0 @@
-import { Command, Option } from "@commander-js/extra-typings";
-import chalk from "chalk";
-import ora from "ora";
-import { download } from "../../template.js";
-export const DEFAULT_TEMPLATES_BRANCH = "prerelease/sdk-12";
-const TEMPLATES = [
-    "cpp",
-    "cpp-low-level",
-    "go",
-    "javascript",
-    "lua",
-    "python",
-    "ruby",
-    "rust",
-    "typescript",
-];
-export const createCreateCommand = () => {
-    return new Command("create")
-        .argument("<name>", "application and directory name")
-        .addOption(new Option("-t, --template <template>", "template name to use")
-        .choices(TEMPLATES)
-        .makeOptionMandatory())
-        .option("-b, --branch <branch>", "cartesi/application-templates repository branch name to use", DEFAULT_TEMPLATES_BRANCH)
-        .action(async (name, { branch, template }) => {
-        const spinner = ora("Creating application...").start();
-        try {
-            const { dir } = await download("rollups", template, branch, 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));
-        }
-    });
-};

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

@@ -1,16 +0,0 @@
-import { Command } from "@commander-js/extra-typings";
-export declare const createDeployCommand: () => Command<[], {
-    chainId: number;
-    rpcUrl?: string | undefined;
-    mnemonic?: string | undefined;
-    mnemonicIndex: number;
-    name?: string | undefined;
-    authorityOwner?: `0x${string}` | undefined;
-    applicationOwner?: `0x${string}` | undefined;
-    epochLength: number;
-    salt: `0x${string}`;
-    json?: true | undefined;
-}, {
-    environmentName: string;
-}>;
-//# sourceMappingURL=deploy.d.ts.map

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

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

package/dist/commands/rollups/deploy.js

@@ -1,237 +0,0 @@
-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 { encodeFunctionData, zeroHash, } from "viem";
-import { cannon } from "viem/chains";
-import { getContextPath, getMachineHash, parseAddress, parseHash, } from "../../base.js";
-import { applicationFactoryAbi, applicationFactoryAddress, authorityFactoryAbi, authorityFactoryAddress, dataAvailabilityAbi, inputBoxAddress, } 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,
-        }));
-    // create data availability descriptor for InputBox only
-    const dataAvailability = encodeFunctionData({
-        abi: dataAvailabilityAbi,
-        functionName: "InputBox",
-        args: [inputBoxAddress],
-    });
-    const applicationAddress = await publicClient.readContract({
-        abi: applicationFactoryAbi,
-        address: applicationFactoryAddress,
-        functionName: "calculateApplicationAddress",
-        args: [
-            authorityAddress,
-            applicationOwner,
-            templateHash,
-            dataAvailability,
-            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,
-                dataAvailability,
-                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, 13370)
-        .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 === cannon.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.map

@@ -1 +0,0 @@
-{"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/start.d.ts.map

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

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

@@ -1 +0,0 @@
-{"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/stop.d.ts

@@ -1,5 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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.d.ts

@@ -1,6 +0,0 @@
-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

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

package/dist/commands/rollups.js

@@ -1,21 +0,0 @@
-import { Command } from "@commander-js/extra-typings";
-import { createCreateCommand } from "./rollups/create.js";
-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());
-    command.addCommand(createCreateCommand());
-    return command;
-};

package/dist/compose/rollups/docker-compose-anvil.yaml

@@ -1,17 +0,0 @@
-services:
-    anvil:
-        image: ${CARTESI_SDK_IMAGE}
-        command: ["devnet", "--block-time", "${BLOCK_TIME:-5}"]
-        healthcheck:
-            test: ["CMD", "eth_isready"]
-            start_period: 10s
-            start_interval: 200ms
-            interval: 10s
-            timeout: 1s
-            retries: 5
-        environment:
-            ANVIL_IP_ADDR: 0.0.0.0
-
-    proxy:
-        volumes:
-            - ./proxy/anvil.yaml:/etc/traefik/conf.d/anvil.yaml