@latticexyz/cli 1.40.0 → 1.41.1-alpha.0

package/src/config/world/resolveWorldConfig.ts

@@ -0,0 +1,80 @@
+import { UnrecognizedSystemErrorFactory } from "../../utils/errors.js";
+import { ParsedWorldConfig } from "./parseWorldConfig.js";
+import { SystemUserConfig } from "./userTypes.js";
+
+export type ResolvedSystemConfig = ReturnType<typeof resolveSystemConfig>;
+
+export type ResolvedWorldConfig = ReturnType<typeof resolveWorldConfig>;
+
+/**
+ * Resolves the world config by combining the default and overridden system configs,
+ * filtering out excluded systems, validate system names refer to existing contracts, and
+ * splitting the access list into addresses and system names.
+ */
+export function resolveWorldConfig(config: ParsedWorldConfig, existingContracts?: string[]) {
+  // Include contract names ending in "System", but not the base "System" contract, and not Interfaces
+  const defaultSystemNames =
+    existingContracts?.filter((name) => name.endsWith("System") && name !== "System" && !name.match(/^I[A-Z]/)) ?? [];
+  const overriddenSystemNames = Object.keys(config.overrideSystems);
+
+  // Validate every key in overrideSystems refers to an existing system contract (and is not called "World")
+  if (existingContracts) {
+    for (const systemName of overriddenSystemNames) {
+      if (!existingContracts.includes(systemName) || systemName === "World") {
+        throw UnrecognizedSystemErrorFactory(["overrideSystems", systemName], systemName);
+      }
+    }
+  }
+
+  // Combine the default and overridden system names and filter out excluded systems
+  const systemNames = [...new Set([...defaultSystemNames, ...overriddenSystemNames])].filter(
+    (name) => !config.excludeSystems.includes(name)
+  );
+
+  // Resolve the config
+  const resolvedSystems: Record<string, ResolvedSystemConfig> = systemNames.reduce((acc, systemName) => {
+    return {
+      ...acc,
+      [systemName]: resolveSystemConfig(systemName, config.overrideSystems[systemName], existingContracts),
+    };
+  }, {});
+
+  const { overrideSystems, excludeSystems, ...otherConfig } = config;
+  return { ...otherConfig, systems: resolvedSystems };
+}
+
+/**
+ * Resolves the system config by combining the default and overridden system configs,
+ * @param systemName name of the system
+ * @param config optional SystemConfig object, if none is provided the default config is used
+ * @param existingContracts optional list of existing contract names, used to validate system names in the access list. If not provided, no validation is performed.
+ * @returns ResolvedSystemConfig object
+ * Default value for fileSelector is `systemName`
+ * Default value for registerFunctionSelectors is true
+ * Default value for openAccess is true
+ * Default value for accessListAddresses is []
+ * Default value for accessListSystems is []
+ */
+export function resolveSystemConfig(systemName: string, config?: SystemUserConfig, existingContracts?: string[]) {
+  const fileSelector = config?.fileSelector ?? systemName;
+  const registerFunctionSelectors = config?.registerFunctionSelectors ?? true;
+  const openAccess = config?.openAccess ?? true;
+  const accessListAddresses: string[] = [];
+  const accessListSystems: string[] = [];
+  const accessList = config && !config.openAccess ? config.accessList : [];
+
+  // Split the access list into addresses and system names
+  for (const accessListItem of accessList) {
+    if (accessListItem.startsWith("0x")) {
+      accessListAddresses.push(accessListItem);
+    } else {
+      // Validate every system refers to an existing system contract
+      if (existingContracts && !existingContracts.includes(accessListItem)) {
+        throw UnrecognizedSystemErrorFactory(["overrideSystems", systemName, "accessList"], accessListItem);
+      }
+      accessListSystems.push(accessListItem);
+    }
+  }
+
+  return { fileSelector, registerFunctionSelectors, openAccess, accessListAddresses, accessListSystems };
+}

package/src/config/world/userTypes.ts

