@paraswap/dex-lib 2.36.1 → 2.36.2-dexalot

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/dex/maverick-v1/maverick-v1-e2e.test.ts

@@ -38,7 +38,13 @@ function testForNetwork(
         ContractMethod.megaSwap,
       ],
     ],
-    [SwapSide.BUY, [ContractMethod.simpleBuy, ContractMethod.buy]],
+    [
+      SwapSide.BUY,
+      [
+        ContractMethod.simpleBuy,
+        ContractMethod.buy,
+      ],
+    ],
   ]);
 
   describe(`${network}`, () => {

package/src/dex/pancakeswap-v3/pancakeswap-v3-e2e.test.ts

@@ -38,7 +38,13 @@ function testForNetwork(
         ContractMethod.megaSwap,
       ],
     ],
-    [SwapSide.BUY, [ContractMethod.simpleBuy, ContractMethod.buy]],
+    [
+      SwapSide.BUY,
+      [
+        ContractMethod.simpleBuy,
+        ContractMethod.buy,
+      ],
+    ],
   ]);
 
   describe(`${network}`, () => {

package/src/dex/quick-perps/pool.ts

@@ -104,7 +104,6 @@ export class QuickPerpsEventPool extends ComposedEventSubscriber<PoolState> {
     const evenState = this.getState(blockNumber);
     if (evenState) return evenState;
     const onChainState = await this.generateState(blockNumber);
-    this.logger.warn(`State is generated in RPC fallback call`);
     this.setState(onChainState, blockNumber);
     return onChainState;
   }
@@ -284,8 +283,7 @@ export class QuickPerpsEventPool extends ComposedEventSubscriber<PoolState> {
     for (let priceFeed of priceFeeds) {
       const api3ServerAddressCallData =
         Api3FeedSubscriber.getApi3ServerV1MultiCallInput(priceFeed);
-      const dataFeedIdCallData =
-        Api3FeedSubscriber.getDapiNameHashMultiCallInput(priceFeed);
+      const dataFeedIdCallData = Api3FeedSubscriber.getDataFeedId(priceFeed);
       multiCallData.push(...[api3ServerAddressCallData, dataFeedIdCallData]);
       multicallSlices.push([i, i + 2]);
       i += 2;
@@ -317,31 +315,24 @@ export class QuickPerpsEventPool extends ComposedEventSubscriber<PoolState> {
       await multiContract.methods.aggregate(multiCallData).call({}, blockNumber)
     ).returnData;
 
-    const api3ServerV1Prep: {
+    const api3ServerV1: {
       [address: string]: {
         proxy: Address;
         api3ServerV1: Address;
+        dataFeedId: string;
       };
     } = {};
-    const getFeedIdRequests: MultiCallInput[] = [];
-
     for (let token of tokens) {
-      const [api3ServerAddressRes, dapiNameHashRes] = configResults.slice(
+      const [api3ServerAddressRes, dataFeedIdRes] = configResults.slice(
         ...multicallSlices.shift()!,
       );
       const serverV1Address =
         Api3FeedSubscriber.decodeApi3ServerV1Result(api3ServerAddressRes);
-      const dapiNameHash =
-        Api3FeedSubscriber.decodeDapiNameHash(dapiNameHashRes);
-      getFeedIdRequests.push(
-        Api3FeedSubscriber.getFeedIdFromDapiNameHash(
-          serverV1Address,
-          dapiNameHash,
-        ),
-      );
-      api3ServerV1Prep[token] = {
+      const dataFeedId = Api3FeedSubscriber.decodeDataFeedId(dataFeedIdRes);
+      api3ServerV1[token] = {
         proxy: priceFeeds.shift(),
         api3ServerV1: serverV1Address,
+        dataFeedId,
       };
     }
 
@@ -364,32 +355,6 @@ export class QuickPerpsEventPool extends ComposedEventSubscriber<PoolState> {
     const vaultConfigResults = configResults.slice(...multicallSlices.shift()!);
     const vaultConfig = Vault.getConfig(vaultConfigResults, tokens);
 
-    const feedIdResults = (
-      await multiContract.methods
-        .aggregate(getFeedIdRequests)
-        .call({}, blockNumber)
-    ).returnData;
-
-    const api3ServerV1: {
-      [address: string]: {
-        proxy: Address;
-        api3ServerV1: Address;
-        dataFeedId: string;
-      };
-    } = {};
-    for (let [i, token] of tokens.entries()) {
-      const { proxy, api3ServerV1: api3ServerAddress } =
-        api3ServerV1Prep[token];
-      const dataFeedId = Api3FeedSubscriber.decodeFeedIdFromDapiNameHash(
-        feedIdResults[i],
-      );
-      api3ServerV1[token] = {
-        proxy,
-        api3ServerV1: api3ServerAddress,
-        dataFeedId,
-      };
-    }
-
     return {
       vaultAddress: dexParams.vault,
       readerAddress: dexParams.reader,

package/src/dex/quick-perps/quick-perps-events.test.ts

@@ -81,6 +81,7 @@ describe('QuickPerps Event', function () {
             dexKey,
             network,
             dexHelper,
+            logger,
             config,
           );
           await testEventSubscriber(

package/src/dex/quick-perps/quick-perps.ts

@@ -117,55 +117,45 @@ export class QuickPerps extends SimpleExchange implements IDex<QuickPerpsData> {
     limitPools?: string[],
   ): Promise<null | ExchangePrices<QuickPerpsData>> {
     if (side === SwapSide.BUY || !this.pool) return null;
-    try {
-      const srcAddress = this.dexHelper.config
-        .wrapETH(srcToken)
-        .address.toLowerCase();
-      const destAddress = this.dexHelper.config
-        .wrapETH(destToken)
-        .address.toLowerCase();
-      if (
-        srcAddress === destAddress ||
-        !(
-          this.supportedTokensMap[srcAddress] &&
-          this.supportedTokensMap[destAddress]
-        )
+    const srcAddress = this.dexHelper.config
+      .wrapETH(srcToken)
+      .address.toLowerCase();
+    const destAddress = this.dexHelper.config
+      .wrapETH(destToken)
+      .address.toLowerCase();
+    if (
+      srcAddress === destAddress ||
+      !(
+        this.supportedTokensMap[srcAddress] &&
+        this.supportedTokensMap[destAddress]
       )
-        return null;
-      const srcPoolIdentifier = `${this.dexKey}_${srcAddress}`;
-      const destPoolIdentifier = `${this.dexKey}_${destAddress}`;
-      const pools = [srcPoolIdentifier, destPoolIdentifier];
-      if (limitPools && pools.some(p => !limitPools.includes(p))) return null;
+    )
+      return null;
+    const srcPoolIdentifier = `${this.dexKey}_${srcAddress}`;
+    const destPoolIdentifier = `${this.dexKey}_${destAddress}`;
+    const pools = [srcPoolIdentifier, destPoolIdentifier];
+    if (limitPools && pools.some(p => !limitPools.includes(p))) return null;
 
-      const unitVolume = getBigIntPow(srcToken.decimals);
-      const prices = await this.pool.getAmountOut(
-        srcAddress,
-        destAddress,
-        [unitVolume, ...amounts],
-        blockNumber,
-      );
+    const unitVolume = getBigIntPow(srcToken.decimals);
+    const prices = await this.pool.getAmountOut(
+      srcAddress,
+      destAddress,
+      [unitVolume, ...amounts],
+      blockNumber,
+    );
 
-      if (!prices) return null;
+    if (!prices) return null;
 
-      return [
-        {
-          prices: prices.slice(1),
-          unit: prices[0],
-          gasCost: QuickPerpsGasCost,
-          exchange: this.dexKey,
-          data: {},
-          poolAddresses: [this.params.vault],
-        },
-      ];
-    } catch (e) {
-      this.logger.error(
-        `Error_getPrices ${srcToken.symbol || srcToken.address}, ${
-          destToken.symbol || destToken.address
-        }, ${side}: `,
-        e,
-      );
-      return null;
-    }
+    return [
+      {
+        prices: prices.slice(1),
+        unit: prices[0],
+        gasCost: QuickPerpsGasCost,
+        exchange: this.dexKey,
+        data: {},
+        poolAddresses: [this.params.vault],
+      },
+    ];
   }
 
   // Returns estimated gas cost of calldata for this DEX in multiSwap

package/src/dex/solidly/config.ts

@@ -204,5 +204,5 @@ export const Adapters: Record<number, AdapterMappings> = {
   },
   [Network.BASE]: {
     [SwapSide.SELL]: [{ name: 'BaseAdapter01', index: 3 }], // aerodrome, equalizer
-  },
+  }
 };

package/src/dex/solidly/forks-override/aerodrome.ts

@@ -16,7 +16,11 @@ export class Aerodrome extends VelodromeV2 {
     dexKey: string,
     protected dexHelper: IDexHelper,
   ) {
-    super(network, dexKey, dexHelper);
+    super(
+      network,
+      dexKey,
+      dexHelper,
+    );
 
     this.factory = new dexHelper.web3Provider.eth.Contract(
       AerodromeFactoryABI as any,

package/src/dex/uniswap-v3/config.ts

@@ -220,7 +220,8 @@ export const UniswapV3Config: DexConfigMap<DexParams> = {
       chunksCount: 10,
       initRetryFrequency: 10,
       initHash: `0xe34f199b19b2b4f47f68442619d555527d244f78a3297ea89325f843f87b8b54`,
-      subgraphURL: 'https://api.studio.thegraph.com/query/32073/v3-base/v0.0.1',
+      subgraphURL:
+        'https://api.studio.thegraph.com/query/32073/v3-base/v0.0.1',
     },
   },
   ChronosV3: {

package/src/dex/uniswap-v3/uniswap-v3-e2e.test.ts

@@ -429,7 +429,13 @@ describe('UniswapV3 E2E', () => {
             ContractMethod.megaSwap,
           ],
         ],
-        [SwapSide.BUY, [ContractMethod.simpleBuy, ContractMethod.buy]],
+        [
+          SwapSide.BUY,
+          [
+            ContractMethod.simpleBuy,
+            ContractMethod.buy
+          ],
+        ],
       ]);
 
       sideToContractMethods.forEach((contractMethods, side) =>

package/src/dex/uniswap-v3/uniswap-v3-integration.test.ts

@@ -1099,4 +1099,6 @@ describe('SushiSwapV3', () => {
       checkPoolsLiquidity(poolLiquidity, TokenB.address, dexKey);
     });
   });
+
 });
+