@pendle/core-v2 0.11.11-testnet → 0.12.1-testnet

package/contracts/core/LiquidityMining/FeeDistributor/PendleFeeDistributor.sol

@@ -0,0 +1,96 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.15;
+
+import "../../../libraries/math/Math.sol";
+import "../../../libraries/helpers/ArrayLib.sol";
+import "../../../libraries/helpers/MiniHelpers.sol";
+import "../../../libraries/math/WeekMath.sol";
+import "../../../libraries/Errors.sol";
+import "../../../libraries/VeHistoryLib.sol";
+import "../../../interfaces/IPFeeDistributor.sol";
+import "../../../interfaces/IPFeeDistributorFactory.sol";
+import "../../../periphery/BoringOwnableUpgradeable.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/core/LiquidityMining/FeeDistributor/PendleFeeDistributorFactory.sol

@@ -0,0 +1,68 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.15;
+
+import "./PendleFeeDistributor.sol";
+import "./EpochResultManager.sol";
+import "../../../libraries/helpers/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/LiquidityMining/GaugeController/PendleGaugeControllerBaseUpg.sol

@@ -5,6 +5,7 @@ import "../../../interfaces/IPGaugeController.sol";
 import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
 import "../../../libraries/math/Math.sol";
 import "../../../libraries/math/WeekMath.sol";
+import "../../../libraries/Errors.sol";
 import "../../../interfaces/IPGaugeController.sol";
 import "../../../interfaces/IPMarketFactory.sol";
 import "../../../interfaces/IPMarket.sol";
@@ -35,7 +36,7 @@ abstract contract PendleGaugeControllerBaseUpg is IPGaugeController, BoringOwnab
         uint128 incentiveEndsAt;
     }
 
-    uint128 internal constant WEEK = 1 weeks;
+    uint128 internal constant WEEK = 1 days;
 
     address public immutable pendle;
     IPMarketFactory public immutable marketFactory;
@@ -46,7 +47,7 @@ abstract contract PendleGaugeControllerBaseUpg is IPGaugeController, BoringOwnab
     uint256[100] private __gap;
 
     modifier onlyPendleMarket() {
-        require(marketFactory.isValidMarket(msg.sender), "invalid market");
+        if (!marketFactory.isValidMarket(msg.sender)) revert Errors.GCNotPendleMarket(msg.sender);
         _;
     }
 
