@paraswap/dex-lib 3.8.38 → 3.8.39-1701-1507

package/src/executor/ExecutorDetector.ts

@@ -19,7 +19,8 @@ export class ExecutorDetector {
   > = {
     [SwapSide.SELL]: {
       [RouteExecutionType.SINGLE_STEP]: Executors.ONE, // simpleSwap via Executor01
-      [RouteExecutionType.HORIZONTAL_SEQUENCE]: Executors.ONE, // multiSwap via Executor01
+      // [RouteExecutionType.HORIZONTAL_SEQUENCE]: Executors.ONE, // multiSwap via Executor01
+      [RouteExecutionType.HORIZONTAL_SEQUENCE]: Executors.TWO, // multiSwap via Executor02
       [RouteExecutionType.VERTICAL_BRANCH]: Executors.TWO, // simpleSwap with percentage on a path via Executor02
       [RouteExecutionType.VERTICAL_BRANCH_HORIZONTAL_SEQUENCE]: Executors.TWO, // multiSwap with percentages on paths via Executor02
       // megaSwap via Executor02

package/src/executor/types.ts

@@ -1,6 +1,7 @@
 export enum Flag {
   SEND_ETH_EQUAL_TO_FROM_AMOUNT_PLUS_INSERT_FROM_AMOUNT_DONT_CHECK_BALANCE_AFTER_SWAP = 18, // // (flag 18 mod 4) = case 2: sendEth equal to fromAmount + insert fromAmount, (flag 18 mod 3) = case 0: don't check balance after swap
   SEND_ETH_EQUAL_TO_FROM_AMOUNT_PLUS_INSERT_FROM_AMOUNT_CHECK_SRC_TOKEN_BALANCE_AFTER_SWAP = 14, // (flag 14 mod 4) = case 2: sendEth equal to fromAmount + insert fromAmount, (flag 14 mod 3) = case 2: case 2: check "srcToken" balance after swap
+  SEND_ETH_EQUAL_TO_FROM_AMOUNT_CHECK_ETH_BALANCE_AFTER_SWAP = 13, // (flag 13 mod 4) = case 1: sendEth equal to fromAmount, (flag 13 mod 3) = case 1: check eth balance after swap
   INSERT_FROM_AMOUNT_CHECK_SRC_TOKEN_BALANCE_AFTER_SWAP = 11, // (flag 11 mod 4) = case 3: insert fromAmount, (flag 11 mod 3) = case 2: check "srcToken" balance after swap
   SEND_ETH_EQUAL_TO_FROM_AMOUNT_DONT_CHECK_BALANCE_AFTER_SWAP = 9, // (flag 9 mod 4) = case 1: sendEth equal to fromAmount, (flag 9 mod 3) = case 0: don't check balance after swap
   DONT_INSERT_FROM_AMOUNT_CHECK_SRC_TOKEN_BALANCE_AFTER_SWAP = 8, // (flag 8 mod 4) = case 0: don't insert fromAmount, (flag 8 mod 3) = case 2: check "srcToken" balance after swap

package/src/generic-swap-transaction-builder.ts

@@ -123,6 +123,8 @@ export class GenericSwapTransactionBuilder {
               recipient,
               wethDeposit,
               wethWithdraw,
+              wethDepositForNeedUnwrapWeth,
+              wethWithdrawForNeedUnwrapWeth,
             } = this.getDexCallsParams(
               priceRoute,
               routeIndex,
@@ -148,6 +150,9 @@ export class GenericSwapTransactionBuilder {
                 isGlobalDestToken:
                   priceRoute.destToken.toLowerCase() ===
                   destToken.toLowerCase(),
+                priceRoute: priceRoute,
+                swap: swap,
+                swapExchange: se,
               },
               executorAddress,
             );
@@ -156,30 +161,47 @@ export class GenericSwapTransactionBuilder {
               dexParams,
               wethDeposit,
               wethWithdraw,
+              wethDepositForNeedUnwrapWeth,
+              wethWithdrawForNeedUnwrapWeth,
             };
           }),
         ),
       ),
     );
 
