@cartesi/cli 2.0.0-alpha.1 → 2.0.0-alpha.12

package/dist/commands/shell.js

@@ -1,65 +1,43 @@
-import { Args, Flags } from "@oclif/core";
+import { Command } from "@commander-js/extra-typings";
 import fs from "fs-extra";
-import path from "path";
-import { BaseCommand } from "../baseCommand.js";
+import path from "node:path";
+import { getApplicationConfig, getContextPath } from "../base.js";
 import { bootMachine } from "../machine.js";
-class Shell extends BaseCommand {
-    async run() {
-        const { flags } = await this.parse(Shell);
+export const createShellCommand = () => {
+    return new Command("shell")
+        .argument("[image]", "image ID|name")
+        .option("--command <command>", "shell command to run", "/bin/sh")
+        .option("-c, --config <config>", "path to the configuration file", "cartesi.toml")
+        .option("--run-as-root", "run as root user", false)
+        .action(async (image, { command, config, runAsRoot }) => {
         // get application configuration from 'cartesi.toml'
-        const config = this.getApplicationConfig(flags.config);
+        const c = getApplicationConfig(config);
         // destination directory for image and intermediate files
-        const destination = path.resolve(this.getContextPath());
+        const destination = path.resolve(getContextPath());
         // check if all drives are built
-        for (const [name, drive] of Object.entries(config.drives)) {
+        for (const [name, drive] of Object.entries(c.drives)) {
             const filename = `${name}.${drive.format}`;
-            const pathname = this.getContextPath(filename);
+            const pathname = getContextPath(filename);
             if (!fs.existsSync(pathname)) {
-                throw new Error(`drive '${name}' not built, run '${this.config.bin} build'`);
+                throw new Error(`drive '${name}' not built, run 'build'`);
             }
         }
         // create shell entrypoint
         const info = {
             cmd: [],
-            entrypoint: [this.flags.command],
+            entrypoint: [command],
             env: [],
             workdir: "/",
         };
         // start with interactive mode on
-        config.machine.interactive = true;
+        c.machine.interactive = true;
         // interactive mode can't have final hash
-        config.machine.finalHash = false;
+        c.machine.finalHash = false;
         // do not store machine in interactive mode
-        config.machine.store = undefined;
+        c.machine.store = undefined;
         // run as root if flag is set
-        config.machine.user = flags["run-as-root"] ? "root" : undefined;
+        c.machine.user = runAsRoot ? "root" : undefined;
         // boot machine
-        await bootMachine(config, info, destination);
-    }
-}
-Shell.description = "Start a shell in cartesi machine of application";
-Shell.examples = ["<%= config.bin %> <%= command.id %>"];
-Shell.args = {
-    image: Args.string({
-        description: "image ID|name",
-        required: false,
-    }),
+        await bootMachine(c, info, destination);
+    });
 };
-Shell.flags = {
-    command: Flags.string({
-        default: "/bin/sh",
-        description: "shell command to run",
-        summary: "shell to run",
-    }),
-    config: Flags.file({
-        char: "c",
-        default: "cartesi.toml",
-        summary: "path to the configuration file",
-    }),
-    "run-as-root": Flags.boolean({
-        default: false,
-        description: "run as root user",
-        summary: "run the cartesi machine as the root user",
-    }),
-};
-export default Shell;

package/dist/commands/start.d.ts

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

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

@@ -0,0 +1,220 @@
+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, 8080)
+        .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 = {
+            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/status.d.ts

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

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

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

package/dist/commands/status.js

@@ -0,0 +1,47 @@
+import { Command } from "@commander-js/extra-typings";
+import chalk from "chalk";
+import Table from "cli-table3";
+import { getServiceState } from "../base.js";
+import { DEFAULT_COMPOSE_ENVIRONMENT_NAME } from "../config.js";
+import { getDeployments } from "../exec/rollups.js";
+export const createStatusCommand = () => {
+    return new Command("status")
+        .description("Shows the status of a local environment.")
+        .configureHelp({ showGlobalOptions: true })
+        .option("--environment-name <string>", "name of environment", DEFAULT_COMPOSE_ENVIRONMENT_NAME)
+        .option("--json", "output in JSON format")
+        .action(async ({ environmentName, json }, command) => {
+        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/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/stop.d.ts.map

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

@@ -0,0 +1,27 @@
+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/default.env

@@ -0,0 +1,35 @@
+# cartesi/rollups-node
+
+#logs
+CARTESI_LOG_LEVEL="${CARTESI_LOG_LEVEL:-info}"
+
+# features
+CARTESI_FEATURE_INPUT_READER_ENABLED="${CARTESI_FEATURE_INPUT_READER_ENABLED:-true}"
+CARTESI_FEATURE_CLAIM_SUBMISSION_ENABLED="${CARTESI_FEATURE_CLAIM_SUBMISSION_ENABLED:-true}"
+CARTESI_FEATURE_MACHINE_HASH_CHECK_ENABLED="${CARTESI_FEATURE_MACHINE_HASH_CHECK_ENABLED:-true}"
+CARTESI_SNAPSHOTS_DIR="/var/lib/cartesi-rollups-node/snapshots"
+
+# rollups
+CARTESI_EVM_READER_RETRY_POLICY_MAX_RETRIES="${CARTESI_EVM_READER_RETRY_POLICY_MAX_RETRIES:-3}"
+CARTESI_EVM_READER_RETRY_POLICY_MAX_DELAY="${CARTESI_EVM_READER_RETRY_POLICY_MAX_DELAY:-3}"
+CARTESI_ADVANCER_POLLING_INTERVAL="${CARTESI_ADVANCER_POLLING_INTERVAL:-3}"
+CARTESI_VALIDATOR_POLLING_INTERVAL="${CARTESI_VALIDATOR_POLLING_INTERVAL:-3}"
+CARTESI_CLAIMER_POLLING_INTERVAL="${CARTESI_CLAIMER_POLLING_INTERVAL:-3}"
+CARTESI_MAX_STARTUP_TIME="${CARTESI_MAX_STARTUP_TIME:-15}"
+
+# blockchain
+CARTESI_BLOCKCHAIN_ID="${CARTESI_BLOCKCHAIN_ID:-13370}"
+CARTESI_BLOCKCHAIN_HTTP_ENDPOINT="${CARTESI_BLOCKCHAIN_HTTP_ENDPOINT:-http://anvil:8545}"
+CARTESI_BLOCKCHAIN_WS_ENDPOINT="${CARTESI_BLOCKCHAIN_WS_ENDPOINT:-ws://anvil:8545}"
+CARTESI_BLOCKCHAIN_DEFAULT_BLOCK="${CARTESI_BLOCKCHAIN_DEFAULT_BLOCK:-latest}"
+
+# contracts
+CARTESI_CONTRACTS_APPLICATION_FACTORY_ADDRESS="${CARTESI_CONTRACTS_APPLICATION_FACTORY_ADDRESS:-0x2210ad1d9B0bD2D470c2bfA4814ab6253BC421A0}"
+CARTESI_CONTRACTS_AUTHORITY_FACTORY_ADDRESS="${CARTESI_CONTRACTS_AUTHORITY_FACTORY_ADDRESS:-0x451f57Ca716046D114Ab9ff23269a2F9F4a1bdaF}"
+CARTESI_CONTRACTS_SELF_HOSTED_APPLICATION_FACTORY_ADDRESS="${CARTESI_CONTRACTS_SELF_HOSTED_APPLICATION_FACTORY_ADDRESS:-0x4a409e1CaB9229711C4e1f68625DdbC75809e721}"
+
+# auth
+CARTESI_AUTH_MNEMONIC="${CARTESI_AUTH_MNEMONIC:-test test test test test test test test test test test junk}"
+
+# postgres
+CARTESI_DATABASE_CONNECTION="postgres://postgres:password@database:5432/rollupsdb?sslmode=disable"

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

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

package/dist/compose/docker-compose-bundler.yaml

@@ -0,0 +1,37 @@
+services:
+    bundler:
+        image: ${CARTESI_SDK_IMAGE}
+        command:
+            - "alto"
+            - "--entrypoints"
+            - "0x5ff137d4b0fdcd49dca30c7cf57e578a026d2789,0x0000000071727De22E5E9d8BAf0edAc6f37da032"
+            - "--log-level"
+            - "info"
+            - "--rpc-url"
+            - "http://anvil:8545"
+            - "--min-executor-balance"
+            - "0"
+            - "--utility-private-key"
+            - "0xdbda1821b80551c9d65939329250298aa3472ba22feea921c0cf5d620ea67b97"
+            - "--executor-private-keys"
+            - "0x2a871d0798f97d79848a013d4936a73bf4cc922c825d33c1cf7073dff6d409c6,0x4bbbf85ce3377467afe5d46f804f221813b2bb87f24d81f60f1fcdbf7cbf4356,0x92db14e403b83dfe3df233f83dfa3a0d7096f21ca9b0d6d6b8d88b2b4ec1564e,0x8b3a350cf5c34c9194ca85829a2df0ec3153be0318b5e2d3348e872092edffba,0x47e179ec197488593b187f80a00eb0da91f1b9d0b13f8733639f19c30a34926a"
+            - "--safe-mode"
+            - "false"
+            - "--port"
+            - "4337"
+            - "--public-client-log-level"
+            - "error"
+            - "--wallet-client-log-level"
+            - "error"
+            - "--enable-debug-endpoints"
+        healthcheck:
+            test: ["CMD", "curl", "-fsS", "http://127.0.0.1:4337/health"]
+            start_period: 10s
+            start_interval: 200ms
+            interval: 10s
+            timeout: 1s
+            retries: 5
+
+    proxy:
+        volumes:
+            - ./proxy/bundler.yaml:/etc/traefik/conf.d/bundler.yaml

package/dist/{node → compose}/docker-compose-database.yaml

@@ -1,10 +1,12 @@
 services:
     database:
-        image: postgres:15-alpine
+        image: cartesi/rollups-database:${CARTESI_SDK_VERSION}
         healthcheck:
             test: ["CMD-SHELL", "pg_isready -U postgres || exit 1"]
+            start_period: 10s
+            start_interval: 200ms
             interval: 10s
-            timeout: 5s
+            timeout: 1s
             retries: 5
         environment:
             - POSTGRES_PASSWORD=password

package/dist/compose/docker-compose-espresso.yaml

@@ -0,0 +1,59 @@
+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: "${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:
+        volumes:
+            - ./proxy/espresso.yaml:/etc/traefik/conf.d/espresso.yaml

package/dist/compose/docker-compose-explorer.yaml

@@ -0,0 +1,57 @@
+x-explorer_db_env: &explorer_db_env
+    DB_NAME: explorer
+    DB_PORT: 5432
+    DB_HOST: database
+    DB_PASS: password
+
+services:
+    explorer_api:
+        image: cartesi/rollups-explorer-api:1.0.0-alpha.3
+        environment:
+            <<: *explorer_db_env
+            GQL_PORT: 4350
+        expose:
+            - 4350
+        command: ["sqd", "serve:prod"]
+        healthcheck:
+            test:
+                [
+                    "CMD",
+                    "curl",
+                    "-fsS",
+                    "http://127.0.0.1:4350/graphql?query=%7B__typename%7D",
+                ]
+            start_period: 10s
+            start_interval: 200ms
+            interval: 10s
+            timeout: 1s
+            retries: 5
+        depends_on:
+            database:
+                condition: service_healthy
+
+    squid_processor:
+        image: cartesi/rollups-explorer-api:1.0.0-alpha.3
+        environment:
+            <<: *explorer_db_env
+            CHAIN_IDS: ${CARTESI_BLOCKCHAIN_ID:-13370}
+            RPC_URL_13370: ${RPC_URL:-http://anvil:8545}
+            BLOCK_CONFIRMATIONS_13370: 0
+            GENESIS_BLOCK_13370: 1
+        command: ["sqd", "process:prod"]
+        depends_on:
+            database:
+                condition: service_healthy
+
+    explorer:
+        image: cartesi/rollups-explorer:1.0.0-alpha.2
+        expose:
+            - 3000
+        depends_on:
+            database:
+                condition: service_healthy
+
+    proxy:
+        volumes:
+            - ./proxy/explorer.yaml:/etc/traefik/conf.d/explorer.yaml
+            - ./proxy/explorer-api.yaml:/etc/traefik/conf.d/explorer-api.yaml