@latticexyz/world-module-erc20 2.2.13-main-23e6a6c97d94f85e163378148c51f51c900b3f8a

package/src/MUDERC20.sol

@@ -0,0 +1,326 @@
+// SPDX-License-Identifier: MIT
+// Adapted from OpenZeppelin Contracts [token/ERC20/ERC20.sol](https://github.com/OpenZeppelin/openzeppelin-contracts/blob/f989fff93168606c726bc5e831ef50dd6e543f45/contracts/token/ERC20/ERC20.sol)
+pragma solidity >=0.8.24;
+
+import { ResourceId } from "@latticexyz/store/src/ResourceId.sol";
+
+import { ERC20Metadata, ERC20MetadataData } from "./codegen/tables/ERC20Metadata.sol";
+import { TotalSupply } from "./codegen/tables/TotalSupply.sol";
+import { Balances } from "./codegen/tables/Balances.sol";
+import { Allowances } from "./codegen/tables/Allowances.sol";
+
+import { IERC20 } from "./interfaces/IERC20.sol";
+import { IERC20Metadata } from "./interfaces/IERC20Metadata.sol";
+import { IERC20Errors } from "./interfaces/IERC20Errors.sol";
+
+import { Context } from "./Context.sol";
+import { StoreConsumer } from "./StoreConsumer.sol";
+
+import { ERC20TableNames } from "./Constants.sol";
+
+abstract contract MUDERC20 is Context, IERC20, IERC20Metadata, IERC20Errors, StoreConsumer {
+  ResourceId internal immutable totalSupplyId;
+  ResourceId internal immutable balancesId;
+  ResourceId internal immutable allowancesId;
+  ResourceId internal immutable metadataId;
+
+  constructor(string memory _name, string memory _symbol) {
+    // Needs to be inlined in the constructor
+    totalSupplyId = _encodeTableId(ERC20TableNames.TOTAL_SUPPLY);
+    balancesId = _encodeTableId(ERC20TableNames.BALANCES);
+    allowancesId = _encodeTableId(ERC20TableNames.ALLOWANCES);
+    metadataId = _encodeTableId(ERC20TableNames.METADATA);
+
+    // Register each table
+    TotalSupply.register(totalSupplyId);
+    Balances.register(balancesId);
+    Allowances.register(allowancesId);
+    ERC20Metadata.register(metadataId);
+
+    _setMetadata(_name, _symbol, 18);
+  }
+
+  /**
+   * @dev Returns the name of the token.
+   */
+  function name() public view virtual returns (string memory) {
+    return _getName();
+  }
+
+  /**
+   * @dev Returns the symbol of the token, usually a shorter version of the
+   * name.
+   */
+  function symbol() public view virtual returns (string memory) {
+    return _getSymbol();
+  }
+
+  /**
+   * @dev Returns the number of decimals used to get its user representation.
+   * For example, if `decimals` equals `2`, a balance of `505` tokens should
+   * be displayed to a user as `5.05` (`505 / 10 ** 2`).
+   *
+   * Tokens usually opt for a value of 18, imitating the relationship between
+   * Ether and Wei. This is the default value returned by this function, unless
+   * it's overridden.
+   *
+   * NOTE: This information is only used for _display_ purposes: it in
+   * no way affects any of the arithmetic of the contract, including
+   * {IERC20-balanceOf} and {IERC20-transfer}.
+   */
+  function decimals() public view virtual returns (uint8) {
+    return _getDecimals();
+  }
+
+  /**
+   * @dev Returns the value of tokens in existence.
+   */
+  function totalSupply() public view returns (uint256) {
+    return _getTotalSupply();
+  }
+
+  /**
+   * @dev Returns the value of tokens owned by `account`.
+   */
+  function balanceOf(address account) public view returns (uint256) {
+    return _getBalance(account);
+  }
+
+  /**
+   * @dev Returns the remaining number of tokens that `spender` will be
+   * allowed to spend on behalf of `owner` through {transferFrom}. This is
+   * zero by default.
+   *
+   * This value changes when {approve} or {transferFrom} are called.
+   */
+  function allowance(address owner, address spender) public view returns (uint256) {
+    return _getAllowance(owner, spender);
+  }
+
+  /**
+   * @dev See {IERC20-transfer}.
+   *
+   * Requirements:
+   *
+   * - `to` cannot be the zero address.
+   * - the caller must have a balance of at least `value`.
+   */
+  function transfer(address to, uint256 value) public virtual returns (bool) {
+    address owner = _msgSender();
+    _transfer(owner, to, value);
+
+    return true;
+  }
+
+  /**
+   * @dev See {IERC20-approve}.
+   *
+   * NOTE: If `value` is the maximum `uint256`, the allowance is not updated on
+   * `transferFrom`. This is semantically equivalent to an infinite approval.
+   *
+   * Requirements:
+   *
+   * - `spender` cannot be the zero address.
+   */
+  function approve(address spender, uint256 value) public virtual returns (bool) {
+    address owner = _msgSender();
+    _approve(owner, spender, value, true);
+
+    return true;
+  }
+
+  /**
+   * @dev See {IERC20-transferFrom}.
+   *
+   * Emits an {Approval} event indicating the updated allowance. This is not
+   * required by the EIP. See the note at the beginning of {ERC20}.
+   *
+   * NOTE: Does not update the allowance if the current allowance
+   * is the maximum `uint256`.
+   *
+   * Requirements:
+   *
+   * - `from` and `to` cannot be the zero address.
+   * - `from` must have a balance of at least `value`.
+   * - the caller must have allowance for ``from``'s tokens of at least
+   * `value`.
+   */
+  function transferFrom(address from, address to, uint256 value) public virtual returns (bool) {
+    address spender = _msgSender();
+    _spendAllowance(from, spender, value);
+    _transfer(from, to, value);
+
+    return true;
+  }
+
+  /**
+   * @dev Creates a `value` amount of tokens and assigns them to `account`, by transferring it from address(0).
+   * Relies on the `_update` mechanism
+   *
+   * Emits a {Transfer} event with `from` set to the zero address.
+   */
+  function _mint(address account, uint256 value) internal {
+    if (account == address(0)) {
+      revert ERC20InvalidReceiver(address(0));
+    }
+
+    _update(address(0), account, value);
+  }
+
+  /**
+   * @dev Destroys a `value` amount of tokens from `account`, lowering the total supply.
+   * Relies on the `_update` mechanism.
+   *
+   * Emits a {Transfer} event with `to` set to the zero address.
+   *
+   * NOTE: This function is not virtual, {_update} should be overridden instead
+   */
+  function _burn(address account, uint256 value) internal {
+    if (account == address(0)) {
+      revert ERC20InvalidSender(address(0));
+    }
+
+    _update(account, address(0), value);
+  }
+
+  /**
+   * @dev Moves a `value` amount of tokens from `from` to `to`.
+   *
+   * This internal function is equivalent to {transfer}, and can be used to
+   * e.g. implement automatic token fees, slashing mechanisms, etc.
+   *
+   * Emits a {Transfer} event.
+   *
+   * NOTE: This function is not virtual, {_update} should be overridden instead.
+   */
+  function _transfer(address from, address to, uint256 value) internal {
+    if (from == address(0)) {
+      revert ERC20InvalidSender(address(0));
+    }
+    if (to == address(0)) {
+      revert ERC20InvalidReceiver(address(0));
+    }
+    _update(from, to, value);
+  }
+
+  /**
+   * @dev Transfers a `value` amount of tokens from `from` to `to`, or alternatively mints (or burns) if `from`
+   * (or `to`) is the zero address. All customizations to transfers, mints, and burns should be done by overriding
+   * this function.
+   *
+   * Emits a {Transfer} event.
+   */
+  function _update(address from, address to, uint256 value) internal virtual {
+    if (from == address(0)) {
+      // Overflow check required: The rest of the code assumes that totalSupply never overflows
+      _setTotalSupply(_getTotalSupply() + value);
+    } else {
+      uint256 fromBalance = _getBalance(from);
+      if (fromBalance < value) {
+        revert ERC20InsufficientBalance(from, fromBalance, value);
+      }
+      unchecked {
+        // Overflow not possible: value <= fromBalance <= totalSupply.
+        _setBalance(from, fromBalance - value);
+      }
+    }
+
+    if (to == address(0)) {
+      unchecked {
+        // Overflow not possible: value <= totalSupply or value <= fromBalance <= totalSupply.
+        _setTotalSupply(_getTotalSupply() - value);
+      }
+    } else {
+      unchecked {
+        // Overflow not possible: balance + value is at most totalSupply, which we know fits into a uint256.
+        _setBalance(to, _getBalance(to) + value);
+      }
+    }
+
+    emit Transfer(from, to, value);
+  }
+
+  /**
+   * @dev Sets `value` as the allowance of `spender` over the `owner`s tokens.
+   *
+   * Requirements:
+   *
+   * - `owner` cannot be the zero address.
+   * - `spender` cannot be the zero address.
+   */
+  function _approve(address owner, address spender, uint256 value, bool emitEvent) internal virtual {
+    if (owner == address(0)) {
+      revert ERC20InvalidApprover(address(0));
+    }
+    if (spender == address(0)) {
+      revert ERC20InvalidSpender(address(0));
+    }
+
+    _setAllowance(owner, spender, value);
+
+    if (emitEvent) {
+      emit Approval(owner, spender, value);
+    }
+  }
+
+  /**
+   * @dev Updates `owner` s allowance for `spender` based on spent `value`.
+   *
+   * Does not update the allowance value in case of infinite allowance.
+   * Revert if not enough allowance is available.
+   *
+   * Does not emit an {Approval} event.
+   */
+  function _spendAllowance(address owner, address spender, uint256 value) internal virtual {
+    uint256 currentAllowance = _getAllowance(owner, spender);
+    if (currentAllowance != type(uint256).max) {
+      if (currentAllowance < value) {
+        revert ERC20InsufficientAllowance(spender, currentAllowance, value);
+      }
+      unchecked {
+        _approve(owner, spender, currentAllowance - value, false);
+      }
+    }
+  }
+
+  function _getName() internal view returns (string memory) {
+    return ERC20Metadata.getName(metadataId);
+  }
+
+  function _getSymbol() internal view returns (string memory) {
+    return ERC20Metadata.getSymbol(metadataId);
+  }
+
+  function _getDecimals() internal view returns (uint8) {
+    return ERC20Metadata.getDecimals(metadataId);
+  }
+
+  function _getTotalSupply() internal view returns (uint256) {
+    return TotalSupply.get(totalSupplyId);
+  }
+
+  function _getBalance(address account) internal view returns (uint256) {
+    return Balances.get(balancesId, account);
+  }
+
+  function _getAllowance(address owner, address spender) internal view returns (uint256) {
+    return Allowances.get(allowancesId, owner, spender);
+  }
+
+  function _setTotalSupply(uint256 value) internal virtual {
+    TotalSupply.set(totalSupplyId, value);
+  }
+
+  function _setBalance(address account, uint256 value) internal virtual {
+    Balances.set(balancesId, account, value);
+  }
+
+  function _setAllowance(address owner, address spender, uint256 value) internal virtual {
+    Allowances.set(allowancesId, owner, spender, value);
+  }
+
+  function _setMetadata(string memory _name, string memory _symbol, uint8 _decimals) internal virtual {
+    ERC20MetadataData memory metadata = ERC20MetadataData(_decimals, _name, _symbol);
+    ERC20Metadata.set(metadataId, metadata);
+  }
+}