@@ -0,0 +1,72 @@
+import { DynamicResolution } from "../dynamicResolution.js";
+
+// zod doesn't preserve doc comments
+export type SystemUserConfig =
+  | {
+      /** The full resource selector consists of namespace and fileSelector */
+      fileSelector?: string;
+      /**
+       * Register function selectors for the system in the World.
+       * Defaults to true.
+       * Note:
+       * - For root systems all World function selectors will correspond to the system's function selectors.
+       * - For non-root systems, the World function selectors will be <namespace>_<system>_<function>.
+       */
+      registerFunctionSelectors?: boolean;
+    } & (
+      | {
+          /** If openAccess is true, any address can call the system */
+          openAccess: true;
+        }
+      | {
+          /** If openAccess is false, only the addresses or systems in `access` can call the system */
+          openAccess: false;
+          /** An array of addresses or system names that can access the system */
+          accessList: string[];
+        }
+    );
+
+export type ValueWithType = {
+  value: string | number | Uint8Array;
+  type: string;
+};
+
+export type ModuleConfig = {
+  /** The name of the module */
+  name: string;
+  /** Should this module be installed as a root module? */
+  root?: boolean;
+  /** Arguments to be passed to the module's install method */
+  args?: (ValueWithType | DynamicResolution)[];
+};
+
+// zod doesn't preserve doc comments
+export interface WorldUserConfig {
+  /** The namespace to register tables and systems at. Defaults to the root namespace (empty string) */
+  namespace?: string;
+  /** The name of the World contract to deploy. If no name is provided, a vanilla World is deployed */
+  worldContractName?: string;
+  /**
+   * Contracts named *System will be deployed by default
+   * as public systems at `namespace/ContractName`, unless overridden
+   *
+   * The key is the system name (capitalized).
+   * The value is a SystemConfig object.
+   */
+  overrideSystems?: Record<string, SystemUserConfig>;
+  /** Systems to exclude from automatic deployment */
+  excludeSystems?: string[];
+  /**
+   * Script to execute after the deployment is complete (Default "PostDeploy").
+   * Script must be placed in the forge scripts directory (see foundry.toml) and have a ".s.sol" extension.
+   */
+  postDeployScript?: string;
+  /** Directory to write the deployment info to (Default "./deploys") */
+  deploysDirectory?: string;
+  /** Directory to output system and world interfaces of `worldgen` (Default "world") */
+  worldgenDirectory?: string;
+  /** Path for world package imports. Default is "@latticexyz/world/src/" */
+  worldImportPath?: string;
+  /** Modules to in the World */
+  modules?: ModuleConfig[];
+}

package/src/index.ts

@@ -1,7 +1,15 @@
-import { loadStoreConfig, parseStoreConfig } from "./config/loadStoreConfig.js";
-import { renderTablesFromConfig } from "./render-table/renderTablesFromConfig.js";
-import { renderTable } from "./render-table/renderTable.js";
+export { loadStoreConfig } from "./config/loadStoreConfig.js";
+export { parseStoreConfig } from "./config/parseStoreConfig.js";
+export { loadWorldConfig, resolveWorldConfig, parseWorldConfig } from "./config/world/index.js";
+export { resolveTableId } from "./config/dynamicResolution.js";
 
-export type { StoreUserConfig, StoreConfig } from "./config/loadStoreConfig.js";
+export type {
+  StoreUserConfig,
+  StoreConfig,
+  WorldUserConfig,
+  ResolvedWorldConfig,
+  MUDUserConfig,
+  MUDConfig,
+} from "./config/index.js";
 
-export { loadStoreConfig, parseStoreConfig, renderTablesFromConfig, renderTable };
+export { storeConfig, mudConfig } from "./config/index.js";

package/src/mud.ts

@@ -5,6 +5,10 @@ import { hideBin } from "yargs/helpers";
 import { commands } from "./commands/index.js";
 import { logError } from "./utils/errors.js";
 
+// Load .env file into process.env
+import * as dotenv from "dotenv";
+dotenv.config();
+
 yargs(hideBin(process.argv))
   // Explicit name to display in help (by default it's the entry file, which may not be "mud" for e.g. ts-node)
   .scriptName("mud")

package/src/render-solidity/common.ts

