Merge pull request #35 from euler-xyz/fInverse

add fInverse() function with tests to periphery

Author: haythemsellami

.gitmodules

@@ -10,3 +10,6 @@
 [submodule "lib/ethereum-vault-connector"]
 	path = lib/ethereum-vault-connector
 	url = https://github.com/euler-xyz/ethereum-vault-connector
+[submodule "lib/v4-core"]
+	path = lib/v4-core
+	url = https://github.com/Uniswap/v4-core

lib/v4-core

@@ -3,4 +3,5 @@ evc/=lib/ethereum-vault-connector/src/
 evk/=lib/euler-vault-kit/src/
 ethereum-vault-connector/=lib/ethereum-vault-connector/src/
 evk-test/=lib/euler-vault-kit/test/
-permit2/=lib/euler-vault-kit/lib/permit2/
+permit2/=lib/euler-vault-kit/lib/permit2/
+@uniswap/v4-core/=lib/v4-core/src/

remappings.txt

@@ -5,6 +5,8 @@ import {IEVC} from "evc/interfaces/IEthereumVaultConnector.sol";
 import {IEVault} from "evk/EVault/IEVault.sol";
 import {IEulerSwapPeriphery} from "./interfaces/IEulerSwapPeriphery.sol";
 import {IERC20, IEulerSwap, SafeERC20} from "./EulerSwap.sol";
+import {Math} from "openzeppelin-contracts/utils/math/Math.sol";
+import "@uniswap/v4-core/libraries/FullMath.sol";
 
 contract EulerSwapPeriphery is IEulerSwapPeriphery {
     using SafeERC20 for IERC20;
@@ -188,4 +190,57 @@ contract EulerSwapPeriphery is IEulerSwapPeriphery {
             else output = uint256(dy);
         }
     }
+
+    /**
+     * @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 Uniswap's FullMath 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)
+    {
+        // 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 = FullMath.mulDiv(absB, absB, 1e18) + (absB * absB % 1e18 == 0 ? 0 : 1);
+
+        // 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);
+    }
 }

src/EulerSwapPeriphery.sol

@@ -1,15 +1,23 @@
 // SPDX-License-Identifier: GPL-2.0-or-later
 pragma solidity ^0.8.24;
 
-import {EulerSwapTestBase, EulerSwap, EulerSwapPeriphery} from "./EulerSwapTestBase.t.sol";
+import {EulerSwapTestBase, EulerSwap, EulerSwapPeriphery, IEulerSwap} from "./EulerSwapTestBase.t.sol";
+import {EulerSwapHarness} from "./harness/EulerSwapHarness.sol";
 
 contract EulerSwapPeripheryTest is EulerSwapTestBase {
     EulerSwap public eulerSwap;
+    EulerSwapHarness public eulerSwapHarness;
 
     function setUp() public virtual override {
         super.setUp();
 
         eulerSwap = createEulerSwap(50e18, 50e18, 0, 1e18, 1e18, 0.4e18, 0.85e18);
+
+        IEulerSwap.Params memory params = getEulerSwapParams(50e18, 50e18, 0.4e18);
+        IEulerSwap.CurveParams memory curveParams =
+            IEulerSwap.CurveParams({priceX: 1e18, priceY: 1e18, concentrationX: 0.85e18, concentrationY: 0.85e18});
+
+        eulerSwapHarness = new EulerSwapHarness(params, curveParams); // Use the mock EulerSwap contract with a public f() function
     }
 
     function test_SwapExactIn() public {
@@ -69,4 +77,17 @@ contract EulerSwapPeripheryTest is EulerSwapTestBase {
         periphery.swapExactOut(address(eulerSwap), address(assetTST), address(assetTST2), amountOut * 2, amountIn);
         vm.stopPrank();
     }
+
+    function test_fInverseFuzz(uint256 x) public view {
+        x = bound(x, 2, 50e18 - 1); // note that it fails if 1 used as minimum, not an issue since only used in periphery
+        uint256 y = eulerSwapHarness.exposedF(x, 1e18, 1e18, 50e18, 50e18, 0.85e18);
+        uint256 outX = periphery.fInverse(y, 1e18, 1e18, 50e18, 50e18, 0.85e18);
+
+        // Ensure x is within the expected range
+        assertGe(outX, x); // Asserts xOut >= x
+        assertLe(outX, x + 1); // Asserts xOut <= x + 1
+
+        // Alternative using assertApproxEqAbs for absolute difference within 1
+        assertApproxEqAbs(x, outX, 1);
+    }
 }

test/EulerSwapPeriphery.t.sol

@@ -0,0 +1,19 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.27;
+
+import {EulerSwap, IEulerSwap} from "../../src/EulerSwap.sol";
+
+contract EulerSwapHarness is EulerSwap {
+    constructor(IEulerSwap.Params memory params, IEulerSwap.CurveParams memory curveParams)
+        EulerSwap(params, curveParams)
+    {}
+
+    /// @notice Exposes the internal f() function as a public function for testing
+    function exposedF(uint256 x, uint256 px, uint256 py, uint256 x0, uint256 y0, uint256 c)
+        external
+        pure
+        returns (uint256)
+    {
+        return f(x, px, py, x0, y0, c);
+    }
+}