@latticexyz/cli 1.41.0 → 1.41.1-alpha.41

package/dist/utils/index.d.ts

@@ -1,5 +1,93 @@
-export { D as DeployConfig, m as DeploymentInfo, F as ForgeConfig, M as MUDError, a as NotESMConfigError, N as NotInsideProjectError, U as UnrecognizedSystemErrorFactory, j as cast, n as deploy, i as forge, k as formatSolidity, f as fromZodErrorCustom, g as getForgeConfig, e as getOutDirectory, h as getRpcUrl, c as getScriptDirectory, b as getSrcDirectory, d as getTestDirectory, l as logError } from '../deploy-v2-b7b3207d.js';
-import 'zod';
-import 'zod-validation-error';
-import '../config/index.js';
+import { ZodError, z } from 'zod';
+import { ValidationError } from 'zod-validation-error';
+import { MUDConfig } from '../config/index.js';
 import '@latticexyz/schema-type';
+
+declare function fromZodErrorCustom(error: ZodError, prefix: string): ValidationError;
+declare class NotInsideProjectError extends Error {
+    name: string;
+    message: string;
+}
+declare class NotESMConfigError extends Error {
+    name: string;
+    message: string;
+}
+declare class MUDError extends Error {
+    name: string;
+}
+declare function UnrecognizedSystemErrorFactory(path: string[], systemName: string): z.ZodError<any>;
+declare function logError(error: unknown): void;
+
+interface ForgeConfig {
+    src: string;
+    test: string;
+    script: string;
+    out: string;
+    libs: string[];
+    eth_rpc_url: string | null;
+    [key: string]: unknown;
+}
+/**
+ * Get forge config as a parsed json object.
+ */
+declare function getForgeConfig(profile?: string): Promise<ForgeConfig>;
+/**
+ * Get the value of "src" from forge config.
+ * The path to the contract sources relative to the root of the project.
+ */
+declare function getSrcDirectory(profile?: string): Promise<string>;
+/**
+ * Get the value of "script" from forge config.
+ * The path to the contract sources relative to the root of the project.
+ */
+declare function getScriptDirectory(profile?: string): Promise<string>;
+/**
+ * Get the value of "test" from forge config.
+ * The path to the test contract sources relative to the root of the project.
+ */
+declare function getTestDirectory(profile?: string): Promise<string>;
+/**
+ * Get the value of "out" from forge config.
+ * The path to put contract artifacts in, relative to the root of the project.
+ */
+declare function getOutDirectory(profile?: string): Promise<string>;
+/**
+ * Get the value of "eth_rpc_url" from forge config, default to "http://127.0.0.1:8545"
+ * @param profile The foundry profile to use
+ * @returns The rpc url
+ */
+declare function getRpcUrl(profile?: string): Promise<string>;
+/**
+ * Execute a forge command
+ * @param args The arguments to pass to forge
+ * @param options { profile?: The foundry profile to use; silent?: If true, nothing will be logged to the console }
+ */
+declare function forge(args: string[], options?: {
+    profile?: string;
+    silent?: boolean;
+}): Promise<void>;
+/**
+ * Execute a cast command
+ * @param args The arguments to pass to cast
+ * @returns Stdout of the command
+ */
+declare function cast(args: string[], options?: {
+    profile?: string;
+}): Promise<string>;
+
+declare function formatSolidity(content: string, prettierConfigPath?: string): Promise<string>;
+
+interface DeployConfig {
+    profile?: string;
+    rpc: string;
+    privateKey: string;
+    priorityFeeMultiplier: number;
+    debug?: boolean;
+}
+interface DeploymentInfo {
+    blockNumber: number;
+    worldAddress: string;
+}
+declare function deploy(mudConfig: MUDConfig, deployConfig: DeployConfig): Promise<DeploymentInfo>;
+
+export { DeployConfig, DeploymentInfo, ForgeConfig, MUDError, NotESMConfigError, NotInsideProjectError, UnrecognizedSystemErrorFactory, cast, deploy, forge, formatSolidity, fromZodErrorCustom, getForgeConfig, getOutDirectory, getRpcUrl, getScriptDirectory, getSrcDirectory, getTestDirectory, logError };