package/src/Ownable.sol

@@ -0,0 +1,110 @@
+// SPDX-License-Identifier: MIT
+// Adapted from OpenZeppelin Contracts [access/Ownable.sol](https://github.com/OpenZeppelin/openzeppelin-contracts/blob/f989fff93168606c726bc5e831ef50dd6e543f45/contracts/access/Ownable.sol)
+pragma solidity >=0.8.24;
+
+import { ResourceId } from "@latticexyz/store/src/ResourceId.sol";
+
+import { Owner } from "./codegen/tables/Owner.sol";
+import { StoreConsumer } from "./StoreConsumer.sol";
+import { Context } from "./Context.sol";
+import { OwnableTableNames } from "./Constants.sol";
+
+/**
+ * @dev Contract module which provides a basic access control mechanism, where
+ * there is an account (an owner) that can be granted exclusive access to
+ * specific functions.
+ *
+ * The initial owner is set to the address provided by the deployer. This can
+ * later be changed with {transferOwnership}.
+ *
+ * This module is used through inheritance. It will make available the modifier
+ * `onlyOwner`, which can be applied to your functions to restrict their use to
+ * the owner.
+ */
+abstract contract Ownable is Context, StoreConsumer {
+  ResourceId internal immutable ownerId;
+
+  /**
+   * @dev The caller account is not authorized to perform an operation.
+   */
+  error OwnableUnauthorizedAccount(address account);
+
+  /**
+   * @dev The owner is not a valid owner account. (eg. `address(0)`)
+   */
+  error OwnableInvalidOwner(address owner);
+
+  event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
+
+  /**
+   * @dev Initializes the contract setting the address provided by the deployer as the initial owner.
+   */
+  constructor(address initialOwner) {
+    if (initialOwner == address(0)) {
+      revert OwnableInvalidOwner(address(0));
+    }
+
+    ownerId = _encodeTableId(OwnableTableNames.OWNER);
+
+    // Register table
+    Owner.register(ownerId);
+
+    _transferOwnership(initialOwner);
+  }
+
+  /**
+   * @dev Throws if called by any account other than the owner.
+   */
+  modifier onlyOwner() {
+    _checkOwner();
+    _;
+  }
+
+  /**
+   * @dev Returns the address of the current owner.
+   */
+  function owner() public view virtual returns (address) {
+    return Owner.get(ownerId);
+  }
+
+  /**
+   * @dev Throws if the sender is not the owner.
+   */
+  function _checkOwner() internal view virtual {
+    if (owner() != _msgSender()) {
+      revert OwnableUnauthorizedAccount(_msgSender());
+    }
+  }
+
+  /**
+   * @dev Leaves the contract without owner. It will not be possible to call
+   * `onlyOwner` functions. Can only be called by the current owner.
+   *
+   * NOTE: Renouncing ownership will leave the contract without an owner,
+   * thereby disabling any functionality that is only available to the owner.
+   */
+  function renounceOwnership() public virtual onlyOwner {
+    _transferOwnership(address(0));
+  }
+
+  /**
+   * @dev Transfers ownership of the contract to a new account (`newOwner`).
+   * Can only be called by the current owner.
+   */
+  function transferOwnership(address newOwner) public virtual onlyOwner {
+    if (newOwner == address(0)) {
+      revert OwnableInvalidOwner(address(0));
+    }
+    _transferOwnership(newOwner);
+  }
+
+  /**
+   * @dev Transfers ownership of the contract to a new account (`newOwner`).
+   * Internal function without access restriction.
+   */
+  function _transferOwnership(address newOwner) internal virtual {
+    address oldOwner = owner();
+    Owner.set(ownerId, newOwner);
+    emit OwnershipTransferred(oldOwner, newOwner);
+  }
+}

