move fee logic to base class so it's shared by all curves

Author: hoytech

src/MaglevBase.sol

@@ -14,6 +14,9 @@ abstract contract MaglevBase is EVCUtil, Ownable {
     address public immutable asset0;
     address public immutable asset1;
     address public immutable myAccount;
+    uint112 public immutable debtLimit0;
+    uint112 public immutable debtLimit1;
+    uint256 public immutable feeMultiplier;
 
     uint112 public reserve0;
     uint112 public reserve1;
@@ -25,6 +28,7 @@ abstract contract MaglevBase is EVCUtil, Ownable {
     error Reentrancy();
     error Overflow();
     error UnsupportedPair();
+    error BadFee();
     error InsufficientReserves();
     error InsufficientCash();
 
@@ -44,14 +48,22 @@ abstract contract MaglevBase is EVCUtil, Ownable {
         address vault0;
         address vault1;
         address myAccount;
+        uint112 debtLimit0;
+        uint112 debtLimit1;
+        uint256 fee;
     }
 
     constructor(BaseParams memory params) EVCUtil(params.evc) Ownable(msg.sender) {
+        require(params.fee < 1e18, BadFee());
+
         vault0 = params.vault0;
         vault1 = params.vault1;
         asset0 = IEVault(vault0).asset();
         asset1 = IEVault(vault1).asset();
         myAccount = params.myAccount;
+        reserve0 = initialReserve0 = adjustReserve(params.debtLimit0, vault0);
+        reserve1 = initialReserve1 = adjustReserve(params.debtLimit1, vault1);
+        feeMultiplier = 1e18 - params.fee;
     }
 
     // Owner functions
@@ -65,11 +77,6 @@ abstract contract MaglevBase is EVCUtil, Ownable {
         IEVC(evc).enableCollateral(myAccount, vault1);
     }
 
-    function setDebtLimit(uint112 debtLimit0, uint112 debtLimit1) external onlyOwner {
-        reserve0 = initialReserve0 = adjustReserve(debtLimit0, vault0);
-        reserve1 = initialReserve1 = adjustReserve(debtLimit1, vault1);
-    }
-
     // Swapper interface
 
     function swap(uint256 amount0Out, uint256 amount1Out, address to, bytes calldata data)
@@ -86,12 +93,19 @@ abstract contract MaglevBase is EVCUtil, Ownable {
 
         if (data.length > 0) IUniswapV2Callee(to).uniswapV2Call(msg.sender, amount0Out, amount1Out, data);
 
-        // Deposit all available funds
+        // Deposit all available funds, adjust received amounts downward to collect fees
 
         uint256 amount0In = IERC20(asset0).balanceOf(address(this));
+        if (amount0In > 0) {
+            depositAssets(vault0, amount0In);
+            amount0In = amount0In * feeMultiplier / 1e18;
+        }
+
         uint256 amount1In = IERC20(asset1).balanceOf(address(this));
-        if (amount0In > 0) depositAssets(vault0, amount0In);
-        if (amount1In > 0) depositAssets(vault1, amount1In);
+        if (amount1In > 0) {
+            depositAssets(vault1, amount1In);
+            amount1In = amount1In * feeMultiplier / 1e18;
+        }
 
         // Verify curve invariant is satisified
 
@@ -176,6 +190,9 @@ abstract contract MaglevBase is EVCUtil, Ownable {
         view
         returns (uint256)
     {
+        // exactIn: decrease received amountIn, rounding down
+        if (exactIn) amount = amount * feeMultiplier / 1e18;
+
         bool asset0IsInput;
         if (tokenIn == asset0 && tokenOut == asset1) asset0IsInput = true;
         else if (tokenIn == asset1 && tokenOut == asset0) asset0IsInput = false;
@@ -189,6 +206,9 @@ abstract contract MaglevBase is EVCUtil, Ownable {
             InsufficientCash()
         );
 
+        // exactOut: increase required amountIn, rounding up
+        if (!exactIn) quote = (quote * 1e18 + (feeMultiplier - 1)) / feeMultiplier;
+
         return quote;
     }
 

src/MaglevConstantProduct.sol

@@ -4,34 +4,23 @@ pragma solidity ^0.8.27;
 import {MaglevBase} from "./MaglevBase.sol";
 
 contract MaglevConstantProduct is MaglevBase {
-    uint64 public fee;
-
     error KNotSatisfied();
 
-    struct ConstantProductParams {
-        uint64 fee;
-    }
-
-    constructor(BaseParams memory baseParams, ConstantProductParams memory params) MaglevBase(baseParams) {
-        setConstantProductParams(params);
-    }
-
-    function setConstantProductParams(ConstantProductParams memory params) public onlyOwner {
-        fee = params.fee;
+    constructor(BaseParams memory baseParams) MaglevBase(baseParams) {
     }
 
     function k(uint256 r0, uint256 r1) public pure returns (uint256) {
         return r0 * r1;
     }
 
-    function verify(uint256 amount0In, uint256 amount1In, uint256 newReserve0, uint256 newReserve1)
+    function verify(uint256, uint256, uint256 newReserve0, uint256 newReserve1)
         internal
         view
         virtual
         override
     {
         uint256 kBefore = k(reserve0, reserve1);
-        uint256 kAfter = k(newReserve0 - (amount0In * fee / 1e18), newReserve1 - (amount1In * fee / 1e18));
+        uint256 kAfter = k(newReserve0, newReserve1);
         require(kAfter >= kBefore, KNotSatisfied());
     }
 
@@ -46,9 +35,9 @@ contract MaglevConstantProduct is MaglevBase {
         uint256 reserveOut = asset0IsInput ? reserve1 : reserve0;
 
         if (exactIn) {
-            return (reserveOut * amount) / (reserveIn + amount) * (1e18 - fee) / 1e18;
+            return (reserveOut * amount) / (reserveIn + amount);
         } else {
-            return (reserveIn * amount) / (reserveOut - amount) * 1e18 / (1e18 - fee);
+            return (reserveIn * amount) / (reserveOut - amount);
         }
     }
 }

src/MaglevConstantSum.sol

@@ -4,24 +4,17 @@ pragma solidity ^0.8.27;
 import {MaglevBase} from "./MaglevBase.sol";
 
 contract MaglevConstantSum is MaglevBase {
-    uint64 public fee;
-    uint96 public priceA;
-    uint96 public priceB;
+    uint256 public immutable priceA;
+    uint256 public immutable priceB;
 
     error KNotSatisfied();
 
     struct ConstantSumParams {
-        uint64 fee;
-        uint96 priceA;
-        uint96 priceB;
+        uint256 priceA;
+        uint256 priceB;
     }
 
     constructor(BaseParams memory baseParams, ConstantSumParams memory params) MaglevBase(baseParams) {
-        setConstantSumParams(params);
-    }
-
-    function setConstantSumParams(ConstantSumParams memory params) public onlyOwner {
-        fee = params.fee;
         priceA = params.priceA;
         priceB = params.priceB;
     }
@@ -30,24 +23,20 @@ contract MaglevConstantSum is MaglevBase {
         return (r0 * priceA) + (r1 * priceB);
     }
 
-    function verify(uint256 amount0In, uint256 amount1In, uint256 newReserve0, uint256 newReserve1)
+    function verify(uint256, uint256, uint256 newReserve0, uint256 newReserve1)
         internal
         view
         virtual
         override
     {
         uint256 kBefore = k(reserve0, reserve1);
-        uint256 kAfter = k(newReserve0 - (amount0In * fee / 1e18), newReserve1 - (amount1In * fee / 1e18));
+        uint256 kAfter = k(newReserve0, newReserve1);
         require(kAfter >= kBefore, KNotSatisfied());
     }
 
     // FIXME: incorporate priceA and priceB
 
-    function computeQuote(uint256 amount, bool exactIn, bool) internal view virtual override returns (uint256) {
-        if (exactIn) {
-            return amount * (1e18 - fee) / 1e18;
-        } else {
-            return amount * 1e18 / (1e18 - fee);
-        }
+    function computeQuote(uint256 amount, bool, bool) internal view virtual override returns (uint256) {
+        return amount;
     }
 }

src/MaglevEulerSwap.sol

@@ -10,7 +10,6 @@ contract MaglevEulerSwap is MaglevBase {
     uint256 public _py;
     uint256 public _cx;
     uint256 public _cy;
-    uint256 public _fee;
 
     error KNotSatisfied();
     error ReservesZero();
@@ -21,7 +20,6 @@ contract MaglevEulerSwap is MaglevBase {
         uint256 py;
         uint256 cx;
         uint256 cy;
-        uint256 fee;
     }
 
     constructor(BaseParams memory baseParams, EulerSwapParams memory params) MaglevBase(baseParams) {
@@ -33,8 +31,6 @@ contract MaglevEulerSwap is MaglevBase {
         _py = params.py;
         _cx = params.cx;
         _cy = params.cy;
-        _fee = params.fee;
-        //_fee = Math.max(params.fee, 0.0000000000001e18); // minimum fee required to compensate for rounding
     }
 
     // FIXME: how to charge fees?
@@ -51,6 +47,8 @@ contract MaglevEulerSwap is MaglevBase {
         require(delta >= 0, KNotSatisfied());
     }
 
+    uint256 private constant roundingCompensation = 1.0000000000001e18;
+
     function computeQuote(uint256 amount, bool exactIn, bool asset0IsInput)
         internal
         view
@@ -89,11 +87,11 @@ contract MaglevEulerSwap is MaglevBase {
         if (exactIn) {
             if (asset0IsInput) output = uint256(-dy);
             else output = uint256(-dx);
-            output = output * 1e18 / (1e18 + _fee);
+            output = output * 1e18 / roundingCompensation;
         } else {
             if (asset0IsInput) output = uint256(dx);
             else output = uint256(dy);
-            output = output * (1e18 + _fee) / 1e18;
+            output = output * roundingCompensation / 1e18;
         }
     }
 

test/ConstantProduct.t.sol

@@ -16,17 +16,34 @@ contract ConstantProductTest is MaglevTestBase {
     function setUp() public virtual override {
         super.setUp();
 
+        createMaglev(50e18, 50e18, 0);
+    }
+
+    function createMaglev(uint112 debtLimit0, uint112 debtLimit1, uint256 fee) internal {
         vm.prank(owner);
-        maglev = new Maglev(_getMaglevBaseParams(), Maglev.ConstantProductParams({fee: 0}));
+        maglev = new Maglev(getMaglevBaseParams(debtLimit0, debtLimit1, fee));
 
         vm.prank(holder);
         evc.setAccountOperator(holder, address(maglev), true);
 
         vm.prank(owner);
         maglev.configure();
+    }
 
-        vm.prank(owner);
-        maglev.setDebtLimit(50e18, 50e18);
+    function test_basicExactIn() public monotonicHolderNAV {
+        uint256 amount = 1e18;
+
+        assetTST.mint(address(this), amount);
+
+        uint256 q = maglev.quoteExactInput(address(assetTST), address(assetTST2), amount);
+
+        assetTST.transfer(address(maglev), amount);
+
+        vm.expectRevert(Maglev.KNotSatisfied.selector);
+        maglev.swap(0, q+1, address(this), "");
+
+        maglev.swap(0, q, address(this), "");
+        assertEq(assetTST2.balanceOf(address(this)), q);
     }
 
     function test_fee_exactIn(uint256 amount, bool dir) public monotonicHolderNAV {
@@ -39,15 +56,20 @@ contract ConstantProductTest is MaglevTestBase {
 
         t1.mint(address(this), amount);
 
-        uint256 qOrig = maglev.quoteExactInput(address(assetTST), address(assetTST2), amount);
+        uint256 qOrig = maglev.quoteExactInput(address(assetTST), address(assetTST2), amount * 0.998e18 / 1e18);
 
-        vm.prank(owner);
-        maglev.setConstantProductParams(Maglev.ConstantProductParams({fee: 0.002e18}));
+        createMaglev(50e18, 50e18, 0.002e18);
 
         uint256 q = maglev.quoteExactInput(address(assetTST), address(assetTST2), amount);
-        assertApproxEqAbs(1e18 * q / qOrig, 0.998e18, 0.000000000001e18);
+
+        assertEq(qOrig, q);
 
         t1.transfer(address(maglev), amount);
+
+        vm.expectRevert(Maglev.KNotSatisfied.selector);
+        if (dir) maglev.swap(0, q+1, address(this), "");
+        else maglev.swap(q+1, 0, address(this), "");
+
         if (dir) maglev.swap(0, q, address(this), "");
         else maglev.swap(q, 0, address(this), "");
         assertEq(t2.balanceOf(address(this)), q);
@@ -72,7 +94,6 @@ contract ConstantProductTest is MaglevTestBase {
 
         t2.transfer(address(maglev), q);
         if (dir) maglev.swap(amount - 2, 0, address(this), ""); // - 2 due to rounding
-
         else maglev.swap(0, amount - 2, address(this), "");
 
         uint256 q2 = maglev.quoteExactInput(address(t1), address(t2), amount);