@latticexyz/world-modules 2.0.12-type-resolutions-effc7ab1 → 2.0.12-type-resolutions-ad8cc987

package/src/modules/erc20-puppet/IERC20Errors.sol

@@ -0,0 +1,49 @@
+// SPDX-License-Identifier: MIT
+// OpenZeppelin Contracts (last updated v5.0.0) (interfaces/draft-IERC6093.sol)
+pragma solidity >=0.8.24;
+
+/**
+ * @dev Standard ERC20 Errors
+ * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC20 tokens.
+ */
+interface IERC20Errors {
+  /**
+   * @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers.
+   * @param sender Address whose tokens are being transferred.
+   * @param balance Current balance for the interacting account.
+   * @param needed Minimum amount required to perform a transfer.
+   */
+  error ERC20InsufficientBalance(address sender, uint256 balance, uint256 needed);
+
+  /**
+   * @dev Indicates a failure with the token `sender`. Used in transfers.
+   * @param sender Address whose tokens are being transferred.
+   */
+  error ERC20InvalidSender(address sender);
+
+  /**
+   * @dev Indicates a failure with the token `receiver`. Used in transfers.
+   * @param receiver Address to which tokens are being transferred.
+   */
+  error ERC20InvalidReceiver(address receiver);
+
+  /**
+   * @dev Indicates a failure with the `spender`’s `allowance`. Used in transfers.
+   * @param spender Address that may be allowed to operate on tokens without being their owner.
+   * @param allowance Amount of tokens a `spender` is allowed to operate with.
+   * @param needed Minimum amount required to perform a transfer.
+   */
+  error ERC20InsufficientAllowance(address spender, uint256 allowance, uint256 needed);
+
+  /**
+   * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
+   * @param approver Address initiating an approval operation.
+   */
+  error ERC20InvalidApprover(address approver);
+
+  /**
+   * @dev Indicates a failure with the `spender` to be approved. Used in approvals.
+   * @param spender Address that may be allowed to operate on tokens without being their owner.
+   */
+  error ERC20InvalidSpender(address spender);
+}

package/src/modules/erc20-puppet/IERC20Events.sol

@@ -0,0 +1,18 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >=0.8.24;
+
+interface IERC20Events {
+  /**
+   * @dev Emitted when `value` tokens are moved from one account (`from`) to
+   * another (`to`).
+   *
+   * Note that `value` may be zero.
+   */
+  event Transfer(address indexed from, address indexed to, uint256 value);
+
+  /**
+   * @dev Emitted when the allowance of a `spender` for an `owner` is set by
+   * a call to {approve}. `value` is the new allowance.
+   */
+  event Approval(address indexed owner, address indexed spender, uint256 value);
+}

package/src/modules/erc20-puppet/IERC20Mintable.sol

@@ -0,0 +1,25 @@
+// SPDX-License-Identifier: MIT
+// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/IERC20.sol)
+
+pragma solidity >=0.8.24;
+
+import { IERC20 } from "./IERC20.sol";
+
+/**
+ * @dev Extending the ERC20 standard with permissioned mint and burn functions.
+ */
+interface IERC20Mintable is IERC20 {
+  /**
+   * @dev Creates a `value` amount of tokens and assigns them to `account`, by transferring it from address(0).
+   *
+   * Emits a {Transfer} event with `from` set to the zero address.
+   */
+  function mint(address account, uint256 value) external;
+
+  /**
+   * @dev Destroys a `value` amount of tokens from `account`, lowering the total supply.
+   *
+   * Emits a {Transfer} event with `to` set to the zero address.
+   */
+  function burn(address account, uint256 value) external;
+}

package/src/modules/erc20-puppet/constants.sol

