@latticexyz/cli 1.41.0 → 2.0.0-alpha.0

package/src/index.ts

@@ -1,8 +1,7 @@
-export { parseStoreConfig } from "./config/parseStoreConfig.js";
 export { loadStoreConfig } from "./config/loadStoreConfig.js";
-export { loadWorldConfig, resolveWorldConfig, parseWorldConfig } from "./config/loadWorldConfig.js";
-export { renderTablesFromConfig } from "./render-solidity/renderTablesFromConfig.js";
-export { renderTable } from "./render-solidity/renderTable.js";
+export { parseStoreConfig } from "./config/parseStoreConfig.js";
+export { loadWorldConfig, resolveWorldConfig, parseWorldConfig } from "./config/world/index.js";
+export { resolveTableId } from "./config/dynamicResolution.js";
 
 export type {
   StoreUserConfig,
@@ -13,5 +12,4 @@ export type {
   MUDConfig,
 } from "./config/index.js";
 
-export * from "./constants.js";
-export * from "./utils/index.js";
+export { storeConfig, mudConfig } from "./config/index.js";

package/src/render-solidity/common.ts

@@ -1,4 +1,5 @@
-import { ImportDatum, RenderTableOptions, RenderTableType } from "./types.js";
+import path from "path";
+import { ImportDatum, RenderTableOptions, RenderTableType, StaticResourceData } from "./types.js";
 
 export const renderedSolidityHeader = `// SPDX-License-Identifier: MIT
 pragma solidity >=0.8.0;
@@ -20,10 +21,13 @@ export function renderArguments(args: (string | undefined)[]) {
   return internalRenderList(",", filteredArgs, (arg) => arg);
 }
 
-export function renderCommonData({ staticRouteData, primaryKeys }: RenderTableOptions) {
-  // static route means static tableId as well, and no tableId arguments
-  const _tableId = staticRouteData ? "" : "_tableId";
-  const _typedTableId = staticRouteData ? "" : "uint256 _tableId";
+export function renderCommonData({
+  staticResourceData,
+  primaryKeys,
+}: Pick<RenderTableOptions, "staticResourceData" | "primaryKeys">) {
+  // static resource means static tableId as well, and no tableId arguments
+  const _tableId = staticResourceData ? "" : "_tableId";
+  const _typedTableId = staticResourceData ? "" : "uint256 _tableId";
 
   const _keyArgs = renderArguments(primaryKeys.map(({ name }) => name));
   const _typedKeyArgs = renderArguments(primaryKeys.map(({ name, typeWithLocation }) => `${typeWithLocation} ${name}`));
@@ -45,6 +49,14 @@ export function renderCommonData({ staticRouteData, primaryKeys }: RenderTableOp
   };
 }
 
+/** For 2 paths which are relative to a common root, create a relative import path from one to another */
+export function solidityRelativeImportPath(fromPath: string, usedInPath: string) {
+  // 1st "./" must be added because path strips it,
+  // but solidity expects it unless there's "../" ("./../" is fine).
+  // 2nd and 3rd "./" forcefully avoid absolute paths (everything is relative to `src`).
+  return "./" + path.relative("./" + usedInPath, "./" + fromPath);
+}
+
 /**
  * Aggregates, deduplicates and renders imports for symbols per path.
  * Identical symbols from different paths are NOT handled, they should be checked before rendering.
@@ -52,7 +64,8 @@ export function renderCommonData({ staticRouteData, primaryKeys }: RenderTableOp
 export function renderImports(imports: ImportDatum[]) {
   // Aggregate symbols by import path, also deduplicating them
   const aggregatedImports = new Map<string, Set<string>>();
-  for (const { symbol, path } of imports) {
+  for (const { symbol, fromPath, usedInPath } of imports) {
+    const path = solidityRelativeImportPath(fromPath, usedInPath);
     if (!aggregatedImports.has(path)) {
       aggregatedImports.set(path, new Set());
     }
@@ -67,6 +80,38 @@ export function renderImports(imports: ImportDatum[]) {
   return renderedImports.join("\n");
 }
 
+export function renderWithStore(
+  storeArgument: boolean,
+  callback: (
+    _typedStore: string | undefined,
+    _store: string,
+    _commentSuffix: string,
+    _untypedStore: string | undefined
+  ) => string
+) {
+  let result = "";
+  result += callback(undefined, "StoreSwitch", "", undefined);
+
+  if (storeArgument) {
+    result += "\n" + callback("IStore _store", "_store", " (using the specified store)", "_store");
+  }
+
+  return result;
+}
+
+export function renderTableId(staticResourceData: StaticResourceData) {
+  const hardcodedTableId = `uint256(bytes32(abi.encodePacked(bytes16("${staticResourceData.namespace}"), bytes16("${staticResourceData.fileSelector}"))))`;
+
+  const tableIdDefinition = `
+    uint256 constant _tableId = ${hardcodedTableId};
+    uint256 constant ${staticResourceData.tableIdName} = _tableId;
+  `;
+  return {
+    hardcodedTableId,
+    tableIdDefinition,
+  };
+}
+
 function renderValueTypeToBytes32(name: string, { staticByteLength, typeUnwrap, internalTypeId }: RenderTableType) {
   const bits = staticByteLength * 8;
   const innerText = `${typeUnwrap}(${name})`;

package/src/render-solidity/field.ts

@@ -1,70 +1,66 @@
-import { renderArguments, renderCommonData } from "./common.js";
+import { renderArguments, renderCommonData, renderWithStore } from "./common.js";
 import { RenderTableField, RenderTableOptions, RenderTableType } from "./types.js";
 
 export function renderFieldMethods(options: RenderTableOptions) {
+  const storeArgument = options.storeArgument;
   const { _typedTableId, _typedKeyArgs, _primaryKeysDefinition } = renderCommonData(options);
 
   let result = "";
   for (const [index, field] of options.fields.entries()) {
     const _typedFieldName = `${field.typeWithLocation} ${field.name}`;
 
-    result += `
-    /** Get ${field.name} */
-    function get${field.methodNameSuffix}(${renderArguments([
-      _typedTableId,
-      _typedKeyArgs,
-    ])}) internal view returns (${_typedFieldName}) {
-      ${_primaryKeysDefinition}
-      bytes memory _blob = StoreSwitch.getField(_tableId, _primaryKeys, ${index});
-      return ${renderDecodeFieldSingle(field)};
-    }
-    `;
-
-    if (options.storeArgument) {
-      result += `
-      /** Get ${field.name} from the specified store */
+    result += renderWithStore(
+      storeArgument,
+      (_typedStore, _store, _commentSuffix) => `
+      /** Get ${field.name}${_commentSuffix} */
       function get${field.methodNameSuffix}(${renderArguments([
+        _typedStore,
         _typedTableId,
-        `IStore _store`,
         _typedKeyArgs,
       ])}) internal view returns (${_typedFieldName}) {
         ${_primaryKeysDefinition}
-        bytes memory _blob = _store.getField(_tableId, _primaryKeys, ${index});
+        bytes memory _blob = ${_store}.getField(_tableId, _primaryKeys, ${index});
         return ${renderDecodeFieldSingle(field)};
       }
-      `;
-    }
+    `
+    );
 
-    result += `
-    /** Set ${field.name} */
-    function set${field.methodNameSuffix}(${renderArguments([
-      _typedTableId,
-      _typedKeyArgs,
-      _typedFieldName,
-    ])}) internal {
-      ${_primaryKeysDefinition}
-      StoreSwitch.setField(_tableId, _primaryKeys, ${index}, ${renderEncodeField(field)});
-    }
-    `;
+    result += renderWithStore(
+      storeArgument,
+      (_typedStore, _store, _commentSuffix) => `
+      /** Set ${field.name}${_commentSuffix} */
+      function set${field.methodNameSuffix}(${renderArguments([
+        _typedStore,
+        _typedTableId,
+        _typedKeyArgs,
+        _typedFieldName,
+      ])}) internal {
+        ${_primaryKeysDefinition}
+        ${_store}.setField(_tableId, _primaryKeys, ${index}, ${renderEncodeField(field)});
+      }
+    `
+    );
 
     // TODO: this is super inefficient right now, need to add support for pushing to arrays to the store core library to avoid reading/writing the entire array
     // (see https://github.com/latticexyz/mud/issues/438)
     if (field.isDynamic) {
       const portionData = fieldPortionData(field);
 
-      result += `
-      /** Push ${portionData.title} to ${field.name} */
-      function push${field.methodNameSuffix}(${renderArguments([
-        _typedTableId,
-        _typedKeyArgs,
-        `${portionData.typeWithLocation} ${portionData.name}`,
-      ])}) internal {
-        ${_primaryKeysDefinition}
-        bytes memory _blob = StoreSwitch.getField(_tableId, _primaryKeys, ${index});
-        bytes memory _newBlob = abi.encodePacked(_blob, ${portionData.encoded});
-        StoreSwitch.setField(_tableId, _primaryKeys, ${index}, _newBlob);
-      }
-      `;
+      result += renderWithStore(
+        storeArgument,
+        (_typedStore, _store, _commentSuffix) => `
+        /** Push ${portionData.title} to ${field.name}${_commentSuffix} */
+        function push${field.methodNameSuffix}(${renderArguments([
+          _typedStore,
+          _typedTableId,
+          _typedKeyArgs,
+          `${portionData.typeWithLocation} ${portionData.name}`,
+        ])}) internal {
+          ${_primaryKeysDefinition}
+          ${_store}.pushToField(_tableId, _primaryKeys, ${index}, ${portionData.encoded});
+        }
+      `
+      );
     }
   }
   return result;

package/src/render-solidity/index.ts

@@ -2,5 +2,9 @@ export * from "./common.js";
 export * from "./field.js";
 export * from "./record.js";
 export * from "./renderTable.js";
-export * from "./renderTablesFromConfig.js";
+export * from "./renderTypes.js";
+export * from "./renderTypesFromConfig.js";
+export * from "./tablegen.js";
+export * from "./tableOptions.js";
 export * from "./types.js";
+export * from "./userType.js";

package/src/render-solidity/record.ts

@@ -1,71 +1,66 @@
-import { renderList, renderArguments, renderCommonData } from "./common.js";
-import { renderDecodeValueType, renderEncodeField } from "./field.js";
+import { renderList, renderArguments, renderCommonData, renderWithStore } from "./common.js";
+import { renderDecodeValueType } from "./field.js";
 import { RenderTableDynamicField, RenderTableOptions } from "./types.js";
 
 export function renderRecordMethods(options: RenderTableOptions) {
-  const { staticFields, dynamicFields, structName, storeArgument } = options;
+  const { structName, storeArgument } = options;
   const { _tableId, _typedTableId, _keyArgs, _typedKeyArgs, _primaryKeysDefinition } = renderCommonData(options);
 
-  let result = `
-  /** Get the full data */
-  function get(${renderArguments([_typedTableId, _typedKeyArgs])}) internal view returns (${renderDecodedRecord(
-    options
-  )}) {
-    ${_primaryKeysDefinition}
-    bytes memory _blob = StoreSwitch.getRecord(_tableId, _primaryKeys, getSchema());
-    return decode(_blob);
-  }
-  `;
-
-  if (storeArgument) {
-    result += `
-    /** Get the full data from the specified store */
+  let result = renderWithStore(
+    storeArgument,
+    (_typedStore, _store, _commentSuffix) => `
+    /** Get the full data${_commentSuffix} */
     function get(${renderArguments([
+      _typedStore,
       _typedTableId,
-      `IStore _store`,
       _typedKeyArgs,
     ])}) internal view returns (${renderDecodedRecord(options)}) {
       ${_primaryKeysDefinition}
-      bytes memory _blob = _store.getRecord(_tableId, _primaryKeys);
+      bytes memory _blob = ${_store}.getRecord(_tableId, _primaryKeys, getSchema());
       return decode(_blob);
     }
-    `;
-  }
-
-  result += `
-  /** Set the full data using individual values */
-  function set(${renderArguments([
-    _typedTableId,
-    _typedKeyArgs,
-    renderArguments(options.fields.map(({ name, typeWithLocation }) => `${typeWithLocation} ${name}`)),
-  ])}) internal {
-    ${renderEncodedLengths(dynamicFields)}
-    bytes memory _data = 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)))]),
-    ])});
+  `
+  );
+
+  result += renderWithStore(
+    storeArgument,
+    (_typedStore, _store, _commentSuffix) => `
+    /** Set the full data using individual values${_commentSuffix} */
+    function set(${renderArguments([
+      _typedStore,
+      _typedTableId,
+      _typedKeyArgs,
+      renderArguments(options.fields.map(({ name, typeWithLocation }) => `${typeWithLocation} ${name}`)),
+    ])}) internal {
+      bytes memory _data = encode(${renderArguments(options.fields.map(({ name }) => name))});
 
-    ${_primaryKeysDefinition}
+      ${_primaryKeysDefinition}
 
-    StoreSwitch.setRecord(_tableId, _primaryKeys, _data);
-  }
-  `;
+      ${_store}.setRecord(_tableId, _primaryKeys, _data);
+    }
+  `
+  );
 
   if (structName !== undefined) {
-    result += `
-    /** Set the full data using the data struct */
-    function set(${renderArguments([_typedTableId, _typedKeyArgs, `${structName} memory _table`])}) internal {
-      set(${renderArguments([
-        _tableId,
-        _keyArgs,
-        renderArguments(options.fields.map(({ name }) => `_table.${name}`)),
-      ])});
-    }
-    `;
+    result += renderWithStore(
+      storeArgument,
+      (_typedStore, _store, _commentSuffix, _untypedStore) => `
+      /** Set the full data using the data struct${_commentSuffix} */
+      function set(${renderArguments([
+        _typedStore,
+        _typedTableId,
+        _typedKeyArgs,
+        `${structName} memory _table`,
+      ])}) internal {
+        set(${renderArguments([
+          _untypedStore,
+          _tableId,
+          _keyArgs,
+          renderArguments(options.fields.map(({ name }) => `_table.${name}`)),
+        ])});
+      }
+    `
+    );
   }
 
   result += renderDecodeFunction(options);
@@ -142,30 +137,18 @@ function renderDecodedRecord({ structName, fields }: RenderTableOptions) {
 }
 
 function renderDecodeDynamicFieldPartial(field: RenderTableDynamicField) {
-  const { typeId, arrayElement } = field;
+  const { typeId, arrayElement, typeWrap } = field;
   if (arrayElement) {
     // arrays
-    return `SliceLib.getSubslice(_blob, _start, _end).decodeArray_${arrayElement.typeId}()`;
+    return `${typeWrap}(
+      SliceLib.getSubslice(_blob, _start, _end).decodeArray_${arrayElement.typeId}()
+    )`;
   } else {
     // bytes/string
-    return `${typeId}(SliceLib.getSubslice(_blob, _start, _end).toBytes())`;
-  }
-}
-
-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 "";
+    return `${typeWrap}(
+      ${typeId}(
+        SliceLib.getSubslice(_blob, _start, _end).toBytes()
+      )
+    )`;
   }
 }

package/src/render-solidity/renderSystemInterface.ts

@@ -0,0 +1,31 @@
+import { renderArguments, renderList, renderedSolidityHeader, renderImports } from "./common.js";
+import { RenderSystemInterfaceOptions } from "./types.js";
+
+export function renderSystemInterface(options: RenderSystemInterfaceOptions) {
+  const { imports, name, functionPrefix, functions } = options;
+
+  return `${renderedSolidityHeader}
+
+${renderImports(imports)}
+
+interface ${name} {
+  ${renderList(
+    functions,
+    ({ name, parameters, returnParameters }) => `
+    function ${functionPrefix}${name}(${renderArguments(parameters)}) external ${renderReturnParameters(
+      returnParameters
+    )};
+  `
+  )}
+}
+
+`;
+}
+
+function renderReturnParameters(returnParameters: string[]) {
+  if (returnParameters.length > 0) {
+    return `returns (${renderArguments(returnParameters)})`;
+  } else {
+    return "";
+  }
+}

package/src/render-solidity/renderTable.ts

@@ -1,10 +1,31 @@
-import { renderArguments, renderCommonData, renderList, renderedSolidityHeader, renderImports } from "./common.js";
-import { renderFieldMethods } from "./field.js";
+import {
+  renderArguments,
+  renderCommonData,
+  renderList,
+  renderedSolidityHeader,
+  renderImports,
+  renderTableId,
+  renderWithStore,
+} from "./common.js";
+import { renderEncodeField, renderFieldMethods } from "./field.js";
 import { renderRecordMethods } from "./record.js";
-import { RenderTableOptions } from "./types.js";
+import { renderTypeHelpers } from "./renderTypeHelpers.js";
+import { RenderTableDynamicField, RenderTableOptions } from "./types.js";
 
 export function renderTable(options: RenderTableOptions) {
-  const { imports, libraryName, structName, staticRouteData, storeImportPath, fields, withRecordMethods } = options;
+  const {
+    imports,
+    libraryName,
+    structName,
+    staticResourceData,
+    storeImportPath,
+    fields,
+    staticFields,
+    dynamicFields,
+    withRecordMethods,
+    storeArgument,
+    primaryKeys,
+  } = options;
 
   const { _typedTableId, _typedKeyArgs, _primaryKeysDefinition } = renderCommonData(options);
 
@@ -18,6 +39,7 @@ 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";
@@ -32,14 +54,7 @@ ${
     : ""
 }
 
-${
-  !staticRouteData
-    ? ""
-    : `
-      uint256 constant _tableId = uint256(keccak256("${staticRouteData.baseRoute + staticRouteData.subRoute}"));
-      uint256 constant ${staticRouteData.tableIdName} = _tableId;
-`
-}
+${staticResourceData ? renderTableId(staticResourceData).tableIdDefinition : ""}
 
 ${
   !structName
@@ -60,6 +75,13 @@ library ${libraryName} {
     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});
@@ -67,70 +89,76 @@ library ${libraryName} {
     return ("${libraryName}", _fieldNames);
   }
 
-  /** Register the table's schema */
-  function registerSchema(${_typedTableId}) internal {
-    StoreSwitch.registerSchema(_tableId, getSchema());
-  }
-
-  /** Set the table's metadata */
-  function setMetadata(${_typedTableId}) internal {
-    (string memory _tableName, string[] memory _fieldNames) = getMetadata();
-    StoreSwitch.setMetadata(_tableId, _tableName, _fieldNames);
-  }
-
-${
-  !options.storeArgument
-    ? ""
-    : `
-  /** Register the table's schema for the specified store */
-  function registerSchema(${renderArguments([_typedTableId, "IStore _store"])}) internal {
-    _store.registerSchema(_tableId, getSchema());
+  ${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)))]),
+    ])});
   }
 
