@pendle/core-v2 0.5.1-beta-5 → 0.6.0

package/contracts/core/actions/ActionCallback.sol

@@ -8,7 +8,7 @@ import "../../interfaces/IPMarketSwapCallback.sol";
 import "../../SuperComposableYield/SCYUtils.sol";
 import "../../libraries/math/MarketApproxLib.sol";
 import "../../libraries/math/MarketMathAux.sol";
-import "./base/ActionSCYAndYOBase.sol";
+import "./base/ActionSCYAndPYBase.sol";
 import "./base/ActionType.sol";
 import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
 
@@ -26,62 +26,80 @@ contract ActionCallback is IPMarketSwapCallback, ActionType {
 
     /// @dev since this contract will be proxied, it must not contains non-immutable variables
     constructor(address _marketFactory) {
+        require(_marketFactory != address(0), "zero address");
         marketFactory = _marketFactory;
     }
 
+    /**
+     * @dev The callback is only callable by a Pendle Market created by the factory
+     */
     function swapCallback(
-        int256 otToAccount,
+        int256 ptToAccount,
         int256 scyToAccount,
         bytes calldata data
     ) external override onlyPendleMarket(msg.sender) {
-        (ACTION_TYPE swapType, ) = abi.decode(data, (ACTION_TYPE, bytes));
-
+        (ACTION_TYPE swapType, ) = abi.decode(data, (ACTION_TYPE, address));
         if (swapType == ACTION_TYPE.SwapExactScyForYt) {
-            _swapExactScyForYt_callback(msg.sender, data);
+            _swapExactScyForYt_callback(msg.sender, ptToAccount, scyToAccount, data);
         } else if (swapType == ACTION_TYPE.SwapSCYForExactYt) {
-            _swapScyForExactYt_callback(msg.sender, otToAccount, scyToAccount, data);
+            _swapScyForExactYt_callback(msg.sender, ptToAccount, scyToAccount, data);
         } else if (
             swapType == ACTION_TYPE.SwapYtForExactScy || swapType == ACTION_TYPE.SwapExactYtForScy
         ) {
-            _swapYtForScy_callback(msg.sender, scyToAccount, data);
+            _swapYtForScy_callback(msg.sender, ptToAccount, scyToAccount, data);
         } else {
             require(false, "unknown swapType");
         }
     }
 
-    function _swapExactScyForYt_callback(address market, bytes calldata data) internal {
+    function _swapExactScyForYt_callback(
+        address market,
+        int256 ptToAccount,
+        int256, /*scyToAccount*/
+        bytes calldata data
+    ) internal {
         (, , IPYieldToken YT) = IPMarket(market).readTokens();
         (, address receiver) = abi.decode(data, (ACTION_TYPE, address));
 
-        YT.mintYO(market, receiver);
+        uint256 ptOwed = ptToAccount.abs();
+        uint256 amountPYout = YT.mintPY(market, receiver);
+
+        require(amountPYout >= ptOwed, "insufficient pt to pay");
     }
 
     function _swapScyForExactYt_callback(
         address market,
-        int256 otToAccount,
+        int256 ptToAccount,
         int256 scyToAccount,
         bytes calldata data
     ) internal {
         (, address payer, address receiver) = abi.decode(data, (ACTION_TYPE, address, address));
         (ISuperComposableYield SCY, , IPYieldToken YT) = IPMarket(market).readTokens();
 
-        uint256 otOwed = otToAccount.neg().Uint();
+        uint256 ptOwed = ptToAccount.neg().Uint();
         uint256 scyReceived = scyToAccount.Uint();
 
-        // otOwed = totalAsset
-        uint256 scyNeedTotal = SCYUtils.assetToScy(SCY.scyIndexCurrent(), otOwed);
+        // ptOwed = totalAsset
+        uint256 scyIndex = SCY.scyIndexCurrent();
+        uint256 scyNeedTotal = SCYUtils.assetToScy(scyIndex, ptOwed);
+        scyNeedTotal += scyIndex.rawDivUp(SCYUtils.ONE);
+
+        {
+            uint256 netScyToPull = scyNeedTotal.subMax0(scyReceived);
+            SCY.safeTransferFrom(payer, address(YT), netScyToPull);
+        }
 
-        uint256 netScyToPull = scyNeedTotal.subMax0(scyReceived);
-        SCY.safeTransferFrom(payer, address(YT), netScyToPull);
+        uint256 amountPYout = YT.mintPY(market, receiver);
 
-        YT.mintYO(market, receiver);
+        require(amountPYout >= ptOwed, "insufficient pt to pay");
     }
 
     /**
-    @dev receive OT -> pair with YT to redeem SCY -> payback SCY
+    @dev receive PT -> pair with YT to redeem SCY -> payback SCY
     */
     function _swapYtForScy_callback(
         address market,
+        int256, /*ptToAccount*/
         int256 scyToAccount,
         bytes calldata data
     ) internal {
@@ -90,7 +108,7 @@ contract ActionCallback is IPMarketSwapCallback, ActionType {
 
         uint256 scyOwed = scyToAccount.neg().Uint();
 
-        uint256 netScyReceived = YT.redeemYO(address(this));
+        uint256 netScyReceived = YT.redeemPY(address(this));
 
         SCY.safeTransfer(market, scyOwed);
 

package/contracts/core/actions/ActionCore.sol

@@ -1,14 +1,14 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity 0.8.9;
 
-import "./base/ActionSCYAndOTBase.sol";
-import "./base/ActionSCYAndYOBase.sol";
-import "../../interfaces/IPOwnershipToken.sol";
+import "./base/ActionSCYAndPTBase.sol";
+import "./base/ActionSCYAndPYBase.sol";
+import "../../interfaces/IPPrincipalToken.sol";
 import "../../interfaces/IPYieldToken.sol";
 import "../../interfaces/IPActionCore.sol";
 import "../../libraries/math/MarketMathAux.sol";
 
-contract ActionCore is IPActionCore, ActionSCYAndOTBase, ActionSCYAndYOBase {
+contract ActionCore is IPActionCore, ActionSCYAndPTBase, ActionSCYAndPYBase {
     using MarketMathCore for MarketState;
     using MarketMathAux for MarketState;
     using Math for uint256;
@@ -20,19 +20,15 @@ contract ActionCore is IPActionCore, ActionSCYAndOTBase, ActionSCYAndYOBase {
         address _joeFactory,
         address _marketFactory
     )
-        ActionSCYAndYOBase(_joeRouter, _joeFactory)
-        ActionSCYAndOTBase()
-    //solhint-disable-next-line no-empty-blocks
-    {
-
-    }
+        ActionSCYAndPYBase(_joeRouter, _joeFactory) //solhint-disable-next-line no-empty-blocks
+    {}
 
     /// @dev docs can be found in the internal function
     function addLiquidity(
         address receiver,
         address market,
         uint256 scyDesired,
-        uint256 otDesired,
+        uint256 ptDesired,
         uint256 minLpOut
     )
         external
@@ -42,7 +38,7 @@ contract ActionCore is IPActionCore, ActionSCYAndOTBase, ActionSCYAndYOBase {
             uint256
         )
     {
-        return _addLiquidity(receiver, market, scyDesired, otDesired, minLpOut, true);
+        return _addLiquidity(receiver, market, scyDesired, ptDesired, minLpOut, true);
     }
 
     /// @dev docs can be found in the internal function
@@ -51,79 +47,49 @@ contract ActionCore is IPActionCore, ActionSCYAndOTBase, ActionSCYAndYOBase {
         address market,
         uint256 lpToRemove,
         uint256 scyOutMin,
-        uint256 otOutMin
+        uint256 ptOutMin
     ) external returns (uint256, uint256) {
-        return _removeLiquidity(receiver, market, lpToRemove, scyOutMin, otOutMin, true);
+        return _removeLiquidity(receiver, market, lpToRemove, scyOutMin, ptOutMin, true);
     }
 
     /// @dev docs can be found in the internal function
-    function swapExactOtForScy(
+    function swapExactPtForScy(
         address receiver,
         address market,
-        uint256 exactOtIn,
+        uint256 exactPtIn,
         uint256 minScyOut
     ) external returns (uint256) {
-        return _swapExactOtForScy(receiver, market, exactOtIn, minScyOut, true);
+        return _swapExactPtForScy(receiver, market, exactPtIn, minScyOut, true);
     }
 
     /// @dev docs can be found in the internal function
-    function swapOtForExactScy(
+    function swapPtForExactScy(
         address receiver,
         address market,
         uint256 exactScyOut,
-        uint256 otInGuessMin,
-        uint256 otInGuessMax,
-        uint256 maxIteration,
-        uint256 eps
+        ApproxParams memory approx
     ) external returns (uint256) {
-        return
-            _swapOtForExactScy(
-                receiver,
-                market,
-                exactScyOut,
-                ApproxParams({
-                    guessMin: otInGuessMin,
-                    guessMax: otInGuessMax,
-                    eps: eps,
-                    maxIteration: maxIteration
-                }),
-                true
-            );
+        return _swapPtForExactScy(receiver, market, exactScyOut, approx, true);
     }
 
     /// @dev docs can be found in the internal function
-    function swapScyForExactOt(
+    function swapScyForExactPt(
         address receiver,
         address market,
-        uint256 exactOtOut,
+        uint256 exactPtOut,
         uint256 maxScyIn
     ) external returns (uint256) {
-        return _swapScyForExactOt(receiver, market, exactOtOut, maxScyIn, true);
+        return _swapScyForExactPt(receiver, market, exactPtOut, maxScyIn, true);
     }
 
     /// @dev docs can be found in the internal function
-    function swapExactScyForOt(
+    function swapExactScyForPt(
         address receiver,
         address market,
         uint256 exactScyIn,
-        uint256 otOutguessMin,
-        uint256 otOutguessMax,
-        uint256 maxIteration,
-        uint256 eps
+        ApproxParams memory approx
     ) external returns (uint256) {
-        return
-            _swapExactScyForOt(
-                receiver,
-                market,
-                exactScyIn,
-                ApproxParams({
-                    guessMin: otOutguessMin,
-                    guessMax: otOutguessMax,
-                    eps: eps,
-                    maxIteration: maxIteration
-                }),
-                true
-            );
+        return _swapExactScyForPt(receiver, market, exactScyIn, approx, true);
     }
 
     /// @dev docs can be found in the internal function
@@ -149,47 +115,45 @@ contract ActionCore is IPActionCore, ActionSCYAndOTBase, ActionSCYAndYOBase {
     }
 
     /// @dev docs can be found in the internal function
-    function mintYoFromRawToken(
+    function mintPyFromRawToken(
         uint256 netRawTokenIn,
         address YT,
-        uint256 minYoOut,
+        uint256 minPyOut,
         address receiver,
         address[] calldata path
     ) external returns (uint256) {
-        return _mintYoFromRawToken(netRawTokenIn, YT, minYoOut, receiver, path, true);
+        return _mintPyFromRawToken(netRawTokenIn, YT, minPyOut, receiver, path, true);
     }
 
     /// @dev docs can be found in the internal function
-    function redeemYoToRawToken(
+    function redeemPyToRawToken(
         address YT,
-        uint256 netYoIn,
+        uint256 netPyIn,
         uint256 minRawTokenOut,
         address receiver,
         address[] memory path
     ) external returns (uint256) {
-        return _redeemYoToRawToken(YT, netYoIn, minRawTokenOut, receiver, path, true);
+        return _redeemPyToRawToken(YT, netPyIn, minRawTokenOut, receiver, path, true);
     }
 
     /**
-    * @dev netOtOutGuessMin & netOtOutGuessMax the minimum & maximum possible guess for the netOtOut
-    the correct otOut must lie between this range, else the function will revert.
+    * @dev netPtOutGuessMin & netPtOutGuessMax the minimum & maximum possible guess for the netPtOut
+    the correct ptOut must lie between this range, else the function will revert.
     * @dev the smaller the range, the fewer iterations it will take (hence less gas). The expected way
     to create the guess is to run this function with min = 0, max = type(uint256.max) to trigger the widest
-    guess range. After getting the result, min = result * (100-slippage) & max = result * (100+slippage)
+    guess range. After getting the result, min = result * (1-eps) & max = result * (1+eps)
     * @param path the path to swap from rawToken to baseToken. path = [baseToken] if no swap is needed
+    * @param approx params to approx. Guess params will be the min, max & offchain guess for netPtOut
     */
-    function swapExactRawTokenForOt(
+    function swapExactRawTokenForPt(
         uint256 exactRawTokenIn,
         address receiver,
         address[] calldata path,
         address market,
-        uint256 otOutguessMin,
-        uint256 otOutguessMax,
-        uint256 maxIteration,
-        uint256 eps
-    ) external returns (uint256 netOtOut) {
+        ApproxParams memory approx
+    ) external returns (uint256 netPtOut) {
         address SCY = IPMarket(market).SCY();
-        uint256 netScyUseToBuyOt = _mintScyFromRawToken(
+        uint256 netScyUseToBuyPt = _mintScyFromRawToken(
             exactRawTokenIn,
             SCY,
             1,
@@ -197,33 +161,22 @@ contract ActionCore is IPActionCore, ActionSCYAndOTBase, ActionSCYAndYOBase {
             path,
             true
         );
-        netOtOut = _swapExactScyForOt(
-            receiver,
-            market,
-            netScyUseToBuyOt,
-            ApproxParams({
-                guessMin: otOutguessMin,
-                guessMax: otOutguessMax,
-                eps: eps,
-                maxIteration: maxIteration
-            }),
-            false
-        );
+        netPtOut = _swapExactScyForPt(receiver, market, netScyUseToBuyPt, approx, false);
     }
 
     /**
-     * @notice sell all Ot for RawToken
+     * @notice sell all Pt for RawToken
      * @param path the path to swap from rawToken to baseToken. path = [baseToken] if no swap is needed
      */
-    function swapExactOtForRawToken(
-        uint256 exactOtIn,
+    function swapExactPtForRawToken(
+        uint256 exactPtIn,
         address receiver,
         address[] calldata path,
         address market,
         uint256 minRawTokenOut
     ) external returns (uint256 netRawTokenOut) {
         address SCY = IPMarket(market).SCY();
-        _swapExactOtForScy(SCY, market, exactOtIn, 1, true);
+        _swapExactPtForScy(SCY, market, exactPtIn, 1, true);
         netRawTokenOut = _redeemScyToRawToken(SCY, 0, minRawTokenOut, receiver, path, false);
     }
 }

package/contracts/core/actions/ActionRedeem.sol

@@ -0,0 +1,36 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.9;
+
+import "../../interfaces/IPActionRedeem.sol";
+import "../../SuperComposableYield/ISuperComposableYield.sol";
+import "../../interfaces/IPYieldToken.sol";
+import "../../core/PendleMarket.sol";
+import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
+
+contract ActionRedeem is IPActionRedeem {
+    function redeemDueIncome(
+        address user,
+        address[] calldata scys,
+        address[] calldata yieldTokens,
+        address[] calldata /*gauges*/
+    )
+        external
+        returns (
+            uint256[][] memory scyRewards,
+            uint256[] memory ytInterests,
+            uint256[][] memory ytRewards
+        )
+    {
+        scyRewards = new uint256[][](scys.length);
+        for (uint256 i = 0; i < scys.length; ++i) {
+            scyRewards[i] = ISuperComposableYield(scys[i]).redeemReward(user);
+        }
+
+        ytInterests = new uint256[](yieldTokens.length);
+        ytRewards = new uint256[][](yieldTokens.length);
+        for (uint256 i = 0; i < yieldTokens.length; ++i) {
+            (ytInterests[i], ytRewards[i]) = IPYieldToken(yieldTokens[i])
+                .redeemDueInterestAndRewards(user);
+        }
+    }
+}

package/contracts/core/actions/ActionYT.sol

@@ -2,7 +2,7 @@
 pragma solidity 0.8.9;
 
 import "./base/ActionSCYAndYTBase.sol";
-import "../../interfaces/IPOwnershipToken.sol";
+import "../../interfaces/IPPrincipalToken.sol";
 import "../../interfaces/IPYieldToken.sol";
 import "../../interfaces/IPActionYT.sol";
 import "../../libraries/math/MarketMathAux.sol";
@@ -15,13 +15,20 @@ contract ActionYT is IPActionYT, ActionSCYAndYTBase {
 
     /// @dev since this contract will be proxied, it must not contains non-immutable variables
     constructor(address _joeRouter, address _joeFactory)
-        ActionSCYAndYOBase(_joeRouter, _joeFactory)
-        ActionSCYAndYTBase()
+        ActionSCYAndPYBase(_joeRouter, _joeFactory)
     //solhint-disable-next-line no-empty-blocks
     {
 
     }
 
+    /**
+     * @dev Take in a fixed amount of YT and returns receiver a corresponding amount of SCY
+     * @dev inner working step
+       - Transfer exactYtIn amount of YT to YT
+       - market.swapScyToExactPt is called, the receiver of PT is YT
+       - YT.redeemPY is called, burning exactYtIn YT & PT to SCY
+       - Return the owed Scy for contract, the rest is transferred to user
+     */
     function swapExactYtForScy(
         address receiver,
         address market,
@@ -31,6 +38,14 @@ contract ActionYT is IPActionYT, ActionSCYAndYTBase {
         return _swapExactYtForScy(receiver, market, exactYtIn, minScyOut, true);
     }
 
+    /**
+     * @dev Take in a corresponding amount of SCY & return receiver a fixed amount of YT
+     * @dev inner working step
+       - Input SCY is transferred to YT address
+       - swap.swapExactPtForScy is called the receiver is YT
+       - YT.mintPY is called, granting router exactYtOut YT & PT
+       - The owed PT is paid by setting the PT receiver is market, YT receiver is $receiver
+     */
     function swapScyForExactYt(
         address receiver,
         address market,
@@ -40,71 +55,49 @@ contract ActionYT is IPActionYT, ActionSCYAndYTBase {
         return _swapScyForExactYt(receiver, market, exactYtOut, maxScyIn);
     }
 
+    /**
+     * @dev Take in a fixed a mount of SCY and return receiver the corresponding amount of YT
+     * @dev can refer to the doc of swapExactRawTokenForYt
+     * @param approx params to approx. Guess params will be the min, max & offchain guess for netYtOut
+     */
     function swapExactScyForYt(
         address receiver,
         address market,
         uint256 exactScyIn,
-        uint256 netYtOutGuessMin,
-        uint256 netYtOutGuessMax,
-        uint256 maxIteration,
-        uint256 eps
-    ) external returns (uint256) {
-        return
-            _swapExactScyForYt(
-                receiver,
-                market,
-                exactScyIn,
-                ApproxParams({
-                    guessMin: netYtOutGuessMin,
-                    guessMax: netYtOutGuessMax,
-                    eps: eps,
-                    maxIteration: maxIteration
-                }),
-                true
-            );
+        ApproxParams memory approx
+    ) external returns (uint256 netYtOut) {
+        return _swapExactScyForYt(receiver, market, exactScyIn, approx, true);
     }
 
+    /**
+     * @dev take in a correesponding amount of YT & return an exactScyOut amount of SCY
+     * @dev can refer to the doc of swapExactYtForRawToken
+     * @param approx params to approx. Guess params will be the min, max & offchain guess for netYtIn
+     */
     function swapYtForExactScy(
         address receiver,
         address market,
         uint256 exactScyOut,
-        uint256 netYtInGuessMin,
-        uint256 netYtInGuessMax,
-        uint256 maxIteration,
-        uint256 eps
+        ApproxParams memory approx
     ) external returns (uint256 netYtIn) {
-        return
-            _swapYtForExactScy(
-                receiver,
-                market,
-                exactScyOut,
-                ApproxParams({
-                    guessMin: netYtInGuessMin,
-                    guessMax: netYtInGuessMax,
-                    eps: eps,
-                    maxIteration: maxIteration
-                }),
-                true
-            );
+        return _swapYtForExactScy(receiver, market, exactScyOut, approx, true);
     }
 
     /**
-     * @dev netYtOutGuessMin & Max can be used in the same way as RawTokenOT
+     * @dev netYtOutGuessMin & Max can be used in the same way as RawTokenPT
      * @param path the path to swap from rawToken to baseToken. path = [baseToken] if no swap is needed
      * @dev inner working of this function:
      - mintScyFromRawToken is invoked, except the YT contract will receive all the outcome SCY
-     - market.swap is called, which will transfer SCY to the YT contract, and callback is invoked
-     - callback will do call YT's mintYO, which will mint OT to the market & YT to the receiver
+     - market.swapExactPtToScy is called, which will transfer SCY to the YT contract, and callback is invoked
+     - callback will do call YT.mintPT, which will mint PT to the market & YT to the receiver
+     * @param approx params to approx. Guess params will be the min, max & offchain guess for netYtOut
      */
     function swapExactRawTokenForYt(
         uint256 exactRawTokenIn,
         address receiver,
         address[] calldata path,
         address market,
-        uint256 netYtOutGuessMin,
-        uint256 netYtOutGuessMax,
-        uint256 maxIteration,
-        uint256 eps
+        ApproxParams memory approx
     ) external returns (uint256 netYtOut) {
         (ISuperComposableYield SCY, , IPYieldToken YT) = IPMarket(market).readTokens();
 
@@ -117,18 +110,7 @@ contract ActionYT is IPActionYT, ActionSCYAndYTBase {
             true
         );
 
-        netYtOut = _swapExactScyForYt(
-            receiver,
-            market,
-            netScyUsedToBuyYT,
-            ApproxParams({
-                guessMin: netYtOutGuessMin,
-                guessMax: netYtOutGuessMax,
-                eps: eps,
-                maxIteration: maxIteration
-            }),
-            false
-        );
+        netYtOut = _swapExactScyForYt(receiver, market, netScyUsedToBuyYT, approx, false);
     }
 
     /**
@@ -137,8 +119,8 @@ contract ActionYT is IPActionYT, ActionSCYAndYTBase {
      * @param path the path to swap from rawToken to baseToken. path = [baseToken] if no swap is needed
      * @dev inner working of this function:
      - YT is transferred to the YT contract
-     - market.swap is called, which will transfer OT directly to the YT contract, and callback is invoked
-     - callback will do call YT's redeemYO, which will redeem the outcome SCY to this router, then
+     - market.swapScyForExactPt is called, which will transfer PT directly to the YT contract, and callback is invoked
+     - callback will do call YT.redeemPY, which will redeem the outcome SCY to this router, then
         all SCY owed to the market will be paid, the rest is used to feed redeemScyToRawToken
      */
     function swapExactYtForRawToken(