@latticexyz/cli 1.41.1-alpha.41 → 1.42.0

package/src/render-ts/renderRecsV1Tables.ts

@@ -0,0 +1,31 @@
+import { RecsV1TableOptions } from "./types.js";
+
+export function renderRecsV1Tables(options: RecsV1TableOptions) {
+  const { tables } = options;
+
+  return `/* Autogenerated file. Do not edit manually. */
+
+import { TableId } from "@latticexyz/utils";
+import { defineComponent, Type as RecsType, World } from "@latticexyz/recs";
+
+export function defineContractComponents(world: World) {
+  return {
+    ${tables.map((table) => `${table.tableName}: ${renderDefineComponent(table)},`).join("")}
+  }
+}
+`;
+}
+
+function renderDefineComponent(table: RecsV1TableOptions["tables"][number]) {
+  const { namespace, name } = table.staticResourceData;
+  return `
+    (() => {
+      const tableId = new TableId("${namespace}", "${name}");
+      return defineComponent(world, {
+        ${table.fields.map(({ name, recsTypeString }) => `${name}: ${recsTypeString},`).join("")}
+      }, {
+        metadata: { contractId: tableId.toHexString(), tableId: tableId.toString() },
+      });
+    })()
+  `;
+}

package/src/render-ts/schemaTypesToRecsTypeStrings.ts

