@pendle/core-v2 0.8.0-beta-10 → 0.8.0-beta-12

package/contracts/core/YieldContracts/PendleYieldToken.sol

@@ -335,20 +335,21 @@ contract PendleYieldToken is
             // hence, we can save users one _redeemExternal here
             for (uint256 i = 0; i < tokens.length; i++)
                 postExpiry.userRewardOwed[tokens[i]] -= userReward[tokens[i]][user].accrued;
-            rewardAmounts = __doTransferOutRewardsLocal(tokens, user, receiver);
+            rewardAmounts = __doTransferOutRewardsLocal(tokens, user, receiver, false);
         } else {
-            _redeemExternalReward();
-            rewardAmounts = __doTransferOutRewardsLocal(tokens, user, receiver);
+            rewardAmounts = __doTransferOutRewardsLocal(tokens, user, receiver, true);
         }
     }
 
     function __doTransferOutRewardsLocal(
         address[] memory tokens,
         address user,
-        address receiver
+        address receiver,
+        bool allowedToRedeemExternalReward
     ) internal returns (uint256[] memory rewardAmounts) {
         address treasury = IPYieldContractFactory(factory).treasury();
         uint256 feeRate = IPYieldContractFactory(factory).rewardFeeRate();
+        bool redeemExternalThisRound;
 
         rewardAmounts = new uint256[](tokens.length);
         for (uint256 i = 0; i < tokens.length; i++) {
@@ -358,6 +359,13 @@ contract PendleYieldToken is
             uint256 feeAmount = rewardPreFee.mulDown(feeRate);
             rewardAmounts[i] = rewardPreFee - feeAmount;
 
+            if (!redeemExternalThisRound && allowedToRedeemExternalReward) {
+                if (_selfBalance(tokens[i]) < rewardPreFee) {
+                    _redeemExternalReward();
+                    redeemExternalThisRound = true;
+                }
+            }
+
             _transferOut(tokens[i], treasury, feeAmount);
             _transferOut(tokens[i], receiver, rewardAmounts[i]);
         }
@@ -395,7 +403,7 @@ contract PendleYieldToken is
         address to,
         uint256
     ) internal override {
-        _setPostExpiryData();
+        if (isExpired()) _setPostExpiryData();
         _updateAndDistributeRewardsForTwo(from, to);
         _distributeInterestForTwo(from, to);
     }

package/contracts/core/actions/ActionCore.sol

@@ -43,6 +43,37 @@ contract ActionCore is IPActionCore, ActionSCYAndPTBase {
         emit AddLiquidity(msg.sender, market, receiver, scyUsed, ptUsed, netLpOut);
     }
 
