@keplr-wallet/background 0.13.13 → 0.13.15-rc.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@keplr-wallet/background",
-  "version": "0.13.13",
+  "version": "0.13.15-rc.0",
   "main": "build/index.js",
   "author": "chainapsis",
   "license": "Apache-2.0",
@@ -33,17 +33,17 @@
     "@ethersproject/hash": "^5.7.0",
     "@ethersproject/transactions": "^5.7.0",
     "@ethersproject/wallet": "^5.7.0",
-    "@keplr-wallet/chain-validator": "0.13.13",
-    "@keplr-wallet/common": "0.13.13",
-    "@keplr-wallet/cosmos": "0.13.13",
-    "@keplr-wallet/crypto": "0.13.13",
-    "@keplr-wallet/ledger-cosmos": "0.13.13",
-    "@keplr-wallet/popup": "0.13.13",
-    "@keplr-wallet/proto-types": "0.13.13",
-    "@keplr-wallet/router": "0.13.13",
-    "@keplr-wallet/simple-fetch": "0.13.13",
-    "@keplr-wallet/types": "0.13.13",
-    "@keplr-wallet/unit": "0.13.13",
+    "@keplr-wallet/chain-validator": "0.13.15-rc.0",
+    "@keplr-wallet/common": "0.13.15-rc.0",
+    "@keplr-wallet/cosmos": "0.13.15-rc.0",
+    "@keplr-wallet/crypto": "0.13.15-rc.0",
+    "@keplr-wallet/ledger-cosmos": "0.13.15-rc.0",
+    "@keplr-wallet/popup": "0.13.15-rc.0",
+    "@keplr-wallet/proto-types": "0.13.15-rc.0",
+    "@keplr-wallet/router": "0.13.15-rc.0",
+    "@keplr-wallet/simple-fetch": "0.13.15-rc.0",
+    "@keplr-wallet/types": "0.13.15-rc.0",
+    "@keplr-wallet/unit": "0.13.15-rc.0",
     "@ledgerhq/hw-app-eth": "6.42.8",
     "@ledgerhq/hw-app-starknet": "^3.0.1",
     "@ledgerhq/hw-transport": "^6.31.4",
@@ -70,5 +70,5 @@
     "mobx-utils": "^6",
     "starknet": "^7"
   },
-  "gitHead": "d806e87af06491dd189d849f69614a8b06c627bc"
+  "gitHead": "5a3e0763e91ef98e83059cb7340074b5967cf897"
 }

package/src/chains/convert.ts

