@latticexyz/cli 2.0.12-main-9be2bb86 → 2.0.12-main-96e7bf43

package/src/commands/deploy.ts

@@ -1,26 +0,0 @@
-import type { CommandModule } from "yargs";
-import { logError } from "../utils/errors";
-import { DeployOptions, deployOptions, runDeploy } from "../runDeploy";
-
-const commandModule: CommandModule<typeof deployOptions, DeployOptions> = {
-  command: "deploy",
-
-  describe: "Deploy MUD contracts",
-
-  builder(yargs) {
-    return yargs.options(deployOptions);
-  },
-
-  async handler(opts) {
-    // Wrap in try/catch, because yargs seems to swallow errors
-    try {
-      await runDeploy(opts);
-    } catch (error) {
-      logError(error);
-      process.exit(1);
-    }
-    process.exit(0);
-  },
-};
-
-export default commandModule;

package/src/commands/dev-contracts.ts

@@ -1,118 +0,0 @@
-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 path from "path";
-import { World as WorldConfig } from "@latticexyz/world";
-import { homedir } from "os";
-import { rmSync } from "fs";
-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,
-  forgeScriptOptions: deployOptions.forgeScriptOptions,
-  worldAddress: deployOptions.worldAddress,
-};
-
-const commandModule: CommandModule<typeof devOptions, InferredOptionTypes<typeof devOptions>> = {
-  command: "dev-contracts",
-
-  describe: "Start a development server for MUD contracts",
-
-  builder(yargs) {
-    return yargs.options(devOptions);
-  },
-
-  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 WorldConfig;
-
-    // Start an anvil instance in the background if no RPC url is provided
-    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";
-    }
-
-    // Watch for changes
-    const lastChange$ = new BehaviorSubject<number>(Date.now());
-    chokidar.watch([configPath, srcDir, scriptDir], { ignoreInitial: true }).on("all", async (_, updatePath) => {
-      if (updatePath.includes(configPath)) {
-        console.log(chalk.blue("Config changed, queuing deploy…"));
-        lastChange$.next(Date.now());
-      }
-      if (updatePath.includes(srcDir) || updatePath.includes(scriptDir)) {
-        // Ignore changes to codegen files to avoid an infinite loop
-        if (!updatePath.includes(initialConfig.codegen.outputDirectory)) {
-          console.log(chalk.blue("Contracts changed, queuing deploy…"));
-          lastChange$.next(Date.now());
-        }
-      }
-    });
-
-    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,
-            rpcBatch: false,
-            skipBuild: false,
-            printConfig: false,
-            profile: undefined,
-            saveDeployment: true,
-            deployerAddress: undefined,
-            worldAddress,
-            srcDir,
-            salt: "0x",
-            kms: undefined,
-          });
-          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();
-  },
-};
-
-export default commandModule;

package/src/commands/devnode.ts

@@ -1,42 +0,0 @@
-import { rmSync } from "fs";
-import { homedir } from "os";
-import path from "path";
-import type { CommandModule } from "yargs";
-import { execa } from "execa";
-
-type Options = {
-  blocktime: number;
-};
-
-const commandModule: CommandModule<Options, Options> = {
-  command: "devnode",
-
-  describe: "Start a local Ethereum node for development",
-
-  builder(yargs) {
-    return yargs.options({
-      blocktime: { type: "number", default: 1, decs: "Interval in which new blocks are produced" },
-    });
-  },
-
-  async handler({ blocktime }) {
-    console.log("Clearing devnode history");
-    const userHomeDir = homedir();
-    rmSync(path.join(userHomeDir, ".foundry", "anvil", "tmp"), { recursive: true, force: true });
-
-    const anvilArgs = ["-b", String(blocktime), "--block-base-fee-per-gas", "0"];
-    console.log(`Running: anvil ${anvilArgs.join(" ")}`);
-    const child = execa("anvil", anvilArgs, {
-      stdio: ["inherit", "inherit", "inherit"],
-    });
-
-    process.on("SIGINT", () => {
-      console.log("\ngracefully shutting down from SIGINT (Crtl-C)");
-      child.kill();
-      process.exit();
-    });
-    await child;
-  },
-};
-
-export default commandModule;

package/src/commands/hello.ts

@@ -1,28 +0,0 @@
-import type { CommandModule } from "yargs";
-
-type Options = {
-  name: string;
-  upper: boolean | undefined;
-};
-
-const commandModule: CommandModule<Options, Options> = {
-  command: "hello <name>",
-
-  describe: "Greet <name> with Hello",
-
-  builder(yargs) {
-    return yargs
-      .options({
-        upper: { type: "boolean" },
-      })
-      .positional("name", { type: "string", demandOption: true });
-  },
-
-  handler({ name }) {
-    const greeting = `Gm, ${name}!`;
-    console.log(greeting);
-    process.exit(0);
-  },
-};
-
-export default commandModule;

