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

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

@@ -1,19 +1,16 @@
 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8.0;
 
-import { IMetaAggregationRouterV2 } from "../interfaces/IMetaAggregationRouterV2.sol";
-import { IAggregationExecutorOptimistic as IExecutorHelperL2 } from "../interfaces/IAggregationExecutorOptimistic.sol";
-import { IExecutorHelper as IExecutorHelperL1 } from "../interfaces/IExecutorHelper.sol";
+import {IMetaAggregationRouterV2} from "../interfaces/IMetaAggregationRouterV2.sol";
+import {IAggregationExecutorOptimistic as IExecutorHelperL2} from "../interfaces/IAggregationExecutorOptimistic.sol";
+import {IExecutorHelper as IExecutorHelperL1} from "../interfaces/IExecutorHelper.sol";
 
 library CalldataWriter {
     function writeSimpleSwapData(
         IMetaAggregationRouterV2.SimpleSwapData memory simpleSwapData
     ) internal pure returns (bytes memory shortData) {
         shortData = bytes.concat(shortData, _writeAddressArray(simpleSwapData.firstPools));
-        shortData = bytes.concat(
-            shortData,
-            _writeUint256ArrayAsUint128Array(simpleSwapData.firstSwapAmounts)
-        );
+        shortData = bytes.concat(shortData, _writeUint256ArrayAsUint128Array(simpleSwapData.firstSwapAmounts));
         shortData = bytes.concat(shortData, _writeBytesArray(simpleSwapData.swapDatas));
         shortData = bytes.concat(shortData, bytes16(uint128(simpleSwapData.deadline)));
         shortData = bytes.concat(shortData, _writeBytes(simpleSwapData.positiveSlippageData));
@@ -78,9 +75,7 @@ library CalldataWriter {
         return data;
     }
 
-    function _writeUint256ArrayAsUint128Array(
-        uint256[] memory us
-    ) internal pure returns (bytes memory data) {
+    function _writeUint256ArrayAsUint128Array(uint256[] memory us) internal pure returns (bytes memory data) {
         uint8 length = uint8(us.length);
         data = bytes.concat(data, bytes1(length));
         for (uint8 i = 0; i < length; ++i) {
@@ -96,9 +91,7 @@ library CalldataWriter {
         return data;
     }
 
-    function _writeBytesArray(
-        bytes[] memory bytesArray
-    ) internal pure returns (bytes memory data) {
+    function _writeBytesArray(bytes[] memory bytesArray) internal pure returns (bytes memory data) {
         uint8 x = uint8(bytesArray.length);
         data = bytes.concat(data, bytes1(x));
         for (uint8 i; i < x; ++i) {
@@ -109,9 +102,7 @@ library CalldataWriter {
         return data;
     }
 
-    function _writeBytes32Array(
-        bytes32[] memory bytesArray
-    ) internal pure returns (bytes memory data) {
+    function _writeBytes32Array(bytes32[] memory bytesArray) internal pure returns (bytes memory data) {
         uint8 x = uint8(bytesArray.length);
         data = bytes.concat(data, bytes1(x));
         for (uint8 i; i < x; ++i) {
@@ -120,9 +111,7 @@ library CalldataWriter {
         return data;
     }
 
-    function _writeSwap(
-        IExecutorHelperL2.Swap memory swap
-    ) internal pure returns (bytes memory shortData) {
+    function _writeSwap(IExecutorHelperL2.Swap memory swap) internal pure returns (bytes memory shortData) {
         shortData = bytes.concat(shortData, _writeBytes(swap.data));
         shortData = bytes.concat(shortData, bytes1(uint8(uint32(swap.functionSelector))));
     }

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

@@ -26,11 +26,10 @@ library Common {
         return (recipient, startByte);
     }
 
-    function _readBytes32Array(bytes memory data, uint256 startByte)
-        internal
-        pure
-        returns (bytes32[] memory bytesArray, uint256)
-    {
+    function _readBytes32Array(
+        bytes memory data,
+        uint256 startByte
+    ) internal pure returns (bytes32[] memory bytesArray, uint256) {
         bytes memory ret;
         (ret, startByte) = data._calldataVal(startByte, 1);
         uint256 length = uint256(uint8(bytes1(ret)));

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

@@ -14,37 +14,37 @@ library DexScaler {
     using CalldataReader for bytes;
     using Common for bytes;
 
-    function scaleUniSwap(bytes memory data, uint256 oldAmount, uint256 newAmount)
-        internal
-        pure
-        returns (bytes memory)
-    {
+    function scaleUniSwap(
+        bytes memory data,
+        uint256 oldAmount,
+        uint256 newAmount
+    ) internal pure returns (bytes memory) {
         uint256 startByte;
         // decode
         (, startByte) = data._readPool(startByte);
         (, startByte) = data._readRecipient(startByte);
-        (uint256 swapAmount,) = data._readUint128AsUint256(startByte);
+        (uint256 swapAmount, ) = data._readUint128AsUint256(startByte);
         return data.write16Bytes(startByte, oldAmount == 0 ? 0 : (swapAmount * newAmount) / oldAmount, "scaleUniSwap");
     }
 
-    function scaleStableSwap(bytes memory data, uint256 oldAmount, uint256 newAmount)
-        internal
-        pure
-        returns (bytes memory)
-    {
+    function scaleStableSwap(
+        bytes memory data,
+        uint256 oldAmount,
+        uint256 newAmount
+    ) internal pure returns (bytes memory) {
         uint256 startByte;
         (, startByte) = data._readPool(startByte);
         (, startByte) = data._readUint8(startByte);
-        (uint256 swapAmount,) = data._readUint128AsUint256(startByte);
+        (uint256 swapAmount, ) = data._readUint128AsUint256(startByte);
         return
             data.write16Bytes(startByte, oldAmount == 0 ? 0 : (swapAmount * newAmount) / oldAmount, "scaleStableSwap");
     }
 
-    function scaleCurveSwap(bytes memory data, uint256 oldAmount, uint256 newAmount)
-        internal
-        pure
-        returns (bytes memory)
-    {
+    function scaleCurveSwap(
+        bytes memory data,
+        uint256 oldAmount,
+        uint256 newAmount
+    ) internal pure returns (bytes memory) {
         uint256 startByte;
         bool canGetIndex;
         (canGetIndex, startByte) = data._readBool(0);
@@ -54,34 +54,38 @@ library DexScaler {
             (, startByte) = data._readUint8(startByte);
         }
         (, startByte) = data._readUint8(startByte);
-        (uint256 swapAmount,) = data._readUint128AsUint256(startByte);
-        return data.write16Bytes(startByte, oldAmount == 0 ? 0 : (swapAmount * newAmount) / oldAmount, "scaleCurveSwap");
+        (uint256 swapAmount, ) = data._readUint128AsUint256(startByte);
+        return
+            data.write16Bytes(startByte, oldAmount == 0 ? 0 : (swapAmount * newAmount) / oldAmount, "scaleCurveSwap");
     }
 
-    function scaleUniswapV3KSElastic(bytes memory data, uint256 oldAmount, uint256 newAmount)
-        internal
-        pure
-        returns (bytes memory)
-    {
+    function scaleUniswapV3KSElastic(
+        bytes memory data,
+        uint256 oldAmount,
+        uint256 newAmount
+    ) internal pure returns (bytes memory) {
         uint256 startByte;
         (, startByte) = data._readRecipient(startByte);
         (, startByte) = data._readPool(startByte);
-        (uint256 swapAmount,) = data._readUint128AsUint256(startByte);
-        return data.write16Bytes(
-            startByte, oldAmount == 0 ? 0 : (swapAmount * newAmount) / oldAmount, "scaleUniswapV3KSElastic"
-        );
+        (uint256 swapAmount, ) = data._readUint128AsUint256(startByte);
+        return
+            data.write16Bytes(
+                startByte,
+                oldAmount == 0 ? 0 : (swapAmount * newAmount) / oldAmount,
+                "scaleUniswapV3KSElastic"
+            );
     }
 
-    function scaleBalancerV2(bytes memory data, uint256 oldAmount, uint256 newAmount)
-        internal
-        pure
-        returns (bytes memory)
-    {
+    function scaleBalancerV2(
+        bytes memory data,
+        uint256 oldAmount,
+        uint256 newAmount
+    ) internal pure returns (bytes memory) {
         uint256 startByte;
         (, startByte) = data._readPool(startByte);
         (, startByte) = data._readBytes32(startByte);
         (, startByte) = data._readUint8(startByte);
-        (uint256 swapAmount,) = data._readUint128AsUint256(startByte);
+        (uint256 swapAmount, ) = data._readUint128AsUint256(startByte);
         return
             data.write16Bytes(startByte, oldAmount == 0 ? 0 : (swapAmount * newAmount) / oldAmount, "scaleBalancerV2");
     }
@@ -90,7 +94,7 @@ library DexScaler {
         uint256 startByte;
         (, startByte) = data._readRecipient(startByte);
         (, startByte) = data._readPool(startByte);
-        (uint256 swapAmount,) = data._readUint128AsUint256(startByte);
+        (uint256 swapAmount, ) = data._readUint128AsUint256(startByte);
         return data.write16Bytes(startByte, oldAmount == 0 ? 0 : (swapAmount * newAmount) / oldAmount, "scaleDODO");
     }
 
@@ -101,15 +105,15 @@ library DexScaler {
 
         (, startByte) = data._readAddress(startByte);
 
-        (uint256 swapAmount,) = data._readUint128AsUint256(startByte);
+        (uint256 swapAmount, ) = data._readUint128AsUint256(startByte);
         return data.write16Bytes(startByte, oldAmount == 0 ? 0 : (swapAmount * newAmount) / oldAmount, "scaleGMX");
     }
 
-    function scaleSynthetix(bytes memory data, uint256 oldAmount, uint256 newAmount)
-        internal
-        pure
-        returns (bytes memory)
-    {
+    function scaleSynthetix(
+        bytes memory data,
+        uint256 oldAmount,
+        uint256 newAmount
+    ) internal pure returns (bytes memory) {
         uint256 startByte;
 
         // decode
@@ -118,35 +122,40 @@ library DexScaler {
         (, startByte) = data._readAddress(startByte);
         (, startByte) = data._readBytes32(startByte);
 
-        (uint256 swapAmount,) = data._readUint128AsUint256(startByte);
-        return data.write16Bytes(startByte, oldAmount == 0 ? 0 : (swapAmount * newAmount) / oldAmount, "scaleSynthetix");
+        (uint256 swapAmount, ) = data._readUint128AsUint256(startByte);
+        return
+            data.write16Bytes(startByte, oldAmount == 0 ? 0 : (swapAmount * newAmount) / oldAmount, "scaleSynthetix");
     }
 
-    function scaleWrappedstETH(bytes memory data, uint256 oldAmount, uint256 newAmount)
-        internal
-        pure
-        returns (bytes memory)
-    {
+    function scaleWrappedstETH(
+        bytes memory data,
+        uint256 oldAmount,
+        uint256 newAmount
+    ) internal pure returns (bytes memory) {
         uint256 startByte;
 
         // decode
         (, startByte) = data._readPool(startByte);
 
-        (uint256 swapAmount,) = data._readUint128AsUint256(startByte);
+        (uint256 swapAmount, ) = data._readUint128AsUint256(startByte);
         return
-            data.write16Bytes(startByte, oldAmount == 0 ? 0 : (swapAmount * newAmount) / oldAmount, "scaleWrappedstETH");
+            data.write16Bytes(
+                startByte,
+                oldAmount == 0 ? 0 : (swapAmount * newAmount) / oldAmount,
+                "scaleWrappedstETH"
+            );
     }
 
     function scaleStETH(bytes memory data, uint256 oldAmount, uint256 newAmount) internal pure returns (bytes memory) {
-        (uint256 swapAmount,) = data._readUint128AsUint256(0);
+        (uint256 swapAmount, ) = data._readUint128AsUint256(0);
         return data.write16Bytes(0, oldAmount == 0 ? 0 : (swapAmount * newAmount) / oldAmount, "scaleStETH");
     }
 
-    function scalePlatypus(bytes memory data, uint256 oldAmount, uint256 newAmount)
-        internal
-        pure
-        returns (bytes memory)
-    {
+    function scalePlatypus(
+        bytes memory data,
+        uint256 oldAmount,
+        uint256 newAmount
+    ) internal pure returns (bytes memory) {
         uint256 startByte;
 
         // decode
@@ -156,7 +165,7 @@ library DexScaler {
 
         (, startByte) = data._readRecipient(startByte);
 
-        (uint256 swapAmount,) = data._readUint128AsUint256(startByte);
+        (uint256 swapAmount, ) = data._readUint128AsUint256(startByte);
         return data.write16Bytes(startByte, oldAmount == 0 ? 0 : (swapAmount * newAmount) / oldAmount, "scalePlatypus");
     }
 
@@ -168,16 +177,16 @@ library DexScaler {
 
         (, startByte) = data._readAddress(startByte);
 
-        (uint256 swapAmount,) = data._readUint128AsUint256(startByte);
+        (uint256 swapAmount, ) = data._readUint128AsUint256(startByte);
 
         return data.write16Bytes(startByte, oldAmount == 0 ? 0 : (swapAmount * newAmount) / oldAmount, "scalePSM");
     }
 
-    function scaleMaverick(bytes memory data, uint256 oldAmount, uint256 newAmount)
-        internal
-        pure
-        returns (bytes memory)
-    {
+    function scaleMaverick(
+        bytes memory data,
+        uint256 oldAmount,
+        uint256 newAmount
+    ) internal pure returns (bytes memory) {
         uint256 startByte;
 
         // decode
@@ -187,15 +196,15 @@ library DexScaler {
 
         (, startByte) = data._readRecipient(startByte);
 
-        (uint256 swapAmount,) = data._readUint128AsUint256(startByte);
+        (uint256 swapAmount, ) = data._readUint128AsUint256(startByte);
         return data.write16Bytes(startByte, oldAmount == 0 ? 0 : (swapAmount * newAmount) / oldAmount, "scaleMaverick");
     }
 
-    function scaleSyncSwap(bytes memory data, uint256 oldAmount, uint256 newAmount)
-        internal
-        pure
-        returns (bytes memory)
-    {
+    function scaleSyncSwap(
+        bytes memory data,
+        uint256 oldAmount,
+        uint256 newAmount
+    ) internal pure returns (bytes memory) {
         uint256 startByte;
 
         // decode
@@ -204,15 +213,15 @@ library DexScaler {
 
         (, startByte) = data._readAddress(startByte);
 
-        (uint256 swapAmount,) = data._readUint128AsUint256(startByte);
+        (uint256 swapAmount, ) = data._readUint128AsUint256(startByte);
         return data.write16Bytes(startByte, oldAmount == 0 ? 0 : (swapAmount * newAmount) / oldAmount, "scaleSyncSwap");
     }
 
-    function scaleAlgebraV1(bytes memory data, uint256 oldAmount, uint256 newAmount)
-        internal
-        pure
-        returns (bytes memory)
-    {
+    function scaleAlgebraV1(
+        bytes memory data,
+        uint256 oldAmount,
+        uint256 newAmount
+    ) internal pure returns (bytes memory) {
         uint256 startByte;
 
         (, startByte) = data._readRecipient(startByte);
@@ -221,16 +230,17 @@ library DexScaler {
 
         (, startByte) = data._readAddress(startByte);
 
-        (uint256 swapAmount,) = data._readUint128AsUint256(startByte);
+        (uint256 swapAmount, ) = data._readUint128AsUint256(startByte);
 
-        return data.write16Bytes(startByte, oldAmount == 0 ? 0 : (swapAmount * newAmount) / oldAmount, "scaleAlgebraV1");
+        return
+            data.write16Bytes(startByte, oldAmount == 0 ? 0 : (swapAmount * newAmount) / oldAmount, "scaleAlgebraV1");
     }
 
-    function scaleBalancerBatch(bytes memory data, uint256 oldAmount, uint256 newAmount)
-        internal
-        pure
-        returns (bytes memory)
-    {
+    function scaleBalancerBatch(
+        bytes memory data,
+        uint256 oldAmount,
+        uint256 newAmount
+    ) internal pure returns (bytes memory) {
         uint256 startByte;
 
         // decode
@@ -240,32 +250,31 @@ library DexScaler {
         (, startByte) = data._readAddressArray(startByte);
         (, startByte) = data._readBytesArray(startByte);
 
-        (uint256 swapAmount,) = data._readUint128AsUint256(startByte);
-        return data.write16Bytes(
-            startByte, oldAmount == 0 ? 0 : (swapAmount * newAmount) / oldAmount, "scaleBalancerBatch"
-        );
+        (uint256 swapAmount, ) = data._readUint128AsUint256(startByte);
+        return
+            data.write16Bytes(
+                startByte,
+                oldAmount == 0 ? 0 : (swapAmount * newAmount) / oldAmount,
+                "scaleBalancerBatch"
+            );
     }
 
-    function scaleMantis(bytes memory data, uint256 oldAmount, uint256 newAmount)
-        internal
-        pure
-        returns (bytes memory)
-    {
+    function scaleMantis(bytes memory data, uint256 oldAmount, uint256 newAmount) internal pure returns (bytes memory) {
         uint256 startByte;
 
         (, startByte) = data._readPool(startByte); // pool
 
         (, startByte) = data._readAddress(startByte); // tokenOut
 
-        (uint256 swapAmount,) = data._readUint128AsUint256(startByte); // amount
+        (uint256 swapAmount, ) = data._readUint128AsUint256(startByte); // amount
         return data.write16Bytes(startByte, oldAmount == 0 ? 0 : (swapAmount * newAmount) / oldAmount, "scaleMantis");
     }
 
-    function scaleIziSwap(bytes memory data, uint256 oldAmount, uint256 newAmount)
-        internal
-        pure
-        returns (bytes memory)
-    {
+    function scaleIziSwap(
+        bytes memory data,
+        uint256 oldAmount,
+        uint256 newAmount
+    ) internal pure returns (bytes memory) {
         uint256 startByte;
 
         (, startByte) = data._readPool(startByte); // pool
@@ -275,15 +284,15 @@ library DexScaler {
         // recipient
         (, startByte) = data._readRecipient(startByte);
 
-        (uint256 swapAmount,) = data._readUint128AsUint256(startByte); // amount
+        (uint256 swapAmount, ) = data._readUint128AsUint256(startByte); // amount
         return data.write16Bytes(startByte, oldAmount == 0 ? 0 : (swapAmount * newAmount) / oldAmount, "scaleIziSwap");
     }
 
-    function scaleTraderJoeV2(bytes memory data, uint256 oldAmount, uint256 newAmount)
-        internal
-        pure
-        returns (bytes memory)
-    {
+    function scaleTraderJoeV2(
+        bytes memory data,
+        uint256 oldAmount,
+        uint256 newAmount
+    ) internal pure returns (bytes memory) {
         uint256 startByte;
 
         // recipient
@@ -295,31 +304,28 @@ library DexScaler {
 
         (, startByte) = data._readBool(startByte); // isV2
 
-        (uint256 swapAmount,) = data._readUint128AsUint256(startByte); // amount
+        (uint256 swapAmount, ) = data._readUint128AsUint256(startByte); // amount
         return
             data.write16Bytes(startByte, oldAmount == 0 ? 0 : (swapAmount * newAmount) / oldAmount, "scaleTraderJoeV2");
     }
 
-    function scaleLevelFiV2(bytes memory data, uint256 oldAmount, uint256 newAmount)
-        internal
-        pure
-        returns (bytes memory)
-    {
+    function scaleLevelFiV2(
+        bytes memory data,
+        uint256 oldAmount,
+        uint256 newAmount
+    ) internal pure returns (bytes memory) {
         uint256 startByte;
 
         (, startByte) = data._readPool(startByte); // pool
 
         (, startByte) = data._readAddress(startByte); // tokenOut
 
-        (uint256 swapAmount,) = data._readUint128AsUint256(startByte); // amount
-        return data.write16Bytes(startByte, oldAmount == 0 ? 0 : (swapAmount * newAmount) / oldAmount, "scaleLevelFiV2");
+        (uint256 swapAmount, ) = data._readUint128AsUint256(startByte); // amount
+        return
+            data.write16Bytes(startByte, oldAmount == 0 ? 0 : (swapAmount * newAmount) / oldAmount, "scaleLevelFiV2");
     }
 
-    function scaleGMXGLP(bytes memory data, uint256 oldAmount, uint256 newAmount)
-        internal
-        pure
-        returns (bytes memory)
-    {
+    function scaleGMXGLP(bytes memory data, uint256 oldAmount, uint256 newAmount) internal pure returns (bytes memory) {
         uint256 startByte;
 
         (, startByte) = data._readPool(startByte); // pool
@@ -330,7 +336,7 @@ library DexScaler {
         (directionFlag, startByte) = data._readUint8(startByte);
         if (directionFlag == 1) (, startByte) = data._readAddress(startByte); // tokenOut
 
-        (uint256 swapAmount,) = data._readUint128AsUint256(startByte); // amount
+        (uint256 swapAmount, ) = data._readUint128AsUint256(startByte); // amount
         return data.write16Bytes(startByte, oldAmount == 0 ? 0 : (swapAmount * newAmount) / oldAmount, "scaleGMXGLP");
     }
 
@@ -341,36 +347,36 @@ library DexScaler {
 
         (, startByte) = data._readUint8(startByte); // toId
 
-        (uint256 fromAmount,) = data._readUint128AsUint256(startByte); // amount
+        (uint256 fromAmount, ) = data._readUint128AsUint256(startByte); // amount
 
         return data.write16Bytes(startByte, oldAmount == 0 ? 0 : (fromAmount * newAmount) / oldAmount, "scaleVooi");
     }
 
-    function scaleVelocoreV2(bytes memory data, uint256 oldAmount, uint256 newAmount)
-        internal
-        pure
-        returns (bytes memory)
-    {
+    function scaleVelocoreV2(
+        bytes memory data,
+        uint256 oldAmount,
+        uint256 newAmount
+    ) internal pure returns (bytes memory) {
         uint256 startByte;
 
         (, startByte) = data._readPool(startByte); // pool
 
         (, startByte) = data._readAddress(startByte); // tokenOut
 
-        (uint256 amount,) = data._readUint128AsUint256(startByte); // amount
+        (uint256 amount, ) = data._readUint128AsUint256(startByte); // amount
         return data.write16Bytes(startByte, oldAmount == 0 ? 0 : (amount * newAmount) / oldAmount, "scaleVelocoreV2");
     }
 
-    function scaleKokonut(bytes memory data, uint256 oldAmount, uint256 newAmount)
-        internal
-        pure
-        returns (bytes memory)
-    {
+    function scaleKokonut(
+        bytes memory data,
+        uint256 oldAmount,
+        uint256 newAmount
+    ) internal pure returns (bytes memory) {
         uint256 startByte;
 
         (, startByte) = data._readPool(startByte); // pool
 
-        (uint256 amount,) = data._readUint128AsUint256(startByte); // amount
+        (uint256 amount, ) = data._readUint128AsUint256(startByte); // amount
         return data.write16Bytes(startByte, oldAmount == 0 ? 0 : (amount * newAmount) / oldAmount, "scaleKokonut");
     }
 }

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

@@ -34,11 +34,9 @@ library ExecutorReader {
         return abi.encode(desc);
     }
 
-    function readSwapSingleSequence(bytes memory data)
-        internal
-        pure
-        returns (IAggregationExecutorOptimistic.Swap[] memory swaps, address tokenIn)
-    {
+    function readSwapSingleSequence(
+        bytes memory data
+    ) internal pure returns (IAggregationExecutorOptimistic.Swap[] memory swaps, address tokenIn) {
         uint256 startByte = 0;
         bytes memory ret;
         (ret, startByte) = CalldataReader._calldataVal(data, startByte, 1);
@@ -50,11 +48,10 @@ library ExecutorReader {
         (tokenIn, startByte) = CalldataReader._readAddress(data, startByte);
     }
 
-    function _readSwap(bytes memory data, uint256 startByte)
-        internal
-        pure
-        returns (IAggregationExecutorOptimistic.Swap memory swap, uint256)
-    {
+    function _readSwap(
+        bytes memory data,
+        uint256 startByte
+    ) internal pure returns (IAggregationExecutorOptimistic.Swap memory swap, uint256) {
         (swap.data, startByte) = CalldataReader._readBytes(data, startByte);
         bytes1 t;
         (t, startByte) = CalldataReader._readBytes1(data, startByte);