@cartesi/cli 1.5.0 → 2.0.0-alpha.1

package/dist/exec/cartesi-machine.d.ts

@@ -0,0 +1,9 @@
+import { Range, SemVer } from "semver";
+import { DockerFallbackOptions, ExecaOptionsDockerFallback } from "./util.js";
+export declare const requiredVersion: Range;
+export declare const boot: (args: readonly string[], options: ExecaOptionsDockerFallback) => Promise<import("execa").Result<import("execa").Options & {
+    image?: string;
+    forceDocker?: false;
+}>>;
+export declare const version: (options?: DockerFallbackOptions) => Promise<SemVer | null>;
+//# sourceMappingURL=cartesi-machine.d.ts.map

package/dist/exec/cartesi-machine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cartesi-machine.d.ts","sourceRoot":"","sources":["../../src/exec/cartesi-machine.ts"],"names":[],"mappings":"AAAA,OAAO,EAAS,KAAK,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAC9C,OAAO,EACH,qBAAqB,EAErB,0BAA0B,EAC7B,MAAM,WAAW,CAAC;AAEnB,eAAO,MAAM,eAAe,OAAuB,CAAC;AAEpD,eAAO,MAAM,IAAI,SACP,SAAS,MAAM,EAAE,WACd,0BAA0B;;;GAGtC,CAAC;AAEF,eAAO,MAAM,OAAO,aACN,qBAAqB,KAChC,OAAO,CAAC,MAAM,GAAG,IAAI,CAgBvB,CAAC"}

package/dist/exec/cartesi-machine.js

@@ -0,0 +1,20 @@
+import { parse, Range } from "semver";
+import { execaDockerFallback, } from "./util.js";
+export const requiredVersion = new Range("^0.18.1");
+export const boot = async (args, options) => {
+    return execaDockerFallback("cartesi-machine", args, options);
+};
+export const version = async (options) => {
+    const { image } = options || {};
+    try {
+        const { stdout } = await execaDockerFallback("cartesi-machine", ["--version-json"], { image });
+        if (typeof stdout === "string") {
+            const output = JSON.parse(stdout);
+            return parse(output.version);
+        }
+        return null;
+    }
+    catch (e) {
+        return null;
+    }
+};

package/dist/exec/crane.d.ts

@@ -0,0 +1,15 @@
+import { Range, SemVer } from "semver";
+import { Stream } from "stream";
+import { DockerFallbackOptions } from "./util.js";
+export declare const requiredVersion: Range;
+export declare const exportImage: (options: {
+    stdin: Stream | number;
+    stdout: Stream | number;
+} & DockerFallbackOptions) => Promise<import("child_process").SpawnSyncReturns<string | Buffer> | {
+    error: {
+        code: string;
+    };
+    stdout: string;
+}>;
+export declare const version: (options?: DockerFallbackOptions) => Promise<SemVer | null>;
+//# sourceMappingURL=crane.d.ts.map

package/dist/exec/crane.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"crane.d.ts","sourceRoot":"","sources":["../../src/exec/crane.ts"],"names":[],"mappings":"AAAA,OAAO,EAAS,KAAK,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAC9C,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAChC,OAAO,EAAE,qBAAqB,EAA2B,MAAM,WAAW,CAAC;AAE3E,eAAO,MAAM,eAAe,OAAuB,CAAC;AAEpD,eAAO,MAAM,WAAW,YACX;IACL,KAAK,EAAE,MAAM,GAAG,MAAM,CAAC;IACvB,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC;CAC3B,GAAG,qBAAqB;;;;;EAO5B,CAAC;AAEF,eAAO,MAAM,OAAO,aACN,qBAAqB,KAChC,OAAO,CAAC,MAAM,GAAG,IAAI,CAMvB,CAAC"}

package/dist/exec/crane.js

