@latticexyz/cli 2.0.0-snapshot-test-32d38619 → 2.0.0

package/src/commands/index.ts

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

package/src/commands/set-version.ts

@@ -1,11 +1,12 @@
 import chalk from "chalk";
-import { existsSync, readFileSync, rmSync, writeFileSync } from "fs";
+import { readFileSync, writeFileSync } from "fs";
 import path from "path";
 import type { CommandModule } from "yargs";
 import { MUDError } from "@latticexyz/common/errors";
 import { logError } from "../utils/errors";
 import localPackageJson from "../../package.json" assert { type: "json" };
 import glob from "glob";
+import { mudPackages } from "../mudPackages";
 
 type Options = {
   backup?: boolean;
@@ -17,9 +18,6 @@ type Options = {
   link?: string;
 };
 
-const BACKUP_FILE = ".mudbackup";
-const MUD_PREFIX = "@latticexyz";
-
 const commandModule: CommandModule<Options, Options> = {
   command: "set-version",
 
@@ -27,12 +25,6 @@ const commandModule: CommandModule<Options, Options> = {
 
   builder(yargs) {
     return yargs.options({
-      backup: { type: "boolean", description: `Back up the current MUD versions to "${BACKUP_FILE}"` },
-      force: {
-        type: "boolean",
-        description: `Backup fails if a "${BACKUP_FILE}" file is found, unless --force is provided`,
-      },
-      restore: { type: "boolean", description: `Restore the previous MUD versions from "${BACKUP_FILE}"` },
       mudVersion: { alias: "v", type: "string", description: "Set MUD to the given version" },
       tag: {
         alias: "t",
@@ -53,7 +45,7 @@ const commandModule: CommandModule<Options, Options> = {
       const mutuallyExclusiveOptions = ["mudVersion", "link", "tag", "commit", "restore"];
       const numMutuallyExclusiveOptions = mutuallyExclusiveOptions.reduce(
         (acc, opt) => (options[opt] ? acc + 1 : acc),
-        0
+        0,
       );
 
       if (numMutuallyExclusiveOptions === 0) {
@@ -64,8 +56,11 @@ const commandModule: CommandModule<Options, Options> = {
         throw new MUDError(`These options are mutually exclusive: ${mutuallyExclusiveOptions.join(", ")}`);
       }
 
+      // If the --link flag is not set, we call resolveVersion to get the version
       // Resolve the version number from available options like `tag` or `commit`
-      options.mudVersion = await resolveVersion(options);
+      if (!options.link) {
+        options.mudVersion = await resolveVersion(options);
+      }
 
       // Update all package.json below the current working directory (except in node_modules)
       const packageJsons = glob.sync("**/package.json").filter((p) => !p.includes("node_modules"));
@@ -117,63 +112,39 @@ async function resolveVersion(options: Options) {
 }
 
 function updatePackageJson(filePath: string, options: Options): { workspaces?: string[] } {
-  const { restore, force, link } = options;
-  let { backup, mudVersion } = options;
-
-  const backupFilePath = path.join(path.dirname(filePath), BACKUP_FILE);
-  const backupFileExists = existsSync(backupFilePath);
-
-  // Create a backup file for previous MUD versions by default if linking to local MUD
-  if (link && !backupFileExists) backup = true;
-
-  // If `backup` is true and force not set, check if a backup file already exists and throw an error if it does
-  if (backup && !force && backupFileExists) {
-    throw new MUDError(
-      `A backup file already exists at ${backupFilePath}.\nUse --force to overwrite it or --restore to restore it.`
-    );
-  }
+  const { link } = options;
+  let { mudVersion } = options;
 
   const packageJson = readPackageJson(filePath);
-
-  // Load .mudbackup if `restore` is true
-  const backupJson = restore ? readPackageJson(backupFilePath) : undefined;
+  const mudPackageNames = Object.keys(mudPackages);
 
   // Find all MUD dependencies
   const mudDependencies: Record<string, string> = {};
-  for (const key in packageJson.dependencies) {
-    if (key.startsWith(MUD_PREFIX)) {
-      mudDependencies[key] = packageJson.dependencies[key];
+  for (const packageName in packageJson.dependencies) {
+    if (mudPackageNames.includes(packageName)) {
+      mudDependencies[packageName] = packageJson.dependencies[packageName];
     }
   }
 
   // Find all MUD devDependencies
   const mudDevDependencies: Record<string, string> = {};
-  for (const key in packageJson.devDependencies) {
-    if (key.startsWith(MUD_PREFIX)) {
-      mudDevDependencies[key] = packageJson.devDependencies[key];
+  for (const packageName in packageJson.devDependencies) {
+    if (mudPackageNames.includes(packageName)) {
+      mudDevDependencies[packageName] = packageJson.devDependencies[packageName];
     }
   }
 
-  // Back up the current dependencies if `backup` is true
-  if (backup) {
-    writeFileSync(
-      backupFilePath,
-      JSON.stringify({ dependencies: mudDependencies, devDependencies: mudDevDependencies }, null, 2)
-    );
-    console.log(chalk.green(`Backed up MUD dependencies from ${filePath} to ${backupFilePath}`));
-  }
-
   // Update the dependencies
-  for (const key in packageJson.dependencies) {
-    if (key.startsWith(MUD_PREFIX)) {
-      packageJson.dependencies[key] = resolveMudVersion(key, "dependencies");
+  for (const packageName in packageJson.dependencies) {
+    if (mudPackageNames.includes(packageName)) {
+      packageJson.dependencies[packageName] = resolveMudVersion(packageName, "dependencies");
     }
   }
 
   // Update the devDependencies
-  for (const key in packageJson.devDependencies) {
-    if (key.startsWith(MUD_PREFIX)) {
-      packageJson.devDependencies[key] = resolveMudVersion(key, "devDependencies");
+  for (const packageName in packageJson.devDependencies) {
+    if (mudPackageNames.includes(packageName)) {
+      packageJson.devDependencies[packageName] = resolveMudVersion(packageName, "devDependencies");
     }
   }
 
@@ -184,17 +155,9 @@ function updatePackageJson(filePath: string, options: Options): { workspaces?: s
   logComparison(mudDependencies, packageJson.dependencies);
   logComparison(mudDevDependencies, packageJson.devDependencies);
 
-  // Remove the backup file if `restore` is true and `backup` is false
-  // because the old backup file is no longer needed
-  if (restore && !backup) {
-    rmSync(backupFilePath);
-    console.log(chalk.green(`Cleaned up ${backupFilePath}`));
-  }
-
   return packageJson;
 
   function resolveMudVersion(key: string, type: "dependencies" | "devDependencies") {
-    if (restore && backupJson) return backupJson[type][key];
     if (link) mudVersion = resolveLinkPath(filePath, link, key);
     if (!mudVersion) return packageJson[type][key];
     return mudVersion;
@@ -225,10 +188,9 @@ function logComparison(prev: Record<string, string>, curr: Record<string, string
 /**
  * Returns path of the package to link, given a path to a local MUD clone and a package
  */
-function resolveLinkPath(packageJsonPath: string, mudLinkPath: string, pkg: string) {
-  const pkgName = pkg.replace(MUD_PREFIX, "");
+function resolveLinkPath(packageJsonPath: string, mudLinkPath: string, packageName: string) {
   const packageJsonToRootPath = path.relative(path.dirname(packageJsonPath), process.cwd());
-  const linkPath = path.join(packageJsonToRootPath, mudLinkPath, "packages", pkgName);
+  const linkPath = path.join(packageJsonToRootPath, mudLinkPath, mudPackages[packageName].localPath);
   return "link:" + linkPath;
 }
 

package/src/commands/tablegen.ts

@@ -1,7 +1,7 @@
 import path from "path";
 import type { CommandModule } from "yargs";
 import { loadConfig } from "@latticexyz/config/node";
-import { StoreConfig } from "@latticexyz/store";
+import { Store as StoreConfig } from "@latticexyz/store";
 import { tablegen } from "@latticexyz/store/codegen";
 import { getRemappings, getSrcDirectory } from "@latticexyz/common/foundry";
 
@@ -25,7 +25,7 @@ const commandModule: CommandModule<Options, Options> = {
     const srcDir = await getSrcDirectory();
     const remappings = await getRemappings();
 
-    await tablegen(config, path.join(srcDir, config.codegenDirectory), remappings);
+    await tablegen(config, path.join(srcDir, config.codegen.outputDirectory), remappings);
 
     process.exit(0);
   },

package/src/commands/test.ts

@@ -1,70 +1,64 @@
-import type { CommandModule } from "yargs";
+import type { CommandModule, InferredOptionTypes, Options } from "yargs";
 import { anvil, forge, getRpcUrl } from "@latticexyz/common/foundry";
 import chalk from "chalk";
-import { rmSync, writeFileSync } from "fs";
-import { yDeployOptions } from "./deploy";
-import { DeployOptions, deployHandler } from "../utils/deployHandler";
+import { deployOptions, runDeploy } from "../runDeploy";
 
-type Options = DeployOptions & { port?: number; worldAddress?: string; forgeOptions?: string };
+const testOptions = {
+  ...deployOptions,
+  port: { type: "number", description: "Port to run internal node for fork testing on", default: 4242 },
+  worldAddress: {
+    type: "string",
+    description:
+      "Address of an existing world contract. If provided, deployment is skipped and the RPC provided in the foundry.toml is used for fork testing.",
+  },
+  forgeOptions: { type: "string", description: "Options to pass to forge test" },
+} as const satisfies Record<string, Options>;
 
-const WORLD_ADDRESS_FILE = ".mudtest";
+type TestOptions = InferredOptionTypes<typeof testOptions>;
 
-const commandModule: CommandModule<Options, Options> = {
+const commandModule: CommandModule<typeof testOptions, TestOptions> = {
   command: "test",
 
   describe: "Run tests in MUD contracts",
 
   builder(yargs) {
-    return yargs.options({
-      ...yDeployOptions,
-      port: { type: "number", description: "Port to run internal node for fork testing on", default: 4242 },
-      worldAddress: {
-        type: "string",
-        description:
-          "Address of an existing world contract. If provided, deployment is skipped and the RPC provided in the foundry.toml is used for fork testing.",
-      },
-      forgeOptions: { type: "string", description: "Options to pass to forge test" },
-    });
+    return yargs.options(testOptions);
   },
 
-  async handler(args) {
+  async handler(opts) {
     // Start an internal anvil process if no world address is provided
-    if (!args.worldAddress) {
-      const anvilArgs = ["--block-base-fee-per-gas", "0", "--port", String(args.port)];
+    if (!opts.worldAddress) {
+      const anvilArgs = ["--block-base-fee-per-gas", "0", "--port", String(opts.port)];
       anvil(anvilArgs);
     }
 
-    const forkRpc = args.worldAddress ? await getRpcUrl(args.profile) : `http://127.0.0.1:${args.port}`;
+    const forkRpc = opts.worldAddress ? await getRpcUrl(opts.profile) : `http://127.0.0.1:${opts.port}`;
 
     const worldAddress =
-      args.worldAddress ??
+      opts.worldAddress ??
       (
-        await deployHandler({
-          ...args,
+        await runDeploy({
+          ...opts,
           saveDeployment: false,
           rpc: forkRpc,
         })
-      ).worldAddress;
+      ).address;
 
     console.log(chalk.blue("World address", worldAddress));
 
-    // Create a temporary file to pass the world address to the tests
-    writeFileSync(WORLD_ADDRESS_FILE, worldAddress);
-
-    const userOptions = args.forgeOptions?.replaceAll("\\", "").split(" ") ?? [];
+    const userOptions = opts.forgeOptions?.replaceAll("\\", "").split(" ") ?? [];
     try {
-      const testResult = await forge(["test", "--fork-url", forkRpc, ...userOptions], {
-        profile: args.profile,
+      await forge(["test", "--fork-url", forkRpc, ...userOptions], {
+        profile: opts.profile,
+        env: {
+          WORLD_ADDRESS: worldAddress,
+        },
       });
-      console.log(testResult);
+      process.exit(0);
     } catch (e) {
       console.error(e);
-      rmSync(WORLD_ADDRESS_FILE);
       process.exit(1);
     }
-
-    rmSync(WORLD_ADDRESS_FILE);
-    process.exit(0);
   },
 };
 

package/src/commands/trace.ts

@@ -5,19 +5,21 @@ 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 { StoreConfig } from "@latticexyz/store";
-import { resolveWorldConfig, WorldConfig } from "@latticexyz/world";
+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.js";
-import { resourceIdToHex } from "@latticexyz/common";
+import worldConfig from "@latticexyz/world/mud.config";
+import { resourceToHex } from "@latticexyz/common";
 import { getExistingContracts } from "../utils/getExistingContracts";
-import { getChainId } from "../utils/utils/getChainId";
+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 = resourceIdToHex({
+const systemsTableId = resourceToHex({
   type: "system",
   namespace: worldConfig.namespace,
-  name: worldConfig.tables.Systems.name,
+  name: worldConfig.tables.world__Systems.name,
 });
 
 type Options = {
@@ -58,11 +60,12 @@ const commandModule: CommandModule<Options, Options> = {
     const existingContracts = getExistingContracts(srcDir);
 
     // Load the config
-    const mudConfig = (await loadConfig(configPath)) as StoreConfig & WorldConfig;
+    const configV2 = (await loadConfig(configPath)) as WorldConfig;
+    const mudConfig = worldToV1(configV2);
 
     const resolvedConfig = resolveWorldConfig(
       mudConfig,
-      existingContracts.map(({ basename }) => basename)
+      existingContracts.map(({ basename }) => basename),
     );
 
     // Get worldAddress either from args or from worldsFile
@@ -80,7 +83,7 @@ const commandModule: CommandModule<Options, Options> = {
     const systemTableFieldLayout = await WorldContract.getFieldLayout(systemsTableId);
     const labels: { name: string; address: string }[] = [];
     for (const name of names) {
-      const systemSelector = resourceIdToHex({ type: "system", namespace, name });
+      const systemSelector = resourceToHex({ type: "system", namespace, name });
       // Get the first field of `Systems` table (the table maps system name to its address and other data)
       const address = await WorldContract.getField(systemsTableId, [systemSelector], 0, systemTableFieldLayout);
       labels.push({ name, address });
@@ -103,7 +106,8 @@ export default commandModule;
 
 async function getWorldAddress(worldsFile: string, rpc: string) {
   if (existsSync(worldsFile)) {
-    const chainId = await getChainId(rpc);
+    const client = createClient({ transport: http(rpc) });
+    const chainId = await getChainId(client);
     const deploys = JSON.parse(readFileSync(worldsFile, "utf-8"));
 
     if (!deploys[chainId]) {

package/src/commands/worldgen.ts

@@ -1,7 +1,6 @@
 import type { CommandModule } from "yargs";
 import { loadConfig } from "@latticexyz/config/node";
-import { StoreConfig } from "@latticexyz/store";
-import { WorldConfig } from "@latticexyz/world";
+import { World as WorldConfig } from "@latticexyz/world";
 import { worldgen } from "@latticexyz/world/node";
 import { getSrcDirectory } from "@latticexyz/common/foundry";
 import path from "path";
@@ -12,7 +11,7 @@ type Options = {
   configPath?: string;
   clean?: boolean;
   srcDir?: string;
-  config?: StoreConfig & WorldConfig;
+  config?: WorldConfig;
 };
 
 const commandModule: CommandModule<Options, Options> = {
@@ -43,12 +42,14 @@ export async function worldgenHandler(args: Options) {
   const existingContracts = getExistingContracts(srcDir);
 
   // Load the config
-  const mudConfig = args.config ?? ((await loadConfig(args.configPath)) as StoreConfig & WorldConfig);
+  const mudConfig = args.config ?? ((await loadConfig(args.configPath)) as WorldConfig);
 
-  const outputBaseDirectory = path.join(srcDir, mudConfig.codegenDirectory);
+  const outputBaseDirectory = path.join(srcDir, mudConfig.codegen.outputDirectory);
 
   // clear the worldgen directory
-  if (args.clean) rmSync(path.join(outputBaseDirectory, mudConfig.worldgenDirectory), { recursive: true, force: true });
+  if (args.clean) {
+    rmSync(path.join(outputBaseDirectory, mudConfig.codegen.worldgenDirectory), { recursive: true, force: true });
+  }
 
   // generate new interfaces
   await worldgen(mudConfig, existingContracts, outputBaseDirectory);

package/src/common.ts

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

package/src/debug.ts

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

package/src/deploy/common.ts

@@ -0,0 +1,122 @@
+import { Abi, Address, Hex, padHex } from "viem";
+import storeConfig from "@latticexyz/store/mud.config";
+import worldConfig from "@latticexyz/world/mud.config";
+import IBaseWorldAbi from "@latticexyz/world/out/IBaseWorld.sol/IBaseWorld.abi.json" assert { type: "json" };
+import IModuleAbi from "@latticexyz/world-modules/out/IModule.sol/IModule.abi.json" assert { type: "json" };
+import { Tables, configToTables } from "./configToTables";
+import { helloStoreEvent } from "@latticexyz/store";
+import { StoreConfig } from "@latticexyz/store/internal";
+import { helloWorldEvent } from "@latticexyz/world";
+import { WorldConfig } from "@latticexyz/world/internal";
+import { storeToV1 } from "@latticexyz/store/config/v2";
+import { worldToV1 } from "@latticexyz/world/config/v2";
+
+export const salt = padHex("0x", { size: 32 });
+
+// https://eips.ethereum.org/EIPS/eip-170
+export const contractSizeLimit = parseInt("6000", 16);
+
+// TODO: add `as const` to mud config so these get more strongly typed (blocked by current config parsing not using readonly)
+export const storeTables = configToTables(storeToV1(storeConfig));
+export const worldTables = configToTables(worldToV1(worldConfig));
+
+export const worldDeployEvents = [helloStoreEvent, helloWorldEvent] as const;
+
+export const worldAbi = [...IBaseWorldAbi, ...IModuleAbi] as const;
+
+// Ideally, this should be an append-only list. Before adding more versions here, be sure to add backwards-compatible support for old Store/World versions.
+export const supportedStoreVersions = ["2.0.0"];
+export const supportedWorldVersions = ["2.0.0"];
+
+// TODO: extend this to include factory+deployer address? so we can reuse the deployer for a world?
+export type WorldDeploy = {
+  readonly address: Address;
+  readonly worldVersion: string;
+  readonly storeVersion: string;
+  /** Block number where the world was deployed */
+  readonly deployBlock: bigint;
+  /**
+   * Block number at the time of fetching world deploy.
+   * We use this block number when requesting data from the chain to align chain state
+   * with the same block during the introspection steps of the deploy.
+   */
+  readonly stateBlock: bigint;
+};
+
+export type WorldFunction = {
+  readonly signature: string;
+  readonly selector: Hex;
+  readonly systemId: Hex;
+  readonly systemFunctionSignature: string;
+  readonly systemFunctionSelector: Hex;
+};
+
+export type LibraryPlaceholder = {
+  /**
+   * Path to library source file, e.g. `src/libraries/SomeLib.sol`
+   */
+  path: string;
+  /**
+   * Library name, e.g. `SomeLib`
+   */
+  name: string;
+  /**
+   * Byte offset of placeholder in bytecode
+   */
+  start: number;
+  /**
+   * Size of placeholder to replace in bytes
+   */
+  length: number;
+};
+
+export type DeterministicContract = {
+  readonly prepareDeploy: (
+    deployer: Address,
+    libraries: readonly Library[],
+  ) => {
+    readonly address: Address;
+    readonly bytecode: Hex;
+  };
+  readonly deployedBytecodeSize: number;
+  readonly abi: Abi;
+};
+
+export type Library = DeterministicContract & {
+  /**
+   * Path to library source file, e.g. `src/libraries/SomeLib.sol`
+   */
+  path: string;
+  /**
+   * Library name, e.g. `SomeLib`
+   */
+  name: string;
+};
+
+export type System = DeterministicContract & {
+  readonly namespace: string;
+  readonly name: string;
+  readonly systemId: Hex;
+  readonly allowAll: boolean;
+  readonly allowedAddresses: readonly Hex[];
+  readonly allowedSystemIds: readonly Hex[];
+  readonly functions: readonly WorldFunction[];
+};
+
+export type DeployedSystem = Omit<System, "abi" | "prepareDeploy" | "deployedBytecodeSize" | "allowedSystemIds"> & {
+  address: Address;
+};
+
+export type Module = DeterministicContract & {
+  readonly name: string;
+  readonly installAsRoot: boolean;
+  readonly installData: Hex; // TODO: figure out better naming for this
+};
+
+export type ConfigInput = StoreConfig & WorldConfig;
+export type Config<config extends ConfigInput> = {
+  readonly tables: Tables<config>;
+  readonly systems: readonly System[];
+  readonly modules: readonly Module[];
+  readonly libraries: readonly Library[];
+};

package/src/deploy/configToTables.ts

@@ -0,0 +1,70 @@
+import { resourceToHex } from "@latticexyz/common";
+import { KeySchema, ValueSchema } from "@latticexyz/protocol-parser/internal";
+import { SchemaAbiType, StaticAbiType } from "@latticexyz/schema-type/internal";
+import { StoreConfig, resolveUserTypes } from "@latticexyz/store/internal";
+import { Hex } from "viem";
+
+// TODO: we shouldn't need this file once our config parsing returns nicely formed tables
+
+type UserTypes<config extends StoreConfig = StoreConfig> = config["userTypes"];
+// TODO: fix strong enum types and avoid every schema getting `{ [k: string]: "uint8" }`
+// type UserTypes<config extends StoreConfig = StoreConfig> = config["userTypes"] & {
+//   [k in keyof config["enums"]]: { internalType: "uint8" };
+// };
+
+export type TableKey<
+  config extends StoreConfig = StoreConfig,
+  table extends config["tables"][keyof config["tables"]] = config["tables"][keyof config["tables"]],
+> = `${config["namespace"]}_${table["name"]}`;
+
+export type Table<
+  config extends StoreConfig = StoreConfig,
+  table extends config["tables"][keyof config["tables"]] = config["tables"][keyof config["tables"]],
+> = {
+  readonly namespace: config["namespace"];
+  readonly name: table["name"];
+  readonly tableId: Hex;
+  readonly keySchema: table["keySchema"] extends KeySchema<UserTypes<config>>
+    ? KeySchema & {
+        readonly [k in keyof table["keySchema"]]: UserTypes<config>[table["keySchema"][k]]["internalType"] extends StaticAbiType
+          ? UserTypes<config>[table["keySchema"][k]]["internalType"]
+          : table["keySchema"][k];
+      }
+    : KeySchema;
+  readonly valueSchema: table["valueSchema"] extends ValueSchema<UserTypes<config>>
+    ? {
+        readonly [k in keyof table["valueSchema"]]: UserTypes<config>[table["valueSchema"][k]]["internalType"] extends SchemaAbiType
+          ? UserTypes<config>[table["valueSchema"][k]]["internalType"]
+          : table["valueSchema"][k];
+      }
+    : ValueSchema;
+};
+
+export type Tables<config extends StoreConfig = StoreConfig> = {
+  readonly [k in keyof config["tables"] as TableKey<config, config["tables"][k]>]: Table<config, config["tables"][k]>;
+};
+
+export function configToTables<config extends StoreConfig>(config: config): Tables<config> {
+  const userTypes = {
+    ...config.userTypes,
+    ...Object.fromEntries(Object.entries(config.enums).map(([key]) => [key, { internalType: "uint8" }] as const)),
+  };
+  return Object.fromEntries(
+    Object.entries(config.tables).map(([tableName, table]) => [
+      `${config.namespace}_${tableName}` satisfies TableKey<config, config["tables"][keyof config["tables"]]>,
+      {
+        namespace: config.namespace,
+        name: table.name,
+        tableId: resourceToHex({
+          type: table.offchainOnly ? "offchainTable" : "table",
+          namespace: config.namespace,
+          name: table.name,
+        }),
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        keySchema: resolveUserTypes(table.keySchema, userTypes) as any,
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        valueSchema: resolveUserTypes(table.valueSchema, userTypes) as any,
+      } satisfies Table<config, config["tables"][keyof config["tables"]]>,
+    ]),
+  ) as Tables<config>;
+}

package/src/deploy/create2/README.md

@@ -0,0 +1,13 @@
+Files generated by
+
+```
+git clone https://github.com/Arachnid/deterministic-deployment-proxy.git
+cd deterministic-deployment-proxy
+git checkout b3bb19c
+npm install
+npm run build
+cd output
+jq --arg bc "$(cat bytecode.txt)" '. + {bytecode: $bc}' deployment.json > deployment-with-bytecode.json
+mv deployment-with-bytecode.json deployment.json
+cp deployment.json ../path/to/this/dir
+```

package/src/deploy/create2/deployment.json

@@ -0,0 +1,8 @@
+{
+  "gasPrice": 100000000000,
+  "gasLimit": 100000,
+  "signerAddress": "3fab184622dc19b6109349b94811493bf2a45362",
+  "transaction": "f8a58085174876e800830186a08080b853604580600e600039806000f350fe7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe03601600081602082378035828234f58015156039578182fd5b8082525050506014600cf31ba02222222222222222222222222222222222222222222222222222222222222222a02222222222222222222222222222222222222222222222222222222222222222",
+  "address": "4e59b44847b379578588920ca78fbf26c0b4956c",
+  "bytecode": "604580600e600039806000f350fe7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe03601600081602082378035828234f58015156039578182fd5b8082525050506014600cf3"
+}

package/src/deploy/createPrepareDeploy.ts

@@ -0,0 +1,28 @@
+import { DeterministicContract, Library, LibraryPlaceholder, salt } from "./common";
+import { spliceHex } from "@latticexyz/common";
+import { Hex, getCreate2Address, Address } from "viem";
+
+export function createPrepareDeploy(
+  bytecodeWithPlaceholders: Hex,
+  placeholders: readonly LibraryPlaceholder[],
+): DeterministicContract["prepareDeploy"] {
+  return function prepareDeploy(deployer: Address, libraries: readonly Library[]) {
+    let bytecode = bytecodeWithPlaceholders;
+    for (const placeholder of placeholders) {
+      const library = libraries.find((lib) => lib.path === placeholder.path && lib.name === placeholder.name);
+      if (!library) {
+        throw new Error(`Could not find library for bytecode placeholder ${placeholder.path}:${placeholder.name}`);
+      }
+      bytecode = spliceHex(
+        bytecode,
+        placeholder.start,
+        placeholder.length,
+        library.prepareDeploy(deployer, libraries).address,
+      );
+    }
+    return {
+      bytecode,
+      address: getCreate2Address({ from: deployer, bytecode, salt }),
+    };
+  };
+}