@@ -0,0 +1,202 @@
+import { SchemaType } from "@latticexyz/schema-type";
+
+export const schemaTypesToRecsTypeStrings: Record<SchemaType, string> = {
+  [SchemaType.UINT8]: "RecsType.Number",
+  [SchemaType.UINT16]: "RecsType.Number",
+  [SchemaType.UINT24]: "RecsType.Number",
+  [SchemaType.UINT32]: "RecsType.Number",
+  [SchemaType.UINT40]: "RecsType.Number",
+  [SchemaType.UINT48]: "RecsType.Number",
+  [SchemaType.UINT56]: "RecsType.BigInt",
+  [SchemaType.UINT64]: "RecsType.BigInt",
+  [SchemaType.UINT72]: "RecsType.BigInt",
+  [SchemaType.UINT80]: "RecsType.BigInt",
+  [SchemaType.UINT88]: "RecsType.BigInt",
+  [SchemaType.UINT96]: "RecsType.BigInt",
+  [SchemaType.UINT104]: "RecsType.BigInt",
+  [SchemaType.UINT112]: "RecsType.BigInt",
+  [SchemaType.UINT120]: "RecsType.BigInt",
+  [SchemaType.UINT128]: "RecsType.BigInt",
+  [SchemaType.UINT136]: "RecsType.BigInt",
+  [SchemaType.UINT144]: "RecsType.BigInt",
+  [SchemaType.UINT152]: "RecsType.BigInt",
+  [SchemaType.UINT160]: "RecsType.BigInt",
+  [SchemaType.UINT168]: "RecsType.BigInt",
+  [SchemaType.UINT176]: "RecsType.BigInt",
+  [SchemaType.UINT184]: "RecsType.BigInt",
+  [SchemaType.UINT192]: "RecsType.BigInt",
+  [SchemaType.UINT200]: "RecsType.BigInt",
+  [SchemaType.UINT208]: "RecsType.BigInt",
+  [SchemaType.UINT216]: "RecsType.BigInt",
+  [SchemaType.UINT224]: "RecsType.BigInt",
+  [SchemaType.UINT232]: "RecsType.BigInt",
+  [SchemaType.UINT240]: "RecsType.BigInt",
+  [SchemaType.UINT248]: "RecsType.BigInt",
+  [SchemaType.UINT256]: "RecsType.BigInt",
+  [SchemaType.INT8]: "RecsType.Number",
+  [SchemaType.INT16]: "RecsType.Number",
+  [SchemaType.INT24]: "RecsType.Number",
+  [SchemaType.INT32]: "RecsType.Number",
+  [SchemaType.INT40]: "RecsType.Number",
+  [SchemaType.INT48]: "RecsType.Number",
+  [SchemaType.INT56]: "RecsType.BigInt",
+  [SchemaType.INT64]: "RecsType.BigInt",
+  [SchemaType.INT72]: "RecsType.BigInt",
+  [SchemaType.INT80]: "RecsType.BigInt",
+  [SchemaType.INT88]: "RecsType.BigInt",
+  [SchemaType.INT96]: "RecsType.BigInt",
+  [SchemaType.INT104]: "RecsType.BigInt",
+  [SchemaType.INT112]: "RecsType.BigInt",
+  [SchemaType.INT120]: "RecsType.BigInt",
+  [SchemaType.INT128]: "RecsType.BigInt",
+  [SchemaType.INT136]: "RecsType.BigInt",
+  [SchemaType.INT144]: "RecsType.BigInt",
+  [SchemaType.INT152]: "RecsType.BigInt",
+  [SchemaType.INT160]: "RecsType.BigInt",
+  [SchemaType.INT168]: "RecsType.BigInt",
+  [SchemaType.INT176]: "RecsType.BigInt",
+  [SchemaType.INT184]: "RecsType.BigInt",
+  [SchemaType.INT192]: "RecsType.BigInt",
+  [SchemaType.INT200]: "RecsType.BigInt",
+  [SchemaType.INT208]: "RecsType.BigInt",
+  [SchemaType.INT216]: "RecsType.BigInt",
+  [SchemaType.INT224]: "RecsType.BigInt",
+  [SchemaType.INT232]: "RecsType.BigInt",
+  [SchemaType.INT240]: "RecsType.BigInt",
+  [SchemaType.INT248]: "RecsType.BigInt",
+  [SchemaType.INT256]: "RecsType.BigInt",
+  [SchemaType.BYTES1]: "RecsType.String",
+  [SchemaType.BYTES2]: "RecsType.String",
+  [SchemaType.BYTES3]: "RecsType.String",
+  [SchemaType.BYTES4]: "RecsType.String",
+  [SchemaType.BYTES5]: "RecsType.String",
+  [SchemaType.BYTES6]: "RecsType.String",
+  [SchemaType.BYTES7]: "RecsType.String",
+  [SchemaType.BYTES8]: "RecsType.String",
+  [SchemaType.BYTES9]: "RecsType.String",
+  [SchemaType.BYTES10]: "RecsType.String",
+  [SchemaType.BYTES11]: "RecsType.String",
+  [SchemaType.BYTES12]: "RecsType.String",
+  [SchemaType.BYTES13]: "RecsType.String",
+  [SchemaType.BYTES14]: "RecsType.String",
+  [SchemaType.BYTES15]: "RecsType.String",
+  [SchemaType.BYTES16]: "RecsType.String",
+  [SchemaType.BYTES17]: "RecsType.String",
+  [SchemaType.BYTES18]: "RecsType.String",
+  [SchemaType.BYTES19]: "RecsType.String",
+  [SchemaType.BYTES20]: "RecsType.String",
+  [SchemaType.BYTES21]: "RecsType.String",
+  [SchemaType.BYTES22]: "RecsType.String",
+  [SchemaType.BYTES23]: "RecsType.String",
+  [SchemaType.BYTES24]: "RecsType.String",
+  [SchemaType.BYTES25]: "RecsType.String",
+  [SchemaType.BYTES26]: "RecsType.String",
+  [SchemaType.BYTES27]: "RecsType.String",
+  [SchemaType.BYTES28]: "RecsType.String",
+  [SchemaType.BYTES29]: "RecsType.String",
+  [SchemaType.BYTES30]: "RecsType.String",
+  [SchemaType.BYTES31]: "RecsType.String",
+  [SchemaType.BYTES32]: "RecsType.String",
+  [SchemaType.BOOL]: "RecsType.Boolean",
+  [SchemaType.ADDRESS]: "RecsType.String",
+  [SchemaType.UINT8_ARRAY]: "RecsType.NumberArray",
+  [SchemaType.UINT16_ARRAY]: "RecsType.NumberArray",
+  [SchemaType.UINT24_ARRAY]: "RecsType.NumberArray",
+  [SchemaType.UINT32_ARRAY]: "RecsType.NumberArray",
+  [SchemaType.UINT40_ARRAY]: "RecsType.NumberArray",
+  [SchemaType.UINT48_ARRAY]: "RecsType.NumberArray",
+  [SchemaType.UINT56_ARRAY]: "RecsType.BigIntArray",
+  [SchemaType.UINT64_ARRAY]: "RecsType.BigIntArray",
+  [SchemaType.UINT72_ARRAY]: "RecsType.BigIntArray",
+  [SchemaType.UINT80_ARRAY]: "RecsType.BigIntArray",
+  [SchemaType.UINT88_ARRAY]: "RecsType.BigIntArray",
+  [SchemaType.UINT96_ARRAY]: "RecsType.BigIntArray",
+  [SchemaType.UINT104_ARRAY]: "RecsType.BigIntArray",
+  [SchemaType.UINT112_ARRAY]: "RecsType.BigIntArray",
+  [SchemaType.UINT120_ARRAY]: "RecsType.BigIntArray",
+  [SchemaType.UINT128_ARRAY]: "RecsType.BigIntArray",
+  [SchemaType.UINT136_ARRAY]: "RecsType.BigIntArray",
+  [SchemaType.UINT144_ARRAY]: "RecsType.BigIntArray",
+  [SchemaType.UINT152_ARRAY]: "RecsType.BigIntArray",
+  [SchemaType.UINT160_ARRAY]: "RecsType.BigIntArray",
+  [SchemaType.UINT168_ARRAY]: "RecsType.BigIntArray",
+  [SchemaType.UINT176_ARRAY]: "RecsType.BigIntArray",
+  [SchemaType.UINT184_ARRAY]: "RecsType.BigIntArray",
+  [SchemaType.UINT192_ARRAY]: "RecsType.BigIntArray",
+  [SchemaType.UINT200_ARRAY]: "RecsType.BigIntArray",
+  [SchemaType.UINT208_ARRAY]: "RecsType.BigIntArray",
+  [SchemaType.UINT216_ARRAY]: "RecsType.BigIntArray",
+  [SchemaType.UINT224_ARRAY]: "RecsType.BigIntArray",
+  [SchemaType.UINT232_ARRAY]: "RecsType.BigIntArray",
+  [SchemaType.UINT240_ARRAY]: "RecsType.BigIntArray",
+  [SchemaType.UINT248_ARRAY]: "RecsType.BigIntArray",
+  [SchemaType.UINT256_ARRAY]: "RecsType.BigIntArray",
+  [SchemaType.INT8_ARRAY]: "RecsType.NumberArray",
+  [SchemaType.INT16_ARRAY]: "RecsType.NumberArray",
+  [SchemaType.INT24_ARRAY]: "RecsType.NumberArray",
+  [SchemaType.INT32_ARRAY]: "RecsType.NumberArray",
+  [SchemaType.INT40_ARRAY]: "RecsType.NumberArray",
+  [SchemaType.INT48_ARRAY]: "RecsType.NumberArray",
+  [SchemaType.INT56_ARRAY]: "RecsType.BigIntArray",
+  [SchemaType.INT64_ARRAY]: "RecsType.BigIntArray",
+  [SchemaType.INT72_ARRAY]: "RecsType.BigIntArray",
+  [SchemaType.INT80_ARRAY]: "RecsType.BigIntArray",
+  [SchemaType.INT88_ARRAY]: "RecsType.BigIntArray",
+  [SchemaType.INT96_ARRAY]: "RecsType.BigIntArray",
+  [SchemaType.INT104_ARRAY]: "RecsType.BigIntArray",
+  [SchemaType.INT112_ARRAY]: "RecsType.BigIntArray",
+  [SchemaType.INT120_ARRAY]: "RecsType.BigIntArray",
+  [SchemaType.INT128_ARRAY]: "RecsType.BigIntArray",
+  [SchemaType.INT136_ARRAY]: "RecsType.BigIntArray",
+  [SchemaType.INT144_ARRAY]: "RecsType.BigIntArray",
+  [SchemaType.INT152_ARRAY]: "RecsType.BigIntArray",
+  [SchemaType.INT160_ARRAY]: "RecsType.BigIntArray",
+  [SchemaType.INT168_ARRAY]: "RecsType.BigIntArray",
+  [SchemaType.INT176_ARRAY]: "RecsType.BigIntArray",
+  [SchemaType.INT184_ARRAY]: "RecsType.BigIntArray",
+  [SchemaType.INT192_ARRAY]: "RecsType.BigIntArray",
+  [SchemaType.INT200_ARRAY]: "RecsType.BigIntArray",
+  [SchemaType.INT208_ARRAY]: "RecsType.BigIntArray",
+  [SchemaType.INT216_ARRAY]: "RecsType.BigIntArray",
+  [SchemaType.INT224_ARRAY]: "RecsType.BigIntArray",
+  [SchemaType.INT232_ARRAY]: "RecsType.BigIntArray",
+  [SchemaType.INT240_ARRAY]: "RecsType.BigIntArray",
+  [SchemaType.INT248_ARRAY]: "RecsType.BigIntArray",
+  [SchemaType.INT256_ARRAY]: "RecsType.BigIntArray",
+  [SchemaType.BYTES1_ARRAY]: "RecsType.BigIntArray",
+  [SchemaType.BYTES2_ARRAY]: "RecsType.BigIntArray",
+  [SchemaType.BYTES3_ARRAY]: "RecsType.BigIntArray",
+  [SchemaType.BYTES4_ARRAY]: "RecsType.BigIntArray",
+  [SchemaType.BYTES5_ARRAY]: "RecsType.BigIntArray",
+  [SchemaType.BYTES6_ARRAY]: "RecsType.BigIntArray",
+  [SchemaType.BYTES7_ARRAY]: "RecsType.BigIntArray",
+  [SchemaType.BYTES8_ARRAY]: "RecsType.BigIntArray",
+  [SchemaType.BYTES9_ARRAY]: "RecsType.BigIntArray",
+  [SchemaType.BYTES10_ARRAY]: "RecsType.BigIntArray",
+  [SchemaType.BYTES11_ARRAY]: "RecsType.BigIntArray",
+  [SchemaType.BYTES12_ARRAY]: "RecsType.BigIntArray",
+  [SchemaType.BYTES13_ARRAY]: "RecsType.BigIntArray",
+  [SchemaType.BYTES14_ARRAY]: "RecsType.BigIntArray",
+  [SchemaType.BYTES15_ARRAY]: "RecsType.BigIntArray",
+  [SchemaType.BYTES16_ARRAY]: "RecsType.BigIntArray",
+  [SchemaType.BYTES17_ARRAY]: "RecsType.BigIntArray",
+  [SchemaType.BYTES18_ARRAY]: "RecsType.BigIntArray",
+  [SchemaType.BYTES19_ARRAY]: "RecsType.BigIntArray",
+  [SchemaType.BYTES20_ARRAY]: "RecsType.BigIntArray",
+  [SchemaType.BYTES21_ARRAY]: "RecsType.BigIntArray",
+  [SchemaType.BYTES22_ARRAY]: "RecsType.BigIntArray",
+  [SchemaType.BYTES23_ARRAY]: "RecsType.BigIntArray",
+  [SchemaType.BYTES24_ARRAY]: "RecsType.BigIntArray",
+  [SchemaType.BYTES25_ARRAY]: "RecsType.BigIntArray",
+  [SchemaType.BYTES26_ARRAY]: "RecsType.BigIntArray",
+  [SchemaType.BYTES27_ARRAY]: "RecsType.BigIntArray",
+  [SchemaType.BYTES28_ARRAY]: "RecsType.BigIntArray",
+  [SchemaType.BYTES29_ARRAY]: "RecsType.BigIntArray",
+  [SchemaType.BYTES30_ARRAY]: "RecsType.BigIntArray",
+  [SchemaType.BYTES31_ARRAY]: "RecsType.BigIntArray",
+  [SchemaType.BYTES32_ARRAY]: "RecsType.BigIntArray",
+  [SchemaType.BOOL_ARRAY]: "RecsType.T", // no boolean array
+  [SchemaType.ADDRESS_ARRAY]: "RecsType.StringArray",
+  [SchemaType.BYTES]: "RecsType.String",
+  [SchemaType.STRING]: "RecsType.String",
+};

