@pendle/core-v2 0.2.3 → 0.3.0

package/contracts/core/router/base/PendleRouterYTBaseUpg.sol

@@ -7,13 +7,15 @@ import "../../../interfaces/IPMarketAddRemoveCallback.sol";
 import "../../../interfaces/IPMarketSwapCallback.sol";
 import "../../../SuperComposableYield/SCYUtils.sol";
 import "../../../libraries/math/MarketApproxLib.sol";
+import "../../../libraries/math/MarketMathAux.sol";
 import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
 
 abstract contract PendleRouterYTBaseUpg is IPMarketSwapCallback {
-    using FixedPoint for uint256;
-    using FixedPoint for int256;
-    using MarketMathLib for MarketParameters;
-    using MarketApproxLib for MarketParameters;
+    using Math for uint256;
+    using Math for int256;
+    using MarketMathCore for MarketState;
+    using MarketMathAux for MarketState;
+    using MarketApproxLib for MarketState;
     using SafeERC20 for ISuperComposableYield;
     using SafeERC20 for IPYieldToken;
 
@@ -21,7 +23,8 @@ abstract contract PendleRouterYTBaseUpg is IPMarketSwapCallback {
     enum YT_SWAP_TYPE {
         ExactYtForScy,
         SCYForExactYt,
-        ExactScyForYt
+        ExactScyForYt,
+        YtForExactScy
     }
 
     address public immutable marketFactory;
@@ -42,40 +45,29 @@ abstract contract PendleRouterYTBaseUpg is IPMarketSwapCallback {
         address receiver,
         address market,
         uint256 exactScyIn,
-        uint256 minYtOut,
-        uint256 netYtOutGuessMin,
-        uint256 netYtOutGuessMax,
+        ApproxParams memory approx,
         bool doPull
     ) internal returns (uint256 netYtOut) {
-        {
-            (ISuperComposableYield SCY, , IPYieldToken YT) = IPMarket(market).readTokens();
-            {
-                MarketParameters memory state = IPMarket(market).readState();
-
-                netYtOut = state.approxSwapExactScyForYt(
-                    SCYIndexLib.newIndex(SCY),
-                    exactScyIn,
-                    block.timestamp,
-                    netYtOutGuessMin,
-                    netYtOutGuessMax
-                );
-                require(netYtOut >= minYtOut, "insufficient out");
-            }
-
-            if (doPull) {
-                SCY.safeTransferFrom(msg.sender, address(YT), exactScyIn);
-            }
-        }
+        (ISuperComposableYield SCY, , IPYieldToken YT) = IPMarket(market).readTokens();
+        MarketState memory state = IPMarket(market).readState(false);
+
+        (netYtOut, ) = state.approxSwapExactScyForYt(
+            SCYIndexLib.newIndex(SCY),
+            exactScyIn,
+            block.timestamp,
+            approx
+        );
 
-        {
-            uint256 exactOtIn = netYtOut;
-            IPMarket(market).swapExactOtForScy(
-                receiver,
-                exactOtIn,
-                1,
-                abi.encode(YT_SWAP_TYPE.ExactScyForYt, receiver)
-            );
+        if (doPull) {
+            SCY.safeTransferFrom(msg.sender, address(YT), exactScyIn);
         }
+
+        IPMarket(market).swapExactOtForScy(
+            receiver,
+            netYtOut, // exactOtIn = netYtOut
+            1,
+            abi.encode(YT_SWAP_TYPE.ExactScyForYt, receiver)
+        );
     }
 
     /**
@@ -94,9 +86,6 @@ abstract contract PendleRouterYTBaseUpg is IPMarketSwapCallback {
     ) internal returns (uint256 netScyOut) {
         (ISuperComposableYield SCY, , IPYieldToken YT) = IPMarket(market).readTokens();
 
-        // takes out the same amount of OT as exactYtIn, to pair together
-        uint256 exactOtOut = exactYtIn;
-
         uint256 preBalanceScy = SCY.balanceOf(receiver);
 
         if (doPull) {
@@ -105,7 +94,7 @@ abstract contract PendleRouterYTBaseUpg is IPMarketSwapCallback {
 
         IPMarket(market).swapScyForExactOt(
             receiver,
-            exactOtOut,
+            exactYtIn, // exactOtOut = exactYtIn
             type(uint256).max,
             abi.encode(YT_SWAP_TYPE.ExactYtForScy, receiver)
         );
@@ -127,12 +116,11 @@ abstract contract PendleRouterYTBaseUpg is IPMarketSwapCallback {
     ) internal returns (uint256 netScyIn) {
         (ISuperComposableYield SCY, , ) = IPMarket(market).readTokens();
 
-        uint256 exactOtIn = exactYtOut;
         uint256 preBalanceScy = SCY.balanceOf(receiver);
 
         IPMarket(market).swapExactOtForScy(
             receiver,
-            exactOtIn,
+            exactYtOut, // exactOtIn = exactYtOut
             1,
             abi.encode(YT_SWAP_TYPE.SCYForExactYt, msg.sender, receiver)
         );
@@ -142,6 +130,35 @@ abstract contract PendleRouterYTBaseUpg is IPMarketSwapCallback {
         require(netScyIn <= maxScyIn, "exceed out limit");
     }
 
+    function _swapYtForExactScy(
+        address receiver,
+        address market,
+        uint256 exactScyOut,
+        ApproxParams memory approx,
+        bool doPull
+    ) internal returns (uint256 netYtIn) {
+        MarketState memory state = IPMarket(market).readState(false);
+        (ISuperComposableYield SCY, , IPYieldToken YT) = IPMarket(market).readTokens();
+
+        (netYtIn, ) = state.approxSwapYtForExactScy(
+            SCYIndexLib.newIndex(SCY),
+            exactScyOut,
+            block.timestamp,
+            approx
+        );
+
+        if (doPull) {
+            YT.safeTransferFrom(msg.sender, address(YT), netYtIn);
+        }
+
+        IPMarket(market).swapScyForExactOt(
+            address(YT),
+            netYtIn, // exactOtOut = netYtIn
+            type(uint256).max,
+            abi.encode(YT_SWAP_TYPE.YtForExactScy, receiver)
+        );
+    }
+
     function swapCallback(
         int256 otToAccount,
         int256 scyToAccount,
@@ -152,9 +169,11 @@ abstract contract PendleRouterYTBaseUpg is IPMarketSwapCallback {
         if (swapType == YT_SWAP_TYPE.ExactScyForYt) {
             _swapExactScyForYt_callback(msg.sender, data);
         } else if (swapType == YT_SWAP_TYPE.ExactYtForScy) {
-            _swapExactYtForScy_callback(msg.sender, scyToAccount, data);
+            _swapYtForScy_callback(msg.sender, scyToAccount, data);
         } else if (swapType == YT_SWAP_TYPE.SCYForExactYt) {
             _swapScyForExactYt_callback(msg.sender, otToAccount, scyToAccount, data);
+        } else if (swapType == YT_SWAP_TYPE.YtForExactScy) {
+            _swapYtForScy_callback(msg.sender, scyToAccount, data);
         } else {
             require(false, "unknown swapType");
         }
@@ -191,7 +210,7 @@ abstract contract PendleRouterYTBaseUpg is IPMarketSwapCallback {
     /**
     @dev receive OT -> pair with YT to redeem SCY -> payback SCY
     */
-    function _swapExactYtForScy_callback(
+    function _swapYtForScy_callback(
         address market,
         int256 scyToAccount,
         bytes calldata data

package/contracts/interfaces/IPMarket.sol

@@ -2,7 +2,9 @@
 pragma solidity 0.8.9;
 
 import "./IPBaseToken.sol";
-import "../libraries/math/MarketMathLib.sol";
+import "./IPOwnershipToken.sol";
+import "./IPYieldToken.sol";
+import "../libraries/math/MarketMathCore.sol";
 
 interface IPMarket is IPBaseToken {
     function addLiquidity(
@@ -38,7 +40,7 @@ interface IPMarket is IPBaseToken {
         bytes calldata data
     ) external returns (uint256 netScyIn, uint256 netScyToReserve);
 
-    function readState() external view returns (MarketParameters memory market);
+    function readState(bool updateRateOracle) external view returns (MarketState memory market);
 
     function OT() external view returns (address);
 

package/contracts/interfaces/{IPPermissionsV2.sol → IPPermissionsV2Upg.sol}

@@ -23,6 +23,6 @@
 
 pragma solidity 0.8.9;
 
-interface IPermissionsV2 {
+interface IPermissionsV2Upg {
     function governanceManager() external view returns (address);
 }

package/contracts/interfaces/IPRouterCore.sol

@@ -11,9 +11,9 @@ interface IPRouterCore {
     )
         external
         returns (
-            uint256 netLpOut,
-            uint256 scyUsed,
-            uint256 otUsed
+            uint256,
+            uint256,
+            uint256
         );
 
     function removeLiquidity(
@@ -22,39 +22,41 @@ interface IPRouterCore {
         uint256 lpToRemove,
         uint256 scyOutMin,
         uint256 otOutMin
-    ) external returns (uint256 netScyOut, uint256 netOtOut);
+    ) external returns (uint256, uint256);
 
     function swapExactOtForScy(
         address receiver,
         address market,
         uint256 exactOtIn,
         uint256 minScyOut
-    ) external returns (uint256 netScyOut);
+    ) external returns (uint256);
 
     function swapOtForExactScy(
         address receiver,
         address market,
-        uint256 maxOtIn,
         uint256 exactScyOut,
-        uint256 netOtInGuessMin,
-        uint256 netOtInGuessMax
-    ) external returns (uint256 netOtIn);
+        uint256 otInGuessMin,
+        uint256 otInGuessMax,
+        uint256 maxIteration,
+        uint256 eps
+    ) external returns (uint256);
 
     function swapScyForExactOt(
         address receiver,
         address market,
         uint256 exactOtOut,
         uint256 maxScyIn
-    ) external returns (uint256 netScyIn);
+    ) external returns (uint256);
 
     function swapExactScyForOt(
         address receiver,
         address market,
         uint256 exactScyIn,
-        uint256 minOtOut,
-        uint256 netOtOutGuessMin,
-        uint256 netOtOutGuessMax
-    ) external returns (uint256 netOtOut);
+        uint256 otOutguessMin,
+        uint256 otOutguessMax,
+        uint256 maxIteration,
+        uint256 eps
+    ) external returns (uint256);
 
     function mintScyFromRawToken(
         uint256 netRawTokenIn,
@@ -62,7 +64,7 @@ interface IPRouterCore {
         uint256 minScyOut,
         address receiver,
         address[] calldata path
-    ) external returns (uint256 netScyOut);
+    ) external returns (uint256);
 
     function redeemScyToRawToken(
         address SCY,
@@ -70,7 +72,7 @@ interface IPRouterCore {
         uint256 minRawTokenOut,
         address receiver,
         address[] memory path
-    ) external returns (uint256 netRawTokenOut);
+    ) external returns (uint256);
 
     function mintYoFromRawToken(
         uint256 netRawTokenIn,
@@ -78,7 +80,7 @@ interface IPRouterCore {
         uint256 minYoOut,
         address receiver,
         address[] calldata path
-    ) external returns (uint256 netYoOut);
+    ) external returns (uint256);
 
     function redeemYoToRawToken(
         address YT,
@@ -86,16 +88,17 @@ interface IPRouterCore {
         uint256 minRawTokenOut,
         address receiver,
         address[] memory path
-    ) external returns (uint256 netRawTokenOut);
+    ) external returns (uint256);
 
     function swapExactRawTokenForOt(
         uint256 exactRawTokenIn,
         address receiver,
         address[] calldata path,
         address market,
-        uint256 minOtOut,
-        uint256 netOtOutGuessMin,
-        uint256 netOtOutGuessMax
+        uint256 otOutguessMin,
+        uint256 otOutguessMax,
+        uint256 maxIteration,
+        uint256 eps
     ) external returns (uint256 netOtOut);
 
     function swapExactOtForRawToken(

package/contracts/interfaces/IPRouterStatic.sol

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity 0.8.9;
 
-import "../libraries/math/MarketMathLib.sol";
+import "../libraries/math/MarketMathCore.sol";
 
 interface IPRouterStatic {
     function addLiquidityStatic(
@@ -32,4 +32,13 @@ interface IPRouterStatic {
     function scyIndex(address market) external returns (SCYIndex index);
 
     function getOtImpliedYield(address market) external view returns (int256);
+
+    function getPendleTokenType(address token)
+        external
+        view
+        returns (
+            bool isOT,
+            bool isYT,
+            bool isMarket
+        );
 }

package/contracts/interfaces/IPRouterYT.sol

@@ -22,19 +22,31 @@ interface IPRouterYT is IPMarketSwapCallback {
         address receiver,
         address market,
         uint256 exactScyIn,
-        uint256 minYtOut,
         uint256 netYtOutGuessMin,
-        uint256 netYtOutGuessMax
+        uint256 netYtOutGuessMax,
+        uint256 maxIteration,
+        uint256 eps
     ) external returns (uint256 netYtOut);
 
+    function swapYtForExactScy(
+        address receiver,
+        address market,
+        uint256 exactScyOut,
+        uint256 netYtInGuessMin,
+        uint256 netYtInGuessMax,
+        uint256 maxIteration,
+        uint256 eps
+    ) external returns (uint256 netYtIn);
+
     function swapExactRawTokenForYt(
         uint256 exactRawTokenIn,
         address receiver,
         address[] calldata path,
         address market,
-        uint256 minYtOut,
         uint256 netYtOutGuessMin,
-        uint256 netYtOutGuessMax
+        uint256 netYtOutGuessMax,
+        uint256 maxIteration,
+        uint256 eps
     ) external returns (uint256 netYtOut);
 
     function swapExactYtForRawToken(

package/contracts/interfaces/IPYieldContractFactory.sol

@@ -33,4 +33,8 @@ interface IPYieldContractFactory {
     function interestFeeRate() external view returns (uint256);
 
     function treasury() external view returns (address);
+
+    function isOT(address) external view returns (bool);
+
+    function isYT(address) external view returns (bool);
 }

package/contracts/interfaces/IPYieldToken.sol

@@ -7,11 +7,9 @@ interface IPYieldToken is IPBaseToken {
 
     function redeemYO(address receiver) external returns (uint256 amountScyOut);
 
-    function redeemDueInterest(address user) external returns (uint256 interestOut);
-
-    function redeemDueRewards(address user, address receiver)
+    function redeemDueInterestAndRewards(address user)
         external
-        returns (uint256[] memory rewardsOut);
+        returns (uint256 interestOut, uint256[] memory rewardsOut);
 
     function SCY() external view returns (address);
 

package/contracts/libraries/SCYIndex.sol

@@ -2,13 +2,13 @@
 pragma solidity 0.8.9;
 import "../SuperComposableYield/ISuperComposableYield.sol";
 import "../SuperComposableYield/SCYUtils.sol";
-import "./math/FixedPoint.sol";
+import "./math/Math.sol";
 
 type SCYIndex is uint256;
 
 library SCYIndexLib {
-    using FixedPoint for uint256;
-    using FixedPoint for int256;
+    using Math for uint256;
+    using Math for int256;
 
     function newIndex(ISuperComposableYield SCY) internal returns (SCYIndex) {
         return SCYIndex.wrap(SCY.scyIndexCurrent());

package/contracts/libraries/math/LogExpMath.sol

@@ -12,7 +12,7 @@
 // COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
 // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
-pragma solidity 0.8.9;
+pragma solidity ^0.8.0;
 
 /* solhint-disable */
 
@@ -53,8 +53,6 @@ library LogExpMath {
     int256 constant LN_36_LOWER_BOUND = ONE_18 - 1e17;
     int256 constant LN_36_UPPER_BOUND = ONE_18 + 1e17;
 
-    uint256 constant MILD_EXPONENT_BOUND = 2**254 / uint256(ONE_20);
-
     // 18 decimal constants
     int256 constant x0 = 128000000000000000000; // 2ˆ7
     int256 constant a0 = 38877084059945950922200000000000000000000000000000000000; // eˆ(x0) (no decimals)
@@ -83,64 +81,6 @@ library LogExpMath {
     int256 constant x11 = 6250000000000000000; // 2ˆ-4
     int256 constant a11 = 106449445891785942956; // eˆ(x11)
 
-    /**
-     * @dev Exponentiation (x^y) with unsigned 18 decimal fixed point base and exponent.
-     *
-     * Reverts if ln(x) * y is smaller than `MIN_NATURAL_EXPONENT`, or larger than `MAX_NATURAL_EXPONENT`.
-     */
-    function pow(uint256 x, uint256 y) internal pure returns (uint256) {
-        unchecked {
-            if (y == 0) {
-                // We solve the 0^0 indetermination by making it equal one.
-                return uint256(ONE_18);
-            }
-
-            if (x == 0) {
-                return 0;
-            }
-
-            // Instead of computing x^y directly, we instead rely on the properties of logarithms and exponentiation to
-            // arrive at that result. In particular, exp(ln(x)) = x, and ln(x^y) = y * ln(x). This means
-            // x^y = exp(y * ln(x)).
-
-            // The ln function takes a signed value, so we need to make sure x fits in the signed 256 bit range.
-            require(x < 2**255, "X out of bounds");
-            int256 x_int256 = int256(x);
-
-            // We will compute y * ln(x) in a single step. Depending on the value of x, we can either use ln or ln_36. In
-            // both cases, we leave the division by ONE_18 (due to fixed point multiplication) to the end.
-
-            // This prevents y * ln(x) from overflowing, and at the same time guarantees y fits in the signed 256 bit range.
-            require(y < MILD_EXPONENT_BOUND, "Y out of bounds");
-            int256 y_int256 = int256(y);
-
-            int256 logx_times_y;
-            if (LN_36_LOWER_BOUND < x_int256 && x_int256 < LN_36_UPPER_BOUND) {
-                int256 ln_36_x = _ln_36(x_int256);
-
-                // ln_36_x has 36 decimal places, so multiplying by y_int256 isn't as straightforward, since we can't just
-                // bring y_int256 to 36 decimal places, as it might overflow. Instead, we perform two 18 decimal
-                // multiplications and add the results: one with the first 18 decimals of ln_36_x, and one with the
-                // (downscaled) last 18 decimals.
-                logx_times_y = ((ln_36_x / ONE_18) *
-                    y_int256 +
-                    ((ln_36_x % ONE_18) * y_int256) /
-                    ONE_18);
-            } else {
-                logx_times_y = _ln(x_int256) * y_int256;
-            }
-            logx_times_y /= ONE_18;
-
-            // Finally, we compute exp(y * ln(x)) to arrive at x^y
-            require(
-                MIN_NATURAL_EXPONENT <= logx_times_y && logx_times_y <= MAX_NATURAL_EXPONENT,
-                "Product out of bounds"
-            );
-
-            return uint256(exp(logx_times_y));
-        }
-    }
-
     /**
      * @dev Natural exponentiation (e^x) with signed 18 decimal fixed point exponent.
      *
@@ -285,35 +225,6 @@ library LogExpMath {
         }
     }
 
-    /**
-     * @dev Logarithm (log(arg, base), with signed 18 decimal fixed point base and argument.
-     */
-    function log(int256 arg, int256 base) internal pure returns (int256) {
-        unchecked {
-            // This performs a simple base change: log(arg, base) = ln(arg) / ln(base).
-
-            // Both logBase and logArg are computed as 36 decimal fixed point numbers, either by using ln_36, or by
-            // upscaling.
-
-            int256 logBase;
-            if (LN_36_LOWER_BOUND < base && base < LN_36_UPPER_BOUND) {
-                logBase = _ln_36(base);
-            } else {
-                logBase = _ln(base) * ONE_18;
-            }
-
-            int256 logArg;
-            if (LN_36_LOWER_BOUND < arg && arg < LN_36_UPPER_BOUND) {
-                logArg = _ln_36(arg);
-            } else {
-                logArg = _ln(arg) * ONE_18;
-            }
-
-            // When dividing, we multiply by ONE_18 to arrive at a result with 18 decimal places
-            return (logArg * ONE_18) / logBase;
-        }
-    }
-
     /**
      * @dev Natural logarithm (ln(a)) with signed 18 decimal fixed point argument.
      */