@pendle/core-v2 0.6.8 → 0.7.0

package/contracts/core/LiquidityMining/PendleGauge.sol

@@ -0,0 +1,118 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.13;
+
+import "../../interfaces/IPGaugeController.sol";
+import "../../interfaces/IPVeToken.sol";
+import "../../interfaces/ISuperComposableYield.sol";
+import "../../libraries/RewardManager.sol";
+import "../../libraries/math/Math.sol";
+import "../../libraries/helpers/ArrayLib.sol";
+import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
+
+abstract contract PendleGauge is RewardManager {
+    using Math for uint256;
+    using SafeERC20 for IERC20;
+    using ArrayLib for address[];
+
+    address private immutable SCY;
+
+    uint256 internal constant TOKENLESS_PRODUCTION = 40;
+    address internal immutable PENDLE;
+
+    IPVeToken public immutable vePENDLE;
+    address public immutable gaugeController;
+
+    uint256 public totalActiveSupply;
+    mapping(address => uint256) public activeBalance;
+
+    constructor(
+        address _SCY,
+        address _vePendle,
+        address _gaugeController
+    ) {
+        SCY = _SCY;
+        vePENDLE = IPVeToken(_vePendle);
+        gaugeController = _gaugeController;
+        PENDLE = IPGaugeController(gaugeController).pendle();
+    }
+
+    /**
+     * @dev It is intended to have user's active balance updated when they try to redeem
+     */
+    function _redeemRewards(address user) internal virtual returns (uint256[] memory) {
+        _updateAndDistributeRewards(user);
+        _updateUserActiveBalance(user);
+        return _doTransferOutRewards(user, user);
+    }
+
+    /**
+     * @dev since rewardShares will be modified after this function, it should update user reward beforehand
+     */
+    function _updateUserActiveBalance(address user) internal virtual {
+        uint256 lpBalance = _stakedBalance(user);
+        uint256 veBoostedLpBalance = _calcVeBoostedLpBalance(user, lpBalance);
+
+        uint256 newActiveBalance = Math.min(veBoostedLpBalance, lpBalance);
+
+        totalActiveSupply = totalActiveSupply - activeBalance[user] + newActiveBalance;
+        activeBalance[user] = newActiveBalance;
+    }
+
+    function _calcVeBoostedLpBalance(address user, uint256 lpBalance)
+        internal
+        virtual
+        returns (uint256)
+    {
+        uint256 vePendleBalance = vePENDLE.balanceOf(user);
+        uint256 vePendleSupply = vePENDLE.totalSupplyCurrent();
+        // Inspired by Curve's Gauge
+        uint256 veBoostedLpBalance = (lpBalance * TOKENLESS_PRODUCTION) / 100;
+        if (vePendleSupply > 0) {
+            veBoostedLpBalance +=
+                (((_totalStaked() * vePendleBalance) / vePendleSupply) *
+                    (100 - TOKENLESS_PRODUCTION)) /
+                100;
+        }
+        return veBoostedLpBalance;
+    }
+
+    function _redeemExternalReward() internal virtual override {
+        ISuperComposableYield(SCY).claimRewards(address(this));
+        IPGaugeController(gaugeController).claimMarketReward();
+    }
+
+    function _stakedBalance(address user) internal view virtual returns (uint256);
+
+    function _totalStaked() internal view virtual returns (uint256);
+
+    function _rewardSharesTotal() internal view virtual override returns (uint256) {
+        return totalActiveSupply;
+    }
+
+    function _rewardSharesUser(address user) internal view virtual override returns (uint256) {
+        return activeBalance[user];
+    }
+
+    function _getRewardTokens() internal view virtual override returns (address[] memory) {
+        address[] memory SCYRewards = ISuperComposableYield(SCY).getRewardTokens();
+        if (SCYRewards.contains(PENDLE)) return SCYRewards;
+        return SCYRewards.append(PENDLE);
+    }
+
+    function _beforeTokenTransfer(
+        address from,
+        address to,
+        uint256
+    ) internal virtual {
+        _updateAndDistributeRewardsForTwo(from, to);
+    }
+
+    function _afterTokenTransfer(
+        address from,
+        address to,
+        uint256
+    ) internal virtual {
+        if (from != address(0) && from != address(this)) _updateUserActiveBalance(from);
+        if (to != address(0) && to != address(this)) _updateUserActiveBalance(to);
+    }
+}

