@bosonprotocol/core-sdk 1.23.0-alpha.9 → 1.23.1-alpha.0

package/src/utils/logs.ts

@@ -1,27 +1,27 @@
 import { Log } from "@bosonprotocol/common";
 import { Interface } from "@ethersproject/abi";
 
-export function getValueFromLogs(args: {
+export function getValueFromLogs<T>(args: {
   iface: Interface;
   logs: Log[];
   eventArgsKey: string;
   eventName: string;
-}): string | null {
-  const relevantLogs = getValuesFromLogs(args);
+}): T | null {
+  const relevantLogs = getValuesFromLogs<T>(args);
 
   if (!relevantLogs || relevantLogs.length === 0) {
     return null;
   }
 
-  return relevantLogs[0];
+  return relevantLogs[0] as T;
 }
 
-export function getValuesFromLogs(args: {
+export function getValuesFromLogs<T>(args: {
   iface: Interface;
   logs: Log[];
   eventArgsKey: string;
   eventName: string;
-}): string[] {
+}): T[] {
   const parsedLogs = args.logs
     .map((log) => {
       try {
@@ -39,7 +39,41 @@ export function getValuesFromLogs(args: {
     return null;
   }
 
-  return relevantLogs.map((relevantLog) =>
-    String(relevantLog.args[args.eventArgsKey])
+  return relevantLogs.map(
+    (relevantLog) => relevantLog.args[args.eventArgsKey] as T
   );
 }
+
+export function getValuesFromLogsExt<T>(args: {
+  iface: Interface;
+  logs: Log[];
+  eventArgsKeys: string[];
+  eventNames: string[];
+}): Record<string, T[]> {
+  const parsedLogs = args.logs
+    .map((log) => {
+      try {
+        return args.iface.parseLog(log);
+      } catch (error) {
+        // assume that failing to parse is irrelevant log
+        return null;
+      }
+    })
+    .filter((log) => log !== null);
+
+  const relevantLogs = parsedLogs.filter((log) =>
+    args.eventNames.includes(log.name)
+  );
+
+  if (relevantLogs.length === 0) {
+    return null;
+  }
+
+  const ret = {};
+  for (const eventArgsKey of args.eventArgsKeys) {
+    ret[eventArgsKey] = relevantLogs.map(
+      (relevantLog) => relevantLog.args[eventArgsKey]
+    );
+  }
+  return ret;
+}

package/src/utils/tokenInfoManager.ts

@@ -1,6 +1,7 @@
 import { Web3LibAdapter } from "@bosonprotocol/common";
 import { AddressZero } from "@ethersproject/constants";
 import { getDecimals, getName, getSymbol } from "../erc20/handler";
+import { getExchangeTokens } from "../erc20/subgraph";
 
 export interface ITokenInfo {
   name: string;
@@ -64,34 +65,88 @@ export const NATIVE_TOKENS: { [key: number]: ITokenInfo } = {
 };
 
 export class TokenInfoManager implements ITokenInfoManager {
-  private _tokenInfos = new Map<string, ITokenInfo>();
+  private static TokenInfos = new Map<number, Map<string, ITokenInfo>>();
+  private static mapInitialized = new Map<number, boolean>();
   private _web3Lib: Web3LibAdapter;
+  private _subgraphUrl: string;
+  private _chainId: number;
+  private static InvalidAddresses = new Map<number, Set<string>>();
 
-  public constructor(chainId: number, web3Lib: Web3LibAdapter) {
+  public constructor(
+    chainId: number,
+    web3Lib: Web3LibAdapter,
+    subgraphUrl: string
+  ) {
     if (!NATIVE_TOKENS[chainId]) {
       throw new Error(`Unexpected chainId value '${chainId}'`);
     }
-    this._tokenInfos.set(AddressZero, NATIVE_TOKENS[chainId]);
+
+    if (!TokenInfoManager.TokenInfos.has(chainId)) {
+      const tokenInfos = new Map<string, ITokenInfo>();
+      tokenInfos.set(AddressZero, NATIVE_TOKENS[chainId]);
+      TokenInfoManager.TokenInfos.set(chainId, tokenInfos);
+    }
+
+    if (!TokenInfoManager.mapInitialized.has(chainId)) {
+      TokenInfoManager.mapInitialized.set(chainId, false);
+    }
+
+    if (!TokenInfoManager.InvalidAddresses.has(chainId)) {
+      TokenInfoManager.InvalidAddresses.set(chainId, new Set<string>());
+    }
     this._web3Lib = web3Lib;
+    this._subgraphUrl = subgraphUrl;
+    this._chainId = chainId;
   }
 
-  public async getExchangeTokenInfo(tokenAddress: string): Promise<ITokenInfo> {
-    if (!this._tokenInfos.has(tokenAddress.toLowerCase())) {
+  public async getExchangeTokenInfo(
+    tokenAddress: string
+  ): Promise<ITokenInfo | undefined> {
+    await this.ensureInitialized();
+    const tokenInfos = TokenInfoManager.TokenInfos.get(this._chainId);
+    const invalidAddressesSet = TokenInfoManager.InvalidAddresses.get(
+      this._chainId
+    );
+    const key = tokenAddress.toLowerCase();
+
+    if (!tokenInfos.has(key) && !invalidAddressesSet.has(key)) {
       const args = {
         web3Lib: this._web3Lib,
         contractAddress: tokenAddress
       };
-      const [decimals, name, symbol] = await Promise.all([
-        getDecimals(args),
-        getName(args),
-        getSymbol(args)
-      ]);
-      this._tokenInfos.set(tokenAddress.toLowerCase(), {
-        decimals,
-        name,
-        symbol
-      });
+      try {
+        const [decimals, name, symbol] = await Promise.all([
+          getDecimals(args),
+          getName(args),
+          getSymbol(args)
+        ]);
+        tokenInfos.set(key, {
+          decimals,
+          name,
+          symbol
+        });
+      } catch (error) {
+        invalidAddressesSet.add(key);
+      }
+    }
+    return tokenInfos.get(key);
+  }
+
+  private async ensureInitialized() {
+    const isInitialized = TokenInfoManager.mapInitialized.get(this._chainId);
+    if (!isInitialized) {
+      // Be sure we are initializing the map only one time per chainId
+      TokenInfoManager.mapInitialized.set(this._chainId, true);
+      const tokenInfos = TokenInfoManager.TokenInfos.get(this._chainId);
+      // Get all tokens from subgraph
+      const tokens = await getExchangeTokens(this._subgraphUrl);
+      for (const token of tokens) {
+        tokenInfos.set(token.address.toLowerCase(), {
+          decimals: parseInt(token.decimals),
+          name: token.name,
+          symbol: token.symbol
+        });
+      }
     }
-    return this._tokenInfos.get(tokenAddress.toLowerCase());
   }
 }