-    const { exchangeParams, srcAmountWethToDeposit, destAmountWethToWithdraw } =
-      await rawDexParams.reduce<{
-        exchangeParams: DexExchangeParam[];
-        srcAmountWethToDeposit: bigint;
-        destAmountWethToWithdraw: bigint;
-      }>(
-        (acc, se) => {
-          acc.srcAmountWethToDeposit += BigInt(se.wethDeposit);
-          acc.destAmountWethToWithdraw += BigInt(se.wethWithdraw);
-          acc.exchangeParams.push(se.dexParams);
-          return acc;
-        },
-        {
-          exchangeParams: [],
-          srcAmountWethToDeposit: 0n,
-          destAmountWethToWithdraw: 0n,
-        },
-      );
+    const {
+      exchangeParams,
+      srcAmountWethToDeposit,
+      destAmountWethToWithdraw,
+      srcAmountWethToWithdrawForNeedUnwrapWeth,
+      destAmountWethToDepositForNeeUnwrapWeth,
+    } = await rawDexParams.reduce<{
+      exchangeParams: DexExchangeParam[];
+      srcAmountWethToDeposit: bigint;
+      destAmountWethToWithdraw: bigint;
+      srcAmountWethToWithdrawForNeedUnwrapWeth: bigint;
+      destAmountWethToDepositForNeeUnwrapWeth: bigint;
+    }>(
+      (acc, se) => {
+        acc.srcAmountWethToDeposit += BigInt(se.wethDeposit);
+        acc.destAmountWethToWithdraw += BigInt(se.wethWithdraw);
+        acc.srcAmountWethToWithdrawForNeedUnwrapWeth += BigInt(
+          se.wethWithdrawForNeedUnwrapWeth,
+        );
+        acc.destAmountWethToDepositForNeeUnwrapWeth += BigInt(
+          se.wethDepositForNeedUnwrapWeth,
+        );
+        acc.exchangeParams.push(se.dexParams);
+        return acc;
+      },
+      {
+        exchangeParams: [],
+        srcAmountWethToDeposit: 0n,
+        destAmountWethToWithdraw: 0n,
+        srcAmountWethToWithdrawForNeedUnwrapWeth: 0n,
+        destAmountWethToDepositForNeeUnwrapWeth: 0n,
+      },
+    );
 
     const maybeWethCallData = this.getDepositWithdrawWethCallData(
       srcAmountWethToDeposit,
@@ -187,11 +209,19 @@ export class GenericSwapTransactionBuilder {
       side,
     );
 
+    const maybeWethCallDataForNeedUnwrapWeth =
+      this.getDepositWithdrawWethCallData(
+        destAmountWethToDepositForNeeUnwrapWeth,
+        srcAmountWethToWithdrawForNeedUnwrapWeth,
+        side,
+      );
+
     const buildExchangeParams = await this.addDexExchangeApproveParams(
       bytecodeBuilder,
       priceRoute,
       exchangeParams,
       maybeWethCallData,
+      maybeWethCallDataForNeedUnwrapWeth,
     );
 
     return bytecodeBuilder.buildByteCode(
@@ -199,6 +229,7 @@ export class GenericSwapTransactionBuilder {
       buildExchangeParams,
       userAddress,
       maybeWethCallData,
+      maybeWethCallDataForNeedUnwrapWeth,
     );
   }
 
@@ -599,9 +630,11 @@ export class GenericSwapTransactionBuilder {
     destAmount: string;
     wethDeposit: bigint;
     wethWithdraw: bigint;
+    wethDepositForNeedUnwrapWeth: bigint;
+    wethWithdrawForNeedUnwrapWeth: bigint;
   } {
     const wethAddress =
-      this.dexAdapterService.dexHelper.config.data.wrappedNativeTokenAddress;
+      this.dexAdapterService.dexHelper.config.data.wrappedNativeTokenAddress.toLowerCase();
 
     const side = priceRoute.side;
 
@@ -617,6 +650,9 @@ export class GenericSwapTransactionBuilder {
 
     let wethWithdraw = 0n;
 
+    let wethWithdrawForNeedUnwrapWeth = 0n;
+    let wethDepositForNeedUnwrapWeth = 0n;
+
     // For case of buy apply slippage is applied to srcAmount in equal proportion as the complete swap
     // This assumes that the sum of all swaps srcAmount would sum to priceRoute.srcAmount
     // Also that it is a direct swap.
@@ -633,7 +669,19 @@ export class GenericSwapTransactionBuilder {
     // should work if the final slippage check passes.
     const _destAmount = side === SwapSide.SELL ? '1' : se.destAmount;
 
-    if (isETHAddress(swap.srcToken) && dex.needWrapNative) {
+    const dexNeedWrapNative =
+      typeof dex.needWrapNative === 'function'
+        ? dex.needWrapNative(priceRoute, swap, se)
+        : dex.needWrapNative;
+
+    const dexNeedUnwrapWeth =
+      dex.needUnwrapWeth !== undefined
+        ? typeof dex.needUnwrapWeth === 'function'
+          ? dex.needUnwrapWeth(priceRoute, swap, se)
+          : dex.needUnwrapWeth
+        : false;
+
+    if (isETHAddress(swap.srcToken) && dexNeedWrapNative) {
       _src = wethAddress;
       wethDeposit = BigInt(_srcAmount);
     }
@@ -641,27 +689,50 @@ export class GenericSwapTransactionBuilder {
     const forceUnwrap =
       isETHAddress(swap.destToken) &&
       (isMultiSwap || isMegaSwap) &&
-      !dex.needWrapNative &&
+      !dexNeedWrapNative &&
       !isLastSwap;
 
-    if ((isETHAddress(swap.destToken) && dex.needWrapNative) || forceUnwrap) {
-      _dest = forceUnwrap && !dex.needWrapNative ? _dest : wethAddress;
+    if ((isETHAddress(swap.destToken) && dexNeedWrapNative) || forceUnwrap) {
+      _dest = forceUnwrap && !dexNeedWrapNative ? _dest : wethAddress;
       wethWithdraw = BigInt(se.destAmount);
     }
 
+    if (dexNeedUnwrapWeth) {
+      const wethAddr =
+        this.dexAdapterService.dexHelper.config.data.wrappedNativeTokenAddress.toLowerCase();
+      if (swap.srcToken.toLowerCase() === wethAddr) {
+        _src = ETHER_ADDRESS;
+        wethWithdrawForNeedUnwrapWeth = BigInt(_srcAmount);
+
+        if (side === SwapSide.BUY) {
+          wethDepositForNeedUnwrapWeth = 1n; // to add wrap after dex call for tokens remainder for buy side cases
+        }
+      }
+
+      if (swap.destToken.toLowerCase() === wethAddr) {
+        _dest = ETHER_ADDRESS;
+        wethDepositForNeedUnwrapWeth = BigInt(se.destAmount); // cant use _destAmount here because _destAmount could be 1
+      }
+    }
+
     const needToWithdrawAfterSwap = _dest === wethAddress && wethWithdraw;
+    const needToDepositAfterSwap =
+      swap.destToken.toLowerCase() === wethAddress &&
+      wethDepositForNeedUnwrapWeth;
 
     return {
       srcToken: _src,
       destToken: _dest,
       recipient:
-        needToWithdrawAfterSwap || !isLastSwap
+        needToWithdrawAfterSwap || !isLastSwap || needToDepositAfterSwap
           ? executionContractAddress
           : this.dexAdapterService.dexHelper.config.data.augustusV6Address!,
       srcAmount: _srcAmount,
       destAmount: _destAmount,
       wethDeposit,
       wethWithdraw,
+      wethWithdrawForNeedUnwrapWeth,
+      wethDepositForNeedUnwrapWeth,
     };
   }
 
@@ -670,6 +741,7 @@ export class GenericSwapTransactionBuilder {
     priceRoute: OptimalRate,
     dexExchangeParams: DexExchangeParam[],
     maybeWethCallData?: DepositWithdrawReturn,
+    maybeWethCallDataForNeedUnwrapWeth?: DepositWithdrawReturn,
   ): Promise<DexExchangeBuildParam[]> {
     const spender = bytecodeBuilder.getAddress();
     const tokenTargetMapping: {

package/src/implementations/local-paraswap-sdk.ts

@@ -262,16 +262,27 @@ export class LocalParaswapSDK implements IParaSwapSDK {
                     }
 
                     const { recipient } =
-                      this.transactionBuilder.getDexCallsParams(
-                        priceRoute,
-                        routeIndex,
-                        swap,
-                        swapIndex,
-                        se,
-                        minMaxAmount.toString(),
-                        dex,
-                        executionContractAddress,
-                      );
+                      priceRoute.version === ParaSwapVersion.V5
+                        ? this.transactionBuilderV5.getDexCallsParams(
+                            priceRoute,
+                            routeIndex,
+                            swap,
+                            swapIndex,
+                            se,
+                            minMaxAmount.toString(),
+                            dex,
+                            executionContractAddress,
+                          )
+                        : this.transactionBuilder.getDexCallsParams(
+                            priceRoute,
+                            routeIndex,
+                            swap,
+                            swapIndex,
+                            se,
+                            minMaxAmount.toString(),
+                            dex,
+                            executionContractAddress,
+                          );
 
                     const [preprocessedRoute, txInfo] =
                       await dexLibExchange.preProcessTransaction(

package/src/lib/fetcher/wsFetcher.ts

@@ -0,0 +1,126 @@
+import { Logger } from 'log4js';
+import { RequestConfig, Response } from '../../dex-helper/irequest-wrapper';
+import {
+  connection as WebSocketConnection,
+  client as WebSocketClient,
+} from 'websocket';
+
+export class SkippingRequest {
+  constructor(public message = '') {}
+}
+
+export type RequestInfo<T> = {
+  requestFunc?: (
+    options: RequestConfig,
+  ) => Promise<Response<T> | SkippingRequest>;
+  requestOptions: RequestConfig;
+  caster: (data: unknown) => T;
+  authenticate?: (options: RequestConfig) => RequestConfig;
+  excludedFieldsCaching?: string[];
+};
+
+export type RequestInfoWithHandler<T> = {
+  info: RequestInfo<T>;
+  handler: (data: T) => void;
+};
+
+export class WebSocketFetcher<T> {
+  private requests: RequestInfoWithHandler<T>;
+  public lastFetchSucceeded: boolean = false;
+  private stop: boolean = true;
+  private ws: WebSocketClient = new WebSocketClient();
+  private connection: WebSocketConnection | null = null;
+
+  constructor(requestsInfo: RequestInfoWithHandler<T>, private logger: Logger) {
+    this.requests = requestsInfo;
+    this.ws.on('connect', this.connected.bind(this));
+    this.ws.on('connectFailed', this.connectFailed.bind(this));
+  }
+
+  private connected(connection: WebSocketConnection) {
+    this.connection = connection;
+    this.logger.info(`Connected to ${this.requests.info.requestOptions.url}`);
+    this.connection.on('error', this.onError.bind(this));
+    this.connection.on('close', this.onClose.bind(this));
+    this.connection.on('message', this.onMessage.bind(this));
+  }
+
+  private connectFailed(error: any) {
+    this.logger.error(`Connect Error: ${error.toString()}`);
+  }
+
+  private onClose() {
+    this.logger.info(`Connection closed`);
+  }
+
+  private onError(error: any) {
+    this.logger.error(`Connection Error: ${error.toString()}`);
+  }
+
+  private onMessage(message: any) {
+    if (message.type === 'utf8') {
+      const response = JSON.parse(message.utf8Data) as Response<T>;
+      const reqInfo = this.requests;
+      const info = reqInfo.info;
+      const options = reqInfo.info.requestOptions;
+      this.logger.debug(`(${options.url}) received new data`);
+
+      try {
+        const parsedData = info.caster(response);
+        reqInfo.handler(parsedData);
+      } catch (e) {
+        this.logger.info(e);
+        this.logger.info(
+          `(${options.url}) received incorrect data ${JSON.stringify(
+            response,
+          ).replace(/(?:\r\n|\r|\n)/g, ' ')}`,
+          e,
+        );
+        return;
+      }
+    }
+  }
+
+  private connect() {
+    const authorization =
+      this.requests.info.requestOptions.headers!.authorization;
+    const name = this.requests.info.requestOptions.headers!.name;
+    if (typeof authorization !== 'string') {
+      throw new Error('Authorization header is not a string');
+    }
+    if (typeof name !== 'string') {
+      throw new Error('Name header is not a string');
+    }
+    this.ws.connect(
+      this.requests.info.requestOptions.url!,
+      undefined,
+      undefined,
+      {
+        Authorization: authorization,
+        name: name,
+      },
+    );
+  }
+
+  startPolling(): void {
+    this.stop = false;
+    this.connect();
+    this.logger.info(
+      `Connection started for ${this.requests.info.requestOptions.url}`,
+    );
+  }
+
+  stopPolling() {
+    if (this.connection) {
+      this.connection.close();
+    }
+    this.stop = true;
+    this.logger.info(
+      `Connection stopped for ${this.requests.info.requestOptions.url}`,
+    );
+  }
+
+  isPolling(): boolean {
+    return !this.stop;
+  }
+}

package/src/router/simpleswap.ts

@@ -6,7 +6,7 @@ import {
   TxInfo,
   SimpleExchangeParam,
 } from '../types';
-import { SwapSide } from '../constants';
+import { ETHER_ADDRESS, SwapSide } from '../constants';
 import IParaswapABI from '../abi/IParaswap.json';
 import { Interface } from '@ethersproject/abi';
 import { isETHAddress, uuidToBytes16 } from '../utils';
@@ -95,9 +95,11 @@ export abstract class SimpleRouterBase<RouterParam>
         swap.swapExchanges.map(async se => {
           const dex = this.dexAdapterService.getTxBuilderDexByKey(se.exchange);
           let _src = swap.srcToken;
-          let wethDeposit = 0n;
+          let wethDepositForNeedWrapNative = 0n;
+          let wethDepositForNeedUnwrapWeth = 0n;
           let _dest = swap.destToken;
-          let wethWithdraw = 0n;
+          let wethWithdrawForNeedWrapNative = 0n;
+          let wethWithdrawForNeedUnwrapWeth = 0n;
 
           // For case of buy apply slippage is applied to srcAmount in equal proportion as the complete swap
           // This assumes that the sum of all swaps srcAmount would sum to priceRoute.srcAmount
@@ -115,13 +117,23 @@ export abstract class SimpleRouterBase<RouterParam>
           // should work if the final slippage check passes.
           const _destAmount = this.side === SwapSide.SELL ? '1' : se.destAmount;
 
-          if (dex.needWrapNative) {
+          const dexNeedWrapNative =
+            typeof dex.needWrapNative === 'function'
+              ? dex.needWrapNative(priceRoute, swap, se)
+              : dex.needWrapNative;
+
+          const dexNeedUnwrapWeth =
+            typeof dex.needUnwrapWeth === 'function'
+              ? dex.needUnwrapWeth(priceRoute, swap, se)
+              : dex.needUnwrapWeth;
+
+          if (dexNeedWrapNative) {
             if (isETHAddress(swap.srcToken)) {
               if (swapIndex !== 0) {
                 throw new Error('Wrap native srcToken not in swapIndex 0');
               }
               _src = wethAddress;
-              wethDeposit = BigInt(_srcAmount);
+              wethDepositForNeedWrapNative = BigInt(_srcAmount);
             }
 
             if (isETHAddress(swap.destToken)) {
@@ -129,7 +141,21 @@ export abstract class SimpleRouterBase<RouterParam>
                 throw new Error('Wrap native destToken not in swapIndex last');
               }
               _dest = wethAddress;
-              wethWithdraw = BigInt(_destAmount);
+              wethWithdrawForNeedWrapNative = BigInt(_destAmount);
+            }
+          }
+
+          if (dexNeedUnwrapWeth) {
+            const wethAddr =
+              this.dexAdapterService.dexHelper.config.data.wrappedNativeTokenAddress.toLowerCase();
+            if (swap.srcToken.toLowerCase() === wethAddr) {
+              _src = ETHER_ADDRESS;
+              wethWithdrawForNeedUnwrapWeth = BigInt(_srcAmount);
+            }
+
+            if (swap.destToken.toLowerCase() === wethAddr) {
+              _dest = ETHER_ADDRESS;
+              wethDepositForNeedUnwrapWeth = BigInt(se.destAmount); // cant use _destAmount here because _destAmount could be 1
             }
           }
 
@@ -144,8 +170,10 @@ export abstract class SimpleRouterBase<RouterParam>
 
           return {
             simpleParams,
-            wethDeposit,
-            wethWithdraw,
+            wethDepositForNeedWrapNative,
+            wethWithdrawForNeedWrapNative,
+            wethWithdrawForNeedUnwrapWeth,
+            wethDepositForNeedUnwrapWeth,
           };
         }),
       ),
@@ -153,16 +181,30 @@ export abstract class SimpleRouterBase<RouterParam>
 
     const {
       simpleExchangeDataList,
-      srcAmountWethToDeposit,
-      destAmountWethToWithdraw,
+      srcAmountWethToDepositForNeedWrapNative,
+      destAmountWethToWithdrawForNeedWrapNative,
+      srcAmountWethToWithdrawForNeedUnwrapWeth,
+      destAmountWethToDepositForNeeUnwrapWeth,
     } = rawSimpleParams.reduce<{
       simpleExchangeDataList: SimpleExchangeParam[];
-      srcAmountWethToDeposit: bigint;
-      destAmountWethToWithdraw: bigint;
+      srcAmountWethToDepositForNeedWrapNative: bigint;
+      srcAmountWethToWithdrawForNeedUnwrapWeth: bigint;
+      destAmountWethToWithdrawForNeedWrapNative: bigint;
+      destAmountWethToDepositForNeeUnwrapWeth: bigint;
     }>(
       (acc, se) => {
-        acc.srcAmountWethToDeposit += BigInt(se.wethDeposit);
-        acc.destAmountWethToWithdraw += BigInt(se.wethWithdraw);
+        acc.srcAmountWethToDepositForNeedWrapNative += BigInt(
+          se.wethDepositForNeedWrapNative,
+        );
+        acc.srcAmountWethToWithdrawForNeedUnwrapWeth += BigInt(
+          se.wethWithdrawForNeedUnwrapWeth,
+        );
+        acc.destAmountWethToWithdrawForNeedWrapNative += BigInt(
+          se.wethWithdrawForNeedWrapNative,
+        );
+        acc.destAmountWethToDepositForNeeUnwrapWeth += BigInt(
+          se.wethDepositForNeedUnwrapWeth,
+        );
         // V6 doesn't have simpleParams
         if (se.simpleParams) {
           acc.simpleExchangeDataList.push(se.simpleParams);
@@ -172,8 +214,10 @@ export abstract class SimpleRouterBase<RouterParam>
       },
       {
         simpleExchangeDataList: [],
-        srcAmountWethToDeposit: 0n,
-        destAmountWethToWithdraw: 0n,
+        srcAmountWethToDepositForNeedWrapNative: 0n,
+        srcAmountWethToWithdrawForNeedUnwrapWeth: 0n,
+        destAmountWethToWithdrawForNeedWrapNative: 0n,
+        destAmountWethToDepositForNeeUnwrapWeth: 0n,
       },
     );
 
@@ -188,10 +232,16 @@ export abstract class SimpleRouterBase<RouterParam>
     );
 
     const maybeWethCallData = this.getDepositWithdrawWethCallData(
-      srcAmountWethToDeposit,
-      destAmountWethToWithdraw,
+      srcAmountWethToDepositForNeedWrapNative,
+      destAmountWethToWithdrawForNeedWrapNative,
     );
 
+    const maybeWethCallDataForNeedUnwrapWeth =
+      this.getDepositWithdrawWethCallData(
+        destAmountWethToDepositForNeeUnwrapWeth,
+        srcAmountWethToWithdrawForNeedUnwrapWeth,
+      );
+
     if (maybeWethCallData) {
       if (maybeWethCallData.deposit) {
         simpleExchangeDataFlat.callees.unshift(
@@ -211,6 +261,32 @@ export abstract class SimpleRouterBase<RouterParam>
       }
     }
 
+    if (maybeWethCallDataForNeedUnwrapWeth) {
+      if (maybeWethCallDataForNeedUnwrapWeth.withdraw) {
+        simpleExchangeDataFlat.callees.unshift(
+          maybeWethCallDataForNeedUnwrapWeth.withdraw.callee,
+        );
+        simpleExchangeDataFlat.values.unshift(
+          maybeWethCallDataForNeedUnwrapWeth.withdraw.value,
+        );
+        simpleExchangeDataFlat.calldata.unshift(
+          maybeWethCallDataForNeedUnwrapWeth.withdraw.calldata,
+        );
+      }
+
+      if (maybeWethCallDataForNeedUnwrapWeth.deposit) {
+        simpleExchangeDataFlat.callees.push(
+          maybeWethCallDataForNeedUnwrapWeth.deposit.callee,
+        );
+        simpleExchangeDataFlat.values.push(
+          maybeWethCallDataForNeedUnwrapWeth.deposit.value,
+        );
+        simpleExchangeDataFlat.calldata.push(
+          maybeWethCallDataForNeedUnwrapWeth.deposit.calldata,
+        );
+      }
+    }
+
     return {
       partialContractSimpleData: this.buildPartialContractSimpleData(
         simpleExchangeDataFlat,

package/src/types.ts

@@ -159,6 +159,7 @@ export type AdapterExchangeParam = {
 
 export type DexExchangeParam = {
   needWrapNative: boolean;
+  needUnwrapWeth?: boolean;
   skipApproval?: boolean;
   wethAddress?: string;
   exchangeData: string;
@@ -304,6 +305,7 @@ export type Config = {
   uniswapV3EventLoggingSampleRate?: number;
   swaapV2AuthToken?: string;
   dexalotAuthToken?: string;
+  bebopAuthToken?: string;
   idleDaoAuthToken?: string;
   forceRpcFallbackDexs: string[];
   apiKeyTheGraph: string;

package/tests/constants-e2e.ts

@@ -1532,7 +1532,7 @@ export const Holders: {
     AA_iETHv2: '0xA118aD79E2152b9a3c7Df8B8791887762b0f1D49',
     BB_iETHv2: '0x15079cBAa74C1df2a602fAc88Bd5b98B08FfE6A4',
     ETH: '0x176F3DAb24a159341c0509bB36B833E7fdd0a132',
-    USDC: '0x7713974908be4bed47172370115e8b1219f4a5f0',
+    USDC: '0xd8A3c2901b736170b70088a0Df9AA914317d43C6',
     USDE: '0x8707f238936c12c309bfc2B9959C35828AcFc512',
     AMPL: '0x223592a191ECfC7FDC38a9256c3BD96E771539A9',
     WBTC: '0x6daB3bCbFb336b29d06B9C793AEF7eaA57888922',
@@ -1770,7 +1770,7 @@ export const Holders: {
     WETH: '0x3368e17064c9ba5d6f1f93c4c678bea00cc78555',
     BAL: '0x7b7b957c284c2c227c980d6e2f804311947b84d0',
     USDCe: '0x62383739d68dd0f844103db8dfb05a7eded5bbe6',
-    USDC: '0xb38e8c17e38363af6ebdcb3dae12e0243582891d',
+    USDC: '0x62383739D68Dd0F844103Db8dFb05a7EdED5BBE6',
     OHM: '0xebce5f29ff5ca9aa330ebdf7ec6b5f474bff271e',
     USDT: '0xf977814e90da44bfa03b6295a0616a897441acec',
     POPS: '0x4b78b52e7de4d8b7d367297cb8a87c1875a9d591',