@paraswap/dex-lib 2.45.0 → 3.0.0

package/src/executor/Executor01BytecodeBuilder.ts

@@ -0,0 +1,433 @@
+import { ethers } from 'ethers';
+import { DexExchangeBuildParam } from '../types';
+import { OptimalRate } from '@paraswap/core';
+import { isETHAddress } from '../utils';
+import { DepositWithdrawReturn } from '../dex/weth/types';
+import { Executors, Flag, SpecialDex } from './types';
+import { BYTES_64_LENGTH } from './constants';
+import { ExecutorBytecodeBuilder } from './ExecutorBytecodeBuilder';
+import { assert } from 'ts-essentials';
+
+const {
+  utils: { hexlify, hexDataLength, hexConcat, hexZeroPad, solidityPack },
+} = ethers;
+
+/**
+ * Class to build bytecode for Executor01 - simpleSwap (SINGLE_STEP) with 100% on a path and multiSwap with 100% amounts on each path (HORIZONTAL_SEQUENCE)
+ */
+export class Executor01BytecodeBuilder extends ExecutorBytecodeBuilder {
+  type = Executors.ONE;
+  /**
+   * Executor01 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
+   */
+  protected buildSimpleSwapFlags(
+    priceRoute: OptimalRate,
+    exchangeParams: DexExchangeBuildParam[],
+    routeIndex: number,
+    swapIndex: number,
+    swapExchangeIndex: number,
+    exchangeParamIndex: number,
+    maybeWethCallData?: DepositWithdrawReturn,
+  ): { dexFlag: Flag; approveFlag: Flag } {
+    const { srcToken, destToken } =
+      priceRoute.bestRoute[routeIndex].swaps[swapIndex];
+    const isEthSrc = isETHAddress(srcToken);
+    const isEthDest = 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 !== SpecialDex.DEFAULT;
+
+    const forcePreventInsertFromAmount =
+      swappedAmountNotPresentInExchangeData ||
+      (isSpecialDex && !specialDexSupportsInsertFromAmount);
+
+    let dexFlag = forcePreventInsertFromAmount
+      ? Flag.DONT_INSERT_FROM_AMOUNT_DONT_CHECK_BALANCE_AFTER_SWAP
+      : Flag.INSERT_FROM_AMOUNT_DONT_CHECK_BALANCE_AFTER_SWAP; // 0 or 3
+    let approveFlag =
+      Flag.DONT_INSERT_FROM_AMOUNT_DONT_CHECK_BALANCE_AFTER_SWAP; // 0
+
+    if (isEthSrc && !needWrap) {
+      dexFlag =
+        Flag.SEND_ETH_EQUAL_TO_FROM_AMOUNT_CHECK_SRC_TOKEN_BALANCE_AFTER_SWAP; // 5
+    } else if (isEthDest && !needUnwrap) {
+      dexFlag = forcePreventInsertFromAmount
+        ? Flag.DONT_INSERT_FROM_AMOUNT_CHECK_ETH_BALANCE_AFTER_SWAP
+        : Flag.INSERT_FROM_AMOUNT_CHECK_ETH_BALANCE_AFTER_SWAP; // 4 or 7
+    } else if (!dexFuncHasRecipient || (isEthDest && needUnwrap)) {
+      dexFlag = forcePreventInsertFromAmount
+        ? Flag.DONT_INSERT_FROM_AMOUNT_CHECK_SRC_TOKEN_BALANCE_AFTER_SWAP
+        : Flag.INSERT_FROM_AMOUNT_CHECK_SRC_TOKEN_BALANCE_AFTER_SWAP; // 8 or 11
+    }
+
+    return {
+      dexFlag,
+      approveFlag,
+    };
+  }
+
+  /**
+   * Executor01 Flags:
+   * switch (flag % 4):
+   * case 0: don't insert 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
+   */
+  // Executor01 doesn't support mega swap routes, flags are built for multi swap routes only here
+  protected buildMultiMegaSwapFlags(
+    priceRoute: OptimalRate,
+    exchangeParams: DexExchangeBuildParam[],
+    routeIndex: number,
+    swapIndex: number,
+    swapExchangeIndex: number,
+    exchangeParamIndex: number,
+    maybeWethCallData?: DepositWithdrawReturn,
+  ): { dexFlag: Flag; approveFlag: Flag } {
+    // same as for Executor02 multi flags, except forceBalanceOfCheck
+    const swap = priceRoute.bestRoute[routeIndex].swaps[swapIndex];
+    const { srcToken, destToken } = swap;
+    const exchangeParam = exchangeParams[exchangeParamIndex];
+    const {
+      dexFuncHasRecipient,
+      needWrapNative,
+      specialDexFlag,
+      specialDexSupportsInsertFromAmount,
+      swappedAmountNotPresentInExchangeData,
+      sendEthButSupportsInsertFromAmount,
+    } = exchangeParam;
+
+    const isLastSwap =
+      swapIndex === priceRoute.bestRoute[routeIndex].swaps.length - 1;
+    const isEthSrc = isETHAddress(srcToken);
+    const isEthDest = isETHAddress(destToken);
+
+    const isSpecialDex =
+      specialDexFlag !== undefined && specialDexFlag !== SpecialDex.DEFAULT;
+
+    const forcePreventInsertFromAmount =
+      swappedAmountNotPresentInExchangeData ||
+      (isSpecialDex && !specialDexSupportsInsertFromAmount);
+
+    const needUnwrap =
+      needWrapNative && isEthDest && maybeWethCallData?.withdraw;
+
+    const forceBalanceOfCheck = isLastSwap
+      ? !dexFuncHasRecipient || needUnwrap
+      : true;
+
+    const needSendEth = isEthSrc && !needWrapNative;
+    const needCheckEthBalance = isEthDest && !needWrapNative;
+
+    const needCheckSrcTokenBalanceOf = needUnwrap && !isLastSwap;
+
+    let dexFlag: Flag;
+    let approveFlag =
+      Flag.DONT_INSERT_FROM_AMOUNT_DONT_CHECK_BALANCE_AFTER_SWAP; // 0
+
+    if (needSendEth) {
+      const preventInsertForSendEth =
+        forcePreventInsertFromAmount || !sendEthButSupportsInsertFromAmount;
+      dexFlag = forceBalanceOfCheck
+        ? preventInsertForSendEth
+          ? Flag.SEND_ETH_EQUAL_TO_FROM_AMOUNT_CHECK_SRC_TOKEN_BALANCE_AFTER_SWAP // 5
+          : Flag.SEND_ETH_EQUAL_TO_FROM_AMOUNT_PLUS_INSERT_FROM_AMOUNT_CHECK_SRC_TOKEN_BALANCE_AFTER_SWAP // 14
+        : dexFuncHasRecipient
+        ? preventInsertForSendEth
+          ? Flag.SEND_ETH_EQUAL_TO_FROM_AMOUNT_DONT_CHECK_BALANCE_AFTER_SWAP // 9
+          : Flag.SEND_ETH_EQUAL_TO_FROM_AMOUNT_PLUS_INSERT_FROM_AMOUNT_DONT_CHECK_BALANCE_AFTER_SWAP // 18
+        : preventInsertForSendEth
+        ? Flag.SEND_ETH_EQUAL_TO_FROM_AMOUNT_CHECK_SRC_TOKEN_BALANCE_AFTER_SWAP // 5
+        : 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
+            ? Flag.DONT_INSERT_FROM_AMOUNT_CHECK_ETH_BALANCE_AFTER_SWAP // 4
+            : Flag.INSERT_FROM_AMOUNT_CHECK_ETH_BALANCE_AFTER_SWAP // 7
+          : forcePreventInsertFromAmount && dexFuncHasRecipient
+          ? Flag.DONT_INSERT_FROM_AMOUNT_DONT_CHECK_BALANCE_AFTER_SWAP // 0
+          : Flag.INSERT_FROM_AMOUNT_DONT_CHECK_BALANCE_AFTER_SWAP; // 3
+    } else {
+      dexFlag =
+        needCheckSrcTokenBalanceOf || forceBalanceOfCheck
+          ? forcePreventInsertFromAmount
+            ? Flag.DONT_INSERT_FROM_AMOUNT_CHECK_SRC_TOKEN_BALANCE_AFTER_SWAP // 8
+            : Flag.INSERT_FROM_AMOUNT_CHECK_SRC_TOKEN_BALANCE_AFTER_SWAP // 11
+          : forcePreventInsertFromAmount
+          ? Flag.DONT_INSERT_FROM_AMOUNT_DONT_CHECK_BALANCE_AFTER_SWAP // 0
+          : Flag.INSERT_FROM_AMOUNT_DONT_CHECK_BALANCE_AFTER_SWAP; // 3
+    }
+
+    return {
+      dexFlag,
+      approveFlag,
+    };
+  }
+
+  protected buildSingleSwapCallData(
+    priceRoute: OptimalRate,
+    exchangeParams: DexExchangeBuildParam[],
+    index: number,
+    flags: { approves: Flag[]; dexes: Flag[]; wrap: Flag },
+    sender: string,
+    maybeWethCallData?: DepositWithdrawReturn,
+  ): string {
+    let swapCallData = '';
+    const swap = priceRoute.bestRoute[0].swaps[index];
+    const curExchangeParam = exchangeParams[index];
+
+    const dexCallData = this.buildDexCallData(
+      priceRoute,
+      0,
+      index,
+      0,
+      exchangeParams,
+      index,
+      index === priceRoute.bestRoute[0].swaps.length - 1,
+      flags.dexes[index],
+    );
+
+    swapCallData = hexConcat([dexCallData]);
+
+    if (curExchangeParam.transferSrcTokenBeforeSwap) {
+      const transferCallData = this.buildTransferCallData(
+        this.erc20Interface.encodeFunctionData('transfer', [
+          curExchangeParam.transferSrcTokenBeforeSwap,
+          swap.swapExchanges[0].srcAmount,
+        ]),
+        isETHAddress(swap.srcToken)
+          ? this.getWETHAddress(curExchangeParam)
+          : swap.srcToken.toLowerCase(),
+      );
+
+      swapCallData = hexConcat([transferCallData, swapCallData]);
+    }
+
+    if (
+      flags.dexes[index] % 4 !== 1 && // not sendEth
+      (!isETHAddress(swap.srcToken) ||
+        (isETHAddress(swap.srcToken) && index !== 0)) &&
+      !curExchangeParam.transferSrcTokenBeforeSwap &&
+      curExchangeParam.approveData
+    ) {
+      const approveCallData = this.buildApproveCallData(
+        curExchangeParam.approveData.target,
+        curExchangeParam.approveData.token,
+        flags.approves[index],
+      );
+
+      swapCallData = hexConcat([approveCallData, swapCallData]);
+    }
+
+    if (curExchangeParam.needWrapNative && maybeWethCallData) {
+      if (maybeWethCallData.deposit && isETHAddress(swap.srcToken)) {
+        const prevExchangeParam = exchangeParams[index - 1];
+
+        if (
+          !prevExchangeParam ||
+          (prevExchangeParam && !prevExchangeParam.needWrapNative)
+        ) {
+          let approveWethCalldata = '0x';
+          if (
+            curExchangeParam.approveData &&
+            !curExchangeParam.transferSrcTokenBeforeSwap
+          ) {
+            approveWethCalldata = this.buildApproveCallData(
+              curExchangeParam.approveData.target,
+              curExchangeParam.approveData.token,
+              flags.approves[index],
+            );
+          }
+
+          const depositCallData = this.buildWrapEthCallData(
+            this.getWETHAddress(curExchangeParam),
+            maybeWethCallData.deposit.calldata,
+            Flag.SEND_ETH_EQUAL_TO_FROM_AMOUNT_DONT_CHECK_BALANCE_AFTER_SWAP,
+          );
+
+          swapCallData = hexConcat([
+            approveWethCalldata,
+            depositCallData,
+            swapCallData,
+          ]);
+        }
+      }
+
+      if (maybeWethCallData.withdraw && isETHAddress(swap.destToken)) {
+        const nextExchangeParam = exchangeParams[index + 1];
+
+        if (
+          !nextExchangeParam ||
+          (nextExchangeParam && !nextExchangeParam.needWrapNative)
+        ) {
+          const withdrawCallData = this.buildUnwrapEthCallData(
+            this.getWETHAddress(curExchangeParam),
+            maybeWethCallData.withdraw.calldata,
+          );
+          swapCallData = hexConcat([swapCallData, withdrawCallData]);
+        }
+      }
+    }
+
+    return swapCallData;
+  }
+
+  protected buildDexCallData(
+    priceRoute: OptimalRate,
+    routeIndex: number,
+    swapIndex: number,
+    swapExchangeIndex: number,
+    exchangeParams: DexExchangeBuildParam[],
+    exchangeParamIndex: number,
+    isLastSwap: boolean,
+    flag: Flag,
+  ): string {
+    const dontCheckBalanceAfterSwap = flag % 3 === 0;
+    const checkDestTokenBalanceAfterSwap = flag % 3 === 2;
+    const insertFromAmount = flag % 4 === 3 || flag % 4 === 2;
+    const exchangeParam = exchangeParams[exchangeParamIndex];
+    const swap = priceRoute.bestRoute[routeIndex].swaps[swapIndex];
+    let { exchangeData, specialDexFlag } = exchangeParam;
+
+    let destTokenPos = 0;
+    if (checkDestTokenBalanceAfterSwap && !dontCheckBalanceAfterSwap) {
+      const destTokenAddr = isETHAddress(swap.destToken)
+        ? this.getWETHAddress(exchangeParam)
+        : swap.destToken.toLowerCase();
+
+      exchangeData = this.addTokenAddressToCallData(
+        exchangeData,
+        destTokenAddr,
+      );
+      const destTokenAddrIndex = exchangeData
+        .replace('0x', '')
+        .indexOf(destTokenAddr.replace('0x', ''));
+      destTokenPos = (destTokenAddrIndex - 24) / 2;
+    }
+
+    let fromAmountPos = 0;
+    if (insertFromAmount) {
+      const fromAmount = ethers.utils.defaultAbiCoder.encode(
+        ['uint256'],
+        [swap.swapExchanges[0].srcAmount],
+      );
+
+      const fromAmountIndex = exchangeData
+        .replace('0x', '')
+        .indexOf(fromAmount.replace('0x', ''));
+
+      assert(
+        fromAmountIndex !== -1,
+        'Encoding error: could not resolve position of fromAmount in exchangeData',
+      );
+
+      fromAmountPos = fromAmountIndex / 2;
+    }
+
+    return this.buildCallData(
+      exchangeParam.targetExchange,
+      exchangeData,
+      fromAmountPos,
+      destTokenPos,
+      specialDexFlag || SpecialDex.DEFAULT,
+      flag,
+    );
+  }
+
+  public getAddress(): string {
+    return this.dexHelper.config.data.executorsAddresses![Executors.ONE];
+  }
+
+  public buildByteCode(
+    priceRoute: OptimalRate,
+    exchangeParams: DexExchangeBuildParam[],
+    sender: string,
+    maybeWethCallData?: DepositWithdrawReturn,
+  ): string {
+    const flags = this.buildFlags(
+      priceRoute,
+      exchangeParams,
+      maybeWethCallData,
+    );
+
+    let swapsCalldata = exchangeParams.reduce<string>(
+      (acc, ep, index) =>
+        hexConcat([
+          acc,
+          this.buildSingleSwapCallData(
+            priceRoute,
+            exchangeParams,
+            index,
+            flags,
+            sender,
+            maybeWethCallData,
+          ),
+        ]),
+      '0x',
+    );
+
+    if (
+      !exchangeParams[exchangeParams.length - 1].dexFuncHasRecipient &&
+      !isETHAddress(priceRoute.destToken)
+    ) {
+      const transferCallData = this.buildTransferCallData(
+        this.erc20Interface.encodeFunctionData('transfer', [
+          this.dexHelper.config.data.augustusV6Address,
+          priceRoute.destAmount,
+        ]),
+        priceRoute.destToken,
+      );
+
+      swapsCalldata = hexConcat([swapsCalldata, transferCallData]);
+    }
+
+    if (
+      (maybeWethCallData?.withdraw && isETHAddress(priceRoute.destToken)) ||
+      (!exchangeParams[exchangeParams.length - 1].dexFuncHasRecipient &&
+        isETHAddress(priceRoute.destToken))
+    ) {
+      const finalSpecialFlagCalldata = this.buildFinalSpecialFlagCalldata();
+      swapsCalldata = hexConcat([swapsCalldata, finalSpecialFlagCalldata]);
+    }
+
+    return solidityPack(
+      ['bytes32', 'bytes', 'bytes'],
+      [
+        hexZeroPad(hexlify(32), 32), // calldata offset
+        hexZeroPad(
+          hexlify(hexDataLength(swapsCalldata) + BYTES_64_LENGTH), // calldata length  (64 bytes = bytes12(0) + msg.sender)
+          32,
+        ),
+        swapsCalldata, // // calldata
+      ],
+    );
+  }
+}