@paraswap/dex-lib 4.0.3-Cables.1 → 4.0.3

package/src/dex/cables/config.ts

@@ -1,13 +0,0 @@
-import { Network } from '../../constants';
-import { DexConfigMap } from '../../types';
-
-export const CablesConfig: DexConfigMap<{ mainnetRFQAddress: string }> = {
-  Cables: {
-    [Network.AVALANCHE]: {
-      mainnetRFQAddress: '0xfA12DCB2e1FD72bD92E8255Db6A781b2c76adC20',
-    },
-    [Network.ARBITRUM]: {
-      mainnetRFQAddress: '0xfA12DCB2e1FD72bD92E8255Db6A781b2c76adC20',
-    },
-  },
-};

package/src/dex/cables/constants.ts

@@ -1,35 +0,0 @@
-import BigNumber from 'bignumber.js';
-
-/**
- * Cables
- */
-export const CABLES_API_URL =
-  'https://cables-evm-rfq-service.cryptosrvc.com/v1';
-
-export const CABLES_PRICES_CACHES_TTL_S = 10;
-export const CABLES_API_PRICES_POLLING_INTERVAL_MS = 2000; // 2 sec
-
-export const CABLES_PAIRS_CACHES_TTL_S = 12;
-export const CABLES_API_PAIRS_POLLING_INTERVAL_MS = 10000; // 10 sec
-
-export const CABLES_BLACKLIST_CACHES_TTL_S = 60;
-export const CABLES_API_BLACKLIST_POLLING_INTERVAL_MS = 30000; // 30 sec
-
-export const CABLES_TOKENS_CACHES_TTL_S = 60;
-export const CABLES_API_TOKENS_POLLING_INTERVAL_MS = 30000; // 30 sec
-
-export const CABLES_FIRM_QUOTE_TIMEOUT_MS = 2000;
-
-export const CABLES_BLACKLIST_CACHE_KEY = 'cablesBlacklistCacheKey';
-
-export const CABLES_RESTRICTED_CACHE_KEY = 'restricted';
-
-export const CABLES_ERRORS_CACHE_KEY = 'errors';
-
-export const CABLES_RESTRICT_CHECK_INTERVAL_MS = 1000 * 60 * 3; // 3 min
-
-export const CABLES_RESTRICT_COUNT_THRESHOLD = 3;
-
-export const CABLES_RESTRICT_TTL_S = 10 * 60; // 10 min
-
-export const CABLES_GAS_COST = 120_000;

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

