@pendle/core-v2 2.29.4 → 2.30.1

package/contracts/router/base/MarketApproxLib.sol

@@ -61,8 +61,7 @@ library MarketApproxPtInLib {
             (uint256 netSyOut, uint256 netSyFee, ) = calcSyOut(market, comp, index, guess);
 
             if (netSyOut >= minSyOut) {
-                if (PMath.isAGreaterApproxB(netSyOut, minSyOut, approx.eps))
-                    return (guess, netSyOut, netSyFee);
+                if (PMath.isAGreaterApproxB(netSyOut, minSyOut, approx.eps)) return (guess, netSyOut, netSyFee);
                 approx.guessMax = guess;
             } else {
                 approx.guessMin = guess;
@@ -107,8 +106,7 @@ library MarketApproxPtInLib {
             uint256 netSyToPull = netSyToTokenizePt - netSyOut;
 
             if (netSyToPull <= exactSyIn) {
-                if (PMath.isASmallerApproxB(netSyToPull, exactSyIn, approx.eps))
-                    return (guess, netSyFee);
+                if (PMath.isASmallerApproxB(netSyToPull, exactSyIn, approx.eps)) return (guess, netSyFee);
                 approx.guessMin = guess;
             } else {
                 approx.guessMax = guess - 1;
@@ -131,11 +129,7 @@ library MarketApproxPtInLib {
         uint256 totalPtIn,
         uint256 blockTime,
         ApproxParams memory approx
-    )
-        internal
-        pure
-        returns (uint256 /*netPtSwap*/, uint256 /*netSyFromSwap*/, uint256 /*netSyFee*/)
-    {
+    ) internal pure returns (uint256 /*netPtSwap*/, uint256 /*netSyFromSwap*/, uint256 /*netSyFee*/) {
         MarketPreCompute memory comp = market.getMarketPreCompute(index, blockTime);
         if (approx.guessOffchain == 0) {
             // no limit on min
@@ -148,16 +142,15 @@ library MarketApproxPtInLib {
         for (uint256 iter = 0; iter < approx.maxIteration; ++iter) {
             uint256 guess = nextGuess(approx, iter);
 
-            (
-                uint256 syNumerator,
-                uint256 ptNumerator,
-                uint256 netSyOut,
-                uint256 netSyFee,
-
-            ) = calcNumerators(market, index, totalPtIn, comp, guess);
+            (uint256 syNumerator, uint256 ptNumerator, uint256 netSyOut, uint256 netSyFee, ) = calcNumerators(
+                market,
+                index,
+                totalPtIn,
+                comp,
+                guess
+            );
 
-            if (PMath.isAApproxB(syNumerator, ptNumerator, approx.eps))
-                return (guess, netSyOut, netSyFee);
+            if (PMath.isAApproxB(syNumerator, ptNumerator, approx.eps)) return (guess, netSyOut, netSyFee);
 
             if (syNumerator <= ptNumerator) {
                 // needs more SY --> swap more PT
@@ -179,13 +172,7 @@ library MarketApproxPtInLib {
     )
         internal
         pure
-        returns (
-            uint256 syNumerator,
-            uint256 ptNumerator,
-            uint256 netSyOut,
-            uint256 netSyFee,
-            uint256 netSyToReserve
-        )
+        returns (uint256 syNumerator, uint256 ptNumerator, uint256 netSyOut, uint256 netSyFee, uint256 netSyToReserve)
     {
         (netSyOut, netSyFee, netSyToReserve) = calcSyOut(market, comp, index, guess);
 
@@ -223,11 +210,7 @@ library MarketApproxPtInLib {
         uint256 exactPtIn,
         uint256 blockTime,
         ApproxParams memory approx
-    )
-        internal
-        pure
-        returns (uint256 /*netYtOut*/, uint256 /*totalPtToSwap*/, uint256 /*netSyFee*/)
-    {
+    ) internal pure returns (uint256 /*netYtOut*/, uint256 /*totalPtToSwap*/, uint256 /*netSyFee*/) {
         MarketPreCompute memory comp = market.getMarketPreCompute(index, blockTime);
         if (approx.guessOffchain == 0) {
             approx.guessMin = PMath.max(approx.guessMin, exactPtIn);
@@ -246,8 +229,7 @@ library MarketApproxPtInLib {
             uint256 netPtToPull = guess - netAssetOut;
 
             if (netPtToPull <= exactPtIn) {
-                if (PMath.isASmallerApproxB(netPtToPull, exactPtIn, approx.eps))
-                    return (netAssetOut, guess, netSyFee);
+                if (PMath.isASmallerApproxB(netPtToPull, exactPtIn, approx.eps)) return (netAssetOut, guess, netSyFee);
                 approx.guessMin = guess;
             } else {
                 approx.guessMax = guess - 1;
@@ -264,11 +246,7 @@ library MarketApproxPtInLib {
         PYIndex index,
         uint256 netPtIn
     ) internal pure returns (uint256 netSyOut, uint256 netSyFee, uint256 netSyToReserve) {
-        (int256 _netSyOut, int256 _netSyFee, int256 _netSyToReserve) = market.calcTrade(
-            comp,
-            index,
-            -int256(netPtIn)
-        );
+        (int256 _netSyOut, int256 _netSyFee, int256 _netSyToReserve) = market.calcTrade(comp, index, -int256(netPtIn));
         netSyOut = uint256(_netSyOut);
         netSyFee = uint256(_netSyFee);
         netSyToReserve = uint256(_netSyToReserve);
@@ -287,10 +265,7 @@ library MarketApproxPtInLib {
             revert Errors.ApproxParamsInvalid(approx.guessMin, approx.guessMax, approx.eps);
     }
 
-    function calcMaxPtIn(
-        MarketState memory market,
-        MarketPreCompute memory comp
-    ) internal pure returns (uint256) {
+    function calcMaxPtIn(MarketState memory market, MarketPreCompute memory comp) internal pure returns (uint256) {
         uint256 low = 0;
         uint256 hi = uint256(comp.totalAsset) - 1;
 
@@ -302,19 +277,13 @@ library MarketApproxPtInLib {
         return low;
     }
 
-    function calcSlope(
-        MarketPreCompute memory comp,
-        int256 totalPt,
-        int256 ptToMarket
-    ) internal pure returns (int256) {
+    function calcSlope(MarketPreCompute memory comp, int256 totalPt, int256 ptToMarket) internal pure returns (int256) {
         int256 diffAssetPtToMarket = comp.totalAsset - ptToMarket;
         int256 sumPt = ptToMarket + totalPt;
 
         require(diffAssetPtToMarket > 0 && sumPt > 0, "invalid ptToMarket");
 
-        int256 part1 = (ptToMarket * (totalPt + comp.totalAsset)).divDown(
-            sumPt * diffAssetPtToMarket
-        );
+        int256 part1 = (ptToMarket * (totalPt + comp.totalAsset)).divDown(sumPt * diffAssetPtToMarket);
 
         int256 part2 = sumPt.divDown(diffAssetPtToMarket).ln();
         int256 part3 = PMath.IONE.divDown(comp.rateScalar);
@@ -357,8 +326,7 @@ library MarketApproxPtOutLib {
             (uint256 netSyIn, uint256 netSyFee, ) = calcSyIn(market, comp, index, guess);
 
             if (netSyIn <= exactSyIn) {
-                if (PMath.isASmallerApproxB(netSyIn, exactSyIn, approx.eps))
-                    return (guess, netSyFee);
+                if (PMath.isASmallerApproxB(netSyIn, exactSyIn, approx.eps)) return (guess, netSyFee);
                 approx.guessMin = guess;
             } else {
                 approx.guessMax = guess - 1;
@@ -399,8 +367,7 @@ library MarketApproxPtOutLib {
             uint256 netSyOut = index.assetToSy(guess - netAssetToRepay);
 
             if (netSyOut >= minSyOut) {
-                if (PMath.isAGreaterApproxB(netSyOut, minSyOut, approx.eps))
-                    return (guess, netSyOut, netSyFee);
+                if (PMath.isAGreaterApproxB(netSyOut, minSyOut, approx.eps)) return (guess, netSyOut, netSyFee);
                 approx.guessMax = guess;
             } else {
                 approx.guessMin = guess + 1;
@@ -431,11 +398,7 @@ library MarketApproxPtOutLib {
         uint256 _totalSyIn,
         uint256 _blockTime,
         ApproxParams memory _approx
-    )
-        internal
-        pure
-        returns (uint256 /*netPtFromSwap*/, uint256 /*netSySwap*/, uint256 /*netSyFee*/)
-    {
+    ) internal pure returns (uint256 /*netPtFromSwap*/, uint256 /*netSySwap*/, uint256 /*netSyFee*/) {
         Args6 memory a = Args6(_market, _index, _totalSyIn, _blockTime, _approx);
 
         MarketPreCompute memory comp = a.market.getMarketPreCompute(a.index, a.blockTime);
@@ -449,12 +412,7 @@ library MarketApproxPtOutLib {
         for (uint256 iter = 0; iter < a.approx.maxIteration; ++iter) {
             uint256 guess = nextGuess(a.approx, iter);
 
-            (uint256 netSyIn, uint256 netSyFee, uint256 netSyToReserve) = calcSyIn(
-                a.market,
-                comp,
-                a.index,
-                guess
-            );
+            (uint256 netSyIn, uint256 netSyFee, uint256 netSyToReserve) = calcSyIn(a.market, comp, a.index, guess);
 
             if (netSyIn > a.totalSyIn) {
                 a.approx.guessMax = guess - 1;
@@ -477,8 +435,7 @@ library MarketApproxPtOutLib {
                 syNumerator = (a.totalSyIn - netSyIn) * newTotalPt;
             }
 
-            if (PMath.isAApproxB(ptNumerator, syNumerator, a.approx.eps))
-                return (guess, netSyIn, netSyFee);
+            if (PMath.isAApproxB(ptNumerator, syNumerator, a.approx.eps)) return (guess, netSyIn, netSyFee);
 
             if (ptNumerator <= syNumerator) {
                 // needs more PT
@@ -506,11 +463,7 @@ library MarketApproxPtOutLib {
         uint256 exactYtIn,
         uint256 blockTime,
         ApproxParams memory approx
-    )
-        internal
-        pure
-        returns (uint256 /*netPtOut*/, uint256 /*totalPtSwapped*/, uint256 /*netSyFee*/)
-    {
+    ) internal pure returns (uint256 /*netPtOut*/, uint256 /*totalPtSwapped*/, uint256 /*netSyFee*/) {
         MarketPreCompute memory comp = market.getMarketPreCompute(index, blockTime);
         if (approx.guessOffchain == 0) {
             approx.guessMin = PMath.max(approx.guessMin, exactYtIn);
@@ -544,11 +497,7 @@ library MarketApproxPtOutLib {
         PYIndex index,
         uint256 netPtOut
     ) internal pure returns (uint256 netSyIn, uint256 netSyFee, uint256 netSyToReserve) {
-        (int256 _netSyIn, int256 _netSyFee, int256 _netSyToReserve) = market.calcTrade(
-            comp,
-            index,
-            int256(netPtOut)
-        );
+        (int256 _netSyIn, int256 _netSyFee, int256 _netSyToReserve) = market.calcTrade(comp, index, int256(netPtOut));
 
         // all safe since totalPt and totalSy is int128
         netSyIn = uint256(-_netSyIn);
@@ -556,10 +505,7 @@ library MarketApproxPtOutLib {
         netSyToReserve = uint256(_netSyToReserve);
     }
 
-    function calcMaxPtOut(
-        MarketPreCompute memory comp,
-        int256 totalPt
-    ) internal pure returns (uint256) {
+    function calcMaxPtOut(MarketPreCompute memory comp, int256 totalPt) internal pure returns (uint256) {
         int256 logitP = (comp.feeRate - comp.rateAnchor).mulDown(comp.rateScalar).exp();
         int256 proportion = logitP.divDown(logitP + PMath.IONE);
         int256 numerator = proportion.mulDown(totalPt + comp.totalAsset);

package/contracts/router/swap-aggregator/PendleSwap.sol

@@ -1,29 +1,19 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.17;
+pragma solidity ^0.8.17;
 
 import "../../core/libraries/TokenHelper.sol";
 import "./IPSwapAggregator.sol";
-import "./kyberswap/KyberInputScalingHelper.sol";
+import "./kyberswap/l1-contracts/InputScalingHelper.sol";
+import "./kyberswap/l2-contracts/InputScalingHelperL2.sol";
 import "./oneinch/OneInchAggregationRouterHelper.sol";
 
-contract PendleSwap is
-    IPSwapAggregator,
-    TokenHelper,
-    KyberInputScalingHelper,
-    OneInchAggregationRouterHelper
-{
+abstract contract PendleSwapBase is IPSwapAggregator, TokenHelper, OneInchAggregationRouterHelper {
     using Address for address;
 
-    function swap(
-        address tokenIn,
-        uint256 amountIn,
-        SwapData calldata data
-    ) external payable {
+    function swap(address tokenIn, uint256 amountIn, SwapData calldata data) external payable {
         _safeApproveInf(tokenIn, data.extRouter);
         data.extRouter.functionCallWithValue(
-            data.needScale
-                ? _getScaledInputData(data.swapType, data.extCalldata, amountIn)
-                : data.extCalldata,
+            data.needScale ? _getScaledInputData(data.swapType, data.extCalldata, amountIn) : data.extCalldata,
             tokenIn == NATIVE ? amountIn : 0
         );
     }
@@ -42,5 +32,28 @@ contract PendleSwap is
         }
     }
 
+    function _getKyberScaledInputData(
+        bytes calldata rawCallData,
+        uint256 amountIn
+    ) internal pure virtual returns (bytes memory scaledCallData);
+
     receive() external payable {}
 }
+
+contract PendleSwapL1 is PendleSwapBase {
+    function _getKyberScaledInputData(
+        bytes calldata rawCallData,
+        uint256 amountIn
+    ) internal pure override returns (bytes memory) {
+        return InputScalingHelper._getScaledInputData(rawCallData, amountIn);
+    }
+}
+
+contract PendleSwapL2 is PendleSwapBase {
+    function _getKyberScaledInputData(
+        bytes calldata rawCallData,
+        uint256 amountIn
+    ) internal pure override returns (bytes memory) {
+        return InputScalingHelperL2._getScaledInputData(rawCallData, amountIn);
+    }
+}

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

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

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

@@ -0,0 +1,59 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity >=0.6.12;
+
+interface IAggregationExecutorOptimistic {
+    event Exchange(address pair, uint256 amountOut, address output);
+
+    struct Swap {
+        bytes data;
+        bytes4 functionSelector;
+    }
+
+    struct SwapCallbackData {
+        bytes path;
+        address payer;
+    }
+
+    struct SwapCallbackDataPath {
+        address pool;
+        address tokenIn;
+        address tokenOut;
+    }
+
+    struct PositiveSlippageFeeData {
+        uint256 partnerPSInfor; // [partnerReceiver (160 bit) + partnerPercent(96bits)]
+        uint256 expectedReturnAmount; // [minimumPSAmount (128 bits) + expectedReturnAmount (128 bits)]
+    }
+
+    struct SwapExecutorDescription {
+        Swap[][] swapSequences;
+        address tokenIn;
+        address tokenOut;
+        address to;
+        uint256 deadline;
+        bytes positiveSlippageData;
+    }
+
+    function rescueFunds(address token, uint256 amount) external;
+
+    function callBytes(bytes calldata data) external payable;
+
+    function swapSingleSequence(bytes calldata data) external;
+
+    function multihopBatchSwapExactIn(
+        Swap[][] memory swapSequences,
+        address tokenIn,
+        address tokenOut,
+        address to,
+        uint256 deadline,
+        bytes memory positiveSlippageData
+    ) external payable;
+
+    function finalTransactionProcessing(address tokenIn, address tokenOut, address to, bytes calldata destTokenFeeData)
+        external;
+
+    function updateExecutor(bytes4 functionSelector, address executor) external;
+
+    function updateBatchExecutors(bytes4[] memory functionSelectors, address[] memory executors) external;
+}

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

@@ -0,0 +1,320 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >=0.6.12;
+
+interface IExecutorHelper {
+    struct Swap {
+        bytes data;
+        bytes32 selectorAndFlags; // [selector (32 bits) + flags (224 bits)]; selector is 4 most significant bytes; flags are stored in 4 least significant bytes.
+    }
+
+    struct SwapExecutorDescription {
+        Swap[][] swapSequences;
+        address tokenIn;
+        address tokenOut;
+        uint256 minTotalAmountOut;
+        address to;
+        uint256 deadline;
+        bytes positiveSlippageData;
+    }
+
+    struct UniSwap {
+        address pool;
+        address tokenIn;
+        address tokenOut;
+        address recipient;
+        uint256 collectAmount; // amount that should be transferred to the pool
+        uint32 swapFee;
+        uint32 feePrecision;
+        uint32 tokenWeightInput;
+    }
+
+    struct StableSwap {
+        address pool;
+        address tokenFrom;
+        address tokenTo;
+        uint8 tokenIndexFrom;
+        uint8 tokenIndexTo;
+        uint256 dx;
+        uint256 poolLength;
+        address poolLp;
+        bool isSaddle; // true: saddle, false: stable
+    }
+
+    struct CurveSwap {
+        address pool;
+        address tokenFrom;
+        address tokenTo;
+        int128 tokenIndexFrom;
+        int128 tokenIndexTo;
+        uint256 dx;
+        bool usePoolUnderlying;
+        bool useTriCrypto;
+    }
+
+    struct UniswapV3KSElastic {
+        address recipient;
+        address pool;
+        address tokenIn;
+        address tokenOut;
+        uint256 swapAmount;
+        uint160 sqrtPriceLimitX96;
+        bool isUniV3; // true = UniV3, false = KSElastic
+    }
+
+    struct BalancerV2 {
+        address vault;
+        bytes32 poolId;
+        address assetIn;
+        address assetOut;
+        uint256 amount;
+    }
+
+    struct DODO {
+        address recipient;
+        address pool;
+        address tokenFrom;
+        address tokenTo;
+        uint256 amount;
+        address sellHelper;
+        bool isSellBase;
+        bool isVersion2;
+    }
+
+    struct GMX {
+        address vault;
+        address tokenIn;
+        address tokenOut;
+        uint256 amount;
+        address receiver;
+    }
+
+    struct Synthetix {
+        address synthetixProxy;
+        address tokenIn;
+        address tokenOut;
+        bytes32 sourceCurrencyKey;
+        uint256 sourceAmount;
+        bytes32 destinationCurrencyKey;
+        bool useAtomicExchange;
+    }
+
+    struct Platypus {
+        address pool;
+        address tokenIn;
+        address tokenOut;
+        address recipient;
+        uint256 collectAmount; // amount that should be transferred to the pool
+    }
+
+    struct PSM {
+        address router;
+        address tokenIn;
+        address tokenOut;
+        uint256 amountIn;
+        address recipient;
+    }
+
+    struct WSTETH {
+        address pool;
+        uint256 amount;
+        bool isWrapping;
+    }
+
+    struct Maverick {
+        address pool;
+        address tokenIn;
+        address tokenOut;
+        address recipient;
+        uint256 swapAmount;
+        uint256 sqrtPriceLimitD18;
+    }
+
+    struct SyncSwap {
+        bytes _data;
+        address vault;
+        address tokenIn;
+        address pool;
+        uint256 collectAmount;
+    }
+
+    struct AlgebraV1 {
+        address recipient;
+        address pool;
+        address tokenIn;
+        address tokenOut;
+        uint256 swapAmount;
+        uint160 sqrtPriceLimitX96;
+        uint256 senderFeeOnTransfer; // [ FoT_FLAG(1 bit) ... SENDER_ADDRESS(160 bits) ]
+    }
+
+    struct BalancerBatch {
+        address vault;
+        bytes32[] poolIds;
+        address[] path; // swap path from assetIn to assetOut
+        bytes[] userDatas;
+        uint256 amountIn; // assetIn amount
+    }
+
+    struct Mantis {
+        address pool;
+        address tokenIn;
+        address tokenOut;
+        uint256 amount;
+        address recipient;
+    }
+
+    struct IziSwap {
+        address pool;
+        address tokenIn;
+        address tokenOut;
+        address recipient;
+        uint256 swapAmount;
+        int24 limitPoint;
+    }
+
+    struct TraderJoeV2 {
+        address recipient;
+        address pool;
+        address tokenIn;
+        address tokenOut;
+        uint256 collectAmount; // most significant 1 bit is to determine whether pool is v2.1, else v2.0
+    }
+
+    struct LevelFiV2 {
+        address pool;
+        address fromToken;
+        address toToken;
+        uint256 amountIn;
+        uint256 minAmountOut;
+        address recipient; // receive token out
+    }
+
+    struct GMXGLP {
+        address rewardRouter;
+        address stakedGLP;
+        address glpManager;
+        address yearnVault;
+        address tokenIn;
+        address tokenOut;
+        uint256 swapAmount;
+        address recipient;
+    }
+
+    struct Vooi {
+        address pool;
+        address fromToken;
+        address toToken;
+        uint256 fromID;
+        uint256 toID;
+        uint256 fromAmount;
+        address to;
+    }
+
+    struct VelocoreV2 {
+        address vault;
+        address tokenIn;
+        address tokenOut;
+        uint256 amount;
+    }
+
+    struct MaticMigrate {
+        address pool;
+        address tokenAddress; // should be POL
+        uint256 amount;
+        address recipient; // empty if migrate
+    }
+
+    struct Kokonut {
+        address pool;
+        uint256 dx;
+        uint256 tokenIndexFrom;
+        address fromToken;
+        address toToken;
+    }
+
+    function executeUniswap(bytes memory data, uint256 flagsAndPrevAmountOut) external payable returns (uint256);
+
+    function executeStableSwap(bytes memory data, uint256 flagsAndPrevAmountOut) external payable returns (uint256);
+
+    function executeCurve(bytes memory data, uint256 flagsAndPrevAmountOut) external payable returns (uint256);
+
+    function executeKSClassic(bytes memory data, uint256 flagsAndPrevAmountOut) external payable returns (uint256);
+
+    function executeUniV3KSElastic(bytes memory data, uint256 flagsAndPrevAmountOut)
+        external
+        payable
+        returns (uint256);
+
+    function executeRfq(bytes memory data, uint256 flagsAndPrevAmountOut) external payable returns (uint256);
+
+    function executeBalV2(bytes memory data, uint256 flagsAndPrevAmountOut) external payable returns (uint256);
+
+    function executeDODO(bytes memory data, uint256 flagsAndPrevAmountOut) external payable returns (uint256);
+
+    function executeVelodrome(bytes memory data, uint256 flagsAndPrevAmountOut) external payable returns (uint256);
+
+    function executeGMX(bytes memory data, uint256 flagsAndPrevAmountOut) external payable returns (uint256);
+
+    function executePlatypus(bytes memory data, uint256 flagsAndPrevAmountOut) external payable returns (uint256);
+
+    function executeWrappedstETH(bytes memory data, uint256 flagsAndPrevAmountOut) external payable returns (uint256);
+
+    function executeStEth(bytes memory data, uint256 flagsAndPrevAmountOut) external payable returns (uint256);
+
+    function executeSynthetix(bytes memory data, uint256 flagsAndPrevAmountOut) external payable returns (uint256);
+
+    function executeHashflow(bytes memory data, uint256 flagsAndPrevAmountOut) external payable returns (uint256);
+
+    function executePSM(bytes memory data, uint256 flagsAndPrevAmountOut) external payable returns (uint256);
+
+    function executeFrax(bytes memory data, uint256 flagsAndPrevAmountOut) external payable returns (uint256);
+
+    function executeCamelot(bytes memory data, uint256 flagsAndPrevAmountOut) external payable returns (uint256);
+
+    function executeKyberLimitOrder(bytes memory data, uint256 flagsAndPrevAmountOut)
+        external
+        payable
+        returns (uint256);
+
+    function executeMaverick(bytes memory data, uint256 flagsAndPrevAmountOut) external payable returns (uint256);
+
+    function executeSyncSwap(bytes memory data, uint256 flagsAndPrevAmountOut) external payable returns (uint256);
+
+    function executeAlgebraV1(bytes memory data, uint256 flagsAndPrevAmountOut) external payable returns (uint256);
+
+    function executeBalancerBatch(bytes memory data, uint256 flagsAndPrevAmountOut)
+        external
+        payable
+        returns (uint256);
+
+    function executeWombat(bytes memory data, uint256 flagsAndPrevAmountOut) external payable returns (uint256);
+
+    function executeMantis(bytes memory data, uint256 flagsAndPrevAmountOut) external payable returns (uint256);
+
+    function executeIziSwap(bytes memory data, uint256 flagsAndPrevAmountOut) external payable returns (uint256);
+
+    function executeWooFiV2(bytes memory data, uint256 flagsAndPrevAmountOut) external payable returns (uint256);
+
+    function executeTraderJoeV2(bytes memory data, uint256 flagsAndPrevAmountOut) external payable returns (uint256);
+
+    function executePancakeStableSwap(bytes memory data, uint256 flagsAndPrevAmountOut)
+        external
+        payable
+        returns (uint256);
+
+    function executeLevelFiV2(bytes memory data, uint256 flagsAndPrevAmountOut) external payable returns (uint256);
+
+    function executeGMXGLP(bytes memory data, uint256 flagsAndPrevAmountOut) external payable returns (uint256);
+
+    function executeVooi(bytes memory data, uint256 flagsAndPrevAmountOut) external payable returns (uint256);
+
+    function executeVelocoreV2(bytes memory data, uint256 flagsAndPrevAmountOut) external payable returns (uint256);
+
+    function executeMaticMigrate(bytes memory data, uint256 flagsAndPrevAmountOut) external payable returns (uint256);
+
+    function executeSmardex(bytes memory data, uint256 flagsAndPrevAmountOut) external payable returns (uint256);
+
+    function executeSolidlyV2(bytes memory data, uint256 flagsAndPrevAmountOut) external payable returns (uint256);
+
+    function executeKokonut(bytes memory data, uint256 flagsAndPrevAmountOut) external payable returns (uint256);
+}