@latticexyz/cli 0.9.0

package/dist/commands/call-system.js

@@ -0,0 +1,57 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handler = exports.builder = exports.desc = exports.command = void 0;
+const utils_1 = require("ethers/lib/utils");
+const utils_2 = require("../utils");
+exports.command = "call-system";
+exports.desc = "Execute a mud system";
+const builder = (yargs) => yargs.options({
+    rpc: { type: "string", description: "json rpc endpoint, defaults to http://localhost:8545" },
+    caller: { type: "string", description: "caller address" },
+    world: { type: "string", required: true, description: "world contract address" },
+    systemId: { type: "string", description: "system id preimage (eg mud.system.Move)" },
+    systemAddress: { type: "string", description: "system address (alternative to system id)" },
+    argTypes: { type: "array", description: "system argument types for abi encoding" },
+    args: { type: "array", description: "system arguments" },
+    calldata: { type: "string", description: "abi encoded system arguments (instead of args/argTypes)" },
+    broadcast: { type: "boolean", description: "send txs to the chain" },
+    callerPrivateKey: {
+        type: "string",
+        description: "must be set if broadcast is set, must correspond to caller address",
+    },
+    debug: { type: "boolean", description: "open debugger" },
+});
+exports.builder = builder;
+const handler = (argv) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a;
+    const { rpc, caller, world, systemId, argTypes, args, calldata, broadcast, callerPrivateKey, debug } = argv;
+    const encodedArgs = (_a = calldata !== null && calldata !== void 0 ? calldata : (argTypes && args && utils_1.defaultAbiCoder.encode(argTypes, args))) !== null && _a !== void 0 ? _a : "";
+    yield (0, utils_2.execLog)("forge", [
+        "script",
+        "--fork-url",
+        rpc !== null && rpc !== void 0 ? rpc : "http://localhost:8545",
+        "--sig",
+        "debug(address,address,string,bytes,bool)",
+        "src/test/utils/Debug.sol",
+        caller !== null && caller !== void 0 ? caller : "0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266",
+        world,
+        systemId || "",
+        encodedArgs,
+        broadcast ? "true" : "false",
+        "-vvvvv",
+        broadcast ? "--broadcast" : "",
+        callerPrivateKey ? `--private-key ${callerPrivateKey}` : "",
+        debug ? "--debug" : "",
+    ]);
+    process.exit(0);
+});
+exports.handler = handler;

package/dist/commands/create.js

@@ -0,0 +1,47 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handler = exports.builder = exports.desc = exports.command = void 0;
+const utils_1 = require("../utils");
+exports.command = "create <name>";
+exports.desc = "Sets up a fresh mud project into <name>. Requires yarn.";
+const builder = (yargs) => yargs.positional("name", { type: "string", demandOption: true });
+exports.builder = builder;
+const handler = (argv) => __awaiter(void 0, void 0, void 0, function* () {
+    const { name } = argv;
+    console.log("Creating new mud project in", name);
+    console.log("Cloning...");
+    yield (0, utils_1.exec)(`git clone https://github.com/latticexyz/mud _mudtemp`);
+    console.log("Moving...");
+    yield (0, utils_1.exec)(`cp -r _mudtemp/packages/ri ${name}`);
+    console.log("Setting up vscode solidity settings...");
+    yield (0, utils_1.exec)(`cp -r _mudtemp/.vscode ${name}/.vscode`);
+    console.log("Cleaning up...");
+    yield (0, utils_1.exec)(`rm -rf _mudtemp`);
+    console.log("Setting up package.json...");
+    yield (0, utils_1.exec)(`mv ${name}/packagejson.template ${name}/package.json`);
+    console.log("Installing dependencies using yarn...");
+    yield (0, utils_1.exec)(`cd ${name} && yarn install`);
+    console.log("Setting up foundry.toml...");
+    yield (0, utils_1.exec)(`rm ${name}/contracts/foundry.toml`);
+    yield (0, utils_1.exec)(`mv ${name}/contracts/foundrytoml.template ${name}/contracts/foundry.toml`);
+    console.log("Setting up remappings...");
+    yield (0, utils_1.exec)(`rm ${name}/contracts/remappings.txt`);
+    yield (0, utils_1.exec)(`mv ${name}/contracts/remappingstxt.template ${name}/contracts/remappings.txt`);
+    console.log("Setting up compile task...");
+    yield (0, utils_1.exec)(`rm ${name}/contracts/tasks/compile.ts`);
+    yield (0, utils_1.exec)(`mv ${name}/contracts/tasks/compilets.template ${name}/contracts/tasks/compile.ts`);
+    console.log("Building contracts...");
+    yield (0, utils_1.exec)(`cd ${name}/contracts && yarn build`);
+    console.log("Done setting up! Run `yarn start` to start client and chain, then head to localhost:3000 to explore.");
+    process.exit(0);
+});
+exports.handler = handler;

package/dist/commands/deploy.js

