@pendle/core-v2 0.18.0-testnet → 0.19.0-testnet

package/build/artifacts/contracts/router/kyberswap/IMultihopRouterEthereum.sol/IMultihopRouterEthereum.dbg.json

@@ -1,4 +1,4 @@
 {
   "_format": "hh-sol-dbg-1",
-  "buildInfo": "../../../../build-info/cfaee2011af0cd925c44a0b8d7310816.json"
+  "buildInfo": "../../../../build-info/92ac36e978c82783b79c3f3381de5170.json"
 }

package/build/artifacts/contracts/router/kyberswap/KyberSwapHelper.sol/KyberSwapHelper.dbg.json

@@ -1,4 +1,4 @@
 {
   "_format": "hh-sol-dbg-1",
-  "buildInfo": "../../../../build-info/cfaee2011af0cd925c44a0b8d7310816.json"
+  "buildInfo": "../../../../build-info/92ac36e978c82783b79c3f3381de5170.json"
 }

package/contracts/LiquidityMining/VeDistributor/PendleFeeDistributor.sol

@@ -0,0 +1,214 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
+import "@openzeppelin/contracts/proxy/utils/UUPSUpgradeable.sol";
+import "../../core/libraries/BoringOwnableUpgradeable.sol";
+import "../../core/libraries/Errors.sol";
+import "../../interfaces/IPFeeDistributor.sol";
+import "../../interfaces/IPVotingEscrowMainchain.sol";
+import "../../interfaces/IPVotingController.sol";
+import "../libraries/WeekMath.sol";
+import "../libraries/VeHistoryLib.sol";
+import "../../core/libraries/ArrayLib.sol";
+
+contract PendleFeeDistributor is UUPSUpgradeable, BoringOwnableUpgradeable, IPFeeDistributor {
+    using SafeERC20 for IERC20;
+    using VeBalanceLib for VeBalance;
+    using ArrayLib for uint256[];
+
+    address public immutable votingController;
+    address public immutable vePendle;
+    address public immutable token;
+
+    address[] public allPools;
+
+    // [pool] => lastFundedWeek
+    mapping(address => uint256) public lastFundedWeek;
+
+    // [pool, user] => UserInfo
+    mapping(address => mapping(address => UserInfo)) public userInfo;
+
+    // [pool, epoch] => [fee]
+    mapping(address => mapping(uint256 => uint256)) public fees;
+
+    modifier ensureValidPool(address pool) {
+        if (lastFundedWeek[pool] == 0) revert Errors.FDInvalidPool(pool);
+        _;
+    }
+
+    constructor(
+        address _votingController,
+        address _vePendle,
+        address _rewardToken
+    ) initializer {
+        votingController = _votingController;
+        vePendle = _vePendle;
+        token = _rewardToken;
+    }
+
+    function addPool(address pool, uint256 _startWeek) external onlyOwner {
+        if (!WeekMath.isValidWTime(_startWeek) || _startWeek == 0)
+            revert Errors.FDInvalidStartEpoch(_startWeek);
+
+        if (lastFundedWeek[pool] != 0) revert Errors.FDPoolAlreadyExists(pool);
+
+        lastFundedWeek[pool] = _startWeek - WeekMath.WEEK;
+        allPools.push(pool);
+    }
+
+    function getAllPools() external view returns (address[] memory) {
+        return allPools;
+    }
+
+    function fund(
+        address[] calldata pools,
+        uint256[][] calldata wTimes,
+        uint256[][] calldata amounts,
+        uint256 totalAmountToFund
+    ) external onlyOwner {
+        uint256 length = pools.length;
+        if (wTimes.length != length || amounts.length != length)
+            revert Errors.ArrayLengthMismatch();
+
+        uint256 totalFunded = 0;
+        for (uint256 i = 0; i < length; ++i) {
+            _fund(pools[i], wTimes[i], amounts[i]);
+            totalFunded += amounts[i].sum();
+        }
+
+        if (totalFunded != totalAmountToFund)
+            revert Errors.FDTotalAmountFundedNotMatch(totalFunded, totalAmountToFund);
+
+        IERC20(token).transferFrom(msg.sender, address(this), totalFunded);
+    }
+
+    function _fund(
+        address pool,
+        uint256[] calldata wTimes,
+        uint256[] calldata amounts
+    ) internal ensureValidPool(pool) {
+        if (wTimes.length != amounts.length) revert Errors.FDEpochLengthMismatch();
+
+        uint256 lastFunded = lastFundedWeek[pool];
+
+        for (uint256 i = 0; i < amounts.length; ++i) {
+            uint256 wTime = wTimes[i];
+            uint256 amount = amounts[i];
+
+            if (wTime != lastFunded + WeekMath.WEEK)
+                revert Errors.FDInvalidWTimeFund(lastFunded, wTime);
+
+            fees[pool][wTime] += amount;
+            lastFunded += WeekMath.WEEK;
+
+            emit UpdateFee(pool, wTime, amount);
+        }
+
+        lastFundedWeek[pool] = lastFunded;
+    }
+
+    function claimReward(address user, address[] calldata pools)
+        external
+        returns (uint256[] memory amountRewardOut)
+    {
+        amountRewardOut = new uint256[](pools.length);
+        for (uint256 i = 0; i < pools.length; ) {
+            amountRewardOut[i] = _accumulateUserReward(pools[i], user);
+            unchecked {
+                i++;
+            }
+        }
+        IERC20(token).safeTransfer(user, amountRewardOut.sum());
+    }
+
+    function _accumulateUserReward(address pool, address user)
+        internal
+        ensureValidPool(pool)
+        returns (uint256 totalReward)
+    {
+        uint256 length = _getUserCheckpointLength(pool, user);
+        if (length == 0) return 0;
+
+        uint256 lastWeek = lastFundedWeek[pool];
+        uint256 curWeek = userInfo[pool][user].firstUnclaimedWeek;
+        uint256 iter = userInfo[pool][user].iter;
+
+        if (curWeek > lastWeek) return 0; // nothing to account
+
+        Checkpoint memory checkpoint = _getUserCheckpointAt(pool, user, iter);
+        Checkpoint memory nextCheckpoint = checkpoint;
+
+        if (curWeek == 0) curWeek = checkpoint.timestamp + WeekMath.WEEK;
+
+        while (curWeek <= lastWeek) {
+            // we have at most one checkpoint per week
+            if (iter + 1 < length) {
+                if (nextCheckpoint.timestamp == checkpoint.timestamp) {
+                    // next have been assigned to current checkpoint, so we need to get the next one
+                    nextCheckpoint = _getUserCheckpointAt(pool, user, iter + 1);
+                }
+
+                if (nextCheckpoint.timestamp < curWeek) {
+                    iter++;
+                    checkpoint = nextCheckpoint;
+                }
+                // Important invariant: checkpoint[iter] < curWeek <= checkpoint[iter+1]
+            }
+
+            // assert(checkpoint.timestamp < curWeek); should always hold
+
+            uint256 userShare = checkpoint.value.getValueAt(uint128(curWeek));
+            if (userShare != 0) {
+                uint256 totalShare = _getPoolTotalSharesAt(pool, uint128(curWeek));
+                // userShare != 0 => totalShare != 0
+                uint256 amountRewardOut = (userShare * fees[pool][curWeek]) / totalShare;
+                totalReward += amountRewardOut;
+                emit ClaimReward(pool, user, curWeek, amountRewardOut);
+            }
+
+            curWeek += WeekMath.WEEK;
+        }
+
+        userInfo[pool][user] = UserInfo({
+            firstUnclaimedWeek: uint128(curWeek),
+            iter: uint128(iter)
+        });
+    }
+
+    function _getPoolTotalSharesAt(address pool, uint128 wTime) internal view returns (uint256) {
+        if (pool == vePendle) {
+            return IPVotingEscrowMainchain(vePendle).totalSupplyAt(wTime);
+        } else {
+            return IPVotingController(votingController).getPoolTotalVoteAt(pool, wTime);
+        }
+    }
+
+    function _getUserCheckpointAt(
+        address pool,
+        address user,
+        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 _getUserCheckpointLength(address pool, address user) internal view returns (uint256) {
+        if (pool == vePendle) {
+            return IPVotingEscrowMainchain(vePendle).getUserHistoryLength(user);
+        } else {
+            return IPVotingController(votingController).getUserPoolHistoryLength(user, pool);
+        }
+    }
+
+    function initialize() external initializer {
+        __BoringOwnable_init();
+    }
+
+    // ----------------- upgrade-related -----------------
+
+    function _authorizeUpgrade(address) internal override onlyOwner {}
+}

package/contracts/core/libraries/ArrayLib.sol

@@ -13,6 +13,15 @@ library ArrayLib {
         return value;
     }
 
+    function max(uint256[] memory input) internal pure returns (uint256 value) {
+        for (uint256 i = 0; i < input.length; ) {
+            if (input[i] > value) value = input[i];
+            unchecked {
+                i++;
+            }
+        }
+    }
+
     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

@@ -138,8 +138,15 @@ library Errors {
     error ExpiryInThePast(uint256 expiry);
     error ChainNotSupported(uint256 chainId);
 
-    error FDCantFundFutureEpoch();
-    error FDFactoryDistributorAlreadyExisted(address pool, address distributor);
+    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 BDInvalidEpoch(uint256 epoch, uint256 startTime);
 
     // Cross-Chain
     error MsgNotFromSendEndpoint(uint16 srcChainId, bytes path);

package/contracts/interfaces/IPFeeDistributor.sol

@@ -2,18 +2,18 @@
 pragma solidity 0.8.17;
 
 interface IPFeeDistributor {
-    event Fund(uint256 indexed epoch, uint256 incentive);
+    event UpdateFee(address indexed pool, uint256 indexed wTime, uint256 amount);
 
-    event ClaimReward(
-        address indexed user,
-        address indexed rewardToken,
-        uint256 lastEpochClaimed,
-        uint256 totalReward
-    );
+    event ClaimReward(address indexed pool, address indexed user, uint256 wTime, uint256 amount);
 
-    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 incentivesForEpoch(uint256 epoch) external returns (uint256);
+    function getAllPools() external view returns (address[] memory);
 }

package/deployments/43113-core.json

@@ -6,9 +6,14 @@
         "governance": "0x1FcCC097db89A86Bfc474A1028F93958295b1Fb7",
         "pendle": "0xB7609dec1C926204c3B67345cbCd54bc4aa7a940",
         "lzEndpoint": "0x93f54D755A063cE7bB9e6Ac47Eccc8e33411d706",
-        "wrappedNative": "0xe43a7aD7C09d8fAE3ADe7361f0b847b23adD5094"
+        "wrappedNative": "0xe43a7aD7C09d8fAE3ADe7361f0b847b23adD5094",
+        "initialRewardFee": "30000000000000000",
+        "initialInterestFee": "30000000000000000",
+        "initialFeeRateRoot": "999500333083533",
+        "initialReserveFeePercent": "80",
+        "initialPendlePerSec": "826719576719576719",
+        "safeWaitTime": 15000
     },
-    "splitter": "0x315A059EB986507A2a6085726643228401ea5e78",
     "PENDLE": "0xB7609dec1C926204c3B67345cbCd54bc4aa7a940",
     "yieldContractFactory": "0xe189c0F1EABDD23AB7DcA0d7657FF60c8f137356",
     "marketFactory": "0x24265d37C87d3ffE64D6B0274c168945d44D1ba2",
@@ -19,5 +24,6 @@
     "vePendle": "0xB20E3c268C993BC3c9Bc1C1cc5D7491F2268cD91",
     "senderEndpoint": "0x86bD575c36e236386284C035ffeBE66CB6ecd2DD",
     "votingController": "0x40ea97a7E9A4A0520229d1bbdf4D82E36b1a5475",
-    "gaugeController": "0x90Fa61ea34f61e31e9471CEB0ED22b12bBf4263E"
+    "gaugeController": "0x90Fa61ea34f61e31e9471CEB0ED22b12bBf4263E",
+    "feeDistributor": "0x40160f3439317bCD0ec8eB09545dD6A30771A7B6"
 }

