chore: rename to EulerSwap

Author: haythemsellami

TODO

@@ -1,13 +1,13 @@
 // SPDX-License-Identifier: UNLICENSED
 pragma solidity ^0.8.27;
 
-import {EVCUtil} from "evc/utils/EVCUtil.sol";
 import {IEVC} from "evc/interfaces/IEthereumVaultConnector.sol";
 import {IEVault, IERC20, IBorrowing, IERC4626, IRiskManager} from "evk/EVault/IEVault.sol";
 import {IUniswapV2Callee} from "./interfaces/IUniswapV2Callee.sol";
-import {IMaglev} from "./interfaces/IMaglev.sol";
+import {IEulerSwap} from "./interfaces/IEulerSwap.sol";
+import {EVCUtil} from "evc/utils/EVCUtil.sol";
 
-contract Maglev is IMaglev, EVCUtil {
+contract EulerSwap is IEulerSwap, EVCUtil {
     bytes32 public constant curve = keccak256("EulerSwap v1");
 
     address public immutable vault0;
@@ -37,7 +37,7 @@ contract Maglev is IMaglev, EVCUtil {
     error AssetsOutOfOrderOrEqual();
     error CurveViolation();
 
-    event MaglevCreated(address indexed maglev, address indexed asset0, address indexed asset1);
+    event EulerSwapCreated(address indexed eulerSwap, address indexed asset0, address indexed asset1);
 
     event Swap(
         address indexed sender,
@@ -76,7 +76,7 @@ contract Maglev is IMaglev, EVCUtil {
     }
 
     constructor(Params memory params, CurveParams memory curveParams) EVCUtil(params.evc) {
-        // Maglev params
+        // EulerSwap params
 
         require(params.fee < 1e18, BadFee());
 
@@ -106,10 +106,10 @@ contract Maglev is IMaglev, EVCUtil {
         concentrationX = curveParams.concentrationX;
         concentrationY = curveParams.concentrationY;
 
-        emit MaglevCreated(address(this), asset0Addr, asset1Addr);
+        emit EulerSwapCreated(address(this), asset0Addr, asset1Addr);
     }
 
-    /// @inheritdoc IMaglev
+    /// @inheritdoc IEulerSwap
     function activate() public {
         require(status != 2, Locked());
         status = 1;
@@ -126,7 +126,7 @@ contract Maglev is IMaglev, EVCUtil {
         return y0 + px * 1e18 / py * (c * (2 * x0 - xt) / 1e18 + (1e18 - c) * x0 / 1e18 * x0 / xt - x0) / 1e18;
     }
 
-    /// @inheritdoc IMaglev
+    /// @inheritdoc IEulerSwap
     function verify(uint256 newReserve0, uint256 newReserve1) public view returns (bool) {
         if (newReserve0 >= initialReserve0) {
             if (newReserve1 >= initialReserve1) return true;
@@ -137,7 +137,7 @@ contract Maglev is IMaglev, EVCUtil {
         }
     }
 
-    /// @inheritdoc IMaglev
+    /// @inheritdoc IEulerSwap
     function swap(uint256 amount0Out, uint256 amount1Out, address to, bytes calldata data)
         external
         callThroughEVC

src/Maglev.sol renamed to src/EulerSwap.sol

@@ -3,10 +3,10 @@ pragma solidity ^0.8.27;
 
 import {IEVC} from "evc/interfaces/IEthereumVaultConnector.sol";
 import {IEVault} from "evk/EVault/IEVault.sol";
-import {IMaglev} from "./interfaces/IMaglev.sol";
-import {IMaglevPeriphery} from "./interfaces/IMaglevPeriphery.sol";
+import {IEulerSwap} from "./interfaces/IEulerSwap.sol";
+import {IEulerSwapPeriphery} from "./interfaces/IEulerSwapPeriphery.sol";
 
-contract MaglevPeriphery is IMaglevPeriphery {
+contract EulerSwapPeriphery is IEulerSwapPeriphery {
     address private immutable evc;
 
     constructor(address evc_) {
@@ -18,52 +18,54 @@ contract MaglevPeriphery is IMaglevPeriphery {
     error InsufficientReserves();
     error InsufficientCash();
 
-    /// @inheritdoc IMaglevPeriphery
-    function quoteExactInput(address maglev, address tokenIn, address tokenOut, uint256 amountIn)
+    /// @inheritdoc IEulerSwapPeriphery
+    function quoteExactInput(address eulerSwap, address tokenIn, address tokenOut, uint256 amountIn)
         external
         view
         returns (uint256)
     {
-        return computeQuote(IMaglev(maglev), tokenIn, tokenOut, amountIn, true);
+        return computeQuote(IEulerSwap(eulerSwap), tokenIn, tokenOut, amountIn, true);
     }
 
-    /// @inheritdoc IMaglevPeriphery
-    function quoteExactOutput(address maglev, address tokenIn, address tokenOut, uint256 amountOut)
+    /// @inheritdoc IEulerSwapPeriphery
+    function quoteExactOutput(address eulerSwap, address tokenIn, address tokenOut, uint256 amountOut)
         external
         view
         returns (uint256)
     {
-        return computeQuote(IMaglev(maglev), tokenIn, tokenOut, amountOut, false);
+        return computeQuote(IEulerSwap(eulerSwap), tokenIn, tokenOut, amountOut, false);
     }
 
     /// @dev High-level quoting function. It handles fees and performs
     /// state validation, for example that there is sufficient cash available.
-    function computeQuote(IMaglev maglev, address tokenIn, address tokenOut, uint256 amount, bool exactIn)
+    function computeQuote(IEulerSwap eulerSwap, address tokenIn, address tokenOut, uint256 amount, bool exactIn)
         internal
         view
         returns (uint256)
     {
-        require(IEVC(evc).isAccountOperatorAuthorized(maglev.myAccount(), address(maglev)), OperatorNotInstalled());
+        require(
+            IEVC(evc).isAccountOperatorAuthorized(eulerSwap.myAccount(), address(eulerSwap)), OperatorNotInstalled()
+        );
 
-        uint256 feeMultiplier = maglev.feeMultiplier();
-        address vault0 = maglev.vault0();
-        address vault1 = maglev.vault1();
-        (uint112 reserve0, uint112 reserve1,) = maglev.getReserves();
+        uint256 feeMultiplier = eulerSwap.feeMultiplier();
+        address vault0 = eulerSwap.vault0();
+        address vault1 = eulerSwap.vault1();
+        (uint112 reserve0, uint112 reserve1,) = eulerSwap.getReserves();
 
         // exactIn: decrease received amountIn, rounding down
         if (exactIn) amount = amount * feeMultiplier / 1e18;
 
         bool asset0IsInput;
         {
-            address asset0 = maglev.asset0();
-            address asset1 = maglev.asset1();
+            address asset0 = eulerSwap.asset0();
+            address asset1 = eulerSwap.asset1();
 
             if (tokenIn == asset0 && tokenOut == asset1) asset0IsInput = true;
             else if (tokenIn == asset1 && tokenOut == asset0) asset0IsInput = false;
             else revert UnsupportedPair();
         }
 
-        uint256 quote = binarySearch(maglev, reserve0, reserve1, amount, exactIn, asset0IsInput);
+        uint256 quote = binarySearch(eulerSwap, reserve0, reserve1, amount, exactIn, asset0IsInput);
 
         if (exactIn) {
             // if `exactIn`, `quote` is the amount of assets to buy from the AMM
@@ -85,7 +87,7 @@ contract MaglevPeriphery is IMaglevPeriphery {
     /// Although some curves may have more efficient closed-form solutions,
     /// this works with any monotonic curve.
     function binarySearch(
-        IMaglev maglev,
+        IEulerSwap eulerSwap,
         uint112 reserve0,
         uint112 reserve1,
         uint256 amount,
@@ -112,7 +114,8 @@ contract MaglevPeriphery is IMaglevPeriphery {
 
             while (low < high) {
                 uint256 mid = (low + high) / 2;
-                if (dy == 0 ? maglev.verify(uint256(reserve0New), mid) : maglev.verify(mid, uint256(reserve1New))) {
+                if (dy == 0 ? eulerSwap.verify(uint256(reserve0New), mid) : eulerSwap.verify(mid, uint256(reserve1New)))
+                {
                     high = mid;
                 } else {
                     low = mid + 1;

src/MaglevPeriphery.sol renamed to src/EulerSwapPeriphery.sol

@@ -1,24 +1,24 @@
 // SPDX-License-Identifier: UNLICENSED
 pragma solidity >=0.8.0;
 
-interface IMaglev {
+interface IEulerSwap {
     /// @notice Optimistically sends the requested amounts of tokens to the `to`
     /// address, invokes `uniswapV2Call` callback on `to` (if `data` was provided),
     /// and then verifies that a sufficient amount of tokens were transferred to
     /// satisfy the swapping curve invariant.
     function swap(uint256 amount0Out, uint256 amount1Out, address to, bytes calldata data) external;
 
-    /// @notice Approves the vaults to access the Maglev instance's tokens, and enables
+    /// @notice Approves the vaults to access the EulerSwap instance's tokens, and enables
     /// vaults as collateral. Can be invoked by anybody, and is harmless if invoked again.
-    /// Calling this function is optional: Maglev can be activated on the first swap.
+    /// Calling this function is optional: EulerSwap can be activated on the first swap.
     function activate() external;
 
     /// @notice Function that defines the shape of the swapping curve. Returns true iff
     /// the specified reserve amounts would be acceptable (ie it is above and to-the-right
     /// of the swapping curve).
     function verify(uint256 newReserve0, uint256 newReserve1) external view returns (bool);
 
-    // Maglev Accessors
+    // EulerSwap Accessors
 
     function curve() external view returns (bytes32);
     function vault0() external view returns (address);

src/interfaces/IMaglev.sol renamed to src/interfaces/IEulerSwap.sol

@@ -1,15 +1,15 @@
 // SPDX-License-Identifier: UNLICENSED
 pragma solidity >=0.8.0;
 
-interface IMaglevPeriphery {
+interface IEulerSwapPeriphery {
     /// @notice How much `tokenOut` can I get for `amountIn` of `tokenIn`?
-    function quoteExactInput(address maglev, address tokenIn, address tokenOut, uint256 amountIn)
+    function quoteExactInput(address eulerSwap, address tokenIn, address tokenOut, uint256 amountIn)
         external
         view
         returns (uint256);
 
     /// @notice How much `tokenIn` do I need to get `amountOut` of `tokenOut`?
-    function quoteExactOutput(address maglev, address tokenIn, address tokenOut, uint256 amountOut)
+    function quoteExactOutput(address eulerSwap, address tokenIn, address tokenOut, uint256 amountOut)
         external
         view
         returns (uint256);