@pendle/core-v2 0.7.1-beta → 0.8.0-beta

package/contracts/interfaces/IPRouterStatic.sol

@@ -1,6 +1,7 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity 0.8.15;
 
+import "./ISuperComposableYield.sol";
 import "../libraries/math/MarketMathCore.sol";
 
 interface IPRouterStatic {
@@ -9,6 +10,12 @@ interface IPRouterStatic {
         uint256 amount;
     }
 
+    struct AssetAmount {
+        ISuperComposableYield.AssetType assetType;
+        address assetAddress;
+        uint256 amount;
+    }
+
     struct RewardIndex {
         address rewardToken;
         uint256 index;
@@ -28,15 +35,64 @@ interface IPRouterStatic {
         uint256 lpBalance;
         TokenAmount ptBalance;
         TokenAmount scyBalance;
-        TokenAmount assetBalance;
+        AssetAmount assetBalance;
     }
 
+    // ============= SYSTEM INFO =============
+
+    function getPYInfo(address py)
+        external
+        returns (
+            uint256 exchangeRate,
+            uint256 totalSupply,
+            RewardIndex[] memory rewardIndexes
+        );
+
+    function getPendleTokenType(address token)
+        external
+        view
+        returns (
+            bool isPT,
+            bool isYT,
+            bool isMarket
+        );
+
+    function getMarketInfo(address market)
+        external
+        view
+        returns (
+            address pt,
+            address scy,
+            MarketState memory state,
+            int256 impliedYield
+        );
+
+    // ============= USER INFO =============
+
+    function getUserPYPositionsByPYs(address user, address[] calldata pys)
+        external
+        view
+        returns (UserPYInfo[] memory userPYPositions);
+
+    function getUserMarketPositions(address user, address[] calldata markets)
+        external
+        view
+        returns (UserMarketInfo[] memory userMarketPositions);
+
+    function getUserSCYInfo(address scy, address user)
+        external
+        view
+        returns (uint256 balance, TokenAmount[] memory rewards);
+
+    // ============= MARKET ACTIONS =============
+
     function addLiquidityStatic(
         address market,
         uint256 scyDesired,
         uint256 ptDesired
     )
         external
+        view
         returns (
             uint256 netLpOut,
             uint256 scyUsed,
@@ -50,70 +106,34 @@ interface IPRouterStatic {
 
     function swapPtForScyStatic(address market, uint256 exactPtIn)
         external
+        view
         returns (uint256 netScyOut, uint256 netScyFee);
 
     function swapScyForPtStatic(address market, uint256 exactPtOut)
         external
+        view
         returns (uint256 netScyIn, uint256 netScyFee);
 
-    function scyIndex(address market) external returns (SCYIndex index);
+    // ============= OTHER HELPERS =============
 
-    function getPtImpliedYield(address market) external view returns (int256);
+    function scyIndex(address market) external view returns (SCYIndex index);
 
-    function getPendleTokenType(address token)
-        external
-        view
-        returns (
-            bool isPT,
-            bool isYT,
-            bool isMarket
-        );
+    function getPY(address py) external view returns (address pt, address yt);
+
+    function getPtImpliedYield(address market) external view returns (int256);
 
     function getUserPYInfo(address py, address user)
         external
         view
         returns (UserPYInfo memory userPYInfo);
 
-    function getPYInfo(address py)
-        external
-        returns (
-            uint256 exchangeRate,
-            uint256 totalSupply,
-            RewardIndex[] memory rewardIndexes
-        );
-
-    function getPY(address py) external view returns (address yt, address pt);
-
-    function getMarketInfo(address market)
-        external
-        view
-        returns (
-            address pt,
-            address scy,
-            MarketState memory state,
-            int256 impliedYield,
-            uint256 exchangeRate
-        );
-
     function getUserMarketInfo(address market, address user)
         external
         view
         returns (UserMarketInfo memory userMarketInfo);
 
-    function getUserPYPositionsByPYs(address user, address[] calldata pys)
+    function hasPYPosition(UserPYInfo calldata userPYInfo)
         external
-        view
-        returns (UserPYInfo[] memory userPYPositions);
-
-    function getUserMarketPositions(address user, address[] calldata markets)
-        external
-        view
-        returns (UserMarketInfo[] memory userMarketPositions);
-
-    function hasPYPosition(UserPYInfo memory userPYInfo) external pure returns (bool hasPosition);
-
-    function getUserSCYInfo(address scy, address user)
-        external
-        view
-        returns (uint256 balance, TokenAmount[] memory rewards);
+        pure
+        returns (bool hasPosition);
 }

package/contracts/interfaces/IPVeToken.sol

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

package/contracts/interfaces/IPVotingEscrow.sol

@@ -20,5 +20,5 @@ interface IPVotingEscrow {
         external
         returns (uint128);
 
-    function withdraw(address user) external returns (uint128);
+    function withdraw() external returns (uint128);
 }

package/contracts/interfaces/IPYieldContractFactory.sol

@@ -30,15 +30,19 @@ interface IPYieldContractFactory {
 
     event SetInterestFeeRate(uint256 newInterestFeeRate);
 
+    event SetRewardFeeRate(uint256 newInterestFeeRate);
+
     event SetTreasury(address indexed treasury);
 
     function getPT(address SCY, uint256 expiry) external view returns (address);
 
     function getYT(address SCY, uint256 expiry) external view returns (address);
 
-    function expiryDivisor() external view returns (uint256);
+    function expiryDivisor() external view returns (uint96);
+
+    function interestFeeRate() external view returns (uint128);
 
-    function interestFeeRate() external view returns (uint256);
+    function rewardFeeRate() external view returns (uint128);
 
     function treasury() external view returns (address);
 

package/contracts/interfaces/IPYieldToken.sol

@@ -5,15 +5,27 @@ import "./IRewardManager.sol";
 import "./IPInterestManagerYT.sol";
 
 interface IPYieldToken is IERC20Metadata, IRewardManager, IPInterestManagerYT {
+    event NewInterestIndex(
+        uint256 indexed newIndex
+    );
+
     event Mint(
         address indexed caller,
         address indexed receiverPT,
         address indexed receiverYT,
-        uint256 amount
+        uint256 amountScyToMint,
+        uint256 amountPYOut
+    );
+
+    event Burn(
+        address indexed caller,
+        address indexed receiver,
+        uint256 amountPYToRedeem,
+        uint256 amountScyOut
     );
-    event Redeem(address indexed caller, address indexed receiver, uint256 amount);
 
     event RedeemRewards(address indexed user, uint256[] amountRewardsOut);
+
     event RedeemInterest(address indexed user, uint256 interestOut);
 
     event WithdrawFeeToTreasury(uint256[] amountRewardsOut, uint256 scyOut);
@@ -22,17 +34,15 @@ interface IPYieldToken is IERC20Metadata, IRewardManager, IPInterestManagerYT {
 
     function redeemPY(address receiver) external returns (uint256 amountScyOut);
 
-    function redeemPY(address[] memory receivers, uint256[] memory maxAmountScyOuts)
-        external
-        returns (uint256 totalAmountScyOut);
-
-    function redeemDueInterestAndRewards(address user)
+    function redeemPYMulti(address[] calldata receivers, uint256[] calldata amountPYToRedeems)
         external
-        returns (uint256 interestOut, uint256[] memory rewardsOut);
-
-    function redeemDueInterest(address user) external returns (uint256 interestOut);
+        returns (uint256[] memory amountScyOuts);
 
-    function redeemDueRewards(address user) external returns (uint256[] memory rewardsOut);
+    function redeemDueInterestAndRewards(
+        address user,
+        bool redeemInterest,
+        bool redeemRewards
+    ) external returns (uint256 interestOut, uint256[] memory rewardsOut);
 
     function rewardIndexesCurrent() external returns (uint256[] memory);
 

package/contracts/interfaces/ISuperComposableYield.sol

@@ -56,58 +56,42 @@ interface ISuperComposableYield is IERC20Metadata {
      * @notice mints an amount of shares by depositing a base token.
      * @param receiver shares recipient address
      * @param tokenIn address of the base tokens to mint shares
-     * @param amountTokenToPull amount of base tokens to be transferred from (`msg.sender`)
+     * @param amountTokenToDeposit amount of base tokens to be transferred from (`msg.sender`)
      * @param minSharesOut reverts if amount of shares minted is lower than this
      * @return amountSharesOut amount of shares minted
-     * @dev
-     *
-     * This contract receives base tokens using these two (possibly both) methods:
-     * - The tokens have been transferred directly to this contract prior to calling deposit().
-     * - Exactly `amountTokenToPull` are transferred to this contract using `transferFrom()` upon calling deposit().
-     *
-     * The amount of shares minted will be based on the combined amount of base tokens deposited
-     * using the given two methods.
-     *
-     * Emits a {Deposit} event
+     * @dev Emits a {Deposit} event
      *
      * Requirements:
      * - (`baseTokenIn`) must be a valid base token.
-     * - There must be an ongoing approval from (`msg.sender`) for this contract with
-     * at least `amountTokenToPull` base tokens.
      */
     function deposit(
         address receiver,
         address tokenIn,
-        uint256 amountTokenToPull,
+        uint256 amountTokenToDeposit,
         uint256 minSharesOut
     ) external payable returns (uint256 amountSharesOut);
 
     /**
      * @notice redeems an amount of base tokens by burning some shares
      * @param receiver recipient address
-     * @param amountSharesToPull amount of shares to be transferred from (`msg.sender`)
+     * @param amountSharesToRedeem amount of shares to be burned from (`msg.sender`)
      * @param tokenOut address of the base token to be redeemed
      * @param minTokenOut reverts if amount of base token redeemed is lower than this
      * @return amountTokenOut amount of base tokens redeemed
-     * @dev
-     *
-     * This contract receives shares using these two (possibly both) methods:
-     * - The shares have been transferred directly to this contract prior to calling redeem().
-     * - Exactly `amountSharesToPull` are transferred to this contract using `transferFrom()` upon calling redeem().
-     *
-     * The amount of base tokens redeemed based on the combined amount of shares deposited
-     * using the given two methods
-     *
-     * Emits a {Redeem} event
+     * @dev Emits a {Redeem} event
      *
      * Requirements:
      * - (`tokenOut`) must be a valid base token.
-     * - There must be an ongoing approval from (`msg.sender`) for this contract with
-     * at least `amountSharesToPull` shares.
      */
     function redeem(
         address receiver,
-        uint256 amountSharesToPull,
+        uint256 amountSharesToRedeem,
+        address tokenOut,
+        uint256 minTokenOut
+    ) external returns (uint256 amountTokenOut);
+
+    function redeemAfterTransfer(
+        address receiver,
         address tokenOut,
         uint256 minTokenOut
     ) external returns (uint256 amountTokenOut);
@@ -163,6 +147,16 @@ interface ISuperComposableYield is IERC20Metadata {
      */
     function isValidBaseToken(address token) external view returns (bool);
 
+    function previewDeposit(address tokenIn, uint256 amountTokenToDeposit)
+        external
+        view
+        returns (uint256 amountSharesOut);
+
+    function previewRedeem(address tokenOut, uint256 amountSharesToRedeem)
+        external
+        view
+        returns (uint256 amountTokenOut);
+
     /**
     * @notice This function contains information to interpret what the asset is
     * @notice decimals is the decimals to format asset balances

package/contracts/interfaces/IYearnVault.sol

@@ -26,9 +26,17 @@ pragma solidity 0.8.15;
 interface IYearnVault {
     function deposit(uint256 amount) external returns (uint256);
 
+    function deposit(uint256 amount, address recipient) external returns (uint256);
+
     function withdraw(uint256 maxShares) external returns (uint256);
 
     function pricePerShare() external view returns (uint256);
 
     function token() external view returns (address);
+
+    function depositLimit() external view returns (uint256);
+
+    function totalAssets() external view returns (uint256);
+
+    function decimals() external view returns (uint256);
 }

package/contracts/libraries/RewardManager.sol

@@ -35,21 +35,20 @@ abstract contract RewardManager is RewardManagerAbstract {
 
             uint256 totalShares = _rewardSharesTotal();
 
-            uint256[] memory preBalances = _selfBalances(tokens);
-
             _redeemExternalReward();
 
-            uint256[] memory accrued = _selfBalances(tokens).sub(preBalances);
-
             for (uint256 i = 0; i < tokens.length; ++i) {
                 address token = tokens[i];
+
+                // the entire token balance of the contract must be the rewards of the contract
+                uint256 accrued = _selfBalance(tokens[i]) - rewardState[token].lastBalance;
                 uint256 index = rewardState[token].index;
 
                 if (index == 0) index = INITIAL_REWARD_INDEX;
-                if (totalShares != 0) index += accrued[i].divDown(totalShares);
+                if (totalShares != 0) index += accrued.divDown(totalShares);
 
                 rewardState[token].index = index.Uint128();
-                rewardState[token].lastBalance += accrued[i].Uint128();
+                rewardState[token].lastBalance += accrued.Uint128();
             }
         }
 
@@ -75,4 +74,8 @@ abstract contract RewardManager is RewardManagerAbstract {
             }
         }
     }
+
+    function _getRewardTokens() internal view virtual returns (address[] memory);
+
+    function _rewardSharesTotal() internal view virtual returns (uint256);
 }

package/contracts/libraries/RewardManagerAbstract.sol

@@ -29,17 +29,19 @@ abstract contract RewardManagerAbstract is IRewardManager, TokenHelper {
         if (tokens.length == 0) return;
 
         if (user1 != address(0) && user1 != address(this))
-            _distributeRewards(user1, tokens, indexes);
+            _distributeRewardsPrivate(user1, tokens, indexes);
         if (user2 != address(0) && user2 != address(this))
-            _distributeRewards(user2, tokens, indexes);
+            _distributeRewardsPrivate(user2, tokens, indexes);
     }
 
-    /// @dev private function
-    function _distributeRewards(
+    // should only be callable from `_updateAndDistributeRewardsForTwo` to guarantee user != address(0) && user != address(this)
+    function _distributeRewardsPrivate(
         address user,
         address[] memory tokens,
         uint256[] memory indexes
     ) private {
+        assert(user != address(0) && user != address(this));
+
         uint256 userShares = _rewardSharesUser(user);
 
         for (uint256 i = 0; i < tokens.length; ++i) {
@@ -77,9 +79,5 @@ abstract contract RewardManagerAbstract is IRewardManager, TokenHelper {
         virtual
         returns (uint256[] memory rewardAmounts);
 
-    function _getRewardTokens() internal view virtual returns (address[] memory);
-
     function _rewardSharesUser(address user) internal view virtual returns (uint256);
-
-    function _rewardSharesTotal() internal view virtual returns (uint256);
 }

package/contracts/libraries/SCY/SCYIndex.sol

@@ -34,6 +34,16 @@ library SCYIndexLib {
         return SCYUtils.assetToScy(SCYIndex.unwrap(index), assetAmount);
     }
 
+
+    function scyToAssetUp(SCYIndex index, uint256 scyAmount)
+        internal
+        pure
+        returns (uint256)
+    {
+        uint256 _index = SCYIndex.unwrap(index);
+        return SCYUtils.scyToAsset(_index, scyAmount)+  _index.rawDivUp(SCYUtils.ONE);
+    }
+
     function scyToAsset(SCYIndex index, int256 scyAmount)
         internal
         pure

package/contracts/libraries/VeBalanceLib.sol

@@ -65,7 +65,6 @@ library VeBalanceLib {
         returns (VeBalance memory res)
     {
         res.slope = position.amount / MAX_LOCK_TIME;
-        require(res.slope > 0, "zero slope");
         res.bias = res.slope * position.expiry;
     }
 

package/contracts/libraries/helpers/ArrayLib.sol

@@ -19,6 +19,17 @@ library ArrayLib {
         return output;
     }
 
+    function sum(uint256[] memory input) internal pure returns (uint256) {
+        uint256 value = 0;
+        for (uint256 i = 0; i < input.length; ) {
+            value += input[i];
+            unchecked {
+                i++;
+            }
+        }
+        return value;
+    }
+
     function contains(address[] memory array, address element) internal pure returns (bool) {
         uint256 length = array.length;
         for (uint256 i = 0; i < length; ) {

package/contracts/libraries/helpers/TokenHelper.sol

@@ -50,19 +50,20 @@ abstract contract TokenHelper {
         uint256 totalAmount,
         address[] memory tos,
         uint256[] memory maxAmounts
-    ) internal {
+    ) internal returns (uint256 leftover) {
         uint256 numTos = tos.length;
         require(numTos == maxAmounts.length, "invalid length");
 
-        uint256 remaining = totalAmount;
+        leftover = totalAmount;
         for (uint256 i = 0; i < numTos; ) {
             uint256 maxAmount = maxAmounts[i];
-            if (maxAmount > remaining) {
-                maxAmount = remaining;
+            if (maxAmount > leftover) {
+                maxAmount = leftover;
             }
             _transferOut(token, tos[i], maxAmount);
             unchecked {
-                remaining -= maxAmount;
+                leftover -= maxAmount;
+                if (leftover == 0) break;
                 i++;
             }
         }