@@ -0,0 +1,442 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deploy = exports.handler = exports.builder = exports.desc = exports.command = void 0;
+/* eslint-disable @typescript-eslint/no-non-null-assertion */
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const ethers_1 = require("ethers");
+const inquirer_1 = __importDefault(require("inquirer"));
+const uuid_1 = require("uuid");
+const listr2_1 = require("listr2");
+const process_1 = require("process");
+const fs_1 = __importDefault(require("fs"));
+const openurl_1 = __importDefault(require("openurl"));
+const inquirer_prompt_suggest_1 = __importDefault(require("inquirer-prompt-suggest"));
+inquirer_1.default.registerPrompt("suggest", inquirer_prompt_suggest_1.default);
+// Workaround to prevent tsc to transpile dynamic imports with require, which causes an error upstream
+// https://github.com/microsoft/TypeScript/issues/43329#issuecomment-922544562
+const importNetlify = eval('import("netlify")');
+const importChalk = eval('import("chalk")');
+const importExeca = eval('import("execa")');
+const importFetch = eval('import("node-fetch")');
+exports.command = "deploy";
+exports.desc = "Deploys the local mud contracts and optionally the client";
+const builder = (yargs) => yargs.options({
+    i: { type: "boolean" },
+    chainSpec: { type: "string" },
+    chainId: { type: "number" },
+    rpc: { type: "string" },
+    wsRpc: { type: "string" },
+    world: { type: "string" },
+    reuseComponents: { type: "boolean" },
+    deployerPrivateKey: { type: "string" },
+    deployClient: { type: "boolean" },
+    clientUrl: { type: "string" },
+    netlifySlug: { type: "string" },
+    netlifyPersonalToken: { type: "string" },
+    upgradeSystems: { type: "boolean" },
+    codespace: { type: "boolean" },
+    dry: { type: "boolean" },
+});
+exports.builder = builder;
+const handler = (args) => __awaiter(void 0, void 0, void 0, function* () {
+    const info = yield getDeployInfo(args);
+    yield (0, exports.deploy)(info);
+});
+exports.handler = handler;
+function isValidHttpUrl(s) {
+    let url;
+    try {
+        url = new URL(s);
+    }
+    catch (_) {
+        return false;
+    }
+    return url.protocol === "http:" || url.protocol === "https:";
+}
+function findLog(deployLogLines, log) {
+    for (const logLine of deployLogLines) {
+        if (logLine.includes(log)) {
+            return logLine.split(log)[1].trim();
+        }
+    }
+    throw new Error("Can not find log");
+}
+const getDeployInfo = (args) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12;
+    const { default: chalk } = yield importChalk;
+    console.log();
+    console.log(chalk.bgWhite.black.bold(" == Mud Deployer == "));
+    console.log();
+    let config = {};
+    try {
+        config = JSON.parse(fs_1.default.readFileSync("mud.config.json", "utf8"));
+    }
+    catch (e) {
+        console.log("No mud.config.json found, using command line args");
+    }
+    const getNetlifyAccounts = (token) => __awaiter(void 0, void 0, void 0, function* () {
+        const { NetlifyAPI: netlify } = yield importNetlify;
+        const netlifyAPI = new netlify(token);
+        console.log("Netlify api");
+        const accounts = yield netlifyAPI.listAccountsForUser();
+        console.log("Accounts");
+        return accounts.map((a) => a.slug);
+    });
+    const defaultOptions = {
+        chainSpec: "chainSpec.json",
+        chainId: 31337,
+        rpc: "http://localhost:8545",
+        wsRpc: "ws://localhost:8545",
+        reuseComponents: false,
+        deployClient: false,
+        clientUrl: "http://localhost:3000",
+        upgradeSystems: false,
+    };
+    const { default: fetch } = yield importFetch;
+    // Fetch deployed lattice chains
+    const latticeChains = args.i
+        ? (yield (yield fetch("https://registry.lattice.xyz/api?update=true")).json())
+        : [];
+    const chainSpecs = (latticeChains === null || latticeChains === void 0 ? void 0 : latticeChains.map((e) => e.specUrl)) || [];
+    console.log("Available Lattice chains");
+    console.log(JSON.stringify(latticeChains, null, 2));
+    const answers = args.upgradeSystems && !args.world
+        ? yield inquirer_1.default.prompt([
+            {
+                type: "input",
+                name: "world",
+                message: "Provide the address of the World contract to upgrade the systems on.",
+                when: () => args.world == null && config.world == null,
+                validate: (i) => {
+                    if (!i || (i[0] == "0" && i[1] == "x" && i.length === 42))
+                        return true;
+                    return "Invalid address";
+                },
+            },
+        ])
+        : args.i
+            ? yield inquirer_1.default.prompt([
+                {
+                    type: "suggest",
+                    name: "chainSpec",
+                    message: "Provide a chainSpec.json location (local or remote)",
+                    suggestions: chainSpecs,
+                    when: () => args.chainSpec == null && config.chainSpec == null,
+                },
+                {
+                    type: "number",
+                    name: "chainId",
+                    default: defaultOptions.chainId,
+                    message: "Provide a chainId for the deployment",
+                    when: (answers) => answers.chainSpec == null && args.chainId == null && config.chainSpec == null,
+                },
+                {
+                    type: "input",
+                    name: "wsRpc",
+                    default: defaultOptions.wsRpc,
+                    message: "Provide a WebSocket RPC endpoint for your deployment",
+                    when: (answers) => answers.chainSpec == null && args.wsRpc == null && config.wsRpc == null,
+                },
+                {
+                    type: "input",
+                    name: "rpc",
+                    default: defaultOptions.rpc,
+                    message: "Provide a JSON RPC endpoint for your deployment",
+                    when: (answers) => answers.chainSpec == null && args.rpc == null && config.rpc == null,
+                    validate: (i) => {
+                        if (isValidHttpUrl(i))
+                            return true;
+                        return "Invalid URL";
+                    },
+                },
+                {
+                    type: "input",
+                    name: "world",
+                    message: "Provide the address of an existing World contract. (If none is given, a new World will be deployed.)",
+                    when: () => args.world == null && config.world == null,
+                    validate: (i) => {
+                        if (!i || (i[0] == "0" && i[1] == "x" && i.length === 42))
+                            return true;
+                        return "Invalid address";
+                    },
+                },
+                {
+                    type: "list",
+                    name: "upgradeSystems",
+                    message: "Only upgrade systems?",
+                    choices: [
+                        { name: "Yes", value: true },
+                        { name: "No", value: false },
+                    ],
+                    default: defaultOptions.upgradeSystems,
+                    when: (answers) => (args.world || config.world || answers.world) &&
+                        args.upgradeSystems == null &&
+                        config.upgradeSystems == null,
+                },
+                {
+                    type: "list",
+                    name: "reuseComponents",
+                    message: "Reuse existing components?",
+                    choices: [
+                        { name: "Yes", value: true },
+                        { name: "No", value: false },
+                    ],
+                    default: defaultOptions.reuseComponents,
+                    when: (answers) => !answers.upgradeSystems &&
+                        !args.upgradeSystems &&
+                        !config.upgradeSystems &&
+                        args.reuseComponents == null &&
+                        config.reuseComponents == null,
+                },
+                {
+                    type: "input",
+                    name: "deployerPrivateKey",
+                    message: "Enter private key of the deployer account:",
+                    when: () => !args.deployerPrivateKey && !config.deployerPrivateKey,
+                    validate: (i) => {
+                        if (i[0] == "0" && i[1] == "x" && i.length === 66)
+                            return true;
+                        return "Invalid private key";
+                    },
+                },
+                {
+                    type: "list",
+                    message: "Deploy the client?",
+                    choices: [
+                        { name: "Yes", value: true },
+                        { name: "No", value: false },
+                    ],
+                    default: defaultOptions.deployClient,
+                    name: "deployClient",
+                    when: () => args.deployClient == null && config.deployClient == null,
+                },
+                {
+                    type: "input",
+                    name: "netlifyPersonalToken",
+                    message: "Enter a netlify personal token for deploying the client:",
+                    when: (answers) => answers.deployClient && !args.netlifyPersonalToken && !config.netlifyPersonalToken,
+                },
+                {
+                    type: "list",
+                    message: "From which netlify account?",
+                    choices: (answers) => __awaiter(void 0, void 0, void 0, function* () {
+                        var _13, _14;
+                        return yield getNetlifyAccounts((_14 = (_13 = args.netlifyPersonalToken) !== null && _13 !== void 0 ? _13 : config.netlifyPersonalToken) !== null && _14 !== void 0 ? _14 : answers.netlifyPersonalToken);
+                    }),
+                    name: "netlifySlug",
+                    when: (answers) => answers.deployClient && !args.netlifySlug && !config.netlifySlug,
+                },
+                {
+                    type: "input",
+                    name: "clientUrl",
+                    message: "Enter URL of an already deployed client:",
+                    when: (answers) => !answers.deployClient && !args.clientUrl && !config.clientUrl,
+                    default: "http://localhost:3000",
+                    validate: (i) => {
+                        if (isValidHttpUrl(i)) {
+                            if (i[i.length - 1] === "/") {
+                                return "No trailing slash";
+                            }
+                            return true;
+                        }
+                        else {
+                            return "Not a valid URL";
+                        }
+                    },
+                },
+            ])
+            : {};
+    const chainSpecUrl = (_b = (_a = args.chainSpec) !== null && _a !== void 0 ? _a : config.chainSpec) !== null && _b !== void 0 ? _b : answers.chainSpec;
+    const chainSpec = !chainSpecUrl
+        ? null
+        : isValidHttpUrl(chainSpecUrl)
+            ? yield (yield fetch(chainSpecUrl)).json()
+            : JSON.parse(fs_1.default.readFileSync(chainSpecUrl, "utf8"));
+    // Priority of config source: command line args >> chainSpec >> local config >> interactive answers >> defaults
+    // -> Command line args can override every other config, interactive questions are only asked if no other config given for this option
+    return {
+        chainSpec: (_e = (_d = (_c = args.chainSpec) !== null && _c !== void 0 ? _c : config.chainSpec) !== null && _d !== void 0 ? _d : answers.chainSpec) !== null && _e !== void 0 ? _e : defaultOptions.chainSpec,
+        chainId: (_j = (_h = (_g = (_f = args.chainId) !== null && _f !== void 0 ? _f : chainSpec === null || chainSpec === void 0 ? void 0 : chainSpec.chainId) !== null && _g !== void 0 ? _g : config.chainId) !== null && _h !== void 0 ? _h : answers.chainId) !== null && _j !== void 0 ? _j : defaultOptions.chainId,
+        rpc: (_o = (_m = (_l = (_k = args.rpc) !== null && _k !== void 0 ? _k : chainSpec === null || chainSpec === void 0 ? void 0 : chainSpec.rpc) !== null && _l !== void 0 ? _l : config.rpc) !== null && _m !== void 0 ? _m : answers.rpc) !== null && _o !== void 0 ? _o : defaultOptions.rpc,
+        wsRpc: (_s = (_r = (_q = (_p = args.wsRpc) !== null && _p !== void 0 ? _p : chainSpec === null || chainSpec === void 0 ? void 0 : chainSpec.wsRpc) !== null && _q !== void 0 ? _q : config.wsRpc) !== null && _r !== void 0 ? _r : answers.wsRpc) !== null && _s !== void 0 ? _s : defaultOptions.wsRpc,
+        world: (_v = (_u = (_t = args.world) !== null && _t !== void 0 ? _t : chainSpec === null || chainSpec === void 0 ? void 0 : chainSpec.world) !== null && _u !== void 0 ? _u : config.world) !== null && _v !== void 0 ? _v : answers.world,
+        upgradeSystems: (_x = (_w = args.upgradeSystems) !== null && _w !== void 0 ? _w : config.upgradeSystems) !== null && _x !== void 0 ? _x : answers.upgradeSystems,
+        reuseComponents: (_0 = (_z = (_y = args.reuseComponents) !== null && _y !== void 0 ? _y : config.reuseComponents) !== null && _z !== void 0 ? _z : answers.reuseComponents) !== null && _0 !== void 0 ? _0 : defaultOptions.reuseComponents,
+        deployerPrivateKey: (_2 = (_1 = args.deployerPrivateKey) !== null && _1 !== void 0 ? _1 : config.deployerPrivateKey) !== null && _2 !== void 0 ? _2 : answers.deployerPrivateKey,
+        deployClient: (_5 = (_4 = (_3 = args.deployClient) !== null && _3 !== void 0 ? _3 : config.deployClient) !== null && _4 !== void 0 ? _4 : answers.deployClient) !== null && _5 !== void 0 ? _5 : defaultOptions.deployClient,
+        clientUrl: (_8 = (_7 = (_6 = args.clientUrl) !== null && _6 !== void 0 ? _6 : config.clientUrl) !== null && _7 !== void 0 ? _7 : answers.clientUrl) !== null && _8 !== void 0 ? _8 : defaultOptions.clientUrl,
+        netlifySlug: (_10 = (_9 = args.netlifySlug) !== null && _9 !== void 0 ? _9 : config.netlifySlug) !== null && _10 !== void 0 ? _10 : answers.netlifySlug,
+        netlifyPersonalToken: (_12 = (_11 = args.netlifyPersonalToken) !== null && _11 !== void 0 ? _11 : config.netlifyPersonalToken) !== null && _12 !== void 0 ? _12 : answers.netlifyPersonalToken,
+        codespace: args.codespace,
+        dry: args.dry,
+    };
+});
+const deploy = (options) => __awaiter(void 0, void 0, void 0, function* () {
+    const { default: chalk } = yield importChalk;
+    const { execa } = yield importExeca;
+    console.log();
+    console.log(chalk.yellow(`>> Deploying contracts <<`));
+    console.log("Options");
+    console.log(options);
+    const wallet = new ethers_1.ethers.Wallet(options.deployerPrivateKey);
+    console.log(chalk.red(`>> Deployer address: ${chalk.bgYellow.black.bold(" " + wallet.address + " ")} <<`));
+    console.log();
+    const logger = new listr2_1.Logger({ useIcons: true });
+    const { NetlifyAPI: netlify } = yield importNetlify;
+    const netlifyAPI = options.deployClient && new netlify(options.netlifyPersonalToken);
+    const id = (0, uuid_1.v4)().substring(0, 6);
+    let launcherUrl;
+    let worldAddress;
+    const cmdArgs = options.upgradeSystems
+        ? [
+            "workspace",
+            "ri-contracts",
+            "forge:deploy",
+            ...(options.dry ? [] : ["--broadcast", "--private-keys", wallet.privateKey]),
+            "--sig",
+            "upgradeSystems(address,address)",
+            wallet.address,
+            options.world || ethers_1.constants.AddressZero,
+            "--fork-url",
+            options.rpc,
+        ]
+        : [
+            "workspace",
+            "ri-contracts",
+            "forge:deploy",
+            ...(options.dry ? [] : ["--broadcast", "--private-keys", wallet.privateKey]),
+            "--sig",
+            "deploy(address,address,bool)",
+            wallet.address,
+            options.world || ethers_1.constants.AddressZero,
+            options.reuseComponents ? "true" : "false",
+            "--fork-url",
+            options.rpc,
+        ];
+    try {
+        const tasks = new listr2_1.Listr([
+            {
+                title: "Deploying",
+                task: () => {
+                    return new listr2_1.Listr([
+                        {
+                            title: "Contracts",
+                            task: (ctx, task) => __awaiter(void 0, void 0, void 0, function* () {
+                                var _a;
+                                const child = execa("yarn", cmdArgs);
+                                (_a = child.stdout) === null || _a === void 0 ? void 0 : _a.pipe(task.stdout());
+                                const { stdout } = yield child;
+                                const lines = stdout.split("\n");
+                                ctx.worldAddress = worldAddress = findLog(lines, "world: address");
+                                ctx.initialBlockNumber = findLog(lines, "initialBlockNumber: uint256");
+                                task.output = chalk.yellow(`World deployed at: ${chalk.bgYellow.black(ctx.worldAddress)}`);
+                            }),
+                            options: { bottomBar: 3 },
+                        },
+                        {
+                            title: "Client",
+                            task: () => {
+                                return new listr2_1.Listr([
+                                    {
+                                        title: "Building",
+                                        task: (_, task) => __awaiter(void 0, void 0, void 0, function* () {
+                                            const time = Date.now();
+                                            task.output = "Building local client...";
+                                            const child = execa("yarn", ["workspace", "ri-client", "build"]);
+                                            yield child;
+                                            const duration = Date.now() - time;
+                                            task.output = "Client built in " + Math.round(duration / 1000) + "s";
+                                        }),
+                                        skip: () => !options.deployClient,
+                                        options: { bottomBar: 3 },
+                                    },
+                                    {
+                                        title: "Creating",
+                                        task: (ctx, task) => __awaiter(void 0, void 0, void 0, function* () {
+                                            const site = yield netlifyAPI.createSite({
+                                                body: {
+                                                    name: `mud-deployment-${wallet.address.substring(2, 8)}-${id}`,
+                                                    account_slug: options.netlifySlug,
+                                                    ssl: true,
+                                                    force_ssl: true,
+                                                },
+                                            });
+                                            ctx.siteId = site.id;
+                                            ctx.clientUrl = site.ssl_url;
+                                            task.output = "Netlify site created with id: " + chalk.bgYellow.black(site.id);
+                                        }),
+                                        skip: () => !options.deployClient,
+                                        options: { bottomBar: 1 },
+                                    },
+                                    {
+                                        title: "Deploying",
+                                        task: (ctx, task) => __awaiter(void 0, void 0, void 0, function* () {
+                                            var _a;
+                                            const child = execa("yarn", ["workspace", "ri-client", "run", "netlify", "deploy", "--prod", "--dir", "dist"], {
+                                                env: {
+                                                    NETLIFY_AUTH_TOKEN: options.netlifyPersonalToken,
+                                                    NETLIFY_SITE_ID: ctx.siteId,
+                                                },
+                                            });
+                                            (_a = child.stdout) === null || _a === void 0 ? void 0 : _a.pipe(task.stdout());
+                                            yield child;
+                                            task.output = chalk.yellow("Netlify site deployed!");
+                                        }),
+                                        skip: () => !options.deployClient,
+                                        options: { bottomBar: 3 },
+                                    },
+                                ], { concurrent: false });
+                            },
+                        },
+                        {
+                            title: "Open Launcher",
+                            task: (ctx) => __awaiter(void 0, void 0, void 0, function* () {
+                                function getCodespaceUrl(port, protocol = "https") {
+                                    return `${protocol}://${process.env["CODESPACE_NAME"]}-${port}.app.online.visualstudio.com`;
+                                }
+                                let clientUrl = options.deployClient ? ctx.clientUrl : options.clientUrl;
+                                if (options.codespace) {
+                                    clientUrl = getCodespaceUrl(3000);
+                                    options.rpc = getCodespaceUrl(8545);
+                                }
+                                launcherUrl = `${clientUrl}?chainId=${options.chainId}&worldAddress=${ctx.worldAddress}&rpc=${options.rpc}&wsRpc=${options.wsRpc}&checkpoint=&initialBlockNumber=${ctx.initialBlockNumber}&dev=true`;
+                                // Launcher version:
+                                // `https://play.lattice.xyz?worldAddress=${ctx.worldAddress || ""}&client=${
+                                //   clientUrl || ""
+                                // }&rpc=${options.rpc || ""}&wsRpc=${options.wsRpc || ""}&chainId=${options.chainId || ""}&dev=${
+                                //   options.chainId === 31337 || ""
+                                // }&initialBlockNumber=${ctx.initialBlockNumber}`;
+                                if (!options.upgradeSystems)
+                                    openurl_1.default.open(launcherUrl);
+                            }),
+                            options: { bottomBar: 3 },
+                        },
+                    ], { concurrent: false });
+                },
+            },
+        ]);
+        yield tasks.run();
+        console.log(chalk.bgGreen.black.bold(" Congratulations! Deployment successful"));
+        console.log();
+        console.log(chalk.green(`World address ${worldAddress}`));
+        console.log(chalk.green(`Open launcher at ${launcherUrl}`));
+        console.log();
+    }
+    catch (e) {
+        logger.fail(e.message);
+    }
+    (0, process_1.exit)(0);
+});
+exports.deploy = deploy;

