@pendle/core-v2 0.21.0-testnet → 1.0.1-mainnet

package/contracts/LiquidityMining/FeeDistributor/PendleFeeDistributor.sol

@@ -0,0 +1,99 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+import "../../core/libraries/math/Math.sol";
+import "../../core/libraries/ArrayLib.sol";
+import "../../core/libraries/MiniHelpers.sol";
+import "../../core/libraries/Errors.sol";
+import "../../core/libraries/BoringOwnableUpgradeable.sol";
+
+import "../libraries/WeekMath.sol";
+import "../libraries/VeHistoryLib.sol";
+
+import "../../interfaces/IPFeeDistributor.sol";
+import "../../interfaces/IPFeeDistributorFactory.sol";
+
+import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
+
+contract PendleFeeDistributor is IPFeeDistributor, BoringOwnableUpgradeable {
+    using Math for uint256;
+    using SafeERC20 for IERC20;
+    using ArrayLib for address[];
+    using VeBalanceLib for VeBalance;
+
+    address public immutable factory;
+    address public immutable pool;
+    address public immutable rewardToken;
+    uint256 public immutable startEpoch;
+
+    uint256 public lastFinishedEpoch;
+
+    // [user] => [epoch]
+    mapping(address => uint256) public userLastClaimedEpoch;
+
+    // [epoch] => [incentive]
+    mapping(uint256 => uint256) public incentivesForEpoch;
+
+    constructor(
+        address _pool,
+        address _rewardToken,
+        uint256 _startEpoch
+    ) initializer {
+        pool = _pool;
+        factory = msg.sender;
+        rewardToken = _rewardToken;
+        startEpoch = _startEpoch;
+        lastFinishedEpoch = _startEpoch;
+        __BoringOwnable_init();
+    }
+
+    function fund(uint256[] calldata rewardsForEpoch) external onlyOwner {
+        uint256 epoch = lastFinishedEpoch;
+        uint256 totalRewardFunding = 0;
+        for (uint256 i = 0; i < rewardsForEpoch.length; ++i) {
+            epoch += WeekMath.WEEK;
+            uint256 incentive = rewardsForEpoch[i];
+
+            incentivesForEpoch[epoch] += incentive;
+            totalRewardFunding += incentive;
+
+            emit Fund(epoch, incentive);
+        }
+
+        if (epoch > WeekMath.getCurrentWeekStart()) revert Errors.FDCantFundFutureEpoch();
+
+        IERC20(rewardToken).transferFrom(msg.sender, address(this), totalRewardFunding);
+        lastFinishedEpoch = epoch;
+    }
+
+    function claimReward(address user) external returns (uint256 amountRewardOut) {
+        IPFeeDistributorFactory(factory).updateUserShare(user, pool);
+
+        uint256 finishedEpoch = lastFinishedEpoch;
+        uint256 userEpoch = userLastClaimedEpoch[user];
+
+        if (userEpoch == finishedEpoch) return 0;
+        if (userEpoch == 0) userEpoch = startEpoch;
+
+        while (userEpoch < finishedEpoch) {
+            userEpoch += WeekMath.WEEK;
+
+            uint256 incentive = incentivesForEpoch[userEpoch];
+            if (incentive == 0) continue;
+
+            (uint256 userShare, uint256 totalShare) = IPFeeDistributorFactory(factory)
+                .getUserAndTotalSharesAt(user, pool, userEpoch);
+
+            if (userShare == 0) continue;
+
+            amountRewardOut += (userShare * incentive) / totalShare;
+        }
+
+        userLastClaimedEpoch[user] = finishedEpoch;
+        if (amountRewardOut > 0) {
+            IERC20(rewardToken).safeTransfer(user, amountRewardOut);
+        }
+
+        emit ClaimReward(user, rewardToken, finishedEpoch, amountRewardOut);
+    }
+}

package/contracts/LiquidityMining/FeeDistributor/PendleFeeDistributorFactory.sol

