pancakeswap · ChefSnoopy · Mar 9, 2026 · Mar 9, 2026
diff --git a/src/MixedQuoter.sol b/src/MixedQuoter.sol
@@ -65,11 +65,7 @@ contract MixedQuoter is IMixedQuoter, IPancakeV3SwapCallback, Multicall {
      */
 
     /// @inheritdoc IPancakeV3SwapCallback
-    function pancakeV3SwapCallback(int256 amount0Delta, int256 amount1Delta, bytes memory data)
-        external
-        view
-        override
-    {
+    function pancakeV3SwapCallback(int256 amount0Delta, int256 amount1Delta, bytes memory data) external view override {
         require(amount0Delta > 0 || amount1Delta > 0); // swaps entirely within 0-liquidity regions are not supported
         (address tokenIn, address tokenOut, uint24 fee) = abi.decode(data, (address, address, uint24));
         V3SmartRouterHelper.verifyCallback(factoryV3, tokenIn, tokenOut, fee);
@@ -144,7 +140,8 @@ contract MixedQuoter is IMixedQuoter, IPancakeV3SwapCallback, Multicall {
                 ? (zeroForOne ? TickMath.MIN_SQRT_RATIO + 1 : TickMath.MAX_SQRT_RATIO - 1)
                 : params.sqrtPriceLimitX96,
             abi.encode(params.tokenIn, params.tokenOut, params.fee)
-        ) {} catch (bytes memory reason) {
+        ) {}
+        catch (bytes memory reason) {
             gasEstimate = gasBefore - gasleft();
             return handleV3Revert(reason, pool, gasEstimate);
         }
@@ -273,11 +270,7 @@ contract MixedQuoter is IMixedQuoter, IPancakeV3SwapCallback, Multicall {
                 if (!withContext) {
                     (amountIn,,, gasEstimateForCurAction) = quoteExactInputSingleV3(
                         QuoteExactInputSingleV3Params({
-                            tokenIn: tokenIn,
-                            tokenOut: tokenOut,
-                            amountIn: amountIn,
-                            fee: fee,
-                            sqrtPriceLimitX96: 0
+                            tokenIn: tokenIn, tokenOut: tokenOut, amountIn: amountIn, fee: fee, sqrtPriceLimitX96: 0
                         })
                     );
                 } else {
@@ -292,11 +285,7 @@ contract MixedQuoter is IMixedQuoter, IPancakeV3SwapCallback, Multicall {
                     amountIn += accAmountIn;
                     (swapAmountOut,,, gasEstimateForCurAction) = quoteExactInputSingleV3(
                         QuoteExactInputSingleV3Params({
-                            tokenIn: tokenIn,
-                            tokenOut: tokenOut,
-                            amountIn: amountIn,
-                            fee: fee,
-                            sqrtPriceLimitX96: 0
+                            tokenIn: tokenIn, tokenOut: tokenOut, amountIn: amountIn, fee: fee, sqrtPriceLimitX96: 0
                         })
                     );
                     MixedQuoterRecorder.setPoolSwapTokenAccumulation(poolHash, amountIn, swapAmountOut, zeroForOne);
@@ -383,10 +372,7 @@ contract MixedQuoter is IMixedQuoter, IPancakeV3SwapCallback, Multicall {
                 if (!withContext) {
                     (amountIn, gasEstimateForCurAction) = quoteExactInputSingleStable(
                         QuoteExactInputSingleStableParams({
-                            tokenIn: tokenIn,
-                            tokenOut: tokenOut,
-                            amountIn: amountIn,
-                            flag: 2
+                            tokenIn: tokenIn, tokenOut: tokenOut, amountIn: amountIn, flag: 2
                         })
                     );
                 } else {
@@ -400,10 +386,7 @@ contract MixedQuoter is IMixedQuoter, IPancakeV3SwapCallback, Multicall {
                     amountIn += accAmountIn;
                     (swapAmountOut, gasEstimateForCurAction) = quoteExactInputSingleStable(
                         QuoteExactInputSingleStableParams({
-                            tokenIn: tokenIn,
-                            tokenOut: tokenOut,
-                            amountIn: amountIn,
-                            flag: 2
+                            tokenIn: tokenIn, tokenOut: tokenOut, amountIn: amountIn, flag: 2
                         })
                     );
                     MixedQuoterRecorder.setPoolSwapTokenAccumulation(poolHash, amountIn, swapAmountOut, zeroForOne);
@@ -415,10 +398,7 @@ contract MixedQuoter is IMixedQuoter, IPancakeV3SwapCallback, Multicall {
                 // params[actionIndex] is zero bytes
                 (amountIn, gasEstimateForCurAction) = quoteExactInputSingleStable(
                     QuoteExactInputSingleStableParams({
-                        tokenIn: tokenIn,
-                        tokenOut: tokenOut,
-                        amountIn: amountIn,
-                        flag: 3
+                        tokenIn: tokenIn, tokenOut: tokenOut, amountIn: amountIn, flag: 3
                     })
                 );
             } else {

diff --git a/src/interfaces/IERC721Permit.sol b/src/interfaces/IERC721Permit.sol
@@ -21,7 +21,5 @@ interface IERC721Permit is IERC721 {
     /// @param v Must produce valid secp256k1 signature from the holder along with `r` and `s`
     /// @param r Must produce valid secp256k1 signature from the holder along with `v` and `s`
     /// @param s Must produce valid secp256k1 signature from the holder along with `r` and `v`
-    function permit(address spender, uint256 tokenId, uint256 deadline, uint8 v, bytes32 r, bytes32 s)
-        external
-        payable;
+    function permit(address spender, uint256 tokenId, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external payable;
 }
diff --git a/src/interfaces/ISelfPermit.sol b/src/interfaces/ISelfPermit.sol
@@ -12,9 +12,7 @@ interface ISelfPermit {
     /// @param v Must produce valid secp256k1 signature from the holder along with `r` and `s`
     /// @param r Must produce valid secp256k1 signature from the holder along with `v` and `s`
     /// @param s Must produce valid secp256k1 signature from the holder along with `r` and `v`
-    function selfPermit(address token, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s)
-        external
-        payable;
+    function selfPermit(address token, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external payable;
 
     /// @notice Permits this contract to spend a given token from `msg.sender`
     /// @dev The `owner` is always msg.sender and the `spender` is always address(this).

diff --git a/src/libraries/CalldataDecoder.sol b/src/libraries/CalldataDecoder.sol
@@ -143,11 +143,7 @@ library CalldataDecoder {
     }
 
     /// @dev equivalent to: abi.decode(params, (Currency, uint256)) in calldata
-    function decodeCurrencyAndUint256(bytes calldata params)
-        internal
-        pure
-        returns (Currency currency, uint256 amount)
-    {
+    function decodeCurrencyAndUint256(bytes calldata params) internal pure returns (Currency currency, uint256 amount) {
         assembly ("memory-safe") {
             if lt(params.length, 0x40) {
                 mstore(0, SLICE_ERROR_SELECTOR)

diff --git a/src/libraries/external/V3SmartRouterHelper.sol b/src/libraries/external/V3SmartRouterHelper.sol
@@ -12,7 +12,6 @@ library V3SmartRouterHelper {
     /**
      * Stable *************************************************
      */
-
     // get the pool info in stable swap
     function getStableInfo(address stableSwapFactory, address input, address output, uint256 flag)
         internal

diff --git a/src/pool-bin/interfaces/IBinQuoter.sol b/src/pool-bin/interfaces/IBinQuoter.sol
@@ -40,9 +40,7 @@ interface IBinQuoter is IQuoter {
     /// exactAmount The desired input amount
     /// @return amountOut The output quote for the exactIn swap
     /// @return gasEstimate Estimated gas units used for the swap
-    function quoteExactInput(QuoteExactParams memory params)
-        external
-        returns (uint256 amountOut, uint256 gasEstimate);
+    function quoteExactInput(QuoteExactParams memory params) external returns (uint256 amountOut, uint256 gasEstimate);
 
     /// @notice Returns the delta amounts for a given exact output swap of a single pool
     /// @param params The params for the quote, encoded as `QuoteExactSingleParams`
@@ -63,7 +61,5 @@ interface IBinQuoter is IQuoter {
     /// exactAmount The desired output amount
     /// @return amountIn The input quote for the exactOut swap
     /// @return gasEstimate Estimated gas units used for the swap
-    function quoteExactOutput(QuoteExactParams memory params)
-        external
-        returns (uint256 amountIn, uint256 gasEstimate);
+    function quoteExactOutput(QuoteExactParams memory params) external returns (uint256 amountIn, uint256 gasEstimate);
 }
diff --git a/src/pool-cl/CLPositionManager.sol b/src/pool-cl/CLPositionManager.sol
@@ -452,10 +452,7 @@ contract CLPositionManager is
         (liquidityDelta, feesAccrued) = clPoolManager.modifyLiquidity(
             poolKey,
             ICLPoolManager.ModifyLiquidityParams({
-                tickLower: info.tickLower(),
-                tickUpper: info.tickUpper(),
-                liquidityDelta: liquidityChange,
-                salt: salt
+                tickLower: info.tickLower(), tickUpper: info.tickUpper(), liquidityDelta: liquidityChange, salt: salt
             }),
             hookData
         );
@@ -494,11 +491,7 @@ contract CLPositionManager is
     }
 
     /// @inheritdoc ICLPositionManager
-    function getPoolAndPositionInfo(uint256 tokenId)
-        public
-        view
-        returns (PoolKey memory poolKey, CLPositionInfo info)
-    {
+    function getPoolAndPositionInfo(uint256 tokenId) public view returns (PoolKey memory poolKey, CLPositionInfo info) {
         info = positionInfo[tokenId];
         poolKey = poolKeys[info.poolId()];
     }

diff --git a/src/pool-cl/CLRouterBase.sol b/src/pool-cl/CLRouterBase.sol
@@ -30,8 +30,8 @@ abstract contract CLRouterBase is ICLRouterBase, DeltaResolver {
                 _getFullCredit(params.zeroForOne ? params.poolKey.currency0 : params.poolKey.currency1).toUint128();
         }
         uint128 amountOut = _swapExactPrivate(
-            params.poolKey, params.zeroForOne, -int256(uint256(amountIn)), params.hookData
-        ).toUint128();
+                params.poolKey, params.zeroForOne, -int256(uint256(amountIn)), params.hookData
+            ).toUint128();
         if (amountOut < params.amountOutMinimum) {
             revert IInfinityRouter.TooLittleReceived(params.amountOutMinimum, amountOut);
         }
@@ -70,9 +70,10 @@ abstract contract CLRouterBase is ICLRouterBase, DeltaResolver {
             amountOut =
                 _getFullDebt(params.zeroForOne ? params.poolKey.currency1 : params.poolKey.currency0).toUint128();
         }
-        uint128 amountIn = (
-            -_swapExactPrivate(params.poolKey, params.zeroForOne, int256(uint256(amountOut)), params.hookData)
-        ).toUint128();
+        uint128 amountIn = (-_swapExactPrivate(
+                params.poolKey, params.zeroForOne, int256(uint256(amountOut)), params.hookData
+            ))
+        .toUint128();
         if (amountIn > params.amountInMaximum) {
             revert IInfinityRouter.TooMuchRequested(params.amountInMaximum, amountIn);
         }
@@ -95,11 +96,10 @@ abstract contract CLRouterBase is ICLRouterBase, DeltaResolver {
                 pathKey = params.path[i - 1];
                 (PoolKey memory poolKey, bool oneForZero) = pathKey.getPoolAndSwapDirection(currencyOut);
                 // The output delta will always be negative, except for when interacting with certain hook pools
-                amountIn = (
-                    uint256(
+                amountIn = (uint256(
                         -int256(_swapExactPrivate(poolKey, !oneForZero, int256(uint256(amountOut)), pathKey.hookData))
-                    )
-                ).toUint128();
+                    ))
+                .toUint128();
 
                 amountOut = amountIn;
                 currencyOut = pathKey.intermediateCurrency;

diff --git a/src/pool-cl/base/CLNotifier.sol b/src/pool-cl/base/CLNotifier.sol
@@ -95,8 +95,9 @@ abstract contract CLNotifier is ICLNotifier {
         // remove the subscriber
         delete subscriber[tokenId];
 
-        bool success =
-            _call(_subscriber, abi.encodeCall(ICLSubscriber.notifyBurn, (tokenId, owner, info, liquidity, feesAccrued)));
+        bool success = _call(
+            _subscriber, abi.encodeCall(ICLSubscriber.notifyBurn, (tokenId, owner, info, liquidity, feesAccrued))
+        );
 
         if (!success) {
             _subscriber.bubbleUpAndRevertWith(ICLSubscriber.notifyBurn.selector, BurnNotificationReverted.selector);

diff --git a/src/pool-cl/base/ERC721Permit.sol b/src/pool-cl/base/ERC721Permit.sol
@@ -93,7 +93,8 @@ abstract contract ERC721Permit is ERC721, IERC721Permit, EIP712, UnorderedNonce
     }
 
     function _isApprovedOrOwner(address spender, uint256 tokenId) internal view returns (bool) {
-        return spender == ownerOf(tokenId) || getApproved[tokenId] == spender
-            || isApprovedForAll[ownerOf(tokenId)][spender];
+        return
+            spender == ownerOf(tokenId) || getApproved[tokenId] == spender
+                || isApprovedForAll[ownerOf(tokenId)][spender];
     }
 }
diff --git a/src/pool-cl/interfaces/ICLQuoter.sol b/src/pool-cl/interfaces/ICLQuoter.sol
@@ -40,9 +40,7 @@ interface ICLQuoter is IQuoter {
     /// exactAmount The desired input amount
     /// @return amountOut The output quote for the exactIn swap
     /// @return gasEstimate Estimated gas units used for the swap
-    function quoteExactInput(QuoteExactParams memory params)
-        external
-        returns (uint256 amountOut, uint256 gasEstimate);
+    function quoteExactInput(QuoteExactParams memory params) external returns (uint256 amountOut, uint256 gasEstimate);
 
     /// @notice Returns the delta amounts for a given exact output swap of a single pool
     /// @param params The params for the quote, encoded as `QuoteExactSingleParams`
@@ -63,7 +61,5 @@ interface ICLQuoter is IQuoter {
     /// exactAmount The desired output amount
     /// @return amountIn The input quote for the exactOut swap
     /// @return gasEstimate Estimated gas units used for the swap
-    function quoteExactOutput(QuoteExactParams memory params)
-        external
-        returns (uint256 amountIn, uint256 gasEstimate);
+    function quoteExactOutput(QuoteExactParams memory params) external returns (uint256 amountIn, uint256 gasEstimate);
 }
diff --git a/src/pool-cl/lens/CLQuoter.sol b/src/pool-cl/lens/CLQuoter.sol
@@ -52,10 +52,7 @@ contract CLQuoter is ICLQuoter, BaseInfinityQuoter {
     }
 
     /// @inheritdoc ICLQuoter
-    function quoteExactInput(QuoteExactParams memory params)
-        external
-        returns (uint256 amountOut, uint256 gasEstimate)
-    {
+    function quoteExactInput(QuoteExactParams memory params) external returns (uint256 amountOut, uint256 gasEstimate) {
         uint256 gasBefore = gasleft();
         try vault.lock(abi.encodeCall(this._quoteExactInput, (params))) {}
         catch (bytes memory reason) {
@@ -80,10 +77,7 @@ contract CLQuoter is ICLQuoter, BaseInfinityQuoter {
     }
 
     /// @inheritdoc ICLQuoter
-    function quoteExactOutput(QuoteExactParams memory params)
-        external
-        returns (uint256 amountIn, uint256 gasEstimate)
-    {
+    function quoteExactOutput(QuoteExactParams memory params) external returns (uint256 amountIn, uint256 gasEstimate) {
         uint256 gasBefore = gasleft();
         try vault.lock(abi.encodeCall(this._quoteExactOutput, (params))) {}
         catch (bytes memory reason) {

diff --git a/src/pool-cl/lens/TickLens.sol b/src/pool-cl/lens/TickLens.sol
@@ -59,9 +59,7 @@ contract TickLens is ITickLens {
                 int24 populatedTick = ((int24(tickBitmapIndex) << 8) + int24(int256(i))) * tickSpacing;
                 Tick.Info memory tickInfo = poolManager.getPoolTickInfo(id, populatedTick);
                 populatedTicks[--numberOfPopulatedTicks] = PopulatedTick({
-                    tick: populatedTick,
-                    liquidityNet: tickInfo.liquidityNet,
-                    liquidityGross: tickInfo.liquidityGross
+                    tick: populatedTick, liquidityNet: tickInfo.liquidityNet, liquidityGross: tickInfo.liquidityGross
                 });
             }
         }

diff --git a/src/pool-cl/libraries/CLPositionInfoLibrary.sol b/src/pool-cl/libraries/CLPositionInfoLibrary.sol
@@ -96,11 +96,10 @@ library CLPositionInfoLibrary {
     {
         bytes25 _poolId = bytes25(PoolId.unwrap(_poolKey.toId()));
         assembly {
-            info :=
-                or(
-                    or(and(MASK_UPPER_200_BITS, _poolId), shl(TICK_UPPER_OFFSET, and(MASK_24_BITS, _tickUpper))),
-                    shl(TICK_LOWER_OFFSET, and(MASK_24_BITS, _tickLower))
-                )
+            info := or(
+                or(and(MASK_UPPER_200_BITS, _poolId), shl(TICK_UPPER_OFFSET, and(MASK_24_BITS, _tickUpper))),
+                shl(TICK_LOWER_OFFSET, and(MASK_24_BITS, _tickLower))
+            )
         }
     }
 }
diff --git a/src/pool-cl/libraries/LiquidityAmounts.sol b/src/pool-cl/libraries/LiquidityAmounts.sol
@@ -56,7 +56,9 @@ library LiquidityAmounts {
         uint256 amount0,
         uint256 amount1
     ) internal pure returns (uint128 liquidity) {
-        if (sqrtRatioAX96 > sqrtRatioBX96) (sqrtRatioAX96, sqrtRatioBX96) = (sqrtRatioBX96, sqrtRatioAX96);
+        if (sqrtRatioAX96 > sqrtRatioBX96) {
+            (sqrtRatioAX96, sqrtRatioBX96) = (sqrtRatioBX96, sqrtRatioAX96);
+        }
 
         if (sqrtRatioX96 <= sqrtRatioAX96) {
             liquidity = getLiquidityForAmount0(sqrtRatioAX96, sqrtRatioBX96, amount0);
@@ -116,7 +118,9 @@ library LiquidityAmounts {
         uint160 sqrtRatioBX96,
         uint128 liquidity
     ) internal pure returns (uint256 amount0, uint256 amount1) {
-        if (sqrtRatioAX96 > sqrtRatioBX96) (sqrtRatioAX96, sqrtRatioBX96) = (sqrtRatioBX96, sqrtRatioAX96);
+        if (sqrtRatioAX96 > sqrtRatioBX96) {
+            (sqrtRatioAX96, sqrtRatioBX96) = (sqrtRatioBX96, sqrtRatioAX96);
+        }
 
         if (sqrtRatioX96 <= sqrtRatioAX96) {
             amount0 = getAmount0ForLiquidity(sqrtRatioAX96, sqrtRatioBX96, liquidity);

diff --git a/test/MixedQuoter.t.sol b/test/MixedQuoter.t.sol
@@ -846,10 +846,7 @@ contract MixedQuoterTest is
 
         (uint256 _amountOut, uint256 _gasEstimate) = clQuoter.quoteExactInputSingle(
             IQuoter.QuoteExactSingleParams({
-                poolKey: poolKey,
-                zeroForOne: true,
-                exactAmount: 1 ether,
-                hookData: ZERO_BYTES
+                poolKey: poolKey, zeroForOne: true, exactAmount: 1 ether, hookData: ZERO_BYTES
             })
         );
         assertEq(_amountOut, amountOut);
@@ -1036,10 +1033,7 @@ contract MixedQuoterTest is
 
         (uint256 _amountOut, uint256 _gasEstimate) = clQuoter.quoteExactInputSingle(
             IQuoter.QuoteExactSingleParams({
-                poolKey: poolKey,
-                zeroForOne: false,
-                exactAmount: 1 ether,
-                hookData: ZERO_BYTES
+                poolKey: poolKey, zeroForOne: false, exactAmount: 1 ether, hookData: ZERO_BYTES
             })
         );
         assertEq(_amountOut, amountOut);
@@ -1072,10 +1066,7 @@ contract MixedQuoterTest is
 
         (uint256 _amountOut, uint256 _gasEstimate) = clQuoter.quoteExactInputSingle(
             IQuoter.QuoteExactSingleParams({
-                poolKey: poolKeyWithWETH,
-                zeroForOne: true,
-                exactAmount: 1 ether,
-                hookData: ZERO_BYTES
+                poolKey: poolKeyWithWETH, zeroForOne: true, exactAmount: 1 ether, hookData: ZERO_BYTES
             })
         );
         assertEq(_amountOut, amountOut);
@@ -1102,10 +1093,7 @@ contract MixedQuoterTest is
 
         (uint256 _amountOut, uint256 _gasEstimate) = binQuoter.quoteExactInputSingle(
             IQuoter.QuoteExactSingleParams({
-                poolKey: binPoolKey,
-                zeroForOne: true,
-                exactAmount: 1 ether,
-                hookData: ZERO_BYTES
+                poolKey: binPoolKey, zeroForOne: true, exactAmount: 1 ether, hookData: ZERO_BYTES
             })
         );
         assertEq(_amountOut, amountOut);
@@ -1285,10 +1273,7 @@ contract MixedQuoterTest is
 
         (uint256 _amountOut, uint256 _gasEstimate) = binQuoter.quoteExactInputSingle(
             IQuoter.QuoteExactSingleParams({
-                poolKey: binPoolKey,
-                zeroForOne: false,
-                exactAmount: 1 ether,
-                hookData: ZERO_BYTES
+                poolKey: binPoolKey, zeroForOne: false, exactAmount: 1 ether, hookData: ZERO_BYTES
             })
         );
         assertEq(_amountOut, amountOut);

diff --git a/test/Multicall.t.sol b/test/Multicall.t.sol
@@ -29,8 +29,9 @@ contract MulticallTest is Test {
 
     function test_multicall_firstRevert() public {
         bytes[] memory calls = new bytes[](2);
-        calls[0] =
-            abi.encodeWithSelector(MockMulticall(multicall).functionThatRevertsWithString.selector, "First call failed");
+        calls[0] = abi.encodeWithSelector(
+            MockMulticall(multicall).functionThatRevertsWithString.selector, "First call failed"
+        );
         calls[1] = abi.encodeWithSelector(MockMulticall(multicall).functionThatReturnsTuple.selector, 1, 2);
 
         vm.expectRevert("First call failed");