@latticexyz/cli 1.41.0 → 1.41.1-alpha.41

package/src/utils/contractToInterface.ts

@@ -0,0 +1,130 @@
+import { parse, visit } from "@solidity-parser/parser";
+import { TypeName, VariableDeclaration } from "@solidity-parser/parser/dist/src/ast-types.js";
+import { RenderSystemInterfaceFunction } from "../render-solidity/types.js";
+import { MUDError } from "./errors.js";
+
+/**
+ * Parse the contract data to get the functions necessary to generate an interface,
+ * and symbols to import from the original contract.
+ * @param data contents of a file with the solidity contract
+ * @param contractName name of the contract
+ * @returns interface data
+ */
+export function contractToInterface(data: string, contractName: string) {
+  const ast = parse(data);
+
+  let withContract = false;
+  let symbols: string[] = [];
+  const functions: RenderSystemInterfaceFunction[] = [];
+
+  visit(ast, {
+    ContractDefinition({ name }) {
+      if (name === contractName) {
+        withContract = true;
+      }
+    },
+    FunctionDefinition(
+      { name, visibility, parameters, returnParameters, isConstructor, isFallback, isReceiveEther },
+      parent
+    ) {
+      if (parent !== undefined && parent.type === "ContractDefinition" && parent.name === contractName) {
+        try {
+          // skip constructor and fallbacks
+          if (isConstructor || isFallback || isReceiveEther) return;
+          // forbid default visibility (this check might be unnecessary, modern solidity already disallows this)
+          if (visibility === "default") throw new MUDError(`Visibility is not specified`);
+
+          if (visibility === "external" || visibility === "public") {
+            functions.push({
+              name: name === null ? "" : name,
+              parameters: parameters.map(parseParameter),
+              returnParameters: returnParameters === null ? [] : returnParameters.map(parseParameter),
+            });
+
+            for (const { typeName } of parameters.concat(returnParameters ?? [])) {
+              symbols = symbols.concat(typeNameToExternalSymbols(typeName));
+            }
+          }
+        } catch (error: unknown) {
+          if (error instanceof MUDError) {
+            error.message = `Function "${name}" in contract "${contractName}": ${error.message}`;
+          }
+          throw error;
+        }
+      }
+    },
+  });
+
+  if (!withContract) {
+    throw new MUDError(`Contract not found: ${contractName}`);
+  }
+
+  return {
+    functions,
+    symbols,
+  };
+}
+
+function parseParameter({ name, typeName, storageLocation }: VariableDeclaration): string {
+  let typedNameWithLocation = "";
+
+  const { name: flattenedTypeName, stateMutability } = flattenTypeName(typeName);
+  // type name (e.g. uint256)
+  typedNameWithLocation += flattenedTypeName;
+  // optional mutability (e.g. address payable)
+  if (stateMutability !== null) {
+    typedNameWithLocation += ` ${stateMutability}`;
+  }
+  // location, when relevant (e.g. string memory)
+  if (storageLocation !== null) {
+    typedNameWithLocation += ` ${storageLocation}`;
+  }
+  // optional variable name
+  if (name !== null) {
+    typedNameWithLocation += ` ${name}`;
+  }
+
+  return typedNameWithLocation;
+}
+
+function flattenTypeName(typeName: TypeName | null): { name: string; stateMutability: string | null } {
+  if (typeName === null) {
+    return {
+      name: "",
+      stateMutability: null,
+    };
+  }
+  if (typeName.type === "ElementaryTypeName") {
+    return {
+      name: typeName.name,
+      stateMutability: typeName.stateMutability,
+    };
+  } else if (typeName.type === "UserDefinedTypeName") {
+    return {
+      name: typeName.namePath,
+      stateMutability: null,
+    };
+  } else if (typeName.type === "ArrayTypeName") {
+    const { name, stateMutability } = flattenTypeName(typeName.baseTypeName);
+    return {
+      name: `${name}[]`,
+      stateMutability,
+    };
+  } else {
+    // TODO function types are unsupported but could be useful
+    throw new MUDError(`Invalid typeName.type ${typeName.type}`);
+  }
+}
+
+// Get symbols that need to be imported for given typeName
+function typeNameToExternalSymbols(typeName: TypeName | null): string[] {
+  if (typeName?.type === "UserDefinedTypeName") {
+    // split is needed to get a library, if types are internal to it
+    const symbol = typeName.namePath.split(".")[0];
+    return [symbol];
+  } else if (typeName?.type === "ArrayTypeName") {
+    return typeNameToExternalSymbols(typeName.baseTypeName);
+  } else {
+    return [];
+  }
+}

