@paraswap/dex-lib 4.1.7-pub-sub.3 → 4.1.7-pub-sub.4

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

@@ -1,17 +1,24 @@
+import {
+  MarketMakersResponse,
+  PriceLevelsResponse,
+} from '@hashflow/taker-js/dist/types/rest';
 import { Network } from '../../constants';
 import { IDexHelper } from '../../dex-helper';
 import { Fetcher, SkippingRequest } from '../../lib/fetcher/fetcher';
 import { validateAndCast } from '../../lib/validators';
-import { Logger } from '../../types';
+import { Address, Logger } from '../../types';
 import {
   HashflowMarketMakersResponse,
   HashflowRateFetcherConfig,
   HashflowRatesResponse,
 } from './types';
 import { marketMakersValidator, pricesResponseValidator } from './validators';
+import { HASHFLOW_BLACKLIST_TTL_S } from './constants';
+import { ExpKeyValuePubSub, NonExpSetPubSub } from '../../lib/pub-sub';
 
 export class RateFetcher {
   private rateFetcher: Fetcher<HashflowRatesResponse>;
+  private ratePubSub: ExpKeyValuePubSub;
   private pricesCacheKey: string;
   private pricesCacheTTL: number;
 
@@ -19,6 +26,8 @@ export class RateFetcher {
   private marketMakersCacheKey: string;
   private marketMakersCacheTTL: number;
 
+  private blacklistedPubSub: NonExpSetPubSub;
+
   constructor(
     private dexHelper: IDexHelper,
     private dexKey: string,
@@ -48,16 +57,18 @@ export class RateFetcher {
       logger,
     );
 
+    this.ratePubSub = new ExpKeyValuePubSub(dexHelper, dexKey, 'rates');
+
     this.rateFetcher = new Fetcher<HashflowRatesResponse>(
       dexHelper.httpRequest,
       {
         info: {
           requestOptions: config.rateConfig.pricesReqParams,
           requestFunc: async options => {
-            const { filterMarketMakers, getCachedMarketMakers } =
-              config.rateConfig;
+            const { filterMarketMakers } = config.rateConfig;
 
-            const cachedMarketMakers = (await getCachedMarketMakers()) || [];
+            const cachedMarketMakers =
+              (await this.getCachedMarketMakers()) || [];
             const filteredMarketMakers = await filterMarketMakers(
               cachedMarketMakers,
             );
@@ -86,11 +97,24 @@ export class RateFetcher {
       config.rateConfig.pricesIntervalMs,
       logger,
     );
+
+    this.blacklistedPubSub = new NonExpSetPubSub(
+      dexHelper,
+      dexKey,
+      'blacklisted',
+    );
   }
 
-  start() {
-    this.marketMakersFetcher.startPolling();
-    this.rateFetcher.startPolling();
+  async start() {
+    if (!this.dexHelper.config.isSlave) {
+      this.marketMakersFetcher.startPolling();
+      this.rateFetcher.startPolling();
+    } else {
+      this.ratePubSub.subscribe();
+
+      const allBlacklisted = await this.getAllBlacklisted();
+      this.blacklistedPubSub.initializeAndSubscribe(allBlacklisted);
+    }
   }
 
   stop() {
@@ -109,10 +133,84 @@ export class RateFetcher {
 
   private handleRatesResponse(resp: HashflowRatesResponse): void {
     const { levels } = resp;
-    this.dexHelper.cache.rawset(
+    this.dexHelper.cache.setex(
+      this.dexKey,
+      this.network,
       this.pricesCacheKey,
+      this.pricesCacheTTL,
       JSON.stringify(levels),
+    );
+
+    this.ratePubSub.publish(
+      { [this.pricesCacheKey]: levels },
       this.pricesCacheTTL,
     );
   }
+
+  async getCachedMarketMakers(): Promise<
+    MarketMakersResponse['marketMakers'] | null
+  > {
+    const cachedMarketMakers = await this.dexHelper.cache.rawget(
+      this.marketMakersCacheKey,
+    );
+
+    if (cachedMarketMakers) {
+      return JSON.parse(
+        cachedMarketMakers,
+      ) as MarketMakersResponse['marketMakers'];
+    }
+
+    return null;
+  }
+
+  async getCachedLevels(): Promise<PriceLevelsResponse['levels'] | null> {
+    const cachedLevels = await this.ratePubSub.getAndCache(this.pricesCacheKey);
+
+    if (cachedLevels) {
+      return cachedLevels as PriceLevelsResponse['levels'];
+    }
+
+    return null;
+  }
+
+  async isBlacklisted(txOrigin: Address): Promise<boolean> {
+    return this.blacklistedPubSub.has(txOrigin.toLowerCase());
+  }
+
+  async setBlacklist(
+    txOrigin: Address,
+    ttl: number = HASHFLOW_BLACKLIST_TTL_S,
+  ) {
+    await this.dexHelper.cache.setex(
+      this.dexKey,
+      this.network,
+      this.getBlackListKey(txOrigin),
+      ttl,
+      'blacklisted',
+    );
+
+    this.blacklistedPubSub.publish([txOrigin.toLowerCase()]);
+
+    return true;
+  }
+
+  async getAllBlacklisted(): Promise<Address[]> {
+    const defaultKey = this.getBlackListKey('');
+    const pattern = `${defaultKey}*`;
+    const allBlacklisted = await this.dexHelper.cache.keys(
+      this.dexKey,
+      this.network,
+      pattern,
+    );
+
+    return allBlacklisted.map(t => this.getAddressFromBlackListKey(t));
+  }
+
+  getBlackListKey(address: Address) {
+    return `blacklist_${address}`.toLowerCase();
+  }
+
+  getAddressFromBlackListKey(key: Address) {
+    return (key.split('blacklist_')[1] ?? '').toLowerCase();
+  }
 }

package/src/dex/hashflow/types.ts

@@ -64,7 +64,6 @@ export type HashflowRateFetcherConfig = {
     };
     pricesIntervalMs: number;
     markerMakersIntervalMs: number;
-    getCachedMarketMakers: () => Promise<string[] | null>;
     filterMarketMakers: (makers: string[]) => Promise<string[]>;
     pricesCacheKey: string;
     marketMakersCacheKey: string;

package/src/lib/pub-sub.ts

@@ -15,7 +15,6 @@ export class ExpKeyValuePubSub {
   channel: string;
   network: Network;
   localCache: NodeCache = new NodeCache();
-  logPrefix = 'ExpKeyValuePubSub';
 
   logger: Logger;
 
@@ -37,21 +36,12 @@ export class ExpKeyValuePubSub {
 
     this.dexHelper.cache.subscribe(this.channel, (_, msg) => {
       const decodedMsg = JSON.parse(msg) as KeyValuePubSubMsg;
-      this.logger.info(
-        `${this.logPrefix} Received msg: '${Object.keys(decodedMsg).length}'`,
-      );
       this.handleSubscription(decodedMsg);
     });
   }
 
   publish(data: Record<string, unknown>, ttl: number) {
     const expiresAt = Math.round(Date.now() / 1000) + ttl;
-    this.logger.info(
-      `${this.logPrefix} Publishing msg: '${JSON.stringify({
-        expiresAt,
-        data: Object.keys(data).length,
-      })}'`,
-    );
     this.dexHelper.cache.publish(
       this.channel,
       JSON.stringify({ expiresAt, data }),
@@ -83,12 +73,6 @@ export class ExpKeyValuePubSub {
   async getAndCache<T>(key: string): Promise<T | null> {
     const localValue = this.localCache.get<T>(key);
 
-    this.logger.info(
-      `${this.logPrefix} Getting and caching key: ${key}, localValue length: ${
-        localValue ? Object.keys(localValue).length : 0
-      }`,
-    );
-
     if (localValue) {
       return localValue;
     }
@@ -280,7 +264,6 @@ export class NonExpSetPubSub {
   channel: string;
   network: Network;
   set = new Set<string>();
-  logPrefix = 'NonExpSetPubSub';
 
   logger: Logger;
 
@@ -296,10 +279,6 @@ export class NonExpSetPubSub {
   }
 
   async initializeAndSubscribe(initialSet: string[]) {
-    this.logger.info(
-      `${this.logPrefix} initializeAndSubscribe with ${initialSet}`,
-    );
-
     for (const member of initialSet) {
       this.set.add(member);
     }
@@ -312,23 +291,17 @@ export class NonExpSetPubSub {
 
     this.dexHelper.cache.subscribe(this.channel, (_, msg) => {
       const decodedMsg = JSON.parse(msg) as SetPubSubMsg;
-      this.logger.info(
-        `${this.logPrefix} Received subscription msg: '${decodedMsg.length}'`,
-      );
       this.handleSubscription(decodedMsg);
     });
   }
 
   publish(msg: SetPubSubMsg) {
     if (msg.length > 0) {
-      this.logger.info(`${this.logPrefix} Publishing msg: '${msg.length}'`);
       this.dexHelper.cache.publish(this.channel, JSON.stringify(msg));
     }
   }
 
   handleSubscription(set: SetPubSubMsg) {
-    this.logger.info(`${this.logPrefix} Received subscription msg: '${set}'`);
-
     for (const key of set) {
       this.set.add(key);
     }