package/src/render-ts/tsgen.ts

@@ -0,0 +1,12 @@
+import path from "path";
+import { StoreConfig } from "@latticexyz/config";
+import { getRecsV1TableOptions } from "../render-ts/recsV1TableOptions.js";
+import { renderRecsV1Tables } from "../render-ts/renderRecsV1Tables.js";
+import { formatAndWriteTypescript } from "../utils/formatAndWrite.js";
+
+export async function tsgen(config: StoreConfig, outDirectory: string) {
+  const fullOutputPath = path.join(outDirectory, `contractComponents.ts`);
+  const options = getRecsV1TableOptions(config);
+  const output = renderRecsV1Tables(options);
+  formatAndWriteTypescript(output, fullOutputPath, "Generated ts definition files");
+}

package/src/render-ts/types.ts

@@ -0,0 +1,13 @@
+export interface RecsV1TableOptions {
+  tables: {
+    tableName: string;
+    fields: {
+      recsTypeString: string;
+      name: string;
+    }[];
+    staticResourceData: {
+      namespace: string;
+      name: string;
+    };
+  }[];
+}

package/src/utils/contractToInterface.ts

@@ -1,7 +1,7 @@
 import { parse, visit } from "@solidity-parser/parser";
 import { TypeName, VariableDeclaration } from "@solidity-parser/parser/dist/src/ast-types.js";
