@pendle/core-v2 5.6.0 → 5.7.0

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

@@ -3,8 +3,8 @@
   "contractName": "MarketApproxPtInLibOnchain",
   "sourceName": "contracts/router/math/MarketApproxLibOnchain.sol",
   "abi": [],
-  "bytecode": "0x60566037600b82828239805160001a607314602a57634e487b7160e01b600052600060045260246000fd5b30600052607381538281f3fe73000000000000000000000000000000000000000030146080604052600080fdfea26469706673582212208926fa6a1669b316ef8b260994b7b3e677164bb23c1d2a9364d7f0c94b85ba4264736f6c63430008170033",
-  "deployedBytecode": "0x73000000000000000000000000000000000000000030146080604052600080fdfea26469706673582212208926fa6a1669b316ef8b260994b7b3e677164bb23c1d2a9364d7f0c94b85ba4264736f6c63430008170033",
+  "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/72388dcca8fd03931a3656e184e016ec.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": "0x60566037600b82828239805160001a607314602a57634e487b7160e01b600052600060045260246000fd5b30600052607381538281f3fe73000000000000000000000000000000000000000030146080604052600080fdfea264697066735822122058fdc410b4b575841c734f083b66e09fe250dc56257b5cb5e9b82e0618f7865264736f6c63430008170033",
-  "deployedBytecode": "0x73000000000000000000000000000000000000000030146080604052600080fdfea264697066735822122058fdc410b4b575841c734f083b66e09fe250dc56257b5cb5e9b82e0618f7865264736f6c63430008170033",
+  "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/72388dcca8fd03931a3656e184e016ec.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": "0x60566037600b82828239805160001a607314602a57634e487b7160e01b600052600060045260246000fd5b30600052607381538281f3fe73000000000000000000000000000000000000000030146080604052600080fdfea2646970667358221220eaa91b6e04a07d29a1951ac794985ee2a81a1d6380d2db556aef65197c71331364736f6c63430008170033",
-  "deployedBytecode": "0x73000000000000000000000000000000000000000030146080604052600080fdfea2646970667358221220eaa91b6e04a07d29a1951ac794985ee2a81a1d6380d2db556aef65197c71331364736f6c63430008170033",
+  "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/72388dcca8fd03931a3656e184e016ec.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": "0x60566037600b82828239805160001a607314602a57634e487b7160e01b600052600060045260246000fd5b30600052607381538281f3fe73000000000000000000000000000000000000000030146080604052600080fdfea26469706673582212204d1223a9f4e93fb50232986ef86372b1e885c1f948787333716c75d5559641eb64736f6c63430008170033",
-  "deployedBytecode": "0x73000000000000000000000000000000000000000030146080604052600080fdfea26469706673582212204d1223a9f4e93fb50232986ef86372b1e885c1f948787333716c75d5559641eb64736f6c63430008170033",
+  "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/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/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);
+    }
+}

package/contracts/offchain-helpers/deploy/lib/MarketDeployLib.sol