@@ -0,0 +1,20 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >=0.8.24;
+import { ResourceId } from "@latticexyz/store/src/ResourceId.sol";
+import { RESOURCE_TABLE } from "@latticexyz/store/src/storeResourceTypes.sol";
+import { RESOURCE_SYSTEM, RESOURCE_NAMESPACE } from "@latticexyz/world/src/worldResourceTypes.sol";
+
+bytes14 constant MODULE_NAMESPACE = "erc20-puppet";
+ResourceId constant MODULE_NAMESPACE_ID = ResourceId.wrap(
+  bytes32(abi.encodePacked(RESOURCE_NAMESPACE, MODULE_NAMESPACE))
+);
+
+bytes16 constant ALLOWANCES_NAME = "Allowances";
+bytes16 constant BALANCES_NAME = "Balances";
+bytes16 constant TOTAL_SUPPLY_NAME = "TotalSupply";
+bytes16 constant METADATA_NAME = "Metadata";
+bytes16 constant ERC20_SYSTEM_NAME = "ERC20System";
+
+ResourceId constant ERC20_REGISTRY_TABLE_ID = ResourceId.wrap(
+  bytes32(abi.encodePacked(RESOURCE_TABLE, MODULE_NAMESPACE, bytes16("ERC20Registry")))
+);

package/src/modules/erc20-puppet/registerERC20.sol

@@ -0,0 +1,35 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >=0.8.24;
+
+import { IBaseWorld } from "@latticexyz/world/src/codegen/interfaces/IBaseWorld.sol";
+import { NamespaceOwner } from "@latticexyz/world/src/codegen/tables/NamespaceOwner.sol";
+import { WorldResourceIdLib } from "@latticexyz/world/src/WorldResourceId.sol";
+
+import { ERC20Module } from "./ERC20Module.sol";
+import { MODULE_NAMESPACE_ID, ERC20_REGISTRY_TABLE_ID } from "./constants.sol";
+import { IERC20Mintable } from "./IERC20Mintable.sol";
+
+import { ERC20MetadataData } from "./tables/ERC20Metadata.sol";
+import { ERC20Registry } from "./tables/ERC20Registry.sol";
+
+/**
+ * @notice Register a new ERC20 token with the given metadata in a given namespace
+ * @dev This function must be called within a Store context (i.e. using StoreSwitch.setStoreAddress())
+ */
+function registerERC20(
+  IBaseWorld world,
+  bytes14 namespace,
+  ERC20MetadataData memory metadata
+) returns (IERC20Mintable token) {
+  // Get the ERC20 module
+  ERC20Module erc20Module = ERC20Module(NamespaceOwner.get(MODULE_NAMESPACE_ID));
+  if (address(erc20Module) == address(0)) {
+    erc20Module = new ERC20Module();
+  }
+
+  // Install the ERC20 module with the provided args
+  world.installModule(erc20Module, abi.encode(namespace, metadata));
+
+  // Return the newly created ERC20 token
+  token = IERC20Mintable(ERC20Registry.get(ERC20_REGISTRY_TABLE_ID, WorldResourceIdLib.encodeNamespace(namespace)));
+}

package/src/modules/erc20-puppet/tables/Allowances.sol

