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

package/src/dex/dexalot/rate-fetcher.ts

@@ -1,197 +0,0 @@
-import { IDexHelper } from '../../dex-helper';
-import { Fetcher } from '../../lib/fetcher/fetcher';
-import { validateAndCast } from '../../lib/validators';
-import { Logger, Token } from '../../types';
-import {
-  DexalotRateFetcherConfig,
-  DexalotPairsResponse,
-  PairDataMap,
-  DexalotPricesResponse,
-  PriceDataMap,
-  DexalotBlacklistResponse,
-} from './types';
-import {
-  pricesResponseValidator,
-  pairsResponseValidator,
-  blacklistResponseValidator,
-} from './validators';
-import { Network } from '../../constants';
-
-export class RateFetcher {
-  private pairsFetcher: Fetcher<DexalotPairsResponse>;
-  private pairsCacheKey: string;
-  private pairsCacheTTL: number;
-
-  private rateFetcher: Fetcher<DexalotPricesResponse>;
-  private pricesCacheKey: string;
-  private pricesCacheTTL: number;
-
-  private tokensAddrCacheKey: string;
-  private tokensCacheKey: string;
-  private tokensCacheTTL: number;
-
-  private blacklistFetcher: Fetcher<DexalotBlacklistResponse>;
-  private blacklistCacheKey: string;
-  private blacklistCacheTTL: number;
-
-  constructor(
-    private dexHelper: IDexHelper,
-    private dexKey: string,
-    private network: Network,
-    private logger: Logger,
-    config: DexalotRateFetcherConfig,
-  ) {
-    this.pairsCacheKey = config.rateConfig.pairsCacheKey;
-    this.pairsCacheTTL = config.rateConfig.pairsCacheTTLSecs;
-    this.pricesCacheKey = config.rateConfig.pricesCacheKey;
-    this.pricesCacheTTL = config.rateConfig.pricesCacheTTLSecs;
-    this.tokensAddrCacheKey = config.rateConfig.tokensAddrCacheKey;
-    this.tokensCacheKey = config.rateConfig.tokensCacheKey;
-    this.tokensCacheTTL = config.rateConfig.tokensCacheTTLSecs;
-    this.blacklistCacheKey = config.rateConfig.blacklistCacheKey;
-    this.blacklistCacheTTL = config.rateConfig.blacklistCacheTTLSecs;
-
-    this.pairsFetcher = new Fetcher<DexalotPairsResponse>(
-      dexHelper.httpRequest,
-      {
-        info: {
-          requestOptions: config.rateConfig.pairsReqParams,
-          caster: (data: unknown) => {
-            return validateAndCast<DexalotPairsResponse>(
-              data,
-              pairsResponseValidator,
-            );
-          },
-        },
-        handler: this.handlePairsResponse.bind(this),
-      },
-      config.rateConfig.pairsIntervalMs,
-      logger,
-    );
-
-    this.rateFetcher = new Fetcher<DexalotPricesResponse>(
-      dexHelper.httpRequest,
-      {
-        info: {
-          requestOptions: config.rateConfig.pricesReqParams,
-          caster: (data: unknown) => {
-            return validateAndCast<DexalotPricesResponse>(
-              data,
-              pricesResponseValidator,
-            );
-          },
-        },
-        handler: this.handleRatesResponse.bind(this),
-      },
-      config.rateConfig.pricesIntervalMs,
-      logger,
-    );
-
-    this.blacklistFetcher = new Fetcher<DexalotBlacklistResponse>(
-      dexHelper.httpRequest,
-      {
-        info: {
-          requestOptions: config.rateConfig.blacklistReqParams,
-          caster: (data: unknown) => {
-            return validateAndCast<DexalotBlacklistResponse>(
-              data,
-              blacklistResponseValidator,
-            );
-          },
-        },
-        handler: this.handleBlacklistResponse.bind(this),
-      },
-      config.rateConfig.blacklistIntervalMs,
-      logger,
-    );
-  }
-
-  start() {
-    this.pairsFetcher.startPolling();
-    this.rateFetcher.startPolling();
-    this.blacklistFetcher.startPolling();
-  }
-
-  stop() {
-    this.pairsFetcher.stopPolling();
-    this.rateFetcher.stopPolling();
-    this.blacklistFetcher.stopPolling();
-  }
-
-  private handlePairsResponse(resp: DexalotPairsResponse): void {
-    const pairs = resp;
-    const dexPairs: PairDataMap = {};
-    const tokenMap: { [address: string]: Token } = {};
-    const tokenAddrMap: { [symbol: string]: string } = {};
-    Object.keys(pairs).forEach(pair => {
-      dexPairs[pair.toLowerCase()] = pairs[pair];
-      tokenAddrMap[pairs[pair].base.toLowerCase()] =
-        pairs[pair].baseAddress.toLowerCase();
-      tokenAddrMap[pairs[pair].quote.toLowerCase()] =
-        pairs[pair].quoteAddress.toLowerCase();
-      tokenMap[pairs[pair].baseAddress.toLowerCase()] = {
-        address: pairs[pair].baseAddress.toLowerCase(),
-        symbol: pairs[pair].base,
-        decimals: pairs[pair].baseDecimals,
-      };
-      tokenMap[pairs[pair].quoteAddress.toLowerCase()] = {
-        address: pairs[pair].quoteAddress.toLowerCase(),
-        symbol: pairs[pair].quote,
-        decimals: pairs[pair].quoteDecimals,
-      };
-    });
-
-    this.dexHelper.cache.setex(
-      this.dexKey,
-      this.network,
-      this.pairsCacheKey,
-      this.pairsCacheTTL,
-      JSON.stringify(dexPairs),
-    );
-
-    this.dexHelper.cache.setex(
-      this.dexKey,
-      this.network,
-      this.tokensCacheKey,
-      this.tokensCacheTTL,
-      JSON.stringify(tokenMap),
-    );
-
-    this.dexHelper.cache.setex(
-      this.dexKey,
-      this.network,
-      this.tokensAddrCacheKey,
-      this.tokensCacheTTL,
-      JSON.stringify(tokenAddrMap),
-    );
-  }
-
-  private handleRatesResponse(resp: DexalotPricesResponse): void {
-    const { prices } = resp;
-    const dexPrices: PriceDataMap = {};
-    Object.keys(prices).forEach(pair => {
-      dexPrices[pair.toLowerCase()] = prices[pair];
-    });
-
-    this.dexHelper.cache.setex(
-      this.dexKey,
-      this.network,
-      this.pricesCacheKey,
-      this.pricesCacheTTL,
-      JSON.stringify(dexPrices),
-    );
-  }
-
-  private async handleBlacklistResponse(
-    resp: DexalotBlacklistResponse,
-  ): Promise<void> {
-    const { blacklist } = resp;
-    this.dexHelper.cache.setex(
-      this.dexKey,
-      this.network,
-      this.blacklistCacheKey,
-      this.blacklistCacheTTL,
-      JSON.stringify(blacklist.map((item) => item.toLowerCase())),
-    );
-  }
-}