@@ -0,0 +1,126 @@
+import {
+  AppCurrency,
+  ChainInfo,
+  ERC20Currency,
+  EvmChainInfo,
+  ModularChainInfo,
+} from "@keplr-wallet/types";
+import { DenomHelper } from "@keplr-wallet/common";
+
+function toERC20Currency(currency: AppCurrency): ERC20Currency {
+  if (
+    "type" in currency &&
+    currency.type === "erc20" &&
+    "contractAddress" in currency
+  ) {
+    return currency as ERC20Currency;
+  }
+  const denomHelper = new DenomHelper(currency.coinMinimalDenom);
+  return {
+    ...currency,
+    type: "erc20" as const,
+    contractAddress: denomHelper.contractAddress,
+  };
+}
+
+export function convertChainInfoToModularChainInfo(
+  chainInfo: ChainInfo
+): ModularChainInfo {
+  const common = {
+    isV2: true as const,
+    chainId: chainInfo.chainId,
+    chainName: chainInfo.chainName,
+    chainSymbolImageUrl: chainInfo.chainSymbolImageUrl,
+    isTestnet: chainInfo.isTestnet,
+    hideInUI: chainInfo.hideInUI,
+  };
+
+  if (chainInfo.evm) {
+    const erc20Tokens: ERC20Currency[] = [];
+    const nonERC20Currencies: AppCurrency[] = [];
+    for (const currency of chainInfo.currencies) {
+      const denomHelper = new DenomHelper(currency.coinMinimalDenom);
+      if (denomHelper.type === "erc20") {
+        erc20Tokens.push(toERC20Currency(currency));
+      } else {
+        nonERC20Currencies.push(currency);
+      }
+    }
+
+    const nativeCurrency =
+      nonERC20Currencies.find((cur) => {
+        const dh = new DenomHelper(cur.coinMinimalDenom);
+        return dh.type === "native";
+      }) ?? nonERC20Currencies[0];
+
+    if (!nativeCurrency) {
+      throw new Error(
+        `Chain ${chainInfo.chainId} has evm module but no non-ERC20 native currency`
+      );
+    }
+
+    const evm: EvmChainInfo = {
+      chainId: chainInfo.evm.chainId,
+      rpc: chainInfo.evm.rpc,
+      websocket: chainInfo.evm.websocket,
+      nativeCurrency: nativeCurrency,
+      tokens: erc20Tokens,
+      features: chainInfo.features,
+    };
+
+    if (chainInfo.chainId.startsWith("eip155:")) {
+      return { ...common, type: "evm", evm };
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    const { evm: _, ...cosmosWithoutEvm } = chainInfo;
+    return { ...common, type: "ethermint", cosmos: cosmosWithoutEvm, evm };
+  }
+
+  return { ...common, type: "cosmos" as const, cosmos: chainInfo };
+}
+
+/**
+ * ModularChainInfo를 ChainInfo로 역변환한다.
+ * cosmos, ethermint, evm 타입만 변환 가능. starknet/bitcoin은 undefined 반환.
+ */
+export function convertModularChainInfoToChainInfo(
+  m: ModularChainInfo
+): ChainInfo | undefined {
+  if (m.type === "cosmos") {
+    return m.cosmos as ChainInfo;
+  }
+
+  if (m.type === "ethermint") {
+    return {
+      ...m.cosmos,
+      evm: {
+        chainId: m.evm.chainId,
+        rpc: m.evm.rpc,
+        websocket: m.evm.websocket,
+      },
+    } as ChainInfo;
+  }
+
+  if (m.type === "evm") {
+    return {
+      rpc: m.evm.rpc,
+      rest: m.evm.rpc,
+      chainId: m.chainId,
+      chainName: m.chainName,
+      chainSymbolImageUrl: m.chainSymbolImageUrl,
+      isTestnet: m.isTestnet,
+      bip44: { coinType: 60 },
+      currencies: [m.evm.nativeCurrency, ...m.evm.tokens],
+      feeCurrencies: [m.evm.nativeCurrency],
+      features: m.evm.features,
+      evm: {
+        chainId: m.evm.chainId,
+        rpc: m.evm.rpc,
+        websocket: m.evm.websocket,
+      },
+    };
+  }
+
+  return undefined;
+}

package/src/chains/handler.ts

@@ -107,7 +107,7 @@ const handleGetInfosWithCoreTypesMsg: (
   return () => {
     return {
       chainInfos: service.getChainInfosWithCoreTypes(),
-      modulrChainInfos: service.getModularChainInfos(),
+      modularChainInfos: service.getModularChainInfos(),
     };
   };
 };

package/src/chains/index.ts

@@ -1,3 +1,4 @@
 export * from "./service";
 export * from "./messages";
 export * from "./types";
+export * from "./convert";

package/src/chains/messages.ts

@@ -31,7 +31,7 @@ export class PingMsg extends Message<void> {
 
 export class GetChainInfosWithCoreTypesMsg extends Message<{
   chainInfos: ChainInfoWithCoreTypes[];
-  modulrChainInfos: ModularChainInfo[];
+  modularChainInfos: ModularChainInfo[];
 }> {
   public static type() {
     return "get-chain-infos-with-core-types";

package/src/chains/service.ts

@@ -32,10 +32,11 @@ import { InteractionService } from "../interaction";
 import { Env } from "@keplr-wallet/router";
 import { SuggestChainInfoMsg } from "./messages";
 import { ChainInfoWithCoreTypes, ChainInfoWithSuggestedOptions } from "./types";
+import { convertChainInfoToModularChainInfo } from "./convert";
 import { AnalyticsService } from "../analytics";
 import { runIfOnlyAppStart } from "../utils";
 
-type ChainRemovedHandler = (chainInfo: ChainInfo) => void;
+type ChainRemovedHandler = (chainId: string) => void;
 type ChainSuggestedHandler = (
   chainInfo: ChainInfo,
   options?: Record<string, any>
@@ -104,31 +105,15 @@ export class ChainsService {
   ) {
     this.modularChainInfos = embedModularChainInfos.map((modularChainInfo) => {
       if ("currencies" in modularChainInfo) {
-        return {
-          chainId: modularChainInfo.chainId,
-          chainName: modularChainInfo.chainName,
-          chainSymbolImageUrl: modularChainInfo.chainSymbolImageUrl,
-          cosmos: modularChainInfo,
-        };
+        return convertChainInfoToModularChainInfo(modularChainInfo);
       }
+      // Already ModularChainInfo
       return modularChainInfo;
     });
-    this.embedChainInfos = embedModularChainInfos
-      .filter(
-        (modularChainInfo) =>
-          "currencies" in modularChainInfo || "cosmos" in modularChainInfo
-      )
-      .map((modularChainInfo) => {
-        if ("currencies" in modularChainInfo) {
-          return modularChainInfo;
-        }
-        if (!("cosmos" in modularChainInfo)) {
-          throw new Error("Can't be happen");
-        }
-        return {
-          ...modularChainInfo.cosmos,
-        };
-      });
+    this.embedChainInfos = embedModularChainInfos.filter(
+      (modularChainInfo): modularChainInfo is ChainInfoWithCoreTypes =>
+        "currencies" in modularChainInfo
+    );
 
     this.updatedChainInfoKVStore = new PrefixKVStore(
       kvStore,
@@ -941,7 +926,7 @@ export class ChainsService {
         this.suggestedChainInfos
       );
       const starknetChainInfos = this.modularChainInfos.reduce((acc, cur) => {
-        if ("starknet" in cur) {
+        if (cur.type === "starknet") {
           acc.push(cur.starknet);
         }
         return acc;
@@ -1150,31 +1135,31 @@ export class ChainsService {
   protected mergeModularChainInfosWithDynamics(
     modularChainInfos: ModularChainInfo[]
   ): ModularChainInfo[] {
-    return modularChainInfos.map((modularChainInfo) => {
-      if (this.hasChainInfo(modularChainInfo.chainId)) {
-        const cosmos = this.getChainInfoOrThrow(modularChainInfo.chainId);
+    return modularChainInfos.map((m) => {
+      if (
+        (m.type === "cosmos" || m.type === "ethermint" || m.type === "evm") &&
+        this.hasChainInfo(m.chainId)
+      ) {
+        const merged = this.getChainInfoOrThrow(m.chainId);
         return {
-          chainId: cosmos.chainId,
-          chainName: cosmos.chainName,
-          chainSymbolImageUrl: cosmos.chainSymbolImageUrl,
-          isTestnet: cosmos.isTestnet,
-          cosmos: this.mergeChainInfosWithDynamics([cosmos])[0],
+          ...m,
+          ...convertChainInfoToModularChainInfo(merged),
         };
       }
 
-      if ("starknet" in modularChainInfo) {
-        const endpoint = this.getEndpoint(modularChainInfo.chainId);
+      if (m.type === "starknet") {
+        const endpoint = this.getEndpoint(m.chainId);
         return {
-          ...modularChainInfo,
+          ...m,
           starknet: {
-            ...modularChainInfo.starknet,
-            rpc: endpoint?.rpc || modularChainInfo.starknet.rpc,
+            ...m.starknet,
+            rpc: endpoint?.rpc || m.starknet.rpc,
           },
         };
       }
 
       // TODO: 나머지 모듈러 체인 정보들에 대해서도 적용하기
-      return modularChainInfo;
+      return m;
     });
   }
 
@@ -1229,7 +1214,7 @@ export class ChainsService {
     }
 
     for (const handler of this.onChainRemovedHandlers) {
-      handler(updated);
+      handler(updated.chainId);
     }
   }
 
@@ -1237,7 +1222,7 @@ export class ChainsService {
     this.onChainRemovedHandlers.push(handler);
   }
 
-  addChainSuggestedHandler(handler: ChainRemovedHandler) {
+  addChainSuggestedHandler(handler: ChainSuggestedHandler) {
     this.onChainSuggestedHandlers.push(handler);
   }
 
@@ -1251,28 +1236,24 @@ export class ChainsService {
   }
 
   getEVMInfoOrThrow(chainId: string): EVMInfo {
-    const chainInfo = this.getChainInfoOrThrow(chainId);
-    if (chainInfo.evm === undefined) {
+    const modularChainInfo = this.getModularChainInfoOrThrow(chainId);
+    if (
+      modularChainInfo.type !== "evm" &&
+      modularChainInfo.type !== "ethermint"
+    ) {
       throw new Error(`There is no EVM info for ${chainId}`);
     }
 
-    return chainInfo.evm;
+    return modularChainInfo.evm;
   }
 
   getModularChainInfos = computedFn(
     (): ModularChainInfo[] => {
       return this.mergeModularChainInfosWithDynamics(
-        this.modularChainInfos.slice()
+        this.modularChainInfos.map((m) => ({ ...m, isBuiltInChain: true }))
       ).concat(
         this.mergeChainInfosWithDynamics(this.suggestedChainInfos).map(
-          (chainInfo) => {
-            return {
-              chainId: chainInfo.chainId,
-              chainName: chainInfo.chainName,
-              chainSymbolImageUrl: chainInfo.chainSymbolImageUrl,
-              cosmos: chainInfo,
-            };
-          }
+          (chainInfo) => convertChainInfoToModularChainInfo(chainInfo)
         )
       );
     },
@@ -1283,8 +1264,8 @@ export class ChainsService {
 
   hasModularChainInfo = computedFn((chainId: string): boolean => {
     return this.getModularChainInfos().some(
-      (modularChainInfo) =>
-        ChainIdHelper.parse(modularChainInfo.chainId).identifier ===
+      (m) =>
+        ChainIdHelper.parse(m.chainId).identifier ===
         ChainIdHelper.parse(chainId).identifier
     );
   });
@@ -1292,36 +1273,40 @@ export class ChainsService {
   getModularChainInfo = computedFn(
     (chainId: string): ModularChainInfo | undefined => {
       return this.getModularChainInfos().find(
-        (modularChainInfo) =>
-          ChainIdHelper.parse(modularChainInfo.chainId).identifier ===
+        (m) =>
+          ChainIdHelper.parse(m.chainId).identifier ===
           ChainIdHelper.parse(chainId).identifier
       );
     }
   );
 
+  getModularChainInfoOrThrow(chainId: string): ModularChainInfo {
+    const m = this.getModularChainInfo(chainId);
+    if (!m) {
+      throw new Error(`There is no modular chain info for ${chainId}`);
+    }
+    return m;
+  }
+
   getModularChainInfoWithLinkedChainKey = computedFn(
     (chainId: string): ModularChainInfo[] => {
       const res: ModularChainInfo[] = [];
 
       let linkedChainKey: string | undefined;
       if (this.hasModularChainInfo(chainId)) {
-        const modularChainInfo = this.getModularChainInfoOrThrow(chainId);
-        if ("linkedChainKey" in modularChainInfo) {
-          linkedChainKey = modularChainInfo.linkedChainKey;
-        }
-        res.push(modularChainInfo);
+        const m = this.getModularChainInfoOrThrow(chainId);
+        linkedChainKey = m.linkedChainKey;
+        res.push(m);
       }
 
       if (linkedChainKey) {
         const chainIdentifier = ChainIdHelper.parse(chainId).identifier;
-        for (const modularChainInfo of this.modularChainInfos) {
+        for (const m of this.getModularChainInfos()) {
           if (
-            ChainIdHelper.parse(modularChainInfo.chainId).identifier !==
-              chainIdentifier &&
-            "linkedChainKey" in modularChainInfo &&
-            modularChainInfo.linkedChainKey === linkedChainKey
+            ChainIdHelper.parse(m.chainId).identifier !== chainIdentifier &&
+            m.linkedChainKey === linkedChainKey
           ) {
-            res.push(modularChainInfo);
+            res.push(m);
           }
         }
       }
@@ -1330,30 +1315,21 @@ export class ChainsService {
     }
   );
 
-  getModularChainInfoOrThrow(chainId: string): ModularChainInfo {
-    const modularChainInfo = this.getModularChainInfo(chainId);
-    if (!modularChainInfo) {
-      throw new Error(`There is no modular chain info for ${chainId}`);
-    }
-
-    return modularChainInfo;
-  }
-
   hasStarknetChainInfo(chainId: string): boolean {
-    const modularChainInfo = this.getModularChainInfo(chainId);
-    if (!modularChainInfo) {
+    const m = this.getModularChainInfo(chainId);
+    if (!m) {
       return false;
     }
-    return "starknet" in modularChainInfo;
+    return m.type === "starknet";
   }
 
   getStarknetChainInfo(chainId: string): StarknetChainInfo | undefined {
-    const modularChainInfo = this.getModularChainInfo(chainId);
-    if (!modularChainInfo) {
+    const m = this.getModularChainInfo(chainId);
+    if (!m) {
       return undefined;
     }
-    if ("starknet" in modularChainInfo) {
-      return modularChainInfo.starknet;
+    if (m.type === "starknet") {
+      return m.starknet;
     }
   }
 
@@ -1362,7 +1338,6 @@ export class ChainsService {
     if (!starknetChainInfo) {
       throw new Error(`There is no starknet chain info for ${chainId}`);
     }
-
     return starknetChainInfo;
   }
 
@@ -1372,14 +1347,14 @@ export class ChainsService {
     const directMatch = modularChainInfos.find(
       (info) => info.chainId === chainId
     );
-    if (directMatch && "bitcoin" in directMatch) {
+    if (directMatch && directMatch.type === "bitcoin") {
       return directMatch.bitcoin;
     }
 
     const baseChainMatch = modularChainInfos.find(
-      (info) => "bitcoin" in info && info.bitcoin.chainId === chainId
+      (info) => info.type === "bitcoin" && info.bitcoin.chainId === chainId
     );
-    if (baseChainMatch && "bitcoin" in baseChainMatch) {
+    if (baseChainMatch && baseChainMatch.type === "bitcoin") {
       return baseChainMatch.bitcoin;
     }
   }
@@ -1389,16 +1364,9 @@ export class ChainsService {
     if (!bitcoinChainInfo) {
       throw new Error(`There is no bitcoin chain info for ${chainId}`);
     }
-
     return bitcoinChainInfo;
   }
 
-  /**
-   * 여러 주소 체계가 존재하는 체인의 경우, chainId에서 주소 체계를 제외한 공통된 부분을 사용하여 하나의 체인으로 취급해야 한다.
-   * 예를 들어, Bitcoin의 경우 `bip122:123456:taproot`와 `bip122:123456:native-segwit`를 사용해
-   * 각 주소 체계를 구분하고 있지만, 공통된 `bip122:123456`을 사용하여 하나의 체인으로 취급되어야 한다.
-   * TODO: 비트 코인 외에도 여러 주소 체계가 존재하는 체인이 추가될 경우, 이 메서드의 부분적인 수정이 필요하다.
-   */
   getBaseChainId(chainId: string): string | undefined {
     chainId = ChainIdHelper.parse(chainId).identifier;
 
@@ -1408,14 +1376,14 @@ export class ChainsService {
       (info) => ChainIdHelper.parse(info.chainId).identifier === chainId
     );
     if (directMatch) {
-      if ("bitcoin" in directMatch) {
+      if (directMatch.type === "bitcoin") {
         return directMatch.bitcoin.chainId;
       }
       return chainId;
     }
 
     const baseChainMatch = modularChainInfos.find(
-      (info) => "bitcoin" in info && info.bitcoin.chainId === chainId
+      (info) => info.type === "bitcoin" && info.bitcoin.chainId === chainId
     );
     if (baseChainMatch) {
       return chainId;
@@ -1429,7 +1397,6 @@ export class ChainsService {
     if (!baseChainId) {
       throw new Error(`There is no modular chain info for ${chainId}`);
     }
-
     return baseChainId;
   }
 }

package/src/chains-ui/service.ts

@@ -9,7 +9,7 @@ import {
   toJS,
 } from "mobx";
 import { KVStore } from "@keplr-wallet/common";
-import { ChainInfo, ModularChainInfo } from "@keplr-wallet/types";
+import { ModularChainInfo } from "@keplr-wallet/types";
 import { ChainIdHelper } from "@keplr-wallet/cosmos";
 import { computedFn } from "mobx-utils";
 import { VaultService } from "../vault";
@@ -76,8 +76,9 @@ export class ChainsUIService {
       if (chainIdentifiers.length === 0) {
         // Should be enabled at least one chain.
         return [
-          ChainIdHelper.parse(this.chainsService.getChainInfos()[0].chainId)
-            .identifier,
+          ChainIdHelper.parse(
+            this.chainsService.getModularChainInfos()[0].chainId
+          ).identifier,
         ];
       } else {
         return chainIdentifiers;
@@ -140,7 +141,7 @@ export class ChainsUIService {
         return ChainIdHelper.parse(chainId).identifier;
       })
       .filter((chainIdentifier) => {
-        return this.chainsService.hasChainInfo(chainIdentifier);
+        return this.chainsService.hasModularChainInfo(chainIdentifier);
       });
 
     const identifierMap = this.enabledChainIdentifierMapForVault(vaultId);
@@ -253,7 +254,7 @@ export class ChainsUIService {
       }
     }
     return Array.from(set).filter((chainIdentifier) => {
-      return this.chainsService.hasChainInfo(chainIdentifier);
+      return this.chainsService.hasModularChainInfo(chainIdentifier);
     });
   }
 
@@ -261,9 +262,9 @@ export class ChainsUIService {
     this.onChainUIEnabledChangedHandlers.push(handler);
   }
 
-  protected readonly onChainRemoved = (chainInfo: ChainInfo) => {
+  protected readonly onChainRemoved = (chainId: string) => {
     runInAction(() => {
-      const identifier = ChainIdHelper.parse(chainInfo.chainId).identifier;
+      const identifier = ChainIdHelper.parse(chainId).identifier;
       const vaultIds = this.enabledChainIdentifiersMap.keys();
       for (const vaultId of vaultIds) {
         const map = (() => {

package/src/chains-update/service.ts

@@ -68,8 +68,8 @@ export class ChainsUpdateService {
       });
     });
 
-    this.chainsService.addChainRemovedHandler((chainInfo) => {
-      this.updateChainInfo(chainInfo.chainId).catch((e) => {
+    this.chainsService.addChainRemovedHandler((chainId) => {
+      this.updateChainInfo(chainId).catch((e) => {
         console.log(e);
       });
     });

package/src/keyring/handler.ts

@@ -523,28 +523,43 @@ const handleGetAllWalletsMsg: (
           const modularChainInfo =
             chainsService.getModularChainInfoOrThrow(chainIdentifier);
 
-          if ("cosmos" in modularChainInfo) {
-            const key = await keyRingCosmosService.getKey(
-              keyInfo.id,
-              modularChainInfo.chainId
-            );
-            const chainInfo = modularChainInfo.cosmos;
-            const isEthermintLike = KeyRingService.isEthermintLike(chainInfo);
-            const evmInfo = ChainsService.getEVMInfo(chainInfo);
-
-            if (isEthermintLike || evmInfo !== undefined) {
-              addresses[modularChainInfo.chainId] = key.ethereumHexAddress;
-            } else {
+          switch (modularChainInfo.type) {
+            case "cosmos": {
+              const key = await keyRingCosmosService.getKey(
+                keyInfo.id,
+                modularChainInfo.chainId
+              );
               addresses[modularChainInfo.chainId] = key.bech32Address;
+              break;
+            }
+            case "ethermint": {
+              const key = await keyRingCosmosService.getKey(
+                keyInfo.id,
+                modularChainInfo.chainId
+              );
+              addresses[modularChainInfo.chainId] = key.ethereumHexAddress;
+              break;
+            }
+            case "evm": {
+              const key = await keyRingCosmosService.getKey(
+                keyInfo.id,
+                modularChainInfo.chainId
+              );
+              addresses[modularChainInfo.chainId] = key.ethereumHexAddress;
+              break;
+            }
+            case "starknet": {
+              const starknetKey = await keyRingStarknetService.getStarknetKey(
+                keyInfo.id,
+                modularChainInfo.chainId
+              );
+              addresses[modularChainInfo.chainId] = starknetKey.hexAddress;
+              break;
             }
-          } else if ("starknet" in modularChainInfo) {
-            const starknetKey = await keyRingStarknetService.getStarknetKey(
-              keyInfo.id,
-              modularChainInfo.chainId
-            );
-            addresses[modularChainInfo.chainId] = starknetKey.hexAddress;
+            case "bitcoin":
+              // Bitcoin: skip (out of scope)
+              break;
           }
-          // Bitcoin: skip (out of scope)
         } catch (e) {
           console.log(e);
           continue;