@pendle/core-v2 2.30.1 → 3.0.0-alpha-1

package/contracts/core/StandardizedYield/SYBaseWithRewardsUpg.sol

@@ -20,7 +20,7 @@ abstract contract SYBaseWithRewardsUpg is SYBaseUpg, RewardManager {
      */
     function claimRewards(
         address user
-    ) external virtual override nonReentrant returns (uint256[] memory rewardAmounts) {
+    ) external virtual override nonReentrant whenNotPaused returns (uint256[] memory rewardAmounts) {
         _updateAndDistributeRewards(user);
         rewardAmounts = _doTransferOutRewards(user, user);
 
@@ -48,9 +48,8 @@ abstract contract SYBaseWithRewardsUpg is SYBaseUpg, RewardManager {
         }
     }
 
-    function rewardIndexesCurrent() external override nonReentrant returns (uint256[] memory indexes) {
-        _updateRewardIndex();
-        return rewardIndexesStored();
+    function rewardIndexesCurrent() external override nonReentrant whenNotPaused returns (uint256[] memory indexes) {
+        (, indexes) = _updateRewardIndex();
     }
 
     function rewardIndexesStored() public view virtual override returns (uint256[] memory indexes) {

package/contracts/core/YieldContracts/InterestManagerYT.sol

@@ -56,6 +56,8 @@ abstract contract InterestManagerYT is TokenHelper, IPInterestManagerYT {
 
         _transferOut(SY, treasury, feeAmount);
         _transferOut(SY, user, interestAmount);
+
+        emit CollectInterestFee(feeAmount);
     }
 
     // should only be callable from `_distributeInterestForTwo` & make sure user != address(0) && user != address(this)

package/contracts/core/YieldContracts/PendleYieldToken.sol

@@ -206,6 +206,7 @@ contract PendleYieldToken is IPYieldToken, PendleERC20Permit, RewardManagerAbstr
 
         for (uint256 i = 0; i < tokens.length; i++) {
             rewardsOut[i] = _selfBalance(tokens[i]) - postExpiry.userRewardOwed[tokens[i]];
+            emit CollectRewardFee(tokens[i], rewardsOut[i]);
         }
 
         _transferOut(tokens, treasury, rewardsOut);
@@ -213,6 +214,8 @@ contract PendleYieldToken is IPYieldToken, PendleERC20Permit, RewardManagerAbstr
         interestOut = postExpiry.totalSyInterestForTreasury;
         postExpiry.totalSyInterestForTreasury = 0;
         _transferOut(SY, treasury, interestOut);
+
+        emit CollectInterestFee(interestOut);
     }
 
     /// @notice updates and returns the reward indexes
@@ -450,6 +453,8 @@ contract PendleYieldToken is IPYieldToken, PendleERC20Permit, RewardManagerAbstr
 
             _transferOut(tokens[i], treasury, feeAmount);
             _transferOut(tokens[i], receiver, rewardAmounts[i]);
+
+            emit CollectRewardFee(tokens[i], feeAmount);
         }
     }
 

package/contracts/core/YieldContractsV2/PendleYieldTokenV2.sol

@@ -344,7 +344,7 @@ contract PendleYieldTokenV2 is IPYieldTokenV2, PendleERC20Permit, RewardManager,
         pyIndexLastUpdatedBlock = uint128(block.number);
     }
 
