Merge pull request #49 from euler-xyz/sauce/v4-exploration/tests

test setup for EulerSwapHook

Author: hoytech

src/EulerSwapHook.sol

@@ -16,7 +16,7 @@ import {EulerSwap, IEulerSwap, IEVault} from "./EulerSwap.sol";
 contract EulerSwapHook is EulerSwap, BaseHook {
     using SafeCast for uint256;
 
-    PoolKey poolKey;
+    PoolKey internal _poolKey;
 
     constructor(IPoolManager _manager, Params memory params, CurveParams memory curveParams)
         EulerSwap(params, curveParams)
@@ -28,7 +28,7 @@ contract EulerSwapHook is EulerSwap, BaseHook {
         // convert fee in WAD to pips. 0.003e18 / 1e12 = 3000 = 0.30%
         uint24 fee = uint24(params.fee / 1e12);
 
-        poolKey = PoolKey({
+        _poolKey = PoolKey({
             currency0: Currency.wrap(asset0Addr),
             currency1: Currency.wrap(asset1Addr),
             fee: fee,
@@ -37,7 +37,12 @@ contract EulerSwapHook is EulerSwap, BaseHook {
         });
 
         // create the pool on v4, using starting price as sqrtPrice(1/1) * Q96
-        poolManager.initialize(poolKey, 79228162514264337593543950336);
+        poolManager.initialize(_poolKey, 79228162514264337593543950336);
+    }
+
+    /// @dev Helper function to return the poolKey as its struct type
+    function poolKey() external view returns (PoolKey memory) {
+        return _poolKey;
     }
 
     function _beforeSwap(address, PoolKey calldata key, IPoolManager.SwapParams calldata params, bytes calldata)

test/EulerSwapHook.swaps.t.sol

@@ -0,0 +1,82 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+pragma solidity ^0.8.24;
+
+import {EulerSwapTestBase, EulerSwap, EulerSwapPeriphery, IEulerSwap} from "./EulerSwapTestBase.t.sol";
+import {TestERC20} from "evk-test/unit/evault/EVaultTestBase.t.sol";
+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 {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";
+
+contract EulerSwapHookTest is EulerSwapTestBase {
+    using StateLibrary for IPoolManager;
+
+    EulerSwapHook public eulerSwap;
+
+    IPoolManager public poolManager;
+    PoolSwapTest public swapRouter;
+
+    PoolSwapTest.TestSettings public settings = PoolSwapTest.TestSettings({takeClaims: false, settleUsingBurn: false});
+
+    function setUp() public virtual override {
+        super.setUp();
+
+        poolManager = PoolManagerDeployer.deploy(address(this));
+        swapRouter = new PoolSwapTest(poolManager);
+
+        eulerSwap = createEulerSwapHook(poolManager, 60e18, 60e18, 0, 1e18, 1e18, 0.4e18, 0.85e18);
+
+        // confirm pool was created
+        assertFalse(eulerSwap.poolKey().currency1 == CurrencyLibrary.ADDRESS_ZERO);
+        (uint160 sqrtPriceX96,,,) = poolManager.getSlot0(eulerSwap.poolKey().toId());
+        assertNotEq(sqrtPriceX96, 0);
+    }
+
+    function test_SwapExactIn() public {
+        uint256 amountIn = 1e18;
+        uint256 amountOut =
+            periphery.quoteExactInput(address(eulerSwap), address(assetTST), address(assetTST2), amountIn);
+
+        assetTST.mint(anyone, amountIn);
+
+        vm.startPrank(anyone);
+        assetTST.approve(address(swapRouter), amountIn);
+
+        bool zeroForOne = address(assetTST) < address(assetTST2);
+        _swap(eulerSwap.poolKey(), zeroForOne, true, amountIn);
+        vm.stopPrank();
+
+        assertEq(assetTST.balanceOf(anyone), 0);
+        assertEq(assetTST2.balanceOf(anyone), amountOut);
+    }
+
+    function test_SwapExactOut() public {
+        uint256 amountOut = 1e18;
+        uint256 amountIn =
+            periphery.quoteExactOutput(address(eulerSwap), address(assetTST), address(assetTST2), amountOut);
+
+        assetTST.mint(anyone, amountIn);
+
+        vm.startPrank(anyone);
+        assetTST.approve(address(periphery), amountIn);
+        bool zeroForOne = address(assetTST) < address(assetTST2);
+        _swap(eulerSwap.poolKey(), zeroForOne, false, amountOut);
+        vm.stopPrank();
+
+        assertEq(assetTST.balanceOf(anyone), 0);
+        assertEq(assetTST2.balanceOf(anyone), amountOut);
+    }
+
+    function _swap(PoolKey memory key, bool zeroForOne, bool exactInput, uint256 amount) internal {
+        IPoolManager.SwapParams memory swapParams = IPoolManager.SwapParams({
+            zeroForOne: zeroForOne,
+            amountSpecified: exactInput ? -int256(amount) : int256(amount),
+            sqrtPriceLimitX96: zeroForOne ? TickMath.MIN_SQRT_PRICE + 1 : TickMath.MAX_SQRT_PRICE - 1
+        });
+        swapRouter.swap(key, swapParams, settings, "");
+    }
+}

test/EulerSwapTestBase.t.sol

@@ -6,6 +6,10 @@ import {EVaultTestBase, TestERC20} from "evk-test/unit/evault/EVaultTestBase.t.s
 import {IEVault} from "evk/EVault/IEVault.sol";
 import {IEulerSwap, IEVC, EulerSwap} from "../src/EulerSwap.sol";
 import {EulerSwapPeriphery} from "../src/EulerSwapPeriphery.sol";
+import {EulerSwapHook} from "../src/EulerSwapHook.sol";
+import {IPoolManager} from "@uniswap/v4-core/src/interfaces/IPoolManager.sol";
+import {HookMiner} from "v4-periphery/src/utils/HookMiner.sol";
+import {Hooks} from "@uniswap/v4-core/src/libraries/Hooks.sol";
 
 contract EulerSwapTestBase is EVaultTestBase {
     address public depositor = makeAddr("depositor");
@@ -96,6 +100,38 @@ contract EulerSwapTestBase is EVaultTestBase {
         return eulerSwap;
     }
 
+    function createEulerSwapHook(
+        IPoolManager _poolManager,
+        uint112 debtLimitA,
+        uint112 debtLimitB,
+        uint256 fee,
+        uint256 px,
+        uint256 py,
+        uint256 cx,
+        uint256 cy
+    ) internal returns (EulerSwapHook) {
+        IEulerSwap.Params memory poolParams = getEulerSwapParams(debtLimitA, debtLimitB, fee);
+        IEulerSwap.CurveParams memory curveParams =
+            IEulerSwap.CurveParams({priceX: px, priceY: py, concentrationX: cx, concentrationY: cy});
+
+        bytes memory constructorArgs = abi.encode(_poolManager, poolParams, curveParams);
+        (address hookAddress, bytes32 salt) = HookMiner.find(
+            creator,
+            uint160(Hooks.BEFORE_SWAP_FLAG | Hooks.BEFORE_SWAP_RETURNS_DELTA_FLAG),
+            type(EulerSwapHook).creationCode,
+            constructorArgs
+        );
+
+        vm.prank(creator);
+        EulerSwapHook eulerSwapHook = new EulerSwapHook{salt: salt}(_poolManager, poolParams, curveParams);
+        assertEq(address(eulerSwapHook), hookAddress);
+
+        vm.prank(holder);
+        evc.setAccountOperator(holder, address(eulerSwapHook), true);
+
+        return eulerSwapHook;
+    }
+
     function mintAndDeposit(address who, IEVault vault, uint256 amount) internal {
         TestERC20 tok = TestERC20(vault.asset());
         tok.mint(who, amount);