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

package/contracts/offchain-helpers/router-static/base/ActionVePendleStatic.sol

@@ -1,10 +1,10 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity ^0.8.17;
 
-import "../../../LiquidityMining/libraries/VeBalanceLib.sol";
 import "../../../core/libraries/MiniHelpers.sol";
 import "../../../interfaces/IPRouterStatic.sol";
 import "../../../interfaces/IPVotingEscrowMainchain.sol";
+import "../../../LiquidityMining/libraries/VeBalanceLib.sol";
 
 contract ActionVePendleStatic is IPActionVePendleStatic {
     using VeBalanceLib for VeBalance;
@@ -19,11 +19,11 @@ contract ActionVePendleStatic is IPActionVePendleStatic {
         vePENDLE = _vePENDLE;
     }
 
-    function increaseLockPositionStatic(address user, uint128 additionalAmountToLock, uint128 newExpiry)
-        external
-        view
-        returns (uint128 newVeBalance)
-    {
+    function increaseLockPositionStatic(
+        address user,
+        uint128 additionalAmountToLock,
+        uint128 newExpiry
+    ) external view returns (uint128 newVeBalance) {
         if (!WeekMath.isValidWTime(newExpiry)) revert Errors.InvalidWTime(newExpiry);
         if (MiniHelpers.isTimeInThePast(newExpiry)) revert Errors.ExpiryInThePast(newExpiry);
 
@@ -44,8 +44,10 @@ contract ActionVePendleStatic is IPActionVePendleStatic {
 
         uint128 additionalDurationToLock = newExpiry - oldPosition.expiry;
 
-        LockedPosition memory newPosition =
-            LockedPosition(oldPosition.amount + additionalAmountToLock, oldPosition.expiry + additionalDurationToLock);
+        LockedPosition memory newPosition = LockedPosition(
+            oldPosition.amount + additionalAmountToLock,
+            oldPosition.expiry + additionalDurationToLock
+        );
 
         VeBalance memory newBalance = newPosition.convertToVeBalance();
         return newBalance.getCurrentValue();

package/contracts/offchain-helpers/router-static/base/MarketApproxLibV1.sol

@@ -1,25 +1,23 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity ^0.8.0;
 
-import "../../../core/Market/MarketMathCore.sol";
 import "../../../core/libraries/math/PMath.sol";
+import "../../../core/Market/MarketMathCore.sol";
 import {ApproxParams} from "../../../interfaces/IPAllActionTypeV3.sol";
 
-/// Further explanation of the eps. Take swapExactSyForPt for example. To calc the corresponding amount of Pt to swap
-/// out, it's necessary to run an approximation algorithm, because by default there only exists the Pt to Sy formula
+/// Further explanation of the eps. Take swapExactSyForPt for example. To calc the corresponding amount of Pt to swap out,
+/// it's necessary to run an approximation algorithm, because by default there only exists the Pt to Sy formula
 /// To approx, the 5 values above will have to be provided, and the approx process will run as follows:
 /// mid = (guessMin + guessMax) / 2 // mid here is the current guess of the amount of Pt out
 /// netSyNeed = calcSwapSyForExactPt(mid)
 /// if (netSyNeed > exactSyIn) guessMax = mid - 1 // since the maximum Sy in can't exceed the exactSyIn
 /// else guessMin = mid (1)
 /// For the (1), since netSyNeed <= exactSyIn, the result might be usable. If the netSyNeed is within eps of
-/// exactSyIn (ex eps=0.1% => we have used 99.9% the amount of Sy specified), mid will be chosen as the final guess
-/// result
+/// exactSyIn (ex eps=0.1% => we have used 99.9% the amount of Sy specified), mid will be chosen as the final guess result
 
 /// for guessOffchain, this is to provide a shortcut to guessing. The offchain SDK can precalculate the exact result
-/// before the tx is sent. When the tx reaches the contract, the guessOffchain will be checked first, and if it
-/// satisfies the approximation, it will be used (and save all the guessing). It's expected that this shortcut will be
-/// used in most cases
+/// before the tx is sent. When the tx reaches the contract, the guessOffchain will be checked first, and if it satisfies the
+/// approximation, it will be used (and save all the guessing). It's expected that this shortcut will be used in most cases
 /// except in cases that there is a trade in the same market right before the tx
 
 library MarketApproxPtInLibV1 {
@@ -42,15 +40,7 @@ library MarketApproxPtInLibV1 {
         uint256 minSyOut,
         uint256 blockTime,
         ApproxParams memory approx
-    )
-        internal
-        pure
-        returns (
-            uint256, /*netPtIn*/
-            uint256, /*netSyOut*/
-            uint256 /*netSyFee*/
-        )
-    {
+    ) internal pure returns (uint256, /*netPtIn*/ uint256, /*netSyOut*/ uint256 /*netSyFee*/) {
         MarketPreCompute memory comp = market.getMarketPreCompute(index, blockTime);
         if (approx.guessOffchain == 0) {
             // no limit on min
@@ -60,7 +50,7 @@ library MarketApproxPtInLibV1 {
 
         for (uint256 iter = 0; iter < approx.maxIteration; ++iter) {
             uint256 guess = nextGuess(approx, iter);
-            (uint256 netSyOut, uint256 netSyFee,) = calcSyOut(market, comp, index, guess);
+            (uint256 netSyOut, uint256 netSyFee, ) = calcSyOut(market, comp, index, guess);
 
             if (netSyOut >= minSyOut) {
                 if (PMath.isAGreaterApproxB(netSyOut, minSyOut, approx.eps)) {
@@ -89,15 +79,7 @@ library MarketApproxPtInLibV1 {
         uint256 exactSyIn,
         uint256 blockTime,
         ApproxParams memory approx
-    )
-        internal
-        pure
-        returns (
-            uint256, /*netYtOut*/
-            uint256, /*netSyFee*/
-            uint256 /*iter*/
-        )
-    {
+    ) internal pure returns (uint256, /*netYtOut*/ uint256 /*netSyFee*/, uint256 /*iter*/) {
         MarketPreCompute memory comp = market.getMarketPreCompute(index, blockTime);
         if (approx.guessOffchain == 0) {
             approx.guessMin = PMath.max(approx.guessMin, index.syToAsset(exactSyIn));
@@ -110,7 +92,7 @@ library MarketApproxPtInLibV1 {
         for (uint256 iter = 0; iter < approx.maxIteration; ++iter) {
             uint256 guess = nextGuess(approx, iter);
 
-            (uint256 netSyOut, uint256 netSyFee,) = calcSyOut(market, comp, index, guess);
+            (uint256 netSyOut, uint256 netSyFee, ) = calcSyOut(market, comp, index, guess);
 
             uint256 netSyToTokenizePt = index.assetToSyUp(guess);
 
@@ -153,16 +135,7 @@ library MarketApproxPtInLibV1 {
         uint256 _netSyHolding,
         uint256 _blockTime,
         ApproxParams memory approx
-    )
-        internal
-        pure
-        returns (
-            uint256, /*netPtSwap*/
-            uint256, /*netSyFromSwap*/
-            uint256, /*netSyFee*/
-            uint256 /*iter*/
-        )
-    {
+    ) internal pure returns (uint256, /*netPtSwap*/ uint256, /*netSyFromSwap*/ uint256, /*netSyFee*/ uint256 /*iter*/) {
         Args5 memory a = Args5(_market, _index, _totalPtIn, _netSyHolding, _blockTime, approx);
         MarketPreCompute memory comp = a.market.getMarketPreCompute(a.index, a.blockTime);
         if (approx.guessOffchain == 0) {
@@ -176,8 +149,14 @@ library MarketApproxPtInLibV1 {
         for (uint256 iter = 0; iter < approx.maxIteration; ++iter) {
             uint256 guess = nextGuess(approx, iter);
 
-            (uint256 syNumerator, uint256 ptNumerator, uint256 netSyOut, uint256 netSyFee,) =
-                calcNumerators(a.market, a.index, a.totalPtIn, a.netSyHolding, comp, guess);
+            (uint256 syNumerator, uint256 ptNumerator, uint256 netSyOut, uint256 netSyFee, ) = calcNumerators(
+                a.market,
+                a.index,
+                a.totalPtIn,
+                a.netSyHolding,
+                comp,
+                guess
+            );
 
             if (PMath.isAApproxB(syNumerator, ptNumerator, approx.eps)) {
                 return (guess, netSyOut, netSyFee, iter);
@@ -235,15 +214,7 @@ library MarketApproxPtInLibV1 {
         uint256 exactPtIn,
         uint256 blockTime,
         ApproxParams memory approx
-    )
-        internal
-        pure
-        returns (
-            uint256, /*netYtOut*/
-            uint256, /*totalPtToSwap*/
-            uint256 /*netSyFee*/
-        )
-    {
+    ) internal pure returns (uint256, /*netYtOut*/ uint256, /*totalPtToSwap*/ uint256 /*netSyFee*/) {
         MarketPreCompute memory comp = market.getMarketPreCompute(index, blockTime);
         if (approx.guessOffchain == 0) {
             approx.guessMin = PMath.max(approx.guessMin, exactPtIn);
@@ -254,7 +225,7 @@ library MarketApproxPtInLibV1 {
         for (uint256 iter = 0; iter < approx.maxIteration; ++iter) {
             uint256 guess = nextGuess(approx, iter);
 
-            (uint256 netSyOut, uint256 netSyFee,) = calcSyOut(market, comp, index, guess);
+            (uint256 netSyOut, uint256 netSyFee, ) = calcSyOut(market, comp, index, guess);
 
             uint256 netAssetOut = index.syToAsset(netSyOut);
 
@@ -275,11 +246,12 @@ library MarketApproxPtInLibV1 {
 
     ////////////////////////////////////////////////////////////////////////////////
 
-    function calcSyOut(MarketState memory market, MarketPreCompute memory comp, PYIndex index, uint256 netPtIn)
-        internal
-        pure
-        returns (uint256 netSyOut, uint256 netSyFee, uint256 netSyToReserve)
-    {
+    function calcSyOut(
+        MarketState memory market,
+        MarketPreCompute memory comp,
+        PYIndex index,
+        uint256 netPtIn
+    ) internal pure returns (uint256 netSyOut, uint256 netSyFee, uint256 netSyToReserve) {
         (int256 _netSyOut, int256 _netSyFee, int256 _netSyToReserve) = market.calcTrade(comp, index, -int256(netPtIn));
         netSyOut = uint256(_netSyOut);
         netSyFee = uint256(_netSyFee);
@@ -351,15 +323,7 @@ library MarketApproxPtOutLibV1 {
         uint256 exactSyIn,
         uint256 blockTime,
         ApproxParams memory approx
-    )
-        internal
-        pure
-        returns (
-            uint256, /*netPtOut*/
-            uint256, /*netSyFee*/
-            uint256 /*iter*/
-        )
-    {
+    ) internal pure returns (uint256, /*netPtOut*/ uint256 /*netSyFee*/, uint256 /*iter*/) {
         MarketPreCompute memory comp = market.getMarketPreCompute(index, blockTime);
         if (approx.guessOffchain == 0) {
             // no limit on min
@@ -370,7 +334,7 @@ library MarketApproxPtOutLibV1 {
         for (uint256 iter = 0; iter < approx.maxIteration; ++iter) {
             uint256 guess = nextGuess(approx, iter);
 
-            (uint256 netSyIn, uint256 netSyFee,) = calcSyIn(market, comp, index, guess);
+            (uint256 netSyIn, uint256 netSyFee, ) = calcSyIn(market, comp, index, guess);
 
             if (netSyIn <= exactSyIn) {
                 if (PMath.isASmallerApproxB(netSyIn, exactSyIn, approx.eps)) {
@@ -399,15 +363,7 @@ library MarketApproxPtOutLibV1 {
         uint256 minSyOut,
         uint256 blockTime,
         ApproxParams memory approx
-    )
-        internal
-        pure
-        returns (
-            uint256, /*netYtIn*/
-            uint256, /*netSyOut*/
-            uint256 /*netSyFee*/
-        )
-    {
+    ) internal pure returns (uint256, /*netYtIn*/ uint256, /*netSyOut*/ uint256 /*netSyFee*/) {
         MarketPreCompute memory comp = market.getMarketPreCompute(index, blockTime);
         if (approx.guessOffchain == 0) {
             // no limit on min
@@ -418,7 +374,7 @@ library MarketApproxPtOutLibV1 {
         for (uint256 iter = 0; iter < approx.maxIteration; ++iter) {
             uint256 guess = nextGuess(approx, iter);
 
-            (uint256 netSyOwed, uint256 netSyFee,) = calcSyIn(market, comp, index, guess);
+            (uint256 netSyOwed, uint256 netSyFee, ) = calcSyIn(market, comp, index, guess);
 
             uint256 netAssetToRepay = index.syToAssetUp(netSyOwed);
             uint256 netSyOut = index.assetToSy(guess - netAssetToRepay);
@@ -459,16 +415,7 @@ library MarketApproxPtOutLibV1 {
         uint256 _netPtHolding,
         uint256 _blockTime,
         ApproxParams memory _approx
-    )
-        internal
-        pure
-        returns (
-            uint256, /*netPtFromSwap*/
-            uint256, /*netSySwap*/
-            uint256, /*netSyFee*/
-            uint256 /*iter*/
-        )
-    {
+    ) internal pure returns (uint256, /*netPtFromSwap*/ uint256, /*netSySwap*/ uint256, /*netSyFee*/ uint256 /*iter*/) {
         Args6 memory a = Args6(_market, _index, _totalSyIn, _netPtHolding, _blockTime, _approx);
 
         MarketPreCompute memory comp = a.market.getMarketPreCompute(a.index, a.blockTime);
@@ -535,15 +482,7 @@ library MarketApproxPtOutLibV1 {
         uint256 exactYtIn,
         uint256 blockTime,
         ApproxParams memory approx
-    )
-        internal
-        pure
-        returns (
-            uint256, /*netPtOut*/
-            uint256, /*totalPtSwapped*/
-            uint256 /*netSyFee*/
-        )
-    {
+    ) internal pure returns (uint256, /*netPtOut*/ uint256, /*totalPtSwapped*/ uint256 /*netSyFee*/) {
         MarketPreCompute memory comp = market.getMarketPreCompute(index, blockTime);
         if (approx.guessOffchain == 0) {
             approx.guessMin = PMath.max(approx.guessMin, exactYtIn);
@@ -554,7 +493,7 @@ library MarketApproxPtOutLibV1 {
         for (uint256 iter = 0; iter < approx.maxIteration; ++iter) {
             uint256 guess = nextGuess(approx, iter);
 
-            (uint256 netSyOwed, uint256 netSyFee,) = calcSyIn(market, comp, index, guess);
+            (uint256 netSyOwed, uint256 netSyFee, ) = calcSyIn(market, comp, index, guess);
 
             uint256 netYtToPull = index.syToAssetUp(netSyOwed);
 
@@ -572,11 +511,12 @@ library MarketApproxPtOutLibV1 {
 
     ////////////////////////////////////////////////////////////////////////////////
 
-    function calcSyIn(MarketState memory market, MarketPreCompute memory comp, PYIndex index, uint256 netPtOut)
-        internal
-        pure
-        returns (uint256 netSyIn, uint256 netSyFee, uint256 netSyToReserve)
-    {
+    function calcSyIn(
+        MarketState memory market,
+        MarketPreCompute memory comp,
+        PYIndex index,
+        uint256 netPtOut
+    ) internal pure returns (uint256 netSyIn, uint256 netSyFee, uint256 netSyToReserve) {
         (int256 _netSyIn, int256 _netSyFee, int256 _netSyToReserve) = market.calcTrade(comp, index, int256(netPtOut));
 
         // all safe since totalPt and totalSy is int128

package/contracts/oracles/CrossChainOracle/base/PendleCrossChainOracleBaseApp_Init.sol

@@ -1,16 +1,9 @@
 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8.0;
 
+import {OAppUpgradeable, Origin, MessagingFee, MessagingReceipt} from "@layerzerolabs/oapp-evm-upgradeable/contracts/oapp/OAppUpgradeable.sol";
+import {OAppOptionsType3Upgradeable} from "@layerzerolabs/oapp-evm-upgradeable/contracts/oapp/libs/OAppOptionsType3Upgradeable.sol";
 import {ILayerZeroEndpointV2} from "@layerzerolabs/lz-evm-protocol-v2/contracts/interfaces/ILayerZeroEndpointV2.sol";
-import {
-    MessagingFee,
-    MessagingReceipt,
-    OAppUpgradeable,
-    Origin
-} from "@layerzerolabs/oapp-evm-upgradeable/contracts/oapp/OAppUpgradeable.sol";
-import {
-    OAppOptionsType3Upgradeable
-} from "@layerzerolabs/oapp-evm-upgradeable/contracts/oapp/libs/OAppOptionsType3Upgradeable.sol";
 
 abstract contract PendleCrossChainOracleBaseApp_Init is OAppUpgradeable, OAppOptionsType3Upgradeable {
     uint32 public immutable eid;
@@ -21,11 +14,10 @@ abstract contract PendleCrossChainOracleBaseApp_Init is OAppUpgradeable, OAppOpt
         eid = ILayerZeroEndpointV2(_endpoint).eid();
     }
 
-    function __PendleCrossChainOracleBaseApp_initialize(address _owner, address _delegate)
-        internal
-        virtual
-        onlyInitializing
-    {
+    function __PendleCrossChainOracleBaseApp_initialize(
+        address _owner,
+        address _delegate
+    ) internal virtual onlyInitializing {
         __OApp_init(_delegate);
         _transferOwnership(_owner);
     }

package/contracts/oracles/CrossChainOracle/exchangeRate/PendleExchangeRateOracleApp.sol

@@ -1,11 +1,11 @@
 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8.0;
 
-import {Errors} from "../../../core/libraries/Errors.sol";
+import "../base/PendleCrossChainOracleBaseApp_Init.sol";
 import "../../../interfaces/IPExchangeRateOracleApp.sol";
 import {IStandardizedYield} from "../../../interfaces/IStandardizedYield.sol";
-import "../base/PendleCrossChainOracleBaseApp_Init.sol";
 import {ExchangeRateMsgCodec} from "../libraries/ExchangeRateMsgCodec.sol";
+import {Errors} from "../../../core/libraries/Errors.sol";
 
 /**
  * @title PendleExchangeRateOracleApp
@@ -34,11 +34,10 @@ contract PendleExchangeRateOracleApp is PendleCrossChainOracleBaseApp_Init, IPEx
     }
 
     /// @inheritdoc IPExchangeRateOracleApp
-    function quoteSendExchangeRateBatch(SendExchangeRateParam[] calldata sendParams, bool[] calldata payInLzTokens)
-        external
-        view
-        returns (MessagingFee[] memory fees)
-    {
+    function quoteSendExchangeRateBatch(
+        SendExchangeRateParam[] calldata sendParams,
+        bool[] calldata payInLzTokens
+    ) external view returns (MessagingFee[] memory fees) {
         if (sendParams.length != payInLzTokens.length) revert Errors.ArrayLengthMismatch();
 
         uint256 length = sendParams.length;
@@ -50,21 +49,18 @@ contract PendleExchangeRateOracleApp is PendleCrossChainOracleBaseApp_Init, IPEx
     }
 
     /// @inheritdoc IPExchangeRateOracleApp
-    function quoteSendExchangeRate(SendExchangeRateParam calldata sendParam, bool payInLzToken)
-        external
-        view
-        returns (MessagingFee memory fee)
-    {
+    function quoteSendExchangeRate(
+        SendExchangeRateParam calldata sendParam,
+        bool payInLzToken
+    ) external view returns (MessagingFee memory fee) {
         return _quoteSendExchangeRate(sendParam, payInLzToken);
     }
 
     /// @inheritdoc IPExchangeRateOracleApp
-    function sendExchangeRateBatch(SendExchangeRateParam[] calldata sendParams, MessagingFee[] calldata fees)
-        external
-        payable
-        onlyOwnerOrAllowedSender
-        returns (MessagingReceipt[] memory receipts)
-    {
+    function sendExchangeRateBatch(
+        SendExchangeRateParam[] calldata sendParams,
+        MessagingFee[] calldata fees
+    ) external payable onlyOwnerOrAllowedSender returns (MessagingReceipt[] memory receipts) {
         if (sendParams.length != fees.length) revert Errors.ArrayLengthMismatch();
         _validateNativeFees(fees);
 
@@ -77,22 +73,19 @@ contract PendleExchangeRateOracleApp is PendleCrossChainOracleBaseApp_Init, IPEx
     }
 
     /// @inheritdoc IPExchangeRateOracleApp
-    function sendExchangeRate(SendExchangeRateParam calldata sendParam, MessagingFee calldata fee)
-        external
-        payable
-        onlyOwnerOrAllowedSender
-        returns (MessagingReceipt memory receipt)
-    {
+    function sendExchangeRate(
+        SendExchangeRateParam calldata sendParam,
+        MessagingFee calldata fee
+    ) external payable onlyOwnerOrAllowedSender returns (MessagingReceipt memory receipt) {
         _validateNativeFee(fee);
         return _sendExchangeRate(sendParam, fee);
     }
 
     /// @inheritdoc IPExchangeRateOracleApp
-    function getExchangeRate(uint32 _srcEid, bytes32 exchangeRateSource)
-        external
-        view
-        returns (ExchangeRateData memory exchangeRateData)
-    {
+    function getExchangeRate(
+        uint32 _srcEid,
+        bytes32 exchangeRateSource
+    ) external view returns (ExchangeRateData memory exchangeRateData) {
         if (_srcEid == eid) {
             uint256 exchangeRate = _getExchangeRateFromSource(exchangeRateSource.bytes32ToAddress());
             return ExchangeRateData(exchangeRate, block.timestamp);
@@ -103,11 +96,10 @@ contract PendleExchangeRateOracleApp is PendleCrossChainOracleBaseApp_Init, IPEx
         if (exchangeRateData.updatedAt == 0) revert Errors.FeedNotInitialized();
     }
 
-    function _quoteSendExchangeRate(SendExchangeRateParam calldata sendParam, bool payInLzToken)
-        internal
-        view
-        returns (MessagingFee memory fee)
-    {
+    function _quoteSendExchangeRate(
+        SendExchangeRateParam calldata sendParam,
+        bool payInLzToken
+    ) internal view returns (MessagingFee memory fee) {
         _validateDstEid(sendParam.dstEid);
         uint256 exchangeRate = _getExchangeRateFromSource(sendParam.exchangeRateSource);
         (bytes memory message, bytes memory options) = _buildMsgAndOptions(sendParam, exchangeRate);
@@ -115,10 +107,10 @@ contract PendleExchangeRateOracleApp is PendleCrossChainOracleBaseApp_Init, IPEx
         fee = _quote(sendParam.dstEid, message, options, payInLzToken);
     }
 
-    function _sendExchangeRate(SendExchangeRateParam calldata sendParam, MessagingFee calldata fee)
-        internal
-        returns (MessagingReceipt memory receipt)
-    {
+    function _sendExchangeRate(
+        SendExchangeRateParam calldata sendParam,
+        MessagingFee calldata fee
+    ) internal returns (MessagingReceipt memory receipt) {
         _validateDstEid(sendParam.dstEid);
         uint256 exchangeRate = _getExchangeRateFromSource(sendParam.exchangeRateSource);
         (bytes memory message, bytes memory options) = _buildMsgAndOptions(sendParam, exchangeRate);
@@ -132,13 +124,9 @@ contract PendleExchangeRateOracleApp is PendleCrossChainOracleBaseApp_Init, IPEx
         Origin calldata _origin,
         bytes32 _guid,
         bytes calldata _message,
-        address,
-        /*_executor*/
+        address /*_executor*/,
         bytes calldata /*_extraData*/
-    )
-        internal
-        override
-    {
+    ) internal override {
         (bytes32 exchangeRateSource, uint256 exchangeRate, uint256 updatedAt) = _message.decodeMessage();
 
         bool rateAccepted = _updateExchangeRate(_origin.srcEid, exchangeRateSource, exchangeRate, updatedAt);
@@ -146,15 +134,17 @@ contract PendleExchangeRateOracleApp is PendleCrossChainOracleBaseApp_Init, IPEx
         emit ExchangeRateReceived(_guid, _origin.srcEid, exchangeRateSource, exchangeRate, updatedAt, rateAccepted);
     }
 
-    function _buildMsgAndOptions(SendExchangeRateParam calldata sendParam, uint256 exchangeRate)
-        internal
-        view
-        returns (bytes memory message, bytes memory options)
-    {
+    function _buildMsgAndOptions(
+        SendExchangeRateParam calldata sendParam,
+        uint256 exchangeRate
+    ) internal view returns (bytes memory message, bytes memory options) {
         uint16 msgType;
 
-        (msgType, message) =
-            ExchangeRateMsgCodec.encodeExchangeRateMessage(sendParam.exchangeRateSource, exchangeRate, block.timestamp);
+        (msgType, message) = ExchangeRateMsgCodec.encodeExchangeRateMessage(
+            sendParam.exchangeRateSource,
+            exchangeRate,
+            block.timestamp
+        );
 
         options = combineOptions(sendParam.dstEid, msgType, sendParam.extraOptions);
     }
@@ -173,10 +163,12 @@ contract PendleExchangeRateOracleApp is PendleCrossChainOracleBaseApp_Init, IPEx
         }
     }
 
-    function _updateExchangeRate(uint32 _srcEid, bytes32 exchangeRateSource, uint256 exchangeRate, uint256 updatedAt)
-        internal
-        returns (bool rateAccepted)
-    {
+    function _updateExchangeRate(
+        uint32 _srcEid,
+        bytes32 exchangeRateSource,
+        uint256 exchangeRate,
+        uint256 updatedAt
+    ) internal returns (bool rateAccepted) {
         ExchangeRateData storage currentFeedData = feedData[_srcEid][exchangeRateSource];
 
         if (updatedAt > currentFeedData.updatedAt) {

package/contracts/oracles/CrossChainOracle/exchangeRate/PendleExchangeRateOracleV2.sol

@@ -16,8 +16,9 @@ contract PendleExchangeRateOracleV2 is IPExchangeRateOracle {
     }
 
     function getExchangeRate() external view returns (uint256) {
-        IPExchangeRateOracleApp.ExchangeRateData memory exchangeRateData =
-            IPExchangeRateOracleApp(exchangeRateOracleApp).getExchangeRate(srcEid, exchangeRateSource);
+        IPExchangeRateOracleApp.ExchangeRateData memory exchangeRateData = IPExchangeRateOracleApp(
+            exchangeRateOracleApp
+        ).getExchangeRate(srcEid, exchangeRateSource);
 
         return exchangeRateData.exchangeRate;
     }

package/contracts/oracles/CrossChainOracle/libraries/ExchangeRateMsgCodec.sol

@@ -6,23 +6,23 @@ import {Errors} from "../../../core/libraries/Errors.sol";
 library ExchangeRateMsgCodec {
     uint16 public constant SEND_EXCHANGE_RATE = 1;
 
-    function encodeExchangeRateMessage(address exchangeRateSource, uint256 exchangeRate, uint256 updatedAt)
-        internal
-        pure
-        returns (uint16 msgType, bytes memory message)
-    {
+    function encodeExchangeRateMessage(
+        address exchangeRateSource,
+        uint256 exchangeRate,
+        uint256 updatedAt
+    ) internal pure returns (uint16 msgType, bytes memory message) {
         msgType = SEND_EXCHANGE_RATE;
         message = abi.encode(msgType, exchangeRateSource, exchangeRate, updatedAt);
     }
 
-    function decodeMessage(bytes calldata message)
-        internal
-        pure
-        returns (bytes32 exchangeRateSource, uint256 exchangeRate, uint256 updatedAt)
-    {
+    function decodeMessage(
+        bytes calldata message
+    ) internal pure returns (bytes32 exchangeRateSource, uint256 exchangeRate, uint256 updatedAt) {
         uint16 msgType;
-        (msgType, exchangeRateSource, exchangeRate, updatedAt) =
-            abi.decode(message, (uint16, bytes32, uint256, uint256));
+        (msgType, exchangeRateSource, exchangeRate, updatedAt) = abi.decode(
+            message,
+            (uint16, bytes32, uint256, uint256)
+        );
         if (msgType != SEND_EXCHANGE_RATE) revert Errors.InvalidMsgType();
     }
 

package/contracts/oracles/PtYtLpOracle/PendleLpOracleLib.sol

@@ -10,8 +10,8 @@ library PendleLpOracleLib {
     using MarketMathCore for MarketState;
 
     /**
-     * This function returns the approximated twap rate LP/asset on market, but take into account the current rate of SY
-     *  This is to account for special cases where underlying asset becomes insolvent and has decreasing exchangeRate
+      * This function returns the approximated twap rate LP/asset on market, but take into account the current rate of SY
+     This is to account for special cases where underlying asset becomes insolvent and has decreasing exchangeRate
      * @param market market to get rate from
      * @param duration twap duration
      */
@@ -26,8 +26,8 @@ library PendleLpOracleLib {
     }
 
     /**
-     * This function returns the approximated twap rate LP/asset on market, but take into account the current rate of SY
-     *  This is to account for special cases where underlying asset becomes insolvent and has decreasing exchangeRate
+      * This function returns the approximated twap rate LP/asset on market, but take into account the current rate of SY
+     This is to account for special cases where underlying asset becomes insolvent and has decreasing exchangeRate
      * @param market market to get rate from
      * @param duration twap duration
      */
@@ -41,11 +41,11 @@ library PendleLpOracleLib {
         }
     }
 
-    function _getLpToAssetRateRaw(IPMarket market, uint32 duration, uint256 pyIndex)
-        private
-        view
-        returns (uint256 lpToAssetRateRaw)
-    {
+    function _getLpToAssetRateRaw(
+        IPMarket market,
+        uint32 duration,
+        uint256 pyIndex
+    ) private view returns (uint256 lpToAssetRateRaw) {
         _checkMarketReentrancy(market);
         MarketState memory state = market.readState(address(0));
 
@@ -59,21 +59,24 @@ library PendleLpOracleLib {
             (int256 rateOracle, int256 rateHypTrade) = _getPtRatesRaw(market, state, duration);
             int256 cParam = LogExpMath.exp(comp.rateScalar.mulDown((rateOracle - comp.rateAnchor)));
 
-            int256 tradeSize =
-                (cParam.mulDown(comp.totalAsset) - state.totalPt).divDown(PMath.IONE + cParam.divDown(rateHypTrade));
+            int256 tradeSize = (cParam.mulDown(comp.totalAsset) - state.totalPt).divDown(
+                PMath.IONE + cParam.divDown(rateHypTrade)
+            );
 
             totalHypotheticalAsset =
-                comp.totalAsset - tradeSize.divDown(rateHypTrade) + (state.totalPt + tradeSize).divDown(rateOracle);
+                comp.totalAsset -
+                tradeSize.divDown(rateHypTrade) +
+                (state.totalPt + tradeSize).divDown(rateOracle);
         }
 
         lpToAssetRateRaw = totalHypotheticalAsset.divDown(state.totalLp).Uint();
     }
 
-    function _getPtRatesRaw(IPMarket market, MarketState memory state, uint32 duration)
-        private
-        view
-        returns (int256 rateOracle, int256 rateHypTrade)
-    {
+    function _getPtRatesRaw(
+        IPMarket market,
+        MarketState memory state,
+        uint32 duration
+    ) private view returns (int256 rateOracle, int256 rateHypTrade) {
         uint256 lnImpliedRate = market.getMarketLnImpliedRate(duration);
         uint256 timeToExpiry = state.expiry - block.timestamp;
         rateOracle = MarketMathCore._getExchangeRateFromImpliedRate(lnImpliedRate, timeToExpiry);