@@ -1,212 +0,0 @@
-import { Network } from '../../constants';
-import { IDexHelper } from '../../dex-helper';
-import { Fetcher } from '../../lib/fetcher/fetcher';
-import { validateAndCast } from '../../lib/validators';
-import { Logger, Token } from '../../types';
-import { PairData } from '../cables/types';
-import {
-  CablesBlacklistResponse,
-  CablesPairsResponse,
-  CablesPricesResponse,
-  CablesRateFetcherConfig,
-  CablesTokensResponse,
-} from './types';
-import {
-  blacklistResponseValidator,
-  pairsResponseValidator,
-  pricesResponseValidator,
-  tokensResponseValidator,
-} from './validators';
-
-export class CablesRateFetcher {
-  public tokensFetcher: Fetcher<CablesTokensResponse>;
-  public tokensCacheKey: string;
-  public tokensCacheTTL: number;
-
-  public pairsFetcher: Fetcher<CablesPairsResponse>;
-  public pairsCacheKey: string;
-  public pairsCacheTTL: number;
-
-  public pricesFetcher: Fetcher<CablesPricesResponse>;
-  public pricesCacheKey: string;
-  public pricesCacheTTL: number;
-
-  public blacklistFetcher: Fetcher<CablesBlacklistResponse>;
-  public blacklistCacheKey: string;
-  public blacklistCacheTTL: number;
-
-  constructor(
-    private dexHelper: IDexHelper,
-    private dexKey: string,
-    private network: Network,
-    private logger: Logger,
-    config: CablesRateFetcherConfig,
-  ) {
-    this.tokensCacheKey = config.rateConfig.tokensCacheKey;
-    this.tokensCacheTTL = config.rateConfig.tokensCacheTTLSecs;
-
-    this.pairsCacheKey = config.rateConfig.pairsCacheKey;
-    this.pairsCacheTTL = config.rateConfig.pairsCacheTTLSecs;
-
-    this.pricesCacheKey = config.rateConfig.pricesCacheKey;
-    this.pricesCacheTTL = config.rateConfig.pricesCacheTTLSecs;
-
-    this.blacklistCacheKey = config.rateConfig.blacklistCacheKey;
-    this.blacklistCacheTTL = config.rateConfig.blacklistCacheTTLSecs;
-
-    this.pairsFetcher = new Fetcher<CablesPairsResponse>(
-      dexHelper.httpRequest,
-      {
-        info: {
-          requestOptions: config.rateConfig.pairsReqParams,
-          caster: (data: unknown) => {
-            return validateAndCast<CablesPairsResponse>(
-              data,
-              pairsResponseValidator,
-            );
-          },
-        },
-        handler: this.handlePairsResponse.bind(this),
-      },
-      config.rateConfig.pairsIntervalMs,
-      logger,
-    );
-
-    this.pricesFetcher = new Fetcher<CablesPricesResponse>(
-      dexHelper.httpRequest,
-      {
-        info: {
-          requestOptions: config.rateConfig.pricesReqParams,
-          caster: (data: unknown) => {
-            return validateAndCast<CablesPricesResponse>(
-              data,
-              pricesResponseValidator,
-            );
-          },
-        },
-        handler: this.handlePricesResponse.bind(this),
-      },
-      config.rateConfig.pricesIntervalMs,
-      logger,
-    );
-
-    this.blacklistFetcher = new Fetcher<CablesBlacklistResponse>(
-      dexHelper.httpRequest,
-      {
-        info: {
-          requestOptions: config.rateConfig.blacklistReqParams,
-          caster: (data: unknown) => {
-            return validateAndCast<CablesBlacklistResponse>(
-              data,
-              blacklistResponseValidator,
-            );
-          },
-        },
-        handler: this.handleBlacklistResponse.bind(this),
-      },
-      config.rateConfig.blacklistIntervalMs,
-      logger,
-    );
-
-    this.tokensFetcher = new Fetcher<CablesTokensResponse>(
-      dexHelper.httpRequest,
-      {
-        info: {
-          requestOptions: config.rateConfig.tokensReqParams,
-          caster: (data: unknown) => {
-            return validateAndCast<CablesTokensResponse>(
-              data,
-              tokensResponseValidator,
-            );
-          },
-        },
-        handler: this.handleTokensResponse.bind(this),
-      },
-      config.rateConfig.tokensIntervalMs,
-      logger,
-    );
-  }
-
-  /**
-   * Utils
-   */
-  start() {
-    this.pairsFetcher.startPolling();
-    this.pricesFetcher.startPolling();
-    this.blacklistFetcher.startPolling();
-    this.tokensFetcher.startPolling();
-  }
-  stop() {
-    this.pairsFetcher.stopPolling();
-    this.pricesFetcher.stopPolling();
-    this.blacklistFetcher.stopPolling();
-    this.tokensFetcher.stopPolling();
-  }
-
-  private handlePairsResponse(res: CablesPairsResponse): void {
-    const networkId = String(this.network);
-    const pairs = res.pairs[networkId];
-
-    let normalized_pairs: { [token: string]: PairData } = {};
-    Object.keys(pairs).forEach(key => {
-      normalized_pairs[key.toLowerCase()] = pairs[key];
-    });
-
-    this.dexHelper.cache.setex(
-      this.dexKey,
-      this.network,
-      this.pairsCacheKey,
-      this.pairsCacheTTL,
-      JSON.stringify(normalized_pairs),
-    );
-  }
-
-  private handlePricesResponse(res: CablesPricesResponse): void {
-    const networkId = String(this.network);
-    const prices = res.prices[networkId];
-
-    this.dexHelper.cache.setex(
-      this.dexKey,
-      this.network,
-      this.pricesCacheKey,
-      this.pricesCacheTTL,
-      JSON.stringify(prices),
-    );
-  }
-
-  private handleBlacklistResponse(res: CablesBlacklistResponse): void {
-    const { blacklist } = res;
-    this.dexHelper.cache.setex(
-      this.dexKey,
-      this.network,
-      this.blacklistCacheKey,
-      this.blacklistCacheTTL,
-      JSON.stringify(blacklist.map(item => item.toLowerCase())),
-    );
-  }
-
-  // Convert addresses to lowercase
-  private normalizeAddressesToLowerCase = (
-    jsonData: Record<string, { address: string }>,
-  ) => {
-    Object.keys(jsonData).forEach(key => {
-      jsonData[key].address = jsonData[key].address.toLowerCase();
-    });
-    return jsonData;
-  };
-
-  private async handleTokensResponse(res: CablesTokensResponse): Promise<void> {
-    const networkId = String(this.network);
-    const tokens = res.tokens[networkId];
-
-    const normalizedTokens = this.normalizeAddressesToLowerCase(tokens);
-
-    this.dexHelper.cache.setex(
-      this.dexKey,
-      this.network,
-      this.tokensCacheKey,
-      this.tokensCacheTTL,
-      JSON.stringify(normalizedTokens),
-    );
-  }
-}

