@latticexyz/cli 1.40.0 → 1.41.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@latticexyz/cli",
-  "version": "1.40.0",
+  "version": "1.41.0",
   "description": "Command line interface for mud",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -16,15 +16,18 @@
   },
   "scripts": {
     "prepare": "yarn build && chmod u+x git-install.sh",
+    "codegen": "ts-node --esm --files ./scripts/codegen.ts",
     "lint": "eslint . --ext .ts",
     "dev": "tsup --watch",
     "build": "tsup",
     "link": "yarn link",
-    "test": "vitest typecheck --run && echo 'todo: add tests'",
+    "test": "vitest typecheck --run && yarn test:contracts",
+    "test:contracts": "yarn codegen && forge test",
     "git:install": "bash git-install.sh",
-    "release": "npm publish || echo 'version already published'"
+    "release": "npm publish --access=public"
   },
   "devDependencies": {
+    "@latticexyz/store": "^1.41.0",
     "@types/ejs": "^3.1.1",
     "@types/glob": "^7.2.0",
     "@types/node": "^17.0.34",
@@ -37,17 +40,18 @@
   "dependencies": {
     "@improbable-eng/grpc-web": "^0.15.0",
     "@improbable-eng/grpc-web-node-http-transport": "^0.15.0",
-    "@latticexyz/schema-type": "^1.40.0",
-    "@latticexyz/services": "^1.40.0",
-    "@latticexyz/solecs": "^1.40.0",
-    "@latticexyz/std-contracts": "^1.40.0",
+    "@latticexyz/schema-type": "^1.41.0",
+    "@latticexyz/services": "^1.41.0",
+    "@latticexyz/solecs": "^1.41.0",
+    "@latticexyz/std-contracts": "^1.41.0",
     "@typechain/ethers-v5": "^10.1.1",
     "chalk": "^5.0.1",
     "chokidar": "^3.5.3",
+    "dotenv": "^16.0.3",
     "ds-test": "https://github.com/dapphub/ds-test.git#c9ce3f25bde29fc5eb9901842bf02850dfd2d084",
     "ejs": "^3.1.8",
     "ethers": "^5.7.2",
-    "execa": "^6.1.0",
+    "execa": "^7.0.0",
     "find-up": "^6.3.0",
     "forge-std": "https://github.com/foundry-rs/forge-std.git#b4f121555729b3afb3c5ffccb62ff4b6e2818fd3",
     "glob": "^8.0.3",
@@ -65,5 +69,5 @@
     "zod": "^3.20.6",
     "zod-validation-error": "^0.3.2"
   },
-  "gitHead": "914a1e0ae4a573d685841ca2ea921435057deb8f"
+  "gitHead": "ecac84146f0288e3a129d1d3dbfaf373db86b1ab"
 }

package/src/commands/deploy-v2.ts

