@paraswap/dex-lib 3.11.11 → 3.11.12-cables.0

package/src/dex/cables/config.ts

@@ -0,0 +1,13 @@
+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

@@ -0,0 +1,35 @@
+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

@@ -0,0 +1,212 @@
+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 handleTokensResponse(res: CablesTokensResponse): void {
+    const networkId = String(this.network);
+    const tokens = res.tokens[networkId];
+
+    const normalized_tokens = this.normalizeAddressesToLowerCase(tokens);
+
+    this.dexHelper.cache.setex(
+      this.dexKey,
+      this.network,
+      this.tokensCacheKey,
+      this.tokensCacheTTL,
+      JSON.stringify(normalized_tokens),
+    );
+  }
+}

package/src/dex/cables/types.ts

@@ -0,0 +1,128 @@
+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;
+};
+
+export enum OrderbookSide {
+  bids = 'bids',
+  asks = 'asks',
+}
+
+/**
+ * Utils
+ */
+export type CablesAPIParameters = {
+  url: string;
+  method: Method;
+};
+export class CablesRfqError extends Error {}
+
+/**
+ * Types
+ */
+export type PairData = {
+  base: string;
+  quote: string;
+  liquidityUSD: number;
+};
+
+export type PriceAndAmount = [string, string];
+
+export type PriceData = {
+  bids: PriceAndAmount[];
+  asks: PriceAndAmount[];
+};
+
+export type PriceDataMap = {
+  [network: string]: {
+    [pair: string]: PriceData;
+  };
+};
+
+export type TokenDataMap = {
+  [network: string]: {
+    [token: string]: Token;
+  };
+};
+
+export 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

@@ -0,0 +1,151 @@
+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

@@ -0,0 +1,61 @@
+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)),
+});

package/src/dex/dexalot/dexalot.ts

@@ -1035,56 +1035,7 @@ export class Dexalot extends SimpleExchange implements IDex<DexalotData> {
     tokenAddress: Address,
     limit: number,
   ): Promise<PoolLiquidity[]> {
-    const normalizedTokenAddress = this.normalizeAddress(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);
+    return []; // not implemented
   }
 
   getAPIReqParams(endpoint: string, method: Method): DexalotAPIParameters {

package/src/dex/index.ts

@@ -94,6 +94,7 @@ import { LitePsm } from './lite-psm/lite-psm';
 import { UsualBond } from './usual-bond/usual-bond';
 import { StkGHO } from './stkgho/stkgho';
 import { SkyConverter } from './sky-converter/sky-converter';
+import { Cables } from './cables/cables';
 import { Stader } from './stader/stader';
 
 const LegacyDexes = [
@@ -184,6 +185,7 @@ const Dexes = [
   UsualBond,
   StkGHO,
   SkyConverter,
+  Cables,
   FluidDex,
 ];
 

package/tests/constants-e2e.ts

@@ -1849,7 +1849,7 @@ export const Holders: {
     BETS: '0x8cc2284c90d05578633418f9cde104f402375a65',
     HATCHY: '0x14ec295ec8def851ec6e2959df872dd24e422631',
     USDCe: '0x3a2434c698f8d79af1f5a9e43013157ca8b11a66',
-    USDC: '0xcc2da711D621A4491b338CAC88B9C0954db3e75B',
+    USDC: '0x64b4dE1b00EF830f3CC2FD68ee056aAD76C45BF6',
     USDTe: '0x84d34f4f83a87596cd3fb6887cff8f17bf5a7b83',
     WETHe: '0x9bdB521a97E95177BF252C253E256A60C3e14447',
     POPS: '0x5268c2331658cb0b2858cfa9db27d8f22f5434bc',
@@ -1865,7 +1865,7 @@ export const Holders: {
     TSD: '0x691A89db352B72dDb249bFe16503494eC0D920A4',
     THO: '0xc40d16c47394a506d451475c8a7c46c1175c1da1',
     aAvaUSDT: '0x50B1Ba98Cf117c9682048D56628B294ebbAA4ec2',
-    USDT: '0x0d0707963952f2fba59dd06f2b425ace40b492fe',
+    USDT: '0xCddc5d0Ebeb71a08ffF26909AA6c0d4e256b4fE1',
     aAvaWAVAX: '0x1B18Df70863636AEe4BfBAb6F7C70ceBCA9bA404',
     oldFRAX: '0x4e3376018add04ebe4c46bf6f924ddec8c67aa7b',
     newFRAX: '0x4e3376018add04ebe4c46bf6f924ddec8c67aa7b',