@latticexyz/cli 1.41.0 → 1.41.1-alpha.41

package/src/render-solidity/renderTypeHelpers.ts

@@ -0,0 +1,99 @@
+import { RenderTableOptions, RenderTableType } from "./types.js";
+
+export function renderTypeHelpers(options: RenderTableOptions) {
+  const { fields, primaryKeys } = options;
+
+  let result = "";
+
+  for (const wrappingHelper of getWrappingHelpers([...fields, ...primaryKeys])) {
+    result += wrappingHelper;
+  }
+
+  // bool is special - it's the only primitive value type that can't be typecasted to/from
+  if (fields.some(({ typeId }) => typeId === "bool")) {
+    result += `
+    function _toBool(uint8 value) pure returns (bool result) {
+      assembly {
+        result := value
+      }
+    }
+    `;
+  }
+  if (primaryKeys.some(({ typeId }) => typeId === "bool")) {
+    result += `
+    function _boolToBytes32(bool value) pure returns (bytes32 result) {
+      assembly {
+        result := value
+      }
+    }
+    `;
+  }
+
+  return result;
+}
+
+function getWrappingHelpers(array: RenderTableType[]) {
+  const wrappers = new Map();
+  const unwrappers = new Map();
+  for (const { typeWrappingData, typeWrap, typeUnwrap, internalTypeId } of array) {
+    if (!typeWrappingData) continue;
+    const { kind } = typeWrappingData;
+
+    if (kind === "staticArray") {
+      const { elementType, staticLength } = typeWrappingData;
+      wrappers.set(typeWrap, renderWrapperStaticArray(typeWrap, elementType, staticLength, internalTypeId));
+      unwrappers.set(typeUnwrap, renderUnwrapperStaticArray(typeUnwrap, elementType, staticLength, internalTypeId));
+    }
+  }
+
+  return [...wrappers.values(), ...unwrappers.values()];
+}
+
+function renderWrapperStaticArray(
+  functionName: string,
+  elementType: string,
+  staticLength: number,
+  internalTypeId: string
+) {
+  // WARNING: ensure this still works if changing major solidity versions!
+  // (the memory layout for static arrays may change)
+  return `
+    function ${functionName}(
+      ${internalTypeId} memory _value
+    ) pure returns (
+      ${elementType}[${staticLength}] memory _result
+    ) {
+      // in memory static arrays are just dynamic arrays without the length byte
+      assembly {
+        _result := add(_value, 0x20)
+      }
+    }
+  `;
+}
+
+function renderUnwrapperStaticArray(
+  functionName: string,
+  elementType: string,
+  staticLength: number,
+  internalTypeId: string
+) {
+  // byte length for memory copying (more efficient than a loop)
+  const byteLength = staticLength * 32;
+  // TODO to optimize memory usage consider generalizing TightEncoder to a render-time utility
+  return `
+    function ${functionName}(
+      ${elementType}[${staticLength}] memory _value
+    ) view returns (
+      ${internalTypeId} memory _result
+    ) {
+      _result = new ${internalTypeId}(${staticLength});
+      uint256 fromPointer;
+      uint256 toPointer;
+      assembly {
+        fromPointer := _value
+        toPointer := add(_result, 0x20)
+      }
+      Memory.copy(fromPointer, toPointer, ${byteLength});
+    }
+  `;
+}

package/src/render-solidity/renderTypesFromConfig.ts