+import { MUDError } from "@latticexyz/config";
 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,
@@ -24,7 +24,7 @@ export function contractToInterface(data: string, contractName: string) {
       }
     },
     FunctionDefinition(
-      { name, visibility, parameters, returnParameters, isConstructor, isFallback, isReceiveEther },
+      { name, visibility, parameters, stateMutability, returnParameters, isConstructor, isFallback, isReceiveEther },
       parent
     ) {
       if (parent !== undefined && parent.type === "ContractDefinition" && parent.name === contractName) {
@@ -38,6 +38,7 @@ export function contractToInterface(data: string, contractName: string) {
             functions.push({
               name: name === null ? "" : name,
               parameters: parameters.map(parseParameter),
+              stateMutability: stateMutability || "",
               returnParameters: returnParameters === null ? [] : returnParameters.map(parseParameter),
             });
 
@@ -105,9 +106,10 @@ function flattenTypeName(typeName: TypeName | null): { name: string; stateMutabi
       stateMutability: null,
     };
   } else if (typeName.type === "ArrayTypeName") {
+    const length = typeName.length?.type === "NumberLiteral" ? typeName.length.number : "";
     const { name, stateMutability } = flattenTypeName(typeName.baseTypeName);
     return {
-      name: `${name}[]`,
+      name: `${name}[${length}]`,
       stateMutability,
     };
   } else {

package/src/utils/deploy-v2.ts

@@ -1,21 +1,21 @@
 import { existsSync, readFileSync } from "fs";
 import path from "path";
-import { MUDConfig, resolveWithContext } from "../config/index.js";
-import { MUDError } from "./errors.js";
+import { MUDConfig, resolveWithContext } from "@latticexyz/config";
+import { MUDError } from "@latticexyz/config";
 import { getOutDirectory, getScriptDirectory, cast, forge } from "./foundry.js";
 import { BigNumber, ContractInterface, ethers } from "ethers";
-import { IWorld } from "@latticexyz/world/types/ethers-contracts/IWorld.js";
-import { ArgumentsType } from "vitest";
+import { IBaseWorld } from "@latticexyz/world/types/ethers-contracts/IBaseWorld.js";
 import chalk from "chalk";
 import { encodeSchema } from "@latticexyz/schema-type";
 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 IBaseWorldData from "@latticexyz/world/abi/IBaseWorld.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" };
+import UniqueEntityModuleData from "@latticexyz/world/abi/UniqueEntityModule.json" assert { type: "json" };
 
 export interface DeployConfig {
   profile?: string;
@@ -23,6 +23,7 @@ export interface DeployConfig {
   privateKey: string;
   priorityFeeMultiplier: number;
   debug?: boolean;
+  worldAddress?: string;
 }
 
 export interface DeploymentInfo {
@@ -33,7 +34,7 @@ export interface DeploymentInfo {
 export async function deploy(mudConfig: MUDConfig, deployConfig: DeployConfig): Promise<DeploymentInfo> {
   const startTime = Date.now();
   const { worldContractName, namespace, postDeployScript } = mudConfig;
-  const { profile, rpc, privateKey, priorityFeeMultiplier, debug } = deployConfig;
+  const { profile, rpc, privateKey, priorityFeeMultiplier, debug, worldAddress } = deployConfig;
   const forgeOutDirectory = await getOutDirectory(profile);
 
   // Set up signer for deployment
@@ -58,9 +59,11 @@ export async function deploy(mudConfig: MUDConfig, deployConfig: DeployConfig):
 
   // Deploy World
   const worldPromise = {
-    World: worldContractName
+    World: worldAddress
+      ? Promise.resolve(worldAddress)
+      : worldContractName
       ? deployContractByName(worldContractName)
-      : deployContract(IWorldData.abi, WorldData.bytecode, "World"),
+      : deployContract(IBaseWorldData.abi, WorldData.bytecode, "World"),
   };
 
   // Deploy Systems
@@ -83,6 +86,11 @@ export async function deploy(mudConfig: MUDConfig, deployConfig: DeployConfig):
       KeysWithValueModuleData.bytecode,
       "KeysWithValueModule"
     ),
+    UniqueEntityModule: deployContract(
+      UniqueEntityModuleData.abi,
+      UniqueEntityModuleData.bytecode,
+      "UniqueEntityModule"
+    ),
   };
 
   // Deploy user Modules
@@ -97,13 +105,15 @@ export async function deploy(mudConfig: MUDConfig, deployConfig: DeployConfig):
   const contractPromises: Record<string, Promise<string>> = { ...worldPromise, ...systemPromises, ...modulePromises };
 
   // Create World contract instance from deployed address
-  const WorldContract = new ethers.Contract(await contractPromises.World, IWorldData.abi, signer) as IWorld;
+  const WorldContract = new ethers.Contract(await contractPromises.World, IBaseWorldData.abi, signer) as IBaseWorld;
 
   // 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"));
+  if (!worldAddress) {
+    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 namespace
   if (namespace) await fastTxExecute(WorldContract, "registerNamespace", [toBytes16(namespace)]);
@@ -112,11 +122,11 @@ export async function deploy(mudConfig: MUDConfig, deployConfig: DeployConfig):
   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}`));
+    ...Object.entries(mudConfig.tables).map(async ([tableName, { name, schema, primaryKeys }]) => {
+      console.log(chalk.blue(`Registering table ${tableName} at ${namespace}/${name}`));
 
       // Store the tableId for later use
-      tableIds[tableName] = toResourceSelector(namespace, fileSelector);
+      tableIds[tableName] = toResourceSelector(namespace, name);
 
       // Register table
       const schemaTypes = Object.values(schema).map((abiOrUserType) => {
@@ -131,7 +141,7 @@ export async function deploy(mudConfig: MUDConfig, deployConfig: DeployConfig):
 
       await fastTxExecute(WorldContract, "registerTable", [
         toBytes16(namespace),
-        toBytes16(fileSelector),
+        toBytes16(name),
         encodeSchema(schemaTypes),
         encodeSchema(keyTypes),
       ]);
@@ -139,69 +149,67 @@ export async function deploy(mudConfig: MUDConfig, deployConfig: DeployConfig):
       // Register table metadata
       await fastTxExecute(WorldContract, "setMetadata(bytes16,bytes16,string,string[])", [
         toBytes16(namespace),
-        toBytes16(fileSelector),
+        toBytes16(name),
         tableName,
         Object.keys(schema),
       ]);
 
-      console.log(chalk.green(`Registered table ${tableName} at ${fileSelector}`));
+      console.log(chalk.green(`Registered table ${tableName} at ${name}`));
     }),
   ];
 
   // Register systems (using forEach instead of for..of to avoid blocking on async calls)
   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}"`));
-            })
-          );
-        }
+    ...Object.entries(mudConfig.systems).map(async ([systemName, { name, openAccess, registerFunctionSelectors }]) => {
+      // Register system at route
+      console.log(chalk.blue(`Registering system ${systemName} at ${namespace}/${name}`));
+      await fastTxExecute(WorldContract, "registerSystem", [
+        toBytes16(namespace),
+        toBytes16(name),
+        await contractPromises[systemName],
+        openAccess,
+      ]);
+      console.log(chalk.green(`Registered system ${systemName} at ${namespace}/${name}`));
+
+      // 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}_${name}_${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(name),
+                worldFunctionSelector,
+                systemFunctionSelector,
+              ]);
+            } else {
+              await fastTxExecute(WorldContract, "registerFunctionSelector", [
+                toBytes16(namespace),
+                toBytes16(name),
+                functionName,
+                functionArgs,
+              ]);
+            }
+            console.log(chalk.green(`Registered function "${functionSignature}"`));
+          })
+        );
       }