package/dist/commands/diamond-abi.js

@@ -0,0 +1,56 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handler = exports.builder = exports.desc = exports.command = void 0;
+const fs_1 = __importDefault(require("fs"));
+const glob_1 = __importDefault(require("glob"));
+const utils_1 = require("../utils");
+exports.command = "diamond-abi";
+exports.desc = "Merges the abis of different facets of a diamond to a single diamond abi";
+const builder = (yargs) => yargs.options({
+    include: { type: "array" },
+    exclude: { type: "array" },
+    out: { type: "string" },
+});
+exports.builder = builder;
+const handler = (argv) => __awaiter(void 0, void 0, void 0, function* () {
+    const { include: _include, exclude: _exclude, out: _out } = argv;
+    const wd = process.cwd();
+    console.log("Current working directory:", wd);
+    const include = _include || [`${wd}/abi/*Facet.json`];
+    const exclude = _exclude ||
+        ["DiamondCutFacet", "DiamondLoupeFacet", "OwnershipFacet"].map((file) => `./abi/${file}.json`);
+    const out = _out || `${wd}/abi/CombinedFacets.json`;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const abi = [];
+    for (const path of include) {
+        const [resolve, , promise] = (0, utils_1.deferred)();
+        (0, glob_1.default)(path, {}, (_, facets) => {
+            // Merge all abis matching the path glob
+            const pathAbi = facets
+                .filter((facet) => !exclude.includes(facet))
+                .map((facet) => require(facet))
+                .map((abis) => abis.abi)
+                .flat(1);
+            abi.push(...pathAbi);
+            resolve();
+        });
+        // Make the callback syncronous
+        yield promise;
+    }
+    fs_1.default.writeFileSync(out, JSON.stringify({ abi }));
+    console.log(`Created diamond abi at ${out}`);
+    process.exit(0);
+});
+exports.handler = handler;

