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

package/contracts/interfaces/IPActionCore.sol

@@ -2,9 +2,10 @@
 pragma solidity 0.8.15;
 
 import "../libraries/math/MarketApproxLib.sol";
+import "../libraries/kyberswap/KyberSwapHelper.sol";
 
 interface IPActionCore {
-    event AddLiquidity(
+    event AddLiquidityDualScyAndPt(
         address indexed caller,
         address indexed market,
         address indexed receiver,
@@ -13,7 +14,16 @@ interface IPActionCore {
         uint256 lpOut
     );
 
-    event RemoveLiquidity(
+    event AddLiquidityDualIbTokenAndPt(
+        address indexed caller,
+        address indexed market,
+        address indexed receiver,
+        uint256 ibTokenUsed,
+        uint256 ptUsed,
+        uint256 lpOut
+    );
+
+    event RemoveLiquidityDualScyAndPt(
         address indexed caller,
         address indexed market,
         address receiver,
@@ -22,6 +32,15 @@ interface IPActionCore {
         uint256 amountSCYOut
     );
 
+    event RemoveLiquidityDualIbTokenAndPt(
+        address indexed caller,
+        address indexed market,
+        address receiver,
+        uint256 lpIn,
+        uint256 amountPTOut,
+        uint256 amountIbTokenOut
+    );
+
     event SwapPtAndScy(
         address indexed caller,
         address indexed market,
@@ -30,31 +49,31 @@ interface IPActionCore {
         int256 amountScyToAccount
     );
 
-    event SwapPtAndRawToken(
+    event SwapPtAndToken(
         address indexed caller,
         address indexed market,
-        address indexed rawToken,
+        address indexed token,
         address receiver,
         int256 amountPtToAccount,
-        int256 amountRawTokenToAccount
+        int256 amountTokenToAccount
     );
 
-    event MintScyFromRawToken(
+    event MintScyFromToken(
         address indexed caller,
         address indexed receiver,
         address indexed SCY,
-        address rawTokenIn,
-        uint256 netRawTokenIn,
+        address tokenIn,
+        uint256 netTokenIn,
         uint256 netScyOut
     );
 
-    event RedeemScyToRawToken(
+    event RedeemScyToToken(
         address indexed caller,
         address indexed receiver,
         address indexed SCY,
         uint256 netScyIn,
-        address rawTokenOut,
-        uint256 netRawTokenOut
+        address tokenOut,
+        uint256 netTokenOut
     );
 
     event MintPyFromScy(
@@ -73,25 +92,25 @@ interface IPActionCore {
         uint256 netScyOut
     );
 
-    event MintPyFromRawToken(
+    event MintPyFromToken(
         address indexed caller,
         address indexed receiver,
         address indexed YT,
-        address rawTokenIn,
-        uint256 netRawTokenIn,
+        address tokenIn,
+        uint256 netTokenIn,
         uint256 netPyOut
     );
 
-    event RedeemPyToRawToken(
+    event RedeemPyToToken(
         address indexed caller,
         address indexed receiver,
         address indexed YT,
         uint256 netPyIn,
-        address rawTokenOut,
-        uint256 netRawTokenOut
+        address tokenOut,
+        uint256 netTokenOut
     );
 
-    function addLiquidity(
+    function addLiquidityDualScyAndPt(
         address receiver,
         address market,
         uint256 scyDesired,
@@ -105,12 +124,27 @@ interface IPActionCore {
             uint256 ptUsed
         );
 
+    /// @dev refer to the internal function
+    function addLiquidityDualIbTokenAndPt(
+        address receiver,
+        address market,
+        uint256 ibTokenDesired,
+        uint256 ptDesired,
+        uint256 minLpOut
+    )
+        external
+        returns (
+            uint256 netLpOut,
+            uint256 ibTokenUsed,
+            uint256 ptUsed
+        );
+
     function addLiquiditySinglePt(
         address receiver,
         address market,
         uint256 netPtIn,
         uint256 minLpOut,
-        ApproxParams memory guessPtSwapToScy
+        ApproxParams calldata guessPtSwapToScy
     ) external returns (uint256 netLpOut);
 
     function addLiquiditySingleScy(
@@ -118,19 +152,18 @@ interface IPActionCore {
         address market,
         uint256 netScyIn,
         uint256 minLpOut,
-        ApproxParams memory guessPtReceivedFromScy
+        ApproxParams calldata guessPtReceivedFromScy
     ) external returns (uint256 netLpOut);
 
-    function addLiquiditySingleRawToken(
+    function addLiquiditySingleToken(
         address receiver,
         address market,
-        uint256 netRawTokenIn,
         uint256 minLpOut,
-        address[] calldata path,
-        ApproxParams memory guessPtReceivedFromScy
+        ApproxParams calldata guessPtReceivedFromScy,
+        TokenInput calldata input
     ) external returns (uint256 netLpOut);
 
-    function removeLiquidity(
+    function removeLiquidityDualScyAndPt(
         address receiver,
         address market,
         uint256 lpToRemove,
@@ -138,12 +171,21 @@ interface IPActionCore {
         uint256 ptOutMin
     ) external returns (uint256 netScyOut, uint256 netPtOut);
 
+    /// @dev refer to the internal function
+    function removeLiquidityDualIbTokenAndPt(
+        address receiver,
+        address market,
+        uint256 lpToRemove,
+        uint256 ibTokenMin,
+        uint256 ptOutMin
+    ) external returns (uint256 netIbTokenOut, uint256 netPtOut);
+
     function removeLiquiditySinglePt(
         address receiver,
         address market,
         uint256 lpToRemove,
         uint256 minPtOut,
-        ApproxParams memory guessPtOut
+        ApproxParams calldata guessPtOut
     ) external returns (uint256 netPtOut);
 
     function removeLiquiditySingleScy(
@@ -153,13 +195,12 @@ interface IPActionCore {
         uint256 minScyOut
     ) external returns (uint256 netScyOut);
 
-    function removeLiquiditySingleRawToken(
+    function removeLiquiditySingleToken(
         address receiver,
         address market,
         uint256 lpToRemove,
-        uint256 minRawTokenOut,
-        address[] memory path
-    ) external returns (uint256 netRawTokenOut);
+        TokenOutput calldata output
+    ) external returns (uint256 netTokenOut);
 
     function swapExactPtForScy(
         address receiver,
@@ -173,7 +214,7 @@ interface IPActionCore {
         address market,
         uint256 exactScyOut,
         uint256 maxPtIn,
-        ApproxParams memory guessPtIn
+        ApproxParams calldata guessPtIn
     ) external returns (uint256 netPtIn);
 
     function swapScyForExactPt(
@@ -188,40 +229,36 @@ interface IPActionCore {
         address market,
         uint256 exactScyIn,
         uint256 minPtOut,
-        ApproxParams memory guessPtOut
+        ApproxParams calldata guessPtOut
     ) external returns (uint256 netPtOut);
 
-    function mintScyFromRawToken(
+    function mintScyFromToken(
         address receiver,
         address SCY,
-        uint256 netRawTokenIn,
         uint256 minScyOut,
-        address[] calldata path
+        TokenInput calldata input
     ) external returns (uint256 netScyOut);
 
-    function redeemScyToRawToken(
+    function redeemScyToToken(
         address receiver,
         address SCY,
         uint256 netScyIn,
-        uint256 minRawTokenOut,
-        address[] memory path
-    ) external returns (uint256 netRawTokenOut);
+        TokenOutput calldata output
+    ) external returns (uint256 netTokenOut);
 
-    function mintPyFromRawToken(
+    function mintPyFromToken(
         address receiver,
         address YT,
-        uint256 netRawTokenIn,
         uint256 minPyOut,
-        address[] calldata path
+        TokenInput calldata input
     ) external returns (uint256 netPyOut);
 
-    function redeemPyToRawToken(
+    function redeemPyToToken(
         address receiver,
         address YT,
         uint256 netPyIn,
-        uint256 minRawTokenOut,
-        address[] memory path
-    ) external returns (uint256 netRawTokenOut);
+        TokenOutput calldata output
+    ) external returns (uint256 netTokenOut);
 
     function mintPyFromScy(
         address receiver,
@@ -237,22 +274,20 @@ interface IPActionCore {
         uint256 minScyOut
     ) external returns (uint256 netScyOut);
 
-    function swapExactRawTokenForPt(
+    function swapExactTokenForPt(
         address receiver,
         address market,
-        uint256 exactRawTokenIn,
         uint256 minPtOut,
-        address[] calldata path,
-        ApproxParams memory guessPtOut
+        ApproxParams calldata guessPtOut,
+        TokenInput calldata input
     ) external returns (uint256 netPtOut);
 
-    function swapExactPtForRawToken(
+    function swapExactPtForToken(
         address receiver,
         address market,
         uint256 exactPtIn,
-        uint256 minRawTokenOut,
-        address[] calldata path
-    ) external returns (uint256 netRawTokenOut);
+        TokenOutput calldata output
+    ) external returns (uint256 netTokenOut);
 
     function redeemDueInterestAndRewards(
         address user,

package/contracts/interfaces/IPActionYT.sol

@@ -2,6 +2,7 @@
 pragma solidity 0.8.15;
 
 import "../libraries/math/MarketApproxLib.sol";
+import "../libraries/kyberswap/KyberSwapHelper.sol";
 
 interface IPActionYT {
     event SwapYTAndSCY(
@@ -11,12 +12,12 @@ interface IPActionYT {
         int256 scyToAccount
     );
 
-    event SwapYTAndRawToken(
+    event SwapYTAndToken(
         address indexed user,
         address indexed market,
-        address indexed rawToken,
+        address indexed token,
         int256 ytToAccount,
-        int256 rawTokenToAccount
+        int256 tokenToAccount
     );
 
     function swapExactYtForScy(
@@ -49,20 +50,18 @@ interface IPActionYT {
         ApproxParams memory guessYtIn
     ) external returns (uint256 netYtIn);
 
-    function swapExactRawTokenForYt(
+    function swapExactTokenForYt(
         address receiver,
         address market,
-        uint256 exactRawTokenIn,
         uint256 minYtOut,
-        address[] calldata path,
-        ApproxParams memory guessYtOut
+        ApproxParams memory guessYtOut,
+        TokenInput calldata input
     ) external returns (uint256 netYtOut);
 
-    function swapExactYtForRawToken(
+    function swapExactYtForToken(
         address receiver,
         address market,
-        uint256 exactYtIn,
-        uint256 minRawTokenOut,
-        address[] calldata path
-    ) external returns (uint256 netRawTokenOut);
+        uint256 netYtIn,
+        TokenOutput calldata output
+    ) external returns (uint256 netTokenOut);
 }

package/contracts/interfaces/IPRouterStatic.sol

@@ -86,7 +86,7 @@ interface IPRouterStatic {
 
     // ============= MARKET ACTIONS =============
 
-    function addLiquidityStatic(
+    function addLiquidityDualScyAndPtStatic(
         address market,
         uint256 scyDesired,
         uint256 ptDesired
@@ -98,7 +98,7 @@ interface IPRouterStatic {
             uint256 ptUsed
         );
 
-    function removeLiquidityStatic(address market, uint256 lpToRemove)
+    function removeLiquidityDualScyAndPtStatic(address market, uint256 lpToRemove)
         external
         view
         returns (uint256 netScyOut, uint256 netPtOut);

package/contracts/libraries/helpers/TokenHelper.sol

@@ -6,6 +6,7 @@ import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
 abstract contract TokenHelper {
     using SafeERC20 for IERC20;
     address internal constant NATIVE = address(0);
+    uint256 internal constant LOWER_BOUND_APPROVAL = type(uint96).max / 2; // some tokens use 96 bits for approval
 
     function _transferIn(
         address token,
@@ -13,9 +14,7 @@ abstract contract TokenHelper {
         uint256 amount
     ) internal {
         if (token == NATIVE) require(msg.value == amount, "eth mismatch");
-        else if (amount != 0) {
-            IERC20(token).safeTransferFrom(from, address(this), amount);
-        }
+        else if (amount != 0) IERC20(token).safeTransferFrom(from, address(this), amount);
     }
 
     function _transferOut(
@@ -105,4 +104,10 @@ abstract contract TokenHelper {
         );
         require(success && (data.length == 0 || abi.decode(data, (bool))), "Safe Approve");
     }
+
+    function _safeApproveInf(address token, address to) internal {
+        if (token == NATIVE) return;
+        if (IERC20(token).allowance(address(this), to) < LOWER_BOUND_APPROVAL)
+            _safeApprove(token, to, type(uint256).max);
+    }
 }

package/contracts/libraries/kyberswap/KyberSwapHelper.sol

@@ -0,0 +1,61 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+/*
+ * MIT License
+ * ===========
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR 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
+ */
+
+pragma solidity 0.8.15;
+import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
+import "@openzeppelin/contracts/utils/Address.sol";
+import "../helpers/TokenHelper.sol";
+
+struct TokenInput {
+    address tokenIn;
+    uint256 netTokenIn;
+    address tokenMintScy;
+    bytes kybercall;
+}
+
+struct TokenOutput {
+    address tokenOut;
+    uint256 minTokenOut;
+    address tokenRedeemScy;
+    bytes kybercall;
+}
+
+abstract contract KyberSwapHelper is TokenHelper {
+    using Address for address;
+    address public immutable kyberSwapRouter;
+
+    /// @dev since this contract will be proxied, it must not contains non-immutable variables
+    constructor(address _kyberSwapRouter) {
+        kyberSwapRouter = _kyberSwapRouter;
+    }
+
+    function _kyberswap(
+        address tokenIn,
+        uint256 amountIn,
+        bytes calldata kybercall
+    ) internal {
+        _safeApproveInf(tokenIn, kyberSwapRouter);
+        kyberSwapRouter.functionCallWithValue(kybercall, tokenIn == NATIVE ? amountIn : 0);
+    }
+}

package/contracts/libraries/math/Math.sol

@@ -59,6 +59,10 @@ library Math {
         }
     }
 
+    function rawDivUp(uint256 a, uint256 b) internal pure returns (uint256) {
+        return (a + b - 1) / b;
+    }
+
     // @author Uniswap
     function sqrt(uint256 y) internal pure returns (uint256 z) {
         if (y > 3) {

package/contracts/offchain-helpers/RouterStatic.sol

@@ -139,7 +139,7 @@ contract RouterStatic is IPRouterStatic {
 
     // ============= MARKET ACTIONS =============
 
-    function addLiquidityStatic(
+    function addLiquidityDualScyAndPtStatic(
         address market,
         uint256 scyDesired,
         uint256 ptDesired
@@ -160,6 +160,35 @@ contract RouterStatic is IPRouterStatic {
         );
     }
 
+    function addLiquidityDualIbTokenAndPtStatic(
+        address market,
+        uint256 ibTokenDesired,
+        uint256 ptDesired
+    )
+        external
+        returns (
+            uint256 netLpOut,
+            uint256 ibTokenUsed,
+            uint256 ptUsed
+        )
+    {
+        (ISuperComposableYield SCY, , ) = 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(
+            pyIndex(market),
+            scyDesired,
+            ptDesired,
+            block.timestamp
+        );
+
+        ibTokenUsed = (ibTokenDesired * scyUsed).rawDivUp(scyDesired);
+    }
+
     function addLiquiditySinglePtStatic(address market, uint256 netPtIn)
         external
         returns (
@@ -197,13 +226,20 @@ contract RouterStatic is IPRouterStatic {
         require(false, "NOT IMPLEMENTED");
     }
 
-    function removeLiquidityStatic(address market, uint256 lpToRemove)
+    function removeLiquidityDualScyAndPtStatic(address market, uint256 lpToRemove)
         external
         view
-        returns (uint256 netScyOut, uint256 netPtOut)
+        returns (uint256 netIbTokenOut, uint256 netPtOut)
     {
+        (ISuperComposableYield SCY, , ) = IPMarket(market).readTokens();
+
+        address ibToken = SCY.yieldToken();
+
+        uint256 netScyOut;
         MarketState memory state = IPMarket(market).readState(false);
         (netScyOut, netPtOut) = state.removeLiquidity(lpToRemove);
+
+        netIbTokenOut = SCY.previewRedeem(ibToken, netScyOut);
     }
 
     function removeLiquiditySinglePtStatic(address market, uint256 lpToRemove)

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.1-gamma",
+  "version": "0.9.2-beta",
   "homepage": "https://pendle.finance",
   "keywords": [
     "pendle",