@pendle/core-v2 2.23.1 → 2.23.2-mantle

package/contracts/core/Market/PendleExternalRewardDistributor.sol

@@ -0,0 +1,126 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+import "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
+import "@openzeppelin/contracts/proxy/utils/UUPSUpgradeable.sol";
+import "../libraries/math/Math.sol";
+import "../libraries/BoringOwnableUpgradeable.sol";
+import "../libraries/TokenHelper.sol";
+import "../libraries/ArrayLib.sol";
+import "../../interfaces/IPExternalRewardDistributor.sol";
+import "../../interfaces/IPMarketFactory.sol";
+
+contract PendleExternalRewardDistributor is
+    IPExternalRewardDistributor,
+    BoringOwnableUpgradeable,
+    UUPSUpgradeable,
+    TokenHelper
+{
+    using Math for uint256;
+    using ArrayLib for address[];
+    using ArrayLib for uint256[];
+
+    uint128 internal constant WEEK = 7 days;
+    address public immutable marketFactory;
+
+    modifier onlyValidMarket(address market) {
+        require(IPMarketFactory(marketFactory).isValidMarket(market), "invalid market");
+        _;
+    }
+
+    constructor(address _marketFactory) initializer {
+        marketFactory = _marketFactory;
+    }
+
+    mapping(address => address[]) internal rewardTokens;
+    mapping(address => mapping(address => MarketRewardData)) internal rewardData;
+
+    function initialize() external initializer {
+        __BoringOwnable_init();
+    }
+
+    function getRewardTokens(address market)
+        external
+        view
+        onlyValidMarket(market)
+        returns (address[] memory)
+    {
+        return rewardTokens[market];
+    }
+
+    function _getUpdatedMarketReward(address token, address market)
+        internal
+        view
+        returns (MarketRewardData memory)
+    {
+        MarketRewardData memory rwd = rewardData[market][token];
+        uint128 newLastUpdated = uint128(Math.min(uint128(block.timestamp), rwd.incentiveEndsAt));
+        rwd.accumulatedReward += rwd.rewardPerSec * (newLastUpdated - rwd.lastUpdated);
+        rwd.lastUpdated = newLastUpdated;
+        return rwd;
+    }
+
+    function redeemRewards() external onlyValidMarket(msg.sender) {
+        address market = msg.sender;
+        address[] memory tokens = rewardTokens[market];
+        for (uint256 i = 0; i < tokens.length; ++i) {
+            address token = tokens[i];
+
+            rewardData[market][token] = _getUpdatedMarketReward(market, token);
+            uint256 amountToDistribute = rewardData[market][token].accumulatedReward;
+
+            if (amountToDistribute > 0) {
+                rewardData[market][token].accumulatedReward = 0;
+                _transferOut(token, market, amountToDistribute);
+                emit DistributeReward(market, token, amountToDistribute);
+            }
+        }
+    }
+
+    function addRewardToMarket(
+        address market,
+        address token,
+        uint128 rewardAmount,
+        uint128 duration
+    ) external onlyOwner {
+        _addRewardToMarket(market, token, rewardAmount, duration);
+    }
+
+    function addWeeklyRewardBatch(
+        address token,
+        address[] memory markets,
+        uint256[] memory weights,
+        uint256 totalRewardToDistribute
+    ) external onlyOwner {
+        require(markets.length == weights.length, "array lengths mismatched");
+
+        uint256 totalWeight = weights.sum();
+        for (uint256 i = 0; i < markets.length; ++i) {
+            uint256 rewardToDistribute = (totalRewardToDistribute * weights[i]) / totalWeight;
+            _addRewardToMarket(markets[i], token, rewardToDistribute.Uint128(), WEEK);
+        }
+    }
+
+    function _addRewardToMarket(
+        address market,
+        address token,
+        uint128 rewardAmount,
+        uint128 duration
+    ) internal onlyValidMarket(market) {
+        MarketRewardData memory rwd = _getUpdatedMarketReward(market, token);
+        require(block.timestamp + duration > rwd.incentiveEndsAt, "Invalid incentive duration");
+
+        uint128 leftover = (rwd.incentiveEndsAt - rwd.lastUpdated) * rwd.rewardPerSec;
+        uint128 newSpeed = (leftover + rewardAmount) / duration;
+
+        rewardData[market][token] = MarketRewardData({
+            rewardPerSec: newSpeed,
+            accumulatedReward: rwd.accumulatedReward,
+            lastUpdated: uint128(block.timestamp),
+            incentiveEndsAt: uint128(block.timestamp) + duration
+        });
+
+        emit AddRewardToMarket(market, token, rewardData[market][token]);
+    }
+
+    function _authorizeUpgrade(address) internal virtual override onlyOwner {}
+}