@@ -95,7 +96,7 @@ abstract contract PendleGaugeControllerBaseUpg is IPGaugeController, BoringOwnab
         address[] memory markets,
         uint256[] memory pendleAmounts
     ) internal {
-        require(markets.length == pendleAmounts.length, "invalid markets length");
+        if (markets.length != pendleAmounts.length) revert Errors.ArrayLengthMismatch();
 
         if (epochRewardReceived[wTime]) return; // only accept the first message for the wTime
         epochRewardReceived[wTime] = true;

package/contracts/core/LiquidityMining/GaugeController/PendleGaugeControllerMainchainUpg.sol

@@ -2,15 +2,19 @@
 pragma solidity 0.8.15;
 
 import "./PendleGaugeControllerBaseUpg.sol";
+import "../../../interfaces/IPGaugeControllerMainchain.sol";
 
 /// This contract is upgradable because
 /// - its constructor only sets immutable variables
 /// - it inherits only upgradable contract
-contract PendleGaugeControllerMainchainUpg is PendleGaugeControllerBaseUpg {
+contract PendleGaugeControllerMainchainUpg is
+    PendleGaugeControllerBaseUpg,
+    IPGaugeControllerMainchain
+{
     address public immutable votingController;
 
     modifier onlyVotingController() {
-        require(msg.sender == votingController, "not voting controller");
+        if (msg.sender != votingController) revert Errors.GCNotVotingController(msg.sender);
         _;
     }
 

package/contracts/core/LiquidityMining/GaugeController/PendleGaugeControllerSidechainUpg.sol

@@ -2,18 +2,26 @@
 pragma solidity 0.8.15;
 
 import "./PendleGaugeControllerBaseUpg.sol";
-import "../CelerAbstracts/CelerReceiverUpg.sol";
+import "../CrossChainMsg/PendleMsgReceiverAppUpg.sol";
 
 // solhint-disable no-empty-blocks
 
 /// This contract is upgradable because
 /// - its constructor only sets immutable variables
 /// - it inherits only upgradable contract
-contract PendleGaugeControllerSidechainUpg is PendleGaugeControllerBaseUpg, CelerReceiverUpg {
+contract PendleGaugeControllerSidechainUpg is
+    PendleGaugeControllerBaseUpg,
+    PendleMsgReceiverAppUpg
+{
     constructor(
         address _pendle,
-        address _marketFactory
-    ) PendleGaugeControllerBaseUpg(_pendle, _marketFactory) initializer {}
+        address _marketFactory,
+        address _PendleMsgReceiveEndpointUpg
+    )
+        PendleGaugeControllerBaseUpg(_pendle, _marketFactory)
+        PendleMsgReceiverAppUpg(_PendleMsgReceiveEndpointUpg)
+        initializer
+    {}
 
     function initialize() external initializer {
         __BoringOwnable_init();

package/contracts/core/LiquidityMining/VotingController/PendleVotingControllerUpg.sol

@@ -2,7 +2,7 @@
 pragma solidity 0.8.15;
 
 import "./VotingControllerStorageUpg.sol";
-import "../CelerAbstracts/CelerSenderUpg.sol";
+import "../CrossChainMsg/PendleMsgSenderAppUpg.sol";
 import "../../../libraries/VeBalanceLib.sol";
 import "../../../libraries/math/Math.sol";
 import "../../../interfaces/IPGaugeControllerMainchain.sol";
@@ -37,10 +37,9 @@ Cons:
 /// - it has storage gaps for safe addition of future variables
 /// - it inherits only upgradable contract
 contract PendleVotingControllerUpg is
-    CelerSenderUpg,
+    PendleMsgSenderAppUpg,
     VotingControllerStorageUpg,
-    UUPSUpgradeable,
-    IPVotingController
+    UUPSUpgradeable
 {
     using VeBalanceLib for VeBalance;
     using Math for uint256;
@@ -48,10 +47,14 @@ contract PendleVotingControllerUpg is
     using EnumerableMap for EnumerableMap.UintToAddressMap;
     using EnumerableSet for EnumerableSet.AddressSet;
 
-    constructor(address _vePendle)
-        VotingControllerStorageUpg(_vePendle) // constructor only set immutable variables
+    constructor(address _vePendle, address _pendleMsgSendEndpoint)
+        VotingControllerStorageUpg(_vePendle)
+        PendleMsgSenderAppUpg(_pendleMsgSendEndpoint) // constructor only set immutable variables
         initializer
-    {}
+    //solhint-disable-next-line
+    {
+
+    }
 
     function initialize() external initializer {
         __BoringOwnable_init();
@@ -72,8 +75,8 @@ contract PendleVotingControllerUpg is
     function vote(address[] calldata pools, uint64[] calldata weights) external {
         address user = msg.sender;
 
-        require(weights.length == pools.length, "invalid array length");
-        require(vePendle.balanceOf(user) > 0 || user == owner, "zero vePENDLE balance");
+        if (pools.length != weights.length) revert Errors.ArrayLengthMismatch();
+        if (user != owner && vePendle.balanceOf(user) == 0) revert Errors.VCZeroVePendle(user);
 
         UserData storage uData = userData[user];
         LockedPosition memory userPosition = _getUserVePendlePosition(user);
@@ -84,10 +87,11 @@ contract PendleVotingControllerUpg is
             emit Vote(user, pools[i], weights[i], newVote);
         }
 
-        require(
-            uData.totalVotedWeight <= VeBalanceLib.USER_VOTE_MAX_WEIGHT,
-            "exceeded max weight"
-        );
+        if (uData.totalVotedWeight > VeBalanceLib.USER_VOTE_MAX_WEIGHT)
+            revert Errors.VCExceededMaxWeight(
+                uData.totalVotedWeight,
+                VeBalanceLib.USER_VOTE_MAX_WEIGHT
+            );
     }
 
     /**
@@ -99,7 +103,7 @@ contract PendleVotingControllerUpg is
         - update poolData
      */
     function applyPoolSlopeChanges(address pool) public {
-        require(_isPoolActive(pool), "invalid pool");
+        if (!_isPoolActive(pool)) revert Errors.VCInactivePool(pool);
 
         uint128 wTime = poolData[pool].lastSlopeChangeAppliedAt;
         uint128 currentWeekStart = WeekMath.getCurrentWeekStart();
@@ -143,7 +147,7 @@ contract PendleVotingControllerUpg is
      */
     function broadcastResults(uint64 chainId) external payable refundUnusedEth {
         uint128 wTime = WeekMath.getCurrentWeekStart();
-        require(weekData[wTime].isEpochFinalized, "epoch not finalized");
+        if (!weekData[wTime].isEpochFinalized) revert Errors.VCEpochNotFinalized(wTime);
         _broadcastResults(chainId, wTime, pendlePerSec);
     }
 
@@ -162,8 +166,8 @@ contract PendleVotingControllerUpg is
       this function
      */
     function addPool(uint64 chainId, address pool) external onlyOwner {
-        require(!_isPoolActive(pool), "pool already added");
-        require(!allRemovedPools.contains(pool), "not allowed to add a removed pool");
+        if (_isPoolActive(pool)) revert Errors.VCPoolAlreadyActive(pool);
+        if (allRemovedPools.contains(pool)) revert Errors.VCPoolAlreadyAddAndRemoved(pool);
 
         _addPool(chainId, pool);
         emit AddPool(chainId, pool);
@@ -180,7 +184,7 @@ contract PendleVotingControllerUpg is
       this function
      */
     function removePool(address pool) external onlyOwner {
-        require(_isPoolActive(pool), "invalid pool");
+        if (!_isPoolActive(pool)) revert Errors.VCInactivePool(pool);
 
         uint64 chainId = poolData[pool].chainId;
 
@@ -227,7 +231,12 @@ contract PendleVotingControllerUpg is
         address[] memory pools = new address[](length);
         uint256[] memory totalPendleAmounts = new uint256[](length);
 
-        return celerMessageBus.calcFee(abi.encode(uint128(0), pools, totalPendleAmounts));
+        return
+            pendleMsgSendEndpoint.calcFee(
+                destinationContracts.get(chainId),
+                chainId,
+                abi.encode(uint128(0), pools, totalPendleAmounts)
+            );
     }
 
     /*///////////////////////////////////////////////////////////////
@@ -288,5 +297,6 @@ contract PendleVotingControllerUpg is
         }
     }
 
+    //solhint-disable-next-line
     function _authorizeUpgrade(address newImplementation) internal override onlyOwner {}
 }

package/contracts/core/LiquidityMining/VotingController/VotingControllerStorageUpg.sol

@@ -6,13 +6,15 @@ import "../../../libraries/VeBalanceLib.sol";
 import "../../../libraries/math/WeekMath.sol";
 import "../../../libraries/helpers/MiniHelpers.sol";
 import "../../../libraries/VeHistoryLib.sol";
+import "../../../libraries/Errors.sol";
+import "../../../interfaces/IPVotingController.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 {
+abstract contract VotingControllerStorageUpg is IPVotingController {
     using VeBalanceLib for VeBalance;
     using VeBalanceLib for LockedPosition;
     using EnumerableSet for EnumerableSet.AddressSet;
@@ -44,7 +46,7 @@ abstract contract VotingControllerStorageUpg {
     }
 
     uint128 public constant MAX_LOCK_TIME = 104 weeks;
-    uint128 public constant WEEK = 1 weeks;
+    uint128 public constant WEEK = 1 days;
     uint128 public constant GOVERNANCE_PENDLE_VOTE = 10**24;
 
     IPVeToken public immutable vePendle;
@@ -83,6 +85,10 @@ abstract contract VotingControllerStorageUpg {
                             VIEW FUNCTIONS
     //////////////////////////////////////////////////////////////*/
 
+    function getPoolTotalVoteAt(address pool, uint128 wTime) public view returns (uint128) {
+        return weekData[wTime].poolVotes[pool];
+    }
+
     function getPoolData(address pool, uint128[] calldata wTimes)
         public
         view
@@ -102,7 +108,7 @@ abstract contract VotingControllerStorageUpg {
 
         slopeChanges = new uint128[](wTimes.length);
         for (uint256 i = 0; i < wTimes.length; ++i) {
-            require(wTimes[i].isValidWTime(), "invalid wTimes");
+            if (!wTimes[i].isValidWTime()) revert Errors.InvalidWTime(wTimes[i]);
             slopeChanges[i] = data.slopeChanges[wTimes[i]];
         }
     }
@@ -129,7 +135,7 @@ abstract contract VotingControllerStorageUpg {
             uint128[] memory poolVotes
         )
     {
-        require(wTime.isValidWTime(), "invalid wTimes");
+        if (!wTime.isValidWTime()) revert Errors.InvalidWTime(wTime);
 
         WeekData storage data = weekData[wTime];
 
@@ -151,7 +157,9 @@ abstract contract VotingControllerStorageUpg {
         returns (uint256 lengthOfRemovedPools, address[] memory arr)
     {
         lengthOfRemovedPools = allRemovedPools.length();
-        require(end < lengthOfRemovedPools, "end is out of bounds");
+
+        if (end >= lengthOfRemovedPools) revert Errors.ArrayOutOfBounds();
+
         arr = new address[](end - start + 1);
         for (uint256 i = start; i <= end; ++i) arr[i - start] = allRemovedPools.at(i);
     }
@@ -170,16 +178,16 @@ abstract contract VotingControllerStorageUpg {
         return userData[user].voteForPools[pool];
     }
 
-    /**
-     * @dev binary search to get the vote of an user on a pool at a specific timestamp
-     * @param timestamp can be any time, not necessary divisible by week
-     */
-    function getUserPoolVoteAt(
+    function getUserPoolHistoryLength(address user, address pool) external view returns (uint256) {
+        return userPoolHistory[user][pool].length();
+    }
+
+    function getUserPoolHistoryAt(
         address user,
         address pool,
-        uint128 timestamp
-    ) external view returns (uint128) {
-        return userPoolHistory[user][pool].getAtTimestamp(timestamp);
+        uint256 index
+    ) external view returns (Checkpoint memory) {
+        return userPoolHistory[user][pool].get(index);
     }
 
     /*///////////////////////////////////////////////////////////////
@@ -192,8 +200,8 @@ abstract contract VotingControllerStorageUpg {
         - set params in poolData
      */
     function _addPool(uint64 chainId, address pool) internal {
-        require(activeChainPools[chainId].add(pool), "IE");
-        require(allActivePools.add(pool), "IE");
+        if (!activeChainPools[chainId].add(pool)) assert(false);
+        if (!allActivePools.add(pool)) assert(false);
 
         poolData[pool].chainId = chainId;
         poolData[pool].lastSlopeChangeAppliedAt = WeekMath.getCurrentWeekStart();
@@ -207,9 +215,9 @@ abstract contract VotingControllerStorageUpg {
      */
     function _removePool(address pool) internal {
         uint64 chainId = poolData[pool].chainId;
-        require(activeChainPools[chainId].remove(pool), "IE");
-        require(allActivePools.remove(pool), "IE");
-        require(allRemovedPools.add(pool), "IE");
+        if (!activeChainPools[chainId].remove(pool)) assert(false);
+        if (!allActivePools.remove(pool)) assert(false);
+        if (!allRemovedPools.add(pool)) assert(false);
 
         delete poolData[pool];
     }
@@ -259,7 +267,7 @@ abstract contract VotingControllerStorageUpg {
 
         // ADD NEW VOTE
         if (weight != 0) {
-            require(_isPoolActive(pool), "pool not active");
+            if (!_isPoolActive(pool)) revert Errors.VCInactivePool(pool);
 
             newVote = userPosition.convertToVeBalance(weight);
 

package/contracts/core/LiquidityMining/VotingEscrow/VotingEscrowPendleMainchain.sol

@@ -1,14 +1,19 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity 0.8.15;
-import "../../../interfaces/IPVotingEscrow.sol";
+import "../../../interfaces/IPVotingEscrowMainchain.sol";
 import "../../../libraries/helpers/MiniHelpers.sol";
 import "./VotingEscrowTokenBase.sol";
-import "../CelerAbstracts/CelerSenderUpg.sol";
+import "../CrossChainMsg/PendleMsgSenderAppUpg.sol";
 import "../../../libraries/VeHistoryLib.sol";
+import "../../../libraries/Errors.sol";
 import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
 import "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
 
-contract VotingEscrowPendleMainchain is IPVotingEscrow, VotingEscrowTokenBase, CelerSenderUpg {
+contract VotingEscrowPendleMainchain is
+    VotingEscrowTokenBase,
+    IPVotingEscrowMainchain,
+    PendleMsgSenderAppUpg
+{
     using SafeERC20 for IERC20;
     using VeBalanceLib for VeBalance;
     using VeBalanceLib for LockedPosition;
@@ -34,11 +39,11 @@ contract VotingEscrowPendleMainchain is IPVotingEscrow, VotingEscrowTokenBase, C
     // to ask for their vePendle balance at any wTime
     mapping(address => Checkpoints.History) internal userHistory;
 
-    constructor(IERC20 _pendle) {
+    constructor(IERC20 _pendle, address _pendleMsgSendEndpoint)
+        initializer
+        PendleMsgSenderAppUpg(_pendleMsgSendEndpoint)
+    {
         pendle = _pendle;
-    }
-
-    function initialize() external initializer {
         __BoringOwnable_init();
     }
 
@@ -67,17 +72,17 @@ contract VotingEscrowPendleMainchain is IPVotingEscrow, VotingEscrowTokenBase, C
         returns (uint128 newVeBalance)
     {
         address user = msg.sender;
-        require(
-            WeekMath.isValidWTime(newExpiry) && !MiniHelpers.isTimeInThePast(newExpiry),
-            "invalid newExpiry"
-        );
 
-        require(newExpiry <= block.timestamp + MAX_LOCK_TIME, "max lock time exceeded");
-        require(newExpiry >= block.timestamp + MIN_LOCK_TIME, "insufficient lock time");
-        require(positionData[user].expiry <= newExpiry, "new expiry must be after current expiry");
+        if (!WeekMath.isValidWTime(newExpiry)) revert Errors.InvalidWTime(newExpiry);
+        if (MiniHelpers.isTimeInThePast(newExpiry)) revert Errors.ExpiryInThePast(newExpiry);
+
+        if (newExpiry < positionData[user].expiry) revert Errors.VENotAllowedReduceExpiry();
+
+        if (newExpiry > block.timestamp + MAX_LOCK_TIME) revert Errors.VEExceededMaxLockTime();
+        if (newExpiry < block.timestamp + MIN_LOCK_TIME) revert Errors.VEInsufficientLockTime();
 
         uint128 newTotalAmountLocked = additionalAmountToLock + positionData[user].amount;
-        require(newTotalAmountLocked > 0, "zero total amount locked");
+        if (newTotalAmountLocked == 0) revert Errors.VEZeroAmountLocked();
 
         uint128 additionalDurationToLock = newExpiry - positionData[user].expiry;
 
@@ -102,10 +107,11 @@ contract VotingEscrowPendleMainchain is IPVotingEscrow, VotingEscrowTokenBase, C
      */
     function withdraw() external returns (uint128 amount) {
         address user = msg.sender;
-        require(_isPositionExpired(user), "position not expired");
+
+        if (!_isPositionExpired(user)) revert Errors.VEPositionNotExpired();
         amount = positionData[user].amount;
 
-        require(amount > 0, "zero position");
+        if (amount == 0) revert Errors.VEZeroPosition();
 
         delete positionData[user];
 
@@ -148,21 +154,50 @@ contract VotingEscrowPendleMainchain is IPVotingEscrow, VotingEscrowTokenBase, C
         payable
         refundUnusedEth
     {
-        require(user != address(0), "zero address user");
+        if (user == address(0)) revert Errors.ZeroAddress();
         _broadcastPosition(user, chainIds);
     }
 
-    /// @notice binary search to find balance at a timestamp. This timestamp does not need to be divisible by week
-    function getUserVeBalanceAt(address user, uint128 timestamp) external view returns (uint128) {
-        return userHistory[user].getAtTimestamp(timestamp);
+    function getUserHistoryLength(address user) external view returns (uint256) {
+        return userHistory[user].length();
     }
 
-    function getBroadcastSupplyFee(uint256[] calldata chainIds) external view returns (uint256) {
-        return celerMessageBus.calcFee(SAMPLE_SUPPLY_UPDATE_MESSAGE) * chainIds.length;
+    function getUserHistoryAt(address user, uint256 index)
+        external
+        view
+        returns (Checkpoint memory)
+    {
+        return userHistory[user].get(index);
     }
 
-    function getBroadcastPositionFee(uint256[] calldata chainIds) external view returns (uint256) {
-        return celerMessageBus.calcFee(SAMPLE_POSITION_UPDATE_MESSAGE) * chainIds.length;
+    function getBroadcastSupplyFee(uint256[] calldata chainIds)
+        external
+        view
+        returns (uint256[] memory fees)
+    {
+        fees = new uint256[](chainIds.length);
+        for (uint256 i = 0; i < chainIds.length; i++) {
+            fees[i] = pendleMsgSendEndpoint.calcFee(
+                destinationContracts.get(chainIds[i]),
+                chainIds[i],
+                SAMPLE_SUPPLY_UPDATE_MESSAGE
+            );
+        }
+    }
+
+    function getBroadcastPositionFee(uint256[] calldata chainIds)
+        external
+        view
+        returns (uint256[] memory fees)
+    {
+        fees = new uint256[](chainIds.length);
+        for (uint256 i = 0; i < chainIds.length; i++) {
+            fees[i] = pendleMsgSendEndpoint.calcFee(
+                destinationContracts.get(chainIds[i]),
+                chainIds[i],
+                SAMPLE_POSITION_UPDATE_MESSAGE
+            );
+        }
     }
 
     /**
@@ -236,7 +271,7 @@ contract VotingEscrowPendleMainchain is IPVotingEscrow, VotingEscrowTokenBase, C
 
     /// @notice broadcast position to all chains in chainIds
     function _broadcastPosition(address user, uint256[] calldata chainIds) internal {
-        require(chainIds.length != 0, "empty chainIds");
+        if (chainIds.length == 0) revert Errors.ArrayEmpty();
 
         (VeBalance memory supply, uint128 wTime) = _applySlopeChange();
 
@@ -245,7 +280,8 @@ contract VotingEscrowPendleMainchain is IPVotingEscrow, VotingEscrowTokenBase, C
         );
 
         for (uint256 i = 0; i < chainIds.length; ++i) {
-            require(destinationContracts.contains(chainIds[i]), "not supported chain");
+            if (!destinationContracts.contains(chainIds[i]))
+                revert Errors.ChainNotSupported(chainIds[i]);
             _broadcast(chainIds[i], wTime, supply, userData);
         }