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

package/contracts/interfaces/IPMarket.sol

@@ -7,17 +7,12 @@ import "./IPYieldToken.sol";
 import "../libraries/math/MarketMathCore.sol";
 
 interface IPMarket is IERC20Metadata {
-    event AddLiquidity(
-        address indexed receiver,
-        uint256 lpToAccount,
-        uint256 scyUsed,
-        uint256 ptUsed
-    );
+    event Mint(address indexed receiver, uint256 lpMinted, uint256 scyUsed, uint256 ptUsed);
 
-    event RemoveLiquidity(
+    event Burn(
         address indexed receiverScy,
         address indexed receiverPt,
-        uint256 lpRemoved,
+        uint256 lpBurned,
         uint256 scyToAccount,
         uint256 ptToAccount
     );
@@ -31,25 +26,11 @@ interface IPMarket is IERC20Metadata {
 
     event UpdateImpliedRate(uint256 indexed timestamp, uint256 lnLastImpliedRate);
 
-    function addLiquidity(
-        address receiver,
-        uint256 scyDesired,
-        uint256 ptDesired,
-        bytes calldata data
-    )
-        external
-        returns (
-            uint256 lpToAccount,
-            uint256 scyUsed,
-            uint256 ptUsed
-        );
+    function mint(address receiver) external returns (uint256);
 
-    function removeLiquidity(
-        address receiverScy,
-        address receiverPt,
-        uint256 lpToRemove,
-        bytes calldata data
-    ) external returns (uint256 scyToAccount, uint256 ptToAccount);
+    function burn(address receiverScy, address receiverPt)
+        external
+        returns (uint256 scyToAccount, uint256 ptToAccount);
 
     function swapExactPtForScy(
         address receiver,

package/contracts/interfaces/IPRouterStatic.sol

@@ -104,16 +104,21 @@ interface IPRouterStatic {
         view
         returns (uint256 netScyOut, uint256 netPtOut);
 
-    function swapPtForScyStatic(address market, uint256 exactPtIn)
+    function swapExactPtForScyStatic(address market, uint256 exactPtIn)
         external
         view
         returns (uint256 netScyOut, uint256 netScyFee);
 
-    function swapScyForPtStatic(address market, uint256 exactPtOut)
+    function swapScyForExactPtStatic(address market, uint256 exactPtOut)
         external
         view
         returns (uint256 netScyIn, uint256 netScyFee);
 
+    function swapExactScyForPtStatic(address market, uint256 exactScyIn)
+        external
+        view
+        returns (uint256 netPtOut, uint256 netScyFee);
+
     // ============= OTHER HELPERS =============
 
     function scyIndex(address market) external view returns (SCYIndex index);

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,21 @@ pragma solidity 0.8.15;
 interface IYearnVault {
     function deposit(uint256 amount) external returns (uint256);
 
-    function withdraw(uint256 maxShares) external returns (uint256);
+    function deposit(uint256 amount, address recipient) external returns (uint256);
+
+    function withdraw(
+        uint256 maxShares,
+        address recipient,
+        uint256 maxLoss
+    ) external returns (uint256 amountTokenRedeemed);
 
     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,23 @@ library SCYIndexLib {
         return SCYUtils.assetToScy(SCYIndex.unwrap(index), assetAmount);
     }
 
+    function assetToScyUp(SCYIndex index, uint256 assetAmount)
+        internal
+        pure
+        returns (uint256)
+    {
+        return SCYUtils.assetToScyUp(SCYIndex.unwrap(index), assetAmount);
+    }
+
+    function scyToAssetUp(SCYIndex index, uint256 scyAmount)
+        internal
+        pure
+        returns (uint256)
+    {
+        uint256 _index = SCYIndex.unwrap(index);
+        return SCYUtils.scyToAssetUp(_index, scyAmount);
+    }
+
     function scyToAsset(SCYIndex index, int256 scyAmount)
         internal
         pure

package/contracts/libraries/SCY/SCYUtils.sol

@@ -8,6 +8,14 @@ library SCYUtils {
         return (scyAmount * exchangeRate) / ONE;
     }
 
+    function scyToAssetUp(uint256 exchangeRate, uint256 scyAmount)
+        internal
+        pure
+        returns (uint256)
+    {
+        return (scyAmount * exchangeRate + ONE - 1) / ONE;
+    }
+
     function assetToScy(uint256 exchangeRate, uint256 assetAmount)
         internal
         pure
@@ -15,4 +23,12 @@ library SCYUtils {
     {
         return (assetAmount * ONE) / exchangeRate;
     }
+
+    function assetToScyUp(uint256 exchangeRate, uint256 assetAmount)
+        internal
+        pure
+        returns (uint256)
+    {
+        return (assetAmount * ONE + exchangeRate - 1) / exchangeRate;
+    }
 }

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