package/dist/commands/hello.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handler = exports.builder = exports.desc = exports.command = void 0;
+exports.command = "hello <name>";
+exports.desc = "Greet <name> with Hello";
+const builder = (yargs) => yargs
+    .options({
+    upper: { type: "boolean" },
+})
+    .positional("name", { type: "string", demandOption: true });
+exports.builder = builder;
+const handler = (argv) => {
+    const { name } = argv;
+    const greeting = `Gm, ${name}!`;
+    console.log(greeting);
+    process.exit(0);
+};
+exports.handler = handler;

package/dist/commands/sync-art.js

@@ -0,0 +1,45 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handler = exports.builder = exports.desc = exports.command = void 0;
+const utils_1 = require("../utils");
+exports.command = "sync-art <repo>";
+exports.desc = "Syncs art from a MUD-compatible art repo, found in <repo>";
+const builder = (yargs) => yargs.positional("repo", { type: "string", demandOption: true }).options({
+    commitHash: { type: "string" },
+});
+exports.builder = builder;
+const handler = (argv) => __awaiter(void 0, void 0, void 0, function* () {
+    const { repo, commitHash } = argv;
+    console.log("Syncing art repo from", repo);
+    const clean = yield (0, utils_1.exec)(`git diff --quiet --exit-code`);
+    if (clean !== 0) {
+        console.log("Directory is not clean! Please git add and commit");
+        process.exit(0);
+    }
+    console.log("Cloning...");
+    yield (0, utils_1.exec)(`git clone ${repo} _artmudtemp`);
+    if (commitHash) {
+        yield (0, utils_1.exec)(`cd _artmudtemp && git reset --hard ${commitHash} && cd -`);
+    }
+    console.log("Moving atlases...");
+    yield (0, utils_1.exec)(`cp -r _artmudtemp/atlases src/public`);
+    console.log("Moving tilesets...");
+    yield (0, utils_1.exec)(`cp -r _artmudtemp/tilesets src/layers/Renderer/assets`);
+    console.log("Moving tileset types...");
+    yield (0, utils_1.exec)(`cp -r _artmudtemp/types/ src/layers/Renderer/Phaser/tilesets/`);
+    console.log("Cleaning up...");
+    yield (0, utils_1.exec)(`rm -rf _artmudtemp`);
+    console.log("Committing...");
+    yield (0, utils_1.exec)(`git add src/public && git add src/layers/Renderer && git commit -m "feat(art): adding art from ${repo}"`);
+    process.exit(0);
+});
+exports.handler = handler;