package/src/dex/cables/types.ts

@@ -1,113 +0,0 @@
-import { RequestHeaders } from '../../dex-helper';
-import { Token } from '../../types';
-import { Method } from '../../dex-helper/irequest-wrapper';
-import { AugustusRFQOrderData } from '../augustus-rfq';
-
-export type CablesRFQResponse = {
-  order: AugustusRFQOrderData;
-  signature: string;
-};
-
-export type CablesData = {
-  quoteData?: AugustusRFQOrderData;
-};
-/**
- * Types
- */
-export type PairData = {
-  base: string;
-  quote: string;
-  liquidityUSD: number;
-};
-
-type PriceAndAmount = [string, string];
-
-type PriceData = {
-  bids: PriceAndAmount[];
-  asks: PriceAndAmount[];
-};
-
-type PriceDataMap = {
-  [network: string]: {
-    [pair: string]: PriceData;
-  };
-};
-
-type TokenDataMap = {
-  [network: string]: {
-    [token: string]: Token;
-  };
-};
-
-type PairsDataMap = {
-  [network: string]: {
-    [token: string]: PairData;
-  };
-};
-
-/**
- * Responses
- */
-export type CablesPricesResponse = {
-  prices: PriceDataMap;
-};
-export type CablesBlacklistResponse = {
-  blacklist: string[];
-};
-export type CablesTokensResponse = {
-  tokens: TokenDataMap;
-};
-export type CablesPairsResponse = {
-  pairs: PairsDataMap;
-};
-
-/**
- * Rate Fetcher
- */
-export type CablesRateFetcherConfig = {
-  rateConfig: {
-    pairsReqParams: {
-      url: string;
-      headers?: RequestHeaders;
-      params?: any;
-    };
-    pricesReqParams: {
-      url: string;
-      headers?: RequestHeaders;
-      params?: any;
-    };
-    blacklistReqParams: {
-      url: string;
-      headers?: RequestHeaders;
-      params?: any;
-    };
-    tokensReqParams: {
-      url: string;
-      headers?: RequestHeaders;
-      params?: any;
-    };
-    pairsIntervalMs: number;
-    pricesIntervalMs: number;
-    blacklistIntervalMs: number;
-    tokensIntervalMs: number;
-
-    pairsCacheKey: string;
-    pricesCacheKey: string;
-    blacklistCacheKey: string;
-    tokensCacheKey: string;
-
-    blacklistCacheTTLSecs: number;
-    pairsCacheTTLSecs: number;
-    pricesCacheTTLSecs: number;
-    tokensCacheTTLSecs: number;
-  };
-};
-
-export type RestrictData = {
-  count: number;
-  addedDatetimeMs: number;
-} | null;
-
-export class SlippageError extends Error {
-  isSlippageError = true;
-}

package/src/dex/cables/validators.test.ts