package/src/commands/index.ts

@@ -1,33 +0,0 @@
-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 hello from "./hello";
-import tablegen from "./tablegen";
-import deploy from "./deploy";
-import worldgen from "./worldgen";
-import setVersion from "./set-version";
-import test from "./test";
-import trace from "./trace";
-import devContracts from "./dev-contracts";
-import verify from "./verify";
-
-// eslint-disable-next-line @typescript-eslint/no-explicit-any -- Each command has different options
-export const commands: CommandModule<any, any>[] = [
-  build,
-  deploy,
-  devnode,
-  gasReport as CommandModule,
-  hello,
-  tablegen,
-  worldgen,
-  setVersion,
-  test,
-  trace,
-  devContracts,
-  abiTs,
-  verify,
-];

package/src/commands/set-version.ts

@@ -1,197 +0,0 @@
-import chalk from "chalk";
-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;
-  force?: boolean;
-  restore?: boolean;
-  mudVersion?: string;
-  tag?: string;
-  commit?: string;
-  link?: string;
-};
-
-const commandModule: CommandModule<Options, Options> = {
-  command: "set-version",
-
-  describe: "Set MUD version in all package.json files and optionally backup the previously installed version",
-
-  builder(yargs) {
-    return yargs.options({
-      mudVersion: { alias: "v", type: "string", description: "Set MUD to the given version" },
-      tag: {
-        alias: "t",
-        type: "string",
-        description: "Set MUD to the latest version with the given tag from npm",
-      },
-      commit: {
-        alias: "c",
-        type: "string",
-        description: "Set MUD to the version based on a given git commit hash from npm",
-      },
-      link: { alias: "l", type: "string", description: "Relative path to the local MUD root directory to link" },
-    });
-  },
-
-  async handler(options) {
-    try {
-      const mutuallyExclusiveOptions = ["mudVersion", "link", "tag", "commit", "restore"];
-      const numMutuallyExclusiveOptions = mutuallyExclusiveOptions.reduce(
-        (acc, opt) => (options[opt] ? acc + 1 : acc),
-        0,
-      );
-
-      if (numMutuallyExclusiveOptions === 0) {
-        throw new MUDError(`You need to provide one these options: ${mutuallyExclusiveOptions.join(", ")}`);
-      }
-
-      if (numMutuallyExclusiveOptions > 1) {
-        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`
-      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"));
-      for (const packageJson of packageJsons) {
-        updatePackageJson(packageJson, options);
-      }
-    } catch (e) {
-      logError(e);
-    } finally {
-      process.exit(0);
-    }
-  },
-};
-
-async function resolveVersion(options: Options) {
-  // Backwards compatibility to previous behavior of this script where passing "canary" as the version resolved to the latest commit on main
-  if (options.mudVersion === "canary") options.tag = "main";
-
-  let npmResult;
-  try {
-    console.log(chalk.blue(`Fetching available versions`));
-    npmResult = await (await fetch(`https://registry.npmjs.org/${localPackageJson.name}`)).json();
-  } catch (e) {
-    throw new MUDError(`Could not fetch available MUD versions`);
-  }
-
-  if (options.tag) {
-    const version = npmResult["dist-tags"][options.tag];
-    if (!version) {
-      throw new MUDError(`Could not find npm version with tag "${options.tag}"`);
-    }
-    console.log(chalk.green(`Latest version with tag ${options.tag}: ${version}`));
-    return version;
-  }
-
-  if (options.commit) {
-    // Find a version with this commit hash
-    const commit = options.commit.substring(0, 8); // changesets uses the first 8 characters of the commit hash as version for prereleases/snapshot releases
-    const version = Object.keys(npmResult["versions"]).find((v) => (v as string).includes(commit));
-    if (!version) {
-      throw new MUDError(`Could not find npm version based on commit "${options.commit}"`);
-    }
-    console.log(chalk.green(`Version from commit ${options.commit}: ${version}`));
-    return version;
-  }
-
-  // If neither a tag nor a commit option is given, return the `mudVersion`
-  return options.mudVersion;
-}
-
-function updatePackageJson(filePath: string, options: Options): { workspaces?: string[] } {
-  const { link } = options;
-  let { mudVersion } = options;
-
-  const packageJson = readPackageJson(filePath);
-  const mudPackageNames = Object.keys(mudPackages);
-
-  // Find all MUD dependencies
-  const mudDependencies: Record<string, string> = {};
-  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 packageName in packageJson.devDependencies) {
-    if (mudPackageNames.includes(packageName)) {
-      mudDevDependencies[packageName] = packageJson.devDependencies[packageName];
-    }
-  }
-
-  // Update the dependencies
-  for (const packageName in packageJson.dependencies) {
-    if (mudPackageNames.includes(packageName)) {
-      packageJson.dependencies[packageName] = resolveMudVersion(packageName, "dependencies");
-    }
-  }
-
-  // Update the devDependencies
-  for (const packageName in packageJson.devDependencies) {
-    if (mudPackageNames.includes(packageName)) {
-      packageJson.devDependencies[packageName] = resolveMudVersion(packageName, "devDependencies");
-    }
-  }
-
-  // Write the updated package.json
-  writeFileSync(filePath, JSON.stringify(packageJson, null, 2) + "\n");
-
-  console.log(`Updating ${filePath}`);
-  logComparison(mudDependencies, packageJson.dependencies);
-  logComparison(mudDevDependencies, packageJson.devDependencies);
-
-  return packageJson;
-
-  function resolveMudVersion(key: string, type: "dependencies" | "devDependencies") {
-    if (link) mudVersion = resolveLinkPath(filePath, link, key);
-    if (!mudVersion) return packageJson[type][key];
-    return mudVersion;
-  }
-}
-
-function readPackageJson(path: string): {
-  workspaces?: string[];
-  dependencies: Record<string, string>;
-  devDependencies: Record<string, string>;
-} {
-  try {
-    const jsonString = readFileSync(path, "utf8");
-    return JSON.parse(jsonString);
-  } catch {
-    throw new MUDError("Could not read JSON at " + path);
-  }
-}
-
-function logComparison(prev: Record<string, string>, curr: Record<string, string>) {
-  for (const key in prev) {
-    if (prev[key] !== curr[key]) {
-      console.log(`${key}: ${chalk.red(prev[key])} -> ${chalk.green(curr[key])}`);
-    }
-  }
-}
-
-/**
- * Returns path of the package to link, given a path to a local MUD clone and a package
- */
-function resolveLinkPath(packageJsonPath: string, mudLinkPath: string, packageName: string) {
-  const packageJsonToRootPath = path.relative(path.dirname(packageJsonPath), process.cwd());
-  const linkPath = path.join(packageJsonToRootPath, mudLinkPath, mudPackages[packageName].localPath);
-  return "link:" + linkPath;
-}
-
-export default commandModule;

package/src/commands/tablegen.ts

@@ -1,34 +0,0 @@
-import path from "path";
-import type { CommandModule } from "yargs";
-import { loadConfig } from "@latticexyz/config/node";
-import { Store as StoreConfig } from "@latticexyz/store";
-import { tablegen } from "@latticexyz/store/codegen";
-import { getRemappings, getSrcDirectory } from "@latticexyz/common/foundry";
-
-type Options = {
-  configPath?: string;
-};
-
-const commandModule: CommandModule<Options, Options> = {
-  command: "tablegen",
-
-  describe: "Autogenerate MUD Store table libraries based on the config file",
-
-  builder(yargs) {
-    return yargs.options({
-      configPath: { type: "string", desc: "Path to the MUD config file" },
-    });
-  },
-
-  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.codegen.outputDirectory), remappings);
-
-    process.exit(0);
-  },
-};
-
-export default commandModule;