-    ),
+    }),
   ];
 
   // Wait for resources to be registered before granting access to them
@@ -209,10 +217,8 @@ export async function deploy(mudConfig: MUDConfig, deployConfig: DeployConfig):
   promises = [];
 
   // Grant access to systems
-  for (const [systemName, { fileSelector, accessListAddresses, accessListSystems }] of Object.entries(
-    mudConfig.systems
-  )) {
-    const resourceSelector = `${namespace}/${fileSelector}`;
+  for (const [systemName, { name, accessListAddresses, accessListSystems }] of Object.entries(mudConfig.systems)) {
+    const resourceSelector = `${namespace}/${name}`;
 
     // Grant access to addresses
     promises = [
@@ -221,10 +227,10 @@ export async function deploy(mudConfig: MUDConfig, deployConfig: DeployConfig):
         console.log(chalk.blue(`Grant ${address} access to ${systemName} (${resourceSelector})`));
         await fastTxExecute(WorldContract, "grantAccess(bytes16,bytes16,address)", [
           toBytes16(namespace),
-          toBytes16(fileSelector),
+          toBytes16(name),
           address,
         ]);
-        console.log(chalk.green(`Granted ${address} access to ${systemName} (${namespace}/${fileSelector})`));
+        console.log(chalk.green(`Granted ${address} access to ${systemName} (${namespace}/${name})`));
       }),
     ];
 
