@latticexyz/cli 1.40.0 → 1.41.1-alpha.0

package/src/render-solidity/renderTable.ts

@@ -0,0 +1,164 @@
+import {
+  renderArguments,
+  renderCommonData,
+  renderList,
+  renderedSolidityHeader,
+  renderImports,
+  renderTableId,
+  renderWithStore,
+} from "./common.js";
+import { renderEncodeField, renderFieldMethods } from "./field.js";
+import { renderRecordMethods } from "./record.js";
+import { renderTypeHelpers } from "./renderTypeHelpers.js";
+import { RenderTableDynamicField, RenderTableOptions } from "./types.js";
+
+export function renderTable(options: RenderTableOptions) {
+  const {
+    imports,
+    libraryName,
+    structName,
+    staticResourceData,
+    storeImportPath,
+    fields,
+    staticFields,
+    dynamicFields,
+    withRecordMethods,
+    storeArgument,
+    primaryKeys,
+  } = options;
+
+  const { _typedTableId, _typedKeyArgs, _primaryKeysDefinition } = renderCommonData(options);
+
+  return `${renderedSolidityHeader}
+
+// Import schema type
+import { SchemaType } from "@latticexyz/schema-type/src/solidity/SchemaType.sol";
+
+// Import store internals
+import { IStore } from "${storeImportPath}IStore.sol";
+import { StoreSwitch } from "${storeImportPath}StoreSwitch.sol";
+import { StoreCore } from "${storeImportPath}StoreCore.sol";
+import { Bytes } from "${storeImportPath}Bytes.sol";
+import { Memory } from "${storeImportPath}Memory.sol";
+import { SliceLib } from "${storeImportPath}Slice.sol";
+import { EncodeArray } from "${storeImportPath}tightcoder/EncodeArray.sol";
+import { Schema, SchemaLib } from "${storeImportPath}Schema.sol";
+import { PackedCounter, PackedCounterLib } from "${storeImportPath}PackedCounter.sol";
+
+${
+  imports.length > 0
+    ? `
+      // Import user types
+      ${renderImports(imports)}
+    `
+    : ""
+}
+
+${staticResourceData ? renderTableId(staticResourceData).tableIdDefinition : ""}
+
+${
+  !structName
+    ? ""
+    : `
+      struct ${structName} {
+        ${renderList(fields, ({ name, typeId }) => `${typeId} ${name};`)}
+      }
+`
+}
+
+library ${libraryName} {
+  /** Get the table's schema */
+  function getSchema() internal pure returns (Schema) {
+    SchemaType[] memory _schema = new SchemaType[](${fields.length});
+    ${renderList(fields, ({ enumName }, index) => `_schema[${index}] = SchemaType.${enumName};`)}
+
+    return SchemaLib.encode(_schema);
+  }
+
+  function getKeySchema() internal pure returns (Schema) {
+    SchemaType[] memory _schema = new SchemaType[](${primaryKeys.length});
+    ${renderList(primaryKeys, ({ enumName }, index) => `_schema[${index}] = SchemaType.${enumName};`)}
+
+    return SchemaLib.encode(_schema);
+  }
+
+  /** Get the table's metadata */
+  function getMetadata() internal pure returns (string memory, string[] memory) {
+    string[] memory _fieldNames = new string[](${fields.length});
+    ${renderList(fields, (field, index) => `_fieldNames[${index}] = "${field.name}";`)}
+    return ("${libraryName}", _fieldNames);
+  }
+
+  ${renderWithStore(
+    storeArgument,
+    (_typedStore, _store, _commentSuffix) => `
+    /** Register the table's schema${_commentSuffix} */
+    function registerSchema(${renderArguments([_typedStore, _typedTableId])}) internal {
+      ${_store}.registerSchema(_tableId, getSchema(), getKeySchema());
+    }
+  `
+  )}
+  ${renderWithStore(
+    storeArgument,
+    (_typedStore, _store, _commentSuffix) => `
+    /** Set the table's metadata${_commentSuffix} */
+    function setMetadata(${renderArguments([_typedStore, _typedTableId])}) internal {
+      (string memory _tableName, string[] memory _fieldNames) = getMetadata();
+      ${_store}.setMetadata(_tableId, _tableName, _fieldNames);
+    }
+  `
+  )}
+
+  ${renderFieldMethods(options)}
+
+  ${withRecordMethods ? renderRecordMethods(options) : ""}
+
+  /** Tightly pack full data using this table's schema */
+  function encode(${renderArguments(
+    options.fields.map(({ name, typeWithLocation }) => `${typeWithLocation} ${name}`)
+  )}) internal view returns (bytes memory) {
+    ${renderEncodedLengths(dynamicFields)}
+    return abi.encodePacked(${renderArguments([
+      renderArguments(staticFields.map(({ name }) => name)),
+      // TODO try gas optimization (preallocate for all, encodePacked statics, and direct encode dynamics)
+      // (see https://github.com/latticexyz/mud/issues/444)
+      ...(dynamicFields.length === 0
+        ? []
+        : ["_encodedLengths.unwrap()", renderArguments(dynamicFields.map((field) => renderEncodeField(field)))]),
+    ])});
+  }
+
+  ${renderWithStore(
+    storeArgument,
+    (_typedStore, _store, _commentSuffix) => `
+    /* Delete all data for given keys${_commentSuffix} */
+    function deleteRecord(${renderArguments([_typedStore, _typedTableId, _typedKeyArgs])}) internal {
+      ${_primaryKeysDefinition}
+      ${_store}.deleteRecord(_tableId, _primaryKeys);
+    }
+  `
+  )}
+}
+
+${renderTypeHelpers(options)}
+
+`;
+}
+
+function renderEncodedLengths(dynamicFields: RenderTableDynamicField[]) {
+  if (dynamicFields.length > 0) {
+    return `
+    uint16[] memory _counters = new uint16[](${dynamicFields.length});
+    ${renderList(dynamicFields, ({ name, arrayElement }, index) => {
+      if (arrayElement) {
+        return `_counters[${index}] = uint16(${name}.length * ${arrayElement.staticByteLength});`;
+      } else {
+        return `_counters[${index}] = uint16(bytes(${name}).length);`;
+      }
+    })}
+    PackedCounter _encodedLengths = PackedCounterLib.pack(_counters);
+    `;
+  } else {
+    return "";
+  }
+}

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/renderTypes.ts

