@latticexyz/world-modules 2.0.12-type-resolutions-effc7ab1 → 2.0.12-type-resolutions-8538f80e

package/src/modules/puppet/Puppet.sol

@@ -0,0 +1,80 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >=0.8.24;
+
+import { StoreSwitch } from "@latticexyz/store/src/StoreSwitch.sol";
+import { ResourceId } from "@latticexyz/store/src/ResourceId.sol";
+import { IBaseWorld } from "@latticexyz/world/src/codegen/interfaces/IBaseWorld.sol";
+import { Systems } from "@latticexyz/world/src/codegen/tables/Systems.sol";
+
+contract Puppet {
+  error Puppet_AccessDenied(address caller);
+
+  IBaseWorld public immutable world;
+  ResourceId public immutable systemId;
+
+  constructor(IBaseWorld _world, ResourceId _systemId) {
+    world = _world;
+    systemId = _systemId;
+    StoreSwitch.setStoreAddress(address(_world));
+  }
+
+  modifier onlyPuppetMaster() {
+    (address systemAddress, ) = Systems.get(systemId);
+    if (msg.sender != systemAddress) {
+      revert Puppet_AccessDenied(msg.sender);
+    }
+    _;
+  }
+
+  fallback() external {
+    // Forward all calls to the system in the world
+    bytes memory returnData = world.callFrom(msg.sender, systemId, msg.data);
+
+    // If the call was successful, return the return data
+    assembly {
+      return(add(returnData, 0x20), mload(returnData))
+    }
+  }
+
+  /**
+   * @dev Log an event with a signature and no additional topic
+   */
+  function log(bytes32 eventSignature, bytes memory eventData) public onlyPuppetMaster {
+    assembly {
+      log1(add(eventData, 0x20), mload(eventData), eventSignature)
+    }
+  }
+
+  /**
+   * @dev Log an event with a signature and one additional topics
+   */
+  function log(bytes32 eventSignature, bytes32 topic1, bytes memory eventData) public onlyPuppetMaster {
+    assembly {
+      log2(add(eventData, 0x20), mload(eventData), eventSignature, topic1)
+    }
+  }
+
+  /**
+   * @dev Log an event with a signature and two additional topics
+   */
+  function log(bytes32 eventSignature, bytes32 topic1, bytes32 topic2, bytes memory eventData) public onlyPuppetMaster {
+    assembly {
+      log3(add(eventData, 0x20), mload(eventData), eventSignature, topic1, topic2)
+    }
+  }
+
+  /**
+   * @dev Log an event with a signature and three additional topics
+   */
+  function log(
+    bytes32 eventSignature,
+    bytes32 topic1,
+    bytes32 topic2,
+    bytes32 topic3,
+    bytes memory eventData
+  ) public onlyPuppetMaster {
+    assembly {
+      log4(add(eventData, 0x20), mload(eventData), eventSignature, topic1, topic2, topic3)
+    }
+  }
+}

package/src/modules/puppet/PuppetDelegationControl.sol

@@ -0,0 +1,17 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >=0.8.24;
+
+import { DelegationControl } from "@latticexyz/world/src/DelegationControl.sol";
+import { ResourceId } from "@latticexyz/world/src/WorldResourceId.sol";
+import { PuppetRegistry } from "./tables/PuppetRegistry.sol";
+import { PUPPET_TABLE_ID } from "./constants.sol";
+
+contract PuppetDelegationControl is DelegationControl {
+  /**
+   * Verify a delegation by checking if the resourceId maps to the caller as puppet
+   */
+  function verify(address, ResourceId systemId, bytes memory) public view returns (bool) {
+    address puppet = _msgSender();
+    return PuppetRegistry.get(PUPPET_TABLE_ID, systemId) == puppet;
+  }
+}

package/src/modules/puppet/PuppetFactorySystem.sol

