@latticexyz/cli 2.0.0-alpha.0 → 2.0.0-alpha.1

package/src/commands/deploy-v2.ts

@@ -1,80 +1,81 @@
 import chalk from "chalk";
 import glob from "glob";
 import path, { basename } from "path";
-import type { CommandModule } from "yargs";
-import { loadWorldConfig } from "../config/world/index.js";
+import type { CommandModule, Options } from "yargs";
+import { loadStoreConfig, loadWorldConfig } from "@latticexyz/config";
+import { MUDError } from "@latticexyz/config";
 import { deploy } from "../utils/deploy-v2.js";
-import { logError, MUDError } from "../utils/errors.js";
+import { logError } from "../utils/errors.js";
 import { forge, getRpcUrl, getSrcDirectory } from "../utils/foundry.js";
 import { mkdirSync, writeFileSync } from "fs";
-import { loadStoreConfig } from "../config/loadStoreConfig.js";
 import { getChainId } from "../utils/getChainId.js";
 
-type Options = {
+export type DeployOptions = {
   configPath?: string;
   printConfig?: boolean;
   profile?: string;
-  privateKey: string;
   priorityFeeMultiplier: number;
   clean?: boolean;
   debug?: boolean;
+  saveDeployment?: boolean;
+  rpc?: string;
+  worldAddress?: string;
+  srcDir?: string;
 };
 
-const commandModule: CommandModule<Options, Options> = {
-  command: "deploy-v2",
-
-  describe: "Deploy MUD v2 contracts",
-
-  builder(yargs) {
-    return yargs.options({
-      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,
-      },
-    });
+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,
   },
-
-  async handler(args) {
-    args.profile = args.profile ?? process.env.FOUNDRY_PROFILE;
-    const { configPath, printConfig, profile, clean } = args;
-
-    const rpc = await getRpcUrl(profile);
-    console.log(
-      chalk.bgBlue(
-        chalk.whiteBright(`\n Deploying MUD v2 contracts${profile ? " with profile " + profile : ""} to RPC ${rpc} \n`)
-      )
-    );
-
-    if (clean) await forge(["clean"], { profile });
-
-    // Run forge build
-    await forge(["build"], { profile });
-
-    // Get a list of all contract names
-    const srcDir = await getSrcDirectory();
-    const existingContracts = glob
-      .sync(`${srcDir}/**/*.sol`)
-      // Get the basename of the file
-      .map((path) => basename(path, ".sol"));
-
-    // Load and resolve the config
-    const worldConfig = await loadWorldConfig(configPath, existingContracts);
-    const storeConfig = await loadStoreConfig(configPath);
-    const mudConfig = { ...worldConfig, ...storeConfig };
-
-    if (printConfig) console.log(chalk.green("\nResolved config:\n"), JSON.stringify(mudConfig, null, 2));
-
-    try {
-      const privateKey = process.env.PRIVATE_KEY;
-      if (!privateKey) throw new MUDError("Missing PRIVATE_KEY environment variable");
-      const deploymentInfo = await deploy(mudConfig, { ...args, rpc, privateKey });
-
+  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." },
+} satisfies Record<keyof DeployOptions, Options>;
+
+export async function deployHandler(args: Parameters<(typeof commandModule)["handler"]>[0]) {
+  args.profile = args.profile ?? process.env.FOUNDRY_PROFILE;
+  const { configPath, printConfig, profile, clean } = args;
+
+  const rpc = args.rpc ?? (await getRpcUrl(profile));
+  console.log(
+    chalk.bgBlue(
+      chalk.whiteBright(`\n Deploying MUD v2 contracts${profile ? " with profile " + profile : ""} to RPC ${rpc} \n`)
+    )
+  );
+
+  if (clean) await forge(["clean"], { profile });
+
+  // Run forge build
+  await forge(["build"], { profile });
+
+  // Get a list of all contract names
+  const srcDir = args?.srcDir ?? (await getSrcDirectory());
+  const existingContracts = glob
+    .sync(`${srcDir}/**/*.sol`)
+    // Get the basename of the file
+    .map((path) => basename(path, ".sol"));
+
+  // Load and resolve the config
+  const worldConfig = await loadWorldConfig(configPath, existingContracts);
+  const storeConfig = await loadStoreConfig(configPath);
+  const mudConfig = { ...worldConfig, ...storeConfig };
+
+  if (printConfig) console.log(chalk.green("\nResolved config:\n"), JSON.stringify(mudConfig, null, 2));
+
+  try {
+    const privateKey = process.env.PRIVATE_KEY;
+    if (!privateKey) throw new MUDError("Missing PRIVATE_KEY environment variable");
+    const deploymentInfo = await deploy(mudConfig, { ...args, rpc, privateKey });
+
+    if (args.saveDeployment) {
       // Write deployment result to file (latest and timestamp)
       const chainId = await getChainId(rpc);
       const outputDir = path.join(mudConfig.deploysDirectory, chainId.toString());
@@ -83,12 +84,27 @@ const commandModule: CommandModule<Options, Options> = {
       writeFileSync(path.join(outputDir, Date.now() + ".json"), JSON.stringify(deploymentInfo, null, 2));
 
       console.log(chalk.bgGreen(chalk.whiteBright(`\n Deployment result (written to ${outputDir}): \n`)));
-      console.log(deploymentInfo);
-    } catch (error: any) {
-      logError(error);
-      process.exit(1);
     }
 
+    console.log(deploymentInfo);
+    return deploymentInfo;
+  } catch (error: any) {
+    logError(error);
+    process.exit(1);
+  }
+}
+
+const commandModule: CommandModule<DeployOptions, DeployOptions> = {
+  command: "deploy-v2",
+
+  describe: "Deploy MUD v2 contracts",
+
+  builder(yargs) {
+    return yargs.options(yDeployOptions);
+  },
+
+  async handler(args) {
+    await deployHandler(args);
     process.exit(0);
   },
 };

package/src/commands/deprecated/index.ts

@@ -0,0 +1,22 @@
+import { CommandModule } from "yargs";
+
+import bulkupload from "./bulkupload.js";
+import callSystem from "./call-system.js";
+import codegenLibdeploy from "./codegen-libdeploy.js";
+import deployContracts from "./deploy-contracts.js";
+import systemTypes from "./system-types.js";
+import test from "./test.js";
+import trace from "./trace.js";
+import types from "./types.js";
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any -- Each command has different options
+export const commands: CommandModule<any, any>[] = [
+  bulkupload,
+  callSystem,
+  deployContracts,
+  codegenLibdeploy,
+  systemTypes,
+  test,
+  trace,
+  types,
+];

package/src/commands/deprecated/test.ts

@@ -43,7 +43,7 @@ const commandModule: CommandModule<Options, Options> = {
     });
 
     await child;
-    
+
     // Reset LibDeploy.sol
     console.log("Reset LibDeploy.sol");
     await resetLibDeploy(testDir);

package/src/commands/gas-report.ts

@@ -39,6 +39,8 @@ type GasReportEntry = {
 
 type GasReport = GasReportEntry[];
 
+const tempFileSuffix = "MudGasReport";
+
 const commandModule: CommandModule<Options, Options> = {
   command: "gas-report",
 
@@ -52,43 +54,43 @@ const commandModule: CommandModule<Options, Options> = {
     });
   },
 
-  async handler({ path, save, compare }) {
-    let gasReport: GasReport = [];
+  async handler({ path: files, save, compare }) {
+    const validFiles = files.filter((file) => file.endsWith(".t.sol"));
+    const tempFiles = await Promise.all(validFiles.map((file) => createGasReport(file)));
+
+    process.once("SIGINT", () => {
+      console.log("caught sigint, deleting temp files");
+      tempFiles.forEach((file) => rmSync(file));
+    });
 
-    // Iterate through all files provided in the path
-    for (const file of path) {
-      gasReport = gasReport.concat(await runGasReport(file));
+    let gasReport: GasReport;
+    try {
+      gasReport = await runGasReport();
+    } catch {
+      setTimeout(() => process.exit());
+      return;
+    } finally {
+      // Delete the temporary files
+      tempFiles.forEach((file) => rmSync(file));
     }
 
     // If this gas report should be compared to an existing one, load the existing one
-    const compareGasReport: GasReport = [];
     if (compare) {
       try {
-        const compareFileContents = readFileSync(compare, "utf8");
-        // Create a regex to extract the name, function call and gas used
-        const compareGasReportRegex = new RegExp(/\((.*)\) \| (.*) \[(.*)\]: (.*)/g);
-        // Loop through the matches and add the resuls to the compareGasReport
-        let compareGasReportMatch;
-        while ((compareGasReportMatch = compareGasReportRegex.exec(compareFileContents)) !== null) {
-          const source = compareGasReportMatch[1];
-          const name = compareGasReportMatch[2];
-          const functionCall = compareGasReportMatch[3];
-          const gasUsed = compareGasReportMatch[4];
-
-          compareGasReport.push({ source, name, functionCall, gasUsed: parseInt(gasUsed) });
-        }
+        const compareGasReport: GasReport = JSON.parse(readFileSync(compare, "utf8"));
+        // Merge the previous gas report with the new one
+        gasReport = gasReport.map((entry) => {
+          const prevEntry = compareGasReport.find(
+            (e) => e.name === entry.name && e.functionCall === entry.functionCall
+          );
+          return { ...entry, prevGasUsed: prevEntry?.gasUsed };
+        });
       } catch {
         console.log(chalk.red(`Gas report to compare not found: ${compare}`));
         compare = undefined;
       }
     }
 
-    // Merge the previous gas report with the new one
-    gasReport = gasReport.map((entry) => {
-      const prevEntry = compareGasReport.find((e) => e.name === entry.name && e.functionCall === entry.functionCall);
-      return { ...entry, prevGasUsed: prevEntry?.gasUsed };
-    });
-
     // Print gas report
     printGasReport(gasReport, compare);
 
@@ -101,16 +103,11 @@ const commandModule: CommandModule<Options, Options> = {
 
 export default commandModule;
 
-async function runGasReport(path: string): Promise<GasReport> {
-  if (!path.endsWith(".t.sol")) {
-    console.log("Skipping gas report for", chalk.bold(path), "(not a test file)");
-    return [];
-  }
-  console.log("Running gas report for", chalk.bold(path));
-  const gasReport: GasReport = [];
+async function createGasReport(filename: string): Promise<string> {
+  console.log("Creating gas report for", chalk.bold(filename));
 
   // Parse the given test file, and add gas reporting wherever requested by a `// !gasreport` comment
-  const fileContents = readFileSync(path, "utf8");
+  const fileContents = readFileSync(filename, "utf8");
   let newFile = fileContents;
 
   // Use a regex to find first line of each function
@@ -139,7 +136,7 @@ async function runGasReport(path: string): Promise<GasReport> {
 _gasreport = gasleft();
 ${functionCall}
 _gasreport = _gasreport - gasleft();
-console.log("GAS REPORT: ${name} [${functionCall.replaceAll('"', '\\"')}]:", _gasreport);`
+console.log("GAS REPORT(${filename}): ${name} [${functionCall.replaceAll('"', '\\"')}]:", _gasreport);`
     );
   }
 
@@ -148,41 +145,47 @@ console.log("GAS REPORT: ${name} [${functionCall.replaceAll('"', '\\"')}]:", _ga
 
   // Write the new file to disk (temporarily)
   // Create the temp file by replacing the previous file name with MudGasReport
-  const tempFileName = path.replace(/\.t\.sol$/, "MudGasReport.t.sol");
+  const tempFileName = filename.replace(/\.t\.sol$/, `${tempFileSuffix}.t.sol`);
   writeFileSync(tempFileName, newFile);
 
-  // Run the generated file using forge
-  const child = execa("forge", ["test", "--match-path", tempFileName, "-vvv"], {
-    stdio: ["inherit", "pipe", "inherit"],
-  });
+  return tempFileName;
+}
+
+async function runGasReport(): Promise<GasReport> {
+  console.log("Running gas report");
+  const gasReport: GasReport = [];
 
   // Extract the logs from the child process
   let logs = "";
   try {
+    // Run the generated file using forge
+    const child = execa("forge", ["test", "--match-path", `*${tempFileSuffix}*`, "-vvv"], {
+      stdio: ["inherit", "pipe", "inherit"],
+    });
     logs = (await child).stdout;
-    rmSync(tempFileName);
-  } catch (e: any) {
-    console.log(e.stdout ?? e);
+  } catch (error: any) {
+    console.log(error.stdout ?? error);
     console.log(chalk.red("\n-----------\nError while running the gas report (see above)"));
-    rmSync(tempFileName);
-    process.exit();
+    throw error;
   }
 
   // Extract the gas reports from the logs
 
   // Create a regex to find all lines starting with `GAS REPORT:` and extract the name, function call and gas used
-  const gasReportRegex = new RegExp(/GAS REPORT: (.*) \[(.*)\]: (.*)/g);
+  const gasReportRegex = new RegExp(/GAS REPORT\((.*)\): (.*) \[(.*)\]: (.*)/g);
 
   // Loop through the matches and print the gas report
   let gasReportMatch;
   while ((gasReportMatch = gasReportRegex.exec(logs)) !== null) {
-    const name = gasReportMatch[1];
-    const functionCall = gasReportMatch[2].replace(";", "");
-    const gasUsed = gasReportMatch[3];
-
-    gasReport.push({ source: path, name, functionCall, gasUsed: parseInt(gasUsed) });
+    const source = gasReportMatch[1];
+    const name = gasReportMatch[2];
+    const functionCall = gasReportMatch[3].replace(";", "");
+    const gasUsed = parseInt(gasReportMatch[4]);
+    gasReport.push({ source, name, functionCall, gasUsed });
   }
 
+  gasReport.sort((a, b) => a.source.localeCompare(b.source));
+
   return gasReport;
 }
 
@@ -212,9 +215,5 @@ function printGasReport(gasReport: GasReport, compare?: string) {
 
 function saveGasReport(gasReport: GasReport, path: string) {
   console.log(chalk.bold(`Saving gas report to ${path}`));
-  const serializedGasReport = gasReport
-    .map((entry) => `(${entry.source}) | ${entry.name} [${entry.functionCall}]: ${entry.gasUsed}`)
-    .join("\n");
-
-  writeFileSync(path, serializedGasReport);
+  writeFileSync(path, `${JSON.stringify(gasReport, null, 2)}\n`);
 }

package/src/commands/index.ts

@@ -1,37 +1,26 @@
 import { CommandModule } from "yargs";
 
-import bulkupload from "./deprecated/bulkupload.js";
-import callSystem from "./deprecated/call-system.js";
-import codegenLibdeploy from "./deprecated/codegen-libdeploy.js";
-import deployContracts from "./deprecated/deploy-contracts.js";
-import systemTypes from "./deprecated/system-types.js";
-import test from "./deprecated/test.js";
-import trace from "./deprecated/trace.js";
-import types from "./deprecated/types.js";
-
 import devnode from "./devnode.js";
 import faucet from "./faucet.js";
 import gasReport from "./gas-report.js";
 import hello from "./hello.js";
 import tablegen from "./tablegen.js";
+import tsgen from "./tsgen.js";
 import deployV2 from "./deploy-v2.js";
 import worldgen from "./worldgen.js";
+import setVersion from "./set-version.js";
+import testV2 from "./test-v2.js";
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any -- Each command has different options
 export const commands: CommandModule<any, any>[] = [
-  bulkupload,
-  callSystem,
-  codegenLibdeploy,
-  deployContracts,
   deployV2,
   devnode,
   faucet,
   gasReport,
   hello,
-  systemTypes,
   tablegen,
-  test,
-  trace,
-  types,
+  tsgen,
   worldgen,
+  setVersion,
+  testV2,
 ];

package/src/commands/set-version.ts

@@ -0,0 +1,172 @@
+import chalk from "chalk";
+import { existsSync, readFileSync, rmSync, writeFileSync } from "fs";
+import path from "path";
+import type { CommandModule } from "yargs";
+import { MUDError } from "@latticexyz/config";
+import { logError } from "../utils/errors.js";
+import localPackageJson from "../../package.json" assert { type: "json" };
+
+type Options = {
+  backup?: boolean;
+  force?: boolean;
+  restore?: boolean;
+  mudVersion?: string;
+};
+
+const BACKUP_FILE = ".mudbackup";
+const MUD_PREFIX = "@latticexyz";
+
+const commandModule: CommandModule<Options, Options> = {
+  command: "set-version",
+
+  describe: "Install a custom MUD version and optionally backup the previously installed version",
+
+  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: "The MUD version to install" },
+    });
+  },
+
+  async handler(options) {
+    try {
+      if (!options.mudVersion && !options.restore) {
+        throw new MUDError(`Version parameter is required unless --restore is provided.`);
+      }
+
+      // Resolve the `canary` version number if needed
+      options.mudVersion =
+        options.mudVersion === "canary" ? await getCanaryVersion(localPackageJson.name) : options.mudVersion;
+
+      // Read the current package.json
+      const rootPath = "./package.json";
+      const { workspaces } = updatePackageJson(rootPath, options);
+
+      // Load the package.json of each workspace
+      if (workspaces) {
+        for (const workspace of workspaces) {
+          const filePath = path.join(workspace, "/package.json");
+          updatePackageJson(filePath, options);
+        }
+      }
+    } catch (e) {
+      logError(e);
+    } finally {
+      process.exit(0);
+    }
+  },
+};
+
+function updatePackageJson(filePath: string, options: Options): { workspaces?: string[] } {
+  const { backup, restore, force, mudVersion } = options;
+  const backupFilePath = path.join(path.dirname(filePath), BACKUP_FILE);
+
+  // 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 && existsSync(backupFilePath)) {
+    throw new MUDError(
+      `A backup file already exists at ${backupFilePath}.\nUse --force to overwrite it or --restore to restore it.`
+    );
+  }
+
+  const packageJson = readPackageJson(filePath);
+
+  // Load .mudbackup if `restore` is true
+  const backupJson = restore ? readPackageJson(backupFilePath) : undefined;
+
+  // 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];
+    }
+  }
+
+  // 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];
+    }
+  }
+
+  // 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] =
+        restore && backupJson ? backupJson.dependencies[key] : mudVersion || packageJson.dependencies[key];
+    }
+  }
+
+  // Update the devDependencies
+  for (const key in packageJson.devDependencies) {
+    if (key.startsWith(MUD_PREFIX)) {
+      packageJson.devDependencies[key] =
+        restore && backupJson ? backupJson.devDependencies[key] : mudVersion || packageJson.devDependencies[key];
+    }
+  }
+
+  // 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);
+
+  // 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 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);
+  }
+}
+
+async function getCanaryVersion(pkg: string) {
+  try {
+    console.log(chalk.blue("fetching MUD canary version..."));
+    const result = await (await fetch(`https://registry.npmjs.org/${pkg}`)).json();
+    const canary = result["dist-tags"].canary;
+    console.log(chalk.green("MUD canary version:", canary));
+    return canary;
+  } catch (e) {
+    throw new MUDError(`Could not fetch canary version of ${pkg}`);
+  }
+}
+
+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])}`);
+    }
+  }
+}
+
+export default commandModule;

package/src/commands/tablegen.ts

@@ -1,7 +1,8 @@
+import path from "path";
 import type { CommandModule } from "yargs";
-import { loadStoreConfig } from "../config/loadStoreConfig.js";
-import { getSrcDirectory } from "../utils/foundry.js";
+import { loadStoreConfig } from "@latticexyz/config";
 import { tablegen } from "../render-solidity/tablegen.js";
+import { getSrcDirectory } from "../utils/index.js";
 
 type Options = {
   configPath?: string;
@@ -19,11 +20,10 @@ const commandModule: CommandModule<Options, Options> = {
   },
 
   async handler({ configPath }) {
-    const srcDirectory = await getSrcDirectory();
-
     const config = await loadStoreConfig(configPath);
+    const srcDir = await getSrcDirectory();
 
-    await tablegen(config, srcDirectory);
+    await tablegen(config, path.join(srcDir, config.codegenDirectory));
 
     process.exit(0);
   },