diff --git a/src/V4Router.sol b/src/V4Router.sol
index c14ad76a7..f9faffed3 100644
--- a/src/V4Router.sol
+++ b/src/V4Router.sol
@@ -8,7 +8,7 @@ import {Currency} from "@uniswap/v4-core/src/types/Currency.sol";
 import {TickMath} from "@uniswap/v4-core/src/libraries/TickMath.sol";
 import {SafeCast} from "@uniswap/v4-core/src/libraries/SafeCast.sol";
 
-import {PathKey, PathKeyLib} from "./libraries/PathKey.sol";
+import {PathKey, PathKeyLibrary} from "./libraries/PathKey.sol";
 import {CalldataDecoder} from "./libraries/CalldataDecoder.sol";
 import {BipsLibrary} from "./libraries/BipsLibrary.sol";
 import {IV4Router} from "./interfaces/IV4Router.sol";
@@ -25,7 +25,7 @@ import {ActionConstants} from "./libraries/ActionConstants.sol";
 abstract contract V4Router is IV4Router, BaseActionsRouter, DeltaResolver {
     using SafeCastTemp for *;
     using SafeCast for *;
-    using PathKeyLib for PathKey;
+    using PathKeyLibrary for PathKey;
     using CalldataDecoder for bytes;
     using BipsLibrary for uint256;
 
diff --git a/src/base/ERC721Permit_v4.sol b/src/base/ERC721Permit_v4.sol
index aab76f7c2..b700db89d 100644
--- a/src/base/ERC721Permit_v4.sol
+++ b/src/base/ERC721Permit_v4.sol
@@ -3,7 +3,7 @@ pragma solidity ^0.8.0;
 
 import {ERC721} from "solmate/src/tokens/ERC721.sol";
 import {EIP712_v4} from "./EIP712_v4.sol";
-import {ERC721PermitHashLibrary} from "../libraries/ERC721PermitHash.sol";
+import {ERC721PermitHash} from "../libraries/ERC721PermitHash.sol";
 import {SignatureVerification} from "permit2/src/libraries/SignatureVerification.sol";
 
 import {IERC721Permit_v4} from "../interfaces/IERC721Permit_v4.sol";
@@ -17,6 +17,7 @@ abstract contract ERC721Permit_v4 is ERC721, IERC721Permit_v4, EIP712_v4, Unorde
     /// @notice Computes the nameHash and versionHash
     constructor(string memory name_, string memory symbol_) ERC721(name_, symbol_) EIP712_v4(name_) {}
 
+    /// @notice Checks if the block's timestamp is before a signature's deadline
     modifier checkSignatureDeadline(uint256 deadline) {
         if (block.timestamp > deadline) revert SignatureDeadlineExpired();
         _;
@@ -31,7 +32,7 @@ abstract contract ERC721Permit_v4 is ERC721, IERC721Permit_v4, EIP712_v4, Unorde
         // the .verify function checks the owner is non-0
         address owner = _ownerOf[tokenId];
 
-        bytes32 digest = ERC721PermitHashLibrary.hashPermit(spender, tokenId, nonce, deadline);
+        bytes32 digest = ERC721PermitHash.hashPermit(spender, tokenId, nonce, deadline);
         signature.verify(_hashTypedData(digest), owner);
 
         _useUnorderedNonce(owner, nonce);
@@ -47,7 +48,7 @@ abstract contract ERC721Permit_v4 is ERC721, IERC721Permit_v4, EIP712_v4, Unorde
         uint256 nonce,
         bytes calldata signature
     ) external payable checkSignatureDeadline(deadline) {
-        bytes32 digest = ERC721PermitHashLibrary.hashPermitForAll(operator, approved, nonce, deadline);
+        bytes32 digest = ERC721PermitHash.hashPermitForAll(operator, approved, nonce, deadline);
         signature.verify(_hashTypedData(digest), owner);
 
         _useUnorderedNonce(owner, nonce);
diff --git a/src/base/ImmutableState.sol b/src/base/ImmutableState.sol
index 70992aa1d..8e30f1a4b 100644
--- a/src/base/ImmutableState.sol
+++ b/src/base/ImmutableState.sol
@@ -3,7 +3,10 @@ pragma solidity ^0.8.0;
 
 import {IPoolManager} from "@uniswap/v4-core/src/interfaces/IPoolManager.sol";
 
+/// @title Immutable State
+/// @notice A collection of immutable state variables, commonly used across multiple contracts
 contract ImmutableState {
+    /// @notice The Uniswap v4 PoolManager contract
     IPoolManager public immutable poolManager;
 
     constructor(IPoolManager _poolManager) {
diff --git a/src/base/Notifier.sol b/src/base/Notifier.sol
index 2992b6a8b..0b7d1d716 100644
--- a/src/base/Notifier.sol
+++ b/src/base/Notifier.sol
@@ -24,7 +24,16 @@ abstract contract Notifier is INotifier {
     /// @inheritdoc INotifier
     mapping(uint256 tokenId => ISubscriber subscriber) public subscriber;
 
+    /// @notice Only allow callers that are approved as spenders or operators of the tokenId
+    /// @dev to be implemented by the parent contract (PositionManager)
+    /// @param caller the address of the caller
+    /// @param tokenId the tokenId of the position
     modifier onlyIfApproved(address caller, uint256 tokenId) virtual;
+
+    /// @notice Only allow callers that provide the correct config for the tokenId
+    /// @dev to be implemented by the parent contract (PositionManager)
+    /// @param tokenId the tokenId of the position
+    /// @param config the config of the tokenId
     modifier onlyValidConfig(uint256 tokenId, PositionConfig calldata config) virtual;
 
     function _positionConfigs(uint256 tokenId) internal view virtual returns (PositionConfigId storage);
diff --git a/src/base/Permit2Forwarder.sol b/src/base/Permit2Forwarder.sol
index 12e378aae..b7c678683 100644
--- a/src/base/Permit2Forwarder.sol
+++ b/src/base/Permit2Forwarder.sol
@@ -6,6 +6,7 @@ import {IAllowanceTransfer} from "permit2/src/interfaces/IAllowanceTransfer.sol"
 /// @notice PermitForwarder allows permitting this contract as a spender on permit2
 /// @dev This contract does not enforce the spender to be this contract, but that is the intended use case
 contract Permit2Forwarder {
+    /// @notice the Permit2 contract to forward approvals
     IAllowanceTransfer public immutable permit2;
 
     error Wrap__Permit2Reverted(address _permit2, bytes reason);
@@ -16,6 +17,9 @@ contract Permit2Forwarder {
 
     /// @notice allows forwarding a single permit to permit2
     /// @dev this function is payable to allow multicall with NATIVE based actions
+    /// @param owner the owner of the tokens
+    /// @param permitSingle the permit data
+    /// @param signature the signature of the permit; abi.encodePacked(r, s, v)
     function permit(address owner, IAllowanceTransfer.PermitSingle calldata permitSingle, bytes calldata signature)
         external
         payable
@@ -30,6 +34,9 @@ contract Permit2Forwarder {
 
     /// @notice allows forwarding batch permits to permit2
     /// @dev this function is payable to allow multicall with NATIVE based actions
+    /// @param owner the owner of the tokens
+    /// @param _permitBatch a batch of approvals
+    /// @param signature the signature of the permit; abi.encodePacked(r, s, v)
     function permitBatch(address owner, IAllowanceTransfer.PermitBatch calldata _permitBatch, bytes calldata signature)
         external
         payable
diff --git a/src/base/PoolInitializer.sol b/src/base/PoolInitializer.sol
index 2e0918985..1f42ab1ff 100644
--- a/src/base/PoolInitializer.sol
+++ b/src/base/PoolInitializer.sol
@@ -5,7 +5,14 @@ import {ImmutableState} from "./ImmutableState.sol";
 
 import {PoolKey} from "@uniswap/v4-core/src/types/PoolKey.sol";
 
+/// @title Pool Initializer
+/// @notice Initializes a Uniswap v4 Pool
+/// @dev Enables create pool + mint liquidity in a single transaction with multicall
 abstract contract PoolInitializer is ImmutableState {
+    /// @notice Initialize a Uniswap v4 Pool
+    /// @param key the PoolKey of the pool to initialize
+    /// @param sqrtPriceX96 the initial sqrtPriceX96 of the pool
+    /// @param hookData the optional data passed to the hook's initialize functions
     function initializePool(PoolKey calldata key, uint160 sqrtPriceX96, bytes calldata hookData)
         external
         payable
diff --git a/src/base/SafeCallback.sol b/src/base/SafeCallback.sol
index ab80cd845..cda2b4a04 100644
--- a/src/base/SafeCallback.sol
+++ b/src/base/SafeCallback.sol
@@ -5,20 +5,26 @@ import {IUnlockCallback} from "@uniswap/v4-core/src/interfaces/callback/IUnlockC
 import {IPoolManager} from "@uniswap/v4-core/src/interfaces/IPoolManager.sol";
 import {ImmutableState} from "./ImmutableState.sol";
 
+/// @title Safe Callback
+/// @notice A contract that only allows the Uniswap v4 PoolManager to call the unlockCallback
 abstract contract SafeCallback is ImmutableState, IUnlockCallback {
+    /// @notice Thrown when calling unlockCallback where the caller is not PoolManager
     error NotPoolManager();
 
     constructor(IPoolManager _poolManager) ImmutableState(_poolManager) {}
 
+    /// @notice Only allow calls from the PoolManager contract
     modifier onlyPoolManager() {
         if (msg.sender != address(poolManager)) revert NotPoolManager();
         _;
     }
 
+    /// @inheritdoc IUnlockCallback
     /// @dev We force the onlyPoolManager modifier by exposing a virtual function after the onlyPoolManager check.
     function unlockCallback(bytes calldata data) external onlyPoolManager returns (bytes memory) {
         return _unlockCallback(data);
     }
 
+    /// @dev to be implemented by the child contract, to safely guarantee the logic is only executed by the PoolManager
     function _unlockCallback(bytes calldata data) internal virtual returns (bytes memory);
 }
diff --git a/src/base/hooks/BaseHook.sol b/src/base/hooks/BaseHook.sol
index c4c0c6b16..331d513c6 100644
--- a/src/base/hooks/BaseHook.sol
+++ b/src/base/hooks/BaseHook.sol
@@ -9,6 +9,8 @@ import {PoolKey} from "@uniswap/v4-core/src/types/PoolKey.sol";
 import {BeforeSwapDelta} from "@uniswap/v4-core/src/types/BeforeSwapDelta.sol";
 import {SafeCallback} from "../SafeCallback.sol";
 
+/// @title Base Hook
+/// @notice abstract contract for hook implementations
 abstract contract BaseHook is IHooks, SafeCallback {
     error NotSelf();
     error InvalidPool();
@@ -31,11 +33,14 @@ abstract contract BaseHook is IHooks, SafeCallback {
         _;
     }
 
+    /// @notice Returns a struct of permissions to signal which hook functions are to be implemented
+    /// @dev Used at deployment to validate the address correctly represents the expected permissions
     function getHookPermissions() public pure virtual returns (Hooks.Permissions memory);
 
-    // this function is virtual so that we can override it during testing,
-    // which allows us to deploy an implementation to any address
-    // and then etch the bytecode into the correct address
+    /// @notice Validates the deployed hook address agrees with the expected permissions of the hook
+    /// @dev this function is virtual so that we can override it during testing,
+    /// which allows us to deploy an implementation to any address
+    /// and then etch the bytecode into the correct address
     function validateHookAddress(BaseHook _this) internal pure virtual {
         Hooks.validateHookPermissions(_this, getHookPermissions());
     }
@@ -50,10 +55,12 @@ abstract contract BaseHook is IHooks, SafeCallback {
         }
     }
 
+    /// @inheritdoc IHooks
     function beforeInitialize(address, PoolKey calldata, uint160, bytes calldata) external virtual returns (bytes4) {
         revert HookNotImplemented();
     }
 
+    /// @inheritdoc IHooks
     function afterInitialize(address, PoolKey calldata, uint160, int24, bytes calldata)
         external
         virtual
@@ -62,6 +69,7 @@ abstract contract BaseHook is IHooks, SafeCallback {
         revert HookNotImplemented();
     }
 
+    /// @inheritdoc IHooks
     function beforeAddLiquidity(address, PoolKey calldata, IPoolManager.ModifyLiquidityParams calldata, bytes calldata)
         external
         virtual
@@ -70,6 +78,7 @@ abstract contract BaseHook is IHooks, SafeCallback {
         revert HookNotImplemented();
     }
 
+    /// @inheritdoc IHooks
     function beforeRemoveLiquidity(
         address,
         PoolKey calldata,
@@ -79,6 +88,7 @@ abstract contract BaseHook is IHooks, SafeCallback {
         revert HookNotImplemented();
     }
 
+    /// @inheritdoc IHooks
     function afterAddLiquidity(
         address,
         PoolKey calldata,
@@ -89,6 +99,7 @@ abstract contract BaseHook is IHooks, SafeCallback {
         revert HookNotImplemented();
     }
 
+    /// @inheritdoc IHooks
     function afterRemoveLiquidity(
         address,
         PoolKey calldata,
@@ -99,6 +110,7 @@ abstract contract BaseHook is IHooks, SafeCallback {
         revert HookNotImplemented();
     }
 
+    /// @inheritdoc IHooks
     function beforeSwap(address, PoolKey calldata, IPoolManager.SwapParams calldata, bytes calldata)
         external
         virtual
@@ -107,6 +119,7 @@ abstract contract BaseHook is IHooks, SafeCallback {
         revert HookNotImplemented();
     }
 
+    /// @inheritdoc IHooks
     function afterSwap(address, PoolKey calldata, IPoolManager.SwapParams calldata, BalanceDelta, bytes calldata)
         external
         virtual
@@ -115,6 +128,7 @@ abstract contract BaseHook is IHooks, SafeCallback {
         revert HookNotImplemented();
     }
 
+    /// @inheritdoc IHooks
     function beforeDonate(address, PoolKey calldata, uint256, uint256, bytes calldata)
         external
         virtual
@@ -123,6 +137,7 @@ abstract contract BaseHook is IHooks, SafeCallback {
         revert HookNotImplemented();
     }
 
+    /// @inheritdoc IHooks
     function afterDonate(address, PoolKey calldata, uint256, uint256, bytes calldata)
         external
         virtual
diff --git a/src/interfaces/IERC721Permit_v4.sol b/src/interfaces/IERC721Permit_v4.sol
index eab4d1285..bc4c7aa06 100644
--- a/src/interfaces/IERC721Permit_v4.sol
+++ b/src/interfaces/IERC721Permit_v4.sol
@@ -12,6 +12,7 @@ interface IERC721Permit_v4 {
     /// @param spender The account that is being approved
     /// @param tokenId The ID of the token that is being approved for spending
     /// @param deadline The deadline timestamp by which the call must be mined for the approve to work
+    /// @param nonce a unique value, for an owner, to prevent replay attacks; an unordered nonce where the top 248 bits correspond to a word and the bottom 8 bits calculate the bit position of the word
     /// @param signature Concatenated data from a valid secp256k1 signature from the holder, i.e. abi.encodePacked(r, s, v)
     /// @dev payable so it can be multicalled with NATIVE related actions
     function permit(address spender, uint256 tokenId, uint256 deadline, uint256 nonce, bytes calldata signature)
@@ -23,7 +24,7 @@ interface IERC721Permit_v4 {
     /// @param operator The address that will be set as an operator for the owner
     /// @param approved The permission to set on the operator
     /// @param deadline The deadline timestamp by which the call must be mined for the approve to work
-    /// @param nonce The nonce of the owner's permit
+    /// @param nonce a unique value, for an owner, to prevent replay attacks; an unordered nonce where the top 248 bits correspond to a word and the bottom 8 bits calculate the bit position of the word
     /// @param signature Concatenated data from a valid secp256k1 signature from the holder, i.e. abi.encodePacked(r, s, v)
     /// @dev payable so it can be multicalled with NATIVE related actions
     function permitForAll(
diff --git a/src/interfaces/IPositionManager.sol b/src/interfaces/IPositionManager.sol
index 8f7a59c63..ff0e03fde 100644
--- a/src/interfaces/IPositionManager.sol
+++ b/src/interfaces/IPositionManager.sol
@@ -5,11 +5,17 @@ import {PositionConfig} from "../libraries/PositionConfig.sol";
 
 import {INotifier} from "./INotifier.sol";
 
+/// @title IPositionManager
+/// @notice Interface for the PositionManager contract
 interface IPositionManager is INotifier {
+    /// @notice Thrown when the caller is not approved to modify a position
     error NotApproved(address caller);
+    /// @notice Thrown when the block.timestamp exceeds the user-provided deadline
     error DeadlinePassed(uint256 deadline);
+    /// @notice Thrown when the caller provides the incorrect PositionConfig for a corresponding tokenId when modifying liquidity
     error IncorrectPositionConfigForTokenId(uint256 tokenId);
 
+    /// @notice Emitted when a new liquidity position is minted
     event MintPosition(uint256 indexed tokenId, PositionConfig config);
 
     /// @notice Unlocks Uniswap v4 PoolManager and batches actions for modifying liquidity
diff --git a/src/lens/Quoter.sol b/src/lens/Quoter.sol
index ee996043c..4f9741943 100644
--- a/src/lens/Quoter.sol
+++ b/src/lens/Quoter.sol
@@ -9,13 +9,13 @@ import {PoolKey} from "@uniswap/v4-core/src/types/PoolKey.sol";
 import {PoolIdLibrary} from "@uniswap/v4-core/src/types/PoolId.sol";
 import {IQuoter} from "../interfaces/IQuoter.sol";
 import {PoolTicksCounter} from "../libraries/PoolTicksCounter.sol";
-import {PathKey, PathKeyLib} from "../libraries/PathKey.sol";
+import {PathKey, PathKeyLibrary} from "../libraries/PathKey.sol";
 import {StateLibrary} from "@uniswap/v4-core/src/libraries/StateLibrary.sol";
 import {SafeCallback} from "../base/SafeCallback.sol";
 
 contract Quoter is IQuoter, SafeCallback {
     using PoolIdLibrary for PoolKey;
-    using PathKeyLib for PathKey;
+    using PathKeyLibrary for PathKey;
     using StateLibrary for IPoolManager;
 
     /// @dev cache used to check a safety condition in exact output swaps.
@@ -231,7 +231,7 @@ contract Quoter is IQuoter, SafeCallback {
             curAmountOut = i == pathLength ? params.exactAmount : cache.prevAmount;
             amountOutCached = curAmountOut;
 
-            (PoolKey memory poolKey, bool oneForZero) = PathKeyLib.getPoolAndSwapDirection(
+            (PoolKey memory poolKey, bool oneForZero) = PathKeyLibrary.getPoolAndSwapDirection(
                 params.path[i - 1], i == pathLength ? params.exactCurrency : cache.prevCurrency
             );
 
diff --git a/src/libraries/ActionConstants.sol b/src/libraries/ActionConstants.sol
index f51b9600d..914528b02 100644
--- a/src/libraries/ActionConstants.sol
+++ b/src/libraries/ActionConstants.sol
@@ -1,6 +1,9 @@
 // SPDX-License-Identifier: GPL-2.0-or-later
 pragma solidity ^0.8.0;
 
+/// @title Action Constants
+/// @notice Common constants used in actions
+/// @dev Constants are gas efficient alternatives to their literal values
 library ActionConstants {
     /// @notice used to signal that an action should use the input value of the open delta on the pool manager
     /// or of the balance that the contract holds
@@ -9,7 +12,9 @@ library ActionConstants {
     /// This value is equivalent to 1<<255, i.e. a singular 1 in the most significant bit.
     uint256 internal constant CONTRACT_BALANCE = 0x8000000000000000000000000000000000000000000000000000000000000000;
 
-    /// @notice used to signal that the recipient of an action should be the msgSender or address(this)
+    /// @notice used to signal that the recipient of an action should be the msgSender
     address internal constant MSG_SENDER = address(1);
+
+    /// @notice used to signal that the recipient of an action should be the address(this)
     address internal constant ADDRESS_THIS = address(2);
 }
diff --git a/src/libraries/ERC721PermitHash.sol b/src/libraries/ERC721PermitHash.sol
index 1ed5c2baa..a8c9cfc87 100644
--- a/src/libraries/ERC721PermitHash.sol
+++ b/src/libraries/ERC721PermitHash.sol
@@ -1,13 +1,19 @@
 // SPDX-License-Identifier: GPL-2.0-or-later
 pragma solidity ^0.8.0;
 
-library ERC721PermitHashLibrary {
+library ERC721PermitHash {
     /// @dev Value is equal to keccak256("Permit(address spender,uint256 tokenId,uint256 nonce,uint256 deadline)");
     bytes32 constant PERMIT_TYPEHASH = 0x49ecf333e5b8c95c40fdafc95c1ad136e8914a8fb55e9dc8bb01eaa83a2df9ad;
 
     /// @dev Value is equal to keccak256("PermitForAll(address operator,bool approved,uint256 nonce,uint256 deadline)");
     bytes32 constant PERMIT_FOR_ALL_TYPEHASH = 0x6673cb397ee2a50b6b8401653d3638b4ac8b3db9c28aa6870ffceb7574ec2f76;
 
+    /// @notice Hashes the data that will be signed for IERC721Permit_v4.permit()
+    /// @param spender The address which may spend the tokenId
+    /// @param tokenId The tokenId of the owner, which may be spent by spender
+    /// @param nonce A unique non-ordered value for each signature to prevent replay attacks
+    /// @param deadline The time at which the signature expires
+    /// @return digest The hash of the data to be signed; the equivalent to keccak256(abi.encode(PERMIT_TYPEHASH, spender, tokenId, nonce, deadline));
     function hashPermit(address spender, uint256 tokenId, uint256 nonce, uint256 deadline)
         internal
         pure
@@ -32,6 +38,12 @@ library ERC721PermitHashLibrary {
         }
     }
 
+    /// @notice Hashes the data that will be signed for IERC721Permit_v4.permit()
+    /// @param operator The address which may spend any of the owner's tokenIds
+    /// @param approved true if the operator is to have full permission over the owner's tokenIds; false otherwise
+    /// @param nonce A unique non-ordered value for each signature to prevent replay attacks
+    /// @param deadline The time at which the signature expires
+    /// @return digest The hash of the data to be signed; the equivalent to keccak256(abi.encode(PERMIT_FOR_ALL_TYPEHASH, operator, approved, nonce, deadline));
     function hashPermitForAll(address operator, bool approved, uint256 nonce, uint256 deadline)
         internal
         pure
diff --git a/src/libraries/PathKey.sol b/src/libraries/PathKey.sol
index b46fb8b59..b3fa1e7f8 100644
--- a/src/libraries/PathKey.sol
+++ b/src/libraries/PathKey.sol
@@ -13,7 +13,14 @@ struct PathKey {
     bytes hookData;
 }
 
-library PathKeyLib {
+/// @title PathKey Library
+/// @notice Functions for working with PathKeys
+library PathKeyLibrary {
+    /// @notice Get the pool and swap direction for a given PathKey
+    /// @param params the given PathKey
+    /// @param currencyIn the input currency
+    /// @return poolKey the pool key of the swap
+    /// @return zeroForOne the direction of the swap, true if currency0 is being swapped for currency1
     function getPoolAndSwapDirection(PathKey calldata params, Currency currencyIn)
         internal
         pure
diff --git a/src/libraries/PoolTicksCounter.sol b/src/libraries/PoolTicksCounter.sol
index f808e61ca..c101a22fa 100644
--- a/src/libraries/PoolTicksCounter.sol
+++ b/src/libraries/PoolTicksCounter.sol
@@ -6,6 +6,8 @@ import {PoolKey} from "@uniswap/v4-core/src/types/PoolKey.sol";
 import {PoolIdLibrary} from "@uniswap/v4-core/src/types/PoolId.sol";
 import {StateLibrary} from "@uniswap/v4-core/src/libraries/StateLibrary.sol";
 
+/// @title Pool Ticks Counter
+/// @notice Functions for counting the number of initialized ticks between two ticks
 library PoolTicksCounter {
     using PoolIdLibrary for PoolKey;
     using StateLibrary for IPoolManager;
@@ -19,10 +21,16 @@ library PoolTicksCounter {
         bool tickAfterInitialized;
     }
 
+    /// @notice Count the number of initialized ticks between two ticks
     /// @dev This function counts the number of initialized ticks that would incur a gas cost between tickBefore and tickAfter.
     /// When tickBefore and/or tickAfter themselves are initialized, the logic over whether we should count them depends on the
     /// direction of the swap. If we are swapping upwards (tickAfter > tickBefore) we don't want to count tickBefore but we do
     /// want to count tickAfter. The opposite is true if we are swapping downwards.
+    /// @param self the IPoolManager
+    /// @param key the PoolKey of the pool
+    /// @param tickBefore the tick before the swap
+    /// @param tickAfter the tick after the swap
+    /// @return initializedTicksLoaded the number of initialized ticks loaded
     function countInitializedTicksLoaded(IPoolManager self, PoolKey memory key, int24 tickBefore, int24 tickAfter)
         internal
         view
@@ -94,6 +102,8 @@ library PoolTicksCounter {
         return initializedTicksLoaded;
     }
 
+    /// @notice Count the number of set bits in a uint256
+    /// @param x the uint256 to count the bits of
     function countOneBits(uint256 x) private pure returns (uint16) {
         uint16 bits = 0;
         while (x != 0) {
diff --git a/test/erc721Permit/ERC721Permit.permit.t.sol b/test/erc721Permit/ERC721Permit.permit.t.sol
index 654c20c93..e567d08f6 100644
--- a/test/erc721Permit/ERC721Permit.permit.t.sol
+++ b/test/erc721Permit/ERC721Permit.permit.t.sol
@@ -4,7 +4,7 @@ pragma solidity ^0.8.24;
 import "forge-std/Test.sol";
 import {SignatureVerification} from "permit2/src/libraries/SignatureVerification.sol";
 
-import {ERC721PermitHashLibrary} from "../../src/libraries/ERC721PermitHash.sol";
+import {ERC721PermitHash} from "../../src/libraries/ERC721PermitHash.sol";
 import {MockERC721Permit} from "../mocks/MockERC721Permit.sol";
 import {IERC721Permit_v4} from "../../src/interfaces/IERC721Permit_v4.sol";
 import {IERC721} from "forge-std/interfaces/IERC721.sol";
@@ -61,15 +61,15 @@ contract ERC721PermitTest is Test {
     // --- Test the signature-based approvals (permit) ---
     function test_permitTypeHash() public pure {
         assertEq(
-            ERC721PermitHashLibrary.PERMIT_TYPEHASH,
+            ERC721PermitHash.PERMIT_TYPEHASH,
             keccak256("Permit(address spender,uint256 tokenId,uint256 nonce,uint256 deadline)")
         );
     }
 
     function test_fuzz_permitHash(address spender, uint256 tokenId, uint256 nonce, uint256 deadline) public pure {
         bytes32 expectedHash =
-            keccak256(abi.encode(ERC721PermitHashLibrary.PERMIT_TYPEHASH, spender, tokenId, nonce, deadline));
-        assertEq(expectedHash, ERC721PermitHashLibrary.hashPermit(spender, tokenId, nonce, deadline));
+            keccak256(abi.encode(ERC721PermitHash.PERMIT_TYPEHASH, spender, tokenId, nonce, deadline));
+        assertEq(expectedHash, ERC721PermitHash.hashPermit(spender, tokenId, nonce, deadline));
     }
 
     function test_domainSeparator() public view {
@@ -284,7 +284,7 @@ contract ERC721PermitTest is Test {
             abi.encodePacked(
                 "\x19\x01",
                 erc721Permit.DOMAIN_SEPARATOR(),
-                keccak256(abi.encode(ERC721PermitHashLibrary.PERMIT_TYPEHASH, spender, tokenId, nonce, deadline))
+                keccak256(abi.encode(ERC721PermitHash.PERMIT_TYPEHASH, spender, tokenId, nonce, deadline))
             )
         );
     }
diff --git a/test/erc721Permit/ERC721Permit.permitForAll.t.sol b/test/erc721Permit/ERC721Permit.permitForAll.t.sol
index 26c97a463..63e99ad31 100644
--- a/test/erc721Permit/ERC721Permit.permitForAll.t.sol
+++ b/test/erc721Permit/ERC721Permit.permitForAll.t.sol
@@ -4,7 +4,7 @@ pragma solidity ^0.8.24;
 import "forge-std/Test.sol";
 import {SignatureVerification} from "permit2/src/libraries/SignatureVerification.sol";
 
-import {ERC721PermitHashLibrary} from "../../src/libraries/ERC721PermitHash.sol";
+import {ERC721PermitHash} from "../../src/libraries/ERC721PermitHash.sol";
 import {MockERC721Permit} from "../mocks/MockERC721Permit.sol";
 import {IERC721Permit_v4} from "../../src/interfaces/IERC721Permit_v4.sol";
 import {IERC721} from "forge-std/interfaces/IERC721.sol";
@@ -51,15 +51,15 @@ contract ERC721PermitForAllTest is Test {
     // --- Test the signature-based approvals (permitForAll) ---
     function test_permitForAllTypeHash() public pure {
         assertEq(
-            ERC721PermitHashLibrary.PERMIT_FOR_ALL_TYPEHASH,
+            ERC721PermitHash.PERMIT_FOR_ALL_TYPEHASH,
             keccak256("PermitForAll(address operator,bool approved,uint256 nonce,uint256 deadline)")
         );
     }
 
     function test_fuzz_permitForAllHash(address operator, bool approved, uint256 nonce, uint256 deadline) public pure {
         bytes32 expectedHash =
-            keccak256(abi.encode(ERC721PermitHashLibrary.PERMIT_FOR_ALL_TYPEHASH, operator, approved, nonce, deadline));
-        assertEq(expectedHash, ERC721PermitHashLibrary.hashPermitForAll(operator, approved, nonce, deadline));
+            keccak256(abi.encode(ERC721PermitHash.PERMIT_FOR_ALL_TYPEHASH, operator, approved, nonce, deadline));
+        assertEq(expectedHash, ERC721PermitHash.hashPermitForAll(operator, approved, nonce, deadline));
     }
 
     /// @dev operator uses alice's signature to approve itself
@@ -338,9 +338,7 @@ contract ERC721PermitForAllTest is Test {
             abi.encodePacked(
                 "\x19\x01",
                 erc721Permit.DOMAIN_SEPARATOR(),
-                keccak256(
-                    abi.encode(ERC721PermitHashLibrary.PERMIT_FOR_ALL_TYPEHASH, operator, approved, nonce, deadline)
-                )
+                keccak256(abi.encode(ERC721PermitHash.PERMIT_FOR_ALL_TYPEHASH, operator, approved, nonce, deadline))
             )
         );
     }
@@ -354,7 +352,7 @@ contract ERC721PermitForAllTest is Test {
             abi.encodePacked(
                 "\x19\x01",
                 erc721Permit.DOMAIN_SEPARATOR(),
-                keccak256(abi.encode(ERC721PermitHashLibrary.PERMIT_TYPEHASH, spender, tokenId, nonce, deadline))
+                keccak256(abi.encode(ERC721PermitHash.PERMIT_TYPEHASH, spender, tokenId, nonce, deadline))
             )
         );
     }
diff --git a/test/shared/PosmTestSetup.sol b/test/shared/PosmTestSetup.sol
index 345726c4d..5c35c316f 100644
--- a/test/shared/PosmTestSetup.sol
+++ b/test/shared/PosmTestSetup.sol
@@ -15,7 +15,7 @@ import {IAllowanceTransfer} from "permit2/src/interfaces/IAllowanceTransfer.sol"
 import {DeployPermit2} from "permit2/test/utils/DeployPermit2.sol";
 import {HookSavesDelta} from "./HookSavesDelta.sol";
 import {HookModifyLiquidities} from "./HookModifyLiquidities.sol";
-import {ERC721PermitHashLibrary} from "../../src/libraries/ERC721PermitHash.sol";
+import {ERC721PermitHash} from "../../src/libraries/ERC721PermitHash.sol";
 
 /// @notice A shared test contract that wraps the v4-core deployers contract and exposes basic liquidity operations on posm.
 contract PosmTestSetup is Test, Deployers, DeployPermit2, LiquidityOperations {
@@ -104,7 +104,7 @@ contract PosmTestSetup is Test, Deployers, DeployPermit2, LiquidityOperations {
             abi.encodePacked(
                 "\x19\x01",
                 lpm.DOMAIN_SEPARATOR(),
-                keccak256(abi.encode(ERC721PermitHashLibrary.PERMIT_TYPEHASH, spender, tokenId, nonce, deadline))
+                keccak256(abi.encode(ERC721PermitHash.PERMIT_TYPEHASH, spender, tokenId, nonce, deadline))
             )
         );
     }