@@ -0,0 +1,138 @@
+import path from "path";
+import { ImportDatum, RenderTableOptions, RenderTableType, StaticResourceData } from "./types.js";
+
+export const renderedSolidityHeader = `// SPDX-License-Identifier: MIT
+pragma solidity >=0.8.0;
+
+/* Autogenerated file. Do not edit manually. */`;
+
+/**
+ * Renders a list of lines
+ */
+export function renderList<T>(list: T[], renderItem: (item: T, index: number) => string) {
+  return internalRenderList("", list, renderItem);
+}
+
+/**
+ * Renders a comma-separated list of arguments for solidity functions, ignoring empty and undefined ones
+ */
+export function renderArguments(args: (string | undefined)[]) {
+  const filteredArgs = args.filter((arg) => arg !== undefined && arg !== "") as string[];
+  return internalRenderList(",", filteredArgs, (arg) => arg);
+}
+
+export function renderCommonData({
+  staticResourceData,
+  primaryKeys,
+}: Pick<RenderTableOptions, "staticResourceData" | "primaryKeys">) {
+  // static resource means static tableId as well, and no tableId arguments
+  const _tableId = staticResourceData ? "" : "_tableId";
+  const _typedTableId = staticResourceData ? "" : "uint256 _tableId";
+
+  const _keyArgs = renderArguments(primaryKeys.map(({ name }) => name));
+  const _typedKeyArgs = renderArguments(primaryKeys.map(({ name, typeWithLocation }) => `${typeWithLocation} ${name}`));
+
+  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,
+  };
+}
+
+/** For 2 paths which are relative to a common root, create a relative import path from one to another */
+export function solidityRelativeImportPath(fromPath: string, usedInPath: string) {
+  // 1st "./" must be added because path strips it,
+  // but solidity expects it unless there's "../" ("./../" is fine).
+  // 2nd and 3rd "./" forcefully avoid absolute paths (everything is relative to `src`).
+  return "./" + path.relative("./" + usedInPath, "./" + fromPath);
+}
+
+/**
+ * Aggregates, deduplicates and renders imports for symbols per path.
+ * Identical symbols from different paths are NOT handled, they should be checked before rendering.
+ */
+export function renderImports(imports: ImportDatum[]) {
+  // Aggregate symbols by import path, also deduplicating them
+  const aggregatedImports = new Map<string, Set<string>>();
+  for (const { symbol, fromPath, usedInPath } of imports) {
+    const path = solidityRelativeImportPath(fromPath, usedInPath);
+    if (!aggregatedImports.has(path)) {
+      aggregatedImports.set(path, new Set());
+    }
+    aggregatedImports.get(path)?.add(symbol);
+  }
+  // Render imports
+  const renderedImports = [];
+  for (const [path, symbols] of aggregatedImports) {
+    const renderedSymbols = [...symbols].join(", ");
+    renderedImports.push(`import { ${renderedSymbols} } from "${path}";`);
+  }
+  return renderedImports.join("\n");
+}
+
+export function renderWithStore(
+  storeArgument: boolean,
+  callback: (
+    _typedStore: string | undefined,
+    _store: string,
+    _commentSuffix: string,
+    _untypedStore: string | undefined
+  ) => string
+) {
+  let result = "";
+  result += callback(undefined, "StoreSwitch", "", undefined);
+
+  if (storeArgument) {
+    result += "\n" + callback("IStore _store", "_store", " (using the specified store)", "_store");
+  }
+
+  return result;
+}
+
+export function renderTableId(staticResourceData: StaticResourceData) {
+  const hardcodedTableId = `uint256(bytes32(abi.encodePacked(bytes16("${staticResourceData.namespace}"), bytes16("${staticResourceData.fileSelector}"))))`;
+
+  const tableIdDefinition = `
+    uint256 constant _tableId = ${hardcodedTableId};
+    uint256 constant ${staticResourceData.tableIdName} = _tableId;
+  `;
+  return {
+    hardcodedTableId,
+    tableIdDefinition,
+  };
+}
+
+function renderValueTypeToBytes32(name: string, { staticByteLength, typeUnwrap, internalTypeId }: RenderTableType) {
+  const bits = staticByteLength * 8;
+  const innerText = `${typeUnwrap}(${name})`;
+
+  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<T>(lineTerminator: string, list: T[], renderItem: (item: T, index: number) => string) {
+  return list
+    .map((item, index) => renderItem(item, index) + (index === list.length - 1 ? "" : lineTerminator))
+    .join("\n");
+}

package/src/render-solidity/field.ts

@@ -0,0 +1,137 @@
+import { renderArguments, renderCommonData, renderWithStore } from "./common.js";
+import { RenderTableField, RenderTableOptions, RenderTableType } from "./types.js";
+
+export function renderFieldMethods(options: RenderTableOptions) {
+  const storeArgument = options.storeArgument;
+  const { _typedTableId, _typedKeyArgs, _primaryKeysDefinition } = renderCommonData(options);
+
+  let result = "";
+  for (const [index, field] of options.fields.entries()) {
+    const _typedFieldName = `${field.typeWithLocation} ${field.name}`;
+
+    result += 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)});
+      }
+    `
+    );
+
+    // TODO: this is super inefficient right now, need to add support for pushing to arrays to the store core library to avoid reading/writing the entire array
+    // (see https://github.com/latticexyz/mud/issues/438)
+    if (field.isDynamic) {
+      const portionData = fieldPortionData(field);
+
+      result += 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;
+}
+
+export function renderEncodeField(field: RenderTableField) {
+  let func;
+  if (field.arrayElement) {
+    func = "EncodeArray.encode";
+  } else if (field.isDynamic) {
+    func = "bytes";
+  } else {
+    func = "abi.encodePacked";
+  }
+  return `${func}(${field.typeUnwrap}(${field.name}))`;
+}
+
+export function renderDecodeValueType(field: RenderTableType, offset: number) {
+  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})`;
+}
+
+/** bytes/string are dynamic, but aren't really arrays */
+function fieldPortionData(field: RenderTableField) {
+  const methodNameSuffix = "";
+  if (field.arrayElement) {
+    const name = "_element";
+    return {
+      typeWithLocation: field.arrayElement.typeWithLocation,
+      name: "_element",
+      encoded: renderEncodeField({ ...field.arrayElement, arrayElement: undefined, 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: RenderTableField) {
+  const { isDynamic, arrayElement } = field;
+  if (arrayElement) {
+    // arrays
+    return `${field.typeWrap}(
+      SliceLib.getSubslice(_blob, 0, _blob.length).decodeArray_${arrayElement.internalTypeId}()
+    )`;
+  } else if (isDynamic) {
+    // bytes/string
+    return `${field.typeWrap}(${field.internalTypeId}(_blob))`;
+  } else {
+    return renderDecodeValueType(field, 0);
+  }
+}

package/src/render-solidity/index.ts

@@ -0,0 +1,10 @@
+export * from "./common.js";
+export * from "./field.js";
+export * from "./record.js";
+export * from "./renderTable.js";
+export * from "./renderTypes.js";
+export * from "./renderTypesFromConfig.js";
+export * from "./tablegen.js";
+export * from "./tableOptions.js";
+export * from "./types.js";
+export * from "./userType.js";

package/src/render-solidity/record.ts

@@ -0,0 +1,154 @@
+import { renderList, renderArguments, renderCommonData, renderWithStore } from "./common.js";
+import { renderDecodeValueType } from "./field.js";
+import { RenderTableDynamicField, RenderTableOptions } from "./types.js";
+
+export function renderRecordMethods(options: RenderTableOptions) {
+  const { 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 !== undefined) {
+    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;
+}
+
+// Renders the `decode` function that parses a bytes blob into the table data
+function renderDecodeFunction({ structName, fields, staticFields, dynamicFields }: RenderTableOptions) {
+  // either set struct properties, or just variables
+  const renderedDecodedRecord = structName
+    ? `${structName} memory _table`
+    : renderArguments(fields.map(({ name, typeWithLocation }) => `${typeWithLocation} ${name}`));
+  const fieldNamePrefix = structName ? "_table." : "";
+
+  // Static field offsets
+  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);
+    // decode static (optionally) and dynamic data
+    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 {
+    // decode only static data
+    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])};
+        `
+      )}
+    }
+    `;
+  }
+}
+
+// contents of `returns (...)` for record getter/decoder
+function renderDecodedRecord({ structName, fields }: RenderTableOptions) {
+  if (structName) {
+    return `${structName} memory _table`;
+  } else {
+    return renderArguments(fields.map(({ name, typeWithLocation }) => `${typeWithLocation} ${name}`));
+  }
+}
+
+function renderDecodeDynamicFieldPartial(field: RenderTableDynamicField) {
+  const { typeId, arrayElement, typeWrap } = field;
+  if (arrayElement) {
+    // arrays
+    return `${typeWrap}(
+      SliceLib.getSubslice(_blob, _start, _end).decodeArray_${arrayElement.typeId}()
+    )`;
+  } else {
+    // bytes/string
+    return `${typeWrap}(
+      ${typeId}(
+        SliceLib.getSubslice(_blob, _start, _end).toBytes()
+      )
+    )`;
+  }
+}

package/src/render-solidity/renderSystemInterface.ts

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