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

package/dist/commands/send/erc721.js

@@ -1,78 +0,0 @@
-import { Command } from "@commander-js/extra-typings";
-import input from "@inquirer/input";
-import ora from "ora";
-import { erc721Abi, getAddress, isAddress, } from "viem";
-import { erc721PortalAbi, erc721PortalAddress } from "../../contracts.js";
-import { connect, getInputApplicationAddress, } from "../send.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 {
-        name,
-        symbol,
-    };
-};
-const ercValidator = (publicClient) => async (value) => {
-    if (!isAddress(value)) {
-        return "Invalid address";
-    }
-    try {
-        await readToken(publicClient, value);
-    }
-    catch (e) {
-        return "Invalid token";
-    }
-    return true;
-};
-export const createErc721Command = () => {
-    return new Command("erc721")
-        .description("Sends ERC-721 deposits to the application, optionally in interactive mode.")
-        .configureHelp({ showGlobalOptions: true })
-        .option("--token <address>", "token address")
-        .option("--token-id <number>", "token ID")
-        .action(async (options, command) => {
-        const sendOptions = command.optsWithGlobals();
-        // connect to RPC provider
-        const { publicClient, walletClient } = await connect(sendOptions);
-        // get dapp address from local node, or ask
-        const applicationAddress = await getInputApplicationAddress(sendOptions.dapp);
-        const token = options.token && isAddress(options.token)
-            ? getAddress(options.token)
-            : (await input({
-                message: "Token address",
-                validate: ercValidator(publicClient),
-            }));
-        const tokenId = options.tokenId ||
-            (await input({
-                message: "Token ID",
-                validate: (value) => {
-                    try {
-                        BigInt(value);
-                        return true;
-                    }
-                    catch (e) {
-                        return "Invalid number";
-                    }
-                },
-            }));
-        const { request } = await publicClient.simulateContract({
-            address: erc721PortalAddress,
-            abi: erc721PortalAbi,
-            functionName: "depositERC721Token",
-            args: [token, applicationAddress, BigInt(tokenId), "0x", "0x"],
-            account: walletClient.account,
-        });
-        // XXX: add support for baseLayerData and execLayerData
-        const hash = await walletClient.writeContract(request);
-        const progress = ora("Sending input...").start();
-        await publicClient.waitForTransactionReceipt({ hash });
-        progress.succeed(`Input sent: ${hash}`);
-    });
-};

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

@@ -1,12 +0,0 @@
-import { Command } from "@commander-js/extra-typings";
-export declare const createEtherCommand: () => Command<[], {
-    amount?: string | undefined;
-    execLayerData: string;
-}, {
-    chainId: number;
-    rpcUrl?: string | undefined;
-    mnemonic?: string | undefined;
-    mnemonicIndex: number;
-    dapp?: `0x${string}` | undefined;
-}>;
-//# sourceMappingURL=ether.d.ts.map

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

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

package/dist/commands/send/ether.js

@@ -1,36 +0,0 @@
-import { Command } from "@commander-js/extra-typings";
-import input from "@inquirer/input";
-import ora from "ora";
-import { isHex, parseEther } from "viem";
-import { etherPortalAbi, etherPortalAddress } from "../../contracts.js";
-import { connect, getInputApplicationAddress, } from "../send.js";
-export const createEtherCommand = () => {
-    return new Command("ether")
-        .description("Sends ether deposits to the application, optionally in interactive mode.")
-        .configureHelp({ showGlobalOptions: true })
-        .option("--amount <number>", "amount, in ETH units")
-        .option("--exec-layer-data <hex>", "exec layer data", "0x")
-        .action(async (options, command) => {
-        const sendOptions = command.optsWithGlobals();
-        // connect to RPC provider
-        const { publicClient, walletClient } = await connect(sendOptions);
-        // get dapp address from local node, or ask
-        const applicationAddress = await getInputApplicationAddress(sendOptions.dapp);
-        const amount = options.amount || (await input({ message: "Amount" }));
-        const { request } = await publicClient.simulateContract({
-            address: etherPortalAddress,
-            abi: etherPortalAbi,
-            functionName: "depositEther",
-            args: [
-                applicationAddress,
-                isHex(options.execLayerData) ? options.execLayerData : "0x", // XXX: validate before this
-            ],
-            value: parseEther(amount),
-            account: walletClient.account,
-        });
-        const hash = await walletClient.writeContract(request);
-        const progress = ora("Sending input...").start();
-        await publicClient.waitForTransactionReceipt({ hash });
-        progress.succeed(`Input sent: ${hash}`);
-    });
-};

