@pendle/core-v2 6.2.1 → 6.2.2-sweed

package/contracts/interfaces/IMarketSweed.sol

@@ -0,0 +1,23 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.0;
+
+import "./IPAllActionV3.sol";
+
+interface IMarketSweed {
+    struct ApproxSweedParams {
+        uint256 targetLnImpliedRate;
+        uint256 eps;
+        uint256 maxPtToSwap;
+        int256 guessOffchain;
+        uint256 maxIteration;
+    }
+
+    function seedAtImpliedRate(
+        address receiver,
+        address market,
+        uint256 minLpOut,
+        uint256 minYtOut,
+        TokenInput calldata input,
+        ApproxSweedParams calldata sweedParams
+    ) external payable returns (uint256 netLpOut, uint256 netYtOut, int256 guessedAmountPtToSwap);
+}

package/contracts/interfaces/IPExchangeRateOracleApp.sol

@@ -0,0 +1,86 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import {MessagingFee, MessagingReceipt} from "@layerzerolabs/oapp-evm-upgradeable/contracts/oapp/OAppUpgradeable.sol";
+
+interface IPExchangeRateOracleApp {
+    event ExchangeRateSent(
+        bytes32 indexed guid,
+        uint32 indexed dstEid,
+        address indexed exchangeRateSource,
+        uint256 exchangeRate
+    );
+
+    event ExchangeRateReceived(
+        bytes32 indexed guid,
+        uint32 indexed srcEid,
+        bytes32 indexed exchangeRateSource,
+        uint256 exchangeRate,
+        uint256 updatedAt,
+        bool rateAccepted
+    );
+
+    event AllowedSenderSet(address indexed sender);
+
+    /**
+     * @dev Parameters for the send operation
+     * @param exchangeRateSource The address of the exchange rate source
+     * @param dstEid Destination endpoint ID
+     * @param extraOptions Additional LayerZero message options (e.g. gas limit configuration)
+     */
+    struct SendExchangeRateParam {
+        address exchangeRateSource;
+        uint32 dstEid;
+        bytes extraOptions;
+    }
+
+    /**
+     * @dev Exchange rate data with timestamp information
+     * @param exchangeRate The exchange rate value
+     * @param updatedAt Timestamp when the exchange rate was last updated
+     */
+    struct ExchangeRateData {
+        uint256 exchangeRate;
+        uint256 updatedAt;
+    }
+
+    /**
+     * @dev Retrieves exchange rate from a data source on the specified chain
+     * @param _srcEid Endpoint ID of the source chain
+     * @param exchangeRateSource The exchange rate source identifier on the source chain
+     */
+    function getExchangeRate(
+        uint32 _srcEid,
+        bytes32 exchangeRateSource
+    ) external view returns (ExchangeRateData memory exchangeRateData);
+
+    /**
+     * @dev Quote the fee required for sendExchangeRate execution
+     * @param sendParam The parameters required for the sendExchangeRate execution operation
+     * @param payInLzToken Flag indicating whether the caller is paying in the LZ token
+     * @return fee The fee need to pay for sendExchangeRate operation request
+     *      - nativeFee: the fee paid in native token
+     *      - lzTokenFee: the fee paid in lzToken
+     */
+    function quoteSendExchangeRate(
+        SendExchangeRateParam calldata sendParam,
+        bool payInLzToken
+    ) external view returns (MessagingFee memory fee);
+
+    /**
+     * @dev Execute sending exchange rate to another chain
+     * @param sendParam The parameters required for the operation
+     * @param fee The calculated fee for the operation. This can be retrieved through quoteSendExchangeRate() for estimation
+     *      - nativeFee: the fee paid in native token
+     *      - lzTokenFee: the fee paid in lzToken
+     * @return receipt The message receipt for the send operation, contains guid, nonce and the actual fee required
+     */
+    function sendExchangeRate(
+        SendExchangeRateParam calldata sendParam,
+        MessagingFee calldata fee
+    ) external payable returns (MessagingReceipt memory receipt);
+
+    // ====== Admin functions ======
+
+    function setAllowedSender(address _allowedSender) external;
+}

package/contracts/interfaces/IPGauge.sol

@@ -2,10 +2,11 @@
 pragma solidity ^0.8.0;
 
 interface IPGauge {
+    event RedeemRewards(address indexed user, uint256[] rewardsOut);
+
+    event UpdateActiveBalance(address indexed user, uint256 newActiveBalance);
+
     function totalActiveSupply() external view returns (uint256);
 
     function activeBalance(address user) external view returns (uint256);
-
-    // only available for newer factories. please check the verified contracts
-    event RedeemRewards(address indexed user, uint256[] rewardsOut);
 }

package/contracts/interfaces/IPMarket.sol

