@latticexyz/common 2.2.18-8d0ce55e964e646a1c804c401df01c4deb866f30 → 2.2.18-9fa07c8489f1fbf167d0db01cd9aaa645a29c8e2

package/dist/codegen.cjs

@@ -0,0 +1,889 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/codegen/index.ts
+var codegen_exports = {};
+__export(codegen_exports, {
+  abiToInterface: () => abiToInterface,
+  contractToInterface: () => contractToInterface,
+  findContractNode: () => findContractNode,
+  formatAndWriteSolidity: () => formatAndWriteSolidity,
+  formatAndWriteTypescript: () => formatAndWriteTypescript,
+  formatSolidity: () => formatSolidity,
+  formatTypescript: () => formatTypescript,
+  getLeftPaddingBits: () => getLeftPaddingBits,
+  isLeftAligned: () => isLeftAligned,
+  renderArguments: () => renderArguments,
+  renderCommonData: () => renderCommonData,
+  renderEnums: () => renderEnums,
+  renderImportPath: () => renderImportPath,
+  renderImports: () => renderImports,
+  renderList: () => renderList,
+  renderTableId: () => renderTableId,
+  renderTypeHelpers: () => renderTypeHelpers,
+  renderValueTypeToBytes32: () => renderValueTypeToBytes32,
+  renderWithFieldSuffix: () => renderWithFieldSuffix,
+  renderWithStore: () => renderWithStore,
+  renderedSolidityHeader: () => renderedSolidityHeader,
+  schemaTypesToRecsTypeStrings: () => schemaTypesToRecsTypeStrings
+});
+module.exports = __toCommonJS(codegen_exports);
+
+// src/codegen/render-solidity/abiToInterface.ts
+var import_abitype = require("abitype");
+
+// src/resourceToHex.ts
+var import_viem = require("viem");
+var resourceTypeIds = {
+  // keep these in sync with storeResourceTypes.sol
+  table: "tb",
+  offchainTable: "ot",
+  // keep these in sync with worldResourceTypes.sol
+  namespace: "ns",
+  system: "sy"
+};
+function resourceToHex(resource) {
+  const typeId = resourceTypeIds[resource.type];
+  if (resource.namespace.length > 14) {
+    throw new Error(`Namespaces must fit into \`bytes14\`, but "${resource.namespace}" is too long.`);
+  }
+  return (0, import_viem.concatHex)([
+    (0, import_viem.stringToHex)(typeId, { size: 2 }),
+    (0, import_viem.stringToHex)(resource.namespace, { size: 14 }),
+    (0, import_viem.stringToHex)(resource.name.slice(0, 16), { size: 16 })
+  ]);
+}
+
+// src/hexToResource.ts
+var import_viem2 = require("viem");
+
+// src/resourceTypes.ts
+var resourceTypes = ["table", "offchainTable", "namespace", "system"];
+
+// src/resourceToLabel.ts
+var rootNamespace = "";
+function resourceToLabel({
+  namespace,
+  name
+}) {
+  return namespace === rootNamespace ? name : `${namespace}__${name}`;
+}
+
+// src/hexToResource.ts
+var resourceTypeIdToType = Object.fromEntries(
+  Object.entries(resourceTypeIds).map(([key, value]) => [value, key])
+);
+function getResourceType(resourceTypeId) {
+  const type = resourceTypeIdToType[resourceTypeId];
+  if (resourceTypes.includes(type)) {
+    return type;
+  }
+}
+function hexToResource(hex) {
+  const resourceTypeId = (0, import_viem2.hexToString)((0, import_viem2.sliceHex)(hex, 0, 2)).replace(/\0+$/, "");
+  const type = getResourceType(resourceTypeId);
+  const namespace = (0, import_viem2.hexToString)((0, import_viem2.sliceHex)(hex, 2, 16)).replace(/\0+$/, "");
+  const name = (0, import_viem2.hexToString)((0, import_viem2.sliceHex)(hex, 16, 32)).replace(/\0+$/, "");
+  if (!type) {
+    throw new Error(`Unknown type (${resourceTypeId}) for resource (${resourceToLabel({ namespace, name })})`);
+  }
+  return { resourceId: hex, type, namespace, name };
+}
+
+// src/codegen/render-solidity/renderImportPath.ts
+var import_node_path = __toESM(require("path"), 1);
+function winToPosix(segment) {
+  return segment.replaceAll(import_node_path.default.win32.sep, import_node_path.default.posix.sep);
+}
+function renderImportPath(basePath, ...segments) {
+  const fullPath = import_node_path.default.posix.join(winToPosix(basePath), ...segments.map(winToPosix)).replace(/\/$/, "");
+  if (basePath.startsWith(".")) {
+    const relativePath = "./" + fullPath;
+    return relativePath.replace(/^(\.\/)+\./, ".");
+  }
+  return fullPath;
+}
+
+// src/codegen/render-solidity/common.ts
+var renderedSolidityHeader = `// SPDX-License-Identifier: MIT
+pragma solidity >=0.8.24;
+
+/* 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,
+  keyTuple
+}) {
+  const _typedTableId = staticResourceData ? "" : "ResourceId _tableId";
+  const _typedKeyArgs = renderArguments(keyTuple.map(({ name, typeWithLocation }) => `${typeWithLocation} ${name}`));
+  const _keyTupleDefinition = `
+    bytes32[] memory _keyTuple = new bytes32[](${keyTuple.length});
+    ${renderList(keyTuple, (key, index) => `_keyTuple[${index}] = ${renderValueTypeToBytes32(key.name, key)};`)}
+  `;
+  return {
+    _typedTableId,
+    _typedKeyArgs,
+    _keyTupleDefinition
+  };
+}
+function renderImports(imports) {
+  const aggregatedImports = /* @__PURE__ */ new Map();
+  for (const { symbol, path: path3 } of imports) {
+    if (!aggregatedImports.has(path3)) {
+      aggregatedImports.set(path3, /* @__PURE__ */ new Set());
+    }
+    aggregatedImports.get(path3)?.add(symbol);
+  }
+  const renderedImports = [];
+  for (const [path3, symbols] of aggregatedImports) {
+    const renderedSymbols = [...symbols].join(", ");
+    renderedImports.push(`import { ${renderedSymbols} } from "${renderImportPath(path3)}";`);
+  }
+  return renderedImports.join("\n");
+}
+function renderWithStore(storeArgument, callback) {
+  let result = "";
+  result += callback({ _typedStore: void 0, _store: "StoreSwitch", _commentSuffix: "", _methodNamePrefix: "" });
+  result += callback({
+    _typedStore: void 0,
+    _store: "StoreCore",
+    _commentSuffix: "",
+    _methodNamePrefix: "_",
+    _useExplicitFieldLayout: true
+  });
+  if (storeArgument) {
+    result += "\n" + callback({
+      _typedStore: "IStore _store",
+      _store: "_store",
+      _commentSuffix: " (using the specified store)",
+      _methodNamePrefix: ""
+    });
+  }
+  return result;
+}
+function renderWithFieldSuffix(withSuffixlessFieldMethods, fieldName, callback) {
+  const methodNameSuffix = `${fieldName[0].toUpperCase()}${fieldName.slice(1)}`;
+  let result = "";
+  result += callback(methodNameSuffix);
+  if (withSuffixlessFieldMethods) {
+    result += "\n" + callback("");
+  }
+  return result;
+}
+function renderTableId({
+  namespace,
+  name,
+  offchainOnly
+}) {
+  const tableId = resourceToHex({
+    type: offchainOnly ? "offchainTable" : "table",
+    namespace,
+    name
+  });
+  const resource = hexToResource(tableId);
+  return `
+    // Hex below is the result of \`WorldResourceIdLib.encode({ namespace: ${JSON.stringify(
+    resource.namespace
+  )}, name: ${JSON.stringify(resource.name)}, typeId: ${offchainOnly ? "RESOURCE_OFFCHAIN_TABLE" : "RESOURCE_TABLE"} });\`
+    ResourceId constant _tableId = ResourceId.wrap(${tableId});
+  `;
+}
+function renderValueTypeToBytes32(name, { typeUnwrap, internalTypeId }) {
+  const innerText = typeUnwrap.length ? `${typeUnwrap}(${name})` : name;
+  if (internalTypeId === "bytes32") {
+    return innerText;
+  } else if (/^bytes\d{1,2}$/.test(internalTypeId)) {
+    return `bytes32(${innerText})`;
+  } else if (/^uint\d{1,3}$/.test(internalTypeId)) {
+    return `bytes32(uint256(${innerText}))`;
+  } else if (/^int\d{1,3}$/.test(internalTypeId)) {
+    return `bytes32(uint256(int256(${innerText})))`;
+  } else if (internalTypeId === "address") {
+    return `bytes32(uint256(uint160(${innerText})))`;
+  } else if (internalTypeId === "bool") {
+    return `_boolToBytes32(${innerText})`;
+  } else {
+    throw new Error(`Unknown value type id ${internalTypeId}`);
+  }
+}
+function isLeftAligned(field) {
+  return /^bytes\d{1,2}$/.test(field.internalTypeId);
+}
+function getLeftPaddingBits(field) {
+  if (isLeftAligned(field)) {
+    return 0;
+  } else {
+    return 256 - field.staticByteLength * 8;
+  }
+}
+function internalRenderList(lineTerminator, list, renderItem) {
+  return list.map((item, index) => renderItem(item, index) + (index === list.length - 1 ? "" : lineTerminator)).join("\n");
+}
+
+// src/codegen/render-solidity/abiToInterface.ts
+function formatParam(param) {
+  return (0, import_abitype.formatAbiParameter)(param);
+}
+function formatFunction(item) {
+  const params = item.inputs.map(formatParam).join(", ");
+  const returns = item.outputs.map(formatParam).join(", ");
+  return `function ${item.name}(${params}) external${returns.length ? ` returns (${returns})` : ""}`;
+}
+function formatSystemId(systemId) {
+  const resource = hexToResource(systemId);
+  return `
+    // equivalent to \`WorldResourceIdLib.encode({ namespace: ${JSON.stringify(
+    resource.namespace
+  )}, name: ${JSON.stringify(resource.name)}, typeId: RESOURCE_SYSTEM });\`
+    ResourceId constant systemId = ResourceId.wrap(${systemId});
+  `;
+}
+function abiToInterface({ name, systemId, abi }) {
+  const imports = systemId ? [`{ ResourceId } from "@latticexyz/store/src/ResourceId.sol"`] : [];
+  const errors = abi.filter((item) => item.type === "error");
+  const functions = abi.filter((item) => item.type === "function");
+  return `
+    ${renderedSolidityHeader}
+
+    ${imports.map((item) => `import ${item};`).join("\n")}
+
+    ${systemId ? formatSystemId(systemId) : ""}
+
+    interface ${name} {
+      ${errors.map((item) => `${(0, import_abitype.formatAbiItem)(item)};`).join("\n")}
+
+      ${functions.map((item) => {
+    if ([...item.inputs, ...item.outputs].some((param) => param.type.startsWith("tuple"))) {
+      return `// TODO: replace tuple with struct
+// ${formatFunction(item)};`;
+    }
+    return `${formatFunction(item)};`;
+  }).join("\n")}
+    }
+  `;
+}
+
+// src/codegen/render-solidity/renderEnums.ts
+function renderEnums(enums) {
+  const enumDefinitions = Object.entries(enums).map(
+    ([name, values]) => `
+      enum ${name} {
+        ${values.join(", ")}
+      }
+    `
+  );
+  return `
+    ${renderedSolidityHeader}
+    ${enumDefinitions.join("")}
+  `;
+}
+
+// src/codegen/render-solidity/renderTypeHelpers.ts
+function renderTypeHelpers(options) {
+  const { fields, keyTuple } = options;
+  let result = "";
+  for (const wrappingHelper of getWrappingHelpers([...fields, ...keyTuple])) {
+    result += wrappingHelper;
+  }
+  if (fields.some(({ internalTypeId }) => internalTypeId.match("bool"))) {
+    result += `
+    /**
+     * @notice Cast a value to a bool.
+     * @dev Boolean values are encoded as uint8 (1 = true, 0 = false), but Solidity doesn't allow casting between uint8 and bool.
+     * @param value The uint8 value to convert.
+     * @return result The boolean value.
+     */
+    function _toBool(uint8 value) pure returns (bool result) {
+      assembly {
+        result := value
+      }
+    }
+    `;
+  }
+  if (keyTuple.some(({ internalTypeId }) => internalTypeId.match("bool"))) {
+    result += `
+    /**
+     * @notice Cast a bool to a bytes32.
+     * @dev The boolean value is casted to a bytes32 value with 0 or 1 at the least significant bit.
+     */
+    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 `
+    /**
+     * @notice Cast a dynamic array to a static array.
+     * @dev In memory static arrays are just dynamic arrays without the 32 length bytes,
+     * so this function moves the pointer to the first element of the dynamic array.
+     * If the length of the dynamic array is smaller than the static length,
+     * the function returns an uninitialized array to avoid memory corruption.
+     * @param _value The dynamic array to cast.
+     * @return _result The static array.
+     */
+    function ${functionName}(
+      ${internalTypeId} memory _value
+    ) pure returns (
+      ${elementType}[${staticLength}] memory _result
+    ) {
+      if (_value.length < ${staticLength}) {
+        // return an uninitialized array if the length is smaller than the fixed length to avoid memory corruption
+        return _result;
+      } else {
+        // in memory static arrays are just dynamic arrays without the 32 length bytes
+        // (without the length check this could lead to memory corruption)
+        assembly {
+          _result := add(_value, 0x20)
+        }
+      }
+    }
+  `;
+}
+function renderUnwrapperStaticArray(functionName, elementType, staticLength, internalTypeId) {
+  const byteLength = staticLength * 32;
+  return `
+    /**
+     * @notice Copy a static array to a dynamic array.
+     * @dev Static arrays don't have a length prefix, so this function copies the memory from the static array to a new dynamic array.
+     * @param _value The static array to copy.
+     * @return _result The dynamic array.
+     */ 
+    function ${functionName}(
+      ${elementType}[${staticLength}] memory _value
+    ) pure 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/codegen/render-typescript/schemaTypesToRecsTypeStrings.ts
+var import_deprecated = require("@latticexyz/schema-type/deprecated");
+var schemaTypesToRecsTypeStrings = {
+  [import_deprecated.SchemaType.UINT8]: "RecsType.Number",
+  [import_deprecated.SchemaType.UINT16]: "RecsType.Number",
+  [import_deprecated.SchemaType.UINT24]: "RecsType.Number",
+  [import_deprecated.SchemaType.UINT32]: "RecsType.Number",
+  [import_deprecated.SchemaType.UINT40]: "RecsType.Number",
+  [import_deprecated.SchemaType.UINT48]: "RecsType.Number",
+  [import_deprecated.SchemaType.UINT56]: "RecsType.BigInt",
+  [import_deprecated.SchemaType.UINT64]: "RecsType.BigInt",
+  [import_deprecated.SchemaType.UINT72]: "RecsType.BigInt",
+  [import_deprecated.SchemaType.UINT80]: "RecsType.BigInt",
+  [import_deprecated.SchemaType.UINT88]: "RecsType.BigInt",
+  [import_deprecated.SchemaType.UINT96]: "RecsType.BigInt",
+  [import_deprecated.SchemaType.UINT104]: "RecsType.BigInt",
+  [import_deprecated.SchemaType.UINT112]: "RecsType.BigInt",
+  [import_deprecated.SchemaType.UINT120]: "RecsType.BigInt",
+  [import_deprecated.SchemaType.UINT128]: "RecsType.BigInt",
+  [import_deprecated.SchemaType.UINT136]: "RecsType.BigInt",
+  [import_deprecated.SchemaType.UINT144]: "RecsType.BigInt",
+  [import_deprecated.SchemaType.UINT152]: "RecsType.BigInt",
+  [import_deprecated.SchemaType.UINT160]: "RecsType.BigInt",
+  [import_deprecated.SchemaType.UINT168]: "RecsType.BigInt",
+  [import_deprecated.SchemaType.UINT176]: "RecsType.BigInt",
+  [import_deprecated.SchemaType.UINT184]: "RecsType.BigInt",
+  [import_deprecated.SchemaType.UINT192]: "RecsType.BigInt",
+  [import_deprecated.SchemaType.UINT200]: "RecsType.BigInt",
+  [import_deprecated.SchemaType.UINT208]: "RecsType.BigInt",
+  [import_deprecated.SchemaType.UINT216]: "RecsType.BigInt",
+  [import_deprecated.SchemaType.UINT224]: "RecsType.BigInt",
+  [import_deprecated.SchemaType.UINT232]: "RecsType.BigInt",
+  [import_deprecated.SchemaType.UINT240]: "RecsType.BigInt",
+  [import_deprecated.SchemaType.UINT248]: "RecsType.BigInt",
+  [import_deprecated.SchemaType.UINT256]: "RecsType.BigInt",
+  [import_deprecated.SchemaType.INT8]: "RecsType.Number",
+  [import_deprecated.SchemaType.INT16]: "RecsType.Number",
+  [import_deprecated.SchemaType.INT24]: "RecsType.Number",
+  [import_deprecated.SchemaType.INT32]: "RecsType.Number",
+  [import_deprecated.SchemaType.INT40]: "RecsType.Number",
+  [import_deprecated.SchemaType.INT48]: "RecsType.Number",
+  [import_deprecated.SchemaType.INT56]: "RecsType.BigInt",
+  [import_deprecated.SchemaType.INT64]: "RecsType.BigInt",
+  [import_deprecated.SchemaType.INT72]: "RecsType.BigInt",
+  [import_deprecated.SchemaType.INT80]: "RecsType.BigInt",
+  [import_deprecated.SchemaType.INT88]: "RecsType.BigInt",
+  [import_deprecated.SchemaType.INT96]: "RecsType.BigInt",
+  [import_deprecated.SchemaType.INT104]: "RecsType.BigInt",
+  [import_deprecated.SchemaType.INT112]: "RecsType.BigInt",
+  [import_deprecated.SchemaType.INT120]: "RecsType.BigInt",
+  [import_deprecated.SchemaType.INT128]: "RecsType.BigInt",
+  [import_deprecated.SchemaType.INT136]: "RecsType.BigInt",
+  [import_deprecated.SchemaType.INT144]: "RecsType.BigInt",
+  [import_deprecated.SchemaType.INT152]: "RecsType.BigInt",
+  [import_deprecated.SchemaType.INT160]: "RecsType.BigInt",
+  [import_deprecated.SchemaType.INT168]: "RecsType.BigInt",
+  [import_deprecated.SchemaType.INT176]: "RecsType.BigInt",
+  [import_deprecated.SchemaType.INT184]: "RecsType.BigInt",
+  [import_deprecated.SchemaType.INT192]: "RecsType.BigInt",
+  [import_deprecated.SchemaType.INT200]: "RecsType.BigInt",
+  [import_deprecated.SchemaType.INT208]: "RecsType.BigInt",
+  [import_deprecated.SchemaType.INT216]: "RecsType.BigInt",
+  [import_deprecated.SchemaType.INT224]: "RecsType.BigInt",
+  [import_deprecated.SchemaType.INT232]: "RecsType.BigInt",
+  [import_deprecated.SchemaType.INT240]: "RecsType.BigInt",
+  [import_deprecated.SchemaType.INT248]: "RecsType.BigInt",
+  [import_deprecated.SchemaType.INT256]: "RecsType.BigInt",
+  [import_deprecated.SchemaType.BYTES1]: "RecsType.String",
+  [import_deprecated.SchemaType.BYTES2]: "RecsType.String",
+  [import_deprecated.SchemaType.BYTES3]: "RecsType.String",
+  [import_deprecated.SchemaType.BYTES4]: "RecsType.String",
+  [import_deprecated.SchemaType.BYTES5]: "RecsType.String",
+  [import_deprecated.SchemaType.BYTES6]: "RecsType.String",
+  [import_deprecated.SchemaType.BYTES7]: "RecsType.String",
+  [import_deprecated.SchemaType.BYTES8]: "RecsType.String",
+  [import_deprecated.SchemaType.BYTES9]: "RecsType.String",
+  [import_deprecated.SchemaType.BYTES10]: "RecsType.String",
+  [import_deprecated.SchemaType.BYTES11]: "RecsType.String",
+  [import_deprecated.SchemaType.BYTES12]: "RecsType.String",
+  [import_deprecated.SchemaType.BYTES13]: "RecsType.String",
+  [import_deprecated.SchemaType.BYTES14]: "RecsType.String",
+  [import_deprecated.SchemaType.BYTES15]: "RecsType.String",
+  [import_deprecated.SchemaType.BYTES16]: "RecsType.String",
+  [import_deprecated.SchemaType.BYTES17]: "RecsType.String",
+  [import_deprecated.SchemaType.BYTES18]: "RecsType.String",
+  [import_deprecated.SchemaType.BYTES19]: "RecsType.String",
+  [import_deprecated.SchemaType.BYTES20]: "RecsType.String",
+  [import_deprecated.SchemaType.BYTES21]: "RecsType.String",
+  [import_deprecated.SchemaType.BYTES22]: "RecsType.String",
+  [import_deprecated.SchemaType.BYTES23]: "RecsType.String",
+  [import_deprecated.SchemaType.BYTES24]: "RecsType.String",
+  [import_deprecated.SchemaType.BYTES25]: "RecsType.String",
+  [import_deprecated.SchemaType.BYTES26]: "RecsType.String",
+  [import_deprecated.SchemaType.BYTES27]: "RecsType.String",
+  [import_deprecated.SchemaType.BYTES28]: "RecsType.String",
+  [import_deprecated.SchemaType.BYTES29]: "RecsType.String",
+  [import_deprecated.SchemaType.BYTES30]: "RecsType.String",
+  [import_deprecated.SchemaType.BYTES31]: "RecsType.String",
+  [import_deprecated.SchemaType.BYTES32]: "RecsType.String",
+  [import_deprecated.SchemaType.BOOL]: "RecsType.Boolean",
+  [import_deprecated.SchemaType.ADDRESS]: "RecsType.String",
+  [import_deprecated.SchemaType.UINT8_ARRAY]: "RecsType.NumberArray",
+  [import_deprecated.SchemaType.UINT16_ARRAY]: "RecsType.NumberArray",
+  [import_deprecated.SchemaType.UINT24_ARRAY]: "RecsType.NumberArray",
+  [import_deprecated.SchemaType.UINT32_ARRAY]: "RecsType.NumberArray",
+  [import_deprecated.SchemaType.UINT40_ARRAY]: "RecsType.NumberArray",
+  [import_deprecated.SchemaType.UINT48_ARRAY]: "RecsType.NumberArray",
+  [import_deprecated.SchemaType.UINT56_ARRAY]: "RecsType.BigIntArray",
+  [import_deprecated.SchemaType.UINT64_ARRAY]: "RecsType.BigIntArray",
+  [import_deprecated.SchemaType.UINT72_ARRAY]: "RecsType.BigIntArray",
+  [import_deprecated.SchemaType.UINT80_ARRAY]: "RecsType.BigIntArray",
+  [import_deprecated.SchemaType.UINT88_ARRAY]: "RecsType.BigIntArray",
+  [import_deprecated.SchemaType.UINT96_ARRAY]: "RecsType.BigIntArray",
+  [import_deprecated.SchemaType.UINT104_ARRAY]: "RecsType.BigIntArray",
+  [import_deprecated.SchemaType.UINT112_ARRAY]: "RecsType.BigIntArray",
+  [import_deprecated.SchemaType.UINT120_ARRAY]: "RecsType.BigIntArray",
+  [import_deprecated.SchemaType.UINT128_ARRAY]: "RecsType.BigIntArray",
+  [import_deprecated.SchemaType.UINT136_ARRAY]: "RecsType.BigIntArray",
+  [import_deprecated.SchemaType.UINT144_ARRAY]: "RecsType.BigIntArray",
+  [import_deprecated.SchemaType.UINT152_ARRAY]: "RecsType.BigIntArray",
+  [import_deprecated.SchemaType.UINT160_ARRAY]: "RecsType.BigIntArray",
+  [import_deprecated.SchemaType.UINT168_ARRAY]: "RecsType.BigIntArray",
+  [import_deprecated.SchemaType.UINT176_ARRAY]: "RecsType.BigIntArray",
+  [import_deprecated.SchemaType.UINT184_ARRAY]: "RecsType.BigIntArray",
+  [import_deprecated.SchemaType.UINT192_ARRAY]: "RecsType.BigIntArray",
+  [import_deprecated.SchemaType.UINT200_ARRAY]: "RecsType.BigIntArray",
+  [import_deprecated.SchemaType.UINT208_ARRAY]: "RecsType.BigIntArray",
+  [import_deprecated.SchemaType.UINT216_ARRAY]: "RecsType.BigIntArray",
+  [import_deprecated.SchemaType.UINT224_ARRAY]: "RecsType.BigIntArray",
+  [import_deprecated.SchemaType.UINT232_ARRAY]: "RecsType.BigIntArray",
+  [import_deprecated.SchemaType.UINT240_ARRAY]: "RecsType.BigIntArray",
+  [import_deprecated.SchemaType.UINT248_ARRAY]: "RecsType.BigIntArray",
+  [import_deprecated.SchemaType.UINT256_ARRAY]: "RecsType.BigIntArray",
+  [import_deprecated.SchemaType.INT8_ARRAY]: "RecsType.NumberArray",
+  [import_deprecated.SchemaType.INT16_ARRAY]: "RecsType.NumberArray",
+  [import_deprecated.SchemaType.INT24_ARRAY]: "RecsType.NumberArray",
+  [import_deprecated.SchemaType.INT32_ARRAY]: "RecsType.NumberArray",
+  [import_deprecated.SchemaType.INT40_ARRAY]: "RecsType.NumberArray",
+  [import_deprecated.SchemaType.INT48_ARRAY]: "RecsType.NumberArray",
+  [import_deprecated.SchemaType.INT56_ARRAY]: "RecsType.BigIntArray",
+  [import_deprecated.SchemaType.INT64_ARRAY]: "RecsType.BigIntArray",
+  [import_deprecated.SchemaType.INT72_ARRAY]: "RecsType.BigIntArray",
+  [import_deprecated.SchemaType.INT80_ARRAY]: "RecsType.BigIntArray",
+  [import_deprecated.SchemaType.INT88_ARRAY]: "RecsType.BigIntArray",
+  [import_deprecated.SchemaType.INT96_ARRAY]: "RecsType.BigIntArray",
+  [import_deprecated.SchemaType.INT104_ARRAY]: "RecsType.BigIntArray",
+  [import_deprecated.SchemaType.INT112_ARRAY]: "RecsType.BigIntArray",
+  [import_deprecated.SchemaType.INT120_ARRAY]: "RecsType.BigIntArray",
+  [import_deprecated.SchemaType.INT128_ARRAY]: "RecsType.BigIntArray",
+  [import_deprecated.SchemaType.INT136_ARRAY]: "RecsType.BigIntArray",
+  [import_deprecated.SchemaType.INT144_ARRAY]: "RecsType.BigIntArray",
+  [import_deprecated.SchemaType.INT152_ARRAY]: "RecsType.BigIntArray",
+  [import_deprecated.SchemaType.INT160_ARRAY]: "RecsType.BigIntArray",
+  [import_deprecated.SchemaType.INT168_ARRAY]: "RecsType.BigIntArray",
+  [import_deprecated.SchemaType.INT176_ARRAY]: "RecsType.BigIntArray",
+  [import_deprecated.SchemaType.INT184_ARRAY]: "RecsType.BigIntArray",
+  [import_deprecated.SchemaType.INT192_ARRAY]: "RecsType.BigIntArray",
+  [import_deprecated.SchemaType.INT200_ARRAY]: "RecsType.BigIntArray",
+  [import_deprecated.SchemaType.INT208_ARRAY]: "RecsType.BigIntArray",
+  [import_deprecated.SchemaType.INT216_ARRAY]: "RecsType.BigIntArray",
+  [import_deprecated.SchemaType.INT224_ARRAY]: "RecsType.BigIntArray",
+  [import_deprecated.SchemaType.INT232_ARRAY]: "RecsType.BigIntArray",
+  [import_deprecated.SchemaType.INT240_ARRAY]: "RecsType.BigIntArray",
+  [import_deprecated.SchemaType.INT248_ARRAY]: "RecsType.BigIntArray",
+  [import_deprecated.SchemaType.INT256_ARRAY]: "RecsType.BigIntArray",
+  [import_deprecated.SchemaType.BYTES1_ARRAY]: "RecsType.BigIntArray",
+  [import_deprecated.SchemaType.BYTES2_ARRAY]: "RecsType.BigIntArray",
+  [import_deprecated.SchemaType.BYTES3_ARRAY]: "RecsType.BigIntArray",
+  [import_deprecated.SchemaType.BYTES4_ARRAY]: "RecsType.BigIntArray",
+  [import_deprecated.SchemaType.BYTES5_ARRAY]: "RecsType.BigIntArray",
+  [import_deprecated.SchemaType.BYTES6_ARRAY]: "RecsType.BigIntArray",
+  [import_deprecated.SchemaType.BYTES7_ARRAY]: "RecsType.BigIntArray",
+  [import_deprecated.SchemaType.BYTES8_ARRAY]: "RecsType.BigIntArray",
+  [import_deprecated.SchemaType.BYTES9_ARRAY]: "RecsType.BigIntArray",
+  [import_deprecated.SchemaType.BYTES10_ARRAY]: "RecsType.BigIntArray",
+  [import_deprecated.SchemaType.BYTES11_ARRAY]: "RecsType.BigIntArray",
+  [import_deprecated.SchemaType.BYTES12_ARRAY]: "RecsType.BigIntArray",
+  [import_deprecated.SchemaType.BYTES13_ARRAY]: "RecsType.BigIntArray",
+  [import_deprecated.SchemaType.BYTES14_ARRAY]: "RecsType.BigIntArray",
+  [import_deprecated.SchemaType.BYTES15_ARRAY]: "RecsType.BigIntArray",
+  [import_deprecated.SchemaType.BYTES16_ARRAY]: "RecsType.BigIntArray",
+  [import_deprecated.SchemaType.BYTES17_ARRAY]: "RecsType.BigIntArray",
+  [import_deprecated.SchemaType.BYTES18_ARRAY]: "RecsType.BigIntArray",
+  [import_deprecated.SchemaType.BYTES19_ARRAY]: "RecsType.BigIntArray",
+  [import_deprecated.SchemaType.BYTES20_ARRAY]: "RecsType.BigIntArray",
+  [import_deprecated.SchemaType.BYTES21_ARRAY]: "RecsType.BigIntArray",
+  [import_deprecated.SchemaType.BYTES22_ARRAY]: "RecsType.BigIntArray",
+  [import_deprecated.SchemaType.BYTES23_ARRAY]: "RecsType.BigIntArray",
+  [import_deprecated.SchemaType.BYTES24_ARRAY]: "RecsType.BigIntArray",
+  [import_deprecated.SchemaType.BYTES25_ARRAY]: "RecsType.BigIntArray",
+  [import_deprecated.SchemaType.BYTES26_ARRAY]: "RecsType.BigIntArray",
+  [import_deprecated.SchemaType.BYTES27_ARRAY]: "RecsType.BigIntArray",
+  [import_deprecated.SchemaType.BYTES28_ARRAY]: "RecsType.BigIntArray",
+  [import_deprecated.SchemaType.BYTES29_ARRAY]: "RecsType.BigIntArray",
+  [import_deprecated.SchemaType.BYTES30_ARRAY]: "RecsType.BigIntArray",
+  [import_deprecated.SchemaType.BYTES31_ARRAY]: "RecsType.BigIntArray",
+  [import_deprecated.SchemaType.BYTES32_ARRAY]: "RecsType.BigIntArray",
+  [import_deprecated.SchemaType.BOOL_ARRAY]: "RecsType.T",
+  // no boolean array
+  [import_deprecated.SchemaType.ADDRESS_ARRAY]: "RecsType.StringArray",
+  [import_deprecated.SchemaType.BYTES]: "RecsType.String",
+  [import_deprecated.SchemaType.STRING]: "RecsType.String"
+};
+
+// src/codegen/utils/contractToInterface.ts
+var import_parser = require("@solidity-parser/parser");
+
+// src/errors/MUDError.ts
+var MUDError = class extends Error {
+  constructor() {
+    super(...arguments);
+    this.name = "MUDError";
+  }
+};
+
+// src/codegen/utils/contractToInterface.ts
+function contractToInterface(source, contractName) {
+  const ast = (0, import_parser.parse)(source);
+  const contractNode = findContractNode(ast, contractName);
+  let symbolImports = [];
+  const functions = [];
+  const errors = [];
+  if (!contractNode) {
+    throw new MUDError(`Contract not found: ${contractName}`);
+  }
+  (0, import_parser.visit)(contractNode, {
+    FunctionDefinition({
+      name,
+      visibility,
+      parameters,
+      stateMutability,
+      returnParameters,
+      isConstructor,
+      isFallback,
+      isReceiveEther
+    }) {
+      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),
+            stateMutability: stateMutability || "",
+            returnParameters: returnParameters === null ? [] : returnParameters.map(parseParameter)
+          });
+          for (const { typeName } of parameters.concat(returnParameters ?? [])) {
+            const symbols = typeNameToSymbols(typeName);
+            symbolImports = symbolImports.concat(symbolsToImports(ast, symbols));
+          }
+        }
+      } catch (error3) {
+        if (error3 instanceof MUDError) {
+          error3.message = `Function "${name}" in contract "${contractName}": ${error3.message}`;
+        }
+        throw error3;
+      }
+    },
+    CustomErrorDefinition({ name, parameters }) {
+      errors.push({
+        name,
+        parameters: parameters.map(parseParameter)
+      });
+      for (const parameter of parameters) {
+        const symbols = typeNameToSymbols(parameter.typeName);
+        symbolImports = symbolImports.concat(symbolsToImports(ast, symbols));
+      }
+    }
+  });
+  return {
+    functions,
+    errors,
+    symbolImports
+  };
+}
+function findContractNode(ast, contractName) {
+  let contract = void 0;
+  (0, import_parser.visit)(ast, {
+    ContractDefinition(node) {
+      if (node.name === contractName) {
+        contract = node;
+      }
+    }
+  });
+  return contract;
+}
+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") {
+    let length = "";
+    if (typeName.length?.type === "NumberLiteral") {
+      length = typeName.length.number;
+    } else if (typeName.length?.type === "Identifier") {
+      length = typeName.length.name;
+    }
+    const { name, stateMutability } = flattenTypeName(typeName.baseTypeName);
+    return {
+      name: `${name}[${length}]`,
+      stateMutability
+    };
+  } else {
+    throw new MUDError(`Invalid typeName.type ${typeName.type}`);
+  }
+}
+function typeNameToSymbols(typeName) {
+  if (typeName?.type === "UserDefinedTypeName") {
+    const symbol = typeName.namePath.split(".")[0];
+    return [symbol];
+  } else if (typeName?.type === "ArrayTypeName") {
+    const symbols = typeNameToSymbols(typeName.baseTypeName);
+    if (typeName.length?.type === "Identifier") {
+      const innerTypeName = typeName.length.name;
+      symbols.push(innerTypeName.split(".")[0]);
+    }
+    return symbols;
+  } else {
+    return [];
+  }
+}
+function symbolsToImports(ast, symbols) {
+  const imports = [];
+  for (const symbol of symbols) {
+    let symbolImport;
+    (0, import_parser.visit)(ast, {
+      ImportDirective({ path: path3, symbolAliases }) {
+        if (symbolAliases) {
+          for (const symbolAndAlias of symbolAliases) {
+            const symbolAlias = symbolAndAlias[1] || symbolAndAlias[0];
+            if (symbol === symbolAlias) {
+              symbolImport = {
+                // always use the original symbol for interface imports
+                symbol: symbolAndAlias[0],
+                path: path3
+              };
+              return;
+            }
+          }
+        }
+      }
+    });
+    if (symbolImport) {
+      imports.push(symbolImport);
+    } else {
+      throw new MUDError(`Symbol "${symbol}" has no explicit import`);
+    }
+  }
+  return imports;
+}
+
+// src/codegen/utils/format.ts
+var import_prettier = __toESM(require("prettier"), 1);
+var import_prettier_plugin_solidity = __toESM(require("prettier-plugin-solidity"), 1);
+async function formatSolidity(content, prettierConfigPath) {
+  let config;
+  if (prettierConfigPath) {
+    config = await import_prettier.default.resolveConfig(prettierConfigPath);
+  }
+  try {
+    return import_prettier.default.format(content, {
+      plugins: [import_prettier_plugin_solidity.default],
+      parser: "solidity-parse",
+      printWidth: 120,
+      semi: true,
+      tabWidth: 2,
+      useTabs: false,
+      bracketSpacing: true,
+      ...config
+    });
+  } catch (error3) {
+    let message;
+    if (error3 instanceof Error) {
+      message = error3.message;
+    } else {
+      message = error3;
+    }
+    console.log(`Error during output formatting: ${message}`);
+    return content;
+  }
+}
+async function formatTypescript(content) {
+  return import_prettier.default.format(content, {
+    parser: "typescript"
+  });
+}
+
+// src/codegen/utils/formatAndWrite.ts
+var import_promises = __toESM(require("fs/promises"), 1);
+var import_node_path2 = __toESM(require("path"), 1);
+
+// src/debug.ts
+var import_debug = __toESM(require("debug"), 1);
+var debug = (0, import_debug.default)("mud:common");
+var error = (0, import_debug.default)("mud:common");
+debug.log = console.debug.bind(console);
+error.log = console.error.bind(console);
+
+// src/codegen/debug.ts
+var debug2 = debug.extend("codegen");
+var error2 = debug.extend("codegen");
+debug2.log = console.debug.bind(console);
+error2.log = console.error.bind(console);
+
+// src/codegen/utils/formatAndWrite.ts
+async function formatAndWriteSolidity(output, fullOutputPath, logPrefix) {
+  const formattedOutput = await formatSolidity(output);
+  await import_promises.default.mkdir(import_node_path2.default.dirname(fullOutputPath), { recursive: true });
+  await import_promises.default.writeFile(fullOutputPath, formattedOutput);
+  debug2(`${logPrefix}: ${fullOutputPath}`);
+}
+async function formatAndWriteTypescript(output, fullOutputPath, logPrefix) {
+  const formattedOutput = await formatTypescript(output);
+  await import_promises.default.mkdir(import_node_path2.default.dirname(fullOutputPath), { recursive: true });
+  await import_promises.default.writeFile(fullOutputPath, formattedOutput);
+  debug2(`${logPrefix}: ${fullOutputPath}`);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  abiToInterface,
+  contractToInterface,
+  findContractNode,
+  formatAndWriteSolidity,
+  formatAndWriteTypescript,
+  formatSolidity,
+  formatTypescript,
+  getLeftPaddingBits,
+  isLeftAligned,
+  renderArguments,
+  renderCommonData,
+  renderEnums,
+  renderImportPath,
+  renderImports,
+  renderList,
+  renderTableId,
+  renderTypeHelpers,
+  renderValueTypeToBytes32,
+  renderWithFieldSuffix,
+  renderWithStore,
+  renderedSolidityHeader,
+  schemaTypesToRecsTypeStrings
+});
+//# sourceMappingURL=codegen.cjs.map