NoOp implementation with flag

.forge-snapshots/before swap hook, already cached dynamic fee.snap

@@ -1 +1 @@
-189798
+189980

.forge-snapshots/cached dynamic fee, no hooks.snap

@@ -1 +1 @@
-145314
+145476

.forge-snapshots/donate gas with 1 token.snap

@@ -1 +1 @@
-134915
+137124

.forge-snapshots/donate gas with 2 tokens.snap

@@ -1 +1 @@
-186636
+186845

.forge-snapshots/initialize.snap

@@ -1 +1 @@
-53843
+53941

.forge-snapshots/mint with empty hook.snap

@@ -1 +1 @@
-319184
+319291

.forge-snapshots/mint with native token.snap

@@ -1 +1 @@
-198926
+199013

.forge-snapshots/mint.snap

@@ -1 +1 @@
-202041
+202128

.forge-snapshots/modify position with noop.snap

@@ -0,0 +1 @@
+52263

.forge-snapshots/poolManager bytecode size.snap

@@ -1 +1 @@
-24805
+25025

.forge-snapshots/simple swap native.snap

@@ -1 +1 @@
-132772
+132954

.forge-snapshots/simple swap with native.snap

@@ -1 +1 @@
-190722
+190884

.forge-snapshots/simple swap.snap

@@ -1 +1 @@
-202425
+202587

.forge-snapshots/swap against liquidity with native token.snap

@@ -1 +1 @@
-121318
+121480

.forge-snapshots/swap against liquidity.snap

@@ -1 +1 @@
-109143
+109305

.forge-snapshots/swap burn claim for input.snap

@@ -1 +1 @@
-127882
+128044

.forge-snapshots/swap mint output as claim.snap

@@ -1 +1 @@
-212594
+212756

.forge-snapshots/swap with dynamic fee.snap

@@ -1 +1 @@
-189038
+189220

.forge-snapshots/swap with hooks.snap

@@ -1 +1 @@
-109122
+109284

.forge-snapshots/swap with native.snap

@@ -0,0 +1 @@
+47418

.forge-snapshots/swap with noop.snap

@@ -0,0 +1 @@
+44944

.forge-snapshots/update dynamic fee in before swap.snap

@@ -1 +1 @@
-195628
+195804

src/PoolManager.sol

