feat: abstract router

.forge-snapshots/RouterBytecode.snap

@@ -1 +1 @@
-5027
+5925

.forge-snapshots/RouterExactIn1Hop.snap

@@ -1 +1 @@
-195446
+101468

.forge-snapshots/RouterExactIn2Hops.snap

@@ -1 +1 @@
-273998
+160449

.forge-snapshots/RouterExactIn3Hops.snap

@@ -1 +1 @@
-352561
+212680

.forge-snapshots/RouterExactInputSingle.snap

@@ -1 +1 @@
-193868
+106771

.forge-snapshots/RouterExactOut1Hop.snap

@@ -1 +1 @@
-194612
+102242

.forge-snapshots/RouterExactOut2Hops.snap

@@ -1 +1 @@
-274060
+159812

.forge-snapshots/RouterExactOut3Hops.snap

@@ -1 +1 @@
-353539
+212732

.forge-snapshots/RouterExactOutputSingle.snap

@@ -1 +1 @@
-193088
+105380

contracts/V4Router.sol

@@ -1,59 +1,58 @@
 // SPDX-License-Identifier: UNLICENSED
 pragma solidity ^0.8.19;
 
-import {Hooks} from "@uniswap/v4-core/contracts/libraries/Hooks.sol";
-import {IPoolManager} from "@uniswap/v4-core/contracts/interfaces/IPoolManager.sol";
-import {BalanceDelta} from "@uniswap/v4-core/contracts/types/BalanceDelta.sol";
-import {PoolKey} from "@uniswap/v4-core/contracts/types/PoolKey.sol";
-import {Currency, CurrencyLibrary} from "@uniswap/v4-core/contracts/types/Currency.sol";
-import {TickMath} from "@uniswap/v4-core/contracts/libraries/TickMath.sol";
-import {IHooks} from "@uniswap/v4-core/contracts/interfaces/IHooks.sol";
+import {Hooks} from "@uniswap/v4-core/src/libraries/Hooks.sol";
+import {IPoolManager} from "@uniswap/v4-core/src/interfaces/IPoolManager.sol";
+import {IUnlockCallback} from "@uniswap/v4-core/src/interfaces/callback/IUnlockCallback.sol";
+import {BalanceDelta} from "@uniswap/v4-core/src/types/BalanceDelta.sol";
+import {PoolKey} from "@uniswap/v4-core/src/types/PoolKey.sol";
+import {Currency, CurrencyLibrary} from "@uniswap/v4-core/src/types/Currency.sol";
+import {TickMath} from "@uniswap/v4-core/src/libraries/TickMath.sol";
+import {IHooks} from "@uniswap/v4-core/src/interfaces/IHooks.sol";
+import {PathKey} from "./libraries/PathKey.sol";
 import {IV4Router} from "./interfaces/IV4Router.sol";
 
