@latticexyz/cli 2.0.0-skystrife-playtest-9e9511d4 → 2.0.0-transaction-context-324984c5

package/src/commands/dev-contracts.ts

@@ -1,166 +1,114 @@
-import type { CommandModule } from "yargs";
-import { anvil, forge, 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 { deployHandler, logError, printMUD } from "../utils";
 import { homedir } from "os";
 import { rmSync } from "fs";
-import { execa } from "execa";
-
-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,
+  worldAddress: deployOptions.worldAddress,
 };
 
-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();
+  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);
-    }
-
-    /** 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 = opts.worldAddress as 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,
+            salt: "0x",
+          });
+          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/index.ts

@@ -3,6 +3,7 @@ import { CommandModule } from "yargs";
 import gasReport from "@latticexyz/gas-report";
 import abiTs from "@latticexyz/abi-ts";
 
+import build from "./build";
 import devnode from "./devnode";
 import faucet from "./faucet";
 import hello from "./hello";
@@ -16,6 +17,7 @@ import devContracts from "./dev-contracts";
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any -- Each command has different options
 export const commands: CommandModule<any, any>[] = [
+  build,
   deploy,
   devnode,
   faucet,

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",
@@ -64,8 +56,11 @@ const commandModule: CommandModule<Options, Options> = {
         throw new MUDError(`These options are mutually exclusive: ${mutuallyExclusiveOptions.join(", ")}`);
       }
 
+      // If the --link flag is not set, we call resolveVersion to get the version
       // Resolve the version number from available options like `tag` or `commit`
-      options.mudVersion = await resolveVersion(options);
+      if (!options.link) {
+        options.mudVersion = await resolveVersion(options);
+      }
 
       // Update all package.json below the current working directory (except in node_modules)
       const packageJsons = glob.sync("**/package.json").filter((p) => !p.includes("node_modules"));
@@ -117,63 +112,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 +155,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 +188,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/tablegen.ts

@@ -3,7 +3,7 @@ import type { CommandModule } from "yargs";
 import { loadConfig } from "@latticexyz/config/node";
 import { StoreConfig } from "@latticexyz/store";
 import { tablegen } from "@latticexyz/store/codegen";
-import { getSrcDirectory } from "@latticexyz/common/foundry";
+import { getRemappings, getSrcDirectory } from "@latticexyz/common/foundry";
 
 type Options = {
   configPath?: string;
@@ -23,8 +23,9 @@ const commandModule: CommandModule<Options, Options> = {
   async handler({ configPath }) {
     const config = (await loadConfig(configPath)) as StoreConfig;
     const srcDir = await getSrcDirectory();
+    const remappings = await getRemappings();
 
-    await tablegen(config, path.join(srcDir, config.codegenDirectory));
+    await tablegen(config, path.join(srcDir, config.codegenDirectory), remappings);
 
     process.exit(0);
   },

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 { deployHandler, DeployOptions } from "../utils";
+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

@@ -8,12 +8,18 @@ import { cast, getRpcUrl, getSrcDirectory } from "@latticexyz/common/foundry";
 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 { tableIdToHex } from "@latticexyz/common";
-import { getChainId, getExistingContracts } from "../utils";
+import worldConfig from "@latticexyz/world/mud.config";
+import { resourceToHex } from "@latticexyz/common";
+import { getExistingContracts } from "../utils/getExistingContracts";
+import { createClient, http } from "viem";
+import { getChainId } from "viem/actions";
 
 // TODO account for multiple namespaces (https://github.com/latticexyz/mud/issues/994)
-const systemsTableId = tableIdToHex(worldConfig.namespace, worldConfig.tables.Systems.name);
+const systemsTableId = resourceToHex({
+  type: "system",
+  namespace: worldConfig.namespace,
+  name: worldConfig.tables.Systems.name,
+});
 
 type Options = {
   tx: string;
@@ -75,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 = tableIdToHex(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 });
@@ -98,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/commands/worldgen.ts

@@ -6,7 +6,7 @@ import { worldgen } from "@latticexyz/world/node";
 import { getSrcDirectory } from "@latticexyz/common/foundry";
 import path from "path";
 import { rmSync } from "fs";
-import { getExistingContracts } from "../utils";
+import { getExistingContracts } from "../utils/getExistingContracts";
 
 type Options = {
   configPath?: string;

package/src/common.ts

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

package/src/debug.ts

@@ -0,0 +1,10 @@
+import createDebug from "debug";
+
+export const debug = createDebug("mud:cli");
+export const error = createDebug("mud:cli");
+
+// Pipe debug output to stdout instead of stderr
+debug.log = console.debug.bind(console);
+
+// Pipe error output to stderr
+error.log = console.error.bind(console);