@paraswap/dex-lib 4.0.0 → 4.0.1-cables.0

package/src/dex/cables/cables.ts

@@ -0,0 +1,888 @@
+import {
+  Address,
+  NumberAsString,
+  OptimalSwapExchange,
+  SwapSide,
+} from '@paraswap/core';
+import { assert, AsyncOrSync } from 'ts-essentials';
+import * as CALLDATA_GAS_COST from '../../calldata-gas-cost';
+import { ETHER_ADDRESS, Network, NULL_ADDRESS } from '../../constants';
+import { IDexHelper } from '../../dex-helper';
+import {
+  AdapterExchangeParam,
+  DexExchangeParam,
+  ExchangePrices,
+  ExchangeTxInfo,
+  Logger,
+  PoolLiquidity,
+  PoolPrices,
+  PreprocessTransactionOptions,
+  Token,
+  TransferFeeParams,
+} from '../../types';
+import { getDexKeysWithNetwork, Utils } from '../../utils';
+import { IDex } from '../idex';
+import { SimpleExchange } from '../simple-exchange';
+import { CablesConfig } from './config';
+import {
+  CABLES_API_BLACKLIST_POLLING_INTERVAL_MS,
+  CABLES_API_PAIRS_POLLING_INTERVAL_MS,
+  CABLES_API_PRICES_POLLING_INTERVAL_MS,
+  CABLES_API_TOKENS_POLLING_INTERVAL_MS,
+  CABLES_API_URL,
+  CABLES_BLACKLIST_CACHE_KEY,
+  CABLES_BLACKLIST_CACHES_TTL_S,
+  CABLES_ERRORS_CACHE_KEY,
+  CABLES_FIRM_QUOTE_TIMEOUT_MS,
+  CABLES_GAS_COST,
+  CABLES_PAIRS_CACHES_TTL_S,
+  CABLES_PRICES_CACHES_TTL_S,
+  CABLES_RESTRICT_CHECK_INTERVAL_MS,
+  CABLES_RESTRICT_COUNT_THRESHOLD,
+  CABLES_RESTRICT_TTL_S,
+  CABLES_RESTRICTED_CACHE_KEY,
+  CABLES_TOKENS_CACHES_TTL_S,
+} from './constants';
+import { CablesRateFetcher } from './rate-fetcher';
+import {
+  CablesData,
+  CablesRFQResponse,
+  RestrictData,
+  SlippageError,
+} from './types';
+import mainnetRFQAbi from '../../abi/cables/CablesMainnetRFQ.json';
+import { Interface } from 'ethers/lib/utils';
+import BigNumber from 'bignumber.js';
+import { ethers } from 'ethers';
+import { BI_MAX_UINT256 } from '../../bigint-constants';
+import { SpecialDex } from '../../executor/types';
+
+export class Cables extends SimpleExchange implements IDex<any> {
+  public static dexKeysWithNetwork: { key: string; networks: Network[] }[] =
+    getDexKeysWithNetwork(CablesConfig);
+
+  readonly isStatePollingDex = true;
+
+  private rateFetcher: CablesRateFetcher;
+
+  logger: Logger;
+  private tokensMap: { [address: string]: Token } = {};
+
+  hasConstantPriceLargeAmounts: boolean = false;
+
+  constructor(
+    readonly network: Network,
+    readonly dexKey: string,
+    readonly dexHelper: IDexHelper,
+    readonly mainnetRFQAddress: string = CablesConfig['Cables'][network]
+      .mainnetRFQAddress,
+    protected rfqInterface = new Interface(mainnetRFQAbi),
+  ) {
+    super(dexHelper, dexKey);
+    this.logger = dexHelper.getLogger(dexKey);
+
+    this.rateFetcher = new CablesRateFetcher(
+      this.dexHelper,
+      this.dexKey,
+      this.network,
+      this.logger,
+      {
+        rateConfig: {
+          pairsReqParams: {
+            url: CABLES_API_URL + '/pairs',
+          },
+          pricesReqParams: {
+            url: CABLES_API_URL + '/prices',
+          },
+          blacklistReqParams: {
+            url: CABLES_API_URL + '/blacklist',
+          },
+          tokensReqParams: {
+            url: CABLES_API_URL + '/tokens',
+          },
+
+          pricesIntervalMs: CABLES_API_PRICES_POLLING_INTERVAL_MS,
+          pricesCacheTTLSecs: CABLES_PRICES_CACHES_TTL_S,
+          pricesCacheKey: 'prices',
+
+          pairsIntervalMs: CABLES_API_PAIRS_POLLING_INTERVAL_MS,
+          pairsCacheTTLSecs: CABLES_PAIRS_CACHES_TTL_S,
+          pairsCacheKey: 'pairs',
+
+          tokensIntervalMs: CABLES_API_TOKENS_POLLING_INTERVAL_MS,
+          tokensCacheTTLSecs: CABLES_TOKENS_CACHES_TTL_S,
+          tokensCacheKey: 'tokens',
+
+          blacklistIntervalMs: CABLES_API_BLACKLIST_POLLING_INTERVAL_MS,
+          blacklistCacheTTLSecs: CABLES_BLACKLIST_CACHES_TTL_S,
+          blacklistCacheKey: CABLES_BLACKLIST_CACHE_KEY,
+
+          tokensHandleResponseCallback: async () => {
+            await this.setTokensMap();
+          },
+        },
+      },
+    );
+  }
+
+  async preProcessTransaction?(
+    optimalSwapExchange: OptimalSwapExchange<CablesData>,
+    srcToken: Token,
+    destToken: Token,
+    side: SwapSide,
+    options: PreprocessTransactionOptions,
+  ): Promise<[OptimalSwapExchange<CablesData>, 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 (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.dexKey}_${normalizedSrcToken.address}_${normalizedDestToken.address}_${side}`;
+
+    try {
+      let makerToken = normalizedDestToken;
+      let takerToken = normalizedSrcToken;
+
+      const isSell = side === SwapSide.SELL;
+      const isBuy = side === SwapSide.BUY;
+
+      const rfqParams = {
+        makerAsset: ethers.utils.getAddress(makerToken.address),
+        takerAsset: ethers.utils.getAddress(takerToken.address),
+        ...(isBuy && { makerAmount: optimalSwapExchange.destAmount }),
+        ...(isSell && { takerAmount: optimalSwapExchange.srcAmount }),
+        userAddress: options.executionContractAddress,
+        chainId: String(this.network),
+      };
+
+      const rfq: CablesRFQResponse = await this.dexHelper.httpRequest.post(
+        `${CABLES_API_URL}/quote`,
+        rfqParams,
+        CABLES_FIRM_QUOTE_TIMEOUT_MS,
+      );
+
+      if (!rfq) {
+        throw new Error(
+          'Failed to fetch RFQ' +
+            swapIdentifier +
+            JSON.stringify(rfq + 'params' + rfqParams),
+        );
+      }
+
+      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 (isSell) {
+        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;
+
+      if (side === SwapSide.BUY) {
+        const requiredAmount = BigInt(optimalSwapExchange.srcAmount);
+        const quoteAmount = BigInt(order.takerAmount);
+        const requiredAmountWithSlippage = new BigNumber(
+          requiredAmount.toString(),
+        )
+          .multipliedBy(options.slippageFactor)
+          .toFixed(0);
+        if (quoteAmount > BigInt(requiredAmountWithSlippage)) {
+          throw new SlippageError(
+            `Slipped, factor: ${quoteAmount.toString()} > ${requiredAmountWithSlippage}`,
+          );
+        }
+      } else {
+        const requiredAmount = BigInt(optimalSwapExchange.destAmount);
+        const quoteAmount = BigInt(order.makerAmount);
+        const requiredAmountWithSlippage = new BigNumber(
+          requiredAmount.toString(),
+        )
+          .multipliedBy(options.slippageFactor)
+          .toFixed(0);
+        if (quoteAmount < BigInt(requiredAmountWithSlippage)) {
+          throw new SlippageError(
+            `Slipped, factor: ${
+              options.slippageFactor
+            } ${quoteAmount.toString()} < ${requiredAmountWithSlippage}`,
+          );
+        }
+      }
+
+      return [
+        {
+          ...optimalSwapExchange,
+          data: {
+            quoteData: order,
+          },
+        },
+        { deadline: minDeadline },
+      ];
+    } catch (e: any) {
+      const message = `${this.dexKey}-${this.network}: ${e}`;
+      this.logger.error(message);
+      if (!e?.isSlippageError) {
+        this.restrict();
+      }
+      throw new Error(message);
+    }
+  }
+
+  getDexParam(
+    srcToken: Address,
+    destToken: Address,
+    srcAmount: NumberAsString,
+    destAmount: NumberAsString,
+    recipient: Address,
+    data: CablesData,
+    side: SwapSide,
+  ): DexExchangeParam {
+    const { quoteData } = data;
+
+    assert(
+      quoteData !== undefined,
+      `${this.dexKey}-${this.network}: quoteData undefined`,
+    );
+
+    const swapFunction = 'partialSwap';
+    const swapFunctionParams = [
+      [
+        quoteData.nonceAndMeta,
+        quoteData.expiry,
+        quoteData.makerAsset,
+        quoteData.takerAsset,
+        quoteData.maker,
+        quoteData.taker,
+        quoteData.makerAmount,
+        quoteData.takerAmount,
+      ],
+      quoteData.signature,
+      // might be overwritten on Executors
+      quoteData.takerAmount,
+    ];
+
+    const exchangeData = this.rfqInterface.encodeFunctionData(
+      swapFunction,
+      swapFunctionParams,
+    );
+
+    const fromAmount = ethers.utils.defaultAbiCoder.encode(
+      ['uint256'],
+      [quoteData.takerAmount],
+    );
+
+    const filledAmountIndex = exchangeData
+      .replace('0x', '')
+      .lastIndexOf(fromAmount.replace('0x', ''));
+
+    const filledAmountPos =
+      (filledAmountIndex !== -1 ? filledAmountIndex : exchangeData.length) / 2;
+
+    return {
+      exchangeData,
+      needWrapNative: this.needWrapNative,
+      dexFuncHasRecipient: false,
+      targetExchange: this.mainnetRFQAddress,
+      returnAmountPos: undefined,
+      insertFromAmountPos: filledAmountPos,
+    };
+  }
+
+  getAdapterParam(
+    srcToken: string,
+    destToken: string,
+    srcAmount: string,
+    destAmount: string,
+    data: CablesData,
+    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',
+    };
+  }
+
+  normalizeToken(token: Token): Token {
+    return {
+      ...token,
+      address: this.normalizeTokenAddress(token.address),
+    };
+  }
+
+  normalizeTokenAddress(address: Address): Address {
+    return address.toLowerCase();
+  }
+
+  getTokenFromAddress(address: Address): Token {
+    return this.tokensMap[this.normalizeAddress(address)];
+  }
+
+  getPoolIdentifier(srcAddress: Address, destAddress: Address, mm?: string) {
+    return `${this.dexKey}_${srcAddress}_${destAddress}`.toLowerCase();
+    return `${this.dexKey}_${srcAddress}_${destAddress}_${mm}`.toLowerCase();
+  }
+
+  async getPoolIdentifiers(
+    srcToken: Token,
+    destToken: Token,
+    side: SwapSide,
+    blockNumber: number,
+  ): Promise<string[]> {
+    await this.setTokensMap();
+
+    if (!srcToken || !destToken) {
+      return [];
+    }
+
+    if (srcToken.address.toLowerCase() === destToken.address.toLowerCase()) {
+      return [];
+    }
+
+    const pairData = await this.getPairData(srcToken, destToken);
+
+    if (!pairData) {
+      return [];
+    }
+
+    const tokensAddr = (await this.getCachedTokensAddr()) || {};
+
+    return [
+      this.getPoolIdentifier(
+        tokensAddr[pairData.base.toLowerCase()],
+        tokensAddr[pairData.quote.toLowerCase()],
+      ),
+    ];
+  }
+
+  calculateOrderPrice(
+    amounts: bigint[],
+    orderbook: string[][],
+    baseToken: Token,
+    quoteToken: Token,
+    isInputQuote: boolean,
+  ) {
+    let result = [];
+
+    for (let i = 0; i < amounts.length; i++) {
+      let amt = amounts[i];
+      if (amt === 0n) {
+        result.push(amt);
+        continue;
+      }
+
+      let decimals = baseToken.decimals;
+      let out_decimals = quoteToken.decimals;
+
+      let price = this.calculatePriceSwap(
+        orderbook,
+        Number(amt) / 10 ** decimals,
+        isInputQuote,
+      );
+      result.push(BigInt(Math.round(price * 10 ** out_decimals)));
+    }
+    return result;
+  }
+
+  calculatePriceSwap(
+    prices: string[][],
+    requiredQty: number,
+    qtyMode: Boolean,
+  ) {
+    let sumBaseQty = 0;
+    let sumQuoteQty = 0;
+    const selectedRows: string[][] = [];
+
+    const isBase = qtyMode;
+    const isQuote = !qtyMode;
+
+    for (const [price, volume] of prices) {
+      if (isBase) {
+        if (sumBaseQty >= requiredQty) {
+          break;
+        }
+      }
+
+      if (isQuote) {
+        if (sumQuoteQty >= requiredQty) {
+          break;
+        }
+      }
+
+      let currentBaseQty = Number(volume);
+      let currentQuoteQty = Number(volume) * Number(price);
+
+      const overQty = isBase
+        ? currentBaseQty + sumBaseQty > requiredQty
+        : currentQuoteQty + sumQuoteQty > requiredQty;
+
+      if (overQty) {
+        if (isBase) {
+          currentBaseQty = requiredQty - sumBaseQty;
+          currentQuoteQty = currentBaseQty * Number(price);
+        }
+
+        if (isQuote) {
+          currentQuoteQty = requiredQty - sumQuoteQty;
+          currentBaseQty =
+            currentQuoteQty *
+            new BigNumber(1).dividedBy(new BigNumber(price)).toNumber();
+        }
+      }
+
+      sumBaseQty += currentBaseQty;
+      sumQuoteQty += currentQuoteQty;
+      selectedRows.push([price, currentBaseQty.toString()]);
+    }
+
+    const vSumBase = selectedRows.reduce((sum: number, [price, volume]) => {
+      return sum + Number(price) * Number(volume);
+    }, 0);
+
+    const price = new BigNumber(vSumBase)
+      .dividedBy(new BigNumber(sumBaseQty))
+      .toNumber();
+
+    if (isBase) {
+      return requiredQty / price;
+    } else {
+      return requiredQty * price;
+    }
+  }
+
+  async getPricesVolume(
+    srcToken: Token,
+    destToken: Token,
+    amounts: bigint[],
+    side: SwapSide,
+    blockNumber: number,
+    limitPools?: string[],
+    transferFees?: TransferFeeParams,
+    isFirstSwap?: boolean,
+  ): Promise<ExchangePrices<CablesData> | null> {
+    const isRestricted = await this.isRestricted();
+    if (isRestricted) {
+      return null;
+    }
+
+    await this.setTokensMap();
+
+    try {
+      const normalizedSrcToken = this.normalizeToken(srcToken);
+      const normalizedDestToken = this.normalizeToken(destToken);
+      // If: same token, return null
+      if (
+        normalizedSrcToken.address.toLowerCase() ===
+        normalizedDestToken.address.toLowerCase()
+      ) {
+        return null;
+      }
+
+      for (const symbol of Object.keys(this.tokensMap)) {
+        const normalizedTokenAddress =
+          this.tokensMap[symbol].address.toLowerCase();
+
+        if (normalizedSrcToken.address === normalizedTokenAddress) {
+          normalizedSrcToken.symbol = this.tokensMap[symbol].symbol;
+        }
+        if (normalizedDestToken.address === normalizedTokenAddress) {
+          normalizedDestToken.symbol = this.tokensMap[symbol].symbol;
+        }
+      }
+
+      // ---------- Pools ----------
+      let pools = await this.getPoolIdentifiers(
+        srcToken,
+        destToken,
+        side,
+        blockNumber,
+      );
+      if (pools.length === 0) return null;
+
+      // ---------- Prices ----------
+      const priceMap = await this.getCachedPrices();
+
+      if (!priceMap) return null;
+
+      let isInputQuote = false;
+      let pairKey = `${normalizedSrcToken.symbol}/${normalizedDestToken.symbol}`;
+      const pairsKeys = Object.keys(priceMap);
+
+      if (!pairsKeys.includes(pairKey)) {
+        // Revert
+        isInputQuote = true;
+        pairKey = `${normalizedDestToken.symbol}/${normalizedSrcToken.symbol}`;
+        if (!pairsKeys.includes(pairKey)) {
+          return null;
+        }
+      }
+
+      /**
+       * Orderbook
+       */
+      const priceData = priceMap[pairKey];
+
+      let orderbook: any[] = [];
+      if (side === SwapSide.BUY) {
+        orderbook = priceData.asks;
+      } else {
+        orderbook = priceData.bids;
+      }
+      if (orderbook?.length === 0) {
+        throw new Error(`Empty orderbook for ${pairKey}`);
+      }
+
+      const prices = this.calculateOrderPrice(
+        amounts,
+        orderbook,
+        side === SwapSide.SELL ? srcToken : destToken,
+        side === SwapSide.SELL ? destToken : srcToken,
+        side === SwapSide.SELL ? isInputQuote : !isInputQuote,
+      );
+
+      const result = [
+        {
+          prices: prices,
+          unit: BigInt(normalizedDestToken.decimals),
+          exchange: this.dexKey,
+          gasCost: CABLES_GAS_COST,
+          poolAddresses: [this.mainnetRFQAddress],
+          data: {},
+        },
+      ];
+
+      return result;
+    } catch (e: unknown) {
+      this.logger.error(
+        `Error in getPricesVolume`,
+        {
+          srcToken: srcToken.address || srcToken.symbol,
+          destToken: destToken.address || destToken.symbol,
+          side,
+        },
+        e,
+      );
+      return null;
+    }
+  }
+
+  getCalldataGasCost(poolPrices: PoolPrices<CablesData>): 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
+    );
+  }
+
+  async initializePricing(blockNumber: number): Promise<void> {
+    if (!this.dexHelper.config.isSlave) {
+      this.rateFetcher.start();
+    }
+    return;
+  }
+
+  getAdapters(side: SwapSide): { name: string; index: number }[] | null {
+    return null;
+  }
+
+  releaseResources?(): AsyncOrSync<void> {
+    if (this.rateFetcher) {
+      this.rateFetcher.stop();
+    }
+  }
+
+  normalizeAddress(address: string): string {
+    return address.toLowerCase() === ETHER_ADDRESS
+      ? NULL_ADDRESS
+      : address.toLowerCase();
+  }
+
+  async setTokensMap() {
+    const tokens = await this.getCachedTokens();
+
+    if (tokens) {
+      this.tokensMap = Object.keys(tokens).reduce((acc, key) => {
+        //@ts-ignore
+        acc[tokens[key].address.toLowerCase()] = tokens[key];
+        return acc;
+      }, {});
+    }
+  }
+
+  async getTopPoolsForToken(
+    tokenAddress: Address,
+    limit: number,
+  ): Promise<PoolLiquidity[]> {
+    return [];
+  }
+
+  /**
+   * CACHED UTILS
+   */
+  async getCachedTokens(): Promise<any> {
+    const cachedTokens = await this.dexHelper.cache.get(
+      this.dexKey,
+      this.network,
+      this.rateFetcher.tokensCacheKey,
+    );
+
+    return cachedTokens ? JSON.parse(cachedTokens) : {};
+  }
+
+  async getCachedPairs(): Promise<any> {
+    const cachedPairs = await this.dexHelper.cache.get(
+      this.dexKey,
+      this.network,
+      this.rateFetcher.pairsCacheKey,
+    );
+
+    return cachedPairs ? JSON.parse(cachedPairs) : {};
+  }
+
+  async getCachedPrices(): Promise<any> {
+    const cachedPrices = await this.dexHelper.cache.get(
+      this.dexKey,
+      this.network,
+      this.rateFetcher.pricesCacheKey,
+    );
+
+    return cachedPrices ? JSON.parse(cachedPrices) : {};
+  }
+
+  async getCachedTokensAddr(): Promise<any> {
+    const tokens = await this.getCachedTokens();
+    const tokensAddr: Record<string, Address> = {};
+    for (const key of Object.keys(tokens)) {
+      tokensAddr[tokens[key].symbol.toLowerCase()] = tokens[key].address;
+    }
+    return tokensAddr;
+  }
+
+  getPairString(baseToken: Token, quoteToken: Token): string {
+    return `${baseToken.symbol}/${quoteToken.symbol}`.toLowerCase();
+  }
+
+  // Function to find a key by address
+  private findKeyByAddress = (
+    jsonData: Record<string, { address: string }>,
+    targetAddress: string,
+  ): string | undefined => {
+    const entries = Object.entries(jsonData);
+    const foundEntry = entries.find(
+      ([_, value]) =>
+        value.address.toLowerCase() === targetAddress.toLowerCase(),
+    );
+    return foundEntry ? foundEntry[0] : undefined;
+  };
+
+  async getPairData(srcToken: Token, destToken: Token): Promise<any> {
+    const normalizedSrcToken = this.normalizeToken(srcToken);
+    const normalizedDestToken = this.normalizeToken(destToken);
+
+    if (normalizedSrcToken.address === normalizedDestToken.address) {
+      return null;
+    }
+
+    const cachedTokens = await this.getCachedTokens();
+
+    normalizedSrcToken.symbol = this.findKeyByAddress(
+      cachedTokens,
+      normalizedSrcToken.address,
+    );
+    normalizedDestToken.symbol = this.findKeyByAddress(
+      cachedTokens,
+      normalizedDestToken.address,
+    );
+
+    const cachedPairs = await this.getCachedPairs();
+
+    const potentialPairs = [
+      {
+        base: normalizedSrcToken.symbol,
+        quote: normalizedDestToken.symbol,
+        identifier: this.getPairString(normalizedSrcToken, normalizedDestToken),
+        isSrcBase: true,
+      },
+      {
+        base: normalizedDestToken.symbol,
+        quote: normalizedSrcToken.symbol,
+        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;
+  }
+
+  async isBlacklisted(txOrigin: Address): Promise<boolean> {
+    const cachedBlacklist = await this.dexHelper.cache.get(
+      this.dexKey,
+      this.network,
+      CABLES_BLACKLIST_CACHE_KEY,
+    );
+
+    if (cachedBlacklist) {
+      const blacklist = JSON.parse(cachedBlacklist) as string[];
+      return blacklist.includes(txOrigin.toLowerCase());
+    }
+
+    return false;
+  }
+
+  async isRestricted(): Promise<boolean> {
+    const result = await this.dexHelper.cache.get(
+      this.dexKey,
+      this.network,
+      CABLES_RESTRICTED_CACHE_KEY,
+    );
+
+    return result === 'true';
+  }
+
+  async restrict() {
+    const errorsDataRaw = await this.dexHelper.cache.get(
+      this.dexKey,
+      this.network,
+      CABLES_ERRORS_CACHE_KEY,
+    );
+
+    const errorsData: RestrictData = Utils.Parse(errorsDataRaw);
+    const ERRORS_TTL_S = Math.floor(CABLES_RESTRICT_CHECK_INTERVAL_MS / 1000);
+
+    if (
+      !errorsData ||
+      errorsData?.addedDatetimeMs + CABLES_RESTRICT_CHECK_INTERVAL_MS <
+        Date.now()
+    ) {
+      this.logger.warn(
+        `${this.dexKey}-${this.network}: First encounter of error OR error ocurred outside of threshold, setting up counter`,
+      );
+      const data: RestrictData = {
+        count: 1,
+        addedDatetimeMs: Date.now(),
+      };
+      await this.dexHelper.cache.setex(
+        this.dexKey,
+        this.network,
+        CABLES_ERRORS_CACHE_KEY,
+        ERRORS_TTL_S,
+        Utils.Serialize(data),
+      );
+      return;
+    } else {
+      if (errorsData.count + 1 >= CABLES_RESTRICT_COUNT_THRESHOLD) {
+        this.logger.warn(
+          `${this.dexKey}-${this.network}: Restricting due to error count=${
+            errorsData.count + 1
+          } within ${CABLES_RESTRICT_CHECK_INTERVAL_MS / 1000 / 60} minutes`,
+        );
+        await this.dexHelper.cache.setex(
+          this.dexKey,
+          this.network,
+          CABLES_RESTRICTED_CACHE_KEY,
+          CABLES_RESTRICT_TTL_S,
+          'true',
+        );
+      } else {
+        this.logger.warn(
+          `${this.dexKey}-${this.network}: Error count increased`,
+        );
+        const data: RestrictData = {
+          count: errorsData.count + 1,
+          addedDatetimeMs: errorsData.addedDatetimeMs,
+        };
+        await this.dexHelper.cache.setex(
+          this.dexKey,
+          this.network,
+          CABLES_RESTRICTED_CACHE_KEY,
+          ERRORS_TTL_S,
+          Utils.Serialize(data),
+        );
+      }
+    }
+  }
+}