@@ -0,0 +1,208 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >=0.8.24;
+
+/* Autogenerated file. Do not edit manually. */
+
+// Import store internals
+import { IStore } from "@latticexyz/store/src/IStore.sol";
+import { StoreSwitch } from "@latticexyz/store/src/StoreSwitch.sol";
+import { StoreCore } from "@latticexyz/store/src/StoreCore.sol";
+import { Bytes } from "@latticexyz/store/src/Bytes.sol";
+import { Memory } from "@latticexyz/store/src/Memory.sol";
+import { SliceLib } from "@latticexyz/store/src/Slice.sol";
+import { EncodeArray } from "@latticexyz/store/src/tightcoder/EncodeArray.sol";
+import { FieldLayout } from "@latticexyz/store/src/FieldLayout.sol";
+import { Schema } from "@latticexyz/store/src/Schema.sol";
+import { EncodedLengths, EncodedLengthsLib } from "@latticexyz/store/src/EncodedLengths.sol";
+import { ResourceId } from "@latticexyz/store/src/ResourceId.sol";
+
+library Allowances {
+  FieldLayout constant _fieldLayout =
+    FieldLayout.wrap(0x0020010020000000000000000000000000000000000000000000000000000000);
+
+  // Hex-encoded key schema of (address, address)
+  Schema constant _keySchema = Schema.wrap(0x0028020061610000000000000000000000000000000000000000000000000000);
+  // Hex-encoded value schema of (uint256)
+  Schema constant _valueSchema = Schema.wrap(0x002001001f000000000000000000000000000000000000000000000000000000);
+
+  /**
+   * @notice Get the table's key field names.
+   * @return keyNames An array of strings with the names of key fields.
+   */
+  function getKeyNames() internal pure returns (string[] memory keyNames) {
+    keyNames = new string[](2);
+    keyNames[0] = "account";
+    keyNames[1] = "spender";
+  }
+
+  /**
+   * @notice Get the table's value field names.
+   * @return fieldNames An array of strings with the names of value fields.
+   */
+  function getFieldNames() internal pure returns (string[] memory fieldNames) {
+    fieldNames = new string[](1);
+    fieldNames[0] = "value";
+  }
+
+  /**
+   * @notice Register the table with its config.
+   */
+  function register(ResourceId _tableId) internal {
+    StoreSwitch.registerTable(_tableId, _fieldLayout, _keySchema, _valueSchema, getKeyNames(), getFieldNames());
+  }
+
+  /**
+   * @notice Register the table with its config.
+   */
+  function _register(ResourceId _tableId) internal {
+    StoreCore.registerTable(_tableId, _fieldLayout, _keySchema, _valueSchema, getKeyNames(), getFieldNames());
+  }
+
+  /**
+   * @notice Get value.
+   */
+  function getValue(ResourceId _tableId, address account, address spender) internal view returns (uint256 value) {
+    bytes32[] memory _keyTuple = new bytes32[](2);
+    _keyTuple[0] = bytes32(uint256(uint160(account)));
+    _keyTuple[1] = bytes32(uint256(uint160(spender)));
+
+    bytes32 _blob = StoreSwitch.getStaticField(_tableId, _keyTuple, 0, _fieldLayout);
+    return (uint256(bytes32(_blob)));
+  }
+
+  /**
+   * @notice Get value.
+   */
+  function _getValue(ResourceId _tableId, address account, address spender) internal view returns (uint256 value) {
+    bytes32[] memory _keyTuple = new bytes32[](2);
+    _keyTuple[0] = bytes32(uint256(uint160(account)));
+    _keyTuple[1] = bytes32(uint256(uint160(spender)));
+
+    bytes32 _blob = StoreCore.getStaticField(_tableId, _keyTuple, 0, _fieldLayout);
+    return (uint256(bytes32(_blob)));
+  }
+
+  /**
+   * @notice Get value.
+   */
+  function get(ResourceId _tableId, address account, address spender) internal view returns (uint256 value) {
+    bytes32[] memory _keyTuple = new bytes32[](2);
+    _keyTuple[0] = bytes32(uint256(uint160(account)));
+    _keyTuple[1] = bytes32(uint256(uint160(spender)));
+
+    bytes32 _blob = StoreSwitch.getStaticField(_tableId, _keyTuple, 0, _fieldLayout);
+    return (uint256(bytes32(_blob)));
+  }
+
+  /**
+   * @notice Get value.
+   */
+  function _get(ResourceId _tableId, address account, address spender) internal view returns (uint256 value) {
+    bytes32[] memory _keyTuple = new bytes32[](2);
+    _keyTuple[0] = bytes32(uint256(uint160(account)));
+    _keyTuple[1] = bytes32(uint256(uint160(spender)));
+
+    bytes32 _blob = StoreCore.getStaticField(_tableId, _keyTuple, 0, _fieldLayout);
+    return (uint256(bytes32(_blob)));
+  }
+
+  /**
+   * @notice Set value.
+   */
+  function setValue(ResourceId _tableId, address account, address spender, uint256 value) internal {
+    bytes32[] memory _keyTuple = new bytes32[](2);
+    _keyTuple[0] = bytes32(uint256(uint160(account)));
+    _keyTuple[1] = bytes32(uint256(uint160(spender)));
+
+    StoreSwitch.setStaticField(_tableId, _keyTuple, 0, abi.encodePacked((value)), _fieldLayout);
+  }
+
+  /**
+   * @notice Set value.
+   */
+  function _setValue(ResourceId _tableId, address account, address spender, uint256 value) internal {
+    bytes32[] memory _keyTuple = new bytes32[](2);
+    _keyTuple[0] = bytes32(uint256(uint160(account)));
+    _keyTuple[1] = bytes32(uint256(uint160(spender)));
+
+    StoreCore.setStaticField(_tableId, _keyTuple, 0, abi.encodePacked((value)), _fieldLayout);
+  }
+
+  /**
+   * @notice Set value.
+   */
+  function set(ResourceId _tableId, address account, address spender, uint256 value) internal {
+    bytes32[] memory _keyTuple = new bytes32[](2);
+    _keyTuple[0] = bytes32(uint256(uint160(account)));
+    _keyTuple[1] = bytes32(uint256(uint160(spender)));
+
+    StoreSwitch.setStaticField(_tableId, _keyTuple, 0, abi.encodePacked((value)), _fieldLayout);
+  }
+
+  /**
+   * @notice Set value.
+   */
+  function _set(ResourceId _tableId, address account, address spender, uint256 value) internal {
+    bytes32[] memory _keyTuple = new bytes32[](2);
+    _keyTuple[0] = bytes32(uint256(uint160(account)));
+    _keyTuple[1] = bytes32(uint256(uint160(spender)));
+
+    StoreCore.setStaticField(_tableId, _keyTuple, 0, abi.encodePacked((value)), _fieldLayout);
+  }
+
+  /**
+   * @notice Delete all data for given keys.
+   */
+  function deleteRecord(ResourceId _tableId, address account, address spender) internal {
+    bytes32[] memory _keyTuple = new bytes32[](2);
+    _keyTuple[0] = bytes32(uint256(uint160(account)));
+    _keyTuple[1] = bytes32(uint256(uint160(spender)));
+
+    StoreSwitch.deleteRecord(_tableId, _keyTuple);
+  }
+
+  /**
+   * @notice Delete all data for given keys.
+   */
+  function _deleteRecord(ResourceId _tableId, address account, address spender) internal {
+    bytes32[] memory _keyTuple = new bytes32[](2);
+    _keyTuple[0] = bytes32(uint256(uint160(account)));
+    _keyTuple[1] = bytes32(uint256(uint160(spender)));
+
+    StoreCore.deleteRecord(_tableId, _keyTuple, _fieldLayout);
+  }
+
+  /**
+   * @notice Tightly pack static (fixed length) data using this table's schema.
+   * @return The static data, encoded into a sequence of bytes.
+   */
+  function encodeStatic(uint256 value) internal pure returns (bytes memory) {
+    return abi.encodePacked(value);
+  }
+
+  /**
+   * @notice Encode all of a record's fields.
+   * @return The static (fixed length) data, encoded into a sequence of bytes.
+   * @return The lengths of the dynamic fields (packed into a single bytes32 value).
+   * @return The dynamic (variable length) data, encoded into a sequence of bytes.
+   */
+  function encode(uint256 value) internal pure returns (bytes memory, EncodedLengths, bytes memory) {
+    bytes memory _staticData = encodeStatic(value);
+
+    EncodedLengths _encodedLengths;
+    bytes memory _dynamicData;
+
+    return (_staticData, _encodedLengths, _dynamicData);
+  }
+
+  /**
+   * @notice Encode keys as a bytes32 array using this table's field layout.
+   */
+  function encodeKeyTuple(address account, address spender) internal pure returns (bytes32[] memory) {
+    bytes32[] memory _keyTuple = new bytes32[](2);
+    _keyTuple[0] = bytes32(uint256(uint160(account)));
+    _keyTuple[1] = bytes32(uint256(uint160(spender)));
+
+    return _keyTuple;
+  }
+}