package/src/commands/test.ts

@@ -1,65 +0,0 @@
-import type { CommandModule, InferredOptionTypes, Options } from "yargs";
-import { anvil, forge, getRpcUrl } from "@latticexyz/common/foundry";
-import chalk from "chalk";
-import { deployOptions, runDeploy } from "../runDeploy";
-
-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>;
-
-type TestOptions = InferredOptionTypes<typeof testOptions>;
-
-const commandModule: CommandModule<typeof testOptions, TestOptions> = {
-  command: "test",
-
-  describe: "Run tests in MUD contracts",
-
-  builder(yargs) {
-    return yargs.options(testOptions);
-  },
-
-  async handler(opts) {
-    // Start an internal anvil process if no world address is provided
-    if (!opts.worldAddress) {
-      const anvilArgs = ["--block-base-fee-per-gas", "0", "--port", String(opts.port)];
-      anvil(anvilArgs);
-    }
-
-    const forkRpc = opts.worldAddress ? await getRpcUrl(opts.profile) : `http://127.0.0.1:${opts.port}`;
-
-    const worldAddress =
-      opts.worldAddress ??
-      (
-        await runDeploy({
-          ...opts,
-          saveDeployment: false,
-          rpc: forkRpc,
-        })
-      ).address;
-
-    console.log(chalk.blue("World address", worldAddress));
-
-    const userOptions = opts.forgeOptions?.replaceAll("\\", "").split(" ") ?? [];
-    try {
-      await forge(["test", "--fork-url", forkRpc, ...userOptions], {
-        profile: opts.profile,
-        env: {
-          WORLD_ADDRESS: worldAddress,
-        },
-      });
-      process.exit(0);
-    } catch (e) {
-      console.error(e);
-      process.exit(1);
-    }
-  },
-};
-
-export default commandModule;