package/contracts/core/Market/v2/PendleGaugeV2.sol

@@ -0,0 +1,137 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+import "../../../interfaces/IPGauge.sol";
+import "../../../interfaces/IPVeToken.sol";
+import "../../../interfaces/IPGaugeController.sol";
+import "../../../interfaces/IStandardizedYield.sol";
+import "../../../interfaces/IPMarketFactoryV2.sol";
+import "../../../interfaces/IPExternalRewardDistributor.sol";
+
+import "../../RewardManager/RewardManager.sol";
+
+/**
+Invariants to maintain:
+- before any changes to active balance, updateAndDistributeRewards() must be called
+ */
+abstract contract PendleGaugeV2 is RewardManager, IPGauge {
+    using Math for uint256;
+    using SafeERC20 for IERC20;
+    using ArrayLib for address[];
+
+    address private immutable SY;
+
+    uint256 internal constant TOKENLESS_PRODUCTION = 40;
+
+    address internal immutable PENDLE;
+    IPVeToken internal immutable vePENDLE;
+    address internal immutable gaugeController;
+    address internal immutable externalRewardDistributor;
+
+    uint256 public totalActiveSupply;
+    mapping(address => uint256) public activeBalance;
+
+    constructor(address _SY, address _vePendle, address _gaugeController, address _factory) {
+        SY = _SY;
+        vePENDLE = IPVeToken(_vePendle);
+        gaugeController = _gaugeController;
+        PENDLE = IPGaugeController(gaugeController).pendle();
+        externalRewardDistributor = IPMarketFactoryV2(_factory).rewardDistributor();
+    }
+
+    /**
+     * @dev Since rewardShares is based on activeBalance, user's activeBalance must be updated AFTER
+        rewards is updated
+     * @dev It's intended to have user's activeBalance updated when rewards is redeemed
+     */
+    function _redeemRewards(address user) internal virtual returns (uint256[] memory rewardsOut) {
+        _updateAndDistributeRewards(user);
+        _updateUserActiveBalance(user);
+        rewardsOut = _doTransferOutRewards(user, user);
+        emit RedeemRewards(user, rewardsOut);
+    }
+
+    function _updateUserActiveBalance(address user) internal virtual {
+        _updateUserActiveBalanceForTwo(user, address(0));
+    }
+
+    function _updateUserActiveBalanceForTwo(address user1, address user2) internal virtual {
+        if (user1 != address(0) && user1 != address(this)) _updateUserActiveBalancePrivate(user1);
+        if (user2 != address(0) && user2 != address(this)) _updateUserActiveBalancePrivate(user2);
+    }
+
+    /**
+     * @dev should only be callable from `_updateUserActiveBalanceForTwo` to guarantee user != address(0) && user != address(this)
+     */
+    function _updateUserActiveBalancePrivate(address user) private {
+        assert(user != address(0) && user != address(this));
+
+        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 vePendleSupply, uint256 vePendleBalance) = vePENDLE.totalSupplyAndBalanceCurrent(
+            user
+        );
+        // 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 {
+        IStandardizedYield(SY).claimRewards(address(this));
+        IPExternalRewardDistributor(externalRewardDistributor).redeemRewards();
+        IPGaugeController(gaugeController).redeemMarketReward();
+    }
+
+    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 rewardTokens)
+    {
+        address[] memory SYRewards = IStandardizedYield(SY).getRewardTokens();
+        address[] memory externalRewards = IPExternalRewardDistributor(externalRewardDistributor)
+            .getRewardTokens(address(this));
+
+        rewardTokens = SYRewards.concat(externalRewards);
+        if (rewardTokens.contains(PENDLE)) return rewardTokens;
+        return rewardTokens.append(PENDLE);
+    }
+
+    function _beforeTokenTransfer(address from, address to, uint256) internal virtual {
+        _updateAndDistributeRewardsForTwo(from, to);
+    }
+
+    function _afterTokenTransfer(address from, address to, uint256) internal virtual {
+        _updateUserActiveBalanceForTwo(from, to);
+    }
+}

