use custom storage for lockData

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

@@ -1 +1 @@
-96005
+95788

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

@@ -1 +1 @@
-153358
+152900

.forge-snapshots/gas overhead of no-op lock.snap

@@ -1 +1 @@
-58562
+58632

.forge-snapshots/initialize.snap

@@ -1 +1 @@
-38009
+37964

.forge-snapshots/mint with empty hook.snap

@@ -1 +1 @@
-307152
+306957

.forge-snapshots/mint with native token.snap

@@ -1 +1 @@
-275102
+274907

.forge-snapshots/mint.snap

@@ -1 +1 @@
-293760
+293565

.forge-snapshots/simple swap.snap

@@ -1 +1 @@
-49720
+49766

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

@@ -1 +1 @@
-124982
+124524

.forge-snapshots/swap against liquidity.snap

@@ -1 +1 @@
-109692
+109234

.forge-snapshots/swap with dynamic fee.snap

@@ -1 +1 @@
-91502
+91548

.forge-snapshots/swap with hooks.snap

@@ -1 +1 @@
-49691
+49737

.forge-snapshots/swap with native.snap

@@ -1 +1 @@
-49720
+49766

contracts/PoolManager.sol

@@ -21,6 +21,7 @@ import {ERC1155} from "@openzeppelin/contracts/token/ERC1155/ERC1155.sol";
 import {IERC1155Receiver} from "@openzeppelin/contracts/token/ERC1155/IERC1155Receiver.sol";
 import {PoolId, PoolIdLibrary} from "./types/PoolId.sol";
 import {BalanceDelta} from "./types/BalanceDelta.sol";
