@pendle/core-v2 6.4.4-unichain → 6.5.0

package/contracts/LiquidityMining/VotingController/PendleVotingControllerUpg.sol

@@ -1,304 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity ^0.8.17;
-
-import "../../core/libraries/math/PMath.sol";
-import "../../interfaces/IPGaugeControllerMainchain.sol";
-import "../../interfaces/IPVotingController.sol";
-import "../CrossChainMsg/PendleMsgSenderAppUpg.sol";
-import "../libraries/VeBalanceLib.sol";
-import "./VotingControllerStorageUpg.sol";
-import "@openzeppelin/contracts/proxy/utils/UUPSUpgradeable.sol";
-
-/*
-Voting accounting:
-    - For gauge controller, it will consider each message from voting controller
-    as a pack of money to incentivize it during the very next WEEK (block.timestamp -> block.timestamp + WEEK)
-    - If the reward duration for the last pack of money has not ended, it will combine
-    the leftover reward with the current reward to distribute.
-
-    - In the very extreme case where no one broadcast the result of week x, and at week x+1,
-    the results for both are now broadcasted, then the WEEK of (block.timestamp -> WEEK)
-    will receive both of the reward pack
-    - Each pack of money will has it own id as timestamp, a gauge controller does not
-    receive a pack of money with the same id twice, this allow governance to rebroadcast
-    in case the last message was corrupted by LayerZero
-
-Pros:
-    - If governance does not forget broadcasting the reward on the early of the week,
-    the mechanism works just the same as the epoch-based one
-    - If governance forget to broadcast the reward, the whole system still works normally,
-    the reward is still incentivized, but only approximately fair
-Cons:
-    - Does not guarantee the reward will be distributed on epoch start and end
-*/
-
-contract PendleVotingControllerUpg is PendleMsgSenderAppUpg, VotingControllerStorageUpg, UUPSUpgradeable {
-    using VeBalanceLib for VeBalance;
-    using PMath for uint256;
-    using PMath for int256;
-    using EnumerableMap for EnumerableMap.UintToAddressMap;
-    using EnumerableSet for EnumerableSet.AddressSet;
-
-    constructor(address _vePendle, address _pendleMsgSendEndpoint, uint256 initialApproxDestinationGas)
-        VotingControllerStorageUpg(_vePendle)
-        PendleMsgSenderAppUpg(_pendleMsgSendEndpoint, initialApproxDestinationGas) // constructor only set immutable
-        // variables
-        initializer
-        //solhint-disable-next-line
-
-    {}
-
-    function initialize(address _owner) external initializer {
-        __BoringOwnableV2_init(_owner);
-        deployedWTime = WeekMath.getCurrentWeekStart();
-    }
-
-    /*///////////////////////////////////////////////////////////////
-                FUNCTIONS CAN BE CALLED BY ANYONE
-    //////////////////////////////////////////////////////////////*/
-
-    /**
-     * @notice updates a user's vote weights, also allowing user to divide their voting power
-     * across different pools
-     * @param pools pools to change vote weights, if not listed then existing weight won't change
-     * @param weights voting weight on each pool in `pools`, must be same length as `pools`
-     * @dev A user's max voting weights is equal to `USER_VOTE_MAX_WEIGHT` (1e18). If their total
-     * voted weights is less than such, then the excess weight is not counted. For such reason, a
-     * user's voting power will only be fully utilized if their total voted weight is exactly 1e18.
-     * @dev Reverts if, after all vote changes, the total voted weight is more than 1e18.
-     * @dev A removed pool can be included, but the new weight must be 0, otherwise will revert.
-     * @dev See {`VotingControllerStorageUpg - getUserData()`} for current user data.
-     */
-    function vote(address[] calldata pools, uint64[] calldata weights) external {
-        address user = msg.sender;
-
-        if (pools.length != weights.length) revert Errors.ArrayLengthMismatch();
-        if (user != owner && vePendle.balanceOf(user) == 0) revert Errors.VCZeroVePendle(user);
-
-        LockedPosition memory userPosition = _getUserVePendlePosition(user);
-
-        for (uint256 i = 0; i < pools.length; ++i) {
-            if (_isPoolActive(pools[i])) applyPoolSlopeChanges(pools[i]);
-            VeBalance memory newVote = _modifyVoteWeight(user, pools[i], userPosition, weights[i]);
-            emit Vote(user, pools[i], weights[i], newVote);
-        }
-
-        uint256 totalVotedWeight = userData[user].totalVotedWeight;
-        if (totalVotedWeight > VeBalanceLib.USER_VOTE_MAX_WEIGHT) {
-            revert Errors.VCExceededMaxWeight(totalVotedWeight, VeBalanceLib.USER_VOTE_MAX_WEIGHT);
-        }
-    }
-
-    /**
-     * @notice Process all the slopeChanges that haven't been processed & update these data into
-     * poolData
-     * @dev reverts if pool is not active
-     * @dev if pool is already up-to-date, the function will succeed without any state updates
-     */
-    function applyPoolSlopeChanges(address pool) public {
-        if (!_isPoolActive(pool)) revert Errors.VCInactivePool(pool);
-
-        uint128 wTime = poolData[pool].lastSlopeChangeAppliedAt;
-        uint128 currentWeekStart = WeekMath.getCurrentWeekStart();
-
-        // no state changes are expected
-        if (wTime >= currentWeekStart) return;
-
-        VeBalance memory currentVote = poolData[pool].totalVote;
-        while (wTime < currentWeekStart) {
-            wTime += WEEK;
-            currentVote = currentVote.sub(poolData[pool].slopeChanges[wTime], wTime);
-            _setFinalPoolVoteForWeek(pool, wTime, currentVote.getValueAt(wTime));
-        }
-
-        _setNewVotePoolData(pool, currentVote, wTime);
-    }
-
-    /**
-     * @notice finalize the voting results of all pools, up to the current epoch
-     * @dev See `applyPoolSlopeChanges()` for more details
-     * @dev This function might be gas-costly if there are a lot of active pools, but this can be
-     * mitigated by calling `applyPoolSlopeChanges()` for each pool separately, spreading the gas
-     * cost across multiple txs (although the total gas cost will be higher).
-     * This is because `applyPoolSlopeChanges()` will not update anything if already up-to-date.
-     */
-    function finalizeEpoch() public {
-        uint256 length = allActivePools.length();
-        for (uint256 i = 0; i < length; ++i) {
-            applyPoolSlopeChanges(allActivePools.at(i));
-        }
-        _setAllPastEpochsAsFinalized();
-    }
-
-    /**
-     * @notice broadcast the voting results of the current week to the chain with chainId. Can be
-     * called by anyone.
-     * @dev It's intentional to allow the same results to be broadcasted multiple
-     * times. The receiver should be able to filter these duplicated messages
-     * @dev The epoch must have already been finalized by `finalizeEpoch()`, otherwise will revert.
-     */
-    function broadcastResults(uint64 chainId) external payable refundUnusedEth {
-        uint128 wTime = WeekMath.getCurrentWeekStart();
-        if (!weekData[wTime].isEpochFinalized) revert Errors.VCEpochNotFinalized(wTime);
-        _broadcastResults(chainId, wTime, pendlePerSec, globalCap);
-    }
-
-    /*///////////////////////////////////////////////////////////////
-                    GOVERNANCE-ONLY FUNCTIONS
-    //////////////////////////////////////////////////////////////*/
-
-    modifier onlyAddPoolHelperAndOwner() {
-        require(msg.sender == addPoolHelper || msg.sender == owner, "add pool not allowed");
-        _;
-    }
-
-    modifier onlyRemovePoolHelperAndOwner() {
-        require(msg.sender == removePoolHelper || msg.sender == owner, "remove pool not allowed");
-        _;
-    }
-
-    /**
-     * @notice add a pool to allow users to vote. Can only be done by [governance/owner helper]
-     * @custom:gov NOTE TO GOV:
-     * - Previous week's results should have been broadcasted prior to calling this function.
-     * - `pool` must not have been added before (even if has been removed).
-     * - `chainId` must be valid.
-     */
-    function addMultiPools(uint64[] memory chainIds, address[] memory pools) external onlyAddPoolHelperAndOwner {
-        if (chainIds.length != pools.length) revert Errors.ArrayLengthMismatch();
-        for (uint256 i = 0; i < chainIds.length; ++i) {
-            (uint64 chainId, address pool) = (chainIds[i], pools[i]);
-            if (_isPoolActive(pool)) revert Errors.VCPoolAlreadyActive(pool);
-            if (allRemovedPools.contains(pool)) revert Errors.VCPoolAlreadyAddAndRemoved(pool);
-
-            _addPool(chainId, pool);
-            emit AddPool(chainId, pool);
-        }
-    }
-
-    /**
-     * @notice remove a pool from voting. Can only be done by governance
-     * @custom:gov NOTE TO GOV:
-     * - Previous week's results should have been broadcasted prior to calling this function.
-     * - `pool` must be currently active.
-     */
-
-    function removeMultiPools(address[] calldata pools) external onlyRemovePoolHelperAndOwner {
-        for (uint256 i = 0; i < pools.length; ++i) {
-            address pool = pools[i];
-            if (!_isPoolActive(pool)) revert Errors.VCInactivePool(pool);
-
-            uint64 chainId = poolData[pool].chainId;
-
-            applyPoolSlopeChanges(pool);
-            _removePool(pool);
-
-            emit RemovePool(chainId, pool);
-        }
-    }
-
-    /**
-     * @notice set the cap for a pool, or remove cap (using global cap) if `cap` is 0
-     */
-    function setPoolCaps(address[] calldata pools, uint256[] calldata caps) external onlyAddPoolHelperAndOwner {
-        if (pools.length != caps.length) revert Errors.ArrayLengthMismatch();
-        for (uint256 i = 0; i < pools.length; ++i) {
-            _setPoolCap(pools[i], caps[i]);
-        }
-        emit SetPoolCaps(pools, caps);
-    }
-
-    function setGlobalCap(uint256 cap) external onlyOwner {
-        _setGlobalCap(cap);
-        emit SetGlobalCap(cap);
-    }
-
-    /**
-     * @notice use the gov-privilege to force broadcast a message in case there are issues with LayerZero
-     * @custom:gov NOTE TO GOV: gov should always call finalizeEpoch beforehand
-     */
-    function forceBroadcastResults(uint64 chainId, uint128 wTime, uint128 forcedPendlePerSec)
-        external
-        payable
-        onlyOwner
-        refundUnusedEth
-    {
-        _broadcastResults(chainId, wTime, forcedPendlePerSec, globalCap);
-    }
-
-    /**
-     * @notice sets new pendlePerSec
-     * @dev no zero checks because gov may want to stop liquidity mining
-     * @custom:gov NOTE TO GOV: Should be done mid-week, well before the next broadcast to avoid
-     * race condition
-     */
-    function setPendlePerSec(uint128 newPendlePerSec) external onlyOwner {
-        pendlePerSec = newPendlePerSec;
-        emit SetPendlePerSec(newPendlePerSec);
-    }
-
-    function getBroadcastResultFee(uint64 chainId) external view returns (uint256) {
-        if (chainId == block.chainid) return 0; // Mainchain broadcast
-
-        uint256 length = activeChainPools[chainId].length();
-        if (length == 0) return 0;
-
-        address[] memory pools = new address[](length);
-        uint256[] memory totalPendleAmounts = new uint256[](length);
-
-        return _getSendMessageFee(chainId, abi.encode(uint128(0), pools, totalPendleAmounts));
-    }
-
-    /*///////////////////////////////////////////////////////////////
-                    INTERNAL FUNCTIONS
-    //////////////////////////////////////////////////////////////*/
-
-    /// @notice broadcast voting results of the timestamp to chainId
-    function _broadcastResults(uint64 chainId, uint128 wTime, uint128 totalPendlePerSec, uint256 currentGlobalCap)
-        internal
-    {
-        uint256 totalVotes = weekData[wTime].totalVotes;
-        if (totalVotes == 0) return;
-
-        uint256 length = activeChainPools[chainId].length();
-        if (length == 0) return;
-
-        address[] memory pools = activeChainPools[chainId].values();
-        uint256[] memory totalPendleAmounts = new uint256[](length);
-
-        for (uint256 i = 0; i < length; ++i) {
-            uint256 poolVotes = weekData[wTime].poolVotes[pools[i]];
-            uint256 cappedRate = PMath.min(_getPoolCapOpt(pools[i], currentGlobalCap), poolVotes.divDown(totalVotes));
-            totalPendleAmounts[i] = (uint256(totalPendlePerSec) * WEEK).mulDown(cappedRate);
-        }
-
-        if (chainId == block.chainid) {
-            address gaugeController = destinationContracts.get(chainId);
-            IPGaugeControllerMainchain(gaugeController).updateVotingResults(wTime, pools, totalPendleAmounts);
-        } else {
-            _sendMessage(chainId, abi.encode(wTime, pools, totalPendleAmounts));
-        }
-
-        emit BroadcastResults(chainId, wTime, totalPendlePerSec);
-    }
-
-    function _getUserVePendlePosition(address user) internal view returns (LockedPosition memory userPosition) {
-        if (user == owner) {
-            (userPosition.amount, userPosition.expiry) =
-            (GOVERNANCE_PENDLE_VOTE, WeekMath.getWeekStartTimestamp(uint128(block.timestamp) + MAX_LOCK_TIME));
-        } else {
-            (userPosition.amount, userPosition.expiry) = vePendle.positionData(user);
-        }
-    }
-
-    function setAddPoolHelper(address _helper) public onlyOwner {
-        addPoolHelper = _helper;
-    }
-
-    function setRemovePoolHelper(address _helper) public onlyOwner {
-        removePoolHelper = _helper;
-    }
-
-    //solhint-disable-next-line
-    function _authorizeUpgrade(address newImplementation) internal override onlyOwner {}
-}