package/src/utils/deploy-v2.ts

@@ -1,33 +1,39 @@
 import { existsSync, readFileSync } from "fs";
 import path from "path";
-import { MUDConfig } from "../config/index.js";
+import { MUDConfig, resolveWithContext } from "../config/index.js";
 import { MUDError } from "./errors.js";
 import { getOutDirectory, getScriptDirectory, cast, forge } from "./foundry.js";
 import { BigNumber, ContractInterface, ethers } from "ethers";
-import { World } from "@latticexyz/world/types/ethers-contracts/World.js";
-import { abi as WorldABI, bytecode as WorldBytecode } from "@latticexyz/world/abi/World.json";
+import { IWorld } from "@latticexyz/world/types/ethers-contracts/IWorld.js";
 import { ArgumentsType } from "vitest";
 import chalk from "chalk";
 import { encodeSchema } from "@latticexyz/schema-type";
-import { resolveSchemaOrUserTypeSimple } from "../render-solidity/userType.js";
+import { resolveAbiOrUserType } from "../render-solidity/userType.js";
+import { defaultAbiCoder as abi, Fragment } from "ethers/lib/utils.js";
+
+import WorldData from "@latticexyz/world/abi/World.json" assert { type: "json" };
+import IWorldData from "@latticexyz/world/abi/IWorld.json" assert { type: "json" };
+import CoreModuleData from "@latticexyz/world/abi/CoreModule.json" assert { type: "json" };
+import RegistrationModuleData from "@latticexyz/world/abi/RegistrationModule.json" assert { type: "json" };
+import KeysWithValueModuleData from "@latticexyz/world/abi/KeysWithValueModule.json" assert { type: "json" };
 
 export interface DeployConfig {
   profile?: string;
   rpc: string;
   privateKey: string;
   priorityFeeMultiplier: number;
+  debug?: boolean;
 }
 
 export interface DeploymentInfo {
   blockNumber: number;
   worldAddress: string;
-  rpc: string;
 }
 
 export async function deploy(mudConfig: MUDConfig, deployConfig: DeployConfig): Promise<DeploymentInfo> {
   const startTime = Date.now();
-  const { worldContractName, baseRoute, postDeployScript } = mudConfig;
-  const { profile, rpc, privateKey, priorityFeeMultiplier } = deployConfig;
+  const { worldContractName, namespace, postDeployScript } = mudConfig;
+  const { profile, rpc, privateKey, priorityFeeMultiplier, debug } = deployConfig;
   const forgeOutDirectory = await getOutDirectory(profile);
 
   // Set up signer for deployment
@@ -44,116 +50,230 @@ export async function deploy(mudConfig: MUDConfig, deployConfig: DeployConfig):
   setInternalFeePerGas(priorityFeeMultiplier);
 
   // Catch all to await any promises before exiting the script
-  const promises: Promise<unknown>[] = [];
+  let promises: Promise<unknown>[] = [];
 
   // Get block number before deploying
   const blockNumber = Number(await cast(["block-number", "--rpc-url", rpc], { profile }));
   console.log("Start deployment at block", blockNumber);
 
-  // Deploy all contracts (World and systems)
-  const contractPromises = Object.keys(mudConfig.systems).reduce<Record<string, Promise<string>>>(
-    (acc, systemName) => {
-      acc[systemName] = deployContractByName(systemName);
+  // Deploy World
+  const worldPromise = {
+    World: worldContractName
+      ? deployContractByName(worldContractName)
+      : deployContract(IWorldData.abi, WorldData.bytecode, "World"),
+  };
+
+  // Deploy Systems
+  const systemPromises = Object.keys(mudConfig.systems).reduce<Record<string, Promise<string>>>((acc, systemName) => {
+    acc[systemName] = deployContractByName(systemName);
+    return acc;
+  }, {});
+
+  // Deploy default World modules
+  const defaultModules: Record<string, Promise<string>> = {
+    // TODO: these only need to be deployed once per chain, add a check if they exist already
+    CoreModule: deployContract(CoreModuleData.abi, CoreModuleData.bytecode, "CoreModule"),
+    RegistrationModule: deployContract(
+      RegistrationModuleData.abi,
+      RegistrationModuleData.bytecode,
+      "RegistrationModule"
+    ),
+    KeysWithValueModule: deployContract(
+      KeysWithValueModuleData.abi,
+      KeysWithValueModuleData.bytecode,
+      "KeysWithValueModule"
+    ),
+  };
+
+  // Deploy user Modules
+  const modulePromises = mudConfig.modules
+    .filter((module) => !defaultModules[module.name]) // Only deploy user modules here, not default modules
+    .reduce<Record<string, Promise<string>>>((acc, module) => {
+      acc[module.name] = deployContractByName(module.name);
       return acc;
-    },
-    {
-      World: worldContractName
-        ? deployContractByName(worldContractName)
-        : deployContract(WorldABI, WorldBytecode, "World"),
-    }
-  );
+    }, defaultModules);
+
+  // Combine all contracts into one object
+  const contractPromises: Record<string, Promise<string>> = { ...worldPromise, ...systemPromises, ...modulePromises };
 
   // Create World contract instance from deployed address
-  const WorldContract = new ethers.Contract(await contractPromises.World, WorldABI, signer) as World;
+  const WorldContract = new ethers.Contract(await contractPromises.World, IWorldData.abi, signer) as IWorld;
+
+  // Install core Modules
+  console.log(chalk.blue("Installing core World modules"));
+  await fastTxExecute(WorldContract, "installRootModule", [await modulePromises.CoreModule, "0x"]);
+  await fastTxExecute(WorldContract, "installRootModule", [await modulePromises.RegistrationModule, "0x"]);
+  console.log(chalk.green("Installed core World modules"));
 
-  // Register baseRoute
-  if (baseRoute) await fastTxExecute(WorldContract, "registerRoute", ["", baseRoute]);
+  // Register namespace
+  if (namespace) await fastTxExecute(WorldContract, "registerNamespace", [toBytes16(namespace)]);
 
   // Register tables
-  promises.push(
-    ...Object.entries(mudConfig.tables).map(async ([tableName, tableConfig]) => {
-      console.log(chalk.blue("Registering table", tableName, "at", baseRoute + tableConfig.route));
+  const tableIds: { [tableName: string]: Uint8Array } = {};
+  promises = [
+    ...promises,
+    ...Object.entries(mudConfig.tables).map(async ([tableName, { fileSelector, schema, primaryKeys }]) => {
+      console.log(chalk.blue(`Registering table ${tableName} at ${namespace}/${fileSelector}`));
 
-      // Register nested route
-      const routeFragments = tableConfig.route.substring(1).split("/"); // Split route into fragments (skip leading slash)
-      const lastRouteFragment = toRoute(routeFragments.pop()); // Register last fragment separately as part of call to registerTable
-      await registerNestedRoute(WorldContract, baseRoute, routeFragments);
+      // Store the tableId for later use
+      tableIds[tableName] = toResourceSelector(namespace, fileSelector);
 
       // Register table
-      const tableBaseRoute = toRoute(baseRoute, ...routeFragments);
+      const schemaTypes = Object.values(schema).map((abiOrUserType) => {
+        const { schemaType } = resolveAbiOrUserType(abiOrUserType, mudConfig);
+        return schemaType;
+      });
 
-      const schemaTypes = Object.values(tableConfig.schema).map((schemaOrUserType) => {
-        return resolveSchemaOrUserTypeSimple(schemaOrUserType, mudConfig.userTypes);
+      const keyTypes = Object.values(primaryKeys).map((abiOrUserType) => {
+        const { schemaType } = resolveAbiOrUserType(abiOrUserType, mudConfig);
+        return schemaType;
       });
 
       await fastTxExecute(WorldContract, "registerTable", [
-        tableBaseRoute,
-        lastRouteFragment,
+        toBytes16(namespace),
+        toBytes16(fileSelector),
         encodeSchema(schemaTypes),
+        encodeSchema(keyTypes),
       ]);
 
       // Register table metadata
-      await fastTxExecute(WorldContract, "setMetadata(string,string,string[])", [
-        baseRoute + tableConfig.route,
+      await fastTxExecute(WorldContract, "setMetadata(bytes16,bytes16,string,string[])", [
+        toBytes16(namespace),
+        toBytes16(fileSelector),
         tableName,
-        Object.keys(tableConfig.schema),
+        Object.keys(schema),
       ]);
 
-      console.log(chalk.green("Registered table", tableName, "at", baseRoute + tableConfig.route));
-    })
-  );
+      console.log(chalk.green(`Registered table ${tableName} at ${fileSelector}`));
+    }),
+  ];
 
   // Register systems (using forEach instead of for..of to avoid blocking on async calls)
-  promises.push(
-    ...Object.entries(mudConfig.systems).map(async ([systemName, systemConfig]) => {
-      console.log(chalk.blue("Registering system", systemName, "at", baseRoute + systemConfig.route));
-
-      // Register system route
-      const routeFragments = systemConfig.route.substring(1).split("/"); // Split route into fragments (skip leading slash)
-      const lastRouteFragment = toRoute(routeFragments.pop()); // Register last fragment as part of call to registerSystem
-      const systemBaseRoute = toRoute(baseRoute, ...routeFragments);
-      await registerNestedRoute(WorldContract, baseRoute, routeFragments);
-
-      // Register system at route
-      await fastTxExecute(WorldContract, "registerSystem", [
-        systemBaseRoute,
-        lastRouteFragment,
-        await contractPromises[systemName],
-        systemConfig.openAccess,
-      ]);
-
-      console.log(chalk.green("Registered system", systemName, "at", baseRoute + systemConfig.route));
-    })
-  );
+  promises = [
+    ...promises,
+    ...Object.entries(mudConfig.systems).map(
+      async ([systemName, { fileSelector, openAccess, registerFunctionSelectors }]) => {
+        // Register system at route
+        console.log(chalk.blue(`Registering system ${systemName} at ${namespace}/${fileSelector}`));
+        await fastTxExecute(WorldContract, "registerSystem", [
+          toBytes16(namespace),
+          toBytes16(fileSelector),
+          await contractPromises[systemName],
+          openAccess,
+        ]);
+        console.log(chalk.green(`Registered system ${systemName} at ${namespace}/${fileSelector}`));
+
+        // Register function selectors for the system
+        if (registerFunctionSelectors) {
+          const functionSignatures: FunctionSignature[] = await loadFunctionSignatures(systemName);
+          const isRoot = namespace === "";
+          // Using Promise.all to avoid blocking on async calls
+          await Promise.all(
+            functionSignatures.map(async ({ functionName, functionArgs }) => {
+              const functionSignature = isRoot
+                ? functionName + functionArgs
+                : `${namespace}_${fileSelector}_${functionName}${functionArgs}`;
+
+              console.log(chalk.blue(`Registering function "${functionSignature}"`));
+              if (isRoot) {
+                const worldFunctionSelector = toFunctionSelector(
+                  functionSignature === ""
+                    ? { functionName: systemName, functionArgs } // Register the system's fallback function as `<systemName>(<args>)`
+                    : { functionName, functionArgs }
+                );
+                const systemFunctionSelector = toFunctionSelector({ functionName, functionArgs });
+                await fastTxExecute(WorldContract, "registerRootFunctionSelector", [
+                  toBytes16(namespace),
+                  toBytes16(fileSelector),
+                  worldFunctionSelector,
+                  systemFunctionSelector,
+                ]);
+              } else {
+                await fastTxExecute(WorldContract, "registerFunctionSelector", [
+                  toBytes16(namespace),
+                  toBytes16(fileSelector),
+                  functionName,
+                  functionArgs,
+                ]);
+              }
+              console.log(chalk.green(`Registered function "${functionSignature}"`));
+            })
+          );
+        }
+      }
+    ),
+  ];
 
-  // Wait for routes to be registered before granting access to them
-  await Promise.all(promises);
+  // Wait for resources to be registered before granting access to them
+  await Promise.all(promises); // ----------------------------------------------------------------------------------------------
+  promises = [];
 
   // Grant access to systems
-  for (const [systemName, systemConfig] of Object.entries(mudConfig.systems)) {
-    const systemRoute = baseRoute + systemConfig.route;
+  for (const [systemName, { fileSelector, accessListAddresses, accessListSystems }] of Object.entries(
+    mudConfig.systems
+  )) {
+    const resourceSelector = `${namespace}/${fileSelector}`;
 
     // Grant access to addresses
-    promises.push(
-      ...systemConfig.accessListAddresses.map(async (address) => {
-        console.log(chalk.blue(`Grant ${address} access to ${systemName} (${systemRoute})`));
-        await fastTxExecute(WorldContract, "grantAccess", [systemRoute, address]);
-        console.log(chalk.green(`Granted ${address} access to ${systemName} (${systemRoute})`));
-      })
-    );
+    promises = [
+      ...promises,
+      ...accessListAddresses.map(async (address) => {
+        console.log(chalk.blue(`Grant ${address} access to ${systemName} (${resourceSelector})`));
+        await fastTxExecute(WorldContract, "grantAccess(bytes16,bytes16,address)", [
+          toBytes16(namespace),
+          toBytes16(fileSelector),
+          address,
+        ]);
+        console.log(chalk.green(`Granted ${address} access to ${systemName} (${namespace}/${fileSelector})`));
+      }),
+    ];
 
     // Grant access to other systems
-    promises.push(
-      ...systemConfig.accessListSystems.map(async (granteeSystem) => {
-        console.log(chalk.blue(`Grant ${granteeSystem} access to ${systemName} (${systemRoute})`));
-        await fastTxExecute(WorldContract, "grantAccess", [systemRoute, await contractPromises[granteeSystem]]);
-        console.log(chalk.green(`Granted ${granteeSystem} access to ${systemName} (${systemRoute})`));
-      })
-    );
+    promises = [
+      ...promises,
+      ...accessListSystems.map(async (granteeSystem) => {
+        console.log(chalk.blue(`Grant ${granteeSystem} access to ${systemName} (${resourceSelector})`));
+        await fastTxExecute(WorldContract, "grantAccess(bytes16,bytes16,address)", [
+          toBytes16(namespace),
+          toBytes16(fileSelector),
+          await contractPromises[granteeSystem],
+        ]);
+        console.log(chalk.green(`Granted ${granteeSystem} access to ${systemName} (${resourceSelector})`));
+      }),
+    ];
   }
 
-  // Await all promises
-  await Promise.all(promises);
+  // Wait for access to be granted before installing modules
+  await Promise.all(promises); // ----------------------------------------------------------------------------------------------
+  promises = [];
+
+  // Install modules
+  promises = [
+    ...promises,
+    ...mudConfig.modules.map(async (module) => {
+      console.log(chalk.blue(`Installing${module.root ? " root " : " "}module ${module.name}`));
+      // Resolve arguments
+      const resolvedArgs = await Promise.all(
+        module.args.map((arg) => resolveWithContext(arg, { tableIds, systemAddresses: contractPromises }))
+      );
+      const values = resolvedArgs.map((arg) => arg.value);
+      const types = resolvedArgs.map((arg) => arg.type);
+      const moduleAddress = await contractPromises[module.name];
+      if (!moduleAddress) throw new Error(`Module ${module.name} not found`);
+
+      // Send transaction to install module
+      await fastTxExecute(WorldContract, module.root ? "installRootModule" : "installModule", [
+        moduleAddress,
+        abi.encode(types, values),
+      ]);
+
+      console.log(chalk.green(`Installed${module.root ? " root " : " "}module ${module.name}`));
+    }),
+  ];
+
+  // Await all promises before executing PostDeploy script
+  await Promise.all(promises); // ----------------------------------------------------------------------------------------------
+  promises = [];
 
   // Execute postDeploy forge script
   const postDeployPath = path.join(await getScriptDirectory(), postDeployScript + ".s.sol");
@@ -181,7 +301,7 @@ export async function deploy(mudConfig: MUDConfig, deployConfig: DeployConfig):
 
   console.log(chalk.green("Deployment completed in", (Date.now() - startTime) / 1000, "seconds"));
 
-  return { worldAddress: await contractPromises.World, blockNumber, rpc };
+  return { worldAddress: await contractPromises.World, blockNumber };
 
   // ------------------- INTERNAL FUNCTIONS -------------------
   // (Inlined to avoid having to pass around nonce, signer and forgeOutDir)
@@ -225,6 +345,7 @@ export async function deploy(mudConfig: MUDConfig, deployConfig: DeployConfig):
       console.log(chalk.green("Deployed", contractName, "to", address));
       return address;
     } catch (error: any) {
+      if (debug) console.error(error);
       if (retryCount === 0 && error?.message.includes("transaction already imported")) {
         // If the deployment failed because the transaction was already imported,
         // retry with a higher priority fee
@@ -234,6 +355,8 @@ export async function deploy(mudConfig: MUDConfig, deployConfig: DeployConfig):
         throw new MUDError(
           `Error deploying ${contractName}: invalid bytecode. Note that linking of public libraries is not supported yet, make sure none of your libraries use "external" functions.`
         );
+      } else if (error?.message.includes("CreateContractLimit")) {
+        throw new MUDError(`Error deploying ${contractName}: CreateContractLimit exceeded.`);
       } else throw error;
     }
   }
@@ -261,6 +384,18 @@ export async function deploy(mudConfig: MUDConfig, deployConfig: DeployConfig):
   //   return deployedTo;
   // }
 
+  async function loadFunctionSignatures(contractName: string): Promise<FunctionSignature[]> {
+    const { abi } = await getContractData(contractName);
+
+    return abi
+      .filter((item) => ["fallback", "function"].includes(item.type))
+      .map((item) => {
+        if (item.type === "fallback") return { functionName: "", functionArgs: "" };
+
+        return { functionName: item.name, functionArgs: `(${item.inputs.map((arg) => arg.type).join(",")})` };
+      });
+  }
+
   /**
    * Only await gas estimation (for speed), only execute if gas estimation succeeds (for safety)
    */
@@ -281,6 +416,7 @@ export async function deploy(mudConfig: MUDConfig, deployConfig: DeployConfig):
       promises.push(txPromise);
       return txPromise;
     } catch (error: any) {
+      if (debug) console.error(error);
       if (retryCount === 0 && error?.message.includes("transaction already imported")) {
         // If the deployment failed because the transaction was already imported,
         // retry with a higher priority fee
@@ -290,30 +426,17 @@ export async function deploy(mudConfig: MUDConfig, deployConfig: DeployConfig):
     }
   }
 
-  async function registerNestedRoute(WorldContract: World, baseRoute: string, registerRouteFragments: string[]) {
-    // Register nested routes
-    for (let i = 0; i < registerRouteFragments.length; i++) {
-      const subRoute = toRoute(registerRouteFragments[i]);
-      try {
-        await fastTxExecute(WorldContract, "registerRoute", [baseRoute, subRoute]);
-      } catch (e) {
-        // TODO: check if the gas estimation error is due to the route already being registered and ignore it
-      }
-      baseRoute += subRoute;
-    }
-  }
-
   /**
    * Load the contract's abi and bytecode from the file system
    * @param contractName: Name of the contract to load
    */
-  async function getContractData(contractName: string): Promise<{ bytecode: string; abi: ContractInterface }> {
+  async function getContractData(contractName: string): Promise<{ bytecode: string; abi: Fragment[] }> {
     let data: any;
     const contractDataPath = path.join(forgeOutDirectory, contractName + ".sol", contractName + ".json");
     try {
       data = JSON.parse(readFileSync(contractDataPath, "utf8"));
     } catch (error: any) {
-      throw new MUDError(`Error reading file at ${contractDataPath}: ${error?.message}`);
+      throw new MUDError(`Error reading file at ${contractDataPath}`);
     }
 
     const bytecode = data?.bytecode?.object;
@@ -334,12 +457,56 @@ export async function deploy(mudConfig: MUDConfig, deployConfig: DeployConfig):
     // Compute maxFeePerGas and maxPriorityFeePerGas like ethers, but allow for a multiplier to allow replacing pending transactions
     const feeData = await provider.getFeeData();
     if (!feeData.lastBaseFeePerGas) throw new MUDError("Can not fetch lastBaseFeePerGas from RPC");
-    maxPriorityFeePerGas = Math.floor(1_500_000_000 * multiplier);
+
+    // Set the priority fee to 0 for development chains with no base fee, to allow transactions from unfunded wallets
+    maxPriorityFeePerGas = feeData.lastBaseFeePerGas.eq(0) ? 0 : Math.floor(1_500_000_000 * multiplier);
     maxFeePerGas = feeData.lastBaseFeePerGas.mul(2).add(maxPriorityFeePerGas);
   }
 }
 
-function toRoute(...routeFragments: (string | undefined)[]): string {
-  const route = routeFragments.filter((e) => Boolean(e)).join("/");
-  return route ? `/${route}` : "";
+// TODO: use stringToBytes16 from utils as soon as utils are usable inside cli
+// (see https://github.com/latticexyz/mud/issues/499)
+function toBytes16(input: string) {
+  if (input.length > 16) throw new Error("String does not fit into 16 bytes");
+
+  const result = new Uint8Array(16);
+  // Set ascii bytes
+  for (let i = 0; i < input.length; i++) {
+    result[i] = input.charCodeAt(i);
+  }
+  // Set the remaining bytes to 0
+  for (let i = input.length; i < 16; i++) {
+    result[i] = 0;
+  }
+  return result;
+}
+
+// TODO: use TableId from utils as soon as utils are usable inside cli
+// (see https://github.com/latticexyz/mud/issues/499)
+function toResourceSelector(namespace: string, file: string): Uint8Array {
+  const namespaceBytes = toBytes16(namespace);
+  const fileBytes = toBytes16(file);
+  const result = new Uint8Array(32);
+  result.set(namespaceBytes);
+  result.set(fileBytes, 16);
+  return result;
+}
+
+interface FunctionSignature {
+  functionName: string;
+  functionArgs: string;
+}
+
+// TODO: move this to utils as soon as utils are usable inside cli
+// (see https://github.com/latticexyz/mud/issues/499)
+function toFunctionSelector({ functionName, functionArgs }: FunctionSignature): string {
+  const functionSignature = functionName + functionArgs;
+  if (functionSignature === "") return "0x";
+  return sigHash(functionSignature);
+}
+
+// TODO: move this to utils as soon as utils are usable inside cli
+// (see https://github.com/latticexyz/mud/issues/499)
+function sigHash(signature: string) {
+  return ethers.utils.hexDataSlice(ethers.utils.keccak256(ethers.utils.toUtf8Bytes(signature)), 0, 4);
 }

package/src/utils/formatAndWrite.ts

@@ -0,0 +1,12 @@
+import { mkdirSync, writeFileSync } from "fs";
+import { dirname } from "path";
+import { formatSolidity } from "./format.js";
+
+export async function formatAndWrite(output: string, fullOutputPath: string, logPrefix: string) {
+  const formattedOutput = await formatSolidity(output);
+
+  mkdirSync(dirname(fullOutputPath), { recursive: true });
+
+  writeFileSync(fullOutputPath, formattedOutput);
+  console.log(`${logPrefix}: ${fullOutputPath}`);
+}

package/src/utils/getChainId.ts

@@ -0,0 +1,10 @@
+import { ethers } from "ethers";
+
+// TODO: Use viem's getChainId
+export async function getChainId(rpc: string) {
+  const { result: chainId } = await ethers.utils.fetchJson(
+    rpc,
+    '{ "id": 42, "jsonrpc": "2.0", "method": "eth_chainId", "params": [ ] }'
+  );
+  return Number(chainId);
+}