@pendle/core-v2 3.0.0-beta-10 → 3.0.0-beta-12

package/contracts/router/swap-aggregator/kyberswap/{KyberInputScalingHelper.sol → l1-contracts/InputScalingHelper.sol}

@@ -1,11 +1,25 @@
 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8.0;
 
-import "./IMetaAggregationRouterV2.sol";
-import "./IExecutorHelper.sol";
-import "./ScalingDataLib.sol";
+import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import {IExecutorHelper} from "../interfaces/IExecutorHelper.sol";
+import {IMetaAggregationRouterV2} from "../interfaces/IMetaAggregationRouterV2.sol";
+import {ScalingDataLib} from "./ScalingDataLib.sol";
 
-abstract contract KyberInputScalingHelper {
+/* ----------------------------------------
+.__   __.   ______   .___________. _______
+|  \ |  |  /  __  \  |           ||   ____|
+|   \|  | |  |  |  | `---|  |----`|  |__
+|  . `  | |  |  |  |     |  |     |   __|
+|  |\   | |  `--'  |     |  |     |  |____
+|__| \__|  \______/      |__|     |_______|
+
+
+Please use InputScalingHelperL2 contract for scaling data on Arbitrum, Optimism, Base
+
+---------------------------------------- */
+
+library InputScalingHelper {
     uint256 private constant _PARTIAL_FILL = 0x01;
     uint256 private constant _REQUIRES_EXTRA_ETH = 0x02;
     uint256 private constant _SHOULD_CLAIM = 0x04;
@@ -41,11 +55,7 @@ abstract contract KyberInputScalingHelper {
         bytes positiveSlippageData;
     }
 
-    function _getKyberScaledInputData(bytes calldata inputData, uint256 newAmount)
-        internal
-        pure
-        returns (bytes memory)
-    {
+    function _getScaledInputData(bytes calldata inputData, uint256 newAmount) internal pure returns (bytes memory) {
         bytes4 selector = bytes4(inputData[:4]);
         bytes calldata dataToDecode = inputData[4:];
 
@@ -68,14 +78,13 @@ abstract contract KyberInputScalingHelper {
                 IMetaAggregationRouterV2.SwapDescriptionV2 memory desc,
                 bytes memory targetData,
                 bytes memory clientData
-            ) = abi.decode(
-                    dataToDecode,
-                    (address, IMetaAggregationRouterV2.SwapDescriptionV2, bytes, bytes)
-                );
+            ) = abi.decode(dataToDecode, (address, IMetaAggregationRouterV2.SwapDescriptionV2, bytes, bytes));
 
             (desc, targetData) = _getScaledInputDataV2(desc, targetData, newAmount, true);
             return abi.encodeWithSelector(selector, callTarget, desc, targetData, clientData);
-        } else revert("InputScalingHelper: Invalid selector");
+        } else {
+            revert("InputScalingHelper: Invalid selector");
+        }
     }
 
     function _getScaledInputDataV2(
@@ -192,11 +201,11 @@ abstract contract KyberInputScalingHelper {
             } else if (functionSelector == IExecutorHelper.executeSynthetix.selector) {
                 swap.data = ScalingDataLib.newSynthetix(swap.data, oldAmount, newAmount);
             } else if (functionSelector == IExecutorHelper.executeHashflow.selector) {
-                revert("InputScalingHelper: Can not scale RFQ swap");
+                revert("InputScalingHelper: Can not scale Hasflow swap");
             } else if (functionSelector == IExecutorHelper.executeCamelot.selector) {
                 swap.data = ScalingDataLib.newCamelot(swap.data, oldAmount, newAmount);
             } else if (functionSelector == IExecutorHelper.executeKyberLimitOrder.selector) {
-                revert("InputScalingHelper: Can not scale RFQ swap");
+                revert("InputScalingHelper: Can not scale KyberLO swap");
             } else if (functionSelector == IExecutorHelper.executePSM.selector) {
                 swap.data = ScalingDataLib.newPSM(swap.data, oldAmount, newAmount);
             } else if (functionSelector == IExecutorHelper.executeFrax.selector) {
@@ -205,7 +214,43 @@ abstract contract KyberInputScalingHelper {
                 swap.data = ScalingDataLib.newPlatypus(swap.data, oldAmount, newAmount);
             } else if (functionSelector == IExecutorHelper.executeMaverick.selector) {
                 swap.data = ScalingDataLib.newMaverick(swap.data, oldAmount, newAmount);
-            } else revert("AggregationExecutor: Dex type not supported");
+            } else if (functionSelector == IExecutorHelper.executeSyncSwap.selector) {
+                swap.data = ScalingDataLib.newSyncSwap(swap.data, oldAmount, newAmount);
+            } else if (functionSelector == IExecutorHelper.executeAlgebraV1.selector) {
+                swap.data = ScalingDataLib.newAlgebraV1(swap.data, oldAmount, newAmount);
+            } else if (functionSelector == IExecutorHelper.executeBalancerBatch.selector) {
+                swap.data = ScalingDataLib.newBalancerBatch(swap.data, oldAmount, newAmount);
+            } else if (functionSelector == IExecutorHelper.executeWombat.selector) {
+                swap.data = ScalingDataLib.newMantis(swap.data, oldAmount, newAmount); // @dev struct Mantis is used for both Wombat and Mantis because of same fields
+            } else if (functionSelector == IExecutorHelper.executeMantis.selector) {
+                swap.data = ScalingDataLib.newMantis(swap.data, oldAmount, newAmount);
+            } else if (functionSelector == IExecutorHelper.executeIziSwap.selector) {
+                swap.data = ScalingDataLib.newIziSwap(swap.data, oldAmount, newAmount);
+            } else if (functionSelector == IExecutorHelper.executeWooFiV2.selector) {
+                swap.data = ScalingDataLib.newMantis(swap.data, oldAmount, newAmount); // @dev using Mantis struct because WooFiV2 and Mantis have same fields
+            } else if (functionSelector == IExecutorHelper.executeTraderJoeV2.selector) {
+                swap.data = ScalingDataLib.newTraderJoeV2(swap.data, oldAmount, newAmount);
+            } else if (functionSelector == IExecutorHelper.executePancakeStableSwap.selector) {
+                swap.data = ScalingDataLib.newCurveSwap(swap.data, oldAmount, newAmount);
+            } else if (functionSelector == IExecutorHelper.executeLevelFiV2.selector) {
+                swap.data = ScalingDataLib.newLevelFiV2(swap.data, oldAmount, newAmount);
+            } else if (functionSelector == IExecutorHelper.executeGMXGLP.selector) {
+                swap.data = ScalingDataLib.newGMXGLP(swap.data, oldAmount, newAmount);
+            } else if (functionSelector == IExecutorHelper.executeVooi.selector) {
+                swap.data = ScalingDataLib.newVooi(swap.data, oldAmount, newAmount);
+            } else if (functionSelector == IExecutorHelper.executeVelocoreV2.selector) {
+                swap.data = ScalingDataLib.newVelocoreV2(swap.data, oldAmount, newAmount);
+            } else if (functionSelector == IExecutorHelper.executeMaticMigrate.selector) {
+                swap.data = ScalingDataLib.newMaticMigrate(swap.data, oldAmount, newAmount);
+            } else if (functionSelector == IExecutorHelper.executeSmardex.selector) {
+                swap.data = ScalingDataLib.newMantis(swap.data, oldAmount, newAmount); // @dev using Mantis struct because Smardex and Mantis have same fields
+            } else if (functionSelector == IExecutorHelper.executeSolidlyV2.selector) {
+                swap.data = ScalingDataLib.newMantis(swap.data, oldAmount, newAmount); // @dev using Mantis struct because Solidly V2 and Mantis have same fields
+            } else if (functionSelector == IExecutorHelper.executeKokonut.selector) {
+                swap.data = ScalingDataLib.newKokonut(swap.data, oldAmount, newAmount);
+            } else {
+                revert("AggregationExecutor: Dex type not supported");
+            }
             unchecked {
                 ++i;
             }
@@ -220,11 +265,17 @@ abstract contract KyberInputScalingHelper {
     ) internal pure returns (bytes memory newData) {
         if (data.length > 32) {
             PositiveSlippageFeeData memory psData = abi.decode(data, (PositiveSlippageFeeData));
-            psData.expectedReturnAmount = (psData.expectedReturnAmount * newAmount) / oldAmount;
+            uint256 left = uint256(psData.expectedReturnAmount >> 128);
+            uint256 right = (uint256(uint128(psData.expectedReturnAmount)) * newAmount) / oldAmount;
+            require(right <= type(uint128).max, "Exceeded type range");
+            psData.expectedReturnAmount = right | (left << 128);
             data = abi.encode(psData);
         } else if (data.length == 32) {
             uint256 expectedReturnAmount = abi.decode(data, (uint256));
-            expectedReturnAmount = (expectedReturnAmount * newAmount) / oldAmount;
+            uint256 left = uint256(expectedReturnAmount >> 128);
+            uint256 right = (uint256(uint128(expectedReturnAmount)) * newAmount) / oldAmount;
+            require(right <= type(uint128).max, "Exceeded type range");
+            expectedReturnAmount = right | (left << 128);
             data = abi.encode(expectedReturnAmount);
         }
         return data;

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

@@ -1,14 +1,10 @@
 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8.0;
 
-import "./IExecutorHelper.sol";
+import {IExecutorHelper} from "../interfaces/IExecutorHelper.sol";
 
 library ScalingDataLib {
-    function newUniSwap(
-        bytes memory data,
-        uint256 oldAmount,
-        uint256 newAmount
-    ) internal pure returns (bytes memory) {
+    function newUniSwap(bytes memory data, uint256 oldAmount, uint256 newAmount) internal pure returns (bytes memory) {
         IExecutorHelper.UniSwap memory uniSwap = abi.decode(data, (IExecutorHelper.UniSwap));
         uniSwap.collectAmount = (uniSwap.collectAmount * newAmount) / oldAmount;
         return abi.encode(uniSwap);
@@ -19,10 +15,7 @@ library ScalingDataLib {
         uint256 oldAmount,
         uint256 newAmount
     ) internal pure returns (bytes memory) {
-        IExecutorHelper.StableSwap memory stableSwap = abi.decode(
-            data,
-            (IExecutorHelper.StableSwap)
-        );
+        IExecutorHelper.StableSwap memory stableSwap = abi.decode(data, (IExecutorHelper.StableSwap));
         stableSwap.dx = (stableSwap.dx * newAmount) / oldAmount;
         return abi.encode(stableSwap);
     }
@@ -37,11 +30,7 @@ library ScalingDataLib {
         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);
@@ -66,19 +55,12 @@ library ScalingDataLib {
         uint256 oldAmount,
         uint256 newAmount
     ) internal pure returns (bytes memory) {
-        IExecutorHelper.BalancerV2 memory balancerV2 = abi.decode(
-            data,
-            (IExecutorHelper.BalancerV2)
-        );
+        IExecutorHelper.BalancerV2 memory balancerV2 = abi.decode(data, (IExecutorHelper.BalancerV2));
         balancerV2.amount = (balancerV2.amount * newAmount) / oldAmount;
         return abi.encode(balancerV2);
     }
 
-    function newDODO(
-        bytes memory data,
-        uint256 oldAmount,
-        uint256 newAmount
-    ) internal pure returns (bytes memory) {
+    function newDODO(bytes memory data, uint256 oldAmount, uint256 newAmount) internal pure returns (bytes memory) {
         IExecutorHelper.DODO memory dodo = abi.decode(data, (IExecutorHelper.DODO));
         dodo.amount = (dodo.amount * newAmount) / oldAmount;
         return abi.encode(dodo);
@@ -94,11 +76,7 @@ library ScalingDataLib {
         return abi.encode(velodrome);
     }
 
-    function newGMX(
-        bytes memory data,
-        uint256 oldAmount,
-        uint256 newAmount
-    ) internal pure returns (bytes memory) {
+    function newGMX(bytes memory data, uint256 oldAmount, uint256 newAmount) internal pure returns (bytes memory) {
         IExecutorHelper.GMX memory gmx = abi.decode(data, (IExecutorHelper.GMX));
         gmx.amount = (gmx.amount * newAmount) / oldAmount;
         return abi.encode(gmx);
@@ -114,21 +92,13 @@ library ScalingDataLib {
         return abi.encode(synthetix);
     }
 
-    function newCamelot(
-        bytes memory data,
-        uint256 oldAmount,
-        uint256 newAmount
-    ) internal pure returns (bytes memory) {
+    function newCamelot(bytes memory data, uint256 oldAmount, uint256 newAmount) internal pure returns (bytes memory) {
         IExecutorHelper.UniSwap memory camelot = abi.decode(data, (IExecutorHelper.UniSwap));
         camelot.collectAmount = (camelot.collectAmount * newAmount) / oldAmount;
         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);
@@ -144,21 +114,13 @@ library ScalingDataLib {
         return abi.encode(wstEthData);
     }
 
-    function newPSM(
-        bytes memory data,
-        uint256 oldAmount,
-        uint256 newAmount
-    ) internal pure returns (bytes memory) {
+    function newPSM(bytes memory data, uint256 oldAmount, uint256 newAmount) internal pure returns (bytes memory) {
         IExecutorHelper.PSM memory psm = abi.decode(data, (IExecutorHelper.PSM));
         psm.amountIn = (psm.amountIn * newAmount) / oldAmount;
         return abi.encode(psm);
     }
 
-    function newFrax(
-        bytes memory data,
-        uint256 oldAmount,
-        uint256 newAmount
-    ) internal pure returns (bytes memory) {
+    function newFrax(bytes memory data, uint256 oldAmount, uint256 newAmount) internal pure returns (bytes memory) {
         IExecutorHelper.UniSwap memory frax = abi.decode(data, (IExecutorHelper.UniSwap));
         frax.collectAmount = (frax.collectAmount * newAmount) / oldAmount;
         return abi.encode(frax);
@@ -174,13 +136,109 @@ library ScalingDataLib {
         return abi.encode(amount);
     }
 
-    function newMaverick(
+    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) {
+        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) {
-        IExecutorHelper.Maverick memory maverick = abi.decode(data, (IExecutorHelper.Maverick));
-        maverick.swapAmount = (maverick.swapAmount * newAmount) / oldAmount;
-        return abi.encode(maverick);
+        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) {
+        IExecutorHelper.BalancerBatch memory balancerBatch = abi.decode(data, (IExecutorHelper.BalancerBatch));
+        balancerBatch.amountIn = (balancerBatch.amountIn * newAmount) / oldAmount;
+        return abi.encode(balancerBatch);
+    }
+
+    function newMantis(bytes memory data, uint256 oldAmount, uint256 newAmount) internal pure returns (bytes memory) {
+        IExecutorHelper.Mantis memory mantis = abi.decode(data, (IExecutorHelper.Mantis));
+        mantis.amount = (mantis.amount * newAmount) / oldAmount;
+        return abi.encode(mantis);
+    }
+
+    function newIziSwap(bytes memory data, uint256 oldAmount, uint256 newAmount) internal pure returns (bytes memory) {
+        IExecutorHelper.IziSwap memory iZi = abi.decode(data, (IExecutorHelper.IziSwap));
+        iZi.swapAmount = (iZi.swapAmount * newAmount) / oldAmount;
+        return abi.encode(iZi);
+    }
+
+    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);
+        return abi.encode(traderJoe);
+    }
+
+    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);
+    }
+
+    function newGMXGLP(bytes memory data, uint256 oldAmount, uint256 newAmount) internal pure returns (bytes memory) {
+        IExecutorHelper.GMXGLP memory swapData = abi.decode(data, (IExecutorHelper.GMXGLP));
+        swapData.swapAmount = (swapData.swapAmount * newAmount) / oldAmount;
+        return abi.encode(swapData);
+    }
+
+    function newVooi(bytes memory data, uint256 oldAmount, uint256 newAmount) internal pure returns (bytes memory) {
+        IExecutorHelper.Vooi memory vooi = abi.decode(data, (IExecutorHelper.Vooi));
+        vooi.fromAmount = (vooi.fromAmount * newAmount) / oldAmount;
+        return abi.encode(vooi);
+    }
+
+    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) {
+        IExecutorHelper.MaticMigrate memory maticMigrate = abi.decode(data, (IExecutorHelper.MaticMigrate));
+        maticMigrate.amount = (maticMigrate.amount * newAmount) / oldAmount;
+        return abi.encode(maticMigrate);
+    }
+
+    function newKokonut(bytes memory data, uint256 oldAmount, uint256 newAmount) internal pure returns (bytes memory) {
+        IExecutorHelper.Kokonut memory kokonut = abi.decode(data, (IExecutorHelper.Kokonut));
+        kokonut.dx = (kokonut.dx * newAmount) / oldAmount;
+        return abi.encode(kokonut);
     }
 }

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

@@ -0,0 +1,29 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+library BytesHelper {
+    function write16Bytes(bytes memory original, uint256 index, bytes16 value) internal pure returns (bytes memory) {
+        assembly {
+            let offset := add(original, add(index, 32))
+            let val := mload(offset) // read 32 bytes [index : index + 32]
+            val := and(val, not(0xffffffffffffffffffffffffffffffff00000000000000000000000000000000)) // clear [index : index + 16]
+            val := or(val, value) // set 16 bytes to val above
+            mstore(offset, val) // store to [index : index + 32]
+        }
+        return original;
+    }
+
+    function write16Bytes(bytes memory original, uint256 index, uint128 value) internal pure returns (bytes memory) {
+        return write16Bytes(original, index, bytes16(value));
+    }
+
+    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

@@ -0,0 +1,149 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+library CalldataReader {
+    /// @notice read the bytes value of data from a starting position and length
+    /// @param data bytes array of data
+    /// @param startByte starting position to read
+    /// @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) {
+        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)
+            } {
+                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)))
+            retVal := m
+        }
+        return (retVal, length + startByte);
+    }
+
+    function _readBool(bytes memory data, uint256 startByte) internal pure returns (bool, uint256) {
+        bytes memory ret;
+        (ret, startByte) = _calldataVal(data, startByte, 1);
+        return (bytes1(ret) > 0, startByte);
+    }
+
+    function _readUint8(bytes memory data, uint256 startByte) internal pure returns (uint8, uint256) {
+        bytes memory ret;
+        (ret, startByte) = _calldataVal(data, startByte, 1);
+        return (uint8(bytes1(ret)), startByte);
+    }
+
+    function _readUint24(bytes memory data, uint256 startByte) internal pure returns (uint24, uint256) {
+        bytes memory ret;
+        (ret, startByte) = _calldataVal(data, startByte, 3);
+        return (uint24(bytes3(ret)), startByte);
+    }
+
+    function _readUint32(bytes memory data, uint256 startByte) internal pure returns (uint32, uint256) {
+        bytes memory ret;
+        (ret, startByte) = _calldataVal(data, startByte, 4);
+        return (uint32(bytes4(ret)), startByte);
+    }
+
+    function _readUint160(bytes memory data, uint256 startByte) internal pure returns (uint160, uint256) {
+        bytes memory ret;
+        (ret, startByte) = _calldataVal(data, startByte, 20);
+        return (uint160(bytes20(ret)), startByte);
+    }
+
+    /// @dev only when sure that the value of uint256 never exceed uint128
+    function _readUint128AsUint256(bytes memory data, uint256 startByte) internal pure returns (uint256, uint256) {
+        bytes memory ret;
+        (ret, startByte) = _calldataVal(data, startByte, 16);
+        return (uint256(uint128(bytes16(ret))), startByte);
+    }
+
+    function _readAddress(bytes memory data, uint256 startByte) internal pure returns (address, uint256) {
+        bytes memory ret;
+        (ret, startByte) = _calldataVal(data, startByte, 20);
+        return (address(bytes20(ret)), startByte);
+    }
+
+    function _readBytes1(bytes memory data, uint256 startByte) internal pure returns (bytes1, uint256) {
+        bytes memory ret;
+        (ret, startByte) = _calldataVal(data, startByte, 1);
+        return (bytes1(ret), startByte);
+    }
+
+    function _readBytes4(bytes memory data, uint256 startByte) internal pure returns (bytes4, uint256) {
+        bytes memory ret;
+        (ret, startByte) = _calldataVal(data, startByte, 4);
+        return (bytes4(ret), startByte);
+    }
+
+    function _readBytes32(bytes memory data, uint256 startByte) internal pure returns (bytes32, uint256) {
+        bytes memory ret;
+        (ret, startByte) = _calldataVal(data, startByte, 32);
+        return (bytes32(ret), startByte);
+    }
+
+    /// @dev length of bytes is currently limited to uint32
+    function _readBytes(bytes memory data, uint256 startByte) internal pure returns (bytes memory b, uint256) {
+        bytes memory ret;
+        (ret, startByte) = _calldataVal(data, startByte, 4);
+        uint256 length = uint256(uint32(bytes4(ret)));
+        (b, startByte) = _calldataVal(data, startByte, length);
+        return (b, startByte);
+    }
+
+    /// @dev length of bytes array is currently limited to uint8
+    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)));
+        bytesArray = new bytes[](length);
+        for (uint8 i = 0; i < length; ++i) {
+            (bytesArray[i], startByte) = _readBytes(data, startByte);
+        }
+        return (bytesArray, startByte);
+    }
+
+    /// @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) {
+        bytes memory ret;
+        (ret, startByte) = _calldataVal(data, startByte, 1);
+        uint256 length = uint256(uint8(bytes1(ret)));
+        addrs = new address[](length);
+        for (uint8 i = 0; i < length; ++i) {
+            (addrs[i], startByte) = _readAddress(data, startByte);
+        }
+        return (addrs, startByte);
+    }
+
+    /// @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) {
+        bytes memory ret;
+        (ret, startByte) = _calldataVal(data, startByte, 1);
+        uint256 length = uint256(uint8(bytes1(ret)));
+        uint256[] memory us = new uint256[](length);
+        for (uint8 i = 0; i < length; ++i) {
+            (us[i], startByte) = _readUint128AsUint256(data, startByte);
+        }
+        return (us, startByte);
+    }
+}

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

