@pendle/core-v2 6.2.2 → 6.3.0-beta

package/contracts/core/Market/{v3/PendleMarketFactoryV3.sol → PendleMarketFactoryV6Upg.sol}

@@ -2,17 +2,19 @@
 pragma solidity ^0.8.17;
 import "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
 
-import "../../../interfaces/IPMarketV3.sol";
-import "../../../interfaces/IPYieldContractFactory.sol";
-import "../../../interfaces/IPMarketFactoryV3.sol";
+import "../../interfaces/IPMarket.sol";
+import "../../interfaces/IPYieldContractFactory.sol";
+import "../../interfaces/IPMarketFactory.sol";
 
-import "../../libraries/BaseSplitCodeFactory.sol";
-import "../../libraries/Errors.sol";
-import "../../libraries/BoringOwnableUpgradeableV2.sol";
+import "../libraries/BaseSplitCodeFactory.sol";
+import "../libraries/Errors.sol";
+import "../libraries/BoringOwnableUpgradeableV2.sol";
 
-contract PendleMarketFactoryV3 is BoringOwnableUpgradeableV2, IPMarketFactoryV3 {
+contract PendleMarketFactoryV6Upg is BoringOwnableUpgradeableV2, IPMarketFactory {
     using EnumerableSet for EnumerableSet.AddressSet;
 
+    uint256 public constant VERSION = 6;
+
     address public immutable marketCreationCodeContractA;
     uint256 public immutable marketCreationCodeSizeA;
     address public immutable marketCreationCodeContractB;
@@ -42,11 +44,9 @@ contract PendleMarketFactoryV3 is BoringOwnableUpgradeableV2, IPMarketFactoryV3
         uint256 _marketCreationCodeSizeA,
         address _marketCreationCodeContractB,
         uint256 _marketCreationCodeSizeB,
-        address _treasury,
-        uint8 _reserveFeePercent,
         address _vePendle,
         address _gaugeController
-    ) initializer {
+    ) {
         yieldContractFactory = _yieldContractFactory;
         maxLnFeeRateRoot = uint256(LogExpMath.ln(int256((105 * PMath.IONE) / 100))); // ln(1.05)
 
@@ -55,11 +55,15 @@ contract PendleMarketFactoryV3 is BoringOwnableUpgradeableV2, IPMarketFactoryV3
         marketCreationCodeContractB = _marketCreationCodeContractB;
         marketCreationCodeSizeB = _marketCreationCodeSizeB;
 
-        __BoringOwnableV2_init(msg.sender);
-        setTreasuryAndFeeReserve(_treasury, _reserveFeePercent);
-
         vePendle = _vePendle;
         gaugeController = _gaugeController;
+
+        _disableInitializers();
+    }
+
+    function initialize(address _owner, address _treasury, uint8 _reserveFeePercent) external initializer {
+        __BoringOwnableV2_init(_owner);
+        setTreasuryAndFeeReserve(_treasury, _reserveFeePercent);
     }
 
     /**
@@ -127,7 +131,7 @@ contract PendleMarketFactoryV3 is BoringOwnableUpgradeableV2, IPMarketFactoryV3
     function setOverriddenFee(address router, address market, uint80 newFee) public onlyOwner {
         if (!allMarkets.contains(market)) revert Errors.MFNotPendleMarket(market);
 
-        uint80 marketFee = IPMarketV3(market).getNonOverrideLnFeeRateRoot();
+        uint80 marketFee = IPMarket(market).getNonOverrideLnFeeRateRoot();
         if (newFee >= marketFee) revert Errors.MarketFactoryOverriddenFeeTooHigh(newFee, marketFee);
 
         // NOTE: newFee = 0 allowed !!

package/contracts/core/Market/{v3/PendleMarketV3.sol → PendleMarketV6.sol}

@@ -1,13 +1,14 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity ^0.8.17;
 
-import "../../../interfaces/IPMarketV3.sol";
-import "../../../interfaces/IPMarketFactoryV3.sol";
-import "../../../interfaces/IPMarketSwapCallback.sol";
+import "../../interfaces/IPMarket.sol";
+import "../../interfaces/IPMarketFactory.sol";
+import "../../interfaces/IPMarketSwapCallback.sol";
 
-import "../../erc20/PendleERC20.sol";
-import "../PendleGauge.sol";
-import "../OracleLib.sol";
+import "../erc20/PendleERC20.sol";
+import "./PendleGauge.sol";
+import "./OracleLib.sol";
+import "../libraries/StringLib.sol";
 
 /**
 Invariance to maintain:
@@ -15,13 +16,16 @@ Invariance to maintain:
 - address(0) & address(this) should never have any rewards & activeBalance accounting done. This is
     guaranteed by address(0) & address(this) check in each updateForTwo function
 */
-contract PendleMarketV3 is PendleERC20, PendleGauge, IPMarketV3 {
+contract PendleMarketV6 is PendleERC20, PendleGauge, IPMarket {
     using PMath for uint256;
     using PMath for int256;
     using MarketMathCore for MarketState;
     using SafeERC20 for IERC20;
     using PYIndexLib for IPYieldToken;
+    using PYIndexLib for PYIndex;
     using OracleLib for OracleLib.Observation[65535];
+    using StringLib for string;
+    using StringLib for StringLib.slice;
 
     struct MarketStorage {
         int128 totalPt;
@@ -34,8 +38,13 @@ contract PendleMarketV3 is PendleERC20, PendleGauge, IPMarketV3 {
         // 1 SLOT = 144 bits
     }
 
-    string private constant NAME = "Pendle Market";
-    string private constant SYMBOL = "PENDLE-LPT";
+    string private constant PT_NAME_PREF = "PT ";
+    string private constant PT_SYMBOL_PREF = "PT-";
+
+    string private constant LP_NAME_PREF = "PLP ";
+    string private constant LP_SYMBOL_PREF = "PLP-";
+
+    uint256 public constant VERSION = 6;
 
     IPPrincipalToken internal immutable PT;
     IStandardizedYield internal immutable SY;
@@ -64,7 +73,10 @@ contract PendleMarketV3 is PendleERC20, PendleGauge, IPMarketV3 {
         uint80 _lnFeeRateRoot,
         address _vePendle,
         address _gaugeController
-    ) PendleERC20(NAME, SYMBOL, 18) PendleGauge(IPPrincipalToken(_PT).SY(), _vePendle, _gaugeController) {
+    )
+        PendleERC20(_getLPName(_PT), _getLPSymbol(_PT), 18)
+        PendleGauge(IPPrincipalToken(_PT).SY(), _vePendle, _gaugeController)
+    {
         PT = IPPrincipalToken(_PT);
         SY = IStandardizedYield(PT.SY());
         YT = IPYieldToken(PT.YT());
@@ -82,6 +94,14 @@ contract PendleMarketV3 is PendleERC20, PendleGauge, IPMarketV3 {
         factory = msg.sender;
     }
 
+    function _getLPName(address _PT) internal view returns (string memory) {
+        return LP_NAME_PREF.toSlice().concat(IPPrincipalToken(_PT).name().stripPrefixSlice(PT_NAME_PREF));
+    }
+
+    function _getLPSymbol(address _PT) internal view returns (string memory) {
+        return LP_SYMBOL_PREF.toSlice().concat(IPPrincipalToken(_PT).symbol().stripPrefixSlice(PT_SYMBOL_PREF));
+    }
+
     /**
      * @notice PendleMarket allows users to provide in PT & SY in exchange for LPs, which
      * will grant LP holders more exchange fee over time
@@ -164,9 +184,10 @@ contract PendleMarketV3 is PendleERC20, PendleGauge, IPMarketV3 {
         bytes calldata data
     ) external nonReentrant notExpired returns (uint256 netSyOut, uint256 netSyFee) {
         MarketState memory market = readState(msg.sender);
+        PYIndex index = YT.newIndex();
 
         uint256 netSyToReserve;
-        (netSyOut, netSyFee, netSyToReserve) = market.swapExactPtForSy(YT.newIndex(), exactPtIn, block.timestamp);
+        (netSyOut, netSyFee, netSyToReserve) = market.swapExactPtForSy(index, exactPtIn, block.timestamp);
 
         if (receiver != address(this)) IERC20(SY).safeTransfer(receiver, netSyOut);
         IERC20(SY).safeTransfer(market.treasury, netSyToReserve);
@@ -180,6 +201,10 @@ contract PendleMarketV3 is PendleERC20, PendleGauge, IPMarketV3 {
         if (_selfBalance(PT) < market.totalPt.Uint())
             revert Errors.MarketInsufficientPtReceived(_selfBalance(PT), market.totalPt.Uint());
 
+        if (index.syToAsset(netSyFee - netSyToReserve) == 0) {
+            revert Errors.MarketZeroNetLPFee();
+        }
+
         emit Swap(msg.sender, receiver, exactPtIn.neg(), netSyOut.Int(), netSyFee, netSyToReserve);
     }
 
@@ -200,8 +225,10 @@ contract PendleMarketV3 is PendleERC20, PendleGauge, IPMarketV3 {
     ) external nonReentrant notExpired returns (uint256 netSyIn, uint256 netSyFee) {
         MarketState memory market = readState(msg.sender);
 
+        PYIndex index = YT.newIndex();
+
         uint256 netSyToReserve;
-        (netSyIn, netSyFee, netSyToReserve) = market.swapSyForExactPt(YT.newIndex(), exactPtOut, block.timestamp);
+        (netSyIn, netSyFee, netSyToReserve) = market.swapSyForExactPt(index, exactPtOut, block.timestamp);
 
         if (receiver != address(this)) IERC20(PT).safeTransfer(receiver, exactPtOut);
         IERC20(SY).safeTransfer(market.treasury, netSyToReserve);
@@ -216,6 +243,10 @@ contract PendleMarketV3 is PendleERC20, PendleGauge, IPMarketV3 {
         if (_selfBalance(SY) < market.totalSy.Uint())
             revert Errors.MarketInsufficientSyReceived(_selfBalance(SY), market.totalSy.Uint());
 
+        if (index.syToAsset(netSyFee - netSyToReserve) == 0) {
+            revert Errors.MarketZeroNetLPFee();
+        }
+
         emit Swap(msg.sender, receiver, exactPtOut.Int(), netSyIn.neg(), netSyFee, netSyToReserve);
     }
 
@@ -279,7 +310,7 @@ contract PendleMarketV3 is PendleERC20, PendleGauge, IPMarketV3 {
 
         uint80 overriddenFee;
 
-        (market.treasury, overriddenFee, market.reserveFeePercent) = IPMarketFactoryV3(factory).getMarketConfig(
+        (market.treasury, overriddenFee, market.reserveFeePercent) = IPMarketFactory(factory).getMarketConfig(
             address(this),
             router
         );
@@ -332,6 +363,10 @@ contract PendleMarketV3 is PendleERC20, PendleGauge, IPMarketV3 {
         return MiniHelpers.isCurrentlyExpired(expiry);
     }
 
+    function reentrancyGuardEntered() external view override(PendleERC20, IPMarket) returns (bool) {
+        return _reentrancyGuardEntered();
+    }
+
     /*///////////////////////////////////////////////////////////////
                     PENDLE GAUGE - RELATED
     //////////////////////////////////////////////////////////////*/

package/contracts/core/YieldContracts/PendlePrincipalToken.sol

@@ -12,6 +12,8 @@ import "../erc20/PendleERC20.sol";
 import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
 
 contract PendlePrincipalToken is PendleERC20, Initializable, IPPrincipalToken {
+    uint256 public constant VERSION = 6;
+
     address public immutable SY;
     address public immutable factory;
     uint256 public immutable expiry;
@@ -60,4 +62,8 @@ contract PendlePrincipalToken is PendleERC20, Initializable, IPPrincipalToken {
     function isExpired() public view returns (bool) {
         return MiniHelpers.isCurrentlyExpired(expiry);
     }
+
+    function reentrancyGuardEntered() external view override(PendleERC20, IPPrincipalToken) returns (bool) {
+        return _reentrancyGuardEntered();
+    }
 }

package/contracts/core/YieldContracts/{PendleYieldContractFactory.sol → PendleYieldContractFactoryUpg.sol}

@@ -38,12 +38,13 @@ import "../libraries/StringLib.sol";
 import "./PendlePrincipalToken.sol";
 import "./PendleYieldToken.sol";
 
-/// @dev If this contract is ever made upgradeable, please pay attention to the numContractDeployed variable
-contract PendleYieldContractFactory is BoringOwnableUpgradeableV2, IPYieldContractFactory {
+contract PendleYieldContractFactoryUpg is BoringOwnableUpgradeableV2, IPYieldContractFactory {
     using ExpiryUtils for string;
     using StringLib for string;
     using StringLib for StringLib.slice;
 
+    uint256 public constant VERSION = 6;
+
     string private constant PT_PREFIX = "PT";
     string private constant YT_PREFIX = "YT";
     string private constant SY_SYMBOL_PREF = "SY-";
@@ -82,15 +83,18 @@ contract PendleYieldContractFactory is BoringOwnableUpgradeableV2, IPYieldContra
         ytCreationCodeSizeA = _ytCreationCodeSizeA;
         ytCreationCodeContractB = _ytCreationCodeContractB;
         ytCreationCodeSizeB = _ytCreationCodeSizeB;
+
+        _disableInitializers();
     }
 
     function initialize(
         uint96 _expiryDivisor,
         uint128 _interestFeeRate,
         uint128 _rewardFeeRate,
-        address _treasury
+        address _treasury,
+        address _owner
     ) external initializer {
-        __BoringOwnableV2_init(msg.sender);
+        __BoringOwnableV2_init(_owner);
         setExpiryDivisor(_expiryDivisor);
         setInterestFeeRate(_interestFeeRate);
         setRewardFeeRate(_rewardFeeRate);
@@ -114,8 +118,8 @@ contract PendleYieldContractFactory is BoringOwnableUpgradeableV2, IPYieldContra
 
         (, , uint8 assetDecimals) = _SY.assetInfo();
 
-        string memory syCoreName = _stripSYPrefix(_SY.name());
-        string memory syCoreSymbol = _stripSYPrefix(_SY.symbol());
+        string memory syCoreName = _SY.name().stripPrefix(SY_NAME_PREF);
+        string memory syCoreSymbol = _SY.symbol().stripPrefix(SY_SYMBOL_PREF);
 
         PT = Create2.deploy(
             0,
@@ -189,11 +193,4 @@ contract PendleYieldContractFactory is BoringOwnableUpgradeableV2, IPYieldContra
         treasury = newTreasury;
         emit SetTreasury(newTreasury);
     }
-
-    function _stripSYPrefix(string memory _str) internal pure returns (string memory) {
-        StringLib.slice memory str = _str.toSlice();
-        StringLib.slice memory delim_name = SY_NAME_PREF.toSlice();
-        StringLib.slice memory delim_symbol = SY_SYMBOL_PREF.toSlice();
-        return str.beyond(delim_name).beyond(delim_symbol).toString();
-    }
 }

package/contracts/core/YieldContracts/PendleYieldToken.sol

@@ -35,6 +35,8 @@ contract PendleYieldToken is IPYieldToken, PendleERC20, RewardManagerAbstract, I
         mapping(address => uint256) userRewardOwed;
     }
 
+    uint256 public constant VERSION = 6;
+
     address public immutable SY;
     address public immutable PT;
     address public immutable factory;
@@ -240,6 +242,10 @@ contract PendleYieldToken is IPYieldToken, PendleERC20, RewardManagerAbstract, I
         return _pyIndexStored;
     }
 
+    function reentrancyGuardEntered() external view override(PendleERC20, IPYieldToken) returns (bool) {
+        return _reentrancyGuardEntered();
+    }
+
     /**
      * @notice do a final rewards redeeming, and sets post-expiry data
      * @dev has no effect if called pre-expiry

package/contracts/core/erc20/PendleERC20.sol

@@ -53,6 +53,18 @@ contract PendleERC20 is Context, IERC20, IERC20Metadata {
         _status = _NOT_ENTERED;
     }
 
+    function reentrancyGuardEntered() external view virtual returns (bool) {
+        return _reentrancyGuardEntered();
+    }
+
+    /**
+     * @dev Returns true if the reentrancy guard is currently set to "entered", which indicates there is a
+     * `nonReentrant` function in the call stack.
+     */
+    function _reentrancyGuardEntered() internal view returns (bool) {
+        return _status == _ENTERED;
+    }
+
     /**
      * @dev Sets the values for {name}, {symbol} and {decimals}.
      *

package/contracts/core/libraries/Errors.sol

@@ -30,6 +30,7 @@ library Errors {
     error MarketZeroAmountsInput();
     error MarketZeroAmountsOutput();
     error MarketZeroLnImpliedRate();
+    error MarketZeroNetLPFee();
     error MarketInsufficientPtForTrade(int256 currentAmount, int256 requiredAmount);
     error MarketInsufficientPtReceived(uint256 actualBalance, uint256 requiredBalance);
     error MarketInsufficientSyReceived(uint256 actualBalance, uint256 requiredBalance);
@@ -180,4 +181,10 @@ library Errors {
     // Swap Aggregator
     error SAInsufficientTokenIn(address tokenIn, uint256 amountExpected, uint256 amountActual);
     error UnsupportedSelector(uint256 aggregatorType, bytes4 selector);
+
+    // Cross Chain Oracle App
+    error FeedNotInitialized();
+    error ExchangeRateCallFailed();
+    error InvalidDestinationEid();
+    error InvalidMsgType();
 }

package/contracts/core/libraries/StringLib.sol

@@ -757,4 +757,16 @@ library StringLib {
 
         return ret;
     }
+
+    function stripPrefix(string memory _str, string memory _prefix) internal pure returns (string memory) {
+        slice memory s = toSlice(_str);
+        slice memory d = toSlice(_prefix);
+        return toString(beyond(s, d));
+    }
+
+    function stripPrefixSlice(string memory _str, string memory _delim) internal pure returns (slice memory) {
+        slice memory s = toSlice(_str);
+        slice memory d = toSlice(_delim);
+        return beyond(s, d);
+    }
 }

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/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 {}