@pendle/core-v2 6.3.0-beta → 6.3.0-sweedtest

package/contracts/offchain-helpers/PendleGovernanceProxy.sol

@@ -1,8 +1,8 @@
 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8.23;
 
-import "../interfaces/IPPausingInterface.sol";
 import "../interfaces/IPGovernanceProxy.sol";
+import "../interfaces/IPPausingInterface.sol";
 import "@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol";
 import "@openzeppelin/contracts/proxy/utils/UUPSUpgradeable.sol";
 
@@ -31,8 +31,8 @@ contract PendleGovernanceProxy is AccessControlUpgradeable, UUPSUpgradeable, IPG
     // to execute calls
 
     mapping(address caller => mapping(bytes4 selector => bool isAdmin)) public isSelectorAdminOf;
-    mapping(address caller => mapping(bytes4 selector => mapping(address target => bool isAllowed)))
-        public hasScopedAccess;
+    mapping(address caller => mapping(bytes4 selector => mapping(address target => bool isAllowed))) public
+        hasScopedAccess;
 
     modifier onlyGuardian() {
         require(hasRole(GUARDIAN, msg.sender) || hasRole(DEFAULT_ADMIN_ROLE, msg.sender), "PGP: n/a");
@@ -65,12 +65,9 @@ contract PendleGovernanceProxy is AccessControlUpgradeable, UUPSUpgradeable, IPG
         }
     }
 
