Merge pull request #21 from euler-xyz/renaming

Renaming & contracts cleaning

Author: euler-mab

TODO

@@ -51,9 +51,9 @@ The EulerSwap contract tracks what it believes the reserves to be by caching the
 
 ### **1. Core contracts**
 
-#### **Maglev contract**
+#### **EulerSwap contract**
 
-The `Maglev` contract is the core of EulerSwap and is responsible for:
+The `EulerSwap` contract is the core of EulerSwap and is responsible for:
 
 - Managing liquidity reserves.
 - Executing token swaps based on the EulerSwap curve.
@@ -76,20 +76,20 @@ The `Maglev` contract is the core of EulerSwap and is responsible for:
 
 ### **2. Periphery contracts**
 
-#### **MaglevPeriphery contract**
+#### **EulerSwapPeriphery contract**
 
-The `MaglevPeriphery` contract extends the functionality of the core Maglev contract by providing:
+The `EulerSwapPeriphery` contract extends the functionality of the core EulerSwap contract by providing:
 
 - **Swap price quotations** before execution.
 - **Liquidity checks** to ensure solvency before transactions.
 - **Binary search mechanisms** for dynamic price calculation.
 
 ##### **Key functions**
 
-- `quoteExactInput(address maglev, address tokenIn, address tokenOut, uint256 amountIn)`: Estimates the output amount for a given input.
-- `quoteExactOutput(address maglev, address tokenIn, address tokenOut, uint256 amountOut)`: Estimates the required input amount to receive a specified output.
-- `computeQuote(IMaglev maglev, address tokenIn, address tokenOut, uint256 amount, bool exactIn)`: A high-level function to compute swaps while enforcing fee multipliers.
-- `binarySearch(IMaglev maglev, uint112 reserve0, uint112 reserve1, uint256 amount, bool exactIn, bool asset0IsInput)`: Uses binary search to determine an optimal swap amount along the curve.
+- `quoteExactInput(address eulerSwap, address tokenIn, address tokenOut, uint256 amountIn)`: Estimates the output amount for a given input.
+- `quoteExactOutput(address eulerSwap, address tokenIn, address tokenOut, uint256 amountOut)`: Estimates the required input amount to receive a specified output.
+- `computeQuote(IEulerSwap eulerSwap, address tokenIn, address tokenOut, uint256 amount, bool exactIn)`: A high-level function to compute swaps while enforcing fee multipliers.
+- `binarySearch(IEulerSwap eulerSwap, uint112 reserve0, uint112 reserve1, uint256 amount, bool exactIn, bool asset0IsInput)`: Uses binary search to determine an optimal swap amount along the curve.
 
 ### **3. Vault integration**
 
@@ -110,8 +110,8 @@ EulerSwap integrates with **Ethereum Vault Connector (EVC)** to enable collatera
 
 EulerSwap’s architecture is designed for **efficient, secure, and collateral-backed trading** with a custom **swapping curve**. The system leverages:
 
-- **Maglev** as the core AMM contract.
-- **MaglevPeriphery** for auxiliary quoting and validations.
+- **EulerSwap** as the core AMM contract.
+- **EulerSwapPeriphery** for auxiliary quoting and validations.
 - **Ethereum Vault Connector (EVC)** for collateralized vault management.
 - **Security-focused design** to prevent vulnerabilities in asset handling.
 

docs/architecture.md

@@ -1,13 +1,30 @@
 // 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 EulerSwap is IEulerSwap, EVCUtil {
+    struct Params {
+        address evc;
+        address vault0;
+        address vault1;
+        address myAccount;
+        uint112 debtLimit0;
+        uint112 debtLimit1;
+        uint256 fee;
+    }
+
+    struct CurveParams {
+        uint256 priceX;
+        uint256 priceY;
+        uint256 concentrationX;
+        uint256 concentrationY;
+    }
 
