@latticexyz/cli 1.41.0 → 1.41.1-alpha.41

package/dist/mud.js

@@ -1,23 +1,18 @@
 #!/usr/bin/env -S TS_NODE_COMPILER_OPTIONS={\"module\":\"esnext\"} node --loader=ts-node/esm --no-warnings
-import {
-  deploymentInfoFilenamePrefix,
-  renderArguments,
-  renderList,
-  renderTablesFromConfig,
-  renderedSolidityHeader
-} from "./chunk-XRS7KWBZ.js";
-import {
-  loadStoreConfig,
-  loadWorldConfig
-} from "./chunk-YZATC2M3.js";
 import {
   deploy,
-  formatSolidity
-} from "./chunk-ZYDMYSTH.js";
+  formatSolidity,
+  getSchemaTypeInfo,
+  importForAbiOrUserType,
+  resolveAbiOrUserType
+} from "./chunk-O57QENJ6.js";
 import {
   MUDError,
+  SchemaTypeArrayToElement,
+  loadStoreConfig,
+  loadWorldConfig,
   logError
-} from "./chunk-GR245KYP.js";
+} from "./chunk-J4DJQNIC.js";
 import {
   JsonRpcProvider,
   componentsDir,
@@ -34,7 +29,6 @@ import {
 } from "./chunk-SLIMIO4Z.js";
 import {
   forge,
-  getOutDirectory,
   getRpcUrl,
   getSrcDirectory,
   getTestDirectory
@@ -11261,9 +11255,9 @@ var commandModule11 = {
       compare: { type: "string", desc: "Compare to an existing gas report" }
     });
   },
