@paraswap/dex-lib 4.1.7-pub-sub → 4.1.8

package/src/dex/generic-rfq/generic-rfq.ts

@@ -447,7 +447,12 @@ export class GenericRFQ extends ParaSwapLimitOrders {
   }
 
   async setBlacklist(userAddress: string): Promise<boolean> {
-    return this.rateFetcher.setBlacklist(userAddress);
+    await this.dexHelper.cache.hset(
+      this.rateFetcher.blackListCacheKey,
+      userAddress.toLowerCase(),
+      'true',
+    );
+    return true;
   }
 
   releaseResources(): void {

package/src/dex/generic-rfq/rate-fetcher.ts

@@ -37,7 +37,6 @@ import {
   ERC1271Contract,
 } from '../../lib/erc1271-utils';
 import { isContractAddress } from '../../utils';
-import { ExpKeyValuePubSub, NonExpSetPubSub } from '../../lib/pub-sub';
 
 const GET_FIRM_RATE_TIMEOUT_MS = 2000;
 export const reversePrice = (price: PriceAndAmountBigNumber) =>
@@ -46,7 +45,6 @@ export const reversePrice = (price: PriceAndAmountBigNumber) =>
     price[1].times(price[0]),
   ] as PriceAndAmountBigNumber;
 
-const logPrefix = 'RateFetched[pub_sub]';
 export class RateFetcher {
   private tokensFetcher: Fetcher<TokensResponse>;
   private pairsFetcher: Fetcher<PairsResponse>;
@@ -57,9 +55,6 @@ export class RateFetcher {
   private addressToTokenMap: Record<string, TokenWithInfo> = {};
   private pairs: PairMap = {};
 
-  private pricesPubSub: ExpKeyValuePubSub;
-  private blacklistPubSub?: NonExpSetPubSub;
-
   private firmRateAuth?: (options: RequestConfig) => void;
 
   public blackListCacheKey: string;
@@ -128,13 +123,6 @@ export class RateFetcher {
       logger,
     );
 
-    this.pricesPubSub = new ExpKeyValuePubSub(
-      this.dexHelper,
-      this.dexKey,
-      'prices',
-    );
-
-    this.blackListCacheKey = `${this.dexHelper.config.data.network}_${this.dexKey}_blacklist`;
     if (config.blacklistConfig) {
       this.blackListFetcher = new Fetcher<BlackListResponse>(
         dexHelper.httpRequest,
@@ -154,21 +142,15 @@ export class RateFetcher {
         config.blacklistConfig.intervalMs,
         logger,
       );
-
-      this.blacklistPubSub = new NonExpSetPubSub(
-        this.dexHelper,
-        this.dexKey,
-        'blacklist',
-      );
     }
 
+    this.blackListCacheKey = `${this.dexHelper.config.data.network}_${this.dexKey}_blacklist`;
     if (this.config.firmRateConfig.secret) {
       this.firmRateAuth = this.authHttp(this.config.firmRateConfig.secret);
     }
   }
 
   async initialize() {
-    this.logger.info(`${logPrefix} Initializing rate fetcher`);
     const isContract = await isContractAddress(
       this.dexHelper.web3Provider,
       this.config.maker,
@@ -179,22 +161,9 @@ export class RateFetcher {
         this.config.maker,
       );
     }
-
-    if (this.dexHelper.config.isSlave) {
-      this.logger.info(`${logPrefix} Subscribing to prices pubsub`);
-      this.pricesPubSub.subscribe();
-      if (this.blacklistPubSub) {
-        this.logger.info(`${logPrefix} Subscribing to blacklist pubsub`);
-        const initSet = await this.dexHelper.cache.smembers(
-          this.blackListCacheKey,
-        );
-        this.blacklistPubSub.initializeAndSubscribe(initSet);
-      }
-    }
   }
 
   start() {
-    this.logger.info(`${logPrefix} Starting rate fetcher`);
     this.tokensFetcher.startPolling();
     this.rateFetcher.startPolling();
     this.pairsFetcher.startPolling();
@@ -204,7 +173,6 @@ export class RateFetcher {
   }
 
   stop() {
-    this.logger.info(`${logPrefix} Stopping rate fetcher`);
     this.tokensFetcher.stopPolling();
     this.pairsFetcher.stopPolling();
     this.rateFetcher.stopPolling();
@@ -215,10 +183,6 @@ export class RateFetcher {
   }
 
   private handleTokensResponse(data: TokensResponse) {
-    this.logger.info(
-      `${logPrefix} Handling tokens response, tokens: `,
-      Object.keys(data.tokens).length,
-    );
     for (const tokenName of Object.keys(data.tokens)) {
       const token = data.tokens[tokenName];
       token.address = token.address.toLowerCase();
@@ -236,10 +200,6 @@ export class RateFetcher {
   }
 
   private handlePairsResponse(resp: PairsResponse) {
-    this.logger.info(
-      `${logPrefix} Handling pairs response, pairs: `,
-      Object.keys(resp.pairs).length,
-    );
     this.pairs = {};
 
     const pairs: PairMap = {};
@@ -251,37 +211,19 @@ export class RateFetcher {
   }
 
   private handleBlackListResponse(resp: BlackListResponse) {
-    this.logger.info(
-      `${logPrefix} Handling blacklist response, blacklist length: `,
-      resp.blacklist.length,
-    );
     for (const address of resp.blacklist) {
       this.dexHelper.cache.sadd(this.blackListCacheKey, address.toLowerCase());
     }
-
-    if (this.blacklistPubSub) {
-      this.logger.info(
-        `${logPrefix} Publishing blacklist to pubsub, blacklist length: `,
-        resp.blacklist.length,
-      );
-      this.blacklistPubSub.publish(resp.blacklist);
-    }
   }
 
   public isBlackListed(userAddress: string) {
-    if (this.blacklistPubSub) {
-      return this.blacklistPubSub.has(userAddress.toLowerCase());
-    }
-    return false;
+    return this.dexHelper.cache.sismember(
+      this.blackListCacheKey,
+      userAddress.toLowerCase(),
+    );
   }
 
   private handleRatesResponse(resp: RatesResponse) {
-    this.logger.info(
-      `${logPrefix} Handling rates response, prices length: `,
-      Object.keys(resp.prices).length,
-    );
-    const pubSubData: Record<string, unknown> = {};
-    const ttl = this.config.rateConfig.dataTTLS;
     const pairs = this.pairs;
 
     if (isEmpty(pairs)) return;
@@ -310,51 +252,37 @@ export class RateFetcher {
       }
 
       if (prices.bids.length) {
-        const key = `${baseToken.address}_${quoteToken.address}_bids`;
-        const value = prices.bids;
-        pubSubData[key] = value;
-
         this.dexHelper.cache.setex(
           this.dexKey,
           this.dexHelper.config.data.network,
-          key,
-          ttl,
-          JSON.stringify(value),
+          `${baseToken.address}_${quoteToken.address}_bids`,
+          this.config.rateConfig.dataTTLS,
+          JSON.stringify(prices.bids),
         );
         currentPricePairs.add(`${baseToken.address}_${quoteToken.address}`);
       }
 
       if (prices.asks.length) {
-        const key = `${baseToken.address}_${quoteToken.address}_asks`;
-        const value = prices.asks;
-        pubSubData[key] = value;
-
         this.dexHelper.cache.setex(
           this.dexKey,
           this.dexHelper.config.data.network,
-          key,
-          ttl,
-          JSON.stringify(value),
+          `${baseToken.address}_${quoteToken.address}_asks`,
+          this.config.rateConfig.dataTTLS,
+          JSON.stringify(prices.asks),
         );
         currentPricePairs.add(`${quoteToken.address}_${baseToken.address}`);
       }
     });
 
     if (currentPricePairs.size > 0) {
-      const key = `pairs`;
-      const value = Array.from(currentPricePairs);
-      pubSubData[key] = value;
-
       this.dexHelper.cache.setex(
         this.dexKey,
         this.dexHelper.config.data.network,
-        key,
-        ttl,
-        JSON.stringify(value),
+        `pairs`,
+        this.config.rateConfig.dataTTLS,
+        JSON.stringify(Array.from(currentPricePairs)),
       );
     }
-
-    this.pricesPubSub.publish(pubSubData, ttl);
   }
 
   checkHealth(): boolean {
@@ -394,16 +322,18 @@ export class RateFetcher {
   }
 
   public async getAvailablePairs(): Promise<string[]> {
-    const pairs = await this.pricesPubSub.getAndCache<string[]>(`pairs`);
-    this.logger.info(
-      `${logPrefix} Getting available pairs, pairs: `,
-      pairs?.length,
+    const pairs = await this.dexHelper.cache.getAndCacheLocally(
+      this.dexKey,
+      this.dexHelper.config.data.network,
+      `pairs`,
+      this.config.rateConfig.intervalMs / 1000,
     );
+
     if (!pairs) {
       return [];
     }
 
-    return pairs;
+    return JSON.parse(pairs) as string[];
   }
 
   public async getOrderPrice(
@@ -413,36 +343,53 @@ export class RateFetcher {
   ): Promise<PriceAndAmountBigNumber[] | null> {
     let reversed = false;
 
-    let prices: PriceAndAmount[] | null = null;
+    let pricesAsString: string | null = null;
     if (side === SwapSide.SELL) {
-      prices = await this.pricesPubSub.getAndCache(
+      pricesAsString = await this.dexHelper.cache.getAndCacheLocally(
+        this.dexKey,
+        this.dexHelper.config.data.network,
         `${srcToken.address}_${destToken.address}_bids`,
+        this.config.rateConfig.intervalMs / 1000,
       );
 
-      if (!prices) {
-        prices = await this.pricesPubSub.getAndCache(
+      if (!pricesAsString) {
+        pricesAsString = await this.dexHelper.cache.getAndCacheLocally(
+          this.dexKey,
+          this.dexHelper.config.data.network,
           `${destToken.address}_${srcToken.address}_asks`,
+          this.config.rateConfig.intervalMs / 1000,
         );
         reversed = true;
       }
     } else {
-      prices = await this.pricesPubSub.getAndCache(
+      pricesAsString = await this.dexHelper.cache.getAndCacheLocally(
+        this.dexKey,
+        this.dexHelper.config.data.network,
         `${destToken.address}_${srcToken.address}_asks`,
+        this.config.rateConfig.intervalMs / 1000,
       );
 
-      if (!prices) {
-        prices = await this.pricesPubSub.getAndCache(
+      if (!pricesAsString) {
+        pricesAsString = await this.dexHelper.cache.getAndCacheLocally(
+          this.dexKey,
+          this.dexHelper.config.data.network,
           `${srcToken.address}_${destToken.address}_bids`,
+          this.config.rateConfig.intervalMs / 1000,
         );
         reversed = true;
       }
     }
 
-    if (!prices) {
+    if (!pricesAsString) {
+      return null;
+    }
+
+    const orderPricesAsString: PriceAndAmount[] = JSON.parse(pricesAsString);
+    if (!orderPricesAsString) {
       return null;
     }
 
-    let orderPrices = prices.map(price => [
+    let orderPrices = orderPricesAsString.map(price => [
       new BigNumber(price[0]),
       new BigNumber(price[1]),
     ]);
@@ -541,16 +488,4 @@ export class RateFetcher {
       throw e;
     }
   }
-
-  async setBlacklist(userAddress: string): Promise<boolean> {
-    await this.dexHelper.cache.hset(
-      this.blackListCacheKey,
-      userAddress.toLowerCase(),
-      'true',
-    );
-    if (this.blacklistPubSub) {
-      this.blacklistPubSub.publish([userAddress.toLowerCase()]);
-    }
-    return true;
-  }
 }

package/src/dex/hashflow/hashflow-gas-estimation.test.ts

@@ -0,0 +1,30 @@
+/* eslint-disable no-console */
+import 'dotenv/config';
+import { testGasEstimation } from '../../../tests/utils-e2e';
+import { Tokens } from '../../../tests/constants-e2e';
+import { Network, SwapSide } from '../../constants';
+import { ContractMethodV6 } from '@paraswap/core';
+
+describe('Hashflow Gas Estimation', () => {
+  const dexKey = 'Hashflow';
+  const network = Network.MAINNET;
+
+  describe('swapExactAmountIn', () => {
+    const USDT = Tokens[network]['USDT'];
+    const USDC = Tokens[network]['USDC'];
+    const amount = 100000000n;
+
+    // todo: fix tx build
+    it('tradeRFQT', async () => {
+      await testGasEstimation(
+        network,
+        USDT,
+        USDC,
+        amount,
+        SwapSide.SELL,
+        dexKey,
+        ContractMethodV6.swapExactAmountIn,
+      );
+    });
+  });
+});

package/src/dex/idle-dao/idle-dao--gas-estimation.test.ts

@@ -0,0 +1,30 @@
+/* eslint-disable no-console */
+import 'dotenv/config';
+import { testGasEstimation } from '../../../tests/utils-e2e';
+import { Tokens } from '../../../tests/constants-e2e';
+import { Network, SwapSide } from '../../constants';
+import { ContractMethodV6 } from '@paraswap/core';
+
+describe('IdleDao Gas Estimation', () => {
+  const dexKey = 'IdleDao';
+  const network = Network.MAINNET;
+
+  describe('swapExactAmountIn', () => {
+    const STETH = Tokens[network]['STETH'];
+    const AA_wstETH = Tokens[network]['AA_wstETH'];
+    const amount = 1000000000000000000n;
+
+    // todo: uncomment? (the dex doesn't seem to be working)
+    // it('deposit', async () => {
+    //   await testGasEstimation(
+    //     network,
+    //     STETH,
+    //     AA_wstETH,
+    //     amount,
+    //     SwapSide.SELL,
+    //     dexKey,
+    //     ContractMethodV6.swapExactAmountIn,
+    //   );
+    // });
+  });
+});

package/src/dex/lido/lido-gas-estimation.test.ts

@@ -0,0 +1,29 @@
+/* eslint-disable no-console */
+import 'dotenv/config';
+import { testGasEstimation } from '../../../tests/utils-e2e';
+import { Tokens } from '../../../tests/constants-e2e';
+import { Network, SwapSide } from '../../constants';
+import { ContractMethodV6 } from '@paraswap/core';
+
+describe('Lido Gas Estimation', () => {
+  const dexKey = 'Lido';
+  const network = Network.MAINNET;
+
+  describe('swapExactAmountIn', () => {
+    const STETH = Tokens[network]['STETH'];
+    const ETH = Tokens[network]['ETH'];
+    const amount = 100000000000000000000n;
+
+    it('submit', async () => {
+      await testGasEstimation(
+        network,
+        ETH,
+        STETH,
+        amount,
+        SwapSide.SELL,
+        dexKey,
+        ContractMethodV6.swapExactAmountIn,
+      );
+    });
+  });
+});

package/src/dex/lite-psm/lite-psm-gas-estimation.test.ts

@@ -0,0 +1,34 @@
+/* eslint-disable no-console */
+import dotenv from 'dotenv';
+import { testGasEstimation } from '../../../tests/utils-e2e';
+import { Tokens } from '../../../tests/constants-e2e';
+import { Network, SwapSide } from '../../constants';
+import { ContractMethodV6 } from '@paraswap/core';
+
+dotenv.config();
+
+describe('LitePsm Gas Estimation', () => {
+  const dexKey = 'LitePsm';
+  const network = Network.MAINNET;
+  const srcToken = Tokens[network]['USDC'];
+  const destToken = Tokens[network]['DAI'];
+  const methods: ContractMethodV6[] = [
+    ContractMethodV6.swapExactAmountInOutOnMakerPSM,
+    ContractMethodV6.swapExactAmountIn,
+  ];
+  const amount = 10000000n;
+
+  methods.forEach(async method => {
+    it(method, async () => {
+      await testGasEstimation(
+        network,
+        srcToken,
+        destToken,
+        amount,
+        SwapSide.SELL,
+        dexKey,
+        method,
+      );
+    });
+  });
+});

package/src/dex/maker-psm/maker-psm-gas-estimation.test.ts

@@ -0,0 +1,34 @@
+/* eslint-disable no-console */
+import dotenv from 'dotenv';
+import { testGasEstimation } from '../../../tests/utils-e2e';
+import { Tokens } from '../../../tests/constants-e2e';
+import { Network, SwapSide } from '../../constants';
+import { ContractMethodV6 } from '@paraswap/core';
+
+dotenv.config();
+
+describe('MakerPsm Gas Estimation', () => {
+  const dexKey = 'MakerPsm';
+  const network = Network.MAINNET;
+  const srcToken = Tokens[network]['USDC'];
+  const destToken = Tokens[network]['DAI'];
+  const methods: ContractMethodV6[] = [
+    ContractMethodV6.swapExactAmountInOutOnMakerPSM,
+    ContractMethodV6.swapExactAmountIn,
+  ];
+  const amount = 10000000n;
+
+  methods.forEach(async method => {
+    it(method, async () => {
+      await testGasEstimation(
+        network,
+        srcToken,
+        destToken,
+        amount,
+        SwapSide.SELL,
+        dexKey,
+        method,
+      );
+    });
+  });
+});

package/src/dex/maverick-v1/maverick-v1-gas-estimation.test.ts

@@ -0,0 +1,29 @@
+/* eslint-disable no-console */
+import 'dotenv/config';
+import { testGasEstimation } from '../../../tests/utils-e2e';
+import { Tokens } from '../../../tests/constants-e2e';
+import { Network, SwapSide } from '../../constants';
+import { ContractMethodV6 } from '@paraswap/core';
+
+describe('MaverickV1 Gas Estimation', () => {
+  const dexKey = 'MaverickV1';
+  const network = Network.MAINNET;
+
+  describe('swapExactAmountIn', () => {
+    const USDT = Tokens[network]['USDT'];
+    const USDC = Tokens[network]['USDC'];
+    const amount = 1000000n;
+
+    it('exactInputSingle', async () => {
+      await testGasEstimation(
+        network,
+        USDT,
+        USDC,
+        amount,
+        SwapSide.SELL,
+        dexKey,
+        ContractMethodV6.swapExactAmountIn,
+      );
+    });
+  });
+});

package/src/dex/maverick-v2/maverick-v2-gas-estimation.test.ts

@@ -0,0 +1,29 @@
+/* eslint-disable no-console */
+import 'dotenv/config';
+import { testGasEstimation } from '../../../tests/utils-e2e';
+import { Tokens } from '../../../tests/constants-e2e';
+import { Network, SwapSide } from '../../constants';
+import { ContractMethodV6 } from '@paraswap/core';
+
+describe('MaverickV2 Gas Estimation', () => {
+  const dexKey = 'MaverickV2';
+  const network = Network.MAINNET;
+
+  describe('swapExactAmountIn', () => {
+    const USDT = Tokens[network]['USDT'];
+    const USDC = Tokens[network]['USDC'];
+    const amount = 100000000n;
+
+    it('swap', async () => {
+      await testGasEstimation(
+        network,
+        USDT,
+        USDC,
+        amount,
+        SwapSide.SELL,
+        dexKey,
+        ContractMethodV6.swapExactAmountIn,
+      );
+    });
+  });
+});

package/src/dex/pancakeswap-v3/pancakeswap-v3-gas-estimation.test.ts

@@ -0,0 +1,29 @@
+/* eslint-disable no-console */
+import 'dotenv/config';
+import { testGasEstimation } from '../../../tests/utils-e2e';
+import { Tokens } from '../../../tests/constants-e2e';
+import { Network, SwapSide } from '../../constants';
+import { ContractMethodV6 } from '@paraswap/core';
+
+describe('PancakeswapV3 Gas Estimation', () => {
+  const dexKey = 'PancakeswapV3';
+  const network = Network.MAINNET;
+
+  describe('swapExactAmountIn', () => {
+    const USDT = Tokens[network]['USDT'];
+    const USDC = Tokens[network]['USDC'];
+    const amount = 100000000n;
+
+    it('exactInput', async () => {
+      await testGasEstimation(
+        network,
+        USDT,
+        USDC,
+        amount,
+        SwapSide.SELL,
+        dexKey,
+        ContractMethodV6.swapExactAmountIn,
+      );
+    });
+  });
+});

package/src/dex/polygon-migrator/polygon-migrator-gas-estimation.test.ts

@@ -0,0 +1,41 @@
+/* eslint-disable no-console */
+import 'dotenv/config';
+import { testGasEstimation } from '../../../tests/utils-e2e';
+import { Tokens } from '../../../tests/constants-e2e';
+import { Network, SwapSide } from '../../constants';
+import { ContractMethodV6 } from '@paraswap/core';
+
+describe('PolygonMigrator Gas Estimation', () => {
+  const dexKey = 'PolygonMigrator';
+  const network = Network.MAINNET;
+
+  describe('swapExactAmountIn', () => {
+    const POL = Tokens[network]['POL'];
+    const MATIC = Tokens[network]['MATIC'];
+    const amount = 10000000000000000000n;
+
+    it('unmigrate', async () => {
+      await testGasEstimation(
+        network,
+        POL,
+        MATIC,
+        amount,
+        SwapSide.SELL,
+        dexKey,
+        ContractMethodV6.swapExactAmountIn,
+      );
+    });
+
+    it('migrate', async () => {
+      await testGasEstimation(
+        network,
+        MATIC,
+        POL,
+        amount,
+        SwapSide.SELL,
+        dexKey,
+        ContractMethodV6.swapExactAmountIn,
+      );
+    });
+  });
+});