@pendle/core-v2 6.3.0-beta → 6.3.0-sweedtest

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,10 +44,8 @@ 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,23 +1,25 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity ^0.8.0;
 
-import "../../../core/libraries/math/PMath.sol";
 import "../../../core/Market/MarketMathCore.sol";
+import "../../../core/libraries/math/PMath.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 {
@@ -40,7 +42,15 @@ 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
@@ -50,7 +60,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)) {
@@ -79,7 +89,15 @@ 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));
@@ -92,7 +110,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);
 
@@ -135,7 +153,16 @@ 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) {
@@ -149,14 +176,8 @@ 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);
@@ -214,7 +235,15 @@ 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);
@@ -225,7 +254,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);
 
@@ -246,12 +275,11 @@ 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);
@@ -323,7 +351,15 @@ 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
@@ -334,7 +370,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)) {
@@ -363,7 +399,15 @@ 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
@@ -374,7 +418,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);
@@ -415,7 +459,16 @@ 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);
@@ -482,7 +535,15 @@ 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);
@@ -493,7 +554,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);
 
@@ -511,12 +572,11 @@ 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,22 +1,31 @@
 // 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 {
-    address payable public immutable refundAddress;
+    uint32 public immutable eid;
 
     uint256[100] private __gap;
 
-    constructor(address _endpoint, address payable _refundAddress) OAppUpgradeable(_endpoint) {
-        refundAddress = _refundAddress;
+    constructor(address _endpoint) OAppUpgradeable(_endpoint) {
+        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,12 +1,11 @@
 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8.0;
 
-import "../base/PendleCrossChainOracleBaseApp_Init.sol";
-import {ILayerZeroEndpointV2} from "@layerzerolabs/lz-evm-protocol-v2/contracts/interfaces/ILayerZeroEndpointV2.sol";
+import {Errors} from "../../../core/libraries/Errors.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
@@ -16,27 +15,17 @@ contract PendleExchangeRateOracleApp is PendleCrossChainOracleBaseApp_Init, IPEx
     using ExchangeRateMsgCodec for bytes;
     using ExchangeRateMsgCodec for bytes32;
 
-    uint32 public immutable eid;
     mapping(uint32 srcEid => mapping(bytes32 source => ExchangeRateData)) private feedData;
 
     address public allowedSender;
 
-    modifier validateDstEid(uint32 dstEid) {
-        if (dstEid == eid) revert Errors.InvalidDestinationEid();
-        _;
-    }
-
     modifier onlyOwnerOrAllowedSender() {
         require(msg.sender == owner() || msg.sender == allowedSender, "Not authorized");
         _;
     }
 
-    constructor(
-        address _endpoint,
-        address payable _refundAddress
-    ) PendleCrossChainOracleBaseApp_Init(_endpoint, _refundAddress) {
+    constructor(address _endpoint) PendleCrossChainOracleBaseApp_Init(_endpoint) {
         _disableInitializers();
-        eid = ILayerZeroEndpointV2(_endpoint).eid();
     }
 
     function initialize(address _owner, address _delegate, address _allowedSender) external initializer {
@@ -45,40 +34,65 @@ contract PendleExchangeRateOracleApp is PendleCrossChainOracleBaseApp_Init, IPEx
     }
 
     /// @inheritdoc IPExchangeRateOracleApp
-    function quoteSendExchangeRate(
-        SendExchangeRateParam calldata sendParam,
-        bool payInLzToken
-    ) external view returns (MessagingFee memory fee) {
-        uint256 exchangeRate = _getExchangeRateFromSource(sendParam.exchangeRateSource);
-        (bytes memory message, bytes memory options) = _buildMsgAndOptions(sendParam, exchangeRate);
+    function quoteSendExchangeRateBatch(SendExchangeRateParam[] calldata sendParams, bool[] calldata payInLzTokens)
+        external
+        view
+        returns (MessagingFee[] memory fees)
+    {
+        if (sendParams.length != payInLzTokens.length) revert Errors.ArrayLengthMismatch();
 
-        fee = _quote(sendParam.dstEid, message, options, payInLzToken);
+        uint256 length = sendParams.length;
+        fees = new MessagingFee[](length);
+
+        for (uint256 i = 0; i < length; ++i) {
+            fees[i] = _quoteSendExchangeRate(sendParams[i], payInLzTokens[i]);
+        }
     }
 
     /// @inheritdoc IPExchangeRateOracleApp
-    function sendExchangeRate(
-        SendExchangeRateParam calldata sendParam,
-        MessagingFee calldata 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
-        validateDstEid(sendParam.dstEid)
-        returns (MessagingReceipt memory receipt)
+        returns (MessagingReceipt[] memory receipts)
     {
-        uint256 exchangeRate = _getExchangeRateFromSource(sendParam.exchangeRateSource);
-        (bytes memory message, bytes memory options) = _buildMsgAndOptions(sendParam, exchangeRate);
+        if (sendParams.length != fees.length) revert Errors.ArrayLengthMismatch();
+        _validateNativeFees(fees);
 
-        receipt = _lzSend(sendParam.dstEid, message, options, fee, refundAddress);
+        uint256 length = sendParams.length;
+        receipts = new MessagingReceipt[](length);
 
-        emit ExchangeRateSent(receipt.guid, sendParam.dstEid, sendParam.exchangeRateSource, exchangeRate);
+        for (uint256 i = 0; i < length; ++i) {
+            receipts[i] = _sendExchangeRate(sendParams[i], fees[i]);
+        }
+    }
+
+    /// @inheritdoc IPExchangeRateOracleApp
+    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);
@@ -89,13 +103,42 @@ 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)
+    {
+        _validateDstEid(sendParam.dstEid);
+        uint256 exchangeRate = _getExchangeRateFromSource(sendParam.exchangeRateSource);
+        (bytes memory message, bytes memory options) = _buildMsgAndOptions(sendParam, exchangeRate);
+
+        fee = _quote(sendParam.dstEid, message, options, payInLzToken);
+    }
+
+    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);
+
+        receipt = _lzSend(sendParam.dstEid, message, options, fee, msg.sender);
+
+        emit ExchangeRateSent(receipt.guid, sendParam.dstEid, sendParam.exchangeRateSource, exchangeRate);
+    }
+
     function _lzReceive(
         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);
@@ -103,17 +146,15 @@ 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);
     }