package/dist/commands/system-types.js

@@ -0,0 +1,92 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handler = exports.builder = exports.desc = exports.command = void 0;
+const fs_1 = __importDefault(require("fs"));
+const glob_1 = __importDefault(require("glob"));
+const utils_1 = require("../utils");
+exports.command = "system-types";
+exports.desc = "Generates system type file. Note: assumes ABIs of all systems in ./abi and typechain generated types in ./types/ethers-contracts";
+const builder = (yargs) => yargs.options({
+    include: { type: "array" },
+    exclude: { type: "array" },
+    out: { type: "string" },
+});
+exports.builder = builder;
+const handler = () => __awaiter(void 0, void 0, void 0, function* () {
+    const wd = process.cwd();
+    let abis = [];
+    let systems = [];
+    let ids = [];
+    let typePaths = [];
+    const systemsPath = `${wd}/src/systems/*.sol`;
+    const [resolve, , promise] = (0, utils_1.deferred)();
+    (0, glob_1.default)(systemsPath, {}, (_, matches) => {
+        systems = matches.map((path) => {
+            const fragments = path.split("/");
+            return fragments[fragments.length - 1].split(".sol")[0];
+        });
+        ids = matches.map((path, index) => {
+            const id = (0, utils_1.extractIdFromFile)(path);
+            if (!id) {
+                console.log("Path:", path);
+                console.log("ID:", id);
+                throw new Error("No ID found for" +
+                    matches[index] +
+                    ". Make sure your system source file includes a ID definition (uint256 constant ID = uint256(keccak256(<ID>));)");
+            }
+            return id;
+        });
+        abis = systems.map((system) => `../abi/${system}.json`);
+        typePaths = systems.map((system) => `./ethers-contracts/${system}.ts`);
+        resolve();
+    });
+    // Make the callback synchronous
+    yield promise;
+    console.log("Matches", systems);
+    console.log("Solidity", ids);
+    console.log("Type paths", typePaths);
+    console.log("ABIs", abis);
+    const SystemMappings = `// Autogenerated using mud system-types
+export const systemToId = {
+${systems.map((system, index) => `  ${system}: "${ids[index]}",`).join("\n")}
+};
+
+export const idToSystem = {
+${ids.map((id, index) => `  "${id}": "${systems[index]}",`).join("\n")}
+};
+  `;
+    const SystemTypes = `// Autogenerated using mud system-types
+${typePaths.map((path, index) => `import { ${systems[index]} } from "${path.replace(".ts", "")}";`).join("\n")}
+ 
+export type SystemTypes = {
+${systems.map((system, index) => `  "${ids[index]}": ${system};`).join("\n")}
+};
+`;
+    const SystemAbis = `// Autogenerated using mud system-types
+${abis.map((path, index) => `import ${systems[index]} from "${path}";`).join("\n")}
+
+export const SystemAbis = {
+${systems.map((system, index) => `  "${ids[index]}": ${system}.abi,`).join("\n")}
+};
+`;
+    console.log("Generating files:");
+    console.log("SystemTypes.ts", SystemTypes);
+    console.log("SystemAbis.mts", SystemAbis);
+    console.log("SystemMappings.ts", SystemMappings);
+    fs_1.default.writeFileSync("./types/SystemTypes.ts", SystemTypes);
+    fs_1.default.writeFileSync("./types/SystemAbis.mts", SystemAbis);
+    fs_1.default.writeFileSync("./types/SystemMappings.ts", SystemMappings);
+});
+exports.handler = handler;

