@latticexyz/world-module-erc20 2.2.20-b774ab28b3de6cefcbfce5e1bb6fcb68b9374abf → 2.2.20-b7901812d4035faa3ec9bb75f31ffe7af398bdf2

package/src/examples/ERC20WithInternalStore.sol

@@ -0,0 +1,32 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >=0.8.24;
+
+// Adapted example from OpenZeppelin's Contract Wizard: https://wizard.openzeppelin.com/
+
+import { WithStore } from "@latticexyz/store-consumer/src/experimental/WithStore.sol";
+import { Ownable } from "../experimental/Ownable.sol";
+import { ERC20Pausable } from "../experimental/ERC20Pausable.sol";
+import { ERC20Burnable } from "../experimental/ERC20Burnable.sol";
+import { MUDERC20 } from "../experimental/MUDERC20.sol";
+
+contract ERC20WithInternalStore is WithStore(address(this)), MUDERC20, ERC20Pausable, ERC20Burnable, Ownable {
+  constructor() MUDERC20("MyERC20", "MTK") Ownable(_msgSender()) {}
+
+  function mint(address to, uint256 value) public onlyOwner {
+    _mint(to, value);
+  }
+
+  function pause() public onlyOwner {
+    _pause();
+  }
+
+  function unpause() public onlyOwner {
+    _unpause();
+  }
+
+  // The following functions are overrides required by Solidity.
+
+  function _update(address from, address to, uint256 value) internal override(MUDERC20, ERC20Pausable) {
+    super._update(from, to, value);
+  }
+}

package/src/examples/{ERC20PausableBurnable.sol → ERC20WithWorld.sol}

@@ -5,21 +5,22 @@ pragma solidity >=0.8.24;
 
 import { ResourceId } from "@latticexyz/store/src/ResourceId.sol";
 import { IBaseWorld } from "@latticexyz/world/src/codegen/interfaces/IBaseWorld.sol";
-import { WorldConsumer } from "@latticexyz/world-consumer/src/experimental/WorldConsumer.sol";
+import { WithWorld } from "@latticexyz/store-consumer/src/experimental/WithWorld.sol";
+import { Context } from "@latticexyz/store-consumer/src/experimental/Context.sol";
 
 import { ERC20Pausable } from "../experimental/ERC20Pausable.sol";
 import { ERC20Burnable } from "../experimental/ERC20Burnable.sol";
 import { MUDERC20 } from "../experimental/MUDERC20.sol";
 
