feat: optional system hooks feature; function that gets triggered on unregister of a delegation

Author: dhvanipa

packages/cli/src/deploy/getWorldContracts.ts

@@ -2,6 +2,7 @@ import accessManagementSystemBuild from "@latticexyz/world/out/AccessManagementS
 import balanceTransferSystemBuild from "@latticexyz/world/out/BalanceTransferSystem.sol/BalanceTransferSystem.json" assert { type: "json" };
 import batchCallSystemBuild from "@latticexyz/world/out/BatchCallSystem.sol/BatchCallSystem.json" assert { type: "json" };
 import registrationSystemBuild from "@latticexyz/world/out/RegistrationSystem.sol/RegistrationSystem.json" assert { type: "json" };
+import extendedRegistrationSystemBuild from "@latticexyz/world/out/ExtendedRegistrationSystem.sol/ExtendedRegistrationSystem.json" assert { type: "json" };
 import initModuleBuild from "@latticexyz/world/out/InitModule.sol/InitModule.json" assert { type: "json" };
 import initModuleAbi from "@latticexyz/world/out/InitModule.sol/InitModule.abi.json" assert { type: "json" };
 import { Hex, encodeDeployData, size } from "viem";
@@ -33,11 +34,18 @@ export function getWorldContracts(deployerAddress: Hex) {
     bytecode: registrationBytecode,
   });
 
+  const extendedRegistrationDeployedBytecodeSize = size(extendedRegistrationSystemBuild.deployedBytecode.object as Hex);
+  const extendedRegistrationBytecode = extendedRegistrationSystemBuild.bytecode.object as Hex;
+  const extendedRegistration = getContractAddress({
+    deployerAddress,
+    bytecode: extendedRegistrationBytecode,
+  });
+
   const initModuleDeployedBytecodeSize = size(initModuleBuild.deployedBytecode.object as Hex);
   const initModuleBytecode = encodeDeployData({
     bytecode: initModuleBuild.bytecode.object as Hex,
     abi: initModuleAbi,
-    args: [accessManagementSystem, balanceTransferSystem, batchCallSystem, registration],
+    args: [accessManagementSystem, balanceTransferSystem, batchCallSystem, registration, extendedRegistration],
   });
   const initModule = getContractAddress({ deployerAddress, bytecode: initModuleBytecode });
 
@@ -66,6 +74,12 @@ export function getWorldContracts(deployerAddress: Hex) {
       debugLabel: "core registration system",
       address: registration,
     },
