@pendle/core-v2 3.0.0-beta-11 → 3.0.0-beta-12

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

@@ -31,12 +31,7 @@ abstract contract PendleGaugeV2 is RewardManager, IPGauge {
     uint256 public totalActiveSupply;
     mapping(address => uint256) public activeBalance;
 
-    constructor(
-        address _SY,
-        address _vePendle,
-        address _gaugeController,
-        address _externalRewardDistributor
-    ) {
+    constructor(address _SY, address _vePendle, address _gaugeController, address _externalRewardDistributor) {
         SY = _SY;
         vePENDLE = IPVeToken(_vePendle);
         gaugeController = _gaugeController;
@@ -80,19 +75,13 @@ abstract contract PendleGaugeV2 is RewardManager, IPGauge {
         activeBalance[user] = newActiveBalance;
     }
 
-    function _calcVeBoostedLpBalance(
-        address user,
-        uint256 lpBalance
-    ) internal virtual returns (uint256) {
-        (uint256 vePendleSupply, uint256 vePendleBalance) = vePENDLE.totalSupplyAndBalanceCurrent(
-            user
-        );
+    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)) /
+                (((_totalStaked() * vePendleBalance) / vePendleSupply) * (100 - TOKENLESS_PRODUCTION)) /
                 100;
         }
         return veBoostedLpBalance;
@@ -116,16 +105,11 @@ abstract contract PendleGaugeV2 is RewardManager, IPGauge {
         return activeBalance[user];
     }
 
-    function _getRewardTokens()
-        internal
-        view
-        virtual
-        override
-        returns (address[] memory rewardTokens)
-    {
+    function _getRewardTokens() internal view virtual override returns (address[] memory rewardTokens) {
         address[] memory SYRewards = IStandardizedYield(SY).getRewardTokens();
-        address[] memory externalRewards = IPExternalRewardDistributor(externalRewardDistributor)
-            .getRewardTokens(address(this));
+        address[] memory externalRewards = IPExternalRewardDistributor(externalRewardDistributor).getRewardTokens(
+            address(this)
+        );
 
         rewardTokens = SYRewards.merge(externalRewards);
         if (rewardTokens.contains(PENDLE)) return rewardTokens;

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

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.17;
+pragma solidity ^0.8.17;
 
 import "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
 
@@ -75,17 +75,11 @@ contract PendleMarketFactoryV2 is BoringOwnableUpgradeable, IPMarketFactory {
      * @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();
+    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 (markets[PT][scalarRoot][initialAnchor] != address(0)) revert Errors.MarketFactoryMarketExists();
 
         if (initialAnchor < minInitialAnchor)
             revert Errors.MarketFactoryInitialAnchorTooLow(initialAnchor, minInitialAnchor);
@@ -93,14 +87,7 @@ contract PendleMarketFactoryV2 is BoringOwnableUpgradeable, IPMarketFactory {
         market = BaseSplitCodeFactory._create2(
             0,
             bytes32(block.chainid),
-            abi.encode(
-                PT,
-                scalarRoot,
-                initialAnchor,
-                vePendle,
-                gaugeController,
-                externalRewardDistributor
-            ),
+            abi.encode(PT, scalarRoot, initialAnchor, vePendle, gaugeController, externalRewardDistributor),
             marketCreationCodeContractA,
             marketCreationCodeSizeA,
             marketCreationCodeContractB,
@@ -147,11 +134,7 @@ contract PendleMarketFactoryV2 is BoringOwnableUpgradeable, IPMarketFactory {
         _emitNewMarketConfigEvent();
     }
 
-    function setOverriddenFee(
-        address router,
-        uint80 newLnFeeRateRoot,
-        uint8 newReserveFeePercent
-    ) public onlyOwner {
+    function setOverriddenFee(address router, uint80 newLnFeeRateRoot, uint8 newReserveFeePercent) public onlyOwner {
         _verifyFeeConfig(newLnFeeRateRoot, newReserveFeePercent);
         overriddenFee[router] = FeeConfig(newLnFeeRateRoot, newReserveFeePercent, true);
         emit SetOverriddenFee(router, newLnFeeRateRoot, newReserveFeePercent);
@@ -166,10 +149,7 @@ contract PendleMarketFactoryV2 is BoringOwnableUpgradeable, IPMarketFactory {
         if (newLnFeeRateRoot > maxLnFeeRateRoot)
             revert Errors.MarketFactoryLnFeeRateRootTooHigh(newLnFeeRateRoot, maxLnFeeRateRoot);
         if (newReserveFeePercent > maxReserveFeePercent)
-            revert Errors.MarketFactoryReserveFeePercentTooHigh(
-                newReserveFeePercent,
-                maxReserveFeePercent
-            );
+            revert Errors.MarketFactoryReserveFeePercentTooHigh(newReserveFeePercent, maxReserveFeePercent);
     }
 
     function _emitNewMarketConfigEvent() internal {

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

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.17;
+pragma solidity ^0.8.17;
 
 import "../../../interfaces/IPMarket.sol";
 import "../../../interfaces/IPMarketFactory.sol";
@@ -64,19 +64,15 @@ contract PendleMarketV2 is PendleERC20Permit, PendleGaugeV2, IPMarket {
         address _externalRewardDistributor
     )
         PendleERC20Permit(NAME, SYMBOL, 18)
-        PendleGaugeV2(
-            IPPrincipalToken(_PT).SY(),
-            _vePendle,
-            _gaugeController,
-            _externalRewardDistributor
-        )
+        PendleGaugeV2(IPPrincipalToken(_PT).SY(), _vePendle, _gaugeController, _externalRewardDistributor)
     {
         PT = IPPrincipalToken(_PT);
         SY = IStandardizedYield(PT.SY());
         YT = IPYieldToken(PT.YT());
 
-        (_storage.observationCardinality, _storage.observationCardinalityNext) = observations
-            .initialize(uint32(block.timestamp));
+        (_storage.observationCardinality, _storage.observationCardinalityNext) = observations.initialize(
+            uint32(block.timestamp)
+        );
 
         if (_scalarRoot <= 0) revert Errors.MarketScalarRootBelowZero(_scalarRoot);
 
@@ -98,12 +94,7 @@ contract PendleMarketV2 is PendleERC20Permit, PendleGaugeV2, IPMarket {
         address receiver,
         uint256 netSyDesired,
         uint256 netPtDesired
-    )
-        external
-        nonReentrant
-        notExpired
-        returns (uint256 netLpOut, uint256 netSyUsed, uint256 netPtUsed)
-    {
+    ) external nonReentrant notExpired returns (uint256 netLpOut, uint256 netSyUsed, uint256 netPtUsed) {
         MarketState memory market = readState(msg.sender);
         PYIndex index = YT.newIndex();
 
@@ -175,11 +166,7 @@ contract PendleMarketV2 is PendleERC20Permit, PendleGaugeV2, IPMarket {
         MarketState memory market = readState(msg.sender);
 
         uint256 netSyToReserve;
-        (netSyOut, netSyFee, netSyToReserve) = market.swapExactPtForSy(
-            YT.newIndex(),
-            exactPtIn,
-            block.timestamp
-        );
+        (netSyOut, netSyFee, netSyToReserve) = market.swapExactPtForSy(YT.newIndex(), exactPtIn, block.timestamp);
 
         if (receiver != address(this)) IERC20(SY).safeTransfer(receiver, netSyOut);
         IERC20(SY).safeTransfer(market.treasury, netSyToReserve);
@@ -214,11 +201,7 @@ contract PendleMarketV2 is PendleERC20Permit, PendleGaugeV2, IPMarket {
         MarketState memory market = readState(msg.sender);
 
         uint256 netSyToReserve;
-        (netSyIn, netSyFee, netSyToReserve) = market.swapSyForExactPt(
-            YT.newIndex(),
-            exactPtOut,
-            block.timestamp
-        );
+        (netSyIn, netSyFee, netSyToReserve) = market.swapSyForExactPt(YT.newIndex(), exactPtOut, block.timestamp);
 
         if (receiver != address(this)) IERC20(PT).safeTransfer(receiver, exactPtOut);
         IERC20(SY).safeTransfer(market.treasury, netSyToReserve);
@@ -262,9 +245,7 @@ contract PendleMarketV2 is PendleERC20Permit, PendleGaugeV2, IPMarket {
                                 ORACLE
     //////////////////////////////////////////////////////////////*/
 
-    function observe(
-        uint32[] memory secondsAgos
-    ) external view returns (uint216[] memory lnImpliedRateCumulative) {
+    function observe(uint32[] memory secondsAgos) external view returns (uint216[] memory lnImpliedRateCumulative) {
         return
             observations.observe(
                 uint32(block.timestamp),
@@ -296,9 +277,9 @@ contract PendleMarketV2 is PendleERC20Permit, PendleGaugeV2, IPMarket {
         market.totalSy = _storage.totalSy;
         market.totalLp = totalSupply().Int();
 
-        (market.treasury, market.lnFeeRateRoot, market.reserveFeePercent) = IPMarketFactory(
-            factory
-        ).getMarketConfig(router);
+        (market.treasury, market.lnFeeRateRoot, market.reserveFeePercent) = IPMarketFactory(factory).getMarketConfig(
+            router
+        );
 
         market.scalarRoot = scalarRoot;
         market.expiry = expiry;
@@ -333,11 +314,7 @@ contract PendleMarketV2 is PendleERC20Permit, PendleGaugeV2, IPMarket {
                             TRIVIAL FUNCTIONS
     //////////////////////////////////////////////////////////////*/
 
-    function readTokens()
-        external
-        view
-        returns (IStandardizedYield _SY, IPPrincipalToken _PT, IPYieldToken _YT)
-    {
+    function readTokens() external view returns (IStandardizedYield _SY, IPPrincipalToken _PT, IPYieldToken _YT) {
         _SY = SY;
         _PT = PT;
         _YT = YT;

package/contracts/core/Market/v3/PendleMarketFactoryV3.sol

@@ -0,0 +1,137 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.17;
+import "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
+
+import "../../../interfaces/IPMarketV3.sol";
+import "../../../interfaces/IPYieldContractFactory.sol";
+import "../../../interfaces/IPMarketFactoryV3.sol";
+
+import "../../libraries/BaseSplitCodeFactory.sol";
+import "../../libraries/Errors.sol";
+import "../../libraries/BoringOwnableUpgradeable.sol";
+
+contract PendleMarketFactoryV3 is BoringOwnableUpgradeable, IPMarketFactoryV3 {
+    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;
+    address public immutable vePendle;
+    address public immutable gaugeController;
+
+    uint256 public immutable maxLnFeeRateRoot;
+    uint8 public constant maxReserveFeePercent = 100;
+    int256 public constant minInitialAnchor = PMath.IONE;
+
+    address public treasury;
+    uint8 public reserveFeePercent;
+
+    // router -> market -> lnFeeRateRoot. lnFeeRateRoot == 0 means no override
+    mapping(address => mapping(address => uint80)) internal overriddenFee;
+
+    // PT -> scalarRoot -> initialAnchor
+    mapping(address => mapping(int256 => mapping(int256 => mapping(uint80 => address)))) internal markets;
+    EnumerableSet.AddressSet internal allMarkets;
+
+    constructor(
+        address _yieldContractFactory,
+        address _marketCreationCodeContractA,
+        uint256 _marketCreationCodeSizeA,
+        address _marketCreationCodeContractB,
+        uint256 _marketCreationCodeSizeB,
+        address _treasury,
+        uint8 _reserveFeePercent,
+        address _vePendle,
+        address _gaugeController
+    ) initializer {
+        yieldContractFactory = _yieldContractFactory;
+        maxLnFeeRateRoot = uint256(LogExpMath.ln(int256((105 * PMath.IONE) / 100))); // ln(1.05)
+
+        marketCreationCodeContractA = _marketCreationCodeContractA;
+        marketCreationCodeSizeA = _marketCreationCodeSizeA;
+        marketCreationCodeContractB = _marketCreationCodeContractB;
+        marketCreationCodeSizeB = _marketCreationCodeSizeB;
+
+        __BoringOwnable_init();
+        setTreasuryAndFeeReserve(_treasury, _reserveFeePercent);
+
+        vePendle = _vePendle;
+        gaugeController = _gaugeController;
+    }
+
+    /**
+     * @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,
+        uint80 lnFeeRateRoot
+    ) external returns (address market) {
+        if (!IPYieldContractFactory(yieldContractFactory).isPT(PT)) revert Errors.MarketFactoryInvalidPt();
+        if (IPPrincipalToken(PT).isExpired()) revert Errors.MarketFactoryExpiredPt();
+        if (lnFeeRateRoot > maxLnFeeRateRoot)
+            revert Errors.MarketFactoryLnFeeRateRootTooHigh(lnFeeRateRoot, maxLnFeeRateRoot);
+
+        if (markets[PT][scalarRoot][initialAnchor][lnFeeRateRoot] != 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, lnFeeRateRoot, vePendle, gaugeController),
+            marketCreationCodeContractA,
+            marketCreationCodeSizeA,
+            marketCreationCodeContractB,
+            marketCreationCodeSizeB
+        );
+
+        markets[PT][scalarRoot][initialAnchor][lnFeeRateRoot] = market;
+
+        if (!allMarkets.add(market)) assert(false);
+
+        emit CreateNewMarket(market, PT, scalarRoot, initialAnchor, lnFeeRateRoot);
+    }
+
+    function getMarketConfig(
+        address market,
+        address router
+    ) external view returns (address _treasury, uint80 _overriddenFee, uint8 _reserveFeePercent) {
+        (_treasury, _reserveFeePercent) = (treasury, reserveFeePercent);
+        _overriddenFee = overriddenFee[router][market];
+    }
+
+    /// @dev for gas-efficient verification of market
+    function isValidMarket(address market) external view returns (bool) {
+        return allMarkets.contains(market);
+    }
+
+    function setTreasuryAndFeeReserve(address newTreasury, uint8 newReserveFeePercent) public onlyOwner {
+        if (newTreasury == address(0)) revert Errors.MarketFactoryZeroTreasury();
+        if (newReserveFeePercent > maxReserveFeePercent)
+            revert Errors.MarketFactoryReserveFeePercentTooHigh(newReserveFeePercent, maxReserveFeePercent);
+
+        treasury = newTreasury;
+        reserveFeePercent = newReserveFeePercent;
+
+        emit NewTreasuryAndFeeReserve(newTreasury, newReserveFeePercent);
+    }
+
+    function setOverriddenFee(address router, address market, uint80 newFee) public onlyOwner {
+        if (!allMarkets.contains(market)) revert Errors.MFNotPendleMarket(market);
+
+        uint80 marketFee = IPMarketV3(market).getNonOverrideLnFeeRateRoot();
+        if (newFee >= marketFee) revert Errors.MarketFactoryOverriddenFeeTooHigh(newFee, marketFee);
+
+        // NOTE: newFee = 0 allowed !!
+        overriddenFee[router][market] = newFee;
+        emit SetOverriddenFee(router, market, newFee);
+    }
+}