@@ -0,0 +1,19 @@
+import { renderArguments, renderList, renderedSolidityHeader } from "./common.js";
+import { RenderTypesOptions } from "./types.js";
+
+export function renderTypes(options: RenderTypesOptions) {
+  const { enums } = options;
+
+  return `${renderedSolidityHeader}
+
+${renderList(
+  enums,
+  ({ name, memberNames }) => `
+  enum ${name} {
+    ${renderArguments(memberNames)}
+  }
+`
+)}
+
+`;
+}

package/src/render-solidity/renderTypesFromConfig.ts

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

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-table/renderTablesFromConfig.ts → render-solidity/tableOptions.ts}

@@ -1,18 +1,26 @@
-import { renderTable } from "./renderTable.js";
-import { SchemaType, SchemaTypeArrayToElement, SchemaTypeId, getStaticByteLength } from "@latticexyz/schema-type";
-import { StoreConfig } from "../config/loadStoreConfig.js";
+import path from "path";
+import { SchemaTypeArrayToElement } from "@latticexyz/schema-type";
+import { StoreConfig } from "../config/parseStoreConfig.js";
 import {
+  ImportDatum,
   RenderTableDynamicField,
   RenderTableField,
+  RenderTableOptions,
   RenderTablePrimaryKey,
   RenderTableStaticField,
-  RenderTableType,
 } from "./types.js";
+import { getSchemaTypeInfo, importForAbiOrUserType, resolveAbiOrUserType } from "./userType.js";
 
-export function renderTablesFromConfig(config: StoreConfig) {
+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];
 
@@ -22,14 +30,21 @@ export function renderTablesFromConfig(config: StoreConfig) {
     const withRecordMethods = withStruct || Object.keys(tableData.schema).length > 1;
     // field methods can be simply get/set if there's only 1 field and no record methods
     const noFieldMethodSuffix = !withRecordMethods && Object.keys(tableData.schema).length === 1;
+    // list of any symbols that need to be imported
+    const imports: ImportDatum[] = [];
 
     const primaryKeys = Object.keys(tableData.primaryKeys).map((name) => {
-      const type = tableData.primaryKeys[name];
-      const typeInfo = getSchemaTypeInfo(type);
-      if (typeInfo.isDynamic) throw new Error("Parsing error: found dynamic primary key");
+      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)
+        throw new Error(`Parsing error: found dynamic primary key ${name} in table ${tableName}`);
 
       const primaryKey: RenderTablePrimaryKey = {
-        ...typeInfo,
+        ...renderTableType,
         name,
         isDynamic: false,
       };
@@ -37,11 +52,16 @@ export function renderTablesFromConfig(config: StoreConfig) {
     });
 
     const fields = Object.keys(tableData.schema).map((name) => {
-      const type = tableData.schema[name];
-      const elementType = SchemaTypeArrayToElement[type];
+      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];
       const field: RenderTableField = {
-        ...getSchemaTypeInfo(type),
-        arrayElement: elementType ? getSchemaTypeInfo(elementType) : undefined,
+        ...renderTableType,
+        arrayElement: elementType !== undefined ? getSchemaTypeInfo(elementType) : undefined,
         name,
         methodNameSuffix: noFieldMethodSuffix ? "" : `${name[0].toUpperCase()}${name.slice(1)}`,
       };
@@ -52,26 +72,27 @@ export function renderTablesFromConfig(config: StoreConfig) {
     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 + tableData.route,
-          subRoute: `/${tableName}`,
+          namespace: config.namespace,
+          fileSelector: tableData.fileSelector,
         };
       }
     })();
 