@@ -0,0 +1,17 @@
+import { parse, Range } from "semver";
+import { spawnSyncDockerFallback } from "./util.js";
+export const requiredVersion = new Range("^0.19.1");
+export const exportImage = async (options) => {
+    const { image, stdin, stdout } = options;
+    return spawnSyncDockerFallback("crane", ["export", "-", "-"], {
+        image,
+        stdio: [stdin, stdout, "inherit"],
+    });
+};
+export const version = async (options) => {
+    const result = spawnSyncDockerFallback("crane", ["version"], options || {});
+    if (result.error) {
+        return null;
+    }
+    return parse(result.stdout.toString());
+};

package/dist/exec/genext2fs.d.ts

@@ -0,0 +1,28 @@
+import { Range, SemVer } from "semver";
+import { DockerFallbackOptions } from "./util.js";
+export declare const requiredVersion: Range;
+export declare const empty: (options: {
+    cwd?: string;
+    size: number;
+    output: string;
+} & DockerFallbackOptions) => Promise<void>;
+export declare const fromDirectory: (options: {
+    cwd?: string;
+    extraSize: number;
+    input: string;
+    output: string;
+} & DockerFallbackOptions) => Promise<import("execa").Result<import("execa").Options & {
+    image?: string;
+    forceDocker?: false;
+}>>;
+export declare const fromTar: (options: {
+    cwd?: string;
+    extraSize: number;
+    input: string;
+    output: string;
+} & DockerFallbackOptions) => Promise<import("execa").Result<import("execa").Options & {
+    image?: string;
+    forceDocker?: false;
+}>>;
+export declare const version: (options?: DockerFallbackOptions) => Promise<SemVer | null>;
+//# sourceMappingURL=genext2fs.d.ts.map

package/dist/exec/genext2fs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"genext2fs.d.ts","sourceRoot":"","sources":["../../src/exec/genext2fs.ts"],"names":[],"mappings":"AAAA,OAAO,EAAS,KAAK,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAC9C,OAAO,EAAE,qBAAqB,EAAuB,MAAM,WAAW,CAAC;AAIvE,eAAO,MAAM,eAAe,EAAE,KAA2B,CAAC;AAU1D,eAAO,MAAM,KAAK,YACL;IACL,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;CAClB,GAAG,qBAAqB,kBAgB5B,CAAC;AAEF,eAAO,MAAM,aAAa,YACb;IACL,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;CAClB,GAAG,qBAAqB;;;GAS5B,CAAC;AAEF,eAAO,MAAM,OAAO,YACP;IACL,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;CAClB,GAAG,qBAAqB;;;GAS5B,CAAC;AAEF,eAAO,MAAM,OAAO,aACN,qBAAqB,KAChC,OAAO,CAAC,MAAM,GAAG,IAAI,CAevB,CAAC"}

package/dist/exec/genext2fs.js

