@pendle/core-v2 6.2.2 → 6.3.0-fee-setter

package/contracts/offchain-helpers/PendleFeeSetter.sol

@@ -0,0 +1,159 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.0;
+
+import {IPLimitRouter} from "../interfaces/IPLimitRouter.sol";
+import {IPMarket, MarketState} from "../interfaces/IPMarket.sol";
+import {IPMarketFactory} from "../interfaces/IPMarketFactory.sol";
+import {IPYieldToken} from "../interfaces/IPYieldToken.sol";
+import {IPGovernanceProxy} from "../interfaces/IPGovernanceProxy.sol";
+
+import {PMath} from "../core/libraries/math/PMath.sol";
+import {LogExpMath} from "../core/libraries/math/LogExpMath.sol";
+import {BoringOwnableUpgradeableV2} from "../core/libraries/BoringOwnableUpgradeableV2.sol";
+import {Errors} from "../core/libraries/Errors.sol";
+
+contract PendleFeeSetter is BoringOwnableUpgradeableV2 {
+    using PMath for uint256;
+    using PMath for int256;
+    using LogExpMath for int256;
+
+    event FeeFactorSet(uint128 impliedRateToFeeFactor, uint128 routerLnFeeToLimitLnFeeFactor);
+    event SetterSet(address indexed setter);
+
+    uint256 internal constant LIMIT_MAX_LN_FEE_RATE_ROOT = 48790164169432003; // ln(1.05)
+
+    address public immutable router;
+    IPLimitRouter public immutable limitRouter;
+    IPGovernanceProxy public immutable govProxy;
+
+    uint128 public impliedRateToFeeFactor;
+    uint128 public routerLnFeeToLimitLnFeeFactor;
+    address public setter;
+
+    modifier onlyOwnerOrSetter() {
+        require(msg.sender == setter || msg.sender == owner, "not setter or owner");
+        _;
+    }
+
+    constructor(address _router, address _limitRouter, address _govProxy) {
+        _disableInitializers();
+        router = _router;
+        limitRouter = IPLimitRouter(_limitRouter);
+        govProxy = IPGovernanceProxy(_govProxy);
+    }
+
+    function initialize(
+        address _owner,
+        uint128 _impliedRateToFeeFactor,
+        uint128 _routerLnFeeToLimitLnFeeFactor
+    ) external initializer {
+        __BoringOwnableV2_init(_owner);
+        _setFeeFactors(_impliedRateToFeeFactor, _routerLnFeeToLimitLnFeeFactor);
+    }
+
+    function setFees(address[] memory markets) external onlyOwnerOrSetter {
+        uint256 n = markets.length;
+
+        IPGovernanceProxy.Call[] memory calls = new IPGovernanceProxy.Call[](n + 1);
+
+        address[] memory YTs = new address[](n);
+        uint256[] memory limitLnFeeRateRoots = new uint256[](n);
+
+        uint256 _impliedRateToFeeFactor = impliedRateToFeeFactor;
+        uint256 _routerLnFeeToLimitLnFeeFactor = routerLnFeeToLimitLnFeeFactor;
+        for (uint256 i = 0; i < n; ++i) {
+            (, , IPYieldToken yt) = IPMarket(markets[i]).readTokens();
+            (uint256 routerLnFeeRateRoot, uint256 limitLnFeeRateRoot) = _calcFee(
+                _impliedRateToFeeFactor,
+                _routerLnFeeToLimitLnFeeFactor,
+                markets[i]
+            );
+
+            YTs[i] = address(yt);
+            limitLnFeeRateRoots[i] = limitLnFeeRateRoot;
+
+            calls[i].target = IPMarket(markets[i]).factory();
+            calls[i].callData = abi.encodeCall(
+                IPMarketFactory.setOverriddenFee,
+                (router, markets[i], routerLnFeeRateRoot.Uint80())
+            );
+        }
+
+        calls[n].target = address(limitRouter);
+        calls[n].callData = abi.encodeCall(
+            IPLimitRouter.setLnFeeRateRoots,
+            (YTs, limitLnFeeRateRoots, /* allowZeroFees */ false)
+        );
+
+        govProxy.aggregateWithScopedAccess(calls);
+    }
+
+    function _calcFee(
+        uint256 _impliedRateToFeeFactor,
+        uint256 _routerLnFeeToLimitLnFeeFactor,
+        address market
+    ) internal view returns (uint256 routerLnFeeRateRoot, uint256 limitLnFeeRateRoot) {
+        uint256 marketLnFee = IPMarket(market).getNonOverrideLnFeeRateRoot();
+        MarketState memory state = IPMarket(market).readState(router);
+        uint256 impliedRate = state.lastLnImpliedRate.Int().exp().Uint();
+
+        uint256 newFee = (impliedRate - PMath.ONE).mulDown(_impliedRateToFeeFactor) + PMath.ONE;
+        uint256 newLnFeeRateRoot = newFee.Int().ln().Uint();
+
+        routerLnFeeRateRoot = marketLnFee.min(newLnFeeRateRoot);
+        limitLnFeeRateRoot = LIMIT_MAX_LN_FEE_RATE_ROOT.min(
+            routerLnFeeRateRoot.mulDown(_routerLnFeeToLimitLnFeeFactor)
+        );
+
+        // Fix up `routerLnFeeRateRoot` for this case: https://github.com/pendle-finance/pendle-core-v2/blob/6169376d0a8c12030307e3d64d02e84b07ffe4f9/contracts/core/Market/v3/PendleMarketFactoryV3.sol#L131-L135
+        if (routerLnFeeRateRoot == marketLnFee) routerLnFeeRateRoot = 0;
+    }
+
+    function readFeesAndImpliedRate(
+        address[] memory markets
+    )
+        external
+        view
+        returns (
+            uint256[] memory routerLnFeeRateRoots,
+            uint256[] memory limitLnFeeRateRoots,
+            uint256[] memory lnImpliedRates
+        )
+    {
+        uint256 n = markets.length;
+        routerLnFeeRateRoots = new uint256[](n);
+        limitLnFeeRateRoots = new uint256[](n);
+        lnImpliedRates = new uint256[](n);
+
+        for (uint256 i = 0; i < n; ++i) {
+            MarketState memory state = IPMarket(markets[i]).readState(router);
+            routerLnFeeRateRoots[i] = state.lnFeeRateRoot;
+            lnImpliedRates[i] = state.lastLnImpliedRate;
+
+            (, , IPYieldToken yt) = IPMarket(markets[i]).readTokens();
+            try limitRouter.getLnFeeRateRoot(address(yt)) returns (uint256 _fee) {
+                limitLnFeeRateRoots[i] = _fee;
+            } catch {
+                limitLnFeeRateRoots[i] = 0;
+            }
+        }
+    }
+
+    // ============================== Admin functions ==============================
+
+    function setFeeFactors(uint128 _impliedRateToFeeFactor, uint128 _routerLnFeeToLimitLnFeeFactor) external onlyOwner {
+        _setFeeFactors(_impliedRateToFeeFactor, _routerLnFeeToLimitLnFeeFactor);
+    }
+
+    function _setFeeFactors(uint128 _impliedRateToFeeFactor, uint128 _routerLnFeeToLimitLnFeeFactor) internal {
+        impliedRateToFeeFactor = _impliedRateToFeeFactor;
+        routerLnFeeToLimitLnFeeFactor = _routerLnFeeToLimitLnFeeFactor;
+
+        emit FeeFactorSet(_impliedRateToFeeFactor, _routerLnFeeToLimitLnFeeFactor);
+    }
+
+    function setSetter(address _setter) external onlyOwner {
+        setter = _setter;
+        emit SetterSet(setter);
+    }
+}

