@pendle/core-v2 0.15.1-mainnet → 0.15.2-mainnet

package/contracts/core/BulkSeller/BulkSeller.sol

@@ -0,0 +1,259 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+import "@openzeppelin/contracts-upgradeable/security/ReentrancyGuardUpgradeable.sol";
+
+import "../../interfaces/IStandardizedYield.sol";
+import "../../interfaces/IPBulkSellerFactory.sol";
+import "../../interfaces/IPBulkSeller.sol";
+
+import "../libraries/TokenHelper.sol";
+import "../libraries/math/Math.sol";
+import "../libraries/Errors.sol";
+
+import "./BulkSellerMathCore.sol";
+
+contract BulkSeller is IPBulkSeller, Initializable, TokenHelper, ReentrancyGuardUpgradeable {
+    using Math for uint256;
+    using SafeERC20 for IERC20;
+    using BulkSellerMathCore for BulkSellerState;
+
+    event SwapExactTokenForSy(address receiver, uint256 netTokenIn, uint256 netSyOut);
+    event SwapExactSyForToken(address receiver, uint256 netSyIn, uint256 netTokenOut);
+    event RateUpdated(
+        uint256 newRateTokenToSy,
+        uint256 newRateSyToToken,
+        uint256 oldRateTokenToSy,
+        uint256 oldRateSyToToken
+    );
+    event ReBalanceTokenToSy(
+        uint256 netTokenDeposit,
+        uint256 netSyFromToken,
+        uint256 newTokenProp,
+        uint256 oldTokenProp
+    );
+    event ReBalanceSyToToken(
+        uint256 netSyRedeem,
+        uint256 netTokenFromSy,
+        uint256 newTokenProp,
+        uint256 oldTokenProp
+    );
+    event ReserveUpdated(uint256 totalToken, uint256 totalSy);
+    event FeeRateUpdated(uint256 newFeeRate, uint256 oldFeeRate);
+
+    struct BulkSellerStorage {
+        uint128 rateTokenToSy;
+        uint128 rateSyToToken;
+        uint128 totalSy;
+        uint128 totalToken;
+    }
+
+    address public token;
+    address public SY;
+    uint64 public feeRate;
+
+    address public factory;
+    BulkSellerStorage public _storage;
+
+    modifier onlyMaintainer() {
+        if (!IPBulkSellerFactory(factory).isMaintainer(msg.sender))
+            revert Errors.BulkNotMaintainer();
+        _;
+    }
+
+    modifier onlyAdmin() {
+        if (!IPBulkSellerFactory(factory).isAdmin(msg.sender)) revert Errors.BulkNotAdmin();
+        _;
+    }
+
+    // Since this contract is a beacon contract, no constructor should be defined.
+    function initialize(
+        address _token,
+        address _SY,
+        address _factory
+    ) external initializer {
+        __ReentrancyGuard_init();
+        token = _token;
+        SY = _SY;
+        factory = _factory;
+    }
+
+    function swapExactTokenForSy(
+        address receiver,
+        uint256 netTokenIn,
+        uint256 minSyOut
+    ) external nonReentrant returns (uint256 netSyOut) {
+        BulkSellerState memory state = readState();
+
+        netSyOut = state.swapExactTokenForSy(netTokenIn);
+
+        if (netSyOut < minSyOut) revert Errors.BulkInSufficientSyOut(netSyOut, minSyOut);
+
+        if (receiver != address(this)) _transferOut(SY, receiver, netSyOut);
+
+        _writeState(state);
+
+        if (_selfBalance(token) < state.totalToken)
+            revert Errors.BulkInsufficientTokenReceived(_selfBalance(token), state.totalToken);
+
+        emit SwapExactTokenForSy(receiver, netTokenIn, netSyOut);
+    }
+
+    function swapExactSyForToken(
+        address receiver,
+        uint256 exactSyIn,
+        uint256 minTokenOut
+    ) external nonReentrant returns (uint256 netTokenOut) {
+        BulkSellerState memory state = readState();
+
+        netTokenOut = state.swapExactSyForToken(exactSyIn);
+
+        if (netTokenOut < minTokenOut)
+            revert Errors.BulkInSufficientTokenOut(netTokenOut, minTokenOut);
+        if (receiver != address(this)) _transferOut(token, receiver, netTokenOut);
+
+        _writeState(state);
+
+        if (_selfBalance(SY) < state.totalSy)
+            revert Errors.BulkInsufficientSyReceived(_selfBalance(SY), state.totalSy);
+
+        emit SwapExactSyForToken(receiver, exactSyIn, netTokenOut);
+    }
+
+    function calcSwapExactTokenForSy(uint256 netTokenIn) external view returns (uint256 netSyOut) {
+        assert(_storage.rateTokenToSy != 0);
+        netSyOut = netTokenIn.mulDown(_storage.rateTokenToSy);
+    }
+
+    function calcSwapExactSyForToken(uint256 netSyIn) external view returns (uint256 netTokenOut) {
+        assert(_storage.rateSyToToken != 0);
+        netTokenOut = netSyIn.mulDown(_storage.rateSyToToken);
+    }
+
+    function readState() public view returns (BulkSellerState memory state) {
+        BulkSellerStorage storage s = _storage;
+
+        state = BulkSellerState({
+            rateTokenToSy: s.rateTokenToSy,
+            rateSyToToken: s.rateSyToToken,
+            totalToken: s.totalToken,
+            totalSy: s.totalSy,
+            feeRate: feeRate
+        });
+    }
+
+    function _writeState(BulkSellerState memory state) internal {
+        BulkSellerStorage memory tmp = BulkSellerStorage({
+            rateTokenToSy: state.rateTokenToSy.Uint128(),
+            rateSyToToken: state.rateSyToToken.Uint128(),
+            totalSy: state.totalSy.Uint128(),
+            totalToken: state.totalToken.Uint128()
+        });
+
+        _storage = tmp;
+    }
+
+    // ----------------- BulkSeller management -----------------
+
+    function increaseReserve(uint256 netTokenIn, uint256 netSyIn) external payable onlyMaintainer {
+        BulkSellerState memory state = readState();
+
+        state.totalToken += netTokenIn;
+        state.totalSy += netSyIn;
+
+        _transferIn(token, msg.sender, netTokenIn);
+        _transferIn(SY, msg.sender, netSyIn);
+
+        emit ReserveUpdated(state.totalToken, state.totalSy);
+
+        _writeState(state);
+    }
+
+    function decreaseReserve(uint256 netTokenOut, uint256 netSyOut) external onlyAdmin {
+        BulkSellerState memory state = readState();
+
+        if (netTokenOut == type(uint256).max) netTokenOut = state.totalToken;
+        if (netSyOut == type(uint256).max) netSyOut = state.totalSy;
+
+        state.totalToken -= netTokenOut;
+        state.totalSy -= netSyOut;
+
+        _transferOut(token, msg.sender, netTokenOut);
+        _transferOut(SY, msg.sender, netSyOut);
+
+        emit ReserveUpdated(state.totalToken, state.totalSy);
+
+        _writeState(state);
+    }
+
+    function reBalance(uint256 targetProp, uint256 maxDiff) external onlyMaintainer {
+        BulkSellerState memory state = readState();
+        uint256 oldTokenProp = state.getTokenProp();
+
+        (uint256 netTokenDeposit, uint256 netSyRedeem) = state.getReBalanceParams(targetProp);
+
+        if (netTokenDeposit > 0) {
+            uint256 netSyFromToken = _depositToken(netTokenDeposit);
+            state.reBalanceTokenToSy(netTokenDeposit, netSyFromToken, maxDiff);
+
+            uint256 newTokenProp = state.getTokenProp();
+            emit ReBalanceTokenToSy(netTokenDeposit, netSyFromToken, newTokenProp, oldTokenProp);
+        } else {
+            uint256 netTokenFromSy = _redeemSy(netSyRedeem);
+            state.reBalanceSyToToken(netSyRedeem, netTokenFromSy, maxDiff);
+
+            uint256 newTokenProp = state.getTokenProp();
+            emit ReBalanceSyToToken(netSyRedeem, netTokenFromSy, newTokenProp, oldTokenProp);
+        }
+
+        _writeState(state);
+    }
+
+    function setRate(
+        uint256 newRateSyToToken,
+        uint256 newRateTokenToSy,
+        uint256 maxDiff
+    ) external onlyMaintainer {
+        BulkSellerState memory state = readState();
+
+        emit RateUpdated(
+            newRateTokenToSy,
+            newRateSyToToken,
+            state.rateTokenToSy,
+            state.rateSyToToken
+        );
+
+        state.setRate(newRateSyToToken, newRateTokenToSy, maxDiff);
+
+        _writeState(state);
+    }
+
+    function setFeeRate(uint64 newFeeRate) external onlyMaintainer {
+        emit FeeRateUpdated(newFeeRate, feeRate);
+        feeRate = newFeeRate;
+    }
+
+    function getTokenProp() external view returns (uint256) {
+        BulkSellerState memory state = readState();
+        return state.getTokenProp();
+    }
+
+    function _depositToken(uint256 netTokenDeposit) internal returns (uint256 netSyFromToken) {
+        _safeApprove(token, SY, netTokenDeposit);
+        uint256 nativeToDeposit = token == NATIVE ? netTokenDeposit : 0;
+        return
+            IStandardizedYield(SY).deposit{ value: nativeToDeposit }(
+                address(this),
+                token,
+                netTokenDeposit,
+                0
+            );
+    }
+
+    function _redeemSy(uint256 netSyRedeem) internal returns (uint256 netTokenFromSy) {
+        _transferOut(SY, SY, netSyRedeem);
+        return IStandardizedYield(SY).redeem(address(this), netSyRedeem, token, 0, true);
+    }
+
+    receive() external payable {}
+}