package/dist/utils/index.js

@@ -1,8 +1,7 @@
-import "../chunk-AER7UDD4.js";
 import {
   deploy,
   formatSolidity
-} from "../chunk-ZYDMYSTH.js";
+} from "../chunk-O57QENJ6.js";
 import {
   MUDError,
   NotESMConfigError,
@@ -10,7 +9,7 @@ import {
   UnrecognizedSystemErrorFactory,
   fromZodErrorCustom,
   logError
-} from "../chunk-GR245KYP.js";
+} from "../chunk-J4DJQNIC.js";
 import {
   cast,
   forge,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@latticexyz/cli",
-  "version": "1.41.0",
+  "version": "1.41.1-alpha.41+efdfeb310",
   "description": "Command line interface for mud",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -27,7 +27,7 @@
     "release": "npm publish --access=public"
   },
   "devDependencies": {
-    "@latticexyz/store": "^1.41.0",
+    "@latticexyz/store": "^1.41.1-alpha.41+efdfeb310",
     "@types/ejs": "^3.1.1",
     "@types/glob": "^7.2.0",
     "@types/node": "^17.0.34",
@@ -40,10 +40,11 @@
   "dependencies": {
     "@improbable-eng/grpc-web": "^0.15.0",
     "@improbable-eng/grpc-web-node-http-transport": "^0.15.0",
-    "@latticexyz/schema-type": "^1.41.0",
-    "@latticexyz/services": "^1.41.0",
-    "@latticexyz/solecs": "^1.41.0",
-    "@latticexyz/std-contracts": "^1.41.0",
+    "@latticexyz/schema-type": "^1.41.1-alpha.41+efdfeb310",
+    "@latticexyz/services": "^1.41.1-alpha.41+efdfeb310",
+    "@latticexyz/solecs": "^1.41.1-alpha.41+efdfeb310",
+    "@latticexyz/std-contracts": "^1.41.1-alpha.41+efdfeb310",
+    "@solidity-parser/parser": "^0.16.0",
     "@typechain/ethers-v5": "^10.1.1",
     "chalk": "^5.0.1",
     "chokidar": "^3.5.3",
@@ -66,8 +67,8 @@
     "typechain": "^8.1.1",
     "typescript": "^4.9.5",
     "yargs": "^17.7.1",
-    "zod": "^3.20.6",
-    "zod-validation-error": "^0.3.2"
+    "zod": "^3.21.4",
+    "zod-validation-error": "^1.0.1"
   },
-  "gitHead": "ecac84146f0288e3a129d1d3dbfaf373db86b1ab"
+  "gitHead": "efdfeb3102429e76ed87352cf69465990004957b"
 }

package/src/commands/deploy-v2.ts

@@ -2,14 +2,13 @@ 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 { loadWorldConfig } from "../config/world/index.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 { forge, getRpcUrl, getSrcDirectory } from "../utils/foundry.js";
 import { mkdirSync, writeFileSync } from "fs";
 import { loadStoreConfig } from "../config/loadStoreConfig.js";
