@pendle/core-v2 0.20.2-testnet → 1.0.0-mainnet

package/contracts/LiquidityMining/CrossChainMsg/libraries/LayerZeroHelper.sol

@@ -5,18 +5,20 @@ library LayerZeroHelper {
     uint256 constant EVM_ADDRESS_SIZE = 20;
 
     function _getLayerZeroChainIds(uint256 chainId) internal pure returns (uint16) {
-        if (chainId == 43113) return 10106; // fuji testnet
-        else if (chainId == 80001) return 10109; // mumbai testnet
-        else if (chainId == 43114) return 106;  // avax mainnet
-        else if (chainId == 42161) return 110; // arbitrum one
+        if (chainId == 43113) return 10106;
+        // fuji testnet
+        else if (chainId == 80001) return 10109;
+        // mumbai testnet
+        else if (chainId == 43114) return 106; // avax mainnet
         assert(false);
     }
 
     function _getOriginalChainIds(uint16 chainId) internal pure returns (uint256) {
-        if (chainId == 10106) return 43113; // fuji testnet
-        else if (chainId == 10109) return 80001; // mumbai testnet
+        if (chainId == 10106) return 43113;
+        // fuji testnet
+        else if (chainId == 10109) return 80001;
+        // mumbai testnet
         else if (chainId == 106) return 43114; // avax mainnet
-        else if (chainId == 110) return 42161; // arbitrum one
         assert(false);
     }
 

package/contracts/LiquidityMining/FeeDistributor/EpochResultManager.sol

@@ -0,0 +1,159 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+import "./PendleFeeDistributor.sol";
+import "../../interfaces/IPVotingEscrowMainchain.sol";
+import "../../interfaces/IPVotingController.sol";
+import "../../interfaces/IPFeeDistributorFactory.sol";
+import "../../core/libraries/BoringOwnableUpgradeable.sol";
+import "../libraries/VeHistoryLib.sol";
+import "../libraries/WeekMath.sol";
+
+abstract contract EpochResultManager is IPFeeDistributorFactory {
+    using Math for uint256;
+    using ArrayLib for address[];
+    using VeBalanceLib for VeBalance;
+    using CheckpointHelper for Checkpoint;
+
+    struct UserInfo {
+        uint128 timestamp;
+        uint128 iter;
+    }
+
+    address public immutable votingController;
+    address public immutable vePendle;
+
+    // [user, pool] => UserInfo
+    mapping(address => mapping(address => UserInfo)) public userInfo;
+
+    // [user, pool, epoch] => share
+    mapping(address => mapping(address => mapping(uint256 => uint256))) internal userShareAtEpoch;
+
+    constructor(address _votingController, address _vePendle) {
+        votingController = _votingController;
+        vePendle = _vePendle;
+    }
+
+    function updateUserShare(address user, address pool) external {
+        _updateExternalGlobalShares(pool);
+        _updateUserShare(user, pool);
+    }
+
+    function getUserAndTotalSharesAt(
+        address user,
+        address pool,
+        uint256 epoch
+    ) external view returns (uint256 userShare, uint256 totalShare) {
+        userShare = userShareAtEpoch[user][pool][epoch];
+        totalShare = _getExternalTotalShares(pool, epoch.Uint128());
+    }
+
+    function _updateUserShare(address user, address pool) internal {
+        uint128 currentEpoch = WeekMath.getCurrentWeekStart();
+        uint128 userEpoch = userInfo[user][pool].timestamp;
+
+        if (userEpoch == currentEpoch) return;
+        if (userEpoch == 0) userEpoch = _getPoolStartTime(pool);
+
+        uint256 length = _getExternalUserHistoryLength(user, pool);
+        if (length == 0) {
+            userInfo[user][pool].timestamp = currentEpoch;
+            return;
+        }
+
+        uint128 iter = userInfo[user][pool].iter;
+        Checkpoint memory lowerCheckpoint = _getExternalUserCheckpointAt(user, pool, iter);
+        Checkpoint memory upperCheckpoint;
+
+        if (iter + 1 < length) {
+            upperCheckpoint = _getExternalUserCheckpointAt(user, pool, iter + 1);
+        }
+
+        while (userEpoch < currentEpoch) {
+            userEpoch += WeekMath.WEEK;
+
+            iter = _moveIterToNextEpoch(
+                user,
+                pool,
+                length,
+                iter,
+                lowerCheckpoint,
+                upperCheckpoint,
+                userEpoch
+            );
+
+            if (userEpoch >= lowerCheckpoint.timestamp) {
+                userShareAtEpoch[user][pool][userEpoch] = lowerCheckpoint.value.getValueAt(
+                    userEpoch
+                );
+            }
+        }
+
+        userInfo[user][pool] = UserInfo({ timestamp: currentEpoch, iter: iter });
+    }
+
+    function _moveIterToNextEpoch(
+        address user,
+        address pool,
+        uint256 userHistoryLength,
+        uint128 iter,
+        Checkpoint memory lowerCheckpoint,
+        Checkpoint memory upperCheckpoint,
+        uint128 nextEpoch
+    ) internal view returns (uint128) {
+        while (iter + 1 < userHistoryLength && nextEpoch > upperCheckpoint.timestamp) {
+            lowerCheckpoint.assignWith(upperCheckpoint);
+            if (iter + 2 < userHistoryLength) {
+                upperCheckpoint.assignWith(_getExternalUserCheckpointAt(user, pool, iter + 2));
+            }
+            ++iter;
+        }
+        return iter;
+    }
+
+    function _updateExternalGlobalShares(address pool) internal {
+        if (pool == vePendle) {
+            IPVeToken(vePendle).totalSupplyCurrent();
+        } else {
+            IPVotingController(votingController).applyPoolSlopeChanges(pool);
+        }
+    }
+
+    function _getExternalTotalShares(address pool, uint128 timestamp)
+        internal
+        view
+        returns (uint256)
+    {
+        if (pool == vePendle) {
+            return IPVotingEscrowMainchain(vePendle).totalSupplyAt(timestamp);
+        } else {
+            return IPVotingController(votingController).getPoolTotalVoteAt(pool, timestamp);
+        }
+    }
+
+    function _getExternalUserCheckpointAt(
+        address user,
+        address pool,
+        uint256 index
+    ) internal view returns (Checkpoint memory) {
+        if (pool == vePendle) {
+            return IPVotingEscrowMainchain(vePendle).getUserHistoryAt(user, index);
+        } else {
+            return IPVotingController(votingController).getUserPoolHistoryAt(user, pool, index);
+        }
+    }
+
+    function _getExternalUserHistoryLength(address user, address pool)
+        internal
+        view
+        returns (uint256)
+    {
+        if (pool == vePendle) {
+            return IPVotingEscrowMainchain(vePendle).getUserHistoryLength(user);
+        } else {
+            return IPVotingController(votingController).getUserPoolHistoryLength(user, pool);
+        }
+    }
+
+    function _getPoolStartTime(address pool) internal view virtual returns (uint64);
+}

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,14 +151,9 @@ library Errors {
     error ArrayEmpty();
     error ArrayOutOfBounds();
     error ZeroAddress();
-    error FailedToSendEther();
 
     error OnlyLayerZeroEndpoint();
     error OnlyYT();
     error OnlyYCFactory();
     error OnlyWhitelisted();
-
-    // Swap Aggregator 
-    error SAInsufficientTokenIn(address tokenIn, uint256 amountExpected, uint256 amountActual);
-    error UnsupportedSelector(uint256 aggregatorType, bytes4 selector);
 }

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/IPActionAddRemoveLiq.sol

@@ -2,7 +2,7 @@
 pragma solidity 0.8.17;
 
 import "../router/base/MarketApproxLib.sol";
-import "../router/base/ActionBaseMintRedeem.sol";
+import "../router/kyberswap/KyberSwapHelper.sol";
 
 interface IPActionAddRemoveLiq {
     event AddLiquidityDualSyAndPt(

package/contracts/interfaces/IPActionMintRedeem.sol

@@ -2,7 +2,7 @@
 pragma solidity 0.8.17;
 
 import "../router/base/MarketApproxLib.sol";
-import "../router/base/ActionBaseMintRedeem.sol";
+import "../router/kyberswap/KyberSwapHelper.sol";
 
 interface IPActionMintRedeem {
     event MintSyFromToken(
@@ -145,8 +145,9 @@ interface IPActionMintRedeem {
     struct RouterSwapAllStruct {
         // key-value pair
         address[] tokens;
-        SwapData[] data;
+        bytes[] kybercalls;
         //
+        address kyberRouter;
         address outputToken;
         uint256 minTokenOut;
     }

package/contracts/interfaces/IPActionSwapPT.sol

@@ -2,7 +2,7 @@
 pragma solidity 0.8.17;
 
 import "../router/base/MarketApproxLib.sol";
-import "../router/base/ActionBaseMintRedeem.sol";
+import "../router/kyberswap/KyberSwapHelper.sol";
 
 interface IPActionSwapPT {
     event SwapPtAndSy(

package/contracts/interfaces/IPActionSwapPTYT.sol

@@ -2,7 +2,7 @@
 pragma solidity 0.8.17;
 
 import "../router/base/MarketApproxLib.sol";
-import "../router/base/ActionBaseMintRedeem.sol";
+import "../router/kyberswap/KyberSwapHelper.sol";
 
 interface IPActionSwapPTYT {
     event SwapPtAndYt(

package/contracts/interfaces/IPActionSwapYT.sol

@@ -2,7 +2,7 @@
 pragma solidity 0.8.17;
 
 import "../router/base/MarketApproxLib.sol";
-import "../router/base/ActionBaseMintRedeem.sol";
+import "../router/kyberswap/KyberSwapHelper.sol";
 
 interface IPActionSwapYT {
     event SwapYtAndSy(

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