@pendle/core-v2 5.5.0 → 5.7.0-sonic

package/build/artifacts/contracts/router/math/MarketApproxLibOnchain.sol/MarketApproxPtInLibOnchain.json

@@ -3,8 +3,8 @@
   "contractName": "MarketApproxPtInLibOnchain",
   "sourceName": "contracts/router/math/MarketApproxLibOnchain.sol",
   "abi": [],
-  "bytecode": "0x60566037600b82828239805160001a607314602a57634e487b7160e01b600052600060045260246000fd5b30600052607381538281f3fe73000000000000000000000000000000000000000030146080604052600080fdfea2646970667358221220dfbe88c029b0e1f842c10ca2d535574c2833191a0a2470fb9b79765315d523a664736f6c63430008170033",
-  "deployedBytecode": "0x73000000000000000000000000000000000000000030146080604052600080fdfea2646970667358221220dfbe88c029b0e1f842c10ca2d535574c2833191a0a2470fb9b79765315d523a664736f6c63430008170033",
+  "bytecode": "0x60566037600b82828239805160001a607314602a57634e487b7160e01b600052600060045260246000fd5b30600052607381538281f3fe73000000000000000000000000000000000000000030146080604052600080fdfea2646970667358221220db58a967387c96ef256ca85026693abcc2eda68d78b98c1e8b09b7b9e5ccc7d464736f6c63430008170033",
+  "deployedBytecode": "0x73000000000000000000000000000000000000000030146080604052600080fdfea2646970667358221220db58a967387c96ef256ca85026693abcc2eda68d78b98c1e8b09b7b9e5ccc7d464736f6c63430008170033",
   "linkReferences": {},
   "deployedLinkReferences": {}
 }

package/build/artifacts/contracts/router/math/MarketApproxLibOnchain.sol/MarketApproxPtOutLibOnchain.dbg.json

@@ -1,4 +1,4 @@
 {
   "_format": "hh-sol-dbg-1",
-  "buildInfo": "../../../../build-info/7fa579b181813c7af64ef3c7fee573ab.json"
+  "buildInfo": "../../../../build-info/6617d382e5ae37096b284b86207f33fd.json"
 }

package/build/artifacts/contracts/router/math/MarketApproxLibOnchain.sol/MarketApproxPtOutLibOnchain.json

@@ -3,8 +3,8 @@
   "contractName": "MarketApproxPtOutLibOnchain",
   "sourceName": "contracts/router/math/MarketApproxLibOnchain.sol",
   "abi": [],
-  "bytecode": "0x60566037600b82828239805160001a607314602a57634e487b7160e01b600052600060045260246000fd5b30600052607381538281f3fe73000000000000000000000000000000000000000030146080604052600080fdfea26469706673582212207eecdd58f9c9504f0ee4fa0cdd4e8962c8952088847de274ffa8e2245e1d158264736f6c63430008170033",
-  "deployedBytecode": "0x73000000000000000000000000000000000000000030146080604052600080fdfea26469706673582212207eecdd58f9c9504f0ee4fa0cdd4e8962c8952088847de274ffa8e2245e1d158264736f6c63430008170033",
+  "bytecode": "0x60566037600b82828239805160001a607314602a57634e487b7160e01b600052600060045260246000fd5b30600052607381538281f3fe73000000000000000000000000000000000000000030146080604052600080fdfea2646970667358221220b01d830ebc55a8101440a48133846bc45b73a5760f470f9d9e71a9bcbb9da5ca64736f6c63430008170033",
+  "deployedBytecode": "0x73000000000000000000000000000000000000000030146080604052600080fdfea2646970667358221220b01d830ebc55a8101440a48133846bc45b73a5760f470f9d9e71a9bcbb9da5ca64736f6c63430008170033",
   "linkReferences": {},
   "deployedLinkReferences": {}
 }

package/build/artifacts/contracts/router/math/MarketApproxLibV2.sol/MarketApproxPtInLibV2.dbg.json

@@ -1,4 +1,4 @@
 {
   "_format": "hh-sol-dbg-1",
-  "buildInfo": "../../../../build-info/7fa579b181813c7af64ef3c7fee573ab.json"
+  "buildInfo": "../../../../build-info/6617d382e5ae37096b284b86207f33fd.json"
 }

