@pendle/core-v2 0.8.1-beta → 0.9.0-gamma-2

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

@@ -14,7 +14,7 @@ abstract contract ActionSCYAndPTBase is ActionSCYAndPYBase {
     using MarketMathCore for MarketState;
     using MarketApproxLib for MarketState;
     using SafeERC20 for IERC20;
-    using SCYIndexLib for ISuperComposableYield;
+    using PYIndexLib for IPYieldToken;
 
     bytes private constant EMPTY_BYTES = abi.encode();
 
@@ -38,11 +38,12 @@ abstract contract ActionSCYAndPTBase is ActionSCYAndPYBase {
             uint256 ptUsed
         )
     {
-        (ISuperComposableYield SCY, IPPrincipalToken PT, ) = IPMarket(market).readTokens();
+        (ISuperComposableYield SCY, IPPrincipalToken PT, IPYieldToken YT) = IPMarket(market)
+            .readTokens();
 
         MarketState memory state = IPMarket(market).readState(false);
         (, netLpOut, scyUsed, ptUsed) = state.addLiquidity(
-            SCY.newIndex(),
+            YT.newIndex(),
             scyDesired,
             ptDesired,
             block.timestamp
@@ -119,10 +120,10 @@ abstract contract ActionSCYAndPTBase is ActionSCYAndPYBase {
         bool doPull
     ) internal returns (uint256 netPtIn) {
         MarketState memory state = IPMarket(market).readState(false);
-        (ISuperComposableYield SCY, IPPrincipalToken PT, ) = IPMarket(market).readTokens();
+        (, IPPrincipalToken PT, IPYieldToken YT) = IPMarket(market).readTokens();
 
         (netPtIn, , ) = state.approxSwapPtForExactScy(
-            SCY.newIndex(),
+            YT.newIndex(),
             exactScyOut,
             block.timestamp,
             guessPtIn
@@ -147,9 +148,9 @@ abstract contract ActionSCYAndPTBase is ActionSCYAndPYBase {
         bool doPull
     ) internal returns (uint256 netScyIn) {
         MarketState memory state = IPMarket(market).readState(false);
-        (ISuperComposableYield SCY, , ) = IPMarket(market).readTokens();
+        (ISuperComposableYield SCY, , IPYieldToken YT) = IPMarket(market).readTokens();
 
-        (netScyIn, ) = state.swapScyForExactPt(SCY.newIndex(), exactPtOut, block.timestamp);
+        (netScyIn, ) = state.swapScyForExactPt(YT.newIndex(), exactPtOut, block.timestamp);
 
         require(netScyIn <= maxScyIn, "exceed limit SCY in");
 
@@ -175,10 +176,10 @@ abstract contract ActionSCYAndPTBase is ActionSCYAndPYBase {
         bool doPull
     ) internal returns (uint256 netPtOut) {
         MarketState memory state = IPMarket(market).readState(false);
-        (ISuperComposableYield SCY, , ) = IPMarket(market).readTokens();
+        (ISuperComposableYield SCY, , IPYieldToken YT) = IPMarket(market).readTokens();
 
         (netPtOut, , ) = state.approxSwapExactScyForPt(
-            SCY.newIndex(),
+            YT.newIndex(),
             exactScyIn,
             block.timestamp,
             guessPtOut
@@ -198,28 +199,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(
@@ -233,30 +225,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

@@ -16,7 +16,7 @@ abstract contract ActionSCYAndYTBase is ActionSCYAndPYBase, CallbackHelper {
     using MarketApproxLib for MarketState;
     using SafeERC20 for ISuperComposableYield;
     using SafeERC20 for IPYieldToken;
-    using SCYIndexLib for ISuperComposableYield;
+    using PYIndexLib for IPYieldToken;
 
     /**
     * @notice swap exact SCY to YT with the help of flashswaps & YT tokenization / redemption
@@ -40,7 +40,7 @@ abstract contract ActionSCYAndYTBase is ActionSCYAndPYBase, CallbackHelper {
         MarketState memory state = IPMarket(market).readState(false);
 
         (netYtOut, , ) = state.approxSwapExactScyForYt(
-            SCY.newIndex(),
+            YT.newIndex(),
             exactScyIn,
             block.timestamp,
             guessYtOut
@@ -141,10 +141,10 @@ abstract contract ActionSCYAndYTBase is ActionSCYAndPYBase, CallbackHelper {
         bool doPull
     ) internal returns (uint256 netYtIn) {
         MarketState memory state = IPMarket(market).readState(false);
-        (ISuperComposableYield SCY, , IPYieldToken YT) = IPMarket(market).readTokens();
+        (, , IPYieldToken YT) = IPMarket(market).readTokens();
 
         (netYtIn, , ) = state.approxSwapYtForExactScy(
-            SCY.newIndex(),
+            YT.newIndex(),
             exactScyOut,
             block.timestamp,
             guessYtIn
@@ -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(receiver, market, netYtIn, 1, doPull);
 
-        netRawTokenOut = _redeemScyToRawToken(
-            receiver,
-            address(SCY),
-            netScyOut,
-            minRawTokenOut,
-            path,
-            false
-        );
+        netTokenOut = _redeemScyToToken(receiver, address(SCY), netScyOut, output, false);
     }
 }

package/contracts/interfaces/IEulerEToken.sol

@@ -0,0 +1,60 @@
+// 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;
+
+interface IEulerEToken {
+    /// @notice Address of underlying asset
+    function underlyingAsset() external view returns (address);
+
+    /// @notice Sum of all balances, in internal book-keeping units (non-increasing)
+    function totalSupply() external view returns (uint256);
+
+    /// @notice Sum of all balances, in underlying units (increases as interest is earned)
+    function totalSupplyUnderlying() external view returns (uint256);
+
+    /// @notice Transfer underlying tokens from sender to the Euler pool, and increase account's eTokens
+    /// @param subAccountId 0 for primary, 1-255 for a sub-account
+    /// @param amount In underlying units (use max uint256 for full underlying token balance)
+    function deposit(uint256 subAccountId, uint256 amount) external;
+
+    function balanceOf(address) external view returns (uint256);
+
+    /// @notice Balance of a particular account, in underlying units (increases as interest is earned)
+    function balanceOfUnderlying(address) external view returns (uint256);
+
+    /// @notice Convert an underlying amount to an eToken balance, taking into account current exchange rate
+    /// @param underlyingAmount Amount in underlying units (same decimals as underlying token)
+    /// @return eToken balance, in internal book-keeping units (18 decimals)
+    function convertUnderlyingToBalance(uint256 underlyingAmount) external view returns (uint256);
+
+    /// @notice Convert an eToken balance to an underlying amount, taking into account current exchange rate
+    /// @param balance eToken balance, in internal book-keeping units (18 decimals)
+    /// @return Amount in underlying units, (same decimals as underlying token)
+    function convertBalanceToUnderlying(uint256 balance) external view returns (uint256);
+
+    /// @notice Transfer underlying tokens from Euler pool to sender, and decrease account's eTokens
+    /// @param subAccountId 0 for primary, 1-255 for a sub-account
+    /// @param amount In underlying units (use max uint256 for full pool balance)
+    function withdraw(uint256 subAccountId, uint256 amount) external;
+}

package/contracts/interfaces/IEulerMarkets.sol

@@ -0,0 +1,46 @@
+// 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;
+
+interface IEulerMarkets {
+    /// @notice Given an EToken address, looks up the associated underlying
+    /// @param eToken EToken address
+    /// @return underlying Token address
+    function eTokenToUnderlying(address eToken) external view returns (address underlying);
+
+    /// @notice Given an underlying, lookup the associated EToken
+    /// @param underlying Token address
+    /// @return EToken address, or address(0) if not activated
+    function underlyingToEToken(address underlying) external view returns (address);
+
+    /// @notice Given an underlying, lookup the associated DToken
+    /// @param underlying Token address
+    /// @return DToken address, or address(0) if not activated
+    function underlyingToDToken(address underlying) external view returns (address);
+
+    /// @notice Retrieves the current interest rate for an asset
+    /// @param underlying Token address
+    /// @return The interest rate in yield-per-second, scaled by 10**27
+    function interestRate(address underlying) external view returns (int96);
+}