quotePadding, add new test

Author: hoytech

README.md

@@ -118,7 +118,7 @@ With careful parameter selection, the EulerSwap curve supports optimal tradeoffs
 
 * The EulerSwap curve has some numerical instability that we believe is caused by rounding
   * We think the biggest effect is that it may cause some swaps to fail even if the exact quoted amount is sent. Also, it may result in users slightly overpaying for swaps.
-  * The code currently has a roundingCompensation adjustment that seems to prevent this, but since we don't know a hard upper-bound it's hard to say if this solves it in all cases
+  * The code currently has a quotePadding adjustment that seems to prevent this, but since we don't know a hard upper-bound it's hard to say if this solves it in all cases. In particular, this will only work well for 18-decimal tokens of reasonable prices
 * Currently we have only been supporting stable-stable pairs
   * What extra considerations would there be for floating pairs?
 * Automatically re-invest fees. There are a few options:

src/MaglevEulerSwap.sol

@@ -34,11 +34,6 @@ contract MaglevEulerSwap is IMaglevEulerSwap, MaglevBase {
         initialReserve1 = reserve1;
     }
 
-    // Due to rounding, computeQuote() may underestimate the amount required to
-    // pass the verify() function. In order to prevent swaps from failing, quotes
-    // are inflated by this compensation factor. FIXME: solve the rounding.
-    uint256 private constant roundingCompensation = 1.0000000000001e18;
-
     function verify(uint256 newReserve0, uint256 newReserve1) internal view virtual override {
         int256 delta = 0;
 
@@ -54,6 +49,11 @@ contract MaglevEulerSwap is IMaglevEulerSwap, MaglevBase {
         require(delta >= 0, KNotSatisfied());
     }
 
+    // Due to rounding, computeQuote() may underestimate the amount required to
+    // pass the verify() function. In order to prevent swaps from failing, quotes
+    // are inflated by this padding factor.
+    uint256 private constant quotePadding = 1.00000000001e18;
+
     function computeQuote(uint256 amount, bool exactIn, bool asset0IsInput)
         internal
         view
@@ -112,11 +112,11 @@ contract MaglevEulerSwap is IMaglevEulerSwap, MaglevBase {
         if (exactIn) {
             if (asset0IsInput) output = uint256(-dy);
             else output = uint256(-dx);
-            output = output * 1e18 / roundingCompensation;
+            output = output * 1e18 / quotePadding;
         } else {
             if (asset0IsInput) output = uint256(dx);
             else output = uint256(dy);
-            output = output * roundingCompensation / 1e18;
+            output = output * quotePadding / 1e18;
         }
     }
 

test/EulerSwap.t.sol

@@ -173,7 +173,7 @@ contract EulerSwapTest is MaglevTestBase {
         assertGe(getHolderNAV(), origNAV);
     }
 
-    // To reproduce, change roundingCompensation to 1e18
+    // To reproduce, change quotePadding to 1e18
     function test_roundingFailure() public {
         uint256 amountIn = 1.4e18;
         uint256 amountOut = maglev.quoteExactInput(address(assetTST), address(assetTST2), amountIn);
@@ -210,7 +210,7 @@ contract EulerSwapTest is MaglevTestBase {
             t1.transfer(address(maglev), amount);
 
             {
-                uint256 qPlus = q * 1.0000000000002e18 / 1e18;
+                uint256 qPlus = q * 1.00000000002e18 / 1e18;
                 vm.expectRevert();
                 if (dir) maglev.swap(0, qPlus, address(this), "");
                 else maglev.swap(qPlus, 0, address(this), "");

test/PreserveNav.t.sol

@@ -0,0 +1,141 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+pragma solidity ^0.8.24;
+
+import {Test, console} from "forge-std/Test.sol";
+
+import {TestERC20} from "evk-test/unit/evault/EVaultTestBase.t.sol";
+import {IEVault} from "evk/EVault/IEVault.sol";
+import {MaglevTestBase} from "./MaglevTestBase.t.sol";
+
+import {MaglevEulerSwap as Maglev, MaglevBase} from "../src/MaglevEulerSwap.sol";
+
+contract PreserveNav is MaglevTestBase {
+    Maglev public maglev;
+
+    function setUp() public virtual override {
+        super.setUp();
+    }
+
+    function createMaglev(
+        uint112 debtLimitA,
+        uint112 debtLimitB,
+        uint256 fee,
+        uint256 px,
+        uint256 py,
+        uint256 cx,
+        uint256 cy
+    ) internal {
+        vm.prank(creator);
+        maglev = new Maglev(
+            getMaglevBaseParams(debtLimitA, debtLimitB, fee),
+            Maglev.EulerSwapParams({priceX: px, priceY: py, concentrationX: cx, concentrationY: cy})
+        );
+
+        vm.prank(holder);
+        evc.setAccountOperator(holder, address(maglev), true);
+
+        vm.prank(anyone);
+        maglev.configure();
+    }
+
+
+
+    function test_preserve_nav(uint256 cx, uint256 cy, uint256 fee, bool preSkimDir, bool dir1, uint256 amount1, bool skimOrder1, bool dir2, uint256 amount2, bool skimOrder2) public {
+        cx = bound(cx, 0.1e18, 0.99e18);
+        cy = bound(cy, 0.1e18, 0.99e18);
+        fee = bound(fee, 0, 0.2e18);
+        amount1 = bound(amount1, 0.00001e18, 25e18);
+        amount2 = bound(amount2, 0.00001e18, 25e18);
+
+        if (fee < 0.1e18) fee = 0; // half of the time use fee 0
+        else fee -= 0.1e18;
+
+        createMaglev(50e18, 50e18, fee, 1e18, 1e18, cx, cy);
+
+        skimAll(preSkimDir);
+        int256 nav1 = getHolderNAV();
+
+        {
+            TestERC20 t1;
+            TestERC20 t2;
+            if (dir1) (t1, t2) = (assetTST, assetTST2);
+            else (t1, t2) = (assetTST2, assetTST);
+
+            uint256 q = maglev.quoteExactInput(address(t1), address(t2), amount1);
+
+            t1.mint(address(this), amount1);
+            t1.transfer(address(maglev), amount1);
+            if (dir1) maglev.swap(0, q, address(this), "");
+            else maglev.swap(q, 0, address(this), "");
+
+            skimAll(skimOrder1);
+        }
+
+        assertGe(getHolderNAV(), nav1);
+
+        {
+            TestERC20 t1;
+            TestERC20 t2;
+            if (dir2) (t1, t2) = (assetTST, assetTST2);
+            else (t1, t2) = (assetTST2, assetTST);
+
+            uint256 q = maglev.quoteExactInput(address(t1), address(t2), amount2);
+
+            t1.mint(address(this), amount2);
+            t1.transfer(address(maglev), amount2);
+            if (dir2) maglev.swap(0, q, address(this), "");
+            else maglev.swap(q, 0, address(this), "");
+
+            skimAll(skimOrder2);
+        }
+
+        assertGe(getHolderNAV(), nav1);
+    }
+
+
+
+    function _skimAll(bool dir) public returns (uint256) {
+        uint256 skimmed = 0;
+        uint256 val = 1;
+
+        // Phase 1: Keep doubling skim amount until it fails
+
+        while (true) {
+            (uint256 amount0, uint256 amount1) = dir ? (val, uint256(0)) : (uint256(0), val);
+
+            try maglev.swap(amount0, amount1, address(0xDEAD), "") {
+                skimmed += val;
+                val *= 2;
+            } catch {
+                break;
+            }
+        }
+
+        // Phase 2: Keep halving skim amount until 1 wei skim fails
+
+        while (true) {
+            if (val > 1) val /= 2;
+
+            (uint256 amount0, uint256 amount1) = dir ? (val, uint256(0)) : (uint256(0), val);
+
+            try maglev.swap(amount0, amount1, address(0xDEAD), "") {
+                skimmed += val;
+            } catch {
+                if (val == 1) break;
+            }
+        }
+
+        return skimmed;
+    }
+
+    function skimAll(bool order) public {
+        if (order) {
+            _skimAll(true);
+            _skimAll(false);
+        } else {
+            _skimAll(false);
+            _skimAll(true);
+        }
+    }
+}