package/build/artifacts/contracts/router/math/MarketApproxLibV2.sol/MarketApproxPtInLibV2.json

@@ -3,8 +3,8 @@
   "contractName": "MarketApproxPtInLibV2",
   "sourceName": "contracts/router/math/MarketApproxLibV2.sol",
   "abi": [],
-  "bytecode": "0x60566037600b82828239805160001a607314602a57634e487b7160e01b600052600060045260246000fd5b30600052607381538281f3fe73000000000000000000000000000000000000000030146080604052600080fdfea26469706673582212206266cb8a9d26cfdec0daacc289ff5027055e0459d4fd3e5e0c05455ab230621f64736f6c63430008170033",
-  "deployedBytecode": "0x73000000000000000000000000000000000000000030146080604052600080fdfea26469706673582212206266cb8a9d26cfdec0daacc289ff5027055e0459d4fd3e5e0c05455ab230621f64736f6c63430008170033",
+  "bytecode": "0x60566037600b82828239805160001a607314602a57634e487b7160e01b600052600060045260246000fd5b30600052607381538281f3fe73000000000000000000000000000000000000000030146080604052600080fdfea26469706673582212200745ab83bec35c6cb543bd00729e05a3d8d559995343acab0afc082338b1eef464736f6c63430008170033",
+  "deployedBytecode": "0x73000000000000000000000000000000000000000030146080604052600080fdfea26469706673582212200745ab83bec35c6cb543bd00729e05a3d8d559995343acab0afc082338b1eef464736f6c63430008170033",
   "linkReferences": {},
   "deployedLinkReferences": {}
 }

package/build/artifacts/contracts/router/math/MarketApproxLibV2.sol/MarketApproxPtOutLibV2.dbg.json

@@ -1,4 +1,4 @@
 {
   "_format": "hh-sol-dbg-1",
-  "buildInfo": "../../../../build-info/7fa579b181813c7af64ef3c7fee573ab.json"
+  "buildInfo": "../../../../build-info/6617d382e5ae37096b284b86207f33fd.json"
 }

package/build/artifacts/contracts/router/math/MarketApproxLibV2.sol/MarketApproxPtOutLibV2.json

@@ -3,8 +3,8 @@
   "contractName": "MarketApproxPtOutLibV2",
   "sourceName": "contracts/router/math/MarketApproxLibV2.sol",
   "abi": [],
-  "bytecode": "0x60566037600b82828239805160001a607314602a57634e487b7160e01b600052600060045260246000fd5b30600052607381538281f3fe73000000000000000000000000000000000000000030146080604052600080fdfea2646970667358221220bd2aa2abb3abdf314b919e4c0916b8e25e2a0cb1591068840a9937ce807dbb2c64736f6c63430008170033",
-  "deployedBytecode": "0x73000000000000000000000000000000000000000030146080604052600080fdfea2646970667358221220bd2aa2abb3abdf314b919e4c0916b8e25e2a0cb1591068840a9937ce807dbb2c64736f6c63430008170033",
+  "bytecode": "0x60566037600b82828239805160001a607314602a57634e487b7160e01b600052600060045260246000fd5b30600052607381538281f3fe73000000000000000000000000000000000000000030146080604052600080fdfea2646970667358221220cab98746dcd717d1857c86a735c91e23176716c3fac175ac2c8a5e4806d36b0e64736f6c63430008170033",
+  "deployedBytecode": "0x73000000000000000000000000000000000000000030146080604052600080fdfea2646970667358221220cab98746dcd717d1857c86a735c91e23176716c3fac175ac2c8a5e4806d36b0e64736f6c63430008170033",
   "linkReferences": {},
   "deployedLinkReferences": {}
 }

package/contracts/core/libraries/math/PMath.sol

@@ -206,6 +206,11 @@ library PMath {
         return uint192(x);
     }
 
+    function Uint80(uint256 x) internal pure returns (uint80) {
+        require(x <= type(uint80).max);
+        return uint80(x);
+    }
+
     function isAApproxB(uint256 a, uint256 b, uint256 eps) internal pure returns (bool) {
         return mulDown(b, ONE - eps) <= a && a <= mulDown(b, ONE + eps);
     }

package/contracts/interfaces/IOwnable.sol

@@ -0,0 +1,6 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.0;
+
+interface IOwnable {
+    function transferOwnership(address newOwner, bool direct, bool renounce) external;
+}

