@pendle/core-v2 0.6.8 → 0.7.0

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

@@ -0,0 +1,224 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.13;
+
+import "../../../interfaces/IPVeToken.sol";
+import "../../../libraries/VeBalanceLib.sol";
+import "../../../libraries/math/WeekMath.sol";
+import "../../../libraries/helpers/MiniHelpers.sol";
+import "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
+
+// no reentracy protection yet?
+// Should VotingController and stuff become upgradeable?
+abstract contract VotingControllerStorage {
+    using VeBalanceLib for VeBalance;
+    using EnumerableSet for EnumerableSet.AddressSet;
+
+    struct PoolInfo {
+        uint64 chainId;
+        uint128 lastUpdated;
+        VeBalance vote;
+        // wTime => slopeChange value
+        mapping(uint128 => uint128) slopeChanges;
+    }
+
+    struct UserPoolInfo {
+        uint64 weight;
+        VeBalance vote;
+    }
+
+    struct UserData {
+        uint64 totalVotedWeight;
+        mapping(address => UserPoolInfo) voteForPools;
+    }
+
+    struct WeekData {
+        uint128 totalVotes;
+        mapping(address => uint128) poolVotes;
+    }
+
+    uint128 internal constant MAX_LOCK_TIME = 104 weeks;
+    uint64 public constant USER_VOTE_MAX_WEIGHT = 10**18;
+    uint128 public constant WEEK = 1 weeks;
+    uint128 public constant GOVERNANCE_PENDLE_VOTE = 10**24;
+
+    IPVeToken public immutable vePendle;
+
+    uint128 public pendlePerSec;
+
+    uint128 public immutable deployedWTime; // divisible by WEEK
+
+    EnumerableSet.AddressSet internal allPools;
+
+    // [chainId] => [pool]
+    mapping(uint64 => EnumerableSet.AddressSet) internal chainPools;
+
+    // [poolAddress] -> PoolInfo
+    mapping(address => PoolInfo) public poolInfo;
+
+    // [wTime] => WeekData
+    mapping(uint128 => WeekData) public weekData;
+
+    // user voting info
+    mapping(address => UserData) public userData;
+
+    // wTime => bool
+    mapping(uint128 => bool) public isEpochFinalized;
+
+    // [user][pool] => checkpoint
+    mapping(address => mapping(address => Checkpoint[])) public userPoolCheckpoints;
+
+    constructor(address _vePendle) {
+        vePendle = IPVeToken(_vePendle);
+        deployedWTime = WeekMath.getCurrentWeekStart();
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                            VIEW FUNCTIONS
+    //////////////////////////////////////////////////////////////*/
+
+    /// @dev trivial view function
+    function getAllPools() external view returns (address[] memory) {
+        return allPools.values();
+    }
+
+    /// @dev trivial view function
+    function getChainPools(uint64 chainId) external view returns (address[] memory) {
+        return chainPools[chainId].values();
+    }
+
+    /// @dev trivial view function
+    function getUserPoolVote(address user, address pool)
+        external
+        view
+        returns (UserPoolInfo memory)
+    {
+        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(
+        address user,
+        address pool,
+        uint128 timestamp
+    ) external view returns (uint128) {
+        return VeBalanceLib.getCheckpointValueAt(userPoolCheckpoints[user][pool], timestamp);
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                            INTERNAL DATA MANIPULATION FUNCTIONS
+    //////////////////////////////////////////////////////////////*/
+
+    /**
+    * @dev expected behavior:
+        - add to allPools, chainPools
+        - set params in poolInfo
+     */
+    function _addPool(uint64 chainId, address pool) internal {
+        poolInfo[pool].chainId = chainId;
+        poolInfo[pool].lastUpdated = WeekMath.getCurrentWeekStart();
+        require(chainPools[chainId].add(pool), "IE: chainPools duplicated");
+        require(allPools.add(pool), "IE: allPools duplicated");
+    }
+
+    /**
+    * @dev expected behavior:
+        - remove from allPools, chainPools
+        - clear all params in poolInfo
+     */
+    function _removePool(address pool) internal {
+        uint64 chainId = poolInfo[pool].chainId;
+        require(chainPools[chainId].remove(pool), "IE: chainPools removal failed");
+        require(allPools.remove(pool), "IE: allPools removal failed");
+        delete poolInfo[pool];
+    }
+
+    /**
+     * @notice set the final pool vote for weekData
+     * @dev assumption: weekData[wTime].poolVotes[pool] == 0
+     */
+    function _setFinalPoolVoteForWeek(
+        address pool,
+        uint128 wTime,
+        uint128 vote
+    ) internal {
+        weekData[wTime].totalVotes += vote;
+        weekData[wTime].poolVotes[pool] = vote;
+    }
+
+    function _setNewVotePoolInfo(
+        address pool,
+        VeBalance memory vote,
+        uint128 wTime
+    ) internal {
+        poolInfo[pool].vote = vote;
+        poolInfo[pool].lastUpdated = wTime;
+    }
+
+    /// @dev only applicable for current pool, hence no changes for weekData
+    function _subtractVotePoolInfo(address pool, VeBalance memory vote) internal {
+        PoolInfo storage pInfo = poolInfo[pool];
+        pInfo.vote = poolInfo[pool].vote.sub(vote);
+        pInfo.slopeChanges[vote.getExpiry()] -= vote.slope;
+    }
+
+    /// @dev only applicable for current pool, hence no changes for weekData
+    function _addVotePoolInfo(address pool, VeBalance memory vote) internal {
+        PoolInfo storage pInfo = poolInfo[pool];
+        pInfo.vote = poolInfo[pool].vote.add(vote);
+        pInfo.slopeChanges[vote.getExpiry()] += vote.slope;
+    }
+
+    function _unsetVoteUserData(address user, address pool) internal {
+        UserData storage uData = userData[user];
+        uData.totalVotedWeight -= uData.voteForPools[pool].weight;
+        delete uData.voteForPools[pool];
+    }
+
+    /// @dev assumption: uData.voteForPools[pool] hasn't been set before
+    /// @dev post-condition: totalVotedWeight <= USER_VOTE_MAX_WEIGHT
+    function _setVoteUserData(
+        address user,
+        address pool,
+        uint64 weight,
+        VeBalance memory vote
+    ) internal {
+        UserData storage uData = userData[user];
+        uData.totalVotedWeight += weight;
+        require(uData.totalVotedWeight <= USER_VOTE_MAX_WEIGHT, "exceeded max weight");
+
+        uData.voteForPools[pool] = UserPoolInfo({ weight: weight, vote: vote });
+    }
+
+    /// @dev post-condition: timestamp is in increasing order (for binary search)
+    function _addUserPoolCheckpoint(
+        address user,
+        address pool,
+        VeBalance memory vote
+    ) internal {
+        userPoolCheckpoints[user][pool].push(
+            Checkpoint({ balance: vote, timestamp: uint128(block.timestamp) })
+        );
+    }
+
+    function _setAllPastEpochsAsFinalized() internal {
+        uint128 wTime = WeekMath.getCurrentWeekStart();
+        while (wTime >= deployedWTime && isEpochFinalized[wTime] == false) {
+            isEpochFinalized[wTime] = true;
+            wTime -= WEEK;
+        }
+    }
+
+    /// @notice check if a pool is votable on by checking the lastUpdated time
+    function _isPoolVotable(address pool) internal view returns (bool) {
+        return poolInfo[pool].lastUpdated != 0;
+    }
+
+    /// @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());
+    }
+}

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

@@ -0,0 +1,241 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.13;
+import "../../../interfaces/IPVotingEscrow.sol";
+import "../../../libraries/helpers/MiniHelpers.sol";
+import "./VotingEscrowToken.sol";
+import "../CelerAbstracts/CelerSender.sol";
+import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
+import "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
+
+contract VotingEscrowPendleMainchain is VotingEscrowToken, IPVotingEscrow, CelerSender {
+    using SafeERC20 for IERC20;
+    using VeBalanceLib for VeBalance;
+    using VeBalanceLib for LockedPosition;
+    using EnumerableMap for EnumerableMap.UintToAddressMap;
+
+    bytes private constant EMPTY_BYTES = abi.encode();
+
+    IERC20 public immutable pendle;
+
+    // [wTime] => slopeChanges
+    mapping(uint128 => uint128) public slopeChanges;
+
+    // Saving totalSupply checkpoint for each week, later can be used for reward accounting
+    // [wTime] => totalSupply
+    mapping(uint128 => uint128) public totalSupplyAt;
+
+    // Saving VeBalance checkpoint for users of each week, can later use binary search
+    // to ask for their vePendle balance at any wTime
+    mapping(address => Checkpoint[]) public userCheckpoints;
+
+    constructor(IERC20 _pendle, address _governanceManager) CelerSender(_governanceManager) {
+        pendle = _pendle;
+    }
+
+    /// @notice basically a proxy function to call increaseLockPosition & broadcastUserPosition at the same time
+    function increaseLockPositionAndBroadcast(
+        uint128 additionalAmountToLock,
+        uint128 newExpiry,
+        uint256[] calldata chainIds
+    ) external payable returns (uint128 newVeBalance) {
+        newVeBalance = increaseLockPosition(additionalAmountToLock, newExpiry);
+        broadcastUserPosition(msg.sender, chainIds);
+    }
+
+    /**
+     * @notice increase the lock position of an user. Applicable even when user has no position or the
+        current position has expired
+     * @dev expected state changes:
+        - a new lock with amount = amountToPull + amountExpired, expiry = expiry is created for msg.sender in positionData
+        - pendle is taken in if necessary
+        - _totalSupply, lastSupplyUpdatedAt, slopeChanges, totalSupplyAt is updated
+        - a checkpoint is added
+     * @dev broadcast is not bundled since it can be done anytime after
+     */
+    function increaseLockPosition(uint128 additionalAmountToLock, uint128 newExpiry)
+        public
+        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");
+
+        uint128 newTotalAmountLocked = additionalAmountToLock + positionData[user].amount;
+        require(newTotalAmountLocked > 0, "zero total amount locked");
+
+        uint128 additionalDurationToLock = newExpiry - positionData[user].expiry;
+
+        if (additionalAmountToLock > 0) {
+            pendle.safeTransferFrom(user, address(this), additionalAmountToLock);
+        }
+
+        newVeBalance = _increasePosition(user, additionalDurationToLock, additionalAmountToLock);
+
+        emit NewLockPosition(user, newTotalAmountLocked, newExpiry);
+    }
+
+    /**
+     * @notice withdraw an expired lock position, get back all locked PENDLE
+     * @dev expected state changes:
+        - positionData is cleared
+        - pendle is transferred out
+        - _totalSupply, lastSupplyUpdatedAt, slopeChanges, totalSupplyAt all doesn't need to be updated
+            since these data will automatically hold true when _updateTotalSupply() is called
+        - no checkpoint is added
+     * @dev broadcast is not bundled since it can be done anytime after
+     */
+    function withdraw(address user) external returns (uint128 amount) {
+        require(isPositionExpired(user), "position not expired");
+        amount = positionData[user].amount;
+
+        require(amount > 0, "zero position");
+
+        delete positionData[user];
+
+        pendle.safeTransfer(user, amount);
+
+        emit Withdraw(user, amount);
+    }
+
+    /**
+     * @notice update & return the current totalSupply
+     * @dev state changes expected:
+        - _totalSupply & lastSupplyUpdatedAt is updated
+     */
+    function totalSupplyCurrent() external virtual override returns (uint128) {
+        (VeBalance memory supply, ) = _updateTotalSupply();
+        return supply.getCurrentValue();
+    }
+
+    /**
+     * @notice broadcast the totalSupply to different chains
+     * @dev state changes expected:
+        - all chains in chainIds receive the new totalSupply
+     */
+    function broadcastTotalSupply(uint256[] calldata chainIds) public payable {
+        _broadcastPosition(address(0), chainIds);
+    }
+
+    /**
+     * @notice broadcast the position of users to different chains
+     * @dev state changes expected:
+        - all chains in chainIds receive the new totalSupply & user's new position
+     */
+    function broadcastUserPosition(address user, uint256[] calldata chainIds) public payable {
+        require(user != address(0), "zero address user");
+        _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 VeBalanceLib.getCheckpointValueAt(userCheckpoints[user], timestamp);
+    }
+
+    /**
+     * @notice increase the locking position of the user
+     * @dev it works by simply removing the old position from all relevant data (as if the user has never locked) and
+        then add in the new position
+      * @dev expected state changes:
+        - a new lock with the amount & expiry increase accordingly
+        - pendle is taken in if necessary
+        - _totalSupply, lastSupplyUpdatedAt, slopeChanges, totalSupplyAt is updated
+        - a checkpoint is added
+     */
+    function _increasePosition(
+        address user,
+        uint128 durationToIncrease,
+        uint128 amountToIncrease
+    ) internal returns (uint128) {
+        LockedPosition memory oldPosition = positionData[user];
+
+        (VeBalance memory newSupply, ) = _updateTotalSupply();
+
+        if (!MiniHelpers.isCurrentlyExpired(oldPosition.expiry)) {
+            // remove old position not yet expired
+            VeBalance memory oldBalance = oldPosition.convertToVeBalance();
+            newSupply = newSupply.sub(oldBalance);
+            slopeChanges[oldPosition.expiry] -= oldBalance.slope;
+        }
+
+        LockedPosition memory newPosition = LockedPosition(
+            oldPosition.amount + amountToIncrease,
+            oldPosition.expiry + durationToIncrease
+        );
+
+        VeBalance memory newBalance = newPosition.convertToVeBalance();
+        // add new position
+        newSupply = newSupply.add(newBalance);
+        slopeChanges[newPosition.expiry] += newBalance.slope;
+
+        _totalSupply = newSupply;
+        positionData[user] = newPosition;
+        userCheckpoints[user].push(Checkpoint(newBalance, uint128(block.timestamp)));
+        return newBalance.getCurrentValue();
+    }
+
+    /**
+     * @notice update the totalSupply, processing all slope changes of past weeks. At the same time, set the finalized
+        totalSupplyAt
+     * @dev state changes expected:
+        - _totalSupply, lastSupplyUpdatedAt, totalSupplyAt is updated
+     */
+    function _updateTotalSupply() internal returns (VeBalance memory, uint128) {
+        VeBalance memory supply = _totalSupply;
+        uint128 wTime = lastSupplyUpdatedAt;
+        uint128 currentWeekStart = WeekMath.getCurrentWeekStart();
+
+        if (wTime >= currentWeekStart) {
+            return (supply, wTime);
+        }
+
+        while (wTime < currentWeekStart) {
+            wTime += WEEK;
+            supply = supply.sub(slopeChanges[wTime], wTime);
+            totalSupplyAt[wTime] = supply.getValueAt(wTime);
+        }
+
+        _totalSupply = supply;
+        lastSupplyUpdatedAt = wTime;
+
+        return (supply, lastSupplyUpdatedAt);
+    }
+
+    /// @notice broadcast position to all chains in chainIds
+    function _broadcastPosition(address user, uint256[] calldata chainIds) public payable {
+        require(chainIds.length != 0, "empty chainIds");
+
+        (VeBalance memory supply, uint256 wTime) = _updateTotalSupply();
+
+        bytes memory userData = (
+            user == address(0) ? EMPTY_BYTES : abi.encode(user, positionData[user])
+        );
+
+        for (uint256 i = 0; i < chainIds.length; ++i) {
+            require(sidechainContracts.contains(chainIds[i]), "not supported chain");
+            _broadcast(chainIds[i], wTime, supply, userData);
+            if (user != address(0)) {
+                emit BroadcastUserPosition(user, chainIds);
+            }
+        }
+
+        emit BroadcastTotalSupply(supply, chainIds);
+    }
+
+    function _afterAddSidechainContract(address, uint256 chainId) internal virtual override {
+        (VeBalance memory supply, uint256 wTime) = _updateTotalSupply();
+        _broadcast(chainId, wTime, supply, EMPTY_BYTES);
+    }
+
+    function _broadcast(
+        uint256 chainId,
+        uint256 wTime,
+        VeBalance memory supply,
+        bytes memory userData
+    ) internal {
+        _sendMessage(chainId, abi.encode(wTime, supply, userData));
+    }
+}

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

@@ -0,0 +1,73 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+pragma solidity 0.8.13;
+
+import "../../../libraries/VeBalanceLib.sol";
+import "../../../libraries/math/WeekMath.sol";
+import "./VotingEscrowToken.sol";
+import "../CelerAbstracts/CelerReceiver.sol";
+
+// solhint-disable no-empty-blocks
+contract VotingEscrowPendleSidechain is VotingEscrowToken, CelerReceiver {
+    mapping(address => address) internal delegatorOf;
+
+    event SetNewDelegator(address delegator, address receiver);
+
+    event SetNewTotalSupply(VeBalance totalSupply);
+
+    event SetNewUserPosition(LockedPosition position);
+
+    constructor(address _governanceManager) CelerReceiver(_governanceManager) {}
+
+    function totalSupplyCurrent() external view virtual override returns (uint128) {
+        return totalSupplyStored();
+    }
+
+    /**
+     * @dev The mechanism of delegating is for governance to support protocol to build on top
+     * This way, it is more gas efficient and does not affect the crosschain messaging cost
+     */
+    function setDelegatorFor(address receiver, address delegator) external onlyGovernance {
+        delegatorOf[receiver] = delegator;
+        emit SetNewDelegator(delegator, receiver);
+    }
+
+    /**
+     * @dev Both two types of message will contain VeBalance supply & wTime
+     * @dev If the message also contains some users' position, we should update it
+     */
+    function _executeMessage(bytes memory message) internal virtual override {
+        (uint128 wTime, VeBalance memory supply, bytes memory userData) = abi.decode(
+            message,
+            (uint128, VeBalance, bytes)
+        );
+        _setNewTotalSupply(wTime, supply);
+        if (userData.length > 0) {
+            _setNewUserPosition(userData);
+        }
+    }
+
+    function _setNewUserPosition(bytes memory userData) internal {
+        (address userAddr, LockedPosition memory position) = abi.decode(
+            userData,
+            (address, LockedPosition)
+        );
+        positionData[userAddr] = position;
+        emit SetNewUserPosition(position);
+    }
+
+    function _setNewTotalSupply(uint128 wTime, VeBalance memory supply) internal {
+        assert(wTime == WeekMath.getWeekStartTimestamp(wTime));
+        lastSupplyUpdatedAt = wTime;
+        _totalSupply = supply;
+        emit SetNewTotalSupply(supply);
+    }
+
+    function balanceOf(address user) public view virtual override returns (uint128) {
+        address delegator = delegatorOf[user];
+        if (delegatorOf[user] == address(0)) {
+            return super.balanceOf(user);
+        }
+        return super.balanceOf(delegator);
+    }
+}

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

@@ -0,0 +1,53 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.13;
+
+import "../../../interfaces/IPVeToken.sol";
+import "../../../libraries/VeBalanceLib.sol";
+import "../../../libraries/math/WeekMath.sol";
+import "../../../libraries/helpers/MiniHelpers.sol";
+
+/**
+ * @dev this contract is an abstract for its mainchain and sidechain variant
+ * PRINCIPLE:
+ *   - All functions implemented in this contract should be either view or pure
+ *     to ensure that no writing logic is inheritted by sidechain version
+ *   - Mainchain version will handle the logic which are:
+ *        + Deposit, withdraw, increase lock, increase amount
+ *        + Mainchain logic will be ensured to have _totalSupply = linear sum of
+ *          all users' veBalance such that their locks are not yet expired
+ *        + Mainchain contract reserves 100% the right to write on sidechain
+ *        + No other transaction is allowed to write on sidechain storage
+ */
+
+abstract contract VotingEscrowToken is IPVeToken {
+    // wrong name, should be VotingEscrowPendle
+    using VeBalanceLib for VeBalance;
+    using VeBalanceLib for LockedPosition;
+
+    uint128 public constant WEEK = 1 weeks;
+    uint128 public constant MAX_LOCK_TIME = 104 weeks;
+
+    VeBalance internal _totalSupply;
+    uint128 public lastSupplyUpdatedAt;
+
+    mapping(address => LockedPosition) public positionData;
+
+    constructor() {
+        lastSupplyUpdatedAt = WeekMath.getCurrentWeekStart();
+    }
+
+    function balanceOf(address user) public view virtual returns (uint128) {
+        if (isPositionExpired(user)) return 0;
+        return positionData[user].convertToVeBalance().getCurrentValue();
+    }
+
+    function totalSupplyStored() public view virtual returns (uint128) {
+        return _totalSupply.getCurrentValue();
+    }
+
+    function totalSupplyCurrent() external virtual returns (uint128);
+
+    function isPositionExpired(address user) public view returns (bool) {
+        return MiniHelpers.isCurrentlyExpired(positionData[user].expiry);
+    }
+}