feat: add fInverse() test and EulerSwapMock.sol contract

Author: euler-mab

test/EulerSwapPeriphery.t.sol

@@ -1,15 +1,27 @@
 // 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 {EulerSwapMock} from "./mocks/EulerSwapMock.sol";
 
 contract EulerSwapPeripheryTest is EulerSwapTestBase {
     EulerSwap public eulerSwap;
+    EulerSwapMock public eulerSwapMock;
 
     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
+        });
+
+        eulerSwapMock = new EulerSwapMock(params, curveParams); // Use the mock EulerSwap contract with a public f() function
     }
 
     function test_SwapExactIn() public {
@@ -69,4 +81,17 @@ contract EulerSwapPeripheryTest is EulerSwapTestBase {
         periphery.swapExactOut(address(eulerSwap), address(assetTST), address(assetTST2), amountOut * 2, amountIn);
         vm.stopPrank();
     }
+
+    function test_fInverseFuzz(uint256 x) public {
+        x = bound(x, 2, 50e18 - 1); // it fails if 1 us used, not an issue since only used in periphery
+        uint256 y = eulerSwapMock.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/mocks/EulerSwapMock.sol

@@ -0,0 +1,23 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.27;
+
+import {EulerSwap, IEulerSwap} from "../../src/EulerSwap.sol";
+
+contract EulerSwapMock 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);
+    }
+}