@pendle/core-v2 6.3.1 → 6.3.2-pendle-merkle-transfer

package/contracts/LiquidityMining/VotingController/VotingControllerStorageUpg.sol

@@ -5,11 +5,11 @@ import "../../interfaces/IPVeToken.sol";
 import "../../interfaces/IPVotingController.sol";
 
 import "../libraries/VeBalanceLib.sol";
-import "../libraries/VeHistoryLib.sol";
 import "../libraries/WeekMath.sol";
+import "../libraries/VeHistoryLib.sol";
 
-import "../../core/libraries/Errors.sol";
 import "../../core/libraries/MiniHelpers.sol";
+import "../../core/libraries/Errors.sol";
 
 import "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
 
@@ -110,7 +110,10 @@ abstract contract VotingControllerStorageUpg is IPVotingController {
         return __dep_userPoolHistory[user][pool].get(index);
     }
 
-    function getPoolData(address pool, uint128[] calldata wTimes)
+    function getPoolData(
+        address pool,
+        uint128[] calldata wTimes
+    )
         public
         view
         returns (
@@ -130,26 +133,22 @@ abstract contract VotingControllerStorageUpg is IPVotingController {
         }
     }
 
-    function getUserData(address user, address[] calldata pools)
-        public
-        view
-        returns (uint64 totalVotedWeight, UserPoolData[] memory voteForPools)
-    {
+    function getUserData(
+        address user,
+        address[] calldata pools
+    ) public view returns (uint64 totalVotedWeight, UserPoolData[] memory voteForPools) {
         UserData storage data = userData[user];
 
         totalVotedWeight = data.totalVotedWeight;
 
         voteForPools = new UserPoolData[](pools.length);
-        for (uint256 i = 0; i < pools.length; ++i) {
-            voteForPools[i] = data.voteForPools[pools[i]];
-        }
+        for (uint256 i = 0; i < pools.length; ++i) voteForPools[i] = data.voteForPools[pools[i]];
     }
 
-    function getWeekData(uint128 wTime, address[] calldata pools)
-        public
-        view
-        returns (bool isEpochFinalized, uint128 totalVotes, uint128[] memory poolVotes)
-    {
+    function getWeekData(
+        uint128 wTime,
+        address[] calldata pools
+    ) public view returns (bool isEpochFinalized, uint128 totalVotes, uint128[] memory poolVotes) {
         if (!wTime.isValidWTime()) revert Errors.InvalidWTime(wTime);
 
         WeekData storage data = weekData[wTime];
@@ -157,28 +156,23 @@ abstract contract VotingControllerStorageUpg is IPVotingController {
         (isEpochFinalized, totalVotes) = (data.isEpochFinalized, data.totalVotes);
 
         poolVotes = new uint128[](pools.length);
-        for (uint256 i = 0; i < pools.length; ++i) {
-            poolVotes[i] = data.poolVotes[pools[i]];
-        }
+        for (uint256 i = 0; i < pools.length; ++i) poolVotes[i] = data.poolVotes[pools[i]];
     }
 
     function getAllActivePools() external view returns (address[] memory) {
         return allActivePools.values();
     }
 
-    function getAllRemovedPools(uint256 start, uint256 end)
-        external
-        view
-        returns (uint256 lengthOfRemovedPools, address[] memory arr)
-    {
+    function getAllRemovedPools(
+        uint256 start,
+        uint256 end
+    ) external view returns (uint256 lengthOfRemovedPools, address[] memory arr) {
         lengthOfRemovedPools = allRemovedPools.length();
 
         if (end >= lengthOfRemovedPools) revert Errors.ArrayOutOfBounds();
 
         arr = new address[](end - start + 1);
-        for (uint256 i = start; i <= end; ++i) {
-            arr[i - start] = allRemovedPools.at(i);
-        }
+        for (uint256 i = start; i <= end; ++i) arr[i - start] = allRemovedPools.at(i);
     }
 
     function getActiveChainPools(uint64 chainId) external view returns (address[] memory) {
@@ -225,10 +219,12 @@ abstract contract VotingControllerStorageUpg is IPVotingController {
      * @notice modifies `user`'s vote weight on `pool`
      * @dev works by simply removing the old vote position, then adds in a fresh vote
      */
-    function _modifyVoteWeight(address user, address pool, LockedPosition memory userPosition, uint64 weight)
-        internal
-        returns (VeBalance memory newVote)
-    {
+    function _modifyVoteWeight(
+        address user,
+        address pool,
+        LockedPosition memory userPosition,
+        uint64 weight
+    ) internal returns (VeBalance memory newVote) {
         UserData storage uData = userData[user];
         PoolData storage pData = poolData[pool];
 

package/contracts/LiquidityMining/VotingEscrow/VotingEscrowPendleMainchain.sol

@@ -7,11 +7,11 @@ import "../../interfaces/IPVotingEscrowMainchain.sol";
 
 import "../libraries/VeHistoryLib.sol";
 
-import "../../core/libraries/Errors.sol";
 import "../../core/libraries/MiniHelpers.sol";
+import "../../core/libraries/Errors.sol";
 
-import "../CrossChainMsg/PendleMsgSenderAppUpg.sol";
 import "./VotingEscrowTokenBase.sol";
+import "../CrossChainMsg/PendleMsgSenderAppUpg.sol";
 
 contract VotingEscrowPendleMainchain is VotingEscrowTokenBase, IPVotingEscrowMainchain, PendleMsgSenderAppUpg {
     using SafeERC20 for IERC20;
@@ -40,10 +40,11 @@ contract VotingEscrowPendleMainchain is VotingEscrowTokenBase, IPVotingEscrowMai
     // to ask for their vePendle balance at any wTime
     mapping(address => Checkpoints.History) internal userHistory;
 
-    constructor(IERC20 _pendle, address _pendleMsgSendEndpoint, uint256 initialApproxDestinationGas)
-        initializer
-        PendleMsgSenderAppUpg(_pendleMsgSendEndpoint, initialApproxDestinationGas)
-    {
+    constructor(
+        IERC20 _pendle,
+        address _pendleMsgSendEndpoint,
+        uint256 initialApproxDestinationGas
+    ) initializer PendleMsgSenderAppUpg(_pendleMsgSendEndpoint, initialApproxDestinationGas) {
         pendle = _pendle;
         lastSlopeChangeAppliedAt = WeekMath.getCurrentWeekStart();
         __BoringOwnableV2_init(msg.sender);
@@ -69,10 +70,10 @@ contract VotingEscrowPendleMainchain is VotingEscrowTokenBase, IPVotingEscrowMai
      * @dev See `_increasePosition()` for details on inner workings.
      * @dev Sidechain broadcasting is not bundled since it can be done anytime after.
      */
-    function increaseLockPosition(uint128 additionalAmountToLock, uint128 newExpiry)
-        public
-        returns (uint128 newVeBalance)
-    {
+    function increaseLockPosition(
+        uint128 additionalAmountToLock,
+        uint128 newExpiry
+    ) public returns (uint128 newVeBalance) {
         address user = msg.sender;
 
         if (!WeekMath.isValidWTime(newExpiry)) revert Errors.InvalidWTime(newExpiry);
@@ -122,7 +123,7 @@ contract VotingEscrowPendleMainchain is VotingEscrowTokenBase, IPVotingEscrowMai
      * @dev See `broadcastTotalSupply()` and `broadcastUserPosition()` for broadcasting
      */
     function totalSupplyCurrent() public virtual override(IPVeToken, VotingEscrowTokenBase) returns (uint128) {
-        (VeBalance memory supply,) = _applySlopeChange();
+        (VeBalance memory supply, ) = _applySlopeChange();
         return supply.getCurrentValue();
     }
 
@@ -165,13 +166,14 @@ contract VotingEscrowPendleMainchain is VotingEscrowTokenBase, IPVotingEscrowMai
      * @dev works by simply removing the old position from all relevant data (as if the user has
      * never locked) and then add in the new position
      */
-    function _increasePosition(address user, uint128 amountToIncrease, uint128 durationToIncrease)
-        internal
-        returns (uint128)
-    {
+    function _increasePosition(
+        address user,
+        uint128 amountToIncrease,
+        uint128 durationToIncrease
+    ) internal returns (uint128) {
         LockedPosition memory oldPosition = positionData[user];
 
-        (VeBalance memory newSupply,) = _applySlopeChange();
+        (VeBalance memory newSupply, ) = _applySlopeChange();
 
         if (!MiniHelpers.isCurrentlyExpired(oldPosition.expiry)) {
             // remove old position not yet expired
@@ -180,8 +182,10 @@ contract VotingEscrowPendleMainchain is VotingEscrowTokenBase, IPVotingEscrowMai
             slopeChanges[oldPosition.expiry] -= oldBalance.slope;
         }
 
-        LockedPosition memory newPosition =
-            LockedPosition(oldPosition.amount + amountToIncrease, oldPosition.expiry + durationToIncrease);
+        LockedPosition memory newPosition = LockedPosition(
+            oldPosition.amount + amountToIncrease,
+            oldPosition.expiry + durationToIncrease
+        );
 
         VeBalance memory newBalance = newPosition.convertToVeBalance();
         // add new position
@@ -223,7 +227,7 @@ contract VotingEscrowPendleMainchain is VotingEscrowTokenBase, IPVotingEscrowMai
     function _broadcastPosition(address user, uint256[] calldata chainIds) internal {
         if (chainIds.length == 0) revert Errors.ArrayEmpty();
 
-        (VeBalance memory supply,) = _applySlopeChange();
+        (VeBalance memory supply, ) = _applySlopeChange();
 
         bytes memory userData = (user == address(0) ? EMPTY_BYTES : abi.encode(user, positionData[user]));
 

package/contracts/LiquidityMining/VotingEscrow/VotingEscrowPendleSidechain.sol

@@ -5,8 +5,8 @@ pragma solidity ^0.8.17;
 import "../libraries/VeBalanceLib.sol";
 import "../libraries/WeekMath.sol";
 
-import "../CrossChainMsg/PendleMsgReceiverAppUpg.sol";
 import "./VotingEscrowTokenBase.sol";
+import "../CrossChainMsg/PendleMsgReceiverAppUpg.sol";
 
 // solhint-disable no-empty-blocks
 contract VotingEscrowPendleSidechain is VotingEscrowTokenBase, PendleMsgReceiverAppUpg, BoringOwnableUpgradeableV2 {
@@ -20,10 +20,9 @@ contract VotingEscrowPendleSidechain is VotingEscrowTokenBase, PendleMsgReceiver
 
     event SetNewUserPosition(LockedPosition position);
 
-    constructor(address _PendleMsgReceiveEndpointUpg)
-        initializer
-        PendleMsgReceiverAppUpg(_PendleMsgReceiveEndpointUpg)
-    {
+    constructor(
+        address _PendleMsgReceiveEndpointUpg
+    ) initializer PendleMsgReceiverAppUpg(_PendleMsgReceiveEndpointUpg) {
         __BoringOwnableV2_init(msg.sender);
     }
 
@@ -45,8 +44,10 @@ contract VotingEscrowPendleSidechain is VotingEscrowTokenBase, PendleMsgReceiver
      * @dev If the message also contains some users' position, we should update it
      */
     function _executeMessage(bytes memory message) internal virtual override {
-        (uint128 msgTime, VeBalance memory supply, bytes memory userData) =
-            abi.decode(message, (uint128, VeBalance, bytes));
+        (uint128 msgTime, VeBalance memory supply, bytes memory userData) = abi.decode(
+            message,
+            (uint128, VeBalance, bytes)
+        );
         _setNewTotalSupply(msgTime, supply);
         if (userData.length > 0) {
             _setNewUserPosition(userData);

package/contracts/LiquidityMining/libraries/VeBalanceLib.sol

@@ -1,8 +1,8 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity ^0.8.0;
 
-import "../../core/libraries/Errors.sol";
 import "../../core/libraries/math/PMath.sol";
+import "../../core/libraries/Errors.sol";
 
 struct VeBalance {
     uint128 bias;
@@ -60,11 +60,10 @@ library VeBalanceLib {
         res.bias = res.slope * position.expiry;
     }
 
-    function convertToVeBalance(LockedPosition memory position, uint256 weight)
-        internal
-        pure
-        returns (VeBalance memory res)
-    {
+    function convertToVeBalance(
+        LockedPosition memory position,
+        uint256 weight
+    ) internal pure returns (VeBalance memory res) {
         res.slope = ((position.amount * weight) / MAX_LOCK_TIME / USER_VOTE_MAX_WEIGHT).Uint128();
         res.bias = res.slope * position.expiry;
     }

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/LogExpMath.sol";
 import "../libraries/math/PMath.sol";
+import "../libraries/math/LogExpMath.sol";
 
 import "../StandardizedYield/PYIndex.sol";
-import "../libraries/Errors.sol";
 import "../libraries/MiniHelpers.sol";
+import "../libraries/Errors.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 = 86_400;
+    uint256 internal constant DAY = 86400;
     uint256 internal constant IMPLIED_RATE_TIME = 365 * DAY;
 
     int256 internal constant MAX_MARKET_PROPORTION = (1e18 * 96) / 100;
@@ -52,13 +52,18 @@ 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();
@@ -66,37 +71,46 @@ 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();
@@ -107,11 +121,12 @@ 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
         /// ------------------------------------------------------------
@@ -150,11 +165,10 @@ 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
         /// ------------------------------------------------------------
@@ -176,18 +190,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
@@ -202,11 +216,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;
@@ -214,22 +228,32 @@ 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;
@@ -246,8 +270,9 @@ 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);
     }
@@ -267,7 +292,11 @@ 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();
@@ -313,11 +342,10 @@ 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());
@@ -334,9 +362,8 @@ 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);
 
@@ -358,10 +385,12 @@ 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
         /// ------------------------------------------------------------
@@ -377,7 +406,12 @@ library MarketMathCore {
         /// ------------------------------------------------------------
         /// WRITE
         /// ------------------------------------------------------------
-        market.lastLnImpliedRate =
-            _getLnImpliedRate(market.totalPt, totalAsset, rateScalar, initialAnchor, timeToExpiry);
+        market.lastLnImpliedRate = _getLnImpliedRate(
+            market.totalPt,
+            totalAsset,
+            rateScalar,
+            initialAnchor,
+            timeToExpiry
+        );
     }
 }