@pendle/core-v2 5.0.0 → 5.0.3

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

@@ -1,129 +0,0 @@
-// 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/PMath.sol";
-import "../../libraries/BoringOwnableUpgradeable.sol";
-import "../../libraries/TokenHelper.sol";
-import "../../libraries/ArrayLib.sol";
-import "../../../interfaces/IPExternalRewardDistributor.sol";
-import "../../../interfaces/IPMarketFactory.sol";
-import "../../../interfaces/IPMarket.sol";
-
-contract PendleExternalRewardDistributor is
-    IPExternalRewardDistributor,
-    BoringOwnableUpgradeable,
-    UUPSUpgradeable,
-    TokenHelper
-{
-    using PMath for uint256;
-    using ArrayLib for address[];
-    using ArrayLib for uint256[];
-
-    uint128 internal constant WEEK = 7 days;
-    address public immutable marketFactory;
-
-    mapping(address => address[]) internal rewardTokens;
-    mapping(address => mapping(address => MarketRewardData)) internal rewardData;
-
-    modifier onlyValidMarket(address market) {
-        require(
-            IPMarketFactory(marketFactory).isValidMarket(market) && block.timestamp < IPMarket(market).expiry(),
-            "invalid market"
-        );
-        _;
-    }
-
-    constructor(address _marketFactory) initializer {
-        marketFactory = _marketFactory;
-    }
-
-    function initialize() external initializer {
-        __BoringOwnable_init();
-    }
-
-    function getRewardTokens(address market) external view returns (address[] memory) {
-        return rewardTokens[market];
-    }
-
-    function redeemRewards() external {
-        address market = msg.sender;
-        address[] memory tokens = rewardTokens[market];
-        for (uint256 i = 0; i < tokens.length; ++i) {
-            address token = tokens[i];
-
-            MarketRewardData memory rwd = _getUpdatedMarketReward(market, token);
-            uint256 amountToDistribute = rwd.accumulatedReward;
-
-            if (amountToDistribute > 0) {
-                rwd.accumulatedReward = 0;
-                // prevent re-entrancy
-                rewardData[market][token] = rwd;
-                _transferOut(token, market, amountToDistribute);
-                emit DistributeReward(market, token, amountToDistribute);
-            } else {
-                rewardData[market][token] = rwd;
-            }
-        }
-    }
-
-    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) {
-        if (!rewardTokens[market].contains(token)) {
-            rewardTokens[market].push(token);
-        }
-
-        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 _getUpdatedMarketReward(address market, address token) internal view returns (MarketRewardData memory) {
-        MarketRewardData memory rwd = rewardData[market][token];
-        uint128 newLastUpdated = uint128(PMath.min(uint128(block.timestamp), rwd.incentiveEndsAt));
-        rwd.accumulatedReward += rwd.rewardPerSec * (newLastUpdated - rwd.lastUpdated);
-        rwd.lastUpdated = newLastUpdated;
-        return rwd;
-    }
-
-    function _authorizeUpgrade(address) internal virtual override onlyOwner {}
-}

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

@@ -1,126 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity ^0.8.0;
-
-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 PMath 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 _externalRewardDistributor) {
-        SY = _SY;
-        vePENDLE = IPVeToken(_vePendle);
-        gaugeController = _gaugeController;
-        PENDLE = IPGaugeController(gaugeController).pendle();
-        externalRewardDistributor = _externalRewardDistributor;
-    }
-
-    /**
-     * @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 = PMath.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.merge(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

@@ -1,158 +0,0 @@
-// 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 = PMath.IONE;
-
-    address public treasury;
-    address public externalRewardDistributor;
-    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 * PMath.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 newExternalRewardDistributor
-    ) external initializer {
-        __BoringOwnable_init();
-        setTreasury(_treasury);
-        setDefaultFee(_defaultLnFeeRateRoot, _defaultReserveFeePercent);
-
-        vePendle = newVePendle;
-        gaugeController = newGaugeController;
-        externalRewardDistributor = newExternalRewardDistributor;
-    }
-
-    /**
-     * @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, externalRewardDistributor),
-            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);
-    }
-}