@pendle/core-v2 1.2.0-mainnet → 1.4.0-mainnet

package/contracts/router/kyberswap/AggregationRouterHelper.sol

@@ -1,12 +1,19 @@
 // SPDX-License-Identifier: MIT
 
 pragma solidity 0.8.17;
-import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
-import "./IMultihopRouterEthereum.sol";
-import "./IAggregatorRouterHelper.sol";
 import "@openzeppelin/contracts/proxy/utils/UUPSUpgradeable.sol";
 import "../../core/libraries/BoringOwnableUpgradeable.sol";
 
+import "../../interfaces/IWETH.sol";
+
+import "./interfaces/IMetaAggregationRouter.sol";
+import "./interfaces/IMetaAggregationRouterV2.sol";
+import "./interfaces/IHashflow.sol";
+import "./interfaces/IExecutorHelperEthereum1.sol";
+
+import "./IAggregatorRouterHelper.sol";
+import "./ScaleDataHelperEthereum1.sol";
+
 contract AggregationRouterHelper is
     IAggregationRouterHelper,
     Initializable,
@@ -20,8 +27,6 @@ contract AggregationRouterHelper is
     uint256 private constant _BURN_FROM_TX_ORIGIN = 0x10;
     uint256 private constant _SIMPLE_SWAP = 0x20;
 
