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

package/contracts/SuperComposableYield/SCY-implementations/AaveV3/PendleAaveV3SCY.sol

@@ -68,18 +68,6 @@ contract PendleAaveV3SCY is SCYBaseWithRewards {
         }
     }
 
-    function _updateYieldReserve() internal virtual override {
-        yieldTokenReserve = IAToken(aToken).scaledBalanceOf(address(this));
-    }
-
-    function _getFloatingAmount(address token) internal view virtual override returns (uint256) {
-        if (token != aToken) return _selfBalance(token) - rewardState[token].lastBalance;
-        // the only reserve token is aToken
-        uint256 scaledATokenAmount = IAToken(aToken).scaledBalanceOf(address(this)) -
-            yieldTokenReserve;
-        return _scaledBalanceToAToken(scaledATokenAmount);
-    }
-
     /*///////////////////////////////////////////////////////////////
                                EXCHANGE-RATE
     //////////////////////////////////////////////////////////////*/
@@ -123,6 +111,22 @@ contract PendleAaveV3SCY is SCYBaseWithRewards {
                             MISC FUNCTIONS FOR METADATA
     //////////////////////////////////////////////////////////////*/
 
+    function _previewDeposit(
+        address, /*tokenIn*/
+        uint256 amountTokenToDeposit
+    ) internal view override returns (uint256 amountSharesOut) {
+        // if tokenIn == aToken => convert aToken to scaledBalance
+        // if tokenIn == underlying => also convert aToken to scaledBalance since 1 aToken = 1 underlying
+        amountSharesOut = _aTokenToScaledBalance(amountTokenToDeposit);
+    }
+
+    function _previewRedeem(
+        address, /*tokenOut*/
+        uint256 amountSharesToRedeem
+    ) internal view override returns (uint256 amountTokenOut) {
+        amountTokenOut = _scaledBalanceToAToken(amountSharesToRedeem);
+    }
+
     function getBaseTokens() public view virtual override returns (address[] memory res) {
         res = new address[](2);
         res[0] = underlying;

package/contracts/SuperComposableYield/SCY-implementations/BenQi/PendleQiTokenHelper.sol

@@ -33,7 +33,7 @@ contract PendleQiTokenHelper {
             reservesPrior
         );
 
-        require(borrowRateMantissa <= borrowRateMantissa, "borrow rate is absurdly high");
+        require(borrowRateMantissa <= borrowRateMaxMantissa, "borrow rate is absurdly high");
 
         uint256 timestampDelta = currentBlockTimestamp - accrualBlockTimestampPrior;
 
@@ -43,8 +43,8 @@ contract PendleQiTokenHelper {
 
         uint256 totalBorrowsNew = interestAccumulated + borrowsPrior;
 
-        uint256 totalReservesNew = qiToken.reserveFactorMantissa() *
-            interestAccumulated +
+        uint256 totalReservesNew = (qiToken.reserveFactorMantissa() * interestAccumulated) /
+            1e18 +
             reservesPrior;
 
         return

package/contracts/SuperComposableYield/SCY-implementations/BenQi/PendleQiTokenSCY.sol

@@ -153,6 +153,26 @@ contract PendleQiTokenSCY is SCYBaseWithRewards, PendleQiTokenHelper {
                     MISC FUNCTIONS FOR METADATA
     //////////////////////////////////////////////////////////////*/
 
+    function _previewDeposit(address tokenIn, uint256 amountTokenToDeposit)
+        internal
+        view
+        override
+        returns (uint256 amountSharesOut)
+    {
+        if (tokenIn == qiToken) amountSharesOut = amountTokenToDeposit;
+        else amountSharesOut = (amountTokenToDeposit * 1e18) / exchangeRate();
+    }
+
+    function _previewRedeem(address tokenOut, uint256 amountSharesToRedeem)
+        internal
+        view
+        override
+        returns (uint256 amountTokenOut)
+    {
+        if (tokenOut == qiToken) amountTokenOut = amountSharesToRedeem;
+        else amountTokenOut = (amountSharesToRedeem * exchangeRate()) / 1e18;
+    }
+
     /**
      * @dev See {ISuperComposableYield-getBaseTokens}
      */

package/contracts/SuperComposableYield/SCY-implementations/PendleERC4626SCY.sol

@@ -75,6 +75,26 @@ contract PendleERC4626SCY is SCYBase {
                 MISC FUNCTIONS FOR METADATA
     //////////////////////////////////////////////////////////////*/
 
+    function _previewDeposit(address tokenIn, uint256 amountTokenToDeposit)
+        internal
+        view
+        override
+        returns (uint256 amountSharesOut)
+    {
+        if (tokenIn == yieldToken) amountSharesOut = amountTokenToDeposit;
+        else amountSharesOut = (amountTokenToDeposit * 1e18) / exchangeRate();
+    }
+
+    function _previewRedeem(address tokenOut, uint256 amountSharesToRedeem)
+        internal
+        view
+        override
+        returns (uint256 amountTokenOut)
+    {
+        if (tokenOut == yieldToken) amountTokenOut = amountSharesToRedeem;
+        else amountTokenOut = (amountSharesToRedeem * exchangeRate()) / 1e18;
+    }
+
     function getBaseTokens() public view virtual override returns (address[] memory res) {
         res = new address[](2);
         res[0] = underlying;

package/contracts/SuperComposableYield/SCY-implementations/PendleWstEthSCY.sol

@@ -77,6 +77,26 @@ contract PendleWstEthSCY is SCYBase {
                 MISC FUNCTIONS FOR METADATA
     //////////////////////////////////////////////////////////////*/
 
+    function _previewDeposit(address tokenIn, uint256 amountTokenToDeposit)
+        internal
+        view
+        override
+        returns (uint256 amountSharesOut)
+    {
+        if (tokenIn == wstETH) amountSharesOut = amountTokenToDeposit;
+        else amountSharesOut = (amountTokenToDeposit * 1e18) / exchangeRate();
+    }
+
+    function _previewRedeem(address tokenOut, uint256 amountSharesToRedeem)
+        internal
+        view
+        override
+        returns (uint256 amountTokenOut)
+    {
+        if (tokenOut == wstETH) amountTokenOut = amountSharesToRedeem;
+        else amountTokenOut = (amountSharesToRedeem * exchangeRate()) / 1e18;
+    }
+
     /**
      * @dev See {ISuperComposableYield-getBaseTokens}
      */

package/contracts/SuperComposableYield/SCY-implementations/PendleYearnVaultScy.sol

@@ -7,6 +7,7 @@ import "../../interfaces/IYearnVault.sol";
 contract PendleYearnVaultSCY is SCYBase {
     address public immutable underlying;
     address public immutable yvToken;
+    uint256 internal immutable yvTokenDecimals;
 
     constructor(
         string memory _name,
@@ -16,6 +17,7 @@ contract PendleYearnVaultSCY is SCYBase {
         require(_yvToken != address(0), "zero address");
         yvToken = _yvToken;
         underlying = IYearnVault(yvToken).token();
+        yvTokenDecimals = IYearnVault(yvToken).decimals();
         _safeApprove(underlying, yvToken, type(uint256).max);
     }
 
@@ -66,7 +68,7 @@ contract PendleYearnVaultSCY is SCYBase {
             uint256 sharesRedeemed = IYearnVault(yvToken).withdraw(amountSharesToRedeem);
 
             require(
-                sharesRedeemed != amountSharesToRedeem,
+                sharesRedeemed == amountSharesToRedeem,
                 "Yearn Vault SCY: Not allowed to redeem all shares"
             );
 
@@ -83,13 +85,38 @@ contract PendleYearnVaultSCY is SCYBase {
      * @dev It is the price per share of the yvToken
      */
     function exchangeRate() public view override returns (uint256) {
-        return IYearnVault(yvToken).pricePerShare();
+        uint256 price = IYearnVault(yvToken).pricePerShare();
+        if (yvTokenDecimals <= 18) {
+            return price * (10**(18 - yvTokenDecimals));
+        } else {
+            return price / (10**(yvTokenDecimals - 18));
+        }
     }
 
     /*///////////////////////////////////////////////////////////////
                 MISC FUNCTIONS FOR METADATA
     //////////////////////////////////////////////////////////////*/
 
+    function _previewDeposit(address tokenIn, uint256 amountTokenToDeposit)
+        internal
+        view
+        override
+        returns (uint256 amountSharesOut)
+    {
+        if (tokenIn == yvToken) amountSharesOut = amountTokenToDeposit;
+        else amountSharesOut = (amountTokenToDeposit * 1e18) / exchangeRate();
+    }
+
+    function _previewRedeem(address tokenOut, uint256 amountSharesToRedeem)
+        internal
+        view
+        override
+        returns (uint256 amountTokenOut)
+    {
+        if (tokenOut == yvToken) amountTokenOut = amountSharesToRedeem;
+        else amountTokenOut = (amountSharesToRedeem * exchangeRate()) / 1e18;
+    }
+
     /**
      * @dev See {ISuperComposableYield-getBaseTokens}
      */

package/contracts/SuperComposableYield/base-implementations/SCYBase.sol

@@ -14,13 +14,6 @@ abstract contract SCYBase is ISuperComposableYield, PendleERC20, TokenHelper {
 
     address public immutable yieldToken;
 
-    uint256 public yieldTokenReserve;
-
-    modifier updateYieldReserve() {
-        _;
-        _updateYieldReserve();
-    }
-
     constructor(
         string memory _name,
         string memory _symbol,
@@ -42,21 +35,20 @@ abstract contract SCYBase is ISuperComposableYield, PendleERC20, TokenHelper {
     function deposit(
         address receiver,
         address tokenIn,
-        uint256 amountTokenToPull,
+        uint256 amountTokenToDeposit,
         uint256 minSharesOut
-    ) external payable nonReentrant updateYieldReserve returns (uint256 amountSharesOut) {
+    ) external payable nonReentrant returns (uint256 amountSharesOut) {
         require(isValidBaseToken(tokenIn), "SCY: Invalid tokenIn");
+        require(amountTokenToDeposit != 0, "SCY: amountTokenToDeposit cannot be 0");
 
-        if (tokenIn == NATIVE) require(amountTokenToPull == 0, "can't pull eth");
-        else if (amountTokenToPull != 0) _transferIn(tokenIn, msg.sender, amountTokenToPull);
+        if (tokenIn == NATIVE) require(msg.value == amountTokenToDeposit, "SCY: eth mismatch");
+        else _transferIn(tokenIn, msg.sender, amountTokenToDeposit);
 
-        uint256 amountDeposited = _getFloatingAmount(tokenIn);
-
-        amountSharesOut = _deposit(tokenIn, amountDeposited);
-        require(amountSharesOut >= minSharesOut, "insufficient out");
+        amountSharesOut = _deposit(tokenIn, amountTokenToDeposit);
+        require(amountSharesOut >= minSharesOut, "SCY: insufficient out");
 
         _mint(receiver, amountSharesOut);
-        emit Deposit(msg.sender, receiver, tokenIn, amountDeposited, amountSharesOut);
+        emit Deposit(msg.sender, receiver, tokenIn, amountTokenToDeposit, amountSharesOut);
     }
 
     /**
@@ -64,22 +56,36 @@ abstract contract SCYBase is ISuperComposableYield, PendleERC20, TokenHelper {
      */
     function redeem(
         address receiver,
-        uint256 amountSharesToPull,
+        uint256 amountSharesToRedeem,
         address tokenOut,
         uint256 minTokenOut
-    ) external nonReentrant updateYieldReserve returns (uint256 amountTokenOut) {
-        require(isValidBaseToken(tokenOut), "SCY: invalid tokenOut");
+    ) external nonReentrant returns (uint256 amountTokenOut) {
+        _burn(msg.sender, amountSharesToRedeem);
+        amountTokenOut = _redeem(receiver, amountSharesToRedeem, tokenOut, minTokenOut);
+    }
 
-        if (amountSharesToPull != 0) {
-            _transfer(msg.sender, address(this), amountSharesToPull);
-        }
+    function redeemAfterTransfer(
+        address receiver,
+        address tokenOut,
+        uint256 minTokenOut
+    ) external nonReentrant returns (uint256 amountTokenOut) {
+        uint256 amountSharesToRedeem = balanceOf(address(this));
+        _burn(address(this), amountSharesToRedeem);
+        amountTokenOut = _redeem(receiver, amountSharesToRedeem, tokenOut, minTokenOut);
+    }
 
-        uint256 amountSharesToRedeem = _getFloatingAmount(address(this));
+    function _redeem(
+        address receiver,
+        uint256 amountSharesToRedeem,
+        address tokenOut,
+        uint256 minTokenOut
+    ) internal returns (uint256 amountTokenOut) {
+        require(isValidBaseToken(tokenOut), "SCY: invalid tokenOut");
+        require(amountSharesToRedeem != 0, "SCY: amountSharesToRedeem cannot be 0");
 
         amountTokenOut = _redeem(tokenOut, amountSharesToRedeem);
-        require(amountTokenOut >= minTokenOut, "insufficient out");
+        require(amountTokenOut >= minTokenOut, "SCY: insufficient out");
 
-        _burn(address(this), amountSharesToRedeem);
         _transferOut(tokenOut, receiver, amountTokenOut);
 
         emit Redeem(msg.sender, receiver, tokenOut, amountSharesToRedeem, amountTokenOut);
@@ -107,22 +113,6 @@ abstract contract SCYBase is ISuperComposableYield, PendleERC20, TokenHelper {
         virtual
         returns (uint256 amountTokenOut);
 
-    /**
-     * @notice updates the amount of yield token reserves in this contract
-     */
-    function _updateYieldReserve() internal virtual {
-        yieldTokenReserve = _selfBalance(yieldToken);
-    }
-
-    /**
-     * @notice returns the amount of unprocessed tokens owned by this contract
-     * @param token address of the token to be queried
-     */
-    function _getFloatingAmount(address token) internal view virtual returns (uint256) {
-        if (token != yieldToken) return _selfBalance(token);
-        return _selfBalance(token) - yieldTokenReserve;
-    }
-
     /*///////////////////////////////////////////////////////////////
                                EXCHANGE-RATE
     //////////////////////////////////////////////////////////////*/
@@ -185,6 +175,38 @@ abstract contract SCYBase is ISuperComposableYield, PendleERC20, TokenHelper {
                 MISC METADATA FUNCTIONS
     //////////////////////////////////////////////////////////////*/
 
+    function previewDeposit(address tokenIn, uint256 amountTokenToDeposit)
+        external
+        view
+        virtual
+        returns (uint256 amountSharesOut)
+    {
+        require(isValidBaseToken(tokenIn), "SCY: Invalid tokenIn");
+        return _previewDeposit(tokenIn, amountTokenToDeposit);
+    }
+
+    function previewRedeem(address tokenOut, uint256 amountSharesToRedeem)
+        external
+        view
+        virtual
+        returns (uint256 amountTokenOut)
+    {
+        require(isValidBaseToken(tokenOut), "SCY: Invalid tokenOut");
+        return _previewRedeem(tokenOut, amountSharesToRedeem);
+    }
+
+    function _previewDeposit(address tokenIn, uint256 amountTokenToDeposit)
+        internal
+        view
+        virtual
+        returns (uint256 amountSharesOut);
+
+    function _previewRedeem(address tokenOut, uint256 amountSharesToRedeem)
+        internal
+        view
+        virtual
+        returns (uint256 amountTokenOut);
+
     /**
      * @notice See {ISuperComposableYield-getBaseTokens}
      */

package/contracts/SuperComposableYield/base-implementations/SCYBaseWithRewards.sol

@@ -20,13 +20,6 @@ abstract contract SCYBaseWithRewards is SCYBase, RewardManager {
         SCYBase(_name, _symbol, _yieldToken) // solhint-disable-next-line no-empty-blocks
     {}
 
-    function _getFloatingAmount(address token) internal view virtual override returns (uint256) {
-        // there are only 2 type of tokens stored in the contract: yieldToken & rewardToken. Since
-        // this is not yield, it must be reward
-        if (token != yieldToken) return _selfBalance(token) - rewardState[token].lastBalance;
-        return _selfBalance(token) - yieldTokenReserve;
-    }
-
     /*///////////////////////////////////////////////////////////////
                                REWARDS-RELATED
     //////////////////////////////////////////////////////////////*/

package/contracts/core/LiquidityMining/GaugeController/PendleGaugeControllerBaseUpg.sol

@@ -35,7 +35,7 @@ abstract contract PendleGaugeControllerBaseUpg is IPGaugeController, Permissions
         uint128 incentiveEndsAt;
     }
 
-    uint128 public constant WEEK = 1 weeks;
+    uint128 internal constant WEEK = 1 weeks;
 
     address public immutable pendle;
     IPMarketFactory public immutable marketFactory;

package/contracts/core/LiquidityMining/PendleGauge.sol

@@ -9,6 +9,10 @@ import "../../libraries/math/Math.sol";
 import "../../libraries/helpers/ArrayLib.sol";
 import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
 
+/**
+Invariants to maintain:
+- before any changes to active balance, updateAndDistributeRewards() must be called
+ */
 abstract contract PendleGauge is RewardManager {
     using Math for uint256;
     using SafeERC20 for IERC20;
@@ -17,10 +21,10 @@ abstract contract PendleGauge is RewardManager {
     address private immutable SCY;
 
     uint256 internal constant TOKENLESS_PRODUCTION = 40;
-    address internal immutable PENDLE;
 
-    IPVeToken public immutable vePENDLE;
-    address public immutable gaugeController;
+    address internal immutable PENDLE;
+    IPVeToken internal immutable vePENDLE;
+    address internal immutable gaugeController;
 
     uint256 public totalActiveSupply;
     mapping(address => uint256) public activeBalance;
@@ -37,7 +41,9 @@ abstract contract PendleGauge is RewardManager {
     }
 
     /**
-     * @dev It is intended to have user's active balance updated when they try to redeem
+     * @dev Since rewardShares is based on activeBalance, user's activeBalance must be updated AFTER
+        rewards is updated
+     * @dev It's intended to have user's activeBalance updated when rewards is redeemed
      */
     function _redeemRewards(address user) internal virtual returns (uint256[] memory) {
         _updateAndDistributeRewards(user);
@@ -45,10 +51,21 @@ abstract contract PendleGauge is RewardManager {
         return _doTransferOutRewards(user, user);
     }
 
+    function _updateUserActiveBalance(address user) internal virtual {
+        _updateUserActiveBalanceForTwo(user, address(0));
+    }
+
+    function _updateUserActiveBalanceForTwo(address user1, address user2) internal virtual {
+        if (user1 != address(0) && user1 != address(this)) _updateUserActiveBalancePrivate(user1);
+        if (user2 != address(0) && user2 != address(this)) _updateUserActiveBalancePrivate(user2);
+    }
+
     /**
-     * @dev since rewardShares will be modified after this function, it should update user reward beforehand
+     * @dev should only be callable from `_updateUserActiveBalanceForTwo` to guarantee user != address(0) && user != address(this)
      */
-    function _updateUserActiveBalance(address user) internal virtual {
+    function _updateUserActiveBalancePrivate(address user) private {
+        assert(user != address(0) && user != address(this));
+
         uint256 lpBalance = _stakedBalance(user);
         uint256 veBoostedLpBalance = _calcVeBoostedLpBalance(user, lpBalance);
 
@@ -112,7 +129,6 @@ abstract contract PendleGauge is RewardManager {
         address to,
         uint256
     ) internal virtual {
-        if (from != address(0) && from != address(this)) _updateUserActiveBalance(from);
-        if (to != address(0) && to != address(this)) _updateUserActiveBalance(to);
+        _updateUserActiveBalanceForTwo(from, to);
     }
 }