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

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];

package/services/history-service/index.js

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

package/services/migration-service/index.js

@@ -10,9 +10,6 @@ export default class MigrationService {
   }
   async run() {
     const keys = Object.keys(MigrationScripts).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 = MigrationScripts[keys[i]];

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

@@ -26,7 +26,7 @@ export default class MigrateNetworkSettings extends BaseMigrationJob {
       }
     });
     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/services/price-service/index.js

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

package/services/storage-service/DatabaseService.d.ts

@@ -1,12 +1,14 @@
 import { _ChainAsset } from '@subwallet/chain-list/types';
 import { BalanceItem, ChainStakingMetadata, CrowdloanItem, NftCollection, NftItem, NominatorMetadata, PriceJson, StakingItem, StakingType, TransactionHistoryItem } from '@subwallet/extension-base/background/KoniTypes';
+import { EventService } from '@subwallet/extension-base/services/event-service';
 import { IBalance, IChain, INft } from '@subwallet/extension-base/services/storage-service/databases';
-import { AssetStore, BalanceStore, ChainStore, CrowdloanStore, MigrationStore, NftCollectionStore, NftStore, PriceStore, StakingStore, TransactionStore } from '@subwallet/extension-base/services/storage-service/db-stores';
+import { AssetStore, BalanceStore, ChainStore, CrowdloanStore, MetadataStore, MigrationStore, NftCollectionStore, NftStore, PriceStore, StakingStore, TransactionStore } from '@subwallet/extension-base/services/storage-service/db-stores';
 import ChainStakingMetadataStore from '@subwallet/extension-base/services/storage-service/db-stores/ChainStakingMetadata';
 import NominatorMetadataStore from '@subwallet/extension-base/services/storage-service/db-stores/NominatorMetadata';
 import { HistoryQuery } from '@subwallet/extension-base/services/storage-service/db-stores/Transaction';
 import { Subscription } from 'dexie';
 export default class DatabaseService {
+    private eventService;
     private _db;
     stores: {
         price: PriceStore;
@@ -17,6 +19,7 @@ export default class DatabaseService {
         staking: StakingStore;
         transaction: TransactionStore;
         migration: MigrationStore;
+        metadata: MetadataStore;
         chain: ChainStore;
         asset: AssetStore;
         chainStakingMetadata: ChainStakingMetadataStore;
@@ -25,7 +28,7 @@ export default class DatabaseService {
     private logger;
     private nftSubscription;
     private stakingSubscription;
-    constructor();
+    constructor(eventService: EventService);
     updatePriceStore(priceData: PriceJson): Promise<void>;
     getPriceStore(): Promise<PriceJson | undefined>;
     getStoredBalance(): Promise<IBalance[]>;

package/services/storage-service/DatabaseService.js

@@ -3,7 +3,7 @@
 
 import { APIItemState, StakingType } from '@subwallet/extension-base/background/KoniTypes';
 import KoniDatabase from '@subwallet/extension-base/services/storage-service/databases';
-import { AssetStore, BalanceStore, ChainStore, CrowdloanStore, MigrationStore, NftCollectionStore, NftStore, PriceStore, StakingStore, TransactionStore } from '@subwallet/extension-base/services/storage-service/db-stores';
+import { AssetStore, BalanceStore, ChainStore, CrowdloanStore, MetadataStore, MigrationStore, NftCollectionStore, NftStore, PriceStore, StakingStore, TransactionStore } from '@subwallet/extension-base/services/storage-service/db-stores';
 import ChainStakingMetadataStore from '@subwallet/extension-base/services/storage-service/db-stores/ChainStakingMetadata';
 import NominatorMetadataStore from '@subwallet/extension-base/services/storage-service/db-stores/NominatorMetadata';
 import { reformatAddress } from '@subwallet/extension-base/utils';
@@ -11,9 +11,13 @@ import { logger as createLogger } from '@polkadot/util';
 export default class DatabaseService {
   // TODO: might remove this
 
-  constructor() {
+  constructor(eventService) {
+    this.eventService = eventService;
     this.logger = createLogger('DB-Service');
     this._db = new KoniDatabase();
+    this._db.on('ready', () => {
+      this.eventService.emit('database.ready', true);
+    });
     this.stores = {
       price: new PriceStore(this._db.price),
       balance: new BalanceStore(this._db.balances),
@@ -23,6 +27,7 @@ export default class DatabaseService {
       staking: new StakingStore(this._db.stakings),
       transaction: new TransactionStore(this._db.transactions),
       migration: new MigrationStore(this._db.migrations),
+      metadata: new MetadataStore(this._db.metadata),
       chain: new ChainStore(this._db.chain),
       asset: new AssetStore(this._db.asset),
       // staking

package/services/storage-service/databases/index.d.ts

@@ -1,5 +1,5 @@
 import { _ChainAsset, _ChainInfo } from '@subwallet/chain-list/types';
-import { BalanceItem, ChainStakingMetadata, CrowdloanItem, NftCollection, NftItem, NominatorMetadata, PriceJson, StakingItem, TransactionHistoryItem } from '@subwallet/extension-base/background/KoniTypes';
+import { BalanceItem, ChainStakingMetadata, CrowdloanItem, MetadataItem, NftCollection, NftItem, NominatorMetadata, PriceJson, StakingItem, TransactionHistoryItem } from '@subwallet/extension-base/background/KoniTypes';
 import Dexie, { Table } from 'dexie';
 export interface DefaultChainDoc {
     chain: string;
@@ -26,6 +26,8 @@ export interface IMigration {
     name: string;
     timestamp: number;
 }
+export interface IMetadataItem extends MetadataItem, DefaultChainDoc {
+}
 export default class KoniDatabase extends Dexie {
     price: Table<PriceJson, object>;
     balances: Table<IBalance, object>;
@@ -35,6 +37,7 @@ export default class KoniDatabase extends Dexie {
     stakings: Table<StakingItem, object>;
     transactions: Table<ITransactionHistoryItem, object>;
     migrations: Table<IMigration, object>;
+    metadata: Table<IMetadataItem, object>;
     chain: Table<IChain, object>;
     asset: Table<_ChainAsset, object>;
     chainStakingMetadata: Table<ChainStakingMetadata, object>;

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

@@ -24,6 +24,9 @@ export default class KoniDatabase extends Dexie {
       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/services/storage-service/db-stores/Metadata.d.ts

@@ -0,0 +1,8 @@
+import { IMetadataItem } from '@subwallet/extension-base/services/storage-service/databases';
+import BaseStoreWithChain from '@subwallet/extension-base/services/storage-service/db-stores/BaseStoreWithChain';
+export default class MetadataStore extends BaseStoreWithChain<IMetadataItem> {
+    getMetadata(chain: string): import("dexie").PromiseExtended<IMetadataItem | undefined>;
+    upsertMetadata(chain: string, metadata: IMetadataItem): import("dexie").PromiseExtended<unknown>;
+    getMetadataByGenesisHash(genesisHash: string): import("dexie").PromiseExtended<IMetadataItem | undefined>;
+    updateMetadataByGenesisHash(genesisHash: string, metadata: IMetadataItem): import("dexie").PromiseExtended<unknown>;
+}

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

@@ -0,0 +1,18 @@
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import BaseStoreWithChain from '@subwallet/extension-base/services/storage-service/db-stores/BaseStoreWithChain';
+export default class MetadataStore extends BaseStoreWithChain {
+  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);
+  }
+}

package/services/storage-service/db-stores/index.d.ts

@@ -6,5 +6,6 @@ export { default as NftCollectionStore } from './NftCollection';
 export { default as StakingStore } from './Staking';
 export { default as TransactionStore } from './Transaction';
 export { default as MigrationStore } from './Migration';
+export { default as MetadataStore } from './Metadata';
 export { default as ChainStore } from './Chain';
 export { default as AssetStore } from './Asset';

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

@@ -9,5 +9,6 @@ export { default as NftCollectionStore } from "./NftCollection.js";
 export { default as StakingStore } from "./Staking.js";
 export { default as TransactionStore } from "./Transaction.js";
 export { default as MigrationStore } from "./Migration.js";
+export { default as MetadataStore } from "./Metadata.js";
 export { default as ChainStore } from "./Chain.js";
 export { default as AssetStore } from "./Asset.js";