package/dist/commands/trace.js

@@ -0,0 +1,66 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handler = exports.builder = exports.desc = exports.command = void 0;
+const utils_1 = require("../utils");
+const fs_1 = require("fs");
+const ethers_1 = require("ethers");
+const providers_1 = require("@ethersproject/providers");
+const World_json_1 = require("@latticexyz/solecs/abi/World.json");
+exports.command = "trace";
+exports.desc = "Display the trace of a transaction";
+const builder = (yargs) => yargs.options({
+    config: { type: "string", description: "path to mud deploy config (deploy.json)" },
+    world: { type: "string", required: true, description: "world contract address" },
+    tx: { type: "string", required: true, description: "tx hash to replay" },
+    rpc: { type: "string", description: "json rpc endpoint, defaults to http://localhost:8545" },
+    debug: { type: "boolean", description: "open debugger" },
+});
+exports.builder = builder;
+const handler = (argv) => __awaiter(void 0, void 0, void 0, function* () {
+    const { config, world, rpc, tx, debug } = argv;
+    const wd = process.cwd();
+    const deployData = config && JSON.parse((0, fs_1.readFileSync)(config, { encoding: "utf8" }));
+    const labels = [];
+    const provider = new providers_1.JsonRpcProvider(rpc || "http://localhost:8545");
+    const World = new ethers_1.Contract(world, World_json_1.abi, provider);
+    if (deployData) {
+        // Create component labels
+        const componentPromises = deployData.components.map((component) => __awaiter(void 0, void 0, void 0, function* () {
+            const path = `${wd}/src/components/${component}.sol`;
+            const id = (0, utils_1.extractIdFromFile)(path);
+            if (!id)
+                return;
+            const address = yield World.getComponent((0, utils_1.keccak256)(id));
+            return [component, address];
+        }));
+        // Create system labels
+        const systemPromises = deployData.systems.map((system) => __awaiter(void 0, void 0, void 0, function* () {
+            const path = `${wd}/src/systems/${system.name}.sol`;
+            const id = (0, utils_1.extractIdFromFile)(path);
+            if (!id)
+                return;
+            const address = yield World.getSystemAddress((0, utils_1.keccak256)(id));
+            return [system.name, address];
+        }));
+        const components = yield Promise.all(componentPromises);
+        const systems = yield Promise.all(systemPromises);
+        labels.push(...components, ...systems);
+    }
+    yield (0, utils_1.execLog)("cast", [
+        "run",
+        ...labels.map((label) => ["--label", `${label[1]}:${label[0]}`]).flat(),
+        ...(debug ? ["--debug"] : []),
+        `${tx}`,
+    ]);
+    process.exit(0);
+});
+exports.handler = handler;

