Middleware remove

.forge-snapshots/FullRangeAddInitialLiquidity.snap

@@ -1 +1 @@
-311181
+310035

.forge-snapshots/FullRangeAddLiquidity.snap

@@ -1 +1 @@
-122990
+121849

.forge-snapshots/FullRangeFirstSwap.snap

@@ -1 +1 @@
-80220
+78755

.forge-snapshots/FullRangeInitialize.snap

@@ -1 +1 @@
-1015181
+1008752

.forge-snapshots/FullRangeRemoveLiquidity.snap

@@ -1 +1 @@
-110566
+109419

.forge-snapshots/FullRangeRemoveLiquidityAndRebalance.snap

@@ -1 +1 @@
-240044
+238654

.forge-snapshots/FullRangeSecondSwap.snap

@@ -1 +1 @@
-45930
+44465

.forge-snapshots/FullRangeSwap.snap

@@ -1 +1 @@
-79351
+77891

.forge-snapshots/TWAMMSubmitOrder.snap

@@ -1 +1 @@
-122336
+121999

.github/workflows/lint.yml

@@ -21,5 +21,5 @@ jobs:
         with:
           version: nightly
 
-      - name: Run tests
+      - name: Check format
         run: forge fmt --check

contracts/interfaces/IMiddlewareFactory.sol

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: UNLICENSED
-pragma solidity ^0.8.19;
+pragma solidity ^0.8.24;
 
 interface IMiddlewareFactory {
     event MiddlewareCreated(address implementation, address middleware);

contracts/middleware/BaseMiddleware.sol

@@ -3,28 +3,37 @@ pragma solidity ^0.8.24;
 
 import {Hooks} from "@uniswap/v4-core/src/libraries/Hooks.sol";
 import {IPoolManager} from "@uniswap/v4-core/src/interfaces/IPoolManager.sol";
-import {IHooks} from "@uniswap/v4-core/src/interfaces/IHooks.sol";
-import {BalanceDelta} from "@uniswap/v4-core/src/types/BalanceDelta.sol";
-import {PoolKey} from "@uniswap/v4-core/src/types/PoolKey.sol";
-import {BeforeSwapDelta} from "@uniswap/v4-core/src/types/BeforeSwapDelta.sol";
 import {Proxy} from "@openzeppelin/contracts/proxy/Proxy.sol";
 
-contract BaseMiddleware is Proxy {
+/**
+ * @notice Proxy contract that forwards calls to an implementation contract.
+ * @dev Inheret this contract and implement hook functions to create a middleware.
+ */
+abstract contract BaseMiddleware is Proxy {
     /// @notice The address of the pool manager
-    IPoolManager public immutable poolManager;
+    /// @dev Use in middleware implementations to access the pool manager
+    IPoolManager public immutable manager;
+
+    /// @notice The address of the implementation contract. All calls to this contract will be forwarded to implementation.
     address public immutable implementation;
 
-    constructor(IPoolManager _poolManager, address _impl) {
-        poolManager = _poolManager;
+    error FlagsMismatch();
+
+    constructor(IPoolManager _manager, address _impl) {
+        _ensureValidFlags(_impl);
+        manager = _manager;
         implementation = _impl;
     }
 
     function _implementation() internal view override returns (address) {
         return implementation;
     }
 
-    // yo i wanna delete this function but how do i remove this warning
-    receive() external payable {
-        _delegate(_implementation());
+    /// @notice Ensure that the implementation contract has the correct hook flags.
+    /// @dev Override to enforce hook flags.
+    function _ensureValidFlags(address _impl) internal view virtual {
+        if (uint160(address(this)) & Hooks.ALL_HOOK_MASK != uint160(_impl) & Hooks.ALL_HOOK_MASK) {
+            revert FlagsMismatch();
+        }
     }
 }

contracts/middleware/BaseMiddlewareFactory.sol

@@ -1,20 +1,17 @@
 // SPDX-License-Identifier: UNLICENSED
-pragma solidity ^0.8.19;
+pragma solidity ^0.8.24;
 
 import {IMiddlewareFactory} from "../interfaces/IMiddlewareFactory.sol";
 import {BaseMiddleware} from "./BaseMiddleware.sol";
 import {IPoolManager} from "@uniswap/v4-core/src/interfaces/IPoolManager.sol";
-import {IHooks} from "@uniswap/v4-core/src/interfaces/IHooks.sol";
-import {Hooks} from "@uniswap/v4-core/src/libraries/Hooks.sol";
-import {IBaseHook} from "../interfaces/IBaseHook.sol";
 
-contract BaseMiddlewareFactory is IMiddlewareFactory {
+abstract contract BaseMiddlewareFactory is IMiddlewareFactory {
     mapping(address => address) private _implementations;
 
-    IPoolManager public immutable poolManager;
+    IPoolManager public immutable manager;
 
-    constructor(IPoolManager _poolManager) {
-        poolManager = _poolManager;
+    constructor(IPoolManager _manager) {
+        manager = _manager;
     }
 
     function getImplementation(address middleware) external view override returns (address implementation) {
@@ -23,12 +20,9 @@ contract BaseMiddlewareFactory is IMiddlewareFactory {
 
     function createMiddleware(address implementation, bytes32 salt) external override returns (address middleware) {
         middleware = _deployMiddleware(implementation, salt);
-        Hooks.validateHookPermissions(IHooks(middleware), IBaseHook(implementation).getHookPermissions());
         _implementations[middleware] = implementation;
         emit MiddlewareCreated(implementation, middleware);
     }
 
-    function _deployMiddleware(address implementation, bytes32 salt) internal virtual returns (address middleware) {
-        return address(new BaseMiddleware{salt: salt}(poolManager, implementation));
-    }
+    function _deployMiddleware(address implementation, bytes32 salt) internal virtual returns (address middleware) {}
 }

contracts/middleware/BaseRemove.sol

@@ -0,0 +1,64 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.8.24;
+
+import {IPoolManager} from "@uniswap/v4-core/src/interfaces/IPoolManager.sol";
+import {BalanceDelta, BalanceDeltaLibrary} from "@uniswap/v4-core/src/types/BalanceDelta.sol";
+import {PoolKey} from "@uniswap/v4-core/src/types/PoolKey.sol";
+import {Proxy} from "@openzeppelin/contracts/proxy/Proxy.sol";
+import {BaseMiddleware} from "./BaseMiddleware.sol";
+import {BaseHook} from "../BaseHook.sol";
+import {BalanceDeltaLibrary} from "@uniswap/v4-core/src/types/BalanceDelta.sol";
+import {Hooks} from "@uniswap/v4-core/src/libraries/Hooks.sol";
+import {TransientStateLibrary} from "@uniswap/v4-core/src/libraries/TransientStateLibrary.sol";
+
+abstract contract BaseRemove is BaseMiddleware {
+    using TransientStateLibrary for IPoolManager;
+
+    error HookPermissionForbidden(address hooks);
+    error HookModifiedDeltas();
+    error FailedImplementationCall();
+
+    bytes internal constant ZERO_BYTES = bytes("");
+    uint256 public constant GAS_LIMIT = 5_000_000;
+    uint256 public constant MAX_BIPS = 10_000;
+
+    // use this hookdata to override checks to save gas. keccak256("override") - 1
+    bytes32 constant OVERRIDE_BYTES = 0x23b70c8dec38c3dec67a5596870027b04c4058cb3ac57b4e589bf628ac6669e7;
+
+    uint256 public immutable maxFeeBips;
+
+    constructor(IPoolManager _manager, address _impl) BaseMiddleware(_manager, _impl) {}
+
+    function beforeRemoveLiquidity(
+        address sender,
+        PoolKey calldata key,
+        IPoolManager.ModifyLiquidityParams calldata params,
+        bytes calldata hookData
+    ) external returns (bytes4) {
+        if (bytes32(hookData) == OVERRIDE_BYTES) {
+            (bool success, bytes memory returnData) = address(implementation).delegatecall(
+                abi.encodeWithSelector(this.beforeRemoveLiquidity.selector, sender, key, params, hookData[32:])
+            );
+            return BaseHook.beforeRemoveLiquidity.selector;
+            return abi.decode(returnData, (bytes4));
+        }
+        address(this).delegatecall{gas: GAS_LIMIT}(
+            abi.encodeWithSelector(this._beforeRemoveLiquidity.selector, msg.data)
+        );
+        return BaseHook.beforeRemoveLiquidity.selector;
+    }
+
+    function _beforeRemoveLiquidity(bytes calldata data) external {
+        (bool success, bytes memory returnData) = address(implementation).delegatecall(data);
+        if (!success) {
+            revert FailedImplementationCall();
+        }
+        (bytes4 selector) = abi.decode(returnData, (bytes4));
+        if (selector != BaseHook.beforeRemoveLiquidity.selector) {
+            revert Hooks.InvalidHookResponse();
+        }
+        if (manager.getNonzeroDeltaCount() != 0) {
+            revert HookModifiedDeltas();
+        }
+    }
+}

contracts/middleware/MiddlewareRemove.sol

@@ -0,0 +1,128 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.8.24;
+
+import {IPoolManager} from "@uniswap/v4-core/src/interfaces/IPoolManager.sol";
+import {BalanceDelta, BalanceDeltaLibrary} from "@uniswap/v4-core/src/types/BalanceDelta.sol";
+import {PoolKey} from "@uniswap/v4-core/src/types/PoolKey.sol";
+import {Proxy} from "@openzeppelin/contracts/proxy/Proxy.sol";
+import {BaseRemove} from "./BaseRemove.sol";
+import {BaseHook} from "../BaseHook.sol";
+import {Hooks} from "@uniswap/v4-core/src/libraries/Hooks.sol";
+import {IHooks} from "@uniswap/v4-core/src/interfaces/IHooks.sol";
+import {CustomRevert} from "@uniswap/v4-core/src/libraries/CustomRevert.sol";
+import {NonZeroDeltaCount} from "@uniswap/v4-core/src/libraries/NonZeroDeltaCount.sol";
+import {TransientStateLibrary} from "@uniswap/v4-core/src/libraries/TransientStateLibrary.sol";
+
+contract MiddlewareRemove is BaseRemove {
+    using CustomRevert for bytes4;
+    using Hooks for IHooks;
+    using TransientStateLibrary for IPoolManager;
+
+    error HookModifiedDeltasBeforeRemove();
+    error HookTookTooMuchFee();
+    error HookInvalidDeltasAfterRemove();
+    error MaxFeeBipsTooHigh();
+
+    constructor(IPoolManager _manager, address _impl, uint256 _maxFeeBips) BaseRemove(_manager, _impl) {
+        if (_maxFeeBips > MAX_BIPS) revert MaxFeeBipsTooHigh();
+        maxFeeBips = _maxFeeBips;
+    }
+
+    function afterRemoveLiquidity(
+        address sender,
+        PoolKey calldata key,
+        IPoolManager.ModifyLiquidityParams calldata params,
+        BalanceDelta delta,
+        bytes calldata hookData
+    ) external returns (bytes4, BalanceDelta) {
+        if (bytes32(hookData) == OVERRIDE_BYTES) {
+            (, bytes memory returnData) = address(implementation).delegatecall(
+                abi.encodeWithSelector(this.afterRemoveLiquidity.selector, sender, key, params, delta, hookData[32:])
+            );
+            return abi.decode(returnData, (bytes4, BalanceDelta));
+        }
+        (bool success, bytes memory returnData) = address(this).delegatecall{gas: GAS_LIMIT}(
+            abi.encodeWithSelector(this._callAndEnsureValidDeltas.selector, sender, key, params, delta, hookData)
+        );
+        if (success) {
+            return (BaseHook.afterRemoveLiquidity.selector, abi.decode(returnData, (BalanceDelta)));
+        } else {
+            return (BaseHook.afterRemoveLiquidity.selector, BalanceDeltaLibrary.ZERO_DELTA);
+        }
+    }
+
+    function _callAndEnsureValidDeltas(
+        address sender,
+        PoolKey calldata key,
+        IPoolManager.ModifyLiquidityParams calldata params,
+        BalanceDelta delta,
+        bytes calldata hookData
+    ) external returns (BalanceDelta) {
+        (bool success, bytes memory returnData) = address(implementation).delegatecall(
+            abi.encodeWithSelector(this.afterRemoveLiquidity.selector, sender, key, params, delta, hookData)
+        );
+        if (!success) {
+            revert FailedImplementationCall();
+        }
+        (bytes4 selector, BalanceDelta returnDelta) = abi.decode(returnData, (bytes4, BalanceDelta));
+        if (selector != BaseHook.afterRemoveLiquidity.selector) {
+            revert Hooks.InvalidHookResponse();
+        }
+        uint256 nonzeroDeltaCount = manager.getNonzeroDeltaCount();
+        if (nonzeroDeltaCount == 0 && returnDelta == BalanceDeltaLibrary.ZERO_DELTA) {
+            return returnDelta;
+        }
+        if (
+            returnDelta.amount0() > int256(uint256(int256(delta.amount0())) * maxFeeBips / MAX_BIPS)
+                || returnDelta.amount1() > int256(uint256(int256(delta.amount1())) * maxFeeBips / MAX_BIPS)
+        ) {
+            revert HookTookTooMuchFee();
+        }
+        // error on overflow
+        returnDelta - delta;
+        uint256 nonzeroHookDeltaCount;
+        int256 hookDelta = manager.currencyDelta(address(this), key.currency0);
+        if (hookDelta != 0) {
+            if (-hookDelta != returnDelta.amount0()) {
+                revert HookInvalidDeltasAfterRemove();
+            }
+            nonzeroHookDeltaCount++;
+            if (nonzeroHookDeltaCount == nonzeroDeltaCount) {
+                return returnDelta;
+            }
+        }
+        hookDelta = manager.currencyDelta(address(this), key.currency1);
+        if (hookDelta != 0) {
+            if (-hookDelta != returnDelta.amount1()) {
+                revert HookInvalidDeltasAfterRemove();
+            }
+            nonzeroHookDeltaCount++;
+            if (nonzeroHookDeltaCount == nonzeroDeltaCount) {
+                return returnDelta;
+            }
+        }
+
+        // weird edge case in case the hook settled the caller's deltas
+        // can prob delete this
+        // if (manager.currencyDelta(sender, key.currency0) != 0) {
+        //     nonzeroHookDeltaCount++;
+        // }
+        // if (manager.currencyDelta(sender, key.currency1) != 0) {
+        //     nonzeroHookDeltaCount++;
+        // }
+        // if (nonzeroHookDeltaCount == nonzeroDeltaCount) {
+        //     return returnDelta;
+        // }
+
+        revert HookInvalidDeltasAfterRemove();
+    }
+
+    function _ensureValidFlags(address _impl) internal view virtual override {
+        if (uint160(address(this)) & Hooks.ALL_HOOK_MASK != uint160(_impl) & Hooks.ALL_HOOK_MASK) {
+            revert FlagsMismatch();
+        }
+        if (!IHooks(address(this)).hasPermission(Hooks.AFTER_REMOVE_LIQUIDITY_RETURNS_DELTA_FLAG)) {
+            HookPermissionForbidden.selector.revertWith(address(this));
+        }
+    }
+}