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

package/src/executor/Executor03BytecodeBuilder.ts

@@ -15,7 +15,6 @@ import {
   ExecutorBytecodeBuilder,
   SingleSwapCallDataParams,
 } from './ExecutorBytecodeBuilder';
-import { assert } from 'ts-essentials';
 
 const {
   utils: { hexlify, hexDataLength, hexConcat, hexZeroPad, solidityPack },
@@ -59,6 +58,7 @@ export class Executor03BytecodeBuilder extends ExecutorBytecodeBuilder<
     swapExchangeIndex: number,
     exchangeParamIndex: number,
     maybeWethCallData?: DepositWithdrawReturn,
+    maybeWethCallDataForNeedUnwrapWeth?: DepositWithdrawReturn,
   ): { dexFlag: Flag; approveFlag: Flag } {
     const { srcToken, destToken } = priceRoute.bestRoute[0].swaps[0];
     const isEthSrc = isETHAddress(srcToken);
@@ -68,8 +68,8 @@ export class Executor03BytecodeBuilder extends ExecutorBytecodeBuilder<
     const swap = priceRoute.bestRoute[0].swaps[0];
 
     const {
-      dexFuncHasRecipient,
       needWrapNative,
+      needUnwrapWeth,
       swappedAmountNotPresentInExchangeData,
       specialDexFlag,
       specialDexSupportsInsertFromAmount,
@@ -77,6 +77,11 @@ export class Executor03BytecodeBuilder extends ExecutorBytecodeBuilder<
     const isSpecialDex =
       specialDexFlag !== undefined && specialDexFlag !== SpecialDex.DEFAULT;
 
+    const wethAddr =
+      this.dexHelper.config.data.wrappedNativeTokenAddress.toLowerCase();
+    const isWethSrc = srcToken.toLowerCase() === wethAddr;
+    const isWethDest = destToken.toLowerCase() === wethAddr;
+
     const forcePreventInsertFromAmount =
       swappedAmountNotPresentInExchangeData ||
       (isSpecialDex && !specialDexSupportsInsertFromAmount);
@@ -85,6 +90,16 @@ export class Executor03BytecodeBuilder extends ExecutorBytecodeBuilder<
     const needUnwrap =
       needWrapNative && isEthDest && maybeWethCallData?.withdraw;
 
+    const needUnwrapForWethSrc =
+      needUnwrapWeth &&
+      isWethSrc &&
+      maybeWethCallDataForNeedUnwrapWeth?.withdraw;
+
+    const needWrapForWethDest =
+      needUnwrapWeth &&
+      isWethDest &&
+      maybeWethCallDataForNeedUnwrapWeth?.deposit;
+
     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
@@ -95,7 +110,12 @@ export class Executor03BytecodeBuilder extends ExecutorBytecodeBuilder<
     if (isEthSrc && !needWrap) {
       dexFlag =
         Flag.SEND_ETH_EQUAL_TO_FROM_AMOUNT_CHECK_SRC_TOKEN_BALANCE_AFTER_SWAP; // 5
-    } else if (isEthDest && !needUnwrap) {
+    } else if (isWethSrc && needUnwrapForWethSrc) {
+      dexFlag = Flag.SEND_ETH_EQUAL_TO_FROM_AMOUNT_CHECK_ETH_BALANCE_AFTER_SWAP; // 13
+    } else if (
+      (isEthDest && !needUnwrap) ||
+      (isWethDest && needWrapForWethDest)
+    ) {
       dexFlag = forcePreventInsertFromAmount
         ? Flag.DONT_INSERT_FROM_AMOUNT_CHECK_ETH_BALANCE_AFTER_SWAP // 4
         : Flag.INSERT_FROM_AMOUNT_CHECK_ETH_BALANCE_AFTER_SWAP; // 7
@@ -103,7 +123,6 @@ export class Executor03BytecodeBuilder extends ExecutorBytecodeBuilder<
       dexFlag = forcePreventInsertFromAmount
         ? Flag.DONT_INSERT_FROM_AMOUNT_CHECK_SRC_TOKEN_BALANCE_AFTER_SWAP // 8
         : Flag.INSERT_FROM_AMOUNT_CHECK_SRC_TOKEN_BALANCE_AFTER_SWAP; // 11
-      // dexFlag = Flag.ZERO;
     } else if (
       !isETHAddress(swap.destToken) &&
       exchangeParams.some(param => !param.dexFuncHasRecipient)
@@ -143,6 +162,7 @@ export class Executor03BytecodeBuilder extends ExecutorBytecodeBuilder<
       index,
       flags,
       maybeWethCallData,
+      maybeWethCallDataForNeedUnwrapWeth,
       swap,
     } = params;
     if (!swap) throw new Error('Swap is not provided for single swap calldata');
@@ -212,8 +232,32 @@ export class Executor03BytecodeBuilder extends ExecutorBytecodeBuilder<
       ]);
     }
 
