@latticexyz/cli 2.0.0-next.10 → 2.0.0-next.12

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@latticexyz/cli",
-  "version": "2.0.0-next.10",
+  "version": "2.0.0-next.12",
   "description": "Command line interface for mud",
   "repository": {
     "type": "git",
@@ -23,6 +23,7 @@
     "@improbable-eng/grpc-web-node-http-transport": "^0.15.0",
     "chalk": "^5.0.1",
     "chokidar": "^3.5.3",
+    "debug": "^4.3.4",
     "dotenv": "^16.0.3",
     "ejs": "^3.1.8",
     "ethers": "^5.7.2",
@@ -30,26 +31,29 @@
     "glob": "^8.0.3",
     "nice-grpc-web": "^2.0.1",
     "openurl": "^1.1.1",
+    "p-retry": "^5.1.2",
     "path": "^0.12.7",
+    "rxjs": "7.5.5",
     "throttle-debounce": "^5.0.0",
     "typescript": "5.1.6",
-    "viem": "1.6.0",
+    "viem": "1.14.0",
     "yargs": "^17.7.1",
     "zod": "^3.21.4",
     "zod-validation-error": "^1.3.0",
-    "@latticexyz/abi-ts": "2.0.0-next.10",
-    "@latticexyz/common": "2.0.0-next.10",
-    "@latticexyz/config": "2.0.0-next.10",
-    "@latticexyz/gas-report": "2.0.0-next.10",
-    "@latticexyz/protocol-parser": "2.0.0-next.10",
-    "@latticexyz/schema-type": "2.0.0-next.10",
-    "@latticexyz/services": "2.0.0-next.10",
-    "@latticexyz/store": "2.0.0-next.10",
-    "@latticexyz/utils": "2.0.0-next.10",
-    "@latticexyz/world": "2.0.0-next.10",
-    "@latticexyz/world-modules": "2.0.0-next.10"
+    "@latticexyz/abi-ts": "2.0.0-next.12",
+    "@latticexyz/common": "2.0.0-next.12",
+    "@latticexyz/config": "2.0.0-next.12",
+    "@latticexyz/gas-report": "2.0.0-next.12",
+    "@latticexyz/protocol-parser": "2.0.0-next.12",
+    "@latticexyz/schema-type": "2.0.0-next.12",
+    "@latticexyz/services": "2.0.0-next.12",
+    "@latticexyz/store": "2.0.0-next.12",
+    "@latticexyz/utils": "2.0.0-next.12",
+    "@latticexyz/world": "2.0.0-next.12",
+    "@latticexyz/world-modules": "2.0.0-next.12"
   },
   "devDependencies": {
+    "@types/debug": "^4.1.7",
     "@types/ejs": "^3.1.1",
     "@types/glob": "^7.2.0",
     "@types/node": "^18.15.11",

package/src/commands/deploy.ts

@@ -1,43 +1,20 @@
-import type { CommandModule, Options } from "yargs";
+import type { CommandModule } from "yargs";
 import { logError } from "../utils/errors";
-import { DeployOptions, deployHandler } from "../utils/deployHandler";
+import { DeployOptions, deployOptions, runDeploy } from "../runDeploy";
 
-export const yDeployOptions = {
-  configPath: { type: "string", desc: "Path to the config file" },
-  clean: { type: "boolean", desc: "Remove the build forge artifacts and cache directories before building" },
-  printConfig: { type: "boolean", desc: "Print the resolved config" },
-  profile: { type: "string", desc: "The foundry profile to use" },
-  debug: { type: "boolean", desc: "Print debug logs, like full error messages" },
-  priorityFeeMultiplier: {
-    type: "number",
-    desc: "Multiply the estimated priority fee by the provided factor",
-    default: 1,
-  },
-  saveDeployment: { type: "boolean", desc: "Save the deployment info to a file", default: true },
-  rpc: { type: "string", desc: "The RPC URL to use. Defaults to the RPC url from the local foundry.toml" },
-  worldAddress: { type: "string", desc: "Deploy to an existing World at the given address" },
-  srcDir: { type: "string", desc: "Source directory. Defaults to foundry src directory." },
-  disableTxWait: { type: "boolean", desc: "Disable waiting for transactions to be confirmed.", default: false },
-  pollInterval: {
-    type: "number",
-    desc: "Interval in miliseconds to use to poll for transaction receipts / block inclusion",
-    default: 1000,
-  },
-  skipBuild: { type: "boolean", desc: "Skip rebuilding the contracts before deploying" },
-} satisfies Record<keyof DeployOptions, Options>;
-
-const commandModule: CommandModule<DeployOptions, DeployOptions> = {
+const commandModule: CommandModule<typeof deployOptions, DeployOptions> = {
   command: "deploy",
 
   describe: "Deploy MUD contracts",
 
   builder(yargs) {
-    return yargs.options(yDeployOptions);
+    return yargs.options(deployOptions);
   },
 
-  async handler(args) {
+  async handler(opts) {
+    // Wrap in try/catch, because yargs seems to swallow errors
     try {
-      await deployHandler(args);
+      await runDeploy(opts);
     } catch (error: any) {
       logError(error);
       process.exit(1);

package/src/commands/dev-contracts.ts

@@ -1,176 +1,112 @@
-import type { CommandModule } from "yargs";
-import {
-  anvil,
-  forge,
-  getRemappings,
-  getRpcUrl,
-  getScriptDirectory,
-  getSrcDirectory,
-} from "@latticexyz/common/foundry";
+import type { CommandModule, InferredOptionTypes } from "yargs";
+import { anvil, getScriptDirectory, getSrcDirectory } from "@latticexyz/common/foundry";
 import chalk from "chalk";
 import chokidar from "chokidar";
 import { loadConfig, resolveConfigPath } from "@latticexyz/config/node";
 import { StoreConfig } from "@latticexyz/store";
-import { tablegen } from "@latticexyz/store/codegen";
 import path from "path";
-import { debounce } from "throttle-debounce";
-import { worldgenHandler } from "./worldgen";
 import { WorldConfig } from "@latticexyz/world";
 import { homedir } from "os";
 import { rmSync } from "fs";
-import { execa } from "execa";
-import { logError } from "../utils/errors";
-import { deployHandler } from "../utils/deployHandler";
-import { printMUD } from "../utils/printMUD";
-
-type Options = {
-  rpc?: string;
-  configPath?: string;
+import { deployOptions, runDeploy } from "../runDeploy";
+import { BehaviorSubject, debounceTime, exhaustMap, filter } from "rxjs";
+import { Address } from "viem";
+import { isDefined } from "@latticexyz/common/utils";
+
+const devOptions = {
+  rpc: deployOptions.rpc,
+  configPath: deployOptions.configPath,
+  alwaysRunPostDeploy: deployOptions.alwaysRunPostDeploy,
 };
 
-const commandModule: CommandModule<Options, Options> = {
+const commandModule: CommandModule<typeof devOptions, InferredOptionTypes<typeof devOptions>> = {
   command: "dev-contracts",
 
   describe: "Start a development server for MUD contracts",
 
   builder(yargs) {
-    return yargs.options({
-      rpc: {
-        type: "string",
-        decs: "RPC endpoint of the development node. If none is provided, an anvil instance is spawned in the background on port 8545.",
-      },
-      configPath: {
-        type: "string",
-        decs: "Path to MUD config",
-      },
-    });
+    return yargs.options(devOptions);
   },
 
-  async handler(args) {
-    // Initial cleanup
-    await forge(["clean"]);
-
-    const rpc = args.rpc ?? (await getRpcUrl());
-    const configPath = args.configPath ?? (await resolveConfigPath(args.configPath));
-    const srcDirectory = await getSrcDirectory();
-    const scriptDirectory = await getScriptDirectory();
-    const remappings = await getRemappings();
+  async handler(opts) {
+    let rpc = opts.rpc;
+    const configPath = opts.configPath ?? (await resolveConfigPath(opts.configPath));
+    const srcDir = await getSrcDirectory();
+    const scriptDir = await getScriptDirectory();
     const initialConfig = (await loadConfig(configPath)) as StoreConfig & WorldConfig;
 
-    // Initial run of all codegen steps before starting anvil
-    // (so clients can wait for everything to be ready before starting)
-    await handleConfigChange(initialConfig);
-    await handleContractsChange(initialConfig);
-
     // Start an anvil instance in the background if no RPC url is provided
-    if (!args.rpc) {
+    if (!opts.rpc) {
+      // Clean anvil cache as 1s block times can fill up the disk
+      // - https://github.com/foundry-rs/foundry/issues/3623
+      // - https://github.com/foundry-rs/foundry/issues/4989
+      // - https://github.com/foundry-rs/foundry/issues/3699
+      // - https://github.com/foundry-rs/foundry/issues/3512
       console.log(chalk.gray("Cleaning devnode cache"));
       const userHomeDir = homedir();
       rmSync(path.join(userHomeDir, ".foundry", "anvil", "tmp"), { recursive: true, force: true });
 
       const anvilArgs = ["--block-time", "1", "--block-base-fee-per-gas", "0"];
       anvil(anvilArgs);
+      rpc = "http://127.0.0.1:8545";
     }
 
-    const changedSinceLastHandled = {
-      config: false,
-      contracts: false,
-    };
-
-    const changeInProgress = {
-      current: false,
-    };
-
     // Watch for changes
-    const configWatcher = chokidar.watch([configPath, srcDirectory]);
-    configWatcher.on("all", async (_, updatePath) => {
+    const lastChange$ = new BehaviorSubject<number>(Date.now());
+    chokidar.watch([configPath, srcDir, scriptDir], { ignoreInitial: true }).on("all", async (_, updatePath) => {
       if (updatePath.includes(configPath)) {
-        changedSinceLastHandled.config = true;
-        // We trigger contract changes if the config changed here instead of
-        // listening to changes in the codegen directory to avoid an infinite loop
-        changedSinceLastHandled.contracts = true;
+        console.log(chalk.blue("Config changed, queuing deploy…"));
+        lastChange$.next(Date.now());
       }
-
-      if (updatePath.includes(srcDirectory) || updatePath.includes(scriptDirectory)) {
+      if (updatePath.includes(srcDir) || updatePath.includes(scriptDir)) {
         // Ignore changes to codegen files to avoid an infinite loop
-        if (updatePath.includes(initialConfig.codegenDirectory)) return;
-        changedSinceLastHandled.contracts = true;
-      }
-
-      // Trigger debounced onChange
-      handleChange();
-    });
-
-    const handleChange = debounce(100, async () => {
-      // Avoid handling changes multiple times in parallel
-      if (changeInProgress.current) return;
-      changeInProgress.current = true;
-
-      // Reset dirty flags
-      const { config, contracts } = changedSinceLastHandled;
-      changedSinceLastHandled.config = false;
-      changedSinceLastHandled.contracts = false;
-
-      try {
-        // Load latest config
-        const mudConfig = (await loadConfig(configPath)) as StoreConfig & WorldConfig;
-
-        // Handle changes
-        if (config) await handleConfigChange(mudConfig);
-        if (contracts) await handleContractsChange(mudConfig);
-
-        await deploy();
-      } catch (error) {
-        console.error(chalk.red("MUD dev-contracts watcher failed to deploy config or contracts changes\n"));
-        logError(error);
-      }
-
-      changeInProgress.current = false;
-      if (changedSinceLastHandled.config || changedSinceLastHandled.contracts) {
-        console.log("Detected change while handling the previous change");
-        handleChange();
+        if (!updatePath.includes(initialConfig.codegenDirectory)) {
+          console.log(chalk.blue("Contracts changed, queuing deploy…"));
+          lastChange$.next(Date.now());
+        }
       }
-
-      printMUD();
-      console.log("MUD watching for changes...");
     });
 
-    /** Codegen to run if config changes */
-    async function handleConfigChange(config: StoreConfig & WorldConfig) {
-      console.log(chalk.blue("mud.config.ts changed - regenerating tables and recs types"));
-      // Run tablegen to generate tables based on the config
-      const outPath = path.join(srcDirectory, config.codegenDirectory);
-      await tablegen(config, outPath, remappings);
-    }
-
-    /** Codegen to run if contracts changed */
-    async function handleContractsChange(config: StoreConfig & WorldConfig) {
-      console.log(chalk.blue("contracts changed - regenerating interfaces and contract types"));
-
-      // Run worldgen to generate interfaces based on the systems
-      await worldgenHandler({ config, clean: true, srcDir: srcDirectory });
-
-      // Build the contracts
-      await forge(["build", "--skip", "test", "script"]);
-
-      // Generate TS type definitions for ABIs
-      await execa("mud", ["abi-ts"], { stdio: "inherit" });
-    }
-
-    /** Run after codegen if either mud config or contracts changed */
-    async function deploy() {
-      console.log(chalk.blue("redeploying World"));
-      await deployHandler({
-        configPath,
-        skipBuild: true,
-        priorityFeeMultiplier: 1,
-        disableTxWait: true,
-        pollInterval: 1000,
-        saveDeployment: true,
-        srcDir: srcDirectory,
-        rpc,
-      });
-    }
+    let worldAddress: Address | undefined;
+
+    const deploys$ = lastChange$.pipe(
+      // debounce so that a large batch of file changes only triggers a deploy after it settles down, rather than the first change it sees (and then redeploying immediately after)
+      debounceTime(200),
+      exhaustMap(async (lastChange) => {
+        if (worldAddress) {
+          console.log(chalk.blue("Rebuilding and upgrading world…"));
+        }
+
+        try {
+          const deploy = await runDeploy({
+            ...opts,
+            configPath,
+            rpc,
+            skipBuild: false,
+            printConfig: false,
+            profile: undefined,
+            saveDeployment: true,
+            worldAddress,
+            srcDir,
+          });
+          worldAddress = deploy.address;
+          // if there were changes while we were deploying, trigger it again
+          if (lastChange < lastChange$.value) {
+            lastChange$.next(lastChange$.value);
+          } else {
+            console.log(chalk.gray("\nWaiting for file changes…\n"));
+          }
+          return deploy;
+        } catch (error) {
+          console.error(chalk.bgRed(chalk.whiteBright("\n Error while attempting deploy \n")));
+          console.error(error);
+          console.log(chalk.gray("\nWaiting for file changes…\n"));
+        }
+      }),
+      filter(isDefined)
+    );
+
+    deploys$.subscribe();
   },
 };
 

package/src/commands/set-version.ts

@@ -1,11 +1,12 @@
 import chalk from "chalk";
-import { existsSync, readFileSync, rmSync, writeFileSync } from "fs";
+import { readFileSync, writeFileSync } from "fs";
 import path from "path";
 import type { CommandModule } from "yargs";
 import { MUDError } from "@latticexyz/common/errors";
 import { logError } from "../utils/errors";
 import localPackageJson from "../../package.json" assert { type: "json" };
 import glob from "glob";
+import { mudPackages } from "../mudPackages";
 
 type Options = {
   backup?: boolean;
@@ -17,9 +18,6 @@ type Options = {
   link?: string;
 };
 
-const BACKUP_FILE = ".mudbackup";
-const MUD_PREFIX = "@latticexyz";
-
 const commandModule: CommandModule<Options, Options> = {
   command: "set-version",
 
@@ -27,12 +25,6 @@ const commandModule: CommandModule<Options, Options> = {
 
   builder(yargs) {
     return yargs.options({
-      backup: { type: "boolean", description: `Back up the current MUD versions to "${BACKUP_FILE}"` },
-      force: {
-        type: "boolean",
-        description: `Backup fails if a "${BACKUP_FILE}" file is found, unless --force is provided`,
-      },
-      restore: { type: "boolean", description: `Restore the previous MUD versions from "${BACKUP_FILE}"` },
       mudVersion: { alias: "v", type: "string", description: "Set MUD to the given version" },
       tag: {
         alias: "t",
@@ -117,63 +109,39 @@ async function resolveVersion(options: Options) {
 }
 
 function updatePackageJson(filePath: string, options: Options): { workspaces?: string[] } {
-  const { restore, force, link } = options;
-  let { backup, mudVersion } = options;
-
-  const backupFilePath = path.join(path.dirname(filePath), BACKUP_FILE);
-  const backupFileExists = existsSync(backupFilePath);
-
-  // Create a backup file for previous MUD versions by default if linking to local MUD
-  if (link && !backupFileExists) backup = true;
-
-  // If `backup` is true and force not set, check if a backup file already exists and throw an error if it does
-  if (backup && !force && backupFileExists) {
-    throw new MUDError(
-      `A backup file already exists at ${backupFilePath}.\nUse --force to overwrite it or --restore to restore it.`
-    );
-  }
+  const { link } = options;
+  let { mudVersion } = options;
 
   const packageJson = readPackageJson(filePath);
-
-  // Load .mudbackup if `restore` is true
-  const backupJson = restore ? readPackageJson(backupFilePath) : undefined;
+  const mudPackageNames = Object.keys(mudPackages);
 
   // Find all MUD dependencies
   const mudDependencies: Record<string, string> = {};
-  for (const key in packageJson.dependencies) {
-    if (key.startsWith(MUD_PREFIX)) {
-      mudDependencies[key] = packageJson.dependencies[key];
+  for (const packageName in packageJson.dependencies) {
+    if (mudPackageNames.includes(packageName)) {
+      mudDependencies[packageName] = packageJson.dependencies[packageName];
     }
   }
 
   // Find all MUD devDependencies
   const mudDevDependencies: Record<string, string> = {};
-  for (const key in packageJson.devDependencies) {
-    if (key.startsWith(MUD_PREFIX)) {
-      mudDevDependencies[key] = packageJson.devDependencies[key];
+  for (const packageName in packageJson.devDependencies) {
+    if (mudPackageNames.includes(packageName)) {
+      mudDevDependencies[packageName] = packageJson.devDependencies[packageName];
     }
   }
 
-  // Back up the current dependencies if `backup` is true
-  if (backup) {
-    writeFileSync(
-      backupFilePath,
-      JSON.stringify({ dependencies: mudDependencies, devDependencies: mudDevDependencies }, null, 2)
-    );
-    console.log(chalk.green(`Backed up MUD dependencies from ${filePath} to ${backupFilePath}`));
-  }
-
   // Update the dependencies
-  for (const key in packageJson.dependencies) {
-    if (key.startsWith(MUD_PREFIX)) {
-      packageJson.dependencies[key] = resolveMudVersion(key, "dependencies");
+  for (const packageName in packageJson.dependencies) {
+    if (mudPackageNames.includes(packageName)) {
+      packageJson.dependencies[packageName] = resolveMudVersion(packageName, "dependencies");
     }
   }
 
   // Update the devDependencies
-  for (const key in packageJson.devDependencies) {
-    if (key.startsWith(MUD_PREFIX)) {
-      packageJson.devDependencies[key] = resolveMudVersion(key, "devDependencies");
+  for (const packageName in packageJson.devDependencies) {
+    if (mudPackageNames.includes(packageName)) {
+      packageJson.devDependencies[packageName] = resolveMudVersion(packageName, "devDependencies");
     }
   }
 
@@ -184,17 +152,9 @@ function updatePackageJson(filePath: string, options: Options): { workspaces?: s
   logComparison(mudDependencies, packageJson.dependencies);
   logComparison(mudDevDependencies, packageJson.devDependencies);
 
-  // Remove the backup file if `restore` is true and `backup` is false
-  // because the old backup file is no longer needed
-  if (restore && !backup) {
-    rmSync(backupFilePath);
-    console.log(chalk.green(`Cleaned up ${backupFilePath}`));
-  }
-
   return packageJson;
 
   function resolveMudVersion(key: string, type: "dependencies" | "devDependencies") {
-    if (restore && backupJson) return backupJson[type][key];
     if (link) mudVersion = resolveLinkPath(filePath, link, key);
     if (!mudVersion) return packageJson[type][key];
     return mudVersion;
@@ -225,10 +185,9 @@ function logComparison(prev: Record<string, string>, curr: Record<string, string
 /**
  * Returns path of the package to link, given a path to a local MUD clone and a package
  */
-function resolveLinkPath(packageJsonPath: string, mudLinkPath: string, pkg: string) {
-  const pkgName = pkg.replace(MUD_PREFIX, "");
+function resolveLinkPath(packageJsonPath: string, mudLinkPath: string, packageName: string) {
   const packageJsonToRootPath = path.relative(path.dirname(packageJsonPath), process.cwd());
-  const linkPath = path.join(packageJsonToRootPath, mudLinkPath, "packages", pkgName);
+  const linkPath = path.join(packageJsonToRootPath, mudLinkPath, mudPackages[packageName].localPath);
   return "link:" + linkPath;
 }
 

package/src/commands/test.ts

@@ -1,70 +1,64 @@
-import type { CommandModule } from "yargs";
+import type { CommandModule, InferredOptionTypes, Options } from "yargs";
 import { anvil, forge, getRpcUrl } from "@latticexyz/common/foundry";
 import chalk from "chalk";
-import { rmSync, writeFileSync } from "fs";
-import { yDeployOptions } from "./deploy";
-import { DeployOptions, deployHandler } from "../utils/deployHandler";
+import { deployOptions, runDeploy } from "../runDeploy";
 
-type Options = DeployOptions & { port?: number; worldAddress?: string; forgeOptions?: string };
+const testOptions = {
+  ...deployOptions,
+  port: { type: "number", description: "Port to run internal node for fork testing on", default: 4242 },
+  worldAddress: {
+    type: "string",
+    description:
+      "Address of an existing world contract. If provided, deployment is skipped and the RPC provided in the foundry.toml is used for fork testing.",
+  },
+  forgeOptions: { type: "string", description: "Options to pass to forge test" },
+} as const satisfies Record<string, Options>;
 
-const WORLD_ADDRESS_FILE = ".mudtest";
+type TestOptions = InferredOptionTypes<typeof testOptions>;
 
-const commandModule: CommandModule<Options, Options> = {
+const commandModule: CommandModule<typeof testOptions, TestOptions> = {
   command: "test",
 
   describe: "Run tests in MUD contracts",
 
   builder(yargs) {
-    return yargs.options({
-      ...yDeployOptions,
-      port: { type: "number", description: "Port to run internal node for fork testing on", default: 4242 },
-      worldAddress: {
-        type: "string",
-        description:
-          "Address of an existing world contract. If provided, deployment is skipped and the RPC provided in the foundry.toml is used for fork testing.",
-      },
-      forgeOptions: { type: "string", description: "Options to pass to forge test" },
-    });
+    return yargs.options(testOptions);
   },
 
-  async handler(args) {
+  async handler(opts) {
     // Start an internal anvil process if no world address is provided
-    if (!args.worldAddress) {
-      const anvilArgs = ["--block-base-fee-per-gas", "0", "--port", String(args.port)];
+    if (!opts.worldAddress) {
+      const anvilArgs = ["--block-base-fee-per-gas", "0", "--port", String(opts.port)];
       anvil(anvilArgs);
     }
 
-    const forkRpc = args.worldAddress ? await getRpcUrl(args.profile) : `http://127.0.0.1:${args.port}`;
+    const forkRpc = opts.worldAddress ? await getRpcUrl(opts.profile) : `http://127.0.0.1:${opts.port}`;
 
     const worldAddress =
-      args.worldAddress ??
+      opts.worldAddress ??
       (
-        await deployHandler({
-          ...args,
+        await runDeploy({
+          ...opts,
           saveDeployment: false,
           rpc: forkRpc,
         })
-      ).worldAddress;
+      ).address;
 
     console.log(chalk.blue("World address", worldAddress));
 
-    // Create a temporary file to pass the world address to the tests
-    writeFileSync(WORLD_ADDRESS_FILE, worldAddress);
-
-    const userOptions = args.forgeOptions?.replaceAll("\\", "").split(" ") ?? [];
+    const userOptions = opts.forgeOptions?.replaceAll("\\", "").split(" ") ?? [];
     try {
-      const testResult = await forge(["test", "--fork-url", forkRpc, ...userOptions], {
-        profile: args.profile,
+      await forge(["test", "--fork-url", forkRpc, ...userOptions], {
+        profile: opts.profile,
+        env: {
+          WORLD_ADDRESS: worldAddress,
+        },
       });
-      console.log(testResult);
+      process.exit(0);
     } catch (e) {
       console.error(e);
-      rmSync(WORLD_ADDRESS_FILE);
       process.exit(1);
     }
-
-    rmSync(WORLD_ADDRESS_FILE);
-    process.exit(0);
   },
 };
 

package/src/commands/trace.ts

@@ -9,12 +9,13 @@ import { StoreConfig } from "@latticexyz/store";
 import { resolveWorldConfig, WorldConfig } from "@latticexyz/world";
 import IBaseWorldAbi from "@latticexyz/world/out/IBaseWorld.sol/IBaseWorld.abi.json" assert { type: "json" };
 import worldConfig from "@latticexyz/world/mud.config.js";
-import { resourceIdToHex } from "@latticexyz/common";
+import { resourceToHex } from "@latticexyz/common";
 import { getExistingContracts } from "../utils/getExistingContracts";
-import { getChainId } from "../utils/utils/getChainId";
+import { createClient, http } from "viem";
+import { getChainId } from "viem/actions";
 
 // TODO account for multiple namespaces (https://github.com/latticexyz/mud/issues/994)
-const systemsTableId = resourceIdToHex({
+const systemsTableId = resourceToHex({
   type: "system",
   namespace: worldConfig.namespace,
   name: worldConfig.tables.Systems.name,
@@ -80,7 +81,7 @@ const commandModule: CommandModule<Options, Options> = {
     const systemTableFieldLayout = await WorldContract.getFieldLayout(systemsTableId);
     const labels: { name: string; address: string }[] = [];
     for (const name of names) {
-      const systemSelector = resourceIdToHex({ type: "system", namespace, name });
+      const systemSelector = resourceToHex({ type: "system", namespace, name });
       // Get the first field of `Systems` table (the table maps system name to its address and other data)
       const address = await WorldContract.getField(systemsTableId, [systemSelector], 0, systemTableFieldLayout);
       labels.push({ name, address });
@@ -103,7 +104,8 @@ export default commandModule;
 
 async function getWorldAddress(worldsFile: string, rpc: string) {
   if (existsSync(worldsFile)) {
-    const chainId = await getChainId(rpc);
+    const client = createClient({ transport: http(rpc) });
+    const chainId = await getChainId(client);
     const deploys = JSON.parse(readFileSync(worldsFile, "utf-8"));
 
     if (!deploys[chainId]) {

package/src/common.ts

@@ -0,0 +1 @@
+export type MudPackages = Record<string, { localPath: string }>;

package/src/debug.ts

@@ -0,0 +1,3 @@
+import createDebug from "debug";
+
+export const debug = createDebug("mud:cli");