@subwallet/extension-base 1.0.9-2 → 1.0.11-0

package/services/chain-service/helper/api-helper/spec/dataavail.js

@@ -0,0 +1,145 @@
+// Copyright 2017-2021 @polkadot/apps-config authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+// import type  {H256}  from '@polkadot/types/interfaces';
+// eslint-disable-next-line header/header
+
+// structs need to be in order
+/* eslint-disable sort-keys */
+
+const definitions = {
+  rpc: {
+    kate: {
+      blockLength: {
+        description: 'Get Block Length',
+        params: [{
+          name: 'at',
+          type: 'Hash',
+          isOptional: true
+        }],
+        type: 'BlockLength'
+      },
+      queryProof: {
+        description: 'Generate the kate proof for the given `cells`',
+        params: [{
+          name: 'cells',
+          type: 'Vec<Cell>'
+        }, {
+          name: 'at',
+          type: 'Hash',
+          isOptional: true
+        }],
+        type: 'Vec<u8>'
+      },
+      queryAppData: {
+        description: 'Fetches app data rows for the given app',
+        params: [{
+          name: 'app_id',
+          type: 'AppId'
+        }, {
+          name: 'at',
+          type: 'Hash',
+          isOptional: true
+        }],
+        type: 'Vec<Option<Vec<u8>>>'
+      },
+      queryDataProof: {
+        description: 'Generate the data proof for the given `index`',
+        params: [{
+          name: 'data_index',
+          type: 'u32'
+        }, {
+          name: 'at',
+          type: 'Hash',
+          isOptional: true
+        }],
+        type: 'DataProof'
+      }
+    }
+  },
+  types: [{
+    // on all versions
+    minmax: [0, undefined],
+    types: {
+      AppId: 'Compact<u32>',
+      DataLookupIndexItem: {
+        appId: 'AppId',
+        start: 'Compact<u32>'
+      },
+      DataLookup: {
+        size: 'Compact<u32>',
+        index: 'Vec<DataLookupIndexItem>'
+      },
+      KateCommitment: {
+        rows: 'Compact<u16>',
+        cols: 'Compact<u16>',
+        dataRoot: 'H256',
+        commitment: 'Vec<u8>'
+      },
+      V1HeaderExtension: {
+        commitment: 'KateCommitment',
+        appLookup: 'DataLookup'
+      },
+      VTHeaderExtension: {
+        newField: 'Vec<u8>',
+        commitment: 'KateCommitment',
+        appLookup: 'DataLookup'
+      },
+      HeaderExtension: {
+        _enum: {
+          V1: 'V1HeaderExtension',
+          VTest: 'VTHeaderExtension'
+        }
+      },
+      DaHeader: {
+        parentHash: 'Hash',
+        number: 'Compact<BlockNumber>',
+        stateRoot: 'Hash',
+        extrinsicsRoot: 'Hash',
+        digest: 'Digest',
+        extension: 'HeaderExtension'
+      },
+      Header: 'DaHeader',
+      CheckAppIdExtra: {
+        appId: 'AppId'
+      },
+      CheckAppIdTypes: {},
+      CheckAppId: {
+        extra: 'CheckAppIdExtra',
+        types: 'CheckAppIdTypes'
+      },
+      BlockLengthColumns: 'Compact<u32>',
+      BlockLengthRows: 'Compact<u32>',
+      BlockLength: {
+        max: 'PerDispatchClass',
+        cols: 'BlockLengthColumns',
+        rows: 'BlockLengthRows',
+        chunkSize: 'Compact<u32>'
+      },
+      PerDispatchClass: {
+        normal: 'u32',
+        operational: 'u32',
+        mandatory: 'u32'
+      },
+      DataProof: {
+        root: 'H256',
+        proof: 'Vec<H256>',
+        numberOfLeaves: 'Compact<u32>',
+        leaf_index: 'Compact<u32>',
+        leaf: 'H256'
+      },
+      Cell: {
+        row: 'BlockLengthRows',
+        col: 'BlockLengthColumns'
+      }
+    }
+  }],
+  signedExtensions: {
+    CheckAppId: {
+      extrinsic: {
+        appId: 'AppId'
+      },
+      payload: {}
+    }
+  }
+};
+export default definitions;

