@subwallet/extension-base 0.8.3-2 → 1.0.1

package/services/chain-service/index.js

@@ -0,0 +1,1139 @@
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { AssetRefMap, ChainAssetMap, ChainInfoMap, MultiChainAssetMap } from '@subwallet/chain-list';
+import { _AssetRefPath, _AssetType, _ChainStatus, _SubstrateChainType } from '@subwallet/chain-list/types';
+import { CRON_GET_API_MAP_STATUS } from '@subwallet/extension-base/constants';
+import { _DEFAULT_ACTIVE_CHAINS } from '@subwallet/extension-base/services/chain-service/constants';
+import { EvmChainHandler } from '@subwallet/extension-base/services/chain-service/handler/EvmChainHandler';
+import { SubstrateChainHandler } from '@subwallet/extension-base/services/chain-service/handler/SubstrateChainHandler';
+import { _CHAIN_VALIDATION_ERROR } from '@subwallet/extension-base/services/chain-service/handler/types';
+import { _ChainConnectionStatus, _CUSTOM_PREFIX, _NFT_CONTRACT_STANDARDS, _SMART_CONTRACT_STANDARDS } from '@subwallet/extension-base/services/chain-service/types';
+import { _isAssetFungibleToken, _isChainEnabled, _isCustomAsset, _isCustomChain, _isEqualContractAddress, _isEqualSmartContractAsset, _isPureEvmChain, _isPureSubstrateChain, _parseAssetRefKey } from '@subwallet/extension-base/services/chain-service/utils';
+import AssetSettingStore from '@subwallet/extension-base/stores/AssetSetting';
+import { BehaviorSubject, Subject } from 'rxjs';
+import Web3 from 'web3';
+import { logger as createLogger } from '@polkadot/util/logger';
+export 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 Subject();
+  chainStateMapSubject = new Subject();
+  assetRegistrySubject = new Subject();
+  multiChainAssetMapSubject = new Subject();
+  xcmRefMapSubject = new Subject();
+
+  // Todo: Update to new store indexed DB
+  store = new AssetSettingStore();
+  assetSettingSubject = new BehaviorSubject({});
+  constructor(dbService) {
+    this.dbService = dbService;
+    this.substrateChainHandler = new SubstrateChainHandler();
+    this.evmChainHandler = new EvmChainHandler();
+    this.chainInfoMapSubject.next(this.dataMap.chainInfoMap);
+    this.chainStateMapSubject.next(this.dataMap.chainStateMap);
+    this.assetRegistrySubject.next(this.dataMap.assetRegistry);
+    this.multiChainAssetMapSubject.next(MultiChainAssetMap);
+    this.xcmRefMapSubject.next(this.getXcmRefMap());
+    this.logger = createLogger('chain-service');
+    this.refreshChainStateInterval(3000);
+  }
+
+  // Getter
+  getXcmRefMap() {
+    const result = {};
+    Object.entries(AssetRefMap).forEach(([key, assetRef]) => {
+      if (assetRef.path === _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 MultiChainAssetMap;
+  }
+  getSmartContractTokens() {
+    const filteredAssetRegistry = {};
+    Object.values(this.getAssetRegistry()).forEach(asset => {
+      if (_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 (_isPureEvmChain(chainInfo)) {
+        result[chainInfo.slug] = chainInfo;
+      }
+    });
+    return result;
+  }
+  getSubstrateChainInfoMap() {
+    const result = {};
+    Object.values(this.getChainInfoMap()).forEach(chainInfo => {
+      if (_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: _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 === _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 [_AssetType.ERC20, _AssetType.ERC721, _AssetType.PSP22, _AssetType.PSP34];
+  }
+  getActiveChainInfoMap() {
+    const result = {};
+    Object.values(this.getChainInfoMap()).forEach(chainInfo => {
+      const chainState = this.getChainStateByKey(chainInfo.slug);
+      if (_isChainEnabled(chainState)) {
+        result[chainInfo.slug] = chainInfo;
+      }
+    });
+    return result;
+  }
+  getActiveChainSlugs() {
+    const result = [];
+    Object.values(this.getChainInfoMap()).forEach(chainInfo => {
+      const chainState = this.getChainStateByKey(chainInfo.slug);
+      if (_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 && _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 = _parseAssetRefKey(originTokenSlug, asset.slug);
+        const assetRef = this.getAssetRefMap()[assetRefKey];
+        if (assetRef && assetRef.path === _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 (_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 (!_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 (!_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 === _AssetType.NATIVE) {
+        const defaultSlug = this.generateSlugForNativeToken(token.originChain, token.assetType, token.symbol);
+        token.slug = `${_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 = `${_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 (!_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 = 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(([slug, chainInfo]) => {
+      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, type = 'substrate', providerName) {
+    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 = _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(ChainInfoMap).forEach(chainInfo => {
+        if (chainInfo.substrateInfo && chainInfo.substrateInfo.genesisHash === genesisHash) {
+          duplicatedSlug = chainInfo.slug;
+        }
+      });
+    } else if (evmChainId) {
+      Object.values(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 = ChainInfoMap;
+      Object.values(ChainInfoMap).forEach(chainInfo => {
+        this.dataMap.chainStateMap[chainInfo.slug] = {
+          currentProvider: Object.keys(chainInfo.providers)[0],
+          slug: chainInfo.slug,
+          connectionStatus: _ChainConnectionStatus.DISCONNECTED,
+          active: _DEFAULT_ACTIVE_CHAINS.includes(chainInfo.slug)
+        };
+
+        // create data for storage
+        newStorageData.push({
+          ...chainInfo,
+          active: _DEFAULT_ACTIVE_CHAINS.includes(chainInfo.slug),
+          currentProvider: Object.keys(chainInfo.providers)[0]
+        });
+      });
+    } else {
+      const mergedChainInfoMap = ChainInfoMap;
+      for (const [storedSlug, storedChainInfo] of Object.entries(storedChainSettingMap)) {
+        if (storedSlug in 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: _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: _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: _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(([slug, chainInfo]) => {
+        if (!(slug in this.dataMap.chainStateMap)) {
+          this.dataMap.chainStateMap[slug] = {
+            currentProvider: Object.keys(chainInfo.providers)[0],
+            slug,
+            connectionStatus: _ChainConnectionStatus.DISCONNECTED,
+            active: _DEFAULT_ACTIVE_CHAINS.includes(slug)
+          };
+          newStorageData.push({
+            ...mergedChainInfoMap[slug],
+            active: _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 = ChainAssetMap;
+    } else {
+      const mergedAssetRegistry = ChainAssetMap;
+      const parsedStoredAssetRegistry = {};
+      const deprecatedAssets = [];
+
+      // Update custom assets of merged custom chains
+      Object.values(storedAssetRegistry).forEach(storedAsset => {
+        if (_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(ChainAssetMap)) {
+          // case merge custom asset with default asset
+          if (_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 ? _SubstrateChainType.PARACHAIN : _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: [_AssetType.ERC20, _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: _ChainStatus.ACTIVE
+    };
+
+    // insert new chainInfo
+    chainInfoMap[newChainSlug] = chainInfo;
+
+    // insert new chainState
+    const chainStateMap = this.getChainStateMap();
+    chainStateMap[newChainSlug] = {
+      active: true,
+      connectionStatus: _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: _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 `${_CUSTOM_PREFIX}${chainType}-${parsedName}-${evmChainId}`;
+    } else {
+      let slug = `${_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 === _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 = _CHAIN_VALIDATION_ERROR.PROVIDER_NOT_SAME_CHAIN;
+              }
+            } else if (existedChainInfo.substrateInfo !== null) {
+              if (result.genesisHash !== existedChainInfo.substrateInfo.genesisHash) {
+                result.error = _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 = _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 = _CHAIN_VALIDATION_ERROR.EXISTED_CHAIN;
+                  result.conflictChain = chainInfo.name;
+                  result.conflictKey = chainInfo.slug;
+                  break;
+                }
+              }
+            }
+          }
+        } else {
+          result.error = _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 = _CHAIN_VALIDATION_ERROR.CONNECTION_FAILURE;
+      return result;
+    }
+  }
+  async getChainSpecByProvider(api) {
+    if (api.api instanceof Web3) {
+      return await this.evmChainHandler.getChainSpec(api);
+    }
+    return await this.substrateChainHandler.getChainSpec(api);
+  }
+  validateProvider(targetProvider, existingChainSlug) {
+    let error = _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 = _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 = _CHAIN_VALIDATION_ERROR.EXISTED_PROVIDER;
+        conflictChainSlug = key;
+        conflictChainName = chainInfoMap[key].name;
+        break;
+      }
+    }
+    return {
+      error,
+      conflictChainSlug,
+      conflictChainName
+    };
+  }
+  async getSmartContractTokenInfo(contractAddress, tokenType, originChain, contractCaller) {
+    if ([_AssetType.ERC721, _AssetType.ERC20].includes(tokenType)) {
+      return await this.evmChainHandler.getSmartContractTokenInfo(contractAddress, tokenType, originChain);
+    } else if ([_AssetType.PSP34, _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 (_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(delay = 0) {
+    clearTimeout(this.refreshChainStateTimeout);
+    setTimeout(() => {
+      this.updateApiMapStatus();
+      this.refreshChainStateTimeout = setTimeout(() => {
+        this.updateApiMapStatus();
+        this.refreshChainStateInterval();
+      }, 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(([chain, chainState]) => {
+      if (chainState.active) {
+        if (substrateApiMap[chain]) {
+          const api = substrateApiMap[chain];
+          if (api) {
+            updateState(chainState, _ChainConnectionStatus.CONNECTED);
+            return;
+          }
+        } else if (evmApiMap[chain]) {
+          const api = evmApiMap[chain];
+          if (api) {
+            updateState(chainState, _ChainConnectionStatus.CONNECTED);
+            return;
+          }
+        }
+      }
+      updateState(chainState, _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;
+  }
+}