add vanilla initialize tests

.forge-snapshots/initialize.snap

@@ -1 +1 @@
-77307
+77664

src/test/AccessLockHook.sol

@@ -30,6 +30,15 @@ contract AccessLockHook is Test, BaseTestHooks {
         NoOp
     }
 
+    function beforeInitialize(
+        address, /* sender **/
+        PoolKey calldata key,
+        uint160, /* sqrtPriceX96 **/
+        bytes calldata hookData
+    ) external override returns (bytes4) {
+        return _executeAction(key, hookData, IHooks.beforeInitialize.selector);
+    }
+
     function beforeSwap(
         address, /* sender **/
         PoolKey calldata key,

src/test/PoolInitializeTest.sol

@@ -7,24 +7,28 @@ import {PoolKey} from "../types/PoolKey.sol";
 import {PoolTestBase} from "./PoolTestBase.sol";
 import {SafeCast} from "../libraries/SafeCast.sol";
 import {Test} from "forge-std/Test.sol";
+import {IHooks} from "../interfaces/IHooks.sol";
+import {Hooks} from "../libraries/Hooks.sol";
 
 contract PoolInitializeTest is Test, PoolTestBase {
     using CurrencyLibrary for Currency;
     using SafeCast for uint256;
+    using Hooks for IHooks;
 
     constructor(IPoolManager _manager) PoolTestBase(_manager) {}
 
     struct CallbackData {
         PoolKey key;
         uint160 sqrtPriceX96;
         bytes hookData;
+        address sender;
     }
 
     function initialize(PoolKey memory key, uint160 sqrtPriceX96, bytes memory hookData)
         external
         returns (int24 tick)
     {
-        tick = abi.decode(manager.lock(abi.encode(CallbackData(key, sqrtPriceX96, hookData))), (int24));
+        tick = abi.decode(manager.lock(abi.encode(CallbackData(key, sqrtPriceX96, hookData, msg.sender))), (int24));
     }
 
     function lockAcquired(bytes calldata rawData) external returns (bytes memory) {
@@ -38,9 +42,17 @@ contract PoolInitializeTest is Test, PoolTestBase {
         int256 delta1 = manager.currencyDelta(address(this), data.key.currency1);
         uint256 nonZeroDC = manager.getLockNonzeroDeltaCount();
 
-        assertEq(delta0, 0, "delta0");
-        assertEq(delta1, 0, "delta1");
-        assertEq(nonZeroDC, 0, "NonzeroDeltaCount");
+        if (!data.key.hooks.hasPermissionToAccessLock()) {
+            assertEq(delta0, 0, "delta0");
+            assertEq(delta1, 0, "delta1");
+            assertEq(nonZeroDC, 0, "NonzeroDeltaCount");
+        } else {
+            // settle deltas
+            if (delta0 > 0) _settle(data.key.currency0, data.sender, int128(delta0), true);
+            if (delta1 > 0) _settle(data.key.currency1, data.sender, int128(delta1), true);
+            if (delta0 < 0) _take(data.key.currency0, data.sender, int128(delta0), true);
+            if (delta1 < 0) _take(data.key.currency1, data.sender, int128(delta1), true);
+        }
 
         return abi.encode(tick);
     }

test/AccessLock.t.sol

@@ -68,8 +68,8 @@ contract AccessLockTest is Test, Deployers {
         // Create AccessLockHook with NoOp.
         address accessLockHook4Address = address(
             uint160(
-                Hooks.NO_OP_FLAG | Hooks.ACCESS_LOCK_FLAG | Hooks.BEFORE_SWAP_FLAG | Hooks.BEFORE_MODIFY_POSITION_FLAG
-                    | Hooks.BEFORE_DONATE_FLAG
+                Hooks.NO_OP_FLAG | Hooks.ACCESS_LOCK_FLAG | Hooks.BEFORE_INITIALIZE_FLAG | Hooks.BEFORE_SWAP_FLAG
+                    | Hooks.BEFORE_MODIFY_POSITION_FLAG | Hooks.BEFORE_DONATE_FLAG
             )
         );
         deployCodeTo("AccessLockHook.sol:AccessLockHook", abi.encode(manager), accessLockHook4Address);
@@ -521,6 +521,96 @@ contract AccessLockTest is Test, Deployers {
         assertLt(balanceOfAfter0, balanceOfBefore0);
         assertLt(balanceOfAfter1, balanceOfBefore1);
     }
+    /**
+     *
+     * BEFORE INITIALIZE TESTS
+     *
+     */
+
+    function test_beforeInitialize_mint_succeedsWithAccessLock(uint128 amount) public {
+        vm.assume(amount != 0 && amount < uint128(type(int128).max));
+
+        PoolKey memory key1 = PoolKey({
+            currency0: currency0,
+            currency1: currency1,
+            fee: Constants.FEE_MEDIUM,
+            tickSpacing: 60,
+            hooks: IHooks(address(accessLockHook4))
+        });
+
+        initializeRouter.initialize(key1, SQRT_RATIO_1_1, abi.encode(amount, AccessLockHook.LockAction.Mint));
+
+        assertEq(manager.balanceOf(address(accessLockHook4), currency1), amount);
+    }
+
+    function test_beforeInitialize_take_succeedsWithAccessLock(uint128 amount) public {
+        PoolKey memory key1 = PoolKey({
+            currency0: currency0,
+            currency1: currency1,
+            fee: Constants.FEE_MEDIUM,
+            tickSpacing: 60,
+            hooks: IHooks(address(accessLockHook4))
+        });
+
+        // Add liquidity to a different pool there is something to take.
+        modifyPositionRouter.modifyPosition(
+            key,
+            IPoolManager.ModifyPositionParams({tickLower: -120, tickUpper: 120, liquidityDelta: 100 * 10e18}),
+            ZERO_BYTES
+        );
+
+        // Can't take more than the manager has.
+        vm.assume(amount < key.currency1.balanceOf(address(manager)));
+
+        initializeRouter.initialize(key1, SQRT_RATIO_1_1, abi.encode(amount, AccessLockHook.LockAction.Take));
+
+        assertEq(MockERC20(Currency.unwrap(currency1)).balanceOf(address(accessLockHook4)), amount);
+    }
+
+    function test_beforeInitialize_swap_revertsOnPoolNotInitialized(uint128 amount) public {
+        vm.assume(amount != 0 && amount > 10); // precision
+
+        PoolKey memory key1 = PoolKey({
+            currency0: currency0,
+            currency1: currency1,
+            fee: Constants.FEE_MEDIUM,
+            tickSpacing: 60,
+            hooks: IHooks(address(accessLockHook4))
+        });
+
+        vm.expectRevert(IPoolManager.PoolNotInitialized.selector);
+        initializeRouter.initialize(key1, SQRT_RATIO_1_1, abi.encode(amount, AccessLockHook.LockAction.Swap));
+    }
+
+    function test_beforeInitialize_modifyPosition_revertsOnPoolNotInitialized(uint128 amount) public {
+        vm.assume(amount != 0 && amount > 10); // precision
+
+        PoolKey memory key1 = PoolKey({
+            currency0: currency0,
+            currency1: currency1,
+            fee: Constants.FEE_MEDIUM,
+            tickSpacing: 60,
+            hooks: IHooks(address(accessLockHook4))
+        });
+
+        vm.expectRevert(IPoolManager.PoolNotInitialized.selector);
+        initializeRouter.initialize(key1, SQRT_RATIO_1_1, abi.encode(amount, AccessLockHook.LockAction.ModifyPosition));
+    }
+
+    function test_beforeInitialize_donate_revertsOnPoolNotInitialized(uint128 amount) public {
+        vm.assume(amount != 0 && amount > 10); // precision
+
+        PoolKey memory key1 = PoolKey({
+            currency0: currency0,
+            currency1: currency1,
+            fee: Constants.FEE_MEDIUM,
+            tickSpacing: 60,
+            hooks: IHooks(address(accessLockHook4))
+        });
+
+        vm.expectRevert(IPoolManager.PoolNotInitialized.selector);
+        initializeRouter.initialize(key1, SQRT_RATIO_1_1, abi.encode(amount, AccessLockHook.LockAction.Donate));
+    }
 
     /**
      *

test/utils/Deployers.sol

@@ -67,8 +67,13 @@ contract Deployers {
     function deployMintAndApprove2Currencies() internal returns (Currency, Currency) {
         MockERC20[] memory tokens = deployTokens(2, 2 ** 255);
 
-        address[4] memory toApprove =
-            [address(swapRouter), address(modifyPositionRouter), address(donateRouter), address(takeRouter)];
+        address[5] memory toApprove = [
+            address(swapRouter),
+            address(modifyPositionRouter),
+            address(donateRouter),
+            address(takeRouter),
+            address(initializeRouter)
+        ];
 
         for (uint256 i = 0; i < toApprove.length; i++) {
             tokens[0].approve(toApprove[i], Constants.MAX_UINT256);