@pendle/core-v2 0.2.3 → 0.3.0

package/contracts/core/router/PendleRouterCoreUpg.sol

@@ -6,15 +6,17 @@ import "./base/PendleRouterOTBaseUpg.sol";
 import "../../interfaces/IPOwnershipToken.sol";
 import "../../interfaces/IPYieldToken.sol";
 import "../../interfaces/IPRouterCore.sol";
+import "../../libraries/math/MarketMathAux.sol";
 
 contract PendleRouterCoreUpg is
     IPRouterCore,
     PendleRouterSCYAndForgeBaseUpg,
     PendleRouterOTBaseUpg
 {
-    using MarketMathLib for MarketParameters;
-    using FixedPoint for uint256;
-    using FixedPoint for int256;
+    using MarketMathCore for MarketState;
+    using MarketMathAux for MarketState;
+    using Math for uint256;
+    using Math for int256;
 
     /// @dev since this contract will be proxied, it must not contains non-immutable variabless
     constructor(
@@ -72,19 +74,23 @@ contract PendleRouterCoreUpg is
     function swapOtForExactScy(
         address receiver,
         address market,
-        uint256 maxOtIn,
         uint256 exactScyOut,
-        uint256 netOtInGuessMin,
-        uint256 netOtInGuessMax
+        uint256 otInGuessMin,
+        uint256 otInGuessMax,
+        uint256 maxIteration,
+        uint256 eps
     ) external returns (uint256) {
         return
             _swapOtForExactScy(
                 receiver,
                 market,
-                maxOtIn,
                 exactScyOut,
-                netOtInGuessMin,
-                netOtInGuessMax,
+                ApproxParams({
+                    guessMin: otInGuessMin,
+                    guessMax: otInGuessMax,
+                    eps: eps,
+                    maxIteration: maxIteration
+                }),
                 true
             );
     }
@@ -104,18 +110,22 @@ contract PendleRouterCoreUpg is
         address receiver,
         address market,
         uint256 exactScyIn,
-        uint256 minOtOut,
-        uint256 netOtOutGuessMin,
-        uint256 netOtOutGuessMax
+        uint256 otOutguessMin,
+        uint256 otOutguessMax,
+        uint256 maxIteration,
+        uint256 eps
     ) external returns (uint256) {
         return
             _swapExactScyForOt(
                 receiver,
                 market,
                 exactScyIn,
-                minOtOut,
-                netOtOutGuessMin,
-                netOtOutGuessMax,
+                ApproxParams({
+                    guessMin: otOutguessMin,
+                    guessMax: otOutguessMax,
+                    eps: eps,
+                    maxIteration: maxIteration
+                }),
                 true
             );
     }
@@ -177,9 +187,10 @@ contract PendleRouterCoreUpg is
         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) {
         address SCY = IPMarket(market).SCY();
         uint256 netScyUseToBuyOt = _mintScyFromRawToken(
@@ -194,9 +205,12 @@ contract PendleRouterCoreUpg is
             receiver,
             market,
             netScyUseToBuyOt,
-            minOtOut,
-            netOtOutGuessMin,
-            netOtOutGuessMax,
+            ApproxParams({
+                guessMin: otOutguessMin,
+                guessMax: otOutguessMax,
+                eps: eps,
+                maxIteration: maxIteration
+            }),
             false
         );
     }

package/contracts/core/router/PendleRouterProxy.sol

@@ -3,21 +3,26 @@ pragma solidity 0.8.9;
 
 import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
 import "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol";
-import "../misc/BoringOwnableUpg.sol";
 import "@openzeppelin/contracts/proxy/Proxy.sol";
 import "../../interfaces/IPRouterCore.sol";
 import "../../interfaces/IPRouterYT.sol";
 import "../../interfaces/IPRouterStatic.sol";