package/src/Pausable.sol

@@ -0,0 +1,125 @@
+// SPDX-License-Identifier: MIT
+// Adapted from OpenZeppelin Contracts [utils/Pausable.sol](https://github.com/OpenZeppelin/openzeppelin-contracts/blob/f989fff93168606c726bc5e831ef50dd6e543f45/contracts/utils/Pausable.sol)
+pragma solidity >=0.8.24;
+
+import { ResourceId } from "@latticexyz/store/src/ResourceId.sol";
+
+import { Paused as PausedTable } from "./codegen/tables/Paused.sol";
+import { StoreConsumer } from "./StoreConsumer.sol";
+import { Context } from "./Context.sol";
+import { PausableTableNames } from "./Constants.sol";
+
+/**
+ * @dev Contract module which allows children to implement an emergency stop
+ * mechanism that can be triggered by an authorized account.
+ *
+ * This module is used through inheritance. It will make available the
+ * modifiers `whenNotPaused` and `whenPaused`, which can be applied to
+ * the functions of your contract. Note that they will not be pausable by
+ * simply including this module, only once the modifiers are put in place.
+ */
+abstract contract Pausable is Context, StoreConsumer {
+  ResourceId internal immutable pausedId;
+
+  /**
+   * @dev Emitted when the pause is triggered by `account`.
+   */
+  event Paused(address account);
+
+  /**
+   * @dev Emitted when the pause is lifted by `account`.
+   */
+  event Unpaused(address account);
+
+  /**
+   * @dev The operation failed because the contract is paused.
+   */
+  error EnforcedPause();
+
+  /**
+   * @dev The operation failed because the contract is not paused.
+   */
+  error ExpectedPause();
+
+  /**
+   * @dev Initializes the contract in unpaused state.
+   */
+  constructor() {
+    pausedId = _encodeTableId(PausableTableNames.PAUSED);
+    PausedTable.register(pausedId);
+    PausedTable.set(pausedId, false);
+  }
+
+  /**
+   * @dev Modifier to make a function callable only when the contract is not paused.
+   *
+   * Requirements:
+   *
+   * - The contract must not be paused.
+   */
+  modifier whenNotPaused() {
+    _requireNotPaused();
+    _;
+  }
+
+  /**
+   * @dev Modifier to make a function callable only when the contract is paused.
+   *
+   * Requirements:
+   *
+   * - The contract must be paused.
+   */
+  modifier whenPaused() {
+    _requirePaused();
+    _;
+  }
+
+  /**
+   * @dev Returns true if the contract is paused, and false otherwise.
+   */
+  function paused() public view virtual returns (bool) {
+    return PausedTable.get(pausedId);
+  }
+
+  /**
+   * @dev Throws if the contract is paused.
+   */
+  function _requireNotPaused() internal view virtual {
+    if (paused()) {
+      revert EnforcedPause();
+    }
+  }
+
+  /**
+   * @dev Throws if the contract is not paused.
+   */
+  function _requirePaused() internal view virtual {
+    if (!paused()) {
+      revert ExpectedPause();
+    }
+  }
+
+  /**
+   * @dev Triggers stopped state.
+   *
+   * Requirements:
+   *
+   * - The contract must not be paused.
+   */
+  function _pause() internal virtual whenNotPaused {
+    PausedTable.set(pausedId, true);
+    emit Paused(_msgSender());
+  }
+
+  /**
+   * @dev Returns to normal state.
+   *
+   * Requirements:
+   *
+   * - The contract must be paused.
+   */
+  function _unpause() internal virtual whenPaused {
+    PausedTable.set(pausedId, false);
+    emit Unpaused(_msgSender());
+  }
+}