@@ -0,0 +1,118 @@
+// 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";
+
+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, _writeBytesArray(simpleSwapData.swapDatas));
+        shortData = bytes.concat(shortData, bytes16(uint128(simpleSwapData.deadline)));
+        shortData = bytes.concat(shortData, _writeBytes(simpleSwapData.positiveSlippageData));
+    }
+
+    /*
+     ************************ AggregationExecutor ************************
+     */
+    function writeSwapExecutorDescription(
+        IExecutorHelperL2.SwapExecutorDescription memory desc
+    ) internal pure returns (bytes memory shortData) {
+        // write Swap array
+        uint8 lX = uint8(desc.swapSequences.length);
+        shortData = bytes.concat(shortData, bytes1(lX));
+        for (uint8 i = 0; i < lX; ++i) {
+            uint8 lY = uint8(desc.swapSequences[i].length);
+            shortData = bytes.concat(shortData, bytes1(lY));
+            for (uint8 j = 0; j < lY; ++j) {
+                shortData = bytes.concat(shortData, _writeSwap(desc.swapSequences[i][j]));
+            }
+        }
+
+        // basic members
+        shortData = bytes.concat(shortData, bytes20(desc.tokenIn));
+        shortData = bytes.concat(shortData, bytes20(desc.tokenOut));
+        shortData = bytes.concat(shortData, bytes20(desc.to));
+        shortData = bytes.concat(shortData, bytes16(uint128(desc.deadline)));
+        shortData = bytes.concat(shortData, _writeBytes(desc.positiveSlippageData));
+    }
+
+    function writeSimpleModeSwapDatas(
+        bytes[] memory swapDatas,
+        address tokenIn
+    ) internal pure returns (bytes[] memory shortData) {
+        uint8 len = uint8(swapDatas.length);
+        for (uint8 i = 0; i < len; ++i) {
+            swapDatas[i] = _writeSwapSingleSequence(swapDatas[i], tokenIn);
+        }
+        return (swapDatas);
+    }
+
+    function _writeSwapSingleSequence(
+        bytes memory data,
+        address tokenIn
+    ) internal pure returns (bytes memory shortData) {
+        IExecutorHelperL2.Swap[] memory swaps = abi.decode(data, (IExecutorHelperL2.Swap[]));
+
+        uint8 len = uint8(swaps.length);
+        shortData = bytes.concat(shortData, bytes1(len));
+        for (uint8 i = 0; i < len; ++i) {
+            shortData = bytes.concat(shortData, _writeSwap(swaps[i]));
+        }
+        shortData = bytes.concat(shortData, bytes20(tokenIn));
+    }
+
+    function _writeAddressArray(address[] memory addrs) internal pure returns (bytes memory data) {
+        uint8 length = uint8(addrs.length);
+        data = bytes.concat(data, bytes1(length));
+        for (uint8 i = 0; i < length; ++i) {
+            data = bytes.concat(data, bytes20(addrs[i]));
+        }
+        return 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) {
+            data = bytes.concat(data, bytes16(uint128(us[i])));
+        }
+        return data;
+    }
+
+    function _writeBytes(bytes memory b) internal pure returns (bytes memory data) {
+        uint32 length = uint32(b.length);
+        data = bytes.concat(data, bytes4(length));
+        data = bytes.concat(data, b);
+        return 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) {
+            uint32 length = uint32(bytesArray[i].length);
+            data = bytes.concat(data, bytes4(length));
+            data = bytes.concat(data, bytesArray[i]);
+        }
+        return 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) {
+            data = bytes.concat(data, bytesArray[i]);
+        }
+        return data;
+    }
+
+    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))));
+    }
+}