-    function modifyScopedAccess(
-        address caller,
-        address[] memory targets,
-        bytes4 selector,
-        bool[] memory accesses
-    ) external {
+    function modifyScopedAccess(address caller, address[] memory targets, bytes4 selector, bool[] memory accesses)
+        external
+    {
         require(targets.length == accesses.length, "PGP: Array length mismatch");
         require(hasRole(DEFAULT_ADMIN_ROLE, msg.sender) || isSelectorAdminOf[msg.sender][selector], "PGP: n/a");
 
@@ -95,7 +92,7 @@ contract PendleGovernanceProxy is AccessControlUpgradeable, UUPSUpgradeable, IPG
 
     function pause(address[] calldata addrs) external onlyGuardian {
         uint256 length = addrs.length;
-        for (uint256 i = 0; i < length; ) {
+        for (uint256 i = 0; i < length;) {
             IPPausingInterface(addrs[i]).pause();
             unchecked {
                 ++i;

package/contracts/offchain-helpers/PendleLPWrapper.sol

@@ -3,9 +3,9 @@ pragma solidity ^0.8.0;
 
 import "../core/erc20/PendleERC20.sol";
 import "../core/libraries/TokenHelper.sol";
-import "../interfaces/IPMarket.sol";
-import "../interfaces/IPLPWrapperFactory.sol";
 import "../interfaces/ILPWrapper.sol";
+import "../interfaces/IPLPWrapperFactory.sol";
+import "../interfaces/IPMarket.sol";
 
 contract PendleLPWrapper is PendleERC20, TokenHelper, ILPWrapper {
     address public immutable LP;
@@ -32,7 +32,16 @@ contract PendleLPWrapper is PendleERC20, TokenHelper, ILPWrapper {
         _transferOut(LP, receiver, netWrapIn);
     }
 
-    function _beforeTokenTransfer(address /*from*/, address /*to*/, uint256 /*amount*/) internal override {
+    function _beforeTokenTransfer(
+        address,
+        /*from*/
+        address,
+        /*to*/
+        uint256 /*amount*/
+    )
+        internal
+        override
+    {
         if (!isRewardRedemptionDisabled) {
             IPMarket(LP).redeemRewards(address(this));
         }

package/contracts/offchain-helpers/PendleLPWrapperFactory.sol

@@ -1,9 +1,9 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity ^0.8.0;
 
-import "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
-import "./PendleLPWrapper.sol";
 import "../core/libraries/BoringOwnableUpgradeableV2.sol";
+import "./PendleLPWrapper.sol";
+import "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
 
 contract PendleLPWrapperFactory is BoringOwnableUpgradeableV2 {
     event LPWrapperCreated(address indexed lpToken, address indexed wrapper);

package/contracts/offchain-helpers/PendleMulticallV1.sol

@@ -15,7 +15,7 @@ contract PendleMulticallV1 {
     function aggregate(Call[] calldata calls) public payable virtual {
         uint256 length = calls.length;
         Call calldata call;
-        for (uint256 i = 0; i < length; ) {
+        for (uint256 i = 0; i < length;) {
             call = calls[i];
 
             (bool success, bytes memory resp) = call.target.call(call.callData);
@@ -31,15 +31,15 @@ contract PendleMulticallV1 {
         }
     }
 
-    function tryAggregate(
-        bool requireSuccess,
-        uint256 gasLimit,
-        Call[] calldata calls
-    ) public payable returns (Result[] memory returnData) {
+    function tryAggregate(bool requireSuccess, uint256 gasLimit, Call[] calldata calls)
+        public
+        payable
+        returns (Result[] memory returnData)
+    {
         uint256 length = calls.length;
         returnData = new Result[](length);
         Call calldata call;
-        for (uint256 i = 0; i < length; ) {
+        for (uint256 i = 0; i < length;) {
             call = calls[i];
 
             (bool success, bytes memory resp) = call.target.call{gas: gasLimit}(calls[i].callData);

package/contracts/offchain-helpers/PendleMulticallV2.sol

@@ -17,7 +17,7 @@ contract PendleMulticallV2 {
     function aggregate(Call[] calldata calls) public payable virtual {
         uint256 length = calls.length;
         Call calldata call;
-        for (uint256 i = 0; i < length; ) {
+        for (uint256 i = 0; i < length;) {
             call = calls[i];
 
             (bool success, bytes memory resp) = call.target.call(call.callData);
@@ -33,15 +33,15 @@ contract PendleMulticallV2 {
         }
     }
 
-    function tryAggregate(
-        bool requireSuccess,
-        uint256 gasLimit,
-        Call[] calldata calls
-    ) public payable returns (Result[] memory returnData) {
+    function tryAggregate(bool requireSuccess, uint256 gasLimit, Call[] calldata calls)
+        public
+        payable
+        returns (Result[] memory returnData)
+    {
         uint256 length = calls.length;
         returnData = new Result[](length);
         Call calldata call;
-        for (uint256 i = 0; i < length; ) {
+        for (uint256 i = 0; i < length;) {
             call = calls[i];
 
             (bool success, bytes memory resp) = call.target.call{gas: gasLimit}(calls[i].callData);
@@ -59,14 +59,15 @@ contract PendleMulticallV2 {
         }
     }
 
-    function tryAggregateRevert(
-        uint256 gasLimit,
-        Call[] calldata calls
-    ) public payable returns (bytes[] memory returnData) {
+    function tryAggregateRevert(uint256 gasLimit, Call[] calldata calls)
+        public
+        payable
+        returns (bytes[] memory returnData)
+    {
         uint256 length = calls.length;
         returnData = new bytes[](length);
         Call calldata call;
-        for (uint256 i = 0; i < length; ) {
+        for (uint256 i = 0; i < length;) {
             call = calls[i];
 
             (, returnData[i]) = address(this).delegatecall{gas: gasLimit}(

package/contracts/offchain-helpers/PendleOffchainStorage.sol

@@ -1,9 +1,9 @@
 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8.17;
 
+import "../interfaces/IPOffchainStorage.sol";
 import "@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol";
 import "@openzeppelin/contracts/proxy/utils/UUPSUpgradeable.sol";
-import "../interfaces/IPOffchainStorage.sol";
 
 contract PendleOffchainStorage is IPOffchainStorage, UUPSUpgradeable, AccessControlUpgradeable {
     bytes32 public constant MAINTAINER = keccak256("MAINTAINER");

package/contracts/offchain-helpers/PendleWstETHPriceFeed.sol

@@ -1,9 +1,11 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity ^0.8.17;
 
-import "../interfaces/IWstETH.sol";
 import "../interfaces/IPPriceFeed.sol";
-import {AggregatorV2V3Interface as IChainlinkAggregator} from "@chainlink/contracts/src/v0.8/interfaces/AggregatorV2V3Interface.sol";
+import "../interfaces/IWstETH.sol";
+import {
+    AggregatorV2V3Interface as IChainlinkAggregator
+} from "@chainlink/contracts/src/v0.8/interfaces/AggregatorV2V3Interface.sol";
 
 contract PendleWstETHPriceFeed is IPPriceFeed {
     // solhint-disable immutable-vars-naming

package/contracts/offchain-helpers/SimulateHelper.sol

@@ -10,17 +10,18 @@ contract SimulateHelper {
         original = address(this);
     }
 
-    function multicallRevert(
-        uint256 gasLimit,
-        address[] calldata targets,
-        bytes[] calldata callDatas
-    ) public payable virtual returns (bytes[] memory res, uint256[] memory gasUsed) {
+    function multicallRevert(uint256 gasLimit, address[] calldata targets, bytes[] calldata callDatas)
+        public
+        payable
+        virtual
+        returns (bytes[] memory res, uint256[] memory gasUsed)
+    {
         require(targets.length == callDatas.length, "length mismatch");
 
         uint256 length = callDatas.length;
         res = new bytes[](length);
         gasUsed = new uint256[](length);
-        for (uint256 i = 0; i < length; ) {
+        for (uint256 i = 0; i < length;) {
             uint256 gasBefore = gasleft();
             (, res[i]) = original.delegatecall{gas: gasLimit}(
                 abi.encodeWithSignature("simulate(address,bytes)", targets[i], callDatas[i])

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

@@ -1,10 +1,10 @@
 // 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/BoringOwnableUpgradeableV2.sol";
+import "../../interfaces/IOwnable.sol";
+import "../../interfaces/IPCommonSYFactory.sol";
+import "./PendlePoolDeployHelperV2.sol";
 
 contract PendleCommonPoolDeployHelperV2 is PendlePoolDeployHelperV2, BoringOwnableUpgradeableV2 {
     bytes32 public constant ERC4626_DEPLOY_ID = keccak256("PendleERC4626SYV2"); // 0x1278efc0e6754cd30fef2df25ff5ced072ebb194d348b0b1b9548166d24352ef
@@ -18,12 +18,9 @@ contract PendleCommonPoolDeployHelperV2 is PendlePoolDeployHelperV2, BoringOwnab
 
     address public immutable syFactory;
 
-    constructor(
-        address _syFactory,
-        address _router,
-        address _yieldContractFactory,
-        address _marketFactory
-    ) PendlePoolDeployHelperV2(_router, _yieldContractFactory, _marketFactory) {
+    constructor(address _syFactory, address _router, address _yieldContractFactory, address _marketFactory)
+        PendlePoolDeployHelperV2(_router, _yieldContractFactory, _marketFactory)
+    {
         syFactory = _syFactory;
         _disableInitializers();
     }
@@ -65,11 +62,7 @@ contract PendleCommonPoolDeployHelperV2 is PendlePoolDeployHelperV2, BoringOwnab
         uint256 amountToSeed,
         address syOwner
     ) external returns (PoolDeploymentAddrs memory) {
-        address SY = IPCommonSYFactory(syFactory).deploySY(
-            ERC4626_NOT_REDEEMABLE_DEPLOY_ID,
-            constructorParams,
-            syOwner
-        );
+        address SY = IPCommonSYFactory(syFactory).deploySY(ERC4626_NOT_REDEEMABLE_DEPLOY_ID, constructorParams, syOwner);
         return deploy5115MarketAndSeedLiquidity(SY, config, tokenToSeedLiqudity, amountToSeed);
     }
 
@@ -92,12 +85,8 @@ contract PendleCommonPoolDeployHelperV2 is PendlePoolDeployHelperV2, BoringOwnab
         uint256 amountToSeed,
         address syOwner
     ) external returns (PoolDeploymentAddrs memory) {
-        address SY = IPCommonSYFactory(syFactory).deployUpgradableSY(
-            ERC4626_WITH_ADAPTER_ID,
-            constructorParams,
-            initData,
-            syOwner
-        );
+        address SY = IPCommonSYFactory(syFactory)
+            .deployUpgradableSY(ERC4626_WITH_ADAPTER_ID, constructorParams, initData, syOwner);
         return deploy5115MarketAndSeedLiquidity(SY, config, tokenToSeedLiqudity, amountToSeed);
     }
 
@@ -109,12 +98,8 @@ contract PendleCommonPoolDeployHelperV2 is PendlePoolDeployHelperV2, BoringOwnab
         uint256 amountToSeed,
         address syOwner
     ) external returns (PoolDeploymentAddrs memory) {
-        address SY = IPCommonSYFactory(syFactory).deployUpgradableSY(
-            ERC4626_NO_REDEEM_WITH_ADAPTER_ID,
-            constructorParams,
-            initData,
-            syOwner
-        );
+        address SY = IPCommonSYFactory(syFactory)
+            .deployUpgradableSY(ERC4626_NO_REDEEM_WITH_ADAPTER_ID, constructorParams, initData, syOwner);
         return deploy5115MarketAndSeedLiquidity(SY, config, tokenToSeedLiqudity, amountToSeed);
     }
 
@@ -126,12 +111,8 @@ contract PendleCommonPoolDeployHelperV2 is PendlePoolDeployHelperV2, BoringOwnab
         uint256 amountToSeed,
         address syOwner
     ) external returns (PoolDeploymentAddrs memory) {
-        address SY = IPCommonSYFactory(syFactory).deployUpgradableSY(
-            ERC20_WITH_ADAPTER_ID,
-            constructorParams,
-            initData,
-            syOwner
-        );
+        address SY = IPCommonSYFactory(syFactory)
+            .deployUpgradableSY(ERC20_WITH_ADAPTER_ID, constructorParams, initData, syOwner);
         return deploy5115MarketAndSeedLiquidity(SY, config, tokenToSeedLiqudity, amountToSeed);
     }
 }

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

@@ -1,8 +1,8 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity ^0.8.17;
 
-import "../../core/libraries/BoringOwnableUpgradeableV2.sol";
 import "../../core/libraries/BaseSplitCodeFactory.sol";
+import "../../core/libraries/BoringOwnableUpgradeableV2.sol";
 import "../../interfaces/IOwnable.sol";
 import "@openzeppelin/contracts/proxy/transparent/TransparentUpgradeableProxy.sol";
 
@@ -41,10 +41,8 @@ contract PendleCommonSYFactory is BoringOwnableUpgradeableV2 {
 
     function setSYCreationCode(bytes32 id, CreationCode memory code) external onlyOwner {
         if (
-            code.creationCodeContractA == address(0) ||
-            code.creationCodeContractB == address(0) ||
-            code.creationCodeSizeA == 0 ||
-            code.creationCodeSizeB == 0
+            code.creationCodeContractA == address(0) || code.creationCodeContractB == address(0)
+                || code.creationCodeSizeA == 0 || code.creationCodeSizeB == 0
         ) {
             revert InvalidCreationCode(id, code);
         }
@@ -73,12 +71,10 @@ contract PendleCommonSYFactory is BoringOwnableUpgradeableV2 {
         IOwnable(SY).transferOwnership(syOwner, true, false);
     }
 
-    function deployUpgradableSY(
-        bytes32 id,
-        bytes memory constructorParams,
-        bytes memory initData,
-        address syOwner
-    ) external returns (address) {
+    function deployUpgradableSY(bytes32 id, bytes memory constructorParams, bytes memory initData, address syOwner)
+        external
+        returns (address)
+    {
         CreationCode memory code = creationCodes[id];
 
         if (code.creationCodeContractA == address(0)) {

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

@@ -2,9 +2,9 @@
 pragma solidity ^0.8.17;
 
 import "../../interfaces/IPAllActionV3.sol";
+import "../../interfaces/IPMarket.sol";
 import "../../interfaces/IPMarketFactory.sol";
 import "../../interfaces/IPYieldContractFactory.sol";
-import "../../interfaces/IPMarket.sol";
 // import "../core/StandardizedYield/implementations/PendleERC4626SY.sol";
 import "../../core/libraries/TokenHelper.sol";
 
@@ -44,32 +44,20 @@ contract PendlePoolDeployHelper is TokenHelper {
         _seedLiquidity(market, address(SY), address(PT), address(YT), tokenToSeedLiqudity, amountToSeed);
     }
 
-    function _deployPYAndMarket(
-        address SY,
-        PoolDeploymentParams memory params
-    ) internal returns (address PT, address YT, address market) {
-        (PT, YT) = IPYieldContractFactory(yieldContractFactory).createYieldContract(
-            SY,
-            params.expiry,
-            params.doCacheIndexSameBlock
-        );
-        market = IPMarketFactory(marketFactory).createNewMarket(
-            PT,
-            params.scalarRoot,
-            params.initialRateAnchor,
-            params.lnFeeRateRoot
-        );
+    function _deployPYAndMarket(address SY, PoolDeploymentParams memory params)
+        internal
+        returns (address PT, address YT, address market)
+    {
+        (PT, YT) = IPYieldContractFactory(yieldContractFactory)
+            .createYieldContract(SY, params.expiry, params.doCacheIndexSameBlock);
+        market = IPMarketFactory(marketFactory)
+            .createNewMarket(PT, params.scalarRoot, params.initialRateAnchor, params.lnFeeRateRoot);
         emit MarketDeployment(market, SY, PT, YT, params);
     }
 
-    function _seedLiquidity(
-        address market,
-        address SY,
-        address PT,
-        address YT,
-        address token,
-        uint256 amountToSeed
-    ) internal {
+    function _seedLiquidity(address market, address SY, address PT, address YT, address token, uint256 amountToSeed)
+        internal
+    {
         _transferIn(token, msg.sender, amountToSeed);
 
         // Approval
@@ -93,10 +81,7 @@ contract PendlePoolDeployHelper is TokenHelper {
                     tokenMintSy: token,
                     pendleSwap: address(0),
                     swapData: SwapData({
-                        swapType: SwapType.NONE,
-                        extRouter: address(0),
-                        extCalldata: abi.encode(),
-                        needScale: false
+                        swapType: SwapType.NONE, extRouter: address(0), extCalldata: abi.encode(), needScale: false
                     })
                 })
             );
@@ -119,13 +104,9 @@ contract PendlePoolDeployHelper is TokenHelper {
         int256 scalarRoot,
         int256 initialRateAnchor
     ) external returns (address newMarket) {
-        (, IPPrincipalToken PT, ) = IPMarket(oldMarket).readTokens();
-        newMarket = IPMarketFactory(marketFactory).createNewMarket(
-            address(PT),
-            scalarRoot,
-            initialRateAnchor,
-            lnFeeRateRoot
-        );
+        (, IPPrincipalToken PT,) = IPMarket(oldMarket).readTokens();
+        newMarket =
+            IPMarketFactory(marketFactory).createNewMarket(address(PT), scalarRoot, initialRateAnchor, lnFeeRateRoot);
         _transferFrom(IERC20(oldMarket), msg.sender, oldMarket, amountLp);
         (uint256 netSyOut, uint256 netPtOut) = IPMarket(oldMarket).burn(newMarket, newMarket, amountLp);
         IPMarket(newMarket).mint(msg.sender, netSyOut, netPtOut);

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/IPMarket.sol";
 import "../../interfaces/IPMarketFactory.sol";
 import "../../interfaces/IPYieldContractFactory.sol";
-import "../../interfaces/IPMarket.sol";
 import "./lib/MarketDeployLib.sol";
 
 contract PendlePoolDeployHelperV2 is TokenHelper {
@@ -61,15 +61,12 @@ contract PendlePoolDeployHelperV2 is TokenHelper {
         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
-        );
+    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,
@@ -82,12 +79,8 @@ contract PendlePoolDeployHelperV2 is TokenHelper {
         addrs.SY = SY;
         (addrs.PT, addrs.YT) = _createPYIfNotExist(SY, params.expiry);
 
-        addrs.market = IPMarketFactory(marketFactory).createNewMarket(
-            addrs.PT,
-            params.scalarRoot,
-            params.initialRateAnchor,
-            params.lnFeeRateRoot
-        );
+        addrs.market = IPMarketFactory(marketFactory)
+            .createNewMarket(addrs.PT, params.scalarRoot, params.initialRateAnchor, params.lnFeeRateRoot);
 
         emit MarketDeployment(addrs, params);
     }
@@ -95,11 +88,8 @@ contract PendlePoolDeployHelperV2 is TokenHelper {
     function _createPYIfNotExist(address SY, uint32 expiry) internal returns (address PT, address YT) {
         PT = IPYieldContractFactory(yieldContractFactory).getPT(SY, uint256(expiry));
         if (PT == address(0)) {
-            (PT, YT) = IPYieldContractFactory(yieldContractFactory).createYieldContract(
-                SY,
-                expiry,
-                doCacheIndexSameBlock
-            );
+            (PT, YT) =
+                IPYieldContractFactory(yieldContractFactory).createYieldContract(SY, expiry, doCacheIndexSameBlock);
         } else {
             YT = IPYieldContractFactory(yieldContractFactory).getYT(SY, expiry);
         }
@@ -135,10 +125,7 @@ contract PendlePoolDeployHelperV2 is TokenHelper {
                     tokenMintSy: token,
                     pendleSwap: address(0),
                     swapData: SwapData({
-                        swapType: SwapType.NONE,
-                        extRouter: address(0),
-                        extCalldata: abi.encode(),
-                        needScale: false
+                        swapType: SwapType.NONE, extRouter: address(0), extCalldata: abi.encode(), needScale: false
                     })
                 })
             );
@@ -147,19 +134,12 @@ contract PendlePoolDeployHelperV2 is TokenHelper {
         }
 
         uint256 initialProportion = MarketDeployLib.calcInitialProportion(
-            params.expiry,
-            params.scalarRoot.Uint(),
-            params.initialRateAnchor.Uint(),
-            desiredImpliedRate
+            params.expiry, params.scalarRoot.Uint(), params.initialRateAnchor.Uint(), desiredImpliedRate
         );
 
         // mint PY
-        uint256 amountPY = IPAllActionV3(router).mintPyFromSy(
-            address(this),
-            addrs.YT,
-            amountSY.mulDown(initialProportion),
-            0
-        );
+        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);

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

@@ -1,8 +1,8 @@
 // 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";
+import "../../../core/libraries/math/PMath.sol";
 
 library MarketDeployLib {
     using PMath for uint256;
@@ -11,7 +11,7 @@ library MarketDeployLib {
     using LogExpMath for int256;
 
     uint256 internal constant YEAR = 365 days;
-    uint256 internal constant LN_9 = 2197224577336219648;
+    uint256 internal constant LN_9 = 2_197_224_577_336_219_648;
 
     struct CalcParamsArgs {
         uint256 yearsToExpiry;
@@ -20,11 +20,11 @@ library MarketDeployLib {
         uint256 rateDiff;
     }
 
-    function calcParams(
-        uint256 rateMin,
-        uint256 rateMax,
-        uint256 expiry
-    ) internal view returns (uint256 scalarRoot, uint256 initialRateAnchor) {
+    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);
@@ -47,12 +47,11 @@ library MarketDeployLib {
         uint256 lnProportion;
     }
 
-    function calcInitialProportion(
-        uint256 expiry,
-        uint256 scalarRoot,
-        uint256 rateAnchor,
-        uint256 desiredImpliedRate
-    ) internal view returns (uint256 initialProportion) {
+    function calcInitialProportion(uint256 expiry, uint256 scalarRoot, uint256 rateAnchor, uint256 desiredImpliedRate)
+        internal
+        view
+        returns (uint256 initialProportion)
+    {
         CalcInitialProportionArgs memory args;
 
         args.timeToExpiry = expiry - block.timestamp;

package/contracts/offchain-helpers/errors/SDKErrorsDirectory.sol

@@ -14,10 +14,7 @@ library SDKErrorsDirectory {
     }
 
     error ApproxBinarySearchInputInvalid(
-        uint256 approxGuessMin,
-        uint256 approxGuessMax,
-        uint256 minGuessMin,
-        uint256 maxGuessMax
+        uint256 approxGuessMin, uint256 approxGuessMax, uint256 minGuessMin, uint256 maxGuessMax
     );
     error ApproxDstExecutionGasNotSet();
     error ApproxFail();

package/contracts/offchain-helpers/router-static/PendleRouterStatic.sol

@@ -1,9 +1,9 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity ^0.8.17;
 
-import "@openzeppelin/contracts/proxy/Proxy.sol";
 import "../../interfaces/IPRouterStatic.sol";
 import "./base/StorageLayout.sol";
+import "@openzeppelin/contracts/proxy/Proxy.sol";
 
 // solhint-disable no-empty-blocks
 contract PendleRouterStatic is Proxy, StorageLayout {

package/contracts/offchain-helpers/router-static/base/ActionInfoStatic.sol

@@ -2,9 +2,9 @@
 pragma solidity ^0.8.17;
 
 import "../../../interfaces/IPMarket.sol";
+import "../../../interfaces/IPMarketFactory.sol";
 import "../../../interfaces/IPRouterStatic.sol";
 import "../../../interfaces/IPYieldContractFactory.sol";
-import "../../../interfaces/IPMarketFactory.sol";
 
 // solhint-disable no-empty-blocks
 contract ActionInfoStatic is IPActionInfoStatic {
@@ -19,9 +19,11 @@ contract ActionInfoStatic is IPActionInfoStatic {
     }
 
     /// can be SY, PY or Market
-    function getTokensInOut(
-        address token
-    ) external view returns (address[] memory tokensIn, address[] memory tokensOut) {
+    function getTokensInOut(address token)
+        external
+        view
+        returns (address[] memory tokensIn, address[] memory tokensOut)
+    {
         try IStandardizedYield(token).getTokensIn() returns (address[] memory res) {
             return (res, IStandardizedYield(token).getTokensOut());
         } catch {}
@@ -75,7 +77,7 @@ contract ActionInfoStatic is IPActionInfoStatic {
         if (uint256(state.totalLp) == 0) return res; // market not initialized
 
         // LP PT SY
-        (IStandardizedYield SY, IPPrincipalToken PT, ) = _market.readTokens();
+        (IStandardizedYield SY, IPPrincipalToken PT,) = _market.readTokens();
 
         uint256 userLp = _balanceOf(market, user);
         uint256 userPt = (userLp * uint256(state.totalPt)) / uint256(state.totalLp);
@@ -92,10 +94,11 @@ contract ActionInfoStatic is IPActionInfoStatic {
         res.unclaimedRewards = _zipTokenAmounts(rewardTokens, rewardsOut);
     }
 
-    function _zipTokenAmounts(
-        address[] memory tokens,
-        uint256[] memory amounts
-    ) internal pure returns (TokenAmount[] memory res) {
+    function _zipTokenAmounts(address[] memory tokens, uint256[] memory amounts)
+        internal
+        pure
+        returns (TokenAmount[] memory res)
+    {
         res = new TokenAmount[](tokens.length);
 
         for (uint256 i = 0; i < tokens.length; i++) {