@@ -0,0 +1,100 @@
+import chalk from "chalk";
+import glob from "glob";
+import path, { basename } from "path";
+import type { CommandModule } from "yargs";
+import { loadWorldConfig } from "../config/loadWorldConfig.js";
+import { deploy } from "../utils/deploy-v2.js";
+import { logError, MUDError } from "../utils/errors.js";
+import { forge, getRpcUrl } from "../utils/foundry.js";
+import { getOutDirectory } from "../utils/foundry.js";
+import { mkdirSync, writeFileSync } from "fs";
+import { loadStoreConfig } from "../config/loadStoreConfig.js";
+import { deploymentInfoFilenamePrefix } from "../constants.js";
+
+type Options = {
+  configPath?: string;
+  printConfig?: boolean;
+  profile?: string;
+  privateKey: string;
+  priorityFeeMultiplier: number;
+  clean?: boolean;
+};
+
+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" },
+      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 outDir = await getOutDirectory();
+    const existingContracts = glob
+      .sync(`${outDir}/*.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 });
+
+      // Write deployment result to file (latest and timestamp)
+      const outputDir = mudConfig.deploymentInfoDirectory;
+      mkdirSync(outputDir, { recursive: true });
+      writeFileSync(
+        path.join(outputDir, deploymentInfoFilenamePrefix + "latest.json"),
+        JSON.stringify(deploymentInfo, null, 2)
+      );
+      writeFileSync(
+        path.join(outputDir, deploymentInfoFilenamePrefix + 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);
+    }
+
+    process.exit(0);
+  },
+};
+
+export default commandModule;

package/src/commands/deprecated/call-system.ts

@@ -2,7 +2,7 @@ import { defaultAbiCoder as abi } from "ethers/lib/utils.js";
 import path from "path";
 import type { CommandModule } from "yargs";
 import { execLog } from "../../utils/deprecated/index.js";
-import { getTestDirectory } from "../../utils/forgeConfig.js";
+import { getTestDirectory } from "../../utils/foundry.js";
 
 type Options = {
   rpc?: string;

package/src/commands/deprecated/deploy-contracts.ts

@@ -2,7 +2,7 @@ import type { CommandModule } from "yargs";
 import { DeployOptions, generateAndDeploy, hsr } from "../../utils/deprecated/index.js";
 import openurl from "openurl";
 import chalk from "chalk";
-import { getSrcDirectory } from "../../utils/forgeConfig.js";
+import { getSrcDirectory } from "../../utils/foundry.js";
 
 type Options = DeployOptions & {
   watch?: boolean;

package/src/commands/deprecated/test.ts

@@ -1,6 +1,6 @@
 import type { CommandModule } from "yargs";
 import { execLog, generateLibDeploy, resetLibDeploy } from "../../utils/deprecated/index.js";
-import { getTestDirectory } from "../../utils/forgeConfig.js";
+import { getTestDirectory } from "../../utils/foundry.js";
 
 type Options = {
   forgeOpts?: string;
@@ -35,15 +35,18 @@ const commandModule: CommandModule<Options, Options> = {
       ...(forgeOpts?.split(" ") || []),
     ]);
 
-    // Reset LibDeploy.sol
-    console.log("Reset LibDeploy.sol");
-    await resetLibDeploy(testDir);
-
-    process.on("SIGINT", () => {
+    process.on("SIGINT", async () => {
       console.log("\ngracefully shutting down from SIGINT (Crtl-C)");
       child.kill();
+      await resetLibDeploy(testDir);
       process.exit();
     });
+
+    await child;
+    
+    // Reset LibDeploy.sol
+    console.log("Reset LibDeploy.sol");
+    await resetLibDeploy(testDir);
   },
 };
 

package/src/commands/deprecated/trace.ts

@@ -4,7 +4,7 @@ import { readFileSync } from "fs";
 import { Contract } from "ethers";
 import { JsonRpcProvider } from "@ethersproject/providers";
 import WorldAbi from "@latticexyz/solecs/abi/World.json" assert { type: "json" };
-import { getSrcDirectory } from "../../utils/forgeConfig.js";
+import { getSrcDirectory } from "../../utils/foundry.js";
 import path from "path";
 import { componentsDir, systemsDir } from "../../utils/deprecated/constants.js";
 

package/src/commands/gas-report.ts

@@ -156,7 +156,7 @@ console.log("GAS REPORT: ${name} [${functionCall.replaceAll('"', '\\"')}]:", _ga
     stdio: ["inherit", "pipe", "inherit"],
   });
 
-  // Extrect the logs from the child process
+  // Extract the logs from the child process
   let logs = "";
   try {
     logs = (await child).stdout;

package/src/commands/index.ts

@@ -14,6 +14,7 @@ import faucet from "./faucet.js";
 import gasReport from "./gas-report.js";
 import hello from "./hello.js";
 import tablegen from "./tablegen.js";
+import deployV2 from "./deploy-v2.js";
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any -- Each command has different options
 export const commands: CommandModule<any, any>[] = [
@@ -21,6 +22,7 @@ export const commands: CommandModule<any, any>[] = [
   callSystem,
   codegenLibdeploy,
   deployContracts,
+  deployV2,
   devnode,
   faucet,
   gasReport,

package/src/commands/tablegen.ts

@@ -1,10 +1,7 @@
 import type { CommandModule } from "yargs";
-import { mkdirSync, writeFileSync } from "fs";
-import path from "path";
 import { loadStoreConfig } from "../config/loadStoreConfig.js";
-import { renderTablesFromConfig } from "../render-table/renderTablesFromConfig.js";
-import { getSrcDirectory } from "../utils/forgeConfig.js";
-import { formatSolidity } from "../utils/format.js";
+import { getSrcDirectory } from "../utils/foundry.js";
+import { tablegen } from "../render-solidity/tablegen.js";
 
 type Options = {
   configPath?: string;
@@ -22,22 +19,11 @@ const commandModule: CommandModule<Options, Options> = {
   },
 
   async handler({ configPath }) {
-    const srcDir = await getSrcDirectory();
+    const srcDirectory = await getSrcDirectory();
 
     const config = await loadStoreConfig(configPath);
-    const renderedTables = renderTablesFromConfig(config);
 
-    for (const { output, tableName } of renderedTables) {
-      const formattedOutput = await formatSolidity(output);
-
-      const tablePath = config.tables[tableName].route;
-      const outputDirectory = path.join(srcDir, tablePath);
-      mkdirSync(outputDirectory, { recursive: true });
-
-      const outputPath = path.join(outputDirectory, `${tableName}.sol`);
-      writeFileSync(outputPath, formattedOutput);
-      console.log(`Generated schema: ${outputPath}`);
-    }
+    await tablegen(config, srcDirectory);
 
     process.exit(0);
   },

package/src/config/commonSchemas.ts

@@ -1,7 +1,11 @@
+import { getStaticByteLength, SchemaType } from "@latticexyz/schema-type";
 import { z } from "zod";
 import {
   validateBaseRoute,
   validateCapitalizedName,
+  validateEthereumAddress,
+  validateEnum,
+  validateName,
   validateRoute,
   validateSingleLevelRoute,
   validateUncapitalizedName,
@@ -11,6 +15,10 @@ import {
 export const ObjectName = z.string().superRefine(validateCapitalizedName);
 /** Uncapitalized names of values, like keys and columns */
 export const ValueName = z.string().superRefine(validateUncapitalizedName);
+/** Name that can start with any case */
+export const AnyCaseName = z.string().superRefine(validateName);
+/** List of unique enum member names and 0 < length < 256 */
+export const UserEnum = z.array(ObjectName).superRefine(validateEnum);
 
 /** Ordinary routes */
 export const OrdinaryRoute = z.string().superRefine(validateRoute);
@@ -18,3 +26,11 @@ export const OrdinaryRoute = z.string().superRefine(validateRoute);
 export const SingleLevelRoute = z.string().superRefine(validateSingleLevelRoute);
 /** Base routes (can be an empty string) */
 export const BaseRoute = z.string().superRefine(validateBaseRoute);
+
+/** A valid Ethereum address */
+export const EthereumAddress = z.string().superRefine(validateEthereumAddress);
+
+/** Static subset of SchemaType enum */
+export const StaticSchemaType = z
+  .nativeEnum(SchemaType)
+  .refine((arg) => getStaticByteLength(arg) > 0, "SchemaType must be static");

package/src/config/index.ts

@@ -1,4 +1,12 @@
+import { StoreUserConfig, StoreConfig } from "./parseStoreConfig.js";
+import { WorldUserConfig, ResolvedWorldConfig } from "./loadWorldConfig.js";
+
+export type MUDUserConfig = StoreUserConfig & WorldUserConfig;
+export type MUDConfig = StoreConfig & ResolvedWorldConfig;
+
 export * from "./commonSchemas.js";
 export * from "./loadConfig.js";
 export * from "./loadStoreConfig.js";
+export * from "./parseStoreConfig.js";
+export * from "./loadWorldConfig.js";
 export * from "./validation.js";

package/src/config/loadStoreConfig.ts

@@ -1,89 +1,7 @@
-import { SchemaType, getStaticByteLength } from "@latticexyz/schema-type";
-import { z, ZodError } from "zod";
+import { ZodError } from "zod";
 import { fromZodErrorCustom } from "../utils/errors.js";
-import { BaseRoute, ObjectName, OrdinaryRoute, ValueName } from "./commonSchemas.js";
 import { loadConfig } from "./loadConfig.js";
-
-const TableName = ObjectName;
-const KeyName = ValueName;
-const ColumnName = ValueName;
-
-const PrimaryKey = z
-  .nativeEnum(SchemaType)
-  .refine((arg) => getStaticByteLength(arg) > 0, "Primary key must not use dynamic SchemaType");
-const PrimaryKeys = z.record(KeyName, PrimaryKey).default({ key: SchemaType.BYTES32 });
-
-const Schema = z
-  .record(ColumnName, z.nativeEnum(SchemaType))
-  .refine((arg) => Object.keys(arg).length > 0, "Table schema may not be empty");
-
-const FullTable = z
-  .object({
-    route: OrdinaryRoute.default("/tables"),
-    tableIdArgument: z.boolean().default(false),
-    storeArgument: z.boolean().default(false),
-    primaryKeys: PrimaryKeys,
-    schema: Schema,
-    dataStruct: z.boolean().optional(),
-  })
-  .transform((arg) => {
-    // default dataStruct value depends on schema's length
-    if (Object.keys(arg.schema).length === 1) {
-      arg.dataStruct ??= false;
-    } else {
-      arg.dataStruct ??= true;
-    }
-    return arg as Omit<typeof arg, "dataStruct"> & Required<Pick<typeof arg, "dataStruct">>;
-  });
-
-const DefaultSingleValueTable = z.nativeEnum(SchemaType).transform((schemaType) => {
-  return FullTable.parse({
-    schema: {
-      value: schemaType,
-    },
-  });
-});
-
-export const StoreConfig = z.object({
-  baseRoute: BaseRoute.default(""),
-  storeImportPath: z.string().default("@latticexyz/store/src/"),
-  tables: z.record(TableName, z.union([DefaultSingleValueTable, FullTable])),
-});
-
-// zod doesn't preserve doc comments
-export interface StoreUserConfig {
-  /** The base route prefix for table ids. Default is "" (empty string) */
-  baseRoute?: string;
-  /** Path for store package imports. Default is "@latticexyz/store/src/" */
-  storeImportPath?: string;
-  /**
-   * Configuration for each table.
-   *
-   * The key is the table name (capitalized).
-   *
-   * The value:
-   *  - SchemaType for a single-value table (aka ECS component).
-   *  - FullTableConfig object for multi-value tables (or for customizable options).
-   */
-  tables: Record<string, SchemaType | FullTableConfig>;
-}
-
-interface FullTableConfig {
-  /** Output path for the file, and relevant for the table id. The table id will be keccak256(concat(baseRoute,route,tableName)). Default is "tables/" */
-  route?: string;
-  /** Make methods accept `tableId` argument instead of it being a hardcoded constant. Default is false */
-  tableIdArgument?: boolean;
-  /** Include methods that accept a manual `IStore` argument. Default is false. */
-  storeArgument?: boolean;
-  /** Include a data struct and methods for it. Default is false for 1-column tables; true for multi-column tables. */
-  dataStruct?: boolean;
-  /** Table's primary key names mapped to their types. Default is `{ key: SchemaType.BYTES32 }` */
-  primaryKeys?: Record<string, SchemaType>;
-  /** Table's column names mapped to their types. Table name's 1st letter should be lowercase. */
-  schema: Record<string, SchemaType>;
-}
-
-export type StoreConfig = z.output<typeof StoreConfig>;
+import { parseStoreConfig } from "./parseStoreConfig.js";
 
 export async function loadStoreConfig(configPath?: string) {
   const config = await loadConfig(configPath);
@@ -98,7 +16,3 @@ export async function loadStoreConfig(configPath?: string) {
     }
   }
 }
-
-export async function parseStoreConfig(config: unknown) {
-  return StoreConfig.parse(config);
-}

package/src/config/loadWorldConfig.test-d.ts

@@ -0,0 +1,11 @@
+import { describe, expectTypeOf } from "vitest";
+import { z } from "zod";
+import { WorldConfig, WorldUserConfig } from "./loadWorldConfig.js";
+
+describe("loadWorldConfig", () => {
+  // Typecheck manual interfaces against zod
+  expectTypeOf<WorldUserConfig>().toEqualTypeOf<z.input<typeof WorldConfig>>();
+  // type equality isn't deep for optionals
+  expectTypeOf<WorldUserConfig["overrideSystems"]>().toEqualTypeOf<z.input<typeof WorldConfig>["overrideSystems"]>();
+  // TODO If more nested schemas are added, provide separate tests for them
+});

package/src/config/loadWorldConfig.ts

@@ -0,0 +1,178 @@
+import { z, ZodError } from "zod";
+import { fromZodErrorCustom, UnrecognizedSystemErrorFactory } from "../utils/errors.js";
+import { BaseRoute, EthereumAddress, ObjectName } from "./commonSchemas.js";
+import { loadConfig } from "./loadConfig.js";
+
+const SystemName = ObjectName;
+const SystemRoute = BaseRoute.optional();
+const SystemAccessList = z.array(SystemName.or(EthereumAddress)).default([]);
+
+// The system config is a combination of a route config and access config
+const SystemConfig = z.intersection(
+  z.object({
+    route: SystemRoute,
+  }),
+  z.discriminatedUnion("openAccess", [
+    z.object({
+      openAccess: z.literal(true),
+    }),
+    z.object({
+      openAccess: z.literal(false),
+      accessList: SystemAccessList,
+    }),
+  ])
+);
+
+// The parsed world config is the result of parsing the user config
+export const WorldConfig = z.object({
+  baseRoute: BaseRoute.default(""),
+  worldContractName: z.string().optional(),
+  overrideSystems: z.record(SystemName, SystemConfig).default({}),
+  excludeSystems: z.array(SystemName).default([]),
+  postDeployScript: z.string().default("PostDeploy"),
+  deploymentInfoDirectory: z.string().default("."),
+});
+
+/**
+ * Resolves the system config by combining the default and overridden system configs,
+ * @param systemName name of the system
+ * @param config optional SystemConfig object, if none is provided the default config is used
+ * @param existingContracts optional list of existing contract names, used to validate system names in the access list. If not provided, no validation is performed.
+ * @returns ResolvedSystemConfig object
+ * Default value for route is `/${systemName}`
+ * Default value for openAccess is true
+ * Default value for accessListAddresses is []
+ * Default value for accessListSystems is []
+ */
+export function resolveSystemConfig(systemName: string, config?: SystemUserConfig, existingContracts?: string[]) {
+  const route = config?.route ?? `/${systemName}`;
+  const openAccess = config?.openAccess ?? true;
+  const accessListAddresses: string[] = [];
+  const accessListSystems: string[] = [];
+  const accessList = config && !config.openAccess ? config.accessList : [];
+
+  // Split the access list into addresses and system names
+  for (const accessListItem of accessList) {
+    if (accessListItem.startsWith("0x")) {
+      accessListAddresses.push(accessListItem);
+    } else {
+      // Validate every system refers to an existing system contract
+      if (existingContracts && !existingContracts.includes(accessListItem)) {
+        throw UnrecognizedSystemErrorFactory(["overrideSystems", systemName, "accessList"], accessListItem);
+      }
+      accessListSystems.push(accessListItem);
+    }
+  }
+
+  return { route, openAccess, accessListAddresses, accessListSystems };
+}
+
+/**
+ * Resolves the world config by combining the default and overridden system configs,
+ * filtering out excluded systems, validate system names refer to existing contracts, and
+ * splitting the access list into addresses and system names.
+ */
+export function resolveWorldConfig(config: ParsedWorldConfig, existingContracts?: string[]) {
+  // Include contract names ending in "System", but not the base "System" contract
+  const defaultSystemNames = existingContracts?.filter((name) => name.endsWith("System") && name !== "System") ?? [];
+  const overriddenSystemNames = Object.keys(config.overrideSystems);
+
+  // Validate every key in overrideSystems refers to an existing system contract (and is not called "World")
+  if (existingContracts) {
+    for (const systemName of overriddenSystemNames) {
+      if (!existingContracts.includes(systemName) || systemName === "World") {
+        throw UnrecognizedSystemErrorFactory(["overrideSystems", systemName], systemName);
+      }
+    }
+  }
+
+  // Combine the default and overridden system names and filter out excluded systems
+  const systemNames = [...new Set([...defaultSystemNames, ...overriddenSystemNames])].filter(
+    (name) => !config.excludeSystems.includes(name)
+  );
+
+  // Resolve the config
+  const resolvedSystems: Record<string, ResolvedSystemConfig> = systemNames.reduce((acc, systemName) => {
+    return {
+      ...acc,
+      [systemName]: resolveSystemConfig(systemName, config.overrideSystems[systemName], existingContracts),
+    };
+  }, {});
+
+  const { overrideSystems, excludeSystems, ...otherConfig } = config;
+  return { ...otherConfig, systems: resolvedSystems };
+}
+
+/**
+ * Loads and resolves the world config.
+ * @param configPath Path to load the config from. Defaults to "mud.config.mts" or "mud.config.ts"
+ * @param existingContracts Optional list of existing contract names to validate system names against. If not provided, no validation is performed. Contract names ending in `System` will be added to the config with default values.
+ * @returns Promise of ResolvedWorldConfig object
+ */
+export async function loadWorldConfig(configPath?: string, existingContracts?: string[]) {
+  const config = await loadConfig(configPath);
+
+  try {
+    const parsedConfig = WorldConfig.parse(config);
+    return resolveWorldConfig(parsedConfig, existingContracts);
+  } catch (error) {
+    if (error instanceof ZodError) {
+      throw fromZodErrorCustom(error, "WorldConfig Validation Error");
+    } else {
+      throw error;
+    }
+  }
+}
+
+export async function parseWorldConfig(config: unknown) {
+  return WorldConfig.parse(config);
+}
+
+// zod doesn't preserve doc comments
+export type SystemUserConfig =
+  | {
+      /** The system will be deployed at `baseRoute + route` */
+      route?: string;
+    } & (
+      | {
+          /** If openAccess is true, any address can call the system */
+          openAccess: true;
+        }
+      | {
+          /** If openAccess is false, only the addresses or systems in `access` can call the system */
+          openAccess: false;
+          /** An array of addresses or system names that can access the system */
+          accessList: string[];
+        }
+    );
+
+// zod doesn't preserve doc comments
+export interface WorldUserConfig {
+  /** The base route to register tables and systems at. Defaults to the root route (empty string) */
+  baseRoute?: string;
+  /** The name of the World contract to deploy. If no name is provided, a vanilla World is deployed */
+  worldContractName?: string;
+  /**
+   * Contracts named *System will be deployed by default
+   * as public systems at `baseRoute/ContractName`, unless overridden
+   *
+   * The key is the system name (capitalized).
+   * The value is a SystemConfig object.
+   */
+  overrideSystems?: Record<string, SystemUserConfig>;
+  /** Systems to exclude from automatic deployment */
+  excludeSystems?: string[];
+  /**
+   * Script to execute after the deployment is complete (Default "PostDeploy").
+   * Script must be placed in the forge scripts directory (see foundry.toml) and have a ".s.sol" extension.
+   */
+  postDeployScript?: string;
+  /** Directory to write the deployment info to (Default ".") */
+  deploymentInfoDirectory?: string;
+}
+
+export type ParsedWorldConfig = z.output<typeof WorldConfig>;
+
+export type ResolvedSystemConfig = ReturnType<typeof resolveSystemConfig>;
+
+export type ResolvedWorldConfig = ReturnType<typeof resolveWorldConfig>;

package/src/config/{loadStoreConfig.test-d.ts → parseStoreConfig.test-d.ts}

@@ -1,11 +1,14 @@
 import { describe, expectTypeOf } from "vitest";
 import { z } from "zod";
-import { StoreConfig, StoreUserConfig } from "./loadStoreConfig.js";
+import { StoreConfig, StoreUserConfig } from "./parseStoreConfig.js";
 
-describe("loadStoreConfig", () => {
+describe("StoreUserConfig", () => {
   // Typecheck manual interfaces against zod
   expectTypeOf<StoreUserConfig>().toEqualTypeOf<z.input<typeof StoreConfig>>();
   // type equality isn't deep for optionals
   expectTypeOf<StoreUserConfig["tables"][string]>().toEqualTypeOf<z.input<typeof StoreConfig>["tables"][string]>();
+  expectTypeOf<NonNullable<NonNullable<StoreUserConfig["userTypes"]>["enums"]>[string]>().toEqualTypeOf<
+    NonNullable<NonNullable<z.input<typeof StoreConfig>["userTypes"]>["enums"]>[string]
+  >();
   // TODO If more nested schemas are added, provide separate tests for them
 });