-contract ERC20PausableBurnable is MUDERC20, ERC20Pausable, ERC20Burnable {
+contract ERC20WithWorld is WithWorld, MUDERC20, ERC20Pausable, ERC20Burnable {
   constructor(
     IBaseWorld world,
     bytes14 namespace,
     string memory name,
     string memory symbol
-  ) WorldConsumer(world, namespace, true) MUDERC20(name, symbol) {
+  ) WithWorld(world, namespace, true) MUDERC20(name, symbol) {
     // Transfer namespace ownership to the creator
-    world.transferOwnership(namespaceId, _msgSender());
+    world.transferOwnership(getNamespaceId(), _msgSender());
   }
 
   function mint(address to, uint256 value) public onlyNamespace {
@@ -36,6 +37,10 @@ contract ERC20PausableBurnable is MUDERC20, ERC20Pausable, ERC20Burnable {
 
   // The following functions are overrides required by Solidity.
 
+  function _msgSender() public view override(Context, WithWorld) returns (address sender) {
+    return WithWorld._msgSender();
+  }
+
   function _update(address from, address to, uint256 value) internal override(MUDERC20, ERC20Pausable) {
     super._update(from, to, value);
   }

package/src/experimental/ERC20Module.sol

@@ -11,14 +11,14 @@ import { IBaseWorld } from "@latticexyz/world/src/codegen/interfaces/IBaseWorld.
 import { revertWithBytes } from "@latticexyz/world/src/revertWithBytes.sol";
 
 import { ERC20Registry } from "../codegen/tables/ERC20Registry.sol";
-import { ERC20PausableBurnable } from "../examples/ERC20PausableBurnable.sol";
+import { ERC20WithWorld } from "../examples/ERC20WithWorld.sol";
 import { ModuleConstants } from "./Constants.sol";
 
 contract ERC20Module is Module {
   error ERC20Module_InvalidNamespace(bytes14 namespace);
   error ERC20Module_NamespaceAlreadyExists(bytes14 namespace);
 
-  function install(bytes memory encodedArgs) public override {
+  function install(bytes memory encodedArgs) public {
     // TODO: we should probably check just for namespace, not for all args
     requireNotInstalled(__self, encodedArgs);
 
@@ -39,7 +39,7 @@ contract ERC20Module is Module {
 
     IBaseWorld world = IBaseWorld(_world());
 
-    ERC20PausableBurnable token = new ERC20PausableBurnable(world, namespace, name, symbol);
+    ERC20WithWorld token = new ERC20WithWorld(world, namespace, name, symbol);
 
     // Grant access to the token so it can write to tables after transferring ownership
     world.grantAccess(namespaceId, address(token));
@@ -52,6 +52,10 @@ contract ERC20Module is Module {
 
     ERC20RegistryLib.register(world, namespaceId, address(token));
   }
+
+  function installRoot(bytes memory) public pure {
+    revert Module_RootInstallNotSupported();
+  }
 }
 
 library ERC20RegistryLib {

package/src/experimental/MUDERC20.sol

@@ -3,9 +3,8 @@
 pragma solidity >=0.8.24;
 
 import { ResourceId } from "@latticexyz/store/src/ResourceId.sol";
-import { WorldConsumer } from "@latticexyz/world-consumer/src/experimental/WorldConsumer.sol";
-import { WorldResourceIdLib } from "@latticexyz/world/src/WorldResourceId.sol";
-import { RESOURCE_TABLE } from "@latticexyz/store/src/storeResourceTypes.sol";
+import { StoreConsumer } from "@latticexyz/store-consumer/src/experimental/StoreConsumer.sol";
+import { Context } from "@latticexyz/store-consumer/src/experimental/Context.sol";
 
 import { ERC20Metadata, ERC20MetadataData } from "../codegen/tables/ERC20Metadata.sol";
 import { TotalSupply } from "../codegen/tables/TotalSupply.sol";
@@ -18,7 +17,7 @@ import { IERC20Errors } from "../interfaces/IERC20Errors.sol";
 
 import { ERC20TableNames } from "./Constants.sol";
 
-abstract contract MUDERC20 is IERC20, IERC20Metadata, IERC20Errors, WorldConsumer {
+abstract contract MUDERC20 is Context, IERC20, IERC20Metadata, IERC20Errors, StoreConsumer {
   ResourceId internal immutable totalSupplyId;
   ResourceId internal immutable balancesId;
   ResourceId internal immutable allowancesId;
@@ -26,10 +25,10 @@ abstract contract MUDERC20 is IERC20, IERC20Metadata, IERC20Errors, WorldConsume
 
   constructor(string memory _name, string memory _symbol) {
     // Needs to be inlined in the constructor
-    totalSupplyId = WorldResourceIdLib.encode(RESOURCE_TABLE, namespace, ERC20TableNames.TOTAL_SUPPLY);
-    balancesId = WorldResourceIdLib.encode(RESOURCE_TABLE, namespace, ERC20TableNames.BALANCES);
-    allowancesId = WorldResourceIdLib.encode(RESOURCE_TABLE, namespace, ERC20TableNames.ALLOWANCES);
-    metadataId = WorldResourceIdLib.encode(RESOURCE_TABLE, namespace, ERC20TableNames.METADATA);
+    totalSupplyId = _encodeTableId(ERC20TableNames.TOTAL_SUPPLY);
+    balancesId = _encodeTableId(ERC20TableNames.BALANCES);
+    allowancesId = _encodeTableId(ERC20TableNames.ALLOWANCES);
+    metadataId = _encodeTableId(ERC20TableNames.METADATA);
 
     // Register each table
     TotalSupply.register(totalSupplyId);

package/src/experimental/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 { StoreConsumer } from "@latticexyz/store-consumer/src/experimental/StoreConsumer.sol";
+import { Context } from "@latticexyz/store-consumer/src/experimental/Context.sol";
+
+import { Owner } from "../codegen/tables/Owner.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/experimental/Pausable.sol

@@ -2,10 +2,9 @@
 // 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 { RESOURCE_TABLE } from "@latticexyz/store/src/storeResourceTypes.sol";
 import { ResourceId } from "@latticexyz/store/src/ResourceId.sol";
-import { WorldResourceIdLib } from "@latticexyz/world/src/WorldResourceId.sol";
-import { WorldConsumer } from "@latticexyz/world-consumer/src/experimental/WorldConsumer.sol";
+import { StoreConsumer } from "@latticexyz/store-consumer/src/experimental/StoreConsumer.sol";
+import { Context } from "@latticexyz/store-consumer/src/experimental/Context.sol";
 
 import { Paused as PausedTable } from "../codegen/tables/Paused.sol";
 import { PausableTableNames } from "./Constants.sol";
@@ -19,7 +18,7 @@ import { PausableTableNames } from "./Constants.sol";
  * 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 WorldConsumer {
+abstract contract Pausable is Context, StoreConsumer {
   ResourceId internal immutable pausedId;
 
   /**
@@ -46,7 +45,7 @@ abstract contract Pausable is WorldConsumer {
    * @dev Initializes the contract in unpaused state.
    */
   constructor() {
-    pausedId = WorldResourceIdLib.encode(RESOURCE_TABLE, namespace, PausableTableNames.PAUSED);
+    pausedId = _encodeTableId(PausableTableNames.PAUSED);
     PausedTable.register(pausedId);
     PausedTable.set(pausedId, false);
   }