@latticexyz/cli 1.40.0 → 1.41.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022-present Lattice Labs Ltd.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/chunk-ATAWDHWC.js

@@ -0,0 +1,67 @@
+// src/utils/foundry.ts
+import { execa as execa2 } from "execa";
+
+// src/utils/execLog.ts
+import chalk from "chalk";
+import { execa } from "execa";
+async function execLog(command, args, options) {
+  const commandString = `${command} ${args.join(" ")}`;
+  try {
+    console.log(chalk.gray(`running "${commandString}"`));
+    const { stdout } = await execa(command, args, { stdout: "pipe", stderr: "pipe", ...options });
+    return stdout;
+  } catch (error) {
+    let errorMessage = error?.stderr || error?.message || "";
+    errorMessage += chalk.red(`
+Error running "${commandString}"`);
+    throw new Error(errorMessage);
+  }
+}
+
+// src/utils/foundry.ts
+async function getForgeConfig(profile) {
+  const { stdout } = await execa2("forge", ["config", "--json"], {
+    stdio: ["inherit", "pipe", "pipe"],
+    env: { FOUNDRY_PROFILE: profile }
+  });
+  return JSON.parse(stdout);
+}
+async function getSrcDirectory(profile) {
+  return (await getForgeConfig(profile)).src;
+}
+async function getScriptDirectory(profile) {
+  return (await getForgeConfig(profile)).script;
+}
+async function getTestDirectory(profile) {
+  return (await getForgeConfig(profile)).test;
+}
+async function getOutDirectory(profile) {
+  return (await getForgeConfig(profile)).out;
+}
+async function getRpcUrl(profile) {
+  return (await getForgeConfig(profile)).eth_rpc_url || "http://127.0.0.1:8545";
+}
+async function forge(args, options) {
+  const execOptions = {
+    env: { FOUNDRY_PROFILE: options?.profile },
+    stdout: "inherit",
+    stderr: "pipe"
+  };
+  await (options?.silent ? execa2("forge", args, execOptions) : execLog("forge", args, execOptions));
+}
+async function cast(args, options) {
+  return execLog("cast", args, {
+    env: { FOUNDRY_PROFILE: options?.profile }
+  });
+}
+
+export {
+  getForgeConfig,
+  getSrcDirectory,
+  getScriptDirectory,
+  getTestDirectory,
+  getOutDirectory,
+  getRpcUrl,
+  forge,
+  cast
+};

package/dist/{chunk-6AQ6LFVZ.js → chunk-GR245KYP.js}