-  async handler({ path: path7, save, compare: compare2 }) {
+  async handler({ path: path11, save, compare: compare2 }) {
     let gasReport = [];
-    for (const file of path7) {
+    for (const file of path11) {
       gasReport = gasReport.concat(await runGasReport(file));
     }
     const compareGasReport = [];
@@ -11295,14 +11289,14 @@ var commandModule11 = {
   }
 };
 var gas_report_default = commandModule11;
-async function runGasReport(path7) {
-  if (!path7.endsWith(".t.sol")) {
-    console.log("Skipping gas report for", chalk3.bold(path7), "(not a test file)");
+async function runGasReport(path11) {
+  if (!path11.endsWith(".t.sol")) {
+    console.log("Skipping gas report for", chalk3.bold(path11), "(not a test file)");
     return [];
   }
-  console.log("Running gas report for", chalk3.bold(path7));
+  console.log("Running gas report for", chalk3.bold(path11));
   const gasReport = [];
-  const fileContents = readFileSync2(path7, "utf8");
+  const fileContents = readFileSync2(path11, "utf8");
   let newFile = fileContents;
   const functionRegex = new RegExp(/function (.*){/g);
   let functionMatch;
@@ -11326,7 +11320,7 @@ console.log("GAS REPORT: ${name} [${functionCall.replaceAll('"', '\\"')}]:", _ga
     );
   }
   newFile = newFile.replace(/pure/g, "view");
-  const tempFileName = path7.replace(/\.t\.sol$/, "MudGasReport.t.sol");
+  const tempFileName = path11.replace(/\.t\.sol$/, "MudGasReport.t.sol");
   writeFileSync(tempFileName, newFile);
   const child = execa2("forge", ["test", "--match-path", tempFileName, "-vvv"], {
     stdio: ["inherit", "pipe", "inherit"]
@@ -11347,7 +11341,7 @@ console.log("GAS REPORT: ${name} [${functionCall.replaceAll('"', '\\"')}]:", _ga
     const name = gasReportMatch[1];
     const functionCall = gasReportMatch[2].replace(";", "");
     const gasUsed = gasReportMatch[3];
-    gasReport.push({ source: path7, name, functionCall, gasUsed: parseInt(gasUsed) });
+    gasReport.push({ source: path11, name, functionCall, gasUsed: parseInt(gasUsed) });
   }
   return gasReport;
 }
@@ -11371,10 +11365,10 @@ function printGasReport(gasReport, compare2) {
   const rows = [headers, ...values];
   console.log(table(rows, { border: getBorderCharacters("norc") }));
 }
-function saveGasReport(gasReport, path7) {
-  console.log(chalk3.bold(`Saving gas report to ${path7}`));
+function saveGasReport(gasReport, path11) {
+  console.log(chalk3.bold(`Saving gas report to ${path11}`));
   const serializedGasReport = gasReport.map((entry) => `(${entry.source}) | ${entry.name} [${entry.functionCall}]: ${entry.gasUsed}`).join("\n");
-  writeFileSync(path7, serializedGasReport);
+  writeFileSync(path11, serializedGasReport);
 }
 
 // src/commands/hello.ts
@@ -11396,7 +11390,644 @@ var hello_default = commandModule12;
 
 // src/render-solidity/tablegen.ts
 import { mkdirSync, writeFileSync as writeFileSync2 } from "fs";
+import path7 from "path";
+
+// src/render-solidity/tableOptions.ts
 import path5 from "path";
+function getTableOptions(config2) {
+  const storeImportPath = config2.storeImportPath;
+  const options = [];
+  for (const tableName of Object.keys(config2.tables)) {
+    const tableData = config2.tables[tableName];
+    const withStruct = tableData.dataStruct;
+    const withRecordMethods = withStruct || Object.keys(tableData.schema).length > 1;
+    const noFieldMethodSuffix = !withRecordMethods && Object.keys(tableData.schema).length === 1;
+    const imports = [];
+    const primaryKeys = Object.keys(tableData.primaryKeys).map((name) => {
+      const abiOrUserType = tableData.primaryKeys[name];
+      const { renderTableType } = resolveAbiOrUserType(abiOrUserType, config2);
+      const importDatum = importForAbiOrUserType(abiOrUserType, tableData.directory, config2);
+      if (importDatum)
+        imports.push(importDatum);
+      if (renderTableType.isDynamic)
+        throw new Error(`Parsing error: found dynamic primary key ${name} in table ${tableName}`);
+      const primaryKey = {
+        ...renderTableType,
+        name,
+        isDynamic: false
+      };
+      return primaryKey;
+    });
+    const fields = Object.keys(tableData.schema).map((name) => {
+      const abiOrUserType = tableData.schema[name];
+      const { renderTableType, schemaType } = resolveAbiOrUserType(abiOrUserType, config2);
+      const importDatum = importForAbiOrUserType(abiOrUserType, tableData.directory, config2);
+      if (importDatum)
+        imports.push(importDatum);
+      const elementType = SchemaTypeArrayToElement[schemaType];
+      const field = {
+        ...renderTableType,
+        arrayElement: elementType !== void 0 ? getSchemaTypeInfo(elementType) : void 0,
+        name,
+        methodNameSuffix: noFieldMethodSuffix ? "" : `${name[0].toUpperCase()}${name.slice(1)}`
+      };
+      return field;
+    });
+    const staticFields = fields.filter(({ isDynamic }) => !isDynamic);
+    const dynamicFields = fields.filter(({ isDynamic }) => isDynamic);
+    const staticResourceData = (() => {
+      if (tableData.tableIdArgument) {
+        return;
+      } else {
+        return {
+          tableIdName: tableName + "TableId",
+          namespace: config2.namespace,
+          fileSelector: tableData.fileSelector
+        };
+      }
+    })();
+    options.push({
+      outputPath: path5.join(tableData.directory, `${tableName}.sol`),
+      tableName,
+      renderOptions: {
+        imports,
+        libraryName: tableName,
+        structName: withStruct ? tableName + "Data" : void 0,
+        staticResourceData,
+        storeImportPath,
+        primaryKeys,
+        fields,
+        staticFields,
+        dynamicFields,
+        withRecordMethods,
+        storeArgument: tableData.storeArgument
+      }
+    });
+  }
+  return options;
+}
+
+// src/render-solidity/common.ts
+import path6 from "path";
+var renderedSolidityHeader = `// SPDX-License-Identifier: MIT
+pragma solidity >=0.8.0;
+
+/* Autogenerated file. Do not edit manually. */`;
+function renderList(list, renderItem) {
+  return internalRenderList("", list, renderItem);
+}
+function renderArguments(args) {
+  const filteredArgs = args.filter((arg) => arg !== void 0 && arg !== "");
+  return internalRenderList(",", filteredArgs, (arg) => arg);
+}
+function renderCommonData({
+  staticResourceData,
+  primaryKeys
+}) {
+  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}`));
+  const _primaryKeysDefinition = `
+    bytes32[] memory _primaryKeys = new bytes32[](${primaryKeys.length});
+    ${renderList(
+    primaryKeys,
+    (primaryKey, index) => `_primaryKeys[${index}] = ${renderValueTypeToBytes32(primaryKey.name, primaryKey)};`
+  )}
+  `;
+  return {
+    _tableId,
+    _typedTableId,
+    _keyArgs,
+    _typedKeyArgs,
+    _primaryKeysDefinition
+  };
+}
+function solidityRelativeImportPath(fromPath, usedInPath) {
+  return "./" + path6.relative("./" + usedInPath, "./" + fromPath);
+}
+function renderImports(imports) {
+  const aggregatedImports = /* @__PURE__ */ new Map();
+  for (const { symbol, fromPath, usedInPath } of imports) {
+    const path11 = solidityRelativeImportPath(fromPath, usedInPath);
+    if (!aggregatedImports.has(path11)) {
+      aggregatedImports.set(path11, /* @__PURE__ */ new Set());
+    }
+    aggregatedImports.get(path11)?.add(symbol);
+  }
+  const renderedImports = [];
+  for (const [path11, symbols] of aggregatedImports) {
+    const renderedSymbols = [...symbols].join(", ");
+    renderedImports.push(`import { ${renderedSymbols} } from "${path11}";`);
+  }
+  return renderedImports.join("\n");
+}
+function renderWithStore(storeArgument, callback) {
+  let result = "";
+  result += callback(void 0, "StoreSwitch", "", void 0);
+  if (storeArgument) {
+    result += "\n" + callback("IStore _store", "_store", " (using the specified store)", "_store");
+  }
+  return result;
+}
+function renderTableId(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, { staticByteLength, typeUnwrap, internalTypeId }) {
+  const bits = staticByteLength * 8;
+  const innerText = `${typeUnwrap}(${name})`;
+  if (internalTypeId.match(/^uint\d{1,3}$/)) {
+    return `bytes32(uint256(${innerText}))`;
+  } else if (internalTypeId.match(/^int\d{1,3}$/)) {
+    return `bytes32(uint256(uint${bits}(${innerText})))`;
+  } else if (internalTypeId.match(/^bytes\d{1,2}$/)) {
+    return `bytes32(${innerText})`;
+  } else if (internalTypeId === "address") {
+    return `bytes32(bytes20(${innerText}))`;
+  } else if (internalTypeId === "bool") {
+    return `_boolToBytes32(${innerText})`;
+  } else {
+    throw new Error(`Unknown value type id ${internalTypeId}`);
+  }
+}
+function internalRenderList(lineTerminator, list, renderItem) {
+  return list.map((item, index) => renderItem(item, index) + (index === list.length - 1 ? "" : lineTerminator)).join("\n");
+}
+
+// src/render-solidity/field.ts
+function renderFieldMethods(options) {
+  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 += renderWithStore(
+      storeArgument,
+      (_typedStore, _store, _commentSuffix) => `
+      /** Get ${field.name}${_commentSuffix} */
+      function get${field.methodNameSuffix}(${renderArguments([
+        _typedStore,
+        _typedTableId,
+        _typedKeyArgs
+      ])}) internal view returns (${_typedFieldName}) {
+        ${_primaryKeysDefinition}
+        bytes memory _blob = ${_store}.getField(_tableId, _primaryKeys, ${index});
+        return ${renderDecodeFieldSingle(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)});
+      }
+    `
+    );
+    if (field.isDynamic) {
+      const portionData = fieldPortionData(field);
+      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;
+}
+function renderEncodeField(field) {
+  let func;
+  if (field.arrayElement) {
+    func = "EncodeArray.encode";
+  } else if (field.isDynamic) {
+    func = "bytes";
+  } else {
+    func = "abi.encodePacked";
+  }
+  return `${func}(${field.typeUnwrap}(${field.name}))`;
+}
+function renderDecodeValueType(field, offset) {
+  const { staticByteLength, internalTypeId } = field;
+  const innerSlice = `Bytes.slice${staticByteLength}(_blob, ${offset})`;
+  const bits = staticByteLength * 8;
+  let result;
+  if (internalTypeId.match(/^uint\d{1,3}$/) || internalTypeId === "address") {
+    result = `${internalTypeId}(${innerSlice})`;
+  } else if (internalTypeId.match(/^int\d{1,3}$/)) {
+    result = `${internalTypeId}(uint${bits}(${innerSlice}))`;
+  } else if (internalTypeId.match(/^bytes\d{1,2}$/)) {
+    result = innerSlice;
+  } else if (internalTypeId === "bool") {
+    result = `_toBool(uint8(${innerSlice}))`;
+  } else {
+    throw new Error(`Unknown value type id ${internalTypeId}`);
+  }
+  return `${field.typeWrap}(${result})`;
+}
+function fieldPortionData(field) {
+  const methodNameSuffix = "";
+  if (field.arrayElement) {
+    const name = "_element";
+    return {
+      typeWithLocation: field.arrayElement.typeWithLocation,
+      name: "_element",
+      encoded: renderEncodeField({ ...field.arrayElement, arrayElement: void 0, name, methodNameSuffix }),
+      title: "an element"
+    };
+  } else {
+    const name = "_slice";
+    return {
+      typeWithLocation: `${field.typeId} memory`,
+      name,
+      encoded: renderEncodeField({ ...field, name, methodNameSuffix }),
+      title: "a slice"
+    };
+  }
+}
+function renderDecodeFieldSingle(field) {
+  const { isDynamic, arrayElement } = field;
+  if (arrayElement) {
+    return `${field.typeWrap}(
+      SliceLib.getSubslice(_blob, 0, _blob.length).decodeArray_${arrayElement.internalTypeId}()
+    )`;
+  } else if (isDynamic) {
+    return `${field.typeWrap}(${field.internalTypeId}(_blob))`;
+  } else {
+    return renderDecodeValueType(field, 0);
+  }
+}
+
+// src/render-solidity/record.ts
+function renderRecordMethods(options) {
+  const { structName, storeArgument } = options;
+  const { _tableId, _typedTableId, _keyArgs, _typedKeyArgs, _primaryKeysDefinition } = renderCommonData(options);
+  let result = renderWithStore(
+    storeArgument,
+    (_typedStore, _store, _commentSuffix) => `
+    /** Get the full data${_commentSuffix} */
+    function get(${renderArguments([
+      _typedStore,
+      _typedTableId,
+      _typedKeyArgs
+    ])}) internal view returns (${renderDecodedRecord(options)}) {
+      ${_primaryKeysDefinition}
+      bytes memory _blob = ${_store}.getRecord(_tableId, _primaryKeys, getSchema());
+      return decode(_blob);
+    }
+  `
+  );
+  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}
+
+      ${_store}.setRecord(_tableId, _primaryKeys, _data);
+    }
+  `
+  );
+  if (structName !== void 0) {
+    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);
+  return result;
+}
+function renderDecodeFunction({ structName, fields, staticFields, dynamicFields }) {
+  const renderedDecodedRecord = structName ? `${structName} memory _table` : renderArguments(fields.map(({ name, typeWithLocation }) => `${typeWithLocation} ${name}`));
+  const fieldNamePrefix = structName ? "_table." : "";
+  const staticOffsets = staticFields.map(() => 0);
+  let _acc = 0;
+  for (const [index, field] of staticFields.entries()) {
+    staticOffsets[index] = _acc;
+    _acc += field.staticByteLength;
+  }
+  if (dynamicFields.length > 0) {
+    const totalStaticLength = staticFields.reduce((acc, { staticByteLength }) => acc + staticByteLength, 0);
+    return `
+    /** Decode the tightly packed blob using this table's schema */
+    function decode(bytes memory _blob) internal view returns (${renderedDecodedRecord}) {
+      // ${totalStaticLength} is the total byte length of static data
+      PackedCounter _encodedLengths = PackedCounter.wrap(Bytes.slice32(_blob, ${totalStaticLength})); 
+
+      ${renderList(
+      staticFields,
+      (field, index) => `
+        ${fieldNamePrefix}${field.name} = ${renderDecodeValueType(field, staticOffsets[index])};
+        `
+    )}
+      uint256 _start;
+      uint256 _end = ${totalStaticLength + 32};
+      ${renderList(
+      dynamicFields,
+      (field, index) => `
+        _start = _end;
+        _end += _encodedLengths.atIndex(${index});
+        ${fieldNamePrefix}${field.name} = ${renderDecodeDynamicFieldPartial(field)};
+        `
+    )}
+    }
+  `;
+  } else {
+    return `
+    /** Decode the tightly packed blob using this table's schema */
+    function decode(bytes memory _blob) internal pure returns (${renderedDecodedRecord}) {
+      ${renderList(
+      staticFields,
+      (field, index) => `
+        ${fieldNamePrefix}${field.name} = ${renderDecodeValueType(field, staticOffsets[index])};
+        `
+    )}
+    }
+    `;
+  }
+}
+function renderDecodedRecord({ structName, fields }) {
+  if (structName) {
+    return `${structName} memory _table`;
+  } else {
+    return renderArguments(fields.map(({ name, typeWithLocation }) => `${typeWithLocation} ${name}`));
+  }
+}
+function renderDecodeDynamicFieldPartial(field) {
+  const { typeId, arrayElement, typeWrap } = field;
+  if (arrayElement) {
+    return `${typeWrap}(
+      SliceLib.getSubslice(_blob, _start, _end).decodeArray_${arrayElement.typeId}()
+    )`;
+  } else {
+    return `${typeWrap}(
+      ${typeId}(
+        SliceLib.getSubslice(_blob, _start, _end).toBytes()
+      )
+    )`;
+  }
+}
+
+// src/render-solidity/renderTypeHelpers.ts
+function renderTypeHelpers(options) {
+  const { fields, primaryKeys } = options;
+  let result = "";
+  for (const wrappingHelper of getWrappingHelpers([...fields, ...primaryKeys])) {
+    result += wrappingHelper;
+  }
+  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) {
+  const wrappers = /* @__PURE__ */ new Map();
+  const unwrappers = /* @__PURE__ */ 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, elementType, staticLength, internalTypeId) {
+  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, elementType, staticLength, internalTypeId) {
+  const byteLength = staticLength * 32;
+  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});
+    }
+  `;
+}
+
+// src/render-solidity/renderTable.ts
+function renderTable(options) {
+  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) {
+  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 "";
+  }
+}
 
 // src/render-solidity/renderTypes.ts
 function renderTypes(options) {
@@ -11417,9 +12048,9 @@ ${renderList(
 
 // src/render-solidity/renderTypesFromConfig.ts
 function renderTypesFromConfig(config2) {
-  const enums = Object.keys(config2.userTypes.enums).map((name) => ({
+  const enums = Object.keys(config2.enums).map((name) => ({
     name,
-    memberNames: config2.userTypes.enums[name]
+    memberNames: config2.enums[name]
   }));
   return renderTypes({
     enums
@@ -11428,24 +12059,24 @@ function renderTypesFromConfig(config2) {
 
 // src/render-solidity/tablegen.ts
 async function tablegen(config2, outputBaseDirectory) {
-  const renderedTables = renderTablesFromConfig(config2, outputBaseDirectory);
-  for (const { outputDirectory, output, tableName } of renderedTables) {
-    const formattedOutput = await formatSolidity(output);
-    mkdirSync(outputDirectory, { recursive: true });
-    const outputPath = path5.join(outputDirectory, `${tableName}.sol`);
-    writeFileSync2(outputPath, formattedOutput);
-    console.log(`Generated table: ${outputPath}`);
+  const allTableOptions = getTableOptions(config2);
+  for (const { outputPath, renderOptions } of allTableOptions) {
+    const fullOutputPath = path7.join(outputBaseDirectory, outputPath);
+    const output = renderTable(renderOptions);
+    formatAndWrite(output, fullOutputPath, "Generated table");
   }
-  if (Object.keys(config2.userTypes.enums).length > 0) {
-    const renderedTypes = renderTypesFromConfig(config2);
-    const formattedOutput = await formatSolidity(renderedTypes);
-    const outputPath = path5.join(outputBaseDirectory, `${config2.userTypes.path}.sol`);
-    const outputDirectory = path5.dirname(outputPath);
-    mkdirSync(outputDirectory, { recursive: true });
-    writeFileSync2(outputPath, formattedOutput);
-    console.log(`Generated types file: ${outputPath}`);
+  if (Object.keys(config2.enums).length > 0) {
+    const fullOutputPath = path7.join(outputBaseDirectory, `${config2.userTypesPath}.sol`);
+    const output = renderTypesFromConfig(config2);
+    formatAndWrite(output, fullOutputPath, "Generated types file");
   }
 }
+async function formatAndWrite(output, fullOutputPath, logPrefix) {
+  const formattedOutput = await formatSolidity(output);
+  mkdirSync(path7.dirname(fullOutputPath), { recursive: true });
+  writeFileSync2(fullOutputPath, formattedOutput);
+  console.log(`${logPrefix}: ${fullOutputPath}`);
+}
 
 // src/commands/tablegen.ts
 var commandModule13 = {
@@ -11468,8 +12099,20 @@ var tablegen_default = commandModule13;
 // src/commands/deploy-v2.ts
 import chalk4 from "chalk";
 import glob from "glob";
-import path6, { basename } from "path";
+import path8, { basename } from "path";
 import { mkdirSync as mkdirSync2, writeFileSync as writeFileSync3 } from "fs";
+
+// src/utils/getChainId.ts
+import { ethers } from "ethers";
+async function getChainId(rpc) {
+  const { result: chainId } = await ethers.utils.fetchJson(
+    rpc,
+    '{ "id": 42, "jsonrpc": "2.0", "method": "eth_chainId", "params": [ ] }'
+  );
+  return Number(chainId);
+}
+
+// src/commands/deploy-v2.ts
 var commandModule14 = {
   command: "deploy-v2",
   describe: "Deploy MUD v2 contracts",
@@ -11479,6 +12122,7 @@ var commandModule14 = {
       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",
@@ -11500,8 +12144,8 @@ var commandModule14 = {
     if (clean)
       await forge(["clean"], { profile });
     await forge(["build"], { profile });
-    const outDir = await getOutDirectory();
-    const existingContracts = glob.sync(`${outDir}/*.sol`).map((path7) => basename(path7, ".sol"));
+    const srcDir = await getSrcDirectory();
+    const existingContracts = glob.sync(`${srcDir}/**/*.sol`).map((path11) => basename(path11, ".sol"));
     const worldConfig = await loadWorldConfig(configPath, existingContracts);
     const storeConfig = await loadStoreConfig(configPath);
     const mudConfig = { ...worldConfig, ...storeConfig };
@@ -11512,16 +12156,11 @@ var commandModule14 = {
       if (!privateKey)
         throw new MUDError("Missing PRIVATE_KEY environment variable");
       const deploymentInfo = await deploy(mudConfig, { ...args, rpc, privateKey });
-      const outputDir = mudConfig.deploymentInfoDirectory;
+      const chainId = await getChainId(rpc);
+      const outputDir = path8.join(mudConfig.deploysDirectory, chainId.toString());
       mkdirSync2(outputDir, { recursive: true });
-      writeFileSync3(
-        path6.join(outputDir, deploymentInfoFilenamePrefix + "latest.json"),
-        JSON.stringify(deploymentInfo, null, 2)
-      );
-      writeFileSync3(
-        path6.join(outputDir, deploymentInfoFilenamePrefix + Date.now() + ".json"),
-        JSON.stringify(deploymentInfo, null, 2)
-      );
+      writeFileSync3(path8.join(outputDir, "latest.json"), JSON.stringify(deploymentInfo, null, 2));
+      writeFileSync3(path8.join(outputDir, Date.now() + ".json"), JSON.stringify(deploymentInfo, null, 2));
       console.log(chalk4.bgGreen(chalk4.whiteBright(`
  Deployment result (written to ${outputDir}): 
 `)));
@@ -11535,6 +12174,246 @@ var commandModule14 = {
 };
 var deploy_v2_default = commandModule14;
 
+// src/commands/worldgen.ts
+import glob2 from "glob";
+import path10, { basename as basename2 } from "path";
+
+// src/render-solidity/worldgen.ts
+import { readFileSync as readFileSync3 } from "fs";
+import path9 from "path";
+
+// src/utils/contractToInterface.ts
+import { parse, visit } from "@solidity-parser/parser";
+function contractToInterface(data, contractName) {
+  const ast = parse(data);
+  let withContract = false;
+  let symbols = [];
+  const functions = [];
+  visit(ast, {
+    ContractDefinition({ name }) {
+      if (name === contractName) {
+        withContract = true;
+      }
+    },
+    FunctionDefinition({ name, visibility, parameters, returnParameters, isConstructor, isFallback, isReceiveEther }, parent) {
+      if (parent !== void 0 && parent.type === "ContractDefinition" && parent.name === contractName) {
+        try {
+          if (isConstructor || isFallback || isReceiveEther)
+            return;
+          if (visibility === "default")
+            throw new MUDError(`Visibility is not specified`);
+          if (visibility === "external" || visibility === "public") {
+            functions.push({
+              name: name === null ? "" : name,
+              parameters: parameters.map(parseParameter),
+              returnParameters: returnParameters === null ? [] : returnParameters.map(parseParameter)
+            });
+            for (const { typeName } of parameters.concat(returnParameters ?? [])) {
+              symbols = symbols.concat(typeNameToExternalSymbols(typeName));
+            }
+          }
+        } catch (error) {
+          if (error instanceof MUDError) {
+            error.message = `Function "${name}" in contract "${contractName}": ${error.message}`;
+          }
+          throw error;
+        }
+      }
+    }
+  });
+  if (!withContract) {
+    throw new MUDError(`Contract not found: ${contractName}`);
+  }
+  return {
+    functions,
+    symbols
+  };
+}
+function parseParameter({ name, typeName, storageLocation }) {
+  let typedNameWithLocation = "";
+  const { name: flattenedTypeName, stateMutability } = flattenTypeName(typeName);
+  typedNameWithLocation += flattenedTypeName;
+  if (stateMutability !== null) {
+    typedNameWithLocation += ` ${stateMutability}`;
+  }
+  if (storageLocation !== null) {
+    typedNameWithLocation += ` ${storageLocation}`;
+  }
+  if (name !== null) {
+    typedNameWithLocation += ` ${name}`;
+  }
+  return typedNameWithLocation;
+}
+function flattenTypeName(typeName) {
+  if (typeName === null) {
+    return {
+      name: "",
+      stateMutability: null
+    };
+  }
+  if (typeName.type === "ElementaryTypeName") {
+    return {
+      name: typeName.name,
+      stateMutability: typeName.stateMutability
+    };
+  } else if (typeName.type === "UserDefinedTypeName") {
+    return {
+      name: typeName.namePath,
+      stateMutability: null
+    };
+  } else if (typeName.type === "ArrayTypeName") {
+    const { name, stateMutability } = flattenTypeName(typeName.baseTypeName);
+    return {
+      name: `${name}[]`,
+      stateMutability
+    };
+  } else {
+    throw new MUDError(`Invalid typeName.type ${typeName.type}`);
+  }
+}
+function typeNameToExternalSymbols(typeName) {
+  if (typeName?.type === "UserDefinedTypeName") {
+    const symbol = typeName.namePath.split(".")[0];
+    return [symbol];
+  } else if (typeName?.type === "ArrayTypeName") {
+    return typeNameToExternalSymbols(typeName.baseTypeName);
+  } else {
+    return [];
+  }
+}
+
+// src/utils/formatAndWrite.ts
+import { mkdirSync as mkdirSync3, writeFileSync as writeFileSync4 } from "fs";
+import { dirname } from "path";
+async function formatAndWrite2(output, fullOutputPath, logPrefix) {
+  const formattedOutput = await formatSolidity(output);
+  mkdirSync3(dirname(fullOutputPath), { recursive: true });
+  writeFileSync4(fullOutputPath, formattedOutput);
+  console.log(`${logPrefix}: ${fullOutputPath}`);
+}
+
+// src/render-solidity/renderSystemInterface.ts
+function renderSystemInterface(options) {
+  const { imports, name, functionPrefix, functions } = options;
+  return `${renderedSolidityHeader}
+
+${renderImports(imports)}
+
+interface ${name} {
+  ${renderList(
+    functions,
+    ({ name: name2, parameters, returnParameters }) => `
+    function ${functionPrefix}${name2}(${renderArguments(parameters)}) external ${renderReturnParameters(
+      returnParameters
+    )};
+  `
+  )}
+}
+
+`;
+}
+function renderReturnParameters(returnParameters) {
+  if (returnParameters.length > 0) {
+    return `returns (${renderArguments(returnParameters)})`;
+  } else {
+    return "";
+  }
+}
+
+// src/render-solidity/renderWorld.ts
+function renderWorld(options) {
+  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)])} {
+
+}
+
+`;
+}
+
+// src/render-solidity/worldgen.ts
+async function worldgen(config2, existingContracts, outputBaseDirectory) {
+  const worldgenBaseDirectory = path9.join(outputBaseDirectory, config2.worldgenDirectory);
+  const systems = existingContracts.filter(({ basename: basename3 }) => Object.keys(config2.systems).includes(basename3));
+  const systemInterfaceImports = [];
+  for (const system of systems) {
+    const data = readFileSync3(system.path, "utf8");
+    const { functions, symbols } = contractToInterface(data, system.basename);
+    const imports = symbols.map((symbol) => ({
+      symbol,
+      fromPath: system.path,
+      usedInPath: worldgenBaseDirectory
+    }));
+    const systemInterfaceName = `I${system.basename}`;
+    const { fileSelector } = config2.systems[system.basename];
+    const output2 = renderSystemInterface({
+      name: systemInterfaceName,
+      functionPrefix: config2.namespace === "" ? "" : `${config2.namespace}_${fileSelector}_`,
+      functions,
+      imports
+    });
+    const fullOutputPath2 = path9.join(worldgenBaseDirectory, systemInterfaceName + ".sol");
+    await formatAndWrite2(output2, fullOutputPath2, "Generated system interface");
+    systemInterfaceImports.push({
+      symbol: systemInterfaceName,
+      fromPath: `${systemInterfaceName}.sol`,
+      usedInPath: "./"
+    });
+  }
+  const worldInterfaceName = "IWorld";
+  const output = renderWorld({
+    interfaceName: worldInterfaceName,
+    imports: systemInterfaceImports,
+    storeImportPath: config2.storeImportPath,
+    worldImportPath: config2.worldImportPath
+  });
+  const fullOutputPath = path9.join(worldgenBaseDirectory, worldInterfaceName + ".sol");
+  await formatAndWrite2(output, fullOutputPath, "Generated system interface");
+}
+
+// src/commands/worldgen.ts
+import { rmSync as rmSync3 } from "fs";
+var commandModule15 = {
+  command: "worldgen",
+  describe: "Autogenerate interfaces for Systems and World based on existing contracts and the config file",
+  builder(yargs2) {
+    return yargs2.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();
+    const existingContracts = glob2.sync(`${srcDir}/**/*.sol`).map((path11) => ({
+      path: path11,
+      basename: basename2(path11, ".sol")
+    }));
+    const worldConfig = await loadWorldConfig(
+      configPath,
+      existingContracts.map(({ basename: basename3 }) => basename3)
+    );
+    const storeConfig = await loadStoreConfig(configPath);
+    const mudConfig = { ...worldConfig, ...storeConfig };
+    if (clean)
+      rmSync3(path10.join(srcDir, worldConfig.worldgenDirectory), { recursive: true, force: true });
+    await worldgen(mudConfig, existingContracts, srcDir);
+    process.exit(0);
+  }
+};
+var worldgen_default = commandModule15;
+
 // src/commands/index.ts
 var commands = [
   bulkupload_default,
@@ -11550,7 +12429,8 @@ var commands = [
   tablegen_default,
   test_default,
   trace_default,
-  types_default
+  types_default,
+  worldgen_default
 ];
 
 // src/mud.ts