@@ -0,0 +1,70 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+import "./PendleFeeDistributor.sol";
+import "./EpochResultManager.sol";
+
+import "../../core/libraries/BaseSplitCodeFactory.sol";
+
+import "../../interfaces/IBoringOwnableUpgradeable.sol";
+import "../../interfaces/IPFeeDistributorFactory.sol";
+
+contract PendleFeeDistributorFactory is BoringOwnableUpgradeable, EpochResultManager {
+    using Math for uint256;
+
+    struct PoolInfo {
+        address distributor;
+        uint64 startTime;
+    }
+
+    address public immutable feeDistributorCreationCodeContractA;
+    uint256 public immutable feeDistributorCreationCodeSizeA;
+    address public immutable feeDistributorCreationCodeContractB;
+    uint256 public immutable feeDistributorCreationCodeSizeB;
+
+    address public immutable rewardToken;
+    uint256 public lastFinishedEpoch;
+    mapping(address => PoolInfo) public poolInfos;
+
+    constructor(
+        address _rewardToken,
+        address _votingController,
+        address _vePendle,
+        address _feeDistributorCreationCodeContractA,
+        uint256 _feeDistributorCreationCodeSizeA,
+        address _feeDistributorCreationCodeContractB,
+        uint256 _feeDistributorCreationCodeSizeB
+    ) EpochResultManager(_votingController, _vePendle) initializer {
+        __BoringOwnable_init();
+        rewardToken = _rewardToken;
+        feeDistributorCreationCodeContractA = _feeDistributorCreationCodeContractA;
+        feeDistributorCreationCodeSizeA = _feeDistributorCreationCodeSizeA;
+        feeDistributorCreationCodeContractB = _feeDistributorCreationCodeContractB;
+        feeDistributorCreationCodeSizeB = _feeDistributorCreationCodeSizeB;
+    }
+
+    function createFeeDistributor(address pool, uint64 startTime)
+        external
+        onlyOwner
+        returns (address distributor)
+    {
+        if (poolInfos[pool].distributor != address(0))
+            revert Errors.FDFactoryDistributorAlreadyExisted(pool, poolInfos[pool].distributor);
+
+        distributor = BaseSplitCodeFactory._create2(
+            0,
+            bytes32(""),
+            abi.encode(pool, rewardToken, uint256(startTime)),
+            feeDistributorCreationCodeContractA,
+            feeDistributorCreationCodeSizeA,
+            feeDistributorCreationCodeContractB,
+            feeDistributorCreationCodeSizeB
+        );
+        IBoringOwnableUpgradeable(distributor).transferOwnership(msg.sender, true, false);
+        poolInfos[pool] = PoolInfo({ distributor: distributor, startTime: startTime });
+    }
+
+    function _getPoolStartTime(address pool) internal view virtual override returns (uint64) {
+        return poolInfos[pool].startTime;
+    }
+}

package/contracts/core/BulkSeller/BulkSeller.sol

@@ -83,7 +83,7 @@ contract BulkSeller is IPBulkSeller, Initializable, TokenHelper, ReentrancyGuard
         else {
             uint256 netSyReceived = _selfBalance(SY) - state.totalSy;
             if (netSyReceived < exactSyIn)
-                revert Errors.BulkInsufficientSyReceived(netSyReceived, exactSyIn);
+                revert Errors.BulkInsufficientSyReceived(exactSyIn, netSyReceived);
         }
 
         netTokenOut = state.swapExactSyForToken(exactSyIn);

package/contracts/core/StandardizedYield/SYBaseWithRewards.sol

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

package/contracts/core/libraries/ArrayLib.sol

@@ -13,18 +13,6 @@ library ArrayLib {
         return value;
     }
 
