feat: swapExactIn() & swapExactOut()

Author: haythemsellami

src/EulerSwap.sol

@@ -150,6 +150,12 @@ contract EulerSwap is IEulerSwap, EVCUtil {
         return (reserve0, reserve1, status);
     }
 
+    /// @notice Returns the address of the Ethereum Vault Connector (EVC) used by this contract.
+    /// @return The address of the EVC contract.
+    function EVC() external view override(EVCUtil, IEulerSwap) returns (address) {
+        return address(evc);
+    }
+
     /// @inheritdoc IEulerSwap
     function activate() public {
         require(status != 2, Locked());

src/EulerSwapPeriphery.sol

@@ -3,20 +3,40 @@ pragma solidity ^0.8.27;
 
 import {IEVC} from "evc/interfaces/IEthereumVaultConnector.sol";
 import {IEVault} from "evk/EVault/IEVault.sol";
-import {IEulerSwap} from "./interfaces/IEulerSwap.sol";
 import {IEulerSwapPeriphery} from "./interfaces/IEulerSwapPeriphery.sol";
+import {IERC20, IEulerSwap, SafeERC20} from "./EulerSwap.sol";
 
 contract EulerSwapPeriphery is IEulerSwapPeriphery {
-    address private immutable evc;
-
-    constructor(address evc_) {
-        evc = evc_;
-    }
+    using SafeERC20 for IERC20;
 
     error UnsupportedPair();
     error OperatorNotInstalled();
     error InsufficientReserves();
     error InsufficientCash();
+    error AmountOutLessThanMin();
+    error AmountInMoreThanMax();
+
+    /// @inheritdoc IEulerSwapPeriphery
+    function swapExactIn(address eulerSwap, address tokenIn, address tokenOut, uint256 amountIn, uint256 amountOutMin)
+        external
+    {
+        uint256 amountOut = computeQuote(IEulerSwap(eulerSwap), tokenIn, tokenOut, amountIn, true);
+
+        require(amountOut >= amountOutMin, AmountOutLessThanMin());
+
+        _swap(eulerSwap, tokenIn, tokenOut, amountIn, amountOut);
+    }
+
+    /// @inheritdoc IEulerSwapPeriphery
+    function swapExactOut(address eulerSwap, address tokenIn, address tokenOut, uint256 amountOut, uint256 amountInMax)
+        external
+    {
+        uint256 amountIn = computeQuote(IEulerSwap(eulerSwap), tokenIn, tokenOut, amountOut, false);
+
+        require(amountIn <= amountInMax, AmountInMoreThanMax());
+
+        _swap(eulerSwap, tokenIn, tokenOut, amountIn, amountOut);
+    }
 
     /// @inheritdoc IEulerSwapPeriphery
     function quoteExactInput(address eulerSwap, address tokenIn, address tokenOut, uint256 amountIn)
@@ -36,6 +56,17 @@ contract EulerSwapPeriphery is IEulerSwapPeriphery {
         return computeQuote(IEulerSwap(eulerSwap), tokenIn, tokenOut, amountOut, false);
     }
 
+    function _swap(address eulerSwap, address tokenIn, address tokenOut, uint256 amountIn, uint256 amountOut)
+        internal
+    {
+        IERC20(tokenIn).safeTransferFrom(msg.sender, eulerSwap, amountIn);
+
+        bool isAsset0In = tokenIn < tokenOut;
+        (isAsset0In)
+            ? IEulerSwap(eulerSwap).swap(0, amountOut, msg.sender, "")
+            : IEulerSwap(eulerSwap).swap(amountOut, 0, msg.sender, "");
+    }
+
     /// @dev High-level quoting function. It handles fees and performs
     /// state validation, for example that there is sufficient cash available.
     function computeQuote(IEulerSwap eulerSwap, address tokenIn, address tokenOut, uint256 amount, bool exactIn)
@@ -44,7 +75,8 @@ contract EulerSwapPeriphery is IEulerSwapPeriphery {
         returns (uint256)
     {
         require(
-            IEVC(evc).isAccountOperatorAuthorized(eulerSwap.myAccount(), address(eulerSwap)), OperatorNotInstalled()
+            IEVC(eulerSwap.EVC()).isAccountOperatorAuthorized(eulerSwap.myAccount(), address(eulerSwap)),
+            OperatorNotInstalled()
         );
 
         uint256 feeMultiplier = eulerSwap.feeMultiplier();

src/interfaces/IEulerSwap.sol

@@ -34,6 +34,10 @@ interface IEulerSwap {
     /// of the swapping curve).
     function verify(uint256 newReserve0, uint256 newReserve1) external view returns (bool);
 
+    /// @notice Returns the address of the Ethereum Vault Connector (EVC) used by this contract.
+    /// @return The address of the EVC contract.
+    function EVC() external view returns (address);
+
     // EulerSwap Accessors
 
     function curve() external view returns (bytes32);

src/interfaces/IEulerSwapPeriphery.sol

@@ -2,6 +2,14 @@
 pragma solidity >=0.8.0;
 
 interface IEulerSwapPeriphery {
+    /// @notice Swap `amountIn` of `tokenIn` for `tokenOut`, with at least `amountOutMin` received.
+    function swapExactIn(address eulerSwap, address tokenIn, address tokenOut, uint256 amountIn, uint256 amountOutMin)
+        external;
+
+    /// @notice Swap `amountOut` of `tokenOut` for `tokenIn`, with at most `amountInMax` paid.
+    function swapExactOut(address eulerSwap, address tokenIn, address tokenOut, uint256 amountOut, uint256 amountInMax)
+        external;
+
     /// @notice How much `tokenOut` can I get for `amountIn` of `tokenIn`?
     function quoteExactInput(address eulerSwap, address tokenIn, address tokenOut, uint256 amountIn)
         external

test/EulerSwapPeriphery.t.sol

@@ -0,0 +1,72 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+pragma solidity ^0.8.24;
+
+import {EulerSwapTestBase, EulerSwap, EulerSwapPeriphery} from "./EulerSwapTestBase.t.sol";
+
+contract EulerSwapPeripheryTest is EulerSwapTestBase {
+    EulerSwap public eulerSwap;
+
+    function setUp() public virtual override {
+        super.setUp();
+
+        eulerSwap = createEulerSwap(50e18, 50e18, 0, 1e18, 1e18, 0.4e18, 0.85e18);
+    }
+
+    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(periphery), amountIn);
+        periphery.swapExactIn(address(eulerSwap), address(assetTST), address(assetTST2), amountIn, amountOut);
+        vm.stopPrank();
+
+        assertEq(assetTST2.balanceOf(anyone), amountOut);
+    }
+
+    function test_SwapExactIn_AmountOutLessThanMin() 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(periphery), amountIn);
+        vm.expectRevert(EulerSwapPeriphery.AmountOutLessThanMin.selector);
+        periphery.swapExactIn(address(eulerSwap), address(assetTST), address(assetTST2), amountIn, amountOut + 1);
+        vm.stopPrank();
+    }
+
+    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);
+        periphery.swapExactOut(address(eulerSwap), address(assetTST), address(assetTST2), amountOut, amountIn);
+        vm.stopPrank();
+
+        assertEq(assetTST2.balanceOf(anyone), amountOut);
+    }
+
+    function test_SwapExactOut_AmountInMoreThanMax() 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);
+        vm.expectRevert(EulerSwapPeriphery.AmountInMoreThanMax.selector);
+        periphery.swapExactOut(address(eulerSwap), address(assetTST), address(assetTST2), amountOut * 2, amountIn);
+        vm.stopPrank();
+    }
+}

test/EulerSwapTestBase.t.sol

@@ -25,7 +25,7 @@ contract EulerSwapTestBase is EVaultTestBase {
     function setUp() public virtual override {
         super.setUp();
 
-        periphery = new EulerSwapPeriphery(address(evc));
+        periphery = new EulerSwapPeriphery();
 
         // Vault config