package/dist/index.js

@@ -0,0 +1,15 @@
+#!/usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const yargs_1 = __importDefault(require("yargs"));
+const helpers_1 = require("yargs/helpers");
+(0, yargs_1.default)((0, helpers_1.hideBin)(process.argv))
+    // Use the commands directory to scaffold.
+    .commandDir("commands")
+    // Enable strict mode.
+    .strict()
+    // Useful aliases.
+    .alias({ h: "help" }).argv;

package/dist/utils.js

@@ -0,0 +1,78 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.keccak256 = exports.extractIdFromFile = exports.execLog = exports.exec = exports.deferred = exports.IDregex = void 0;
+const child_process_1 = require("child_process");
+const utils_1 = require("ethers/lib/utils");
+const fs_1 = require("fs");
+exports.IDregex = new RegExp(/(?<=uint256 constant ID = uint256\(keccak256\(")(.*)(?="\))/);
+/**
+ * A convenient way to create a promise with resolve and reject functions.
+ * @returns Tuple with resolve function, reject function and promise.
+ */
+function deferred() {
+    let resolve = null;
+    let reject = null;
+    const promise = new Promise((r, rj) => {
+        resolve = (t) => r(t);
+        reject = (e) => rj(e);
+    });
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return [resolve, reject, promise];
+}
+exports.deferred = deferred;
+/**
+ * Await execution of bash scripts
+ * @param command Bash script to execute
+ * @returns Promise that resolves with exit code when script finished executing
+ */
+function exec(command) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const [resolve, , promise] = deferred();
+        const child = (0, child_process_1.exec)(command, (error, stdout, stderr) => {
+            if (error || stderr) {
+                console.error(error);
+                console.error(stderr);
+            }
+            console.log(stdout);
+        });
+        child.on("exit", (code) => resolve(code !== null && code !== void 0 ? code : 0));
+        return promise;
+    });
+}
+exports.exec = exec;
+/**
+ * Await execution of bash scripts
+ * @param command Bash script to execute
+ * @param options Args to pass to the script
+ * @returns Promise that resolves with exit code when script finished executing
+ */
+function execLog(command, options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        console.log("Cmd:");
+        console.log([command, ...options].join(" "));
+        const [resolve, , promise] = deferred();
+        const child = (0, child_process_1.spawn)(command, options, { stdio: [process.stdin, process.stdout, process.stderr] });
+        child.on("exit", (code) => resolve(code !== null && code !== void 0 ? code : 0));
+        return promise;
+    });
+}
+exports.execLog = execLog;
+function extractIdFromFile(path) {
+    const content = (0, fs_1.readFileSync)(path).toString();
+    const regexResult = exports.IDregex.exec(content);
+    return regexResult && regexResult[0];
+}
+exports.extractIdFromFile = extractIdFromFile;
+function keccak256(data) {
+    return (0, utils_1.keccak256)((0, utils_1.toUtf8Bytes)(data));
+}
+exports.keccak256 = keccak256;