-    uint256 private constant SLIPPAGE_RANGE = 10; // over 100
-
     constructor() initializer {}
 
     function initialize() external initializer {
@@ -30,29 +35,9 @@ contract AggregationRouterHelper is
 
     function _authorizeUpgrade(address newImplementation) internal override onlyOwner {}
 
-    enum DexType {
-        UNI,
-        STABLESWAP,
-        CURVE,
-        KYBERDMM,
-        SADDLE,
-        UNIV3PROMM,
-        BALANCERV2,
-        KYBERRFQ,
-        DODO,
-        WSTETH
-    }
-
-    struct SwapDescription {
-        IERC20 srcToken;
-        IERC20 dstToken;
-        address[] srcReceivers;
-        uint256[] srcAmounts;
-        address dstReceiver;
-        uint256 amount;
-        uint256 minReturnAmount;
-        uint256 flags;
-        bytes permit;
+    struct Swap {
+        bytes data;
+        bytes4 selector;
     }
 
     struct SimpleSwapData {
@@ -64,7 +49,7 @@ contract AggregationRouterHelper is
     }
 
     struct SwapExecutorDescription {
-        IMultihopRouterEthereum.Swap[][] swapSequences;
+        Swap[][] swapSequences;
         address tokenIn;
         address tokenOut;
         uint256 minTotalAmountOut;
@@ -79,47 +64,129 @@ contract AggregationRouterHelper is
         returns (bytes memory)
     {
         bytes4 selector = bytes4(kybercall[:4]);
-        (
-            address caller,
-            SwapDescription memory desc,
-            bytes memory executorData,
-            bytes memory clientData
-        ) = abi.decode(kybercall[4:], (address, SwapDescription, bytes, bytes));
-
-        (desc, executorData) = _getScaledInputData(desc, executorData, newAmount);
-        return abi.encodeWithSelector(selector, caller, desc, executorData, clientData);
+
+        if (selector == IWETH.deposit.selector) {
+            return kybercall; // no scaling needed
+        }
+
+        if (selector == IWETH.withdraw.selector) {
+            return abi.encodeWithSelector(selector, newAmount);
+        }
+
+        if (
+            selector == IMetaAggregationRouter.swap.selector ||
+            selector == IMetaAggregationRouter.swapSimpleMode.selector
+        ) {
+            (
+                address callTarget,
+                IMetaAggregationRouter.SwapDescription memory desc,
+                bytes memory targetData,
+                bytes memory clientData
+            ) = abi.decode(
+                    kybercall[4:],
+                    (address, IMetaAggregationRouter.SwapDescription, bytes, bytes)
+                );
+
+            (desc, targetData) = _getScaledInputDataV1(
+                desc,
+                targetData,
+                newAmount,
+                selector == IMetaAggregationRouter.swapSimpleMode.selector ||
+                    _flagsChecked(desc.flags, _SIMPLE_SWAP)
+            );
+            return abi.encodeWithSelector(selector, callTarget, desc, targetData, clientData);
+        }
+
+        if (selector == IMetaAggregationRouterV2.swap.selector) {
+            IMetaAggregationRouterV2.SwapExecutionParams memory params = abi.decode(
+                kybercall[4:],
+                (IMetaAggregationRouterV2.SwapExecutionParams)
+            );
+
+            (params.desc, params.targetData) = _getScaledInputDataV2(
+                params.desc,
+                params.targetData,
+                newAmount,
+                _flagsChecked(params.desc.flags, _SIMPLE_SWAP)
+            );
+            return abi.encodeWithSelector(selector, params);
+        }
+
+        if (selector == IMetaAggregationRouterV2.swapSimpleMode.selector) {
+            (
+                address callTarget,
+                IMetaAggregationRouterV2.SwapDescriptionV2 memory desc,
+                bytes memory targetData,
+                bytes memory clientData
+            ) = abi.decode(
+                    kybercall[4:],
+                    (address, IMetaAggregationRouterV2.SwapDescriptionV2, bytes, bytes)
+                );
+
+            (desc, targetData) = _getScaledInputDataV2(desc, targetData, newAmount, true);
+            return abi.encodeWithSelector(selector, callTarget, desc, targetData, clientData);
+        }
+
+        revert("InputScalingHelper: Invalid selector");
     }
 
-    function _getScaledInputData(
-        SwapDescription memory desc,
+    function _getScaledInputDataV1(
+        IMetaAggregationRouter.SwapDescription memory desc,
         bytes memory executorData,
-        uint256 newAmount
-    ) internal pure returns (SwapDescription memory, bytes memory) {
-        uint256 flags = desc.flags;
+        uint256 newAmount,
+        bool isSimpleMode
+    ) internal pure returns (IMetaAggregationRouter.SwapDescription memory, bytes memory) {
         uint256 oldAmount = desc.amount;
         if (oldAmount == newAmount) {
             return (desc, executorData);
         }
 
         // simple mode swap
-        if (flags & _SIMPLE_SWAP != 0) {
-            require(desc.srcReceivers.length == 0, "kyber: can't scale if take fee");
+        if (isSimpleMode) {
             return (
-                _getNewDescription(desc, oldAmount, newAmount),
-                _getNewSimpleSwapData(executorData, oldAmount, newAmount)
+                _scaledSwapDescriptionV1(desc, oldAmount, newAmount),
+                _scaledSimpleSwapData(executorData, oldAmount, newAmount)
             );
         }
 
         //normal mode swap
-        bytes memory newExecutorData = _getNewExecutorData(executorData, oldAmount, newAmount);
-        return (_getNewDescription(desc, oldAmount, newAmount), newExecutorData);
+        return (
+            _scaledSwapDescriptionV1(desc, oldAmount, newAmount),
+            _scaledExecutorCallBytesData(executorData, oldAmount, newAmount)
+        );
     }
 
-    function _getNewDescription(
-        SwapDescription memory desc,
+    function _getScaledInputDataV2(
+        IMetaAggregationRouterV2.SwapDescriptionV2 memory desc,
+        bytes memory executorData,
+        uint256 newAmount,
+        bool isSimpleMode
+    ) internal pure returns (IMetaAggregationRouterV2.SwapDescriptionV2 memory, bytes memory) {
+        uint256 oldAmount = desc.amount;
+        if (oldAmount == newAmount) {
+            return (desc, executorData);
+        }
+
+        // simple mode swap
+        if (isSimpleMode) {
+            return (
+                _scaledSwapDescriptionV2(desc, oldAmount, newAmount),
+                _scaledSimpleSwapData(executorData, oldAmount, newAmount)
+            );
+        }
+
+        //normal mode swap
+        return (
+            _scaledSwapDescriptionV2(desc, oldAmount, newAmount),
+            _scaledExecutorCallBytesData(executorData, oldAmount, newAmount)
+        );
+    }
+
+    function _scaledSwapDescriptionV1(
+        IMetaAggregationRouter.SwapDescription memory desc,
         uint256 oldAmount,
         uint256 newAmount
-    ) internal pure returns (SwapDescription memory) {
+    ) internal pure returns (IMetaAggregationRouter.SwapDescription memory) {
         uint256 oldMinReturnAmount = desc.minReturnAmount;
         desc.minReturnAmount = (desc.minReturnAmount * newAmount) / oldAmount;
         //newMinReturnAmount should no be 0 if oldMinReturnAmount > 0
@@ -141,7 +208,7 @@ contract AggregationRouterHelper is
         return desc;
     }
 
-    function _getNewSimpleSwapData(
+    function _scaledSimpleSwapData(
         bytes memory data,
         uint256 oldAmount,
         uint256 newAmount
@@ -162,170 +229,89 @@ contract AggregationRouterHelper is
         return abi.encode(swapData);
     }
 
-    function _getNewExecutorData(
+    function _scaledExecutorCallBytesData(
         bytes memory data,
         uint256 oldAmount,
         uint256 newAmount
     ) internal pure returns (bytes memory) {
-        SwapExecutorDescription memory swapExecutorDescription = abi.decode(
-            data,
-            (SwapExecutorDescription)
-        );
-        swapExecutorDescription.minTotalAmountOut =
-            (swapExecutorDescription.minTotalAmountOut * newAmount) /
-            oldAmount;
+        SwapExecutorDescription memory executorDesc = abi.decode(data, (SwapExecutorDescription));
+        executorDesc.minTotalAmountOut = (executorDesc.minTotalAmountOut * newAmount) / oldAmount;
+        for (uint256 i = 0; i < executorDesc.swapSequences.length; i++) {
+            Swap memory swap = executorDesc.swapSequences[i][0];
+            bytes4 selector = swap.selector;
 
-        uint256 newTotalSwapAmount;
-        for (uint256 i = 0; i < swapExecutorDescription.swapSequences.length; i++) {
-            IMultihopRouterEthereum.Swap memory swap = swapExecutorDescription.swapSequences[i][0];
-            uint8 dexType = uint8(swap.dexOption >> 8);
-            uint256 value;
-            if (i == swapExecutorDescription.swapSequences.length - 1)
-                value = newAmount - newTotalSwapAmount;
-
-            if (dexType == uint8(DexType.UNI)) {
-                (swap.data, value) = _newUniSwap(swap.data, value, oldAmount, newAmount);
-            } else if (dexType == uint8(DexType.STABLESWAP) || dexType == uint8(DexType.SADDLE)) {
-                (swap.data, value) = _newStableSwap(swap.data, value, oldAmount, newAmount);
-            } else if (dexType == uint8(DexType.CURVE)) {
-                (swap.data, value) = _newCurveSwap(swap.data, value, oldAmount, newAmount);
-            } else if (dexType == uint8(DexType.KYBERDMM)) {
-                (swap.data, value) = _newKyberDMMSwap(swap.data, value, oldAmount, newAmount);
-            } else if (dexType == uint8(DexType.UNIV3PROMM)) {
-                (swap.data, value) = _newUniV3ProMMSwap(swap.data, value, oldAmount, newAmount);
-            } else if (dexType == uint8(DexType.BALANCERV2)) {
-                (swap.data, value) = _newBalancerV2Swap(swap.data, value, oldAmount, newAmount);
-            } else if (dexType == uint8(DexType.KYBERRFQ)) {
-                revert("kyber: can't scale kyberrfq");
-            } else if (dexType == uint8(DexType.DODO)) {
-                (swap.data, value) = _newDODOSwap(swap.data, value, oldAmount, newAmount);
-            } else if (dexType == uint8(DexType.WSTETH)) {
-                (swap.data, value) = _newWrappedstETHSwap(swap.data, value, oldAmount, newAmount);
-            } else {
-                revert("AggregationExecutor: Dex type not supported");
-            }
-            newTotalSwapAmount += value;
+            if (selector == IExecutorHelperEthereum1.executeUniSwap.selector) {
+                swap.data = ScaleDataHelperEthereum1.newUniSwap(swap.data, oldAmount, newAmount);
+            } else if (selector == IExecutorHelperEthereum1.executeStableSwap.selector) {
+                swap.data = ScaleDataHelperEthereum1.newStableSwap(
+                    swap.data,
+                    oldAmount,
+                    newAmount
+                );
+            } else if (selector == IExecutorHelperEthereum1.executeCurveSwap.selector) {
+                swap.data = ScaleDataHelperEthereum1.newCurveSwap(swap.data, oldAmount, newAmount);
+            } else if (selector == IExecutorHelperEthereum1.executeKyberDMMSwap.selector) {
+                swap.data = ScaleDataHelperEthereum1.newKyberDMM(swap.data, oldAmount, newAmount);
+            } else if (selector == IExecutorHelperEthereum1.executeUniV3ProMMSwap.selector) {
+                swap.data = ScaleDataHelperEthereum1.newUniV3ProMM(
+                    swap.data,
+                    oldAmount,
+                    newAmount
+                );
+            } else if (selector == IExecutorHelperEthereum1.executeRfqSwap.selector) {
+                revert("InputScalingHelper: Can not scale RFQ swap");
+            } else if (selector == IExecutorHelperEthereum1.executeBalV2Swap.selector) {
+                swap.data = ScaleDataHelperEthereum1.newBalancerV2(
+                    swap.data,
+                    oldAmount,
+                    newAmount
+                );
+            } else if (selector == IExecutorHelperEthereum1.executeDODOSwap.selector) {
+                swap.data = ScaleDataHelperEthereum1.newDODO(swap.data, oldAmount, newAmount);
+            } else if (selector == IExecutorHelperEthereum1.executeWrappedstETHSwap.selector) {
+                swap.data = ScaleDataHelperEthereum1.newWrappedstETHSwap(
+                    swap.data,
+                    oldAmount,
+                    newAmount
+                );
+            } else if (selector == IExecutorHelperEthereum1.executeSynthetixSwap.selector) {
+                swap.data = ScaleDataHelperEthereum1.newSynthetix(swap.data, oldAmount, newAmount);
+            } else if (selector == IExecutorHelperEthereum1.executePSMSwap.selector) {
+                swap.data = ScaleDataHelperEthereum1.newPSM(swap.data, oldAmount, newAmount);
+            } else if (selector == IExecutorHelperEthereum1.executeHashflowSwap.selector) {
+                revert("InputScalingHelper: Can not scale RFQ swap");
+            } else revert("AggregationExecutor: Dex type not supported");
         }
-        return abi.encode(swapExecutorDescription);
+        return abi.encode(executorDesc);
     }
 
-    function _newUniSwap(
-        bytes memory data,
-        uint256 value,
-        uint256 oldAmount,
-        uint256 newAmount
-    ) internal pure returns (bytes memory, uint256) {
-        IMultihopRouterEthereum.UniSwap memory uniSwap = abi.decode(
-            data,
-            (IMultihopRouterEthereum.UniSwap)
-        );
-        if (value > 0) uniSwap.collectAmount = value;
-        else uniSwap.collectAmount = (uniSwap.collectAmount * newAmount) / oldAmount;
-        return (abi.encode(uniSwap), uniSwap.collectAmount);
-    }
-
-    function _newStableSwap(
-        bytes memory data,
-        uint256 value,
+    function _scaledSwapDescriptionV2(
+        IMetaAggregationRouterV2.SwapDescriptionV2 memory desc,
         uint256 oldAmount,
         uint256 newAmount
-    ) internal pure returns (bytes memory, uint256) {
-        IMultihopRouterEthereum.StableSwap memory stableSwap = abi.decode(
-            data,
-            (IMultihopRouterEthereum.StableSwap)
-        );
-        if (value > 0) stableSwap.dx = value;
-        else stableSwap.dx = (stableSwap.dx * newAmount) / oldAmount;
-        return (abi.encode(stableSwap), stableSwap.dx);
-    }
-
-    function _newCurveSwap(
-        bytes memory data,
-        uint256 value,
-        uint256 oldAmount,
-        uint256 newAmount
-    ) internal pure returns (bytes memory, uint256) {
-        IMultihopRouterEthereum.CurveSwap memory curveSwap = abi.decode(
-            data,
-            (IMultihopRouterEthereum.CurveSwap)
-        );
-        if (value > 0) curveSwap.dx = value;
-        else curveSwap.dx = (curveSwap.dx * newAmount) / oldAmount;
-        return (abi.encode(curveSwap), curveSwap.dx);
-    }
-
-    function _newKyberDMMSwap(
-        bytes memory data,
-        uint256 value,
-        uint256 oldAmount,
-        uint256 newAmount
-    ) internal pure returns (bytes memory, uint256) {
-        IMultihopRouterEthereum.UniSwap memory kyberDMMSwap = abi.decode(
-            data,
-            (IMultihopRouterEthereum.UniSwap)
-        );
-        if (value > 0) kyberDMMSwap.collectAmount = value;
-        else kyberDMMSwap.collectAmount = (kyberDMMSwap.collectAmount * newAmount) / oldAmount;
-        return (abi.encode(kyberDMMSwap), kyberDMMSwap.collectAmount);
-    }
-
-    function _newUniV3ProMMSwap(
-        bytes memory data,
-        uint256 value,
-        uint256 oldAmount,
-        uint256 newAmount
-    ) internal pure returns (bytes memory, uint256) {
-        IMultihopRouterEthereum.UniSwapV3ProMM memory uniSwapV3ProMM = abi.decode(
-            data,
-            (IMultihopRouterEthereum.UniSwapV3ProMM)
-        );
-        if (value > 0) uniSwapV3ProMM.swapAmount = value;
-        else uniSwapV3ProMM.swapAmount = (uniSwapV3ProMM.swapAmount * newAmount) / oldAmount;
-        return (abi.encode(uniSwapV3ProMM), uniSwapV3ProMM.swapAmount);
-    }
-
-    function _newBalancerV2Swap(
-        bytes memory data,
-        uint256 value,
-        uint256 oldAmount,
-        uint256 newAmount
-    ) internal pure returns (bytes memory, uint256) {
-        IMultihopRouterEthereum.BalancerV2 memory balancerV2 = abi.decode(
-            data,
-            (IMultihopRouterEthereum.BalancerV2)
-        );
-        if (value > 0) balancerV2.amount = value;
-        else balancerV2.amount = (balancerV2.amount * newAmount) / oldAmount;
-        return (abi.encode(balancerV2, balancerV2.amount), balancerV2.amount);
-    }
+    ) internal pure returns (IMetaAggregationRouterV2.SwapDescriptionV2 memory) {
+        uint256 oldMinReturnAmount = desc.minReturnAmount;
+        desc.minReturnAmount = (desc.minReturnAmount * newAmount) / oldAmount;
+        //newMinReturnAmount should no be 0 if oldMinReturnAmount > 0
+        if (oldMinReturnAmount > 0 && desc.minReturnAmount == 0) desc.minReturnAmount = 1;
+        desc.amount = newAmount;
+        if (desc.srcReceivers.length == 0) {
+            return desc;
+        }
 
-    function _newDODOSwap(
-        bytes memory data,
-        uint256 value,
-        uint256 oldAmount,
-        uint256 newAmount
-    ) internal pure returns (bytes memory, uint256) {
-        IMultihopRouterEthereum.DODO memory dodo = abi.decode(
-            data,
-            (IMultihopRouterEthereum.DODO)
-        );
-        if (value > 0) dodo.amount = value;
-        else dodo.amount = (dodo.amount * newAmount) / oldAmount;
-        return (abi.encode(dodo), dodo.amount);
+        uint256 newTotal;
+        for (uint256 i = 0; i < desc.srcReceivers.length; i++) {
+            if (i == desc.srcReceivers.length - 1) {
+                desc.srcAmounts[i] = newAmount - newTotal;
+            } else {
+                desc.srcAmounts[i] = (desc.srcAmounts[i] * newAmount) / oldAmount;
+            }
+            newTotal += desc.srcAmounts[i];
+        }
+        return desc;
     }
 
-    function _newWrappedstETHSwap(
-        bytes memory data,
-        uint256 value,
-        uint256 oldAmount,
-        uint256 newAmount
-    ) internal pure returns (bytes memory, uint256) {
-        IMultihopRouterEthereum.WSTETH memory wstEthData = abi.decode(
-            data,
-            (IMultihopRouterEthereum.WSTETH)
-        );
-        if (value > 0) wstEthData.amount = value;
-        else wstEthData.amount = (wstEthData.amount * newAmount) / oldAmount;
-        return (abi.encode(wstEthData), wstEthData.amount);
+    function _flagsChecked(uint256 number, uint256 flag) internal pure returns (bool) {
+        return number & flag != 0;
     }
 }

package/contracts/router/kyberswap/ScaleDataHelperEthereum1.sol

@@ -0,0 +1,134 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.17;
+
+import "./interfaces/IExecutorHelperEthereum1.sol";
+
+library ScaleDataHelperEthereum1 {
+    function newUniSwap(
+        bytes memory data,
+        uint256 oldAmount,
+        uint256 newAmount
+    ) internal pure returns (bytes memory) {
+        IExecutorHelperEthereum1.UniSwap memory uniSwap = abi.decode(
+            data,
+            (IExecutorHelperEthereum1.UniSwap)
+        );
+        uniSwap.collectAmount = (uniSwap.collectAmount * newAmount) / oldAmount;
+        return abi.encode(uniSwap);
+    }
+
+    function newStableSwap(
+        bytes memory data,
+        uint256 oldAmount,
+        uint256 newAmount
+    ) internal pure returns (bytes memory) {
+        IExecutorHelperEthereum1.StableSwap memory stableSwap = abi.decode(
+            data,
+            (IExecutorHelperEthereum1.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) {
+        IExecutorHelperEthereum1.CurveSwap memory curveSwap = abi.decode(
+            data,
+            (IExecutorHelperEthereum1.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) {
+        IExecutorHelperEthereum1.UniSwap memory kyberDMMSwap = abi.decode(
+            data,
+            (IExecutorHelperEthereum1.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) {
+        IExecutorHelperEthereum1.UniSwapV3ProMM memory uniSwapV3ProMM = abi.decode(
+            data,
+            (IExecutorHelperEthereum1.UniSwapV3ProMM)
+        );
+        uniSwapV3ProMM.swapAmount = (uniSwapV3ProMM.swapAmount * newAmount) / oldAmount;
+
+        return abi.encode(uniSwapV3ProMM);
+    }
+
+    function newBalancerV2(
+        bytes memory data,
+        uint256 oldAmount,
+        uint256 newAmount
+    ) internal pure returns (bytes memory) {
+        IExecutorHelperEthereum1.BalancerV2 memory balancerV2 = abi.decode(
+            data,
+            (IExecutorHelperEthereum1.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) {
+        IExecutorHelperEthereum1.DODO memory dodo = abi.decode(
+            data,
+            (IExecutorHelperEthereum1.DODO)
+        );
+        dodo.amount = (dodo.amount * newAmount) / oldAmount;
+        return abi.encode(dodo);
+    }
+
+    function newSynthetix(
+        bytes memory data,
+        uint256 oldAmount,
+        uint256 newAmount
+    ) internal pure returns (bytes memory) {
+        IExecutorHelperEthereum1.Synthetix memory synthetix = abi.decode(
+            data,
+            (IExecutorHelperEthereum1.Synthetix)
+        );
+        synthetix.sourceAmount = (synthetix.sourceAmount * newAmount) / oldAmount;
+        return abi.encode(synthetix);
+    }
+
+    function newWrappedstETHSwap(
+        bytes memory data,
+        uint256 oldAmount,
+        uint256 newAmount
+    ) internal pure returns (bytes memory) {
+        IExecutorHelperEthereum1.WSTETH memory wstEthData = abi.decode(
+            data,
+            (IExecutorHelperEthereum1.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) {
+        IExecutorHelperEthereum1.PSM memory psm = abi.decode(data, (IExecutorHelperEthereum1.PSM));
+        psm.amountIn = (psm.amountIn * newAmount) / oldAmount;
+        return abi.encode(psm);
+    }
+}

package/contracts/router/kyberswap/interfaces/IAggregationExecutor.sol

@@ -0,0 +1,17 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity >=0.6.12;
+
+interface IAggregationExecutor {
+  function callBytes(bytes calldata data) external payable; // 0xd9c45357
+
+  // callbytes per swap sequence
+  function swapSingleSequence(bytes calldata data) external;
+
+  function finalTransactionProcessing(
+    address tokenIn,
+    address tokenOut,
+    address to,
+    bytes calldata destTokenFeeData
+  ) external;
+}