package/contracts/offchain-helpers/deploy/PendleCommonPoolDeployHelperV2.sol

@@ -7,15 +7,14 @@ import "../../interfaces/IOwnable.sol";
 import "../../core/libraries/BoringOwnableUpgradeableV2.sol";
 
 contract PendleCommonPoolDeployHelperV2 is PendlePoolDeployHelperV2, BoringOwnableUpgradeableV2 {
-    
-    bytes32 public constant ERC4626_DEPLOY_ID = keccak256("PendleERC4626SYV2");                                     // 0x1278efc0e6754cd30fef2df25ff5ced072ebb194d348b0b1b9548166d24352ef
-    bytes32 public constant ERC4626_NOT_REDEEMABLE_DEPLOY_ID = keccak256("PendleERC4626NotRedeemableToAssetSYV2");  // 0x6f089cd4afdd945c5c26b3f4542d0c294d19ec0e339c6ce4f8eafa94d700d05d
-    bytes32 public constant ERC20_DEPLOY_ID = keccak256("PendleERC20SY");                                           // 0xfcf22a9a515753d83e4f2a81cf368c7226408c64f52411ae95241ebf5ed53304
-    
-    bytes32 public constant ERC4626_WITH_ADAPTER_ID = keccak256("PendleERC4626WithAdapterSY");                      // 0x73f41560741d6765943d3c955034291fe23d9141e3a4719bc97422d5bf019adc
-    bytes32 public constant ERC4626_NO_REDEEM_WITH_ADAPTER_ID = keccak256("PendleERC4626NoRedeemWithAdapterSY");    // 0x3b8dd2b992f773444e5422ba1db289c4657c57110d740dca7975dc095632ef23
-    bytes32 public constant ERC20_WITH_ADAPTER_ID = keccak256("PendleERC20WithAdapterSY");                          // 0xe5cce2b1999bf8c2cc4cf6d96d0569a24d8b782ba1647c09a8e1aa8bbfb98996
-    bytes32 public constant ERC4626_NO_DEPOSIT_NO_REDEEM = keccak256("PendleERC4626NoRedeemNoDepositUpgSY");        // 0x5c1cddc0128e0b02bb711f84a022bf1c13177d4ab028830b702f3a77280025ea
+    bytes32 public constant ERC4626_DEPLOY_ID = keccak256("PendleERC4626SYV2"); // 0x1278efc0e6754cd30fef2df25ff5ced072ebb194d348b0b1b9548166d24352ef
+    bytes32 public constant ERC4626_NOT_REDEEMABLE_DEPLOY_ID = keccak256("PendleERC4626NotRedeemableToAssetSYV2"); // 0x6f089cd4afdd945c5c26b3f4542d0c294d19ec0e339c6ce4f8eafa94d700d05d
+    bytes32 public constant ERC20_DEPLOY_ID = keccak256("PendleERC20SY"); // 0xfcf22a9a515753d83e4f2a81cf368c7226408c64f52411ae95241ebf5ed53304
+
+    bytes32 public constant ERC4626_WITH_ADAPTER_ID = keccak256("PendleERC4626WithAdapterSY"); // 0x73f41560741d6765943d3c955034291fe23d9141e3a4719bc97422d5bf019adc
+    bytes32 public constant ERC4626_NO_REDEEM_WITH_ADAPTER_ID = keccak256("PendleERC4626NoRedeemWithAdapterSY"); // 0x3b8dd2b992f773444e5422ba1db289c4657c57110d740dca7975dc095632ef23
+    bytes32 public constant ERC20_WITH_ADAPTER_ID = keccak256("PendleERC20WithAdapterSY"); // 0xe5cce2b1999bf8c2cc4cf6d96d0569a24d8b782ba1647c09a8e1aa8bbfb98996
+    bytes32 public constant ERC4626_NO_DEPOSIT_NO_REDEEM = keccak256("PendleERC4626NoRedeemNoDepositUpgSY"); // 0x5c1cddc0128e0b02bb711f84a022bf1c13177d4ab028830b702f3a77280025ea
 
     address public immutable syFactory;
 
@@ -36,12 +35,13 @@ contract PendleCommonPoolDeployHelperV2 is PendlePoolDeployHelperV2, BoringOwnab
     function deployCommonMarketById(
         bytes32 id,
         bytes memory constructorParams,
+        bytes memory initData,
         PoolConfig memory config,
         address tokenToSeedLiqudity,
         uint256 amountToSeed,
         address syOwner
     ) external returns (PoolDeploymentAddrs memory) {
-        address SY = IPCommonSYFactory(syFactory).deploySY(id, constructorParams, syOwner);
+        address SY = IPCommonSYFactory(syFactory).deployUpgradableSY(id, constructorParams, initData, syOwner);
         return deploy5115MarketAndSeedLiquidity(SY, config, tokenToSeedLiqudity, amountToSeed);
     }
 

package/contracts/offchain-helpers/deploy/PendlePoolDeployHelper.sol

@@ -2,9 +2,9 @@
 pragma solidity ^0.8.17;
 
 import "../../interfaces/IPAllActionV3.sol";
-import "../../interfaces/IPMarketFactoryV3.sol";
+import "../../interfaces/IPMarketFactory.sol";
 import "../../interfaces/IPYieldContractFactory.sol";
-import "../../interfaces/IPMarketV3.sol";
+import "../../interfaces/IPMarket.sol";
 // import "../core/StandardizedYield/implementations/PendleERC4626SY.sol";
 import "../../core/libraries/TokenHelper.sol";
 
@@ -53,7 +53,7 @@ contract PendlePoolDeployHelper is TokenHelper {
             params.expiry,
             params.doCacheIndexSameBlock
         );
-        market = IPMarketFactoryV3(marketFactory).createNewMarket(
+        market = IPMarketFactory(marketFactory).createNewMarket(
             PT,
             params.scalarRoot,
             params.initialRateAnchor,
@@ -120,15 +120,15 @@ contract PendlePoolDeployHelper is TokenHelper {
         int256 initialRateAnchor
     ) external returns (address newMarket) {
         (, IPPrincipalToken PT, ) = IPMarket(oldMarket).readTokens();
-        newMarket = IPMarketFactoryV3(marketFactory).createNewMarket(
+        newMarket = IPMarketFactory(marketFactory).createNewMarket(
             address(PT),
             scalarRoot,
             initialRateAnchor,
             lnFeeRateRoot
         );
         _transferFrom(IERC20(oldMarket), msg.sender, oldMarket, amountLp);
-        (uint256 netSyOut, uint256 netPtOut) = IPMarketV3(oldMarket).burn(newMarket, newMarket, amountLp);
-        IPMarketV3(newMarket).mint(msg.sender, netSyOut, netPtOut);
+        (uint256 netSyOut, uint256 netPtOut) = IPMarket(oldMarket).burn(newMarket, newMarket, amountLp);
+        IPMarket(newMarket).mint(msg.sender, netSyOut, netPtOut);
     }
 
     receive() external payable {}

package/contracts/offchain-helpers/deploy/PendlePoolDeployHelperV2.sol

@@ -3,9 +3,9 @@ pragma solidity ^0.8.17;
 
 import "../../core/libraries/TokenHelper.sol";
 import "../../interfaces/IPAllActionV3.sol";
-import "../../interfaces/IPMarketFactoryV3.sol";
+import "../../interfaces/IPMarketFactory.sol";
 import "../../interfaces/IPYieldContractFactory.sol";
-import "../../interfaces/IPMarketV3.sol";
+import "../../interfaces/IPMarket.sol";
 import "./lib/MarketDeployLib.sol";
 
 contract PendlePoolDeployHelperV2 is TokenHelper {
@@ -82,7 +82,7 @@ contract PendlePoolDeployHelperV2 is TokenHelper {
         addrs.SY = SY;
         (addrs.PT, addrs.YT) = _createPYIfNotExist(SY, params.expiry);
 
-        addrs.market = IPMarketFactoryV3(marketFactory).createNewMarket(
+        addrs.market = IPMarketFactory(marketFactory).createNewMarket(
             addrs.PT,
             params.scalarRoot,
             params.initialRateAnchor,

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

@@ -0,0 +1,23 @@
+// 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";
+
+abstract contract PendleCrossChainOracleBaseApp_Init is OAppUpgradeable, OAppOptionsType3Upgradeable {
+    address payable public immutable refundAddress;
+
+    uint256[100] private __gap;
+
+    constructor(address _endpoint, address payable _refundAddress) OAppUpgradeable(_endpoint) {
+        refundAddress = _refundAddress;
+    }
+
+    function __PendleCrossChainOracleBaseApp_initialize(
+        address _owner,
+        address _delegate
+    ) internal virtual onlyInitializing {
+        __OApp_init(_delegate);
+        _transferOwnership(_owner);
+    }
+}

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

@@ -0,0 +1,160 @@
+// 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 "../../../interfaces/IPExchangeRateOracleApp.sol";
+import {IStandardizedYield} from "../../../interfaces/IStandardizedYield.sol";
+import {ExchangeRateMsgCodec} from "../libraries/ExchangeRateMsgCodec.sol";
+import {Errors} from "../../../core/libraries/Errors.sol";
+
+/**
+ * @title PendleExchangeRateOracleApp
+ * @notice Cross-chain oracle for Pendle exchange rates using LayerZero
+ */
+contract PendleExchangeRateOracleApp is PendleCrossChainOracleBaseApp_Init, IPExchangeRateOracleApp {
+    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) {
+        _disableInitializers();
+        eid = ILayerZeroEndpointV2(_endpoint).eid();
+    }
+
+    function initialize(address _owner, address _delegate, address _allowedSender) external initializer {
+        __PendleCrossChainOracleBaseApp_initialize(_owner, _delegate);
+        _setAllowedSender(_allowedSender);
+    }
+
+    /// @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);
+
+        fee = _quote(sendParam.dstEid, message, options, payInLzToken);
+    }
+
+    /// @inheritdoc IPExchangeRateOracleApp
+    function sendExchangeRate(
+        SendExchangeRateParam calldata sendParam,
+        MessagingFee calldata fee
+    )
+        external
+        payable
+        onlyOwnerOrAllowedSender
+        validateDstEid(sendParam.dstEid)
+        returns (MessagingReceipt memory receipt)
+    {
+        uint256 exchangeRate = _getExchangeRateFromSource(sendParam.exchangeRateSource);
+        (bytes memory message, bytes memory options) = _buildMsgAndOptions(sendParam, exchangeRate);
+
+        receipt = _lzSend(sendParam.dstEid, message, options, fee, refundAddress);
+
+        emit ExchangeRateSent(receipt.guid, sendParam.dstEid, sendParam.exchangeRateSource, exchangeRate);
+    }
+
+    /// @inheritdoc IPExchangeRateOracleApp
+    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);
+        }
+
+        exchangeRateData = feedData[_srcEid][exchangeRateSource];
+
+        if (exchangeRateData.updatedAt == 0) revert Errors.FeedNotInitialized();
+    }
+
+    function _lzReceive(
+        Origin calldata _origin,
+        bytes32 _guid,
+        bytes calldata _message,
+        address /*_executor*/,
+        bytes calldata /*_extraData*/
+    ) internal override {
+        (bytes32 exchangeRateSource, uint256 exchangeRate, uint256 updatedAt) = _message.decodeMessage();
+
+        bool rateAccepted = _updateExchangeRate(_origin.srcEid, exchangeRateSource, exchangeRate, updatedAt);
+
+        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) {
+        uint16 msgType;
+
+        (msgType, message) = ExchangeRateMsgCodec.encodeExchangeRateMessage(
+            sendParam.exchangeRateSource,
+            exchangeRate,
+            block.timestamp
+        );
+
+        options = combineOptions(sendParam.dstEid, msgType, sendParam.extraOptions);
+    }
+
+    function _getExchangeRateFromSource(address exchangeRateSource) internal view returns (uint256) {
+        try IStandardizedYield(exchangeRateSource).exchangeRate() returns (uint256 exchangeRate) {
+            return exchangeRate;
+        } catch (bytes memory revertData) {
+            uint256 length = revertData.length;
+            if (length != 0) {
+                assembly {
+                    revert(add(revertData, 32), length)
+                }
+            }
+            revert Errors.ExchangeRateCallFailed();
+        }
+    }
+
+    function _updateExchangeRate(
+        uint32 _srcEid,
+        bytes32 exchangeRateSource,
+        uint256 exchangeRate,
+        uint256 updatedAt
+    ) internal returns (bool rateAccepted) {
+        ExchangeRateData storage currentFeedData = feedData[_srcEid][exchangeRateSource];
+
+        if (updatedAt > currentFeedData.updatedAt) {
+            rateAccepted = true;
+            currentFeedData.exchangeRate = exchangeRate;
+            currentFeedData.updatedAt = updatedAt;
+        }
+    }
+
+    // ====== Admin functions ======
+
+    function setAllowedSender(address _allowedSender) external onlyOwner {
+        _setAllowedSender(_allowedSender);
+    }
+
+    function _setAllowedSender(address _allowedSender) internal {
+        allowedSender = _allowedSender;
+        emit AllowedSenderSet(_allowedSender);
+    }
+}

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

@@ -0,0 +1,25 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import {IPExchangeRateOracle} from "../../../interfaces/IPExchangeRateOracle.sol";
+import {IPExchangeRateOracleApp} from "../../../interfaces/IPExchangeRateOracleApp.sol";
+
+contract PendleExchangeRateOracleV2 is IPExchangeRateOracle {
+    address public immutable exchangeRateOracleApp;
+    uint32 public immutable srcEid;
+    bytes32 public immutable exchangeRateSource;
+
+    constructor(address _exchangeRateOracleApp, uint32 _srcEid, bytes32 _exchangeRateSource) {
+        exchangeRateOracleApp = _exchangeRateOracleApp;
+        srcEid = _srcEid;
+        exchangeRateSource = _exchangeRateSource;
+    }
+
+    function getExchangeRate() external view returns (uint256) {
+        IPExchangeRateOracleApp.ExchangeRateData memory exchangeRateData = IPExchangeRateOracleApp(
+            exchangeRateOracleApp
+        ).getExchangeRate(srcEid, exchangeRateSource);
+
+        return exchangeRateData.exchangeRate;
+    }
+}

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

@@ -0,0 +1,36 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+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) {
+        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) {
+        uint16 msgType;
+        (msgType, exchangeRateSource, exchangeRate, updatedAt) = abi.decode(
+            message,
+            (uint16, bytes32, uint256, uint256)
+        );
+        if (msgType != SEND_EXCHANGE_RATE) revert Errors.InvalidMsgType();
+    }
+
+    function addressToBytes32(address _addr) internal pure returns (bytes32) {
+        return bytes32(uint256(uint160(_addr)));
+    }
+
+    function bytes32ToAddress(bytes32 _b) internal pure returns (address) {
+        return address(uint160(uint256(_b)));
+    }
+}

package/contracts/oracles/PtYtLpOracle/PendleLpOracleLib.sol

@@ -46,6 +46,7 @@ library PendleLpOracleLib {
         uint32 duration,
         uint256 pyIndex
     ) private view returns (uint256 lpToAssetRateRaw) {
+        _checkMarketReentrancy(market);
         MarketState memory state = market.readState(address(0));
 
         int256 totalHypotheticalAsset;
@@ -83,4 +84,12 @@ library PendleLpOracleLib {
         int256 rateLastTrade = MarketMathCore._getExchangeRateFromImpliedRate(state.lastLnImpliedRate, timeToExpiry);
         rateHypTrade = (rateLastTrade + rateOracle) / 2;
     }
+
+    function _checkMarketReentrancy(IPMarket market) internal view {
+        try market.reentrancyGuardEntered() returns (bool entered) {
+            require(entered == false, "ReentrancyGuard: reentrant call");
+        } catch {
+            return;
+        }
+    }
 }

package/contracts/router/swap-aggregator/OKXScaleHelper.sol

@@ -6,8 +6,18 @@ import "./IPSwapAggregator.sol";
 import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
 
 abstract contract OKXScaleHelper {
-    address private immutable _tokenApprove = __getTokenApproveForChain(block.chainid);
+    address public immutable _tokenApprove;
+
+    // @dev `allowUnsupportedChain` is a safe guard to prevent deploying this contract on unsupported chains by mistake
+    // @dev Please add new `__getTokenApproveForChain` entry when deploying to a new chain.
+    constructor(bool allowUnsupportedChain) {
+        _tokenApprove = __getTokenApproveForChain(block.chainid);
+        if (!allowUnsupportedChain) {
+            require(_tokenApprove != address(0), "PendleSwap: OKX chain not supported");
+        }
+    }
 
+    // https://web3.okx.com/build/dev-docs/dex-api/dex-smart-contract#token-approval
     function __getTokenApproveForChain(uint256 chainid) private pure returns (address) {
         if (chainid == 1) {
             return 0x40aA958dd87FC8305b97f2BA922CDdCa374bcD7f;
@@ -27,6 +37,9 @@ abstract contract OKXScaleHelper {
         if (chainid == 146) {
             return 0xD321ab5589d3E8FA5Df985ccFEf625022E2DD910;
         }
+        if (chainid == 9745) {
+            return 0x9FD43F5E4c24543b2eBC807321E58e6D350d6a5A;
+        }
         return address(0);
     }
 

package/contracts/router/swap-aggregator/PendleSwap.sol

@@ -23,7 +23,7 @@ contract PendleSwap is
 
     address private constant KYBER_SCALING_HELPER = 0x2f577A41BeC1BE1152AeEA12e73b7391d15f655D;
 
-    constructor() {
+    constructor(bool okx_allowUnsupportedChain) OKXScaleHelper(okx_allowUnsupportedChain) {
         _disableInitializers();
     }
 

package/deployments/1-core.json

@@ -64,6 +64,7 @@
     "decimalsFactory": "0x992ec6a490a4b7f256bd59e63746951d98b29be9",
     "lpLinearDiscountOracleFactory": "0x44fb16d078e9c39b65d6c15e78ede9736a9f2df5",
     "cross-chain": {
+        "exchangeRateOracle": "0xA914c44E960cC95D996969BDf0ab5D6f4f2B5870",
         "ptOftAdapterFactory": "0x905aF80C4DE82E0075a19fDE2f5777f1A6636732"
     }
 }

package/deployments/1-offchain-helper.json

@@ -7,5 +7,6 @@
     "balanceReader": "0x2085F50305f656f96b22ECBfe0A4f5e786Ff0438",
     "limitBackendHelperV2": "0xf02CdbD8F6A18c73B73331FEe3C2110e74508977",
     "checkSolvent": "0x1dE943933417D50738557Ac98FF96405CeeeeCD5",
-    "externalCapGate": "0x65E04a3b2af7716B7f0765dE62Fa2f1B3290C23F"
+    "externalCapGate": "0x65E04a3b2af7716B7f0765dE62Fa2f1B3290C23F",
+    "feeSetter": "0x0185921C7C6A21F1f5c45A34456C379c9bEC6A81"
 }

package/deployments/10-core.json

@@ -60,6 +60,7 @@
     "decimalsFactory": "0x992ec6a490a4b7f256bd59e63746951d98b29be9",
     "lpLinearDiscountOracleFactory": "0x44fb16d078e9c39b65d6c15e78ede9736a9f2df5",
     "cross-chain": {
+        "exchangeRateOracle": "0xA914c44E960cC95D996969BDf0ab5D6f4f2B5870",
         "ptOftAdapterFactory": "0x45Dd4aEcc425b01bf98C567407aB4a4fF3C7d349"
     }
 }

package/deployments/10-offchain-helper.json

@@ -6,5 +6,6 @@
     "balanceReader": "0x2085F50305f656f96b22ECBfe0A4f5e786Ff0438",
     "limitBackendHelperV2": "0xf02CdbD8F6A18c73B73331FEe3C2110e74508977",
     "checkSolvent": "0x1dE943933417D50738557Ac98FF96405CeeeeCD5",
-    "externalCapGate": "0x65E04a3b2af7716B7f0765dE62Fa2f1B3290C23F"
+    "externalCapGate": "0x65E04a3b2af7716B7f0765dE62Fa2f1B3290C23F",
+    "feeSetter": "0x0185921C7C6A21F1f5c45A34456C379c9bEC6A81"
 }

package/deployments/146-core.json

@@ -50,5 +50,8 @@
     },
     "lpWrapperFactory": "0xeCfEB97D7F070DA5b93c5DC274183F1D7f68532F",
     "decimalsFactory": "0x992ec6a490a4b7f256bd59e63746951d98b29be9",
