@latticexyz/cli 1.41.0 → 2.0.0-alpha.0

package/src/utils/typeUtils.ts

@@ -0,0 +1,17 @@
+import { AbiType, StaticAbiType } from "@latticexyz/schema-type";
+
+export type RequireKeys<T extends Record<string, unknown>, P extends string> = T & Required<Pick<T, P>>;
+
+// This allows unions between string literals and `string` without sacrificing autocompletion.
+// Workaround for https://github.com/Microsoft/TypeScript/issues/29729
+export type StringForUnion = string & Record<never, never>;
+
+export type StaticArray = `${StaticAbiType}[${number}]`;
+// static arrays and inferred enum names get mixed together - this helper separates them
+export type ExtractUserTypes<UnknownTypes extends StringForUnion> = Exclude<UnknownTypes, AbiType | StaticArray>;
+
+// When type inference sees multiple uses of 1 generic, it can only guess
+// which of those are supposed to define the generic (and it will be wrong in complex situations).
+// This helper explicitly makes a type that's dependent on some generic,
+// and will not be inferred as the generic's definition.
+export type AsDependent<T> = T extends infer P ? P : never;

package/dist/chunk-XRS7KWBZ.js

@@ -1,547 +0,0 @@
-import {
-  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;
-
-/* 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({ staticRouteData, primaryKeys }) {
-  const _tableId = staticRouteData ? "" : "_tableId";
-  const _typedTableId = staticRouteData ? "" : "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 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;
-  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 { _typedTableId, _typedKeyArgs, _primaryKeysDefinition } = renderCommonData(options);
-  let result = "";
-  for (const [index, field] of options.fields.entries()) {
-    const _typedFieldName = `${field.typeWithLocation} ${field.name}`;
-    result += `
-    /** Get ${field.name} */
-    function get${field.methodNameSuffix}(${renderArguments([
-      _typedTableId,
-      _typedKeyArgs
-    ])}) internal view returns (${_typedFieldName}) {
-      ${_primaryKeysDefinition}
-      bytes memory _blob = StoreSwitch.getField(_tableId, _primaryKeys, ${index});
-      return ${renderDecodeFieldSingle(field)};
-    }
-    `;
-    if (options.storeArgument) {
-      result += `
-      /** Get ${field.name} from the specified store */
-      function get${field.methodNameSuffix}(${renderArguments([
-        _typedTableId,
-        `IStore _store`,
-        _typedKeyArgs
-      ])}) internal view returns (${_typedFieldName}) {
-        ${_primaryKeysDefinition}
-        bytes memory _blob = _store.getField(_tableId, _primaryKeys, ${index});
-        return ${renderDecodeFieldSingle(field)};
-      }
-      `;
-    }
-    result += `
-    /** Set ${field.name} */
-    function set${field.methodNameSuffix}(${renderArguments([
-      _typedTableId,
-      _typedKeyArgs,
-      _typedFieldName
-    ])}) internal {
-      ${_primaryKeysDefinition}
-      StoreSwitch.setField(_tableId, _primaryKeys, ${index}, ${renderEncodeField(field)});
-    }
-    `;
-    if (field.isDynamic) {
-      const portionData = fieldPortionData(field);
-      result += `
-      /** Push ${portionData.title} to ${field.name} */
-      function push${field.methodNameSuffix}(${renderArguments([
-        _typedTableId,
-        _typedKeyArgs,
-        `${portionData.typeWithLocation} ${portionData.name}`
-      ])}) internal {
-        ${_primaryKeysDefinition}
-        bytes memory _blob = StoreSwitch.getField(_tableId, _primaryKeys, ${index});
-        bytes memory _newBlob = abi.encodePacked(_blob, ${portionData.encoded});
-        StoreSwitch.setField(_tableId, _primaryKeys, ${index}, _newBlob);
-      }
-      `;
-    }
-  }
-  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 { staticFields, dynamicFields, structName, storeArgument } = options;
-  const { _tableId, _typedTableId, _keyArgs, _typedKeyArgs, _primaryKeysDefinition } = renderCommonData(options);
-  let result = `
-  /** Get the full data */
-  function get(${renderArguments([_typedTableId, _typedKeyArgs])}) internal view returns (${renderDecodedRecord(
-    options
-  )}) {
-    ${_primaryKeysDefinition}
-    bytes memory _blob = StoreSwitch.getRecord(_tableId, _primaryKeys, getSchema());
-    return decode(_blob);
-  }
-  `;
-  if (storeArgument) {
-    result += `
-    /** Get the full data from the specified store */
-    function get(${renderArguments([
-      _typedTableId,
-      `IStore _store`,
-      _typedKeyArgs
-    ])}) internal view returns (${renderDecodedRecord(options)}) {
-      ${_primaryKeysDefinition}
-      bytes memory _blob = _store.getRecord(_tableId, _primaryKeys);
-      return decode(_blob);
-    }
-    `;
-  }
-  result += `
-  /** Set the full data using individual values */
-  function set(${renderArguments([
-    _typedTableId,
-    _typedKeyArgs,
-    renderArguments(options.fields.map(({ name, typeWithLocation }) => `${typeWithLocation} ${name}`))
-  ])}) internal {
-    ${renderEncodedLengths(dynamicFields)}
-    bytes memory _data = abi.encodePacked(${renderArguments([
-    renderArguments(staticFields.map(({ name }) => name)),
-    // TODO try gas optimization (preallocate for all, encodePacked statics, and direct encode dynamics)
-    // (see https://github.com/latticexyz/mud/issues/444)
-    ...dynamicFields.length === 0 ? [] : ["_encodedLengths.unwrap()", renderArguments(dynamicFields.map((field) => renderEncodeField(field)))]
-  ])});
-
-    ${_primaryKeysDefinition}
-
-    StoreSwitch.setRecord(_tableId, _primaryKeys, _data);
-  }
-  `;
-  if (structName !== void 0) {
-    result += `
-    /** Set the full data using the data struct */
-    function set(${renderArguments([_typedTableId, _typedKeyArgs, `${structName} memory _table`])}) internal {
-      set(${renderArguments([
-      _tableId,
-      _keyArgs,
-      renderArguments(options.fields.map(({ name }) => `_table.${name}`))
-    ])});
-    }
-    `;
-  }
-  result += 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 } = field;
-  if (arrayElement) {
-    return `SliceLib.getSubslice(_blob, _start, _end).decodeArray_${arrayElement.typeId}()`;
-  } else {
-    return `${typeId}(SliceLib.getSubslice(_blob, _start, _end).toBytes())`;
-  }
-}
-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/renderTable.ts
-function renderTable(options) {
-  const { imports, libraryName, structName, staticRouteData, storeImportPath, fields, withRecordMethods } = 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 { 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)}
-    ` : ""}
-
-${!staticRouteData ? "" : `
-      uint256 constant _tableId = uint256(keccak256("${staticRouteData.baseRoute + staticRouteData.subRoute}"));
-      uint256 constant ${staticRouteData.tableIdName} = _tableId;
-`}
-
-${!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);
-  }
-
-  /** 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)}
-
-${withRecordMethods ? renderRecordMethods(options) : ""}
-
-  /* Delete all data for given keys */
-  function deleteRecord(${renderArguments([_typedTableId, _typedKeyArgs])}) internal {
-    ${_primaryKeysDefinition}
-    StoreSwitch.deleteRecord(_tableId, _primaryKeys);
-  }
-}
-
-${// nothing can be cast to bool, so an assembly helper is required
-  !fields.some(({ typeId }) => typeId === "bool") ? "" : `
-  function _toBool(uint8 value) pure returns (bool result) {
-    assembly {
-      result := value
-    }
-  }
-`}
-
-${// nothing can be cast from bool, so an assembly helper is required
-  !options.primaryKeys.some(({ typeId }) => typeId === "bool") ? "" : `
-  function _boolToBytes32(bool value) pure returns (bytes32 result) {
-    assembly {
-      result := value
-    }
-  }
-`}
-
-`;
-}
-
-// 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 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 = {
-        ...renderTableType,
-        name,
-        isDynamic: false
-      };
-      return primaryKey;
-    });
-    const fields = Object.keys(tableData.schema).map((name) => {
-      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 = {
-        ...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 staticRouteData = (() => {
-      if (tableData.tableIdArgument) {
-        return;
-      } else {
-        return {
-          tableIdName: tableName + "TableId",
-          baseRoute: config.baseRoute,
-          subRoute: tableData.route
-        };
-      }
-    })();
-    renderedTables.push({
-      outputDirectory,
-      tableName,
-      tableData,
-      output: renderTable({
-        imports,
-        libraryName: tableName,
-        structName: withStruct ? tableName + "Data" : void 0,
-        staticRouteData,
-        storeImportPath,
-        primaryKeys,
-        fields,
-        staticFields,
-        dynamicFields,
-        withRecordMethods,
-        storeArgument: tableData.storeArgument
-      })
-    });
-  }
-  return renderedTables;
-}
-
-// src/constants.ts
-var deploymentInfoFilenamePrefix = "mud-deployment-";
-
-export {
-  renderedSolidityHeader,
-  renderList,
-  renderArguments,
-  renderTable,
-  renderTablesFromConfig,
-  deploymentInfoFilenamePrefix
-};