package/contracts/LiquidityMining/VotingController/VotingControllerStorageUpg.sol

@@ -1,301 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity ^0.8.17;
-
-import "../../interfaces/IPVeToken.sol";
-import "../../interfaces/IPVotingController.sol";
-
-import "../libraries/VeBalanceLib.sol";
-import "../libraries/VeHistoryLib.sol";
-import "../libraries/WeekMath.sol";
-
-import "../../core/libraries/Errors.sol";
-import "../../core/libraries/MiniHelpers.sol";
-
-import "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
-
-abstract contract VotingControllerStorageUpg is IPVotingController {
-    using VeBalanceLib for VeBalance;
-    using VeBalanceLib for LockedPosition;
-    using EnumerableSet for EnumerableSet.AddressSet;
-    using Checkpoints for Checkpoints.History;
-    using WeekMath for uint128;
-
-    struct PoolData {
-        uint64 chainId;
-        uint128 lastSlopeChangeAppliedAt;
-        VeBalance totalVote;
-        // wTime => slopeChange value
-        mapping(uint128 => uint128) slopeChanges;
-    }
-
-    struct UserPoolData {
-        uint64 weight;
-        VeBalance vote;
-    }
-
-    struct UserData {
-        uint64 totalVotedWeight;
-        mapping(address => UserPoolData) voteForPools;
-    }
-
-    struct WeekData {
-        bool isEpochFinalized;
-        uint128 totalVotes;
-        mapping(address => uint128) poolVotes;
-    }
-
-    uint128 public constant MAX_LOCK_TIME = 104 weeks;
-    uint128 public constant WEEK = 1 weeks;
-    uint128 public constant GOVERNANCE_PENDLE_VOTE = 10 * (10 ** 6) * (10 ** 18); // 10 mils of PENDLE
-
-    IPVeToken public immutable vePendle;
-
-    uint128 public deployedWTime;
-
-    uint128 public pendlePerSec;
-
-    EnumerableSet.AddressSet internal allActivePools;
-
-    EnumerableSet.AddressSet internal allRemovedPools;
-
-    // [chainId] => [pool]
-    mapping(uint64 => EnumerableSet.AddressSet) internal activeChainPools;
-
-    // [poolAddress] -> PoolData
-    mapping(address => PoolData) internal poolData;
-
-    // [wTime] => WeekData
-    mapping(uint128 => WeekData) internal weekData;
-
-    // user voting data
-    mapping(address => UserData) internal userData;
-
-    // [user][pool] => checkpoint
-    mapping(address => mapping(address => Checkpoints.History)) internal __dep_userPoolHistory;
-
-    address public addPoolHelper;
-    address public removePoolHelper;
-
-    // [pool] => cap
-    mapping(address => uint256) public poolCaps;
-
-    uint256 public globalCap;
-
-    uint256[96] private __gap;
-
-    constructor(address _vePendle) {
-        vePendle = IPVeToken(_vePendle);
-    }
-
-    /*///////////////////////////////////////////////////////////////
-                            VIEW FUNCTIONS
-    //////////////////////////////////////////////////////////////*/
-
-    function getPoolCap(address pool) public view returns (uint256) {
-        uint256 cap = poolCaps[pool];
-        return (cap != 0) ? cap : globalCap;
-    }
-
-    function getPoolTotalVoteAt(address pool, uint128 wTime) public view returns (uint128) {
-        return weekData[wTime].poolVotes[pool];
-    }
-
-    /// @notice deprecated, only kept for compatibility reasons
-    function getUserPoolHistoryLength(address user, address pool) external view returns (uint256) {
-        return __dep_userPoolHistory[user][pool].length();
-    }
-
-    /// @notice deprecated, only kept for compatibility reasons
-    function getUserPoolHistoryAt(address user, address pool, uint256 index) external view returns (Checkpoint memory) {
-        return __dep_userPoolHistory[user][pool].get(index);
-    }
-
-    function getPoolData(address pool, uint128[] calldata wTimes)
-        public
-        view
-        returns (
-            uint64 chainId,
-            uint128 lastSlopeChangeAppliedAt,
-            VeBalance memory totalVote,
-            uint128[] memory slopeChanges
-        )
-    {
-        PoolData storage data = poolData[pool];
-        (chainId, lastSlopeChangeAppliedAt, totalVote) = (data.chainId, data.lastSlopeChangeAppliedAt, data.totalVote);
-
-        slopeChanges = new uint128[](wTimes.length);
-        for (uint256 i = 0; i < wTimes.length; ++i) {
-            if (!wTimes[i].isValidWTime()) revert Errors.InvalidWTime(wTimes[i]);
-            slopeChanges[i] = data.slopeChanges[wTimes[i]];
-        }
-    }
-
-    function getUserData(address user, address[] calldata pools)
-        public
-        view
-        returns (uint64 totalVotedWeight, UserPoolData[] memory voteForPools)
-    {
-        UserData storage data = userData[user];
-
-        totalVotedWeight = data.totalVotedWeight;
-
-        voteForPools = new UserPoolData[](pools.length);
-        for (uint256 i = 0; i < pools.length; ++i) {
-            voteForPools[i] = data.voteForPools[pools[i]];
-        }
-    }
-
-    function getWeekData(uint128 wTime, address[] calldata pools)
-        public
-        view
-        returns (bool isEpochFinalized, uint128 totalVotes, uint128[] memory poolVotes)
-    {
-        if (!wTime.isValidWTime()) revert Errors.InvalidWTime(wTime);
-
-        WeekData storage data = weekData[wTime];
-
-        (isEpochFinalized, totalVotes) = (data.isEpochFinalized, data.totalVotes);
-
-        poolVotes = new uint128[](pools.length);
-        for (uint256 i = 0; i < pools.length; ++i) {
-            poolVotes[i] = data.poolVotes[pools[i]];
-        }
-    }
-
-    function getAllActivePools() external view returns (address[] memory) {
-        return allActivePools.values();
-    }
-
-    function getAllRemovedPools(uint256 start, uint256 end)
-        external
-        view
-        returns (uint256 lengthOfRemovedPools, address[] memory arr)
-    {
-        lengthOfRemovedPools = allRemovedPools.length();
-
-        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);
-        }
-    }
-
-    function getActiveChainPools(uint64 chainId) external view returns (address[] memory) {
-        return activeChainPools[chainId].values();
-    }
-
-    function getUserPoolVote(address user, address pool) external view returns (UserPoolData memory) {
-        return userData[user].voteForPools[pool];
-    }
-
-    /*///////////////////////////////////////////////////////////////
-                INTERNAL DATA MANIPULATION FUNCTIONS
-    //////////////////////////////////////////////////////////////*/
-
-    function _addPool(uint64 chainId, address pool) internal {
-        if (!activeChainPools[chainId].add(pool)) assert(false);
-        if (!allActivePools.add(pool)) assert(false);
-
-        poolData[pool].chainId = chainId;
-        poolData[pool].lastSlopeChangeAppliedAt = WeekMath.getCurrentWeekStart();
-    }
-
-    function _removePool(address pool) internal {
-        uint64 chainId = poolData[pool].chainId;
-        if (!activeChainPools[chainId].remove(pool)) assert(false);
-        if (!allActivePools.remove(pool)) assert(false);
-        if (!allRemovedPools.add(pool)) assert(false);
-
-        delete poolData[pool];
-    }
-
-    function _setFinalPoolVoteForWeek(address pool, uint128 wTime, uint128 vote) internal {
-        weekData[wTime].totalVotes += vote;
-        weekData[wTime].poolVotes[pool] = vote;
-    }
-
-    function _setNewVotePoolData(address pool, VeBalance memory vote, uint128 wTime) internal {
-        poolData[pool].totalVote = vote;
-        poolData[pool].lastSlopeChangeAppliedAt = wTime;
-        emit PoolVoteChange(pool, vote);
-    }
-
-    /**
-     * @notice modifies `user`'s vote weight on `pool`
-     * @dev works by simply removing the old vote position, then adds in a fresh vote
-     */
-    function _modifyVoteWeight(address user, address pool, LockedPosition memory userPosition, uint64 weight)
-        internal
-        returns (VeBalance memory newVote)
-    {
-        UserData storage uData = userData[user];
-        PoolData storage pData = poolData[pool];
-
-        VeBalance memory oldVote = uData.voteForPools[pool].vote;
-
-        // REMOVE OLD VOTE
-        if (oldVote.bias != 0) {
-            if (_isPoolActive(pool) && _isVoteActive(oldVote)) {
-                pData.totalVote = pData.totalVote.sub(oldVote);
-                pData.slopeChanges[oldVote.getExpiry()] -= oldVote.slope;
-            }
-            uData.totalVotedWeight -= uData.voteForPools[pool].weight;
-            delete uData.voteForPools[pool];
-        }
-
-        // ADD NEW VOTE
-        if (weight != 0) {
-            if (!_isPoolActive(pool)) revert Errors.VCInactivePool(pool);
-
-            newVote = userPosition.convertToVeBalance(weight);
-
-            pData.totalVote = pData.totalVote.add(newVote);
-            pData.slopeChanges[newVote.getExpiry()] += newVote.slope;
-
-            uData.voteForPools[pool] = UserPoolData(weight, newVote);
-            uData.totalVotedWeight += weight;
-        }
-
-        emit PoolVoteChange(pool, pData.totalVote);
-    }
-
-    function _setAllPastEpochsAsFinalized() internal {
-        uint128 wTime = WeekMath.getCurrentWeekStart();
-        while (wTime > deployedWTime && weekData[wTime].isEpochFinalized == false) {
-            weekData[wTime].isEpochFinalized = true;
-            wTime -= WEEK;
-        }
-    }
-
-    function _isPoolActive(address pool) internal view returns (bool) {
-        return allActivePools.contains(pool);
-    }
-
-    /// @notice check if a vote still counts by checking if the vote is not (x,0) (in case the
-    /// weight of the vote is too small) & the expiry is after the current time
-    function _isVoteActive(VeBalance memory vote) internal view returns (bool) {
-        return vote.slope != 0 && !MiniHelpers.isCurrentlyExpired(vote.getExpiry());
-    }
-
-    function _setPoolCap(address pool, uint256 cap) internal {
-        _validateCap(cap);
-        poolCaps[pool] = cap;
-    }
-
-    function _setGlobalCap(uint256 cap) internal {
-        _validateCap(cap);
-        globalCap = cap;
-    }
-
-    function _getPoolCapOpt(address _pool, uint256 _globalCap) internal view returns (uint256) {
-        uint256 cap = poolCaps[_pool];
-        return (cap != 0) ? cap : _globalCap;
-    }
-
-    function _validateCap(uint256 cap) internal pure {
-        if (cap > PMath.ONE) {
-            revert Errors.VCInvalidCap(cap);
-        }
-    }
-}