@@ -235,7 +241,7 @@ export async function deploy(mudConfig: MUDConfig, deployConfig: DeployConfig):
         console.log(chalk.blue(`Grant ${granteeSystem} access to ${systemName} (${resourceSelector})`));
         await fastTxExecute(WorldContract, "grantAccess(bytes16,bytes16,address)", [
           toBytes16(namespace),
-          toBytes16(fileSelector),
+          toBytes16(name),
           await contractPromises[granteeSystem],
         ]);
         console.log(chalk.green(`Granted ${granteeSystem} access to ${systemName} (${resourceSelector})`));
@@ -402,17 +408,17 @@ export async function deploy(mudConfig: MUDConfig, deployConfig: DeployConfig):
   async function fastTxExecute<C extends { estimateGas: any; [key: string]: any }, F extends keyof C>(
     contract: C,
     func: F,
-    args: ArgumentsType<C[F]>,
-    retryCount = 0
-  ): Promise<Awaited<ReturnType<C[F]>>> {
+    args: Parameters<C[F]>,
+    retryCount = 0,
+    confirmations = 1
+  ): Promise<Awaited<ReturnType<Awaited<ReturnType<C[F]>>["wait"]>>> {
     const functionName = `${func as string}(${args.map((arg) => `'${arg}'`).join(",")})`;
     try {
       const gasLimit = await contract.estimateGas[func].apply(null, args);
       console.log(chalk.gray(`executing transaction: ${functionName} with nonce ${nonce}`));
-      const txPromise = contract[func].apply(null, [
-        ...args,
-        { gasLimit, nonce: nonce++, maxPriorityFeePerGas, maxFeePerGas },
-      ]);
+      const txPromise = contract[func]
+        .apply(null, [...args, { gasLimit, nonce: nonce++, maxPriorityFeePerGas, maxFeePerGas }])
+        .then((tx: any) => tx.wait(confirmations));
       promises.push(txPromise);
       return txPromise;
     } catch (error: any) {
@@ -421,7 +427,7 @@ export async function deploy(mudConfig: MUDConfig, deployConfig: DeployConfig):
         // If the deployment failed because the transaction was already imported,
         // retry with a higher priority fee
         setInternalFeePerGas(priorityFeeMultiplier * 1.1);
-        return fastTxExecute(contract, func, args, retryCount++);
+        return fastTxExecute(contract, func, args, retryCount++, confirmations);
       } else throw new MUDError(`Gas estimation error for ${functionName}: ${error?.reason}`);
     }
   }

