@subwallet/extension-base 1.0.10-0 → 1.0.11-0

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

@@ -42,14 +42,13 @@ class ChainService {
   constructor(dbService, eventService) {
     this.dbService = dbService;
     this.eventService = eventService;
-    this.substrateChainHandler = new _SubstrateChainHandler.SubstrateChainHandler();
-    this.evmChainHandler = new _EvmChainHandler.EvmChainHandler();
-    this.chainInfoMapSubject.next(this.dataMap.chainInfoMap);
     this.chainStateMapSubject.next(this.dataMap.chainStateMap);
+    this.chainInfoMapSubject.next(this.dataMap.chainInfoMap);
     this.assetRegistrySubject.next(this.dataMap.assetRegistry);
     this.xcmRefMapSubject.next(this.dataMap.assetRefMap);
+    this.substrateChainHandler = new _SubstrateChainHandler.SubstrateChainHandler(this);
+    this.evmChainHandler = new _EvmChainHandler.EvmChainHandler(this);
     this.logger = (0, _logger.logger)('chain-service');
-    this.refreshChainStateInterval(3000, 6);
   }
 
   // Getter
@@ -179,6 +178,15 @@ class ChainService {
   getChainStateByKey(key) {
     return this.dataMap.chainStateMap[key];
   }
+  getActiveChains() {
+    return Object.entries(this.dataMap.chainStateMap).filter(_ref => {
+      let [, chainState] = _ref;
+      return (0, _utils._isChainEnabled)(chainState);
+    }).map(_ref2 => {
+      let [key] = _ref2;
+      return key;
+    });
+  }
   getSupportedSmartContractTypes() {
     return [_types._AssetType.ERC20, _types._AssetType.ERC721, _types._AssetType.PSP22, _types._AssetType.PSP34];
   }
@@ -360,6 +368,8 @@ class ChainService {
 
   // Business logic
   async init() {
+    await this.eventService.waitDatabaseReady;
+
     // TODO: reconsider the flow of initiation
     const [latestAssetRefMap, latestMultiChainAssetMap] = await Promise.all([this.fetchLatestData(_constants._ASSET_REF_SRC, _chainList.AssetRefMap), this.fetchLatestData(_constants._MULTI_CHAIN_ASSET_SRC, _chainList.MultiChainAssetMap)]);
     this.multiChainAssetMapSubject.next(latestMultiChainAssetMap);
@@ -369,29 +379,53 @@ class ChainService {
     this.chainStateMapSubject.next(this.getChainStateMap());
     this.assetRegistrySubject.next(this.getAssetRegistry());
     this.xcmRefMapSubject.next(this.dataMap.assetRefMap);
-    this.initApis();
+    await this.initApis();
     await this.initAssetSettings();
   }
-  initApis() {
-    // TODO: this might be async
-    Object.entries(this.getChainInfoMap()).forEach(_ref => {
-      let [slug, chainInfo] = _ref;
-      if (this.getChainStateByKey(slug).active) {
-        this.initApiForChain(chainInfo);
+  async initApis() {
+    const chainInfoMap = this.getChainInfoMap();
+    const chainStateMap = this.getChainStateMap();
+    await Promise.all(Object.entries(chainInfoMap).filter(_ref3 => {
+      var _chainStateMap$slug;
+      let [slug] = _ref3;
+      return (_chainStateMap$slug = chainStateMap[slug]) === null || _chainStateMap$slug === void 0 ? void 0 : _chainStateMap$slug.active;
+    }).map(_ref4 => {
+      let [, chainInfo] = _ref4;
+      try {
+        return this.initApiForChain(chainInfo);
+      } catch (e) {
+        console.error(e);
+        return Promise.resolve();
       }
-    });
+    }));
   }
-  initApiForChain(chainInfo) {
+  async initApiForChain(chainInfo) {
     const {
       endpoint,
       providerName
     } = this.getChainCurrentProviderByKey(chainInfo.slug);
-    if (chainInfo.substrateInfo !== null) {
-      const chainApi = this.initApi(chainInfo.slug, endpoint, 'substrate', providerName);
+    const onUpdateStatus = isConnected => {
+      const currentStatus = this.getChainStateByKey(chainInfo.slug).connectionStatus;
+      const newStatus = isConnected ? _types3._ChainConnectionStatus.CONNECTED : _types3._ChainConnectionStatus.DISCONNECTED;
+
+      // Avoid unnecessary update in case disable chain
+      if (currentStatus !== newStatus) {
+        this.setChainConnectionStatus(chainInfo.slug, newStatus);
+        this.chainStateMapSubject.next(this.getChainStateMap());
+      }
+    };
+    if (chainInfo.substrateInfo !== null && chainInfo.substrateInfo !== undefined) {
+      const chainApi = await this.substrateChainHandler.initApi(chainInfo.slug, endpoint, {
+        providerName,
+        onUpdateStatus
+      });
       this.substrateChainHandler.setSubstrateApi(chainInfo.slug, chainApi);
     }
-    if (chainInfo.evmInfo !== null) {
-      const chainApi = this.initApi(chainInfo.slug, endpoint, 'evm', providerName);
+    if (chainInfo.evmInfo !== null && chainInfo.evmInfo !== undefined) {
+      const chainApi = await this.evmChainHandler.initApi(chainInfo.slug, endpoint, {
+        providerName,
+        onUpdateStatus
+      });
       this.evmChainHandler.setEvmApi(chainInfo.slug, chainApi);
     }
   }
@@ -403,49 +437,53 @@ class ChainService {
       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) {
+  async 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(3000, 6);
     this.dbService.updateChainStore({
       ...chainInfo,
       active: true,
       currentProvider: chainStateMap[chainSlug].currentProvider
     }).catch(console.error);
+    chainStateMap[chainSlug].active = true;
+    await this.initApiForChain(chainInfo);
     this.lockChainInfoMap = false;
     this.eventService.emit('chain.updateState', chainSlug);
+    this.updateChainStateMapSubscription();
     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();
+  async enableChains(chainSlugs) {
+    const chainInfoMap = this.getChainInfoMap();
+    const chainStateMap = this.getChainStateMap();
+    let needUpdate = false;
+    if (this.lockChainInfoMap) {
+      return false;
     }
-    return rs.every(r => r);
+    this.lockChainInfoMap = true;
+    const initPromises = chainSlugs.map(async chainSlug => {
+      var _chainStateMap$chainS;
+      const chainInfo = chainInfoMap[chainSlug];
+      const currentState = (_chainStateMap$chainS = chainStateMap[chainSlug]) === null || _chainStateMap$chainS === void 0 ? void 0 : _chainStateMap$chainS.active;
+      if (!currentState) {
+        this.dbService.updateChainStore({
+          ...chainInfo,
+          active: true,
+          currentProvider: chainStateMap[chainSlug].currentProvider
+        }).catch(console.error);
+        chainStateMap[chainSlug].active = true;
+        await this.initApiForChain(chainInfo);
+        this.eventService.emit('chain.updateState', chainSlug);
+        needUpdate = true;
+      }
+    });
+    await Promise.all(initPromises);
+    this.lockChainInfoMap = false;
+    needUpdate && this.updateChainStateMapSubscription();
+    return needUpdate;
   }
   disableChain(chainSlug) {
     const chainInfo = this.getChainInfoByKey(chainSlug);
@@ -621,8 +659,8 @@ class ChainService {
       }
 
       // Fill in the missing chainState and storageData (new chains never before seen)
-      Object.entries(mergedChainInfoMap).forEach(_ref2 => {
-        let [slug, chainInfo] = _ref2;
+      Object.entries(mergedChainInfoMap).forEach(_ref5 => {
+        let [slug, chainInfo] = _ref5;
         if (!(slug in this.dataMap.chainStateMap)) {
           this.dataMap.chainStateMap[slug] = {
             currentProvider: Object.keys(chainInfo.providers)[0],
@@ -700,7 +738,7 @@ class ChainService {
   }
 
   // Can only update providers or block explorer, crowdloan url
-  updateChain(params) {
+  async updateChain(params) {
     const chainSlug = params.chainEditInfo.slug;
     const targetChainInfo = this.getChainInfoByKey(chainSlug);
     const targetChainState = this.getChainStateByKey(chainSlug);
@@ -714,8 +752,8 @@ class ChainService {
         targetChainState.active = true;
       }
 
-      // TODO: it might override existed API
-      this.initApiForChain(targetChainInfo);
+      // It auto detects the change of api url to create new instance or reuse existed one
+      await this.initApiForChain(targetChainInfo);
       this.updateChainStateMapSubscription();
     }
     if (targetChainInfo.substrateInfo) {
@@ -740,7 +778,7 @@ class ChainService {
       this.eventService.emit('chain.updateState', chainSlug);
     }).catch(e => this.logger.error(e));
   }
-  insertChain(params) {
+  async insertChain(params) {
     const chainInfoMap = this.getChainInfoMap();
     if (!params.chainSpec) {
       return;
@@ -798,7 +836,7 @@ class ChainService {
       currentProvider: params.chainEditInfo.currentProvider,
       slug: newChainSlug
     };
-    this.initApiForChain(chainInfo);
+    await this.initApiForChain(chainInfo);
 
     // create a record in assetRegistry for native token and update store/subscription
     const nativeTokenSlug = this.upsertCustomToken({
@@ -829,7 +867,7 @@ class ChainService {
     }).catch(e => this.logger.error(e));
     return nativeTokenSlug;
   }
-  upsertChain(params) {
+  async upsertChain(params) {
     if (this.lockChainInfoMap) {
       return;
     }
@@ -837,10 +875,10 @@ class ChainService {
     let result;
     if (params.mode === 'update') {
       // update existing chainInfo
-      this.updateChain(params);
+      await this.updateChain(params);
     } else {
       // insert custom network
-      result = this.insertChain(params);
+      result = await this.insertChain(params);
     }
     this.lockChainInfoMap = false;
     return result;
@@ -882,9 +920,9 @@ class ChainService {
         // TODO: EVM chain might have WS provider
         if (provider.startsWith('http')) {
           // HTTP provider is EVM by default
-          api = this.evmChainHandler.initApi('custom', provider);
+          api = await this.evmChainHandler.initApi('custom', provider);
         } else {
-          api = this.substrateChainHandler.initApi('custom', provider);
+          api = await this.substrateChainHandler.initApi('custom', provider);
         }
         const connectionTimeout = new Promise(resolve => {
           const id = setTimeout(() => {
@@ -1069,70 +1107,21 @@ class ChainService {
     return `${originChain}-${assetType}-${symbol}`;
   }
   refreshSubstrateApi(slug) {
-    this.substrateChainHandler.refreshApi(slug);
+    this.substrateChainHandler.recoverApi(slug).catch(console.error);
   }
   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();
+    this.evmChainHandler.recoverApi(slug).catch(console.error);
   }
-  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();
-  }
-  refreshChainStateTimeout = undefined;
-  refreshChainStateTimes = 0;
-  refreshChainStateInterval() {
-    let delay = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
-    let times = arguments.length > 1 ? arguments[1] : undefined;
-    clearTimeout(this.refreshChainStateTimeout);
-    setTimeout(() => {
-      if (times) {
-        this.refreshChainStateTimes = times;
-      }
-      this.refreshChainStateTimes -= 1;
-      if (this.refreshChainStateTimes < 0) {
-        return;
-      }
-      this.updateApiMapStatus().catch(console.error);
-      this.refreshChainStateTimeout = setTimeout(() => {
-        this.updateApiMapStatus().catch(console.error);
-        this.refreshChainStateInterval(0);
-      }, 3000);
-    }, delay);
-  }
-  async updateApiMapStatus() {
+  async stopAllChainApis() {
+    await Promise.all([this.substrateChainHandler.sleep(), this.evmChainHandler.sleep()]);
+  }
+  async resumeAllChainApis() {
+    await Promise.all([this.substrateChainHandler.wakeUp(), this.evmChainHandler.wakeUp()]);
+  }
+  checkAndUpdateStatusMapForChain(chainSlug) {
     const substrateApiMap = this.getSubstrateApiMap();
     const evmApiMap = this.getEvmApiMap();
-    const chainStateMap = this.getChainStateMap();
+    const chainState = this.getChainStateByKey(chainSlug);
     let update = false;
     function updateState(current, status) {
       if (current.connectionStatus !== status) {
@@ -1140,33 +1129,16 @@ class ChainService {
         update = true;
       }
     }
-    const promiseList = Object.entries(chainStateMap).map(async _ref3 => {
-      let [chain, chainState] = _ref3;
-      try {
-        if (chainState.active) {
-          if (substrateApiMap[chain]) {
-            const api = substrateApiMap[chain];
-            if (api.isApiConnected) {
-              updateState(chainState, _types3._ChainConnectionStatus.CONNECTED);
-              return;
-            }
-          } else if (evmApiMap[chain]) {
-            var _api$api;
-            const api = evmApiMap[chain];
-            if (await (api === null || api === void 0 ? void 0 : (_api$api = api.api) === null || _api$api === void 0 ? void 0 : _api$api.eth.net.isListening())) {
-              updateState(chainState, _types3._ChainConnectionStatus.CONNECTED);
-              return;
-            }
-          }
-        }
-        updateState(chainState, _types3._ChainConnectionStatus.DISCONNECTED);
-      } catch (e) {
-        updateState(chainState, _types3._ChainConnectionStatus.DISCONNECTED);
+    if (chainState.active) {
+      const api = substrateApiMap[chainSlug] || evmApiMap[chainSlug];
+      if (api) {
+        updateState(chainState, api.isApiConnected ? _types3._ChainConnectionStatus.CONNECTED : _types3._ChainConnectionStatus.DISCONNECTED);
       }
-    });
-    await Promise.all(promiseList);
+    } else {
+      updateState(chainState, _types3._ChainConnectionStatus.DISCONNECTED);
+    }
     if (update) {
-      this.chainStateMapSubject.next(chainStateMap);
+      this.dataMap.chainStateMap[chainSlug] = chainState;
     }
   }
   async initAssetSettings() {
@@ -1231,7 +1203,7 @@ class ChainService {
 
       // if chain not enabled, then automatically enable
       if (chainState && !chainState.active) {
-        this.enableChain(chainState.slug);
+        await this.enableChain(chainState.slug);
         needUpdateSubject = true;
         if (autoEnableNativeToken) {
           const nativeAsset = this.getNativeTokenInfo(assetInfo.originChain);
@@ -1295,5 +1267,11 @@ class ChainService {
       this.deleteCustomAssets(customToken);
     }
   }
+  getMetadata(chain) {
+    return this.dbService.stores.metadata.getMetadata(chain);
+  }
+  upsertMetadata(chain, metadata) {
+    return this.dbService.stores.metadata.upsertMetadata(chain, metadata);
+  }
 }
 exports.ChainService = ChainService;

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

@@ -21,6 +21,8 @@ class EventService extends _eventemitter.default {
     super();
     this.lazyTime = options.lazyTime;
     this.timeoutId = null;
+    this.waitCryptoReady = this.generateWaitPromise('crypto.ready');
+    this.waitDatabaseReady = this.generateWaitPromise('database.ready');
     this.waitKeyringReady = this.generateWaitPromise('keyring.ready');
     this.waitAccountReady = this.generateWaitPromise('account.ready');
     this.waitChainReady = this.generateWaitPromise('chain.ready');

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

@@ -208,7 +208,11 @@ class HistoryService {
     this.startRecoverHistories().catch(console.error);
   }
   async start() {
+    if (this.status === _types.ServiceStatus.STARTED) {
+      return;
+    }
     try {
+      await Promise.all([this.eventService.waitKeyringReady, this.eventService.waitChainReady]);
       this.startPromiseHandler = (0, _promise.createPromiseHandler)();
       this.status = _types.ServiceStatus.STARTING;
       await this.startCron();

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

@@ -18,9 +18,6 @@ class MigrationService {
   }
   async run() {
     const keys = Object.keys(_scripts.default).sort((a, b) => a.localeCompare(b));
-
-    // Await timeout 1s
-    await new Promise(resolve => setTimeout(resolve, 1000));
     for (let i = 0; i < keys.length; i++) {
       try {
         const JobClass = _scripts.default[keys[i]];

package/cjs/services/migration-service/scripts/MigrateNetworkSettings.js

@@ -34,7 +34,7 @@ class MigrateNetworkSettings extends _Base.default {
       }
     });
     if (enableList.length > 0) {
-      state.chainService.enableChains(enableList);
+      await state.chainService.enableChains(enableList);
 
       // Enable native token of these chains
       const currentAssetSettings = await state.chainService.getAssetSettings();

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

@@ -65,7 +65,6 @@ class PriceService {
         this.refreshPriceData(this.priceIds);
       }
     };
-    await this.eventService.waitAssetReady;
     this.status = _types.ServiceStatus.INITIALIZED;
     this.eventService.on('asset.updateState', eventHandler);
   }
@@ -78,7 +77,11 @@ class PriceService {
   }
   startPromiseHandler = (0, _promise.createPromiseHandler)();
   async start() {
+    if (this.status === _types.ServiceStatus.STARTED) {
+      return;
+    }
     try {
+      await this.eventService.waitAssetReady;
       this.startPromiseHandler = (0, _promise.createPromiseHandler)();
       this.status = _types.ServiceStatus.STARTING;
       await this.startCron();

package/cjs/services/storage-service/DatabaseService.js

@@ -18,9 +18,13 @@ var _util = require("@polkadot/util");
 class DatabaseService {
   // TODO: might remove this
 
-  constructor() {
+  constructor(eventService) {
+    this.eventService = eventService;
     this.logger = (0, _util.logger)('DB-Service');
     this._db = new _databases.default();
+    this._db.on('ready', () => {
+      this.eventService.emit('database.ready', true);
+    });
     this.stores = {
       price: new _dbStores.PriceStore(this._db.price),
       balance: new _dbStores.BalanceStore(this._db.balances),
@@ -30,6 +34,7 @@ class DatabaseService {
       staking: new _dbStores.StakingStore(this._db.stakings),
       transaction: new _dbStores.TransactionStore(this._db.transactions),
       migration: new _dbStores.MigrationStore(this._db.migrations),
+      metadata: new _dbStores.MetadataStore(this._db.metadata),
       chain: new _dbStores.ChainStore(this._db.chain),
       asset: new _dbStores.AssetStore(this._db.asset),
       // staking

package/cjs/services/storage-service/databases/index.js

@@ -33,6 +33,9 @@ class KoniDatabase extends _dexie.default {
       chainStakingMetadata: '[chain+type], chain, type',
       nominatorMetadata: '[chain+address+type], [chain+address], chain, address, type'
     });
+    this.conditionalVersion(2, {
+      metadata: 'genesisHash, chain'
+    });
   }
   conditionalVersion(version, schema, upgrade) {
     if (this.schemaVersion != null && this.schemaVersion < version) {

package/cjs/services/storage-service/db-stores/Metadata.js

@@ -0,0 +1,26 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _BaseStoreWithChain = _interopRequireDefault(require("@subwallet/extension-base/services/storage-service/db-stores/BaseStoreWithChain"));
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+class MetadataStore extends _BaseStoreWithChain.default {
+  getMetadata(chain) {
+    return this.table.where('chain').equals(chain).first();
+  }
+  upsertMetadata(chain, metadata) {
+    return this.table.put(metadata, chain);
+  }
+  getMetadataByGenesisHash(genesisHash) {
+    return this.table.where('[genesisHash]').equals([genesisHash]).first();
+  }
+  updateMetadataByGenesisHash(genesisHash, metadata) {
+    return this.table.put(metadata, genesisHash);
+  }
+}
+exports.default = MetadataStore;

package/cjs/services/storage-service/db-stores/index.js

@@ -28,6 +28,12 @@ Object.defineProperty(exports, "CrowdloanStore", {
     return _Crowdloan.default;
   }
 });
+Object.defineProperty(exports, "MetadataStore", {
+  enumerable: true,
+  get: function () {
+    return _Metadata.default;
+  }
+});
 Object.defineProperty(exports, "MigrationStore", {
   enumerable: true,
   get: function () {
@@ -72,5 +78,6 @@ var _NftCollection = _interopRequireDefault(require("./NftCollection"));
 var _Staking = _interopRequireDefault(require("./Staking"));
 var _Transaction = _interopRequireDefault(require("./Transaction"));
 var _Migration = _interopRequireDefault(require("./Migration"));
+var _Metadata = _interopRequireDefault(require("./Metadata"));
 var _Chain = _interopRequireDefault(require("./Chain"));
 var _Asset = _interopRequireDefault(require("./Asset"));

package/koni/api/nft/wasm_nft/index.js

@@ -61,7 +61,10 @@ export class WasmNftApi extends BaseNftApi {
     });
     const _attributeCount = _onChainAttributeCount === null || _onChainAttributeCount === void 0 ? void 0 : (_onChainAttributeCoun = _onChainAttributeCount.output) === null || _onChainAttributeCoun === void 0 ? void 0 : _onChainAttributeCoun.toJSON();
     const onChainAttributeCount = _onChainAttributeCount.output ? (_attributeCount === null || _attributeCount === void 0 ? void 0 : _attributeCount.ok) || (_attributeCount === null || _attributeCount === void 0 ? void 0 : _attributeCount.Ok) : '0';
-    return parseInt(onChainAttributeCount) !== 0;
+    if (!_onChainAttributeCount.result.isOk) {
+      return false;
+    }
+    return !!onChainAttributeCount && parseInt(onChainAttributeCount) !== 0;
   }
   parseFeaturedTokenUri(tokenUri) {
     if (!tokenUri || tokenUri.length === 0) {

package/koni/api/staking/bonding/index.js

@@ -106,6 +106,9 @@ export function subscribeEssentialChainStakingMetadata(substrateApiMap, chainInf
 
   // eslint-disable-next-line @typescript-eslint/no-misused-promises
   Object.values(chainInfoMap).forEach(async chainInfo => {
+    if (!substrateApiMap[chainInfo.slug]) {
+      return;
+    }
     const substrateApi = await substrateApiMap[chainInfo.slug].isReady;
     if (_STAKING_CHAIN_GROUP.astar.includes(chainInfo.slug)) {
       const unsub = await subscribeAstarStakingMetadata(chainInfo.slug, substrateApi, callback);

package/koni/background/cron.d.ts

@@ -22,10 +22,8 @@ export declare class KoniCron {
     addSubscribeCron: <T>(name: string, callback: (subject: Subject<T>) => void, interval: number) => void;
     removeCron: (name: string) => void;
     removeAllCrons: () => void;
-    start: () => void;
-    stop: () => void;
-    updateApiMapStatus: () => void;
-    recoverApiMap: () => void;
+    start: () => Promise<void>;
+    stop: () => Promise<void>;
     refreshNft: (address: string, apiMap: ApiMap, smartContractNfts: _ChainAsset[], chainInfoMap: Record<string, _ChainInfo>) => () => void;
     resetNft: (newAddress: string) => void;
     resetStakingReward: () => void;