package/dist/commands/send/generic.d.ts

@@ -1,15 +0,0 @@
-import { Command } from "@commander-js/extra-typings";
-export declare const createGenericCommand: () => Command<[], {
-    input?: string | undefined;
-    inputEncoding?: "string" | "hex" | "abi" | undefined;
-    type: "evm" | "eip712";
-    eip712TxUrl: string;
-    inputAbiParams?: string | undefined;
-}, {
-    chainId: number;
-    rpcUrl?: string | undefined;
-    mnemonic?: string | undefined;
-    mnemonicIndex: number;
-    dapp?: `0x${string}` | undefined;
-}>;
-//# sourceMappingURL=generic.d.ts.map

package/dist/commands/send/generic.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"generic.d.ts","sourceRoot":"","sources":["../../../src/commands/send/generic.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAU,MAAM,6BAA6B,CAAC;AAqG9D,eAAO,MAAM,oBAAoB;;;;;;;;;;;;EA8DhC,CAAC"}

package/dist/commands/send/generic.js

@@ -1,122 +0,0 @@
-import { Command, Option } from "@commander-js/extra-typings";
-import ora from "ora";
-import { encodeAbiParameters, getAddress, isAddress, isHex, parseAbiParameters, stringToHex, } from "viem";
-import { inputBoxAbi, inputBoxAddress } from "../../contracts.js";
-import { bytesInput } from "../../prompts.js";
-import { connect, getInputApplicationAddress, } from "../send.js";
-import { DEFAULT_SEND_CONFIG, sendEip712 } from "./eip712.js";
-const getInput = async (options) => {
-    const input = options.input;
-    const encoding = options.inputEncoding;
-    if (input) {
-        if (encoding === "hex") {
-            // validate if is a hex value
-            if (!isHex(input)) {
-                throw new Error("input encoded as hex must start with 0x");
-            }
-            return input;
-        }
-        if (encoding === "string") {
-            // encode UTF-8 string as hex
-            return stringToHex(input);
-        }
-        if (encoding === "abi") {
-            const abiParams = options.inputAbiParams;
-            if (!abiParams) {
-                throw new Error("Undefined input-abi-params");
-            }
-            const abiParameters = parseAbiParameters(abiParams);
-            // TODO: decode values
-            const values = input.split(",").map((v, index) => {
-                if (index >= abiParameters.length) {
-                    throw new Error(`Too many values, expected ${abiParameters.length} values based on --input-abi-params '${abiParams}', parsing value at index ${index} from input '${input}'`);
-                }
-                const param = abiParameters[index];
-                switch (param.type) {
-                    case "string":
-                        return v;
-                    case "bool":
-                        if (v === "true")
-                            return true;
-                        if (v === "false")
-                            return false;
-                        throw new Error(`Invalid boolean value: ${v}`);
-                    case "uint":
-                    case "uint8":
-                    case "uint16":
-                    case "uint32":
-                    case "uint64":
-                    case "uint128":
-                    case "uint256":
-                        try {
-                            return BigInt(v);
-                        }
-                        catch (e) {
-                            throw new Error(`Invalid uint value: ${v}`);
-                        }
-                    case "bytes":
-                        if (isHex(v)) {
-                            return v;
-                        }
-                        throw new Error(`Invalid bytes value: ${v}`);
-                    case "address":
-                        if (isAddress(v)) {
-                            return getAddress(v);
-                        }
-                        throw new Error(`Invalid address value: ${v}`);
-                    default:
-                        throw new Error(`Unsupported type ${param.type}`);
-                }
-            });
-            if (values.length !== abiParameters.length) {
-                throw new Error(`Not enough values, expected ${abiParameters.length} values based on --input-abi-params '${abiParams}', parsed ${values.length} values from input '${input}'`);
-            }
-            return encodeAbiParameters(abiParameters, values);
-        }
-        if (isHex(input)) {
-            return input;
-        }
-        // encode UTF-8 string as hex
-        return stringToHex(input);
-    }
-    return undefined;
-};
-export const createGenericCommand = () => {
-    return new Command("generic")
-        .description("Sends generics inputs to the application, optionally in interactive mode.")
-        .configureHelp({ showGlobalOptions: true })
-        .option("--input <input>", "input payload")
-        .addOption(new Option("--input-encoding <input-encoding>", "input encoding").choices(["hex", "string", "abi"]))
-        .addOption(new Option("--type <type>", "Transaction type").choices(["evm", "eip712"])
-        .default("evm"))
-        .addOption(new Option("--eip712-tx-url <url>", "EIP-712 base url").default(DEFAULT_SEND_CONFIG.eip712TxUrl))
-        .option("--input-abi-params <input-abi-params>", "input abi params")
-        .action(async (options, command) => {
-        const sendOptions = command.optsWithGlobals();
-        // connect to RPC provider
-        const { publicClient, walletClient } = await connect(sendOptions);
-        // get dapp address from local node, or ask
-        const applicationAddress = await getInputApplicationAddress(sendOptions.dapp);
-        const payload = (await getInput(options)) ||
-            (await bytesInput({ message: "Input" }));
-        if (options.type === 'eip712') {
-            const progress = ora("Sending input...").start();
-            const hash = await sendEip712(walletClient, applicationAddress, payload, {
-                eip712TxUrl: options.eip712TxUrl,
-            });
-            progress.succeed(`Input sent: ${hash}`);
-            return;
-        }
-        const { request } = await publicClient.simulateContract({
-            address: inputBoxAddress,
-            abi: inputBoxAbi,
-            functionName: "addInput",
-            args: [applicationAddress, payload],
-            account: walletClient.account,
-        });
-        const hash = await walletClient.writeContract(request);
-        const progress = ora("Sending input...").start();
-        await publicClient.waitForTransactionReceipt({ hash });
-        progress.succeed(`Input sent: ${hash}`);
-    });
-};