-    /// @notice return index of the element if found, else return uint256.max
-    function find(address[] memory array, address element) internal pure returns (uint256 index) {
-        uint256 length = array.length;
-        for (uint256 i = 0; i < length; ) {
-            if (array[i] == element) return i;
-            unchecked {
-                i++;
-            }
-        }
-        return type(uint256).max;
-    }
-
     function contains(address[] memory array, address element) internal pure returns (bool) {
         uint256 length = array.length;
         for (uint256 i = 0; i < length; ) {

package/contracts/core/libraries/Errors.sol

@@ -111,10 +111,6 @@ library Errors {
     error SYCurveInvalidPid();
     error SYCurve3crvPoolNotFound();
 
-    error SYApeDepositAmountTooSmall(uint256 amountDeposited);
-    error SYBalancerInvalidPid();
-    error SYInvalidRewardToken(address token);
-
     // Liquidity Mining
     error VCInactivePool(address pool);
     error VCPoolAlreadyActive(address pool);
@@ -140,16 +136,8 @@ library Errors {
     error ExpiryInThePast(uint256 expiry);
     error ChainNotSupported(uint256 chainId);
 
-    error FDTotalAmountFundedNotMatch(uint256 actualTotalAmount, uint256 expectedTotalAmount);
-    error FDEpochLengthMismatch();
-    error FDInvalidPool(address pool);
-    error FDPoolAlreadyExists(address pool);
-    error FDInvalidNewFinishedEpoch(uint256 oldFinishedEpoch, uint256 newFinishedEpoch);
-    error FDInvalidStartEpoch(uint256 startEpoch);
-    error FDInvalidWTimeFund(uint256 lastFunded, uint256 wTime);
-    error FDFutureFunding(uint256 lastFunded, uint256 currentWTime);
-
-    error BDInvalidEpoch(uint256 epoch, uint256 startTime);
+    error FDCantFundFutureEpoch();
+    error FDFactoryDistributorAlreadyExisted(address pool, address distributor);
 
     // Cross-Chain
     error MsgNotFromSendEndpoint(uint16 srcChainId, bytes path);
@@ -163,7 +151,6 @@ library Errors {
     error ArrayEmpty();
     error ArrayOutOfBounds();
     error ZeroAddress();
-    error FailedToSendEther();
 
     error OnlyLayerZeroEndpoint();
     error OnlyYT();

package/contracts/interfaces/ConvexCurve/IRewards.sol

@@ -14,11 +14,6 @@ interface IRewards {
 
     function exit(address) external;
 
-    function getReward(
-        address, /*_account*/
-        bool /*_claimExtras*/
-    ) external;
-
     function getReward() external;
 
     function queueNewRewards(uint256) external;

package/contracts/interfaces/IPFeeDistributor.sol

@@ -2,20 +2,18 @@
 pragma solidity 0.8.17;
 
 interface IPFeeDistributor {
-    event UpdateFee(address indexed pool, uint256 indexed wTime, uint256 amount);
+    event Fund(uint256 indexed epoch, uint256 incentive);
 
-    event ClaimReward(address indexed pool, address indexed user, uint256 wTime, uint256 amount);
+    event ClaimReward(
+        address indexed user,
+        address indexed rewardToken,
+        uint256 lastEpochClaimed,
+        uint256 totalReward
+    );
 
-    event PoolAdded(address indexed pool, uint256 indexed startWeek);
+    function fund(uint256[] calldata rewardsForEpoch) external;
 
-    struct UserInfo {
-        uint128 firstUnclaimedWeek;
-        uint128 iter;
-    }
+    function claimReward(address user) external returns (uint256 amountRewardOut);
 
-    function claimReward(address user, address[] calldata pools)
-        external
-        returns (uint256[] memory amountRewardOut);
-
-    function getAllPools() external view returns (address[] memory);
+    function incentivesForEpoch(uint256 epoch) external returns (uint256);
 }

package/contracts/interfaces/IPFeeDistributorFactory.sol

@@ -0,0 +1,14 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+interface IPFeeDistributorFactory {
+    function lastFinishedEpoch() external returns (uint256);
+
+    function updateUserShare(address user, address pool) external;
+
+    function getUserAndTotalSharesAt(
+        address user,
+        address pool,
+        uint256 epoch
+    ) external view returns (uint256 userShare, uint256 totalShare);
+}

package/contracts/offchain-helpers/MarketMathStatic.sol

@@ -322,7 +322,7 @@ library MarketMathStatic {
         priceImpact = calcPriceImpactYt(market, netYtOut.neg());
 
         // Execute swap to calculate exchangeRateAfter
-        state.swapExactPtForSy(index, netYtOut, block.timestamp);
+        state.swapSyForExactPt(index, netYtOut, block.timestamp);
         exchangeRateAfter = _getTradeExchangeRateExcludeFee(market, state);
     }