package/src/dex/dexalot/types.ts

@@ -1,131 +0,0 @@
-import { RequestHeaders } from '../../dex-helper';
-import { Token } from '../../types';
-import { Method } from '../../dex-helper/irequest-wrapper';
-
-type RFQOrder = {
-  nonceAndMeta: string;
-  expiry: number;
-  makerAsset: string;
-  takerAsset: string;
-  maker: string;
-  taker: string;
-  makerAmount: string;
-  takerAmount: string;
-  signature?: string;
-};
-
-export type RFQResponse = {
-  order: RFQOrder;
-  signature: string;
-};
-
-export type RFQResponseError = {
-  Reason: string;
-  ReasonCode: string;
-  Success: boolean;
-  RetryAfter?: number;
-};
-
-export type DexalotData = {
-  quoteData?: RFQOrder;
-};
-
-export type DexParams = {
-  mainnetRFQAddress: string;
-};
-
-export enum ClobSide {
-  BID = 'BID',
-  ASK = 'ASK',
-}
-
-export class DexalotRfqError extends Error {}
-
-export type PairData = {
-  base: string;
-  quote: string;
-  liquidityUSD: number;
-  isSrcBase?: boolean;
-};
-
-export type PairDataMap = {
-  [pair: string]: PairData;
-};
-
-export type PairDataResp = {
-  base: string;
-  quote: string;
-  liquidityUSD: number;
-  baseAddress: string;
-  quoteAddress: string;
-  baseDecimals: number;
-  quoteDecimals: number;
-};
-
-export type DexalotPairsResponse = {
-  [pair: string]: PairDataResp;
-};
-
-type PriceData = {
-  bids: string[][];
-  asks: string[][];
-};
-
-export type PriceDataMap = {
-  [pair: string]: PriceData;
-};
-
-export type DexalotPricesResponse = {
-  prices: PriceDataMap;
-};
-
-export type TokenAddrDataMap = {
-  [symbol: string]: string;
-};
-
-export type TokenDataMap = {
-  [address: string]: Token;
-};
-
-export type DexalotBlacklistResponse = {
-  blacklist: string[];
-};
-
-export type DexalotRateFetcherConfig = {
-  rateConfig: {
-    pairsReqParams: {
-      url: string;
-      headers?: RequestHeaders;
-      params?: any;
-    };
-    pricesReqParams: {
-      url: string;
-      headers?: RequestHeaders;
-      params?: any;
-    };
-    blacklistReqParams: {
-      url: string;
-      headers?: RequestHeaders;
-      params?: any;
-    };
-    pairsIntervalMs: number;
-    pricesIntervalMs: number;
-    blacklistIntervalMs: number;
-    pairsCacheKey: string;
-    pricesCacheKey: string;
-    tokensAddrCacheKey: string;
-    tokensCacheKey: string;
-    blacklistCacheKey: string;
-    blacklistCacheTTLSecs: number;
-    pairsCacheTTLSecs: number;
-    pricesCacheTTLSecs: number;
-    tokensCacheTTLSecs: number;
-  };
-};
-
-export type DexalotAPIParameters = {
-  url: string;
-  headers?: RequestHeaders;
-  params?: any;
-  method?: Method;
-};