package/services/chain-service/index.d.ts

@@ -1,7 +1,9 @@
 import { _AssetRef, _AssetType, _ChainAsset, _ChainInfo, _MultiChainAsset } from '@subwallet/chain-list/types';
 import { AssetSetting, ValidateNetworkResponse } from '@subwallet/extension-base/background/KoniTypes';
-import { _ChainConnectionStatus, _ChainState, _EvmApi, _NetworkUpsertParams, _SubstrateApi, _ValidateCustomAssetRequest, _ValidateCustomAssetResponse } from '@subwallet/extension-base/services/chain-service/types';
+import { SubstrateApi } from '@subwallet/extension-base/services/chain-service/handler/SubstrateApi';
+import { _ChainConnectionStatus, _ChainState, _NetworkUpsertParams, _ValidateCustomAssetRequest, _ValidateCustomAssetResponse } from '@subwallet/extension-base/services/chain-service/types';
 import { EventService } from '@subwallet/extension-base/services/event-service';
+import { IMetadataItem } from '@subwallet/extension-base/services/storage-service/databases';
 import DatabaseService from '@subwallet/extension-base/services/storage-service/DatabaseService';
 import { BehaviorSubject, Subject } from 'rxjs';
 export declare class ChainService {
@@ -21,10 +23,10 @@ export declare class ChainService {
     private logger;
     constructor(dbService: DatabaseService, eventService: EventService);
     getXcmRefMap(): Record<string, _AssetRef>;
-    getEvmApi(slug: string): _EvmApi;
-    getEvmApiMap(): Record<string, _EvmApi>;
-    getSubstrateApiMap(): Record<string, _SubstrateApi>;
-    getSubstrateApi(slug: string): _SubstrateApi;
+    getEvmApi(slug: string): import("./handler/EvmApi").EvmApi;
+    getEvmApiMap(): Record<string, import("./handler/EvmApi").EvmApi>;
+    getSubstrateApiMap(): Record<string, SubstrateApi>;
+    getSubstrateApi(slug: string): SubstrateApi;
     getChainCurrentProviderByKey(slug: string): {
         endpoint: string;
         providerName: string;
@@ -45,6 +47,7 @@ export declare class ChainService {
     getAssetRefMap(): Record<string, _AssetRef>;
     getChainStateMap(): Record<string, _ChainState>;
     getChainStateByKey(key: string): _ChainState;
+    getActiveChains(): string[];
     getSupportedSmartContractTypes(): _AssetType[];
     getActiveChainInfoMap(): Record<string, _ChainInfo>;
     getActiveChainSlugs(): string[];
@@ -65,10 +68,8 @@ export declare class ChainService {
     private initApis;
     private initApiForChain;
     private destroyApiForChain;
-    private initApi;
-    private _enableChain;
-    enableChain(chainSlug: string): boolean;
-    enableChains(chainSlugs: string[]): boolean;
+    enableChain(chainSlug: string): Promise<boolean>;
+    enableChains(chainSlugs: string[]): Promise<boolean>;
     disableChain(chainSlug: string): boolean;
     private checkExistedPredefinedChain;
     private fetchLatestData;
@@ -79,7 +80,7 @@ export declare class ChainService {
     private updateChainSubscription;
     private updateChain;
     private insertChain;
-    upsertChain(params: _NetworkUpsertParams): string | undefined;
+    upsertChain(params: _NetworkUpsertParams): Promise<string | undefined>;
     private generateSlugForCustomChain;
     validateCustomChain(provider: string, existingChainSlug?: string): Promise<ValidateNetworkResponse>;
     private getChainSpecByProvider;
@@ -90,12 +91,9 @@ export declare class ChainService {
     private generateSlugForNativeToken;
     refreshSubstrateApi(slug: string): void;
     refreshEvmApi(slug: string): void;
-    stopAllChainApis(): Promise<void[]>;
-    resumeAllChainApis(): Promise<void[]>;
-    private refreshChainStateTimeout;
-    private refreshChainStateTimes;
-    private refreshChainStateInterval;
-    updateApiMapStatus(): Promise<void>;
+    stopAllChainApis(): Promise<void>;
+    resumeAllChainApis(): Promise<void>;
+    checkAndUpdateStatusMapForChain(chainSlug: string): void;
     initAssetSettings(): Promise<void>;
     setAssetSettings(assetSettings: Record<string, AssetSetting>, emitEvent?: boolean): void;
     getStoreAssetSettings(): Promise<Record<string, AssetSetting>>;
@@ -106,4 +104,6 @@ export declare class ChainService {
     getChainLogoMap(): Promise<Record<string, string>>;
     getAssetLogoMap(): Promise<Record<string, string>>;
     resetWallet(resetAll: boolean): void;
+    getMetadata(chain: string): import("dexie").PromiseExtended<IMetadataItem | undefined>;
+    upsertMetadata(chain: string, metadata: IMetadataItem): import("dexie").PromiseExtended<unknown>;
 }

package/services/chain-service/index.js

@@ -35,14 +35,13 @@ export class ChainService {
   constructor(dbService, eventService) {
     this.dbService = dbService;
     this.eventService = eventService;
-    this.substrateChainHandler = new SubstrateChainHandler();
-    this.evmChainHandler = new 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(this);
+    this.evmChainHandler = new EvmChainHandler(this);
     this.logger = createLogger('chain-service');
-    this.refreshChainStateInterval(3000, 6);
   }
 
   // Getter
@@ -172,6 +171,9 @@ export class ChainService {
   getChainStateByKey(key) {
     return this.dataMap.chainStateMap[key];
   }
+  getActiveChains() {
+    return Object.entries(this.dataMap.chainStateMap).filter(([, chainState]) => _isChainEnabled(chainState)).map(([key]) => key);
+  }
   getSupportedSmartContractTypes() {
     return [_AssetType.ERC20, _AssetType.ERC721, _AssetType.PSP22, _AssetType.PSP34];
   }
@@ -352,6 +354,8 @@ export class ChainService {
 
   // Business logic
   async init() {
+    await this.eventService.waitDatabaseReady;
+
     // TODO: reconsider the flow of initiation
     const [latestAssetRefMap, latestMultiChainAssetMap] = await Promise.all([this.fetchLatestData(_ASSET_REF_SRC, AssetRefMap), this.fetchLatestData(_MULTI_CHAIN_ASSET_SRC, MultiChainAssetMap)]);
     this.multiChainAssetMapSubject.next(latestMultiChainAssetMap);
@@ -361,28 +365,51 @@ export 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(([slug, chainInfo]) => {
-      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(([slug]) => {
+      var _chainStateMap$slug;
+      return (_chainStateMap$slug = chainStateMap[slug]) === null || _chainStateMap$slug === void 0 ? void 0 : _chainStateMap$slug.active;
+    }).map(([, chainInfo]) => {
+      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 ? _ChainConnectionStatus.CONNECTED : _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);
     }
   }
@@ -394,47 +421,53 @@ export class ChainService {
       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) {
+  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);
@@ -688,7 +721,7 @@ export 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);
@@ -702,8 +735,8 @@ export 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) {
@@ -728,7 +761,7 @@ export 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;
@@ -786,7 +819,7 @@ export 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({
@@ -817,7 +850,7 @@ export class ChainService {
     }).catch(e => this.logger.error(e));
     return nativeTokenSlug;
   }
-  upsertChain(params) {
+  async upsertChain(params) {
     if (this.lockChainInfoMap) {
       return;
     }
@@ -825,10 +858,10 @@ export 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;
@@ -870,9 +903,9 @@ export 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(() => {
@@ -1057,68 +1090,21 @@ export 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(delay = 0, times) {
-    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) {
@@ -1126,32 +1112,16 @@ export class ChainService {
         update = true;
       }
     }
-    const promiseList = Object.entries(chainStateMap).map(async ([chain, chainState]) => {
-      try {
-        if (chainState.active) {
-          if (substrateApiMap[chain]) {
-            const api = substrateApiMap[chain];
-            if (api.isApiConnected) {
-              updateState(chainState, _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, _ChainConnectionStatus.CONNECTED);
-              return;
-            }
-          }
-        }
-        updateState(chainState, _ChainConnectionStatus.DISCONNECTED);
-      } catch (e) {
-        updateState(chainState, _ChainConnectionStatus.DISCONNECTED);
+    if (chainState.active) {
+      const api = substrateApiMap[chainSlug] || evmApiMap[chainSlug];
+      if (api) {
+        updateState(chainState, api.isApiConnected ? _ChainConnectionStatus.CONNECTED : _ChainConnectionStatus.DISCONNECTED);
       }
-    });
-    await Promise.all(promiseList);
+    } else {
+      updateState(chainState, _ChainConnectionStatus.DISCONNECTED);
+    }
     if (update) {
-      this.chainStateMapSubject.next(chainStateMap);
+      this.dataMap.chainStateMap[chainSlug] = chainState;
     }
   }
   async initAssetSettings() {
@@ -1215,7 +1185,7 @@ export 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);
@@ -1279,4 +1249,10 @@ export 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);
+  }
 }

package/services/chain-service/types.d.ts

@@ -1,5 +1,6 @@
 import { _AssetRef, _AssetType, _ChainAsset, _ChainInfo } from '@subwallet/chain-list/types';
 import { _CHAIN_VALIDATION_ERROR } from '@subwallet/extension-base/services/chain-service/handler/types';
+import { BehaviorSubject } from 'rxjs';
 import Web3 from 'web3';
 import { ApiPromise } from '@polkadot/api';
 import { SubmittableExtrinsicFunction } from '@polkadot/api/promise/types';
@@ -34,12 +35,15 @@ export interface _ChainBaseApi {
     apiError?: string;
     apiRetry?: number;
     isApiReady: boolean;
+    isApiConnectedSubject: BehaviorSubject<boolean>;
     isApiReadyOnce: boolean;
     isApiConnected: boolean;
-    isApiInitialized: boolean;
-    isDevelopment?: boolean;
-    recoverConnect?: () => void;
-    isReady: Promise<any>;
+    updateApiUrl: (apiUrl: string) => Promise<void>;
+    connect: () => void;
+    disconnect: () => Promise<void>;
+    recoverConnect: () => Promise<void>;
+    destroy: () => Promise<void>;
+    isReady: Promise<_ChainBaseApi>;
 }
 export interface _SubstrateChainMetadata {
     properties: ChainProperties;
@@ -55,7 +59,6 @@ export interface _SubstrateApiState {
 }
 export interface _SubstrateApi extends _SubstrateApiState, _ChainBaseApi {
     api: ApiPromise;
-    isNotSupport?: boolean;
     isReady: Promise<_SubstrateApi>;
     specName: string;
     specVersion: string;

package/services/event-service/index.d.ts

@@ -5,6 +5,8 @@ export declare class EventService extends EventEmitter<EventRegistry> {
     private timeoutId;
     private pendingEvents;
     private lazyEmitter;
+    readonly waitCryptoReady: Promise<boolean>;
+    readonly waitDatabaseReady: Promise<boolean>;
     readonly waitKeyringReady: Promise<boolean>;
     readonly waitAccountReady: Promise<boolean>;
     readonly waitChainReady: Promise<boolean>;

package/services/event-service/index.js

@@ -13,6 +13,8 @@ export class EventService extends EventEmitter {
     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/services/event-service/types.d.ts

@@ -1,6 +1,10 @@
 import { CurrentAccountInfo } from '@subwallet/extension-base/background/KoniTypes';
 import { SWTransaction } from '@subwallet/extension-base/services/transaction-service/types';
 export interface EventRegistry {
+    'general.sleep': [boolean];
+    'general.wakeup': [boolean];
+    'crypto.ready': [boolean];
+    'database.ready': [boolean];
     'keyring.ready': [boolean];
     'account.updateCurrent': [CurrentAccountInfo];
     'account.ready': [boolean];