package/contracts/interfaces/IPCommonSYFactory.sol

@@ -0,0 +1,6 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+interface IPCommonSYFactory {
+    function deploySY(bytes32 id, bytes memory constructorParams, address syOwner) external returns (address SY);
+}

package/contracts/interfaces/IPGovernanceProxy.sol

@@ -11,4 +11,14 @@ interface IPGovernanceProxy {
     function pause(address[] calldata addrs) external;
 
     function aggregate(Call[] calldata calls) external payable returns (bytes[] memory rtnData);
+
+    event SetAllowedSelectors(bytes4[] selectors, bytes32 indexed role);
+
+    function ALICE() external view returns (bytes32);
+
+    function BOB() external view returns (bytes32);
+
+    function CHARLIE() external view returns (bytes32);
+
+    function allowedSelectors(bytes4 selector) external view returns (bytes32);
 }

package/contracts/interfaces/IPLimitRouter.sol

@@ -89,6 +89,9 @@ interface IPLimitRouter is IPLimitOrderType {
         address taker
     );
 
+    // event added on 2/1/2025
+    event LnFeeRateRootsSet(address[] YTs, uint256[] lnFeeRateRoots);
+
     // @dev actualMaking, actualTaking are in the SY form
     function fill(
         FillOrderParams[] memory params,
@@ -118,6 +121,8 @@ interface IPLimitRouter is IPLimitOrderType {
 
     function simulate(address target, bytes calldata data) external payable;
 
+    function WNATIVE() external view returns (address);
+
     function _checkSig(
         Order memory order,
         bytes memory signature

package/contracts/interfaces/IPMarketFactoryV3.sol

@@ -28,4 +28,6 @@ interface IPMarketFactoryV3 {
         int256 initialAnchor,
         uint80 lnFeeRateRoot
     ) external returns (address market);
+
+    function setOverriddenFee(address router, address market, uint80 newFee) external;
 }

package/contracts/interfaces/IPPoolDeployHelperV2.sol

@@ -0,0 +1,36 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+interface IPPoolDeployHelperV2 {
+    struct PoolDeploymentParams {
+        uint32 expiry;
+        uint80 lnFeeRateRoot;
+        int256 scalarRoot;
+        int256 initialRateAnchor;
+        bool doCacheIndexSameBlock;
+    }
+
+    struct PoolDeploymentAddrs {
+        address SY;
+        address PT;
+        address YT;
+        address market;
+    }
+
+    struct PoolConfig {
+        uint32 expiry;
+        uint256 rateMin;
+        uint256 rateMax;
+        uint256 desiredImpliedRate;
+        uint256 fee;
+    }
+
+    event MarketDeployment(PoolDeploymentAddrs addrs, PoolDeploymentParams params);
+
+    function deploy5115MarketAndSeedLiquidity(
+        address SY,
+        PoolConfig memory config,
+        address tokenToSeedLiqudity,
+        uint256 amountToSeed
+    ) external payable returns (PoolDeploymentAddrs memory);
+}

package/contracts/interfaces/IPendleCommonPoolDeployHelperV2.sol

@@ -0,0 +1,30 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.0;
+
+import "./IPPoolDeployHelperV2.sol";
+
+interface IPendleCommonPoolDeployHelperV2 is IPPoolDeployHelperV2 {
+    function deployERC4626Market(
+        bytes memory constructorParams,
+        PoolConfig memory config,
+        address tokenToSeedLiqudity,
+        uint256 amountToSeed,
+        address syOwner
+    ) external returns (PoolDeploymentAddrs memory);
+
+    function deployERC4626NotRedeemableMarket(
+        bytes memory constructorParams,
+        PoolConfig memory config,
+        address tokenToSeedLiqudity,
+        uint256 amountToSeed,
+        address syOwner
+    ) external returns (PoolDeploymentAddrs memory);
+
+    function deployERC20Market(
+        bytes memory constructorParams,
+        PoolConfig memory config,
+        address tokenToSeedLiqudity,
+        uint256 amountToSeed,
+        address syOwner
+    ) external returns (PoolDeploymentAddrs memory);
+}

package/contracts/limit/LimitRouterBase.sol

@@ -30,6 +30,8 @@ abstract contract LimitRouterBase is
     uint128 internal constant _ORDER_DOES_NOT_EXIST = 0;
     uint128 internal constant _ORDER_FILLED = 1;
     uint256 internal constant NEW_PRIME = 12421;
+    uint256 internal constant MAX_LN_FEE_RATE_ROOT = 48790164169432003; // ln(1.05)
+
     bytes private constant EMPTY_BYTES = abi.encode();
 
     address public feeRecipient;
@@ -37,7 +39,7 @@ abstract contract LimitRouterBase is
     // YT => lnFeeRateRoot // not to be accessed directly
     mapping(address => uint256) internal __lnFeeRateRoot;
 
-    address private immutable WNATIVE;
+    address public immutable WNATIVE;
 
     mapping(bytes32 => OrderStatus) internal _status;
 
@@ -486,19 +488,13 @@ abstract contract LimitRouterBase is
         uint256 len = YTs.length;
         require(len == lnFeeRateRoots.length, "LOP: length mismatch");
 
-        if (msg.sender == ownerHelper) {
-            _requireFeeNotSet(YTs);
-        }
-
         for (uint256 i = 0; i < len; i++) {
             require(lnFeeRateRoots[i] > 0, "LOP: zero fee not allowed");
+            require(lnFeeRateRoots[i] <= MAX_LN_FEE_RATE_ROOT, "LOP: fee too high");
+
             __lnFeeRateRoot[YTs[i]] = lnFeeRateRoots[i];
         }
-    }
 
-    function _requireFeeNotSet(address[] memory YTs) internal view {
-        for (uint256 i = 0; i < YTs.length; i++) {
-            require(__lnFeeRateRoot[YTs[i]] == 0, "LOP: fee already set");
-        }
+        emit LnFeeRateRootsSet(YTs, lnFeeRateRoots);
     }
 }