+import "../../periphery/PermissionsV2Upg.sol";
 
 /// @dev this contract will be deployed behind an ERC1967 proxy
 /// calls to the ERC1967 proxy will be resolved at this contract, and proxied again to the
 /// corresponding implementation contracts
-contract PendleRouterProxy is Proxy, Initializable, UUPSUpgradeable, BoringOwnableUpg {
+contract PendleRouterProxy is Proxy, Initializable, UUPSUpgradeable, PermissionsV2Upg {
     address public immutable PENDLE_ROUTER_CORE;
     address public immutable PENDLE_ROUTER_YT;
     address public immutable PENDLE_ROUTER_STATIC;
 
-    constructor(address _PENDLE_ROUTER_CORE, address _PENDLE_ROUTER_YT, address _PENDLE_ROUTER_STATIC) {
+    constructor(
+        address _PENDLE_ROUTER_CORE,
+        address _PENDLE_ROUTER_YT,
+        address _PENDLE_ROUTER_STATIC,
+        address _governanceManager
+    ) PermissionsV2Upg(_governanceManager) initializer {
         PENDLE_ROUTER_CORE = _PENDLE_ROUTER_CORE;
         PENDLE_ROUTER_YT = _PENDLE_ROUTER_YT;
         PENDLE_ROUTER_STATIC = _PENDLE_ROUTER_STATIC;
@@ -25,7 +30,7 @@ contract PendleRouterProxy is Proxy, Initializable, UUPSUpgradeable, BoringOwnab
 
     function initialize() external initializer {
         __UUPSUpgradeable_init();
-        __BoringOwnable_init();
+        // no need to initialize PermissionsV2Upg
     }
 
     function getRouterImplementation(bytes4 sig) public view returns (address) {
@@ -63,7 +68,8 @@ contract PendleRouterProxy is Proxy, Initializable, UUPSUpgradeable, BoringOwnab
             sig == IPRouterStatic.swapOtForScyStatic.selector ||
             sig == IPRouterStatic.swapScyForOtStatic.selector ||
             sig == IPRouterStatic.scyIndex.selector ||
-            sig == IPRouterStatic.getOtImpliedYield.selector
+            sig == IPRouterStatic.getOtImpliedYield.selector ||
+            sig == IPRouterStatic.getPendleTokenType.selector
         ) {
             return PENDLE_ROUTER_STATIC;
         }
@@ -74,5 +80,5 @@ contract PendleRouterProxy is Proxy, Initializable, UUPSUpgradeable, BoringOwnab
         return getRouterImplementation(msg.sig);
     }
 
-    function _authorizeUpgrade(address newImplementation) internal override onlyOwner {}
+    function _authorizeUpgrade(address newImplementation) internal override onlyGovernance {}
 }

package/contracts/core/router/PendleRouterStaticUpg.sol

@@ -2,19 +2,27 @@
 pragma solidity 0.8.9;
 
 import "../../interfaces/IPRouterStatic.sol";
+import "../../interfaces/IPMarket.sol";
+import "../../interfaces/IPYieldContractFactory.sol";
+import "../../interfaces/IPMarketFactory.sol";
+import "../../libraries/math/MarketMathAux.sol";
+import "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol";
+import "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
 
 contract PendleRouterStaticUpg is IPRouterStatic {
-    using MarketMathLib for MarketParameters;
-    using FixedPoint for uint256;
-    using FixedPoint for int256;
+    using MarketMathCore for MarketState;
+    using MarketMathAux for MarketState;
+    using Math for uint256;
+    using Math for int256;
     using LogExpMath for int256;
 
-    /// @dev since this contract will be proxied, it must not contains non-immutable variabless
-    constructor(
-        address _joeRouter,
-        address _joeFactory,
-        address _marketFactory //solhint-disable-next-line no-empty-blocks
-    ) {}
+    IPYieldContractFactory public immutable yieldContractFactory;
+    IPMarketFactory public immutable marketFactory;
+
+    constructor(IPYieldContractFactory _yieldContractFactory, IPMarketFactory _marketFactory) {
+        yieldContractFactory = _yieldContractFactory;
+        marketFactory = _marketFactory;
+    }
 
     function addLiquidityStatic(
         address market,
@@ -28,11 +36,12 @@ contract PendleRouterStaticUpg is IPRouterStatic {
             uint256 otUsed
         )
     {
-        MarketParameters memory state = IPMarket(market).readState();
+        MarketState memory state = IPMarket(market).readState(false);
         (, netLpOut, scyUsed, otUsed) = state.addLiquidity(
             scyIndex(market),
             scyDesired,
-            otDesired
+            otDesired,
+            false
         );
     }
 
@@ -41,19 +50,20 @@ contract PendleRouterStaticUpg is IPRouterStatic {
         view
         returns (uint256 netScyOut, uint256 netOtOut)
     {
-        MarketParameters memory state = IPMarket(market).readState();
-        (netScyOut, netOtOut) = state.removeLiquidity(lpToRemove);
+        MarketState memory state = IPMarket(market).readState(false);
+        (netScyOut, netOtOut) = state.removeLiquidity(lpToRemove, false);
     }
 
     function swapOtForScyStatic(address market, uint256 exactOtIn)
         external
         returns (uint256 netScyOut, uint256 netScyFee)
     {
-        MarketParameters memory state = IPMarket(market).readState();
+        MarketState memory state = IPMarket(market).readState(false);
         (netScyOut, netScyFee) = state.swapExactOtForScy(
             scyIndex(market),
             exactOtIn,
-            block.timestamp
+            block.timestamp,
+            false
         );
     }
 
@@ -61,11 +71,12 @@ contract PendleRouterStaticUpg is IPRouterStatic {
         external
         returns (uint256 netScyIn, uint256 netScyFee)
     {
-        MarketParameters memory state = IPMarket(market).readState();
+        MarketState memory state = IPMarket(market).readState(false);
         (netScyIn, netScyFee) = state.swapScyForExactOt(
             scyIndex(market),
             exactOtOut,
-            block.timestamp
+            block.timestamp,
+            false
         );
     }
 
@@ -74,9 +85,23 @@ contract PendleRouterStaticUpg is IPRouterStatic {
     }
 
     function getOtImpliedYield(address market) external view returns (int256) {
-        MarketParameters memory state = IPMarket(market).readState();
+        MarketState memory state = IPMarket(market).readState(false);
 
         int256 lnImpliedRate = (state.lastImpliedRate).Int();
         return lnImpliedRate.exp();
     }
+
+    function getPendleTokenType(address token)
+        external
+        view
+        returns (
+            bool isOT,
+            bool isYT,
+            bool isMarket
+        )
+    {
+        if (yieldContractFactory.isOT(token)) isOT = true;
+        else if (yieldContractFactory.isYT(token)) isYT = true;
+        else if (marketFactory.isValidMarket(token)) isMarket = true;
+    }
 }

package/contracts/core/router/PendleRouterYTUpg.sol

@@ -6,11 +6,13 @@ import "./base/PendleRouterYTBaseUpg.sol";
 import "../../interfaces/IPOwnershipToken.sol";
 import "../../interfaces/IPYieldToken.sol";
 import "../../interfaces/IPRouterYT.sol";
+import "../../libraries/math/MarketMathAux.sol";
 
 contract PendleRouterYTUpg is IPRouterYT, PendleRouterSCYAndForgeBaseUpg, PendleRouterYTBaseUpg {
-    using MarketMathLib for MarketParameters;
-    using FixedPoint for uint256;
-    using FixedPoint for int256;
+    using MarketMathCore for MarketState;
+    using MarketMathAux for MarketState;
+    using Math for uint256;
+    using Math for int256;
 
     /// @dev since this contract will be proxied, it must not contains non-immutable variables
     constructor(
@@ -47,18 +49,46 @@ contract PendleRouterYTUpg is IPRouterYT, PendleRouterSCYAndForgeBaseUpg, Pendle
         address receiver,
         address market,
         uint256 exactScyIn,
-        uint256 minYtOut,
         uint256 netYtOutGuessMin,
-        uint256 netYtOutGuessMax
+        uint256 netYtOutGuessMax,
+        uint256 maxIteration,
+        uint256 eps
     ) external returns (uint256) {
         return
             _swapExactScyForYt(
                 receiver,
                 market,
                 exactScyIn,
-                minYtOut,
-                netYtOutGuessMin,
-                netYtOutGuessMax,
+                ApproxParams({
+                    guessMin: netYtOutGuessMin,
+                    guessMax: netYtOutGuessMax,
+                    eps: eps,
+                    maxIteration: maxIteration
+                }),
+                true
+            );
+    }
+
+    function swapYtForExactScy(
+        address receiver,
+        address market,
+        uint256 exactScyOut,
+        uint256 netYtInGuessMin,
+        uint256 netYtInGuessMax,
+        uint256 maxIteration,
+        uint256 eps
+    ) external returns (uint256 netYtIn) {
+        return
+            _swapYtForExactScy(
+                receiver,
+                market,
+                exactScyOut,
+                ApproxParams({
+                    guessMin: netYtInGuessMin,
+                    guessMax: netYtInGuessMax,
+                    eps: eps,
+                    maxIteration: maxIteration
+                }),
                 true
             );
     }
@@ -76,9 +106,10 @@ contract PendleRouterYTUpg is IPRouterYT, PendleRouterSCYAndForgeBaseUpg, Pendle
         address receiver,
         address[] calldata path,
         address market,
-        uint256 minYtOut,
         uint256 netYtOutGuessMin,
-        uint256 netYtOutGuessMax
+        uint256 netYtOutGuessMax,
+        uint256 maxIteration,
+        uint256 eps
     ) external returns (uint256 netYtOut) {
         (ISuperComposableYield SCY, , IPYieldToken YT) = IPMarket(market).readTokens();
 
@@ -95,9 +126,12 @@ contract PendleRouterYTUpg is IPRouterYT, PendleRouterSCYAndForgeBaseUpg, Pendle
             receiver,
             market,
             netScyUsedToBuyYT,
-            minYtOut,
-            netYtOutGuessMin,
-            netYtOutGuessMax,
+            ApproxParams({
+                guessMin: netYtOutGuessMin,
+                guessMax: netYtOutGuessMax,
+                eps: eps,
+                maxIteration: maxIteration
+            }),
             false
         );
     }

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

@@ -6,13 +6,15 @@ import "../../../interfaces/IPMarket.sol";
 import "../../../interfaces/IPMarketAddRemoveCallback.sol";
 import "../../../interfaces/IPMarketSwapCallback.sol";
 import "../../../libraries/math/MarketApproxLib.sol";
+import "../../../libraries/math/MarketMathAux.sol";
 import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
 
 abstract contract PendleRouterOTBaseUpg {
-    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 IERC20;
 
     /// @dev since this contract will be proxied, it must not contains non-immutable variables
@@ -46,11 +48,12 @@ abstract contract PendleRouterOTBaseUpg {
     {
         (ISuperComposableYield SCY, IPOwnershipToken OT, ) = IPMarket(market).readTokens();
 
-        MarketParameters memory state = IPMarket(market).readState();
+        MarketState memory state = IPMarket(market).readState(false);
         (, netLpOut, scyUsed, otUsed) = state.addLiquidity(
             SCYIndexLib.newIndex(SCY),
             scyDesired,
-            otDesired
+            otDesired,
+            false
         );
 
         require(netLpOut >= minLpOut, "insufficient lp out");
@@ -79,9 +82,9 @@ abstract contract PendleRouterOTBaseUpg {
         uint256 otOutMin,
         bool doPull
     ) internal returns (uint256 netScyOut, uint256 netOtOut) {
-        MarketParameters memory state = IPMarket(market).readState();
+        MarketState memory state = IPMarket(market).readState(false);
 
-        (netScyOut, netOtOut) = state.removeLiquidity(lpToRemove);
+        (netScyOut, netOtOut) = state.removeLiquidity(lpToRemove, false);
         require(netScyOut >= scyOutMin, "insufficient scy out");
         require(netOtOut >= otOutMin, "insufficient ot out");
 
@@ -125,25 +128,20 @@ abstract contract PendleRouterOTBaseUpg {
     function _swapOtForExactScy(
         address receiver,
         address market,
-        uint256 maxOtIn,
         uint256 exactScyOut,
-        uint256 netOtInGuessMin,
-        uint256 netOtInGuessMax,
+        ApproxParams memory approx,
         bool doPull
     ) internal returns (uint256 netOtIn) {
-        MarketParameters memory state = IPMarket(market).readState();
+        MarketState memory state = IPMarket(market).readState(false);
         (ISuperComposableYield SCY, IPOwnershipToken OT, ) = IPMarket(market).readTokens();
 
-        netOtIn = state.approxSwapOtForExactScy(
+        (netOtIn, ) = state.approxSwapOtForExactScy(
             SCYIndexLib.newIndex(SCY),
             exactScyOut,
             block.timestamp,
-            netOtInGuessMin,
-            netOtInGuessMax
+            approx
         );
 
-        require(netOtIn <= maxOtIn, "ot in exceed limit");
-
         if (doPull) {
             IERC20(OT).safeTransferFrom(msg.sender, market, netOtIn);
         }
@@ -166,13 +164,14 @@ abstract contract PendleRouterOTBaseUpg {
         uint256 maxScyIn,
         bool doPull
     ) internal returns (uint256 netScyIn) {
-        MarketParameters memory state = IPMarket(market).readState();
+        MarketState memory state = IPMarket(market).readState(false);
         address SCY = IPMarket(market).SCY();
 
         (netScyIn, ) = state.swapScyForExactOt(
             SCYIndexLib.newIndex(SCY),
             exactOtOut,
-            block.timestamp
+            block.timestamp,
+            false
         );
         require(netScyIn <= maxScyIn, "exceed limit scy in");
 
@@ -187,28 +186,19 @@ abstract contract PendleRouterOTBaseUpg {
         address receiver,
         address market,
         uint256 exactScyIn,
-        uint256 minOtOut,
-        uint256 netOtOutGuessMin,
-        uint256 netOtOutGuessMax,
+        ApproxParams memory approx,
         bool doPull
     ) internal returns (uint256 netOtOut) {
-        MarketParameters memory state = IPMarket(market).readState();
+        MarketState memory state = IPMarket(market).readState(false);
         address SCY = IPMarket(market).SCY();
 
-        if (netOtOutGuessMax == type(uint256).max) {
-            netOtOutGuessMax = state.totalOt.Uint();
-        }
-
-        netOtOut = state.approxSwapExactScyForOt(
+        (netOtOut, ) = state.approxSwapExactScyForOt(
             SCYIndexLib.newIndex(SCY),
             exactScyIn,
             block.timestamp,
-            netOtOutGuessMin,
-            netOtOutGuessMax
+            approx
         );
 
-        require(netOtOut >= minOtOut, "insufficient out");
-
         if (doPull) {
             IERC20(SCY).safeTransferFrom(msg.sender, market, exactScyIn);
         }

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

@@ -2,7 +2,7 @@
 pragma solidity 0.8.9;
 
 import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
-import "../../misc/PendleJoeSwapHelperUpg.sol";
+import "../../../periphery/PendleJoeSwapHelperUpg.sol";
 import "../../../SuperComposableYield/ISuperComposableYield.sol";
 import "../../../interfaces/IPYieldToken.sol";