@@ -0,0 +1,25 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >=0.8.24;
+
+import { ResourceId } from "@latticexyz/store/src/ResourceId.sol";
+import { System } from "@latticexyz/world/src/System.sol";
+import { IBaseWorld } from "@latticexyz/world/src/codegen/interfaces/IBaseWorld.sol";
+
+import { AccessControlLib } from "../../utils/AccessControlLib.sol";
+
+import { PuppetRegistry } from "./tables/PuppetRegistry.sol";
+import { Puppet } from "./Puppet.sol";
+import { PUPPET_TABLE_ID } from "./constants.sol";
+
+contract PuppetFactorySystem is System {
+  function createPuppet(ResourceId systemId) public returns (address puppet) {
+    // Only the owner of a system can create a puppet for it
+    AccessControlLib.requireOwner(systemId, _msgSender());
+
+    // Deploy a new puppet contract
+    puppet = address(new Puppet(IBaseWorld(_world()), systemId));
+
+    // Register the puppet
+    PuppetRegistry.set(PUPPET_TABLE_ID, systemId, puppet);
+  }
+}

package/src/modules/puppet/PuppetMaster.sol

@@ -0,0 +1,19 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >=0.8.24;
+
+import { ResourceId } from "@latticexyz/store/src/ResourceId.sol";
+import { SystemRegistry } from "@latticexyz/world/src/codegen/tables/SystemRegistry.sol";
+import { PuppetRegistry } from "./tables/PuppetRegistry.sol";
+import { PUPPET_TABLE_ID } from "./constants.sol";
+import { Puppet } from "./Puppet.sol";
+
+contract PuppetMaster {
+  error PuppetMaster_NoPuppet(address systemAddress, ResourceId systemId);
+
+  function puppet() internal view returns (Puppet) {
+    ResourceId systemId = SystemRegistry.getSystemId(address(this));
+    address puppetAddress = PuppetRegistry.get(PUPPET_TABLE_ID, systemId);
+    if (puppetAddress == address(0)) revert PuppetMaster_NoPuppet(address(this), systemId);
+    return Puppet(puppetAddress);
+  }
+}

package/src/modules/puppet/PuppetModule.sol

@@ -0,0 +1,64 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >=0.8.24;
+
+import { IBaseWorld } from "@latticexyz/world/src/codegen/interfaces/IBaseWorld.sol";
+import { Module } from "@latticexyz/world/src/Module.sol";
+import { revertWithBytes } from "@latticexyz/world/src/revertWithBytes.sol";
+import { WorldResourceIdInstance } from "@latticexyz/world/src/WorldResourceId.sol";
+
+import { ResourceId } from "@latticexyz/store/src/ResourceId.sol";
+
+import { PuppetFactorySystem } from "./PuppetFactorySystem.sol";
+import { PuppetDelegationControl } from "./PuppetDelegationControl.sol";
+import { PUPPET_DELEGATION, PUPPET_FACTORY, PUPPET_TABLE_ID, NAMESPACE_ID } from "./constants.sol";
+
+import { PuppetRegistry } from "./tables/PuppetRegistry.sol";
+
+/**
+ * This module registers tables and delegation control systems required for puppet delegations
+ */
+contract PuppetModule is Module {
+  using WorldResourceIdInstance for ResourceId;
+
+  PuppetDelegationControl private immutable puppetDelegationControl = new PuppetDelegationControl();
+  PuppetFactorySystem private immutable puppetFactorySystem = new PuppetFactorySystem();
+
+  function installRoot(bytes memory) public {
+    IBaseWorld world = IBaseWorld(_world());
+
+    // Register namespace
+    (bool success, bytes memory returnData) = address(world).delegatecall(
+      abi.encodeCall(world.registerNamespace, (NAMESPACE_ID))
+    );
+    if (!success) revertWithBytes(returnData);
+
+    // Register table
+    PuppetRegistry.register(PUPPET_TABLE_ID);
+
+    // Register puppet factory
+    (success, returnData) = address(world).delegatecall(
+      abi.encodeCall(world.registerSystem, (PUPPET_FACTORY, puppetFactorySystem, true))
+    );
+    if (!success) revertWithBytes(returnData);
+
+    // Register puppet delegation control
+    (success, returnData) = address(world).delegatecall(
+      abi.encodeCall(world.registerSystem, (PUPPET_DELEGATION, puppetDelegationControl, true))
+    );
+    if (!success) revertWithBytes(returnData);
+  }
+
+  function install(bytes memory) public {
+    IBaseWorld world = IBaseWorld(_world());
+
+    // Register namespace
+    world.registerNamespace(NAMESPACE_ID);
+
+    // Register table
+    PuppetRegistry.register(PUPPET_TABLE_ID);
+
+    // Register puppet factory and delegation control
+    world.registerSystem(PUPPET_FACTORY, puppetFactorySystem, true);
+    world.registerSystem(PUPPET_DELEGATION, puppetDelegationControl, true);
+  }
+}