package/contracts/core/BulkSeller/BulkSellerFactory.sol

@@ -0,0 +1,88 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+import "@openzeppelin/contracts/proxy/beacon/IBeacon.sol";
+import "@openzeppelin/contracts/proxy/beacon/BeaconProxy.sol";
+import "@openzeppelin/contracts/proxy/utils/UUPSUpgradeable.sol";
+
+import "@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol";
+import "../libraries/BoringOwnableUpgradeable.sol";
+
+import "../../interfaces/IStandardizedYield.sol";
+import "../../interfaces/IPBulkSellerFactory.sol";
+import "../libraries/Errors.sol";
+
+contract BulkSellerFactory is
+    IBeacon,
+    IPBulkSellerFactory,
+    Initializable,
+    AccessControlUpgradeable,
+    UUPSUpgradeable
+{
+    bytes32 public constant MAINTAINER = keccak256("MAINTAINER");
+
+    address public implementation;
+
+    mapping(address => mapping(address => address)) internal syToBulkSeller;
+
+    modifier onlyAdmin() {
+        if (!isAdmin(msg.sender)) revert Errors.BulkNotAdmin();
+        _;
+    }
+
+    constructor() initializer {}
+
+    function initialize(address implementation_) external initializer {
+        _grantRole(DEFAULT_ADMIN_ROLE, msg.sender);
+        upgradeBeacon(implementation_);
+    }
+
+    function createBulkSeller(address token, address SY)
+        external
+        onlyAdmin
+        returns (address bulk)
+    {
+        IStandardizedYield _SY = IStandardizedYield(SY);
+        if (syToBulkSeller[token][SY] != address(0))
+            revert Errors.BulkSellerAlreadyExisted(token, SY, syToBulkSeller[token][SY]);
+        if (_SY.isValidTokenIn(token) == false || _SY.isValidTokenOut(token) == false)
+            revert Errors.BulkSellerInvalidToken(token, SY);
+
+        bytes memory data = abi.encodeWithSignature(
+            "initialize(address,address,address)",
+            token,
+            SY,
+            address(this)
+        );
+
+        bulk = address(new BeaconProxy(address(this), data));
+
+        syToBulkSeller[token][SY] = bulk;
+
+        return bulk;
+    }
+
+    function get(address token, address SY) external view override returns (address) {
+        return syToBulkSeller[token][SY];
+    }
+
+    function isMaintainer(address addr) public view override returns (bool) {
+        return (hasRole(DEFAULT_ADMIN_ROLE, addr) || hasRole(MAINTAINER, addr));
+    }
+
+    function isAdmin(address addr) public view override returns (bool) {
+        return hasRole(DEFAULT_ADMIN_ROLE, addr);
+    }
+
+    // ----------------- upgrade-related -----------------
+    function upgradeBeacon(address newImplementation) public onlyAdmin {
+        require(
+            AddressUpgradeable.isContract(newImplementation),
+            "UpgradeableBeacon: implementation is not a contract"
+        );
+        implementation = newImplementation;
+        emit UpgradedBeacon(newImplementation);
+    }
+
+    function _authorizeUpgrade(address) internal override onlyAdmin {}
+}