package/src/dex/dexalot/validators.ts

@@ -1,46 +0,0 @@
-import joi from 'joi';
-
-const pairValidator = joi.object({
-  base: joi.string().min(1).required(),
-  quote: joi.string().min(1).required(),
-  liquidityUSD: joi.number().min(0).required(),
-  baseAddress: joi.string().min(1).required(),
-  quoteAddress: joi.string().min(1).required(),
-  baseDecimals: joi.number().min(0).required(),
-  quoteDecimals: joi.number().min(0).required(),
-});
-
-export const pairsResponseValidator = joi
-  .object()
-  .pattern(joi.string(), pairValidator);
-
-const orderbookRecordValidator = joi
-  .array()
-  .items(joi.string().min(1))
-  .length(2);
-
-const orderbookValidator = joi.object({
-  bids: joi.array().items(orderbookRecordValidator).required(),
-  asks: joi.array().items(orderbookRecordValidator).required(),
-});
-
-export const pricesResponseValidator = joi.object({
-  prices: joi.object().pattern(joi.string(), orderbookValidator),
-});
-
-const tokenValidator = joi.object({
-  symbol: joi.string().min(1).required(),
-  name: joi.string().min(1).required(),
-  description: joi.string().min(1).required(),
-  address: joi.string().min(1).required(),
-  decimals: joi.number().min(0).required(),
-  type: joi.string().min(1).required(),
-});
-
-export const tokensResponseValidator = joi.object({
-  tokens: joi.object().pattern(joi.string(), tokenValidator),
-});
-
-export const blacklistResponseValidator = joi.object({
-  blacklist: joi.array().items(joi.string().min(1)).required(),
-});