package/src/modules/puppet/constants.sol

@@ -0,0 +1,23 @@
+// 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";
+import { ROOT_NAMESPACE } from "@latticexyz/world/src/constants.sol";
+
+bytes14 constant NAMESPACE = bytes14("puppet");
+
+ResourceId constant NAMESPACE_ID = ResourceId.wrap(bytes32(abi.encodePacked(RESOURCE_NAMESPACE, NAMESPACE)));
+
+ResourceId constant PUPPET_DELEGATION = ResourceId.wrap(
+  bytes32(abi.encodePacked(RESOURCE_SYSTEM, NAMESPACE, bytes16("Delegation")))
+);
+
+ResourceId constant PUPPET_FACTORY = ResourceId.wrap(
+  bytes32(abi.encodePacked(RESOURCE_SYSTEM, NAMESPACE, bytes16("Factory")))
+);
+
+ResourceId constant PUPPET_TABLE_ID = ResourceId.wrap(
+  bytes32(abi.encodePacked(RESOURCE_TABLE, NAMESPACE, bytes16("PuppetRegistry")))
+);

package/src/modules/puppet/createPuppet.sol

@@ -0,0 +1,24 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >=0.8.24;
+
+import { ResourceId } from "@latticexyz/store/src/ResourceId.sol";
+import { IBaseWorld } from "@latticexyz/world/src/codegen/interfaces/IBaseWorld.sol";
+import { WorldResourceIdInstance } from "@latticexyz/world/src/WorldResourceId.sol";
+import { PUPPET_DELEGATION, PUPPET_FACTORY } from "./constants.sol";
+import { PuppetDelegationControl } from "./PuppetDelegationControl.sol";
+import { Puppet } from "./Puppet.sol";
+import { PuppetFactorySystem } from "./PuppetFactorySystem.sol";
+
+using WorldResourceIdInstance for ResourceId;
+
+/**
+ * This free function can be used to create a puppet and register it with the puppet delegation control.
+ * Since it is inlined in the caller's context, the calls originate from the caller's address.
+ */
+function createPuppet(IBaseWorld world, ResourceId systemId) returns (address puppet) {
+  puppet = abi.decode(
+    world.call(PUPPET_FACTORY, abi.encodeCall(PuppetFactorySystem.createPuppet, (systemId))),
+    (address)
+  );
+  world.registerNamespaceDelegation(systemId.getNamespaceId(), PUPPET_DELEGATION, new bytes(0));
+}

package/src/modules/puppet/tables/PuppetRegistry.sol