-/// @title UniswapV4Routing
+/// @title UniswapV4Router
 /// @notice Abstract contract that contains all internal logic needed for routing through Uniswap V4 pools
 abstract contract V4Router is IV4Router {
     using CurrencyLibrary for Currency;
 
     IPoolManager immutable poolManager;
 
-    /// @dev Only the pool manager may call this function
-    modifier poolManagerOnly() {
-        if (msg.sender != address(poolManager)) revert NotPoolManager();
-        _;
-    }
-
     constructor(IPoolManager _poolManager) {
         poolManager = _poolManager;
     }
 
     function _v4Swap(SwapType swapType, bytes memory params) internal {
-        poolManager.lock(abi.encode(SwapInfo(swapType, msg.sender, params)));
+        poolManager.unlock(abi.encode(SwapInfo(swapType, msg.sender, params)));
     }
 
-    function lockAcquired(bytes calldata encodedSwapInfo) external poolManagerOnly returns (bytes memory) {
+    /// @inheritdoc IUnlockCallback
+    function unlockCallback(bytes calldata encodedSwapInfo) external override returns (bytes memory) {
+        if (msg.sender != address(poolManager)) revert NotPoolManager();
+
         SwapInfo memory swapInfo = abi.decode(encodedSwapInfo, (SwapInfo));
 
         if (swapInfo.swapType == SwapType.ExactInput) {
-            _swapExactInput(abi.decode(swapInfo.params, (ExactInputParams)), swapInfo.msgSender);
+            _swapExactInput(abi.decode(swapInfo.params, (IV4Router.ExactInputParams)), swapInfo.msgSender);
         } else if (swapInfo.swapType == SwapType.ExactInputSingle) {
-            _swapExactInputSingle(abi.decode(swapInfo.params, (ExactInputSingleParams)), swapInfo.msgSender);
+            _swapExactInputSingle(abi.decode(swapInfo.params, (IV4Router.ExactInputSingleParams)), swapInfo.msgSender);
         } else if (swapInfo.swapType == SwapType.ExactOutput) {
-            _swapExactOutput(abi.decode(swapInfo.params, (ExactOutputParams)), swapInfo.msgSender);
+            _swapExactOutput(abi.decode(swapInfo.params, (IV4Router.ExactOutputParams)), swapInfo.msgSender);
         } else if (swapInfo.swapType == SwapType.ExactOutputSingle) {
-            _swapExactOutputSingle(abi.decode(swapInfo.params, (ExactOutputSingleParams)), swapInfo.msgSender);
+            _swapExactOutputSingle(abi.decode(swapInfo.params, (IV4Router.ExactOutputSingleParams)), swapInfo.msgSender);
         } else {
             revert InvalidSwapType();
         }
 
         return bytes("");
     }
 
-    function _swapExactInputSingle(ExactInputSingleParams memory params, address msgSender) private {
-        _swapExactPrivate(
+    function _swapExactInputSingle(IV4Router.ExactInputSingleParams memory params, address msgSender) private {
+        _swap(
             params.poolKey,
             params.zeroForOne,
-            int256(int128(params.amountIn)),
+            int256(-int128(params.amountIn)),
             params.sqrtPriceLimitX96,
             msgSender,
             true,
@@ -62,18 +61,18 @@ abstract contract V4Router is IV4Router {
         );
     }
 
-    function _swapExactInput(ExactInputParams memory params, address msgSender) private {
+    function _swapExactInput(IV4Router.ExactInputParams memory params, address msgSender) private {
         unchecked {
             uint256 pathLength = params.path.length;
             uint128 amountOut;
 
             for (uint256 i = 0; i < pathLength; i++) {
                 (PoolKey memory poolKey, bool zeroForOne) = _getPoolAndSwapDirection(params.path[i], params.currencyIn);
                 amountOut = uint128(
-                    -_swapExactPrivate(
+                    _swap(
                         poolKey,
                         zeroForOne,
-                        int256(int128(params.amountIn)),
+                        int256(-int128(params.amountIn)),
                         0,
                         msgSender,
                         i == 0,
@@ -90,11 +89,11 @@ abstract contract V4Router is IV4Router {
         }
     }
 
-    function _swapExactOutputSingle(ExactOutputSingleParams memory params, address msgSender) private {
-        _swapExactPrivate(
+    function _swapExactOutputSingle(IV4Router.ExactOutputSingleParams memory params, address msgSender) private {
+        _swap(
             params.poolKey,
             params.zeroForOne,
-            -int256(int128(params.amountOut)),
+            int256(int128(params.amountOut)),
             params.sqrtPriceLimitX96,
             msgSender,
             true,
@@ -103,7 +102,7 @@ abstract contract V4Router is IV4Router {
         );
     }
 
-    function _swapExactOutput(ExactOutputParams memory params, address msgSender) private {
+    function _swapExactOutput(IV4Router.ExactOutputParams memory params, address msgSender) private {
         unchecked {
             uint256 pathLength = params.path.length;
             uint128 amountIn;
@@ -112,10 +111,10 @@ abstract contract V4Router is IV4Router {
                 (PoolKey memory poolKey, bool oneForZero) =
                     _getPoolAndSwapDirection(params.path[i - 1], params.currencyOut);
                 amountIn = uint128(
-                    _swapExactPrivate(
+                    -_swap(
                         poolKey,
                         !oneForZero,
-                        -int256(int128(params.amountOut)),
+                        int256(int128(params.amountOut)),
                         0,
                         msgSender,
                         i == 1,
@@ -131,7 +130,7 @@ abstract contract V4Router is IV4Router {
         }
     }
 
-    function _swapExactPrivate(
+    function _swap(
         PoolKey memory poolKey,
         bool zeroForOne,
         int256 amountSpecified,
@@ -147,20 +146,20 @@ abstract contract V4Router is IV4Router {
                 zeroForOne,
                 amountSpecified,
                 sqrtPriceLimitX96 == 0
-                    ? (zeroForOne ? TickMath.MIN_SQRT_RATIO + 1 : TickMath.MAX_SQRT_RATIO - 1)
+                    ? (zeroForOne ? TickMath.MIN_SQRT_PRICE + 1 : TickMath.MAX_SQRT_PRICE - 1)
                     : sqrtPriceLimitX96
             ),
             hookData
         );
 
         if (zeroForOne) {
-            reciprocalAmount = amountSpecified > 0 ? delta.amount1() : delta.amount0();
+            reciprocalAmount = amountSpecified < 0 ? delta.amount1() : delta.amount0();
             if (settle) _payAndSettle(poolKey.currency0, msgSender, delta.amount0());
-            if (take) poolManager.take(poolKey.currency1, msgSender, uint128(-delta.amount1()));
+            if (take) poolManager.take(poolKey.currency1, msgSender, uint128(delta.amount1()));
         } else {
-            reciprocalAmount = amountSpecified > 0 ? delta.amount0() : delta.amount1();
+            reciprocalAmount = amountSpecified < 0 ? delta.amount0() : delta.amount1();
             if (settle) _payAndSettle(poolKey.currency1, msgSender, delta.amount1());
-            if (take) poolManager.take(poolKey.currency0, msgSender, uint128(-delta.amount0()));
+            if (take) poolManager.take(poolKey.currency0, msgSender, uint128(delta.amount0()));
         }
     }
 
@@ -178,7 +177,8 @@ abstract contract V4Router is IV4Router {
     }
 
     function _payAndSettle(Currency currency, address msgSender, int128 settleAmount) private {
-        _pay(Currency.unwrap(currency), msgSender, address(poolManager), uint256(uint128(settleAmount)));
+        poolManager.sync(currency);
+        _pay(Currency.unwrap(currency), msgSender, address(poolManager), uint256(uint128(-settleAmount)));
         poolManager.settle(currency);
     }
 

contracts/hooks/examples/LimitOrder.sol

@@ -324,7 +324,7 @@ contract LimitOrder is BaseHook {
     ) external selfOnly returns (uint128 amount0Fee, uint128 amount1Fee) {
         int24 tickUpper = tickLower + key.tickSpacing;
 
-        // because `modifyPosition` includes not just principal value but also fees, we cannot allocate
+        // because `modifyLiquidity` includes not just principal value but also fees, we cannot allocate
         // the proceeds pro-rata. if we were to do so, users who have been in a limit order that's partially filled
         // could be unfairly diluted by a user sychronously placing then killing a limit order to skim off fees.
         // to prevent this, we allocate all fee revenue to remaining limit order placers, unless this is the last order.

contracts/interfaces/IPeripheryPayments.sol

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: UNLICENSED
-pragma solidity ^0.8.19;
+pragma solidity ^0.8.20;
 
 import {Currency} from "@uniswap/v4-core/src/types/Currency.sol";
 

contracts/interfaces/IV4Router.sol

@@ -1,18 +1,19 @@
 // SPDX-License-Identifier: UNLICENSED
 pragma solidity ^0.8.19;
 
-import "forge-std/console.sol";
-import {Hooks} from "@uniswap/v4-core/contracts/libraries/Hooks.sol";
-import {IPoolManager} from "@uniswap/v4-core/contracts/interfaces/IPoolManager.sol";
-import {BalanceDelta} from "@uniswap/v4-core/contracts/types/BalanceDelta.sol";
-import {PoolKey} from "@uniswap/v4-core/contracts/types/PoolKey.sol";
-import {Currency, CurrencyLibrary} from "@uniswap/v4-core/contracts/types/Currency.sol";
-import {TickMath} from "@uniswap/v4-core/contracts/libraries/TickMath.sol";
-import {IHooks} from "@uniswap/v4-core/contracts/interfaces/IHooks.sol";
+import {Hooks} from "@uniswap/v4-core/src/libraries/Hooks.sol";
+import {IUnlockCallback} from "@uniswap/v4-core/src/interfaces/callback/IUnlockCallback.sol";
+import {IPoolManager} from "@uniswap/v4-core/src/interfaces/IPoolManager.sol";
+import {BalanceDelta} from "@uniswap/v4-core/src/types/BalanceDelta.sol";
+import {PoolKey} from "@uniswap/v4-core/src/types/PoolKey.sol";
+import {Currency, CurrencyLibrary} from "@uniswap/v4-core/src/types/Currency.sol";
+import {TickMath} from "@uniswap/v4-core/src/libraries/TickMath.sol";
+import {IHooks} from "@uniswap/v4-core/src/interfaces/IHooks.sol";
+import {PathKey} from "../libraries/PathKey.sol";
 
 /// @title UniswapV4Routing
 /// @notice Abstract contract that contains all internal logic needed for routing through Uniswap V4 pools
-interface IV4Router {
+interface IV4Router is IUnlockCallback {
     error NotPoolManager();
     error InvalidSwapType();
     error TooLittleReceived();
@@ -24,14 +25,6 @@ interface IV4Router {
         bytes params;
     }
 
-    struct PathKey {
-        Currency intermediateCurrency;
-        uint24 fee;
-        int24 tickSpacing;
-        IHooks hooks;
-        bytes hookData;
-    }
-
     struct ExactInputSingleParams {
         PoolKey poolKey;
         bool zeroForOne;
@@ -74,6 +67,4 @@ interface IV4Router {
         ExactOutput,
         ExactOutputSingle
     }
-
-    function lockAcquired(bytes calldata encodedSwapInfo) external returns (bytes memory);
 }

test/FullRange.t.sol

@@ -36,7 +36,7 @@ contract TestFullRange is Test, Deployers, GasSnapshot {
         int24 tickSpacing,
         IHooks hooks
     );
-    event ModifyPosition(
+    event ModifyLiquidity(
         PoolId indexed poolId, address indexed sender, int24 tickLower, int24 tickUpper, int256 liquidityDelta
     );
     event Swap(