-import { deploymentInfoFilenamePrefix } from "../constants.js";
+import { getChainId } from "../utils/getChainId.js";
 
 type Options = {
   configPath?: string;
@@ -18,6 +17,7 @@ type Options = {
   privateKey: string;
   priorityFeeMultiplier: number;
   clean?: boolean;
+  debug?: boolean;
 };
 
 const commandModule: CommandModule<Options, Options> = {
@@ -31,6 +31,7 @@ const commandModule: CommandModule<Options, Options> = {
       clean: { type: "boolean", desc: "Remove the build forge artifacts and cache directories before building" },
       printConfig: { type: "boolean", desc: "Print the resolved config" },
       profile: { type: "string", desc: "The foundry profile to use" },
+      debug: { type: "boolean", desc: "Print debug logs, like full error messages" },
       priorityFeeMultiplier: {
         type: "number",
         desc: "Multiply the estimated priority fee by the provided factor",
@@ -56,9 +57,9 @@ const commandModule: CommandModule<Options, Options> = {
     await forge(["build"], { profile });
 
     // Get a list of all contract names
-    const outDir = await getOutDirectory();
+    const srcDir = await getSrcDirectory();
     const existingContracts = glob
-      .sync(`${outDir}/*.sol`)
+      .sync(`${srcDir}/**/*.sol`)
       // Get the basename of the file
       .map((path) => basename(path, ".sol"));
 
@@ -75,16 +76,11 @@ const commandModule: CommandModule<Options, Options> = {
       const deploymentInfo = await deploy(mudConfig, { ...args, rpc, privateKey });
 
       // Write deployment result to file (latest and timestamp)
-      const outputDir = mudConfig.deploymentInfoDirectory;
+      const chainId = await getChainId(rpc);
+      const outputDir = path.join(mudConfig.deploysDirectory, chainId.toString());
       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)
-      );
+      writeFileSync(path.join(outputDir, "latest.json"), JSON.stringify(deploymentInfo, null, 2));
+      writeFileSync(path.join(outputDir, Date.now() + ".json"), JSON.stringify(deploymentInfo, null, 2));
 
       console.log(chalk.bgGreen(chalk.whiteBright(`\n Deployment result (written to ${outputDir}): \n`)));
       console.log(deploymentInfo);

package/src/commands/index.ts

@@ -15,6 +15,7 @@ import gasReport from "./gas-report.js";
 import hello from "./hello.js";
 import tablegen from "./tablegen.js";
 import deployV2 from "./deploy-v2.js";
+import worldgen from "./worldgen.js";
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any -- Each command has different options
 export const commands: CommandModule<any, any>[] = [
@@ -32,4 +33,5 @@ export const commands: CommandModule<any, any>[] = [
   test,
   trace,
   types,
+  worldgen,
 ];

package/src/commands/worldgen.ts

@@ -0,0 +1,55 @@
+import type { CommandModule } from "yargs";
+import { loadStoreConfig } from "../config/loadStoreConfig.js";
+import { loadWorldConfig } from "../config/index.js";
+import { getSrcDirectory } from "../utils/foundry.js";
+import glob from "glob";
+import path, { basename } from "path";
+import { worldgen } from "../render-solidity/worldgen.js";
+import { rmSync } from "fs";
+
+type Options = {
+  configPath?: string;
+  clean?: boolean;
+};
+
+const commandModule: CommandModule<Options, Options> = {
+  command: "worldgen",
+
+  describe: "Autogenerate interfaces for Systems and World based on existing contracts and the config file",
+
+  builder(yargs) {
+    return yargs.options({
+      configPath: { type: "string", desc: "Path to the config file" },
+      clean: { type: "boolean", desc: "Clear the worldgen directory before generating new interfaces" },
+    });
+  },
+
+  async handler(args) {
+    const { configPath, clean } = args;
+    const srcDir = await getSrcDirectory();
+
+    // Get a list of all contract names
+    const existingContracts = glob.sync(`${srcDir}/**/*.sol`).map((path) => ({
+      path,
+      basename: basename(path, ".sol"),
+    }));
+
+    // Load and resolve the config
+    const worldConfig = await loadWorldConfig(
+      configPath,
+      existingContracts.map(({ basename }) => basename)
+    );
+    const storeConfig = await loadStoreConfig(configPath);
+    const mudConfig = { ...worldConfig, ...storeConfig };
+
+    // clear the worldgen directory
+    if (clean) rmSync(path.join(srcDir, worldConfig.worldgenDirectory), { recursive: true, force: true });
+
+    // generate new interfaces
+    await worldgen(mudConfig, existingContracts, srcDir);
+
+    process.exit(0);
+  },
+};
+
+export default commandModule;

package/src/config/commonSchemas.ts

@@ -1,4 +1,3 @@
-import { getStaticByteLength, SchemaType } from "@latticexyz/schema-type";
 import { z } from "zod";
 import {
   validateBaseRoute,
@@ -9,28 +8,27 @@ import {
   validateRoute,
   validateSingleLevelRoute,
   validateUncapitalizedName,
+  validateSelector,
 } from "./validation.js";
 
 /** Capitalized names of objects, like tables and systems */
-export const ObjectName = z.string().superRefine(validateCapitalizedName);
+export const zObjectName = z.string().superRefine(validateCapitalizedName);
 /** Uncapitalized names of values, like keys and columns */
-export const ValueName = z.string().superRefine(validateUncapitalizedName);
+export const zValueName = z.string().superRefine(validateUncapitalizedName);
 /** Name that can start with any case */
-export const AnyCaseName = z.string().superRefine(validateName);
+export const zAnyCaseName = z.string().superRefine(validateName);
 /** List of unique enum member names and 0 < length < 256 */
-export const UserEnum = z.array(ObjectName).superRefine(validateEnum);
+export const zUserEnum = z.array(zObjectName).superRefine(validateEnum);
 
 /** Ordinary routes */
-export const OrdinaryRoute = z.string().superRefine(validateRoute);
+export const zOrdinaryRoute = z.string().superRefine(validateRoute);
 /** Routes with exactly 1 non-empty level */
-export const SingleLevelRoute = z.string().superRefine(validateSingleLevelRoute);
+export const zSingleLevelRoute = z.string().superRefine(validateSingleLevelRoute);
 /** Base routes (can be an empty string) */
-export const BaseRoute = z.string().superRefine(validateBaseRoute);
+export const zBaseRoute = z.string().superRefine(validateBaseRoute);
 
 /** A valid Ethereum address */
-export const EthereumAddress = z.string().superRefine(validateEthereumAddress);
+export const zEthereumAddress = z.string().superRefine(validateEthereumAddress);
 
-/** Static subset of SchemaType enum */
-export const StaticSchemaType = z
-  .nativeEnum(SchemaType)
-  .refine((arg) => getStaticByteLength(arg) > 0, "SchemaType must be static");
+/** A selector for namespace/file/resource */
+export const zSelector = z.string().superRefine(validateSelector);

package/src/config/dynamicResolution.ts

@@ -0,0 +1,49 @@
+import { MUDError } from "../utils/errors.js";
+import { ValueWithType } from "./world/userTypes.js";
+
+export enum DynamicResolutionType {
+  TABLE_ID,
+  SYSTEM_ADDRESS,
+}
+
+export type DynamicResolution = {
+  type: DynamicResolutionType;
+  input: string;
+};
+
+/**
+ * Dynamically resolve a table name to a table id at deploy time
+ */
+export function resolveTableId(tableName: string) {
+  return {
+    type: DynamicResolutionType.TABLE_ID,
+    input: tableName,
+  };
+}
+
+/** Type guard for DynamicResolution */
+export function isDynamicResolution(value: unknown): value is DynamicResolution {
+  return typeof value === "object" && value !== null && "type" in value && "input" in value;
+}
+
+/**
+ * Turn a DynamicResolution object into a ValueWithType based on the provided context
+ */
+export async function resolveWithContext(
+  unresolved: any,
+  context: { systemAddresses?: Record<string, Promise<string>>; tableIds?: Record<string, Uint8Array> }
+): Promise<ValueWithType> {
+  if (!isDynamicResolution(unresolved)) return unresolved;
+  let resolved: ValueWithType | undefined = undefined;
+
+  if (unresolved.type === DynamicResolutionType.TABLE_ID) {
+    const tableId = context.tableIds?.[unresolved.input];
+    resolved = tableId && { value: tableId, type: "bytes32" };
+  }
+
+  if (resolved === undefined) {
+    throw new MUDError(`Could not resolve dynamic resolution: \n${JSON.stringify(unresolved, null, 2)}`);
+  }
+
+  return resolved;
+}

package/src/config/index.ts

@@ -1,12 +1,24 @@
+import { ExtractUserTypes, StringForUnion } from "../utils/typeUtils.js";
 import { StoreUserConfig, StoreConfig } from "./parseStoreConfig.js";
-import { WorldUserConfig, ResolvedWorldConfig } from "./loadWorldConfig.js";
+import { WorldUserConfig, ResolvedWorldConfig } from "./world/index.js";
 
-export type MUDUserConfig = StoreUserConfig & WorldUserConfig;
+export type MUDUserConfig<
+  EnumNames extends StringForUnion = StringForUnion,
+  StaticUserTypes extends ExtractUserTypes<EnumNames> = ExtractUserTypes<EnumNames>
+> = StoreUserConfig<EnumNames, StaticUserTypes> & WorldUserConfig;
 export type MUDConfig = StoreConfig & ResolvedWorldConfig;
 
+export function mudConfig<
+  EnumNames extends StringForUnion = never,
+  StaticUserTypes extends ExtractUserTypes<EnumNames> = ExtractUserTypes<EnumNames>
+>(config: MUDUserConfig<EnumNames, StaticUserTypes>) {
+  return config;
+}
+
 export * from "./commonSchemas.js";
 export * from "./loadConfig.js";
 export * from "./loadStoreConfig.js";
 export * from "./parseStoreConfig.js";
-export * from "./loadWorldConfig.js";
+export * from "./world/index.js";
 export * from "./validation.js";
+export * from "./dynamicResolution.js";

package/src/config/loadStoreConfig.ts

@@ -7,7 +7,7 @@ export async function loadStoreConfig(configPath?: string) {
   const config = await loadConfig(configPath);
 
   try {
-    return parseStoreConfig(config);
+    return parseStoreConfig(config as any);
   } catch (error) {
     if (error instanceof ZodError) {
       throw fromZodErrorCustom(error, "StoreConfig Validation Error");

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

@@ -1,14 +1,40 @@
 import { describe, expectTypeOf } from "vitest";
 import { z } from "zod";
-import { StoreConfig, StoreUserConfig } from "./parseStoreConfig.js";
+import { storeConfig, zStoreConfig, StoreUserConfig } from "./parseStoreConfig.js";
 
 describe("StoreUserConfig", () => {
   // Typecheck manual interfaces against zod
-  expectTypeOf<StoreUserConfig>().toEqualTypeOf<z.input<typeof StoreConfig>>();
+  expectTypeOf<StoreUserConfig>().toEqualTypeOf<z.input<typeof zStoreConfig>>();
   // 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]
+  expectTypeOf<StoreUserConfig["tables"][string]>().toEqualTypeOf<z.input<typeof zStoreConfig>["tables"][string]>();
+  expectTypeOf<NonNullable<StoreUserConfig["enums"]>[string]>().toEqualTypeOf<
+    NonNullable<NonNullable<z.input<typeof zStoreConfig>>["enums"]>[string]
   >();
   // TODO If more nested schemas are added, provide separate tests for them
+
+  // Test possible inference confusion.
+  // This would fail if you remove `AsDependent` from `StoreUserConfig`
+  expectTypeOf(
+    storeConfig({
+      tables: {
+        Table1: {
+          primaryKeys: {
+            a: "Enum1",
+          },
+          schema: {
+            b: "Enum2",
+          },
+        },
+        Table2: {
+          schema: {
+            a: "uint32",
+          },
+        },
+      },
+      enums: {
+        Enum1: ["E1"],
+        Enum2: ["E1"],
+      },
+    })
+  ).toEqualTypeOf<StoreUserConfig<"Enum1" | "Enum2", "Enum1" | "Enum2">>();
 });