package/package.json

@@ -0,0 +1,64 @@
+{
+  "name": "@latticexyz/cli",
+  "version": "0.9.0",
+  "description": "Command line interface for mud",
+  "main": "dist/index.js",
+  "license": "MIT",
+  "bin": {
+    "mud": "./dist/index.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/latticexyz/mud.git",
+    "directory": "packages/cli"
+  },
+  "scripts": {
+    "prepare": "yarn build",
+    "prepack": "mv package.json package.json.bak && jq \".main = \\\"dist/index.js\\\"\" package.json.bak > package.json ",
+    "postpack": "mv package.json.bak package.json",
+    "globalinstall": "yarn build && yarn prepare && npm link",
+    "build": "rimraf dist && tsc -p . && chmod u+x dist/index.js",
+    "link": "yarn link",
+    "test": "echo 'todo: add tests'"
+  },
+  "devDependencies": {
+    "@types/clear": "^0.1.2",
+    "@types/figlet": "^1.5.4",
+    "@types/glob": "^7.2.0",
+    "@types/inquirer": "^8.2.1",
+    "@types/node": "^17.0.34",
+    "@types/openurl": "^1.0.0",
+    "@types/yargs": "^17.0.10",
+    "nodemon": "^2.0.16",
+    "pkg": "^5.7.0",
+    "rimraf": "^3.0.2",
+    "ts-node": "^10.7.0",
+    "typescript": "^4.6.4"
+  },
+  "dependencies": {
+    "@latticexyz/solecs": "^0.9.0",
+    "@latticexyz/utils": "^0.9.0",
+    "chalk": "^5.0.1",
+    "clear": "^0.1.0",
+    "commander": "^9.2.0",
+    "esm": "^3.2.25",
+    "ethers": "^5.6.7",
+    "execa": "^6.1.0",
+    "figlet": "^1.5.2",
+    "glob": "^8.0.3",
+    "inquirer": "^8.2.4",
+    "inquirer-prompt-suggest": "^0.1.0",
+    "listr2": "^4.0.5",
+    "netlify": "^11.0.1",
+    "node-fetch": "^3.2.6",
+    "openurl": "^1.1.1",
+    "path": "^0.12.7",
+    "typechain": "^8.1.0",
+    "uuid": "^8.3.2",
+    "yargs": "^17.5.1"
+  },
+  "pkg": {
+    "scripts": "build/**/*.js"
+  },
+  "gitHead": "40718ea9955e61196942d040189adec464500446"
+}