@@ -2,9 +2,9 @@ import { StoreConfig } from "../config/parseStoreConfig.js";
 import { renderTypes } from "./renderTypes.js";
 
 export function renderTypesFromConfig(config: StoreConfig) {
-  const enums = Object.keys(config.userTypes.enums).map((name) => ({
+  const enums = Object.keys(config.enums).map((name) => ({
     name,
-    memberNames: config.userTypes.enums[name],
+    memberNames: config.enums[name],
   }));
 
   return renderTypes({

package/src/render-solidity/renderWorld.ts

@@ -0,0 +1,24 @@
+import { renderArguments, renderedSolidityHeader, renderImports } from "./common.js";
+import { RenderWorldOptions } from "./types.js";
+
+export function renderWorld(options: RenderWorldOptions) {
+  const { interfaceName, storeImportPath, worldImportPath, imports } = options;
+
+  return `${renderedSolidityHeader}
+
+import { IStore } from "${storeImportPath}IStore.sol";
+
+import { IWorldCore } from "${worldImportPath}interfaces/IWorldCore.sol";
+
+${renderImports(imports)}
+
+/**
+ * The ${interfaceName} interface includes all systems dynamically added to the World
+ * during the deploy process.
+ */
+interface ${interfaceName} is ${renderArguments(["IStore", "IWorldCore", ...imports.map(({ symbol }) => symbol)])} {
+
+}
+
+`;
+}

package/src/render-solidity/{renderTablesFromConfig.ts → tableOptions.ts}

@@ -1,23 +1,28 @@
 import path from "path";
-import { renderTable } from "./renderTable.js";
 import { SchemaTypeArrayToElement } from "@latticexyz/schema-type";
 import { StoreConfig } from "../config/parseStoreConfig.js";
 import {
   ImportDatum,
   RenderTableDynamicField,
   RenderTableField,
+  RenderTableOptions,
   RenderTablePrimaryKey,
   RenderTableStaticField,
 } from "./types.js";
-import { getSchemaTypeInfo, resolveSchemaOrUserType } from "./userType.js";
+import { getSchemaTypeInfo, importForAbiOrUserType, resolveAbiOrUserType } from "./userType.js";
 
-export function renderTablesFromConfig(config: StoreConfig, srcDirectory: string) {
+export interface TableOptions {
+  outputPath: string;
+  tableName: string;
+  renderOptions: RenderTableOptions;
+}
+
+export function getTableOptions(config: StoreConfig): TableOptions[] {
   const storeImportPath = config.storeImportPath;
 
-  const renderedTables = [];
+  const options = [];
   for (const tableName of Object.keys(config.tables)) {
     const tableData = config.tables[tableName];
-    const outputDirectory = path.join(srcDirectory, tableData.directory);
 
     // struct adds methods to get/set all values at once
     const withStruct = tableData.dataStruct;
@@ -29,13 +34,10 @@ export function renderTablesFromConfig(config: StoreConfig, srcDirectory: string
     const imports: ImportDatum[] = [];
 
     const primaryKeys = Object.keys(tableData.primaryKeys).map((name) => {
-      const schemaOrUserType = tableData.primaryKeys[name];
-      const { renderTableType, importDatum } = resolveSchemaOrUserType(
-        schemaOrUserType,
-        srcDirectory,
-        outputDirectory,
-        config.userTypes
-      );
+      const abiOrUserType = tableData.primaryKeys[name];
+      const { renderTableType } = resolveAbiOrUserType(abiOrUserType, config);
+
+      const importDatum = importForAbiOrUserType(abiOrUserType, tableData.directory, config);
       if (importDatum) imports.push(importDatum);
 
       if (renderTableType.isDynamic)
@@ -50,13 +52,10 @@ export function renderTablesFromConfig(config: StoreConfig, srcDirectory: string
     });
 
     const fields = Object.keys(tableData.schema).map((name) => {
-      const schemaOrUserType = tableData.schema[name];
-      const { renderTableType, importDatum, schemaType } = resolveSchemaOrUserType(
-        schemaOrUserType,
-        srcDirectory,
-        outputDirectory,
-        config.userTypes
-      );
+      const abiOrUserType = tableData.schema[name];
+      const { renderTableType, schemaType } = resolveAbiOrUserType(abiOrUserType, config);
+
+      const importDatum = importForAbiOrUserType(abiOrUserType, tableData.directory, config);
       if (importDatum) imports.push(importDatum);
 
       const elementType = SchemaTypeArrayToElement[schemaType];
@@ -73,28 +72,27 @@ export function renderTablesFromConfig(config: StoreConfig, srcDirectory: string
     const dynamicFields = fields.filter(({ isDynamic }) => isDynamic) as RenderTableDynamicField[];
 
     // With tableIdArgument: tableId is a dynamic argument for each method
-    // Without tableIdArgument: tableId is a file-level constant generated from `staticRouteData`
-    const staticRouteData = (() => {
+    // Without tableIdArgument: tableId is a file-level constant generated from `staticResourceData`
+    const staticResourceData = (() => {
       if (tableData.tableIdArgument) {
         return;
       } else {
         return {
           tableIdName: tableName + "TableId",
-          baseRoute: config.baseRoute,
-          subRoute: tableData.route,
+          namespace: config.namespace,
+          fileSelector: tableData.fileSelector,
         };
       }
     })();
 
-    renderedTables.push({
-      outputDirectory,
+    options.push({
+      outputPath: path.join(tableData.directory, `${tableName}.sol`),
       tableName,
-      tableData,
-      output: renderTable({
+      renderOptions: {
         imports,
         libraryName: tableName,
         structName: withStruct ? tableName + "Data" : undefined,
-        staticRouteData,
+        staticResourceData,
         storeImportPath,
         primaryKeys,
         fields,
@@ -102,8 +100,8 @@ export function renderTablesFromConfig(config: StoreConfig, srcDirectory: string
         dynamicFields,
         withRecordMethods,
         storeArgument: tableData.storeArgument,
-      }),
+      },
     });
   }
-  return renderedTables;
+  return options;
 }

package/src/render-solidity/tablegen.ts

@@ -1,35 +1,33 @@
 import { mkdirSync, writeFileSync } from "fs";
 import path from "path";
-import { StoreConfig } from "../index.js";
+import { StoreConfig } from "../config/index.js";
 import { formatSolidity } from "../utils/format.js";
-import { renderTablesFromConfig } from "./renderTablesFromConfig.js";
+import { getTableOptions } from "./tableOptions.js";
+import { renderTable } from "./renderTable.js";
 import { renderTypesFromConfig } from "./renderTypesFromConfig.js";
 
 export async function tablegen(config: StoreConfig, outputBaseDirectory: string) {
-  // render tables
-  const renderedTables = renderTablesFromConfig(config, outputBaseDirectory);
+  const allTableOptions = getTableOptions(config);
   // write tables to files
-  for (const { outputDirectory, output, tableName } of renderedTables) {
-    const formattedOutput = await formatSolidity(output);
-
-    mkdirSync(outputDirectory, { recursive: true });
+  for (const { outputPath, renderOptions } of allTableOptions) {
+    const fullOutputPath = path.join(outputBaseDirectory, outputPath);
+    const output = renderTable(renderOptions);
+    formatAndWrite(output, fullOutputPath, "Generated table");
+  }
 
-    const outputPath = path.join(outputDirectory, `${tableName}.sol`);
-    writeFileSync(outputPath, formattedOutput);
-    console.log(`Generated table: ${outputPath}`);
+  // write types to file
+  if (Object.keys(config.enums).length > 0) {
+    const fullOutputPath = path.join(outputBaseDirectory, `${config.userTypesPath}.sol`);
+    const output = renderTypesFromConfig(config);
+    formatAndWrite(output, fullOutputPath, "Generated types file");
   }
+}
 
-  // render types
-  if (Object.keys(config.userTypes.enums).length > 0) {
-    const renderedTypes = renderTypesFromConfig(config);
-    // write types to file
-    const formattedOutput = await formatSolidity(renderedTypes);
+async function formatAndWrite(output: string, fullOutputPath: string, logPrefix: string) {
+  const formattedOutput = await formatSolidity(output);
 
-    const outputPath = path.join(outputBaseDirectory, `${config.userTypes.path}.sol`);
-    const outputDirectory = path.dirname(outputPath);
-    mkdirSync(outputDirectory, { recursive: true });
+  mkdirSync(path.dirname(fullOutputPath), { recursive: true });
 
-    writeFileSync(outputPath, formattedOutput);
-    console.log(`Generated types file: ${outputPath}`);
-  }
+  writeFileSync(fullOutputPath, formattedOutput);
+  console.log(`${logPrefix}: ${fullOutputPath}`);
 }

package/src/render-solidity/types.ts

@@ -6,7 +6,7 @@ export interface RenderTableOptions {
   /** Name of the struct to render. If undefined, struct and its methods aren't rendered. */
   structName?: string;
   /** Data used to statically registed the table. If undefined, all methods receive `_tableId` as an argument. */
-  staticRouteData?: StaticRouteData;
+  staticResourceData?: StaticResourceData;
   /** Path for store package imports */
   storeImportPath: string;
   primaryKeys: RenderTablePrimaryKey[];
@@ -21,14 +21,15 @@ export interface RenderTableOptions {
 
 export interface ImportDatum {
   symbol: string;
-  path: string;
+  fromPath: string;
+  usedInPath: string;
 }
 
-export interface StaticRouteData {
+export interface StaticResourceData {
   /** Name of the table id constant to render. */
   tableIdName: string;
-  baseRoute: string;
-  subRoute: string;
+  namespace: string;
+  fileSelector: string;
 }
 
 export interface RenderTableType {
@@ -42,10 +43,18 @@ export interface RenderTableType {
   typeWrap: string;
   /** Empty for internal types. Custom `unwrap` method for user defined types. */
   typeUnwrap: string;
+  /** Data to generate the custom wrapper and unwrapper if necessary. */
+  typeWrappingData?: RenderTableTypeWrappingData;
   /** Same as typeId for internal types. The underlying `typeId` for user defined types. */
   internalTypeId: string;
 }
 
+export type RenderTableTypeWrappingData = {
+  kind: "staticArray";
+  elementType: string;
+  staticLength: number;
+};
+
 export interface RenderTablePrimaryKey extends RenderTableType {
   name: string;
   isDynamic: false;
@@ -74,3 +83,28 @@ export interface RenderTypesEnum {
   name: string;
   memberNames: string[];
 }
+
+export interface RenderSystemInterfaceOptions {
+  /** List of symbols to import, and their file paths */
+  imports: ImportDatum[];
+  name: string;
+  functionPrefix: string;
+  functions: RenderSystemInterfaceFunction[];
+}
+
+export interface RenderSystemInterfaceFunction {
+  name: string;
+  parameters: string[];
+  returnParameters: string[];
+}
+
+export interface RenderWorldOptions {
+  /** List of symbols to import, and their file paths */
+  imports: ImportDatum[];
+  /** Name of the interface to render */
+  interfaceName: string;
+  /** Path for store package imports */
+  storeImportPath: string;
+  /** Path for world package imports */
+  worldImportPath: string;
+}

package/src/render-solidity/userType.ts

@@ -1,62 +1,70 @@
-import { getStaticByteLength, SchemaType, SchemaTypeId } from "@latticexyz/schema-type";
-import path from "path";
-import { StoreConfig } from "../index.js";
-import { RenderTableType } from "./types.js";
+import { AbiTypeToSchemaType, getStaticByteLength, SchemaType, SchemaTypeToAbiType } from "@latticexyz/schema-type";
+import { StoreConfig } from "../config/index.js";
+import { ImportDatum, RenderTableType } from "./types.js";
+import { parseStaticArray } from "../config/validation.js";
 
 export type UserTypeInfo = ReturnType<typeof getUserTypeInfo>;
 
 /**
- * Resolve a SchemaType|userType into a SchemaType
+ * Resolve an abi or user type into a SchemaType
  */
-export function resolveSchemaOrUserTypeSimple(
-  schemaOrUserType: SchemaType | string,
-  userTypesConfig: StoreConfig["userTypes"]
-) {
-  if (typeof schemaOrUserType === "string") {
-    const { schemaType } = getUserTypeInfo(schemaOrUserType, userTypesConfig);
-    return schemaType;
-  } else {
-    return schemaOrUserType;
+export function resolveAbiOrUserType(
+  abiOrUserType: string,
+  config: StoreConfig
+): {
+  schemaType: SchemaType;
+  renderTableType: RenderTableType;
+} {
+  // abi types which directly mirror a SchemaType
+  if (abiOrUserType in AbiTypeToSchemaType) {
+    const schemaType = AbiTypeToSchemaType[abiOrUserType];
+    return {
+      schemaType,
+      renderTableType: getSchemaTypeInfo(schemaType),
+    };
+  }
+  // static arrays
+  const staticArray = parseStaticArray(abiOrUserType);
+  if (staticArray) {
+    if (staticArray.elementType in AbiTypeToSchemaType) {
+      return getStaticArrayTypeInfo(abiOrUserType, staticArray.elementType, staticArray.staticLength);
+    } else {
+      throw new Error("Static arrays of user types are not supported");
+    }
   }
+  // user types
+  return getUserTypeInfo(abiOrUserType, config);
 }
 
 /**
- * Resolve a SchemaType|userType into RenderTableType, required import, and internal SchemaType
+ * Get the required import for SchemaType|userType (`undefined` means that no import is required)
  */
-export function resolveSchemaOrUserType(
-  schemaOrUserType: SchemaType | string,
-  srcDirectory: string,
+export function importForAbiOrUserType(
+  abiOrUserType: string,
   usedInDirectory: string,
-  userTypesConfig: StoreConfig["userTypes"]
-) {
-  if (typeof schemaOrUserType === "string") {
-    // Relative import path for this type.
-    // "./" must be added because path stripts it,
-    // but solidity expects it unless there's "../" ("./../" is fine)
-    const importedFromPath = path.join(srcDirectory, userTypesConfig.path);
-    const importDatum = {
-      symbol: schemaOrUserType,
-      path: "./" + path.relative(usedInDirectory, importedFromPath) + ".sol",
-    };
-    const { schemaType, renderTableType } = getUserTypeInfo(schemaOrUserType, userTypesConfig);
-    return {
-      importDatum,
-      renderTableType,
-      schemaType,
-    };
-  } else {
-    return {
-      importDatum: undefined,
-      renderTableType: getSchemaTypeInfo(schemaOrUserType),
-      schemaType: schemaOrUserType,
-    };
+  config: StoreConfig
+): ImportDatum | undefined {
+  // abi types which directly mirror a SchemaType
+  if (abiOrUserType in AbiTypeToSchemaType) {
+    return undefined;
   }
+  // static arrays
+  const staticArray = parseStaticArray(abiOrUserType);
+  if (staticArray) {
+    return undefined;
+  }
+  // user types
+  return {
+    symbol: abiOrUserType,
+    fromPath: config.userTypesPath + ".sol",
+    usedInPath: usedInDirectory,
+  };
 }
 
 export function getSchemaTypeInfo(schemaType: SchemaType): RenderTableType {
   const staticByteLength = getStaticByteLength(schemaType);
   const isDynamic = staticByteLength === 0;
-  const typeId = SchemaTypeId[schemaType];
+  const typeId = SchemaTypeToAbiType[schemaType];
   return {
     typeId,
     typeWithLocation: isDynamic ? typeId + " memory" : typeId,
@@ -71,12 +79,13 @@ export function getSchemaTypeInfo(schemaType: SchemaType): RenderTableType {
 
 export function getUserTypeInfo(
   userType: string,
-  userTypesConfig: StoreConfig["userTypes"]
+  config: StoreConfig
 ): {
   schemaType: SchemaType;
   renderTableType: RenderTableType;
 } {
-  if (userType in userTypesConfig.enums) {
+  // enums
+  if (userType in config.enums) {
     const schemaType = SchemaType.UINT8;
     const staticByteLength = getStaticByteLength(schemaType);
     const isDynamic = staticByteLength === 0;
@@ -90,11 +99,34 @@ export function getUserTypeInfo(
         staticByteLength,
         isDynamic,
         typeWrap: `${userType}`,
-        typeUnwrap: `${userType}`,
-        internalTypeId: `${SchemaTypeId[schemaType]}`,
+        typeUnwrap: `uint8`,
+        internalTypeId: `${SchemaTypeToAbiType[schemaType]}`,
       },
     };
-  } else {
-    throw new Error(`User type "${userType}" does not exist`);
   }
+  // invalid
+  throw new Error(`User type "${userType}" does not exist`);
+}
+
+function getStaticArrayTypeInfo(abiType: string, elementType: string, staticLength: number) {
+  const internalTypeId = elementType + "[]";
+  const schemaType = AbiTypeToSchemaType[internalTypeId];
+  return {
+    schemaType,
+    renderTableType: {
+      typeId: abiType,
+      typeWithLocation: `${abiType} memory`,
+      enumName: SchemaType[schemaType],
+      staticByteLength: 0,
+      isDynamic: true,
+      typeWrap: `toStaticArray_${elementType}_${staticLength}`,
+      typeUnwrap: `fromStaticArray_${elementType}_${staticLength}`,
+      typeWrappingData: {
+        kind: "staticArray",
+        elementType,
+        staticLength,
+      },
+      internalTypeId,
+    },
+  } as const;
 }

package/src/render-solidity/worldgen.ts

@@ -0,0 +1,60 @@
+import { readFileSync } from "fs";
+import path from "path";
+import { MUDConfig } from "../config/index.js";
+import { contractToInterface } from "../utils/contractToInterface.js";
+import { formatAndWrite } from "../utils/formatAndWrite.js";
+import { renderSystemInterface } from "./renderSystemInterface.js";
+import { renderWorld } from "./renderWorld.js";
+import { ImportDatum } from "./types.js";
+
+export async function worldgen(
+  config: MUDConfig,
+  existingContracts: { path: string; basename: string }[],
+  outputBaseDirectory: string
+) {
+  const worldgenBaseDirectory = path.join(outputBaseDirectory, config.worldgenDirectory);
+  const systems = existingContracts.filter(({ basename }) => Object.keys(config.systems).includes(basename));
+
+  const systemInterfaceImports: ImportDatum[] = [];
+  for (const system of systems) {
+    const data = readFileSync(system.path, "utf8");
+    // get external funcions from a contract
+    const { functions, symbols } = contractToInterface(data, system.basename);
+    const imports = symbols.map((symbol) => ({
+      symbol,
+      fromPath: system.path,
+      usedInPath: worldgenBaseDirectory,
+    }));
+    const systemInterfaceName = `I${system.basename}`;
+    // create an interface using the external functions and imports
+    const { fileSelector } = config.systems[system.basename];
+    const output = renderSystemInterface({
+      name: systemInterfaceName,
+      functionPrefix: config.namespace === "" ? "" : `${config.namespace}_${fileSelector}_`,
+      functions,
+      imports,
+    });
+    // write to file
+    const fullOutputPath = path.join(worldgenBaseDirectory, systemInterfaceName + ".sol");
+    await formatAndWrite(output, fullOutputPath, "Generated system interface");
+
+    // prepare imports for IWorld
+    systemInterfaceImports.push({
+      symbol: systemInterfaceName,
+      fromPath: `${systemInterfaceName}.sol`,
+      usedInPath: "./",
+    });
+  }
+
+  // render IWorld
+  const worldInterfaceName = "IWorld";
+  const output = renderWorld({
+    interfaceName: worldInterfaceName,
+    imports: systemInterfaceImports,
+    storeImportPath: config.storeImportPath,
+    worldImportPath: config.worldImportPath,
+  });
+  // write to file
+  const fullOutputPath = path.join(worldgenBaseDirectory, worldInterfaceName + ".sol");
+  await formatAndWrite(output, fullOutputPath, "Generated system interface");
+}