+import {LockData} from "./types/LockData.sol";
 
 /// @notice Holds the state for all pools
 contract PoolManager is IPoolManager, Fees, NoDelegateCall, ERC1155, IERC1155Receiver {
@@ -30,7 +31,6 @@ contract PoolManager is IPoolManager, Fees, NoDelegateCall, ERC1155, IERC1155Rec
     using Hooks for IHooks;
     using Position for mapping(bytes32 => Position.Info);
     using CurrencyLibrary for Currency;
-    using LockDataLibrary for IPoolManager.LockData;
     using FeeLibrary for uint24;
 
     /// @inheritdoc IPoolManager
@@ -39,9 +39,6 @@ contract PoolManager is IPoolManager, Fees, NoDelegateCall, ERC1155, IERC1155Rec
     /// @inheritdoc IPoolManager
     int24 public constant override MIN_TICK_SPACING = 1;
 
-    /// @inheritdoc IPoolManager
-    IPoolManager.LockData public override lockData;
-
     /// @dev Represents the currencies due/owed to each locker.
     /// Must all net to zero when the last lock is released.
     mapping(address locker => mapping(Currency currency => int256 currencyDelta)) public currencyDelta;
@@ -138,14 +135,16 @@ contract PoolManager is IPoolManager, Fees, NoDelegateCall, ERC1155, IERC1155Rec
 
     /// @inheritdoc IPoolManager
     function lock(bytes calldata data) external override returns (bytes memory result) {
+        LockData lockData = LockDataLibrary.getLockData();
         lockData.push(msg.sender);
 
         // the caller does everything in this callback, including paying what they owe via calls to settle
         result = ILockCallback(msg.sender).lockAcquired(data);
 
-        if (lockData.length == 1) {
-            if (lockData.nonzeroDeltaCount != 0) revert CurrencyNotSettled();
-            delete lockData;
+        lockData = LockDataLibrary.getLockData();
+        if (lockData.length() == 1) {
+            if (lockData.nonzeroDeltaCount() != 0) revert CurrencyNotSettled();
+            lockData.update(0, 0);
         } else {
             lockData.pop();
         }
@@ -154,15 +153,18 @@ contract PoolManager is IPoolManager, Fees, NoDelegateCall, ERC1155, IERC1155Rec
     function _accountDelta(Currency currency, int128 delta) internal {
         if (delta == 0) return;
 
+        LockData lockData = LockDataLibrary.getLockData();
         address locker = lockData.getActiveLock();
         int256 current = currencyDelta[locker][currency];
         int256 next = current + delta;
 
+        uint128 nonzeroDeltaCount = lockData.nonzeroDeltaCount();
+
         unchecked {
             if (next == 0) {
-                lockData.nonzeroDeltaCount--;
+                lockData.update(lockData.length(), nonzeroDeltaCount - 1);
             } else if (current == 0) {
-                lockData.nonzeroDeltaCount++;
+                lockData.update(lockData.length(), nonzeroDeltaCount + 1);
             }
         }
 
@@ -176,7 +178,7 @@ contract PoolManager is IPoolManager, Fees, NoDelegateCall, ERC1155, IERC1155Rec
     }
 
     modifier onlyByLocker() {
-        address locker = lockData.getActiveLock();
+        address locker = LockDataLibrary.getLockData().getActiveLock();
         if (msg.sender != locker) revert LockedBy(locker);
         _;
     }
@@ -411,6 +413,10 @@ contract PoolManager is IPoolManager, Fees, NoDelegateCall, ERC1155, IERC1155Rec
         return value;
     }
 
+    function getLockData() external view returns (LockData lockData) {
+        return LockDataLibrary.getLockData();
+    }
+
     /// @notice receive native tokens for native pools
     receive() external payable {}
 }

contracts/interfaces/IPoolManager.sol

@@ -10,6 +10,7 @@ import {IFees} from "./IFees.sol";
 import {BalanceDelta} from "../types/BalanceDelta.sol";
 import {PoolId} from "../types/PoolId.sol";
 import {Position} from "../libraries/Position.sol";
+import {LockData} from "../types/LockData.sol";
 
 interface IPoolManager is IFees, IERC1155 {
     /// @notice Thrown when currencies touched has exceeded max of 256
@@ -112,19 +113,11 @@ interface IPoolManager is IFees, IERC1155 {
     /// @notice Returns the reserves for a given ERC20 currency
     function reservesOf(Currency currency) external view returns (uint256);
 
-    /// @notice Contains data about pool lockers.
-    struct LockData {
-        /// @notice The current number of active lockers
-        uint128 length;
-        /// @notice The total number of nonzero deltas over all active + completed lockers
-        uint128 nonzeroDeltaCount;
-    }
-
     /// @notice Returns the locker in the ith position of the locker queue.
     function getLock(uint256 i) external view returns (address locker);
 
-    /// @notice Returns lock data
-    function lockData() external view returns (uint128 length, uint128 nonzeroDeltaCount);
+    /// @notice Returns the lock data (length and nonzeroDeltaCount) for the lock data structure.
+    function getLockData() external view returns (LockData lockData);
 
     /// @notice Initialize the state for a given pool ID
     function initialize(PoolKey memory key, uint160 sqrtPriceX96, bytes calldata hookData)

contracts/libraries/LockDataLibrary.sol

@@ -2,49 +2,91 @@
 pragma solidity ^0.8.20;
 
 import {IPoolManager} from "../interfaces/IPoolManager.sol";
+import {LockData} from "../types/LockData.sol";
 
 /// @dev This library manages a custom storage implementation for a queue
-///      that tracks current lockers. The "sentinel" storage slot for this data structure,
-///      always passed in as IPoolManager.LockData storage self, stores not just the current
+///      that tracks current lockers. The LOCK_DATA storage slot for this data structure,
+///      passed in as a LockData custom type that is a uint256, stores not just the current
 ///      length of the queue but also the global count of non-zero deltas across all lockers.
-///      The values of the data structure start at OFFSET, and each value is a locker address.
+///      The values of the data structure start at LOCKERS, and each value is a locker address.
 library LockDataLibrary {
-    uint256 private constant OFFSET = uint256(keccak256("LockData"));
+    using LockDataLibrary for LockData;
 
-    /// @dev Pushes a locker onto the end of the queue, and updates the sentinel storage slot.
-    function push(IPoolManager.LockData storage self, address locker) internal {
-        // read current value from the sentinel storage slot
-        uint128 length = self.length;
+    uint256 private constant LOCK_DATA = uint256(keccak256("LockData"));
+    uint256 private constant LOCKERS = uint256(keccak256("Lockers"));
+
+    /// @dev Pushes a locker onto the end of the queue at the LOCKERS + length storage slot, and updates the length at the LOCK_DATA storage slot.
+    function push(LockData lockData, address locker) internal {
+        // read current length from the LOCK_DATA storage slot
+        uint128 _length = lockData.length();
         unchecked {
-            uint256 indexToWrite = OFFSET + length; // not in assembly because OFFSET is in the library scope
+            uint256 lockerSlot = LOCKERS + _length; // not in assembly because LOCKERS is in the library scope
+
             /// @solidity memory-safe-assembly
             assembly {
                 // in the next storage slot, write the locker
-                sstore(indexToWrite, locker)
+                sstore(lockerSlot, locker)
             }
-            // update the sentinel storage slot
-            self.length = length + 1;
+            lockData.update(_length + 1, lockData.nonzeroDeltaCount());
         }
     }
 
     /// @dev Pops a locker off the end of the queue. Note that no storage gets cleared.
-    function pop(IPoolManager.LockData storage self) internal {
+    function pop(LockData lockData) internal {
         unchecked {
-            self.length--;
+            lockData.update(lockData.length() - 1, lockData.nonzeroDeltaCount());
+        }
+    }
+
+    function length(LockData lockData) internal pure returns (uint128 _length) {
+        /// @solidity memory-safe-assembly
+        assembly {
+            _length := shr(128, lockData)
+        }
+    }
+
+    function nonzeroDeltaCount(LockData lockData) internal pure returns (uint128 _nonzeroDeltaCount) {
+        /// @solidity memory-safe-assembly
+        assembly {
+            _nonzeroDeltaCount := lockData
+        }
+    }
+
+    function update(LockData lockData, uint128 _length, uint128 _nonzeroDeltaCount) internal {
+        uint256 lockDataSlot = LOCK_DATA;
+        assembly {
+            lockData :=
+                or(
+                    shl(128, _length),
+                    and(0x00000000000000000000000000000000ffffffffffffffffffffffffffffffff, _nonzeroDeltaCount)
+                )
+
+            sstore(lockDataSlot, lockData)
         }
     }
 
     function getLock(uint256 i) internal view returns (address locker) {
         unchecked {
-            uint256 position = OFFSET + i; // not in assembly because OFFSET is in the library scope
+            uint256 position = LOCKERS + i; // not in assembly because LOCKERS is in the library scope
             /// @solidity memory-safe-assembly
             assembly {
                 locker := sload(position)
             }
         }
     }
 
-    function getActiveLock(IPoolManager.LockData storage self) internal view returns (address locker) {
-        return getLock(self.length - 1);
+    function getActiveLock(LockData lockData) internal view returns (address) {
+        uint128 _length;
+        unchecked {
+            _length = lockData.length() - 1;
+        }
+        return getLock(_length);
+    }
+
+    function getLockData() internal view returns (LockData lockData) {
+        uint256 lockDataSlot = LOCK_DATA;
+        assembly {
+            lockData := sload(lockDataSlot)
+        }
     }
 }

contracts/types/LockData.sol

@@ -0,0 +1,12 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+pragma solidity ^0.8.20;
+
+import {LockDataLibrary} from "../libraries/LockDataLibrary.sol";
+
+/// @notice The LockData holds global information for the lock data structure: the length and nonzeroDeltaCount.
+/// @dev The left most 128 bits is the length, or total number of active lockers.
+/// @dev The right most 128 bits is the nonzeroDeltaCount, or total number of nonzero deltas over all active + completed lockers.
+/// @dev Located in transient storage.
+type LockData is uint256;
+
+using LockDataLibrary for LockData global;