-    renderedTables.push({
+    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,
@@ -79,21 +100,8 @@ export function renderTablesFromConfig(config: StoreConfig) {
         dynamicFields,
         withRecordMethods,
         storeArgument: tableData.storeArgument,
-      }),
+      },
     });
   }
-  return renderedTables;
-}
-
-function getSchemaTypeInfo(schemaType: SchemaType): RenderTableType {
-  const staticByteLength = getStaticByteLength(schemaType);
-  const isDynamic = staticByteLength === 0;
-  const typeId = SchemaTypeId[schemaType];
-  return {
-    typeId,
-    typeWithLocation: isDynamic ? typeId + " memory" : typeId,
-    enumName: SchemaType[schemaType],
-    staticByteLength,
-    isDynamic,
-  };
+  return options;
 }

package/src/render-solidity/tablegen.ts

@@ -0,0 +1,33 @@
+import { mkdirSync, writeFileSync } from "fs";
+import path from "path";
+import { StoreConfig } from "../config/index.js";
+import { formatSolidity } from "../utils/format.js";
+import { getTableOptions } from "./tableOptions.js";
+import { renderTable } from "./renderTable.js";
+import { renderTypesFromConfig } from "./renderTypesFromConfig.js";
+
+export async function tablegen(config: StoreConfig, outputBaseDirectory: string) {
+  const allTableOptions = getTableOptions(config);
+  // write tables to files
+  for (const { outputPath, renderOptions } of allTableOptions) {
+    const fullOutputPath = path.join(outputBaseDirectory, outputPath);
+    const output = renderTable(renderOptions);
+    formatAndWrite(output, fullOutputPath, "Generated table");
+  }
+
+  // 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");
+  }
+}
+
+async function formatAndWrite(output: string, fullOutputPath: string, logPrefix: string) {
+  const formattedOutput = await formatSolidity(output);
+
+  mkdirSync(path.dirname(fullOutputPath), { recursive: true });
+
+  writeFileSync(fullOutputPath, formattedOutput);
+  console.log(`${logPrefix}: ${fullOutputPath}`);
+}

package/src/render-solidity/types.ts

@@ -0,0 +1,110 @@
+export interface RenderTableOptions {
+  /** List of symbols to import, and their file paths */
+  imports: ImportDatum[];
+  /** Name of the library to render. */
+  libraryName: string;
+  /** 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. */
+  staticResourceData?: StaticResourceData;
+  /** Path for store package imports */
+  storeImportPath: string;
+  primaryKeys: RenderTablePrimaryKey[];
+  fields: RenderTableField[];
+  staticFields: RenderTableStaticField[];
+  dynamicFields: RenderTableDynamicField[];
+  /** Whether to render get/set methods for the whole record */
+  withRecordMethods: boolean;
+  /** Whether to render additional methods that accept a manual `IStore` argument */
+  storeArgument: boolean;
+}
+
+export interface ImportDatum {
+  symbol: string;
+  fromPath: string;
+  usedInPath: string;
+}
+
+export interface StaticResourceData {
+  /** Name of the table id constant to render. */
+  tableIdName: string;
+  namespace: string;
+  fileSelector: string;
+}
+
+export interface RenderTableType {
+  typeId: string;
+  typeWithLocation: string;
+  /** The name of the enum element in SchemaType to use for schema registration (e.g. "UINT256_ARRAY") */
+  enumName: string;
+  staticByteLength: number;
+  isDynamic: boolean;
+  /** Empty for internal types. Custom `wrap` method for user defined types. */
+  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;
+}
+
+export interface RenderTableStaticField extends RenderTableField {
+  isDynamic: false;
+}
+
+export interface RenderTableDynamicField extends RenderTableField {
+  isDynamic: true;
+}
+
+export interface RenderTableField extends RenderTableType {
+  arrayElement: RenderTableType | undefined;
+  name: string;
+  methodNameSuffix: string;
+}
+
+export interface RenderTypesOptions {
+  /** List of enums to render */
+  enums: RenderTypesEnum[];
+}
+
+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;
+}