@@ -1,3 +1,63 @@
+// src/utils/errors.ts
+import chalk from "chalk";
+import { z, ZodError, ZodIssueCode } from "zod";
+import { fromZodError, ValidationError } from "zod-validation-error";
+function fromZodErrorCustom(error, prefix) {
+  return fromZodError(error, {
+    prefix: chalk.red(prefix),
+    prefixSeparator: "\n- ",
+    issueSeparator: "\n- "
+  });
+}
+var NotInsideProjectError = class extends Error {
+  constructor() {
+    super(...arguments);
+    this.name = "NotInsideProjectError";
+    this.message = "You are not inside a MUD project";
+  }
+};
+var NotESMConfigError = class extends Error {
+  constructor() {
+    super(...arguments);
+    this.name = "NotESMConfigError";
+    this.message = "MUD config must be an ES module";
+  }
+};
+var MUDError = class extends Error {
+  constructor() {
+    super(...arguments);
+    this.name = "MUDError";
+  }
+};
+function UnrecognizedSystemErrorFactory(path, systemName) {
+  return new z.ZodError([{ code: ZodIssueCode.custom, path, message: `Unrecognized system: "${systemName}"` }]);
+}
+function logError(error) {
+  if (error instanceof ValidationError) {
+    console.log(chalk.redBright(error.message));
+  } else if (error instanceof ZodError) {
+    const validationError = fromZodError(error, {
+      prefixSeparator: "\n- ",
+      issueSeparator: "\n- "
+    });
+    console.log(chalk.redBright(validationError.message));
+  } else if (error instanceof NotInsideProjectError) {
+    console.log(chalk.red(error.message));
+    console.log("");
+    console.log(chalk.blue(`To learn more about MUD's configuration, please go to https://mud.dev/packages/cli/`));
+  } else if (error instanceof NotESMConfigError) {
+    console.log(chalk.red(error.message));
+    console.log("");
+    console.log(
+      chalk.blue(`Please name your config file \`mud.config.mts\`, or use \`type: "module"\` in package.json`)
+    );
+  } else if (error instanceof MUDError) {
+    console.log(chalk.red(error));
+  } else {
+    console.log(error);
+  }
+}
+
 // ../schema-type/src/typescript/SchemaType.ts
 var SchemaType = /* @__PURE__ */ ((SchemaType2) => {
   SchemaType2[SchemaType2["UINT8"] = 0] = "UINT8";
@@ -516,10 +576,44 @@ var SchemaTypeArrayToElement = {
   [194 /* BOOL_ARRAY */]: 96 /* BOOL */,
   [195 /* ADDRESS_ARRAY */]: 97 /* ADDRESS */
 };
+function encodeSchema(schema) {
+  if (schema.length > 28)
+    throw new Error("Schema can only have up to 28 fields");
+  const encodedSchema = new Uint8Array(32);
+  let length = 0;
+  let staticFields = 0;
+  let hasDynamicFields = false;
+  for (let i = 0; i < schema.length; i++) {
+    const staticByteLength = getStaticByteLength(schema[i]);
+    if (staticByteLength > 0) {
+      if (hasDynamicFields)
+        throw new Error("Static fields must come before dynamic fields in the schema");
+      staticFields++;
+    } else {
+      hasDynamicFields = true;
+    }
+    length += staticByteLength;
+    encodedSchema[i + 4] = schema[i];
+  }
+  const dynamicFields = schema.length - staticFields;
+  if (dynamicFields > 14)
+    throw new Error("Schema can only have up to 14 dynamic fields");
+  new DataView(encodedSchema.buffer).setUint16(0, length);
+  encodedSchema[2] = staticFields;
+  encodedSchema[3] = dynamicFields;
+  return encodedSchema;
+}
 
 export {
   SchemaType,
   getStaticByteLength,
   SchemaTypeId,
-  SchemaTypeArrayToElement
+  SchemaTypeArrayToElement,
+  encodeSchema,
+  fromZodErrorCustom,
+  NotInsideProjectError,
+  NotESMConfigError,
+  MUDError,
+  UnrecognizedSystemErrorFactory,
+  logError
 };

package/dist/{chunk-S3V3XX7N.js → chunk-SLIMIO4Z.js}

@@ -1,7 +1,7 @@
 import {
   getOutDirectory,
   getSrcDirectory
-} from "./chunk-PJ6GS2R4.js";
+} from "./chunk-ATAWDHWC.js";
 import {
   __commonJS,
   __require,

package/dist/{chunk-JNGSW4AP.js → chunk-XRS7KWBZ.js}

@@ -1,11 +1,16 @@
 import {
-  SchemaType,
-  SchemaTypeArrayToElement,
-  SchemaTypeId,
-  getStaticByteLength
-} from "./chunk-6AQ6LFVZ.js";
+  getSchemaTypeInfo,
+  resolveSchemaOrUserType
+} from "./chunk-ZYDMYSTH.js";
+import {
+  SchemaTypeArrayToElement
+} from "./chunk-GR245KYP.js";
+
+// src/render-solidity/common.ts
+var renderedSolidityHeader = `// SPDX-License-Identifier: MIT
+pragma solidity >=0.8.0;
 
-// src/render-table/common.ts
+/* Autogenerated file. Do not edit manually. */`;
 function renderList(list, renderItem) {
   return internalRenderList("", list, renderItem);
 }
@@ -22,9 +27,7 @@ function renderCommonData({ staticRouteData, primaryKeys }) {
     bytes32[] memory _primaryKeys = new bytes32[](${primaryKeys.length});
     ${renderList(
     primaryKeys,
-    ({ name, typeId, staticByteLength }, index) => `
-    _primaryKeys[${index}] = ${renderValueTypeToBytes32(name, typeId, staticByteLength)};
-    `
+    (primaryKey, index) => `_primaryKeys[${index}] = ${renderValueTypeToBytes32(primaryKey.name, primaryKey)};`
   )}
   `;
   return {
@@ -35,27 +38,43 @@ function renderCommonData({ staticRouteData, primaryKeys }) {
     _primaryKeysDefinition
   };
 }
-function renderValueTypeToBytes32(innerText, typeId, staticByteLength) {
+function renderImports(imports) {
+  const aggregatedImports = /* @__PURE__ */ new Map();
+  for (const { symbol, path: path2 } of imports) {
+    if (!aggregatedImports.has(path2)) {
+      aggregatedImports.set(path2, /* @__PURE__ */ new Set());
+    }
+    aggregatedImports.get(path2)?.add(symbol);
+  }
+  const renderedImports = [];
+  for (const [path2, symbols] of aggregatedImports) {
+    const renderedSymbols = [...symbols].join(", ");
+    renderedImports.push(`import { ${renderedSymbols} } from "${path2}";`);
+  }
+  return renderedImports.join("\n");
+}
+function renderValueTypeToBytes32(name, { staticByteLength, typeUnwrap, internalTypeId }) {
   const bits = staticByteLength * 8;
-  if (typeId.match(/^uint\d{1,3}$/)) {
+  const innerText = `${typeUnwrap}(${name})`;
+  if (internalTypeId.match(/^uint\d{1,3}$/)) {
     return `bytes32(uint256(${innerText}))`;
-  } else if (typeId.match(/^int\d{1,3}$/)) {
+  } else if (internalTypeId.match(/^int\d{1,3}$/)) {
     return `bytes32(uint256(uint${bits}(${innerText})))`;
-  } else if (typeId.match(/^bytes\d{1,2}$/)) {
+  } else if (internalTypeId.match(/^bytes\d{1,2}$/)) {
     return `bytes32(${innerText})`;
-  } else if (typeId === "address") {
+  } else if (internalTypeId === "address") {
     return `bytes32(bytes20(${innerText}))`;
-  } else if (typeId === "bool") {
+  } else if (internalTypeId === "bool") {
     return `_boolToBytes32(${innerText})`;
   } else {
-    throw new Error(`Unknown value type id ${typeId}`);
+    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-table/field.ts
+// src/render-solidity/field.ts
 function renderFieldMethods(options) {
   const { _typedTableId, _typedKeyArgs, _primaryKeysDefinition } = renderCommonData(options);
   let result = "";
@@ -108,7 +127,7 @@ function renderFieldMethods(options) {
       ])}) internal {
         ${_primaryKeysDefinition}
         bytes memory _blob = StoreSwitch.getField(_tableId, _primaryKeys, ${index});
-        bytes memory _newBlob = abi.encodePacked(_blob, ${portionData.encodeFunc}(${portionData.name}));
+        bytes memory _newBlob = abi.encodePacked(_blob, ${portionData.encoded});
         StoreSwitch.setField(_tableId, _primaryKeys, ${index}, _newBlob);
       }
       `;
@@ -125,52 +144,60 @@ function renderEncodeField(field) {
   } else {
     func = "abi.encodePacked";
   }
-  return `${func}(${field.name})`;
+  return `${func}(${field.typeUnwrap}(${field.name}))`;
 }
-function renderDecodeValueType(typeId, staticByteLength, offset) {
+function renderDecodeValueType(field, offset) {
+  const { staticByteLength, internalTypeId } = field;
   const innerSlice = `Bytes.slice${staticByteLength}(_blob, ${offset})`;
   const bits = staticByteLength * 8;
-  if (typeId.match(/^uint\d{1,3}$/) || typeId === "address") {
-    return `${typeId}(${innerSlice})`;
-  } else if (typeId.match(/^int\d{1,3}$/)) {
-    return `${typeId}(uint${bits}(${innerSlice}))`;
-  } else if (typeId.match(/^bytes\d{1,2}$/)) {
-    return innerSlice;
-  } else if (typeId === "bool") {
-    return `_toBool(uint8(${innerSlice}))`;
+  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 ${typeId}`);
+    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",
-      encodeFunc: "abi.encodePacked",
+      encoded: renderEncodeField({ ...field.arrayElement, arrayElement: void 0, name, methodNameSuffix }),
       title: "an element"
     };
   } else {
+    const name = "_slice";
     return {
       typeWithLocation: `${field.typeId} memory`,
-      name: "_slice",
-      encodeFunc: "bytes",
+      name,
+      encoded: renderEncodeField({ ...field, name, methodNameSuffix }),
       title: "a slice"
     };
   }
 }
 function renderDecodeFieldSingle(field) {
-  const { typeId, isDynamic, arrayElement } = field;
+  const { isDynamic, arrayElement } = field;
   if (arrayElement) {
-    return `SliceLib.getSubslice(_blob, 0, _blob.length).decodeArray_${arrayElement.typeId}()`;
+    return `${field.typeWrap}(
+      SliceLib.getSubslice(_blob, 0, _blob.length).decodeArray_${arrayElement.internalTypeId}()
+    )`;
   } else if (isDynamic) {
-    return `${typeId}(_blob)`;
+    return `${field.typeWrap}(${field.internalTypeId}(_blob))`;
   } else {
-    return renderDecodeValueType(typeId, field.staticByteLength, 0);
+    return renderDecodeValueType(field, 0);
   }
 }
 
-// src/render-table/record.ts
+// src/render-solidity/record.ts
 function renderRecordMethods(options) {
   const { staticFields, dynamicFields, structName, storeArgument } = options;
   const { _tableId, _typedTableId, _keyArgs, _typedKeyArgs, _primaryKeysDefinition } = renderCommonData(options);
@@ -253,7 +280,7 @@ function renderDecodeFunction({ structName, fields, staticFields, dynamicFields
       ${renderList(
       staticFields,
       (field, index) => `
-        ${fieldNamePrefix}${field.name} = ${renderDecodeStaticFieldPartial(field, staticOffsets[index])};
+        ${fieldNamePrefix}${field.name} = ${renderDecodeValueType(field, staticOffsets[index])};
         `
     )}
       uint256 _start;
@@ -275,7 +302,7 @@ function renderDecodeFunction({ structName, fields, staticFields, dynamicFields
       ${renderList(
       staticFields,
       (field, index) => `
-        ${fieldNamePrefix}${field.name} = ${renderDecodeStaticFieldPartial(field, staticOffsets[index])};
+        ${fieldNamePrefix}${field.name} = ${renderDecodeValueType(field, staticOffsets[index])};
         `
     )}
     }
@@ -297,10 +324,6 @@ function renderDecodeDynamicFieldPartial(field) {
     return `${typeId}(SliceLib.getSubslice(_blob, _start, _end).toBytes())`;
   }
 }
-function renderDecodeStaticFieldPartial(field, start) {
-  const { typeId, staticByteLength } = field;
-  return renderDecodeValueType(typeId, staticByteLength, start);
-}
 function renderEncodedLengths(dynamicFields) {
   if (dynamicFields.length > 0) {
     return `
@@ -319,17 +342,16 @@ function renderEncodedLengths(dynamicFields) {
   }
 }
 
-// src/render-table/renderTable.ts
+// src/render-solidity/renderTable.ts
 function renderTable(options) {
-  const { libraryName, structName, staticRouteData, storeImportPath, fields, withRecordMethods } = options;
+  const { imports, libraryName, structName, staticRouteData, storeImportPath, fields, withRecordMethods } = options;
   const { _typedTableId, _typedKeyArgs, _primaryKeysDefinition } = renderCommonData(options);
-  return `// SPDX-License-Identifier: MIT
-pragma solidity >=0.8.0;
-
-/* Autogenerated file. Do not edit manually. */
+  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";
@@ -339,15 +361,20 @@ 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)}
+    ` : ""}
+
 ${!staticRouteData ? "" : `
-  uint256 constant _tableId = uint256(keccak256("${staticRouteData.baseRoute + staticRouteData.subRoute}"));
-  uint256 constant ${staticRouteData.tableIdName} = _tableId;
+      uint256 constant _tableId = uint256(keccak256("${staticRouteData.baseRoute + staticRouteData.subRoute}"));
+      uint256 constant ${staticRouteData.tableIdName} = _tableId;
 `}
 
 ${!structName ? "" : `
-  struct ${structName} {
-    ${renderList(fields, ({ name, typeId }) => `${typeId} ${name};`)}
-  }
+      struct ${structName} {
+        ${renderList(fields, ({ name, typeId }) => `${typeId} ${name};`)}
+      }
 `}
 
 library ${libraryName} {
@@ -359,16 +386,35 @@ library ${libraryName} {
     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);
+  }
+
   /** 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());
   }
+
+  /** 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);
+  }
 `}
 
 ${renderFieldMethods(options)}
@@ -403,33 +449,51 @@ ${// nothing can be cast from bool, so an assembly helper is required
 `;
 }
 
-// src/render-table/renderTablesFromConfig.ts
-function renderTablesFromConfig(config) {
+// src/render-solidity/renderTablesFromConfig.ts
+import path from "path";
+function renderTablesFromConfig(config, srcDirectory) {
   const storeImportPath = config.storeImportPath;
   const renderedTables = [];
   for (const tableName of Object.keys(config.tables)) {
     const tableData = config.tables[tableName];
+    const outputDirectory = path.join(srcDirectory, tableData.directory);
     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 type = tableData.primaryKeys[name];
-      const typeInfo = getSchemaTypeInfo(type);
-      if (typeInfo.isDynamic)
-        throw new Error("Parsing error: found dynamic primary key");
+      const schemaOrUserType = tableData.primaryKeys[name];
+      const { renderTableType, importDatum } = resolveSchemaOrUserType(
+        schemaOrUserType,
+        srcDirectory,
+        outputDirectory,
+        config.userTypes
+      );
+      if (importDatum)
+        imports.push(importDatum);
+      if (renderTableType.isDynamic)
+        throw new Error(`Parsing error: found dynamic primary key ${name} in table ${tableName}`);
       const primaryKey = {
-        ...typeInfo,
+        ...renderTableType,
         name,
         isDynamic: false
       };
       return primaryKey;
     });
     const fields = Object.keys(tableData.schema).map((name) => {
-      const type = tableData.schema[name];
-      const elementType = SchemaTypeArrayToElement[type];
+      const schemaOrUserType = tableData.schema[name];
+      const { renderTableType, importDatum, schemaType } = resolveSchemaOrUserType(
+        schemaOrUserType,
+        srcDirectory,
+        outputDirectory,
+        config.userTypes
+      );
+      if (importDatum)
+        imports.push(importDatum);
+      const elementType = SchemaTypeArrayToElement[schemaType];
       const field = {
-        ...getSchemaTypeInfo(type),
-        arrayElement: elementType ? getSchemaTypeInfo(elementType) : void 0,
+        ...renderTableType,
+        arrayElement: elementType !== void 0 ? getSchemaTypeInfo(elementType) : void 0,
         name,
         methodNameSuffix: noFieldMethodSuffix ? "" : `${name[0].toUpperCase()}${name.slice(1)}`
       };
@@ -443,15 +507,17 @@ function renderTablesFromConfig(config) {
       } else {
         return {
           tableIdName: tableName + "TableId",
-          baseRoute: config.baseRoute + tableData.route,
-          subRoute: `/${tableName}`
+          baseRoute: config.baseRoute,
+          subRoute: tableData.route
         };
       }
     })();
     renderedTables.push({
+      outputDirectory,
       tableName,
       tableData,
       output: renderTable({
+        imports,
         libraryName: tableName,
         structName: withStruct ? tableName + "Data" : void 0,
         staticRouteData,
@@ -467,27 +533,15 @@ function renderTablesFromConfig(config) {
   }
   return renderedTables;
 }
-function getSchemaTypeInfo(schemaType) {
-  const staticByteLength = getStaticByteLength(schemaType);
-  const isDynamic = staticByteLength === 0;
-  const typeId = SchemaTypeId[schemaType];
-  return {
-    typeId,
-    typeWithLocation: isDynamic ? typeId + " memory" : typeId,
-    enumName: SchemaType[schemaType],
-    staticByteLength,
-    isDynamic
-  };
-}
+
+// src/constants.ts
+var deploymentInfoFilenamePrefix = "mud-deployment-";
 
 export {
+  renderedSolidityHeader,
   renderList,
   renderArguments,
-  renderCommonData,
-  renderFieldMethods,
-  renderEncodeField,
-  renderDecodeValueType,
-  renderRecordMethods,
   renderTable,
-  renderTablesFromConfig
+  renderTablesFromConfig,
+  deploymentInfoFilenamePrefix
 };