-    // after the last path
+    if (
+      maybeWethCallDataForNeedUnwrapWeth?.withdraw &&
+      swap.srcToken.toLowerCase() ===
+        this.dexHelper.config.data.wrappedNativeTokenAddress.toLowerCase() &&
+      curExchangeParam.needUnwrapWeth
+    ) {
+      const withdrawCallData = this.buildUnwrapEthCallData(
+        this.getWETHAddress(curExchangeParam),
+        maybeWethCallDataForNeedUnwrapWeth.withdraw.calldata,
+      );
+
+      swapCallData = hexConcat([withdrawCallData, swapCallData]);
+
+      if (maybeWethCallDataForNeedUnwrapWeth.deposit) {
+        const depositCallData = this.buildWrapEthCallData(
+          this.getWETHAddress(curExchangeParam),
+          maybeWethCallDataForNeedUnwrapWeth.deposit?.calldata,
+          Flag.SEND_ETH_EQUAL_TO_FROM_AMOUNT_DONT_CHECK_BALANCE_AFTER_SWAP, // 9
+        );
+
+        swapCallData = hexConcat([swapCallData, depositCallData]);
+      }
+    }
+
     if (index === exchangeParams.length - 1) {
+      // after the last path
       // if some of dexes doesn't have recipient add one transfer in the end
       if (
         exchangeParams.some(param => !param.dexFuncHasRecipient) &&
@@ -240,6 +284,43 @@ export class Executor03BytecodeBuilder extends ExecutorBytecodeBuilder<
         swapCallData = hexConcat([swapCallData, withdrawCallData]);
       }
 
+      if (
+        maybeWethCallDataForNeedUnwrapWeth?.deposit &&
+        swap.destToken.toLowerCase() ===
+          this.dexHelper.config.data.wrappedNativeTokenAddress.toLowerCase()
+      ) {
+        let approveWethCalldata = '0x';
+        if (curExchangeParam.approveData) {
+          approveWethCalldata = this.buildApproveCallData(
+            curExchangeParam.approveData.target,
+            curExchangeParam.approveData.token,
+            flags.approves[index],
+          );
+        }
+
+        const depositCallData = this.buildWrapEthCallData(
+          this.getWETHAddress(curExchangeParam),
+          maybeWethCallDataForNeedUnwrapWeth.deposit.calldata,
+          Flag.SEND_ETH_EQUAL_TO_FROM_AMOUNT_DONT_CHECK_BALANCE_AFTER_SWAP, // 9
+        );
+
+        const transferCallData = this.buildTransferCallData(
+          this.erc20Interface.encodeFunctionData('transfer', [
+            this.dexHelper.config.data.augustusV6Address,
+            // insert 0 because it's still gonna be replaced with balance check result
+            '0',
+          ]),
+          swap.destToken,
+        );
+
+        swapCallData = hexConcat([
+          swapCallData,
+          approveWethCalldata,
+          depositCallData,
+          transferCallData,
+        ]);
+      }
+
       // send ETH to augustus
       if (
         isETHAddress(swap.destToken) &&
@@ -362,6 +443,7 @@ export class Executor03BytecodeBuilder extends ExecutorBytecodeBuilder<
     exchangeParams: DexExchangeBuildParam[],
     sender: string,
     maybeWethCallData?: DepositWithdrawReturn,
+    maybeWethCallDataForNeedUnwrapWeth?: DepositWithdrawReturn,
   ): string {
     const swap = priceRoute.bestRoute[0].swaps[0];
 
@@ -384,6 +466,7 @@ export class Executor03BytecodeBuilder extends ExecutorBytecodeBuilder<
       priceRoute,
       orderedExchangeParams.map(e => e.exchangeParam),
       maybeWethCallData,
+      maybeWethCallDataForNeedUnwrapWeth,
     );
 
     let swapsCalldata = orderedExchangeParams.reduce<string>(
@@ -397,6 +480,7 @@ export class Executor03BytecodeBuilder extends ExecutorBytecodeBuilder<
             flags,
             sender,
             maybeWethCallData,
+            maybeWethCallDataForNeedUnwrapWeth,
             swap: swapWithOrderedExchanges,
           }),
         ]),

