@pendle/core-v2 6.3.0 → 6.3.1

package/contracts/core/Market/MarketMathCore.sol

@@ -1,12 +1,12 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity ^0.8.0;
 
-import "../libraries/math/PMath.sol";
 import "../libraries/math/LogExpMath.sol";
+import "../libraries/math/PMath.sol";
 
 import "../StandardizedYield/PYIndex.sol";
-import "../libraries/MiniHelpers.sol";
 import "../libraries/Errors.sol";
+import "../libraries/MiniHelpers.sol";
 
 struct MarketState {
     int256 totalPt;
@@ -40,7 +40,7 @@ library MarketMathCore {
 
     int256 internal constant MINIMUM_LIQUIDITY = 10 ** 3;
     int256 internal constant PERCENTAGE_DECIMALS = 100;
-    uint256 internal constant DAY = 86400;
+    uint256 internal constant DAY = 86_400;
     uint256 internal constant IMPLIED_RATE_TIME = 365 * DAY;
 
     int256 internal constant MAX_MARKET_PROPORTION = (1e18 * 96) / 100;
@@ -52,18 +52,13 @@ library MarketMathCore {
                 UINT FUNCTIONS TO PROXY TO CORE FUNCTIONS
     //////////////////////////////////////////////////////////////*/
 
-    function addLiquidity(
-        MarketState memory market,
-        uint256 syDesired,
-        uint256 ptDesired,
-        uint256 blockTime
-    ) internal pure returns (uint256 lpToReserve, uint256 lpToAccount, uint256 syUsed, uint256 ptUsed) {
-        (int256 _lpToReserve, int256 _lpToAccount, int256 _syUsed, int256 _ptUsed) = addLiquidityCore(
-            market,
-            syDesired.Int(),
-            ptDesired.Int(),
-            blockTime
-        );
+    function addLiquidity(MarketState memory market, uint256 syDesired, uint256 ptDesired, uint256 blockTime)
+        internal
+        pure
+        returns (uint256 lpToReserve, uint256 lpToAccount, uint256 syUsed, uint256 ptUsed)
+    {
+        (int256 _lpToReserve, int256 _lpToAccount, int256 _syUsed, int256 _ptUsed) =
+            addLiquidityCore(market, syDesired.Int(), ptDesired.Int(), blockTime);
 
         lpToReserve = _lpToReserve.Uint();
         lpToAccount = _lpToAccount.Uint();
@@ -71,46 +66,37 @@ library MarketMathCore {
         ptUsed = _ptUsed.Uint();
     }
 
-    function removeLiquidity(
-        MarketState memory market,
-        uint256 lpToRemove
-    ) internal pure returns (uint256 netSyToAccount, uint256 netPtToAccount) {
+    function removeLiquidity(MarketState memory market, uint256 lpToRemove)
+        internal
+        pure
+        returns (uint256 netSyToAccount, uint256 netPtToAccount)
+    {
         (int256 _syToAccount, int256 _ptToAccount) = removeLiquidityCore(market, lpToRemove.Int());
 
         netSyToAccount = _syToAccount.Uint();
         netPtToAccount = _ptToAccount.Uint();
     }
 
-    function swapExactPtForSy(
-        MarketState memory market,
-        PYIndex index,
-        uint256 exactPtToMarket,
-        uint256 blockTime
-    ) internal pure returns (uint256 netSyToAccount, uint256 netSyFee, uint256 netSyToReserve) {
-        (int256 _netSyToAccount, int256 _netSyFee, int256 _netSyToReserve) = executeTradeCore(
-            market,
-            index,
-            exactPtToMarket.neg(),
-            blockTime
-        );
+    function swapExactPtForSy(MarketState memory market, PYIndex index, uint256 exactPtToMarket, uint256 blockTime)
+        internal
+        pure
+        returns (uint256 netSyToAccount, uint256 netSyFee, uint256 netSyToReserve)
+    {
+        (int256 _netSyToAccount, int256 _netSyFee, int256 _netSyToReserve) =
+            executeTradeCore(market, index, exactPtToMarket.neg(), blockTime);
 
         netSyToAccount = _netSyToAccount.Uint();
         netSyFee = _netSyFee.Uint();
         netSyToReserve = _netSyToReserve.Uint();
     }
 
-    function swapSyForExactPt(
-        MarketState memory market,
-        PYIndex index,
-        uint256 exactPtToAccount,
-        uint256 blockTime
-    ) internal pure returns (uint256 netSyToMarket, uint256 netSyFee, uint256 netSyToReserve) {
-        (int256 _netSyToAccount, int256 _netSyFee, int256 _netSyToReserve) = executeTradeCore(
-            market,
-            index,
-            exactPtToAccount.Int(),
-            blockTime
-        );
+    function swapSyForExactPt(MarketState memory market, PYIndex index, uint256 exactPtToAccount, uint256 blockTime)
+        internal
+        pure
+        returns (uint256 netSyToMarket, uint256 netSyFee, uint256 netSyToReserve)
+    {
+        (int256 _netSyToAccount, int256 _netSyFee, int256 _netSyToReserve) =
+            executeTradeCore(market, index, exactPtToAccount.Int(), blockTime);
 
         netSyToMarket = _netSyToAccount.neg().Uint();
         netSyFee = _netSyFee.Uint();
@@ -121,12 +107,11 @@ library MarketMathCore {
                     CORE FUNCTIONS
     //////////////////////////////////////////////////////////////*/
 
-    function addLiquidityCore(
-        MarketState memory market,
-        int256 syDesired,
-        int256 ptDesired,
-        uint256 blockTime
-    ) internal pure returns (int256 lpToReserve, int256 lpToAccount, int256 syUsed, int256 ptUsed) {
+    function addLiquidityCore(MarketState memory market, int256 syDesired, int256 ptDesired, uint256 blockTime)
+        internal
+        pure
+        returns (int256 lpToReserve, int256 lpToAccount, int256 syUsed, int256 ptUsed)
+    {
         /// ------------------------------------------------------------
         /// CHECKS
         /// ------------------------------------------------------------
@@ -165,10 +150,11 @@ library MarketMathCore {
         market.totalLp += lpToAccount + lpToReserve;
     }
 
-    function removeLiquidityCore(
-        MarketState memory market,
-        int256 lpToRemove
-    ) internal pure returns (int256 netSyToAccount, int256 netPtToAccount) {
+    function removeLiquidityCore(MarketState memory market, int256 lpToRemove)
+        internal
+        pure
+        returns (int256 netSyToAccount, int256 netPtToAccount)
+    {
         /// ------------------------------------------------------------
         /// CHECKS
         /// ------------------------------------------------------------
@@ -190,18 +176,18 @@ library MarketMathCore {
         market.totalSy = market.totalSy.subNoNeg(netSyToAccount);
     }
 
-    function executeTradeCore(
-        MarketState memory market,
-        PYIndex index,
-        int256 netPtToAccount,
-        uint256 blockTime
-    ) internal pure returns (int256 netSyToAccount, int256 netSyFee, int256 netSyToReserve) {
+    function executeTradeCore(MarketState memory market, PYIndex index, int256 netPtToAccount, uint256 blockTime)
+        internal
+        pure
+        returns (int256 netSyToAccount, int256 netSyFee, int256 netSyToReserve)
+    {
         /// ------------------------------------------------------------
         /// CHECKS
         /// ------------------------------------------------------------
         if (MiniHelpers.isExpired(market.expiry, blockTime)) revert Errors.MarketExpired();
-        if (market.totalPt <= netPtToAccount)
+        if (market.totalPt <= netPtToAccount) {
             revert Errors.MarketInsufficientPtForTrade(market.totalPt, netPtToAccount);
+        }
 
         /// ------------------------------------------------------------
         /// MATH
@@ -216,11 +202,11 @@ library MarketMathCore {
         _setNewMarketStateTrade(market, comp, index, netPtToAccount, netSyToAccount, netSyToReserve, blockTime);
     }
 
-    function getMarketPreCompute(
-        MarketState memory market,
-        PYIndex index,
-        uint256 blockTime
-    ) internal pure returns (MarketPreCompute memory res) {
+    function getMarketPreCompute(MarketState memory market, PYIndex index, uint256 blockTime)
+        internal
+        pure
+        returns (MarketPreCompute memory res)
+    {
         if (MiniHelpers.isExpired(market.expiry, blockTime)) revert Errors.MarketExpired();
 
         uint256 timeToExpiry = market.expiry - blockTime;
@@ -228,32 +214,22 @@ library MarketMathCore {
         res.rateScalar = _getRateScalar(market, timeToExpiry);
         res.totalAsset = index.syToAsset(market.totalSy);
 
-        if (market.totalPt == 0 || res.totalAsset == 0)
+        if (market.totalPt == 0 || res.totalAsset == 0) {
             revert Errors.MarketZeroTotalPtOrTotalAsset(market.totalPt, res.totalAsset);
+        }
 
-        res.rateAnchor = _getRateAnchor(
-            market.totalPt,
-            market.lastLnImpliedRate,
-            res.totalAsset,
-            res.rateScalar,
-            timeToExpiry
-        );
+        res.rateAnchor =
+            _getRateAnchor(market.totalPt, market.lastLnImpliedRate, res.totalAsset, res.rateScalar, timeToExpiry);
         res.feeRate = _getExchangeRateFromImpliedRate(market.lnFeeRateRoot, timeToExpiry);
     }
 
-    function calcTrade(
-        MarketState memory market,
-        MarketPreCompute memory comp,
-        PYIndex index,
-        int256 netPtToAccount
-    ) internal pure returns (int256 netSyToAccount, int256 netSyFee, int256 netSyToReserve) {
-        int256 preFeeExchangeRate = _getExchangeRate(
-            market.totalPt,
-            comp.totalAsset,
-            comp.rateScalar,
-            comp.rateAnchor,
-            netPtToAccount
-        );
+    function calcTrade(MarketState memory market, MarketPreCompute memory comp, PYIndex index, int256 netPtToAccount)
+        internal
+        pure
+        returns (int256 netSyToAccount, int256 netSyFee, int256 netSyToReserve)
+    {
+        int256 preFeeExchangeRate =
+            _getExchangeRate(market.totalPt, comp.totalAsset, comp.rateScalar, comp.rateAnchor, netPtToAccount);
 
         int256 preFeeAssetToAccount = netPtToAccount.divDown(preFeeExchangeRate).neg();
         int256 fee = comp.feeRate;
@@ -270,9 +246,8 @@ library MarketMathCore {
         int256 netAssetToReserve = (fee * market.reserveFeePercent.Int()) / PERCENTAGE_DECIMALS;
         int256 netAssetToAccount = preFeeAssetToAccount - fee;
 
-        netSyToAccount = netAssetToAccount < 0
-            ? index.assetToSyUp(netAssetToAccount)
-            : index.assetToSy(netAssetToAccount);
+        netSyToAccount =
+            netAssetToAccount < 0 ? index.assetToSyUp(netAssetToAccount) : index.assetToSy(netAssetToAccount);
         netSyFee = index.assetToSy(fee);
         netSyToReserve = index.assetToSy(netAssetToReserve);
     }
@@ -292,11 +267,7 @@ library MarketMathCore {
         market.totalSy = market.totalSy.subNoNeg(netSyToAccount + netSyToReserve);
 
         market.lastLnImpliedRate = _getLnImpliedRate(
-            market.totalPt,
-            index.syToAsset(market.totalSy),
-            comp.rateScalar,
-            comp.rateAnchor,
-            timeToExpiry
+            market.totalPt, index.syToAsset(market.totalSy), comp.rateScalar, comp.rateAnchor, timeToExpiry
         );
 
         if (market.lastLnImpliedRate == 0) revert Errors.MarketZeroLnImpliedRate();
@@ -342,10 +313,11 @@ library MarketMathCore {
 
     /// @notice Converts an implied rate to an exchange rate given a time to expiry. The
     /// formula is E = e^rt
-    function _getExchangeRateFromImpliedRate(
-        uint256 lnImpliedRate,
-        uint256 timeToExpiry
-    ) internal pure returns (int256 exchangeRate) {
+    function _getExchangeRateFromImpliedRate(uint256 lnImpliedRate, uint256 timeToExpiry)
+        internal
+        pure
+        returns (int256 exchangeRate)
+    {
         uint256 rt = (lnImpliedRate * timeToExpiry) / IMPLIED_RATE_TIME;
 
         exchangeRate = LogExpMath.exp(rt.Int());
@@ -362,8 +334,9 @@ library MarketMathCore {
 
         int256 proportion = (numerator.divDown(totalPt + totalAsset));
 
-        if (proportion > MAX_MARKET_PROPORTION)
+        if (proportion > MAX_MARKET_PROPORTION) {
             revert Errors.MarketProportionTooHigh(proportion, MAX_MARKET_PROPORTION);
+        }
 
         int256 lnProportion = _logProportion(proportion);
 
@@ -385,12 +358,10 @@ library MarketMathCore {
         if (rateScalar <= 0) revert Errors.MarketRateScalarBelowZero(rateScalar);
     }
 
-    function setInitialLnImpliedRate(
-        MarketState memory market,
-        PYIndex index,
-        int256 initialAnchor,
-        uint256 blockTime
-    ) internal pure {
+    function setInitialLnImpliedRate(MarketState memory market, PYIndex index, int256 initialAnchor, uint256 blockTime)
+        internal
+        pure
+    {
         /// ------------------------------------------------------------
         /// CHECKS
         /// ------------------------------------------------------------
@@ -406,12 +377,7 @@ library MarketMathCore {
         /// ------------------------------------------------------------
         /// WRITE
         /// ------------------------------------------------------------
-        market.lastLnImpliedRate = _getLnImpliedRate(
-            market.totalPt,
-            totalAsset,
-            rateScalar,
-            initialAnchor,
-            timeToExpiry
-        );
+        market.lastLnImpliedRate =
+            _getLnImpliedRate(market.totalPt, totalAsset, rateScalar, initialAnchor, timeToExpiry);
     }
 }

package/contracts/core/Market/OracleLib.sol

@@ -13,31 +13,29 @@ library OracleLib {
         // 1 SLOT = 256 bits
     }
 
-    function transform(
-        Observation memory last,
-        uint32 blockTimestamp,
-        uint96 lnImpliedRate
-    ) public pure returns (Observation memory) {
-        return
-            Observation({
-                blockTimestamp: blockTimestamp,
-                lnImpliedRateCumulative: last.lnImpliedRateCumulative +
-                    uint216(lnImpliedRate) *
-                    (blockTimestamp - last.blockTimestamp),
-                initialized: true
-            });
+    function transform(Observation memory last, uint32 blockTimestamp, uint96 lnImpliedRate)
+        public
+        pure
+        returns (Observation memory)
+    {
+        return Observation({
+            blockTimestamp: blockTimestamp,
+            lnImpliedRateCumulative: last.lnImpliedRateCumulative + uint216(lnImpliedRate)
+                * (blockTimestamp - last.blockTimestamp),
+            initialized: true
+        });
     }
 
-    function initialize(
-        Observation[65535] storage self,
-        uint32 time
-    ) public returns (uint16 cardinality, uint16 cardinalityNext) {
+    function initialize(Observation[65_535] storage self, uint32 time)
+        public
+        returns (uint16 cardinality, uint16 cardinalityNext)
+    {
         self[0] = Observation({blockTimestamp: time, lnImpliedRateCumulative: 0, initialized: true});
         return (1, 1);
     }
 
     function write(
-        Observation[65535] storage self,
+        Observation[65_535] storage self,
         uint16 index,
         uint32 blockTimestamp,
         uint96 lnImpliedRate,
@@ -60,13 +58,13 @@ library OracleLib {
         self[indexUpdated] = transform(last, blockTimestamp, lnImpliedRate);
     }
 
-    function grow(Observation[65535] storage self, uint16 current, uint16 next) public returns (uint16) {
+    function grow(Observation[65_535] storage self, uint16 current, uint16 next) public returns (uint16) {
         if (current == 0) revert Errors.OracleUninitialized();
         // no-op if the passed next value isn't greater than the current next value
         if (next <= current) return current;
         // store in each slot to prevent fresh SSTOREs in swaps
         // this data will not be used because the initialized boolean is still false
-        for (uint16 i = current; i != next; ) {
+        for (uint16 i = current; i != next;) {
             self[i].blockTimestamp = 1;
             unchecked {
                 ++i;
@@ -75,12 +73,11 @@ library OracleLib {
         return next;
     }
 
-    function binarySearch(
-        Observation[65535] storage self,
-        uint32 target,
-        uint16 index,
-        uint16 cardinality
-    ) public view returns (Observation memory beforeOrAt, Observation memory atOrAfter) {
+    function binarySearch(Observation[65_535] storage self, uint32 target, uint16 index, uint16 cardinality)
+        public
+        view
+        returns (Observation memory beforeOrAt, Observation memory atOrAfter)
+    {
         uint256 l = (index + 1) % cardinality; // oldest observation
         uint256 r = l + cardinality - 1; // newest observation
         uint256 i;
@@ -108,7 +105,7 @@ library OracleLib {
     }
 
     function getSurroundingObservations(
-        Observation[65535] storage self,
+        Observation[65_535] storage self,
         uint32 target,
         uint96 lnImpliedRate,
         uint16 index,
@@ -140,7 +137,7 @@ library OracleLib {
     }
 
     function observeSingle(
-        Observation[65535] storage self,
+        Observation[65_535] storage self,
         uint32 time,
         uint32 secondsAgo,
         uint96 lnImpliedRate,
@@ -157,13 +154,8 @@ library OracleLib {
 
         uint32 target = time - secondsAgo;
 
-        (Observation memory beforeOrAt, Observation memory atOrAfter) = getSurroundingObservations(
-            self,
-            target,
-            lnImpliedRate,
-            index,
-            cardinality
-        );
+        (Observation memory beforeOrAt, Observation memory atOrAfter) =
+            getSurroundingObservations(self, target, lnImpliedRate, index, cardinality);
 
         if (target == beforeOrAt.blockTimestamp) {
             // we're at the left boundary
@@ -173,16 +165,17 @@ library OracleLib {
             return atOrAfter.lnImpliedRateCumulative;
         } else {
             // we're in the middle
-            return (beforeOrAt.lnImpliedRateCumulative +
-                uint216(
-                    (uint256(atOrAfter.lnImpliedRateCumulative - beforeOrAt.lnImpliedRateCumulative) *
-                        (target - beforeOrAt.blockTimestamp)) / (atOrAfter.blockTimestamp - beforeOrAt.blockTimestamp)
-                ));
+            return (beforeOrAt.lnImpliedRateCumulative
+                    + uint216(
+                        (uint256(atOrAfter.lnImpliedRateCumulative - beforeOrAt.lnImpliedRateCumulative)
+                                * (target - beforeOrAt.blockTimestamp))
+                            / (atOrAfter.blockTimestamp - beforeOrAt.blockTimestamp)
+                    ));
         }
     }
 
     function observe(
-        Observation[65535] storage self,
+        Observation[65_535] storage self,
         uint32 time,
         uint32[] memory secondsAgos,
         uint96 lnImpliedRate,

package/contracts/core/Market/PendleGauge.sol

@@ -2,15 +2,15 @@
 pragma solidity ^0.8.0;
 
 import "../../interfaces/IPGauge.sol";
-import "../../interfaces/IPVeToken.sol";
 import "../../interfaces/IPGaugeController.sol";
+import "../../interfaces/IPVeToken.sol";
 import "../../interfaces/IStandardizedYield.sol";
 
 import "../RewardManager/RewardManager.sol";
 
 /**
-Invariants to maintain:
-- before any changes to active balance, updateAndDistributeRewards() must be called
+ * Invariants to maintain:
+ * - before any changes to active balance, updateAndDistributeRewards() must be called
  */
 abstract contract PendleGauge is RewardManager, IPGauge {
     using PMath for uint256;
@@ -37,7 +37,7 @@ abstract contract PendleGauge is RewardManager, IPGauge {
 
     /**
      * @dev Since rewardShares is based on activeBalance, user's activeBalance must be updated AFTER
-        rewards is updated
+     *     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) {
@@ -57,7 +57,8 @@ abstract contract PendleGauge is RewardManager, IPGauge {
     }
 
     /**
-     * @dev should only be callable from `_updateUserActiveBalanceForTwo` to guarantee user != address(0) && user != address(this)
+     * @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));
@@ -78,9 +79,8 @@ abstract contract PendleGauge is RewardManager, IPGauge {
         // Inspired by Curve's Gauge
         uint256 veBoostedLpBalance = (lpBalance * TOKENLESS_PRODUCTION) / 100;
         if (vePendleSupply > 0) {
-            veBoostedLpBalance +=
-                (((_totalStaked() * vePendleBalance) / vePendleSupply) * (100 - TOKENLESS_PRODUCTION)) /
-                100;
+            veBoostedLpBalance += (((_totalStaked() * vePendleBalance) / vePendleSupply) * (100 - TOKENLESS_PRODUCTION))
+                / 100;
         }
         return veBoostedLpBalance;
     }

package/contracts/core/Market/PendleMarketFactoryV6Upg.sol

@@ -3,12 +3,12 @@ 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 "../../interfaces/IPYieldContractFactory.sol";
 
 import "../libraries/BaseSplitCodeFactory.sol";
-import "../libraries/Errors.sol";
 import "../libraries/BoringOwnableUpgradeableV2.sol";
+import "../libraries/Errors.sol";
 
 contract PendleMarketFactoryV6Upg is BoringOwnableUpgradeableV2, IPMarketFactory {
     using EnumerableSet for EnumerableSet.AddressSet;
@@ -70,22 +70,23 @@ contract PendleMarketFactoryV6Upg is BoringOwnableUpgradeableV2, 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,
-        uint80 lnFeeRateRoot
-    ) external returns (address market) {
+    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)
+        if (lnFeeRateRoot > maxLnFeeRateRoot) {
             revert Errors.MarketFactoryLnFeeRateRootTooHigh(lnFeeRateRoot, maxLnFeeRateRoot);
+        }
 
-        if (markets[PT][scalarRoot][initialAnchor][lnFeeRateRoot] != address(0))
+        if (markets[PT][scalarRoot][initialAnchor][lnFeeRateRoot] != address(0)) {
             revert Errors.MarketFactoryMarketExists();
+        }
 
-        if (initialAnchor < minInitialAnchor)
+        if (initialAnchor < minInitialAnchor) {
             revert Errors.MarketFactoryInitialAnchorTooLow(initialAnchor, minInitialAnchor);
+        }
 
         market = BaseSplitCodeFactory._create2(
             0,
@@ -104,10 +105,11 @@ contract PendleMarketFactoryV6Upg is BoringOwnableUpgradeableV2, IPMarketFactory
         emit CreateNewMarket(market, PT, scalarRoot, initialAnchor, lnFeeRateRoot);
     }
 
-    function getMarketConfig(
-        address market,
-        address router
-    ) external view returns (address _treasury, uint80 _overriddenFee, uint8 _reserveFeePercent) {
+    function getMarketConfig(address market, address router)
+        external
+        view
+        returns (address _treasury, uint80 _overriddenFee, uint8 _reserveFeePercent)
+    {
         (_treasury, _reserveFeePercent) = (treasury, reserveFeePercent);
         _overriddenFee = overriddenFee[router][market];
     }
@@ -119,8 +121,9 @@ contract PendleMarketFactoryV6Upg is BoringOwnableUpgradeableV2, IPMarketFactory
 
     function setTreasuryAndFeeReserve(address newTreasury, uint8 newReserveFeePercent) public onlyOwner {
         if (newTreasury == address(0)) revert Errors.MarketFactoryZeroTreasury();
-        if (newReserveFeePercent > maxReserveFeePercent)
+        if (newReserveFeePercent > maxReserveFeePercent) {
             revert Errors.MarketFactoryReserveFeePercentTooHigh(newReserveFeePercent, maxReserveFeePercent);
+        }
 
         treasury = newTreasury;
         reserveFeePercent = newReserveFeePercent;