package/package.json

@@ -2,7 +2,7 @@
   "name": "@pendle/core-v2",
   "description": "Core smart contracts of Pendle Protocol.",
   "license": "BUSL-1.1",
-  "version": "0.18.0-testnet",
+  "version": "0.19.0-testnet",
   "homepage": "https://pendle.finance",
   "keywords": [
     "pendle",

package/typechain-types/IPFeeDistributor.ts

@@ -25,58 +25,50 @@ import type {
 export interface IPFeeDistributorInterface extends utils.Interface {
   contractName: "IPFeeDistributor";
   functions: {
-    "claimReward(address)": FunctionFragment;
-    "fund(uint256[])": FunctionFragment;
-    "incentivesForEpoch(uint256)": FunctionFragment;
+    "claimReward(address,address[])": FunctionFragment;
+    "getAllPools()": FunctionFragment;
   };
 
-  encodeFunctionData(functionFragment: "claimReward", values: [string]): string;
   encodeFunctionData(
-    functionFragment: "fund",
-    values: [BigNumberish[]]
+    functionFragment: "claimReward",
+    values: [string, string[]]
   ): string;
   encodeFunctionData(
-    functionFragment: "incentivesForEpoch",
-    values: [BigNumberish]
+    functionFragment: "getAllPools",
+    values?: undefined
   ): string;
 
   decodeFunctionResult(
     functionFragment: "claimReward",
     data: BytesLike
   ): Result;
-  decodeFunctionResult(functionFragment: "fund", data: BytesLike): Result;
   decodeFunctionResult(
-    functionFragment: "incentivesForEpoch",
+    functionFragment: "getAllPools",
     data: BytesLike
   ): Result;
 
   events: {
     "ClaimReward(address,address,uint256,uint256)": EventFragment;
-    "Fund(uint256,uint256)": EventFragment;
+    "UpdateFee(address,uint256,uint256)": EventFragment;
   };
 
   getEvent(nameOrSignatureOrTopic: "ClaimReward"): EventFragment;
-  getEvent(nameOrSignatureOrTopic: "Fund"): EventFragment;
+  getEvent(nameOrSignatureOrTopic: "UpdateFee"): EventFragment;
 }
 
 export type ClaimRewardEvent = TypedEvent<
   [string, string, BigNumber, BigNumber],
-  {
-    user: string;
-    rewardToken: string;
-    lastEpochClaimed: BigNumber;
-    totalReward: BigNumber;
-  }
+  { pool: string; user: string; wTime: BigNumber; amount: BigNumber }
 >;
 
 export type ClaimRewardEventFilter = TypedEventFilter<ClaimRewardEvent>;
 
-export type FundEvent = TypedEvent<
-  [BigNumber, BigNumber],
-  { epoch: BigNumber; incentive: BigNumber }
+export type UpdateFeeEvent = TypedEvent<
+  [string, BigNumber, BigNumber],
+  { pool: string; wTime: BigNumber; amount: BigNumber }
 >;
 
-export type FundEventFilter = TypedEventFilter<FundEvent>;
+export type UpdateFeeEventFilter = TypedEventFilter<UpdateFeeEvent>;
 
 export interface IPFeeDistributor extends BaseContract {
   contractName: "IPFeeDistributor";
@@ -108,101 +100,74 @@ export interface IPFeeDistributor extends BaseContract {
   functions: {
     claimReward(
       user: string,
+      pools: string[],
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<ContractTransaction>;
 
-    fund(
-      rewardsForEpoch: BigNumberish[],
-      overrides?: Overrides & { from?: string | Promise<string> }
-    ): Promise<ContractTransaction>;
-
-    incentivesForEpoch(
-      epoch: BigNumberish,
-      overrides?: Overrides & { from?: string | Promise<string> }
-    ): Promise<ContractTransaction>;
+    getAllPools(overrides?: CallOverrides): Promise<[string[]]>;
   };
 
   claimReward(
     user: string,
+    pools: string[],
     overrides?: Overrides & { from?: string | Promise<string> }
   ): Promise<ContractTransaction>;
 
-  fund(
-    rewardsForEpoch: BigNumberish[],
-    overrides?: Overrides & { from?: string | Promise<string> }
-  ): Promise<ContractTransaction>;
-
-  incentivesForEpoch(
-    epoch: BigNumberish,
-    overrides?: Overrides & { from?: string | Promise<string> }
-  ): Promise<ContractTransaction>;
+  getAllPools(overrides?: CallOverrides): Promise<string[]>;
 
   callStatic: {
-    claimReward(user: string, overrides?: CallOverrides): Promise<BigNumber>;
-
-    fund(
-      rewardsForEpoch: BigNumberish[],
+    claimReward(
+      user: string,
+      pools: string[],
       overrides?: CallOverrides
-    ): Promise<void>;
+    ): Promise<BigNumber[]>;
 
-    incentivesForEpoch(
-      epoch: BigNumberish,
-      overrides?: CallOverrides
-    ): Promise<BigNumber>;
+    getAllPools(overrides?: CallOverrides): Promise<string[]>;
   };
 
   filters: {
     "ClaimReward(address,address,uint256,uint256)"(
+      pool?: string | null,
       user?: string | null,
-      rewardToken?: string | null,
-      lastEpochClaimed?: null,
-      totalReward?: null
+      wTime?: null,
+      amount?: null
     ): ClaimRewardEventFilter;
     ClaimReward(
+      pool?: string | null,
       user?: string | null,
-      rewardToken?: string | null,
-      lastEpochClaimed?: null,
-      totalReward?: null
+      wTime?: null,
+      amount?: null
     ): ClaimRewardEventFilter;
 
-    "Fund(uint256,uint256)"(
-      epoch?: BigNumberish | null,
-      incentive?: null
-    ): FundEventFilter;
-    Fund(epoch?: BigNumberish | null, incentive?: null): FundEventFilter;
+    "UpdateFee(address,uint256,uint256)"(
+      pool?: string | null,
+      wTime?: BigNumberish | null,
+      amount?: null
+    ): UpdateFeeEventFilter;
+    UpdateFee(
+      pool?: string | null,
+      wTime?: BigNumberish | null,
+      amount?: null
+    ): UpdateFeeEventFilter;
   };
 
   estimateGas: {
     claimReward(
       user: string,
+      pools: string[],
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<BigNumber>;
 
-    fund(
-      rewardsForEpoch: BigNumberish[],
-      overrides?: Overrides & { from?: string | Promise<string> }
-    ): Promise<BigNumber>;
-
-    incentivesForEpoch(
-      epoch: BigNumberish,
-      overrides?: Overrides & { from?: string | Promise<string> }
-    ): Promise<BigNumber>;
+    getAllPools(overrides?: CallOverrides): Promise<BigNumber>;
   };
 
   populateTransaction: {
     claimReward(
       user: string,
+      pools: string[],
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<PopulatedTransaction>;
 
-    fund(
-      rewardsForEpoch: BigNumberish[],
-      overrides?: Overrides & { from?: string | Promise<string> }
-    ): Promise<PopulatedTransaction>;
-
-    incentivesForEpoch(
-      epoch: BigNumberish,
-      overrides?: Overrides & { from?: string | Promise<string> }
-    ): Promise<PopulatedTransaction>;
+    getAllPools(overrides?: CallOverrides): Promise<PopulatedTransaction>;
   };
 }