verify that prepaid input does not have token liquidity issues

Author: saucepoint

test/EulerSwapHook.swaps.t.sol

@@ -8,6 +8,7 @@ import {EulerSwapHook} from "../src/EulerSwapHook.sol";
 import {PoolKey} from "@uniswap/v4-core/src/types/PoolKey.sol";
 import {IPoolManager, PoolManagerDeployer} from "./utils/PoolManagerDeployer.sol";
 import {PoolSwapTest} from "@uniswap/v4-core/src/test/PoolSwapTest.sol";
+import {MinimalRouter} from "./utils/MinimalRouter.sol";
 import {Currency, CurrencyLibrary} from "@uniswap/v4-core/src/types/Currency.sol";
 import {StateLibrary} from "@uniswap/v4-core/src/libraries/StateLibrary.sol";
 import {TickMath} from "@uniswap/v4-core/src/libraries/TickMath.sol";
@@ -19,6 +20,7 @@ contract EulerSwapHookTest is EulerSwapTestBase {
 
     IPoolManager public poolManager;
     PoolSwapTest public swapRouter;
+    MinimalRouter public minimalRouter;
 
     PoolSwapTest.TestSettings public settings = PoolSwapTest.TestSettings({takeClaims: false, settleUsingBurn: false});
 
@@ -27,6 +29,7 @@ contract EulerSwapHookTest is EulerSwapTestBase {
 
         poolManager = PoolManagerDeployer.deploy(address(this));
         swapRouter = new PoolSwapTest(poolManager);
+        minimalRouter = new MinimalRouter(poolManager);
 
         eulerSwap = createEulerSwapHook(poolManager, 60e18, 60e18, 0, 1e18, 1e18, 0.4e18, 0.85e18);
         eulerSwap.activate();
@@ -42,23 +45,40 @@ contract EulerSwapHookTest is EulerSwapTestBase {
     }
 
     function test_SwapExactIn() public {
-        uint256 amountIn = 1e18;
+        uint256 amountIn = 1001e18;
         uint256 amountOut =
             periphery.quoteExactInput(address(eulerSwap), address(assetTST), address(assetTST2), amountIn);
 
         assetTST.mint(anyone, amountIn);
 
         vm.startPrank(anyone);
-        assetTST.approve(address(swapRouter), amountIn);
+        assetTST.approve(address(minimalRouter), amountIn);
 
         bool zeroForOne = address(assetTST) < address(assetTST2);
-        _swap(eulerSwap.poolKey(), zeroForOne, true, amountIn);
+        minimalRouter.swap(eulerSwap.poolKey(), zeroForOne, true, amountIn, "");
         vm.stopPrank();
 
         assertEq(assetTST.balanceOf(anyone), 0);
         assertEq(assetTST2.balanceOf(anyone), amountOut);
     }
 
+    /// @dev swapping with an amount that exceeds PoolManager's ERC20 token balance will revert
+    /// if the router does not pre-pay the input
+    function test_swapExactIn_revertWithoutTokenLiquidity() public {
+        uint256 amountIn = 1001e18; // input amount exceeds
+
+        assetTST.mint(anyone, amountIn);
+
+        vm.startPrank(anyone);
+        assetTST.approve(address(swapRouter), amountIn);
+
+        bool zeroForOne = address(assetTST) < address(assetTST2);
+        PoolKey memory poolKey = eulerSwap.poolKey();
+        vm.expectRevert();
+        _swap(poolKey, zeroForOne, true, amountIn);
+        vm.stopPrank();
+    }
+
     function test_SwapExactOut() public {
         uint256 amountOut = 1e18;
         uint256 amountIn =

test/utils/MinimalRouter.sol

@@ -0,0 +1,70 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.8.24;
+
+import {CurrencyLibrary, Currency} from "@uniswap/v4-core/src/types/Currency.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 {IHooks} from "@uniswap/v4-core/src/interfaces/IHooks.sol";
+import {Hooks} from "@uniswap/v4-core/src/libraries/Hooks.sol";
+import {CurrencySettler} from "@uniswap/v4-core/test/utils/CurrencySettler.sol";
+import {SafeCallback} from "v4-periphery/src/base/SafeCallback.sol";
+import {TickMath} from "@uniswap/v4-core/src/libraries/TickMath.sol";
+
+contract MinimalRouter is SafeCallback {
+    using CurrencySettler for Currency;
+
+    uint160 public constant MIN_PRICE_LIMIT = TickMath.MIN_SQRT_PRICE + 1;
+    uint160 public constant MAX_PRICE_LIMIT = TickMath.MAX_SQRT_PRICE - 1;
+
+    constructor(IPoolManager _manager) SafeCallback(_manager) {}
+
+    function swap(PoolKey memory key, bool zeroForOne, bool exactInput, uint256 amount, bytes memory hookData)
+        external
+        payable
+        returns (BalanceDelta delta)
+    {
+        delta = abi.decode(
+            poolManager.unlock(abi.encode(msg.sender, key, zeroForOne, exactInput, amount, hookData)), (BalanceDelta)
+        );
+
+        uint256 ethBalance = address(this).balance;
+        if (ethBalance > 0) CurrencyLibrary.ADDRESS_ZERO.transfer(msg.sender, ethBalance);
+    }
+
+    function _unlockCallback(bytes calldata data) internal override returns (bytes memory) {
+        (address sender, PoolKey memory key, bool zeroForOne, bool exactInput, uint256 amount, bytes memory hookData) =
+            abi.decode(data, (address, PoolKey, bool, bool, uint256, bytes));
+
+        // for exact input swaps, send the input first to avoid PoolManager token balance issues
+        if (exactInput) {
+            zeroForOne
+                ? key.currency0.settle(poolManager, sender, amount, false)
+                : key.currency1.settle(poolManager, sender, amount, false);
+        }
+
+        BalanceDelta delta = poolManager.swap(
+            key,
+            IPoolManager.SwapParams({
+                zeroForOne: zeroForOne,
+                amountSpecified: exactInput ? -int256(amount) : int256(amount),
+                sqrtPriceLimitX96: zeroForOne ? MIN_PRICE_LIMIT : MAX_PRICE_LIMIT
+            }),
+            hookData
+        );
+
+        if (!exactInput && delta.amount0() < 0) {
+            key.currency0.settle(poolManager, sender, uint256(int256(-delta.amount0())), false);
+        } else if (delta.amount0() > 0) {
+            key.currency0.take(poolManager, sender, uint256(int256(delta.amount0())), false);
+        }
+
+        if (!exactInput && delta.amount1() < 0) {
+            key.currency1.settle(poolManager, sender, uint256(int256(-delta.amount1())), false);
+        } else if (delta.amount1() > 0) {
+            key.currency1.take(poolManager, sender, uint256(int256(delta.amount1())), false);
+        }
+
+        return abi.encode(delta);
+    }
+}