+    function addLiquiditySinglePt(
+        address receiver,
+        address market,
+        uint256 netPtIn,
+        uint256 minLpOut,
+        ApproxParams memory guessPtSwapToScy
+    ) external returns (uint256 netLpOut) {
+        require(false, "NOT IMPLEMENTED");
+    }
+
+    function addLiquiditySingleScy(
+        address receiver,
+        address market,
+        uint256 netScyIn,
+        uint256 minLpOut,
+        ApproxParams memory guessPtReceivedFromScy
+    ) external returns (uint256 netLpOut) {
+        require(false, "NOT IMPLEMENTED");
+    }
+
+    function addLiquiditySingleRawToken(
+        address receiver,
+        address market,
+        uint256 netRawTokenIn,
+        uint256 minLpOut,
+        address[] calldata path,
+        ApproxParams memory guessPtReceivedFromScy
+    ) external returns (uint256 netLpOut) {
+        require(false, "NOT IMPLEMENTED");
+    }
+
     /// @dev refer to the internal function
     function removeLiquidity(
         address receiver,
@@ -62,6 +93,35 @@ contract ActionCore is IPActionCore, ActionSCYAndPTBase {
         emit RemoveLiquidity(msg.sender, market, receiver, lpToRemove, netPtOut, netScyOut);
     }
 
+    function removeLiquiditySinglePt(
+        address receiver,
+        address market,
+        uint256 lpToRemove,
+        uint256 minPtOut,
+        ApproxParams memory guessPtOut
+    ) external returns (uint256 netPtOut) {
+        require(false, "NOT IMPLEMENTED");
+    }
+
+    function removeLiquiditySingleScy(
+        address receiver,
+        address market,
+        uint256 lpToRemove,
+        uint256 minScyOut
+    ) external returns (uint256 netScyOut) {
+        require(false, "NOT IMPLEMENTED");
+    }
+
+    function removeLiquiditySingleRawToken(
+        address receiver,
+        address market,
+        uint256 lpToRemove,
+        uint256 minRawTokenOut,
+        address[] memory path
+    ) external returns (uint256 netRawTokenOut) {
+        require(false, "NOT IMPLEMENTED");
+    }
+
     /// @dev refer to the internal function
     function swapExactPtForScy(
         address receiver,
@@ -169,6 +229,26 @@ contract ActionCore is IPActionCore, ActionSCYAndPTBase {
         );
     }
 
+    function mintPyFromScy(
+        address receiver,
+        address YT,
+        uint256 netScyIn,
+        uint256 minPyOut
+    ) external returns (uint256 netPyOut) {
+        netPyOut = _mintPyFromScy(receiver, YT, netScyIn, minPyOut, true);
+        emit MintPyFromScy(msg.sender, receiver, YT, netScyIn, netPyOut);
+    }
+
+    function redeemPyToScy(
+        address receiver,
+        address YT,
+        uint256 netPyIn,
+        uint256 minScyOut
+    ) external returns (uint256 netScyOut) {
+        netScyOut = _redeemPyToScy(receiver, YT, netPyIn, minScyOut, true);
+        emit RedeemPyToScy(msg.sender, receiver, YT, netPyIn, netScyOut);
+    }
+
     /// @dev refer to the internal function
     function swapExactRawTokenForPt(
         address receiver,

package/contracts/core/actions/base/ActionSCYAndPYBase.sol

@@ -129,4 +129,40 @@ abstract contract ActionSCYAndPYBase is PendleJoeSwapHelperUpg, TokenHelper {
 
         netRawTokenOut = _redeemScyToRawToken(receiver, SCY, 0, minRawTokenOut, path, false);
     }
+
+    function _mintPyFromScy(
+        address receiver,
+        address YT,
+        uint256 netScyIn,
+        uint256 minPyOut,
+        bool doPull
+    ) internal returns (uint256 netPyOut) {
+        address SCY = IPYieldToken(YT).SCY();
+
+        if (doPull) {
+            IERC20(SCY).safeTransferFrom(msg.sender, YT, netScyIn);
+        }
+
+        netPyOut = IPYieldToken(YT).mintPY(receiver, receiver);
+        require(netPyOut >= minPyOut, "insufficient PY out");
+    }
+
+    function _redeemPyToScy(
+        address receiver,
+        address YT,
+        uint256 netPyIn,
+        uint256 minScyOut,
+        bool doPull
+    ) internal returns (uint256 netScyOut) {
+        address PT = IPYieldToken(YT).PT();
+
+        if (doPull) {
+            bool needToBurnYt = (!IPYieldToken(YT).isExpired());
+            IERC20(PT).safeTransferFrom(msg.sender, YT, netPyIn);
+            if (needToBurnYt) IERC20(YT).safeTransferFrom(msg.sender, YT, netPyIn);
+        }
+
+        netScyOut = IPYieldToken(YT).redeemPY(receiver);
+        require(netScyOut >= minScyOut, "insufficient SCY out");
+    }
 }

package/contracts/interfaces/IPActionCore.sol

@@ -57,6 +57,22 @@ interface IPActionCore {
         uint256 netRawTokenOut
     );
 
+    event MintPyFromScy(
+        address indexed caller,
+        address indexed receiver,
+        address indexed YT,
+        uint256 netScyIn,
+        uint256 netPyOut
+    );
+
+    event RedeemPyToScy(
+        address indexed caller,
+        address indexed receiver,
+        address indexed YT,
+        uint256 netPyIn,
+        uint256 netScyOut
+    );
+
     event MintPyFromRawToken(
         address indexed caller,
         address indexed receiver,
@@ -89,6 +105,31 @@ interface IPActionCore {
             uint256 ptUsed
         );
 
+    function addLiquiditySinglePt(
+        address receiver,
+        address market,
+        uint256 netPtIn,
+        uint256 minLpOut,
+        ApproxParams memory guessPtSwapToScy
+    ) external returns (uint256 netLpOut);
+
+    function addLiquiditySingleScy(
+        address receiver,
+        address market,
+        uint256 netScyIn,
+        uint256 minLpOut,
+        ApproxParams memory guessPtReceivedFromScy
+    ) external returns (uint256 netLpOut);
+
+    function addLiquiditySingleRawToken(
+        address receiver,
+        address market,
+        uint256 netRawTokenIn,
+        uint256 minLpOut,
+        address[] calldata path,
+        ApproxParams memory guessPtReceivedFromScy
+    ) external returns (uint256 netLpOut);
+
     function removeLiquidity(
         address receiver,
         address market,
@@ -97,6 +138,29 @@ interface IPActionCore {
         uint256 ptOutMin
     ) external returns (uint256 netScyOut, uint256 netPtOut);
 
+    function removeLiquiditySinglePt(
+        address receiver,
+        address market,
+        uint256 lpToRemove,
+        uint256 minPtOut,
+        ApproxParams memory guessPtOut
+    ) external returns (uint256 netPtOut);
+
+    function removeLiquiditySingleScy(
+        address receiver,
+        address market,
+        uint256 lpToRemove,
+        uint256 minScyOut
+    ) external returns (uint256 netScyOut);
+
+    function removeLiquiditySingleRawToken(
+        address receiver,
+        address market,
+        uint256 lpToRemove,
+        uint256 minRawTokenOut,
+        address[] memory path
+    ) external returns (uint256 netRawTokenOut);
+
     function swapExactPtForScy(
         address receiver,
         address market,
@@ -159,6 +223,20 @@ interface IPActionCore {
         address[] memory path
     ) external returns (uint256 netRawTokenOut);
 
+    function mintPyFromScy(
+        address receiver,
+        address YT,
+        uint256 netScyIn,
+        uint256 minPyOut
+    ) external returns (uint256 netPyOut);
+
+    function redeemPyToScy(
+        address receiver,
+        address YT,
+        uint256 netPyIn,
+        uint256 minScyOut
+    ) external returns (uint256 netScyOut);
+
     function swapExactRawTokenForPt(
         address receiver,
         address market,

package/contracts/interfaces/IPRouterStatic.sol

@@ -64,7 +64,8 @@ interface IPRouterStatic {
             address pt,
             address scy,
             MarketState memory state,
-            int256 impliedYield
+            int256 impliedYield,
+            uint256 exchangeRate
         );
 
     // ============= USER INFO =============

package/contracts/offchain-helpers/RouterStatic.sol

@@ -83,7 +83,8 @@ contract RouterStatic is IPRouterStatic {
             address pt,
             address scy,
             MarketState memory state,
-            int256 impliedYield
+            int256 impliedYield,
+            uint256 exchangeRate
         )
     {
         IPMarket _market = IPMarket(market);
@@ -93,6 +94,7 @@ contract RouterStatic is IPRouterStatic {
         scy = address(SCY);
         state = _market.readState(true);
         impliedYield = getPtImpliedYield(market);
+        exchangeRate = getExchangeRate(market);
     }
 
     // ============= USER INFO =============
@@ -159,6 +161,28 @@ contract RouterStatic is IPRouterStatic {
         );
     }
 
+    function addLiquiditySinglePtStatic(address market, uint256 netPtIn)
+        external
+        returns (uint256 netLpOut)
+    {
+        require(false, "NOT IMPLEMENTED");
+    }
+
+    function addLiquiditySingleScy(address market, uint256 netScyIn)
+        external
+        returns (uint256 netLpOut)
+    {
+        require(false, "NOT IMPLEMENTED");
+    }
+
+    function addLiquiditySingleBaseToken(
+        address market,
+        address baseToken,
+        uint256 netBaseTokenIn
+    ) external returns (uint256 netLpOut) {
+        require(false, "NOT IMPLEMENTED");
+    }
+
     function removeLiquidityStatic(address market, uint256 lpToRemove)
         external
         view
@@ -168,6 +192,28 @@ contract RouterStatic is IPRouterStatic {
         (netScyOut, netPtOut) = state.removeLiquidity(lpToRemove);
     }
 
+    function removeLiquiditySinglePtStatic(address market, uint256 lpToRemove)
+        external
+        returns (uint256 netPtOut)
+    {
+        require(false, "NOT IMPLEMENTED");
+    }
+
+    function removeLiquiditySingleScy(address market, uint256 lpToRemove)
+        external
+        returns (uint256 netScyOut)
+    {
+        require(false, "NOT IMPLEMENTED");
+    }
+
+    function removeLiquiditySingleBaseToken(
+        address market,
+        uint256 lpToRemove,
+        address baseToken
+    ) external returns (uint256 netBaseTokenOut) {
+        require(false, "NOT IMPLEMENTED");
+    }
+
     function swapExactPtForScyStatic(address market, uint256 exactPtIn)
         public
         view

package/deployments/43113-core.json

@@ -8,7 +8,7 @@
     "yieldContractFactory": "0x2B233F133f3DA67698453F4A251BAF8BAc1E584d",
     "marketFactory": "0xE3a730f28EAe40309A9868Fb5b66B5BaaF531204",
     "router": "0xFEdBED4682D136925d30FFb9B8977CC9b3a6c406",
-    "routerStatic": "0x258711b4Ab5b5fA49ac2883B649b10D9818B8435",
+    "routerStatic": "0x1436Cb03C753bB9fAc7fcfE5627d08F143D6d8ed",
     "startTime": 1657756800,
     "vePendle": "0xD05B49500F35d879F3Bf220c81BE3ff9d73Ca205",
     "votingController": "0x449f676be160C5C682E1E64934f29641D6096116",

package/deployments/80001-core.json

@@ -8,7 +8,7 @@
     "yieldContractFactory": "0xa8E22cc2E74dACb43E73cFa89172bfa30eFA0A56",
     "marketFactory": "0x5539C4BCcff8d5881eCb1B95D2f6E7Eb47f0f801",
     "router": "0x24d7CEaFBA7c7b32BE200aD6dA38C03797F0611f",
-    "routerStatic": "0x62c42ec5ebD0f587C61A078a656A4235582131Fd",
+    "routerStatic": "0xf68aD0dF5E6034A934bE0e3E8b23Ab77f9778315",
     "startTime": 1657756800,
     "vePendle": "0x35d294d0922838b0899Cbf4C35f4945B2b3D20f1",
     "gaugeController": "0x36e65521b2a1AEBA9a009226e75125cEcf00702f"

package/package.json

@@ -2,7 +2,7 @@
   "name": "@pendle/core-v2",
   "description": "Core smart contracts of Pendle Protocol.",
   "license": "BUSL-1.1",
-  "version": "0.8.0-beta-10",
+  "version": "0.8.0-beta-12",
   "homepage": "https://pendle.finance",
   "keywords": [
     "pendle",