exposing getStrategiesByPairs

Author: zavelevsky

src/chain-cache/ChainCache.ts

@@ -216,6 +216,25 @@ export class ChainCache extends (EventEmitter as new () => TypedEventEmitter<Cac
     return this._strategiesByPair[key];
   }
 
+  public async getStrategiesByPairs(pairs: TokenPair[]): Promise<
+    {
+      pair: TokenPair;
+      strategies: EncodedStrategy[];
+    }[]
+  > {
+    const result: {
+      pair: TokenPair;
+      strategies: EncodedStrategy[];
+    }[] = [];
+    for (const pair of pairs) {
+      const strategies = await this.getStrategiesByPair(pair[0], pair[1]);
+      if (strategies) {
+        result.push({ pair, strategies });
+      }
+    }
+    return result;
+  }
+
   public getStrategyById(id: BigNumberish): EncodedStrategy | undefined {
     return this._strategiesById[id.toString()];
   }

src/strategy-management/Toolkit.ts

@@ -28,6 +28,7 @@ import {
   EncodedStrategyBNStr,
   MatchType,
   MatchOptions,
+  TokenPair,
 } from '../common/types';
 import { DecimalFetcher, Decimals } from '../utils/decimals';
 
@@ -327,6 +328,79 @@ export class Toolkit {
     return strategies;
   }
 
+  /**
+   * Gets all the strategies that belong to pairs in the given list.
+   * If the cache is synced, it will return the strategies from the cache.
+   * Otherwise, it will fetch the strategies from the chain.
+   *
+   * @param {TokenPair[]} pairs - List of pairs to get strategies for.
+   *
+   * @returns {Promise<{
+   *   pair: TokenPair;
+   *   strategies: Strategy[];
+   * }[]>} An array of pairs and their strategies.
+   */
+  public async getStrategiesByPairs(pairs: TokenPair[]): Promise<
+    {
+      pair: TokenPair;
+      strategies: Strategy[];
+    }[]
+  > {
+    logger.debug('getStrategiesByPairs called', arguments);
+
+    let encodedStrategies:
+      | {
+          pair: TokenPair;
+          strategies: EncodedStrategy[];
+        }[]
+      | undefined;
+
+    if (this._cache) {
+      encodedStrategies = await this._cache.getStrategiesByPairs(pairs);
+    }
+
+    if (encodedStrategies) {
+      logger.debug('getStrategiesByPairs fetched from cache');
+    } else {
+      logger.debug('getStrategiesByPairs fetching from chain');
+      encodedStrategies = await this._api.reader.strategiesByPairs(pairs);
+    }
+
+    const decodedStrategies: {
+      pair: TokenPair;
+      strategies: (DecodedStrategy & {
+        id: BigNumber;
+        encoded: EncodedStrategy;
+      })[];
+    }[] = encodedStrategies.map(({ pair, strategies }) => ({
+      pair,
+      strategies: strategies.map(decodeStrategy),
+    }));
+
+    const strategies: {
+      pair: TokenPair;
+      strategies: Strategy[];
+    }[] = await Promise.all(
+      decodedStrategies.map(async ({ pair, strategies }) => ({
+        pair,
+        strategies: await Promise.all(
+          strategies.map(async (strategy) => {
+            return await parseStrategy(strategy, this._decimals);
+          })
+        ),
+      }))
+    );
+
+    logger.debug('getStrategiesByPairs info:', {
+      pairs,
+      encodedStrategies,
+      decodedStrategies,
+      strategies,
+    });
+
+    return strategies;
+  }
+
   /**
    * Gets the strategies that are owned by the user.
    * It does so by reading the voucher token and