package/contracts/core/LiquidityMining/README.md

@@ -0,0 +1,63 @@
+# vePendle For Launch
+
+### Locking PENDLE for vePendle (on ETH)
+* Each user can only lock for a maximum of $MAXLOCKTIME$ = 2 years
+* vePendle balance for users is represented by:
+$balance_u(t) = bias_u - slope_u * t$
+
+* As such, we just need to store $bias_u$ and $slope_u$ for each user. (Considerations: store $bias_u$ and $t_{expiry}$ for the user instead, because $t_{expiry}$ is always an exact number)
+* The amount of PENDLE locked by user $u$ is $locked_u$
+* For total supply, it's simply $totalBalance = totalBias - totalSlope * t$
+* Possible actions by an user:
+    * User $u$ create a new lock by locking $d_{PENDLE}$ of PENDLE tokens, expiring at $t_{expiry}$
+        $slope_u = d_{PENDLE} / MAXLOCKTIME$
+        $bias_u = slope_u \cdot t_{expiry}$
+    * User $u$ locks an additional of $d_{PENDLE}$ PENDLE tokens, into his existing lock expiring at $t_{expiry}$
+        $slope_{u_{new}} = slope_u + d_{PENDLE} / MAXLOCKTIME$
+        $bias_{u_{new}} = slope_{u_{new}} \cdot t_{expiry}$
+    * User $u$ extends his expiry from $t_{expiry}$ to $t_{expiry_{new}}$
+        $bias_{u_{new}} = slope_{u} \cdot t_{expiry_{new}}$
+        
+* Similar to Curve:
+    * We store the checkpoints for when a user's $slope$ or $bias$ changes
+    * We restrict the possible expiries to exact weeks from UNIX timestamp 0
+    * We store the global bias and slope changes due to expiry of user's vote-locks per week, and process it when the week comes
+
+### Cross-chain messaging module
+* There are contracts inheritting `CelerSender` on governance chain - Ethereum, with a function `sendMessage(chain Y, sender, message)` to send messages to other chains.
+* On each non-governance chain, we have contracts inheritting `CelerReceiver`. Each has a function `afterReceivingMessage(sender, message)` to receive the message from governance.
+* When `sendMessage(chain Y, sender, message)` is called on governance chain, `afterReceivingMessage(sender, message)`  will be called on chain Y, thanks to the cross-chain messaging module
+* The current mechanics for the module is using Celer
+* The cross-chain messaging module can be plugged in/plugged out by the governance address (which will initially be controlled by a team multisig)
+
+### Voting for incentives on market and chains
+* On Ethereum, there is a `VotingController` contract to control the voting on incentives for the different markets on the different chains.
+* Adding a new chain:
+    * Only the governance address will be able to add markets and a new chains' GaugeController.
+* There is a list of `(market)` that are elligible for the voting, added by governance
+    * markets that are expired will be removed by governance
+* vePendle holders can allocate their vePendle to multiple markets on multiple chains
+* Similar to Curve, we store the bias and slope of the total vePendle voted for every market
+    * Similary, we adjust the slope/bias changes due to expired vePendle at the weekly mark
+* There is a global PENDLE per second rate for all the incentives across all the chains. This is set by governance.
+* The `VotingController` does not hold any fund. The incentivizing PENDLE is transferred directly to GaugeController by governacne. 
+        * GaugeControllers: admin can withdraw PENDLE from it
+* In each chain, there is a `GaugeController` contract that is responsible for keeping PENDLE incentives and distributing PENDLE to incentivise different markets.
+* At the finalization of each week (starting of new week), anyone can call a function `finalizeVotingResults` and then `broadcastVotes()` in `VotingController` to broadcast to any chain:
+    1. The PENDLE allocation of each market for the next week
+    2. The timestamp to mark which week is the incentivization coming from
+    When this happens, the `GaugeController` in each chain will update the PENDLE per second among the different markets
+* At any time, the governacne has the voting power equivalent to locking X PENDLE in 2 years
+
+### GaugeController
+
+Gauge controller will receive the voting results from VotingController and incentivize the amount of PENDLE from `block.timestamp` to `block.timestamp + 1 WEEK`.
+
+If there is still leftover reward in each pool, the gauge controller will remove and take the leftover to top up the incentivize for the current week.
+
+### Gauge & Market
+* The Gauge/Market will receive rewardTokens from SCY as well as claiming the PENDLE token from gauge controller. All of the reward tokens (including PENDLE) will be distributed with boosting mechanism
+
+### Broadcasting vePendle balance & different address for boosting rewards for each chain
+* At anytime, an address A could send a cross message to update the vePendle balance on a specific chain
+* The governance reserves the right to set the vePENDLE delegator for some address (for other protocols to build on top).

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