package/contracts/core/BulkSeller/BulkSellerMathCore.sol

@@ -0,0 +1,143 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+import "../libraries/TokenHelper.sol";
+import "../libraries/math/Math.sol";
+import "../libraries/Errors.sol";
+
+struct BulkSellerState {
+    uint256 rateTokenToSy;
+    uint256 rateSyToToken;
+    uint256 totalToken;
+    uint256 totalSy;
+    uint256 feeRate;
+}
+
+library BulkSellerMathCore {
+    using Math for uint256;
+
+    function swapExactTokenForSy(BulkSellerState memory state, uint256 netTokenIn)
+        internal
+        pure
+        returns (uint256 netSyOut)
+    {
+        netSyOut = calcSwapExactTokenForSy(state, netTokenIn);
+        state.totalToken += netTokenIn;
+        state.totalSy -= netSyOut;
+    }
+
+    function swapExactSyForToken(BulkSellerState memory state, uint256 netSyIn)
+        internal
+        pure
+        returns (uint256 netTokenOut)
+    {
+        netTokenOut = calcSwapExactSyForToken(state, netSyIn);
+        state.totalSy += netSyIn;
+        state.totalToken -= netTokenOut;
+    }
+
+    function calcSwapExactTokenForSy(BulkSellerState memory state, uint256 netTokenIn)
+        internal
+        pure
+        returns (uint256 netSyOut)
+    {
+        uint256 postFeeRate = state.rateTokenToSy.mulDown(Math.ONE - state.feeRate);
+        assert(postFeeRate != 0);
+
+        netSyOut = netTokenIn.mulDown(postFeeRate);
+        if (netSyOut > state.totalSy)
+            revert Errors.BulkInsufficientSyForTrade(state.totalSy, netSyOut);
+    }
+
+    function calcSwapExactSyForToken(BulkSellerState memory state, uint256 netSyIn)
+        internal
+        pure
+        returns (uint256 netTokenOut)
+    {
+        uint256 postFeeRate = state.rateSyToToken.mulDown(Math.ONE - state.feeRate);
+        assert(postFeeRate != 0);
+
+        netTokenOut = netSyIn.mulDown(postFeeRate);
+        if (netTokenOut > state.totalToken)
+            revert Errors.BulkInsufficientTokenForTrade(state.totalToken, netTokenOut);
+    }
+
+    function getTokenProp(BulkSellerState memory state) internal pure returns (uint256) {
+        uint256 totalToken = state.totalToken;
+        uint256 totalTokenFromSy = state.totalSy.mulDown(state.rateSyToToken);
+        return totalToken.divDown(totalToken + totalTokenFromSy);
+    }
+
+    function getReBalanceParams(BulkSellerState memory state, uint256 targetTokenProp)
+        internal
+        pure
+        returns (uint256 netTokenToDeposit, uint256 netSyToRedeem)
+    {
+        uint256 currentTokenProp = getTokenProp(state);
+
+        if (currentTokenProp > targetTokenProp) {
+            netTokenToDeposit = state.totalToken.mulDown(
+                (currentTokenProp - targetTokenProp).divDown(currentTokenProp)
+            );
+        } else {
+            uint256 currentSyProp = Math.ONE - currentTokenProp;
+            netSyToRedeem = state.totalSy.mulDown(
+                (targetTokenProp - currentTokenProp).divDown(currentSyProp)
+            );
+        }
+    }
+
+    function reBalanceTokenToSy(
+        BulkSellerState memory state,
+        uint256 netTokenToDeposit,
+        uint256 netSyFromToken,
+        uint256 maxDiff
+    ) internal pure {
+        uint256 rate = netSyFromToken.divDown(netTokenToDeposit);
+
+        if (!Math.isAApproxB(rate, state.rateTokenToSy, maxDiff))
+            revert Errors.BulkBadRateTokenToSy(rate, state.rateTokenToSy, maxDiff);
+
+        state.totalToken -= netTokenToDeposit;
+        state.totalSy += netSyFromToken;
+    }
+
+    function reBalanceSyToToken(
+        BulkSellerState memory state,
+        uint256 netSyToRedeem,
+        uint256 netTokenFromSy,
+        uint256 maxDiff
+    ) internal pure {
+        uint256 rate = netTokenFromSy.divDown(netSyToRedeem);
+
+        if (!Math.isAApproxB(rate, state.rateSyToToken, maxDiff))
+            revert Errors.BulkBadRateSyToToken(rate, state.rateSyToToken, maxDiff);
+
+        state.totalToken += netTokenFromSy;
+        state.totalSy -= netSyToRedeem;
+    }
+
+    function setRate(
+        BulkSellerState memory state,
+        uint256 rateSyToToken,
+        uint256 rateTokenToSy,
+        uint256 maxDiff
+    ) internal pure {
+        if (
+            state.rateTokenToSy != 0 &&
+            !Math.isAApproxB(rateTokenToSy, state.rateTokenToSy, maxDiff)
+        ) {
+            revert Errors.BulkBadRateTokenToSy(rateTokenToSy, state.rateTokenToSy, maxDiff);
+        }
+
+        if (
+            state.rateSyToToken != 0 &&
+            !Math.isAApproxB(rateSyToToken, state.rateSyToToken, maxDiff)
+        ) {
+            revert Errors.BulkBadRateSyToToken(rateSyToToken, state.rateSyToToken, maxDiff);
+        }
+
+        state.rateTokenToSy = rateTokenToSy;
+        state.rateSyToToken = rateSyToToken;
+    }
+}

