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

package/contracts/interfaces/IPActionCore.sol

@@ -2,6 +2,7 @@
 pragma solidity 0.8.15;
 
 import "../libraries/math/MarketApproxLib.sol";
+import "../libraries/kyberswap/KyberSwapHelper.sol";
 
 interface IPActionCore {
     event AddLiquidity(
@@ -30,31 +31,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,22 +74,22 @@ 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(
@@ -110,7 +111,7 @@ interface IPActionCore {
         address market,
         uint256 netPtIn,
         uint256 minLpOut,
-        ApproxParams memory guessPtSwapToScy
+        ApproxParams calldata guessPtSwapToScy
     ) external returns (uint256 netLpOut);
 
     function addLiquiditySingleScy(
@@ -118,16 +119,15 @@ 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(
@@ -143,7 +143,7 @@ interface IPActionCore {
         address market,
         uint256 lpToRemove,
         uint256 minPtOut,
-        ApproxParams memory guessPtOut
+        ApproxParams calldata guessPtOut
     ) external returns (uint256 netPtOut);
 
     function removeLiquiditySingleScy(
@@ -153,13 +153,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 +172,7 @@ interface IPActionCore {
         address market,
         uint256 exactScyOut,
         uint256 maxPtIn,
-        ApproxParams memory guessPtIn
+        ApproxParams calldata guessPtIn
     ) external returns (uint256 netPtIn);
 
     function swapScyForExactPt(
@@ -188,40 +187,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 +232,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/IPInterestManagerYT.sol

@@ -5,5 +5,5 @@ interface IPInterestManagerYT {
     function userInterest(address user)
         external
         view
-        returns (uint128 lastScyIndex, uint128 accruedInterest);
+        returns (uint128 lastPYIndex, uint128 accruedInterest);
 }

package/contracts/interfaces/IPMarket.sol

@@ -4,6 +4,7 @@ pragma solidity 0.8.15;
 import "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
 import "./IPPrincipalToken.sol";
 import "./IPYieldToken.sol";
+import "./ISuperComposableYield.sol";
 import "../libraries/math/MarketMathCore.sol";
 
 interface IPMarket is IERC20Metadata {

package/contracts/interfaces/IPRouterStatic.sol

@@ -59,7 +59,6 @@ interface IPRouterStatic {
 
     function getMarketInfo(address market)
         external
-        view
         returns (
             address pt,
             address scy,
@@ -93,7 +92,6 @@ interface IPRouterStatic {
         uint256 ptDesired
     )
         external
-        view
         returns (
             uint256 netLpOut,
             uint256 scyUsed,
@@ -107,7 +105,6 @@ interface IPRouterStatic {
 
     function swapExactPtForScyStatic(address market, uint256 exactPtIn)
         external
-        view
         returns (
             uint256 netScyOut,
             uint256 netScyFee,
@@ -116,7 +113,6 @@ interface IPRouterStatic {
 
     function swapScyForExactPtStatic(address market, uint256 exactPtOut)
         external
-        view
         returns (
             uint256 netScyIn,
             uint256 netScyFee,
@@ -125,7 +121,6 @@ interface IPRouterStatic {
 
     function swapExactScyForPtStatic(address market, uint256 exactScyIn)
         external
-        view
         returns (
             uint256 netPtOut,
             uint256 netScyFee,
@@ -134,11 +129,11 @@ interface IPRouterStatic {
 
     // ============= OTHER HELPERS =============
 
-    function scyIndex(address market) external view returns (SCYIndex index);
+    function pyIndex(address market) external returns (PYIndex index);
 
     function getPY(address py) external view returns (address pt, address yt);
 
-    function getPtImpliedYield(address market) external view returns (int256);
+    function getPtImpliedYield(address market) external returns (int256);
 
     function getUserPYInfo(address py, address user)
         external

package/contracts/interfaces/IPVeToken.sol

@@ -14,4 +14,6 @@ interface IPVeToken {
     function totalSupplyStored() external view returns (uint128);
 
     function totalSupplyCurrent() external returns (uint128);
+
+    function totalSupplyAndBlanaceCurrent(address user) external returns (uint128, uint128);
 }

package/contracts/interfaces/IPYieldToken.sol

@@ -46,9 +46,9 @@ interface IPYieldToken is IERC20Metadata, IRewardManager, IPInterestManagerYT {
 
     function rewardIndexesCurrent() external returns (uint256[] memory);
 
-    function scyIndexCurrent() external returns (uint256);
+    function pyIndexCurrent() external returns (uint256);
 
-    function scyIndexStored() external view returns (uint256);
+    function pyIndexStored() external view returns (uint256);
 
     function getRewardTokens() external view returns (address[] memory);
 

package/contracts/interfaces/ISAvax.sol

@@ -0,0 +1,61 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.15;
+
+interface ISAvax {
+    function decimals() external pure returns (uint8);
+
+    function balanceOf(address account) external view returns (uint256);
+
+    function totalPooledAvax() external returns (uint256);
+
+    function totalShares() external returns (uint256);
+
+    /**
+     * @return The amount of AVAX that corresponds to `shareAmount` sAVAX token shares.
+     */
+    function getPooledAvaxByShares(uint256 shareAmount) external view returns (uint256);
+
+    function cooldownPeriod() external returns (uint256);
+
+    function redeemPeriod() external returns (uint256);
+
+    /**
+     * @notice Process user deposit, mints liquid tokens and increase the pool buffer -> Will be called when NATIVE AVAX is transferred to SAVAX (Dont need to call this function explicitly)
+     * @return Amount of sAVAX shares generated
+     */
+    function submit() external payable returns (uint256);
+
+    /**
+     * @notice Redeem all redeemable AVAX from all unlocks
+     */
+    function redeem() external;
+
+    /**
+     * @notice Redeem AVAX after cooldown has finished
+     * @param unlockIndex Index number of the redeemed unlock request
+     */
+    function redeem(uint256 unlockIndex) external;
+
+    /**
+     * @notice Redeem all sAVAX held in custody for overdue unlock requests
+     */
+    function redeemOverdueShares() external;
+
+    /**
+     * @notice Redeem sAVAX held in custody for the given unlock request
+     * @param unlockIndex Unlock request array index
+     */
+    function redeemOverdueShares(uint256 unlockIndex) external;
+
+    /**
+     * @notice Start unlocking cooldown period for `shareAmount` AVAX
+     * @param shareAmount Amount of shares to unlock
+     */
+    function requestUnlock(uint256 shareAmount) external;
+
+    /**
+     * @notice Get the number of active unlock requests by user
+     * @param user User address
+     */
+    function getUnlockRequestCount(address user) external view returns (uint256);
+}

package/contracts/interfaces/ISJoe.sol

@@ -0,0 +1,60 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.15;
+
+import "@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol";
+
+interface ISJoe {
+    function joe() external view returns (address);
+
+    function depositFeePercent() external view returns (uint256);
+
+    function internalJoeBalance() external view returns (uint256);
+
+    /**
+     * @notice Deposit JOE for reward token allocation
+     * @param _amount The amount of JOE to deposit
+     */
+    function deposit(uint256 _amount) external;
+
+    /**
+     * @notice Get user info
+     * @param _user The address of the user
+     * @param _rewardToken The address of the reward token
+     * @return The amount of JOE user has deposited
+     * @return The reward debt for the chosen token
+     */
+    function getUserInfo(address _user, IERC20Upgradeable _rewardToken)
+        external
+        view
+        returns (uint256, uint256);
+
+    /**
+     * @notice Get the number of reward tokens
+     * @return The length of the array
+     */
+    function rewardTokensLength() external view returns (uint256);
+
+    function rewardTokens(uint256 _index) external view returns (address);
+
+    /**
+     * @notice View function to see pending reward token on frontend
+     * @param _user The address of the user
+     * @param _token The address of the token
+     * @return `_user`'s pending reward token
+     */
+    function pendingReward(address _user, IERC20Upgradeable _token)
+        external
+        view
+        returns (uint256);
+
+    /**
+     * @notice Withdraw JOE and harvest the rewards
+     * @param _amount The amount of JOE to withdraw
+     */
+    function withdraw(uint256 _amount) external;
+
+    /**
+     * @notice Withdraw without caring about rewards. EMERGENCY ONLY
+     */
+    function emergencyWithdraw() external;
+}

package/contracts/interfaces/IStETH.sol

@@ -0,0 +1,14 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.15;
+
+interface IStETH {
+    function getSharesByPooledEth(uint256 _ethAmount) external view returns (uint256);
+
+    function getPooledEthByShares(uint256 _sharesAmount) external view returns (uint256);
+
+    function submit(address referral) external payable returns (uint256 amount);
+
+    function burnShares(address _account, uint256 _sharesAmount)
+        external
+        returns (uint256 newTotalShares);
+}

package/contracts/interfaces/IWAvax.sol

@@ -0,0 +1,34 @@
+// 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";
+
+interface IWAvax is IERC20 {
+    event Deposit(address indexed dst, uint256 wad);
+    event Withdrawal(address indexed src, uint256 wad);
+
+    function deposit() external payable;
+
+    function withdraw(uint256 wad) external;
+}

package/contracts/libraries/helpers/PYIndex.sol

@@ -0,0 +1,69 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.15;
+import "../../interfaces/IPYieldToken.sol";
+import "../../interfaces/IPPrincipalToken.sol";
+import "../SCY/SCYUtils.sol";
+import "../math/Math.sol";
+
+type PYIndex is uint256;
+
+library PYIndexLib {
+    using Math for uint256;
+    using Math for int256;
+
+    function newIndex(IPYieldToken YT) internal returns (PYIndex) {
+        return PYIndex.wrap(YT.pyIndexCurrent());
+    }
+
+    function scyToAsset(PYIndex index, uint256 scyAmount)
+        internal
+        pure
+        returns (uint256)
+    {
+        return SCYUtils.scyToAsset(PYIndex.unwrap(index), scyAmount);
+    }
+
+    function assetToScy(PYIndex index, uint256 assetAmount)
+        internal
+        pure
+        returns (uint256)
+    {
+        return SCYUtils.assetToScy(PYIndex.unwrap(index), assetAmount);
+    }
+
+    function assetToScyUp(PYIndex index, uint256 assetAmount)
+        internal
+        pure
+        returns (uint256)
+    {
+        return SCYUtils.assetToScyUp(PYIndex.unwrap(index), assetAmount);
+    }
+
+    function scyToAssetUp(PYIndex index, uint256 scyAmount)
+        internal
+        pure
+        returns (uint256)
+    {
+        uint256 _index = PYIndex.unwrap(index);
+        return SCYUtils.scyToAssetUp(_index, scyAmount);
+    }
+
+    function scyToAsset(PYIndex index, int256 scyAmount)
+        internal
+        pure
+        returns (int256)
+    {
+        int256 sign = scyAmount < 0 ? int256(-1) : int256(1);
+        return sign * (SCYUtils.scyToAsset(PYIndex.unwrap(index), scyAmount.abs())).Int();
+    }
+
+    function assetToScy(PYIndex index, int256 assetAmount)
+        internal
+        pure
+        returns (int256)
+    {
+        int256 sign = assetAmount < 0 ? int256(-1) : int256(1);
+        return sign * (SCYUtils.assetToScy(PYIndex.unwrap(index), assetAmount.abs())).Int();
+    }
+
+}

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);
+    }
 }