-  /** Set the table's metadata for the specified store */
-  function setMetadata(${renderArguments([_typedTableId, "IStore _store"])}) internal {
-    (string memory _tableName, string[] memory _fieldNames) = getMetadata();
-    _store.setMetadata(_tableId, _tableName, _fieldNames);
-  }
-`
+  ${renderWithStore(
+    storeArgument,
+    (_typedStore, _store, _commentSuffix) => `
+    /* Delete all data for given keys${_commentSuffix} */
+    function deleteRecord(${renderArguments([_typedStore, _typedTableId, _typedKeyArgs])}) internal {
+      ${_primaryKeysDefinition}
+      ${_store}.deleteRecord(_tableId, _primaryKeys);
+    }
+  `
+  )}
 }
 
-${renderFieldMethods(options)}
+${renderTypeHelpers(options)}
 
-${withRecordMethods ? renderRecordMethods(options) : ""}
-
-  /* Delete all data for given keys */
-  function deleteRecord(${renderArguments([_typedTableId, _typedKeyArgs])}) internal {
-    ${_primaryKeysDefinition}
-    StoreSwitch.deleteRecord(_tableId, _primaryKeys);
-  }
-}
-
-${
-  // nothing can be cast to bool, so an assembly helper is required
-  !fields.some(({ typeId }) => typeId === "bool")
-    ? ""
-    : `
-  function _toBool(uint8 value) pure returns (bool result) {
-    assembly {
-      result := value
-    }
-  }
-`
+`;
 }
 
-${
-  // nothing can be cast from bool, so an assembly helper is required
-  !options.primaryKeys.some(({ typeId }) => typeId === "bool")
-    ? ""
-    : `
-  function _boolToBytes32(bool value) pure returns (bytes32 result) {
-    assembly {
-      result := value
-    }
+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 "";
   }
-`
-}
-
-`;
 }