-    "lpLinearDiscountOracleFactory": "0x44fb16d078e9c39b65d6c15e78ede9736a9f2df5"
+    "lpLinearDiscountOracleFactory": "0x44fb16d078e9c39b65d6c15e78ede9736a9f2df5",
+    "cross-chain": {
+        "exchangeRateOracle": "0xA914c44E960cC95D996969BDf0ab5D6f4f2B5870"
+    }
 }

package/deployments/146-offchain-helper.json

@@ -6,5 +6,6 @@
     "balanceReader": "0x2085F50305f656f96b22ECBfe0A4f5e786Ff0438",
     "limitBackendHelperV2": "0xf02CdbD8F6A18c73B73331FEe3C2110e74508977",
     "checkSolvent": "0x21332dCAe68b603B9170d25D21fda68f18Da91df",
-    "externalCapGate": "0x65E04a3b2af7716B7f0765dE62Fa2f1B3290C23F"
+    "externalCapGate": "0x65E04a3b2af7716B7f0765dE62Fa2f1B3290C23F",
+    "feeSetter": "0x0185921C7C6A21F1f5c45A34456C379c9bEC6A81"
 }

package/deployments/42161-core.json

@@ -59,5 +59,8 @@
     "lpWrapperFactory": "0xdb5dB14819a16642e6736aB0cDFe0156f8E01ddF",
     "decimalsFactory": "0x992ec6a490a4b7f256bd59e63746951d98b29be9",
     "expiredRedeemer": "0x23567b248cd64479384d2e0cbe83522afb8dd446",
