@pendle/core-v2 0.17.5-testnet → 0.17.7-testnet

package/contracts/LiquidityMining/VotingController/VotingControllerStorageUpg.sol

@@ -13,10 +13,6 @@ import "../../core/libraries/Errors.sol";
 
 import "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
 
-/// This contract is upgradable because
-/// - its constructor only sets immutable variables
-/// - it has storage gaps for safe addition of future variables
-/// - it inherits only upgradable contract
 abstract contract VotingControllerStorageUpg is IPVotingController {
     using VeBalanceLib for VeBalance;
     using VeBalanceLib for LockedPosition;
@@ -50,7 +46,7 @@ abstract contract VotingControllerStorageUpg is IPVotingController {
 
     uint128 public constant MAX_LOCK_TIME = 104 weeks;
     uint128 public constant WEEK = 1 weeks;
-    uint128 public constant GOVERNANCE_PENDLE_VOTE = 10**24;
+    uint128 public constant GOVERNANCE_PENDLE_VOTE = 10 * (10**6) * (10**18); // 10 mils of PENDLE
 
     IPVeToken public immutable vePendle;
 
@@ -147,12 +143,10 @@ abstract contract VotingControllerStorageUpg is IPVotingController {
         for (uint256 i = 0; i < pools.length; ++i) poolVotes[i] = data.poolVotes[pools[i]];
     }
 
-    /// @dev trivial view function
     function getAllActivePools() external view returns (address[] memory) {
         return allActivePools.values();
     }
 
-    /// @dev trivial view function
     function getAllRemovedPools(uint256 start, uint256 end)
         external
         view
@@ -166,12 +160,10 @@ abstract contract VotingControllerStorageUpg is IPVotingController {
         for (uint256 i = start; i <= end; ++i) arr[i - start] = allRemovedPools.at(i);
     }
 
-    /// @dev trivial view function
     function getActiveChainPools(uint64 chainId) external view returns (address[] memory) {
         return activeChainPools[chainId].values();
     }
 
-    /// @dev trivial view function
     function getUserPoolVote(address user, address pool)
         external
         view
@@ -193,14 +185,9 @@ abstract contract VotingControllerStorageUpg is IPVotingController {
     }
 
     /*///////////////////////////////////////////////////////////////
-                            INTERNAL DATA MANIPULATION FUNCTIONS
+                INTERNAL DATA MANIPULATION FUNCTIONS
     //////////////////////////////////////////////////////////////*/
 
-    /**
-    * @dev expected behavior:
-        - add to allActivePools, activeChainPools
-        - set params in poolData
-     */
     function _addPool(uint64 chainId, address pool) internal {
         if (!activeChainPools[chainId].add(pool)) assert(false);
         if (!allActivePools.add(pool)) assert(false);
@@ -209,12 +196,6 @@ abstract contract VotingControllerStorageUpg is IPVotingController {
         poolData[pool].lastSlopeChangeAppliedAt = WeekMath.getCurrentWeekStart();
     }
 
-    /**
-    * @dev expected behavior:
-        - remove from allActivePool, activeChainPools
-        - add to allRemovedPools
-        - clear all params in poolData
-     */
     function _removePool(address pool) internal {
         uint64 chainId = poolData[pool].chainId;
         if (!activeChainPools[chainId].remove(pool)) assert(false);
@@ -224,10 +205,6 @@ abstract contract VotingControllerStorageUpg is IPVotingController {
         delete poolData[pool];
     }
 
-    /**
-     * @notice set the final pool vote for weekData
-     * @dev assumption: weekData[wTime].poolVotes[pool] == 0
-     */
     function _setFinalPoolVoteForWeek(
         address pool,
         uint128 wTime,
@@ -247,6 +224,10 @@ abstract contract VotingControllerStorageUpg is IPVotingController {
         emit PoolVoteChange(pool, vote);
     }
 
+    /**
+     * @notice modifies `user`'s vote weight on `pool`
+     * @dev works by simply removing the old vote position, then adds in a fresh vote
+     */
     function _modifyVoteWeight(
         address user,
         address pool,

package/contracts/LiquidityMining/VotingEscrow/VotingEscrowPendleMainchain.sol

@@ -66,14 +66,14 @@ contract VotingEscrowPendleMainchain is
     }
 
     /**
-     * @notice increase the lock position of an user. Applicable even when user has no position or the
-        current position has expired
-     * @dev expected state changes:
-        - a new lock with amount = amountToPull + amountExpired, expiry = expiry is created for msg.sender in positionData
-        - pendle is taken in if necessary
-        - _totalSupply, lastSlopeChangeAppliedAt, slopeChanges, totalSupplyAt is updated
-        - a checkpoint is added
-     * @dev broadcast is not bundled since it can be done anytime after
+     * @notice increases the lock position of a user (amount and/or expiry). Applicable even when
+     * user has no position or the current position has expired.
+     * @param additionalAmountToLock pendle amount to be pulled in from user to lock.
+     * @param newExpiry new lock expiry. Must be a valid week beginning, and resulting lock
+     * duration (since `block.timestamp`) must be within the allowed range.
+     * @dev Will revert if resulting position has zero lock amount.
+     * @dev See `_increasePosition()` for details on inner workings.
+     * @dev Sidechain broadcasting is not bundled since it can be done anytime after.
      */
     function increaseLockPosition(uint128 additionalAmountToLock, uint128 newExpiry)
         public
@@ -104,13 +104,8 @@ contract VotingEscrowPendleMainchain is
     }
 
     /**
-     * @notice withdraw an expired lock position, get back all locked PENDLE
-     * @dev expected state changes:
-        - positionData is cleared
-        - pendle is transferred out
-        - _totalSupply, lastSlopeChangeAppliedAt, slopeChanges, totalSupplyAt all doesn't need to be updated
-            since these data will automatically hold true when _applySlopeChange() is called
-        - no checkpoint is added
+     * @notice Withdraws an expired lock position, returns locked PENDLE back to user
+     * @dev reverts if position is not expired, or if no locked PENDLE to withdraw
      * @dev broadcast is not bundled since it can be done anytime after
      */
     function withdraw() external returns (uint128 amount) {
@@ -129,9 +124,8 @@ contract VotingEscrowPendleMainchain is
     }
 
     /**
-     * @notice update & return the current totalSupply
-     * @dev state changes expected:
-        - _totalSupply & lastSlopeChangeAppliedAt is updated
+     * @notice update & return the current totalSupply, but does not broadcast info to other chains
+     * @dev See `broadcastTotalSupply()` and `broadcastUserPosition()` for broadcasting
      */
     function totalSupplyCurrent()
         public
@@ -143,19 +137,14 @@ contract VotingEscrowPendleMainchain is
         return supply.getCurrentValue();
     }
 
-    /**
-     * @notice broadcast the totalSupply to different chains
-     * @dev state changes expected:
-        - all chains in chainIds receive the new totalSupply
-     */
+    /// @notice updates and broadcast the current totalSupply to different chains
     function broadcastTotalSupply(uint256[] calldata chainIds) public payable refundUnusedEth {
         _broadcastPosition(address(0), chainIds);
     }
 
     /**
-     * @notice broadcast the position of users to different chains
-     * @dev state changes expected:
-        - all chains in chainIds receive the new totalSupply & user's new position
+     * @notice updates and broadcast the position of `user` to different chains, also updates and
+     * broadcasts totalSupply
      */
     function broadcastUserPosition(address user, uint256[] calldata chainIds)
         public
@@ -200,13 +189,8 @@ contract VotingEscrowPendleMainchain is
 
     /**
      * @notice increase the locking position of the user
-     * @dev it works by simply removing the old position from all relevant data (as if the user has never locked) and
-        then add in the new position
-      * @dev expected state changes:
-        - a new lock with the amount & expiry increase accordingly
-        - pendle is taken in if necessary
-        - _totalSupply, lastSlopeChangeAppliedAt, slopeChanges, totalSupplyAt is updated
-        - a checkpoint is added
+     * @dev works by simply removing the old position from all relevant data (as if the user has
+     * never locked) and then add in the new position
      */
     function _increasePosition(
         address user,
@@ -241,10 +225,8 @@ contract VotingEscrowPendleMainchain is
     }
 
     /**
-     * @notice update the totalSupply, processing all slope changes of past weeks. At the same time, set the finalized
-        totalSupplyAt
-     * @dev state changes expected:
-        - _totalSupply, lastSlopeChangeAppliedAt, totalSupplyAt is updated
+     * @notice updates the totalSupply, processing all slope changes of past weeks. At the same time,
+     * set the finalized totalSupplyAt
      */
     function _applySlopeChange() internal returns (VeBalance memory, uint128) {
         VeBalance memory supply = _totalSupply;
@@ -271,7 +253,7 @@ contract VotingEscrowPendleMainchain is
     function _broadcastPosition(address user, uint256[] calldata chainIds) internal {
         if (chainIds.length == 0) revert Errors.ArrayEmpty();
 
-        (VeBalance memory supply,) = _applySlopeChange();
+        (VeBalance memory supply, ) = _applySlopeChange();
 
         bytes memory userData = (
             user == address(0) ? EMPTY_BYTES : abi.encode(user, positionData[user])

package/contracts/LiquidityMining/libraries/VeHistoryLib.sol

@@ -1,4 +1,4 @@
-// SPDX-License-Identifier: MIT
+// SPDX-License-Identifier: GPL-3.0-or-later
 // Forked from OpenZeppelin (v4.5.0) (utils/Checkpoints.sol)
 pragma solidity ^0.8.0;
 

package/contracts/core/BulkSeller/BulkSeller.sol

@@ -18,29 +18,6 @@ contract BulkSeller is IPBulkSeller, Initializable, TokenHelper, ReentrancyGuard
     using SafeERC20 for IERC20;
     using BulkSellerMathCore for BulkSellerState;
 
-    event SwapExactTokenForSy(address receiver, uint256 netTokenIn, uint256 netSyOut);
-    event SwapExactSyForToken(address receiver, uint256 netSyIn, uint256 netTokenOut);
-    event RateUpdated(
-        uint256 newRateTokenToSy,
-        uint256 newRateSyToToken,
-        uint256 oldRateTokenToSy,
-        uint256 oldRateSyToToken
-    );
-    event ReBalanceTokenToSy(
-        uint256 netTokenDeposit,
-        uint256 netSyFromToken,
-        uint256 newTokenProp,
-        uint256 oldTokenProp
-    );
-    event ReBalanceSyToToken(
-        uint256 netSyRedeem,
-        uint256 netTokenFromSy,
-        uint256 newTokenProp,
-        uint256 oldTokenProp
-    );
-    event ReserveUpdated(uint256 totalToken, uint256 totalSy);
-    event FeeRateUpdated(uint256 newFeeRate, uint256 oldFeeRate);
-
     struct BulkSellerStorage {
         uint128 rateTokenToSy;
         uint128 rateSyToToken;
@@ -61,11 +38,6 @@ contract BulkSeller is IPBulkSeller, Initializable, TokenHelper, ReentrancyGuard
         _;
     }
 
-    modifier onlyAdmin() {
-        if (!IPBulkSellerFactory(factory).isAdmin(msg.sender)) revert Errors.BulkNotAdmin();
-        _;
-    }
-
     // Since this contract is a beacon contract, no constructor should be defined.
     function initialize(
         address _token,
@@ -76,46 +48,52 @@ contract BulkSeller is IPBulkSeller, Initializable, TokenHelper, ReentrancyGuard
         token = _token;
         SY = _SY;
         factory = _factory;
+        _safeApproveInf(token, SY);
     }
 
     function swapExactTokenForSy(
         address receiver,
         uint256 netTokenIn,
         uint256 minSyOut
-    ) external nonReentrant returns (uint256 netSyOut) {
+    ) external payable nonReentrant returns (uint256 netSyOut) {
         BulkSellerState memory state = readState();
 
+        _transferIn(token, msg.sender, netTokenIn);
+
         netSyOut = state.swapExactTokenForSy(netTokenIn);
 
         if (netSyOut < minSyOut) revert Errors.BulkInSufficientSyOut(netSyOut, minSyOut);
 
-        if (receiver != address(this)) _transferOut(SY, receiver, netSyOut);
+        _transferOut(SY, receiver, netSyOut);
 
         _writeState(state);
 
-        if (_selfBalance(token) < state.totalToken)
-            revert Errors.BulkInsufficientTokenReceived(_selfBalance(token), state.totalToken);
-
         emit SwapExactTokenForSy(receiver, netTokenIn, netSyOut);
     }
 
     function swapExactSyForToken(
         address receiver,
         uint256 exactSyIn,
-        uint256 minTokenOut
+        uint256 minTokenOut,
+        bool swapFromInternalBalance
     ) external nonReentrant returns (uint256 netTokenOut) {
         BulkSellerState memory state = readState();
 
+        if (!swapFromInternalBalance) _transferIn(SY, msg.sender, exactSyIn);
+        else {
+            uint256 netSyReceived = _selfBalance(SY) - state.totalSy;
+            if (netSyReceived < exactSyIn)
+                revert Errors.BulkInsufficientSyReceived(exactSyIn, netSyReceived);
+        }
+
         netTokenOut = state.swapExactSyForToken(exactSyIn);
 
         if (netTokenOut < minTokenOut)
             revert Errors.BulkInSufficientTokenOut(netTokenOut, minTokenOut);
-        if (receiver != address(this)) _transferOut(token, receiver, netTokenOut);
 
-        _writeState(state);
+        _transferOut(token, receiver, netTokenOut);
 
-        if (_selfBalance(SY) < state.totalSy)
-            revert Errors.BulkInsufficientSyReceived(_selfBalance(SY), state.totalSy);
+        _writeState(state);
 
         emit SwapExactSyForToken(receiver, exactSyIn, netTokenOut);
     }
@@ -159,7 +137,7 @@ contract BulkSeller is IPBulkSeller, Initializable, TokenHelper, ReentrancyGuard
         _writeState(state);
     }
 
-    function decreaseReserve(uint256 netTokenOut, uint256 netSyOut) external onlyAdmin {
+    function decreaseReserve(uint256 netTokenOut, uint256 netSyOut) external onlyMaintainer {
         BulkSellerState memory state = readState();
 
         if (netTokenOut == type(uint256).max) netTokenOut = state.totalToken;
@@ -176,6 +154,24 @@ contract BulkSeller is IPBulkSeller, Initializable, TokenHelper, ReentrancyGuard
         _writeState(state);
     }
 
+    function redeemRewards() external onlyMaintainer {
+        IStandardizedYield(SY).claimRewards(address(this));
+        address[] memory rewardTokens = IStandardizedYield(SY).getRewardTokens();
+
+        for (uint256 i = 0; i < rewardTokens.length; i++) {
+            if (rewardTokens[i] == token) continue;
+            _transferOut(rewardTokens[i], msg.sender, _selfBalance(rewardTokens[i]));
+        }
+    }
+
+    function skim() external onlyMaintainer {
+        BulkSellerState memory state = readState();
+        uint256 excessToken = _selfBalance(token) - state.totalToken;
+        uint256 excessSy = _selfBalance(SY) - state.totalSy;
+        if (excessToken != 0) IERC20(token).safeTransfer(msg.sender, excessToken);
+        if (excessSy != 0) IERC20(SY).safeTransfer(msg.sender, excessSy);
+    }
+
     function reBalance(uint256 targetProp, uint256 maxDiff) external onlyMaintainer {
         BulkSellerState memory state = readState();
         uint256 oldTokenProp = state.getTokenProp();
@@ -224,7 +220,6 @@ contract BulkSeller is IPBulkSeller, Initializable, TokenHelper, ReentrancyGuard
     }
 
     function _depositToken(uint256 netTokenDeposit) internal returns (uint256 netSyFromToken) {
-        _safeApprove(token, SY, netTokenDeposit);
         uint256 nativeToDeposit = token == NATIVE ? netTokenDeposit : 0;
         return
             IStandardizedYield(SY).deposit{ value: nativeToDeposit }(
@@ -239,6 +234,4 @@ contract BulkSeller is IPBulkSeller, Initializable, TokenHelper, ReentrancyGuard
         _transferOut(SY, SY, netSyRedeem);
         return IStandardizedYield(SY).redeem(address(this), netSyRedeem, token, 0, true);
     }
-
-    receive() external payable {}
 }

package/contracts/core/BulkSeller/BulkSellerFactory.sol

@@ -25,8 +25,8 @@ contract BulkSellerFactory is
 
     mapping(address => mapping(address => address)) internal syToBulkSeller;
 
-    modifier onlyAdmin() {
-        if (!isAdmin(msg.sender)) revert Errors.BulkNotAdmin();
+    modifier onlyMaintainer() {
+        if (!isMaintainer(msg.sender)) revert Errors.BulkNotMaintainer();
         _;
     }
 
@@ -39,7 +39,7 @@ contract BulkSellerFactory is
 
     function createBulkSeller(address token, address SY)
         external
-        onlyAdmin
+        onlyMaintainer
         returns (address bulk)
     {
         IStandardizedYield _SY = IStandardizedYield(SY);
@@ -72,12 +72,8 @@ contract BulkSellerFactory is
         return (hasRole(DEFAULT_ADMIN_ROLE, addr) || hasRole(MAINTAINER, addr));
     }
 
-    function isAdmin(address addr) public view override returns (bool) {
-        return hasRole(DEFAULT_ADMIN_ROLE, addr);
-    }
-
     // ----------------- upgrade-related -----------------
-    function upgradeBeacon(address newImplementation) public onlyAdmin {
+    function upgradeBeacon(address newImplementation) public onlyMaintainer {
         require(
             AddressUpgradeable.isContract(newImplementation),
             "UpgradeableBeacon: implementation is not a contract"
@@ -86,5 +82,5 @@ contract BulkSellerFactory is
         emit UpgradedBeacon(newImplementation);
     }
 
-    function _authorizeUpgrade(address) internal override onlyAdmin {}
+    function _authorizeUpgrade(address) internal override onlyMaintainer {}
 }

package/contracts/core/BulkSeller/BulkSellerMathCore.sol

@@ -76,13 +76,14 @@ library BulkSellerMathCore {
         uint256 currentTokenProp = getTokenProp(state);
 
         if (currentTokenProp > targetTokenProp) {
-            netTokenToDeposit = state.totalToken.mulDown(
-                (currentTokenProp - targetTokenProp).divDown(currentTokenProp)
-            );
+            netTokenToDeposit = state
+                .totalToken
+                .mulDown(currentTokenProp - targetTokenProp)
+                .divDown(currentTokenProp);
         } else {
             uint256 currentSyProp = Math.ONE - currentTokenProp;
-            netSyToRedeem = state.totalSy.mulDown(
-                (targetTokenProp - currentTokenProp).divDown(currentSyProp)
+            netSyToRedeem = state.totalSy.mulDown(targetTokenProp - currentTokenProp).divDown(
+                currentSyProp
             );
         }
     }

package/contracts/core/StandardizedYield/SYBase.sol

@@ -1,22 +1,13 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity 0.8.17;
-import "../../interfaces/IStandardizedYield.sol";
 
+import "../../interfaces/IStandardizedYield.sol";
 import "../erc20/PendleERC20Permit.sol";
-
 import "../libraries/math/Math.sol";
 import "../libraries/TokenHelper.sol";
 import "../libraries/Errors.sol";
-import "../libraries/BoringOwnableUpgradeable.sol";
-import "@openzeppelin/contracts/security/Pausable.sol";
-
-abstract contract SYBase is
-    IStandardizedYield,
-    PendleERC20Permit,
-    TokenHelper,
-    BoringOwnableUpgradeable,
-    Pausable
-{
+
+abstract contract SYBase is IStandardizedYield, PendleERC20Permit, TokenHelper {
     using Math for uint256;
 
     address public immutable yieldToken;
@@ -25,9 +16,8 @@ abstract contract SYBase is
         string memory _name,
         string memory _symbol,
         address _yieldToken
-    ) PendleERC20Permit(_name, _symbol, IERC20Metadata(_yieldToken).decimals()) initializer {
+    ) PendleERC20Permit(_name, _symbol, IERC20Metadata(_yieldToken).decimals()) {
         yieldToken = _yieldToken;
-        __BoringOwnable_init();
     }
 
     // solhint-disable no-empty-blocks
@@ -189,19 +179,11 @@ abstract contract SYBase is
         return _previewRedeem(tokenOut, amountSharesToRedeem);
     }
 
-    function pause() external onlyOwner {
-        _pause();
-    }
-
-    function unpause() external onlyOwner {
-        _unpause();
-    }
-
     function _beforeTokenTransfer(
         address,
         address,
         uint256
-    ) internal virtual override whenNotPaused {}
+    ) internal virtual override {}
 
     function _previewDeposit(address tokenIn, uint256 amountTokenToDeposit)
         internal

package/contracts/core/StandardizedYield/SYBaseWithRewards.sol

@@ -29,7 +29,6 @@ abstract contract SYBaseWithRewards is SYBase, RewardManager {
         virtual
         override
         nonReentrant
-        whenNotPaused
         returns (uint256[] memory rewardAmounts)
     {
         _updateAndDistributeRewards(user);
@@ -74,7 +73,6 @@ abstract contract SYBaseWithRewards is SYBase, RewardManager {
     function rewardIndexesCurrent()
         external
         override
-        whenNotPaused
         nonReentrant
         returns (uint256[] memory indexes)
     {
@@ -122,7 +120,7 @@ abstract contract SYBaseWithRewards is SYBase, RewardManager {
         address from,
         address to,
         uint256
-    ) internal virtual override whenNotPaused {
+    ) internal virtual override {
         _updateAndDistributeRewardsForTwo(from, to);
     }
 }