@@ -185,16 +185,20 @@ contract PoolManager is IPoolManager, Fees, NoDelegateCall, Claims {
         IPoolManager.ModifyPositionParams memory params,
         bytes calldata hookData
     ) external override noDelegateCall onlyByLocker returns (BalanceDelta delta) {
+        PoolId id = key.toId();
+        if (pools[id].isNotInitialized()) revert PoolNotInitialized();
+
         if (key.hooks.shouldCallBeforeModifyPosition()) {
-            if (
-                key.hooks.beforeModifyPosition(msg.sender, key, params, hookData)
-                    != IHooks.beforeModifyPosition.selector
-            ) {
-                revert Hooks.InvalidHookResponse();
+            bytes4 selector = key.hooks.beforeModifyPosition(msg.sender, key, params, hookData);
+            if (selector != IHooks.beforeModifyPosition.selector) {
+                if (key.hooks.isValidNoOpCall(selector)) {
+                    return BalanceDelta.wrap(0);
+                } else {
+                    revert Hooks.InvalidHookResponse();
+                }
             }
         }
 
-        PoolId id = key.toId();
         Pool.FeeAmounts memory feeAmounts;
         (delta, feeAmounts) = pools[id].modifyPosition(
             Pool.ModifyPositionParams({
@@ -243,14 +247,20 @@ contract PoolManager is IPoolManager, Fees, NoDelegateCall, Claims {
         onlyByLocker
         returns (BalanceDelta delta)
     {
+        PoolId id = key.toId();
+        if (pools[id].isNotInitialized()) revert PoolNotInitialized();
+
         if (key.hooks.shouldCallBeforeSwap()) {
-            if (key.hooks.beforeSwap(msg.sender, key, params, hookData) != IHooks.beforeSwap.selector) {
-                revert Hooks.InvalidHookResponse();
+            bytes4 selector = key.hooks.beforeSwap(msg.sender, key, params, hookData);
+            if (selector != IHooks.beforeSwap.selector) {
+                if (key.hooks.isValidNoOpCall(selector)) {
+                    return BalanceDelta.wrap(0);
+                } else {
+                    revert Hooks.InvalidHookResponse();
+                }
             }
         }
 
-        PoolId id = key.toId();
-
         uint256 feeForProtocol;
         uint256 feeForHook;
         uint24 swapFee;
@@ -295,13 +305,21 @@ contract PoolManager is IPoolManager, Fees, NoDelegateCall, Claims {
         onlyByLocker
         returns (BalanceDelta delta)
     {
+        PoolId id = key.toId();
+        if (pools[id].isNotInitialized()) revert PoolNotInitialized();
+
         if (key.hooks.shouldCallBeforeDonate()) {
-            if (key.hooks.beforeDonate(msg.sender, key, amount0, amount1, hookData) != IHooks.beforeDonate.selector) {
-                revert Hooks.InvalidHookResponse();
+            bytes4 selector = key.hooks.beforeDonate(msg.sender, key, amount0, amount1, hookData);
+            if (selector != IHooks.beforeDonate.selector) {
+                if (key.hooks.isValidNoOpCall(selector)) {
+                    return BalanceDelta.wrap(0);
+                } else {
+                    revert Hooks.InvalidHookResponse();
+                }
             }
         }
 
-        delta = _getPool(key).donate(amount0, amount1);
+        delta = pools[id].donate(amount0, amount1);
 
         _accountPoolBalanceDelta(key, delta);
 

src/interfaces/IPoolManager.sol

@@ -18,6 +18,9 @@ interface IPoolManager is IFees, IClaims {
     /// @notice Thrown when a currency is not netted out after a lock
     error CurrencyNotSettled();
 
+    /// @notice Thrown when trying to interact with a non-initialized pool
+    error PoolNotInitialized();
+
     /// @notice Thrown when a function is called by an address that is not the current locker
     /// @param locker The current locker
     error LockedBy(address locker);

src/libraries/Hooks.sol

@@ -19,6 +19,9 @@ library Hooks {
     uint256 internal constant AFTER_SWAP_FLAG = 1 << 154;
     uint256 internal constant BEFORE_DONATE_FLAG = 1 << 153;
     uint256 internal constant AFTER_DONATE_FLAG = 1 << 152;
+    uint256 internal constant NO_OP_FLAG = 1 << 151;
+
+    bytes4 public constant NO_OP_SELECTOR = bytes4(keccak256(abi.encodePacked("NoOp")));
 
     struct Calls {
         bool beforeInitialize;
@@ -29,6 +32,7 @@ library Hooks {
         bool afterSwap;
         bool beforeDonate;
         bool afterDonate;
+        bool noOp;
     }
 
     /// @notice Thrown if the address will not lead to the specified hook calls being called
@@ -50,6 +54,7 @@ library Hooks {
                 || calls.afterModifyPosition != shouldCallAfterModifyPosition(self)
                 || calls.beforeSwap != shouldCallBeforeSwap(self) || calls.afterSwap != shouldCallAfterSwap(self)
                 || calls.beforeDonate != shouldCallBeforeDonate(self) || calls.afterDonate != shouldCallAfterDonate(self)
+                || calls.noOp != shouldAllowNoOp(self)
         ) {
             revert HookAddressNotValid(address(self));
         }
@@ -58,7 +63,12 @@ library Hooks {
     /// @notice Ensures that the hook address includes at least one hook flag or dynamic fees, or is the 0 address
     /// @param hook The hook to verify
     function isValidHookAddress(IHooks hook, uint24 fee) internal pure returns (bool) {
-        // If there is no hook contract set, then fee cannot be dynamic and there cannot be a hook fee on swap or withdrawal.
+        if (
+            shouldAllowNoOp(hook) && !shouldCallBeforeModifyPosition(hook) && !shouldCallBeforeSwap(hook)
+                && !shouldCallBeforeDonate(hook)
+        ) {
+            return false;
+        }
         return address(hook) == address(0)
             ? !fee.isDynamicFee() && !fee.hasHookSwapFee() && !fee.hasHookWithdrawFee()
             : (
@@ -98,4 +108,12 @@ library Hooks {
     function shouldCallAfterDonate(IHooks self) internal pure returns (bool) {
         return uint256(uint160(address(self))) & AFTER_DONATE_FLAG != 0;
     }
+
+    function shouldAllowNoOp(IHooks self) internal pure returns (bool) {
+        return uint256(uint160(address(self))) & NO_OP_FLAG != 0;
+    }
+
+    function isValidNoOpCall(IHooks self, bytes4 selector) internal pure returns (bool) {
+        return shouldAllowNoOp(self) && selector == NO_OP_SELECTOR;
+    }
 }

src/libraries/Pool.sol

@@ -16,6 +16,7 @@ library Pool {
     using TickBitmap for mapping(int16 => uint256);
     using Position for mapping(bytes32 => Position.Info);
     using Position for Position.Info;
+    using Pool for State;
 
     /// @notice Thrown when tickLower is not below tickUpper
     /// @param tickLower The invalid tickLower
@@ -134,20 +135,20 @@ library Pool {
     }
 
     function setProtocolFees(State storage self, uint24 protocolFees) internal {
-        if (self.slot0.sqrtPriceX96 == 0) revert PoolNotInitialized();
+        if (self.isNotInitialized()) revert PoolNotInitialized();
 
         self.slot0.protocolFees = protocolFees;
     }
 
     function setHookFees(State storage self, uint24 hookFees) internal {
-        if (self.slot0.sqrtPriceX96 == 0) revert PoolNotInitialized();
+        if (self.isNotInitialized()) revert PoolNotInitialized();
 
         self.slot0.hookFees = hookFees;
     }
 
     /// @notice Only dynamic fee pools may update the swap fee.
     function setSwapFee(State storage self, uint24 swapFee) internal {
-        if (self.slot0.sqrtPriceX96 == 0) revert PoolNotInitialized();
+        if (self.isNotInitialized()) revert PoolNotInitialized();
         self.slot0.swapFee = swapFee;
     }
 
@@ -179,23 +180,22 @@ library Pool {
         uint256 feeForHook1;
     }
 
-    /// @dev Effect changes to a position in a pool
+    /// @notice Effect changes to a position in a pool
+    /// @dev PoolManager checks that the pool is initialized before calling
     /// @param params the position details and the change to the position's liquidity to effect
     /// @return result the deltas of the token balances of the pool
     function modifyPosition(State storage self, ModifyPositionParams memory params)
         internal
         returns (BalanceDelta result, FeeAmounts memory fees)
     {
-        if (self.slot0.sqrtPriceX96 == 0) revert PoolNotInitialized();
-
         checkTicks(params.tickLower, params.tickUpper);
 
         uint256 feesOwed0;
         uint256 feesOwed1;
         {
             ModifyPositionState memory state;
-            // if we need to update the ticks, do it
 
+            // if we need to update the ticks, do it
             if (params.liquidityDelta != 0) {
                 (state.flippedLower, state.liquidityGrossAfterLower) =
                     updateTick(self, params.tickLower, params.liquidityDelta, false);
@@ -386,7 +386,8 @@ library Pool {
         uint160 sqrtPriceLimitX96;
     }
 
-    /// @dev Executes a swap against the state, and returns the amount deltas of the pool
+    /// @notice Executes a swap against the state, and returns the amount deltas of the pool
+    /// @dev PoolManager checks that the pool is initialized before calling
     function swap(State storage self, SwapParams memory params)
         internal
         returns (
@@ -401,7 +402,6 @@ library Pool {
 
         Slot0 memory slot0Start = self.slot0;
         swapFee = slot0Start.swapFee;
-        if (slot0Start.sqrtPriceX96 == 0) revert PoolNotInitialized();
         if (params.zeroForOne) {
             if (params.sqrtPriceLimitX96 >= slot0Start.sqrtPriceX96) {
                 revert PriceLimitAlreadyExceeded(slot0Start.sqrtPriceX96, params.sqrtPriceLimitX96);
@@ -681,6 +681,10 @@ library Pool {
         }
     }
 
+    function isNotInitialized(State storage self) internal view returns (bool) {
+        return self.slot0.sqrtPriceX96 == 0;
+    }
+
     /// @notice Clears tick data
     /// @param self The mapping containing all initialized tick information for initialized ticks
     /// @param tick The tick that will be cleared

src/test/EmptyTestHooks.sol

@@ -20,7 +20,8 @@ contract EmptyTestHooks is IHooks {
                 beforeSwap: true,
                 afterSwap: true,
                 beforeDonate: true,
-                afterDonate: true
+                afterDonate: true,
+                noOp: true
             })
         );
     }

src/test/NoOpTestHooks.sol

@@ -0,0 +1,54 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.8.19;
+
+import {BaseTestHooks} from "./BaseTestHooks.sol";
+import {Hooks} from "../libraries/Hooks.sol";
+import {IPoolManager} from "../interfaces/IPoolManager.sol";
+import {PoolKey} from "../types/PoolKey.sol";
+import {BalanceDelta} from "../types/BalanceDelta.sol";
+
+contract NoOpTestHooks is BaseTestHooks {
+    constructor() {
+        Hooks.validateHookAddress(
+            this,
+            Hooks.Calls({
+                beforeInitialize: false,
+                afterInitialize: false,
+                beforeModifyPosition: true,
+                afterModifyPosition: false,
+                beforeSwap: true,
+                afterSwap: false,
+                beforeDonate: true,
+                afterDonate: false,
+                noOp: true
+            })
+        );
+    }
+
+    function beforeModifyPosition(address, PoolKey calldata, IPoolManager.ModifyPositionParams calldata, bytes calldata)
+        external
+        pure
+        override
+        returns (bytes4)
+    {
+        return Hooks.NO_OP_SELECTOR;
+    }
+
+    function beforeSwap(address, PoolKey calldata, IPoolManager.SwapParams calldata, bytes calldata)
+        external
+        pure
+        override
+        returns (bytes4)
+    {
+        return Hooks.NO_OP_SELECTOR;
+    }
+
+    function beforeDonate(address, PoolKey calldata, uint256, uint256, bytes calldata)
+        external
+        pure
+        override
+        returns (bytes4)
+    {
+        return Hooks.NO_OP_SELECTOR;
+    }
+}