periphery: getLimits

Author: hoytech

src/EulerSwapPeriphery.sol

@@ -102,15 +102,7 @@ contract EulerSwapPeriphery is IEulerSwapPeriphery {
         // exactIn: decrease received amountIn, rounding down
         if (exactIn) amount = amount * feeMultiplier / 1e18;
 
-        bool asset0IsInput;
-        {
-            address asset0 = eulerSwap.asset0();
-            address asset1 = eulerSwap.asset1();
-
-            if (tokenIn == asset0 && tokenOut == asset1) asset0IsInput = true;
-            else if (tokenIn == asset1 && tokenOut == asset0) asset0IsInput = false;
-            else revert UnsupportedPair();
-        }
+        bool asset0IsInput = checkTokens(eulerSwap, tokenIn, tokenOut);
 
         uint256 quote = binarySearch(eulerSwap, reserve0, reserve1, amount, exactIn, asset0IsInput);
 
@@ -242,4 +234,71 @@ contract EulerSwapPeriphery is IEulerSwapPeriphery {
         // Compute and return x = fInverse(y) using the quadratic formula
         return Math.mulDiv(uint256(int256(sqrt) - B), 1e18, A, Math.Rounding.Ceil);
     }
+
+    /// @dev Max amount the pool can buy of tokenIn and sell of tokenOut
+    function getLimits(address eulerSwap, address tokenIn, address tokenOut)
+        external
+        view
+        returns (uint256 inLimit, uint256 outLimit)
+    {
+        IEulerSwap es = IEulerSwap(eulerSwap);
+        if (!IEVC(es.EVC()).isAccountOperatorAuthorized(es.eulerAccount(), eulerSwap)) return (0, 0);
+
+        inLimit = outLimit = type(uint112).max;
+        bool asset0IsInput = checkTokens(es, tokenIn, tokenOut);
+
+        // Supply caps on input
+        {
+            IEVault vault = IEVault(asset0IsInput ? es.vault0() : es.vault1());
+            uint256 maxDeposit = vault.debtOf(es.eulerAccount()) + vault.maxDeposit(es.eulerAccount());
+            if (maxDeposit < inLimit) inLimit = maxDeposit;
+        }
+
+        // Remaining reserves of output
+
+        {
+            (uint112 reserve0, uint112 reserve1,) = es.getReserves();
+            uint112 reserveLimit = asset0IsInput ? reserve1 : reserve0;
+            if (reserveLimit < outLimit) outLimit = reserveLimit;
+        }
+
+        // Remaining cash and borrow caps in output
+
+        {
+            IEVault vault = IEVault(asset0IsInput ? es.vault1() : es.vault0());
+
+            uint256 cash = vault.cash();
+            if (cash < outLimit) outLimit = cash;
+
+            (, uint16 borrowCap) = vault.caps();
+            uint256 maxWithdraw = decodeCap(uint256(borrowCap));
+            maxWithdraw = vault.totalBorrows() > maxWithdraw ? 0 : maxWithdraw - vault.totalBorrows();
+            if (maxWithdraw > cash) maxWithdraw = cash;
+            maxWithdraw += vault.convertToAssets(vault.balanceOf(es.eulerAccount()));
+            if (maxWithdraw < outLimit) outLimit = maxWithdraw;
+        }
+    }
+
+    function decodeCap(uint256 amountCap) internal pure returns (uint256) {
+        if (amountCap == 0) return type(uint256).max;
+
+        unchecked {
+            // Cannot overflow because this is less than 2**256:
+            //   10**(2**6 - 1) * (2**10 - 1) = 1.023e+66
+            return 10 ** (amountCap & 63) * (amountCap >> 6) / 100;
+        }
+    }
+
+    function checkTokens(IEulerSwap eulerSwap, address tokenIn, address tokenOut)
+        internal
+        view
+        returns (bool asset0IsInput)
+    {
+        address asset0 = eulerSwap.asset0();
+        address asset1 = eulerSwap.asset1();
+
+        if (tokenIn == asset0 && tokenOut == asset1) asset0IsInput = true;
+        else if (tokenIn == asset1 && tokenOut == asset0) asset0IsInput = false;
+        else revert UnsupportedPair();
+    }
 }

test/Limits.t.sol

@@ -0,0 +1,63 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+pragma solidity ^0.8.24;
+
+import {EulerSwapTestBase, EulerSwap, EulerSwapPeriphery, IEulerSwap} from "./EulerSwapTestBase.t.sol";
+
+contract LimitsTest is EulerSwapTestBase {
+    EulerSwap public eulerSwap;
+
+    function setUp() public virtual override {
+        super.setUp();
+
+        eulerSwap = createEulerSwap(50e18, 50e18, 0, 1e18, 1e18, 0.4e18, 0.85e18);
+    }
+
+    function test_basicLimits() public {
+        (uint256 inLimit, uint256 outLimit) =
+            periphery.getLimits(address(eulerSwap), address(assetTST), address(assetTST2));
+
+        assertEq(inLimit, type(uint112).max - 110e18); // max uint minus 110 (100 deposited by depositor, 10 by holder)
+        assertEq(outLimit, 60e18);
+    }
+
+    function test_supplyCapExceeded() public {
+        eTST.setCaps(uint16(2.72e2 << 6) | 18, 0);
+
+        (uint256 inLimit, uint256 outLimit) =
+            periphery.getLimits(address(eulerSwap), address(assetTST), address(assetTST2));
+
+        assertEq(inLimit, 0); // cap exceeded
+        assertEq(outLimit, 60e18);
+    }
+
+    function test_supplyCapExtra() public {
+        eTST.setCaps(uint16(2.72e2 << 6) | (18 + 2), 0);
+
+        (uint256 inLimit, uint256 outLimit) =
+            periphery.getLimits(address(eulerSwap), address(assetTST), address(assetTST2));
+
+        assertEq(inLimit, 162e18); // 272 - 110
+        assertEq(outLimit, 60e18);
+    }
+
+    function test_utilisation() public {
+        vm.prank(depositor);
+        eTST2.withdraw(95e18, address(depositor), address(depositor));
+
+        (uint256 inLimit, uint256 outLimit) =
+            periphery.getLimits(address(eulerSwap), address(assetTST), address(assetTST2));
+
+        assertEq(inLimit, type(uint112).max - 110e18);
+        assertEq(outLimit, 15e18); // 110 - 95
+    }
+
+    function test_borrowCap() public {
+        eTST2.setCaps(0, uint16(8.5e2 << 6) | 18);
+
+        (uint256 inLimit, uint256 outLimit) =
+            periphery.getLimits(address(eulerSwap), address(assetTST), address(assetTST2));
+
+        assertEq(inLimit, type(uint112).max - 110e18);
+        assertEq(outLimit, 18.5e18); // 10 in balance, plus 8.5 borrow cap
+    }
+}