@@ -0,0 +1,323 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.13;
+
+import "./VotingControllerStorage.sol";
+import "../CelerAbstracts/CelerSender.sol";
+import "../../../libraries/VeBalanceLib.sol";
+import "../../../libraries/math/Math.sol";
+import "../../../interfaces/IPGaugeControllerMainchain.sol";
+import "../../../interfaces/IPVotingController.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 Celer
+
+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 PendleVotingController is CelerSender, VotingControllerStorage, IPVotingController {
+    using VeBalanceLib for VeBalance;
+    using Math for uint256;
+    using Math for int256;
+    using EnumerableMap for EnumerableMap.UintToAddressMap;
+    using EnumerableSet for EnumerableSet.AddressSet;
+
+    constructor(address _vePendle, address _governanceManager)
+        VotingControllerStorage(_vePendle)
+        CelerSender(_governanceManager)
+    {}
+
+    /*///////////////////////////////////////////////////////////////
+                FUNCTIONS CAN BE CALLED BY ANYONE
+    //////////////////////////////////////////////////////////////*/
+
+    /**
+     * @notice set a new voting weight for the target pool
+     * @dev pre-condition:
+        - pool must have been added before
+        - the vePENDLE position must still be active
+     * @dev state changes expected:
+        - update weekData (if any)
+        - update poolInfo, userData to reflect the new vote
+        - add 1 check point for both the unvote & new vote
+     * @dev vePENDLE position not expired is a must, else bias - t*slope < 0 & it will be
+        negative weight
+     */
+    function vote(address pool, uint64 weight) external {
+        address user = msg.sender;
+
+        require(weight != 0, "zero weight");
+        require(_isPoolVotable(pool), "invalid pool");
+        require(!vePendle.isPositionExpired(user), "user position expired");
+
+        updatePoolVotes(pool);
+        _unvote(user, pool, false);
+        _vote(user, pool, weight);
+    }
+
+    /**
+     * @notice remove the vote from the current pool
+     * @dev no pre-condition as opposed to vote since this function is to clear the vote
+     * @dev allow removing vote from a non-votable pool BY not requiring pool to be votable
+     * @dev state changes expected:
+        - update weekData (if any)
+        - update poolInfo, userData to reflect the new vote
+        - add 1 check point for the unvote
+     */
+    function unvote(address pool) external {
+        if (_isPoolVotable(pool)) {
+            updatePoolVotes(pool);
+        }
+        _unvote(msg.sender, pool, true);
+    }
+
+    /**
+     * @notice Process all the slopeChanges that haven't been processed & update these data into
+        poolInfo
+     * @dev pre-condition: the pool must be votable
+     * @dev state changes expected:
+        - update weekData
+        - update poolInfo
+     */
+    function updatePoolVotes(address pool) public {
+        require(_isPoolVotable(pool), "invalid pool");
+
+        uint128 wTime = poolInfo[pool].lastUpdated;
+        uint128 currentWeekStart = WeekMath.getCurrentWeekStart();
+
+        // no state changes are expected
+        if (wTime >= currentWeekStart) return;
+
+        VeBalance memory currentVote = poolInfo[pool].vote;
+        while (wTime < currentWeekStart) {
+            wTime += WEEK;
+            currentVote = currentVote.sub(poolInfo[pool].slopeChanges[wTime], wTime);
+            _setFinalPoolVoteForWeek(pool, wTime, currentVote.getValueAt(wTime));
+        }
+
+        _setNewVotePoolInfo(pool, currentVote, wTime);
+    }
+
+    /**
+     * @notice finalize the voting results of all pools, up to the current epoch
+     * @dev state changes expected:
+        - weekData, poolInfo is updated for all pools in allPools
+        - isEpochFinalized is set to true for all epochs since the last time until now
+     * @dev this function might take a lot of gas, but can be mitigated by calling updatePoolVotes
+        separately, hence reduce the number of states to be updated
+     */
+    function finalizeEpoch() public {
+        uint256 length = allPools.length();
+        for (uint256 i = 0; i < length; ++i) {
+            updatePoolVotes(allPools.at(i));
+        }
+        _setAllPastEpochsAsFinalized();
+    }
+
+    /**
+     * @notice broadcast the voting results of the current week to the chain with chainId. Can be
+        called by anyone
+     * @dev pre-condition: the epoch must have already been finalized by finalizeEpoch
+     * @dev state changes expected:
+        - the gaugeController receives the new pendle allocation
+     */
+    function broadcastResults(uint64 chainId) external payable {
+        uint128 wTime = WeekMath.getCurrentWeekStart();
+        require(isEpochFinalized[wTime], "epoch not finalized");
+        _broadcastResults(chainId, wTime, pendlePerSec);
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                    GOVERNANCE-ONLY FUNCTIONS
+    //////////////////////////////////////////////////////////////*/
+
+    /**
+     * @notice add a pool to allow users to vote. Can only be done by governance
+     * @dev pre-condition: pool must not have been added before
+     * @dev assumption: chainId is valid, pool does exist on the chain (guaranteed by gov)
+     * @dev state changes expected:
+        - add to allPools & chainPools
+        - set params in poolInfo
+     */
+    function addPool(uint64 chainId, address pool) external onlyGovernance {
+        require(!_isPoolVotable(pool), "pool already added");
+        _addPool(chainId, pool);
+        emit AddPool(chainId, pool);
+    }
+
+    /**
+     * @notice remove a pool from voting. Can only be done by governance
+     * @dev pre-condition: pool must have been added before
+     * @dev state changes expected:
+        - update weekData (if any)
+        - remove from allPools & chainPools
+        - clear info in poolInfo
+     */
+    function removePool(address pool) external onlyGovernance {
+        require(_isPoolVotable(pool), "invalid pool");
+        uint64 chainId = poolInfo[pool].chainId;
+
+        updatePoolVotes(pool);
+        _removePool(pool);
+
+        emit RemovePool(chainId, pool);
+    }
+
+    /**
+     * @notice use the gov-privilege to force broadcast a message in case there are issues with Celer
+     * @dev it's intentional for this function to have minimal checks since we assume gov has done the
+        due dilligence
+     * @dev gov should always call finalizeEpoch beforehand
+     * @dev state changes expected:
+        - the gaugeController receives the new pendle allocation
+     */
+    function forceBroadcastResults(
+        uint64 chainId,
+        uint128 wTime,
+        uint128 forcedPendlePerSec
+    ) external payable onlyGovernance {
+        _broadcastResults(chainId, wTime, forcedPendlePerSec);
+    }
+
+    /**
+     * @notice set new pendlePerSec
+     * @dev no zero checks because gov may want to stop liquidity mining
+     * @dev state changes expected: pendlePerSec is updated
+     */
+    function setPendlePerSec(uint128 newPendlePerSec) external onlyGovernance {
+        pendlePerSec = newPendlePerSec;
+        emit SetPendlePerSec(newPendlePerSec);
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                    INTERNAL FUNCTIONS
+    //////////////////////////////////////////////////////////////*/
+
+    /**
+     * @notice broadcast voting results of the timestamp to chainId
+     * @dev assumption: the epoch is already finalized, lastUpdated of all pools >= currentWeekTimestamp
+     * @dev state changes expected:
+        - the gaugeController receives the new pendle allocation
+     */
+    function _broadcastResults(
+        uint64 chainId,
+        uint128 wTime,
+        uint128 totalPendlePerSec
+    ) internal {
+        uint256 totalVotes = weekData[wTime].totalVotes;
+        if (totalVotes == 0) return;
+
+        uint256 length = chainPools[chainId].length();
+        if (length == 0) return;
+
+        address[] memory pools = chainPools[chainId].values();
+        uint256[] memory totalPendleAmounts = new uint256[](length);
+
+        for (uint256 i = 0; i < length; ++i) {
+            uint256 poolVotes = weekData[wTime].poolVotes[pools[i]];
+            uint256 pendlePerSec = (uint256(totalPendlePerSec) * poolVotes) / totalVotes;
+            totalPendleAmounts[i] = pendlePerSec * WEEK;
+        }
+
+        if (chainId == block.chainid) {
+            address gaugeController = sidechainContracts.get(uint256(chainId));
+            IPGaugeControllerMainchain(gaugeController).updateVotingResults(
+                wTime,
+                pools,
+                totalPendleAmounts
+            );
+        } else {
+            _sendMessage(chainId, abi.encode(wTime, pools, totalPendleAmounts));
+        }
+
+        emit BroadcastResults(chainId, wTime, totalPendlePerSec);
+    }
+
+    /**
+     * @notice remove the vote from the current pool
+     * @dev state changes expected:
+        - vote in poolInfo is cleared if the vote is still valid
+        - update UserData to remove the vote weight
+        - add a check-point if required
+     */
+    function _unvote(
+        address user,
+        address pool,
+        bool doCreateCheckpoint
+    ) internal {
+        VeBalance memory oldUVote = userData[user].voteForPools[pool].vote;
+        if (_isPoolVotable(pool) && _isVoteActive(oldUVote)) {
+            _subtractVotePoolInfo(pool, oldUVote);
+        }
+        _unsetVoteUserData(user, pool);
+
+        if (doCreateCheckpoint) {
+            _addUserPoolCheckpoint(user, pool, VeBalance(0, 0));
+        }
+        emit Unvote(user, pool, oldUVote);
+    }
+
+    /**
+     * @notice remove the vote from the current pool
+     * @dev there must not be any current vote on this pool by the user
+     * @dev state changes expected:
+        - vote in poolInfo is added
+        - update UserData to set the new vote weight
+        - add a check-point
+     */
+    function _vote(
+        address user,
+        address pool,
+        uint64 weight
+    ) internal {
+        VeBalance memory votingPower = _getVotingPowerByWeight(user, weight);
+        _addVotePoolInfo(pool, votingPower);
+        _setVoteUserData(user, pool, weight, votingPower);
+        _addUserPoolCheckpoint(user, pool, votingPower);
+
+        emit Vote(user, pool, weight, votingPower);
+    }
+
+    /**
+     * @notice return the corresponding voting power of an user given the weight. Basically his voting power
+        will be vePendle * weight / USER_VOTE_MAX_WEIGHT
+     * @notice governance will always has the vePendle equivalent to 1M PENDLE locked for MAX_LOCK_TIME
+     */
+    function _getVotingPowerByWeight(address user, uint64 weight)
+        internal
+        view
+        virtual
+        returns (VeBalance memory res)
+    {
+        uint128 amount;
+        uint128 expiry;
+
+        if (user == _governance()) {
+            amount = GOVERNANCE_PENDLE_VOTE;
+            expiry = WeekMath.getWeekStartTimestamp(uint128(block.timestamp) + MAX_LOCK_TIME);
+        } else {
+            (amount, expiry) = vePendle.positionData(user);
+        }
+
+        (res.bias, res.slope) = VeBalanceLib.convertToVeBalance(
+            uint128((uint256(amount) * weight) / USER_VOTE_MAX_WEIGHT),
+            expiry
+        );
+    }
+}