@@ -0,0 +1,199 @@
+// 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";
+
+// Import user types
+import { ResourceId } from "@latticexyz/store/src/ResourceId.sol";
+
+library PuppetRegistry {
+  FieldLayout constant _fieldLayout =
+    FieldLayout.wrap(0x0014010014000000000000000000000000000000000000000000000000000000);
+
+  // Hex-encoded key schema of (bytes32)
+  Schema constant _keySchema = Schema.wrap(0x002001005f000000000000000000000000000000000000000000000000000000);
+  // Hex-encoded value schema of (address)
+  Schema constant _valueSchema = Schema.wrap(0x0014010061000000000000000000000000000000000000000000000000000000);
+
+  /**
+   * @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[](1);
+    keyNames[0] = "systemId";
+  }
+
+  /**
+   * @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] = "puppet";
+  }
+
+  /**
+   * @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 puppet.
+   */
+  function getPuppet(ResourceId _tableId, ResourceId systemId) internal view returns (address puppet) {
+    bytes32[] memory _keyTuple = new bytes32[](1);
+    _keyTuple[0] = ResourceId.unwrap(systemId);
+
+    bytes32 _blob = StoreSwitch.getStaticField(_tableId, _keyTuple, 0, _fieldLayout);
+    return (address(bytes20(_blob)));
+  }
+
+  /**
+   * @notice Get puppet.
+   */
+  function _getPuppet(ResourceId _tableId, ResourceId systemId) internal view returns (address puppet) {
+    bytes32[] memory _keyTuple = new bytes32[](1);
+    _keyTuple[0] = ResourceId.unwrap(systemId);
+
+    bytes32 _blob = StoreCore.getStaticField(_tableId, _keyTuple, 0, _fieldLayout);
+    return (address(bytes20(_blob)));
+  }
+
+  /**
+   * @notice Get puppet.
+   */
+  function get(ResourceId _tableId, ResourceId systemId) internal view returns (address puppet) {
+    bytes32[] memory _keyTuple = new bytes32[](1);
+    _keyTuple[0] = ResourceId.unwrap(systemId);
+
+    bytes32 _blob = StoreSwitch.getStaticField(_tableId, _keyTuple, 0, _fieldLayout);
+    return (address(bytes20(_blob)));
+  }
+
+  /**
+   * @notice Get puppet.
+   */
+  function _get(ResourceId _tableId, ResourceId systemId) internal view returns (address puppet) {
+    bytes32[] memory _keyTuple = new bytes32[](1);
+    _keyTuple[0] = ResourceId.unwrap(systemId);
+
+    bytes32 _blob = StoreCore.getStaticField(_tableId, _keyTuple, 0, _fieldLayout);
+    return (address(bytes20(_blob)));
+  }
+
+  /**
+   * @notice Set puppet.
+   */
+  function setPuppet(ResourceId _tableId, ResourceId systemId, address puppet) internal {
+    bytes32[] memory _keyTuple = new bytes32[](1);
+    _keyTuple[0] = ResourceId.unwrap(systemId);
+
+    StoreSwitch.setStaticField(_tableId, _keyTuple, 0, abi.encodePacked((puppet)), _fieldLayout);
+  }
+
+  /**
+   * @notice Set puppet.
+   */
+  function _setPuppet(ResourceId _tableId, ResourceId systemId, address puppet) internal {
+    bytes32[] memory _keyTuple = new bytes32[](1);
+    _keyTuple[0] = ResourceId.unwrap(systemId);
+
+    StoreCore.setStaticField(_tableId, _keyTuple, 0, abi.encodePacked((puppet)), _fieldLayout);
+  }
+
+  /**
+   * @notice Set puppet.
+   */
+  function set(ResourceId _tableId, ResourceId systemId, address puppet) internal {
+    bytes32[] memory _keyTuple = new bytes32[](1);
+    _keyTuple[0] = ResourceId.unwrap(systemId);
+
+    StoreSwitch.setStaticField(_tableId, _keyTuple, 0, abi.encodePacked((puppet)), _fieldLayout);
+  }
+
+  /**
+   * @notice Set puppet.
+   */
+  function _set(ResourceId _tableId, ResourceId systemId, address puppet) internal {
+    bytes32[] memory _keyTuple = new bytes32[](1);
+    _keyTuple[0] = ResourceId.unwrap(systemId);
+
+    StoreCore.setStaticField(_tableId, _keyTuple, 0, abi.encodePacked((puppet)), _fieldLayout);
+  }
+
+  /**
+   * @notice Delete all data for given keys.
+   */
+  function deleteRecord(ResourceId _tableId, ResourceId systemId) internal {
+    bytes32[] memory _keyTuple = new bytes32[](1);
+    _keyTuple[0] = ResourceId.unwrap(systemId);
+
+    StoreSwitch.deleteRecord(_tableId, _keyTuple);
+  }
+
+  /**
+   * @notice Delete all data for given keys.
+   */
+  function _deleteRecord(ResourceId _tableId, ResourceId systemId) internal {
+    bytes32[] memory _keyTuple = new bytes32[](1);
+    _keyTuple[0] = ResourceId.unwrap(systemId);
+
+    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(address puppet) internal pure returns (bytes memory) {
+    return abi.encodePacked(puppet);
+  }
+
+  /**
+   * @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(address puppet) internal pure returns (bytes memory, EncodedLengths, bytes memory) {
+    bytes memory _staticData = encodeStatic(puppet);
+
+    EncodedLengths _encodedLengths;
+    bytes memory _dynamicData;
+
+    return (_staticData, _encodedLengths, _dynamicData);
+  }
+
+  /**
+   * @notice Encode keys as a bytes32 array using this table's field layout.
+   */
+  function encodeKeyTuple(ResourceId systemId) internal pure returns (bytes32[] memory) {
+    bytes32[] memory _keyTuple = new bytes32[](1);
+    _keyTuple[0] = ResourceId.unwrap(systemId);
+
+    return _keyTuple;
+  }
+}

package/src/modules/puppet/utils.sol

@@ -0,0 +1,10 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >=0.8.24;
+
+function toTopic(address value) pure returns (bytes32) {
+  return bytes32(uint256(uint160(value)));
+}
+
+function toTopic(uint256 value) pure returns (bytes32) {
+  return bytes32(value);
+}

package/src/modules/std-delegations/CallboundDelegationControl.sol

@@ -0,0 +1,64 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >=0.8.24;
+
+import { DelegationControl } from "@latticexyz/world/src/DelegationControl.sol";
+import { ResourceId } from "@latticexyz/world/src/WorldResourceId.sol";
+import { CallboundDelegations } from "./tables/CallboundDelegations.sol";
+
+contract CallboundDelegationControl is DelegationControl {
+  /**
+   * Verify a delegation by checking if the delegator has any available calls left in the CallboundDelegations table and decrementing the available calls if so.
+   */
+  function verify(address delegator, ResourceId systemId, bytes memory callData) public returns (bool) {
+    bytes32 callDataHash = keccak256(callData);
+
+    // Get the number of available calls for the given delegator, systemId and callData
+    uint256 availableCalls = CallboundDelegations.get({
+      delegator: delegator,
+      delegatee: _msgSender(),
+      systemId: systemId,
+      callDataHash: callDataHash
+    });
+
+    if (availableCalls == 1) {
+      // Remove the delegation from the CallboundDelegations table
+      CallboundDelegations.deleteRecord({
+        delegator: delegator,
+        delegatee: _msgSender(),
+        systemId: systemId,
+        callDataHash: callDataHash
+      });
+      return true;
+    }
+
+    if (availableCalls > 0) {
+      // Decrement the number of available calls
+      unchecked {
+        availableCalls--;
+      }
+      CallboundDelegations.set({
+        delegator: delegator,
+        delegatee: _msgSender(),
+        systemId: systemId,
+        callDataHash: callDataHash,
+        availableCalls: availableCalls
+      });
+      return true;
+    }
+
+    return false;
+  }
+
+  /**
+   * Initialize a delegation by setting the number of available calls in the CallboundDelegations table
+   */
+  function initDelegation(address delegatee, ResourceId systemId, bytes memory callData, uint256 numCalls) public {
+    CallboundDelegations.set({
+      delegator: _msgSender(),
+      delegatee: delegatee,
+      systemId: systemId,
+      callDataHash: keccak256(callData),
+      availableCalls: numCalls
+    });
+  }
+}

package/src/modules/std-delegations/StandardDelegationsModule.sol

@@ -0,0 +1,55 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >=0.8.24;
+
+import { IBaseWorld } from "@latticexyz/world/src/codegen/interfaces/IBaseWorld.sol";
+
+import { Module } from "@latticexyz/world/src/Module.sol";
+import { WorldContextConsumer } from "@latticexyz/world/src/WorldContext.sol";
+import { revertWithBytes } from "@latticexyz/world/src/revertWithBytes.sol";
+
+import { CallboundDelegationControl } from "./CallboundDelegationControl.sol";
+import { SystemboundDelegationControl } from "./SystemboundDelegationControl.sol";
+import { TimeboundDelegationControl } from "./TimeboundDelegationControl.sol";
+import { CALLBOUND_DELEGATION, SYSTEMBOUND_DELEGATION, TIMEBOUND_DELEGATION } from "./constants.sol";
+
+import { CallboundDelegations } from "./tables/CallboundDelegations.sol";
+import { SystemboundDelegations } from "./tables/SystemboundDelegations.sol";
+import { TimeboundDelegations } from "./tables/TimeboundDelegations.sol";
+
+/**
+ * This module registers tables and delegation control systems required for standard delegations
+ */
+contract StandardDelegationsModule is Module {
+  CallboundDelegationControl private immutable callboundDelegationControl = new CallboundDelegationControl();
+  SystemboundDelegationControl private immutable systemboundDelegationControl = new SystemboundDelegationControl();
+  TimeboundDelegationControl private immutable timeboundDelegationControl = new TimeboundDelegationControl();
+
+  function installRoot(bytes memory) public {
+    IBaseWorld world = IBaseWorld(_world());
+
+    // Register tables
+    CallboundDelegations.register();
+    SystemboundDelegations.register();
+    TimeboundDelegations.register();
+
+    // Register systems
+    (bool success, bytes memory returnData) = address(world).delegatecall(
+      abi.encodeCall(world.registerSystem, (CALLBOUND_DELEGATION, callboundDelegationControl, true))
+    );
+    if (!success) revertWithBytes(returnData);
+
+    (success, returnData) = address(world).delegatecall(
+      abi.encodeCall(world.registerSystem, (SYSTEMBOUND_DELEGATION, systemboundDelegationControl, true))
+    );
+    if (!success) revertWithBytes(returnData);
+
+    (success, returnData) = address(world).delegatecall(
+      abi.encodeCall(world.registerSystem, (TIMEBOUND_DELEGATION, timeboundDelegationControl, true))
+    );
+    if (!success) revertWithBytes(returnData);
+  }
+
+  function install(bytes memory) public pure {
+    revert Module_NonRootInstallNotSupported();
+  }
+}

package/src/modules/std-delegations/SystemboundDelegationControl.sol

@@ -0,0 +1,54 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >=0.8.24;
+
+import { DelegationControl } from "@latticexyz/world/src/DelegationControl.sol";
+import { ResourceId } from "@latticexyz/world/src/WorldResourceId.sol";
+import { SystemboundDelegations } from "./tables/SystemboundDelegations.sol";
+
+contract SystemboundDelegationControl is DelegationControl {
+  /**
+   * Verify a delegation by checking if the caller (delegatee) has any available calls left for the given delegator in the SystemboundDelegations table and decrementing the available calls if so.
+   */
+  function verify(address delegator, ResourceId systemId, bytes memory) public returns (bool) {
+    // Get the number of available calls for the given delegator, systemId and callData
+    uint256 availableCalls = SystemboundDelegations.get({
+      delegator: delegator,
+      delegatee: _msgSender(),
+      systemId: systemId
+    });
+
+    if (availableCalls == 1) {
+      // Remove the delegation from the SystemboundDelegations table
+      SystemboundDelegations.deleteRecord({ delegator: delegator, delegatee: _msgSender(), systemId: systemId });
+      return true;
+    }
+
+    if (availableCalls > 0) {
+      // Decrement the number of available calls
+      unchecked {
+        availableCalls--;
+      }
+      SystemboundDelegations.set({
+        delegator: delegator,
+        delegatee: _msgSender(),
+        systemId: systemId,
+        availableCalls: availableCalls
+      });
+      return true;
+    }
+
+    return false;
+  }
+
+  /**
+   * Initialize a delegation by setting the number of available calls in the SystemboundDelegations table
+   */
+  function initDelegation(address delegatee, ResourceId systemId, uint256 numCalls) public {
+    SystemboundDelegations.set({
+      delegator: _msgSender(),
+      delegatee: delegatee,
+      systemId: systemId,
+      availableCalls: numCalls
+    });
+  }
+}

package/src/modules/std-delegations/TimeboundDelegationControl.sol

@@ -0,0 +1,27 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >=0.8.24;
+
+import { DelegationControl } from "@latticexyz/world/src/DelegationControl.sol";
+import { ResourceId } from "@latticexyz/world/src/WorldResourceId.sol";
+import { TimeboundDelegations } from "./tables/TimeboundDelegations.sol";
+
+contract TimeboundDelegationControl is DelegationControl {
+  /**
+   * Verify a delegation by checking if the current block timestamp is not larger than the max valid timestamp for the delegation.
+   * Note: the delegation control check ignores the systemId and callData parameters.
+   */
+  function verify(address delegator, ResourceId, bytes memory) public view returns (bool) {
+    // Get the max valid timestamp for the given delegator
+    uint256 maxTimestamp = TimeboundDelegations.get({ delegator: delegator, delegatee: _msgSender() });
+
+    // Return true if the current timestamp is smaller or equal to the max valid timestamp
+    return block.timestamp <= maxTimestamp;
+  }
+
+  /**
+   * Initialize a delegation by setting the max valid timestamp in the TimeboundDelegations table
+   */
+  function initDelegation(address delegatee, uint256 maxTimestamp) public {
+    TimeboundDelegations.set({ delegator: _msgSender(), delegatee: delegatee, maxTimestamp: maxTimestamp });
+  }
+}