Routing

.forge-snapshots/BaseActionsRouter_mock10commands.snap

@@ -1 +1 @@
-62824
+62960

.forge-snapshots/PositionManager_collect.snap

@@ -1 +1 @@
-162252
+162329

.forge-snapshots/PositionManager_collect_native.snap

@@ -1 +1 @@
-153467
+153544

.forge-snapshots/PositionManager_collect_sameRange.snap

@@ -1 +1 @@
-162252
+162329

.forge-snapshots/PositionManager_decreaseLiquidity.snap

@@ -1 +1 @@
-127630
+127707

.forge-snapshots/PositionManager_decreaseLiquidity_native.snap

@@ -1 +1 @@
-119010
+119087

.forge-snapshots/PositionManager_decrease_sameRange_allLiquidity.snap

@@ -1 +1 @@
-140511
+140588

.forge-snapshots/PositionManager_increaseLiquidity_erc20.snap

@@ -1 +1 @@
-156808
+156885

.forge-snapshots/PositionManager_increaseLiquidity_native.snap

@@ -1 +1 @@
-142246
+142323

.forge-snapshots/PositionManager_increase_autocompoundExactUnclaimedFees.snap

@@ -1 +1 @@
-148668
+148711

.forge-snapshots/PositionManager_increase_autocompoundExcessFeesCredit.snap

@@ -1 +1 @@
-184822
+184899

.forge-snapshots/PositionManager_mint.snap

@@ -1 +1 @@
-417817
+417894

.forge-snapshots/PositionManager_mint_native.snap

@@ -1 +1 @@
-366027
+366104

.forge-snapshots/PositionManager_mint_nativeWithSweep.snap

@@ -1 +1 @@
-372965
+373042

.forge-snapshots/PositionManager_mint_onSameTickLower.snap

@@ -1 +1 @@
-360499
+360576

.forge-snapshots/PositionManager_mint_onSameTickUpper.snap

@@ -1 +1 @@
-361141
+361218

.forge-snapshots/PositionManager_mint_sameRange.snap

@@ -1 +1 @@
-286723
+286800

.forge-snapshots/PositionManager_mint_warmedPool_differentRange.snap

@@ -1 +1 @@
-366517
+366594

.forge-snapshots/PositionManager_multicall_initialize_mint.snap

@@ -1 +1 @@
-462307
+462384

.forge-snapshots/V4Router_Bytecode.snap

@@ -0,0 +1 @@
+6189

.forge-snapshots/V4Router_ExactIn1Hop.snap

@@ -0,0 +1 @@
+136315

.forge-snapshots/V4Router_ExactIn2Hops.snap

@@ -0,0 +1 @@
+187572

.forge-snapshots/V4Router_ExactIn3Hops.snap

@@ -0,0 +1 @@
+245746

.forge-snapshots/V4Router_ExactInputSingle.snap

@@ -0,0 +1 @@
+135175

.forge-snapshots/V4Router_ExactOut1Hop.snap

@@ -0,0 +1 @@
+135133

.forge-snapshots/V4Router_ExactOut2Hops.snap

@@ -0,0 +1 @@
+187005

.forge-snapshots/V4Router_ExactOut3Hops.snap

@@ -0,0 +1 @@
+243778

.forge-snapshots/V4Router_ExactOutputSingle.snap

@@ -0,0 +1 @@
+133709

src/V4Router.sol