package/contracts/core/Market/PendleMarket.sol

@@ -83,6 +83,10 @@ contract PendleMarket is PendleERC20Permit, PendleGauge, IPMarket {
     /**
      * @notice PendleMarket allows users to provide in PT & SY in exchange for LPs, which
      * will grant LP holders more exchange fee over time
+     * @dev will mint as much LP as possible such that the corresponding SY and PT used do
+     * not exceed `netSyDesired` and `netPtDesired`, respectively
+     * @dev PT and SY should be transferred to this contract prior to calling
+     * @dev will revert if PT is expired
      */
     function mint(
         address receiver,
@@ -129,7 +133,7 @@ contract PendleMarket is PendleERC20Permit, PendleGauge, IPMarket {
 
     /**
      * @notice LP Holders can burn their LP to receive back SY & PT proportionally
-     * to their share of market
+     * to their share of the market
      */
     function burn(
         address receiverSy,
@@ -158,7 +162,8 @@ contract PendleMarket is PendleERC20Permit, PendleGauge, IPMarket {
        - Release the calculated amount of SY to receiver
        - Callback to msg.sender if data.length > 0
        - Ensure exactPtIn amount of PT has been transferred to this address
-     * @param data bytes data to be sent in the callback
+     * @dev will revert if PT is expired
+     * @param data bytes data to be sent in the callback (if any)
      */
     function swapExactPtForSy(
         address receiver,
@@ -190,12 +195,13 @@ contract PendleMarket is PendleERC20Permit, PendleGauge, IPMarket {
 
     /**
      * @notice Pendle Market allows swaps between PT & SY it is holding. This function
-     * aims to swap an exact amount of SY to PT.
+     * aims to swap SY for an exact amount of PT.
      * @dev steps working of this function
        - The exact outcome amount of PT will be transferred to receiver
        - Callback to msg.sender if data.length > 0
        - Ensure the calculated required amount of SY is transferred to this address
-     * @param data bytes data to be sent in the callback
+     * @dev will revert if PT is expired
+     * @param data bytes data to be sent in the callback (if any)
      */
     function swapSyForExactPt(
         address receiver,
@@ -226,7 +232,7 @@ contract PendleMarket is PendleERC20Permit, PendleGauge, IPMarket {
         emit Swap(receiver, exactPtOut.Int(), netSyIn.neg(), netSyToReserve);
     }
 
-    /// @notice force balances to match reserves
+    /// @notice forces balances to match reserves
     function skim() external nonReentrant {
         MarketState memory market = readState();
         uint256 excessPt = _selfBalance(PT) - market.totalPt.Uint();
@@ -235,10 +241,15 @@ contract PendleMarket is PendleERC20Permit, PendleGauge, IPMarket {
         IERC20(SY).safeTransfer(market.treasury, excessSy);
     }
 
+    /**
+     * @notice redeems the user's reward
+     * @return amount of reward token redeemed, in the same order as `getRewardTokens()`
+     */
     function redeemRewards(address user) external nonReentrant returns (uint256[] memory) {
         return _redeemRewards(user);
     }
 
+    /// @notice returns the list of reward tokens
     function getRewardTokens() external view returns (address[] memory) {
         return _getRewardTokens();
     }
@@ -248,7 +259,7 @@ contract PendleMarket is PendleERC20Permit, PendleGauge, IPMarket {
     //////////////////////////////////////////////////////////////*/
 
     function observe(uint32[] memory secondsAgos)
-        public
+        external
         view
         returns (uint216[] memory lnImpliedRateCumulative)
     {
@@ -302,7 +313,7 @@ contract PendleMarket is PendleERC20Permit, PendleGauge, IPMarket {
         (uint16 observationIndex, uint16 observationCardinality) = observations.write(
             _storage.observationIndex,
             uint32(block.timestamp),
-            lastLnImpliedRate96,
+            _storage.lastLnImpliedRate,
             _storage.observationCardinality,
             _storage.observationCardinalityNext
         );

package/contracts/core/Market/PendleMarketFactory.sol

@@ -30,6 +30,8 @@ contract PendleMarketFactory is BoringOwnableUpgradeable, IPMarketFactory {
 
     address public immutable yieldContractFactory;
     uint256 public immutable maxLnFeeRateRoot;
+    uint8 public constant maxReserveFeePercent = 100;
+    int256 public constant minInitialAnchor = Math.IONE;
 
     // PT -> scalarRoot -> initialAnchor
     mapping(address => mapping(int256 => mapping(int256 => address))) internal markets;
@@ -72,8 +74,8 @@ contract PendleMarketFactory 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.
+     * @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,
@@ -87,6 +89,9 @@ contract PendleMarketFactory is BoringOwnableUpgradeable, IPMarketFactory {
         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),
@@ -114,21 +119,26 @@ contract PendleMarketFactory is BoringOwnableUpgradeable, IPMarketFactory {
     }
 
     function setTreasury(address newTreasury) public onlyOwner {
+        if (newTreasury == address(0)) revert Errors.MarketFactoryZeroTreasury();
+
         marketConfig.treasury = newTreasury;
         _emitNewMarketConfigEvent();
     }
 
     function setlnFeeRateRoot(uint88 newLnFeeRateRoot) public onlyOwner {
         if (newLnFeeRateRoot > maxLnFeeRateRoot)
-            revert Errors.MFactoryLnFeeRateRootTooHigh(newLnFeeRateRoot, maxLnFeeRateRoot);
+            revert Errors.MarketFactoryLnFeeRateRootTooHigh(newLnFeeRateRoot, maxLnFeeRateRoot);
 
         marketConfig.lnFeeRateRoot = newLnFeeRateRoot;
         _emitNewMarketConfigEvent();
     }
 
     function setReserveFeePercent(uint8 newReserveFeePercent) public onlyOwner {
-        if (newReserveFeePercent > 100)
-            revert Errors.MFactoryReserveFeePercentTooHigh(newReserveFeePercent, 100);
+        if (newReserveFeePercent > maxReserveFeePercent)
+            revert Errors.MarketFactoryReserveFeePercentTooHigh(
+                newReserveFeePercent,
+                maxReserveFeePercent
+            );
 
         marketConfig.reserveFeePercent = newReserveFeePercent;
         _emitNewMarketConfigEvent();