@subwallet/extension-base 0.8.3-2 → 1.0.1

package/cjs/services/chain-service/index.js

@@ -0,0 +1,1154 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ChainService = void 0;
+var _chainList = require("@subwallet/chain-list");
+var _types = require("@subwallet/chain-list/types");
+var _constants = require("@subwallet/extension-base/constants");
+var _constants2 = require("@subwallet/extension-base/services/chain-service/constants");
+var _EvmChainHandler = require("@subwallet/extension-base/services/chain-service/handler/EvmChainHandler");
+var _SubstrateChainHandler = require("@subwallet/extension-base/services/chain-service/handler/SubstrateChainHandler");
+var _types2 = require("@subwallet/extension-base/services/chain-service/handler/types");
+var _types3 = require("@subwallet/extension-base/services/chain-service/types");
+var _utils = require("@subwallet/extension-base/services/chain-service/utils");
+var _AssetSetting = _interopRequireDefault(require("@subwallet/extension-base/stores/AssetSetting"));
+var _rxjs = require("rxjs");
+var _web = _interopRequireDefault(require("web3"));
+var _logger = require("@polkadot/util/logger");
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+class ChainService {
+  dataMap = {
+    chainInfoMap: {},
+    chainStateMap: {},
+    assetRegistry: {},
+    assetRefMap: {}
+  };
+  // to save chain, token settings from user
+
+  lockChainInfoMap = false; // prevent unwanted changes (edit, enable, disable) to chainInfoMap
+
+  // TODO: consider BehaviorSubject
+  chainInfoMapSubject = new _rxjs.Subject();
+  chainStateMapSubject = new _rxjs.Subject();
+  assetRegistrySubject = new _rxjs.Subject();
+  multiChainAssetMapSubject = new _rxjs.Subject();
+  xcmRefMapSubject = new _rxjs.Subject();
+
+  // Todo: Update to new store indexed DB
+  store = new _AssetSetting.default();
+  assetSettingSubject = new _rxjs.BehaviorSubject({});
+  constructor(dbService) {
+    this.dbService = dbService;
+    this.substrateChainHandler = new _SubstrateChainHandler.SubstrateChainHandler();
+    this.evmChainHandler = new _EvmChainHandler.EvmChainHandler();
+    this.chainInfoMapSubject.next(this.dataMap.chainInfoMap);
+    this.chainStateMapSubject.next(this.dataMap.chainStateMap);
+    this.assetRegistrySubject.next(this.dataMap.assetRegistry);
+    this.multiChainAssetMapSubject.next(_chainList.MultiChainAssetMap);
+    this.xcmRefMapSubject.next(this.getXcmRefMap());
+    this.logger = (0, _logger.logger)('chain-service');
+    this.refreshChainStateInterval(3000);
+  }
+
+  // Getter
+  getXcmRefMap() {
+    const result = {};
+    Object.entries(_chainList.AssetRefMap).forEach(_ref => {
+      let [key, assetRef] = _ref;
+      if (assetRef.path === _types._AssetRefPath.XCM) {
+        result[key] = assetRef;
+      }
+    });
+    return result;
+  }
+  getEvmApi(slug) {
+    return this.evmChainHandler.getEvmApiByChain(slug);
+  }
+  getEvmApiMap() {
+    return this.evmChainHandler.getEvmApiMap();
+  }
+  getSubstrateApiMap() {
+    return this.substrateChainHandler.getSubstrateApiMap();
+  }
+  getSubstrateApi(slug) {
+    return this.substrateChainHandler.getSubstrateApiByChain(slug);
+  }
+  getChainCurrentProviderByKey(slug) {
+    const providerName = this.getChainStateByKey(slug).currentProvider;
+    const providerMap = this.getChainInfoByKey(slug).providers;
+    const endpoint = providerMap[providerName];
+    return {
+      endpoint,
+      providerName
+    };
+  }
+  subscribeChainInfoMap() {
+    return this.chainInfoMapSubject;
+  }
+  subscribeAssetRegistry() {
+    return this.assetRegistrySubject;
+  }
+  subscribeMultiChainAssetMap() {
+    return this.multiChainAssetMapSubject;
+  }
+  subscribeXcmRefMap() {
+    return this.xcmRefMapSubject;
+  }
+  subscribeChainStateMap() {
+    return this.chainStateMapSubject;
+  }
+  getAssetRegistry() {
+    return this.dataMap.assetRegistry;
+  }
+  getMultiChainAssetMap() {
+    return _chainList.MultiChainAssetMap;
+  }
+  getSmartContractTokens() {
+    const filteredAssetRegistry = {};
+    Object.values(this.getAssetRegistry()).forEach(asset => {
+      if (_types3._SMART_CONTRACT_STANDARDS.includes(asset.assetType)) {
+        filteredAssetRegistry[asset.slug] = asset;
+      }
+    });
+    return filteredAssetRegistry;
+  }
+  getChainInfoMap() {
+    return this.dataMap.chainInfoMap;
+  }
+  getEvmChainInfoMap() {
+    const result = {};
+    Object.values(this.getChainInfoMap()).forEach(chainInfo => {
+      if ((0, _utils._isPureEvmChain)(chainInfo)) {
+        result[chainInfo.slug] = chainInfo;
+      }
+    });
+    return result;
+  }
+  getSubstrateChainInfoMap() {
+    const result = {};
+    Object.values(this.getChainInfoMap()).forEach(chainInfo => {
+      if ((0, _utils._isPureSubstrateChain)(chainInfo)) {
+        result[chainInfo.slug] = chainInfo;
+      }
+    });
+    return result;
+  }
+  getAllPriceIds() {
+    const result = [];
+    Object.values(this.getAssetRegistry()).forEach(assetInfo => {
+      if (assetInfo.priceId !== null) {
+        result.push(assetInfo.priceId);
+      }
+    });
+    return result;
+  }
+  getNativeTokenInfo(chainSlug) {
+    let nativeTokenInfo = {
+      assetType: _types._AssetType.NATIVE,
+      decimals: 0,
+      metadata: null,
+      minAmount: '',
+      multiChainAsset: '',
+      name: '',
+      originChain: '',
+      priceId: '',
+      slug: '',
+      symbol: '',
+      hasValue: true
+    };
+    for (const assetInfo of Object.values(this.getAssetRegistry())) {
+      if (assetInfo.assetType === _types._AssetType.NATIVE && assetInfo.originChain === chainSlug) {
+        nativeTokenInfo = assetInfo;
+        break;
+      }
+    }
+    return nativeTokenInfo;
+  }
+  getAssetRefMap() {
+    return this.dataMap.assetRefMap;
+  }
+  getChainStateMap() {
+    return this.dataMap.chainStateMap;
+  }
+  getChainStateByKey(key) {
+    return this.dataMap.chainStateMap[key];
+  }
+  getSupportedSmartContractTypes() {
+    return [_types._AssetType.ERC20, _types._AssetType.ERC721, _types._AssetType.PSP22, _types._AssetType.PSP34];
+  }
+  getActiveChainInfoMap() {
+    const result = {};
+    Object.values(this.getChainInfoMap()).forEach(chainInfo => {
+      const chainState = this.getChainStateByKey(chainInfo.slug);
+      if ((0, _utils._isChainEnabled)(chainState)) {
+        result[chainInfo.slug] = chainInfo;
+      }
+    });
+    return result;
+  }
+  getActiveChainSlugs() {
+    const result = [];
+    Object.values(this.getChainInfoMap()).forEach(chainInfo => {
+      const chainState = this.getChainStateByKey(chainInfo.slug);
+      if ((0, _utils._isChainEnabled)(chainState)) {
+        result.push(chainInfo.slug);
+      }
+    });
+    return result;
+  }
+  getChainInfoByKey(key) {
+    return this.dataMap.chainInfoMap[key];
+  }
+  getActiveChainInfos() {
+    const result = {};
+    Object.values(this.getChainStateMap()).forEach(chainState => {
+      if (chainState.active) {
+        result[chainState.slug] = this.getChainInfoByKey(chainState.slug);
+      }
+    });
+    return result;
+  }
+  getAssetBySlug(slug) {
+    return this.getAssetRegistry()[slug];
+  }
+  getFungibleTokensByChain(chainSlug) {
+    const result = {};
+    Object.values(this.getAssetRegistry()).forEach(chainAsset => {
+      if (chainAsset.originChain === chainSlug && (0, _utils._isAssetFungibleToken)(chainAsset)) {
+        result[chainAsset.slug] = chainAsset;
+      }
+    });
+    return result;
+  }
+  getXcmEqualAssetByChain(destinationChainSlug, originTokenSlug) {
+    let destinationTokenInfo;
+    for (const asset of Object.values(this.getAssetRegistry())) {
+      if (asset.originChain === destinationChainSlug) {
+        // check
+        const assetRefKey = (0, _utils._parseAssetRefKey)(originTokenSlug, asset.slug);
+        const assetRef = this.getAssetRefMap()[assetRefKey];
+        if (assetRef && assetRef.path === _types._AssetRefPath.XCM) {
+          // there's only 1 corresponding token on 1 chain
+          destinationTokenInfo = asset;
+          break;
+        }
+      }
+    }
+    return destinationTokenInfo;
+  }
+  getAssetByChainAndType(chainSlug, assetTypes) {
+    const result = {};
+    Object.values(this.getAssetRegistry()).forEach(assetInfo => {
+      if (assetTypes.includes(assetInfo.assetType) && assetInfo.originChain === chainSlug) {
+        result[assetInfo.slug] = assetInfo;
+      }
+    });
+    return result;
+  }
+  getSmartContractNfts() {
+    const result = [];
+    Object.values(this.getAssetRegistry()).forEach(assetInfo => {
+      if (_types3._NFT_CONTRACT_STANDARDS.includes(assetInfo.assetType)) {
+        result.push(assetInfo);
+      }
+    });
+    return result;
+  }
+
+  // Setter
+  removeCustomChain(slug) {
+    if (this.lockChainInfoMap) {
+      return false;
+    }
+    this.lockChainInfoMap = true;
+    const chainInfoMap = this.getChainInfoMap();
+    const chainStateMap = this.getChainStateMap();
+    if (!(slug in chainInfoMap)) {
+      return false;
+    }
+    if (!(0, _utils._isCustomChain)(slug)) {
+      return false;
+    }
+    if (chainStateMap[slug].active) {
+      return false;
+    }
+    delete chainStateMap[slug];
+    delete chainInfoMap[slug];
+    this.deleteAssetsByChain(slug);
+    this.dbService.removeFromChainStore([slug]).catch(console.error);
+    this.updateChainSubscription();
+    this.lockChainInfoMap = false;
+    return true;
+  }
+  resetChainInfoMap(excludedChains) {
+    if (this.lockChainInfoMap) {
+      return false;
+    }
+    this.lockChainInfoMap = true;
+    const chainStateMap = this.getChainStateMap();
+    for (const [slug, chainState] of Object.entries(chainStateMap)) {
+      if (!_constants2._DEFAULT_ACTIVE_CHAINS.includes(slug) && !(excludedChains !== null && excludedChains !== void 0 && excludedChains.includes(slug))) {
+        chainState.active = false;
+      }
+    }
+    this.updateChainStateMapSubscription();
+    this.lockChainInfoMap = false;
+    return true;
+  }
+  setChainConnectionStatus(slug, connectionStatus) {
+    const chainStateMap = this.getChainStateMap();
+    chainStateMap[slug].connectionStatus = connectionStatus;
+  }
+  upsertCustomToken(token) {
+    if (token.slug.length === 0) {
+      // new token
+      if (token.assetType === _types._AssetType.NATIVE) {
+        const defaultSlug = this.generateSlugForNativeToken(token.originChain, token.assetType, token.symbol);
+        token.slug = `${_types3._CUSTOM_PREFIX}${defaultSlug}`;
+      } else {
+        var _token$metadata;
+        const defaultSlug = this.generateSlugForSmartContractAsset(token.originChain, token.assetType, token.symbol, (_token$metadata = token.metadata) === null || _token$metadata === void 0 ? void 0 : _token$metadata.contractAddress);
+        token.slug = `${_types3._CUSTOM_PREFIX}${defaultSlug}`;
+      }
+    }
+    const assetRegistry = this.getAssetRegistry();
+    assetRegistry[token.slug] = token;
+    this.dbService.updateAssetStore(token).catch(e => this.logger.error(e));
+    this.assetRegistrySubject.next(assetRegistry);
+    return token.slug;
+  }
+  deleteAssetsByChain(chainSlug) {
+    if (!(0, _utils._isCustomChain)(chainSlug)) {
+      return;
+    }
+    const targetAssets = [];
+    const assetRegistry = this.getAssetRegistry();
+    Object.values(assetRegistry).forEach(targetToken => {
+      if (targetToken.originChain === chainSlug) {
+        targetAssets.push(targetToken.slug);
+      }
+    });
+    this.deleteCustomAssets(targetAssets);
+  }
+  deleteCustomAssets(targetAssets) {
+    const assetRegistry = this.getAssetRegistry();
+    targetAssets.forEach(targetToken => {
+      delete assetRegistry[targetToken];
+    });
+    this.dbService.removeFromBalanceStore(targetAssets).catch(e => this.logger.error(e));
+    this.dbService.removeFromAssetStore(targetAssets).catch(e => this.logger.error(e));
+    this.assetRegistrySubject.next(assetRegistry);
+  }
+
+  // Business logic
+  async init() {
+    // TODO: reconsider the flow of initiation
+    this.dataMap.assetRefMap = _chainList.AssetRefMap;
+    await this.initChains();
+    this.chainInfoMapSubject.next(this.getChainInfoMap());
+    this.chainStateMapSubject.next(this.getChainStateMap());
+    this.assetRegistrySubject.next(this.getAssetRegistry());
+    this.initApis();
+    await this.initAssetSettings();
+    this.logger.log('Initiated chains, assets and APIs');
+  }
+  initApis() {
+    // TODO: this might be async
+    Object.entries(this.getChainInfoMap()).forEach(_ref2 => {
+      let [slug, chainInfo] = _ref2;
+      if (this.getChainStateByKey(slug).active) {
+        this.initApiForChain(chainInfo);
+      }
+    });
+  }
+  initApiForChain(chainInfo) {
+    const {
+      endpoint,
+      providerName
+    } = this.getChainCurrentProviderByKey(chainInfo.slug);
+    if (chainInfo.substrateInfo !== null) {
+      const chainApi = this.initApi(chainInfo.slug, endpoint, 'substrate', providerName);
+      this.substrateChainHandler.setSubstrateApi(chainInfo.slug, chainApi);
+    }
+    if (chainInfo.evmInfo !== null) {
+      const chainApi = this.initApi(chainInfo.slug, endpoint, 'evm', providerName);
+      this.evmChainHandler.setEvmApi(chainInfo.slug, chainApi);
+    }
+  }
+  destroyApiForChain(chainInfo) {
+    if (chainInfo.substrateInfo !== null) {
+      this.substrateChainHandler.destroySubstrateApi(chainInfo.slug);
+    }
+    if (chainInfo.evmInfo !== null) {
+      this.evmChainHandler.destroyEvmApi(chainInfo.slug);
+    }
+  }
+  initApi(slug, endpoint) {
+    let type = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 'substrate';
+    let providerName = arguments.length > 3 ? arguments[3] : undefined;
+    switch (type) {
+      case 'evm':
+        return this.evmChainHandler.initApi(slug, endpoint, providerName);
+      default:
+        // substrate by default
+        return this.substrateChainHandler.initApi(slug, endpoint, providerName);
+    }
+  }
+  _enableChain(chainSlug) {
+    const chainInfo = this.getChainInfoByKey(chainSlug);
+    const chainStateMap = this.getChainStateMap();
+    if (chainStateMap[chainSlug].active || this.lockChainInfoMap) {
+      return false;
+    }
+    this.lockChainInfoMap = true;
+    chainStateMap[chainSlug].active = true;
+    this.initApiForChain(chainInfo);
+    this.refreshChainStateInterval(1000);
+    this.dbService.updateChainStore({
+      ...chainInfo,
+      active: true,
+      currentProvider: chainStateMap[chainSlug].currentProvider
+    }).catch(console.error);
+    this.lockChainInfoMap = false;
+    return true;
+  }
+  enableChain(chainSlug) {
+    const rs = this._enableChain(chainSlug);
+    if (rs) {
+      this.updateChainStateMapSubscription();
+    }
+    return rs;
+  }
+  enableChains(chainSlugs) {
+    const rs = chainSlugs.map(this._enableChain.bind(this));
+    if (rs.some(r => r)) {
+      this.updateChainStateMapSubscription();
+    }
+    return rs.every(r => r);
+  }
+  disableChain(chainSlug) {
+    const chainInfo = this.getChainInfoByKey(chainSlug);
+    const chainStateMap = this.getChainStateMap();
+    if (!chainStateMap[chainSlug].active || this.lockChainInfoMap) {
+      return false;
+    }
+    this.lockChainInfoMap = true;
+    chainStateMap[chainSlug].active = false;
+    // Set disconnect state for inactive chain
+    chainStateMap[chainSlug].connectionStatus = _types3._ChainConnectionStatus.DISCONNECTED;
+    this.destroyApiForChain(chainInfo);
+    this.dbService.updateChainStore({
+      ...chainInfo,
+      active: false,
+      currentProvider: chainStateMap[chainSlug].currentProvider
+    }).catch(console.error);
+    this.updateChainStateMapSubscription();
+    this.lockChainInfoMap = false;
+    return true;
+  }
+  checkExistedPredefinedChain(genesisHash, evmChainId) {
+    let duplicatedSlug = '';
+    if (genesisHash) {
+      Object.values(_chainList.ChainInfoMap).forEach(chainInfo => {
+        if (chainInfo.substrateInfo && chainInfo.substrateInfo.genesisHash === genesisHash) {
+          duplicatedSlug = chainInfo.slug;
+        }
+      });
+    } else if (evmChainId) {
+      Object.values(_chainList.ChainInfoMap).forEach(chainInfo => {
+        if (chainInfo.evmInfo && chainInfo.evmInfo.evmChainId === evmChainId) {
+          duplicatedSlug = chainInfo.slug;
+        }
+      });
+    }
+    return duplicatedSlug;
+  }
+  async initChains() {
+    const storedChainSettings = await this.dbService.getAllChainStore();
+    const storedChainSettingMap = {};
+    storedChainSettings.forEach(chainStoredSetting => {
+      storedChainSettingMap[chainStoredSetting.slug] = chainStoredSetting;
+    });
+    const newStorageData = [];
+    const deprecatedChains = [];
+    const deprecatedChainMap = {};
+    if (storedChainSettings.length === 0) {
+      this.dataMap.chainInfoMap = _chainList.ChainInfoMap;
+      Object.values(_chainList.ChainInfoMap).forEach(chainInfo => {
+        this.dataMap.chainStateMap[chainInfo.slug] = {
+          currentProvider: Object.keys(chainInfo.providers)[0],
+          slug: chainInfo.slug,
+          connectionStatus: _types3._ChainConnectionStatus.DISCONNECTED,
+          active: _constants2._DEFAULT_ACTIVE_CHAINS.includes(chainInfo.slug)
+        };
+
+        // create data for storage
+        newStorageData.push({
+          ...chainInfo,
+          active: _constants2._DEFAULT_ACTIVE_CHAINS.includes(chainInfo.slug),
+          currentProvider: Object.keys(chainInfo.providers)[0]
+        });
+      });
+    } else {
+      const mergedChainInfoMap = _chainList.ChainInfoMap;
+      for (const [storedSlug, storedChainInfo] of Object.entries(storedChainSettingMap)) {
+        if (storedSlug in _chainList.ChainInfoMap) {
+          // check predefined chains first, update providers and currentProvider
+          mergedChainInfoMap[storedSlug].providers = {
+            ...storedChainInfo.providers,
+            ...mergedChainInfoMap[storedSlug].providers
+          };
+          this.dataMap.chainStateMap[storedSlug] = {
+            currentProvider: storedChainInfo.currentProvider,
+            slug: storedSlug,
+            connectionStatus: _types3._ChainConnectionStatus.DISCONNECTED,
+            active: storedChainInfo.active
+          };
+          newStorageData.push({
+            ...mergedChainInfoMap[storedSlug],
+            active: storedChainInfo.active,
+            currentProvider: storedChainInfo.currentProvider
+          });
+        } else {
+          var _storedChainInfo$subs, _storedChainInfo$evmI;
+          // only custom chains are left
+          // check custom chain duplicated with predefined chain => merge into predefined chain
+          const duplicatedDefaultSlug = this.checkExistedPredefinedChain((_storedChainInfo$subs = storedChainInfo.substrateInfo) === null || _storedChainInfo$subs === void 0 ? void 0 : _storedChainInfo$subs.genesisHash, (_storedChainInfo$evmI = storedChainInfo.evmInfo) === null || _storedChainInfo$evmI === void 0 ? void 0 : _storedChainInfo$evmI.evmChainId);
+          if (duplicatedDefaultSlug.length > 0) {
+            // merge custom chain with existed chain
+            mergedChainInfoMap[duplicatedDefaultSlug].providers = {
+              ...storedChainInfo.providers,
+              ...mergedChainInfoMap[duplicatedDefaultSlug].providers
+            };
+            this.dataMap.chainStateMap[duplicatedDefaultSlug] = {
+              currentProvider: storedChainInfo.currentProvider,
+              slug: duplicatedDefaultSlug,
+              connectionStatus: _types3._ChainConnectionStatus.DISCONNECTED,
+              active: storedChainInfo.active
+            };
+            newStorageData.push({
+              ...mergedChainInfoMap[duplicatedDefaultSlug],
+              active: storedChainInfo.active,
+              currentProvider: storedChainInfo.currentProvider
+            });
+            deprecatedChainMap[storedSlug] = duplicatedDefaultSlug;
+            deprecatedChains.push(storedSlug);
+          } else {
+            mergedChainInfoMap[storedSlug] = {
+              slug: storedSlug,
+              name: storedChainInfo.name,
+              providers: storedChainInfo.providers,
+              evmInfo: storedChainInfo.evmInfo,
+              substrateInfo: storedChainInfo.substrateInfo,
+              isTestnet: storedChainInfo.isTestnet,
+              chainStatus: storedChainInfo.chainStatus
+            };
+            this.dataMap.chainStateMap[storedSlug] = {
+              currentProvider: storedChainInfo.currentProvider,
+              slug: storedSlug,
+              connectionStatus: _types3._ChainConnectionStatus.DISCONNECTED,
+              active: storedChainInfo.active
+            };
+            newStorageData.push({
+              ...mergedChainInfoMap[storedSlug],
+              active: storedChainInfo.active,
+              currentProvider: storedChainInfo.currentProvider
+            });
+          }
+        }
+      }
+
+      // Fill in the missing chainState and storageData (new chains never before seen)
+      Object.entries(mergedChainInfoMap).forEach(_ref3 => {
+        let [slug, chainInfo] = _ref3;
+        if (!(slug in this.dataMap.chainStateMap)) {
+          this.dataMap.chainStateMap[slug] = {
+            currentProvider: Object.keys(chainInfo.providers)[0],
+            slug,
+            connectionStatus: _types3._ChainConnectionStatus.DISCONNECTED,
+            active: _constants2._DEFAULT_ACTIVE_CHAINS.includes(slug)
+          };
+          newStorageData.push({
+            ...mergedChainInfoMap[slug],
+            active: _constants2._DEFAULT_ACTIVE_CHAINS.includes(slug),
+            currentProvider: Object.keys(chainInfo.providers)[0]
+          });
+        }
+      });
+      this.dataMap.chainInfoMap = mergedChainInfoMap;
+    }
+    await this.dbService.bulkUpdateChainStore(newStorageData);
+    await this.dbService.removeFromChainStore(deprecatedChains); // remove outdated records
+    await this.initAssetRegistry(deprecatedChainMap);
+  }
+  async initAssetRegistry(deprecatedCustomChainMap) {
+    const storedAssetRegistry = await this.dbService.getAllAssetStore();
+    if (storedAssetRegistry.length === 0) {
+      this.dataMap.assetRegistry = _chainList.ChainAssetMap;
+    } else {
+      const mergedAssetRegistry = _chainList.ChainAssetMap;
+      const parsedStoredAssetRegistry = {};
+      const deprecatedAssets = [];
+
+      // Update custom assets of merged custom chains
+      Object.values(storedAssetRegistry).forEach(storedAsset => {
+        if ((0, _utils._isCustomAsset)(storedAsset.slug) && Object.keys(deprecatedCustomChainMap).includes(storedAsset.originChain)) {
+          var _storedAsset$metadata;
+          const newOriginChain = deprecatedCustomChainMap[storedAsset.originChain];
+          const newSlug = this.generateSlugForSmartContractAsset(newOriginChain, storedAsset.assetType, storedAsset.symbol, (_storedAsset$metadata = storedAsset.metadata) === null || _storedAsset$metadata === void 0 ? void 0 : _storedAsset$metadata.contractAddress);
+          deprecatedAssets.push(storedAsset.slug);
+          parsedStoredAssetRegistry[newSlug] = {
+            ...storedAsset,
+            originChain: newOriginChain,
+            slug: newSlug
+          };
+        } else {
+          parsedStoredAssetRegistry[storedAsset.slug] = storedAsset;
+        }
+      });
+      for (const assetInfo of Object.values(parsedStoredAssetRegistry)) {
+        let duplicated = false;
+        for (const defaultChainAsset of Object.values(_chainList.ChainAssetMap)) {
+          // case merge custom asset with default asset
+          if ((0, _utils._isEqualSmartContractAsset)(assetInfo, defaultChainAsset)) {
+            duplicated = true;
+            break;
+          }
+        }
+        if (!duplicated) {
+          mergedAssetRegistry[assetInfo.slug] = assetInfo;
+        }
+      }
+      this.dataMap.assetRegistry = mergedAssetRegistry;
+      await this.dbService.removeFromAssetStore(deprecatedAssets);
+    }
+  }
+  updateChainStateMapSubscription() {
+    this.chainStateMapSubject.next(this.getChainStateMap());
+  }
+  updateChainInfoMapSubscription() {
+    this.chainInfoMapSubject.next(this.getChainInfoMap());
+  }
+  updateChainSubscription() {
+    this.updateChainInfoMapSubscription();
+    this.updateChainStateMapSubscription();
+  }
+
+  // Can only update providers or block explorer, crowdloan url
+  updateChain(params) {
+    const chainSlug = params.chainEditInfo.slug;
+    const targetChainInfo = this.getChainInfoByKey(chainSlug);
+    const targetChainState = this.getChainStateByKey(chainSlug);
+    const changedProvider = params.chainEditInfo.currentProvider !== targetChainState.currentProvider;
+    if (changedProvider) {
+      targetChainInfo.providers = params.chainEditInfo.providers;
+      targetChainState.currentProvider = params.chainEditInfo.currentProvider;
+
+      // Enable chain if not before
+      if (!targetChainState.active) {
+        targetChainState.active = true;
+      }
+
+      // TODO: it might override existed API
+      this.initApiForChain(targetChainInfo);
+      this.updateChainStateMapSubscription();
+    }
+    if (targetChainInfo.substrateInfo) {
+      if (params.chainEditInfo.blockExplorer !== undefined) {
+        targetChainInfo.substrateInfo.blockExplorer = params.chainEditInfo.blockExplorer;
+      }
+      if (params.chainEditInfo.crowdloanUrl !== undefined) {
+        targetChainInfo.substrateInfo.crowdloanUrl = params.chainEditInfo.crowdloanUrl;
+      }
+    }
+    this.updateChainInfoMapSubscription();
+    this.dbService.updateChainStore({
+      ...targetChainInfo,
+      active: targetChainState.active,
+      currentProvider: targetChainState.currentProvider
+    }).catch(e => this.logger.error(e));
+  }
+  insertChain(params) {
+    const chainInfoMap = this.getChainInfoMap();
+    if (!params.chainSpec) {
+      return;
+    }
+    const newChainSlug = this.generateSlugForCustomChain(params.chainEditInfo.chainType, params.chainEditInfo.name, params.chainSpec.paraId, params.chainSpec.evmChainId);
+    let substrateInfo = null;
+    let evmInfo = null;
+    if (params.chainSpec.genesisHash !== '') {
+      substrateInfo = {
+        addressPrefix: params.chainSpec.addressPrefix,
+        blockExplorer: params.chainEditInfo.blockExplorer || null,
+        chainType: params.chainSpec.paraId !== null ? _types._SubstrateChainType.PARACHAIN : _types._SubstrateChainType.RELAYCHAIN,
+        crowdloanUrl: params.chainEditInfo.crowdloanUrl || null,
+        decimals: params.chainSpec.decimals,
+        existentialDeposit: params.chainSpec.existentialDeposit,
+        paraId: params.chainSpec.paraId,
+        symbol: params.chainEditInfo.symbol,
+        genesisHash: params.chainSpec.genesisHash,
+        relaySlug: null,
+        hasNativeNft: false,
+        supportStaking: params.chainSpec.paraId === null,
+        supportSmartContract: null
+      };
+    } else if (params.chainSpec.evmChainId !== null) {
+      evmInfo = {
+        supportSmartContract: [_types._AssetType.ERC20, _types._AssetType.ERC721],
+        // set support for ERC token by default
+        blockExplorer: params.chainEditInfo.blockExplorer || null,
+        decimals: params.chainSpec.decimals,
+        evmChainId: params.chainSpec.evmChainId,
+        existentialDeposit: params.chainSpec.existentialDeposit,
+        symbol: params.chainEditInfo.symbol,
+        abiExplorer: null
+      };
+    }
+    const chainInfo = {
+      slug: newChainSlug,
+      name: params.chainEditInfo.name,
+      providers: params.chainEditInfo.providers,
+      substrateInfo,
+      evmInfo,
+      isTestnet: false,
+      chainStatus: _types._ChainStatus.ACTIVE
+    };
+
+    // insert new chainInfo
+    chainInfoMap[newChainSlug] = chainInfo;
+
+    // insert new chainState
+    const chainStateMap = this.getChainStateMap();
+    chainStateMap[newChainSlug] = {
+      active: true,
+      connectionStatus: _types3._ChainConnectionStatus.DISCONNECTED,
+      currentProvider: params.chainEditInfo.currentProvider,
+      slug: newChainSlug
+    };
+    this.initApiForChain(chainInfo);
+
+    // create a record in assetRegistry for native token and update store/subscription
+    const nativeTokenSlug = this.upsertCustomToken({
+      assetType: _types._AssetType.NATIVE,
+      decimals: params.chainSpec.decimals,
+      metadata: null,
+      minAmount: params.chainSpec.existentialDeposit,
+      multiChainAsset: null,
+      name: params.chainEditInfo.name,
+      originChain: newChainSlug,
+      priceId: params.chainEditInfo.priceId || null,
+      slug: '',
+      symbol: params.chainEditInfo.symbol,
+      hasValue: true
+    });
+
+    // update subscription
+    this.updateChainSubscription();
+
+    // TODO: add try, catch, move storage update and subject update to somewhere else
+    this.dbService.updateChainStore({
+      active: true,
+      currentProvider: params.chainEditInfo.currentProvider,
+      ...chainInfo
+    }).catch(e => this.logger.error(e));
+    return nativeTokenSlug;
+  }
+  upsertChain(params) {
+    if (this.lockChainInfoMap) {
+      return;
+    }
+    this.lockChainInfoMap = true;
+    let result;
+    if (params.mode === 'update') {
+      // update existing chainInfo
+      this.updateChain(params);
+    } else {
+      // insert custom network
+      result = this.insertChain(params);
+    }
+    this.lockChainInfoMap = false;
+    return result;
+  }
+  generateSlugForCustomChain(chainType, name, paraId, evmChainId) {
+    const parsedName = name.replaceAll(' ', '').toLowerCase();
+    if (evmChainId !== null && evmChainId !== undefined) {
+      return `${_types3._CUSTOM_PREFIX}${chainType}-${parsedName}-${evmChainId}`;
+    } else {
+      let slug = `${_types3._CUSTOM_PREFIX}${chainType}-${parsedName}`;
+      if (paraId !== null && paraId !== undefined) {
+        slug = slug.concat(`-${paraId}`);
+      }
+      return slug;
+    }
+  }
+  async validateCustomChain(provider, existingChainSlug) {
+    // currently only supports WS provider for Substrate and HTTP provider for EVM
+    let result = {
+      decimals: 0,
+      existentialDeposit: '',
+      paraId: null,
+      symbol: '',
+      success: false,
+      genesisHash: '',
+      addressPrefix: '',
+      name: '',
+      evmChainId: null
+    };
+    try {
+      const {
+        conflictChainName: providerConflictChainName,
+        conflictChainSlug: providerConflictChainSlug,
+        error: providerError
+      } = this.validateProvider(provider, existingChainSlug);
+      if (providerError === _types2._CHAIN_VALIDATION_ERROR.NONE) {
+        let api;
+
+        // TODO: EVM chain might have WS provider
+        if (provider.startsWith('http')) {
+          // HTTP provider is EVM by default
+          api = this.evmChainHandler.initApi('custom', provider);
+        } else {
+          api = this.substrateChainHandler.initApi('custom', provider);
+        }
+        const connectionTimeout = new Promise(resolve => {
+          const id = setTimeout(() => {
+            clearTimeout(id);
+            resolve(null);
+          }, 5000);
+        });
+        const connectionTrial = await Promise.race([connectionTimeout, api.isReady]); // check connection
+
+        if (connectionTrial !== null) {
+          let _api = connectionTrial;
+          const chainSpec = await this.getChainSpecByProvider(_api);
+          result = Object.assign(result, chainSpec);
+
+          // TODO: disconnect and destroy API
+          // @ts-ignore
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-call
+          // _api?.api?.disconnect && await _api?.api?.disconnect();
+          _api = null;
+          if (existingChainSlug) {
+            // check if same network (with existingChainSlug)
+            const existedChainInfo = this.getChainInfoByKey(existingChainSlug);
+            if (existedChainInfo.evmInfo !== null) {
+              if (result.evmChainId !== existedChainInfo.evmInfo.evmChainId) {
+                result.error = _types2._CHAIN_VALIDATION_ERROR.PROVIDER_NOT_SAME_CHAIN;
+              }
+            } else if (existedChainInfo.substrateInfo !== null) {
+              if (result.genesisHash !== existedChainInfo.substrateInfo.genesisHash) {
+                result.error = _types2._CHAIN_VALIDATION_ERROR.PROVIDER_NOT_SAME_CHAIN;
+              }
+            }
+          } else {
+            // check if network existed
+            if (result.evmChainId !== null) {
+              for (const chainInfo of Object.values(this.getEvmChainInfoMap())) {
+                var _chainInfo$evmInfo;
+                if ((chainInfo === null || chainInfo === void 0 ? void 0 : (_chainInfo$evmInfo = chainInfo.evmInfo) === null || _chainInfo$evmInfo === void 0 ? void 0 : _chainInfo$evmInfo.evmChainId) === result.evmChainId) {
+                  result.error = _types2._CHAIN_VALIDATION_ERROR.EXISTED_CHAIN;
+                  result.conflictChain = chainInfo.name;
+                  result.conflictKey = chainInfo.slug;
+                  break;
+                }
+              }
+            } else if (result.genesisHash !== '') {
+              for (const chainInfo of Object.values(this.getSubstrateChainInfoMap())) {
+                var _chainInfo$substrateI;
+                if ((chainInfo === null || chainInfo === void 0 ? void 0 : (_chainInfo$substrateI = chainInfo.substrateInfo) === null || _chainInfo$substrateI === void 0 ? void 0 : _chainInfo$substrateI.genesisHash) === result.genesisHash) {
+                  result.error = _types2._CHAIN_VALIDATION_ERROR.EXISTED_CHAIN;
+                  result.conflictChain = chainInfo.name;
+                  result.conflictKey = chainInfo.slug;
+                  break;
+                }
+              }
+            }
+          }
+        } else {
+          result.error = _types2._CHAIN_VALIDATION_ERROR.CONNECTION_FAILURE;
+          result.success = false;
+        }
+      } else {
+        result.success = false;
+        result.error = providerError;
+        result.conflictChain = providerConflictChainName;
+        result.conflictKey = providerConflictChainSlug;
+      }
+      if (!result.error && (result.evmChainId !== null || result.genesisHash !== '')) {
+        result.success = true;
+      }
+      return result;
+    } catch (e) {
+      console.error('Error connecting to provider', e);
+      result.success = false;
+      result.error = _types2._CHAIN_VALIDATION_ERROR.CONNECTION_FAILURE;
+      return result;
+    }
+  }
+  async getChainSpecByProvider(api) {
+    if (api.api instanceof _web.default) {
+      return await this.evmChainHandler.getChainSpec(api);
+    }
+    return await this.substrateChainHandler.getChainSpec(api);
+  }
+  validateProvider(targetProvider, existingChainSlug) {
+    let error = _types2._CHAIN_VALIDATION_ERROR.NONE;
+    const chainInfoMap = this.getChainInfoMap();
+    const allExistedProviders = [];
+    let conflictChainSlug = '';
+    let conflictChainName = '';
+    if (existingChainSlug) {
+      const chainInfo = chainInfoMap[existingChainSlug];
+      if (Object.values(chainInfo.providers).includes(targetProvider)) {
+        error = _types2._CHAIN_VALIDATION_ERROR.EXISTED_PROVIDER;
+        conflictChainSlug = chainInfo.slug;
+        conflictChainName = chainInfo.name;
+      }
+      return {
+        error,
+        conflictChainSlug,
+        conflictChainName
+      };
+    }
+
+    // get all providers
+    for (const [key, value] of Object.entries(chainInfoMap)) {
+      Object.values(value.providers).forEach(provider => {
+        allExistedProviders.push({
+          key,
+          provider
+        });
+      });
+    }
+    for (const {
+      key,
+      provider
+    } of allExistedProviders) {
+      if (provider === targetProvider) {
+        error = _types2._CHAIN_VALIDATION_ERROR.EXISTED_PROVIDER;
+        conflictChainSlug = key;
+        conflictChainName = chainInfoMap[key].name;
+        break;
+      }
+    }
+    return {
+      error,
+      conflictChainSlug,
+      conflictChainName
+    };
+  }
+  async getSmartContractTokenInfo(contractAddress, tokenType, originChain, contractCaller) {
+    if ([_types._AssetType.ERC721, _types._AssetType.ERC20].includes(tokenType)) {
+      return await this.evmChainHandler.getSmartContractTokenInfo(contractAddress, tokenType, originChain);
+    } else if ([_types._AssetType.PSP34, _types._AssetType.PSP22].includes(tokenType)) {
+      return await this.substrateChainHandler.getSmartContractTokenInfo(contractAddress, tokenType, originChain, contractCaller);
+    }
+    return {
+      decimals: -1,
+      name: '',
+      symbol: '',
+      contractError: false
+    };
+  }
+  async validateCustomToken(data) {
+    const assetRegistry = this.getSmartContractTokens();
+    let isExist = false;
+    for (const token of Object.values(assetRegistry)) {
+      var _token$metadata2;
+      const contractAddress = token === null || token === void 0 ? void 0 : (_token$metadata2 = token.metadata) === null || _token$metadata2 === void 0 ? void 0 : _token$metadata2.contractAddress;
+      if ((0, _utils._isEqualContractAddress)(contractAddress, data.contractAddress) && token.assetType === data.type && token.originChain === data.originChain) {
+        isExist = true;
+        break;
+      }
+    }
+    if (isExist) {
+      return {
+        decimals: -1,
+        name: '',
+        symbol: '',
+        isExist,
+        contractError: false
+      };
+    }
+    const {
+      contractError,
+      decimals,
+      name,
+      symbol
+    } = await this.getSmartContractTokenInfo(data.contractAddress, data.type, data.originChain, data.contractCaller);
+    return {
+      name,
+      decimals,
+      symbol,
+      isExist,
+      contractError
+    };
+  }
+  generateSlugForSmartContractAsset(originChain, assetType, symbol, contractAddress) {
+    return `${originChain}-${assetType}-${symbol}-${contractAddress}`;
+  }
+  generateSlugForNativeToken(originChain, assetType, symbol) {
+    return `${originChain}-${assetType}-${symbol}`;
+  }
+  refreshSubstrateApi(slug) {
+    this.substrateChainHandler.refreshApi(slug);
+  }
+  refreshEvmApi(slug) {
+    const {
+      endpoint,
+      providerName
+    } = this.getChainCurrentProviderByKey(slug);
+    this.evmChainHandler.refreshApi(slug, endpoint, providerName);
+  }
+  stopAllChainApis() {
+    // TODO: add logic for EvmApi
+    // Object.entries(this.apiMap.web3).forEach(([key, network]) => {
+    //   if (network.currentProvider instanceof Web3.providers.WebsocketProvider) {
+    //     if (network.currentProvider?.connected) {
+    //       console.log(`[Web3] ${key} is connected`);
+    //       network.currentProvider?.disconnect(code, reason);
+    //       console.log(`[Web3] ${key} is ${network.currentProvider.connected ? 'connected' : 'disconnected'} now`);
+    //     }
+    //   }
+    // });
+
+    return this.substrateChainHandler.disconnectAllApis();
+  }
+  resumeAllChainApis() {
+    // TODO: add logic for EvmApi
+    // Object.entries(this.apiMap.web3).forEach(([key, network]) => {
+    //   const currentProvider = network.currentProvider;
+
+    //   if (currentProvider instanceof Web3.providers.WebsocketProvider) {
+    //     if (!currentProvider.connected) {
+    //       console.log(`[Web3] ${key} is disconnected`);
+    //       currentProvider?.connect();
+    //       setTimeout(() => console.log(`[Web3] ${key} is ${currentProvider.connected ? 'connected' : 'disconnected'} now`), 500);
+    //     }
+    //   }
+    // });
+
+    return this.substrateChainHandler.resumeAllApis();
+  }
+
+  // Interval update api status
+  refreshChainStateInterval() {
+    let delay = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
+    clearTimeout(this.refreshChainStateTimeout);
+    setTimeout(() => {
+      this.updateApiMapStatus();
+      this.refreshChainStateTimeout = setTimeout(() => {
+        this.updateApiMapStatus();
+        this.refreshChainStateInterval();
+      }, _constants.CRON_GET_API_MAP_STATUS);
+    }, delay);
+  }
+  updateApiMapStatus() {
+    const substrateApiMap = this.getSubstrateApiMap();
+    const evmApiMap = this.getEvmApiMap();
+    const chainStateMap = this.getChainStateMap();
+    let update = false;
+    function updateState(current, status) {
+      if (current.connectionStatus !== status) {
+        current.connectionStatus = status;
+        update = true;
+      }
+    }
+    Object.entries(chainStateMap).forEach(_ref4 => {
+      let [chain, chainState] = _ref4;
+      if (chainState.active) {
+        if (substrateApiMap[chain]) {
+          const api = substrateApiMap[chain];
+          if (api) {
+            updateState(chainState, _types3._ChainConnectionStatus.CONNECTED);
+            return;
+          }
+        } else if (evmApiMap[chain]) {
+          const api = evmApiMap[chain];
+          if (api) {
+            updateState(chainState, _types3._ChainConnectionStatus.CONNECTED);
+            return;
+          }
+        }
+      }
+      updateState(chainState, _types3._ChainConnectionStatus.DISCONNECTED);
+    });
+    if (update) {
+      console.log('Update chain connection state');
+      this.chainStateMapSubject.next(chainStateMap);
+    }
+  }
+  async initAssetSettings() {
+    const assetSettings = await this.getAssetSettings();
+    const activeChainSlugs = this.getActiveChainSlugs();
+    const assetRegistry = this.getAssetRegistry();
+    if (Object.keys(assetSettings).length === 0) {
+      // only initiate the first time
+      Object.values(assetRegistry).forEach(assetInfo => {
+        const isSettingExisted = (assetInfo.slug in assetSettings);
+
+        // Set visible for every enabled chains
+        if (activeChainSlugs.includes(assetInfo.originChain) && !isSettingExisted) {
+          // Setting only exist when set either by chain settings or user
+          assetSettings[assetInfo.slug] = {
+            visible: true
+          };
+        }
+      });
+      this.setAssetSettings(assetSettings);
+    }
+    console.log('Done init asset settings');
+  }
+  setAssetSettings(assetSettings) {
+    this.assetSettingSubject.next(assetSettings);
+    this.store.set('AssetSetting', assetSettings);
+  }
+  async getStoreAssetSettings() {
+    return new Promise(resolve => {
+      this.store.get('AssetSetting', resolve);
+    });
+  }
+  async getAssetSettings() {
+    if (Object.keys(this.assetSettingSubject.value).length === 0) {
+      const assetSettings = (await this.getStoreAssetSettings()) || {};
+      this.assetSettingSubject.next(assetSettings);
+    }
+    return this.assetSettingSubject.value;
+  }
+  async updateAssetSetting(assetSlug, assetSetting) {
+    const currentAssetSettings = await this.getAssetSettings();
+
+    // Update settings
+    currentAssetSettings[assetSlug] = assetSetting;
+    this.setAssetSettings(currentAssetSettings);
+    if (assetSetting.visible) {
+      const assetInfo = this.getAssetBySlug(assetSlug);
+      const chainState = this.getChainStateByKey(assetInfo.originChain);
+
+      // if chain not enabled, then automatically enable
+      if (chainState && !chainState.active) {
+        this.enableChain(chainState.slug);
+      }
+    }
+  }
+  async updateAssetSettingByChain(chainSlug, visible) {
+    const storedAssetSettings = await this.getAssetSettings();
+    const assetsByChain = this.getFungibleTokensByChain(chainSlug);
+    const assetSettings = storedAssetSettings || {};
+    Object.values(assetsByChain).forEach(assetInfo => {
+      assetSettings[assetInfo.slug] = {
+        visible
+      };
+    });
+    this.setAssetSettings(assetSettings);
+  }
+  subscribeAssetSettings() {
+    return this.assetSettingSubject;
+  }
+}
+exports.ChainService = ChainService;