@@ -0,0 +1,44 @@
+import { parse, Range } from "semver";
+import { execaDockerFallback } from "./util.js";
+const BLOCK_SIZE = 4096; // fixed at 4k
+export const requiredVersion = new Range("^1.5.6");
+const baseArgs = (options) => [
+    "--block-size",
+    BLOCK_SIZE.toString(),
+    "--faketime",
+    "--readjustment",
+    `+${options.extraBlocks}`,
+];
+export const empty = async (options) => {
+    const { size, output } = options;
+    const blocks = Math.ceil(size / BLOCK_SIZE); // size in blocks
+    await execaDockerFallback("xgenext2fs", [
+        "--block-size",
+        BLOCK_SIZE.toString(),
+        "--faketime",
+        "--size-in-blocks",
+        blocks.toString(),
+        output,
+    ], options);
+};
+export const fromDirectory = async (options) => {
+    const { cwd, extraSize, image, input, output } = options;
+    const extraBlocks = Math.ceil(extraSize / BLOCK_SIZE);
+    return execaDockerFallback("xgenext2fs", [...baseArgs({ extraBlocks }), "--root", input, output], { cwd, image });
+};
+export const fromTar = async (options) => {
+    const { cwd, extraSize, image, input, output } = options;
+    const extraBlocks = Math.ceil(extraSize / BLOCK_SIZE);
+    return execaDockerFallback("xgenext2fs", [...baseArgs({ extraBlocks }), "--tarball", input, output], { cwd, image });
+};
+export const version = async (options) => {
+    const { stdout } = await execaDockerFallback("xgenext2fs", ["--version"], options || {});
+    if (typeof stdout === "string") {
+        const regex = /(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-((?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+([0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?/;
+        const m = stdout.match(regex);
+        if (m && m[0]) {
+            return parse(m[0]);
+        }
+    }
+    return null;
+};

package/dist/exec/index.d.ts

@@ -0,0 +1,5 @@
+export * as cartesiMachine from "./cartesi-machine.js";
+export * as crane from "./crane.js";
+export * as genext2fs from "./genext2fs.js";
+export * as mksquashfs from "./mksquashfs.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/exec/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/exec/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,cAAc,MAAM,sBAAsB,CAAC;AACvD,OAAO,KAAK,KAAK,MAAM,YAAY,CAAC;AACpC,OAAO,KAAK,SAAS,MAAM,gBAAgB,CAAC;AAC5C,OAAO,KAAK,UAAU,MAAM,iBAAiB,CAAC"}

package/dist/exec/index.js

@@ -0,0 +1,4 @@
+export * as cartesiMachine from "./cartesi-machine.js";
+export * as crane from "./crane.js";
+export * as genext2fs from "./genext2fs.js";
+export * as mksquashfs from "./mksquashfs.js";

package/dist/exec/mksquashfs.d.ts

@@ -0,0 +1,21 @@
+import { Range, SemVer } from "semver";
+import { DockerFallbackOptions } from "./util.js";
+export declare const requiredVersion: Range;
+export declare const fromDirectory: (options: {
+    cwd?: string;
+    input: string;
+    output: string;
+} & DockerFallbackOptions) => Promise<import("execa").Result<import("execa").Options & {
+    image?: string;
+    forceDocker?: false;
+}>>;
+export declare const fromTar: (options: {
+    cwd?: string;
+    input: string;
+    output: string;
+} & DockerFallbackOptions) => Promise<import("execa").Result<import("execa").Options & {
+    image?: string;
+    forceDocker?: false;
+}>>;
+export declare const version: (options?: DockerFallbackOptions) => Promise<SemVer | null>;
+//# sourceMappingURL=mksquashfs.d.ts.map

package/dist/exec/mksquashfs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mksquashfs.d.ts","sourceRoot":"","sources":["../../src/exec/mksquashfs.ts"],"names":[],"mappings":"AAAA,OAAO,EAAS,KAAK,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAC9C,OAAO,EAAE,qBAAqB,EAAuB,MAAM,WAAW,CAAC;AAIvE,eAAO,MAAM,eAAe,EAAE,KAA2B,CAAC;AAY1D,eAAO,MAAM,aAAa,YACb;IACL,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;CAClB,GAAG,qBAAqB;;;GAO5B,CAAC;AAEF,eAAO,MAAM,OAAO,YACP;IACL,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;CAClB,GAAG,qBAAqB;;;GAY5B,CAAC;AAEF,eAAO,MAAM,OAAO,aACN,qBAAqB,KAChC,OAAO,CAAC,MAAM,GAAG,IAAI,CAoBvB,CAAC"}

package/dist/exec/mksquashfs.js

@@ -0,0 +1,45 @@
+import { parse, Range } from "semver";
+import { execaDockerFallback } from "./util.js";
+const COMPRESSION = "lzo"; // make customizable? default is gzip
+export const requiredVersion = new Range("^4.5.1");
+const baseArgs = () => [
+    "-all-time",
+    "0",
+    "-all-root", // XXX: should we use this?
+    "-noappend",
+    "-comp",
+    COMPRESSION,
+    "-no-progress",
+];
+export const fromDirectory = (options) => {
+    const { cwd, image, input, output } = options;
+    return execaDockerFallback("mksquashfs", [input, output, ...baseArgs()], {
+        cwd,
+        image,
+    });
+};
+export const fromTar = (options) => {
+    const { cwd, image, input, output } = options;
+    return execaDockerFallback("mksquashfs", ["-", output, "-tar", ...baseArgs()], {
+        cwd,
+        image,
+        inputFile: input, // use stdin in case of tar file
+    });
+};
+export const version = async (options) => {
+    try {
+        const { stdout } = await execaDockerFallback("mksquashfs", ["-version"], options || {});
+        if (typeof stdout === "string") {
+            const regex = /(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-((?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+([0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?/gm;
+            const m = stdout.match(regex);
+            if (m && m[0]) {
+                return parse(m[0]);
+            }
+        }
+    }
+    catch (e) {
+        console.error(e);
+        return null;
+    }
+    return null;
+};

package/dist/exec/util.d.ts

@@ -0,0 +1,36 @@
+import { SpawnSyncOptions } from "child_process";
+import { Options } from "execa";
+export type DockerFallbackOptions = {
+    image: string;
+    forceDocker: true;
+} | {
+    image?: string;
+    forceDocker?: false;
+};
+/**
+ * Calls execa and falls back to docker run if command (on the host) fails
+ * @param command command to be executed
+ * @param args arguments to be passed to the command
+ * @param options execution options
+ * @returns return of execa
+ */
+export type ExecaOptionsDockerFallback = Options & DockerFallbackOptions;
+export declare const execaDockerFallback: (command: string, args: readonly string[], options: ExecaOptionsDockerFallback) => Promise<import("execa").Result<Options & {
+    image?: string;
+    forceDocker?: false;
+}>>;
+/**
+ * Calls spawnSync and falls back to docker run if command (on the host) fails
+ * @param command command to be executed
+ * @param args arguments to be passed to the command
+ * @param options execution options
+ * @returns return of execa
+ */
+export type SpawnOptionsDockerFallback = SpawnSyncOptions & DockerFallbackOptions;
+export declare const spawnSyncDockerFallback: (command: string, args: readonly string[], options: SpawnOptionsDockerFallback) => import("child_process").SpawnSyncReturns<string | Buffer> | {
+    error: {
+        code: string;
+    };
+    stdout: string;
+};
+//# sourceMappingURL=util.d.ts.map

package/dist/exec/util.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"util.d.ts","sourceRoot":"","sources":["../../src/exec/util.ts"],"names":[],"mappings":"AAAA,OAAO,EAAa,gBAAgB,EAAE,MAAM,eAAe,CAAC;AAC5D,OAAO,EAAqB,OAAO,EAAE,MAAM,OAAO,CAAC;AAGnD,MAAM,MAAM,qBAAqB,GAC3B;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,IAAI,CAAA;CAAE,GACpC;IAAE,KAAK,CAAC,EAAE,MAAM,CAAC;IAAC,WAAW,CAAC,EAAE,KAAK,CAAA;CAAE,CAAC;AAE9C;;;;;;GAMG;AACH,MAAM,MAAM,0BAA0B,GAAG,OAAO,GAAG,qBAAqB,CAAC;AACzE,eAAO,MAAM,mBAAmB,YACnB,MAAM,QACT,SAAS,MAAM,EAAE,WACd,0BAA0B;YAbvB,MAAM;kBAAgB,KAAK;GAmD1C,CAAC;AAEF;;;;;;GAMG;AACH,MAAM,MAAM,0BAA0B,GAAG,gBAAgB,GACrD,qBAAqB,CAAC;AAC1B,eAAO,MAAM,uBAAuB,YACvB,MAAM,QACT,SAAS,MAAM,EAAE,WACd,0BAA0B;;;;;CA6CtC,CAAC"}

package/dist/exec/util.js

@@ -0,0 +1,78 @@
+import { spawnSync } from "child_process";
+import { execa, ExecaError } from "execa";
+import os from "os";
+export const execaDockerFallback = async (command, args, options) => {
+    try {
+        if (options.forceDocker) {
+            const error = new ExecaError();
+            error.code = "ENOENT";
+            throw error;
+        }
+        return await execa(command, args, options);
+    }
+    catch (error) {
+        if (error instanceof ExecaError) {
+            if (error.code === "ENOENT" && options.image) {
+                if (!options.forceDocker) {
+                    console.warn(`error executing '${command}', falling back to docker execution using image '${options.image}'`);
+                }
+                const userInfo = os.userInfo();
+                const dockerOpts = [
+                    "--volume",
+                    `${options.cwd}:/work`,
+                    "--workdir",
+                    "/work",
+                    "--interactive",
+                    "--user",
+                    `${userInfo.uid}:${userInfo.gid}`,
+                ];
+                return await execa("docker", ["run", ...dockerOpts, options.image, command, ...args], options);
+            }
+            else {
+                console.error(`error executing '${command}'`, error);
+            }
+        }
+        throw error;
+    }
+};
+export const spawnSyncDockerFallback = (command, args, options) => {
+    const result = options.forceDocker
+        ? { error: { code: "ENOENT" }, stdout: "" }
+        : spawnSync(command, args, options);
+    if (result.error) {
+        const code = result.error.code;
+        if (code === "ENOENT" && options.image) {
+            if (!options.forceDocker) {
+                console.warn(`error executing '${command}', falling back to docker execution using image '${options.image}'`);
+            }
+            const userInfo = os.userInfo();
+            const dockerOpts = [
+                "--volume",
+                `${options.cwd}:/work`,
+                "--workdir",
+                "/work",
+                "--interactive",
+                "--user",
+                `${userInfo.uid}:${userInfo.gid}`,
+            ];
+            const dockerArgs = [
+                "run",
+                ...dockerOpts,
+                options.image,
+                command,
+                ...args,
+            ];
+            const dockerResult = spawnSync("docker", dockerArgs, options);
+            if (dockerResult.error) {
+                console.error(`error executing '${command}'`, dockerResult.error);
+                throw dockerResult.error;
+            }
+            return dockerResult;
+        }
+        else {
+            console.error(`error executing '${command}'`, result.error);
+            throw result.error;
+        }
+    }
+    return result;
+};

package/dist/machine.d.ts

@@ -0,0 +1,6 @@
+import { Config, ImageInfo } from "./config.js";
+export declare const bootMachine: (config: Config, info: ImageInfo | undefined, destination: string) => Promise<import("execa").Result<import("execa").Options & {
+    image?: string;
+    forceDocker?: false;
+}>>;
+//# sourceMappingURL=machine.d.ts.map

package/dist/machine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"machine.d.ts","sourceRoot":"","sources":["../src/machine.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAe,SAAS,EAAE,MAAM,aAAa,CAAC;AAoB7D,eAAO,MAAM,WAAW,WACZ,MAAM,QACR,SAAS,GAAG,SAAS,eACd,MAAM;;;GAwFtB,CAAC"}

package/dist/machine.js

@@ -0,0 +1,80 @@
+import { cartesiMachine } from "./exec/index.js";
+const flashDrive = (label, drive) => {
+    const { format, mount, shared, user } = drive;
+    const filename = `${label}.${format}`;
+    const vars = [`label:${label}`, `filename:${filename}`];
+    if (mount !== undefined) {
+        vars.push(`mount:${mount}`);
+    }
+    if (user) {
+        vars.push(`user:${user}`);
+    }
+    if (shared) {
+        vars.push("shared");
+    }
+    // don't specify start and length
+    return `--flash-drive=${vars.join(",")}`;
+};
+export const bootMachine = async (config, info, destination) => {
+    const { machine } = config;
+    const { assertRollingTemplate, finalHash, interactive, maxMCycle, noRollup, ramLength, ramImage, store, user, } = machine;
+    // list of environment variables of docker image
+    const env = info?.env ?? [];
+    const envs = env.map((variable) => `--env=${variable}`);
+    // check if we need a rootfstype boot arg
+    const root = config.drives.root;
+    if (root?.format === "sqfs") {
+        const definedRootfsType = config.machine.bootargs.find((arg) => arg.startsWith("rootfstype="));
+        // not checking here if user intentionally defined wrong type
+        if (!definedRootfsType) {
+            config.machine.bootargs.push("rootfstype=squashfs");
+        }
+    }
+    // bootargs from config string array
+    const bootargs = machine.bootargs.map((arg) => `--append-bootargs="${arg}"`);
+    // entrypoint from config or image info (Docker ENTRYPOINT + CMD)
+    const entrypoint = machine.entrypoint ?? // takes priority
+        (info ? [...info.entrypoint, ...info.cmd].join(" ") : undefined); // ENTRYPOINT and CMD as a space separated string
+    if (!entrypoint) {
+        throw new Error("Undefined machine entrypoint");
+    }
+    const flashDrives = Object.entries(config.drives).map(([label, drive]) => flashDrive(label, drive));
+    // command to change working directory if WORKDIR is defined
+    const args = [
+        ...bootargs,
+        ...envs,
+        ...flashDrives,
+        `--ram-image=${ramImage}`,
+        `--ram-length=${ramLength}`,
+        `--append-entrypoint=${entrypoint}`,
+    ];
+    if (assertRollingTemplate) {
+        args.push("--assert-rolling-template");
+    }
+    if (finalHash) {
+        args.push("--final-hash");
+    }
+    if (info?.workdir) {
+        args.push(`--workdir="${info.workdir}"`);
+    }
+    if (interactive) {
+        args.push("-it");
+    }
+    if (noRollup) {
+        args.push("--no-rollup");
+    }
+    if (maxMCycle) {
+        args.push(`--max-mcycle=${maxMCycle.toString()}`);
+    }
+    if (store) {
+        args.push(`--store=${store}`);
+    }
+    if (user) {
+        args.push(`--user=${user}`);
+    }
+    return cartesiMachine.boot(args, {
+        cwd: destination,
+        image: config.sdk,
+        stdio: "inherit",
+    });
+};

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

@@ -1,6 +1,6 @@
 services:
     anvil:
-        image: cartesi/sdk:0.10.0
+        image: cartesi/sdk:0.12.0-alpha.0
         command:
             [
                 "devnet",
@@ -19,7 +19,7 @@ services:
             - 8545:8545
 
     dapp_deployer:
-        image: cartesi/sdk:0.10.0
+        image: cartesi/sdk:0.12.0-alpha.0
         restart: on-failure
         depends_on:
             anvil:
@@ -32,9 +32,10 @@ services:
                 "http://anvil:8545",
                 "--private-key",
                 "0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80",
-                "0x9E32e06Fd23675b2DF8eA8e6b0A25c3DF6a60AbC",
+                "0x4C11C7F82D6D56a726f9B53dd99af031AFd86BB6",
                 "deployContracts(address,address,bytes32,bytes32)",
                 "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266",
+                "720",
                 "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266",
                 "0x0000000000000000000000000000000000000000000000000000000000000000",
                 "0x0000000000000000000000000000000000000000000000000000000000000000",

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

@@ -1,6 +1,6 @@
 services:
     alto:
-        image: cartesi/sdk:0.10.0
+        image: cartesi/sdk:0.12.0-alpha.0
         command:
             - "alto"
             - "--entrypoints"

package/dist/node/docker-compose-paymaster.yaml

@@ -1,6 +1,6 @@
 services:
     mock-verifying-paymaster:
-        image: cartesi/sdk:0.10.0
+        image: cartesi/sdk:0.12.0-alpha.0
         command: "mock-verifying-paymaster"
         environment:
             - ALTO_RPC=http://alto:4337