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

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

package/contracts/core/LiquidityMining/VotingController/PendleVotingControllerUpg.sol

@@ -59,98 +59,90 @@ contract PendleVotingControllerUpg is
     //////////////////////////////////////////////////////////////*/
 
     /**
-     * @notice set a new voting weight for the target pool
-     * @dev pre-condition:
-        - pool must have been added before
-        - the vePENDLE position must still be active
      * @dev state changes expected:
         - update weekData (if any)
-        - update poolInfo, userData to reflect the new vote
-        - add 1 check point for both the unvote & new vote
+        - update poolData, userData to reflect the new vote
+        - add 1 check point for each of pools
      * @dev vePENDLE position not expired is a must, else bias - t*slope < 0 & it will be
         negative weight
      */
-    function vote(address pool, uint64 weight) external {
+    function vote(address[] calldata pools, uint64[] calldata weights) external {
         address user = msg.sender;
 
-        require(weight != 0, "zero weight");
-        require(_isPoolVotable(pool), "invalid pool");
-        require(!vePendle.isPositionExpired(user), "user position expired");
+        require(weights.length == pools.length, "invaid array length");
+        require(vePendle.balanceOf(user) > 0, "zero vependle balance");
 
-        updatePoolVotes(pool);
-        _unvote(user, pool, false);
-        _vote(user, pool, weight);
-    }
+        UserData storage uData = userData[user];
 
-    /**
-     * @notice remove the vote from the current pool
-     * @dev no pre-condition as opposed to vote since this function is to clear the vote
-     * @dev allow removing vote from a non-votable pool BY not requiring pool to be votable
-     * @dev state changes expected:
-        - update weekData (if any)
-        - update poolInfo, userData to reflect the new vote
-        - add 1 check point for the unvote
-     */
-    function unvote(address pool) external {
-        if (_isPoolVotable(pool)) {
-            updatePoolVotes(pool);
+        for (uint256 i = 0; i < pools.length; ++i) {
+            if (_isPoolActive(pools[i])) applyPoolSlopeChanges(pools[i]);
+        }
+
+        for (uint256 i = 0; i < pools.length; ++i) {
+            if (uData.voteForPools[pools[i]].weight <= weights[i])
+                _modifyVoteWeight(user, pools[i], weights[i]);
+        }
+
+        for (uint256 i = 0; i < pools.length; ++i) {
+            if (uData.voteForPools[pools[i]].weight > weights[i])
+                _modifyVoteWeight(user, pools[i], weights[i]);
         }
-        _unvote(msg.sender, pool, true);
     }
 
     /**
      * @notice Process all the slopeChanges that haven't been processed & update these data into
-        poolInfo
-     * @dev pre-condition: the pool must be votable
+        poolData
+     * @dev pre-condition: the pool must be active
      * @dev state changes expected:
         - update weekData
-        - update poolInfo
+        - update poolData
      */
-    function updatePoolVotes(address pool) public {
-        require(_isPoolVotable(pool), "invalid pool");
+    function applyPoolSlopeChanges(address pool) public {
+        require(_isPoolActive(pool), "invalid pool");
 
-        uint128 wTime = poolInfo[pool].lastUpdated;
+        uint128 wTime = poolData[pool].lastSlopeChangeAppliedAt;
         uint128 currentWeekStart = WeekMath.getCurrentWeekStart();
 
         // no state changes are expected
         if (wTime >= currentWeekStart) return;
 
-        VeBalance memory currentVote = poolInfo[pool].vote;
+        VeBalance memory currentVote = poolData[pool].totalVote;
         while (wTime < currentWeekStart) {
             wTime += WEEK;
-            currentVote = currentVote.sub(poolInfo[pool].slopeChanges[wTime], wTime);
+            currentVote = currentVote.sub(poolData[pool].slopeChanges[wTime], wTime);
             _setFinalPoolVoteForWeek(pool, wTime, currentVote.getValueAt(wTime));
         }
 
-        _setNewVotePoolInfo(pool, currentVote, wTime);
+        _setNewVotePoolData(pool, currentVote, wTime);
     }
 
     /**
      * @notice finalize the voting results of all pools, up to the current epoch
      * @dev state changes expected:
-        - weekData, poolInfo is updated for all pools in allPools
+        - weekData, poolData is updated for all pools in allActivePools
         - isEpochFinalized is set to true for all epochs since the last time until now
-     * @dev this function might take a lot of gas, but can be mitigated by calling updatePoolVotes
+     * @dev this function might take a lot of gas, but can be mitigated by calling applyPoolSlopeChanges
         separately, hence reduce the number of states to be updated
      */
     function finalizeEpoch() public {
-        uint256 length = allPools.length();
+        uint256 length = allActivePools.length();
         for (uint256 i = 0; i < length; ++i) {
-            updatePoolVotes(allPools.at(i));
+            applyPoolSlopeChanges(allActivePools.at(i));
         }
         _setAllPastEpochsAsFinalized();
     }
 
     /**
      * @notice broadcast the voting results of the current week to the chain with chainId. Can be
-        called by anyone
+        called by anyone. It's intentional to allow the same results to be broadcasted multiple
+        times. The receiver should be able to filter these duplicated messages
      * @dev pre-condition: the epoch must have already been finalized by finalizeEpoch
      * @dev state changes expected:
         - the gaugeController receives the new pendle allocation
      */
     function broadcastResults(uint64 chainId) external payable {
         uint128 wTime = WeekMath.getCurrentWeekStart();
-        require(isEpochFinalized[wTime], "epoch not finalized");
+        require(weekData[wTime].isEpochFinalized, "epoch not finalized");
         _broadcastResults(chainId, wTime, pendlePerSec);
     }
 
@@ -163,11 +155,13 @@ contract PendleVotingControllerUpg is
      * @dev pre-condition: pool must not have been added before
      * @dev assumption: chainId is valid, pool does exist on the chain (guaranteed by gov)
      * @dev state changes expected:
-        - add to allPools & chainPools
-        - set params in poolInfo
+        - add to allActivePools & chainPools
+        - set params in poolData
      */
     function addPool(uint64 chainId, address pool) external onlyGovernance {
-        require(!_isPoolVotable(pool), "pool already added");
+        require(!_isPoolActive(pool), "pool already added");
+        require(!allRemovedPools.contains(pool), "not allowed to add a removed pool");
+
         _addPool(chainId, pool);
         emit AddPool(chainId, pool);
     }
@@ -177,14 +171,15 @@ contract PendleVotingControllerUpg is
      * @dev pre-condition: pool must have been added before
      * @dev state changes expected:
         - update weekData (if any)
-        - remove from allPools & chainPools
-        - clear info in poolInfo
+        - remove from allActivePools & chainPools
+        - clear data in poolData
      */
     function removePool(address pool) external onlyGovernance {
-        require(_isPoolVotable(pool), "invalid pool");
-        uint64 chainId = poolInfo[pool].chainId;
+        require(_isPoolActive(pool), "invalid pool");
+
+        uint64 chainId = poolData[pool].chainId;
 
-        updatePoolVotes(pool);
+        applyPoolSlopeChanges(pool);
         _removePool(pool);
 
         emit RemovePool(chainId, pool);
@@ -222,7 +217,7 @@ contract PendleVotingControllerUpg is
 
     /**
      * @notice broadcast voting results of the timestamp to chainId
-     * @dev assumption: the epoch is already finalized, lastUpdated of all pools >= currentWeekTimestamp
+     * @dev assumption: the epoch is already finalized, lastSlopeChangeAppliedAt of all pools >= currentWeekTimestamp
      * @dev state changes expected:
         - the gaugeController receives the new pendle allocation
      */
@@ -260,51 +255,6 @@ contract PendleVotingControllerUpg is
         emit BroadcastResults(chainId, wTime, totalPendlePerSec);
     }
 
-    /**
-     * @notice remove the vote from the current pool
-     * @dev state changes expected:
-        - vote in poolInfo is cleared if the vote is still valid
-        - update UserData to remove the vote weight
-        - add a check-point if required
-     */
-    function _unvote(
-        address user,
-        address pool,
-        bool doCreateCheckpoint
-    ) internal {
-        VeBalance memory oldUVote = userData[user].voteForPools[pool].vote;
-        if (_isPoolVotable(pool) && _isVoteActive(oldUVote)) {
-            _subtractVotePoolInfo(pool, oldUVote);
-        }
-        _unsetVoteUserData(user, pool);
-
-        if (doCreateCheckpoint) {
-            _addUserPoolCheckpoint(user, pool, VeBalance(0, 0));
-        }
-        emit Unvote(user, pool, oldUVote);
-    }
-
-    /**
-     * @notice remove the vote from the current pool
-     * @dev there must not be any current vote on this pool by the user
-     * @dev state changes expected:
-        - vote in poolInfo is added
-        - update UserData to set the new vote weight
-        - add a check-point
-     */
-    function _vote(
-        address user,
-        address pool,
-        uint64 weight
-    ) internal {
-        VeBalance memory votingPower = _getVotingPowerByWeight(user, weight);
-        _addVotePoolInfo(pool, votingPower);
-        _setVoteUserData(user, pool, weight, votingPower);
-        _addUserPoolCheckpoint(user, pool, votingPower);
-
-        emit Vote(user, pool, weight, votingPower);
-    }
-
     /**
      * @notice return the corresponding voting power of an user given the weight. Basically his voting power
         will be vePendle * weight / USER_VOTE_MAX_WEIGHT
@@ -314,6 +264,7 @@ contract PendleVotingControllerUpg is
         internal
         view
         virtual
+        override
         returns (VeBalance memory res)
     {
         uint128 amount;