@@ -0,0 +1,70 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.17;
+
+import "../../../core/libraries/math/PMath.sol";
+import "../../../core/libraries/math/LogExpMath.sol";
+
+library MarketDeployLib {
+    using PMath for uint256;
+    using PMath for int256;
+    using LogExpMath for uint256;
+    using LogExpMath for int256;
+
+    uint256 internal constant YEAR = 365 days;
+    uint256 internal constant LN_9 = 2197224577336219648;
+
+    struct CalcParamsArgs {
+        uint256 yearsToExpiry;
+        uint256 rateMinScaled;
+        uint256 rateMaxScaled;
+        uint256 rateDiff;
+    }
+
+    function calcParams(
+        uint256 rateMin,
+        uint256 rateMax,
+        uint256 expiry
+    ) internal view returns (uint256 scalarRoot, uint256 initialRateAnchor) {
+        CalcParamsArgs memory args;
+
+        args.yearsToExpiry = (expiry - block.timestamp).divDown(YEAR);
+        args.rateMinScaled = (rateMin + PMath.ONE).pow(args.yearsToExpiry);
+        args.rateMaxScaled = (rateMax + PMath.ONE).pow(args.yearsToExpiry);
+
+        // [initRateAnchor]
+        initialRateAnchor = (args.rateMinScaled + args.rateMaxScaled) / 2;
+
+        args.rateDiff = args.rateMaxScaled - initialRateAnchor;
+
+        // [scalarRoot]
+        scalarRoot = (LN_9 * args.yearsToExpiry) / args.rateDiff;
+    }
+
+    struct CalcInitialProportionArgs {
+        uint256 timeToExpiry;
+        uint256 lnImpliedRate;
+        int256 desiredExchangeRate;
+        uint256 lnProportion;
+    }
+
+    function calcInitialProportion(
+        uint256 expiry,
+        uint256 scalarRoot,
+        uint256 rateAnchor,
+        uint256 desiredImpliedRate
+    ) internal view returns (uint256 initialProportion) {
+        CalcInitialProportionArgs memory args;
+
+        args.timeToExpiry = expiry - block.timestamp;
+        args.lnImpliedRate = LogExpMath.ln(PMath.IONE + desiredImpliedRate.Int()).Uint();
+        args.desiredExchangeRate = ((args.lnImpliedRate * args.timeToExpiry) / YEAR).Int().exp();
+
+        uint256 rateScalar = (scalarRoot * YEAR) / args.timeToExpiry;
+        int256 logitP = (args.desiredExchangeRate - rateAnchor.Int()).mulDown(rateScalar.Int()).exp();
+        initialProportion = (logitP.divDown(PMath.IONE + logitP)).Uint();
+    }
+
+    function calcFee(uint256 fee) internal pure returns (uint80 lnFeeRateRoot) {
+        return (PMath.ONE + fee).Int().ln().Uint().Uint80();
+    }
+}

package/contracts/oracles/internal/PendleSparkLinearDiscountOracleFactory.sol

@@ -2,9 +2,16 @@
 pragma solidity ^0.8.19;
 
 import {PendleSparkLinearDiscountOracle} from "./PendleSparkLinearDiscountOracle.sol";