-contract Maglev is IMaglev, EVCUtil {
     bytes32 public constant curve = keccak256("EulerSwap v1");
 
     address public immutable vault0;
@@ -30,15 +47,7 @@ contract Maglev is IMaglev, EVCUtil {
     uint112 public reserve1;
     uint32 public status; // 0 = unactivated, 1 = unlocked, 2 = locked
 
-    error Locked();
-    error Overflow();
-    error BadFee();
-    error DifferentEVC();
-    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,
         uint256 amount0In,
@@ -50,6 +59,13 @@ contract Maglev is IMaglev, EVCUtil {
         address indexed to
     );
 
+    error Locked();
+    error Overflow();
+    error BadFee();
+    error DifferentEVC();
+    error AssetsOutOfOrderOrEqual();
+    error CurveViolation();
+
     modifier nonReentrant() {
         if (status == 0) activate();
         require(status == 1, Locked());
@@ -58,25 +74,8 @@ contract Maglev is IMaglev, EVCUtil {
         status = 1;
     }
 
-    struct Params {
-        address evc;
-        address vault0;
-        address vault1;
-        address myAccount;
-        uint112 debtLimit0;
-        uint112 debtLimit1;
-        uint256 fee;
-    }
-
-    struct CurveParams {
-        uint256 priceX;
-        uint256 priceY;
-        uint256 concentrationX;
-        uint256 concentrationY;
-    }
-
     constructor(Params memory params, CurveParams memory curveParams) EVCUtil(params.evc) {
-        // Maglev params
+        // EulerSwap params
 
         require(params.fee < 1e18, BadFee());
 
@@ -106,38 +105,10 @@ contract Maglev is IMaglev, EVCUtil {
         concentrationX = curveParams.concentrationX;
         concentrationY = curveParams.concentrationY;
 
-        emit MaglevCreated(address(this), asset0Addr, asset1Addr);
-    }
-
-    /// @inheritdoc IMaglev
-    function activate() public {
-        require(status != 2, Locked());
-        status = 1;
-
-        IERC20(asset0).approve(vault0, type(uint256).max);
-        IERC20(asset1).approve(vault1, type(uint256).max);
-
-        IEVC(evc).enableCollateral(myAccount, vault0);
-        IEVC(evc).enableCollateral(myAccount, vault1);
-    }
-
-    /// @dev EulerSwap curve definition
-    function f(uint256 xt, uint256 px, uint256 py, uint256 x0, uint256 y0, uint256 c) internal pure returns (uint256) {
-        return y0 + px * 1e18 / py * (c * (2 * x0 - xt) / 1e18 + (1e18 - c) * x0 / 1e18 * x0 / xt - x0) / 1e18;
-    }
-
-    /// @inheritdoc IMaglev
-    function verify(uint256 newReserve0, uint256 newReserve1) public view returns (bool) {
-        if (newReserve0 >= initialReserve0) {
-            if (newReserve1 >= initialReserve1) return true;
-            return newReserve0 >= f(newReserve1, priceY, priceX, initialReserve1, initialReserve0, concentrationY);
-        } else {
-            if (newReserve1 < initialReserve1) return false;
-            return newReserve1 >= f(newReserve0, priceX, priceY, initialReserve0, initialReserve1, concentrationX);
-        }
+        emit EulerSwapCreated(address(this), asset0Addr, asset1Addr);
     }
 
-    /// @inheritdoc IMaglev
+    /// @inheritdoc IEulerSwap
     function swap(uint256 amount0Out, uint256 amount1Out, address to, bytes calldata data)
         external
         callThroughEVC
@@ -188,29 +159,27 @@ contract Maglev is IMaglev, EVCUtil {
         return (reserve0, reserve1, status);
     }
 
-    // Internal utilities
+    /// @inheritdoc IEulerSwap
+    function activate() public {
+        require(status != 2, Locked());
+        status = 1;
 
-    function myDebt(address vault) internal view returns (uint256) {
-        return IEVault(vault).debtOf(myAccount);
-    }
+        IERC20(asset0).approve(vault0, type(uint256).max);
+        IERC20(asset1).approve(vault1, type(uint256).max);
 
-    function myBalance(address vault) internal view returns (uint256) {
-        uint256 shares = IEVault(vault).balanceOf(myAccount);
-        return shares == 0 ? 0 : IEVault(vault).convertToAssets(shares);
+        IEVC(evc).enableCollateral(myAccount, vault0);
+        IEVC(evc).enableCollateral(myAccount, vault1);
     }
 
-    function offsetReserve(uint112 reserve, address vault) internal view returns (uint112) {
-        uint256 offset;
-        uint256 debt = myDebt(vault);
-
-        if (debt != 0) {
-            offset = reserve > debt ? reserve - debt : 0;
+    /// @inheritdoc IEulerSwap
+    function verify(uint256 newReserve0, uint256 newReserve1) public view returns (bool) {
+        if (newReserve0 >= initialReserve0) {
+            if (newReserve1 >= initialReserve1) return true;
+            return newReserve0 >= f(newReserve1, priceY, priceX, initialReserve1, initialReserve0, concentrationY);
         } else {
-            offset = reserve + myBalance(vault);
+            if (newReserve1 < initialReserve1) return false;
+            return newReserve1 >= f(newReserve0, priceX, priceY, initialReserve0, initialReserve1, concentrationX);
         }
-
-        require(offset <= type(uint112).max, Overflow());
-        return uint112(offset);
     }
 
     function withdrawAssets(address vault, uint256 amount, address to) internal {
@@ -243,4 +212,32 @@ contract Maglev is IMaglev, EVCUtil {
             }
         }
     }
+
+    function myDebt(address vault) internal view returns (uint256) {
+        return IEVault(vault).debtOf(myAccount);
+    }
+
+    function myBalance(address vault) internal view returns (uint256) {
+        uint256 shares = IEVault(vault).balanceOf(myAccount);
+        return shares == 0 ? 0 : IEVault(vault).convertToAssets(shares);
+    }
+
+    function offsetReserve(uint112 reserve, address vault) internal view returns (uint112) {
+        uint256 offset;
+        uint256 debt = myDebt(vault);
+
+        if (debt != 0) {
+            offset = reserve > debt ? reserve - debt : 0;
+        } else {
+            offset = reserve + myBalance(vault);
+        }
+
+        require(offset <= type(uint112).max, Overflow());
+        return uint112(offset);
+    }
+
+    /// @dev EulerSwap curve definition
+    function f(uint256 xt, uint256 px, uint256 py, uint256 x0, uint256 y0, uint256 c) internal pure returns (uint256) {
+        return y0 + px * 1e18 / py * (c * (2 * x0 - xt) / 1e18 + (1e18 - c) * x0 / 1e18 * x0 / xt - x0) / 1e18;
+    }
 }