package/src/StoreConsumer.sol

@@ -0,0 +1,24 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >=0.8.24;
+
+import { StoreSwitch } from "@latticexyz/store/src/StoreSwitch.sol";
+import { RESOURCE_TABLE, RESOURCE_OFFCHAIN_TABLE } from "@latticexyz/store/src/storeResourceTypes.sol";
+import { ResourceId } from "@latticexyz/store/src/ResourceId.sol";
+
+import { Context } from "./Context.sol";
+
+abstract contract StoreConsumer {
+  function getStore() public view returns (address) {
+    return StoreSwitch.getStoreAddress();
+  }
+
+  function _encodeResourceId(bytes2 typeId, bytes16 name) internal view virtual returns (ResourceId);
+
+  function _encodeTableId(bytes16 name) internal view returns (ResourceId) {
+    return _encodeResourceId(RESOURCE_TABLE, name);
+  }
+
+  function _encodeOffchainTableId(bytes16 name) internal view returns (ResourceId) {
+    return _encodeResourceId(RESOURCE_OFFCHAIN_TABLE, name);
+  }
+}

package/src/WithStore.sol

@@ -0,0 +1,22 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >=0.8.24;
+
+import { StoreCore } from "@latticexyz/store/src/Store.sol";
+import { StoreSwitch } from "@latticexyz/store/src/StoreSwitch.sol";
+import { ResourceId, ResourceIdLib } from "@latticexyz/store/src/ResourceId.sol";
+import { Context } from "./Context.sol";
+import { StoreConsumer } from "./StoreConsumer.sol";
+
+abstract contract WithStore is Context, StoreConsumer {
+  constructor(address store) {
+    StoreSwitch.setStoreAddress(store);
+
+    if (store == address(this)) {
+      StoreCore.registerInternalTables();
+    }
+  }
+
+  function _encodeResourceId(bytes2 typeId, bytes16 name) internal view virtual override returns (ResourceId) {
+    return ResourceIdLib.encode(typeId, name);
+  }
+}