package/contracts/core/Market/v2/PendleMarketFactoryV2.sol

@@ -0,0 +1,170 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+import "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
+
+import "../../../interfaces/IPMarket.sol";
+import "../../../interfaces/IPYieldContractFactory.sol";
+import "../../../interfaces/IPMarketFactory.sol";
+
+import "../../libraries/BaseSplitCodeFactory.sol";
+import "../../libraries/Errors.sol";
+import "../../libraries/BoringOwnableUpgradeable.sol";
+
+contract PendleMarketFactoryV2 is BoringOwnableUpgradeable, IPMarketFactory {
+    using EnumerableSet for EnumerableSet.AddressSet;
+
+    address public immutable marketCreationCodeContractA;
+    uint256 public immutable marketCreationCodeSizeA;
+    address public immutable marketCreationCodeContractB;
+    uint256 public immutable marketCreationCodeSizeB;
+
+    address public immutable yieldContractFactory;
+    uint256 public immutable maxLnFeeRateRoot;
+    uint8 public constant maxReserveFeePercent = 100;
+    int256 public constant minInitialAnchor = Math.IONE;
+
+    address public treasury;
+    address public rewardDistributor;
+    FeeConfig public defaultFee;
+    /// 1 SLOT
+
+    // router -> overriddenFee
+    mapping(address => FeeConfig) public overriddenFee;
+
+    // PT -> scalarRoot -> initialAnchor
+    mapping(address => mapping(int256 => mapping(int256 => address))) internal markets;
+    EnumerableSet.AddressSet internal allMarkets;
+    address public vePendle;
+    address public gaugeController;
+
+    constructor(
+        address _yieldContractFactory,
+        address _marketCreationCodeContractA,
+        uint256 _marketCreationCodeSizeA,
+        address _marketCreationCodeContractB,
+        uint256 _marketCreationCodeSizeB
+    ) {
+        yieldContractFactory = _yieldContractFactory;
+        maxLnFeeRateRoot = uint256(LogExpMath.ln(int256((105 * Math.IONE) / 100))); // ln(1.05)
+
+        marketCreationCodeContractA = _marketCreationCodeContractA;
+        marketCreationCodeSizeA = _marketCreationCodeSizeA;
+        marketCreationCodeContractB = _marketCreationCodeContractB;
+        marketCreationCodeSizeB = _marketCreationCodeSizeB;
+    }
+
+    function initialize(
+        address _treasury,
+        uint80 _defaultLnFeeRateRoot,
+        uint8 _defaultReserveFeePercent,
+        address newVePendle,
+        address newGaugeController,
+        address newRewardDistributor
+    ) external initializer {
+        __BoringOwnable_init();
+        setTreasury(_treasury);
+        setDefaultFee(_defaultLnFeeRateRoot, _defaultReserveFeePercent);
+
+        vePendle = newVePendle;
+        gaugeController = newGaugeController;
+        rewardDistributor = newRewardDistributor;
+    }
+
+    /**
+     * @notice Create a market between PT and its corresponding SY with scalar & anchor config.
+     * Anyone is allowed to create a market on their own.
+     */
+    function createNewMarket(
+        address PT,
+        int256 scalarRoot,
+        int256 initialAnchor
+    ) external returns (address market) {
+        if (!IPYieldContractFactory(yieldContractFactory).isPT(PT))
+            revert Errors.MarketFactoryInvalidPt();
+        if (IPPrincipalToken(PT).isExpired()) revert Errors.MarketFactoryExpiredPt();
+
+        if (markets[PT][scalarRoot][initialAnchor] != address(0))
+            revert Errors.MarketFactoryMarketExists();
+
+        if (initialAnchor < minInitialAnchor)
+            revert Errors.MarketFactoryInitialAnchorTooLow(initialAnchor, minInitialAnchor);
+
+        market = BaseSplitCodeFactory._create2(
+            0,
+            bytes32(block.chainid),
+            abi.encode(PT, scalarRoot, initialAnchor, vePendle, gaugeController),
+            marketCreationCodeContractA,
+            marketCreationCodeSizeA,
+            marketCreationCodeContractB,
+            marketCreationCodeSizeB
+        );
+
+        markets[PT][scalarRoot][initialAnchor] = market;
+
+        if (!allMarkets.add(market)) assert(false);
+
+        emit CreateNewMarket(market, PT, scalarRoot, initialAnchor);
+    }
+
+    function getMarketConfig(
+        address router
+    ) external view returns (address _treasury, uint80 _lnFeeRateRoot, uint8 _reserveFeePercent) {
+        (_treasury, _lnFeeRateRoot, _reserveFeePercent) = (
+            treasury,
+            defaultFee.lnFeeRateRoot,
+            defaultFee.reserveFeePercent
+        );
+
+        FeeConfig memory over = overriddenFee[router];
+        if (over.active) {
+            (_lnFeeRateRoot, _reserveFeePercent) = (over.lnFeeRateRoot, over.reserveFeePercent);
+        }
+    }
+
+    /// @dev for gas-efficient verification of market
+    function isValidMarket(address market) external view returns (bool) {
+        return allMarkets.contains(market);
+    }
+
+    function setTreasury(address newTreasury) public onlyOwner {
+        if (newTreasury == address(0)) revert Errors.MarketFactoryZeroTreasury();
+
+        treasury = newTreasury;
+        _emitNewMarketConfigEvent();
+    }
+
+    function setDefaultFee(uint80 newLnFeeRateRoot, uint8 newReserveFeePercent) public onlyOwner {
+        _verifyFeeConfig(newLnFeeRateRoot, newReserveFeePercent);
+        defaultFee = FeeConfig(newLnFeeRateRoot, newReserveFeePercent, true);
+        _emitNewMarketConfigEvent();
+    }
+
+    function setOverriddenFee(
+        address router,
+        uint80 newLnFeeRateRoot,
+        uint8 newReserveFeePercent
+    ) public onlyOwner {
+        _verifyFeeConfig(newLnFeeRateRoot, newReserveFeePercent);
+        overriddenFee[router] = FeeConfig(newLnFeeRateRoot, newReserveFeePercent, true);
+        emit SetOverriddenFee(router, newLnFeeRateRoot, newReserveFeePercent);
+    }
+
+    function unsetOverriddenFee(address router) external onlyOwner {
+        delete overriddenFee[router];
+        emit UnsetOverriddenFee(router);
+    }
+
+    function _verifyFeeConfig(uint80 newLnFeeRateRoot, uint8 newReserveFeePercent) internal view {
+        if (newLnFeeRateRoot > maxLnFeeRateRoot)
+            revert Errors.MarketFactoryLnFeeRateRootTooHigh(newLnFeeRateRoot, maxLnFeeRateRoot);
+        if (newReserveFeePercent > maxReserveFeePercent)
+            revert Errors.MarketFactoryReserveFeePercentTooHigh(
+                newReserveFeePercent,
+                maxReserveFeePercent
+            );
+    }
+
+    function _emitNewMarketConfigEvent() internal {
+        emit NewMarketConfig(treasury, defaultFee.lnFeeRateRoot, defaultFee.reserveFeePercent);
+    }
+}