@@ -0,0 +1,160 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.8.19;
+
+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 {PathKey, PathKeyLib} from "./libraries/PathKey.sol";
+import {CalldataBytesLib} from "./libraries/CalldataBytesLib.sol";
+import {IV4Router} from "./interfaces/IV4Router.sol";
+import {BaseActionsRouter} from "./base/BaseActionsRouter.sol";
+import {DeltaResolver} from "./base/DeltaResolver.sol";
+import {Actions} from "./libraries/Actions.sol";
+
+/// @title UniswapV4Router
+/// @notice Abstract contract that contains all internal logic needed for routing through Uniswap V4 pools
+/// @dev the entry point to executing actions in this contract is calling `BaseActionsRouter._executeActions`
+/// An inheriting contract should call _executeActions at the point that they wish actions to be executed
+abstract contract V4Router is IV4Router, BaseActionsRouter, DeltaResolver {
+    using PathKeyLib for PathKey;
+    using CalldataBytesLib for bytes;
+
+    constructor(IPoolManager poolManager) BaseActionsRouter(poolManager) {}
+
+    // TODO native support !!
+    function _handleAction(uint256 action, bytes calldata params) internal override {
+        // swap actions and payment actions in different blocks for gas efficiency
+        if (action < Actions.SETTLE) {
+            if (action == Actions.SWAP_EXACT_IN) {
+                _swapExactInput(abi.decode(params, (IV4Router.ExactInputParams)));
+            } else if (action == Actions.SWAP_EXACT_IN_SINGLE) {
+                _swapExactInputSingle(abi.decode(params, (IV4Router.ExactInputSingleParams)));
+            } else if (action == Actions.SWAP_EXACT_OUT) {
+                _swapExactOutput(abi.decode(params, (IV4Router.ExactOutputParams)));
+            } else if (action == Actions.SWAP_EXACT_OUT_SINGLE) {
+                _swapExactOutputSingle(abi.decode(params, (IV4Router.ExactOutputSingleParams)));
+            } else {
+                revert UnsupportedAction(action);
+            }
+        } else {
+            if (action == Actions.SETTLE) {
+                // equivalent: abi.decode(params, (Currency, uint256))
+                Currency currency;
+                uint256 amount;
+                assembly ("memory-safe") {
+                    currency := calldataload(params.offset)
+                    amount := calldataload(add(params.offset, 0x20))
+                }
+
+                // TODO support address(this) paying too
+                // TODO should it have a maxAmountOut added slippage protection?
+                _settle(currency, _msgSender(), amount);
+            } else if (action == Actions.TAKE) {
+                // equivalent: abi.decode(params, (Currency, address, uint256))
+                Currency currency;
+                address recipient;
+                uint256 amount;
+                assembly ("memory-safe") {
+                    currency := calldataload(params.offset)
+                    recipient := calldataload(add(params.offset, 0x20))
+                    amount := calldataload(add(params.offset, 0x40))
+                }
+
+                // TODO should _take have a minAmountOut added slippage check?
+                _take(currency, recipient, amount);
+            } else {
+                revert UnsupportedAction(action);
+            }
+        }
+    }
+
+    function _swapExactInputSingle(IV4Router.ExactInputSingleParams memory params) private {
+        _swap(
+            params.poolKey,
+            params.zeroForOne,
+            int256(-int128(params.amountIn)),
+            params.sqrtPriceLimitX96,
+            params.hookData
+        );
+    }
+
+    function _swapExactInput(IV4Router.ExactInputParams memory params) private {
+        unchecked {
+            // Caching for gas savings
+            uint256 pathLength = params.path.length;
+            uint128 amountOut;
+            uint128 amountIn = params.amountIn;
+            Currency currencyIn = params.currencyIn;
+            PathKey memory pathKey;
+
+            for (uint256 i = 0; i < pathLength; i++) {
+                pathKey = params.path[i];
+                (PoolKey memory poolKey, bool zeroForOne) = pathKey.getPoolAndSwapDirection(currencyIn);
+                amountOut = uint128(_swap(poolKey, zeroForOne, -int256(uint256(amountIn)), 0, pathKey.hookData));
+
+                amountIn = amountOut;
+                currencyIn = pathKey.intermediateCurrency;
+            }
+
+            if (amountOut < params.amountOutMinimum) revert TooLittleReceived();
+        }
+    }
+
+    function _swapExactOutputSingle(IV4Router.ExactOutputSingleParams memory params) private {
+        _swap(
+            params.poolKey,
+            params.zeroForOne,
+            int256(int128(params.amountOut)),
+            params.sqrtPriceLimitX96,
+            params.hookData
+        );
+    }
+
+    function _swapExactOutput(IV4Router.ExactOutputParams memory params) private {
+        unchecked {
+            // Caching for gas savings
+            uint256 pathLength = params.path.length;
+            uint128 amountIn;
+            uint128 amountOut = params.amountOut;
+            Currency currencyOut = params.currencyOut;
+            PathKey memory pathKey;
+
+            for (uint256 i = pathLength; i > 0; i--) {
+                pathKey = params.path[i - 1];
+                (PoolKey memory poolKey, bool oneForZero) = pathKey.getPoolAndSwapDirection(currencyOut);
+                amountIn = uint128(-_swap(poolKey, !oneForZero, int256(uint256(amountOut)), 0, pathKey.hookData));
+
+                amountOut = amountIn;
+                currencyOut = pathKey.intermediateCurrency;
+            }
+            if (amountIn > params.amountInMaximum) revert TooMuchRequested();
+        }
+    }
+
+    function _swap(
+        PoolKey memory poolKey,
+        bool zeroForOne,
+        int256 amountSpecified,
+        uint160 sqrtPriceLimitX96,
+        bytes memory hookData
+    ) private returns (int128 reciprocalAmount) {
+        unchecked {
+            BalanceDelta delta = poolManager.swap(
+                poolKey,
+                IPoolManager.SwapParams(
+                    zeroForOne,
+                    amountSpecified,
+                    sqrtPriceLimitX96 == 0
+                        ? (zeroForOne ? TickMath.MIN_SQRT_PRICE + 1 : TickMath.MAX_SQRT_PRICE - 1)
+                        : sqrtPriceLimitX96
+                ),
+                hookData
+            );
+
+            reciprocalAmount = (zeroForOne == amountSpecified < 0) ? delta.amount1() : delta.amount0();
+        }
+    }
+}