@@ -132,12 +173,10 @@ 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) {
@@ -147,6 +186,33 @@ contract PendleExchangeRateOracleApp is PendleCrossChainOracleBaseApp_Init, IPEx
         }
     }
 
+    function _validateDstEid(uint32 dstEid) internal view {
+        if (dstEid == eid) revert Errors.InvalidDestinationEid();
+    }
+
+    /**
+     * @dev Override of base _payNative function.
+     * The original implementation enforced msg.value == _nativeFee, which is incompatible with
+     * batching multiple messages. Fee checks are performed by _validateNativeFees / _validateNativeFee,
+     * so this implementation simply returns the provided native fee.
+     */
+    function _payNative(uint256 _nativeFee) internal pure override returns (uint256 nativeFee) {
+        return _nativeFee;
+    }
+
+    function _validateNativeFees(MessagingFee[] calldata fees) internal {
+        uint256 totalFee = 0;
+        for (uint256 i = 0; i < fees.length; ++i) {
+            totalFee += fees[i].nativeFee;
+        }
+
+        if (totalFee != msg.value) revert Errors.NotEnoughNativeFee(msg.value, totalFee);
+    }
+
+    function _validateNativeFee(MessagingFee calldata fee) internal {
+        if (fee.nativeFee != msg.value) revert Errors.NotEnoughNativeFee(msg.value, fee.nativeFee);
+    }
+
     // ====== Admin functions ======
 
     function setAllowedSender(address _allowedSender) external onlyOwner {

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

@@ -16,9 +16,8 @@ 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();
     }