package/src/executor/ExecutorBytecodeBuilder.ts

@@ -38,6 +38,7 @@ export type SingleSwapCallDataParams<T> = {
   flags: { approves: Flag[]; dexes: Flag[]; wrap: Flag };
   sender: string;
   maybeWethCallData?: DepositWithdrawReturn;
+  maybeWethCallDataForNeedUnwrapWeth?: DepositWithdrawReturn;
 } & T;
 
 export type DexCallDataParams<T> = {
@@ -67,6 +68,7 @@ export abstract class ExecutorBytecodeBuilder<S = {}, D = {}> {
     swapExchangeIndex: number,
     exchangeParamIndex: number,
     maybeWethCallData?: DepositWithdrawReturn,
+    maybeWethCallDataForNeedUnwrapWeth?: DepositWithdrawReturn,
   ): {
     dexFlag: Flag;
     approveFlag: Flag;
@@ -86,6 +88,7 @@ export abstract class ExecutorBytecodeBuilder<S = {}, D = {}> {
     swapExchangeIndex: number,
     exchangeParamIndex: number,
     maybeWethCallData?: DepositWithdrawReturn,
+    maybeWethCallDataForNeedUnwrapWeth?: DepositWithdrawReturn,
   ): {
     dexFlag: Flag;
     approveFlag: Flag;
@@ -102,6 +105,7 @@ export abstract class ExecutorBytecodeBuilder<S = {}, D = {}> {
     exchangeParams: DexExchangeBuildParam[],
     sender: string,
     maybeWethCallData?: DepositWithdrawReturn,
+    maybeWethCallDataForNeedUnwrapWeth?: DepositWithdrawReturn,
   ): string;
 
   public abstract getAddress(): string;
@@ -297,6 +301,7 @@ export abstract class ExecutorBytecodeBuilder<S = {}, D = {}> {
     priceRoute: OptimalRate,
     exchangeParams: DexExchangeBuildParam[],
     maybeWethCallData?: DepositWithdrawReturn,
+    maybeWethCallDataForNeedUnwrapWeth?: DepositWithdrawReturn,
   ): { approves: Flag[]; dexes: Flag[]; wrap: Flag } {
     const isMegaSwap = priceRoute.bestRoute.length > 1;
     const isMultiSwap = !isMegaSwap && priceRoute.bestRoute[0].swaps.length > 1;
@@ -323,6 +328,7 @@ export abstract class ExecutorBytecodeBuilder<S = {}, D = {}> {
             swapExchangeIndex,
             exchangeParamIndex,
             maybeWethCallData,
+            maybeWethCallDataForNeedUnwrapWeth,
           );
 
           flags.dexes.push(dexFlag);

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;
+  }
+}