@pendle/core-v2 2.29.4 → 2.30.1

package/contracts/core/Market/v2/PendleMarketV2.sol

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.17;
+pragma solidity ^0.8.17;
 
 import "../../../interfaces/IPMarket.sol";
 import "../../../interfaces/IPMarketFactory.sol";
@@ -64,19 +64,15 @@ contract PendleMarketV2 is PendleERC20Permit, PendleGaugeV2, IPMarket {
         address _externalRewardDistributor
     )
         PendleERC20Permit(NAME, SYMBOL, 18)
-        PendleGaugeV2(
-            IPPrincipalToken(_PT).SY(),
-            _vePendle,
-            _gaugeController,
-            _externalRewardDistributor
-        )
+        PendleGaugeV2(IPPrincipalToken(_PT).SY(), _vePendle, _gaugeController, _externalRewardDistributor)
     {
         PT = IPPrincipalToken(_PT);
         SY = IStandardizedYield(PT.SY());
         YT = IPYieldToken(PT.YT());
 
-        (_storage.observationCardinality, _storage.observationCardinalityNext) = observations
-            .initialize(uint32(block.timestamp));
+        (_storage.observationCardinality, _storage.observationCardinalityNext) = observations.initialize(
+            uint32(block.timestamp)
+        );
 
         if (_scalarRoot <= 0) revert Errors.MarketScalarRootBelowZero(_scalarRoot);
 
@@ -98,12 +94,7 @@ contract PendleMarketV2 is PendleERC20Permit, PendleGaugeV2, IPMarket {
         address receiver,
         uint256 netSyDesired,
         uint256 netPtDesired
-    )
-        external
-        nonReentrant
-        notExpired
-        returns (uint256 netLpOut, uint256 netSyUsed, uint256 netPtUsed)
-    {
+    ) external nonReentrant notExpired returns (uint256 netLpOut, uint256 netSyUsed, uint256 netPtUsed) {
         MarketState memory market = readState(msg.sender);
         PYIndex index = YT.newIndex();
 
@@ -175,11 +166,7 @@ contract PendleMarketV2 is PendleERC20Permit, PendleGaugeV2, IPMarket {
         MarketState memory market = readState(msg.sender);
 
         uint256 netSyToReserve;
-        (netSyOut, netSyFee, netSyToReserve) = market.swapExactPtForSy(
-            YT.newIndex(),
-            exactPtIn,
-            block.timestamp
-        );
+        (netSyOut, netSyFee, netSyToReserve) = market.swapExactPtForSy(YT.newIndex(), exactPtIn, block.timestamp);
 
         if (receiver != address(this)) IERC20(SY).safeTransfer(receiver, netSyOut);
         IERC20(SY).safeTransfer(market.treasury, netSyToReserve);
@@ -214,11 +201,7 @@ contract PendleMarketV2 is PendleERC20Permit, PendleGaugeV2, IPMarket {
         MarketState memory market = readState(msg.sender);
 
         uint256 netSyToReserve;
-        (netSyIn, netSyFee, netSyToReserve) = market.swapSyForExactPt(
-            YT.newIndex(),
-            exactPtOut,
-            block.timestamp
-        );
+        (netSyIn, netSyFee, netSyToReserve) = market.swapSyForExactPt(YT.newIndex(), exactPtOut, block.timestamp);
 
         if (receiver != address(this)) IERC20(PT).safeTransfer(receiver, exactPtOut);
         IERC20(SY).safeTransfer(market.treasury, netSyToReserve);
@@ -262,9 +245,7 @@ contract PendleMarketV2 is PendleERC20Permit, PendleGaugeV2, IPMarket {
                                 ORACLE
     //////////////////////////////////////////////////////////////*/
 
-    function observe(
-        uint32[] memory secondsAgos
-    ) external view returns (uint216[] memory lnImpliedRateCumulative) {
+    function observe(uint32[] memory secondsAgos) external view returns (uint216[] memory lnImpliedRateCumulative) {
         return
             observations.observe(
                 uint32(block.timestamp),
@@ -296,9 +277,9 @@ contract PendleMarketV2 is PendleERC20Permit, PendleGaugeV2, IPMarket {
         market.totalSy = _storage.totalSy;
         market.totalLp = totalSupply().Int();
 
-        (market.treasury, market.lnFeeRateRoot, market.reserveFeePercent) = IPMarketFactory(
-            factory
-        ).getMarketConfig(router);
+        (market.treasury, market.lnFeeRateRoot, market.reserveFeePercent) = IPMarketFactory(factory).getMarketConfig(
+            router
+        );
 
         market.scalarRoot = scalarRoot;
         market.expiry = expiry;
@@ -333,11 +314,7 @@ contract PendleMarketV2 is PendleERC20Permit, PendleGaugeV2, IPMarket {
                             TRIVIAL FUNCTIONS
     //////////////////////////////////////////////////////////////*/
 
-    function readTokens()
-        external
-        view
-        returns (IStandardizedYield _SY, IPPrincipalToken _PT, IPYieldToken _YT)
-    {
+    function readTokens() external view returns (IStandardizedYield _SY, IPPrincipalToken _PT, IPYieldToken _YT) {
         _SY = SY;
         _PT = PT;
         _YT = YT;

package/contracts/core/RewardManager/PendleLinearDistributor.sol

@@ -0,0 +1,143 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.17;
+
+import "@openzeppelin/contracts/proxy/utils/UUPSUpgradeable.sol";
+import "@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol";
+import "../libraries/BoringOwnableUpgradeable.sol";
+import "../libraries/TokenHelper.sol";
+import "../libraries/math/PMath.sol";
+import "../../interfaces/IPLinearDistributor.sol";
+
+contract PendleLinearDistributor is UUPSUpgradeable, AccessControlUpgradeable, TokenHelper, IPLinearDistributor {
+    using PMath for uint128;
+    using PMath for uint192;
+    using PMath for uint256;
+
+    bytes32 public constant MAINTAINER = keccak256("MAINTAINER");
+
+    mapping(address => bool) internal isWhitelisted;
+
+    // [token, addr] => distribution
+    mapping(address => mapping(address => DistributionData)) public distributionDatas;
+
+    constructor() {
+        _disableInitializers();
+    }
+
+    modifier onlyWhitelisted() {
+        require(isWhitelisted[msg.sender], "not whitelisted");
+        _;
+    }
+
+    function isMaintainer(address addr) public view returns (bool) {
+        return (hasRole(DEFAULT_ADMIN_ROLE, addr) || hasRole(MAINTAINER, addr));
+    }
+
+    modifier onlyMaintainer() {
+        require(isMaintainer(msg.sender), "not maintainer");
+        _;
+    }
+
+    modifier onlyAdmin() {
+        require(hasRole(DEFAULT_ADMIN_ROLE, msg.sender), "not admin");
+        _;
+    }
+
+    // ----------------- core-logic ----------------------
+
+    function queueVestAndClaim(address token, uint256 amountVestToQueue) external onlyWhitelisted returns (uint256) {
+        require(amountVestToQueue > 0, "invalid amountVestToQueue");
+
+        uint256 amountOut = _getClaimableRewardAndUpdate(token, msg.sender, amountVestToQueue);
+
+        // dodging extreme case of amountOut = amountVestToQueue
+        if (amountOut > amountVestToQueue) {
+            _transferOut(token, msg.sender, amountOut - amountVestToQueue);
+        } else if (amountVestToQueue > amountOut) {
+            _transferIn(token, msg.sender, amountVestToQueue - amountOut);
+        }
+
+        emit VestQueued(token, msg.sender, amountVestToQueue);
+        emit Claim(token, msg.sender, amountOut);
+
+        return amountOut;
+    }
+
+    function claim(address token) external returns (uint256) {
+        uint256 amountOut = _getClaimableRewardAndUpdate(token, msg.sender, 0);
+        if (amountOut > 0) {
+            _transferOut(token, msg.sender, amountOut);
+        }
+        emit Claim(token, msg.sender, amountOut);
+        return amountOut;
+    }
+
+    function applyVestRewards(
+        address[] memory tokens,
+        address[] memory addrs,
+        uint256[] memory durations
+    ) external onlyMaintainer {
+        require(tokens.length == addrs.length, "invalid array length");
+        require(tokens.length == durations.length, "invalid array length");
+
+        for (uint256 i = 0; i < tokens.length; ++i) {
+            _applyVestReward(tokens[i], addrs[i], durations[i]);
+        }
+    }
+
+    function _applyVestReward(address token, address addr, uint256 duration) internal {
+        DistributionData memory data = _updateRewardView(token, addr);
+
+        uint256 amountVesting = data.unvestedReward;
+        if (amountVesting == 0) {
+            return;
+        }
+
+        uint256 leftOver = data.rewardPerSec.mulDown((data.endTime - PMath.min(block.timestamp, data.endTime)));
+        uint256 undistrbutedReward = amountVesting + leftOver;
+
+        data.unvestedReward = 0;
+        data.endTime = (block.timestamp + duration).Uint32();
+        data.rewardPerSec = undistrbutedReward.divDown(duration).Uint192();
+        distributionDatas[token][addr] = data;
+
+        emit Vested(token, addr, amountVesting, duration);
+    }
+
+    // data.lastDistributedTime is guaranteed to be block.timestamp after calling this
+    function _getClaimableRewardAndUpdate(
+        address token,
+        address addr,
+        uint256 amountVestToQueue
+    ) internal returns (uint256 amountOut) {
+        DistributionData memory data = _updateRewardView(token, addr);
+        amountOut = data.accruedReward;
+
+        data.accruedReward = 0;
+        data.unvestedReward += amountVestToQueue.Uint128();
+
+        distributionDatas[token][addr] = data;
+    }
+
+    function _updateRewardView(address token, address addr) internal view returns (DistributionData memory data) {
+        data = distributionDatas[token][addr];
+        uint256 distributeFrom = PMath.min(data.lastDistributedTime, data.endTime);
+        uint256 distributeTo = PMath.min(block.timestamp, data.endTime);
+        data.accruedReward += data.rewardPerSec.mulDown(distributeTo - distributeFrom).Uint128();
+        data.lastDistributedTime = block.timestamp.Uint32();
+    }
+
+    // ----------------- governance-related --------------
+
+    function setWhitelisted(address addr, bool status) external onlyAdmin {
+        isWhitelisted[addr] = status;
+    }
+
+    function initialize() external initializer {
+        _grantRole(DEFAULT_ADMIN_ROLE, msg.sender);
+    }
+
+    // ----------------- upgrade-related -----------------
+
+    function _authorizeUpgrade(address) internal override onlyAdmin {}
+}

package/contracts/core/RewardManager/RewardManager.sol

@@ -13,7 +13,6 @@ abstract contract RewardManager is RewardManagerAbstract {
 
     mapping(address => RewardState) public rewardState;
 
-
     function _updateRewardIndex()
         internal
         virtual

package/contracts/core/RewardManager/RewardManagerAbstract.sol

@@ -36,18 +36,12 @@ abstract contract RewardManagerAbstract is IRewardManager, TokenHelper {
         (address[] memory tokens, uint256[] memory indexes) = _updateRewardIndex();
         if (tokens.length == 0) return;
 
-        if (user1 != address(0) && user1 != address(this))
-            _distributeRewardsPrivate(user1, tokens, indexes);
-        if (user2 != address(0) && user2 != address(this))
-            _distributeRewardsPrivate(user2, tokens, indexes);
+        if (user1 != address(0) && user1 != address(this)) _distributeRewardsPrivate(user1, tokens, indexes);
+        if (user2 != address(0) && user2 != address(this)) _distributeRewardsPrivate(user2, tokens, indexes);
     }
 
     // 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 {
+    function _distributeRewardsPrivate(address user, address[] memory tokens, uint256[] memory indexes) private {
         assert(user != address(0) && user != address(this));
 
         uint256 userShares = _rewardSharesUser(user);
@@ -67,17 +61,11 @@ abstract contract RewardManagerAbstract is IRewardManager, TokenHelper {
             uint256 rewardDelta = userShares.mulDown(deltaIndex);
             uint256 rewardAccrued = userReward[token][user].accrued + rewardDelta;
 
-            userReward[token][user] = UserReward({
-                index: index.Uint128(),
-                accrued: rewardAccrued.Uint128()
-            });
+            userReward[token][user] = UserReward({index: index.Uint128(), accrued: rewardAccrued.Uint128()});
         }
     }
 
-    function _updateRewardIndex()
-        internal
-        virtual
-        returns (address[] memory tokens, uint256[] memory indexes);
+    function _updateRewardIndex() internal virtual returns (address[] memory tokens, uint256[] memory indexes);
 
     function _redeemExternalReward() internal virtual;
 

package/contracts/core/StandardizedYield/SYBase.sol

@@ -10,13 +10,7 @@ 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, BoringOwnableUpgradeable, Pausable {
     using PMath for uint256;
 
     address public immutable yieldToken;
@@ -52,8 +46,7 @@ abstract contract SYBase is
         _transferIn(tokenIn, msg.sender, amountTokenToDeposit);
 
         amountSharesOut = _deposit(tokenIn, amountTokenToDeposit);
-        if (amountSharesOut < minSharesOut)
-            revert Errors.SYInsufficientSharesOut(amountSharesOut, minSharesOut);
+        if (amountSharesOut < minSharesOut) revert Errors.SYInsufficientSharesOut(amountSharesOut, minSharesOut);
 
         _mint(receiver, amountSharesOut);
         emit Deposit(msg.sender, receiver, tokenIn, amountTokenToDeposit, amountSharesOut);
@@ -79,8 +72,7 @@ abstract contract SYBase is
         }
 
         amountTokenOut = _redeem(receiver, tokenOut, amountSharesToRedeem);
-        if (amountTokenOut < minTokenOut)
-            revert Errors.SYInsufficientTokenOut(amountTokenOut, minTokenOut);
+        if (amountTokenOut < minTokenOut) revert Errors.SYInsufficientTokenOut(amountTokenOut, minTokenOut);
         emit Redeem(msg.sender, receiver, tokenOut, amountSharesToRedeem, amountTokenOut);
     }
 
@@ -90,10 +82,7 @@ abstract contract SYBase is
      * @param amountDeposited amount of base tokens deposited
      * @return amountSharesOut amount of shares minted
      */
-    function _deposit(
-        address tokenIn,
-        uint256 amountDeposited
-    ) internal virtual returns (uint256 amountSharesOut);
+    function _deposit(address tokenIn, uint256 amountDeposited) internal virtual returns (uint256 amountSharesOut);
 
     /**
      * @notice redeems base tokens based on amount of shares to be burned
@@ -123,31 +112,21 @@ abstract contract SYBase is
     /**
      * @dev See {IStandardizedYield-claimRewards}
      */
-    function claimRewards(
-        address /*user*/
-    ) external virtual override returns (uint256[] memory rewardAmounts) {
+    function claimRewards(address /*user*/) external virtual override returns (uint256[] memory rewardAmounts) {
         rewardAmounts = new uint256[](0);
     }
 
     /**
      * @dev See {IStandardizedYield-getRewardTokens}
      */
-    function getRewardTokens()
-        external
-        view
-        virtual
-        override
-        returns (address[] memory rewardTokens)
-    {
+    function getRewardTokens() external view virtual override returns (address[] memory rewardTokens) {
         rewardTokens = new address[](0);
     }
 
     /**
      * @dev See {IStandardizedYield-accruedRewards}
      */
-    function accruedRewards(
-        address /*user*/
-    ) external view virtual override returns (uint256[] memory rewardAmounts) {
+    function accruedRewards(address /*user*/) external view virtual override returns (uint256[] memory rewardAmounts) {
         rewardAmounts = new uint256[](0);
     }
 
@@ -155,13 +134,7 @@ abstract contract SYBase is
         indexes = new uint256[](0);
     }
 
-    function rewardIndexesStored()
-        external
-        view
-        virtual
-        override
-        returns (uint256[] memory indexes)
-    {
+    function rewardIndexesStored() external view virtual override returns (uint256[] memory indexes) {
         indexes = new uint256[](0);
     }
 
@@ -193,11 +166,7 @@ abstract contract SYBase is
         _unpause();
     }
 
-    function _beforeTokenTransfer(
-        address,
-        address,
-        uint256
-    ) internal virtual override whenNotPaused {}
+    function _beforeTokenTransfer(address, address, uint256) internal virtual override whenNotPaused {}
 
     function _previewDeposit(
         address tokenIn,

package/contracts/core/StandardizedYield/SYBaseUpg.sol

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.17;
+pragma solidity ^0.8.17;
 
 import "../../interfaces/IStandardizedYield.sol";
 
@@ -24,9 +24,7 @@ abstract contract SYBaseUpg is
 
     uint256[100] private __gap;
 
-    constructor(address _yieldToken)
-        PendleERC20Upg(IERC20Metadata(_yieldToken).decimals())
-    {
+    constructor(address _yieldToken) PendleERC20Upg(IERC20Metadata(_yieldToken).decimals()) {
         yieldToken = _yieldToken;
     }
 
@@ -57,8 +55,7 @@ abstract contract SYBaseUpg is
         _transferIn(tokenIn, msg.sender, amountTokenToDeposit);
 
         amountSharesOut = _deposit(tokenIn, amountTokenToDeposit);
-        if (amountSharesOut < minSharesOut)
-            revert Errors.SYInsufficientSharesOut(amountSharesOut, minSharesOut);
+        if (amountSharesOut < minSharesOut) revert Errors.SYInsufficientSharesOut(amountSharesOut, minSharesOut);
 
         _mint(receiver, amountSharesOut);
         emit Deposit(msg.sender, receiver, tokenIn, amountTokenToDeposit, amountSharesOut);
@@ -84,8 +81,7 @@ abstract contract SYBaseUpg is
         }
 
         amountTokenOut = _redeem(receiver, tokenOut, amountSharesToRedeem);
-        if (amountTokenOut < minTokenOut)
-            revert Errors.SYInsufficientTokenOut(amountTokenOut, minTokenOut);
+        if (amountTokenOut < minTokenOut) revert Errors.SYInsufficientTokenOut(amountTokenOut, minTokenOut);
         emit Redeem(msg.sender, receiver, tokenOut, amountSharesToRedeem, amountTokenOut);
     }
 
@@ -95,10 +91,7 @@ abstract contract SYBaseUpg is
      * @param amountDeposited amount of base tokens deposited
      * @return amountSharesOut amount of shares minted
      */
-    function _deposit(
-        address tokenIn,
-        uint256 amountDeposited
-    ) internal virtual returns (uint256 amountSharesOut);
+    function _deposit(address tokenIn, uint256 amountDeposited) internal virtual returns (uint256 amountSharesOut);
 
     /**
      * @notice redeems base tokens based on amount of shares to be burned
@@ -128,31 +121,21 @@ abstract contract SYBaseUpg is
     /**
      * @dev See {IStandardizedYield-claimRewards}
      */
-    function claimRewards(
-        address /*user*/
-    ) external virtual override returns (uint256[] memory rewardAmounts) {
+    function claimRewards(address /*user*/) external virtual override returns (uint256[] memory rewardAmounts) {
         rewardAmounts = new uint256[](0);
     }
 
     /**
      * @dev See {IStandardizedYield-getRewardTokens}
      */
-    function getRewardTokens()
-        external
-        view
-        virtual
-        override
-        returns (address[] memory rewardTokens)
-    {
+    function getRewardTokens() external view virtual override returns (address[] memory rewardTokens) {
         rewardTokens = new address[](0);
     }
 
     /**
      * @dev See {IStandardizedYield-accruedRewards}
      */
-    function accruedRewards(
-        address /*user*/
-    ) external view virtual override returns (uint256[] memory rewardAmounts) {
+    function accruedRewards(address /*user*/) external view virtual override returns (uint256[] memory rewardAmounts) {
         rewardAmounts = new uint256[](0);
     }
 
@@ -160,13 +143,7 @@ abstract contract SYBaseUpg is
         indexes = new uint256[](0);
     }
 
-    function rewardIndexesStored()
-        external
-        view
-        virtual
-        override
-        returns (uint256[] memory indexes)
-    {
+    function rewardIndexesStored() external view virtual override returns (uint256[] memory indexes) {
         indexes = new uint256[](0);
     }
 
@@ -198,11 +175,7 @@ abstract contract SYBaseUpg is
         _unpause();
     }
 
-    function _beforeTokenTransfer(
-        address,
-        address,
-        uint256
-    ) internal virtual override whenNotPaused {}
+    function _beforeTokenTransfer(address, address, uint256) internal virtual override whenNotPaused {}
 
     function _previewDeposit(
         address tokenIn,

package/contracts/core/StandardizedYield/SYBaseWithRewards.sol

@@ -24,13 +24,9 @@ abstract contract SYBaseWithRewards is SYBase, RewardManager {
     /**
      * @dev See {IStandardizedYield-claimRewards}
      */
-    function claimRewards(address user)
-        external
-        virtual
-        override
-        nonReentrant
-        returns (uint256[] memory rewardAmounts)
-    {
+    function claimRewards(
+        address user
+    ) external virtual override nonReentrant returns (uint256[] memory rewardAmounts) {
         _updateAndDistributeRewards(user);
         rewardAmounts = _doTransferOutRewards(user, user);
 
@@ -40,26 +36,14 @@ abstract contract SYBaseWithRewards is SYBase, RewardManager {
     /**
      * @dev See {IStandardizedYield-getRewardTokens}
      */
-    function getRewardTokens()
-        external
-        view
-        virtual
-        override
-        returns (address[] memory rewardTokens)
-    {
+    function getRewardTokens() external view virtual override returns (address[] memory rewardTokens) {
         rewardTokens = _getRewardTokens();
     }
 
     /**
      * @dev See {IStandardizedYield-accruedRewards}
      */
-    function accruedRewards(address user)
-        external
-        view
-        virtual
-        override
-        returns (uint256[] memory rewardAmounts)
-    {
+    function accruedRewards(address user) external view virtual override returns (uint256[] memory rewardAmounts) {
         address[] memory rewardTokens = _getRewardTokens();
         rewardAmounts = new uint256[](rewardTokens.length);
         for (uint256 i = 0; i < rewardTokens.length; ) {
@@ -70,23 +54,12 @@ abstract contract SYBaseWithRewards is SYBase, RewardManager {
         }
     }
 
-    function rewardIndexesCurrent()
-        external
-        override
-        nonReentrant
-        returns (uint256[] memory indexes)
-    {
+    function rewardIndexesCurrent() external override nonReentrant returns (uint256[] memory indexes) {
         _updateRewardIndex();
         return rewardIndexesStored();
     }
 
-    function rewardIndexesStored()
-        public
-        view
-        virtual
-        override
-        returns (uint256[] memory indexes)
-    {
+    function rewardIndexesStored() public view virtual override returns (uint256[] memory indexes) {
         address[] memory rewardTokens = _getRewardTokens();
         indexes = new uint256[](rewardTokens.length);
         for (uint256 i = 0; i < rewardTokens.length; ) {
@@ -116,11 +89,7 @@ abstract contract SYBaseWithRewards is SYBase, RewardManager {
     /*///////////////////////////////////////////////////////////////
                             TRANSFER HOOKS
     //////////////////////////////////////////////////////////////*/
-    function _beforeTokenTransfer(
-        address from,
-        address to,
-        uint256
-    ) internal virtual override whenNotPaused {
+    function _beforeTokenTransfer(address from, address to, uint256) internal virtual override whenNotPaused {
         _updateAndDistributeRewardsForTwo(from, to);
     }
 }