package/src/commands/trace.ts

@@ -1,120 +0,0 @@
-import { existsSync, readFileSync } from "fs";
-import type { CommandModule } from "yargs";
-import { ethers } from "ethers";
-
-import { loadConfig } from "@latticexyz/config/node";
-import { MUDError } from "@latticexyz/common/errors";
-import { cast, getRpcUrl, getSrcDirectory } from "@latticexyz/common/foundry";
-import { resolveWorldConfig } from "@latticexyz/world/internal";
-import IBaseWorldAbi from "@latticexyz/world/out/IBaseWorld.sol/IBaseWorld.abi.json" assert { type: "json" };
-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";
-import { World as WorldConfig } from "@latticexyz/world";
-import { worldToV1 } from "@latticexyz/world/config/v2";
-
-// TODO account for multiple namespaces (https://github.com/latticexyz/mud/issues/994)
-const systemsTableId = resourceToHex({
-  type: "system",
-  namespace: worldConfig.namespace,
-  name: worldConfig.tables.world__Systems.name,
-});
-
-type Options = {
-  tx: string;
-  worldAddress?: string;
-  configPath?: string;
-  profile?: string;
-  srcDir?: string;
-  rpc?: string;
-};
-
-const commandModule: CommandModule<Options, Options> = {
-  command: "trace",
-
-  describe: "Display the trace of a transaction",
-
-  builder(yargs) {
-    return yargs.options({
-      tx: { type: "string", required: true, description: "Transaction hash to replay" },
-      worldAddress: {
-        type: "string",
-        description: "World contract address. Defaults to the value from worlds.json, based on rpc's chainId",
-      },
-      configPath: { type: "string", description: "Path to the MUD config file" },
-      profile: { type: "string", description: "The foundry profile to use" },
-      srcDir: { type: "string", description: "Source directory. Defaults to foundry src directory." },
-      rpc: { type: "string", description: "json rpc endpoint. Defaults to foundry's configured eth_rpc_url" },
-    });
-  },
-
-  async handler(args) {
-    args.profile ??= process.env.FOUNDRY_PROFILE;
-    const { profile } = args;
-    args.srcDir ??= await getSrcDirectory(profile);
-    args.rpc ??= await getRpcUrl(profile);
-    const { tx, configPath, srcDir, rpc } = args;
-
-    const existingContracts = getExistingContracts(srcDir);
-
-    // Load the config
-    const configV2 = (await loadConfig(configPath)) as WorldConfig;
-    const mudConfig = worldToV1(configV2);
-
-    const resolvedConfig = resolveWorldConfig(
-      mudConfig,
-      existingContracts.map(({ basename }) => basename),
-    );
-
-    // Get worldAddress either from args or from worldsFile
-    const worldAddress = args.worldAddress ?? (await getWorldAddress(mudConfig.worldsFile, rpc));
-
-    // Create World contract instance from deployed address
-    const provider = new ethers.providers.StaticJsonRpcProvider(rpc);
-    const WorldContract = new ethers.Contract(worldAddress, IBaseWorldAbi, provider);
-
-    // TODO account for multiple namespaces (https://github.com/latticexyz/mud/issues/994)
-    const namespace = mudConfig.namespace;
-    const names = Object.values(resolvedConfig.systems).map(({ name }) => name);
-
-    // Fetch system table field layout from chain
-    const systemTableFieldLayout = await WorldContract.getFieldLayout(systemsTableId);
-    const labels: { name: string; address: string }[] = [];
-    for (const name of names) {
-      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 });
-    }
-
-    const result = await cast([
-      "run",
-      "--label",
-      `${worldAddress}:World`,
-      ...labels.map(({ name, address }) => ["--label", `${address}:${name}`]).flat(),
-      `${tx}`,
-    ]);
-    console.log(result);
-
-    process.exit(0);
-  },
-};
-
-export default commandModule;
-
-async function getWorldAddress(worldsFile: string, rpc: string) {
-  if (existsSync(worldsFile)) {
-    const client = createClient({ transport: http(rpc) });
-    const chainId = await getChainId(client);
-    const deploys = JSON.parse(readFileSync(worldsFile, "utf-8"));
-
-    if (!deploys[chainId]) {
-      throw new MUDError(`chainId ${chainId} is missing in worldsFile "${worldsFile}"`);
-    }
-    return deploys[chainId].address as string;
-  } else {
-    throw new MUDError("worldAddress is not specified and worldsFile is missing");
-  }
-}