package/contracts/offchain-helpers/PendleGovernanceProxy.sol

@@ -13,13 +13,30 @@ import "@openzeppelin/contracts/proxy/utils/UUPSUpgradeable.sol";
 contract PendleGovernanceProxy is AccessControlUpgradeable, UUPSUpgradeable, IPGovernanceProxy {
     bytes32 public constant GUARDIAN = keccak256("GUARDIAN");
 
+    bytes32 public constant ALICE = keccak256("ALICE");
+    bytes32 public constant BOB = keccak256("BOB");
+    bytes32 public constant CHARLIE = keccak256("CHARLIE");
+
+    mapping(bytes4 => bytes32) public allowedSelectors;
+
     modifier onlyGuardian() {
-        require(hasRole(DEFAULT_ADMIN_ROLE, msg.sender) || hasRole(GUARDIAN, msg.sender), "not authorized");
+        require(hasRole(GUARDIAN, msg.sender) || hasRole(DEFAULT_ADMIN_ROLE, msg.sender), "n/a");
         _;
     }
 
     modifier onlyAdmin() {
-        require(hasRole(DEFAULT_ADMIN_ROLE, msg.sender), "not authorized");
+        require(hasRole(DEFAULT_ADMIN_ROLE, msg.sender), "n/a");
+        _;
+    }
+
+    modifier onlyHaveSomeRole() {
+        require(
+            hasRole(ALICE, msg.sender) ||
+                hasRole(BOB, msg.sender) ||
+                hasRole(CHARLIE, msg.sender) ||
+                hasRole(DEFAULT_ADMIN_ROLE, msg.sender),
+            "n/a"
+        );
         _;
     }
 
@@ -27,6 +44,19 @@ contract PendleGovernanceProxy is AccessControlUpgradeable, UUPSUpgradeable, IPG
         _disableInitializers();
     }
 
+    function aggregate(Call[] calldata calls) external payable onlyHaveSomeRole returns (bytes[] memory) {
+        bool isAdmin = hasRole(DEFAULT_ADMIN_ROLE, msg.sender);
+
+        if (!isAdmin) {
+            for (uint256 i = 0; i < calls.length; i++) {
+                bytes4 selector = bytes4(calls[i].callData[:4]);
+                require(hasRole(allowedSelectors[selector], msg.sender), "n/a");
+            }
+        }
+
+        return _aggregate(calls);
+    }
+
     /*///////////////////////////////////////////////////////////////
                                 PAUSING
     //////////////////////////////////////////////////////////////*/