@@ -1,151 +0,0 @@
-import Joi from 'joi';
-import {
-  pairsResponseValidator,
-  pricesResponseValidator,
-  tokensResponseValidator,
-  blacklistResponseValidator,
-} from './validators'; //
-
-describe('Validation Schemas', () => {
-  describe('pairsResponseValidator', () => {
-    it('should validate correct pairs response', () => {
-      const validData = {
-        pairs: { '43114': { 'USDC/USDT': { base: 'USDC', quote: 'USDT' } } },
-      };
-      const { error } = pairsResponseValidator.validate(validData);
-      expect(error).toBeUndefined();
-    });
-
-    it('should invalidate incorrect pairs response', () => {
-      const invalidData = { pairs: { '43114': 'USDC/USDT' } };
-      const { error } = pairsResponseValidator.validate(invalidData);
-      expect(error).toBeDefined();
-    });
-  });
-
-  describe('pricesResponseValidator', () => {
-    it('should validate correct prices response', () => {
-      const validData = {
-        prices: {
-          '43114': {
-            'USDC/USDT': {
-              bids: [
-                ['0.9996', '244305.9'],
-                ['0.9995', '236021.6'],
-              ],
-              asks: [
-                ['0.9996', '244305.9'],
-                ['0.9995', '236021.6'],
-              ],
-            },
-          },
-        },
-      };
-      const { error } = pricesResponseValidator.validate(validData);
-      expect(error).toBeUndefined();
-    });
-
-    it('should invalidate incorrect prices response', () => {
-      const invalidData = {
-        prices: {
-          chain1: {
-            bids: [
-              ['1000'], // invalid entry length
-            ],
-            asks: [['1010', '1']],
-          },
-        },
-      };
-      const { error } = pricesResponseValidator.validate(invalidData);
-      expect(error).toBeDefined();
-    });
-  });
-
-  describe('tokensResponseValidator', () => {
-    it('should validate correct tokens response', () => {
-      const validData = {
-        tokens: {
-          '43114': {
-            AVAX: {
-              symbol: 'AVAX',
-              decimals: 18,
-              name: 'AVAX',
-              address: '0x0000000000000000000000000000000000000000',
-            },
-            WAVAX: {
-              symbol: 'WAVAX',
-              decimals: 18,
-              name: 'WAVAX',
-              address: '0xB31f66AA3C1e785363F0875A1B74E27b85FD66c7',
-            },
-            'WETH.e': {
-              symbol: 'WETH.e',
-              decimals: 18,
-              name: 'WETH.e',
-              address: '0x49D5c2BdFfac6CE2BFdB6640F4F80f226bc10bAB',
-            },
-            USDT: {
-              symbol: 'USDT',
-              decimals: 6,
-              name: 'USDT',
-              address: '0x9702230A8Ea53601f5cD2dc00fDBc13d4dF4A8c7',
-            },
-            USDC: {
-              symbol: 'USDC',
-              decimals: 6,
-              name: 'USDC',
-              address: '0xB97EF9Ef8734C71904D8002F8b6Bc66Dd9c48a6E',
-            },
-            'USDC.e': {
-              symbol: 'USDC.e',
-              decimals: 6,
-              name: 'USDC.e',
-              address: '0xA7D7079b0FEaD91F3e65f86E8915Cb59c1a4C664',
-            },
-          },
-        },
-      };
-      const { error } = tokensResponseValidator.validate(validData);
-      expect(error).toBeUndefined();
-    });
-
-    it('should invalidate incorrect tokens response', () => {
-      const invalidData = {
-        tokens: {
-          chain1: {
-            ETH: {
-              symbol: '', // invalid value
-              name: 'Ethereum',
-              description: 'A popular cryptocurrency',
-              address: '0x...',
-              decimals: 18,
-              type: 'ERC20',
-            },
-          },
-        },
-      };
-      const { error } = tokensResponseValidator.validate(invalidData);
-      expect(error).toBeDefined();
-    });
-  });
-
-  describe('blacklistResponseValidator', () => {
-    it('should validate correct blacklist response', () => {
-      const validData = {
-        blacklist: ['0xAddress1', '0xAddress2'],
-      };
-      const { error } = blacklistResponseValidator.validate(validData);
-      expect(error).toBeUndefined();
-    });
-
-    it('should invalidate incorrect blacklist response', () => {
-      const invalidData = {
-        blacklist: [
-          '', // invalid value
-        ],
-      };
-      const { error } = blacklistResponseValidator.validate(invalidData);
-      expect(error).toBeDefined();
-    });
-  });
-});

package/src/dex/cables/validators.ts

@@ -1,61 +0,0 @@
-import joi from 'joi';
-
-const pairValidator = joi.object({
-  base: joi.string().min(1),
-  quote: joi.string().min(1),
-  liquidityUSD: joi.number().min(0),
-  baseAddress: joi.string().min(1),
-  quoteAddress: joi.string().min(1),
-  baseDecimals: joi.number().min(0),
-  quoteDecimals: joi.number().min(0),
-});
-
-const pairMap = joi.object().pattern(
-  joi.string(), // Pair name ETH/USDT
-  pairValidator,
-);
-
-export const pairsResponseValidator = joi.object({
-  pairs: joi.object().pattern(
-    joi.string(), // chain id
-    pairMap,
-  ),
-});
-
-const orderbookEntry = joi.array().items(joi.string().min(1)).length(2);
-
-const orderbookValidator = joi.object({
-  bids: joi.array().items(orderbookEntry),
-  asks: joi.array().items(orderbookEntry),
-});
-
-const chainDataSchema = joi.object().pattern(
-  joi.string(), // pair name USDC/USDT
-  orderbookValidator,
-);
-
-export const pricesResponseValidator = joi.object({
-  prices: joi.object().pattern(
-    joi.string(), // chain id
-    chainDataSchema,
-  ),
-});
-
-const tokenValidator = joi.object({
-  symbol: joi.string().min(1),
-  name: joi.string().min(1),
-  description: joi.string().min(1),
-  address: joi.string().min(1),
-  decimals: joi.number().min(0),
-  type: joi.string().min(1),
-});
-
-const chainTokens = joi.object().pattern(joi.string(), tokenValidator);
-
-export const tokensResponseValidator = joi.object({
-  tokens: joi.object().pattern(joi.string(), chainTokens),
-});
-
-export const blacklistResponseValidator = joi.object({
-  blacklist: joi.array().items(joi.string().min(1)),
-});