+import "../../interfaces/IPPrincipalToken.sol";
+import "../../interfaces/IPMarket.sol";
 
 contract PendleSparkLinearDiscountOracleFactory {
-    function create(address _pt, uint256 _baseDiscountPerYear) external returns (address) {
-        return address(new PendleSparkLinearDiscountOracle(_pt, _baseDiscountPerYear));
+    function createWithPt(address pt, uint256 baseDiscountPerYear) external returns (address) {
+        return address(new PendleSparkLinearDiscountOracle(pt, baseDiscountPerYear));
+    }
+
+    function createWithMarket(address market, uint256 baseDiscountPerYear) external returns (address) {
+        (, IPPrincipalToken PT, ) = IPMarket(market).readTokens();
+        return address(new PendleSparkLinearDiscountOracle(address(PT), baseDiscountPerYear));
     }
 }

package/deployments/146-core.json

@@ -0,0 +1,47 @@
+{
+    "deployer": "0x1FcCC097db89A86Bfc474A1028F93958295b1Fb7",
+    "network": {
+        "chainId": 146,
+        "treasury": "0xCbcb48e22622a3778b6F14C2f5d258Ba026b05e6",
+        "governance": "0x7877adfaded756f3248a0ebfe8ac2e2ef87b75ac",
+        "devMultisig": "0x7877adfaded756f3248a0ebfe8ac2e2ef87b75ac",
+        "pendle": "0xf1eF7d2D4C0c881cd634481e0586ed5d2871A74B",
+        "lzEndpoint": "0xb6319cC6c8c27A8F5dAF0dD3DF91EA35C4720dd7",
+        "wrappedNative": "0x039e2fb66102314ce7b64ce5ce3e5183bc94ad38",
+        "initialRewardFee": "30000000000000000",
+        "initialInterestFee": "30000000000000000",
+        "initialReserveFeePercent": "80",
+        "safeWaitTime": 15000,
+        "hardwareDeployer": "0xeea6F790F18563E91b18DF00B89d9f79b2E6761F"
+    },
+    "baseCodeSplitter": "0x6952Eb0c152D683ea2F2B8B90a5E888c1550B69D",
+    "PENDLE": "0xf1eF7d2D4C0c881cd634481e0586ed5d2871A74B",
+    "governanceProxy": "0x2aD631F72fB16d91c4953A7f4260A97C2fE2f31e",
+    "yieldContractFactoryV5": "0x0582D93FD9c9d42f26bE5D86a5f75291F92102C2",
+    "marketFactoryV5": "0xFeE31A6eC6eBefa0b5A594Bf5b1139e3c6fAA0fB",
+    "router": "0x888888888889758F76e7103c6CbF23ABbF58F946",
+    "routerFacets": {
+        "ActionAddRemoveLiqV3": "0x663C21103915B68e9dA797CfdF3cAb01a037D5Ff",
+        "ActionSwapPTV3": "0xd8D200d9A713A1c71cF1e7F694B14E5F1D948b15",
+        "ActionSwapYTV3": "0x4a03Ce0a268951d04E187B1CF48075eE69266e27",
+        "ActionMiscV3": "0x373Dba2055Ad40cb4815148bC47cd1DC16e92E44",
+        "ActionSimple": "0x852e59252c94716F0df19B52b36512f6C9297a96",
+        "ActionCallbackV3": "0x7b78F36aBf6cF3C6C0dd54716dFeF0607ae17846",
+        "ActionStorageV4": "0xdED51dca2ECED7a0BAab3D9711A87f214769Da0f"
+    },
+    "routerStatic": "0x0013ACc071f732fd6BF8210AB46A3794a7D8945e",
+    "pendleSwap": "0x313e7Ef7d52f5C10aC04ebaa4d33CDc68634c212",
+    "pyYtLpOracle": "0x9a9fa8338dd5e5b2188006f1cd2ef26d921650c2",
+    "reflector": "0x5039Da22E5126e7c4e9284376116716A91782faF",
+    "receiverEndpoint": "0x3209E9412cca80B18338f2a56ADA59c484c39644",
+    "limitRouter": "0x0000000000000000000000000000000000000000",
+    "proxyAdmin": "0xA28c08f165116587D4F3E708743B4dEe155c5E64",
+    "vePendle": "0xE017CCC08505Ac8fbb5a364680e459d9fBaEE74d",
+    "gaugeController": "0xeE708FC793a02F1eDd5BB9DBD7fD13010D1F7136",
+    "sparkLinearDiscountOracleFactory": "0xA9A924A4BB95509F77868E086154C25e934F6171",
+    "vePendleAirdropDistributor": "0x3942F7B55094250644cFfDa7160226Caa349A38E",
+    "externalRewardsDistributor": "0xae898a7d07f8e27f25e13d0f351a7401f9a5bf9d",
+    "beta": {
+        "PendleChainlinkOracleFactory": "0x0000000000000000000000000000000000000000"
+    }
+}

package/deployments/146-offchain-helper.json

@@ -0,0 +1,6 @@
+{
+    "pendleMulticallV2": "0x1ca3352a55A3D69cA8e5aB06006e08aaF2bD09f1",
+    "implicitSwapfeeContract": "0x82Fae57b2A79D893D88488A7D8BdF2AC6bd2C463",
+    "simulateHelper": "0xc23Dd2807e51dd1D317e1321CBeEb9ace98531EE",
+    "supplyCapReader": "0x251CfB4E84CefecA6c1e6a4D8a0cb9c524e7484f"
+}

package/package.json

@@ -2,7 +2,7 @@
   "name": "@pendle/core-v2",
   "description": "Core smart contracts of Pendle Protocol.",
   "license": "BUSL-1.1",
-  "version": "5.6.0",
+  "version": "5.7.0",
   "homepage": "https://pendle.finance",
   "keywords": [
     "pendle",