-    function _collectInterest() internal override returns (uint256 accuredAmount, uint256 currentIndex) {
+    function _collectInterest() internal override returns (uint256 accruedAmount, uint256 currentIndex) {
         uint256 prevIndex = _lastCollectedInterestIndex;
         currentIndex = _pyIndexCurrent();
 
@@ -357,7 +357,7 @@ contract PendleYieldTokenV2 is IPYieldTokenV2, PendleERC20Permit, RewardManager,
 
             uint256 totalInterest = _calcInterest(totalSupply(), prevIndex, currentIndex);
             uint256 feeAmount = totalInterest.mulDown(interestFeeRate);
-            accuredAmount = totalInterest - feeAmount;
+            accruedAmount = totalInterest - feeAmount;
 
             _transferOut(SY, treasury, feeAmount);
             _updateSyReserve();

package/contracts/core/libraries/Errors.sol

@@ -49,9 +49,11 @@ library Errors {
     error MarketFactoryMarketExists();
 
     error MarketFactoryLnFeeRateRootTooHigh(uint80 lnFeeRateRoot, uint256 maxLnFeeRateRoot);
+    error MarketFactoryOverriddenFeeTooHigh(uint80 overriddenFee, uint256 marketLnFeeRateRoot);
     error MarketFactoryReserveFeePercentTooHigh(uint8 reserveFeePercent, uint8 maxReserveFeePercent);
     error MarketFactoryZeroTreasury();
     error MarketFactoryInitialAnchorTooLow(int256 initialAnchor, int256 minInitialAnchor);
+    error MFNotPendleMarket(address addr);
 
     // ROUTER
     error RouterInsufficientLpOut(uint256 actualLpOut, uint256 requiredLpOut);

package/contracts/interfaces/IPInterestManagerYT.sol

@@ -2,5 +2,7 @@
 pragma solidity ^0.8.0;
 
 interface IPInterestManagerYT {
+    event CollectInterestFee(uint256 amountInterestFee);
+
     function userInterest(address user) external view returns (uint128 lastPYIndex, uint128 accruedInterest);
 }

package/contracts/interfaces/IPMarketFactoryV3.sol

@@ -0,0 +1,24 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.0;
+
+interface IPMarketFactoryV3 {
+    event SetOverriddenFee(address indexed router, address indexed market, uint80 lnFeeRateRoot);
+
+    event CreateNewMarket(
+        address indexed market,
+        address indexed PT,
+        int256 scalarRoot,
+        int256 initialAnchor,
+        uint256 lnFeeRateRoot
+    );
+
+    event NewTreasuryAndFeeReserve(address indexed treasury, uint8 reserveFeePercent);
+
+    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 overriddenFee, uint8 reserveFeePercent);
+}

package/contracts/interfaces/IPMarketV3.sol

@@ -0,0 +1,8 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.0;
+
+import "./IPMarket.sol";
+
+interface IPMarketV3 is IPMarket {
+    function getNonOverrideLnFeeRateRoot() external view returns (uint80);
+}

package/contracts/interfaces/IPYieldToken.sol

@@ -21,7 +21,7 @@ interface IPYieldToken is IERC20Metadata, IRewardManager, IPInterestManagerYT {
 
     event RedeemInterest(address indexed user, uint256 interestOut);
 
-    event WithdrawFeeToTreasury(uint256[] amountRewardsOut, uint256 syOut);
+    event CollectRewardFee(address indexed rewardToken, uint256 amountRewardFee);
 
     function mintPY(address receiverPT, address receiverYT) external returns (uint256 amountPYOut);
 

package/contracts/oracles/PendleLpOracleLib.sol

@@ -18,7 +18,11 @@ library PendleLpOracleLib {
     function getLpToAssetRate(IPMarket market, uint32 duration) internal view returns (uint256) {
         (uint256 syIndex, uint256 pyIndex) = PendlePtOracleLib.getSYandPYIndexCurrent(market);
         uint256 lpToAssetRateRaw = _getLpToAssetRateRaw(market, duration, pyIndex);
-        return (lpToAssetRateRaw * syIndex) / pyIndex;
+        if (syIndex >= pyIndex) {
+            return lpToAssetRateRaw;
+        } else {
+            return (lpToAssetRateRaw * syIndex) / pyIndex;
+        }
     }
 
     function _getLpToAssetRateRaw(
@@ -28,13 +32,13 @@ library PendleLpOracleLib {
     ) private view returns (uint256 lpToAssetRateRaw) {
         MarketState memory state = market.readState(address(0));
 
-        MarketPreCompute memory comp = state.getMarketPreCompute(PYIndex.wrap(pyIndex), block.timestamp);
-
         int256 totalHypotheticalAsset;
         if (state.expiry <= block.timestamp) {
             // 1 PT = 1 Asset post-expiry
-            totalHypotheticalAsset = state.totalPt + comp.totalAsset;
+            totalHypotheticalAsset = state.totalPt + PYIndexLib.syToAsset(PYIndex.wrap(pyIndex), state.totalSy);
         } else {
+            MarketPreCompute memory comp = state.getMarketPreCompute(PYIndex.wrap(pyIndex), block.timestamp);
+
             (int256 rateOracle, int256 rateHypTrade) = _getPtRatesRaw(market, state, duration);
             int256 cParam = LogExpMath.exp(comp.rateScalar.mulDown((rateOracle - comp.rateAnchor)));
 

package/contracts/oracles/PendlePtOracle.sol

@@ -77,7 +77,8 @@ contract PendlePtOracle is BoringOwnableUpgradeable, IPPtOracle {
     }
 
     function _calcCardinalityRequiredRequired(uint32 duration) internal view returns (uint16) {
-        uint32 cardinalityRequired = (duration * BLOCK_CYCLE_DENOMINATOR) / blockCycleNumerator;
+        uint32 cardinalityRequired =
+            (duration * BLOCK_CYCLE_DENOMINATOR + blockCycleNumerator - 1) / blockCycleNumerator + 1;
         if (cardinalityRequired > type(uint16).max) {
             revert TwapDurationTooLarge(duration, cardinalityRequired);
         }

package/contracts/oracles/PendlePtOracleLib.sol

@@ -16,7 +16,11 @@ library PendlePtOracleLib {
      */
     function getPtToAssetRate(IPMarket market, uint32 duration) internal view returns (uint256) {
         (uint256 syIndex, uint256 pyIndex) = getSYandPYIndexCurrent(market);
-        return (getPtToAssetRateRaw(market, duration) * syIndex) / pyIndex;
+        if (syIndex >= pyIndex) {
+            return getPtToAssetRateRaw(market, duration);
+        } else {
+            return (getPtToAssetRateRaw(market, duration) * syIndex) / pyIndex;
+        }
     }
 
     function getPtToAssetRateRaw(IPMarket market, uint32 duration) internal view returns (uint256) {

package/contracts/router/swap-aggregator/kyberswap/interfaces/IAggregationExecutor.sol

@@ -8,6 +8,10 @@ interface IAggregationExecutor {
     // callbytes per swap sequence
     function swapSingleSequence(bytes calldata data) external;
 
-    function finalTransactionProcessing(address tokenIn, address tokenOut, address to, bytes calldata destTokenFeeData)
-        external;
+    function finalTransactionProcessing(
+        address tokenIn,
+        address tokenOut,
+        address to,
+        bytes calldata destTokenFeeData
+    ) external;
 }

package/contracts/router/swap-aggregator/kyberswap/interfaces/IAggregationExecutorOptimistic.sol

@@ -50,8 +50,12 @@ interface IAggregationExecutorOptimistic {
         bytes memory positiveSlippageData
     ) external payable;
 
-    function finalTransactionProcessing(address tokenIn, address tokenOut, address to, bytes calldata destTokenFeeData)
-        external;
+    function finalTransactionProcessing(
+        address tokenIn,
+        address tokenOut,
+        address to,
+        bytes calldata destTokenFeeData
+    ) external;
 
     function updateExecutor(bytes4 functionSelector, address executor) external;
 

package/contracts/router/swap-aggregator/kyberswap/interfaces/IExecutorHelper.sol

@@ -240,10 +240,7 @@ interface IExecutorHelper {
 
     function executeKSClassic(bytes memory data, uint256 flagsAndPrevAmountOut) external payable returns (uint256);
 
-    function executeUniV3KSElastic(bytes memory data, uint256 flagsAndPrevAmountOut)
-        external
-        payable
-        returns (uint256);
+    function executeUniV3KSElastic(bytes memory data, uint256 flagsAndPrevAmountOut) external payable returns (uint256);
 
     function executeRfq(bytes memory data, uint256 flagsAndPrevAmountOut) external payable returns (uint256);
 
@@ -271,10 +268,10 @@ interface IExecutorHelper {
 
     function executeCamelot(bytes memory data, uint256 flagsAndPrevAmountOut) external payable returns (uint256);
 
-    function executeKyberLimitOrder(bytes memory data, uint256 flagsAndPrevAmountOut)
-        external
-        payable
-        returns (uint256);
+    function executeKyberLimitOrder(
+        bytes memory data,
+        uint256 flagsAndPrevAmountOut
+    ) external payable returns (uint256);
 
     function executeMaverick(bytes memory data, uint256 flagsAndPrevAmountOut) external payable returns (uint256);
 
@@ -282,10 +279,7 @@ interface IExecutorHelper {
 
     function executeAlgebraV1(bytes memory data, uint256 flagsAndPrevAmountOut) external payable returns (uint256);
 
-    function executeBalancerBatch(bytes memory data, uint256 flagsAndPrevAmountOut)
-        external
-        payable
-        returns (uint256);
+    function executeBalancerBatch(bytes memory data, uint256 flagsAndPrevAmountOut) external payable returns (uint256);
 
     function executeWombat(bytes memory data, uint256 flagsAndPrevAmountOut) external payable returns (uint256);
 
@@ -297,10 +291,10 @@ interface IExecutorHelper {
 
     function executeTraderJoeV2(bytes memory data, uint256 flagsAndPrevAmountOut) external payable returns (uint256);
 
-    function executePancakeStableSwap(bytes memory data, uint256 flagsAndPrevAmountOut)
-        external
-        payable
-        returns (uint256);
+    function executePancakeStableSwap(
+        bytes memory data,
+        uint256 flagsAndPrevAmountOut
+    ) external payable returns (uint256);
 
     function executeLevelFiV2(bytes memory data, uint256 flagsAndPrevAmountOut) external payable returns (uint256);
 

package/contracts/router/swap-aggregator/kyberswap/l1-contracts/ScalingDataLib.sol

@@ -10,53 +10,51 @@ library ScalingDataLib {
         return abi.encode(uniSwap);
     }
 
-    function newStableSwap(bytes memory data, uint256 oldAmount, uint256 newAmount)
-        internal
-        pure
-        returns (bytes memory)
-    {
+    function newStableSwap(
+        bytes memory data,
+        uint256 oldAmount,
+        uint256 newAmount
+    ) internal pure returns (bytes memory) {
         IExecutorHelper.StableSwap memory stableSwap = abi.decode(data, (IExecutorHelper.StableSwap));
         stableSwap.dx = (stableSwap.dx * newAmount) / oldAmount;
         return abi.encode(stableSwap);
     }
 
-    function newCurveSwap(bytes memory data, uint256 oldAmount, uint256 newAmount)
-        internal
-        pure
-        returns (bytes memory)
-    {
+    function newCurveSwap(
+        bytes memory data,
+        uint256 oldAmount,
+        uint256 newAmount
+    ) internal pure returns (bytes memory) {
         IExecutorHelper.CurveSwap memory curveSwap = abi.decode(data, (IExecutorHelper.CurveSwap));
         curveSwap.dx = (curveSwap.dx * newAmount) / oldAmount;
         return abi.encode(curveSwap);
     }
 
-    function newKyberDMM(bytes memory data, uint256 oldAmount, uint256 newAmount)
-        internal
-        pure
-        returns (bytes memory)
-    {
+    function newKyberDMM(bytes memory data, uint256 oldAmount, uint256 newAmount) internal pure returns (bytes memory) {
         IExecutorHelper.UniSwap memory kyberDMMSwap = abi.decode(data, (IExecutorHelper.UniSwap));
         kyberDMMSwap.collectAmount = (kyberDMMSwap.collectAmount * newAmount) / oldAmount;
         return abi.encode(kyberDMMSwap);
     }
 
-    function newUniV3ProMM(bytes memory data, uint256 oldAmount, uint256 newAmount)
-        internal
-        pure
-        returns (bytes memory)
-    {
-        IExecutorHelper.UniswapV3KSElastic memory uniSwapV3ProMM =
-            abi.decode(data, (IExecutorHelper.UniswapV3KSElastic));
+    function newUniV3ProMM(
+        bytes memory data,
+        uint256 oldAmount,
+        uint256 newAmount
+    ) internal pure returns (bytes memory) {
+        IExecutorHelper.UniswapV3KSElastic memory uniSwapV3ProMM = abi.decode(
+            data,
+            (IExecutorHelper.UniswapV3KSElastic)
+        );
         uniSwapV3ProMM.swapAmount = (uniSwapV3ProMM.swapAmount * newAmount) / oldAmount;
 
         return abi.encode(uniSwapV3ProMM);
     }
 
-    function newBalancerV2(bytes memory data, uint256 oldAmount, uint256 newAmount)
-        internal
-        pure
-        returns (bytes memory)
-    {
+    function newBalancerV2(
+        bytes memory data,
+        uint256 oldAmount,
+        uint256 newAmount
+    ) internal pure returns (bytes memory) {
         IExecutorHelper.BalancerV2 memory balancerV2 = abi.decode(data, (IExecutorHelper.BalancerV2));
         balancerV2.amount = (balancerV2.amount * newAmount) / oldAmount;
         return abi.encode(balancerV2);
@@ -68,11 +66,11 @@ library ScalingDataLib {
         return abi.encode(dodo);
     }
 
-    function newVelodrome(bytes memory data, uint256 oldAmount, uint256 newAmount)
-        internal
-        pure
-        returns (bytes memory)
-    {
+    function newVelodrome(
+        bytes memory data,
+        uint256 oldAmount,
+        uint256 newAmount
+    ) internal pure returns (bytes memory) {
         IExecutorHelper.UniSwap memory velodrome = abi.decode(data, (IExecutorHelper.UniSwap));
         velodrome.collectAmount = (velodrome.collectAmount * newAmount) / oldAmount;
         return abi.encode(velodrome);
@@ -84,11 +82,11 @@ library ScalingDataLib {
         return abi.encode(gmx);
     }
 
-    function newSynthetix(bytes memory data, uint256 oldAmount, uint256 newAmount)
-        internal
-        pure
-        returns (bytes memory)
-    {
+    function newSynthetix(
+        bytes memory data,
+        uint256 oldAmount,
+        uint256 newAmount
+    ) internal pure returns (bytes memory) {
         IExecutorHelper.Synthetix memory synthetix = abi.decode(data, (IExecutorHelper.Synthetix));
         synthetix.sourceAmount = (synthetix.sourceAmount * newAmount) / oldAmount;
         return abi.encode(synthetix);
@@ -100,21 +98,17 @@ library ScalingDataLib {
         return abi.encode(camelot);
     }
 
-    function newPlatypus(bytes memory data, uint256 oldAmount, uint256 newAmount)
-        internal
-        pure
-        returns (bytes memory)
-    {
+    function newPlatypus(bytes memory data, uint256 oldAmount, uint256 newAmount) internal pure returns (bytes memory) {
         IExecutorHelper.Platypus memory platypus = abi.decode(data, (IExecutorHelper.Platypus));
         platypus.collectAmount = (platypus.collectAmount * newAmount) / oldAmount;
         return abi.encode(platypus);
     }
 
-    function newWrappedstETHSwap(bytes memory data, uint256 oldAmount, uint256 newAmount)
-        internal
-        pure
-        returns (bytes memory)
-    {
+    function newWrappedstETHSwap(
+        bytes memory data,
+        uint256 oldAmount,
+        uint256 newAmount
+    ) internal pure returns (bytes memory) {
         IExecutorHelper.WSTETH memory wstEthData = abi.decode(data, (IExecutorHelper.WSTETH));
         wstEthData.amount = (wstEthData.amount * newAmount) / oldAmount;
         return abi.encode(wstEthData);
@@ -132,51 +126,43 @@ library ScalingDataLib {
         return abi.encode(frax);
     }
 
-    function newStETHSwap(bytes memory data, uint256 oldAmount, uint256 newAmount)
-        internal
-        pure
-        returns (bytes memory)
-    {
+    function newStETHSwap(
+        bytes memory data,
+        uint256 oldAmount,
+        uint256 newAmount
+    ) internal pure returns (bytes memory) {
         uint256 amount = abi.decode(data, (uint256));
         amount = (amount * newAmount) / oldAmount;
         return abi.encode(amount);
     }
 
-    function newMaverick(bytes memory data, uint256 oldAmount, uint256 newAmount)
-        internal
-        pure
-        returns (bytes memory)
-    {
+    function newMaverick(bytes memory data, uint256 oldAmount, uint256 newAmount) internal pure returns (bytes memory) {
         IExecutorHelper.Maverick memory maverick = abi.decode(data, (IExecutorHelper.Maverick));
         maverick.swapAmount = (maverick.swapAmount * newAmount) / oldAmount;
         return abi.encode(maverick);
     }
 
-    function newSyncSwap(bytes memory data, uint256 oldAmount, uint256 newAmount)
-        internal
-        pure
-        returns (bytes memory)
-    {
+    function newSyncSwap(bytes memory data, uint256 oldAmount, uint256 newAmount) internal pure returns (bytes memory) {
         IExecutorHelper.SyncSwap memory syncSwap = abi.decode(data, (IExecutorHelper.SyncSwap));
         syncSwap.collectAmount = (syncSwap.collectAmount * newAmount) / oldAmount;
         return abi.encode(syncSwap);
     }
 
-    function newAlgebraV1(bytes memory data, uint256 oldAmount, uint256 newAmount)
-        internal
-        pure
-        returns (bytes memory)
-    {
+    function newAlgebraV1(
+        bytes memory data,
+        uint256 oldAmount,
+        uint256 newAmount
+    ) internal pure returns (bytes memory) {
         IExecutorHelper.AlgebraV1 memory algebraV1Swap = abi.decode(data, (IExecutorHelper.AlgebraV1));
         algebraV1Swap.swapAmount = (algebraV1Swap.swapAmount * newAmount) / oldAmount;
         return abi.encode(algebraV1Swap);
     }
 
-    function newBalancerBatch(bytes memory data, uint256 oldAmount, uint256 newAmount)
-        internal
-        pure
-        returns (bytes memory)
-    {
+    function newBalancerBatch(
+        bytes memory data,
+        uint256 oldAmount,
+        uint256 newAmount
+    ) internal pure returns (bytes memory) {
         IExecutorHelper.BalancerBatch memory balancerBatch = abi.decode(data, (IExecutorHelper.BalancerBatch));
         balancerBatch.amountIn = (balancerBatch.amountIn * newAmount) / oldAmount;
         return abi.encode(balancerBatch);
@@ -194,24 +180,25 @@ library ScalingDataLib {
         return abi.encode(iZi);
     }
 
-    function newTraderJoeV2(bytes memory data, uint256 oldAmount, uint256 newAmount)
-        internal
-        pure
-        returns (bytes memory)
-    {
+    function newTraderJoeV2(
+        bytes memory data,
+        uint256 oldAmount,
+        uint256 newAmount
+    ) internal pure returns (bytes memory) {
         IExecutorHelper.TraderJoeV2 memory traderJoe = abi.decode(data, (IExecutorHelper.TraderJoeV2));
 
         // traderJoe.collectAmount; // most significant 1 bit is to determine whether pool is v2.1, else v2.0
-        traderJoe.collectAmount = (traderJoe.collectAmount & (1 << 255))
-            | ((uint256((traderJoe.collectAmount << 1) >> 1) * newAmount) / oldAmount);
+        traderJoe.collectAmount =
+            (traderJoe.collectAmount & (1 << 255)) |
+            ((uint256((traderJoe.collectAmount << 1) >> 1) * newAmount) / oldAmount);
         return abi.encode(traderJoe);
     }
 
-    function newLevelFiV2(bytes memory data, uint256 oldAmount, uint256 newAmount)
-        internal
-        pure
-        returns (bytes memory)
-    {
+    function newLevelFiV2(
+        bytes memory data,
+        uint256 oldAmount,
+        uint256 newAmount
+    ) internal pure returns (bytes memory) {
         IExecutorHelper.LevelFiV2 memory levelFiV2 = abi.decode(data, (IExecutorHelper.LevelFiV2));
         levelFiV2.amountIn = (levelFiV2.amountIn * newAmount) / oldAmount;
         return abi.encode(levelFiV2);
@@ -229,21 +216,21 @@ library ScalingDataLib {
         return abi.encode(vooi);
     }
 
-    function newVelocoreV2(bytes memory data, uint256 oldAmount, uint256 newAmount)
-        internal
-        pure
-        returns (bytes memory)
-    {
+    function newVelocoreV2(
+        bytes memory data,
+        uint256 oldAmount,
+        uint256 newAmount
+    ) internal pure returns (bytes memory) {
         IExecutorHelper.VelocoreV2 memory velocorev2 = abi.decode(data, (IExecutorHelper.VelocoreV2));
         velocorev2.amount = (velocorev2.amount * newAmount) / oldAmount;
         return abi.encode(velocorev2);
     }
 
-    function newMaticMigrate(bytes memory data, uint256 oldAmount, uint256 newAmount)
-        internal
-        pure
-        returns (bytes memory)
-    {
+    function newMaticMigrate(
+        bytes memory data,
+        uint256 oldAmount,
+        uint256 newAmount
+    ) internal pure returns (bytes memory) {
         IExecutorHelper.MaticMigrate memory maticMigrate = abi.decode(data, (IExecutorHelper.MaticMigrate));
         maticMigrate.amount = (maticMigrate.amount * newAmount) / oldAmount;
         return abi.encode(maticMigrate);

package/contracts/router/swap-aggregator/kyberswap/l2-contracts/BytesHelper.sol

@@ -17,11 +17,12 @@ library BytesHelper {
         return write16Bytes(original, index, bytes16(value));
     }
 
-    function write16Bytes(bytes memory original, uint256 index, uint256 value, string memory errorMsg)
-        internal
-        pure
-        returns (bytes memory)
-    {
+    function write16Bytes(
+        bytes memory original,
+        uint256 index,
+        uint256 value,
+        string memory errorMsg
+    ) internal pure returns (bytes memory) {
         require(value <= type(uint128).max, string(abi.encodePacked(errorMsg, "/Exceed compressed type range")));
         return write16Bytes(original, index, uint128(value));
     }

package/contracts/router/swap-aggregator/kyberswap/l2-contracts/CalldataReader.sol

@@ -8,17 +8,21 @@ library CalldataReader {
     /// @param length length from starting position
     /// @return retVal value of the bytes
     /// @return (the next position to read from)
-    function _calldataVal(bytes memory data, uint256 startByte, uint256 length)
-        internal
-        pure
-        returns (bytes memory retVal, uint256)
-    {
+    function _calldataVal(
+        bytes memory data,
+        uint256 startByte,
+        uint256 length
+    ) internal pure returns (bytes memory retVal, uint256) {
         require(length + startByte <= data.length, "calldataVal trying to read beyond data size");
         uint256 loops = (length + 31) / 32;
         assembly {
             let m := mload(0x40)
             mstore(m, length)
-            for { let i := 0 } lt(i, loops) { i := add(1, i) } {
+            for {
+                let i := 0
+            } lt(i, loops) {
+                i := add(1, i)
+            } {
                 mstore(add(m, mul(32, add(1, i))), mload(add(data, add(mul(32, add(1, i)), startByte))))
             }
             mstore(0x40, add(m, add(32, length)))
@@ -98,11 +102,10 @@ library CalldataReader {
     }
 
     /// @dev length of bytes array is currently limited to uint8
-    function _readBytesArray(bytes memory data, uint256 startByte)
-        internal
-        pure
-        returns (bytes[] memory bytesArray, uint256)
-    {
+    function _readBytesArray(
+        bytes memory data,
+        uint256 startByte
+    ) internal pure returns (bytes[] memory bytesArray, uint256) {
         bytes memory ret;
         (ret, startByte) = _calldataVal(data, startByte, 1);
         uint256 length = uint256(uint8(bytes1(ret)));
@@ -114,11 +117,10 @@ library CalldataReader {
     }
 
     /// @dev length of address array is currently limited to uint8 to save bytes
-    function _readAddressArray(bytes memory data, uint256 startByte)
-        internal
-        pure
-        returns (address[] memory addrs, uint256)
-    {
+    function _readAddressArray(
+        bytes memory data,
+        uint256 startByte
+    ) internal pure returns (address[] memory addrs, uint256) {
         bytes memory ret;
         (ret, startByte) = _calldataVal(data, startByte, 1);
         uint256 length = uint256(uint8(bytes1(ret)));
@@ -131,11 +133,10 @@ library CalldataReader {
 
     /// @dev length of uint array is currently limited to uint8 to save bytes
     /// @dev same as _readUint128AsUint256, only use when sure that value never exceed uint128
-    function _readUint128ArrayAsUint256Array(bytes memory data, uint256 startByte)
-        internal
-        pure
-        returns (uint256[] memory, uint256)
-    {
+    function _readUint128ArrayAsUint256Array(
+        bytes memory data,
+        uint256 startByte
+    ) internal pure returns (uint256[] memory, uint256) {
         bytes memory ret;
         (ret, startByte) = _calldataVal(data, startByte, 1);
         uint256 length = uint256(uint8(bytes1(ret)));