@paraswap/dex-lib 2.45.0 → 3.0.0

package/build/executor/Executor02BytecodeBuilder.js

@@ -0,0 +1,717 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Executor02BytecodeBuilder = 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 ts_essentials_1 = require("ts-essentials");
+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 Executor02BytecodeBuilder extends ExecutorBytecodeBuilder_1.ExecutorBytecodeBuilder {
+    constructor() {
+        super(...arguments);
+        this.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(priceRoute, exchangeParams, routeIndex, swapIndex, swapExchangeIndex, exchangeParamIndex, maybeWethCallData) {
+        const { srcToken, destToken } = priceRoute.bestRoute[routeIndex].swaps[swapIndex];
+        const isEthSrc = (0, utils_1.isETHAddress)(srcToken);
+        const isEthDest = (0, utils_1.isETHAddress)(destToken);
+        const exchangeParam = exchangeParams[exchangeParamIndex];
+        const { dexFuncHasRecipient, needWrapNative, specialDexFlag, specialDexSupportsInsertFromAmount, swappedAmountNotPresentInExchangeData, } = 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 =
+                types_1.Flag.SEND_ETH_EQUAL_TO_FROM_AMOUNT_CHECK_SRC_TOKEN_BALANCE_AFTER_SWAP; // 5
+        }
+        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
+        }
+        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(priceRoute, exchangeParams, routeIndex, swapIndex, swapExchangeIndex, exchangeParamIndex, maybeWethCallData) {
+        const route = priceRoute.bestRoute[routeIndex];
+        const swap = route.swaps[swapIndex];
+        const exchangeParam = exchangeParams[exchangeParamIndex];
+        const { srcToken, destToken } = swap;
+        const applyVerticalBranching = this.doesSwapNeedToApplyVerticalBranching(priceRoute, 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, } = 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 needCheckSrcTokenBalanceOf = (needUnwrap && !applyVerticalBranching && !isLastSwap) ||
+            (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 = 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
+        }
+        return {
+            dexFlag,
+            approveFlag,
+        };
+    }
+    buildDexCallData(priceRoute, routeIndex, swapIndex, swapExchangeIndex, exchangeParams, exchangeParamIndex, isLastSwap, flag, swapExchange) {
+        const swap = priceRoute.bestRoute[routeIndex].swaps[swapIndex];
+        const exchangeParam = exchangeParams[exchangeParamIndex];
+        let { exchangeData, specialDexFlag, targetExchange, needWrapNative } = exchangeParam;
+        const applyVerticalBranching = this.doesSwapNeedToApplyVerticalBranching(priceRoute, 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) {
+            const fromAmount = ethers_1.ethers.utils.defaultAbiCoder.encode(['uint256'], [swapExchange.srcAmount]);
+            const fromAmountIndex = exchangeData
+                .replace('0x', '')
+                .indexOf(fromAmount.replace('0x', ''));
+            (0, ts_essentials_1.assert)(fromAmountIndex !== -1, 'Encoding error: could not resolve position of fromAmount in exchangeData');
+            fromAmountPos = fromAmountIndex / 2;
+        }
+        return this.buildCallData(targetExchange, exchangeData, fromAmountPos, destTokenPos, specialDexFlag || types_1.SpecialDex.DEFAULT, flag);
+    }
+    addMultiSwapMetadata(priceRoute, exchangeParams, callData, percentage, swap, exchangeParamIndex, wrapWasAddedInSwapExchange, addedUnwrapForDexWithNoNeedWrapNative = false) {
+        let srcTokenAddress = swap.srcToken;
+        let doesAnyDexOnSwapNeedsWrapNative;
+        if (exchangeParamIndex > -1) {
+            doesAnyDexOnSwapNeedsWrapNative =
+                (0, utils_1.isETHAddress)(srcTokenAddress) &&
+                    (exchangeParams[exchangeParamIndex].needWrapNative ||
+                        (!exchangeParams[exchangeParamIndex].needWrapNative &&
+                            addedUnwrapForDexWithNoNeedWrapNative));
+        }
+        else {
+            doesAnyDexOnSwapNeedsWrapNative =
+                (0, utils_1.isETHAddress)(srcTokenAddress) &&
+                    this.anyDexOnSwapNeedsWrapNative(priceRoute, swap, exchangeParams);
+        }
+        if (doesAnyDexOnSwapNeedsWrapNative &&
+            (0, utils_1.isETHAddress)(srcTokenAddress) &&
+            !wrapWasAddedInSwapExchange) {
+            srcTokenAddress =
+                exchangeParamIndex > -1
+                    ? this.getWETHAddress(exchangeParams[exchangeParamIndex])
+                    : 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),
+            srcTokenPos,
+            hexZeroPad(hexlify(Math.round(percentage * 100)), 8),
+            callData, // swap calldata
+        ]);
+    }
+    packVerticalBranchingData(swapCallData) {
+        return solidityPack(['bytes28', 'bytes4', 'bytes32', 'bytes32', 'bytes'], [
+            constants_1.ZEROS_28_BYTES,
+            constants_1.ZEROS_4_BYTES,
+            hexZeroPad(hexlify(32), 32),
+            hexZeroPad(hexlify(hexDataLength(swapCallData)), 32),
+            swapCallData, // calldata
+        ]);
+    }
+    packVerticalBranchingCallData(verticalBranchingData, fromAmountPos, destTokenPos, flag) {
+        return solidityPack([
+            'bytes20',
+            'bytes4',
+            'bytes2',
+            'bytes2',
+            'bytes1',
+            'bytes1',
+            'bytes2',
+            'bytes',
+        ], [
+            constants_1.ZEROS_20_BYTES,
+            hexZeroPad(hexlify(hexDataLength(verticalBranchingData)), 4),
+            hexZeroPad(hexlify(fromAmountPos), 2),
+            hexZeroPad(hexlify(destTokenPos), 2),
+            hexZeroPad(hexlify(0), 1),
+            hexZeroPad(hexlify(types_1.SpecialDex.EXECUTE_VERTICAL_BRANCHING), 1),
+            hexZeroPad(hexlify(flag), 2),
+            verticalBranchingData, // dexes calldata
+        ]);
+    }
+    buildVerticalBranchingCallData(priceRoute, routeIndex, exchangeParams, swap, swapCallData, flag) {
+        const data = this.packVerticalBranchingData(swapCallData);
+        const destTokenAddrLowered = swap.destToken.toLowerCase();
+        const isEthDest = (0, utils_1.isETHAddress)(destTokenAddrLowered);
+        let anyDexOnSwapNeedsWrapNative = false;
+        let anyDexOnSwapDoesntNeedWrapNative = false;
+        let destTokenPos;
+        if (isEthDest) {
+            anyDexOnSwapNeedsWrapNative = this.anyDexOnSwapNeedsWrapNative(priceRoute, swap, exchangeParams);
+            anyDexOnSwapDoesntNeedWrapNative = this.anyDexOnSwapDoesntNeedWrapNative(priceRoute, swap, exchangeParams);
+        }
+        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(priceRoute, routeIndex, swapIndex, swapExchangeIndex, exchangeParams, flags, addedWrapToSwapExchangeMap, allowToAddWrap = true, prevBranchWasWrapped = false, maybeWethCallData, addMultiSwapMetadata, applyVerticalBranching) {
+        const isSimpleSwap = priceRoute.bestRoute.length === 1 &&
+            priceRoute.bestRoute[0].swaps.length === 1;
+        let swapExchangeCallData = '';
+        const swap = priceRoute.bestRoute[routeIndex].swaps[swapIndex];
+        const swapExchange = swap.swapExchanges[swapExchangeIndex];
+        let exchangeParamIndex = 0;
+        let tempExchangeParamIndex = 0;
+        priceRoute.bestRoute.map(route => route.swaps.map(curSwap => {
+            curSwap.swapExchanges.map(async (se) => {
+                if (Object.is(se, swapExchange)) {
+                    exchangeParamIndex = tempExchangeParamIndex;
+                }
+                tempExchangeParamIndex++;
+            });
+        }));
+        const curExchangeParam = exchangeParams[exchangeParamIndex];
+        const dexCallData = this.buildDexCallData(priceRoute, routeIndex, swapIndex, swapExchangeIndex, exchangeParams, exchangeParamIndex, false, flags.dexes[exchangeParamIndex], swapExchange);
+        swapExchangeCallData = hexConcat([dexCallData]);
+        const isLastSwap = swapIndex === priceRoute.bestRoute[routeIndex].swaps.length - 1;
+        const isLast = exchangeParamIndex === exchangeParams.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.approveData) {
+            const approveCallData = this.buildApproveCallData(curExchangeParam.approveData.target, curExchangeParam.approveData.token, flags.approves[exchangeParamIndex]);
+            swapExchangeCallData = hexConcat([approveCallData, swapExchangeCallData]);
+        }
+        if (curExchangeParam.needWrapNative) {
+            if ((0, utils_1.isETHAddress)(swap.srcToken)) {
+                let approveWethCalldata = '0x';
+                if (curExchangeParam.approveData &&
+                    !curExchangeParam.transferSrcTokenBeforeSwap) {
+                    approveWethCalldata = this.buildApproveCallData(curExchangeParam.approveData.target, curExchangeParam.approveData.token, flags.approves[exchangeParamIndex]);
+                }
+                const isNotFirstSwap = swapIndex !== 0;
+                let skipWrap = false;
+                if (isNotFirstSwap) {
+                    const prevSwap = priceRoute.bestRoute[routeIndex].swaps[swapIndex - 1];
+                    const anyDexOnSwapDoesntNeedWrapNative = this.anyDexOnSwapDoesntNeedWrapNative(priceRoute, prevSwap, exchangeParams);
+                    skipWrap = !anyDexOnSwapDoesntNeedWrapNative;
+                }
+                let depositCallData = '0x';
+                if (maybeWethCallData &&
+                    maybeWethCallData.deposit &&
+                    !this.doesRouteNeedsRootWrapEth(priceRoute, exchangeParams) &&
+                    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,
+                ]);
+            }
+            if (maybeWethCallData &&
+                maybeWethCallData.withdraw &&
+                ((!applyVerticalBranching && (0, utils_1.isETHAddress)(swap.destToken)) ||
+                    (applyVerticalBranching &&
+                        (0, utils_1.isETHAddress)(swap.destToken) &&
+                        this.anyDexOnSwapDoesntNeedWrapNative(priceRoute, swap, exchangeParams)))) {
+                let withdrawCallData = '0x';
+                const customWethAddress = curExchangeParam.wethAddress;
+                const isLastSimpleWithUnwrap = isSimpleSwap &&
+                    // check if current exchange is the last with needWrapNative
+                    exchangeParams.reduceRight((acc, exchangeParam, index) => exchangeParam.needWrapNative === true && acc === -1 ? index : acc, -1) === exchangeParamIndex;
+                if (customWethAddress ||
+                    isLastSimpleWithUnwrap // unwrap after last dex call with unwrap for simple swap case
+                ) {
+                    withdrawCallData = this.buildUnwrapEthCallData(this.getWETHAddress(curExchangeParam), maybeWethCallData.withdraw.calldata);
+                }
+                swapExchangeCallData = hexConcat([
+                    swapExchangeCallData,
+                    withdrawCallData,
+                ]);
+                if (isLastSimpleWithUnwrap || customWethAddress) {
+                    const finalSpecialFlagCalldata = this.buildFinalSpecialFlagCalldata();
+                    swapExchangeCallData = hexConcat([
+                        swapExchangeCallData,
+                        finalSpecialFlagCalldata,
+                    ]);
+                }
+            }
+        }
+        let addedUnwrapForDexWithNoNeedWrapNative = false;
+        if ((0, utils_1.isETHAddress)(swap.srcToken) &&
+            maybeWethCallData &&
+            maybeWethCallData.withdraw &&
+            !curExchangeParam.needWrapNative) {
+            const prevSwap = priceRoute.bestRoute[routeIndex].swaps[swapIndex - 1];
+            let eachDexOnPrevSwapReturnsWeth = false;
+            if (prevSwap && !prevBranchWasWrapped) {
+                eachDexOnPrevSwapReturnsWeth = this.eachDexOnSwapNeedsWrapNative(priceRoute, prevSwap, exchangeParams);
+            }
+            if (prevBranchWasWrapped || eachDexOnPrevSwapReturnsWeth) {
+                const withdrawCallData = this.buildUnwrapEthCallData(this.getWETHAddress(curExchangeParam), maybeWethCallData.withdraw.calldata);
+                swapExchangeCallData = hexConcat([
+                    withdrawCallData,
+                    swapExchangeCallData,
+                ]);
+                addedUnwrapForDexWithNoNeedWrapNative = true;
+            }
+        }
+        if (isLastSwap &&
+            !exchangeParams[exchangeParamIndex].dexFuncHasRecipient &&
+            !(0, utils_1.isETHAddress)(swap.destToken) &&
+            priceRoute.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 (!exchangeParams[exchangeParamIndex].dexFuncHasRecipient &&
+            (0, utils_1.isETHAddress)(swap.destToken) &&
+            isLast) {
+            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);
+        }
+        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(priceRoute, swap, exchangeParams) {
+        return swap.swapExchanges.every(curSe => {
+            let index = 0;
+            let swapExchangeIndex = 0;
+            priceRoute.bestRoute.map(route => {
+                route.swaps.map(curSwap => curSwap.swapExchanges.map(async (se) => {
+                    if (Object.is(se, curSe)) {
+                        index = swapExchangeIndex;
+                    }
+                    swapExchangeIndex++;
+                }));
+            });
+            const curExchangeParam = exchangeParams[index];
+            return curExchangeParam.needWrapNative && !curExchangeParam.wethAddress;
+        });
+    }
+    anyDexOnSwapNeedsWrapNative(priceRoute, swap, exchangeParams) {
+        const res = swap.swapExchanges.map(curSe => {
+            let index = 0;
+            let swapExchangeIndex = 0;
+            priceRoute.bestRoute.map(route => {
+                route.swaps.map(curSwap => {
+                    return curSwap.swapExchanges.map(async (se) => {
+                        if (Object.is(se, curSe)) {
+                            index = swapExchangeIndex;
+                        }
+                        swapExchangeIndex++;
+                    });
+                });
+            });
+            const curExchangeParam = exchangeParams[index];
+            return curExchangeParam.needWrapNative && !curExchangeParam.wethAddress;
+        });
+        return res.includes(true);
+    }
+    getSwapExchangesWhichNeedWrapNative(priceRoute, swap, exchangeParams) {
+        return swap.swapExchanges.filter(curSe => {
+            let index = 0;
+            let swapExchangeIndex = 0;
+            priceRoute.bestRoute.map(route => {
+                route.swaps.map(curSwap => {
+                    return curSwap.swapExchanges.map(async (se) => {
+                        if (Object.is(se, curSe)) {
+                            index = swapExchangeIndex;
+                        }
+                        swapExchangeIndex++;
+                    });
+                });
+            });
+            const curExchangeParam = exchangeParams[index];
+            return curExchangeParam.needWrapNative && !curExchangeParam.wethAddress;
+        });
+    }
+    getSwapExchangesWhichDontNeedWrapNative(priceRoute, swap, exchangeParams) {
+        return swap.swapExchanges.filter(curSe => {
+            let index = 0;
+            let swapExchangeIndex = 0;
+            priceRoute.bestRoute.map(route => {
+                route.swaps.map(curSwap => {
+                    return curSwap.swapExchanges.map(async (se) => {
+                        if (Object.is(se, curSe)) {
+                            index = swapExchangeIndex;
+                        }
+                        swapExchangeIndex++;
+                    });
+                });
+            });
+            const curExchangeParam = exchangeParams[index];
+            return !curExchangeParam.needWrapNative || curExchangeParam.wethAddress;
+        });
+    }
+    anyDexOnSwapDoesntNeedWrapNative(priceRoute, swap, exchangeParams) {
+        return swap.swapExchanges
+            .map(curSe => {
+            let index = 0;
+            let swapExchangeIndex = 0;
+            priceRoute.bestRoute.map(route => {
+                route.swaps.map(curSwap => curSwap.swapExchanges.map(async (se) => {
+                    if (Object.is(se, curSe)) {
+                        index = swapExchangeIndex;
+                    }
+                    swapExchangeIndex++;
+                }));
+            });
+            const curExchangeParam = exchangeParams[index];
+            return !curExchangeParam.needWrapNative;
+        })
+            .includes(true);
+    }
+    doesSwapNeedToApplyVerticalBranching(priceRoute, routeIndex, swap) {
+        const isMegaSwap = priceRoute.bestRoute.length > 1;
+        const isMultiSwap = !isMegaSwap && priceRoute.bestRoute[routeIndex].swaps.length > 1;
+        return (isMultiSwap || isMegaSwap) && swap.swapExchanges.length > 1;
+    }
+    buildVerticalBranchingFlag(priceRoute, swap, exchangeParams, routeIndex, swapIndex) {
+        let flag = types_1.Flag.INSERT_FROM_AMOUNT_CHECK_SRC_TOKEN_BALANCE_AFTER_SWAP; // 11
+        const isLastSwap = swapIndex === priceRoute.bestRoute[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 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) => {
+                    if (Object.is(se, curSe)) {
+                        index = swapExchangeIndex;
+                    }
+                    swapExchangeIndex++;
+                }));
+                const curExchangeParam = exchangeParams[index];
+                return (curExchangeParam.needWrapNative && !curExchangeParam.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(priceRoute, swap, exchangeParams)) {
+                    flag = types_1.Flag.INSERT_FROM_AMOUNT_CHECK_ETH_BALANCE_AFTER_SWAP; // 7
+                }
+            }
+        }
+        return flag;
+    }
+    buildSingleSwapCallData(priceRoute, exchangeParams, routeIndex, swapIndex, flags, sender, appendedWrapToSwapMap, addedWrapToSwapExchangeMap, maybeWethCallData, swap) {
+        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 { swapExchanges } = swap;
+        const applyVerticalBranching = this.doesSwapNeedToApplyVerticalBranching(priceRoute, routeIndex, swap);
+        const anyDexOnSwapDoesntNeedWrapNative = this.anyDexOnSwapDoesntNeedWrapNative(priceRoute, swap, exchangeParams);
+        const needToAppendWrapCallData = (0, utils_1.isETHAddress)(swap.destToken) &&
+            anyDexOnSwapDoesntNeedWrapNative &&
+            !isLastSwap &&
+            maybeWethCallData?.deposit;
+        let swapCallData = swapExchanges.reduce((acc, swapExchange, swapExchangeIndex) => {
+            return hexConcat([
+                acc,
+                this.buildSingleSwapExchangeCallData(priceRoute, routeIndex, swapIndex, swapExchangeIndex, exchangeParams, flags, addedWrapToSwapExchangeMap, !appendedWrapToSwapMap[swapIndex - 1], appendedWrapToSwapMap[swapIndex - 1], maybeWethCallData, swap.swapExchanges.length > 1, applyVerticalBranching),
+            ]);
+        }, '0x');
+        if (needToAppendWrapCallData) {
+            appendedWrapToSwapMap[swapIndex] = true;
+        }
+        if (!isMultiSwap && !isMegaSwap) {
+            return needToAppendWrapCallData
+                ? this.appendWrapEthCallData(swapCallData, maybeWethCallData)
+                : swapCallData;
+        }
+        if (applyVerticalBranching) {
+            const vertBranchingCallData = this.buildVerticalBranchingCallData(priceRoute, routeIndex, exchangeParams, swap, swapCallData, this.buildVerticalBranchingFlag(priceRoute, swap, exchangeParams, routeIndex, swapIndex));
+            return needToAppendWrapCallData
+                ? this.appendWrapEthCallData(vertBranchingCallData, maybeWethCallData, true)
+                : vertBranchingCallData;
+        }
+        return needToAppendWrapCallData
+            ? this.appendWrapEthCallData(swapCallData, maybeWethCallData)
+            : swapCallData;
+    }
+    buildSingleRouteCallData(priceRoute, exchangeParams, route, routeIndex, flags, sender, maybeWethCallData) {
+        const isMegaSwap = priceRoute.bestRoute.length > 1;
+        const { swaps } = route;
+        const appendedWrapToSwapExchangeMap = {};
+        const addedWrapToSwapMap = {};
+        const callData = swaps.reduce((swapAcc, swap, swapIndex) => hexConcat([
+            swapAcc,
+            this.buildSingleSwapCallData(priceRoute, exchangeParams, routeIndex, swapIndex, flags, sender, appendedWrapToSwapExchangeMap, addedWrapToSwapMap, maybeWethCallData, swap),
+        ]), '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));
+        }
+        return callData;
+    }
+    doesRouteNeedsRootWrapEth(priceRoute, exchangeParams) {
+        if (!(0, utils_1.isETHAddress)(priceRoute.srcToken)) {
+            return false;
+        }
+        const res = priceRoute.bestRoute.every((route, routeIndex) => {
+            const firstSwap = route.swaps[0];
+            const eachDexOnSwapNeedsWrapNative = this.eachDexOnSwapNeedsWrapNative(priceRoute, firstSwap, exchangeParams);
+            return eachDexOnSwapNeedsWrapNative;
+        });
+        return res;
+    }
+    doesRouteNeedsRootUnwrapEth(priceRoute, exchangeParams) {
+        if (!(0, utils_1.isETHAddress)(priceRoute.destToken)) {
+            return false;
+        }
+        const res = priceRoute.bestRoute.every((route, routeIndex) => {
+            const lastSwap = route.swaps[route.swaps.length - 1];
+            const eachDexOnSwapNeedsWrapNative = this.anyDexOnSwapNeedsWrapNative(priceRoute, lastSwap, exchangeParams);
+            return eachDexOnSwapNeedsWrapNative;
+        });
+        return res;
+    }
+    getAddress() {
+        return this.dexHelper.config.data.executorsAddresses[types_1.Executors.TWO];
+    }
+    buildByteCode(priceRoute, 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);
+        let swapsCalldata = priceRoute.bestRoute.reduce((routeAcc, route, routeIndex) => hexConcat([
+            routeAcc,
+            this.buildSingleRouteCallData(priceRoute, exchangeParams, route, routeIndex, flags, sender, maybeWethCallData),
+        ]), '0x');
+        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
+                ? 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);
+        }
+        // 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.addMultiSwapMetadata(priceRoute, 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),
+            hexZeroPad(hexlify(hexDataLength(swapsCalldata) + constants_1.BYTES_64_LENGTH), // calldata length  (64 bytes = bytes12(0) + msg.sender)
+            32),
+            swapsCalldata, // calldata
+        ]);
+    }
+}
+exports.Executor02BytecodeBuilder = Executor02BytecodeBuilder;
+//# sourceMappingURL=Executor02BytecodeBuilder.js.map