@pendle/core-v2 3.0.0-beta-11 → 3.0.0-beta-13

package/contracts/router/base/MarketApproxLib.sol

@@ -10,7 +10,7 @@ struct ApproxParams {
     uint256 guessOffchain; // pass 0 in to skip this variable
     uint256 maxIteration; // every iteration, the diff between guessMin and guessMax will be divided by 2
     uint256 eps; // the max eps between the returned result & the correct result, base 1e18. Normally this number will be set
-        // to 1e15 (1e18/1000 = 0.1%)
+    // to 1e15 (1e18/1000 = 0.1%)
 }
 
 /// Further explanation of the eps. Take swapExactSyForPt for example. To calc the corresponding amount of Pt to swap out,
@@ -48,7 +48,7 @@ library MarketApproxPtInLib {
         uint256 minSyOut,
         uint256 blockTime,
         ApproxParams memory approx
-    ) internal pure returns (uint256, /*netPtIn*/ uint256, /*netSyOut*/ uint256 /*netSyFee*/ ) {
+    ) internal pure returns (uint256, /*netPtIn*/ uint256, /*netSyOut*/ uint256 /*netSyFee*/) {
         MarketPreCompute memory comp = market.getMarketPreCompute(index, blockTime);
         if (approx.guessOffchain == 0) {
             // no limit on min
@@ -58,7 +58,7 @@ library MarketApproxPtInLib {
 
         for (uint256 iter = 0; iter < approx.maxIteration; ++iter) {
             uint256 guess = nextGuess(approx, iter);
-            (uint256 netSyOut, uint256 netSyFee,) = calcSyOut(market, comp, index, guess);
+            (uint256 netSyOut, uint256 netSyFee, ) = calcSyOut(market, comp, index, guess);
 
             if (netSyOut >= minSyOut) {
                 if (PMath.isAGreaterApproxB(netSyOut, minSyOut, approx.eps)) {
@@ -87,7 +87,7 @@ library MarketApproxPtInLib {
         uint256 exactSyIn,
         uint256 blockTime,
         ApproxParams memory approx
-    ) internal pure returns (uint256, /*netYtOut*/ uint256 /*netSyFee*/ ) {
+    ) internal pure returns (uint256, /*netYtOut*/ uint256 /*netSyFee*/) {
         MarketPreCompute memory comp = market.getMarketPreCompute(index, blockTime);
         if (approx.guessOffchain == 0) {
             approx.guessMin = PMath.max(approx.guessMin, index.syToAsset(exactSyIn));
@@ -100,7 +100,7 @@ library MarketApproxPtInLib {
         for (uint256 iter = 0; iter < approx.maxIteration; ++iter) {
             uint256 guess = nextGuess(approx, iter);
 
-            (uint256 netSyOut, uint256 netSyFee,) = calcSyOut(market, comp, index, guess);
+            (uint256 netSyOut, uint256 netSyFee, ) = calcSyOut(market, comp, index, guess);
 
             uint256 netSyToTokenizePt = index.assetToSyUp(guess);
 
@@ -143,7 +143,7 @@ library MarketApproxPtInLib {
         uint256 _netSyHolding,
         uint256 _blockTime,
         ApproxParams memory approx
-    ) internal pure returns (uint256, /*netPtSwap*/ uint256, /*netSyFromSwap*/ uint256 /*netSyFee*/ ) {
+    ) internal pure returns (uint256, /*netPtSwap*/ uint256, /*netSyFromSwap*/ uint256 /*netSyFee*/) {
         Args5 memory a = Args5(_market, _index, _totalPtIn, _netSyHolding, _blockTime, approx);
         MarketPreCompute memory comp = a.market.getMarketPreCompute(a.index, a.blockTime);
         if (approx.guessOffchain == 0) {
@@ -157,8 +157,14 @@ library MarketApproxPtInLib {
         for (uint256 iter = 0; iter < approx.maxIteration; ++iter) {
             uint256 guess = nextGuess(approx, iter);
 
-            (uint256 syNumerator, uint256 ptNumerator, uint256 netSyOut, uint256 netSyFee,) =
-                calcNumerators(a.market, a.index, a.totalPtIn, a.netSyHolding, comp, guess);
+            (uint256 syNumerator, uint256 ptNumerator, uint256 netSyOut, uint256 netSyFee, ) = calcNumerators(
+                a.market,
+                a.index,
+                a.totalPtIn,
+                a.netSyHolding,
+                comp,
+                guess
+            );
 
             if (PMath.isAApproxB(syNumerator, ptNumerator, approx.eps)) {
                 return (guess, netSyOut, netSyFee);
@@ -216,7 +222,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);
@@ -227,7 +233,7 @@ library MarketApproxPtInLib {
         for (uint256 iter = 0; iter < approx.maxIteration; ++iter) {
             uint256 guess = nextGuess(approx, iter);
 
-            (uint256 netSyOut, uint256 netSyFee,) = calcSyOut(market, comp, index, guess);
+            (uint256 netSyOut, uint256 netSyFee, ) = calcSyOut(market, comp, index, guess);
 
             uint256 netAssetOut = index.syToAsset(netSyOut);
 
@@ -248,11 +254,12 @@ library MarketApproxPtInLib {
 
     ////////////////////////////////////////////////////////////////////////////////
 
-    function calcSyOut(MarketState memory market, MarketPreCompute memory comp, PYIndex index, uint256 netPtIn)
-        internal
-        pure
-        returns (uint256 netSyOut, uint256 netSyFee, uint256 netSyToReserve)
-    {
+    function calcSyOut(
+        MarketState memory market,
+        MarketPreCompute memory comp,
+        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));
         netSyOut = uint256(_netSyOut);
         netSyFee = uint256(_netSyFee);
@@ -285,11 +292,7 @@ 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;
 
@@ -324,7 +327,7 @@ library MarketApproxPtOutLib {
         uint256 exactSyIn,
         uint256 blockTime,
         ApproxParams memory approx
-    ) internal pure returns (uint256, /*netPtOut*/ uint256 /*netSyFee*/ ) {
+    ) internal pure returns (uint256, /*netPtOut*/ uint256 /*netSyFee*/) {
         MarketPreCompute memory comp = market.getMarketPreCompute(index, blockTime);
         if (approx.guessOffchain == 0) {
             // no limit on min
@@ -335,7 +338,7 @@ library MarketApproxPtOutLib {
         for (uint256 iter = 0; iter < approx.maxIteration; ++iter) {
             uint256 guess = nextGuess(approx, iter);
 
-            (uint256 netSyIn, uint256 netSyFee,) = calcSyIn(market, comp, index, guess);
+            (uint256 netSyIn, uint256 netSyFee, ) = calcSyIn(market, comp, index, guess);
 
             if (netSyIn <= exactSyIn) {
                 if (PMath.isASmallerApproxB(netSyIn, exactSyIn, approx.eps)) {
@@ -364,7 +367,7 @@ library MarketApproxPtOutLib {
         uint256 minSyOut,
         uint256 blockTime,
         ApproxParams memory approx
-    ) internal pure returns (uint256, /*netYtIn*/ uint256, /*netSyOut*/ uint256 /*netSyFee*/ ) {
+    ) internal pure returns (uint256, /*netYtIn*/ uint256, /*netSyOut*/ uint256 /*netSyFee*/) {
         MarketPreCompute memory comp = market.getMarketPreCompute(index, blockTime);
         if (approx.guessOffchain == 0) {
             // no limit on min
@@ -375,7 +378,7 @@ library MarketApproxPtOutLib {
         for (uint256 iter = 0; iter < approx.maxIteration; ++iter) {
             uint256 guess = nextGuess(approx, iter);
 
-            (uint256 netSyOwed, uint256 netSyFee,) = calcSyIn(market, comp, index, guess);
+            (uint256 netSyOwed, uint256 netSyFee, ) = calcSyIn(market, comp, index, guess);
 
             uint256 netAssetToRepay = index.syToAssetUp(netSyOwed);
             uint256 netSyOut = index.assetToSy(guess - netAssetToRepay);
@@ -416,7 +419,7 @@ library MarketApproxPtOutLib {
         uint256 _netPtHolding,
         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, _netPtHolding, _blockTime, _approx);
 
         MarketPreCompute memory comp = a.market.getMarketPreCompute(a.index, a.blockTime);
@@ -483,7 +486,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);
@@ -494,7 +497,7 @@ library MarketApproxPtOutLib {
         for (uint256 iter = 0; iter < approx.maxIteration; ++iter) {
             uint256 guess = nextGuess(approx, iter);
 
-            (uint256 netSyOwed, uint256 netSyFee,) = calcSyIn(market, comp, index, guess);
+            (uint256 netSyOwed, uint256 netSyFee, ) = calcSyIn(market, comp, index, guess);
 
             uint256 netYtToPull = index.syToAssetUp(netSyOwed);
 
@@ -512,11 +515,12 @@ library MarketApproxPtOutLib {
 
     ////////////////////////////////////////////////////////////////////////////////
 
-    function calcSyIn(MarketState memory market, MarketPreCompute memory comp, PYIndex index, uint256 netPtOut)
-        internal
-        pure
-        returns (uint256 netSyIn, uint256 netSyFee, uint256 netSyToReserve)
-    {
+    function calcSyIn(
+        MarketState memory market,
+        MarketPreCompute memory comp,
+        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));
 
         // all safe since totalPt and totalSy is int128

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

@@ -3,10 +3,11 @@ 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 {
@@ -17,11 +18,11 @@ contract PendleSwap is IPSwapAggregator, TokenHelper, KyberInputScalingHelper, O
         );
     }
 
-    function _getScaledInputData(SwapType swapType, bytes calldata rawCallData, uint256 amountIn)
-        internal
-        pure
-        returns (bytes memory scaledCallData)
-    {
+    function _getScaledInputData(
+        SwapType swapType,
+        bytes calldata rawCallData,
+        uint256 amountIn
+    ) internal pure returns (bytes memory scaledCallData) {
         if (swapType == SwapType.KYBERSWAP) {
             scaledCallData = _getKyberScaledInputData(rawCallData, amountIn);
         } else if (swapType == SwapType.ONE_INCH) {
@@ -31,5 +32,28 @@ contract PendleSwap is IPSwapAggregator, TokenHelper, KyberInputScalingHelper, O
         }
     }
 
+    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/interfaces/IAggregationExecutorOptimistic.sol

@@ -0,0 +1,63 @@
+// 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,314 @@
+// 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);
+}