clean

Author: haythemsellami

src/EulerSwap.sol

@@ -152,12 +152,12 @@ contract EulerSwap is IEulerSwap, EVCUtil {
         }
     }
 
+    /// @inheritdoc IEulerSwap
     function getReserves() external view returns (uint112, uint112, uint32) {
         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.
+    /// @inheritdoc IEulerSwap
     function EVC() external view override(EVCUtil, IEulerSwap) returns (address) {
         return address(evc);
     }
@@ -189,6 +189,13 @@ contract EulerSwap is IEulerSwap, EVCUtil {
         }
     }
 
+    /// @notice Withdraws assets from a vault, first using available balance and then borrowing if needed
+    /// @param vault The address of the vault to withdraw from
+    /// @param amount The total amount of assets to withdraw
+    /// @param to The address that will receive the withdrawn assets
+    /// @dev This function first checks if there's an existing balance in the vault.
+    /// @dev If there is, it withdraws the minimum of the requested amount and available balance.
+    /// @dev If more assets are needed after withdrawal, it enables the controller and borrows the remaining amount.
     function withdrawAssets(address vault, uint256 amount, address to) internal {
         uint256 balance = myBalance(vault);
 
@@ -204,6 +211,14 @@ contract EulerSwap is IEulerSwap, EVCUtil {
         }
     }
 
+    /// @notice Deposits assets into a vault and automatically repays any outstanding debt
+    /// @param vault The address of the vault to deposit into
+    /// @param amount The amount of assets to deposit
+    /// @return The amount of assets successfully deposited
+    /// @dev This function attempts to deposit assets into the specified vault.
+    /// @dev If the deposit fails with E_ZeroShares error, it safely returns 0 (this happens with very small amounts).
+    /// @dev After successful deposit, if the user has any outstanding controller-enabled debt, it attempts to repay it.
+    /// @dev If all debt is repaid, the controller is automatically disabled to reduce gas costs in future operations.
     function depositAssets(address vault, uint256 amount) internal returns (uint256) {
         try IEVault(vault).deposit(amount, eulerAccount) {}
         catch (bytes memory reason) {
@@ -237,10 +252,16 @@ contract EulerSwap is IEulerSwap, EVCUtil {
         }
     }
 
+    /// @notice Retrieves the current debt amount for the pool's eulerAccount
+    /// @param vault The address of the vault to check for debt
+    /// @return The amount of debt that the Euler account has in the specified vault
     function myDebt(address vault) internal view returns (uint256) {
         return IEVault(vault).debtOf(eulerAccount);
     }
 
+    /// @notice Calculates the asset balance of the pool's eulerAccount
+    /// @param vault The address of the vault to check for balance
+    /// @return The amount of assets that the Euler account has deposited in the specified vault
     function myBalance(address vault) internal view returns (uint256) {
         uint256 shares = IEVault(vault).balanceOf(eulerAccount);
         return shares == 0 ? 0 : IEVault(vault).convertToAssets(shares);

src/EulerSwapPeriphery.sol

@@ -67,41 +67,6 @@ contract EulerSwapPeriphery is IEulerSwapPeriphery {
         return calcLimits(IEulerSwap(eulerSwap), checkTokens(IEulerSwap(eulerSwap), tokenIn, tokenOut));
     }
 
-    /// @inheritdoc IEulerSwapPeriphery
-    function fInverse(uint256 y, uint256 px, uint256 py, uint256 x0, uint256 y0, uint256 c)
-        external
-        pure
-        returns (uint256)
-    {
-        // A component of the quadratic formula: a = 2 * c
-        uint256 A = 2 * c;
-
-        // B component of the quadratic formula
-        int256 B = int256((px * (y - y0) + py - 1) / py) - int256((x0 * (2 * c - 1e18) + 1e18 - 1) / 1e18);
-
-        // B^2 component, using FullMath for overflow safety
-        uint256 absB = B < 0 ? uint256(-B) : uint256(B);
-        uint256 squaredB = Math.mulDiv(absB, absB, 1e18, Math.Rounding.Ceil);
-
-        // 4 * A * C component of the quadratic formula
-        uint256 AC4 = Math.mulDiv(
-            Math.mulDiv(4 * c, (1e18 - c), 1e18, Math.Rounding.Ceil),
-            Math.mulDiv(x0, x0, 1e18, Math.Rounding.Ceil),
-            1e18,
-            Math.Rounding.Ceil
-        );
-
-        // Discriminant: b^2 + 4ac, scaled up to maintain precision
-        uint256 discriminant = (squaredB + AC4) * 1e18;
-
-        // Square root of the discriminant (rounded up)
-        uint256 sqrt = Math.sqrt(discriminant);
-        sqrt = (sqrt * sqrt < discriminant) ? sqrt + 1 : sqrt;
-
-        // Compute and return x = fInverse(y) using the quadratic formula
-        return Math.mulDiv(uint256(int256(sqrt) - B), 1e18, A, Math.Rounding.Ceil);
-    }
-
     /// @dev Internal function to execute a token swap through EulerSwap
     /// @param eulerSwap The EulerSwap contract address to execute the swap through
     /// @param tokenIn The address of the input token being swapped

src/interfaces/IEulerSwap.sol

@@ -51,6 +51,10 @@ interface IEulerSwap {
     function equilibriumReserve0() external view returns (uint112);
     function equilibriumReserve1() external view returns (uint112);
     function feeMultiplier() external view returns (uint256);
+    /// @notice Returns the current reserves of the pool
+    /// @return reserve0 The amount of asset0 in the pool
+    /// @return reserve1 The amount of asset1 in the pool
+    /// @return status The status of the pool (0 = unactivated, 1 = unlocked, 2 = locked)
     function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 status);
 
     // Curve Accessors

src/interfaces/IEulerSwapPeriphery.sol

@@ -24,28 +24,4 @@ interface IEulerSwapPeriphery {
 
     /// @notice Max amount the pool can buy of tokenIn and sell of tokenOut
     function getLimits(address eulerSwap, address tokenIn, address tokenOut) external view returns (uint256, uint256);
-
-    /**
-     * @notice Computes the inverse of the `f()` function for the EulerSwap liquidity curve.
-     * @dev Solves for `x` given `y` using the quadratic formula derived from the liquidity curve:
-     *      x = (-b + sqrt(b^2 + 4ac)) / 2a
-     *      Utilises mulDiv to avoid overflow and ensures precision with upward rounding.
-     *
-     * @param y The y-coordinate input value (must be greater than `y0`).
-     * @param px Price factor for the x-axis (scaled by 1e18, between 1e18 and 1e36).
-     * @param py Price factor for the y-axis (scaled by 1e18, between 1e18 and 1e36).
-     * @param x0 Reference x-value on the liquidity curve (≤ 2^112 - 1).
-     * @param y0 Reference y-value on the liquidity curve (≤ 2^112 - 1).
-     * @param c Curve parameter shaping liquidity concentration (scaled by 1e18, between 0 and 1e18).
-     *
-     * @return x The computed x-coordinate on the liquidity curve.
-     *
-     * @custom:precision Uses rounding up to maintain precision in all calculations.
-     * @custom:safety FullMath handles potential overflow in the b^2 computation.
-     * @custom:requirement Input `y` must be strictly greater than `y0`; otherwise, the function will revert.
-     */
-    function fInverse(uint256 y, uint256 px, uint256 py, uint256 x0, uint256 y0, uint256 c)
-        external
-        pure
-        returns (uint256);
 }