@paraswap/dex-lib 4.1.9 → 4.1.10-pubsub

package/src/dex/aave-v3-stata/config.ts

@@ -17,28 +17,28 @@ import {
 export const AaveV3StataConfig: DexConfigMap<DexParams> = {
   AaveV3Stata: {
     [Network.MAINNET]: {
-      factoryAddress: AaveV3Ethereum.STATIC_A_TOKEN_FACTORY,
+      factoryAddress: AaveV3Ethereum.LEGACY_STATIC_A_TOKEN_FACTORY,
     },
     [Network.POLYGON]: {
-      factoryAddress: AaveV3Polygon.STATIC_A_TOKEN_FACTORY,
+      factoryAddress: AaveV3Polygon.LEGACY_STATIC_A_TOKEN_FACTORY,
     },
     [Network.AVALANCHE]: {
-      factoryAddress: AaveV3Avalanche.STATIC_A_TOKEN_FACTORY,
+      factoryAddress: AaveV3Avalanche.LEGACY_STATIC_A_TOKEN_FACTORY,
     },
     [Network.ARBITRUM]: {
-      factoryAddress: AaveV3Arbitrum.STATIC_A_TOKEN_FACTORY,
+      factoryAddress: AaveV3Arbitrum.LEGACY_STATIC_A_TOKEN_FACTORY,
     },
     [Network.OPTIMISM]: {
-      factoryAddress: AaveV3Optimism.STATIC_A_TOKEN_FACTORY,
+      factoryAddress: AaveV3Optimism.LEGACY_STATIC_A_TOKEN_FACTORY,
     },
     [Network.BASE]: {
-      factoryAddress: AaveV3Base.STATIC_A_TOKEN_FACTORY,
+      factoryAddress: AaveV3Base.LEGACY_STATIC_A_TOKEN_FACTORY,
     },
     [Network.BSC]: {
-      factoryAddress: AaveV3BNB.STATIC_A_TOKEN_FACTORY,
+      factoryAddress: AaveV3BNB.LEGACY_STATIC_A_TOKEN_FACTORY,
     },
     [Network.GNOSIS]: {
-      factoryAddress: AaveV3Gnosis.STATIC_A_TOKEN_FACTORY,
+      factoryAddress: AaveV3Gnosis.LEGACY_STATIC_A_TOKEN_FACTORY,
     },
     // [Network.Scroll]: {
     //   factoryAddress: AaveV3Scroll.STATIC_A_TOKEN_FACTORY,

package/src/dex/aave-v3-stata-v2/aave-v3-stata-v2-e2e.test.ts

@@ -264,28 +264,28 @@ describe('AaveV3Stata E2E', () => {
   });
 
   // no tokens yet deployed
-  describe.skip('Optimism', () => {
+  describe('Optimism', () => {
     const network = Network.OPTIMISM;
 
     const pairs: { name: string; amount: string; skipBuy?: boolean }[][] = [
       [
         {
-          name: 'USDT',
+          name: 'USDC',
           amount: '100000',
         },
         {
-          name: 'stataUSDT',
+          name: 'stataUSDC',
           amount: '100000',
         },
       ],
       [
         {
-          name: 'aaveUSDT',
+          name: 'aOptUSDCn',
           amount: '100000',
           skipBuy: true,
         },
         {
-          name: 'stataUSDT',
+          name: 'stataUSDC', // no holders
           amount: '100000',
         },
       ],

package/src/dex/aave-v3-stata-v2/aave-v3-stata-v2.ts

@@ -103,7 +103,7 @@ export class AaveV3StataV2
 
     let tokenList = await fetchTokenList(
       this.dexHelper.web3Provider,
-      this.config.factoryAddresses,
+      this.config,
       this.dexHelper.multiWrapper,
       blockNumber,
     );
@@ -216,7 +216,7 @@ export class AaveV3StataV2
         true,
         [
           {
-            target: this.config.pool,
+            target: stataToken.pool,
             callData: AaveV3StataV2.pool.encodeFunctionData(
               'getReserveNormalizedIncome',
               [stataToken.underlying],

package/src/dex/aave-v3-stata-v2/config.ts

@@ -12,29 +12,36 @@ import {
 
 export const AaveV3StataConfig: DexConfigMap<DexParams> = {
   AaveV3StataV2: {
-    [Network.MAINNET]: {
-      factoryAddresses: [
-        AaveV3Ethereum.STATA_FACTORY,
-        AaveV3EthereumLido.STATA_FACTORY,
-      ],
-      pool: AaveV3Ethereum.POOL,
-    },
-    [Network.GNOSIS]: {
-      factoryAddresses: [AaveV3Gnosis.STATA_FACTORY],
-      pool: AaveV3Gnosis.POOL,
-    },
-    // Waiting for BalancerV3 to get released on Optimism
-    // [Network.OPTIMISM]: {
-    //   factoryAddresses: [AaveV3Optimism.STATA_FACTORY],
-    //   pool: AaveV3Optimism.POOL,
-    // },
-    [Network.ARBITRUM]: {
-      factoryAddresses: [AaveV3Arbitrum.STATA_FACTORY],
-      pool: AaveV3Arbitrum.POOL,
-    },
-    [Network.BASE]: {
-      factoryAddresses: [AaveV3Base.STATA_FACTORY],
-      pool: AaveV3Base.POOL,
-    },
+    [Network.MAINNET]: [
+      { factory: AaveV3Ethereum.STATA_FACTORY, pool: AaveV3Ethereum.POOL },
+      {
+        factory: AaveV3EthereumLido.STATA_FACTORY,
+        pool: AaveV3EthereumLido.POOL,
+      },
+    ],
+    [Network.GNOSIS]: [
+      {
+        factory: AaveV3Gnosis.STATA_FACTORY,
+        pool: AaveV3Gnosis.POOL,
+      },
+    ],
+    [Network.OPTIMISM]: [
+      {
+        factory: AaveV3Optimism.STATA_FACTORY,
+        pool: AaveV3Optimism.POOL,
+      },
+    ],
+    [Network.ARBITRUM]: [
+      {
+        factory: AaveV3Arbitrum.STATA_FACTORY,
+        pool: AaveV3Arbitrum.POOL,
+      },
+    ],
+    [Network.BASE]: [
+      {
+        factory: AaveV3Base.STATA_FACTORY,
+        pool: AaveV3Base.POOL,
+      },
+    ],
   },
 };

package/src/dex/aave-v3-stata-v2/types.ts

@@ -8,9 +8,9 @@ export enum TokenType {
 }
 
 export type DexParams = {
-  factoryAddresses: string[];
+  factory: string;
   pool: string;
-};
+}[];
 
 export type AaveV3StataV2Data = {
   exchange: Address;
@@ -24,6 +24,7 @@ export type StataToken = {
   underlyingAToken: string;
   stataSymbol: string;
   decimals: number;
+  pool: string;
 };
 
 export enum StataFunctions {

package/src/dex/aave-v3-stata-v2/utils.ts

@@ -6,21 +6,26 @@ import { Interface } from '@ethersproject/abi';
 import Web3 from 'web3';
 import { MultiCallParams, MultiWrapper } from '../../lib/multi-wrapper';
 import { stringDecode, uint8ToNumber, addressDecode } from '../../lib/decoders';
-import { StataToken } from './types';
+import { StataToken, DexParams } from './types';
 import FactoryABI from '../../abi/aavev3statav2/Factory.json';
 import TokenABI from '../../abi/aavev3statav2/Token.json';
 import { AbiItem } from 'web3-utils';
 
+type PoolAndToken = {
+  token: string;
+  pool: string;
+};
+
 // const stataInterface = new Interface(IStaticATokenLM_ABI);
 const statav2Interface = new Interface(TokenABI);
 
 async function getTokenMetaData(
-  stataTokens: string[],
+  stataTokens: PoolAndToken[],
   multiWrapper: MultiWrapper,
   blockNumber?: number,
 ): Promise<StataToken[]> {
   const calls: MultiCallParams<any>[] = stataTokens
-    .map(token => {
+    .map(({ token }) => {
       return [
         {
           target: token,
@@ -54,7 +59,8 @@ async function getTokenMetaData(
   let tokenList: StataToken[] = [];
   for (let i = 0, x = 0; i < stataTokens.length; ++i, x += 4) {
     tokenList.push({
-      address: stataTokens[i].toLowerCase(),
+      address: stataTokens[i].token.toLowerCase(),
+      pool: stataTokens[i].pool.toLowerCase(),
       stataSymbol: results[x] as string,
       decimals: results[x + 1] as number,
       underlying: (results[x + 2] as string).toLowerCase(),
@@ -66,22 +72,24 @@ async function getTokenMetaData(
 
 export const fetchTokenList = async (
   web3Provider: Web3,
-  factoryAddresses: string[],
+  config: DexParams,
   multiWrapper: MultiWrapper,
   blockNumber?: number,
 ): Promise<StataToken[]> => {
-  let stataList: string[] = (
+  let stataList: PoolAndToken[] = (
     (await Promise.all(
-      factoryAddresses.map(async factoryAddress => {
+      config.map(async ({ factory, pool }) => {
         let factoryContract = new web3Provider.eth.Contract(
           FactoryABI as AbiItem[],
           // IStaticATokenFactory_ABI as any,
-          factoryAddress,
+          factory,
         );
 
-        return await factoryContract.methods.getStataTokens().call();
+        return (
+          (await factoryContract.methods.getStataTokens().call()) as string[]
+        ).map(address => ({ token: address, pool }));
       }),
-    )) as string[][]
+    )) as PoolAndToken[][]
   ).flat();
 
   return getTokenMetaData(stataList, multiWrapper, blockNumber);

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

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

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

@@ -37,6 +37,7 @@ 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) =>
@@ -55,6 +56,9 @@ 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;
@@ -123,6 +127,13 @@ 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,
@@ -142,9 +153,14 @@ 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);
     }
@@ -161,6 +177,30 @@ export class RateFetcher {
         this.config.maker,
       );
     }
+
+    this.logger.info(
+      `Initializing RateFetcher for ${this.dexKey}, isSlave=${this.dexHelper.config.isSlave}`,
+    );
+
+    if (this.dexHelper.config.isSlave) {
+      this.logger.info(
+        `Subscribing to price updates as slave for ${this.dexKey}`,
+      );
+      this.pricesPubSub.subscribe();
+      if (this.blacklistPubSub) {
+        const initSet = await this.dexHelper.cache.smembers(
+          this.blackListCacheKey,
+        );
+        this.logger.info(
+          `Initializing blacklist with ${initSet.length} entries`,
+        );
+        this.blacklistPubSub.initializeAndSubscribe(initSet);
+      }
+    } else {
+      this.logger.info(
+        `Not subscribing to price updates as master for ${this.dexKey}`,
+      );
+    }
   }
 
   start() {
@@ -214,74 +254,110 @@ export class RateFetcher {
     for (const address of resp.blacklist) {
       this.dexHelper.cache.sadd(this.blackListCacheKey, address.toLowerCase());
     }
+
+    if (this.blacklistPubSub) {
+      this.blacklistPubSub.publish(resp.blacklist);
+    }
   }
 
   public isBlackListed(userAddress: string) {
-    return this.dexHelper.cache.sismember(
-      this.blackListCacheKey,
-      userAddress.toLowerCase(),
-    );
+    if (this.blacklistPubSub) {
+      return this.blacklistPubSub.has(userAddress.toLowerCase());
+    }
+    return false;
   }
 
   private handleRatesResponse(resp: RatesResponse) {
+    const pubSubData: Record<string, unknown> = {};
+    const ttl = this.config.rateConfig.dataTTLS;
     const pairs = this.pairs;
 
-    if (isEmpty(pairs)) return;
+    if (isEmpty(pairs)) {
+      this.logger.debug(`No pairs available for ${this.dexKey}`);
+      return;
+    }
 
     const currentPricePairs = new Set();
+    let updatedPairsCount = 0;
 
     Object.keys(resp.prices).forEach(pairName => {
       const pair = pairs[pairName];
       if (!pair) {
+        this.logger.debug(`Pair ${pairName} not found in available pairs`);
         return;
       }
       const prices = resp.prices[pairName];
 
       if (!prices.asks || !prices.bids) {
+        this.logger.debug(`No asks or bids for pair ${pairName}`);
         return;
       }
 
-      if (isEmpty(this.tokens)) return;
+      if (isEmpty(this.tokens)) {
+        this.logger.debug(`No tokens available for ${this.dexKey}`);
+        return;
+      }
 
       const baseToken = this.tokens[pair.base];
       const quoteToken = this.tokens[pair.quote];
 
       if (!baseToken || !quoteToken) {
-        this.logger.warn(`missing base or quote token`);
+        this.logger.warn(`Missing base or quote token for pair ${pairName}`);
         return;
       }
 
       if (prices.bids.length) {
+        const key = `${baseToken.address}_${quoteToken.address}_bids`;
+        const value = prices.bids;
+        pubSubData[key] = value;
+        updatedPairsCount++;
+
         this.dexHelper.cache.setex(
           this.dexKey,
           this.dexHelper.config.data.network,
-          `${baseToken.address}_${quoteToken.address}_bids`,
-          this.config.rateConfig.dataTTLS,
-          JSON.stringify(prices.bids),
+          key,
+          ttl,
+          JSON.stringify(value),
         );
         currentPricePairs.add(`${baseToken.address}_${quoteToken.address}`);
       }
 
       if (prices.asks.length) {
+        const key = `${baseToken.address}_${quoteToken.address}_asks`;
+        const value = prices.asks;
+        pubSubData[key] = value;
+        updatedPairsCount++;
+
         this.dexHelper.cache.setex(
           this.dexKey,
           this.dexHelper.config.data.network,
-          `${baseToken.address}_${quoteToken.address}_asks`,
-          this.config.rateConfig.dataTTLS,
-          JSON.stringify(prices.asks),
+          key,
+          ttl,
+          JSON.stringify(value),
         );
         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,
-        `pairs`,
-        this.config.rateConfig.dataTTLS,
-        JSON.stringify(Array.from(currentPricePairs)),
+        key,
+        ttl,
+        JSON.stringify(value),
+      );
+
+      this.logger.info(
+        `Updated ${updatedPairsCount} price entries for ${currentPricePairs.size} pairs`,
       );
+      this.pricesPubSub.publish(pubSubData, ttl);
+    } else {
+      this.logger.warn(`No price pairs were updated for ${this.dexKey}`);
     }
   }
 
@@ -322,18 +398,12 @@ export class RateFetcher {
   }
 
   public async getAvailablePairs(): Promise<string[]> {
-    const pairs = await this.dexHelper.cache.getAndCacheLocally(
-      this.dexKey,
-      this.dexHelper.config.data.network,
-      `pairs`,
-      this.config.rateConfig.intervalMs / 1000,
-    );
-
+    const pairs = await this.pricesPubSub.getAndCache<string[]>(`pairs`);
     if (!pairs) {
       return [];
     }
 
-    return JSON.parse(pairs) as string[];
+    return pairs;
   }
 
   public async getOrderPrice(
@@ -342,54 +412,44 @@ export class RateFetcher {
     side: SwapSide,
   ): Promise<PriceAndAmountBigNumber[] | null> {
     let reversed = false;
+    const srcAddress = srcToken.address.toLowerCase();
+    const destAddress = destToken.address.toLowerCase();
+
+    let prices: PriceAndAmount[] | null = null;
+    let cacheKey = '';
 
-    let pricesAsString: string | null = null;
     if (side === SwapSide.SELL) {
-      pricesAsString = await this.dexHelper.cache.getAndCacheLocally(
-        this.dexKey,
-        this.dexHelper.config.data.network,
-        `${srcToken.address}_${destToken.address}_bids`,
-        this.config.rateConfig.intervalMs / 1000,
-      );
+      cacheKey = `${srcAddress}_${destAddress}_bids`;
+      prices = await this.pricesPubSub.getAndCache(cacheKey);
 
-      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,
-        );
+      if (!prices) {
+        cacheKey = `${destAddress}_${srcAddress}_asks`;
+        prices = await this.pricesPubSub.getAndCache(cacheKey);
         reversed = true;
       }
     } else {
-      pricesAsString = await this.dexHelper.cache.getAndCacheLocally(
-        this.dexKey,
-        this.dexHelper.config.data.network,
-        `${destToken.address}_${srcToken.address}_asks`,
-        this.config.rateConfig.intervalMs / 1000,
-      );
+      cacheKey = `${destAddress}_${srcAddress}_asks`;
+      prices = await this.pricesPubSub.getAndCache(cacheKey);
 
-      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,
-        );
+      if (!prices) {
+        cacheKey = `${srcAddress}_${destAddress}_bids`;
+        prices = await this.pricesPubSub.getAndCache(cacheKey);
         reversed = true;
       }
     }
 
-    if (!pricesAsString) {
+    if (!prices) {
+      this.logger.debug(
+        `No prices found for ${srcAddress} to ${destAddress} (${side}) using key ${cacheKey}`,
+      );
       return null;
     }
 
-    const orderPricesAsString: PriceAndAmount[] = JSON.parse(pricesAsString);
-    if (!orderPricesAsString) {
-      return null;
-    }
+    this.logger.debug(
+      `Found ${prices.length} prices for ${srcAddress} to ${destAddress} (${side}), reversed=${reversed}`,
+    );
 
-    let orderPrices = orderPricesAsString.map(price => [
+    let orderPrices = prices.map(price => [
       new BigNumber(price[0]),
       new BigNumber(price[1]),
     ]);
@@ -488,4 +548,16 @@ 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.ts

@@ -191,6 +191,9 @@ export class Hashflow extends SimpleExchange implements IDex<HashflowData> {
     side: SwapSide,
     blockNumber: number,
   ): Promise<string[]> {
+    this.logger.debug(
+      `Getting pool identifiers for ${srcToken.address} to ${destToken.address} (${side}) for ${this.dexKey}-${this.network}`,
+    );
     const _srcToken = this.dexHelper.config.wrapETH(srcToken);
     const _destToken = this.dexHelper.config.wrapETH(destToken);
 
@@ -398,6 +401,9 @@ export class Hashflow extends SimpleExchange implements IDex<HashflowData> {
   }
 
   async getCachedLevels(): Promise<PriceLevelsResponse['levels'] | null> {
+    this.logger.debug(
+      `Getting cached levels for ${this.pricesCacheKey} for ${this.dexKey}-${this.network}`,
+    );
     const cachedLevels = await this.dexHelper.cache.rawget(this.pricesCacheKey);
 
     if (cachedLevels) {
@@ -416,6 +422,11 @@ export class Hashflow extends SimpleExchange implements IDex<HashflowData> {
     limitPools?: string[],
   ): Promise<null | ExchangePrices<HashflowData>> {
     try {
+      this.logger.debug(
+        `Getting prices volume for ${srcToken.symbol || srcToken.address}, ${
+          destToken.symbol || destToken.address
+        }, ${side} for ${this.dexKey}-${this.network}`,
+      );
       const _srcToken = this.dexHelper.config.wrapETH(srcToken);
       const _destToken = this.dexHelper.config.wrapETH(destToken);
 
@@ -916,6 +927,7 @@ export class Hashflow extends SimpleExchange implements IDex<HashflowData> {
   }
 
   async isBlacklisted(txOrigin: Address): Promise<boolean> {
+    this.logger.debug(`Checking if ${txOrigin} is blacklisted for Hashflow`);
     const result = await this.dexHelper.cache.get(
       this.dexKey,
       this.network,

package/src/dex-helper/dummy-dex-helper.ts

@@ -329,6 +329,7 @@ export class DummyDexHelper implements IDexHelper {
       rpcUrl ? rpcUrl : this.config.data.privateHttpProvider,
       network,
     );
+
     this.web3Provider = new Web3(
       rpcUrl ? rpcUrl : this.config.data.privateHttpProvider,
     );
@@ -365,5 +366,14 @@ export class DummyDexHelper implements IDexHelper {
 
   replaceProviderWithRPC(rpcUrl: string) {
     this.provider = new StaticJsonRpcProvider(rpcUrl, this.config.data.network);
+    this.web3Provider = new Web3(rpcUrl);
+    this.multiContract = new this.web3Provider.eth.Contract(
+      multiABIV2 as any,
+      this.config.data.multicallV2Address,
+    );
+    this.multiWrapper = new MultiWrapper(
+      this.multiContract,
+      this.getLogger(`MultiWrapper-${this.config.data.network}`),
+    );
   }
 }