@paraswap/dex-lib 2.36.3-dexalot → 2.36.3-sequential-preprocessing.0

package/src/dex/dexalot/dexalot.ts

@@ -1,935 +0,0 @@
-import {
-  Token,
-  Address,
-  ExchangePrices,
-  PoolPrices,
-  AdapterExchangeParam,
-  SimpleExchangeParam,
-  PoolLiquidity,
-  Logger,
-  ExchangeTxInfo,
-  OptimalSwapExchange,
-  PreprocessTransactionOptions,
-} from '../../types';
-import {
-  SwapSide,
-  Network,
-  ETHER_ADDRESS,
-  NULL_ADDRESS,
-} from '../../constants';
-import * as CALLDATA_GAS_COST from '../../calldata-gas-cost';
-import { getDexKeysWithNetwork, isAxiosError } from '../../utils';
-import { IDex } from '../idex';
-import { IDexHelper } from '../../dex-helper/idex-helper';
-import {
-  ClobSide,
-  DexalotData,
-  PairData,
-  PairDataMap,
-  PriceDataMap,
-  DexalotRfqError,
-  DexalotAPIParameters,
-  RFQResponse,
-  RFQResponseError,
-  TokenAddrDataMap,
-  TokenDataMap,
-} from './types';
-import { SlippageCheckError, TooStrictSlippageCheckError } from '../generic-rfq/types';
-import { SimpleExchange } from '../simple-exchange';
-import { Adapters, DexalotConfig } from './config';
-import { RateFetcher } from './rate-fetcher';
-import mainnetRFQAbi from '../../abi/dexalot/DexalotMainnetRFQ.json';
-import { Interface } from 'ethers/lib/utils';
-import { assert } from 'ts-essentials';
-import {
-  DEXALOT_API_URL,
-  DEXALOT_API_PRICES_POLLING_INTERVAL_MS,
-  DEXALOT_PRICES_CACHES_TTL_S,
-  DEXALOT_GAS_COST,
-  DEXALOT_PAIRS_CACHES_TTL_S,
-  DEXALOT_API_PAIRS_POLLING_INTERVAL_MS,
-  DEXALOT_TOKENS_CACHES_TTL_S,
-  DEXALOT_API_BLACKLIST_POLLING_INTERVAL_MS,
-  DEXALOT_RATE_LIMITED_TTL_S,
-  DEXALOT_MIN_SLIPPAGE_FACTOR_THRESHOLD_FOR_RESTRICTION,
-  DEXALOT_RESTRICTED_CACHE_KEY,
-  DEXALOT_RESTRICT_TTL_S,
-  DEXALOT_RATELIMIT_CACHE_VALUE,
-  DEXALOT_BLACKLIST_CACHES_TTL_S,
-} from './constants';
-import { BI_MAX_UINT256 } from '../../bigint-constants';
-import { ethers } from 'ethers';
-import BigNumber from 'bignumber.js';
-import { Method } from '../../dex-helper/irequest-wrapper';
-import { normalizeTokenAddress } from '../swaap-v2/utils';
-
-export class Dexalot extends SimpleExchange implements IDex<DexalotData> {
-  readonly isStatePollingDex = true;
-  readonly hasConstantPriceLargeAmounts = false;
-  readonly needWrapNative = false;
-  readonly isFeeOnTransferSupported = false;
-  private rateFetcher: RateFetcher;
-
-  private dexalotAuthToken: string;
-
-  private pricesCacheKey: string;
-  private pairsCacheKey: string;
-  private tokensAddrCacheKey: string;
-  private tokensCacheKey: string;
-  private blacklistCacheKey: string;
-  private tokensMap: TokenDataMap = {};
-
-  public static dexKeysWithNetwork: { key: string; networks: Network[] }[] =
-    getDexKeysWithNetwork(DexalotConfig);
-
-  logger: Logger;
-
-  constructor(
-    readonly network: Network,
-    readonly dexKey: string,
-    readonly dexHelper: IDexHelper,
-    protected adapters = Adapters[network] || {},
-    readonly mainnetRFQAddress: string = DexalotConfig['Dexalot'][network]
-      .mainnetRFQAddress,
-    protected rfqInterface = new Interface(mainnetRFQAbi),
-  ) {
-    super(dexHelper, dexKey);
-    this.logger = dexHelper.getLogger(dexKey);
-
-    const authToken = dexHelper.config.data.dexalotAuthToken;
-    assert(
-      authToken !== undefined,
-      'Dexalot auth token is not specified with env variable',
-    );
-    this.dexalotAuthToken = authToken;
-
-    this.pricesCacheKey = 'prices';
-    this.pairsCacheKey = 'pairs';
-    this.tokensAddrCacheKey = 'tokens_addr';
-    this.tokensCacheKey = 'tokens';
-    this.blacklistCacheKey = 'blacklist';
-
-    this.rateFetcher = new RateFetcher(
-      this.dexHelper,
-      this.dexKey,
-      this.network,
-      this.logger,
-      {
-        rateConfig: {
-          pairsIntervalMs: DEXALOT_API_PAIRS_POLLING_INTERVAL_MS,
-          pricesIntervalMs: DEXALOT_API_PRICES_POLLING_INTERVAL_MS,
-          blacklistIntervalMs: DEXALOT_API_BLACKLIST_POLLING_INTERVAL_MS,
-          pairsReqParams: this.getAPIReqParams('api/rfq/pairs', 'GET'),
-          pricesReqParams: this.getAPIReqParams('api/rfq/prices', 'GET'),
-          blacklistReqParams: this.getAPIReqParams('api/rfq/blacklist', 'GET'),
-          pairsCacheKey: this.pairsCacheKey,
-          pairsCacheTTLSecs: DEXALOT_PAIRS_CACHES_TTL_S,
-          pricesCacheKey: this.pricesCacheKey,
-          pricesCacheTTLSecs: DEXALOT_PRICES_CACHES_TTL_S,
-          tokensAddrCacheKey: this.tokensAddrCacheKey,
-          tokensCacheKey: this.tokensCacheKey,
-          tokensCacheTTLSecs: DEXALOT_TOKENS_CACHES_TTL_S,
-          blacklistCacheKey: this.blacklistCacheKey,
-          blacklistCacheTTLSecs: DEXALOT_BLACKLIST_CACHES_TTL_S,
-        },
-      },
-    );
-  }
-
-  async initializePricing(blockNumber: number): Promise<void> {
-    if (!this.dexHelper.config.isSlave) {
-      this.rateFetcher.start();
-    }
-
-    return;
-  }
-
-  getAdapters(side: SwapSide): { name: string; index: number }[] | null {
-    return this.adapters[side] ? this.adapters[side] : null;
-  }
-
-  getPairString(baseToken: Token, quoteToken: Token): string {
-    return `${baseToken.symbol}/${quoteToken.symbol}`.toLowerCase();
-  }
-
-  async getPairData(
-    srcToken: Token,
-    destToken: Token,
-  ): Promise<PairData | null> {
-    const normalizedSrcToken = this.normalizeToken(srcToken);
-    const normalizedDestToken = this.normalizeToken(destToken);
-    if (normalizedSrcToken.address === normalizedDestToken.address) {
-      return null;
-    }
-
-    const cachedTokens = (await this.getCachedTokens()) || {};
-    if (
-      !(normalizedSrcToken.address in cachedTokens) ||
-      !(normalizedDestToken.address in cachedTokens)
-    ) {
-      return null;
-    }
-    normalizedSrcToken.symbol = cachedTokens[normalizedSrcToken.address].symbol;
-    normalizedDestToken.symbol =
-      cachedTokens[normalizedDestToken.address].symbol;
-
-    const cachedPairs = (await this.getCachedPairs()) || {};
-
-    const potentialPairs = [
-      {
-        identifier: this.getPairString(normalizedSrcToken, normalizedDestToken),
-        isSrcBase: true,
-      },
-      {
-        identifier: this.getPairString(normalizedDestToken, normalizedSrcToken),
-        isSrcBase: false,
-      },
-    ];
-
-    for (const pair of potentialPairs) {
-      if (pair.identifier in cachedPairs) {
-        const pairData = cachedPairs[pair.identifier];
-        pairData.isSrcBase = pair.isSrcBase;
-        return pairData;
-      }
-    }
-    return null;
-  }
-
-  getIdentifier(baseSymbol: string, quoteSymbol: string) {
-    // return `${this.dexKey}_${baseSymbol}_${quoteSymbol}`.toLowerCase();
-    // To disable Dexalot in multi/mega routes
-    return this.dexKey;
-  }
-
-  async getPoolIdentifiers(
-    srcToken: Token,
-    destToken: Token,
-    side: SwapSide,
-    blockNumber: number,
-  ): Promise<string[]> {
-    if (!srcToken || !destToken) {
-      return [];
-    }
-    const pairData = await this.getPairData(srcToken, destToken);
-    if (!pairData) {
-      return [];
-    }
-    return [this.getIdentifier(pairData.base, pairData.quote)];
-  }
-
-  async getCachedPairs(): Promise<PairDataMap | null> {
-    const cachedPairs = await this.dexHelper.cache.get(
-      this.dexKey,
-      this.network,
-      this.pairsCacheKey,
-    );
-
-    if (cachedPairs) {
-      return JSON.parse(cachedPairs) as PairDataMap;
-    }
-
-    return null;
-  }
-
-  async getCachedPrices(): Promise<PriceDataMap | null> {
-    const cachedPrices = await this.dexHelper.cache.get(
-      this.dexKey,
-      this.network,
-      this.pricesCacheKey,
-    );
-
-    if (cachedPrices) {
-      return JSON.parse(cachedPrices) as PriceDataMap;
-    }
-
-    return null;
-  }
-
-  async getCachedTokensAddr(): Promise<TokenAddrDataMap | null> {
-    const cachedTokensAddr = await this.dexHelper.cache.get(
-      this.dexKey,
-      this.network,
-      this.tokensAddrCacheKey,
-    );
-
-    if (cachedTokensAddr) {
-      return JSON.parse(cachedTokensAddr) as TokenAddrDataMap;
-    }
-
-    return null;
-  }
-
-  async getCachedTokens(): Promise<TokenDataMap | null> {
-    const cachedTokens = await this.dexHelper.cache.get(
-      this.dexKey,
-      this.network,
-      this.tokensCacheKey,
-    );
-
-    if (cachedTokens) {
-      return JSON.parse(cachedTokens) as TokenDataMap;
-    }
-
-    return null;
-  }
-
-  normalizeAddress(address: string): string {
-    return address.toLowerCase() === ETHER_ADDRESS
-      ? NULL_ADDRESS
-      : address.toLowerCase();
-  }
-
-  denormalizeAddress(address: string): string {
-    return address.toLowerCase() === NULL_ADDRESS
-      ? ETHER_ADDRESS
-      : address.toLowerCase();
-  }
-
-  // Dexalot protocol for native token expects 0x00000... instead of 0xeeeee...
-  normalizeToken(token: Token): Token {
-    return {
-      address: this.normalizeAddress(token.address),
-      decimals: token.decimals,
-    };
-  }
-
-  denormalizeToken(token: Token): Token {
-    return {
-      address: this.denormalizeAddress(token.address),
-      decimals: token.decimals,
-    };
-  }
-
-  calculateOrderPrice(
-    amounts: bigint[],
-    orderbook: string[][],
-    baseToken: Token,
-    quoteToken: Token,
-    side: ClobSide,
-  ) {
-    let result = [];
-
-    for (let i = 0; i < amounts.length; i++) {
-      let amt = amounts[i];
-      if (amt === 0n) {
-        result.push(amt);
-        continue;
-      }
-
-      let totalVolume = 0n;
-      let combinedPrice = 0n;
-
-      for (let j = 0; j < orderbook.length; j++) {
-        const order = orderbook[j];
-        const priceBN = ethers.utils.parseUnits(order[0], quoteToken.decimals);
-        const price = BigInt(priceBN.toString());
-        const qtyBN = ethers.utils.parseUnits(order[1], baseToken.decimals);
-        const qty = BigInt(qtyBN.toString());
-        let vol = qty;
-        if (side === ClobSide.BID) {
-          vol = (qty * price) / BigInt(10 ** baseToken.decimals);
-        }
-        if (amt < vol) {
-          totalVolume += amt;
-          combinedPrice += amt * price;
-          amt = 0n;
-        } else {
-          amt -= vol;
-          totalVolume += vol;
-          combinedPrice += vol * price;
-        }
-        if (amt === 0n) {
-          break;
-        }
-      }
-      if (amt > 0n) {
-        return result;
-      }
-      const avgPrice = combinedPrice / totalVolume;
-      if (side === ClobSide.BID) {
-        result.push((amounts[i] * BigInt(10 ** baseToken.decimals)) / avgPrice);
-      } else {
-        result.push((avgPrice * amounts[i]) / BigInt(10 ** baseToken.decimals));
-      }
-    }
-    return result;
-  }
-
-  async getPricesVolume(
-    srcToken: Token,
-    destToken: Token,
-    amounts: bigint[],
-    side: SwapSide,
-    blockNumber: number,
-    limitPools?: string[],
-  ): Promise<null | ExchangePrices<DexalotData>> {
-    try {
-      if (await this.isRestricted()) {
-        return null;
-      }
-
-      const normalizedSrcToken = this.normalizeToken(srcToken);
-      const normalizedDestToken = this.normalizeToken(destToken);
-
-      this.tokensMap = (await this.getCachedTokens()) || {};
-      if (normalizedSrcToken.address === normalizedDestToken.address) {
-        return null;
-      }
-
-      if (limitPools && limitPools.length !== 1) {
-        return null;
-      }
-
-      const pairData = await this.getPairData(
-        normalizedSrcToken,
-        normalizedDestToken,
-      );
-      if (!pairData) {
-        return null;
-      }
-
-      const priceMap = await this.getCachedPrices();
-      if (!priceMap) {
-        return null;
-      }
-
-      const pairKey = `${pairData.base}/${pairData.quote}`.toLowerCase();
-      if (!(pairKey in priceMap)) {
-        return null;
-      }
-
-      const priceData = priceMap[pairKey];
-      const baseToken = pairData.isSrcBase
-        ? normalizedSrcToken
-        : normalizedDestToken;
-      const quoteToken = pairData.isSrcBase
-        ? normalizedDestToken
-        : normalizedSrcToken;
-
-      // convert from swap to clob side
-      let orderbook = priceData.asks;
-      let clobSide = ClobSide.BID;
-      if (
-        (side === SwapSide.SELL && pairData.isSrcBase) ||
-        (side === SwapSide.BUY && !pairData.isSrcBase)
-      ) {
-        orderbook = priceData.bids;
-        clobSide = ClobSide.ASK;
-      }
-      if (orderbook.length === 0) {
-        throw new Error(`Empty orderbook for ${pairKey}`);
-      }
-
-      const prices = this.calculateOrderPrice(
-        amounts,
-        orderbook,
-        baseToken,
-        quoteToken,
-        clobSide,
-      );
-      const outDecimals =
-        clobSide === ClobSide.BID ? baseToken.decimals : quoteToken.decimals;
-      const poolIdentifier = this.getIdentifier(pairData.base, pairData.quote);
-
-      return [
-        {
-          prices,
-          unit: BigInt(outDecimals),
-          data: {},
-          poolIdentifier: poolIdentifier,
-          exchange: this.dexKey,
-          gasCost: DEXALOT_GAS_COST,
-          poolAddresses: [this.mainnetRFQAddress],
-        },
-      ];
-    } catch (e: unknown) {
-      this.logger.error(
-        `Error_getPricesVolume ${srcToken.symbol || srcToken.address}, ${
-          destToken.symbol || destToken.address
-        }, ${side}:`,
-        e,
-      );
-      return null;
-    }
-  }
-
-  generateRFQError(errorStr: string, swapIdentifier: string) {
-    const message = `${this.dexKey}-${this.network}: Failed to fetch RFQ for ${swapIdentifier}. ${errorStr}`;
-    this.logger.warn(message);
-    throw new DexalotRfqError(message);
-  }
-
-  async preProcessTransaction(
-    optimalSwapExchange: OptimalSwapExchange<DexalotData>,
-    srcToken: Token,
-    destToken: Token,
-    side: SwapSide,
-    options: PreprocessTransactionOptions,
-  ): Promise<[OptimalSwapExchange<DexalotData>, ExchangeTxInfo]> {
-    if (await this.isBlacklisted(options.txOrigin)) {
-      this.logger.warn(
-        `${this.dexKey}-${this.network}: blacklisted TX Origin address '${options.txOrigin}' trying to build a transaction. Bailing...`,
-      );
-      throw new Error(
-        `${this.dexKey}-${
-          this.network
-        }: user=${options.txOrigin.toLowerCase()} is blacklisted`,
-      );
-    }
-    if (await this.isRateLimited(options.txOrigin)) {
-      this.logger.warn(
-        `${this.dexKey}-${this.network}: rate limited TX Origin address '${options.txOrigin}' trying to build a transaction. Bailing...`,
-      );
-      throw new Error(
-        `${this.dexKey}-${
-          this.network
-        }: user=${options.txOrigin.toLowerCase()} is rate limited`,
-      );
-    }
-    if (BigInt(optimalSwapExchange.srcAmount) === 0n) {
-      throw new Error('getFirmRate failed with srcAmount === 0');
-    }
-
-    const normalizedSrcToken = this.normalizeToken(srcToken);
-    const normalizedDestToken = this.normalizeToken(destToken);
-    const swapIdentifier = `${this.getIdentifier(
-      normalizedSrcToken.address,
-      normalizedDestToken.address,
-    )}_${side}`;
-
-    try {
-      const makerToken = normalizedDestToken;
-      const takerToken = normalizedSrcToken;
-
-      const rfqParams = {
-        makerAsset: ethers.utils.getAddress(makerToken.address),
-        takerAsset: ethers.utils.getAddress(takerToken.address),
-        makerAmount:
-          side === SwapSide.BUY ? optimalSwapExchange.destAmount : undefined,
-        takerAmount:
-          side === SwapSide.SELL ? optimalSwapExchange.srcAmount : undefined,
-        userAddress: options.txOrigin,
-        chainid: this.network,
-      };
-
-      const rfq: RFQResponse = await this.dexHelper.httpRequest.post(
-        `${DEXALOT_API_URL}/api/rfq/firm`,
-        rfqParams,
-        undefined,
-        { 'x-apikey': this.dexalotAuthToken },
-      );
-      if (!rfq) {
-        this.generateRFQError(
-          'Missing quote data',
-          `RFQ ${swapIdentifier} ${JSON.stringify(rfq)}`,
-        );
-      } else if (!rfq.signature) {
-        this.generateRFQError('Missing signature', swapIdentifier);
-      }
-      rfq.order.signature = rfq.signature;
-
-      const { order } = rfq;
-
-      assert(
-        order.makerAsset.toLowerCase() === makerToken.address,
-        `QuoteData makerAsset=${order.makerAsset} is different from Paraswap makerAsset=${makerToken.address}`,
-      );
-      assert(
-        order.takerAsset.toLowerCase() === takerToken.address,
-        `QuoteData takerAsset=${order.takerAsset} is different from Paraswap takerAsset=${takerToken.address}`,
-      );
-      if (side === SwapSide.SELL) {
-        assert(
-          order.takerAmount === optimalSwapExchange.srcAmount,
-          `QuoteData takerAmount=${order.takerAmount} is different from Paraswap srcAmount=${optimalSwapExchange.srcAmount}`,
-        );
-      } else {
-        assert(
-          order.makerAmount === optimalSwapExchange.destAmount,
-          `QuoteData makerAmount=${order.makerAmount} is different from Paraswap destAmount=${optimalSwapExchange.destAmount}`,
-        );
-      }
-
-      const expiryAsBigInt = BigInt(order.expiry);
-      const minDeadline = expiryAsBigInt > 0 ? expiryAsBigInt : BI_MAX_UINT256;
-
-      const slippageFactor = options.slippageFactor;
-      let isFailOnSlippage = false;
-      let slippageErrorMessage = '';
-
-      if (side === SwapSide.SELL) {
-        if (
-          BigInt(order.makerAmount) <
-          BigInt(
-            new BigNumber(optimalSwapExchange.destAmount.toString())
-              .times(slippageFactor)
-              .toFixed(0),
-          )
-        ) {
-          isFailOnSlippage = true;
-          const message = `${this.dexKey}-${this.network}: too much slippage on quote ${side} quoteTokenAmount ${order.makerAmount} / destAmount ${optimalSwapExchange.destAmount} < ${slippageFactor}`;
-          slippageErrorMessage = message;
-          this.logger.warn(message);
-        }
-      } else {
-        if (
-          BigInt(order.takerAmount) >
-          BigInt(slippageFactor.times(optimalSwapExchange.srcAmount.toString()).toFixed(0))
-        ) {
-          isFailOnSlippage = true;
-          const message = `${this.dexKey}-${
-            this.network
-          }: too much slippage on quote ${side} baseTokenAmount ${order.takerAmount} / srcAmount ${optimalSwapExchange.srcAmount} > ${slippageFactor.toFixed()}`;
-          slippageErrorMessage = message;
-          this.logger.warn(message);
-        }
-      }
-
-      let isTooStrictSlippage = false;
-      if (
-        isFailOnSlippage &&
-        side === SwapSide.SELL &&
-        new BigNumber(1)
-          .minus(slippageFactor)
-          .lt(DEXALOT_MIN_SLIPPAGE_FACTOR_THRESHOLD_FOR_RESTRICTION)
-      ) {
-        isTooStrictSlippage = true;
-      } else if (
-        isFailOnSlippage &&
-        side === SwapSide.BUY &&
-        slippageFactor
-          .minus(1)
-          .lt(DEXALOT_MIN_SLIPPAGE_FACTOR_THRESHOLD_FOR_RESTRICTION)
-      ) {
-        isTooStrictSlippage = true;
-      }
-
-      if (isFailOnSlippage && isTooStrictSlippage) {
-        throw new TooStrictSlippageCheckError(slippageErrorMessage);
-      } else if (isFailOnSlippage && !isTooStrictSlippage) {
-        throw new SlippageCheckError(slippageErrorMessage);
-      }
-
-      return [
-        {
-          ...optimalSwapExchange,
-          data: {
-            quoteData: order,
-          },
-        },
-        { deadline: minDeadline },
-      ];
-    } catch (e) {
-      if (isAxiosError(e) && e.response && e.response.data) {
-        const errorData: RFQResponseError = e.response.data;
-        if (errorData.ReasonCode === 'FQ-009') {
-          this.logger.warn(
-            `${this.dexKey}-${this.network}: Encountered rate limited user=${options.txOrigin}. Adding to local rate limit cache`,
-          );
-          await this.setRateLimited(options.txOrigin, errorData.RetryAfter);
-        } else {
-          await this.setBlacklist(options.txOrigin);
-          this.logger.error(
-            `${this.dexKey}-${this.network}: Failed to fetch RFQ for ${swapIdentifier}: ${errorData.Reason}`,
-          );
-        }
-      } else {
-        if(e instanceof TooStrictSlippageCheckError) {
-          this.logger.warn(
-            `${this.dexKey}-${this.network}: failed to build transaction on side ${side} with too strict slippage. Skipping restriction`,
-          );
-        } else {
-          this.logger.warn(
-            `${this.dexKey}-${this.network}: protocol is restricted`,
-          );
-          await this.restrict();
-        }
-      }
-
-      throw e;
-    }
-  }
-
-  getCalldataGasCost(poolPrices: PoolPrices<DexalotData>): number | number[] {
-    return (
-      CALLDATA_GAS_COST.DEX_OVERHEAD +
-      // addresses: makerAsset, takerAsset, maker, taker
-      CALLDATA_GAS_COST.ADDRESS * 4 +
-      // uint256: expiry
-      CALLDATA_GAS_COST.wordNonZeroBytes(16) +
-      // uint256: nonceAndMeta, makerAmount, takerAmount
-      CALLDATA_GAS_COST.AMOUNT * 3 +
-      // bytes: _signature (65 bytes)
-      CALLDATA_GAS_COST.FULL_WORD * 2 +
-      CALLDATA_GAS_COST.OFFSET_SMALL
-    );
-  }
-
-  getTokenFromAddress(address: Address): Token {
-    return this.tokensMap[this.normalizeAddress(address)];
-  }
-
-  getAdapterParam(
-    srcToken: string,
-    destToken: string,
-    srcAmount: string,
-    destAmount: string,
-    data: DexalotData,
-    side: SwapSide,
-  ): AdapterExchangeParam {
-    const { quoteData } = data;
-
-    assert(
-      quoteData !== undefined,
-      `${this.dexKey}-${this.network}: quoteData undefined`,
-    );
-
-    const params = [
-      {
-        nonceAndMeta: quoteData.nonceAndMeta,
-        expiry: quoteData.expiry,
-        makerAsset: quoteData.makerAsset,
-        takerAsset: quoteData.takerAsset,
-        maker: quoteData.maker,
-        taker: quoteData.taker,
-        makerAmount: quoteData.makerAmount,
-        takerAmount: quoteData.takerAmount,
-      },
-      quoteData.signature,
-    ];
-
-    const payload = this.abiCoder.encodeParameter(
-      {
-        ParentStruct: {
-          order: {
-            nonceAndMeta: 'uint256',
-            expiry: 'uint128',
-            makerAsset: 'address',
-            takerAsset: 'address',
-            maker: 'address',
-            taker: 'address',
-            makerAmount: 'uint256',
-            takerAmount: 'uint256',
-          },
-          signature: 'bytes',
-        },
-      },
-      {
-        order: params[0],
-        signature: params[1],
-      },
-    );
-
-    return {
-      targetExchange: this.mainnetRFQAddress,
-      payload,
-      networkFee: '0',
-    };
-  }
-
-  async restrict(ttl: number = DEXALOT_RESTRICT_TTL_S): Promise<boolean> {
-    await this.dexHelper.cache.setex(
-      this.dexKey,
-      this.network,
-      DEXALOT_RESTRICTED_CACHE_KEY,
-      ttl,
-      'true',
-    );
-    return true;
-  }
-
-  async isRestricted(): Promise<boolean> {
-    const result = await this.dexHelper.cache.get(
-      this.dexKey,
-      this.network,
-      DEXALOT_RESTRICTED_CACHE_KEY,
-    );
-
-    return result === 'true';
-  }
-
-  async setBlacklist(txOrigin: Address, ttl: number = DEXALOT_BLACKLIST_CACHES_TTL_S,): Promise<boolean> {
-    const cachedBlacklist = await this.dexHelper.cache.get(
-      this.dexKey,
-      this.network,
-      this.blacklistCacheKey,
-    );
-
-    let blacklist: string[] = [];
-    if (cachedBlacklist) {
-      blacklist = JSON.parse(cachedBlacklist);
-    }
-
-    blacklist.push(txOrigin.toLowerCase());
-
-    this.dexHelper.cache.setex(
-      this.dexKey,
-      this.network,
-      this.blacklistCacheKey,
-      ttl,
-      JSON.stringify(blacklist),
-    );
-
-    return true;
-  }
-
-  async isBlacklisted(txOrigin: Address): Promise<boolean> {
-    const cachedBlacklist = await this.dexHelper.cache.get(
-      this.dexKey,
-      this.network,
-      this.blacklistCacheKey,
-    );
-
-    if (cachedBlacklist) {
-      const blacklist = JSON.parse(cachedBlacklist) as string[];
-      return blacklist.includes(txOrigin.toLowerCase());
-    }
-
-    return false;
-  }
-
-  getRateLimitedKey(address: Address) {
-    return `rate_limited_${address}`.toLowerCase();
-  }
-
-  async isRateLimited(txOrigin: Address): Promise<boolean> {
-    const result = await this.dexHelper.cache.get(
-      this.dexKey,
-      this.network,
-      this.getRateLimitedKey(txOrigin),
-    );
-    return result === DEXALOT_RATELIMIT_CACHE_VALUE;
-  }
-
-  async setRateLimited(txOrigin: Address, ttl = DEXALOT_RATE_LIMITED_TTL_S) {
-    await this.dexHelper.cache.setex(
-      this.dexKey,
-      this.network,
-      this.getRateLimitedKey(txOrigin),
-      ttl,
-      DEXALOT_RATELIMIT_CACHE_VALUE,
-    );
-    return true;
-  }
-
-  async getSimpleParam(
-    srcToken: string,
-    destToken: string,
-    srcAmount: string,
-    destAmount: string,
-    data: DexalotData,
-    side: SwapSide,
-  ): Promise<SimpleExchangeParam> {
-    const { quoteData } = data;
-
-    assert(
-      quoteData !== undefined,
-      `${this.dexKey}-${this.network}: quoteData undefined`,
-    );
-
-    const swapFunction = 'simpleSwap';
-    const swapFunctionParams = [
-      [
-        quoteData.nonceAndMeta,
-        quoteData.expiry,
-        quoteData.makerAsset,
-        quoteData.takerAsset,
-        quoteData.maker,
-        quoteData.taker,
-        quoteData.makerAmount,
-        quoteData.takerAmount,
-      ],
-      quoteData.signature,
-    ];
-
-    const swapData = this.rfqInterface.encodeFunctionData(
-      swapFunction,
-      swapFunctionParams,
-    );
-
-    return this.buildSimpleParamWithoutWETHConversion(
-      srcToken,
-      srcAmount,
-      destToken,
-      destAmount,
-      swapData,
-      this.mainnetRFQAddress,
-    );
-  }
-
-  async getTopPoolsForToken(
-    tokenAddress: Address,
-    limit: number,
-  ): Promise<PoolLiquidity[]> {
-    if (await this.isRestricted()) {
-      return [];
-    }
-
-    const normalizedTokenAddress = normalizeTokenAddress(tokenAddress);
-    const pairs = (await this.getCachedPairs()) || {};
-    this.tokensMap = (await this.getCachedTokens()) || {};
-    const tokensAddr = (await this.getCachedTokensAddr()) || {};
-    const token = this.getTokenFromAddress(normalizedTokenAddress);
-    if (!token) {
-      return [];
-    }
-
-    const tokenSymbol = token.symbol?.toLowerCase() || '';
-
-    let pairsByLiquidity = [];
-    for (const pairName of Object.keys(pairs)) {
-      if (!pairName.includes(tokenSymbol)) {
-        continue;
-      }
-
-      const tokensInPair = pairName.split('/');
-      if (tokensInPair.length !== 2) {
-        continue;
-      }
-
-      const [ baseToken, quoteToken ] = tokensInPair;
-      const addr = tokensAddr[baseToken.toLowerCase()];
-      let outputToken = this.getTokenFromAddress(addr);
-      if (baseToken === tokenSymbol) {
-        const addr = tokensAddr[quoteToken.toLowerCase()];
-        outputToken = this.getTokenFromAddress(addr);
-      }
-
-      const denormalizedToken = this.denormalizeToken(outputToken);
-
-      pairsByLiquidity.push({
-        exchange: this.dexKey,
-        address: this.mainnetRFQAddress,
-        connectorTokens: [{
-          address: denormalizedToken.address,
-          decimals: denormalizedToken.decimals,
-        }],
-        liquidityUSD: pairs[pairName].liquidityUSD,
-      });
-    }
-
-    pairsByLiquidity.sort(
-      (a: PoolLiquidity, b: PoolLiquidity) => b.liquidityUSD - a.liquidityUSD,
-    );
-
-    return pairsByLiquidity.slice(0, limit);
-  }
-
-  getAPIReqParams(endpoint: string, method: Method): DexalotAPIParameters {
-    return {
-      url: `${DEXALOT_API_URL}/${endpoint}`,
-      headers: { 'x-apikey': this.dexalotAuthToken },
-      params: {
-        chainid: this.network,
-      },
-      method: method,
-    };
-  }
-
-  releaseResources(): void {
-    if (this.rateFetcher) {
-      this.rateFetcher.stop();
-    }
-  }
-}