@paraswap/dex-lib 3.0.6 → 3.2.5-return-amount-pos.5

package/src/executor/Executor02BytecodeBuilder.ts

@@ -9,7 +9,11 @@ import { DexExchangeBuildParam, DexExchangeParam } from '../types';
 import { Executors, Flag, SpecialDex } from './types';
 import { isETHAddress } from '../utils';
 import { DepositWithdrawReturn } from '../dex/weth/types';
-import { ExecutorBytecodeBuilder } from './ExecutorBytecodeBuilder';
+import {
+  DexCallDataParams,
+  ExecutorBytecodeBuilder,
+  SingleSwapCallDataParams,
+} from './ExecutorBytecodeBuilder';
 import {
   BYTES_64_LENGTH,
   NOT_EXISTING_EXCHANGE_PARAM_INDEX,
@@ -18,6 +22,7 @@ import {
   ZEROS_20_BYTES,
   ZEROS_28_BYTES,
   ZEROS_4_BYTES,
+  DEFAULT_RETURN_AMOUNT_POS,
 } from './constants';
 import { assert } from 'ts-essentials';
 
@@ -25,10 +30,25 @@ const {
   utils: { hexlify, hexDataLength, hexConcat, hexZeroPad, solidityPack },
 } = ethers;
 
+export type Executor02SingleSwapCallDataParams = {
+  routeIndex: number;
+  swapIndex: number;
+  wrapToSwapMap: { [key: number]: boolean };
+  wrapToSwapExchangeMap: { [key: string]: boolean };
+  swap: OptimalSwap;
+};
+
+export type Executor02DexCallDataParams = {
+  swapExchange: OptimalSwapExchange<any>;
+};
+
 /**
  * Class to build bytecode for Executor02 - simpleSwap with N DEXs (VERTICAL_BRANCH), multiSwaps (VERTICAL_BRANCH_HORIZONTAL_SEQUENCE) and megaswaps (NESTED_VERTICAL_BRANCH_HORIZONTAL_SEQUENCE)
  */
-export class Executor02BytecodeBuilder extends ExecutorBytecodeBuilder {
+export class Executor02BytecodeBuilder extends ExecutorBytecodeBuilder<
+  Executor02SingleSwapCallDataParams,
+  Executor02DexCallDataParams
+> {
   type = Executors.TWO;
   /**
    * Executor02 Flags:
@@ -64,6 +84,7 @@ export class Executor02BytecodeBuilder extends ExecutorBytecodeBuilder {
       specialDexFlag,
       specialDexSupportsInsertFromAmount,
       swappedAmountNotPresentInExchangeData,
+      preSwapUnwrapCalldata,
     } = exchangeParam;
 
     const needWrap = needWrapNative && isEthSrc && maybeWethCallData?.deposit;
@@ -95,6 +116,13 @@ export class Executor02BytecodeBuilder extends ExecutorBytecodeBuilder {
         : 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 =
+        Flag.SEND_ETH_EQUAL_TO_FROM_AMOUNT_CHECK_SRC_TOKEN_BALANCE_AFTER_SWAP;
+    }
+
     return {
       dexFlag,
       approveFlag,
@@ -147,6 +175,7 @@ export class Executor02BytecodeBuilder extends ExecutorBytecodeBuilder {
       swappedAmountNotPresentInExchangeData,
       wethAddress,
       sendEthButSupportsInsertFromAmount,
+      preSwapUnwrapCalldata,
     } = exchangeParam;
 
     const isEthSrc = isETHAddress(srcToken);
@@ -217,6 +246,13 @@ export class Executor02BytecodeBuilder extends ExecutorBytecodeBuilder {
           : 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 =
+        Flag.SEND_ETH_EQUAL_TO_FROM_AMOUNT_CHECK_SRC_TOKEN_BALANCE_AFTER_SWAP;
+    }
+
     return {
       dexFlag,
       approveFlag,
@@ -224,21 +260,27 @@ export class Executor02BytecodeBuilder extends ExecutorBytecodeBuilder {
   }
 
   protected buildDexCallData(
-    priceRoute: OptimalRate,
-    routeIndex: number,
-    swapIndex: number,
-    swapExchangeIndex: number,
-    exchangeParams: DexExchangeBuildParam[],
-    exchangeParamIndex: number,
-    isLastSwap: boolean,
-    flag: Flag,
-    swapExchange: OptimalSwapExchange<any>,
+    params: DexCallDataParams<Executor02DexCallDataParams>,
   ): string {
+    const {
+      priceRoute,
+      exchangeParamIndex,
+      swapExchange,
+      exchangeParams,
+      routeIndex,
+      swapIndex,
+      flag,
+    } = params;
+
     const swap = priceRoute.bestRoute[routeIndex].swaps[swapIndex];
     const exchangeParam = exchangeParams[exchangeParamIndex];
     let { exchangeData, specialDexFlag, targetExchange, needWrapNative } =
       exchangeParam;
 
+    const returnAmountPos =
+      exchangeParam.returnAmountPos !== undefined
+        ? exchangeParam.returnAmountPos
+        : DEFAULT_RETURN_AMOUNT_POS;
     const applyVerticalBranching = this.doesSwapNeedToApplyVerticalBranching(
       priceRoute,
       routeIndex,
@@ -306,6 +348,8 @@ export class Executor02BytecodeBuilder extends ExecutorBytecodeBuilder {
       destTokenPos,
       specialDexFlag || SpecialDex.DEFAULT,
       flag,
+      undefined,
+      returnAmountPos,
     );
   }
 
@@ -510,19 +554,27 @@ export class Executor02BytecodeBuilder extends ExecutorBytecodeBuilder {
 
     const curExchangeParam = exchangeParams[exchangeParamIndex];
 
-    const dexCallData = this.buildDexCallData(
+    const dexCallData = this.buildDexCallData({
       priceRoute,
       routeIndex,
       swapIndex,
       swapExchangeIndex,
       exchangeParams,
       exchangeParamIndex,
-      false,
-      flags.dexes[exchangeParamIndex],
+      isLastSwap: false,
+      flag: flags.dexes[exchangeParamIndex],
       swapExchange,
-    );
+    });
 
-    swapExchangeCallData = hexConcat([dexCallData]);
+    if (curExchangeParam.preSwapUnwrapCalldata) {
+      const withdrawCallData = this.buildUnwrapEthCallData(
+        this.getWETHAddress(curExchangeParam),
+        curExchangeParam.preSwapUnwrapCalldata,
+      );
+      swapExchangeCallData = hexConcat([withdrawCallData, dexCallData]);
+    } else {
+      swapExchangeCallData = hexConcat([dexCallData]);
+    }
 
     const isLastSwap =
       swapIndex === priceRoute.bestRoute[routeIndex].swaps.length - 1;
@@ -546,7 +598,7 @@ export class Executor02BytecodeBuilder extends ExecutorBytecodeBuilder {
     }
 
     if (
-      !isETHAddress(swap!.srcToken) &&
+      !isETHAddress(swap.srcToken) &&
       !curExchangeParam.transferSrcTokenBeforeSwap &&
       curExchangeParam.approveData
     ) {
@@ -560,7 +612,7 @@ export class Executor02BytecodeBuilder extends ExecutorBytecodeBuilder {
     }
 
     if (curExchangeParam.needWrapNative) {
-      if (isETHAddress(swap!.srcToken)) {
+      if (isETHAddress(swap.srcToken)) {
         let approveWethCalldata = '0x';
         if (
           curExchangeParam.approveData &&
@@ -963,7 +1015,7 @@ export class Executor02BytecodeBuilder extends ExecutorBytecodeBuilder {
         flag = Flag.INSERT_FROM_AMOUNT_DONT_CHECK_BALANCE_AFTER_SWAP; // 3
       }
     } else {
-      const isEthDest = isETHAddress(swap!.destToken);
+      const isEthDest = isETHAddress(swap.destToken);
 
       if (isEthDest) {
         if (
@@ -982,36 +1034,38 @@ export class Executor02BytecodeBuilder extends ExecutorBytecodeBuilder {
   }
 
   protected buildSingleSwapCallData(
-    priceRoute: OptimalRate,
-    exchangeParams: DexExchangeBuildParam[],
-    routeIndex: number,
-    swapIndex: number,
-    flags: { approves: Flag[]; dexes: Flag[]; wrap: Flag },
-    sender: string,
-    appendedWrapToSwapMap: { [key: number]: boolean },
-    addedWrapToSwapExchangeMap: { [key: string]: boolean },
-    maybeWethCallData?: DepositWithdrawReturn,
-    swap?: OptimalSwap,
+    params: SingleSwapCallDataParams<Executor02SingleSwapCallDataParams>,
   ): string {
+    const {
+      priceRoute,
+      exchangeParams,
+      routeIndex,
+      swapIndex,
+      flags,
+      maybeWethCallData,
+      wrapToSwapMap,
+      wrapToSwapExchangeMap,
+      swap,
+    } = params;
     const isLastSwap =
       swapIndex === priceRoute.bestRoute[routeIndex].swaps.length - 1;
     const isMegaSwap = priceRoute.bestRoute.length > 1;
     const isMultiSwap =
       !isMegaSwap && priceRoute.bestRoute[routeIndex].swaps.length > 1;
 
-    const { swapExchanges } = swap!;
+    const { swapExchanges } = swap;
 
     const applyVerticalBranching = this.doesSwapNeedToApplyVerticalBranching(
       priceRoute,
       routeIndex,
-      swap!,
+      swap,
     );
 
     const anyDexOnSwapDoesntNeedWrapNative =
-      this.anyDexOnSwapDoesntNeedWrapNative(priceRoute, swap!, exchangeParams);
+      this.anyDexOnSwapDoesntNeedWrapNative(priceRoute, swap, exchangeParams);
 
     const needToAppendWrapCallData =
-      isETHAddress(swap!.destToken) &&
+      isETHAddress(swap.destToken) &&
       anyDexOnSwapDoesntNeedWrapNative &&
       !isLastSwap &&
       maybeWethCallData?.deposit;
@@ -1027,11 +1081,11 @@ export class Executor02BytecodeBuilder extends ExecutorBytecodeBuilder {
             swapExchangeIndex,
             exchangeParams,
             flags,
-            addedWrapToSwapExchangeMap,
-            !appendedWrapToSwapMap[swapIndex - 1],
-            appendedWrapToSwapMap[swapIndex - 1],
+            wrapToSwapExchangeMap,
+            !wrapToSwapMap[swapIndex - 1],
+            wrapToSwapMap[swapIndex - 1],
             maybeWethCallData,
-            swap!.swapExchanges.length > 1,
+            swap.swapExchanges.length > 1,
             applyVerticalBranching,
           ),
         ]);
@@ -1040,7 +1094,7 @@ export class Executor02BytecodeBuilder extends ExecutorBytecodeBuilder {
     );
 
     if (needToAppendWrapCallData) {
-      appendedWrapToSwapMap[swapIndex] = true;
+      wrapToSwapMap[swapIndex] = true;
     }
 
     if (!isMultiSwap && !isMegaSwap) {
@@ -1054,11 +1108,11 @@ export class Executor02BytecodeBuilder extends ExecutorBytecodeBuilder {
         priceRoute,
         routeIndex,
         exchangeParams,
-        swap!,
+        swap,
         swapCallData,
         this.buildVerticalBranchingFlag(
           priceRoute,
-          swap!,
+          swap,
           exchangeParams,
           routeIndex,
           swapIndex,
@@ -1098,18 +1152,19 @@ export class Executor02BytecodeBuilder extends ExecutorBytecodeBuilder {
       (swapAcc, swap, swapIndex) =>
         hexConcat([
           swapAcc,
-          this.buildSingleSwapCallData(
+          this.buildSingleSwapCallData({
             priceRoute,
             exchangeParams,
             routeIndex,
             swapIndex,
             flags,
             sender,
-            appendedWrapToSwapExchangeMap,
-            addedWrapToSwapMap,
+            wrapToSwapExchangeMap: appendedWrapToSwapExchangeMap,
+            wrapToSwapMap: addedWrapToSwapMap,
             maybeWethCallData,
             swap,
-          ),
+            index: 0,
+          }),
         ]),
       '0x',
     );

package/src/executor/Executor03BytecodeBuilder.ts

@@ -9,18 +9,34 @@ import {
 import { isETHAddress } from '../utils';
 import { DepositWithdrawReturn } from '../dex/weth/types';
 import { Executors, Flag, SpecialDex } from './types';
-import { BYTES_96_LENGTH, ZEROS_28_BYTES } from './constants';
-import { ExecutorBytecodeBuilder } from './ExecutorBytecodeBuilder';
+import { BYTES_96_LENGTH } from './constants';
+import {
+  DexCallDataParams,
+  ExecutorBytecodeBuilder,
+  SingleSwapCallDataParams,
+} from './ExecutorBytecodeBuilder';
 import { assert } from 'ts-essentials';
 
 const {
   utils: { hexlify, hexDataLength, hexConcat, hexZeroPad, solidityPack },
 } = ethers;
 
+export type Executor03SingleSwapCallDataParams = {
+  swap: OptimalSwap;
+};
+
+export type Executor03DexCallDataParams = {
+  swapExchange?: OptimalSwapExchange<any>;
+  maybeWethCallData?: DepositWithdrawReturn;
+};
+
 /**
  * Class to build bytecode for Executor03 - simpleSwap (SINGLE_STEP) with 100% on a path and multiSwap with 100% amounts on each path (HORIZONTAL_SEQUENCE)
  */
-export class Executor03BytecodeBuilder extends ExecutorBytecodeBuilder {
+export class Executor03BytecodeBuilder extends ExecutorBytecodeBuilder<
+  Executor03SingleSwapCallDataParams,
+  Executor03DexCallDataParams
+> {
   type = Executors.THREE;
   /**
    * Executor03 Flags:
@@ -98,30 +114,33 @@ export class Executor03BytecodeBuilder extends ExecutorBytecodeBuilder {
   }
 
   protected buildSingleSwapCallData(
-    priceRoute: OptimalRate,
-    exchangeParams: DexExchangeBuildParam[],
-    index: number,
-    flags: { approves: Flag[]; dexes: Flag[]; wrap: Flag },
-    sender: string,
-    maybeWethCallData: DepositWithdrawReturn | undefined,
-    swap: OptimalSwap,
+    params: SingleSwapCallDataParams<Executor03SingleSwapCallDataParams>,
   ): string {
+    const {
+      priceRoute,
+      exchangeParams,
+      index,
+      flags,
+      maybeWethCallData,
+      swap,
+    } = params;
+    if (!swap) throw new Error('Swap is not provided for single swap calldata');
+
     let swapCallData = '';
 
     const curExchangeParam = exchangeParams[index];
 
-    const dexCallData = this.buildDexCallData(
+    const dexCallData = this.buildDexCallData({
       priceRoute,
-      0,
-      0,
-      index,
+      routeIndex: 0,
+      swapIndex: 0,
+      swapExchangeIndex: index,
       exchangeParams,
-      index,
-      true,
-      flags.dexes[index],
-      undefined,
+      exchangeParamIndex: index,
+      isLastSwap: true,
+      flag: flags.dexes[index],
       maybeWethCallData,
-    );
+    });
 
     swapCallData = hexConcat([dexCallData]);
 
@@ -220,17 +239,17 @@ export class Executor03BytecodeBuilder extends ExecutorBytecodeBuilder {
   }
 
   protected buildDexCallData(
-    priceRoute: OptimalRate,
-    routeIndex: number,
-    swapIndex: number,
-    swapExchangeIndex: number,
-    exchangeParams: DexExchangeBuildParam[],
-    exchangeParamIndex: number,
-    isLastSwap: boolean,
-    flag: Flag,
-    _?: OptimalSwapExchange<any>,
-    maybeWethCalldata?: DepositWithdrawReturn,
+    params: DexCallDataParams<Executor03DexCallDataParams>,
   ): string {
+    const {
+      priceRoute,
+      routeIndex,
+      swapIndex,
+      exchangeParams,
+      exchangeParamIndex,
+      flag,
+      maybeWethCallData,
+    } = params;
     const dontCheckBalanceAfterSwap = flag % 3 === 0;
     const checkDestTokenBalanceAfterSwap = flag % 3 === 2;
 
@@ -254,7 +273,7 @@ export class Executor03BytecodeBuilder extends ExecutorBytecodeBuilder {
     if (
       isETHAddress(swap.destToken) &&
       exchangeParam.needWrapNative &&
-      maybeWethCalldata?.withdraw
+      maybeWethCallData?.withdraw
     ) {
       exchangeData = this.addTokenAddressToCallData(
         exchangeData,
@@ -354,15 +373,15 @@ export class Executor03BytecodeBuilder extends ExecutorBytecodeBuilder {
       (acc, ep, index) =>
         hexConcat([
           acc,
-          this.buildSingleSwapCallData(
+          this.buildSingleSwapCallData({
             priceRoute,
             exchangeParams,
             index,
             flags,
             sender,
             maybeWethCallData,
-            swapWithOrderedExchanges,
-          ),
+            swap: swapWithOrderedExchanges,
+          }),
         ]),
       '0x',
     );

package/src/executor/ExecutorBytecodeBuilder.ts

@@ -30,7 +30,27 @@ const {
   utils: { hexlify, hexDataLength, hexConcat, hexZeroPad, solidityPack },
 } = ethers;
 
-export abstract class ExecutorBytecodeBuilder {
+export type SingleSwapCallDataParams<T> = {
+  priceRoute: OptimalRate;
+  exchangeParams: DexExchangeBuildParam[];
+  index: number;
+  flags: { approves: Flag[]; dexes: Flag[]; wrap: Flag };
+  sender: string;
+  maybeWethCallData?: DepositWithdrawReturn;
+} & T;
+
+export type DexCallDataParams<T> = {
+  priceRoute: OptimalRate;
+  routeIndex: number;
+  swapIndex: number;
+  swapExchangeIndex: number;
+  exchangeParams: DexExchangeBuildParam[];
+  exchangeParamIndex: number;
+  isLastSwap: boolean;
+  flag: Flag;
+} & T;
+
+export abstract class ExecutorBytecodeBuilder<S = {}, D = {}> {
   type!: Executors;
   erc20Interface: Interface;
 
@@ -38,7 +58,7 @@ export abstract class ExecutorBytecodeBuilder {
     this.erc20Interface = new Interface(ERC20ABI);
   }
 
-  protected abstract buildSimpleSwapFlags(
+  protected buildSimpleSwapFlags(
     priceRoute: OptimalRate,
     exchangeParams: DexExchangeBuildParam[],
     routeIndex: number,
@@ -46,9 +66,18 @@ export abstract class ExecutorBytecodeBuilder {
     swapExchangeIndex: number,
     exchangeParamIndex: number,
     maybeWethCallData?: DepositWithdrawReturn,
-  ): { dexFlag: Flag; approveFlag: Flag };
+  ): {
+    dexFlag: Flag;
+    approveFlag: Flag;
+  } {
+    return {
+      dexFlag:
+        Flag.SEND_ETH_EQUAL_TO_FROM_AMOUNT_CHECK_SRC_TOKEN_BALANCE_AFTER_SWAP,
+      approveFlag: 0,
+    };
+  }
 
-  protected abstract buildMultiMegaSwapFlags(
+  protected buildMultiMegaSwapFlags(
     priceRoute: OptimalRate,
     exchangeParams: DexExchangeBuildParam[],
     routeIndex: number,
@@ -56,7 +85,16 @@ export abstract class ExecutorBytecodeBuilder {
     swapExchangeIndex: number,
     exchangeParamIndex: number,
     maybeWethCallData?: DepositWithdrawReturn,
-  ): { dexFlag: Flag; approveFlag: Flag };
+  ): {
+    dexFlag: Flag;
+    approveFlag: Flag;
+  } {
+    return {
+      dexFlag:
+        Flag.SEND_ETH_EQUAL_TO_FROM_AMOUNT_CHECK_SRC_TOKEN_BALANCE_AFTER_SWAP,
+      approveFlag: 0,
+    };
+  }
 
   public abstract buildByteCode(
     priceRoute: OptimalRate,
@@ -67,18 +105,15 @@ export abstract class ExecutorBytecodeBuilder {
 
   public abstract getAddress(): string;
 
-  protected abstract buildDexCallData(
-    priceRoute: OptimalRate,
-    routeIndex: number,
-    swapIndex: number,
-    swapExchangeIndex: number,
-    exchangeParams: DexExchangeBuildParam[],
-    exchangeParamIndex: number,
-    isLastSwap: boolean,
-    flag: Flag,
-    swapExchange?: OptimalSwapExchange<any>,
-    maybeWethCallData?: DepositWithdrawReturn,
-  ): string;
+  protected buildSingleSwapCallData(
+    params: SingleSwapCallDataParams<S>,
+  ): string {
+    return '0x';
+  }
+
+  protected buildDexCallData(params: DexCallDataParams<D>): string {
+    return '0x';
+  }
 
   protected buildApproveCallData(
     spender: string,
@@ -193,6 +228,7 @@ export abstract class ExecutorBytecodeBuilder {
     specialDexFlag: SpecialDex,
     flag: Flag,
     toAmountPos = 0,
+    returnAmountPos = DEFAULT_RETURN_AMOUNT_POS,
   ): string {
     const builder =
       this.type !== Executors.THREE
@@ -207,6 +243,7 @@ export abstract class ExecutorBytecodeBuilder {
       specialDexFlag,
       flag,
       toAmountPos,
+      returnAmountPos,
     );
   }
 
@@ -217,13 +254,15 @@ export abstract class ExecutorBytecodeBuilder {
     destTokenPos: number,
     specialDexFlag: SpecialDex,
     flag: Flag,
+    toAmountPos = 0, // not used for Executor01 and Executor02, just to follow the same interface
+    returnAmountPos = DEFAULT_RETURN_AMOUNT_POS,
   ) {
     return solidityPack(EXECUTOR_01_02_FUNCTION_CALL_DATA_TYPES, [
       tokenAddress, // token address
       hexZeroPad(hexlify(hexDataLength(calldata) + BYTES_28_LENGTH), 4), // calldata length + bytes28(0)
       hexZeroPad(hexlify(fromAmountPos), 2), // fromAmountPos
       hexZeroPad(hexlify(destTokenPos), 2), // destTokenPos
-      hexZeroPad(hexlify(DEFAULT_RETURN_AMOUNT_POS), 1), // TODO: Fix returnAmount Pos
+      hexZeroPad(hexlify(returnAmountPos), 1), // returnAmountPos
       hexZeroPad(hexlify(specialDexFlag), 1), // special
       hexZeroPad(hexlify(flag), 2), // flag
       ZEROS_28_BYTES, // bytes28(0)

package/src/executor/ExecutorDetector.ts

@@ -5,11 +5,13 @@ import { Executor01BytecodeBuilder } from './Executor01BytecodeBuilder';
 import { Executor02BytecodeBuilder } from './Executor02BytecodeBuilder';
 import { Executors, RouteExecutionType } from './types';
 import { Executor03BytecodeBuilder } from './Executor03BytecodeBuilder';
+import { WETHBytecodeBuilder, isSingleWrapRoute } from './WETHBytecodeBuilder';
 
 export class ExecutorDetector {
   private executor01BytecodeBuilder: ExecutorBytecodeBuilder;
   private executor02BytecodeBuilder: ExecutorBytecodeBuilder;
   private executor03BytecodeBuilder: ExecutorBytecodeBuilder;
+  private wethBytecodeBuilder: ExecutorBytecodeBuilder;
 
   protected routeExecutionTypeToExecutorMap: Record<
     SwapSide,
@@ -40,6 +42,8 @@ export class ExecutorDetector {
     this.executor03BytecodeBuilder = new Executor03BytecodeBuilder(
       this.dexHelper,
     );
+
+    this.wethBytecodeBuilder = new WETHBytecodeBuilder(this.dexHelper);
   }
 
   protected getRouteExecutionType(priceRoute: OptimalRate): RouteExecutionType {
@@ -82,7 +86,15 @@ export class ExecutorDetector {
     throw new Error('Route type is not supported yet');
   }
 
+  detectSpecialExecutor(priceRoute: OptimalRate): Executors | null {
+    if (isSingleWrapRoute(priceRoute)) return Executors.WETH;
+    return null;
+  }
+
   getExecutorByPriceRoute(priceRoute: OptimalRate): Executors {
+    const specialExecutor = this.detectSpecialExecutor(priceRoute);
+    if (specialExecutor) return specialExecutor;
+
     const routeExecutionType = this.getRouteExecutionType(priceRoute);
     const executorName =
       this.routeExecutionTypeToExecutorMap[priceRoute.side][routeExecutionType];
@@ -110,6 +122,8 @@ export class ExecutorDetector {
         return this.executor02BytecodeBuilder;
       case Executors.THREE:
         return this.executor03BytecodeBuilder;
+      case Executors.WETH:
+        return this.wethBytecodeBuilder;
       default:
         throw new Error(`${executorName} is not supported`);
     }

package/src/executor/WETHBytecodeBuilder.ts

@@ -0,0 +1,57 @@
+import { DexExchangeBuildParam } from '../types';
+import { OptimalRate, SwapSide } from '@paraswap/core';
+import { isETHAddress } from '../utils';
+import { DepositWithdrawReturn } from '../dex/weth/types';
+import { WethConfig } from '../dex/weth/config';
+import { Executors, Flag, SpecialDex } from './types';
+import { ExecutorBytecodeBuilder } from './ExecutorBytecodeBuilder';
+import { Network } from '../constants';
+
+const SUPPORTED_NETWORKS = [
+  Network.MAINNET,
+  Network.AVALANCHE,
+  Network.BSC,
+  Network.BASE,
+  Network.POLYGON,
+  Network.OPTIMISM,
+  Network.ZKEVM,
+];
+const SUPPORTED_EXCHANGES = Object.keys(WethConfig);
+
+export const isSingleWrapRoute = (priceRoute: OptimalRate): boolean => {
+  //note: FANTOM and ARBITRUM doesnt support fallback deposit case
+
+  const isSingleSwap =
+    priceRoute.bestRoute.length === 1 &&
+    priceRoute.bestRoute[0].swaps.length === 1 &&
+    priceRoute.bestRoute[0].swaps[0].swapExchanges.length === 1;
+
+  const { exchange } = priceRoute.bestRoute[0].swaps[0].swapExchanges[0];
+
+  const isWethExchange = SUPPORTED_EXCHANGES.includes(exchange);
+  const supportedNetwork = SUPPORTED_NETWORKS.includes(priceRoute.network);
+
+  const isWrap = isETHAddress(priceRoute.srcToken);
+
+  return supportedNetwork && isSingleSwap && isWethExchange && isWrap;
+};
+
+/**
+ * Class to build bytecode for WETH - simple optimisation for a single ETH->WETH Swap
+ */
+export class WETHBytecodeBuilder extends ExecutorBytecodeBuilder {
+  type = Executors.WETH;
+
+  public getAddress(): string {
+    return this.dexHelper.config.data.wrappedNativeTokenAddress;
+  }
+
+  public buildByteCode(
+    priceRoute: OptimalRate,
+    exchangeParams: DexExchangeBuildParam[],
+    sender: string,
+    maybeWethCallData?: DepositWithdrawReturn,
+  ): string {
+    return '0x';
+  }
+}