package/src/WithWorld.sol

@@ -0,0 +1,40 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >=0.8.24;
+
+import { ResourceId } from "@latticexyz/store/src/ResourceId.sol";
+import { ResourceAccess } from "@latticexyz/world/src/codegen/tables/ResourceAccess.sol";
+import { IBaseWorld } from "@latticexyz/world/src/codegen/interfaces/IBaseWorld.sol";
+import { WorldResourceIdLib } from "@latticexyz/world/src/WorldResourceId.sol";
+
+import { WithStore } from "./WithStore.sol";
+
+abstract contract WithWorld is WithStore {
+  bytes14 public immutable namespace;
+
+  error WithWorld_CallerHasNoNamespaceAccess();
+
+  modifier onlyNamespace() {
+    address sender = _msgSender();
+    if (!ResourceAccess.get(getNamespaceId(), sender)) {
+      revert WithWorld_CallerHasNoNamespaceAccess();
+    }
+    _;
+  }
+
+  constructor(IBaseWorld world, bytes14 _namespace) WithStore(address(world)) {
+    namespace = _namespace;
+
+    ResourceId namespaceId = getNamespaceId();
+
+    // This will revert if namespace already exists
+    world.registerNamespace(namespaceId);
+  }
+
+  function getNamespaceId() public view returns (ResourceId) {
+    return WorldResourceIdLib.encodeNamespace(namespace);
+  }
+
+  function _encodeResourceId(bytes2 typeId, bytes16 name) internal view virtual override returns (ResourceId) {
+    return WorldResourceIdLib.encode(typeId, namespace, name);
+  }
+}

package/src/codegen/index.sol

@@ -0,0 +1,12 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >=0.8.24;
+
+/* Autogenerated file. Do not edit manually. */
+
+import { Owner } from "./tables/Owner.sol";
+import { ERC20Metadata, ERC20MetadataData } from "./tables/ERC20Metadata.sol";
+import { TotalSupply } from "./tables/TotalSupply.sol";
+import { Balances } from "./tables/Balances.sol";
+import { Allowances } from "./tables/Allowances.sol";
+import { Paused } from "./tables/Paused.sol";
+import { ERC20Registry } from "./tables/ERC20Registry.sol";