@paraswap/dex-lib 2.36.1 → 2.36.2-dexalot.2

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

@@ -0,0 +1,187 @@
+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;
+
+  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.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;
+    for (const address of blacklist) {
+      this.dexHelper.cache.sadd(this.blacklistCacheKey, address.toLowerCase());
+    }
+  }
+}

package/src/dex/dexalot/types.ts

@@ -0,0 +1,122 @@
+import { RequestHeaders } from '../../dex-helper';
+import { Token } from '../../types';
+
+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;
+    pairsCacheTTLSecs: number;
+    pricesCacheTTLSecs: number;
+    tokensCacheTTLSecs: number;
+  };
+};

package/src/dex/dexalot/validators.ts

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

package/src/dex/index.ts

@@ -76,6 +76,7 @@ import { PancakeswapV3 } from './pancakeswap-v3/pancakeswap-v3';
 import { Algebra } from './algebra/algebra';
 import { QuickPerps } from './quick-perps/quick-perps';
 import { NomiswapV2 } from './uniswap-v2/nomiswap-v2';
+import { Dexalot } from './dexalot/dexalot';
 
 const LegacyDexes = [
   CurveV2,
@@ -102,6 +103,7 @@ const LegacyDexes = [
 ];
 
 const Dexes = [
+  Dexalot,
   CurveV1,
   CurveFork,
   Swerve,

package/src/types.ts

@@ -276,6 +276,7 @@ export type Config = {
   hashFlowDisabledMMs: string[];
   uniswapV3EventLoggingSampleRate?: number;
   swaapV2AuthToken?: string;
+  dexalotAuthToken?: string;
   forceRpcFallbackDexs: string[];
 };
 

package/build/abi/quickPerps/fast-price-events.json

@@ -1,70 +0,0 @@
-[
-    {
-        "anonymous": false,
-        "inputs": [
-            {
-                "indexed": false,
-                "internalType": "address",
-                "name": "token",
-                "type": "address"
-            },
-            {
-                "indexed": false,
-                "internalType": "uint256",
-                "name": "price",
-                "type": "uint256"
-            },
-            {
-                "indexed": false,
-                "internalType": "address",
-                "name": "priceFeed",
-                "type": "address"
-            }
-        ],
-        "name": "PriceUpdate",
-        "type": "event"
-    },
-    {
-        "inputs": [
-            { "internalType": "address", "name": "_token", "type": "address" },
-            { "internalType": "uint256", "name": "_price", "type": "uint256" }
-        ],
-        "name": "emitPriceEvent",
-        "outputs": [],
-        "stateMutability": "nonpayable",
-        "type": "function"
-    },
-    {
-        "inputs": [],
-        "name": "gov",
-        "outputs": [{ "internalType": "address", "name": "", "type": "address" }],
-        "stateMutability": "view",
-        "type": "function"
-    },
-    {
-        "inputs": [{ "internalType": "address", "name": "", "type": "address" }],
-        "name": "isPriceFeed",
-        "outputs": [{ "internalType": "bool", "name": "", "type": "bool" }],
-        "stateMutability": "view",
-        "type": "function"
-    },
-    {
-        "inputs": [
-            { "internalType": "address", "name": "_gov", "type": "address" }
-        ],
-        "name": "setGov",
-        "outputs": [],
-        "stateMutability": "nonpayable",
-        "type": "function"
-    },
-    {
-        "inputs": [
-            { "internalType": "address", "name": "_priceFeed", "type": "address" },
-            { "internalType": "bool", "name": "_isPriceFeed", "type": "bool" }
-        ],
-        "name": "setIsPriceFeed",
-        "outputs": [],
-        "stateMutability": "nonpayable",
-        "type": "function"
-    }
-]