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

package/build/executor/Executor02BytecodeBuilderMultiRoute.js

@@ -0,0 +1,744 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Executor02BytecodeBuilderMultiRoute = void 0;
+const ethers_1 = require("ethers");
+const types_1 = require("./types");
+const utils_1 = require("../utils");
+const ExecutorBytecodeBuilder_1 = require("./ExecutorBytecodeBuilder");
+const constants_1 = require("./constants");
+const { utils: { hexlify, hexDataLength, hexConcat, hexZeroPad, solidityPack }, } = ethers_1.ethers;
+/**
+ * Class to build bytecode for Executor02 - simpleSwap with N DEXs (VERTICAL_BRANCH), multiSwaps (VERTICAL_BRANCH_HORIZONTAL_SEQUENCE) and megaswaps (NESTED_VERTICAL_BRANCH_HORIZONTAL_SEQUENCE)
+ */
+class Executor02BytecodeBuilderMultiRoute extends ExecutorBytecodeBuilder_1.ExecutorBytecodeBuilder {
+    type = types_1.Executors.TWO;
+    /**
+     * Executor02 Flags:
+     * switch (flag % 4):
+     * case 0: don't instert fromAmount
+     * case 1: sendEth equal to fromAmount
+     * case 2: sendEth equal to fromAmount + insert fromAmount
+     * case 3: insert fromAmount
+  
+     * switch (flag % 3):
+     * case 0: don't check balance after swap
+     * case 1: check eth balance after swap
+     * case 2: check destToken balance after swap
+     */
+    buildSimpleSwapFlags(params) {
+        const { maybeWethCallData, swapExchange, swap } = params;
+        const { srcToken, destToken } = swap;
+        const isEthSrc = (0, utils_1.isETHAddress)(srcToken);
+        const isEthDest = (0, utils_1.isETHAddress)(destToken);
+        const exchangeParam = swapExchange.build.dexParams;
+        const { dexFuncHasRecipient, needWrapNative, specialDexFlag, specialDexSupportsInsertFromAmount, swappedAmountNotPresentInExchangeData, preSwapUnwrapCalldata, sendEthButSupportsInsertFromAmount, } = exchangeParam;
+        const needWrap = needWrapNative && isEthSrc && maybeWethCallData?.deposit;
+        const needUnwrap = needWrapNative && isEthDest && maybeWethCallData?.withdraw;
+        const isSpecialDex = specialDexFlag !== undefined && specialDexFlag !== types_1.SpecialDex.DEFAULT;
+        const forcePreventInsertFromAmount = swappedAmountNotPresentInExchangeData ||
+            (isSpecialDex && !specialDexSupportsInsertFromAmount);
+        let dexFlag = forcePreventInsertFromAmount
+            ? types_1.Flag.DONT_INSERT_FROM_AMOUNT_DONT_CHECK_BALANCE_AFTER_SWAP
+            : types_1.Flag.INSERT_FROM_AMOUNT_DONT_CHECK_BALANCE_AFTER_SWAP; // 0 or 3
+        let approveFlag = types_1.Flag.DONT_INSERT_FROM_AMOUNT_DONT_CHECK_BALANCE_AFTER_SWAP; // 0
+        if (isEthSrc && !needWrap) {
+            dexFlag = dexFuncHasRecipient
+                ? !sendEthButSupportsInsertFromAmount
+                    ? types_1.Flag.SEND_ETH_EQUAL_TO_FROM_AMOUNT_DONT_CHECK_BALANCE_AFTER_SWAP // 9
+                    : types_1.Flag.SEND_ETH_EQUAL_TO_FROM_AMOUNT_PLUS_INSERT_FROM_AMOUNT_DONT_CHECK_BALANCE_AFTER_SWAP // 18
+                : !sendEthButSupportsInsertFromAmount
+                    ? types_1.Flag.SEND_ETH_EQUAL_TO_FROM_AMOUNT_CHECK_SRC_TOKEN_BALANCE_AFTER_SWAP // 5
+                    : types_1.Flag.SEND_ETH_EQUAL_TO_FROM_AMOUNT_PLUS_INSERT_FROM_AMOUNT_DONT_CHECK_BALANCE_AFTER_SWAP; // 18
+        }
+        else if (isEthDest && !needUnwrap) {
+            dexFlag = forcePreventInsertFromAmount
+                ? types_1.Flag.DONT_INSERT_FROM_AMOUNT_CHECK_ETH_BALANCE_AFTER_SWAP
+                : types_1.Flag.INSERT_FROM_AMOUNT_CHECK_ETH_BALANCE_AFTER_SWAP; // 4 or 7
+        }
+        else if (!dexFuncHasRecipient || (isEthDest && needUnwrap)) {
+            dexFlag = forcePreventInsertFromAmount
+                ? types_1.Flag.DONT_INSERT_FROM_AMOUNT_CHECK_SRC_TOKEN_BALANCE_AFTER_SWAP
+                : types_1.Flag.INSERT_FROM_AMOUNT_CHECK_SRC_TOKEN_BALANCE_AFTER_SWAP; // 8 or 11
+        }
+        // Actual srcToken is eth, because we'll unwrap weth before swap.
+        // Need to check balance, some dexes don't have 1:1 ETH -> custom_ETH rate
+        if (preSwapUnwrapCalldata) {
+            dexFlag =
+                types_1.Flag.SEND_ETH_EQUAL_TO_FROM_AMOUNT_CHECK_SRC_TOKEN_BALANCE_AFTER_SWAP;
+        }
+        return {
+            dexFlag,
+            approveFlag,
+        };
+    }
+    /**
+     * Executor02 Flags:
+     * switch (flag % 4):
+     * case 0: don't instert fromAmount
+     * case 1: sendEth equal to fromAmount
+     * case 2: sendEth equal to fromAmount + insert fromAmount
+     * case 3: insert fromAmount
+  
+     * switch (flag % 3):
+     * case 0: don't check balance after swap
+     * case 1: check eth balance after swap
+     * case 2: check destToken balance after swap
+     */
+    buildMultiMegaSwapFlags(params) {
+        const { singleRoutes, swap, swapExchange, maybeWethCallData, routeIndex, swapIndex, swapExchangeIndex, } = params;
+        const route = singleRoutes[routeIndex];
+        const exchangeParam = swapExchange.build.dexParams;
+        const { srcToken, destToken } = swap;
+        const applyVerticalBranching = this.doesSwapNeedToBeAsVerticalBranch(singleRoutes, 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;
+        const { dexFuncHasRecipient, needWrapNative, specialDexFlag, specialDexSupportsInsertFromAmount, swappedAmountNotPresentInExchangeData, wethAddress, sendEthButSupportsInsertFromAmount, preSwapUnwrapCalldata, } = exchangeParam;
+        const isEthSrc = (0, utils_1.isETHAddress)(srcToken);
+        const isEthDest = (0, utils_1.isETHAddress)(destToken);
+        const isWethDest = (wethAddress && destToken.toLowerCase() === wethAddress.toLowerCase()) ||
+            this.dexHelper.config.isWETH(destToken);
+        const isSpecialDex = specialDexFlag !== undefined && specialDexFlag !== types_1.SpecialDex.DEFAULT;
+        const forcePreventInsertFromAmount = swappedAmountNotPresentInExchangeData ||
+            (isSpecialDex && !specialDexSupportsInsertFromAmount);
+        const forceBalanceOfCheck = (isSpecialDex &&
+            isHorizontalSequence &&
+            !applyVerticalBranching &&
+            !isLastSwap) ||
+            !dexFuncHasRecipient;
+        const needUnwrap = needWrapNative && isEthDest && maybeWethCallData?.withdraw;
+        const needSendEth = isEthSrc && !needWrapNative;
+        const needCheckEthBalance = isEthDest && !needWrapNative;
+        const anyDexOnSwapDoesntNeedWrapNative = this.anyDexOnSwapDoesntNeedWrapNative(swap);
+        // check if current exchange is the last with needWrapNative
+        const isLastExchangeWithNeedWrapNative = this.isLastExchangeWithNeedWrapNative(swap, swapExchangeIndex);
+        //  for the first part, basically replicates the logic from `unwrap after last swap` in buildSingleSwapExchangeCallData
+        const needCheckSrcTokenBalanceOf = (needUnwrap &&
+            (!applyVerticalBranching ||
+                (applyVerticalBranching && anyDexOnSwapDoesntNeedWrapNative)) &&
+            (isLastExchangeWithNeedWrapNative || exchangeParam.wethAddress)) ||
+            (isHorizontalSequence && !applyVerticalBranching && !isLastSwap);
+        let dexFlag;
+        let approveFlag = types_1.Flag.DONT_INSERT_FROM_AMOUNT_DONT_CHECK_BALANCE_AFTER_SWAP; // 0
+        if (needSendEth) {
+            const preventInsertForSendEth = forcePreventInsertFromAmount || !sendEthButSupportsInsertFromAmount;
+            dexFlag =
+                needCheckSrcTokenBalanceOf || forceBalanceOfCheck
+                    ? preventInsertForSendEth
+                        ? types_1.Flag.SEND_ETH_EQUAL_TO_FROM_AMOUNT_CHECK_SRC_TOKEN_BALANCE_AFTER_SWAP // 5
+                        : types_1.Flag.SEND_ETH_EQUAL_TO_FROM_AMOUNT_PLUS_INSERT_FROM_AMOUNT_CHECK_SRC_TOKEN_BALANCE_AFTER_SWAP // 14
+                    : dexFuncHasRecipient
+                        ? preventInsertForSendEth
+                            ? types_1.Flag.SEND_ETH_EQUAL_TO_FROM_AMOUNT_DONT_CHECK_BALANCE_AFTER_SWAP // 9
+                            : types_1.Flag.SEND_ETH_EQUAL_TO_FROM_AMOUNT_PLUS_INSERT_FROM_AMOUNT_DONT_CHECK_BALANCE_AFTER_SWAP // 18
+                        : preventInsertForSendEth
+                            ? types_1.Flag.SEND_ETH_EQUAL_TO_FROM_AMOUNT_CHECK_SRC_TOKEN_BALANCE_AFTER_SWAP // 5
+                            : types_1.Flag.SEND_ETH_EQUAL_TO_FROM_AMOUNT_PLUS_INSERT_FROM_AMOUNT_DONT_CHECK_BALANCE_AFTER_SWAP; // 18
+        }
+        else if (needCheckEthBalance) {
+            dexFlag =
+                needCheckSrcTokenBalanceOf || forceBalanceOfCheck
+                    ? forcePreventInsertFromAmount && dexFuncHasRecipient
+                        ? types_1.Flag.DONT_INSERT_FROM_AMOUNT_CHECK_ETH_BALANCE_AFTER_SWAP // 4
+                        : types_1.Flag.INSERT_FROM_AMOUNT_CHECK_ETH_BALANCE_AFTER_SWAP // 7
+                    : forcePreventInsertFromAmount && dexFuncHasRecipient
+                        ? types_1.Flag.DONT_INSERT_FROM_AMOUNT_DONT_CHECK_BALANCE_AFTER_SWAP // 0
+                        : types_1.Flag.INSERT_FROM_AMOUNT_DONT_CHECK_BALANCE_AFTER_SWAP; // 3
+        }
+        else {
+            dexFlag =
+                needCheckSrcTokenBalanceOf || forceBalanceOfCheck
+                    ? forcePreventInsertFromAmount
+                        ? types_1.Flag.DONT_INSERT_FROM_AMOUNT_CHECK_SRC_TOKEN_BALANCE_AFTER_SWAP // 8
+                        : types_1.Flag.INSERT_FROM_AMOUNT_CHECK_SRC_TOKEN_BALANCE_AFTER_SWAP // 11
+                    : forcePreventInsertFromAmount
+                        ? types_1.Flag.DONT_INSERT_FROM_AMOUNT_DONT_CHECK_BALANCE_AFTER_SWAP // 0
+                        : types_1.Flag.INSERT_FROM_AMOUNT_DONT_CHECK_BALANCE_AFTER_SWAP; // 3
+        }
+        // Actual srcToken is eth, because we'll unwrap weth before swap.
+        // Need to check balance, some dexes don't have 1:1 ETH -> custom_ETH rate
+        if (preSwapUnwrapCalldata) {
+            dexFlag =
+                types_1.Flag.SEND_ETH_EQUAL_TO_FROM_AMOUNT_CHECK_SRC_TOKEN_BALANCE_AFTER_SWAP;
+        }
+        return {
+            dexFlag,
+            approveFlag,
+        };
+    }
+    buildDexCallData(params) {
+        const { singleRoutes, swapExchangeIndex, routeIndex, swapIndex, destToken, } = params;
+        const swap = singleRoutes[routeIndex].swaps[swapIndex];
+        const swapExchange = swap.swapExchanges[swapExchangeIndex];
+        const flag = swapExchange.build.dexFlag;
+        const exchangeParam = swap.swapExchanges[swapExchangeIndex].build.dexParams;
+        let { exchangeData, specialDexFlag, targetExchange, needWrapNative } = exchangeParam;
+        const routeNeedsRootUnwrapEth = this.doesRouteNeedsRootUnwrapEth(singleRoutes, destToken);
+        const needUnwrap = 
+        // check if current exchange is the last with needWrapNative
+        this.isLastExchangeWithNeedWrapNative(swap, swapExchangeIndex) ||
+            exchangeParam.wethAddress;
+        const needUnwrapAfterLastSwapInRoute = needUnwrap &&
+            (0, utils_1.isETHAddress)(swap.destToken) &&
+            this.anyDexOnSwapDoesntNeedWrapNative(swap);
+        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.doesSwapNeedToBeAsVerticalBranch(singleRoutes, routeIndex, swap);
+        const dontCheckBalanceAfterSwap = flag % 3 === 0;
+        const checkDestTokenBalanceAfterSwap = flag % 3 === 2;
+        const insertFromAmount = flag % 4 === 3 || flag % 4 === 2;
+        const srcTokenAddress = (0, utils_1.isETHAddress)(swap.srcToken) && needWrapNative
+            ? this.getWETHAddress(exchangeParam)
+            : swap.srcToken.toLowerCase();
+        const destTokenAddress = (0, utils_1.isETHAddress)(swap.destToken) && needWrapNative
+            ? this.getWETHAddress(exchangeParam)
+            : swap.destToken.toLowerCase();
+        exchangeData = this.addTokenAddressToCallData(exchangeData, srcTokenAddress);
+        if (applyVerticalBranching ||
+            (checkDestTokenBalanceAfterSwap && !dontCheckBalanceAfterSwap)) {
+            exchangeData = this.addTokenAddressToCallData(exchangeData, destTokenAddress);
+        }
+        let destTokenPos = 0;
+        if (checkDestTokenBalanceAfterSwap && !dontCheckBalanceAfterSwap) {
+            const destTokenAddrIndex = exchangeData
+                .replace('0x', '')
+                .indexOf(destTokenAddress.replace('0x', ''));
+            destTokenPos = (destTokenAddrIndex - 24) / 2;
+        }
+        let fromAmountPos = 0;
+        if (insertFromAmount) {
+            if (exchangeParam.insertFromAmountPos) {
+                fromAmountPos = exchangeParam.insertFromAmountPos;
+            }
+            else {
+                const fromAmount = ethers_1.ethers.utils.defaultAbiCoder.encode(['uint256'], [swapExchange.srcAmount]);
+                const fromAmountIndex = exchangeData
+                    .replace('0x', '')
+                    .indexOf(fromAmount.replace('0x', ''));
+                fromAmountPos =
+                    (fromAmountIndex !== -1 ? fromAmountIndex : exchangeData.length) / 2;
+            }
+        }
+        return this.buildCallData(targetExchange, exchangeData, fromAmountPos, destTokenPos, specialDexFlag || types_1.SpecialDex.DEFAULT, flag, undefined, returnAmountPos);
+    }
+    wrapAsVerticalBranch(callData, percentage, swap, wrapWasAddedInSwapExchange, curExchangeParam = null, addedUnwrapForDexWithNoNeedWrapNative = false) {
+        let srcTokenAddress = swap.srcToken;
+        let doesAnyDexOnSwapNeedsWrapNative;
+        // if (exchangeParamIndex > -1) { // TODO-multi: what this case is about?
+        if (curExchangeParam) {
+            doesAnyDexOnSwapNeedsWrapNative =
+                (0, utils_1.isETHAddress)(srcTokenAddress) &&
+                    (curExchangeParam.needWrapNative ||
+                        (!curExchangeParam.needWrapNative &&
+                            addedUnwrapForDexWithNoNeedWrapNative));
+        }
+        else {
+            doesAnyDexOnSwapNeedsWrapNative =
+                (0, utils_1.isETHAddress)(srcTokenAddress) && this.anyDexOnSwapNeedsWrapNative(swap);
+        }
+        if (doesAnyDexOnSwapNeedsWrapNative &&
+            (0, utils_1.isETHAddress)(srcTokenAddress) &&
+            !wrapWasAddedInSwapExchange) {
+            srcTokenAddress =
+                // exchangeParamIndex > -1 TODO-multi
+                curExchangeParam
+                    ? this.getWETHAddress(curExchangeParam)
+                    : this.dexHelper.config.data.wrappedNativeTokenAddress;
+        }
+        let srcTokenAddressLowered = srcTokenAddress.toLowerCase();
+        let srcTokenPos;
+        if (percentage === constants_1.SWAP_EXCHANGE_100_PERCENTAGE) {
+            srcTokenPos = hexZeroPad(hexlify(0), 8);
+        }
+        else if ((0, utils_1.isETHAddress)(srcTokenAddressLowered)) {
+            srcTokenPos = constants_1.ETH_SRC_TOKEN_POS_FOR_MULTISWAP_METADATA;
+        }
+        else {
+            const srcTokenAddrIndex = callData
+                .replace('0x', '')
+                .indexOf(srcTokenAddressLowered.replace('0x', ''));
+            srcTokenPos = hexZeroPad(hexlify(srcTokenAddrIndex / 2), 8);
+        }
+        return solidityPack(['bytes16', 'bytes8', 'bytes8', 'bytes'], [
+            hexZeroPad(hexlify(hexDataLength(callData)), 16), // calldata size
+            srcTokenPos, // srcTokenPos
+            hexZeroPad(hexlify(Math.round(percentage * 100)), 8), // percentage
+            callData, // swap calldata
+        ]);
+    }
+    packVerticalBranchingData(swapCallData) {
+        return solidityPack(['bytes28', 'bytes4', 'bytes32', 'bytes32', 'bytes'], [
+            constants_1.ZEROS_28_BYTES, // empty bytes28
+            constants_1.ZEROS_4_BYTES, // fallback selector
+            hexZeroPad(hexlify(32), 32), // calldata offset
+            hexZeroPad(hexlify(hexDataLength(swapCallData)), 32), // calldata length
+            swapCallData, // calldata
+        ]);
+    }
+    packVerticalBranchingCallData(verticalBranchingData, fromAmountPos, destTokenPos, flag) {
+        return solidityPack([
+            'bytes20',
+            'bytes4',
+            'bytes2',
+            'bytes2',
+            'bytes1',
+            'bytes1',
+            'bytes2',
+            'bytes',
+        ], [
+            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
+            hexZeroPad(hexlify(0), 1), // returnAmountPos
+            hexZeroPad(hexlify(types_1.SpecialDex.EXECUTE_VERTICAL_BRANCHING), 1), // special
+            hexZeroPad(hexlify(flag), 2), // flag
+            verticalBranchingData, // dexes calldata
+        ]);
+    }
+    buildVerticalBranchingCallData(singleRoutes, swap, swapCallData, flag, isRoot = false) {
+        const destTokenAddrLowered = swap.destToken.toLowerCase();
+        const isEthDest = (0, utils_1.isETHAddress)(destTokenAddrLowered);
+        let anyDexOnSwapNeedsWrapNative = false;
+        let anyDexOnSwapDoesntNeedWrapNative = false;
+        let destTokenPos;
+        if (isEthDest) {
+            if (!isRoot) {
+                anyDexOnSwapNeedsWrapNative = this.anyDexOnSwapNeedsWrapNative(swap);
+                anyDexOnSwapDoesntNeedWrapNative =
+                    this.anyDexOnSwapDoesntNeedWrapNative(swap);
+            }
+            else {
+                anyDexOnSwapNeedsWrapNative = singleRoutes.some(route => this.anyDexOnSwapNeedsWrapNative(route.swaps[route.swaps.length - 1]));
+                anyDexOnSwapDoesntNeedWrapNative = singleRoutes.some(route => this.anyDexOnSwapDoesntNeedWrapNative(route.swaps[route.swaps.length - 1]));
+            }
+        }
+        // 'bytes28', 'bytes4', 'bytes32', 'bytes32', 'bytes'
+        const data = this.packVerticalBranchingData(swapCallData);
+        if (isEthDest &&
+            anyDexOnSwapDoesntNeedWrapNative &&
+            !anyDexOnSwapNeedsWrapNative) {
+            destTokenPos = 0;
+        }
+        else {
+            const destTokenAddrIndex = data
+                .replace('0x', '')
+                .indexOf((isEthDest
+                ? this.dexHelper.config.data.wrappedNativeTokenAddress.toLowerCase()
+                : destTokenAddrLowered.toLowerCase()).replace('0x', ''));
+            destTokenPos = destTokenAddrIndex / 2 - 40;
+        }
+        const fromAmountPos = hexDataLength(data) - 64 - 28; // 64 (position), 28 (selector padding);
+        return this.packVerticalBranchingCallData(data, fromAmountPos, destTokenPos < 0 ? 0 : destTokenPos, flag);
+    }
+    buildSingleSwapExchangeCallData(singleRoutes, routeIndex, swapIndex, swapExchangeIndex, addedWrapToSwapExchangeMap, allowToAddWrap = true, prevBranchWasWrapped = false, unwrapToSwapMap, srcToken, destToken, maybeWethCallData, hasMultipleSwapExchanges, isMultiOrMegaSwap) {
+        const isSimpleSwap = singleRoutes.length === 1 && singleRoutes[0].swaps.length === 1;
+        let swapExchangeCallData = '';
+        const swap = singleRoutes[routeIndex].swaps[swapIndex];
+        const swapExchange = swap.swapExchanges[swapExchangeIndex];
+        const curExchangeParam = swapExchange.build.dexParams;
+        const approveFlag = swapExchange.build.approveFlag;
+        const dexCallData = this.buildDexCallData({
+            singleRoutes,
+            routeIndex,
+            swapIndex,
+            swapExchangeIndex,
+            isLastSwap: false,
+            destToken,
+            // TODO-multi to be removed after refactoring
+            routes: [],
+            exchangeParams: [],
+            exchangeParamIndex: constants_1.NOT_EXISTING_EXCHANGE_PARAM_INDEX,
+            flag: types_1.Flag.DONT_INSERT_FROM_AMOUNT_DONT_CHECK_BALANCE_AFTER_SWAP,
+        });
+        if (curExchangeParam.preSwapUnwrapCalldata) {
+            const withdrawCallData = this.buildUnwrapEthCallData(this.getWETHAddress(curExchangeParam), curExchangeParam.preSwapUnwrapCalldata);
+            swapExchangeCallData = hexConcat([withdrawCallData, dexCallData]);
+        }
+        else {
+            swapExchangeCallData = hexConcat([dexCallData]);
+        }
+        const isLastSwap = swapIndex === singleRoutes[routeIndex].swaps.length - 1;
+        if (curExchangeParam.transferSrcTokenBeforeSwap) {
+            const transferCallData = this.buildTransferCallData(this.erc20Interface.encodeFunctionData('transfer', [
+                curExchangeParam.transferSrcTokenBeforeSwap,
+                swapExchange.srcAmount,
+            ]), (0, utils_1.isETHAddress)(swap.srcToken)
+                ? this.getWETHAddress(curExchangeParam)
+                : swap.srcToken.toLowerCase());
+            swapExchangeCallData = hexConcat([
+                transferCallData,
+                swapExchangeCallData,
+            ]);
+        }
+        if (!(0, utils_1.isETHAddress)(swap.srcToken) &&
+            !curExchangeParam.transferSrcTokenBeforeSwap &&
+            !curExchangeParam.skipApproval &&
+            curExchangeParam.approveData) {
+            const approveCallData = this.buildApproveCallData(curExchangeParam.approveData.target, curExchangeParam.approveData.token, approveFlag, curExchangeParam.permit2Approval);
+            swapExchangeCallData = hexConcat([approveCallData, swapExchangeCallData]);
+        }
+        if (curExchangeParam.needWrapNative) {
+            if ((0, utils_1.isETHAddress)(swap.srcToken)) {
+                let approveWethCalldata = '0x';
+                if (curExchangeParam.approveData &&
+                    !curExchangeParam.transferSrcTokenBeforeSwap &&
+                    !curExchangeParam.skipApproval) {
+                    approveWethCalldata = this.buildApproveCallData(curExchangeParam.approveData.target, curExchangeParam.approveData.token, approveFlag, curExchangeParam.permit2Approval);
+                }
+                const isNotFirstSwap = swapIndex !== 0;
+                let skipWrap = false;
+                if (isNotFirstSwap) {
+                    const prevSwap = singleRoutes[routeIndex].swaps[swapIndex - 1];
+                    const anyDexOnSwapDoesntNeedWrapNative = this.anyDexOnSwapDoesntNeedWrapNative(prevSwap);
+                    skipWrap = !anyDexOnSwapDoesntNeedWrapNative;
+                }
+                let depositCallData = '0x';
+                if (maybeWethCallData &&
+                    maybeWethCallData.deposit &&
+                    !this.doesRouteNeedsRootWrapEth(singleRoutes, srcToken) &&
+                    allowToAddWrap &&
+                    !addedWrapToSwapExchangeMap[`${routeIndex}_${swapIndex}_${swapExchangeIndex}`] &&
+                    !skipWrap) {
+                    depositCallData = this.buildWrapEthCallData(this.getWETHAddress(curExchangeParam), maybeWethCallData.deposit.calldata, types_1.Flag.SEND_ETH_EQUAL_TO_FROM_AMOUNT_DONT_CHECK_BALANCE_AFTER_SWAP);
+                    addedWrapToSwapExchangeMap[`${routeIndex}_${swapIndex}_${swapExchangeIndex}`] = true;
+                }
+                swapExchangeCallData = hexConcat([
+                    approveWethCalldata,
+                    depositCallData,
+                    swapExchangeCallData,
+                ]);
+            }
+            const needUnwrap = isMultiOrMegaSwap && hasMultipleSwapExchanges;
+            // unwrap after last swap
+            if (maybeWethCallData &&
+                maybeWethCallData.withdraw &&
+                ((!needUnwrap && (0, utils_1.isETHAddress)(swap.destToken)) ||
+                    (needUnwrap &&
+                        (0, utils_1.isETHAddress)(swap.destToken) &&
+                        this.anyDexOnSwapDoesntNeedWrapNative(swap)))) {
+                let withdrawCallData = '0x';
+                const customWethAddress = curExchangeParam.wethAddress;
+                const nextSwap = singleRoutes[routeIndex].swaps[swapIndex + 1];
+                const needUnwrapAll = isSimpleSwap ||
+                    (isLastSwap
+                        ? !this.doesRouteNeedsRootUnwrapEth(singleRoutes, destToken)
+                        : this.everyDexOnSwapNeedWrapNative(nextSwap) ||
+                            this.everyDexOnSwapDoesntNeedWrapNative(nextSwap));
+                // check if current exchange is the last with needWrapNative
+                const needUnwrap = needUnwrapAll &&
+                    this.isLastExchangeWithNeedWrapNative(swap, swapExchangeIndex);
+                if (customWethAddress || needUnwrap) {
+                    unwrapToSwapMap[swapIndex] = true;
+                    withdrawCallData = this.buildUnwrapEthCallData(this.getWETHAddress(curExchangeParam), maybeWethCallData.withdraw.calldata);
+                }
+                swapExchangeCallData = hexConcat([
+                    swapExchangeCallData,
+                    withdrawCallData,
+                ]);
+                if (isSimpleSwap && (needUnwrap || customWethAddress)) {
+                    const finalSpecialFlagCalldata = this.buildFinalSpecialFlagCalldata();
+                    swapExchangeCallData = hexConcat([
+                        swapExchangeCallData,
+                        finalSpecialFlagCalldata,
+                    ]);
+                }
+            }
+        }
+        let addedUnwrapForDexWithNoNeedWrapNative = false;
+        if ((0, utils_1.isETHAddress)(swap.srcToken) &&
+            maybeWethCallData &&
+            maybeWethCallData.withdraw &&
+            !curExchangeParam.needWrapNative &&
+            !unwrapToSwapMap[swapIndex - 1]) {
+            const prevSwap = singleRoutes[routeIndex].swaps[swapIndex - 1];
+            let eachDexOnPrevSwapReturnsWeth = false;
+            if (prevSwap && !prevBranchWasWrapped) {
+                eachDexOnPrevSwapReturnsWeth =
+                    this.eachDexOnSwapNeedsWrapNative(prevSwap);
+            }
+            if (prevBranchWasWrapped || eachDexOnPrevSwapReturnsWeth) {
+                const withdrawCallData = this.buildUnwrapEthCallData(this.getWETHAddress(curExchangeParam), maybeWethCallData.withdraw.calldata);
+                swapExchangeCallData = hexConcat([
+                    withdrawCallData,
+                    swapExchangeCallData,
+                ]);
+                addedUnwrapForDexWithNoNeedWrapNative = true;
+            }
+        }
+        if (isLastSwap &&
+            !curExchangeParam.dexFuncHasRecipient &&
+            !(0, utils_1.isETHAddress)(swap.destToken) &&
+            destToken === swap.destToken) {
+            const transferCallData = this.buildTransferCallData(this.erc20Interface.encodeFunctionData('transfer', [
+                this.dexHelper.config.data.augustusV6Address,
+                swapExchange.destAmount,
+            ]), swap.destToken);
+            swapExchangeCallData = hexConcat([
+                swapExchangeCallData,
+                transferCallData,
+            ]);
+        }
+        if (!curExchangeParam.dexFuncHasRecipient &&
+            (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(singleRoutes, destToken)) {
+            const finalSpecialFlagCalldata = this.buildFinalSpecialFlagCalldata();
+            swapExchangeCallData = hexConcat([
+                swapExchangeCallData,
+                finalSpecialFlagCalldata,
+            ]);
+        }
+        // if swap has multiple exchanges, then each exchange is executed as part of vertical branching
+        if (hasMultipleSwapExchanges) {
+            return this.wrapAsVerticalBranch(swapExchangeCallData, swapExchange.percent, swap, addedWrapToSwapExchangeMap[`${routeIndex}_${swapIndex}_${swapExchangeIndex}`], curExchangeParam, addedUnwrapForDexWithNoNeedWrapNative);
+        }
+        return swapExchangeCallData;
+    }
+    appendWrapEthCallData(calldata, maybeWethCallData, checkWethBalanceAfter = false) {
+        if (maybeWethCallData?.deposit) {
+            const callData = checkWethBalanceAfter
+                ? this.addTokenAddressToCallData(maybeWethCallData.deposit.calldata, this.dexHelper.config.data.wrappedNativeTokenAddress.toLowerCase())
+                : maybeWethCallData.deposit.calldata;
+            const depositCallData = this.buildWrapEthCallData(this.dexHelper.config.data.wrappedNativeTokenAddress.toLowerCase(), callData, checkWethBalanceAfter
+                ? types_1.Flag.SEND_ETH_EQUAL_TO_FROM_AMOUNT_CHECK_SRC_TOKEN_BALANCE_AFTER_SWAP // 5
+                : types_1.Flag.SEND_ETH_EQUAL_TO_FROM_AMOUNT_DONT_CHECK_BALANCE_AFTER_SWAP, // 9
+            checkWethBalanceAfter ? 4 : 0);
+            return hexConcat([calldata, depositCallData]);
+        }
+        return calldata;
+    }
+    eachDexOnSwapNeedsWrapNative(swap) {
+        return swap.swapExchanges.every(se => {
+            return (se.build.dexParams.needWrapNative && !se.build.dexParams.wethAddress);
+        });
+    }
+    anyDexOnSwapNeedsWrapNative(swap) {
+        return swap.swapExchanges
+            .map(s => s.build.dexParams.needWrapNative && !s.build.dexParams.wethAddress)
+            .includes(true);
+    }
+    isLastExchangeWithNeedWrapNative(swap, swapExchangeIndex) {
+        return (swap.swapExchanges
+            .map(t => t.build.dexParams.needWrapNative)
+            .reduceRight((acc, needWrapNative, index) => needWrapNative === true && acc === -1 ? index : acc, -1) === swapExchangeIndex);
+    }
+    anyDexOnSwapDoesntNeedWrapNative(swap) {
+        return swap.swapExchanges
+            .map(s => !s.build.dexParams.needWrapNative)
+            .includes(true);
+    }
+    everyDexOnSwapNeedWrapNative(swap) {
+        if (!swap) {
+            return false;
+        }
+        return swap.swapExchanges
+            .map(s => s.build.dexParams.needWrapNative)
+            .every(t => t === true);
+    }
+    everyDexOnSwapDoesntNeedWrapNative(swap) {
+        if (!swap) {
+            return false;
+        }
+        return swap.swapExchanges
+            .map(s => s.build.dexParams.needWrapNative)
+            .every(t => t === false);
+    }
+    doesSwapNeedToBeAsVerticalBranch(singleRoutes, routeIndex, swap) {
+        const isMegaSwap = singleRoutes.length > 1;
+        const isMultiSwap = !isMegaSwap && singleRoutes[routeIndex].swaps.length > 1;
+        return (isMultiSwap || isMegaSwap) && swap.swapExchanges.length > 1;
+    }
+    buildVerticalBranchingFlag(singleRoutes, swap, routeIndex, swapIndex, destToken) {
+        let flag = types_1.Flag.INSERT_FROM_AMOUNT_CHECK_SRC_TOKEN_BALANCE_AFTER_SWAP; // 11
+        const isLastSwap = swapIndex === singleRoutes[routeIndex].swaps.length - 1;
+        if (isLastSwap) {
+            const isEthDest = (0, utils_1.isETHAddress)(destToken);
+            const lastSwap = singleRoutes[routeIndex].swaps[singleRoutes[routeIndex].swaps.length - 1];
+            const lastSwapExchanges = lastSwap.swapExchanges;
+            const anyDexLastSwapNeedUnwrap = lastSwapExchanges
+                .map(se => se.build.dexParams.needWrapNative &&
+                !se.build.dexParams.wethAddress)
+                .includes(true);
+            const noNeedUnwrap = isEthDest && !anyDexLastSwapNeedUnwrap;
+            if (noNeedUnwrap || !isEthDest) {
+                flag = types_1.Flag.INSERT_FROM_AMOUNT_DONT_CHECK_BALANCE_AFTER_SWAP; // 3
+            }
+        }
+        else {
+            const isEthDest = (0, utils_1.isETHAddress)(swap.destToken);
+            if (isEthDest) {
+                if (this.anyDexOnSwapDoesntNeedWrapNative(swap)) {
+                    flag = types_1.Flag.INSERT_FROM_AMOUNT_CHECK_ETH_BALANCE_AFTER_SWAP; // 7
+                }
+            }
+        }
+        return flag;
+    }
+    buildSingleSwapCallData(params) {
+        const { routeIndex, swapIndex, maybeWethCallData, wrapToSwapMap, unwrapToSwapMap, wrapToSwapExchangeMap, swap, srcToken, destToken, singleRoutes, } = params;
+        const isLastSwap = swapIndex === singleRoutes[routeIndex].swaps.length - 1;
+        const isMegaSwap = singleRoutes.length > 1;
+        const isMultiSwap = !isMegaSwap && singleRoutes[routeIndex].swaps.length > 1;
+        const { swapExchanges } = swap;
+        const applyVerticalBranching = this.doesSwapNeedToBeAsVerticalBranch(singleRoutes, routeIndex, swap);
+        const anyDexOnSwapDoesntNeedWrapNative = this.anyDexOnSwapDoesntNeedWrapNative(swap);
+        const needToAppendWrapCallData = (0, utils_1.isETHAddress)(swap.destToken) &&
+            anyDexOnSwapDoesntNeedWrapNative &&
+            !isLastSwap &&
+            maybeWethCallData?.deposit;
+        let swapCallData = swapExchanges.reduce((acc, _swapExchange, swapExchangeIndex) => {
+            return hexConcat([
+                acc,
+                this.buildSingleSwapExchangeCallData(singleRoutes, routeIndex, swapIndex, swapExchangeIndex, wrapToSwapExchangeMap, !wrapToSwapMap[swapIndex - 1], wrapToSwapMap[swapIndex - 1], unwrapToSwapMap, srcToken, destToken, maybeWethCallData, swap.swapExchanges.length > 1, isMultiSwap || isMegaSwap),
+            ]);
+        }, '0x');
+        if (needToAppendWrapCallData) {
+            wrapToSwapMap[swapIndex] = true;
+        }
+        if (!isMultiSwap && !isMegaSwap) {
+            return needToAppendWrapCallData
+                ? this.appendWrapEthCallData(swapCallData, maybeWethCallData)
+                : swapCallData;
+        }
+        if (applyVerticalBranching) {
+            const vertBranchingCallData = this.buildVerticalBranchingCallData(singleRoutes, swap, swapCallData, this.buildVerticalBranchingFlag(singleRoutes, swap, routeIndex, swapIndex, destToken));
+            return needToAppendWrapCallData
+                ? this.appendWrapEthCallData(vertBranchingCallData, maybeWethCallData, true)
+                : vertBranchingCallData;
+        }
+        return needToAppendWrapCallData
+            ? this.appendWrapEthCallData(swapCallData, maybeWethCallData)
+            : swapCallData;
+    }
+    buildSingleRouteCallData(singleRoutes, route, routeIndex, flags, sender, srcToken, destToken, maybeWethCallData) {
+        const isMegaSwap = singleRoutes.length > 1;
+        const { swaps } = route;
+        const appendedWrapToSwapExchangeMap = {};
+        const addedWrapToSwapMap = {};
+        const unwrapToSwapMap = {};
+        const callData = swaps.reduce((swapAcc, swap, swapIndex) => hexConcat([
+            swapAcc,
+            this.buildSingleSwapCallData({
+                singleRoutes,
+                routeIndex,
+                swapIndex,
+                flags,
+                sender,
+                wrapToSwapExchangeMap: appendedWrapToSwapExchangeMap,
+                wrapToSwapMap: addedWrapToSwapMap,
+                unwrapToSwapMap,
+                maybeWethCallData,
+                swap,
+                index: 0,
+                srcToken,
+                destToken,
+                // TODO-multi to be removed after refactoring
+                routes: [],
+                exchangeParams: [],
+            }),
+        ]), '0x');
+        if (isMegaSwap) {
+            return this.wrapAsVerticalBranch(callData, route.percent, route.swaps[0], Object.values(addedWrapToSwapMap).includes(true) ||
+                Object.values(appendedWrapToSwapExchangeMap).includes(true), null);
+        }
+        return callData;
+    }
+    doesRouteNeedsRootWrapEth(singleRoutes, srcToken) {
+        if (!(0, utils_1.isETHAddress)(srcToken)) {
+            return false;
+        }
+        return singleRoutes.every(route => this.eachDexOnSwapNeedsWrapNative(route.swaps[0]));
+    }
+    doesRouteNeedsRootUnwrapEth(singleRoutes, destToken) {
+        if (!(0, utils_1.isETHAddress)(destToken)) {
+            return false;
+        }
+        const res = singleRoutes.some(route => {
+            const lastSwap = route.swaps[route.swaps.length - 1];
+            const anyDexOnSwapNeedsWrapNative = this.anyDexOnSwapNeedsWrapNative(lastSwap);
+            return anyDexOnSwapNeedsWrapNative;
+        });
+        return res;
+    }
+    getAddress() {
+        return this.dexHelper.config.data.executorsAddresses[types_1.Executors.TWO];
+    }
+    buildByteCode(priceRoute, routes, exchangeParams, sender, maybeWethCallData) {
+        // TODO-multi: temporary to handle all cases for single-route after refactoring
+        const _routes = routes.filter(r => r.type === 'single-route');
+        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(_routes, priceRoute.srcToken);
+        const routeNeedsRootUnwrapEth = this.doesRouteNeedsRootUnwrapEth(_routes, priceRoute.destToken);
+        const flags = this.buildFlags(priceRoute.bestRoute, _routes, exchangeParams, priceRoute.srcToken, maybeWethCallData);
+        let swapsCalldata = _routes.reduce((routeAcc, route, routeIndex) => hexConcat([
+            routeAcc,
+            this.buildSingleRouteCallData(_routes, 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 lastRoute = _routes[_routes.length - 1];
+            swapsCalldata = this.buildVerticalBranchingCallData(_routes, lastRoute.swaps[lastRoute.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);
+        }
+        // ETH wrap
+        if (needWrapEth && routeNeedsRootWrapEth) {
+            let depositCallData = this.buildWrapEthCallData(this.dexHelper.config.data.wrappedNativeTokenAddress, maybeWethCallData.deposit.calldata, types_1.Flag.SEND_ETH_EQUAL_TO_FROM_AMOUNT_DONT_CHECK_BALANCE_AFTER_SWAP);
+            if (!(isMegaSwap || isMultiSwap)) {
+                const swap = priceRoute.bestRoute[0].swaps[0];
+                const percent = exchangeParams.every(ep => ep.needWrapNative)
+                    ? 100
+                    : swap.swapExchanges
+                        .filter((_se, index) => {
+                        return exchangeParams[index].needWrapNative;
+                    })
+                        .reduce((acc, se) => {
+                        acc += se.percent;
+                        return acc;
+                    }, 0);
+                depositCallData = solidityPack(['bytes16', 'bytes16', 'bytes'], [
+                    hexZeroPad(hexlify(hexDataLength(depositCallData)), 16),
+                    hexZeroPad(hexlify(100 * percent), 16),
+                    depositCallData,
+                ]);
+            }
+            swapsCalldata = hexConcat([depositCallData, swapsCalldata]);
+        }
+        // ETH unwrap, only for multiswaps and mega swaps
+        if (needUnwrapEth &&
+            routeNeedsRootUnwrapEth &&
+            (isMultiSwap || isMegaSwap)) {
+            const withdrawCallData = this.buildUnwrapEthCallData(this.dexHelper.config.data.wrappedNativeTokenAddress, maybeWethCallData.withdraw.calldata);
+            swapsCalldata = hexConcat([swapsCalldata, withdrawCallData]);
+        }
+        // Special flag (send native) calldata, only for multiswaps and mega swaps
+        if (needSendNativeEth &&
+            routeNeedsRootUnwrapEth &&
+            (isMultiSwap || isMegaSwap)) {
+            const finalSpecialFlagCalldata = this.buildFinalSpecialFlagCalldata();
+            swapsCalldata = hexConcat([swapsCalldata, finalSpecialFlagCalldata]);
+        }
+        if (((needWrapEth || needUnwrapEth) && isMegaSwap) || isMultiSwap) {
+            swapsCalldata = this.wrapAsVerticalBranch(swapsCalldata, constants_1.SWAP_EXCHANGE_100_PERCENTAGE, _routes[0].swaps[0], false, null);
+        }
+        return solidityPack(['bytes32', 'bytes', 'bytes'], [
+            hexZeroPad(hexlify(32), 32), // calldata offset
+            hexZeroPad(hexlify(hexDataLength(swapsCalldata) + constants_1.BYTES_64_LENGTH), // calldata length  (64 bytes = bytes12(0) + msg.sender)
+            32),
+            swapsCalldata, // calldata
+        ]);
+    }
+}
+exports.Executor02BytecodeBuilderMultiRoute = Executor02BytecodeBuilderMultiRoute;
+//# sourceMappingURL=Executor02BytecodeBuilderMultiRoute.js.map