@@ -45,14 +75,19 @@ contract PendleGovernanceProxy is AccessControlUpgradeable, UUPSUpgradeable, IPG
                             ADMIN CALL
     //////////////////////////////////////////////////////////////*/
 
-    function aggregate(
-        IPGovernanceProxy.Call[] calldata calls
-    ) external payable onlyAdmin returns (bytes[] memory rtnData) {
+    function setAllowedSelectors(bytes4[] calldata selectors, bytes32 role) external onlyAdmin {
+        for (uint256 i = 0; i < selectors.length; i++) {
+            allowedSelectors[selectors[i]] = role;
+        }
+        emit SetAllowedSelectors(selectors, role);
+    }
+
+    function _aggregate(Call[] calldata calls) internal returns (bytes[] memory rtnData) {
         uint256 length = calls.length;
         rtnData = new bytes[](length);
 
         Call calldata call;
-        for (uint256 i = 0; i < length; ) {
+        for (uint256 i = 0; i < length; i++) {
             call = calls[i];
 
             (bool success, bytes memory resp) = call.target.call{value: call.value}(call.callData);
@@ -63,10 +98,6 @@ contract PendleGovernanceProxy is AccessControlUpgradeable, UUPSUpgradeable, IPG
             }
 
             rtnData[i] = resp;
-
-            unchecked {
-                ++i;
-            }
         }
     }
 

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

@@ -0,0 +1,68 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.17;
+
+import "./PendlePoolDeployHelperV2.sol";
+import "../../interfaces/IPCommonSYFactory.sol";
+import "../../interfaces/IOwnable.sol";
+import "../../core/libraries/BoringOwnableUpgradeable.sol";
+
+contract PendleCommonPoolDeployHelperV2 is PendlePoolDeployHelperV2, BoringOwnableUpgradeable {
+    bytes32 public constant ERC4626_DEPLOY_ID = keccak256("PendleERC4626SYV2");
+    bytes32 public constant ERC4626_NOT_REDEEMABLE_DEPLOY_ID = keccak256("PendleERC4626NotRedeemableToAssetSYV2");
+    bytes32 public constant ERC20_DEPLOY_ID = keccak256("PendleERC20SY");
+
+    address public immutable syFactory;
+
+    constructor(
+        address _syFactory,
+        address _router,
+        address _yieldContractFactory,
+        address _marketFactory
+    ) PendlePoolDeployHelperV2(_router, _yieldContractFactory, _marketFactory) {
+        syFactory = _syFactory;
+        _disableInitializers();
+    }
+
+    function initialize() external initializer {
+        __BoringOwnable_init();
+    }
+
+    // Those 3 are all not payable as they should not accept tokenIn as native
+
+    function deployERC4626Market(
+        bytes memory constructorParams,
+        PoolConfig memory config,
+        address tokenToSeedLiqudity,
+        uint256 amountToSeed,
+        address syOwner
+    ) external returns (PoolDeploymentAddrs memory) {
+        address SY = IPCommonSYFactory(syFactory).deploySY(ERC4626_DEPLOY_ID, constructorParams, syOwner);
+        return deploy5115MarketAndSeedLiquidity(SY, config, tokenToSeedLiqudity, amountToSeed);
+    }
+
+    function deployERC4626NotRedeemableMarket(
+        bytes memory constructorParams,
+        PoolConfig memory config,
+        address tokenToSeedLiqudity,
+        uint256 amountToSeed,
+        address syOwner
+    ) external returns (PoolDeploymentAddrs memory) {
+        address SY = IPCommonSYFactory(syFactory).deploySY(
+            ERC4626_NOT_REDEEMABLE_DEPLOY_ID,
+            constructorParams,
+            syOwner
+        );
+        return deploy5115MarketAndSeedLiquidity(SY, config, tokenToSeedLiqudity, amountToSeed);
+    }
+
+    function deployERC20Market(
+        bytes memory constructorParams,
+        PoolConfig memory config,
+        address tokenToSeedLiqudity,
+        uint256 amountToSeed,
+        address syOwner
+    ) external returns (PoolDeploymentAddrs memory) {
+        address SY = IPCommonSYFactory(syFactory).deploySY(ERC20_DEPLOY_ID, constructorParams, syOwner);
+        return deploy5115MarketAndSeedLiquidity(SY, config, tokenToSeedLiqudity, amountToSeed);
+    }
+}

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

@@ -0,0 +1,67 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.17;
+
+import "../../core/libraries/BoringOwnableUpgradeable.sol";
+import "../../core/libraries/BaseSplitCodeFactory.sol";
+import "../../interfaces/IOwnable.sol";
+
+contract PendleCommonSYFactory is BoringOwnableUpgradeable {
+    error InvalidCreationCode(bytes32 id, CreationCode code);
+
+    error InvalidSYId(bytes32 id);
+
+    struct CreationCode {
+        address creationCodeContractA;
+        uint256 creationCodeSizeA;
+        address creationCodeContractB;
+        uint256 creationCodeSizeB;
+    }
+
+    event SetSYCreationCode(bytes32 id, CreationCode code);
+
+    event DeployedSY(bytes32 id, bytes constructorParams, address SY);
+
+    mapping(bytes32 => CreationCode) public creationCodes;
+
+    constructor() {
+        _disableInitializers();
+    }
+
+    function initialize() external initializer {
+        __BoringOwnable_init();
+    }
+
+    function setSYCreationCode(bytes32 id, CreationCode memory code) external onlyOwner {
+        if (
+            code.creationCodeContractA == address(0) ||
+            code.creationCodeContractB == address(0) ||
+            code.creationCodeSizeA == 0 ||
+            code.creationCodeSizeB == 0
+        ) {
+            revert InvalidCreationCode(id, code);
+        }
+        creationCodes[id] = code;
+        emit SetSYCreationCode(id, code);
+    }
+
+    function deploySY(bytes32 id, bytes memory constructorParams, address syOwner) external returns (address SY) {
+        CreationCode memory code = creationCodes[id];
+
+        if (code.creationCodeContractA == address(0)) {
+            revert InvalidSYId(id);
+        }
+
+        SY = BaseSplitCodeFactory._create2(
+            0,
+            bytes32(block.chainid),
+            constructorParams,
+            code.creationCodeContractA,
+            code.creationCodeSizeA,
+            code.creationCodeContractB,
+            code.creationCodeSizeB
+        );
+
+        emit DeployedSY(id, constructorParams, SY);
+        IOwnable(SY).transferOwnership(syOwner, true, false);
+    }
+}

package/contracts/offchain-helpers/{PendlePoolDeployHelper.sol → deploy/PendlePoolDeployHelper.sol}

@@ -1,12 +1,12 @@
 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8.17;
 
-import "../interfaces/IPAllActionV3.sol";
-import "../interfaces/IPMarketFactoryV3.sol";
-import "../interfaces/IPYieldContractFactory.sol";
-import "../interfaces/IPMarketV3.sol";
+import "../../interfaces/IPAllActionV3.sol";
+import "../../interfaces/IPMarketFactoryV3.sol";
+import "../../interfaces/IPYieldContractFactory.sol";
+import "../../interfaces/IPMarketV3.sol";
 // import "../core/StandardizedYield/implementations/PendleERC4626SY.sol";
-import "../core/libraries/TokenHelper.sol";
+import "../../core/libraries/TokenHelper.sol";
 
 contract PendlePoolDeployHelper is TokenHelper {
     address public immutable router;

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

@@ -0,0 +1,159 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.17;
+
+import "../../core/libraries/TokenHelper.sol";
+import "../../interfaces/IPAllActionV3.sol";
+import "../../interfaces/IPMarketFactoryV3.sol";
+import "../../interfaces/IPYieldContractFactory.sol";
+import "../../interfaces/IPMarketV3.sol";
+import "./lib/MarketDeployLib.sol";
+
+contract PendlePoolDeployHelperV2 is TokenHelper {
+    using PMath for uint256;
+    using PMath for int256;
+
+    struct PoolDeploymentParams {
+        uint32 expiry;
+        uint80 lnFeeRateRoot;
+        int256 scalarRoot;
+        int256 initialRateAnchor;
+        bool doCacheIndexSameBlock;
+    }
+
+    struct PoolDeploymentAddrs {
+        address SY;
+        address PT;
+        address YT;
+        address market;
+    }
+
+    struct PoolConfig {
+        uint32 expiry;
+        uint256 rateMin;
+        uint256 rateMax;
+        uint256 desiredImpliedRate;
+        uint256 fee;
+    }
+
+    event MarketDeployment(PoolDeploymentAddrs addrs, PoolDeploymentParams params);
+
+    // solhint-disable immutable-vars-naming
+    address public immutable router;
+    address public immutable yieldContractFactory;
+    address public immutable marketFactory;
+    bool public immutable doCacheIndexSameBlock;
+
+    constructor(address _router, address _yieldContractFactory, address _marketFactory) {
+        doCacheIndexSameBlock = block.chainid == 1;
+        router = _router;
+        yieldContractFactory = _yieldContractFactory;
+        marketFactory = _marketFactory;
+    }
+
+    function deploy5115MarketAndSeedLiquidity(
+        address SY,
+        PoolConfig memory config,
+        address tokenToSeedLiqudity,
+        uint256 amountToSeed
+    ) public payable returns (PoolDeploymentAddrs memory) {
+        (PoolDeploymentParams memory params, PoolDeploymentAddrs memory addrs) = _deployPYAndMarket(SY, config);
+        _seedLiquidity(params, addrs, tokenToSeedLiqudity, amountToSeed, config.desiredImpliedRate);
+        return addrs;
+    }
+
+    function _deployPYAndMarket(
+        address SY,
+        PoolConfig memory config
+    ) internal returns (PoolDeploymentParams memory params, PoolDeploymentAddrs memory addrs) {
+        (uint256 scalarRoot, uint256 initialRateAnchor) = MarketDeployLib.calcParams(
+            config.rateMin,
+            config.rateMax,
+            config.expiry
+        );
+
+        params = PoolDeploymentParams({
+            expiry: config.expiry,
+            lnFeeRateRoot: MarketDeployLib.calcFee(config.fee),
+            scalarRoot: scalarRoot.Int(),
+            initialRateAnchor: initialRateAnchor.Int(),
+            doCacheIndexSameBlock: doCacheIndexSameBlock
+        });
+
+        addrs.SY = SY;
+        (addrs.PT, addrs.YT) = IPYieldContractFactory(yieldContractFactory).createYieldContract(
+            SY,
+            params.expiry,
+            params.doCacheIndexSameBlock
+        );
+
+        addrs.market = IPMarketFactoryV3(marketFactory).createNewMarket(
+            addrs.PT,
+            params.scalarRoot,
+            params.initialRateAnchor,
+            params.lnFeeRateRoot
+        );
+
+        emit MarketDeployment(addrs, params);
+    }
+
+    function _seedLiquidity(
+        PoolDeploymentParams memory params,
+        PoolDeploymentAddrs memory addrs,
+        address token,
+        uint256 amountToSeed,
+        uint256 desiredImpliedRate
+    ) internal {
+        _transferIn(token, msg.sender, amountToSeed);
+
+        // Approval
+        _safeApproveInf(token, router);
+        if (token != addrs.SY) {
+            _safeApproveInf(addrs.SY, router);
+        }
+        _safeApproveInf(addrs.PT, router);
+
+        // Mint SY
+        uint256 amountSY;
+        if (token != addrs.SY) {
+            uint256 netNative = (token == NATIVE ? amountToSeed : 0);
+            amountSY = IPAllActionV3(router).mintSyFromToken{value: netNative}(
+                address(this),
+                addrs.SY,
+                0,
+                TokenInput({
+                    tokenIn: token,
+                    netTokenIn: amountToSeed,
+                    tokenMintSy: token,
+                    pendleSwap: address(0),
+                    swapData: SwapData({
+                        swapType: SwapType.NONE,
+                        extRouter: address(0),
+                        extCalldata: abi.encode(),
+                        needScale: false
+                    })
+                })
+            );
+        } else {
+            amountSY = amountToSeed;
+        }
+
+        uint256 initialProportion = MarketDeployLib.calcInitialProportion(
+            params.expiry,
+            params.scalarRoot.Uint(),
+            params.initialRateAnchor.Uint(),
+            desiredImpliedRate
+        );
+
+        // mint PY
+        uint256 amountPY = IPAllActionV3(router).mintPyFromSy(
+            address(this),
+            addrs.YT,
+            amountSY.mulDown(initialProportion),
+            0
+        );
+
+        // mint LP
+        IPAllActionV3(router).addLiquidityDualSyAndPt(msg.sender, addrs.market, _selfBalance(addrs.SY), amountPY, 0);
+        _transferOut(addrs.YT, msg.sender, amountPY);
+    }
+}