package/src/utils/errors.ts

@@ -1,33 +1,8 @@
 import chalk from "chalk";
-import { z, ZodError, ZodIssueCode } from "zod";
+import { ZodError } from "zod";
 import { fromZodError, ValidationError } from "zod-validation-error";
-
-// Wrapper with preset styles, only requires a `prefix`
-export function fromZodErrorCustom(error: ZodError, prefix: string) {
-  return fromZodError(error, {
-    prefix: chalk.red(prefix),
-    prefixSeparator: "\n- ",
-    issueSeparator: "\n- ",
-  });
-}
-
-export class NotInsideProjectError extends Error {
-  name = "NotInsideProjectError";
-  message = "You are not inside a MUD project";
-}
-
-export class NotESMConfigError extends Error {
-  name = "NotESMConfigError";
-  message = "MUD config must be an ES module";
-}
-
-export class MUDError extends Error {
-  name = "MUDError";
-}
-
-export function UnrecognizedSystemErrorFactory(path: string[], systemName: string) {
-  return new z.ZodError([{ code: ZodIssueCode.custom, path: path, message: `Unrecognized system: "${systemName}"` }]);
-}
+import { NotInsideProjectError } from "@latticexyz/config";
+import { MUDError } from "@latticexyz/config";
 
 export function logError(error: unknown) {
   if (error instanceof ValidationError) {
@@ -46,12 +21,6 @@ export function logError(error: unknown) {
     // TODO add docs to the website and update the link to the specific page
     // (see https://github.com/latticexyz/mud/issues/445)
     console.log(chalk.blue(`To learn more about MUD's configuration, please go to https://mud.dev/packages/cli/`));
-  } else if (error instanceof NotESMConfigError) {
-    console.log(chalk.red(error.message));
-    console.log("");
-    console.log(
-      chalk.blue(`Please name your config file \`mud.config.mts\`, or use \`type: "module"\` in package.json`)
-    );
   } else if (error instanceof MUDError) {
     console.log(chalk.red(error));
   } else {