@pendle/core-v2 5.0.3 → 5.0.5

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

@@ -1,11 +1,15 @@
 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8.0;
 
-import {IExecutorHelper} from "../interfaces/IExecutorHelper.sol";
+import {IExecutorHelperStruct} from "../interfaces/IExecutorHelperStruct.sol";
+import {IBebopV3} from "../interfaces/pools/IBebopV3.sol";
+import {BytesHelper} from "../libraries/BytesHelper.sol";
 
 library ScalingDataLib {
+    using BytesHelper for bytes;
+
     function newUniSwap(bytes memory data, uint256 oldAmount, uint256 newAmount) internal pure returns (bytes memory) {
-        IExecutorHelper.UniSwap memory uniSwap = abi.decode(data, (IExecutorHelper.UniSwap));
+        IExecutorHelperStruct.UniSwap memory uniSwap = abi.decode(data, (IExecutorHelperStruct.UniSwap));
         uniSwap.collectAmount = (uniSwap.collectAmount * newAmount) / oldAmount;
         return abi.encode(uniSwap);
     }
@@ -15,7 +19,7 @@ library ScalingDataLib {
         uint256 oldAmount,
         uint256 newAmount
     ) internal pure returns (bytes memory) {
-        IExecutorHelper.StableSwap memory stableSwap = abi.decode(data, (IExecutorHelper.StableSwap));
+        IExecutorHelperStruct.StableSwap memory stableSwap = abi.decode(data, (IExecutorHelperStruct.StableSwap));
         stableSwap.dx = (stableSwap.dx * newAmount) / oldAmount;
         return abi.encode(stableSwap);
     }
@@ -25,25 +29,19 @@ library ScalingDataLib {
         uint256 oldAmount,
         uint256 newAmount
     ) internal pure returns (bytes memory) {
-        IExecutorHelper.CurveSwap memory curveSwap = abi.decode(data, (IExecutorHelper.CurveSwap));
+        IExecutorHelperStruct.CurveSwap memory curveSwap = abi.decode(data, (IExecutorHelperStruct.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) {
-        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(
+        IExecutorHelperStruct.UniswapV3KSElastic memory uniSwapV3ProMM = abi.decode(
             data,
-            (IExecutorHelper.UniswapV3KSElastic)
+            (IExecutorHelperStruct.UniswapV3KSElastic)
         );
         uniSwapV3ProMM.swapAmount = (uniSwapV3ProMM.swapAmount * newAmount) / oldAmount;
 
@@ -55,29 +53,19 @@ library ScalingDataLib {
         uint256 oldAmount,
         uint256 newAmount
     ) internal pure returns (bytes memory) {
-        IExecutorHelper.BalancerV2 memory balancerV2 = abi.decode(data, (IExecutorHelper.BalancerV2));
+        IExecutorHelperStruct.BalancerV2 memory balancerV2 = abi.decode(data, (IExecutorHelperStruct.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) {
-        IExecutorHelper.DODO memory dodo = abi.decode(data, (IExecutorHelper.DODO));
+        IExecutorHelperStruct.DODO memory dodo = abi.decode(data, (IExecutorHelperStruct.DODO));
         dodo.amount = (dodo.amount * newAmount) / oldAmount;
         return abi.encode(dodo);
     }
 
-    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);
-    }
-
     function newGMX(bytes memory data, uint256 oldAmount, uint256 newAmount) internal pure returns (bytes memory) {
-        IExecutorHelper.GMX memory gmx = abi.decode(data, (IExecutorHelper.GMX));
+        IExecutorHelperStruct.GMX memory gmx = abi.decode(data, (IExecutorHelperStruct.GMX));
         gmx.amount = (gmx.amount * newAmount) / oldAmount;
         return abi.encode(gmx);
     }
@@ -87,19 +75,19 @@ library ScalingDataLib {
         uint256 oldAmount,
         uint256 newAmount
     ) internal pure returns (bytes memory) {
-        IExecutorHelper.Synthetix memory synthetix = abi.decode(data, (IExecutorHelper.Synthetix));
+        IExecutorHelperStruct.Synthetix memory synthetix = abi.decode(data, (IExecutorHelperStruct.Synthetix));
         synthetix.sourceAmount = (synthetix.sourceAmount * newAmount) / oldAmount;
         return abi.encode(synthetix);
     }
 
     function newCamelot(bytes memory data, uint256 oldAmount, uint256 newAmount) internal pure returns (bytes memory) {
-        IExecutorHelper.UniSwap memory camelot = abi.decode(data, (IExecutorHelper.UniSwap));
+        IExecutorHelperStruct.UniSwap memory camelot = abi.decode(data, (IExecutorHelperStruct.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) {
-        IExecutorHelper.Platypus memory platypus = abi.decode(data, (IExecutorHelper.Platypus));
+        IExecutorHelperStruct.Platypus memory platypus = abi.decode(data, (IExecutorHelperStruct.Platypus));
         platypus.collectAmount = (platypus.collectAmount * newAmount) / oldAmount;
         return abi.encode(platypus);
     }
@@ -109,23 +97,17 @@ library ScalingDataLib {
         uint256 oldAmount,
         uint256 newAmount
     ) internal pure returns (bytes memory) {
-        IExecutorHelper.WSTETH memory wstEthData = abi.decode(data, (IExecutorHelper.WSTETH));
+        IExecutorHelperStruct.WSTETH memory wstEthData = abi.decode(data, (IExecutorHelperStruct.WSTETH));
         wstEthData.amount = (wstEthData.amount * newAmount) / oldAmount;
         return abi.encode(wstEthData);
     }
 
     function newPSM(bytes memory data, uint256 oldAmount, uint256 newAmount) internal pure returns (bytes memory) {
-        IExecutorHelper.PSM memory psm = abi.decode(data, (IExecutorHelper.PSM));
+        IExecutorHelperStruct.PSM memory psm = abi.decode(data, (IExecutorHelperStruct.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) {
-        IExecutorHelper.UniSwap memory frax = abi.decode(data, (IExecutorHelper.UniSwap));
-        frax.collectAmount = (frax.collectAmount * newAmount) / oldAmount;
-        return abi.encode(frax);
-    }
-
     function newStETHSwap(
         bytes memory data,
         uint256 oldAmount,
@@ -137,13 +119,13 @@ library ScalingDataLib {
     }
 
     function newMaverick(bytes memory data, uint256 oldAmount, uint256 newAmount) internal pure returns (bytes memory) {
-        IExecutorHelper.Maverick memory maverick = abi.decode(data, (IExecutorHelper.Maverick));
+        IExecutorHelperStruct.Maverick memory maverick = abi.decode(data, (IExecutorHelperStruct.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));
+        IExecutorHelperStruct.SyncSwap memory syncSwap = abi.decode(data, (IExecutorHelperStruct.SyncSwap));
         syncSwap.collectAmount = (syncSwap.collectAmount * newAmount) / oldAmount;
         return abi.encode(syncSwap);
     }
@@ -153,7 +135,7 @@ library ScalingDataLib {
         uint256 oldAmount,
         uint256 newAmount
     ) internal pure returns (bytes memory) {
-        IExecutorHelper.AlgebraV1 memory algebraV1Swap = abi.decode(data, (IExecutorHelper.AlgebraV1));
+        IExecutorHelperStruct.AlgebraV1 memory algebraV1Swap = abi.decode(data, (IExecutorHelperStruct.AlgebraV1));
         algebraV1Swap.swapAmount = (algebraV1Swap.swapAmount * newAmount) / oldAmount;
         return abi.encode(algebraV1Swap);
     }
@@ -163,19 +145,22 @@ library ScalingDataLib {
         uint256 oldAmount,
         uint256 newAmount
     ) internal pure returns (bytes memory) {
-        IExecutorHelper.BalancerBatch memory balancerBatch = abi.decode(data, (IExecutorHelper.BalancerBatch));
+        IExecutorHelperStruct.BalancerBatch memory balancerBatch = abi.decode(
+            data,
+            (IExecutorHelperStruct.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));
+        IExecutorHelperStruct.Mantis memory mantis = abi.decode(data, (IExecutorHelperStruct.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));
+        IExecutorHelperStruct.IziSwap memory iZi = abi.decode(data, (IExecutorHelperStruct.IziSwap));
         iZi.swapAmount = (iZi.swapAmount * newAmount) / oldAmount;
         return abi.encode(iZi);
     }
@@ -185,7 +170,7 @@ library ScalingDataLib {
         uint256 oldAmount,
         uint256 newAmount
     ) internal pure returns (bytes memory) {
-        IExecutorHelper.TraderJoeV2 memory traderJoe = abi.decode(data, (IExecutorHelper.TraderJoeV2));
+        IExecutorHelperStruct.TraderJoeV2 memory traderJoe = abi.decode(data, (IExecutorHelperStruct.TraderJoeV2));
 
         // traderJoe.collectAmount; // most significant 1 bit is to determine whether pool is v2.1, else v2.0
         traderJoe.collectAmount =
@@ -199,19 +184,19 @@ library ScalingDataLib {
         uint256 oldAmount,
         uint256 newAmount
     ) internal pure returns (bytes memory) {
-        IExecutorHelper.LevelFiV2 memory levelFiV2 = abi.decode(data, (IExecutorHelper.LevelFiV2));
+        IExecutorHelperStruct.LevelFiV2 memory levelFiV2 = abi.decode(data, (IExecutorHelperStruct.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));
+        IExecutorHelperStruct.GMXGLP memory swapData = abi.decode(data, (IExecutorHelperStruct.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));
+        IExecutorHelperStruct.Vooi memory vooi = abi.decode(data, (IExecutorHelperStruct.Vooi));
         vooi.fromAmount = (vooi.fromAmount * newAmount) / oldAmount;
         return abi.encode(vooi);
     }
@@ -221,7 +206,7 @@ library ScalingDataLib {
         uint256 oldAmount,
         uint256 newAmount
     ) internal pure returns (bytes memory) {
-        IExecutorHelper.VelocoreV2 memory velocorev2 = abi.decode(data, (IExecutorHelper.VelocoreV2));
+        IExecutorHelperStruct.VelocoreV2 memory velocorev2 = abi.decode(data, (IExecutorHelperStruct.VelocoreV2));
         velocorev2.amount = (velocorev2.amount * newAmount) / oldAmount;
         return abi.encode(velocorev2);
     }
@@ -231,13 +216,13 @@ library ScalingDataLib {
         uint256 oldAmount,
         uint256 newAmount
     ) internal pure returns (bytes memory) {
-        IExecutorHelper.MaticMigrate memory maticMigrate = abi.decode(data, (IExecutorHelper.MaticMigrate));
+        IExecutorHelperStruct.MaticMigrate memory maticMigrate = abi.decode(data, (IExecutorHelperStruct.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));
+        IExecutorHelperStruct.Kokonut memory kokonut = abi.decode(data, (IExecutorHelperStruct.Kokonut));
         kokonut.dx = (kokonut.dx * newAmount) / oldAmount;
         return abi.encode(kokonut);
     }
@@ -247,7 +232,7 @@ library ScalingDataLib {
         uint256 oldAmount,
         uint256 newAmount
     ) internal pure returns (bytes memory) {
-        IExecutorHelper.BalancerV1 memory balancerV1 = abi.decode(data, (IExecutorHelper.BalancerV1));
+        IExecutorHelperStruct.BalancerV1 memory balancerV1 = abi.decode(data, (IExecutorHelperStruct.BalancerV1));
         balancerV1.amount = (balancerV1.amount * newAmount) / oldAmount;
         return abi.encode(balancerV1);
     }
@@ -257,19 +242,22 @@ library ScalingDataLib {
         uint256 oldAmount,
         uint256 newAmount
     ) internal pure returns (bytes memory) {
-        IExecutorHelper.ArbswapStable memory arbswapStable = abi.decode(data, (IExecutorHelper.ArbswapStable));
+        IExecutorHelperStruct.ArbswapStable memory arbswapStable = abi.decode(
+            data,
+            (IExecutorHelperStruct.ArbswapStable)
+        );
         arbswapStable.dx = (arbswapStable.dx * newAmount) / oldAmount;
         return abi.encode(arbswapStable);
     }
 
     function newBancorV2(bytes memory data, uint256 oldAmount, uint256 newAmount) internal pure returns (bytes memory) {
-        IExecutorHelper.BancorV2 memory bancorV2 = abi.decode(data, (IExecutorHelper.BancorV2));
+        IExecutorHelperStruct.BancorV2 memory bancorV2 = abi.decode(data, (IExecutorHelperStruct.BancorV2));
         bancorV2.amount = (bancorV2.amount * newAmount) / oldAmount;
         return abi.encode(bancorV2);
     }
 
     function newAmbient(bytes memory data, uint256 oldAmount, uint256 newAmount) internal pure returns (bytes memory) {
-        IExecutorHelper.Ambient memory ambient = abi.decode(data, (IExecutorHelper.Ambient));
+        IExecutorHelperStruct.Ambient memory ambient = abi.decode(data, (IExecutorHelperStruct.Ambient));
         ambient.qty = uint128((uint256(ambient.qty) * newAmount) / oldAmount);
         return abi.encode(ambient);
     }
@@ -279,39 +267,29 @@ library ScalingDataLib {
         uint256 oldAmount,
         uint256 newAmount
     ) internal pure returns (bytes memory) {
-        IExecutorHelper.LighterV2 memory structData = abi.decode(data, (IExecutorHelper.LighterV2));
+        IExecutorHelperStruct.LighterV2 memory structData = abi.decode(data, (IExecutorHelperStruct.LighterV2));
         structData.amount = uint128((uint256(structData.amount) * newAmount) / oldAmount);
         return abi.encode(structData);
     }
 
     function newUniV1(bytes memory data, uint256 oldAmount, uint256 newAmount) internal pure returns (bytes memory) {
-        IExecutorHelper.UniV1 memory structData = abi.decode(data, (IExecutorHelper.UniV1));
+        IExecutorHelperStruct.UniV1 memory structData = abi.decode(data, (IExecutorHelperStruct.UniV1));
         structData.amount = uint128((uint256(structData.amount) * newAmount) / oldAmount);
         return abi.encode(structData);
     }
 
-    function newEtherFieETH(
-        bytes memory data,
-        uint256 oldAmount,
-        uint256 newAmount
-    ) internal pure returns (bytes memory) {
-        uint256 depositAmount = abi.decode(data, (uint256));
-        depositAmount = uint128((depositAmount * newAmount) / oldAmount);
-        return abi.encode(depositAmount);
-    }
-
     function newEtherFiWeETH(
         bytes memory data,
         uint256 oldAmount,
         uint256 newAmount
     ) internal pure returns (bytes memory) {
-        IExecutorHelper.EtherFiWeETH memory structData = abi.decode(data, (IExecutorHelper.EtherFiWeETH));
+        IExecutorHelperStruct.EtherFiWeETH memory structData = abi.decode(data, (IExecutorHelperStruct.EtherFiWeETH));
         structData.amount = uint128((uint256(structData.amount) * newAmount) / oldAmount);
         return abi.encode(structData);
     }
 
     function newKelp(bytes memory data, uint256 oldAmount, uint256 newAmount) internal pure returns (bytes memory) {
-        IExecutorHelper.Kelp memory structData = abi.decode(data, (IExecutorHelper.Kelp));
+        IExecutorHelperStruct.Kelp memory structData = abi.decode(data, (IExecutorHelperStruct.Kelp));
         structData.amount = uint128((uint256(structData.amount) * newAmount) / oldAmount);
         return abi.encode(structData);
     }
@@ -321,7 +299,7 @@ library ScalingDataLib {
         uint256 oldAmount,
         uint256 newAmount
     ) internal pure returns (bytes memory) {
-        IExecutorHelper.EthenaSusde memory structData = abi.decode(data, (IExecutorHelper.EthenaSusde));
+        IExecutorHelperStruct.EthenaSusde memory structData = abi.decode(data, (IExecutorHelperStruct.EthenaSusde));
         structData.amount = uint128((uint256(structData.amount) * newAmount) / oldAmount);
         return abi.encode(structData);
     }
@@ -331,7 +309,7 @@ library ScalingDataLib {
         uint256 oldAmount,
         uint256 newAmount
     ) internal pure returns (bytes memory) {
-        IExecutorHelper.RocketPool memory structData = abi.decode(data, (IExecutorHelper.RocketPool));
+        IExecutorHelperStruct.RocketPool memory structData = abi.decode(data, (IExecutorHelperStruct.RocketPool));
 
         uint128 _amount = uint128((uint256(uint128(structData.isDepositAndAmount)) * newAmount) / oldAmount);
 
@@ -350,7 +328,7 @@ library ScalingDataLib {
         uint256 oldAmount,
         uint256 newAmount
     ) internal pure returns (bytes memory) {
-        IExecutorHelper.MakersDAI memory structData = abi.decode(data, (IExecutorHelper.MakersDAI));
+        IExecutorHelperStruct.MakersDAI memory structData = abi.decode(data, (IExecutorHelperStruct.MakersDAI));
         uint128 _amount = uint128((uint256(uint128(structData.isRedeemAndAmount)) * newAmount) / oldAmount);
 
         bool _isRedeem = (structData.isRedeemAndAmount >> 255) == 1;
@@ -364,19 +342,19 @@ library ScalingDataLib {
     }
 
     function newRenzo(bytes memory data, uint256 oldAmount, uint256 newAmount) internal pure returns (bytes memory) {
-        IExecutorHelper.Renzo memory structData = abi.decode(data, (IExecutorHelper.Renzo));
+        IExecutorHelperStruct.Renzo memory structData = abi.decode(data, (IExecutorHelperStruct.Renzo));
         structData.amount = uint128((uint256(structData.amount) * newAmount) / oldAmount);
         return abi.encode(structData);
     }
 
     function newFrxETH(bytes memory data, uint256 oldAmount, uint256 newAmount) internal pure returns (bytes memory) {
-        IExecutorHelper.FrxETH memory structData = abi.decode(data, (IExecutorHelper.FrxETH));
+        IExecutorHelperStruct.FrxETH memory structData = abi.decode(data, (IExecutorHelperStruct.FrxETH));
         structData.amount = uint128((uint256(structData.amount) * newAmount) / oldAmount);
         return abi.encode(structData);
     }
 
     function newSfrxETH(bytes memory data, uint256 oldAmount, uint256 newAmount) internal pure returns (bytes memory) {
-        IExecutorHelper.SfrxETH memory structData = abi.decode(data, (IExecutorHelper.SfrxETH));
+        IExecutorHelperStruct.SfrxETH memory structData = abi.decode(data, (IExecutorHelperStruct.SfrxETH));
         structData.amount = uint128((uint256(structData.amount) * newAmount) / oldAmount);
         return abi.encode(structData);
     }
@@ -386,7 +364,10 @@ library ScalingDataLib {
         uint256 oldAmount,
         uint256 newAmount
     ) internal pure returns (bytes memory) {
-        IExecutorHelper.SfrxETHConvertor memory structData = abi.decode(data, (IExecutorHelper.SfrxETHConvertor));
+        IExecutorHelperStruct.SfrxETHConvertor memory structData = abi.decode(
+            data,
+            (IExecutorHelperStruct.SfrxETHConvertor)
+        );
 
         uint128 _amount = uint128((uint256(uint128(structData.isDepositAndAmount)) * newAmount) / oldAmount);
 
@@ -405,7 +386,7 @@ library ScalingDataLib {
         uint256 oldAmount,
         uint256 newAmount
     ) internal pure returns (bytes memory) {
-        IExecutorHelper.OriginETH memory structData = abi.decode(data, (IExecutorHelper.OriginETH));
+        IExecutorHelperStruct.OriginETH memory structData = abi.decode(data, (IExecutorHelperStruct.OriginETH));
         structData.amount = uint128((uint256(structData.amount) * newAmount) / oldAmount);
         return abi.encode(structData);
     }
@@ -428,4 +409,113 @@ library ScalingDataLib {
 
         return abi.encode(isWrapAndAmount);
     }
+
+    function newPufferFinance(
+        bytes memory data,
+        uint256 oldAmount,
+        uint256 newAmount
+    ) internal pure returns (bytes memory) {
+        IExecutorHelperStruct.PufferFinance memory structData = abi.decode(data, (IExecutorHelperStruct.PufferFinance));
+        structData.permit.amount = uint128((uint256(structData.permit.amount) * newAmount) / oldAmount);
+        return abi.encode(structData);
+    }
+
+    function newKyberRfq(bytes memory data, uint256 oldAmount, uint256 newAmount) internal pure returns (bytes memory) {
+        IExecutorHelperStruct.KyberRFQ memory structData = abi.decode(data, (IExecutorHelperStruct.KyberRFQ));
+        structData.amount = (structData.amount * newAmount) / oldAmount;
+        return abi.encode(structData);
+    }
+
+    function newKyberLimitOrder(
+        bytes memory data,
+        uint256 oldAmount,
+        uint256 newAmount
+    ) internal pure returns (bytes memory) {
+        IExecutorHelperStruct.KyberLimitOrder memory structData = abi.decode(
+            data,
+            (IExecutorHelperStruct.KyberLimitOrder)
+        );
+        structData.params.takingAmount = (structData.params.takingAmount * newAmount) / oldAmount;
+        structData.params.thresholdAmount = 1;
+        return abi.encode(structData);
+    }
+
+    function newKyberDSLO(
+        bytes memory data,
+        uint256 oldAmount,
+        uint256 newAmount
+    ) internal pure returns (bytes memory) {
+        IExecutorHelperStruct.KyberDSLO memory structData = abi.decode(data, (IExecutorHelperStruct.KyberDSLO));
+        structData.params.takingAmount = (structData.params.takingAmount * newAmount) / oldAmount;
+        structData.params.thresholdAmount = 1;
+        return abi.encode(structData);
+    }
+
+    function newNative(bytes memory data, uint256 oldAmount, uint256 newAmount) internal pure returns (bytes memory) {
+        require(newAmount < oldAmount, "Native: not support scale up");
+
+        IExecutorHelperStruct.Native memory structData = abi.decode(data, (IExecutorHelperStruct.Native));
+
+        require(structData.multihopAndOffset >> 255 == 0, "Native: Multihop not supported");
+
+        structData.amount = (structData.amount * newAmount) / oldAmount;
+
+        uint256 amountInOffset = uint256(uint64(structData.multihopAndOffset >> 64));
+        uint256 amountOutMinOffset = uint256(uint64(structData.multihopAndOffset));
+        bytes memory newCallData = structData.data;
+
+        newCallData = newCallData.update(structData.amount, amountInOffset);
+
+        // update amount out min if needed
+        if (amountOutMinOffset != 0) {
+            newCallData = newCallData.update(1, amountOutMinOffset);
+        }
+
+        return abi.encode(structData);
+    }
+
+    function newHashflow(bytes memory data, uint256 oldAmount, uint256 newAmount) internal pure returns (bytes memory) {
+        IExecutorHelperStruct.Hashflow memory structData = abi.decode(data, (IExecutorHelperStruct.Hashflow));
+        structData.quote.effectiveBaseTokenAmount = (structData.quote.effectiveBaseTokenAmount * newAmount) / oldAmount;
+        return abi.encode(structData);
+    }
+
+    function newBebop(bytes memory data, uint256 oldAmount, uint256 newAmount) internal pure returns (bytes memory) {
+        require(newAmount < oldAmount, "Bebop: not support scale up");
+
+        IExecutorHelperStruct.Bebop memory structData = abi.decode(data, (IExecutorHelperStruct.Bebop));
+
+        structData.amount = (structData.amount * newAmount) / oldAmount;
+
+        // update calldata with new swap amount
+        (bytes4 selector, bytes memory callData) = structData.data.splitCalldata();
+
+        (IBebopV3.Single memory s, IBebopV3.MakerSignature memory m, ) = abi.decode(
+            callData,
+            (IBebopV3.Single, IBebopV3.MakerSignature, uint256)
+        );
+        structData.data = bytes.concat(bytes4(selector), abi.encode(s, m, structData.amount));
+
+        return abi.encode(structData);
+    }
+
+    function newSymbioticLRT(
+        bytes memory data,
+        uint256 oldAmount,
+        uint256 newAmount
+    ) internal pure returns (bytes memory) {
+        IExecutorHelperStruct.SymbioticLRT memory structData = abi.decode(data, (IExecutorHelperStruct.SymbioticLRT));
+        structData.amount = (structData.amount * newAmount) / oldAmount;
+        return abi.encode(structData);
+    }
+
+    function newMaverickV2(
+        bytes memory data,
+        uint256 oldAmount,
+        uint256 newAmount
+    ) internal pure returns (bytes memory) {
+        IExecutorHelperStruct.MaverickV2 memory structData = abi.decode(data, (IExecutorHelperStruct.MaverickV2));
+        structData.collectAmount = (structData.collectAmount * newAmount) / oldAmount;
+        return abi.encode(structData);
+    }
 }

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

@@ -1,7 +1,35 @@
-// SPDX-License-Identifier: MIT
 pragma solidity ^0.8.0;
 
 library BytesHelper {
+    function splitCalldata(bytes memory data) internal pure returns (bytes4 selector, bytes memory functionCalldata) {
+        require(data.length >= 4, "Calldata too short");
+
+        // Extract the selector
+        assembly {
+            selector := mload(add(data, 32))
+        }
+        // Extract the function calldata
+        functionCalldata = new bytes(data.length - 4);
+        for (uint256 i = 0; i < data.length - 4; i++) {
+            functionCalldata[i] = data[i + 4];
+        }
+    }
+
+    function writeBytes(
+        bytes memory originalCalldata,
+        uint256 index,
+        bytes memory value
+    ) internal pure returns (bytes memory) {
+        require(index + value.length <= originalCalldata.length, "Offset out of bounds");
+
+        // Update the value length bytes at the specified offset with the new value
+        for (uint256 i; i < value.length; ++i) {
+            originalCalldata[index + i] = value[i];
+        }
+
+        return originalCalldata;
+    }
+
     function write16Bytes(bytes memory original, uint256 index, bytes16 value) internal pure returns (bytes memory) {
         assembly {
             let offset := add(original, add(index, 32))
@@ -26,4 +54,40 @@ library BytesHelper {
         require(value <= type(uint128).max, string(abi.encodePacked(errorMsg, "/Exceed compressed type range")));
         return write16Bytes(original, index, uint128(value));
     }
+
+    /**
+     * @dev Writes a 32-byte value into the specified index of a bytes array.
+     * @param original The original bytes array.
+     * @param index The index in the bytes array where the 32-byte value should be written.
+     * @param value The 32-byte value to write.
+     * @return The modified bytes array.
+     */
+    function write32Bytes(bytes memory original, uint256 index, bytes32 value) internal pure returns (bytes memory) {
+        assembly {
+            let offset := add(add(original, 32), index)
+            mstore(offset, value) // Store the 32-byte value directly at the specified offset
+        }
+        return original;
+    }
+
+    /**
+     * @dev Overloaded function to write a uint256 value as a 32-byte value.
+     * @param original The original bytes array.
+     * @param index The index in the bytes array where the 32-byte value should be written.
+     * @param value The uint256 value to write.
+     * @return The modified bytes array.
+     */
+    function write32Bytes(bytes memory original, uint256 index, uint256 value) internal pure returns (bytes memory) {
+        return write32Bytes(original, index, bytes32(value));
+    }
+
+    function write32Bytes(
+        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 write32Bytes(original, index, value);
+    }
 }