src/base/BaseActionsRouter.sol

@@ -3,15 +3,15 @@ pragma solidity ^0.8.24;
 
 import {IPoolManager} from "@uniswap/v4-core/src/interfaces/IPoolManager.sol";
 import {SafeCallback} from "./SafeCallback.sol";
-import {BytesLib} from "../libraries/BytesLib.sol";
+import {CalldataBytesLib} from "../libraries/CalldataBytesLib.sol";
 
 /// @notice Abstract contract for performing a combination of actions on Uniswap v4.
 /// @dev Suggested uint256 action values are defined in Actions.sol, however any definition can be used
 abstract contract BaseActionsRouter is SafeCallback {
-    using BytesLib for bytes;
+    using CalldataBytesLib for bytes;
 
     /// @notice emitted when different numbers of parameters and actions are provided
-    error LengthMismatch();
+    error InputLengthMismatch();
 
     /// @notice emitted when an inheriting contract does not support an action
     error UnsupportedAction(uint256 action);
@@ -30,7 +30,7 @@ abstract contract BaseActionsRouter is SafeCallback {
         (uint256[] calldata actions, bytes[] calldata params) = data.decodeInCalldata();
 
         uint256 numActions = actions.length;
-        if (numActions != params.length) revert LengthMismatch();
+        if (numActions != params.length) revert InputLengthMismatch();
 
         for (uint256 actionIndex = 0; actionIndex < numActions; actionIndex++) {
             uint256 action = actions[actionIndex];
@@ -49,6 +49,6 @@ abstract contract BaseActionsRouter is SafeCallback {
     /// @dev The other context functions, _msgData and _msgValue, are not supported by this contract
     /// In many contracts this will be the address that calls the initial entry point that calls `_executeActions`
     /// `msg.sender` shouldnt be used, as this will be the v4 pool manager contract that calls `unlockCallback`
-    /// If using ReentrancyLock.sol, this function can return Locker.get() - locker of the contract
+    /// If using ReentrancyLock.sol, this function can return _getLocker()
     function _msgSender() internal view virtual returns (address);
 }

src/base/DeltaResolver.sol

@@ -1,17 +1,33 @@
 // SPDX-License-Identifier: GPL-2.0-or-later
 pragma solidity ^0.8.24;
 
+import {IPoolManager} from "@uniswap/v4-core/src/interfaces/IPoolManager.sol";
 import {Currency} from "@uniswap/v4-core/src/types/Currency.sol";
 import {ImmutableState} from "./ImmutableState.sol";
+import {TransientStateLibrary} from "@uniswap/v4-core/src/libraries/TransientStateLibrary.sol";
 
 /// @notice Abstract contract used to sync, send, and settle funds to the pool manager
 /// @dev Note that sync() is called before any erc-20 transfer in `settle`.
 abstract contract DeltaResolver is ImmutableState {
+    using TransientStateLibrary for IPoolManager;
+
+    /// @notice Value used to signal that an entire open delta should be taken/settled
+    uint256 public constant ENTIRE_OPEN_DELTA = 0;
+
+    /// @notice Emitted trying to settle a positive delta, or take a negative delta
+    error InvalidDeltaForAction();
+
     /// @notice Take an amount of currency out of the PoolManager
     /// @param currency Currency to take
     /// @param recipient Address to receive the currency
     /// @param amount Amount to take
     function _take(Currency currency, address recipient, uint256 amount) internal {
+        if (amount == ENTIRE_OPEN_DELTA) {
+            int256 delta = poolManager.currencyDelta(address(this), currency);
+            if (delta < 0) revert InvalidDeltaForAction();
+            amount = uint256(delta);
+        }
+
         poolManager.take(currency, recipient, amount);
     }
 
@@ -21,6 +37,12 @@ abstract contract DeltaResolver is ImmutableState {
     /// @param payer Address of the payer
     /// @param amount Amount to send
     function _settle(Currency currency, address payer, uint256 amount) internal {
+        if (amount == ENTIRE_OPEN_DELTA) {
+            int256 delta = poolManager.currencyDelta(address(this), currency);
+            if (delta > 0) revert InvalidDeltaForAction();
+            amount = uint256(-delta);
+        }
+
         if (currency.isNative()) {
             poolManager.settle{value: amount}();
         } else {

src/base/ReentrancyLock.sol

@@ -13,4 +13,8 @@ contract ReentrancyLock {
         _;
         Locker.set(address(0));
     }
+
+    function _getLocker() internal view returns (address) {
+        return Locker.get();
+    }
 }