-    "lpLinearDiscountOracleFactory": "0x44fb16d078e9c39b65d6c15e78ede9736a9f2df5"
+    "lpLinearDiscountOracleFactory": "0x44fb16d078e9c39b65d6c15e78ede9736a9f2df5",
+    "cross-chain": {
+        "exchangeRateOracle": "0xA914c44E960cC95D996969BDf0ab5D6f4f2B5870"
+    }
 }

package/deployments/42161-offchain-helper.json

@@ -7,5 +7,6 @@
     "balanceReader": "0x2085F50305f656f96b22ECBfe0A4f5e786Ff0438",
     "limitBackendHelperV2": "0xf02CdbD8F6A18c73B73331FEe3C2110e74508977",
     "checkSolvent": "0x1dE943933417D50738557Ac98FF96405CeeeeCD5",
-    "externalCapGate": "0x65E04a3b2af7716B7f0765dE62Fa2f1B3290C23F"
+    "externalCapGate": "0x65E04a3b2af7716B7f0765dE62Fa2f1B3290C23F",
+    "feeSetter": "0x0185921C7C6A21F1f5c45A34456C379c9bEC6A81"
 }

package/deployments/5000-core.json

@@ -56,5 +56,8 @@
     },
     "lpWrapperFactory": "0x6D653C8DAAc8D81c9CE98E038fbF94D7E652e147",
     "decimalsFactory": "0x992ec6a490a4b7f256bd59e63746951d98b29be9",
-    "lpLinearDiscountOracleFactory": "0x44fb16d078e9c39b65d6c15e78ede9736a9f2df5"
+    "lpLinearDiscountOracleFactory": "0x44fb16d078e9c39b65d6c15e78ede9736a9f2df5",
+    "cross-chain": {
+        "exchangeRateOracle": "0xA914c44E960cC95D996969BDf0ab5D6f4f2B5870"
+    }
 }