@pendle/core-v2 0.8.1-gamma → 0.9.2-beta

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

@@ -23,7 +23,7 @@ abstract contract ActionSCYAndPTBase is ActionSCYAndPYBase {
     /// @dev For doPull: if doPull is true, this function will do transferFrom as necessary from msg.sender. Else, it will
     /// assume tokens have already been transferred in.
 
-    function _addLiquidity(
+    function _addLiquidityDualScyAndPt(
         address receiver,
         address market,
         uint256 scyDesired,
@@ -63,31 +63,88 @@ abstract contract ActionSCYAndPTBase is ActionSCYAndPYBase {
         require(netLpOut >= minLpOut, "FS insufficient lp out");
     }
 
-    function _removeLiquidity(
+    function _addLiquidityDualIbTokenAndPt(
+        address receiver,
+        address market,
+        uint256 ibTokenDesired,
+        uint256 ptDesired,
+        uint256 minLpOut
+    )
+        internal
+        returns (
+            uint256 netLpOut,
+            uint256 ibTokenUsed,
+            uint256 ptUsed
+        )
+    {
+        (ISuperComposableYield SCY, IPPrincipalToken PT, IPYieldToken YT) = IPMarket(market)
+            .readTokens();
+
+        address ibToken = SCY.yieldToken();
+        uint256 scyDesired = SCY.previewDeposit(ibToken, ibTokenDesired);
+        uint256 scyUsed;
+
+        {
+            MarketState memory state = IPMarket(market).readState(false);
+            (, netLpOut, scyUsed, ptUsed) = state.addLiquidity(
+                YT.newIndex(),
+                scyDesired,
+                ptDesired,
+                block.timestamp
+            );
+        }
+
+        // early-check
+        require(netLpOut >= minLpOut, "insufficient lp out");
+
+        IERC20(PT).safeTransferFrom(msg.sender, market, ptUsed);
+
+        // convert ibToken to SCY to deposit
+        ibTokenUsed = (ibTokenDesired * scyUsed).rawDivUp(scyDesired);
+
+        IERC20(ibToken).safeTransferFrom(msg.sender, address(this), ibTokenUsed);
+
+        _safeApproveInf(ibToken, address(SCY));
+
+        SCY.deposit(market, ibToken, ibTokenUsed, scyDesired);
+
+        netLpOut = IPMarket(market).mint(receiver);
+        // fail-safe
+        require(netLpOut >= minLpOut, "FS insufficient lp out");
+    }
+
+    function _removeLiquidityDualScyAndPt(
         address receiver,
         address market,
         uint256 lpToRemove,
         uint256 scyOutMin,
-        uint256 ptOutMin,
-        bool doPull
+        uint256 ptOutMin
     ) internal returns (uint256 netScyOut, uint256 netPtOut) {
-        MarketState memory state = IPMarket(market).readState(false);
+        IERC20(market).safeTransferFrom(msg.sender, market, lpToRemove);
 
-        (netScyOut, netPtOut) = state.removeLiquidity(lpToRemove);
+        (netScyOut, netPtOut) = IPMarket(market).burn(receiver, receiver);
 
-        // early-check
         require(netScyOut >= scyOutMin, "insufficient SCY out");
         require(netPtOut >= ptOutMin, "insufficient PT out");
+    }
 
-        if (doPull) {
-            IERC20(market).safeTransferFrom(msg.sender, market, lpToRemove);
-        }
+    function _removeLiquidityDualIbTokenAndPt(
+        address receiver,
+        address market,
+        uint256 lpToRemove,
+        uint256 ibTokenOutMin,
+        uint256 ptOutMin
+    ) internal returns (uint256 netIbTokenOut, uint256 netPtOut) {
+        (ISuperComposableYield SCY, , ) = IPMarket(market).readTokens();
+        address ibToken = SCY.yieldToken();
 
-        (netScyOut, netPtOut) = IPMarket(market).burn(receiver, receiver);
+        IERC20(market).safeTransferFrom(msg.sender, market, lpToRemove);
 
-        // fail-safe
-        require(netScyOut >= scyOutMin, "FS insufficient SCY out");
-        require(netPtOut >= ptOutMin, "FS insufficient PT out");
+        (, netPtOut) = IPMarket(market).burn(address(SCY), receiver);
+
+        netIbTokenOut = SCY.redeemAfterTransfer(receiver, ibToken, ibTokenOutMin);
+
+        require(netPtOut >= ptOutMin, "insufficient PT out");
     }
 
     function _swapExactPtForScy(
@@ -199,28 +256,19 @@ abstract contract ActionSCYAndPTBase is ActionSCYAndPYBase {
     /**
      * @notice swap from any ERC20 tokens, through Uniswap's forks, to get baseTokens to make SCY, then swap
         from SCY to PT
-     * @dev simply a combination of _mintScyFromRawToken & _swapExactScyForPt
+     * @dev simply a combination of _mintScyFromToken & _swapExactScyForPt
      */
-    function _swapExactRawTokenForPt(
+    function _swapExactTokenForPt(
         address receiver,
         address market,
-        uint256 exactRawTokenIn,
         uint256 minPtOut,
-        address[] calldata path,
         ApproxParams memory guessPtOut,
-        bool doPull
+        TokenInput calldata input
     ) internal returns (uint256 netPtOut) {
         (ISuperComposableYield SCY, , ) = IPMarket(market).readTokens();
 
         // all output SCY is transferred directly to the market
-        uint256 netScyUseToBuyPt = _mintScyFromRawToken(
-            market,
-            address(SCY),
-            exactRawTokenIn,
-            1,
-            path,
-            doPull
-        );
+        uint256 netScyUseToBuyPt = _mintScyFromToken(address(market), address(SCY), 1, input);
 
         // SCY is already in the market, hence doPull = false
         netPtOut = _swapExactScyForPt(
@@ -234,30 +282,22 @@ abstract contract ActionSCYAndPTBase is ActionSCYAndPYBase {
     }
 
     /**
-     * @notice swap from PT to SCY, then redeem SCY to baseToken & swap through Uniswap's forks to get rawTokenOut
-     * @dev simply a combination of _swapExactPtForScy & _redeemScyToRawToken
+     * @notice swap from PT to SCY, then redeem SCY to baseToken & swap through Uniswap's forks to get tokenOut
+     * @dev simply a combination of _swapExactPtForScy & _redeemScyToToken
      */
-    function _swapExactPtForRawToken(
+    function _swapExactPtForToken(
         address receiver,
         address market,
         uint256 exactPtIn,
-        uint256 minRawTokenOut,
-        address[] calldata path,
+        TokenOutput calldata output,
         bool doPull
-    ) internal returns (uint256 netRawTokenOut) {
+    ) internal returns (uint256 netTokenOut) {
         (ISuperComposableYield SCY, , ) = IPMarket(market).readTokens();
 
         // all output SCY is directly transferred to the SCY contract
-        _swapExactPtForScy(address(SCY), market, exactPtIn, 1, doPull);
+        uint256 netScyReceived = _swapExactPtForScy(address(SCY), market, exactPtIn, 1, doPull);
 
         // since all SCY is already at the SCY contract, doPull = false
-        netRawTokenOut = _redeemScyToRawToken(
-            receiver,
-            address(SCY),
-            0,
-            minRawTokenOut,
-            path,
-            false
-        );
+        netTokenOut = _redeemScyToToken(receiver, address(SCY), netScyReceived, output, false);
     }
 }

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

@@ -2,120 +2,108 @@
 pragma solidity 0.8.15;
 
 import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
-import "../../../libraries/traderjoe/PendleJoeSwapHelperUpg.sol";
+import "../../../libraries/kyberswap/KyberSwapHelper.sol";
 import "../../../libraries/helpers/MiniHelpers.sol";
 import "../../../libraries/helpers/TokenHelper.sol";
 import "../../../interfaces/ISuperComposableYield.sol";
 import "../../../interfaces/IPYieldToken.sol";
 
 // solhint-disable no-empty-blocks
-abstract contract ActionSCYAndPYBase is PendleJoeSwapHelperUpg, TokenHelper {
+abstract contract ActionSCYAndPYBase is TokenHelper, KyberSwapHelper {
     using SafeERC20 for IERC20;
 
     /// @dev since this contract will be proxied, it must not contains non-immutable variables
-    constructor(address _joeFactory) PendleJoeSwapHelperUpg(_joeFactory) {}
+    constructor(address _kyberSwapRouter) KyberSwapHelper(_kyberSwapRouter) {}
 
     /// @dev for Path. If no swap is needed, path = [token]
     /// else, path = [inputToken, token0, token1, ...., outputToken]
 
     /**
-     * @notice swap rawToken to baseToken through Uniswap's forks & use it to mint SCY
+     * @notice swap token to baseToken through Uniswap's forks & use it to mint SCY
      */
-    function _mintScyFromRawToken(
+    function _mintScyFromToken(
         address receiver,
         address SCY,
-        uint256 netRawTokenIn,
         uint256 minScyOut,
-        address[] calldata path,
-        bool doPull
+        TokenInput calldata input
     ) internal returns (uint256 netScyOut) {
-        uint256 amountBaseToken;
-        if (path.length == 1) {
-            if (doPull) {
-                IERC20(path[0]).safeTransferFrom(msg.sender, address(this), netRawTokenIn);
-            }
-            amountBaseToken = netRawTokenIn;
-        } else {
-            if (doPull) {
-                IERC20(path[0]).safeTransferFrom(msg.sender, _getFirstPair(path), netRawTokenIn);
-            }
-            amountBaseToken = _swapExactIn(path, netRawTokenIn, address(this));
+        _transferIn(input.tokenIn, msg.sender, input.netTokenIn);
+        if (input.tokenIn != input.tokenMintScy) {
+            _kyberswap(input.tokenIn, input.netTokenIn, input.kybercall);
         }
 
-        address baseToken = path[path.length - 1];
-        IERC20(baseToken).approve(SCY, amountBaseToken);
+        _safeApproveInf(input.tokenMintScy, SCY);
         netScyOut = ISuperComposableYield(SCY).deposit(
             receiver,
-            baseToken,
-            amountBaseToken,
+            input.tokenMintScy,
+            _selfBalance(input.tokenMintScy),
             minScyOut
         );
     }
 
     /**
-     * @notice redeem SCY to baseToken -> swap baseToken to rawToken through Uniswap's forks
+     * @notice redeem SCY to baseToken -> swap baseToken to token through Uniswap's forks
      */
-    function _redeemScyToRawToken(
+    function _redeemScyToToken(
         address receiver,
         address SCY,
         uint256 netScyIn,
-        uint256 minRawTokenOut,
-        address[] memory path,
+        TokenOutput calldata output,
         bool doPull
-    ) internal returns (uint256 netRawTokenOut) {
+    ) internal returns (uint256 netTokenOut) {
         if (doPull) {
             IERC20(SCY).safeTransferFrom(msg.sender, SCY, netScyIn);
         }
 
-        address baseToken = path[0];
-        if (path.length == 1) {
-            netRawTokenOut = ISuperComposableYield(SCY).redeemAfterTransfer(
+        if (output.tokenRedeemScy == output.tokenOut) {
+            netTokenOut = ISuperComposableYield(SCY).redeemAfterTransfer(
                 receiver,
-                baseToken,
-                minRawTokenOut
+                output.tokenRedeemScy,
+                output.minTokenOut
             );
         } else {
-            uint256 netBaseTokenOut = ISuperComposableYield(SCY).redeemAfterTransfer(
-                _getFirstPair(path),
-                baseToken,
+            uint256 netTokenRedeemed = ISuperComposableYield(SCY).redeemAfterTransfer(
+                address(this),
+                output.tokenRedeemScy,
                 1
             );
-            netRawTokenOut = _swapExactIn(path, netBaseTokenOut, receiver);
-            require(netRawTokenOut >= minRawTokenOut, "insufficient out");
+            _kyberswap(output.tokenRedeemScy, netTokenRedeemed, output.kybercall);
+
+            netTokenOut = _selfBalance(output.tokenOut);
+            require(netTokenOut >= output.minTokenOut, "insufficient out");
+
+            _transferOut(output.tokenOut, receiver, netTokenOut);
         }
     }
 
     /**
-     * @notice swap rawToken to baseToken through Uniswap's forks -> convert to SCY -> convert to PT + YT
+     * @notice swap token to baseToken through Uniswap's forks -> convert to SCY -> convert to PT + YT
      */
-    function _mintPyFromRawToken(
+    function _mintPyFromToken(
         address receiver,
         address YT,
-        uint256 netRawTokenIn,
         uint256 minPyOut,
-        address[] calldata path,
-        bool doPull
+        TokenInput calldata input
     ) internal returns (uint256 netPyOut) {
         address SCY = IPYieldToken(YT).SCY();
 
-        _mintScyFromRawToken(YT, SCY, netRawTokenIn, 1, path, doPull);
+        _mintScyFromToken(YT, SCY, 1, input);
 
         netPyOut = IPYieldToken(YT).mintPY(receiver, receiver);
         require(netPyOut >= minPyOut, "insufficient PY out");
     }
 
     /**
-     * @notice redeem PT + YT to SCY -> redeem SCY to baseToken -> swap baseToken to rawToken through Uniswap's forks.
+     * @notice redeem PT + YT to SCY -> redeem SCY to baseToken -> swap baseToken to token through Uniswap's forks.
         If the YT hasn't expired, both PT & YT will be needed to redeem. Else, only PT is needed
      */
-    function _redeemPyToRawToken(
+    function _redeemPyToToken(
         address receiver,
         address YT,
         uint256 netPyIn,
-        uint256 minRawTokenOut,
-        address[] memory path,
+        TokenOutput calldata output,
         bool doPull
-    ) internal returns (uint256 netRawTokenOut) {
+    ) internal returns (uint256 netTokenOut) {
         address PT = IPYieldToken(YT).PT();
         address SCY = IPYieldToken(YT).SCY();
 
@@ -125,9 +113,9 @@ abstract contract ActionSCYAndPYBase is PendleJoeSwapHelperUpg, TokenHelper {
             if (needToBurnYt) IERC20(YT).safeTransferFrom(msg.sender, YT, netPyIn);
         }
 
-        IPYieldToken(YT).redeemPY(SCY); // ignore return
+        uint256 amountScyOut = IPYieldToken(YT).redeemPY(SCY); // ignore return
 
-        netRawTokenOut = _redeemScyToRawToken(receiver, SCY, 0, minRawTokenOut, path, false);
+        netTokenOut = _redeemScyToToken(receiver, SCY, amountScyOut, output, false);
     }
 
     function _mintPyFromScy(

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

@@ -167,25 +167,16 @@ abstract contract ActionSCYAndYTBase is ActionSCYAndPYBase, CallbackHelper {
      * @notice swap any ERC20 tokens, through Uniswap's forks, to baseToken of the corresponding SCY of YT. These SCY is then
         used to swap to YT. Please refer to swapExactScyForYt for more details.
      */
-    function _swapExactRawTokenForYt(
+    function _swapExactTokenForYt(
         address receiver,
         address market,
-        uint256 exactRawTokenIn,
         uint256 minYtOut,
-        address[] calldata path,
         ApproxParams memory guessYtOut,
-        bool doPull
+        TokenInput calldata input
     ) internal returns (uint256 netYtOut) {
         (ISuperComposableYield SCY, , IPYieldToken YT) = IPMarket(market).readTokens();
 
-        uint256 netScyUsedToBuyYT = _mintScyFromRawToken(
-            address(YT),
-            address(SCY),
-            exactRawTokenIn,
-            1,
-            path,
-            doPull
-        );
+        uint256 netScyUsedToBuyYT = _mintScyFromToken(address(YT), address(SCY), 1, input);
 
         netYtOut = _swapExactScyForYt(
             receiver,
@@ -198,28 +189,20 @@ abstract contract ActionSCYAndYTBase is ActionSCYAndPYBase, CallbackHelper {
     }
 
     /**
-     * @notice swap YT to SCY (using `swapExactYtForScy` logic), then redeem SCY to baseToken & swap baseToken to rawToken
+     * @notice swap YT to SCY (using `swapExactYtForScy` logic), then redeem SCY to baseToken & swap baseToken to token
         through Uniswap's forks
      */
-    function _swapExactYtForRawToken(
+    function _swapExactYtForToken(
         address receiver,
         address market,
-        uint256 exactYtIn,
-        uint256 minRawTokenOut,
-        address[] calldata path,
+        uint256 netYtIn,
+        TokenOutput calldata output,
         bool doPull
-    ) internal returns (uint256 netRawTokenOut) {
+    ) internal returns (uint256 netTokenOut) {
         (ISuperComposableYield SCY, , ) = IPMarket(market).readTokens();
 
-        uint256 netScyOut = _swapExactYtForScy(address(SCY), market, exactYtIn, 1, doPull);
+        uint256 netScyOut = _swapExactYtForScy(address(SCY), market, netYtIn, 1, doPull);
 
-        netRawTokenOut = _redeemScyToRawToken(
-            receiver,
-            address(SCY),
-            netScyOut,
-            minRawTokenOut,
-            path,
-            false
-        );
+        netTokenOut = _redeemScyToToken(receiver, address(SCY), netScyOut, output, false);
     }
 }