package/dist/commands/start.d.ts

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

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

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

package/dist/commands/start.js

@@ -1,220 +0,0 @@
-import { Command, Option } from "@commander-js/extra-typings";
-import chalk from "chalk";
-import { execa } from "execa";
-import { Listr } from "listr2";
-import path from "node:path";
-import pRetry from "p-retry";
-import { getServiceHealth } from "../base.js";
-import { DEFAULT_COMPOSE_ENVIRONMENT_NAME, DEFAULT_SDK_IMAGE, DEFAULT_SDK_VERSION, } 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: (port) => `${chalk.cyan("anvil")} service ready at ${chalk.cyan(`${host}:${port}/anvil`)}`,
-        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`,
-    },
-    {
-        name: "passkey",
-        file: "docker-compose-passkey-server.yaml",
-        healthySemaphore: "passkey-server",
-        healthyTitle: (port) => `${chalk.cyan("passkey")} service ready at ${chalk.cyan(`${host}:${port}/passkey`)}`,
-        waitTitle: `${chalk.cyan("passkey")} service starting...`,
-        errorTitle: `${chalk.red("passkey")} 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 environment.")
-        .configureHelp({ showGlobalOptions: true })
-        .addOption(new Option("--runtime-version <version>", "version for Cartesi Rollups Runtime to use")
-        .default(DEFAULT_SDK_VERSION)
-        .hideHelp())
-        .option("--environment-name <string>", "name of environment", DEFAULT_COMPOSE_ENVIRONMENT_NAME)
-        .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", Number, 6751)
-        .option("--dry-run", "show the docker compose configuration", false)
-        .option("-v, --verbose", "verbose output", false)
-        .action(async (options, command) => {
-        const { blockTime, cpus, defaultBlock, dryRun, environmentName, memory, port, services, verbose, runtimeVersion, } = 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 = {
-            CARTESI_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_IMAGE}:${runtimeVersion}`,
-            CARTESI_SDK_VERSION: runtimeVersion,
-        };
-        // 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.flatMap((f) => [
-            "--file",
-            path.join(binPath, "compose", f),
-        ]);
-        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
-            const pullArgs = ["--policy", "missing"];
-            await execa("docker", [...composeArgs, "pull", ...pullArgs], {
-                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/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/stop.d.ts.map

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

package/dist/commands/stop.js

@@ -1,27 +0,0 @@
-import { Command } from "@commander-js/extra-typings";
-import chalk from "chalk";
-import { execa } from "execa";
-import ora from "ora";
-import { DEFAULT_COMPOSE_ENVIRONMENT_NAME } from "../config.js";
-export const createStopCommand = () => {
-    return new Command("stop")
-        .description("Stop a local environment.")
-        .configureHelp({ showGlobalOptions: true })
-        .option("--environment-name <string>", "name of environment", DEFAULT_COMPOSE_ENVIRONMENT_NAME)
-        .action(async ({ environmentName }, command) => {
-        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/compose/docker-compose-espresso.yaml

@@ -1,81 +0,0 @@
-configs:
-    espresso_proxy:
-        content: |
-            http:
-                routers:
-                    espresso-reader:
-                        rule: "PathPrefix(`/transaction`)"
-                        middlewares:
-                            - "remove-espresso-reader-prefix"
-                        service: espresso-reader
-                middlewares:
-                    remove-espresso-reader-prefix:
-                        replacePathRegex:
-                            regex: "^/transaction/(.*)"
-                            replacement: "/$1"
-                services:
-                    espresso-reader:
-                        loadBalancer:
-                            servers:
-                                - url: "http://espresso_reader:8081"
-
-services:
-    espresso:
-        image: ${CARTESI_SDK_IMAGE}
-        command: ["espresso-dev-node"]
-        init: true
-        deploy:
-            resources:
-                limits:
-                    cpus: "4"
-                    memory: "1G"
-        depends_on:
-            database:
-                condition: service_healthy
-            anvil:
-                condition: service_healthy
-        environment:
-            ESPRESSO_SEQUENCER_L1_PROVIDER: ${CARTESI_BLOCKCHAIN_HTTP_ENDPOINT:-http://anvil:8545}
-            ESPRESSO_SEQUENCER_API_PORT: 24000
-            ESPRESSO_BUILDER_PORT: 23000
-            ESPRESSO_DEV_NODE_PORT: 20000
-            ESPRESSO_SEQUENCER_ETH_MNEMONIC: ${CARTESI_AUTH_MNEMONIC:-test test test test test test test test test test test junk}
-            ESPRESSO_SEQUENCER_L1_POLLING_INTERVAL: "${CARTESI_BLOCK_TIME}s"
-            ESPRESSO_STATE_PROVER_UPDATE_INTERVAL: "10s"
-            ESPRESSO_SEQUENCER_DATABASE_MAX_CONNECTIONS: 25
-            ESPRESSO_SEQUENCER_STORAGE_PATH: /data/espresso
-        healthcheck:
-            test:
-                [
-                    "CMD",
-                    "curl",
-                    "-fsS",
-                    "http://127.0.0.1:24000/status/block-height",
-                ]
-            start_period: 10s
-            start_interval: 200ms
-            interval: 10s
-            timeout: 1s
-            retries: 5
-
-    espresso_reader:
-        image: ${CARTESI_SDK_IMAGE}
-        command: ["cartesi-rollups-espresso-reader"]
-        env_file:
-            - ${CARTESI_BIN_PATH}/compose/default.env
-        ports:
-            - 8081
-        depends_on:
-            database:
-                condition: service_healthy
-            espresso:
-                condition: service_healthy
-        environment:
-            CARTESI_DATABASE_CONNECTION: postgres://postgres:password@database:5432/rollupsdb?sslmode=disable
-            ESPRESSO_SERVICE_ENDPOINT: ":8081"
-            ESPRESSO_BASE_URL: http://espresso:24000
-
-    proxy:
-        configs:
-            - source: espresso_proxy
-              target: /etc/traefik/conf.d/espresso.yaml