+    ExtendedRegistrationSystem: {
+      bytecode: extendedRegistrationBytecode,
+      deployedBytecodeSize: extendedRegistrationDeployedBytecodeSize,
+      debugLabel: "extended core registration system",
+      address: extendedRegistration,
+    },
     InitModule: {
       bytecode: initModuleBytecode,
       deployedBytecodeSize: initModuleDeployedBytecodeSize,

packages/world/mud.config.ts

@@ -44,6 +44,9 @@ export const configInput = {
         delegationControlId: "ResourceId",
       },
       key: ["delegator", "delegatee"],
+      codegen: {
+        storeArgument: true,
+      },
     },
     NamespaceDelegationControl: {
       schema: {
@@ -84,6 +87,18 @@ export const configInput = {
       },
       key: ["systemId"],
     },
+    OptionalSystemHooks: {
+      schema: {
+        player: "address",
+        systemId: "ResourceId",
+        callDataHash: "bytes32",
+        hooks: "bytes21[]",
+      },
+      key: ["player", "systemId", "callDataHash"],
+      codegen: {
+        storeArgument: true,
+      },
+    },
     FunctionSelectors: {
       schema: {
         worldFunctionSelector: "bytes4",

packages/world/src/ICustomUnregisterDelegation.sol

@@ -0,0 +1,8 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >=0.8.24;
+
+import { IERC165 } from "./IERC165.sol";
+
+interface ICustomUnregisterDelegation is IERC165 {
+  function canUnregister(address delegator) external returns (bool);
+}

packages/world/src/IOptionalSystemHook.sol

@@ -0,0 +1,43 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >=0.8.24;
+
+import { ResourceId } from "@latticexyz/store/src/ResourceId.sol";
+import { ISystemHook } from "./ISystemHook.sol";
+
+/**
+ * @title IOptionalSystemHook
+ * @dev Interface defining optional hooks for external functionality.
+ * Provides pre and post hooks that can be triggered before and after a system call respectively.
+ * This interface adheres to the ERC-165 standard for determining interface support.
+ */
+interface IOptionalSystemHook is ISystemHook {
+  /**
+   * @notice Executes when a system hook is registered by the user.
+   * @dev Provides the ability to add custom logic or checks when a system hook is registered.
+   * @param msgSender The original sender of the system call.
+   * @param systemId The ID of the system
+   * @param enabledHooksBitmap Bitmap indicating which hooks are enabled
+   * @param callDataHash The hash of the call data for the system hook
+   */
+  function onRegisterHook(
+    address msgSender,
+    ResourceId systemId,
+    uint8 enabledHooksBitmap,
+    bytes32 callDataHash
+  ) external;
+
+  /**
+   * @notice Executes when a system hook is unregistered by the user.
+   * @dev Provides the ability to add custom logic or checks when a system hook is unregistered.
+   * @param msgSender The original sender of the system call.
+   * @param systemId The ID of the system
+   * @param enabledHooksBitmap Bitmap indicating which hooks are enabled
+   * @param callDataHash The hash of the call data for the system hook
+   */
+  function onUnregisterHook(
+    address msgSender,
+    ResourceId systemId,
+    uint8 enabledHooksBitmap,
+    bytes32 callDataHash
+  ) external;
+}

packages/world/src/IWorldErrors.sol

@@ -80,6 +80,12 @@ interface IWorldErrors {
    */
   error World_UnlimitedDelegationNotAllowed();
 
+  /**
+   * @notice Raised when unregister delegation is called but a custom unregister delegation blocks it
+   * e.g. if the delegation agreement wanted to enforce some conditions before allowing the delegation to be removed
+   */
+  error World_CustomUnregisterDelegationNotAllowed();
+
   /**
    * @notice Raised when there's an insufficient balance for a particular operation.
    * @param balance The current balance.
@@ -107,4 +113,12 @@ interface IWorldErrors {
    * @param functionSelector The function selector of the disallowed callback.
    */
   error World_CallbackNotAllowed(bytes4 functionSelector);
+
+  /**
+   * @notice  Raised when trying to register an optional system hook that is already registered.
+   * @param systemId The ID of the system.
+   * @param hookAddress The address of the hook.
+   * @param callDataHash The hash of the call data.
+   */
+  error World_OptionalHookAlreadyRegistered(ResourceId systemId, address hookAddress, bytes32 callDataHash);
 }

packages/world/src/SystemCall.sol

@@ -12,9 +12,11 @@ import { BEFORE_CALL_SYSTEM, AFTER_CALL_SYSTEM } from "./systemHookTypes.sol";
 
 import { IWorldErrors } from "./IWorldErrors.sol";
 import { ISystemHook } from "./ISystemHook.sol";
+import { IOptionalSystemHook } from "./IOptionalSystemHook.sol";
 
 import { Systems } from "./codegen/tables/Systems.sol";
 import { SystemHooks } from "./codegen/tables/SystemHooks.sol";
+import { OptionalSystemHooks } from "./codegen/tables/OptionalSystemHooks.sol";
 import { Balances } from "./codegen/tables/Balances.sol";
 
 /**
@@ -145,6 +147,10 @@ library SystemCall {
     // Get system hooks
     bytes21[] memory hooks = SystemHooks._get(systemId);
 
+    // Get optional hooks specified by the caller
+    bytes21[] memory optionalSystemHooks = OptionalSystemHooks._get(caller, systemId, bytes32(0));
+    bytes21[] memory optionalSystemHooksWithCallData = OptionalSystemHooks._get(caller, systemId, keccak256(callData));
+
     // Call onBeforeCallSystem hooks (before calling the system)
     for (uint256 i; i < hooks.length; i++) {
       Hook hook = Hook.wrap(hooks[i]);
@@ -153,6 +159,21 @@ library SystemCall {
       }
     }
 
+    // Call optional onBeforeCallSystem hooks (before calling the system)
+    for (uint256 i; i < optionalSystemHooks.length; i++) {
+      Hook hook = Hook.wrap(optionalSystemHooks[i]);
+      if (hook.isEnabled(BEFORE_CALL_SYSTEM)) {
+        IOptionalSystemHook(hook.getAddress()).onBeforeCallSystem(caller, systemId, callData);
+      }
+    }
+
+    for (uint256 i; i < optionalSystemHooksWithCallData.length; i++) {
+      Hook hook = Hook.wrap(optionalSystemHooksWithCallData[i]);
+      if (hook.isEnabled(BEFORE_CALL_SYSTEM)) {
+        IOptionalSystemHook(hook.getAddress()).onBeforeCallSystem(caller, systemId, callData);
+      }
+    }
+
     // Call the system and forward any return data
     (success, data) = call({ caller: caller, value: value, systemId: systemId, callData: callData });
 
@@ -163,6 +184,20 @@ library SystemCall {
         ISystemHook(hook.getAddress()).onAfterCallSystem(caller, systemId, callData);
       }
     }
+
+    // Call optional onAfterCallSystem hooks (after calling the system)
+    for (uint256 i; i < optionalSystemHooks.length; i++) {
+      Hook hook = Hook.wrap(optionalSystemHooks[i]);
+      if (hook.isEnabled(AFTER_CALL_SYSTEM)) {
+        IOptionalSystemHook(hook.getAddress()).onAfterCallSystem(caller, systemId, callData);
+      }
+    }
+    for (uint256 i; i < optionalSystemHooksWithCallData.length; i++) {
+      Hook hook = Hook.wrap(optionalSystemHooksWithCallData[i]);
+      if (hook.isEnabled(AFTER_CALL_SYSTEM)) {
+        IOptionalSystemHook(hook.getAddress()).onAfterCallSystem(caller, systemId, callData);
+      }
+    }
   }
 
   /**