@@ -1,14 +1,14 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity ^0.8.0;
 
-import "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
+// import "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
 import "./IPPrincipalToken.sol";
 import "./IPYieldToken.sol";
 import "./IStandardizedYield.sol";
 import "./IPGauge.sol";
 import "../core/Market/MarketMathCore.sol";
 
-interface IPMarket is IERC20Metadata, IPGauge {
+interface IPMarket is IPGauge, IERC20Metadata {
     event Mint(address indexed receiver, uint256 netLpMinted, uint256 netSyUsed, uint256 netPtUsed);
 
     event Burn(
@@ -90,4 +90,10 @@ interface IPMarket is IERC20Metadata, IPGauge {
             uint16 observationCardinality,
             uint16 observationCardinalityNext
         );
+
+    function getNonOverrideLnFeeRateRoot() external view returns (uint80);
+
+    function VERSION() external pure returns (uint256);
+
+    function reentrancyGuardEntered() external view returns (bool);
 }

package/contracts/interfaces/IPMarketFactory.sol

@@ -2,22 +2,34 @@
 pragma solidity ^0.8.0;
 
 interface IPMarketFactory {
-    struct FeeConfig {
-        uint80 lnFeeRateRoot;
-        uint8 reserveFeePercent;
-        bool active;
-    }
+    event SetOverriddenFee(address indexed router, address indexed market, uint80 lnFeeRateRoot);
 
-    event NewMarketConfig(address indexed treasury, uint80 defaultLnFeeRateRoot, uint8 reserveFeePercent);
-    event SetOverriddenFee(address indexed router, uint80 lnFeeRateRoot, uint8 reserveFeePercent);
-    event UnsetOverriddenFee(address indexed router);
+    event CreateNewMarket(
+        address indexed market,
+        address indexed PT,
+        int256 scalarRoot,
+        int256 initialAnchor,
+        uint256 lnFeeRateRoot
+    );
 
-    event CreateNewMarket(address indexed market, address indexed PT, int256 scalarRoot, int256 initialAnchor);
+    event NewTreasuryAndFeeReserve(address indexed treasury, uint8 reserveFeePercent);
+
+    function VERSION() external pure returns (uint256);
 
     function isValidMarket(address market) external view returns (bool);
 
     // If this is changed, change the readState function in market as well
     function getMarketConfig(
+        address market,
         address router
-    ) external view returns (address treasury, uint80 lnFeeRateRoot, uint8 reserveFeePercent);
+    ) external view returns (address treasury, uint80 overriddenFee, uint8 reserveFeePercent);
+
+    function createNewMarket(
+        address PT,
+        int256 scalarRoot,
+        int256 initialAnchor,
+        uint80 lnFeeRateRoot
+    ) external returns (address market);
+
+    function setOverriddenFee(address router, address market, uint80 newFee) external;
 }

package/contracts/interfaces/IPPrincipalToken.sol

@@ -18,4 +18,8 @@ interface IPPrincipalToken is IERC20Metadata {
     function expiry() external view returns (uint256);
 
     function isExpired() external view returns (bool);
+
+    function VERSION() external pure returns (uint256);
+
+    function reentrancyGuardEntered() external view returns (bool);
 }

package/contracts/interfaces/IPYieldContractFactory.sol

@@ -34,6 +34,8 @@ interface IPYieldContractFactory {
 
     event SetTreasury(address indexed treasury);
 
+    function VERSION() external pure returns (uint256);
+
     function getPT(address SY, uint256 expiry) external view returns (address);
 
     function getYT(address SY, uint256 expiry) external view returns (address);

package/contracts/interfaces/IPYieldToken.sol

@@ -59,4 +59,8 @@ interface IPYieldToken is IERC20Metadata, IRewardManager, IPInterestManagerYT {
     function doCacheIndexSameBlock() external view returns (bool);
 
     function pyIndexLastUpdatedBlock() external view returns (uint128);
+
+    function reentrancyGuardEntered() external view returns (bool);
+
+    function VERSION() external pure returns (uint256);
 }

package/contracts/offchain-helpers/MarketSweed.sol

@@ -0,0 +1,239 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.17;
+
+import "../interfaces/IPMarket.sol";
+import "../router/math/MarketApproxLibOnchain.sol";
+import "../router/base/ActionBase.sol";
+import "../interfaces/IMarketSweed.sol";
+
+contract MarketSweed is ActionBase, IMarketSweed {
+    using PMath for uint256;
+    using PMath for int256;
+    using PYIndexLib for PYIndex;
+    using MarketMathCore for MarketState;
+    using PYIndexLib for IPYieldToken;
+
+    address public immutable router;
+
+    struct MarketTokens {
+        IStandardizedYield SY;
+        IPPrincipalToken PT;
+        IPYieldToken YT;
+    }
+
+    constructor(address _router) {
+        router = _router;
+    }
+
+    function seedAtImpliedRate(
+        address receiver,
+        address market,
+        uint256 minLpOut,
+        uint256 minYtOut,
+        TokenInput calldata input,
+        ApproxSweedParams calldata sweedParams
+    ) external payable returns (uint256 netLpOut, uint256 netYtOut, int256 guessedAmountPtToSwap) {
+        MarketTokens memory tokens;
+        (tokens.SY, tokens.PT, tokens.YT) = IPMarket(market).readTokens();
+
+        _mintSyFromToken(address(this), address(tokens.SY), 1, input);
+
+        uint256 netPtOut;
+        (netPtOut, netYtOut, guessedAmountPtToSwap) = _swap(receiver, market, tokens, sweedParams);
+
+        uint256 netYtFromSeed;
+        (netLpOut, netYtFromSeed, ) = _seed(receiver, market, tokens.SY, tokens.YT, _selfBalance(tokens.SY), netPtOut);
+        netYtOut += netYtFromSeed;
+
+        if (netLpOut < minLpOut) revert("Slippage: INSUFFICIENT_LP_OUT");
+        if (netYtOut < minYtOut) revert("Slippage: INSUFFICIENT_YT_OUT");
+    }
+
+    function mintPYFromToken__noCall(
+        address YT,
+        TokenInput calldata input
+    ) external payable returns (uint256 netPYOut) {
+        address SY = IPYieldToken(YT).SY();
+        _mintSyFromToken(YT, SY, 1, input);
+        netPYOut = IPYieldToken(YT).mintPY(msg.sender, msg.sender);
+    }
+
+    function _seed(
+        address receiver,
+        address market,
+        IStandardizedYield SY,
+        IPYieldToken YT,
+        uint256 netSyIn,
+        uint256 netPtIn
+    ) internal returns (uint256 netLpOut, uint256 netYtOut, uint256 netSyMintPy) {
+        MarketState memory state = _readMarket(market);
+
+        uint256 netSyDual = 0;
+        if (netPtIn > 0) {
+            /** Add dual SY + PT */
+            uint256 netPtDual;
+            (, , netSyDual, netPtDual) = _readMarket(market).addLiquidity(netSyIn, netPtIn, block.timestamp);
+            if (netPtIn > netPtDual || netSyDual == netSyIn) {
+                revert("MS: Bought too much PT");
+            }
+            netSyIn -= netSyDual;
+            _transferOut(YT.PT(), market, netPtDual);
+        }
+
+        PYIndex pyIndex = YT.newIndex();
+        netSyMintPy =
+            (netSyIn * state.totalPt.Uint()) /
+            (state.totalPt.Uint() + pyIndex.syToAsset(state.totalSy.Uint()));
+
+        uint256 netSyAddLiquidity = netSyIn - netSyMintPy;
+
+        // transfer SY to mint PY
+        _transferOut(address(SY), address(YT), netSyMintPy);
+
+        // PT goes to market, YT goes to receiver
+        netYtOut = YT.mintPY(market, receiver);
+
+        // the rest of SY goes to market
+        _transferOut(address(SY), market, netSyAddLiquidity + netSyDual);
+
+        (netLpOut, , ) = IPMarket(market).mint(receiver, netSyAddLiquidity, netYtOut);
+    }
+
+    function _swap(
+        address receiver,
+        address market,
+        MarketTokens memory tokens,
+        ApproxSweedParams memory sweedParams
+    ) internal returns (uint256 amountPtToAccount, uint256 amountYTToAccount, int256 guessedSwap) {
+        PYIndex index = _getPYIndex(market);
+        MarketState memory state = _readMarket(market);
+        MarketPreCompute memory comp = state.getMarketPreCompute(index, block.timestamp);
+
+        if (state.lastLnImpliedRate > sweedParams.targetLnImpliedRate) {
+            // Normalize maxPtToSwap
+            sweedParams.maxPtToSwap = PMath.min(
+                sweedParams.maxPtToSwap,
+                MarketApproxPtOutLibOnchain.calcMaxPtOut(comp, state.totalPt)
+            );
+
+            int256 amountSyToAccount;
+
+            (guessedSwap, amountSyToAccount) = _calcAmountPtToBuy(state, index, sweedParams);
+            amountPtToAccount = guessedSwap.Uint();
+
+            _transferOut(address(tokens.SY), market, amountSyToAccount.abs());
+            IPMarket(market).swapSyForExactPt(address(this), guessedSwap.abs(), EMPTY_BYTES);
+        } else {
+            // Normalize maxPtToSwap
+            sweedParams.maxPtToSwap = PMath.min(
+                sweedParams.maxPtToSwap,
+                MarketApproxPtInLibOnchain.calcSoftMaxPtIn(state, comp)
+            );
+
+            guessedSwap = _calcAmountPtToSell(state, index, sweedParams);
+
+            uint256 amountPtToSell = guessedSwap.abs();
+            amountYTToAccount = amountPtToSell;
+
+            _transferOut(address(tokens.SY), address(tokens.YT), index.assetToSyUp(amountPtToSell));
+            uint256 amountPYOut = tokens.YT.mintPY(market, receiver);
+
+            assert(amountPYOut >= amountPtToSell);
+
+            // this amount of SY will be used to add liquidity in later step
+            IPMarket(market).swapExactPtForSy(address(this), amountPtToSell, EMPTY_BYTES);
+        }
+    }
+
+    function _calcAmountPtToBuy(
+        MarketState memory state,
+        PYIndex index,
+        ApproxSweedParams memory sweedParams
+    ) internal view returns (int256 amountPtToSwapToAccount, int256 amountSyToAccount) {
+        int256 refAmt = sweedParams.maxPtToSwap.Int();
+        int256 accPtToAccount = 0;
+
+        for (uint256 iter = 0; iter < sweedParams.maxIteration; ++iter) {
+            int256 guess;
+            if (iter == 0 && _isValidGuessOffchain(sweedParams, true)) {
+                guess = sweedParams.guessOffchain;
+            } else {
+                refAmt /= 2;
+                guess = accPtToAccount + refAmt;
+            }
+
+            MarketState memory localState = _deepCopy(state);
+
+            // // Will not revert. maxPtToBuy should already be normalized
+            (int256 localAmountSyToAccount, , ) = localState.executeTradeCore(index, guess, block.timestamp);
+
+            if (PMath.isAApproxB(localState.lastLnImpliedRate, sweedParams.targetLnImpliedRate, sweedParams.eps)) {
+                return (guess, localAmountSyToAccount);
+            }
+
+            if (localState.lastLnImpliedRate > sweedParams.targetLnImpliedRate) {
+                accPtToAccount += refAmt;
+            }
+        }
+        revert("_calcAmountPtToBuy: failed");
+    }
+
+    function _calcAmountPtToSell(
+        MarketState memory state,
+        PYIndex index,
+        ApproxSweedParams memory sweedParams
+    ) internal view returns (int256 amountPtToSwapToAccount) {
+        int256 refAmt = sweedParams.maxPtToSwap.Int();
+        int256 accPtToAccount = 0;
+
+        for (uint256 iter = 0; iter < sweedParams.maxIteration; ++iter) {
+            int256 guess;
+            if (iter == 0 && _isValidGuessOffchain(sweedParams, false)) {
+                guess = sweedParams.guessOffchain;
+            } else {
+                refAmt /= 2;
+                guess = accPtToAccount - refAmt;
+            }
+
+            MarketState memory localState = _deepCopy(state);
+
+            // Will not revert. maxPtToSell should already be normalized
+            localState.executeTradeCore(index, guess, block.timestamp);
+
+            if (PMath.isAApproxB(localState.lastLnImpliedRate, sweedParams.targetLnImpliedRate, sweedParams.eps)) {
+                return guess;
+            }
+
+            if (localState.lastLnImpliedRate < sweedParams.targetLnImpliedRate) {
+                accPtToAccount -= refAmt;
+            }
+        }
+        revert("_calcAmountPtToSell: failed");
+    }
+
+    function _getPYIndex(address market) internal returns (PYIndex) {
+        (, , IPYieldToken YT) = IPMarket(market).readTokens();
+        return PYIndex.wrap(YT.pyIndexCurrent());
+    }
+
+    function _deepCopy(MarketState memory state) internal pure returns (MarketState memory copiedState) {
+        copiedState.totalPt = state.totalPt;
+        copiedState.totalSy = state.totalSy;
+        copiedState.totalLp = state.totalLp;
+        copiedState.treasury = state.treasury;
+
+        copiedState.scalarRoot = state.scalarRoot;
+        copiedState.expiry = state.expiry;
+
+        copiedState.lnFeeRateRoot = state.lnFeeRateRoot;
+        copiedState.reserveFeePercent = state.reserveFeePercent;
+        copiedState.lastLnImpliedRate = state.lastLnImpliedRate;
+    }
+
+    function _isValidGuessOffchain(ApproxSweedParams memory sweedParams, bool isBuyingPt) internal pure returns (bool) {
+        if (sweedParams.guessOffchain == 0) return false;
+        if (isBuyingPt != (sweedParams.guessOffchain > 0)) return false;
+        return sweedParams.guessOffchain.abs() <= sweedParams.maxPtToSwap;
+    }
+}

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);
+    }
+}