feat: add optional system hooks

packages/world/mud.config.ts

@@ -84,6 +84,16 @@ export default mudConfig({
       },
       valueSchema: "bytes21[]",
     },
+    OptionalSystemHooks: {
+      keySchema: {
+        player: "address",
+        systemId: "ResourceId",
+        callDataHash: "bytes32",
+      },
+      valueSchema: {
+        hooks: "bytes21[]",
+      },
+    },
     FunctionSelectors: {
       keySchema: {
         worldFunctionSelector: "bytes4",

packages/world/src/IOptionalSystemHook.sol

@@ -0,0 +1,24 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >=0.8.24;
+
+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.
+   */
+  function onRegisterHook() 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.
+   */
+  function onUnregisterHook() external;
+}

packages/world/src/SystemCall.sol

@@ -15,6 +15,7 @@ import { ISystemHook } from "./ISystemHook.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";
 
 /**
@@ -93,6 +94,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]);
@@ -101,6 +106,20 @@ 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)) {
+        ISystemHook(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)) {
+        ISystemHook(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 });
 
@@ -111,6 +130,22 @@ 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)) {
+        ISystemHook(hook.getAddress()).onAfterCallSystem(caller, systemId, callData);
+      }
+    }
+
+    // Call optional onAfterCallSystem hooks (after calling the system)
+    for (uint256 i; i < optionalSystemHooksWithCallData.length; i++) {
+      Hook hook = Hook.wrap(optionalSystemHooksWithCallData[i]);
+      if (hook.isEnabled(AFTER_CALL_SYSTEM)) {
+        ISystemHook(hook.getAddress()).onAfterCallSystem(caller, systemId, callData);
+      }
+    }
   }
 
   /**