@paraswap/dex-lib 4.7.13 → 4.7.14-multi-route.1

package/build/executor/Executor02BytecodeBuilder.js

@@ -25,8 +25,8 @@ class Executor02BytecodeBuilder extends ExecutorBytecodeBuilder_1.ExecutorByteco
      * case 1: check eth balance after swap
      * case 2: check destToken balance after swap
      */
-    buildSimpleSwapFlags(priceRoute, exchangeParams, routeIndex, swapIndex, swapExchangeIndex, exchangeParamIndex, maybeWethCallData) {
-        const { srcToken, destToken } = priceRoute.bestRoute[routeIndex].swaps[swapIndex];
+    buildSimpleSwapFlags(routes, exchangeParams, routeIndex, swapIndex, swapExchangeIndex, exchangeParamIndex, maybeWethCallData) {
+        const { srcToken, destToken } = routes[routeIndex].swaps[swapIndex];
         const isEthSrc = (0, utils_1.isETHAddress)(srcToken);
         const isEthDest = (0, utils_1.isETHAddress)(destToken);
         const exchangeParam = exchangeParams[exchangeParamIndex];
@@ -83,12 +83,12 @@ class Executor02BytecodeBuilder extends ExecutorBytecodeBuilder_1.ExecutorByteco
      * case 1: check eth balance after swap
      * case 2: check destToken balance after swap
      */
-    buildMultiMegaSwapFlags(priceRoute, exchangeParams, routeIndex, swapIndex, swapExchangeIndex, exchangeParamIndex, maybeWethCallData) {
-        const route = priceRoute.bestRoute[routeIndex];
+    buildMultiMegaSwapFlags(routes, exchangeParams, routeIndex, swapIndex, swapExchangeIndex, exchangeParamIndex, maybeWethCallData) {
+        const route = routes[routeIndex];
         const swap = route.swaps[swapIndex];
         const exchangeParam = exchangeParams[exchangeParamIndex];
         const { srcToken, destToken } = swap;
-        const applyVerticalBranching = this.doesSwapNeedToApplyVerticalBranching(priceRoute, routeIndex, swap);
+        const applyVerticalBranching = this.doesSwapNeedToBeAsVerticalBranch(routes, routeIndex, swap);
         const isHorizontalSequence = route.swaps.length > 1; // check if route is a multi-swap (horizontal sequence)
         const isFirstSwap = swapIndex === 0;
         const isLastSwap = !isFirstSwap && swapIndex === route.swaps.length - 1;
@@ -108,9 +108,9 @@ class Executor02BytecodeBuilder extends ExecutorBytecodeBuilder_1.ExecutorByteco
         const needUnwrap = needWrapNative && isEthDest && maybeWethCallData?.withdraw;
         const needSendEth = isEthSrc && !needWrapNative;
         const needCheckEthBalance = isEthDest && !needWrapNative;
-        const anyDexOnSwapDoesntNeedWrapNative = this.anyDexOnSwapDoesntNeedWrapNative(priceRoute, swap, exchangeParams);
+        const anyDexOnSwapDoesntNeedWrapNative = this.anyDexOnSwapDoesntNeedWrapNative(routes, swap, exchangeParams);
         // check if current exchange is the last with needWrapNative
-        const isLastExchangeWithNeedWrapNative = this.isLastExchangeWithNeedWrapNative(priceRoute, swap, exchangeParams, exchangeParamIndex);
+        const isLastExchangeWithNeedWrapNative = this.isLastExchangeWithNeedWrapNative(routes, swap, exchangeParams, exchangeParamIndex);
         //  for the first part, basically replicates the logic from `unwrap after last swap` in buildSingleSwapExchangeCallData
         const needCheckSrcTokenBalanceOf = (needUnwrap &&
             (!applyVerticalBranching ||
@@ -166,23 +166,23 @@ class Executor02BytecodeBuilder extends ExecutorBytecodeBuilder_1.ExecutorByteco
         };
     }
     buildDexCallData(params) {
-        const { priceRoute, exchangeParamIndex, swapExchange, exchangeParams, routeIndex, swapIndex, flag, } = params;
-        const swap = priceRoute.bestRoute[routeIndex].swaps[swapIndex];
+        const { routes, exchangeParamIndex, swapExchange, exchangeParams, routeIndex, swapIndex, flag, destToken, } = params;
+        const swap = routes[routeIndex].swaps[swapIndex];
         const exchangeParam = exchangeParams[exchangeParamIndex];
         let { exchangeData, specialDexFlag, targetExchange, needWrapNative } = exchangeParam;
-        const routeNeedsRootUnwrapEth = this.doesRouteNeedsRootUnwrapEth(priceRoute, exchangeParams);
+        const routeNeedsRootUnwrapEth = this.doesRouteNeedsRootUnwrapEth(routes, exchangeParams, destToken);
         const needUnwrap = 
         // check if current exchange is the last with needWrapNative
-        this.isLastExchangeWithNeedWrapNative(priceRoute, swap, exchangeParams, exchangeParamIndex) || exchangeParam.wethAddress;
+        this.isLastExchangeWithNeedWrapNative(routes, swap, exchangeParams, exchangeParamIndex) || exchangeParam.wethAddress;
         const needUnwrapAfterLastSwapInRoute = needUnwrap &&
             (0, utils_1.isETHAddress)(swap.destToken) &&
-            this.anyDexOnSwapDoesntNeedWrapNative(priceRoute, swap, exchangeParams);
+            this.anyDexOnSwapDoesntNeedWrapNative(routes, swap, exchangeParams);
         const returnAmountPos = exchangeParam.returnAmountPos !== undefined &&
             !routeNeedsRootUnwrapEth &&
             !needUnwrapAfterLastSwapInRoute // prevent returnAmoutPos optimisation if route needs root unwrap eth
             ? exchangeParam.returnAmountPos
             : constants_1.DEFAULT_RETURN_AMOUNT_POS;
-        const applyVerticalBranching = this.doesSwapNeedToApplyVerticalBranching(priceRoute, routeIndex, swap);
+        const applyVerticalBranching = this.doesSwapNeedToBeAsVerticalBranch(routes, routeIndex, swap);
         const dontCheckBalanceAfterSwap = flag % 3 === 0;
         const checkDestTokenBalanceAfterSwap = flag % 3 === 2;
         const insertFromAmount = flag % 4 === 3 || flag % 4 === 2;
@@ -220,7 +220,7 @@ class Executor02BytecodeBuilder extends ExecutorBytecodeBuilder_1.ExecutorByteco
         }
         return this.buildCallData(targetExchange, exchangeData, fromAmountPos, destTokenPos, specialDexFlag || types_1.SpecialDex.DEFAULT, flag, undefined, returnAmountPos);
     }
-    addMultiSwapMetadata(priceRoute, exchangeParams, callData, percentage, swap, exchangeParamIndex, wrapWasAddedInSwapExchange, addedUnwrapForDexWithNoNeedWrapNative = false) {
+    wrapAsVerticalBranch(routes, exchangeParams, callData, percentage, swap, exchangeParamIndex, wrapWasAddedInSwapExchange, addedUnwrapForDexWithNoNeedWrapNative = false) {
         let srcTokenAddress = swap.srcToken;
         let doesAnyDexOnSwapNeedsWrapNative;
         if (exchangeParamIndex > -1) {
@@ -233,7 +233,7 @@ class Executor02BytecodeBuilder extends ExecutorBytecodeBuilder_1.ExecutorByteco
         else {
             doesAnyDexOnSwapNeedsWrapNative =
                 (0, utils_1.isETHAddress)(srcTokenAddress) &&
-                    this.anyDexOnSwapNeedsWrapNative(priceRoute, swap, exchangeParams);
+                    this.anyDexOnSwapNeedsWrapNative(routes, swap, exchangeParams);
         }
         if (doesAnyDexOnSwapNeedsWrapNative &&
             (0, utils_1.isETHAddress)(srcTokenAddress) &&
@@ -284,7 +284,7 @@ class Executor02BytecodeBuilder extends ExecutorBytecodeBuilder_1.ExecutorByteco
             'bytes2',
             'bytes',
         ], [
-            constants_1.ZEROS_20_BYTES, // bytes20(0)
+            constants_1.ZEROS_20_BYTES, // zero address. go to vertical branch, so no call is made
             hexZeroPad(hexlify(hexDataLength(verticalBranchingData)), 4), // dex calldata length
             hexZeroPad(hexlify(fromAmountPos), 2), // fromAmountPos
             hexZeroPad(hexlify(destTokenPos), 2), // destTokenPos
@@ -294,8 +294,7 @@ class Executor02BytecodeBuilder extends ExecutorBytecodeBuilder_1.ExecutorByteco
             verticalBranchingData, // dexes calldata
         ]);
     }
-    buildVerticalBranchingCallData(priceRoute, routeIndex, exchangeParams, swap, swapCallData, flag, isRoot = false) {
-        const data = this.packVerticalBranchingData(swapCallData);
+    buildVerticalBranchingCallData(routes, routeIndex, exchangeParams, swap, swapCallData, flag, isRoot = false) {
         const destTokenAddrLowered = swap.destToken.toLowerCase();
         const isEthDest = (0, utils_1.isETHAddress)(destTokenAddrLowered);
         let anyDexOnSwapNeedsWrapNative = false;
@@ -303,15 +302,17 @@ class Executor02BytecodeBuilder extends ExecutorBytecodeBuilder_1.ExecutorByteco
         let destTokenPos;
         if (isEthDest) {
             if (!isRoot) {
-                anyDexOnSwapNeedsWrapNative = this.anyDexOnSwapNeedsWrapNative(priceRoute, swap, exchangeParams);
+                anyDexOnSwapNeedsWrapNative = this.anyDexOnSwapNeedsWrapNative(routes, swap, exchangeParams);
                 anyDexOnSwapDoesntNeedWrapNative =
-                    this.anyDexOnSwapDoesntNeedWrapNative(priceRoute, swap, exchangeParams);
+                    this.anyDexOnSwapDoesntNeedWrapNative(routes, swap, exchangeParams);
             }
             else {
-                anyDexOnSwapNeedsWrapNative = priceRoute.bestRoute.some(route => this.anyDexOnSwapNeedsWrapNative(priceRoute, route.swaps[route.swaps.length - 1], exchangeParams));
-                anyDexOnSwapDoesntNeedWrapNative = priceRoute.bestRoute.some(route => this.anyDexOnSwapDoesntNeedWrapNative(priceRoute, route.swaps[route.swaps.length - 1], exchangeParams));
+                anyDexOnSwapNeedsWrapNative = routes.some(route => this.anyDexOnSwapNeedsWrapNative(routes, route.swaps[route.swaps.length - 1], exchangeParams));
+                anyDexOnSwapDoesntNeedWrapNative = routes.some(route => this.anyDexOnSwapDoesntNeedWrapNative(routes, route.swaps[route.swaps.length - 1], exchangeParams));
             }
         }
+        // 'bytes28', 'bytes4', 'bytes32', 'bytes32', 'bytes'
+        const data = this.packVerticalBranchingData(swapCallData);
         if (isEthDest &&
             anyDexOnSwapDoesntNeedWrapNative &&
             !anyDexOnSwapNeedsWrapNative) {
@@ -328,15 +329,14 @@ class Executor02BytecodeBuilder extends ExecutorBytecodeBuilder_1.ExecutorByteco
         const fromAmountPos = hexDataLength(data) - 64 - 28; // 64 (position), 28 (selector padding);
         return this.packVerticalBranchingCallData(data, fromAmountPos, destTokenPos < 0 ? 0 : destTokenPos, flag);
     }
-    buildSingleSwapExchangeCallData(priceRoute, routeIndex, swapIndex, swapExchangeIndex, exchangeParams, flags, addedWrapToSwapExchangeMap, allowToAddWrap = true, prevBranchWasWrapped = false, unwrapToSwapMap, maybeWethCallData, addMultiSwapMetadata, applyVerticalBranching) {
-        const isSimpleSwap = priceRoute.bestRoute.length === 1 &&
-            priceRoute.bestRoute[0].swaps.length === 1;
+    buildSingleSwapExchangeCallData(routes, routeIndex, swapIndex, swapExchangeIndex, exchangeParams, flags, addedWrapToSwapExchangeMap, allowToAddWrap = true, prevBranchWasWrapped = false, unwrapToSwapMap, srcToken, destToken, maybeWethCallData, hasMultipleSwapExchanges, isMultiOrMegaSwap) {
+        const isSimpleSwap = routes.length === 1 && routes[0].swaps.length === 1;
         let swapExchangeCallData = '';
-        const swap = priceRoute.bestRoute[routeIndex].swaps[swapIndex];
+        const swap = routes[routeIndex].swaps[swapIndex];
         const swapExchange = swap.swapExchanges[swapExchangeIndex];
         let exchangeParamIndex = 0;
         let tempExchangeParamIndex = 0;
-        priceRoute.bestRoute.map(route => route.swaps.map(curSwap => {
+        routes.map(route => route.swaps.map(curSwap => {
             curSwap.swapExchanges.map(async (se) => {
                 if (Object.is(se, swapExchange)) {
                     exchangeParamIndex = tempExchangeParamIndex;
@@ -346,7 +346,7 @@ class Executor02BytecodeBuilder extends ExecutorBytecodeBuilder_1.ExecutorByteco
         }));
         const curExchangeParam = exchangeParams[exchangeParamIndex];
         const dexCallData = this.buildDexCallData({
-            priceRoute,
+            routes,
             routeIndex,
             swapIndex,
             swapExchangeIndex,
@@ -355,6 +355,7 @@ class Executor02BytecodeBuilder extends ExecutorBytecodeBuilder_1.ExecutorByteco
             isLastSwap: false,
             flag: flags.dexes[exchangeParamIndex],
             swapExchange,
+            destToken,
         });
         if (curExchangeParam.preSwapUnwrapCalldata) {
             const withdrawCallData = this.buildUnwrapEthCallData(this.getWETHAddress(curExchangeParam), curExchangeParam.preSwapUnwrapCalldata);
@@ -363,7 +364,7 @@ class Executor02BytecodeBuilder extends ExecutorBytecodeBuilder_1.ExecutorByteco
         else {
             swapExchangeCallData = hexConcat([dexCallData]);
         }
-        const isLastSwap = swapIndex === priceRoute.bestRoute[routeIndex].swaps.length - 1;
+        const isLastSwap = swapIndex === routes[routeIndex].swaps.length - 1;
         const isLast = exchangeParamIndex === exchangeParams.length - 1;
         if (curExchangeParam.transferSrcTokenBeforeSwap) {
             const transferCallData = this.buildTransferCallData(this.erc20Interface.encodeFunctionData('transfer', [
@@ -395,14 +396,14 @@ class Executor02BytecodeBuilder extends ExecutorBytecodeBuilder_1.ExecutorByteco
                 const isNotFirstSwap = swapIndex !== 0;
                 let skipWrap = false;
                 if (isNotFirstSwap) {
-                    const prevSwap = priceRoute.bestRoute[routeIndex].swaps[swapIndex - 1];
-                    const anyDexOnSwapDoesntNeedWrapNative = this.anyDexOnSwapDoesntNeedWrapNative(priceRoute, prevSwap, exchangeParams);
+                    const prevSwap = routes[routeIndex].swaps[swapIndex - 1];
+                    const anyDexOnSwapDoesntNeedWrapNative = this.anyDexOnSwapDoesntNeedWrapNative(routes, prevSwap, exchangeParams);
                     skipWrap = !anyDexOnSwapDoesntNeedWrapNative;
                 }
                 let depositCallData = '0x';
                 if (maybeWethCallData &&
                     maybeWethCallData.deposit &&
-                    !this.doesRouteNeedsRootWrapEth(priceRoute, exchangeParams) &&
+                    !this.doesRouteNeedsRootWrapEth(routes, exchangeParams, srcToken) &&
                     allowToAddWrap &&
                     !addedWrapToSwapExchangeMap[`${routeIndex}_${swapIndex}_${swapExchangeIndex}`] &&
                     !skipWrap) {
@@ -415,23 +416,24 @@ class Executor02BytecodeBuilder extends ExecutorBytecodeBuilder_1.ExecutorByteco
                     swapExchangeCallData,
                 ]);
             }
+            const needUnwrap = isMultiOrMegaSwap && hasMultipleSwapExchanges;
             // unwrap after last swap
             if (maybeWethCallData &&
                 maybeWethCallData.withdraw &&
-                ((!applyVerticalBranching && (0, utils_1.isETHAddress)(swap.destToken)) ||
-                    (applyVerticalBranching &&
+                ((!needUnwrap && (0, utils_1.isETHAddress)(swap.destToken)) ||
+                    (needUnwrap &&
                         (0, utils_1.isETHAddress)(swap.destToken) &&
-                        this.anyDexOnSwapDoesntNeedWrapNative(priceRoute, swap, exchangeParams)))) {
+                        this.anyDexOnSwapDoesntNeedWrapNative(routes, swap, exchangeParams)))) {
                 let withdrawCallData = '0x';
                 const customWethAddress = curExchangeParam.wethAddress;
                 const needUnwrapAll = isSimpleSwap ||
                     (isLastSwap
-                        ? !this.doesRouteNeedsRootUnwrapEth(priceRoute, exchangeParams)
-                        : this.everyDexOnSwapNeedWrapNative(priceRoute, priceRoute.bestRoute[routeIndex].swaps[swapIndex + 1], exchangeParams) ||
-                            this.everyDexOnSwapDoesntNeedWrapNative(priceRoute, priceRoute.bestRoute[routeIndex].swaps[swapIndex + 1], exchangeParams));
+                        ? !this.doesRouteNeedsRootUnwrapEth(routes, exchangeParams, destToken)
+                        : this.everyDexOnSwapNeedWrapNative(routes, routes[routeIndex].swaps[swapIndex + 1], exchangeParams) ||
+                            this.everyDexOnSwapDoesntNeedWrapNative(routes, routes[routeIndex].swaps[swapIndex + 1], exchangeParams));
                 // check if current exchange is the last with needWrapNative
                 const needUnwrap = needUnwrapAll &&
-                    this.isLastExchangeWithNeedWrapNative(priceRoute, swap, exchangeParams, exchangeParamIndex);
+                    this.isLastExchangeWithNeedWrapNative(routes, swap, exchangeParams, exchangeParamIndex);
                 if (customWethAddress || needUnwrap) {
                     unwrapToSwapMap[swapIndex] = true;
                     withdrawCallData = this.buildUnwrapEthCallData(this.getWETHAddress(curExchangeParam), maybeWethCallData.withdraw.calldata);
@@ -455,10 +457,10 @@ class Executor02BytecodeBuilder extends ExecutorBytecodeBuilder_1.ExecutorByteco
             maybeWethCallData.withdraw &&
             !curExchangeParam.needWrapNative &&
             !unwrapToSwapMap[swapIndex - 1]) {
-            const prevSwap = priceRoute.bestRoute[routeIndex].swaps[swapIndex - 1];
+            const prevSwap = routes[routeIndex].swaps[swapIndex - 1];
             let eachDexOnPrevSwapReturnsWeth = false;
             if (prevSwap && !prevBranchWasWrapped) {
-                eachDexOnPrevSwapReturnsWeth = this.eachDexOnSwapNeedsWrapNative(priceRoute, prevSwap, exchangeParams);
+                eachDexOnPrevSwapReturnsWeth = this.eachDexOnSwapNeedsWrapNative(routes, prevSwap, exchangeParams);
             }
             if (prevBranchWasWrapped || eachDexOnPrevSwapReturnsWeth) {
                 const withdrawCallData = this.buildUnwrapEthCallData(this.getWETHAddress(curExchangeParam), maybeWethCallData.withdraw.calldata);
@@ -472,7 +474,7 @@ class Executor02BytecodeBuilder extends ExecutorBytecodeBuilder_1.ExecutorByteco
         if (isLastSwap &&
             !exchangeParams[exchangeParamIndex].dexFuncHasRecipient &&
             !(0, utils_1.isETHAddress)(swap.destToken) &&
-            priceRoute.destToken === swap.destToken) {
+            destToken === swap.destToken) {
             const transferCallData = this.buildTransferCallData(this.erc20Interface.encodeFunctionData('transfer', [
                 this.dexHelper.config.data.augustusV6Address,
                 swapExchange.destAmount,
@@ -486,15 +488,16 @@ class Executor02BytecodeBuilder extends ExecutorBytecodeBuilder_1.ExecutorByteco
             (0, utils_1.isETHAddress)(swap.destToken) &&
             isLastSwap &&
             // don't need to send eth without unwrapping, handling unwrap and sendEth in the end of root branch
-            !this.doesRouteNeedsRootUnwrapEth(priceRoute, exchangeParams)) {
+            !this.doesRouteNeedsRootUnwrapEth(routes, exchangeParams, destToken)) {
             const finalSpecialFlagCalldata = this.buildFinalSpecialFlagCalldata();
             swapExchangeCallData = hexConcat([
                 swapExchangeCallData,
                 finalSpecialFlagCalldata,
             ]);
         }
-        if (addMultiSwapMetadata) {
-            return this.addMultiSwapMetadata(priceRoute, exchangeParams, swapExchangeCallData, swapExchange.percent, swap, exchangeParamIndex, addedWrapToSwapExchangeMap[`${routeIndex}_${swapIndex}_${swapExchangeIndex}`], addedUnwrapForDexWithNoNeedWrapNative);
+        // if swap has multiple exchanges, then each exchange is executed as part of vertical branching
+        if (hasMultipleSwapExchanges) {
+            return this.wrapAsVerticalBranch(routes, exchangeParams, swapExchangeCallData, swapExchange.percent, swap, exchangeParamIndex, addedWrapToSwapExchangeMap[`${routeIndex}_${swapIndex}_${swapExchangeIndex}`], addedUnwrapForDexWithNoNeedWrapNative);
         }
         return swapExchangeCallData;
     }
@@ -511,11 +514,11 @@ class Executor02BytecodeBuilder extends ExecutorBytecodeBuilder_1.ExecutorByteco
         }
         return calldata;
     }
-    eachDexOnSwapNeedsWrapNative(priceRoute, swap, exchangeParams) {
+    eachDexOnSwapNeedsWrapNative(routes, swap, exchangeParams) {
         return swap.swapExchanges.every(curSe => {
             let index = 0;
             let swapExchangeIndex = 0;
-            priceRoute.bestRoute.map(route => {
+            routes.map(route => {
                 route.swaps.map(curSwap => curSwap.swapExchanges.map(async (se) => {
                     if (Object.is(se, curSe)) {
                         index = swapExchangeIndex;
@@ -527,11 +530,11 @@ class Executor02BytecodeBuilder extends ExecutorBytecodeBuilder_1.ExecutorByteco
             return curExchangeParam.needWrapNative && !curExchangeParam.wethAddress;
         });
     }
-    anyDexOnSwapNeedsWrapNative(priceRoute, swap, exchangeParams) {
+    anyDexOnSwapNeedsWrapNative(routes, swap, exchangeParams) {
         const res = swap.swapExchanges.map(curSe => {
             let index = 0;
             let swapExchangeIndex = 0;
-            priceRoute.bestRoute.map(route => {
+            routes.map(route => {
                 route.swaps.map(curSwap => {
                     return curSwap.swapExchanges.map(async (se) => {
                         if (Object.is(se, curSe)) {
@@ -546,12 +549,12 @@ class Executor02BytecodeBuilder extends ExecutorBytecodeBuilder_1.ExecutorByteco
         });
         return res.includes(true);
     }
-    isLastExchangeWithNeedWrapNative(priceRoute, swap, exchangeParams, exchangeParamIndex) {
+    isLastExchangeWithNeedWrapNative(routes, swap, exchangeParams, exchangeParamIndex) {
         const currentSwapExchangeParamsIndexes = [];
         swap.swapExchanges.forEach(curSe => {
             let index = 0;
             let swapExchangeIndex = 0;
-            priceRoute.bestRoute.forEach(route => {
+            routes.forEach(route => {
                 route.swaps.forEach(curSwap => {
                     return curSwap.swapExchanges.forEach(async (se) => {
                         if (Object.is(se, curSe)) {
@@ -569,11 +572,11 @@ class Executor02BytecodeBuilder extends ExecutorBytecodeBuilder_1.ExecutorByteco
             ? index
             : acc, -1) === exchangeParamIndex);
     }
-    getSwapExchangesWhichNeedWrapNative(priceRoute, swap, exchangeParams) {
+    getSwapExchangesWhichNeedWrapNative(routes, swap, exchangeParams) {
         return swap.swapExchanges.filter(curSe => {
             let index = 0;
             let swapExchangeIndex = 0;
-            priceRoute.bestRoute.map(route => {
+            routes.map(route => {
                 route.swaps.map(curSwap => {
                     return curSwap.swapExchanges.map(async (se) => {
                         if (Object.is(se, curSe)) {
@@ -587,11 +590,11 @@ class Executor02BytecodeBuilder extends ExecutorBytecodeBuilder_1.ExecutorByteco
             return curExchangeParam.needWrapNative && !curExchangeParam.wethAddress;
         });
     }
-    getSwapExchangesWhichDontNeedWrapNative(priceRoute, swap, exchangeParams) {
+    getSwapExchangesWhichDontNeedWrapNative(routes, swap, exchangeParams) {
         return swap.swapExchanges.filter(curSe => {
             let index = 0;
             let swapExchangeIndex = 0;
-            priceRoute.bestRoute.map(route => {
+            routes.map(route => {
                 route.swaps.map(curSwap => {
                     return curSwap.swapExchanges.map(async (se) => {
                         if (Object.is(se, curSe)) {
@@ -605,12 +608,12 @@ class Executor02BytecodeBuilder extends ExecutorBytecodeBuilder_1.ExecutorByteco
             return !curExchangeParam.needWrapNative || curExchangeParam.wethAddress;
         });
     }
-    anyDexOnSwapDoesntNeedWrapNative(priceRoute, swap, exchangeParams) {
+    anyDexOnSwapDoesntNeedWrapNative(routes, swap, exchangeParams) {
         return swap.swapExchanges
             .map(curSe => {
             let index = 0;
             let swapExchangeIndex = 0;
-            priceRoute.bestRoute.map(route => {
+            routes.map(route => {
                 route.swaps.map(curSwap => curSwap.swapExchanges.map(async (se) => {
                     if (Object.is(se, curSe)) {
                         index = swapExchangeIndex;
@@ -623,7 +626,7 @@ class Executor02BytecodeBuilder extends ExecutorBytecodeBuilder_1.ExecutorByteco
         })
             .includes(true);
     }
-    everyDexOnSwapNeedWrapNative(priceRoute, swap, exchangeParams) {
+    everyDexOnSwapNeedWrapNative(routes, swap, exchangeParams) {
         if (!swap) {
             return false;
         }
@@ -631,7 +634,7 @@ class Executor02BytecodeBuilder extends ExecutorBytecodeBuilder_1.ExecutorByteco
             .map(curSe => {
             let index = 0;
             let swapExchangeIndex = 0;
-            priceRoute.bestRoute.map(route => {
+            routes.map(route => {
                 route.swaps.map(curSwap => curSwap.swapExchanges.map(async (se) => {
                     if (Object.is(se, curSe)) {
                         index = swapExchangeIndex;
@@ -644,7 +647,7 @@ class Executor02BytecodeBuilder extends ExecutorBytecodeBuilder_1.ExecutorByteco
         })
             .every(t => t === true);
     }
-    everyDexOnSwapDoesntNeedWrapNative(priceRoute, swap, exchangeParams) {
+    everyDexOnSwapDoesntNeedWrapNative(routes, swap, exchangeParams) {
         if (!swap) {
             return false;
         }
@@ -652,7 +655,7 @@ class Executor02BytecodeBuilder extends ExecutorBytecodeBuilder_1.ExecutorByteco
             .map(curSe => {
             let index = 0;
             let swapExchangeIndex = 0;
-            priceRoute.bestRoute.map(route => {
+            routes.map(route => {
                 route.swaps.map(curSwap => curSwap.swapExchanges.map(async (se) => {
                     if (Object.is(se, curSe)) {
                         index = swapExchangeIndex;
@@ -665,23 +668,23 @@ class Executor02BytecodeBuilder extends ExecutorBytecodeBuilder_1.ExecutorByteco
         })
             .every(t => t === false);
     }
-    doesSwapNeedToApplyVerticalBranching(priceRoute, routeIndex, swap) {
-        const isMegaSwap = priceRoute.bestRoute.length > 1;
-        const isMultiSwap = !isMegaSwap && priceRoute.bestRoute[routeIndex].swaps.length > 1;
+    doesSwapNeedToBeAsVerticalBranch(routes, routeIndex, swap) {
+        const isMegaSwap = routes.length > 1;
+        const isMultiSwap = !isMegaSwap && routes[routeIndex].swaps.length > 1;
         return (isMultiSwap || isMegaSwap) && swap.swapExchanges.length > 1;
     }
-    buildVerticalBranchingFlag(priceRoute, swap, exchangeParams, routeIndex, swapIndex) {
+    buildVerticalBranchingFlag(routes, swap, exchangeParams, routeIndex, swapIndex, destToken) {
         let flag = types_1.Flag.INSERT_FROM_AMOUNT_CHECK_SRC_TOKEN_BALANCE_AFTER_SWAP; // 11
-        const isLastSwap = swapIndex === priceRoute.bestRoute[routeIndex].swaps.length - 1;
+        const isLastSwap = swapIndex === routes[routeIndex].swaps.length - 1;
         if (isLastSwap) {
-            const isEthDest = (0, utils_1.isETHAddress)(priceRoute.destToken);
-            const lastSwap = priceRoute.bestRoute[routeIndex].swaps[priceRoute.bestRoute[routeIndex].swaps.length - 1];
+            const isEthDest = (0, utils_1.isETHAddress)(destToken);
+            const lastSwap = routes[routeIndex].swaps[routes[routeIndex].swaps.length - 1];
             const lastSwapExchanges = lastSwap.swapExchanges;
             const anyDexLastSwapNeedUnwrap = lastSwapExchanges
                 .map(curSe => {
                 let index = 0;
                 let swapExchangeIndex = 0;
-                priceRoute.bestRoute[routeIndex].swaps.map(curSwap => curSwap.swapExchanges.map(async (se) => {
+                routes[routeIndex].swaps.map(curSwap => curSwap.swapExchanges.map(async (se) => {
                     if (Object.is(se, curSe)) {
                         index = swapExchangeIndex;
                     }
@@ -699,7 +702,7 @@ class Executor02BytecodeBuilder extends ExecutorBytecodeBuilder_1.ExecutorByteco
         else {
             const isEthDest = (0, utils_1.isETHAddress)(swap.destToken);
             if (isEthDest) {
-                if (this.anyDexOnSwapDoesntNeedWrapNative(priceRoute, swap, exchangeParams)) {
+                if (this.anyDexOnSwapDoesntNeedWrapNative(routes, swap, exchangeParams)) {
                     flag = types_1.Flag.INSERT_FROM_AMOUNT_CHECK_ETH_BALANCE_AFTER_SWAP; // 7
                 }
             }
@@ -707,21 +710,21 @@ class Executor02BytecodeBuilder extends ExecutorBytecodeBuilder_1.ExecutorByteco
         return flag;
     }
     buildSingleSwapCallData(params) {
-        const { priceRoute, exchangeParams, routeIndex, swapIndex, flags, maybeWethCallData, wrapToSwapMap, unwrapToSwapMap, wrapToSwapExchangeMap, swap, } = params;
-        const isLastSwap = swapIndex === priceRoute.bestRoute[routeIndex].swaps.length - 1;
-        const isMegaSwap = priceRoute.bestRoute.length > 1;
-        const isMultiSwap = !isMegaSwap && priceRoute.bestRoute[routeIndex].swaps.length > 1;
+        const { routes, exchangeParams, routeIndex, swapIndex, flags, maybeWethCallData, wrapToSwapMap, unwrapToSwapMap, wrapToSwapExchangeMap, swap, srcToken, destToken, } = params;
+        const isLastSwap = swapIndex === routes[routeIndex].swaps.length - 1;
+        const isMegaSwap = routes.length > 1;
+        const isMultiSwap = !isMegaSwap && routes[routeIndex].swaps.length > 1;
         const { swapExchanges } = swap;
-        const applyVerticalBranching = this.doesSwapNeedToApplyVerticalBranching(priceRoute, routeIndex, swap);
-        const anyDexOnSwapDoesntNeedWrapNative = this.anyDexOnSwapDoesntNeedWrapNative(priceRoute, swap, exchangeParams);
+        const applyVerticalBranching = this.doesSwapNeedToBeAsVerticalBranch(routes, routeIndex, swap);
+        const anyDexOnSwapDoesntNeedWrapNative = this.anyDexOnSwapDoesntNeedWrapNative(routes, swap, exchangeParams);
         const needToAppendWrapCallData = (0, utils_1.isETHAddress)(swap.destToken) &&
             anyDexOnSwapDoesntNeedWrapNative &&
             !isLastSwap &&
             maybeWethCallData?.deposit;
-        let swapCallData = swapExchanges.reduce((acc, swapExchange, swapExchangeIndex) => {
+        let swapCallData = swapExchanges.reduce((acc, _swapExchange, swapExchangeIndex) => {
             return hexConcat([
                 acc,
-                this.buildSingleSwapExchangeCallData(priceRoute, routeIndex, swapIndex, swapExchangeIndex, exchangeParams, flags, wrapToSwapExchangeMap, !wrapToSwapMap[swapIndex - 1], wrapToSwapMap[swapIndex - 1], unwrapToSwapMap, maybeWethCallData, swap.swapExchanges.length > 1, applyVerticalBranching),
+                this.buildSingleSwapExchangeCallData(routes, routeIndex, swapIndex, swapExchangeIndex, exchangeParams, flags, wrapToSwapExchangeMap, !wrapToSwapMap[swapIndex - 1], wrapToSwapMap[swapIndex - 1], unwrapToSwapMap, srcToken, destToken, maybeWethCallData, swap.swapExchanges.length > 1, isMultiSwap || isMegaSwap),
             ]);
         }, '0x');
         if (needToAppendWrapCallData) {
@@ -733,7 +736,7 @@ class Executor02BytecodeBuilder extends ExecutorBytecodeBuilder_1.ExecutorByteco
                 : swapCallData;
         }
         if (applyVerticalBranching) {
-            const vertBranchingCallData = this.buildVerticalBranchingCallData(priceRoute, routeIndex, exchangeParams, swap, swapCallData, this.buildVerticalBranchingFlag(priceRoute, swap, exchangeParams, routeIndex, swapIndex));
+            const vertBranchingCallData = this.buildVerticalBranchingCallData(routes, routeIndex, exchangeParams, swap, swapCallData, this.buildVerticalBranchingFlag(routes, swap, exchangeParams, routeIndex, swapIndex, destToken));
             return needToAppendWrapCallData
                 ? this.appendWrapEthCallData(vertBranchingCallData, maybeWethCallData, true)
                 : vertBranchingCallData;
@@ -742,8 +745,8 @@ class Executor02BytecodeBuilder extends ExecutorBytecodeBuilder_1.ExecutorByteco
             ? this.appendWrapEthCallData(swapCallData, maybeWethCallData)
             : swapCallData;
     }
-    buildSingleRouteCallData(priceRoute, exchangeParams, route, routeIndex, flags, sender, maybeWethCallData) {
-        const isMegaSwap = priceRoute.bestRoute.length > 1;
+    buildSingleRouteCallData(routes, exchangeParams, route, routeIndex, flags, sender, srcToken, destToken, maybeWethCallData) {
+        const isMegaSwap = routes.length > 1;
         const { swaps } = route;
         const appendedWrapToSwapExchangeMap = {};
         const addedWrapToSwapMap = {};
@@ -751,7 +754,7 @@ class Executor02BytecodeBuilder extends ExecutorBytecodeBuilder_1.ExecutorByteco
         const callData = swaps.reduce((swapAcc, swap, swapIndex) => hexConcat([
             swapAcc,
             this.buildSingleSwapCallData({
-                priceRoute,
+                routes,
                 exchangeParams,
                 routeIndex,
                 swapIndex,
@@ -763,35 +766,34 @@ class Executor02BytecodeBuilder extends ExecutorBytecodeBuilder_1.ExecutorByteco
                 maybeWethCallData,
                 swap,
                 index: 0,
+                srcToken,
+                destToken,
             }),
         ]), '0x');
-        const routeDoesntNeedToAddMultiSwapMetadata = route.swaps.length === 1 &&
-            route.swaps[0].swapExchanges.length !== 1 &&
-            !this.doesSwapNeedToApplyVerticalBranching(priceRoute, routeIndex, route.swaps[0]);
-        if (isMegaSwap && !routeDoesntNeedToAddMultiSwapMetadata) {
-            return this.addMultiSwapMetadata(priceRoute, exchangeParams, callData, route.percent, route.swaps[0], constants_1.NOT_EXISTING_EXCHANGE_PARAM_INDEX, Object.values(addedWrapToSwapMap).includes(true) ||
+        if (isMegaSwap) {
+            return this.wrapAsVerticalBranch(routes, exchangeParams, callData, route.percent, route.swaps[0], constants_1.NOT_EXISTING_EXCHANGE_PARAM_INDEX, Object.values(addedWrapToSwapMap).includes(true) ||
                 Object.values(appendedWrapToSwapExchangeMap).includes(true));
         }
         return callData;
     }
-    doesRouteNeedsRootWrapEth(priceRoute, exchangeParams) {
-        if (!(0, utils_1.isETHAddress)(priceRoute.srcToken)) {
+    doesRouteNeedsRootWrapEth(routes, exchangeParams, srcToken) {
+        if (!(0, utils_1.isETHAddress)(srcToken)) {
             return false;
         }
-        const res = priceRoute.bestRoute.every((route, routeIndex) => {
+        const res = routes.every(route => {
             const firstSwap = route.swaps[0];
-            const eachDexOnSwapNeedsWrapNative = this.eachDexOnSwapNeedsWrapNative(priceRoute, firstSwap, exchangeParams);
+            const eachDexOnSwapNeedsWrapNative = this.eachDexOnSwapNeedsWrapNative(routes, firstSwap, exchangeParams);
             return eachDexOnSwapNeedsWrapNative;
         });
         return res;
     }
-    doesRouteNeedsRootUnwrapEth(priceRoute, exchangeParams) {
-        if (!(0, utils_1.isETHAddress)(priceRoute.destToken)) {
+    doesRouteNeedsRootUnwrapEth(routes, exchangeParams, destToken) {
+        if (!(0, utils_1.isETHAddress)(destToken)) {
             return false;
         }
-        const res = priceRoute.bestRoute.some((route, routeIndex) => {
+        const res = routes.some(route => {
             const lastSwap = route.swaps[route.swaps.length - 1];
-            const anyDexOnSwapNeedsWrapNative = this.anyDexOnSwapNeedsWrapNative(priceRoute, lastSwap, exchangeParams);
+            const anyDexOnSwapNeedsWrapNative = this.anyDexOnSwapNeedsWrapNative(routes, lastSwap, exchangeParams);
             return anyDexOnSwapNeedsWrapNative;
         });
         return res;
@@ -799,22 +801,24 @@ class Executor02BytecodeBuilder extends ExecutorBytecodeBuilder_1.ExecutorByteco
     getAddress() {
         return this.dexHelper.config.data.executorsAddresses[types_1.Executors.TWO];
     }
-    buildByteCode(priceRoute, exchangeParams, sender, maybeWethCallData) {
+    buildByteCode(priceRoute, routes, exchangeParams, sender, maybeWethCallData) {
         const isMegaSwap = priceRoute.bestRoute.length > 1;
         const isMultiSwap = !isMegaSwap && priceRoute.bestRoute[0].swaps.length > 1;
         const needWrapEth = maybeWethCallData?.deposit && (0, utils_1.isETHAddress)(priceRoute.srcToken);
         const needUnwrapEth = maybeWethCallData?.withdraw && (0, utils_1.isETHAddress)(priceRoute.destToken);
         const needSendNativeEth = (0, utils_1.isETHAddress)(priceRoute.destToken);
-        const routeNeedsRootWrapEth = this.doesRouteNeedsRootWrapEth(priceRoute, exchangeParams);
-        const routeNeedsRootUnwrapEth = this.doesRouteNeedsRootUnwrapEth(priceRoute, exchangeParams);
-        const flags = this.buildFlags(priceRoute, exchangeParams, maybeWethCallData);
+        const routeNeedsRootWrapEth = this.doesRouteNeedsRootWrapEth(priceRoute.bestRoute, exchangeParams, priceRoute.srcToken);
+        const routeNeedsRootUnwrapEth = this.doesRouteNeedsRootUnwrapEth(priceRoute.bestRoute, exchangeParams, priceRoute.destToken);
+        const flags = this.buildFlags(priceRoute.bestRoute, exchangeParams, priceRoute.srcToken, maybeWethCallData);
         let swapsCalldata = priceRoute.bestRoute.reduce((routeAcc, route, routeIndex) => hexConcat([
             routeAcc,
-            this.buildSingleRouteCallData(priceRoute, exchangeParams, route, routeIndex, flags, sender, maybeWethCallData),
+            this.buildSingleRouteCallData(priceRoute.bestRoute, exchangeParams, route, routeIndex, flags, sender, priceRoute.srcToken, priceRoute.destToken, maybeWethCallData),
         ]), '0x');
+        // hack to do wrap/unwrap before the priceRoute execution
+        // first make wrap/unwrap, then execute mega swap as vertical branch
         if (isMegaSwap && (needWrapEth || needUnwrapEth)) {
             const lastPriceRoute = priceRoute.bestRoute[priceRoute.bestRoute.length - 1];
-            swapsCalldata = this.buildVerticalBranchingCallData(priceRoute, priceRoute.bestRoute.length - 1, exchangeParams, lastPriceRoute.swaps[lastPriceRoute.swaps.length - 1], swapsCalldata, needWrapEth
+            swapsCalldata = this.buildVerticalBranchingCallData(priceRoute.bestRoute, priceRoute.bestRoute.length - 1, exchangeParams, lastPriceRoute.swaps[lastPriceRoute.swaps.length - 1], swapsCalldata, needWrapEth
                 ? types_1.Flag.DONT_INSERT_FROM_AMOUNT_DONT_CHECK_BALANCE_AFTER_SWAP // 0
                 : types_1.Flag.DONT_INSERT_FROM_AMOUNT_CHECK_SRC_TOKEN_BALANCE_AFTER_SWAP, // 8
             true);
@@ -827,7 +831,7 @@ class Executor02BytecodeBuilder extends ExecutorBytecodeBuilder_1.ExecutorByteco
                 const percent = exchangeParams.every(ep => ep.needWrapNative)
                     ? 100
                     : swap.swapExchanges
-                        .filter((se, index) => {
+                        .filter((_se, index) => {
                         return exchangeParams[index].needWrapNative;
                     })
                         .reduce((acc, se) => {
@@ -857,7 +861,7 @@ class Executor02BytecodeBuilder extends ExecutorBytecodeBuilder_1.ExecutorByteco
             swapsCalldata = hexConcat([swapsCalldata, finalSpecialFlagCalldata]);
         }
         if (((needWrapEth || needUnwrapEth) && isMegaSwap) || isMultiSwap) {
-            swapsCalldata = this.addMultiSwapMetadata(priceRoute, exchangeParams, swapsCalldata, constants_1.SWAP_EXCHANGE_100_PERCENTAGE, priceRoute.bestRoute[0].swaps[0], constants_1.NOT_EXISTING_EXCHANGE_PARAM_INDEX, false);
+            swapsCalldata = this.wrapAsVerticalBranch(priceRoute.bestRoute, exchangeParams, swapsCalldata, constants_1.SWAP_EXCHANGE_100_PERCENTAGE, priceRoute.bestRoute[0].swaps[0], constants_1.NOT_EXISTING_EXCHANGE_PARAM_INDEX, false);
         }
         return solidityPack(['bytes32', 'bytes', 'bytes'], [
             hexZeroPad(hexlify(32), 32), // calldata offset