@subwallet/extension-base 1.1.38-1 → 1.1.39-beta.0

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

@@ -38,6 +38,7 @@ class ChainService {
   // TODO: consider BehaviorSubject
   chainInfoMapSubject = new _rxjs.Subject();
   chainStateMapSubject = new _rxjs.Subject();
+  chainStatusMapSubject = new _rxjs.BehaviorSubject({});
   assetRegistrySubject = new _rxjs.Subject();
   multiChainAssetMapSubject = new _rxjs.Subject();
   xcmRefMapSubject = new _rxjs.Subject();
@@ -111,6 +112,9 @@ class ChainService {
   subscribeChainStateMap() {
     return this.chainStateMapSubject;
   }
+  subscribeChainStatusMap() {
+    return this.chainStatusMapSubject;
+  }
   getAssetRegistry() {
     return this.dataMap.assetRegistry;
   }
@@ -188,6 +192,12 @@ class ChainService {
   getChainStateByKey(key) {
     return this.dataMap.chainStateMap[key];
   }
+  getChainStatusMap() {
+    return this.chainStatusMapSubject.getValue();
+  }
+  getChainStatusByKey(key) {
+    return this.getChainStatusMap()[key];
+  }
   getActiveChains() {
     return Object.entries(this.dataMap.chainStateMap).filter(_ref => {
       let [, chainState] = _ref;
@@ -353,9 +363,32 @@ class ChainService {
     this.lockChainInfoMap = false;
     return true;
   }
-  setChainConnectionStatus(slug, connectionStatus) {
-    const chainStateMap = this.getChainStateMap();
-    chainStateMap[slug].connectionStatus = connectionStatus;
+  connectionStatusQueueMap = {};
+  updateChainConnectionStatus(slug, connectionStatus) {
+    this.connectionStatusQueueMap[slug] = connectionStatus;
+    (0, _utils2.addLazy)('updateChainConnectionStatus', () => {
+      const chainStatusMap = this.getChainStatusMap();
+      let update = false;
+      Object.entries(this.connectionStatusQueueMap).forEach(_ref3 => {
+        let [slug, status] = _ref3;
+        if (chainStatusMap[slug]) {
+          if (chainStatusMap[slug].connectionStatus !== status) {
+            chainStatusMap[slug].connectionStatus = status;
+            chainStatusMap[slug].lastUpdated = Date.now();
+            update = true;
+          }
+        } else {
+          chainStatusMap[slug] = {
+            slug,
+            connectionStatus: status,
+            lastUpdated: Date.now()
+          };
+          update = true;
+        }
+      });
+      this.connectionStatusQueueMap = {};
+      update && this.chainStatusMapSubject.next(chainStatusMap);
+    });
   }
   upsertCustomToken(token) {
     if (token.slug.length === 0) {
@@ -484,8 +517,8 @@ class ChainService {
     this.logger.log('Finished updating latest asset ref');
   }
   handleLatestPriceId(latestPriceIds) {
-    Object.entries(latestPriceIds).forEach(_ref3 => {
-      let [slug, priceId] = _ref3;
+    Object.entries(latestPriceIds).forEach(_ref4 => {
+      let [slug, priceId] = _ref4;
       if (this.dataMap.assetRegistry[slug]) {
         this.dataMap.assetRegistry[slug].priceId = priceId;
       }
@@ -510,12 +543,12 @@ class ChainService {
   async initApis() {
     const chainInfoMap = this.getChainInfoMap();
     const chainStateMap = this.getChainStateMap();
-    await Promise.all(Object.entries(chainInfoMap).filter(_ref4 => {
+    await Promise.all(Object.entries(chainInfoMap).filter(_ref5 => {
       var _chainStateMap$slug;
-      let [slug] = _ref4;
+      let [slug] = _ref5;
       return (_chainStateMap$slug = chainStateMap[slug]) === null || _chainStateMap$slug === void 0 ? void 0 : _chainStateMap$slug.active;
-    }).map(_ref5 => {
-      let [, chainInfo] = _ref5;
+    }).map(_ref6 => {
+      let [, chainInfo] = _ref6;
       try {
         return this.initApiForChain(chainInfo);
       } catch (e) {
@@ -530,13 +563,8 @@ class ChainService {
       providerName
     } = this.getChainCurrentProviderByKey(chainInfo.slug);
     const onUpdateStatus = status => {
-      const currentStatus = this.getChainStateByKey(chainInfo.slug).connectionStatus;
-
-      // Avoid unnecessary update in case disable chain
-      if (currentStatus !== status) {
-        this.setChainConnectionStatus(chainInfo.slug, status);
-        this.updateChainStateMapSubscription();
-      }
+      const slug = chainInfo.slug;
+      this.updateChainConnectionStatus(slug, status);
     };
     if (chainInfo.substrateInfo !== null && chainInfo.substrateInfo !== undefined) {
       if (_constants._MANTA_ZK_CHAIN_GROUP.includes(chainInfo.slug) && _utils2.MODULE_SUPPORT.MANTA_ZK && this.mantaChainHandler) {
@@ -635,7 +663,7 @@ class ChainService {
     this.lockChainInfoMap = true;
     chainStateMap[chainSlug].active = false;
     // Set disconnect state for inactive chain
-    chainStateMap[chainSlug].connectionStatus = _types3._ChainConnectionStatus.DISCONNECTED;
+    this.updateChainConnectionStatus(chainSlug, _types3._ChainConnectionStatus.DISCONNECTED);
     this.destroyApiForChain(chainInfo);
     this.dbService.updateChainStore({
       ...chainInfo,
@@ -728,9 +756,9 @@ class ChainService {
         this.dataMap.chainStateMap[chainInfo.slug] = {
           currentProvider: providerKey,
           slug: chainInfo.slug,
-          connectionStatus: _types3._ChainConnectionStatus.DISCONNECTED,
           active: _constants._DEFAULT_ACTIVE_CHAINS.includes(chainInfo.slug)
         };
+        this.updateChainConnectionStatus(chainInfo.slug, _types3._ChainConnectionStatus.DISCONNECTED);
 
         // create data for storage
         newStorageData.push({
@@ -781,9 +809,9 @@ class ChainService {
           this.dataMap.chainStateMap[storedSlug] = {
             currentProvider: selectedProvider,
             slug: storedSlug,
-            connectionStatus: _types3._ChainConnectionStatus.DISCONNECTED,
             active: canActive && storedChainInfo.active
           };
+          this.updateChainConnectionStatus(storedSlug, _types3._ChainConnectionStatus.DISCONNECTED);
           newStorageData.push({
             ...mergedChainInfoMap[storedSlug],
             active: canActive && storedChainInfo.active,
@@ -803,9 +831,9 @@ class ChainService {
             this.dataMap.chainStateMap[duplicatedDefaultSlug] = {
               currentProvider: storedChainInfo.currentProvider,
               slug: duplicatedDefaultSlug,
-              connectionStatus: _types3._ChainConnectionStatus.DISCONNECTED,
               active: storedChainInfo.active
             };
+            this.updateChainConnectionStatus(duplicatedDefaultSlug, _types3._ChainConnectionStatus.DISCONNECTED);
             newStorageData.push({
               ...mergedChainInfoMap[duplicatedDefaultSlug],
               active: storedChainInfo.active,
@@ -830,9 +858,9 @@ class ChainService {
               currentProvider: storedChainInfo.currentProvider,
               // TODO: review
               slug: storedSlug,
-              connectionStatus: _types3._ChainConnectionStatus.DISCONNECTED,
               active: storedChainInfo.active
             };
+            this.updateChainConnectionStatus(storedSlug, _types3._ChainConnectionStatus.DISCONNECTED);
             newStorageData.push({
               ...mergedChainInfoMap[storedSlug],
               active: storedChainInfo.active,
@@ -845,15 +873,15 @@ class ChainService {
       }
 
       // Fill in the missing chainState and storageData (new chains never before seen)
-      Object.entries(mergedChainInfoMap).forEach(_ref6 => {
-        let [slug, chainInfo] = _ref6;
+      Object.entries(mergedChainInfoMap).forEach(_ref7 => {
+        let [slug, chainInfo] = _ref7;
         if (!(slug in this.dataMap.chainStateMap)) {
           this.dataMap.chainStateMap[slug] = {
             currentProvider: Object.keys(chainInfo.providers)[0],
             slug,
-            connectionStatus: _types3._ChainConnectionStatus.DISCONNECTED,
             active: _constants._DEFAULT_ACTIVE_CHAINS.includes(slug)
           };
+          this.updateChainConnectionStatus(slug, _types3._ChainConnectionStatus.DISCONNECTED);
           newStorageData.push({
             ...mergedChainInfoMap[slug],
             active: _constants._DEFAULT_ACTIVE_CHAINS.includes(slug),
@@ -928,9 +956,7 @@ class ChainService {
     }
   }
   updateChainStateMapSubscription() {
-    (0, _utils2.addLazy)('updateChainStateMapSubscription', () => {
-      this.chainStateMapSubject.next(this.getChainStateMap());
-    }, 300, 900);
+    this.chainStateMapSubject.next(this.getChainStateMap());
   }
   updateChainInfoMapSubscription() {
     this.chainInfoMapSubject.next(this.getChainInfoMap());
@@ -1039,10 +1065,17 @@ class ChainService {
     const chainStateMap = this.getChainStateMap();
     chainStateMap[newChainSlug] = {
       active: true,
-      connectionStatus: _types3._ChainConnectionStatus.DISCONNECTED,
       currentProvider: params.chainEditInfo.currentProvider,
       slug: newChainSlug
     };
+
+    // const chainStatusMap = this.getChainStatusMap();
+    // const chainStatusMap[newChainSlug] = {
+    //   slug: newChainSlug,
+    //   connectionStatus: _ChainConnectionStatus.DISCONNECTED,
+    //   lastUpdated: Date.now()
+    // };
+
     await this.initApiForChain(chainInfo);
 
     // create a record in assetRegistry for native token and update store/subscription
@@ -1327,29 +1360,6 @@ class ChainService {
     await Promise.all([this.substrateChainHandler.wakeUp(), this.evmChainHandler.wakeUp()]);
     this.checkLatestData();
   }
-  checkAndUpdateStatusMapForChain(chainSlug) {
-    const substrateApiMap = this.getSubstrateApiMap();
-    const evmApiMap = this.getEvmApiMap();
-    const chainState = this.getChainStateByKey(chainSlug);
-    let update = false;
-    function updateState(current, status) {
-      if (current.connectionStatus !== status) {
-        current.connectionStatus = status;
-        update = true;
-      }
-    }
-    if (chainState.active) {
-      const api = substrateApiMap[chainSlug] || evmApiMap[chainSlug];
-      if (api) {
-        updateState(chainState, api.isApiConnected ? _types3._ChainConnectionStatus.CONNECTED : _types3._ChainConnectionStatus.DISCONNECTED);
-      }
-    } else {
-      updateState(chainState, _types3._ChainConnectionStatus.DISCONNECTED);
-    }
-    if (update) {
-      this.dataMap.chainStateMap[chainSlug] = chainState;
-    }
-  }
   async initAssetSettings() {
     const assetSettings = await this.getAssetSettings();
     const activeChainSlugs = this.getActiveChainSlugs();

package/cjs/services/earning-service/handlers/native-staking/relay-chain.js

@@ -287,7 +287,21 @@ class RelayNativeStakingPoolHandler extends _base.default {
     const currentEra = _era.toString();
     const allValidators = [];
     const validatorInfoList = [];
-    const [_totalEraStake, _eraStakers, _minBond, _stakingRewards] = await Promise.all([chainApi.api.query.staking.erasTotalStake(parseInt(currentEra)), chainApi.api.query.staking.erasStakers.entries(parseInt(currentEra)), chainApi.api.query.staking.minNominatorBond(), ((_chainApi$api$query$s = chainApi.api.query.stakingRewards) === null || _chainApi$api$query$s === void 0 ? void 0 : _chainApi$api$query$s.data) && chainApi.api.query.stakingRewards.data()]);
+    const [_totalEraStake, _eraStakers, _minBond, _stakingRewards, _validators] = await Promise.all([chainApi.api.query.staking.erasTotalStake(parseInt(currentEra)), chainApi.api.query.staking.erasStakers.entries(parseInt(currentEra)), chainApi.api.query.staking.minNominatorBond(), ((_chainApi$api$query$s = chainApi.api.query.stakingRewards) === null || _chainApi$api$query$s === void 0 ? void 0 : _chainApi$api$query$s.data) && chainApi.api.query.stakingRewards.data(), chainApi.api.query.staking.validators.entries()]);
+
+    // filter blocked validators
+    const validators = _validators;
+    const blockValidatorList = [];
+    for (const validator of validators) {
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-member-access
+      const validatorAddress = validator[0].toHuman()[0];
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-member-access
+      const validatorPrefs = validator[1].toHuman();
+      const isBlocked = validatorPrefs.blocked;
+      if (isBlocked) {
+        blockValidatorList.push(validatorAddress);
+      }
+    }
     const stakingRewards = _stakingRewards === null || _stakingRewards === void 0 ? void 0 : _stakingRewards.toPrimitive();
     const unlimitedNominatorRewarded = chainApi.api.consts.staking.maxExposurePageSize !== undefined;
     const maxNominatorRewarded = (chainApi.api.consts.staking.maxNominatorRewardedPerValidator || 0).toString();
@@ -303,32 +317,34 @@ class RelayNativeStakingPoolHandler extends _base.default {
       // eslint-disable-next-line @typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-member-access
       const rawValidatorStat = item[1].toHuman();
       const validatorAddress = rawValidatorInfo[1];
-      const rawTotalStake = rawValidatorStat.total;
-      const rawOwnStake = rawValidatorStat.own;
-      const bnTotalStake = new _util.BN(rawTotalStake.replaceAll(',', ''));
-      const bnOwnStake = new _util.BN(rawOwnStake.replaceAll(',', ''));
-      const otherStake = bnTotalStake.sub(bnOwnStake);
-      totalStakeMap[validatorAddress] = bnTotalStake;
-      let nominatorCount = 0;
-      if ('others' in rawValidatorStat) {
-        const others = rawValidatorStat.others;
-        nominatorCount = others.length;
+      if (!blockValidatorList.includes(validatorAddress)) {
+        const rawTotalStake = rawValidatorStat.total;
+        const rawOwnStake = rawValidatorStat.own;
+        const bnTotalStake = new _util.BN(rawTotalStake.replaceAll(',', ''));
+        const bnOwnStake = new _util.BN(rawOwnStake.replaceAll(',', ''));
+        const otherStake = bnTotalStake.sub(bnOwnStake);
+        totalStakeMap[validatorAddress] = bnTotalStake;
+        let nominatorCount = 0;
+        if ('others' in rawValidatorStat) {
+          const others = rawValidatorStat.others;
+          nominatorCount = others.length;
+        }
+        allValidators.push(validatorAddress);
+        validatorInfoList.push({
+          address: validatorAddress,
+          totalStake: bnTotalStake.toString(),
+          ownStake: bnOwnStake.toString(),
+          otherStake: otherStake.toString(),
+          nominatorCount,
+          // to be added later
+          commission: 0,
+          expectedReturn: 0,
+          blocked: false,
+          isVerified: false,
+          minBond,
+          isCrowded: unlimitedNominatorRewarded ? false : nominatorCount > parseInt(maxNominatorRewarded)
+        });
       }
-      allValidators.push(validatorAddress);
-      validatorInfoList.push({
-        address: validatorAddress,
-        totalStake: bnTotalStake.toString(),
-        ownStake: bnOwnStake.toString(),
-        otherStake: otherStake.toString(),
-        nominatorCount,
-        // to be added later
-        commission: 0,
-        expectedReturn: 0,
-        blocked: false,
-        isVerified: false,
-        minBond,
-        isCrowded: unlimitedNominatorRewarded ? false : nominatorCount > parseInt(maxNominatorRewarded)
-      });
     }
     const extraInfoMap = {};
     await Promise.all(allValidators.map(async address => {

package/cjs/services/earning-service/service.js

@@ -134,13 +134,20 @@ class EarningService {
     this.eventService.onLazy((events, eventTypes) => {
       (async () => {
         const removedAddresses = [];
+        const removeChains = [];
         events.forEach(event => {
           if (event.type === 'account.remove') {
             removedAddresses.push(event.data[0]);
           }
+          if (event.type === 'chain.updateState') {
+            const chainState = this.state.getChainStateByKey(event.data[0]);
+            if (chainState && !(0, _utils._isChainEnabled)(chainState)) {
+              removeChains.push(event.data[0]);
+            }
+          }
         });
-        if (removedAddresses.length > 0) {
-          await this.removeYieldPositions(undefined, removedAddresses);
+        if (removeChains.length || removedAddresses.length) {
+          await this.removeYieldPositions(removeChains, removedAddresses);
         }
 
         // Account changed or chain changed (active or inactive)

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

@@ -0,0 +1,17 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _MigrateProvider = _interopRequireDefault(require("./MigrateProvider"));
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+class MigrateEthProvider extends _MigrateProvider.default {
+  newProvider = 'ethereum';
+  oldProvider = 'Cloudflare';
+  slug = 'Llamarpc';
+}
+exports.default = MigrateEthProvider;

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

@@ -0,0 +1,17 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _MigrateProvider = _interopRequireDefault(require("./MigrateProvider"));
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+class MigratePioneerProvider extends _MigrateProvider.default {
+  slug = 'pioneer';
+  oldProvider = 'OnFinality';
+  newProvider = 'Pioneer';
+}
+exports.default = MigratePioneerProvider;

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

@@ -0,0 +1,29 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _Base = _interopRequireDefault(require("@subwallet/extension-base/services/migration-service/Base"));
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+class MigrateProvider extends _Base.default {
+  async run() {
+    const state = this.state;
+    const chainState = state.getChainStateByKey(this.slug);
+    const chainInfo = state.getChainInfo(this.slug);
+    if (chainState && chainState.active && chainState.currentProvider === this.oldProvider) {
+      await state.upsertChainInfo({
+        mode: 'update',
+        chainEditInfo: {
+          currentProvider: this.newProvider,
+          slug: this.slug,
+          providers: chainInfo.providers
+        }
+      });
+    }
+  }
+}
+exports.default = MigrateProvider;

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

@@ -0,0 +1,241 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.DatabaseService = void 0;
+var _KoniTypes = require("@subwallet/extension-base/background/KoniTypes");
+var _databases = _interopRequireDefault(require("@subwallet/extension-base/services/storage-service/databases"));
+var _dbStores = require("@subwallet/extension-base/services/storage-service/db-stores");
+var _ChainStakingMetadata = _interopRequireDefault(require("@subwallet/extension-base/services/storage-service/db-stores/ChainStakingMetadata"));
+var _NominatorMetadata = _interopRequireDefault(require("@subwallet/extension-base/services/storage-service/db-stores/NominatorMetadata"));
+var _utils = require("@subwallet/extension-base/utils");
+var _util = require("@polkadot/util");
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+class DatabaseService {
+  // TODO: might remove this
+
+  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),
+      nft: new _dbStores.NftStore(this._db.nfts),
+      nftCollection: new _dbStores.NftCollectionStore(this._db.nftCollections),
+      crowdloan: new _dbStores.CrowdloanStore(this._db.crowdloans),
+      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
+      chainStakingMetadata: new _ChainStakingMetadata.default(this._db.chainStakingMetadata),
+      nominatorMetadata: new _NominatorMetadata.default(this._db.nominatorMetadata)
+    };
+  }
+  async updatePriceStore(priceData) {
+    await this.stores.price.table.put(priceData);
+  }
+  async getPriceStore() {
+    try {
+      const rs = await this.stores.price.table.get('usd');
+      return rs;
+    } catch (e) {
+      this.logger.error(e);
+      return undefined;
+    }
+  }
+
+  // Balance
+  async getStoredBalance() {
+    return this.stores.balance.table.toArray();
+  }
+  async updateBalanceStore(address, item) {
+    if (item.state === _KoniTypes.APIItemState.READY) {
+      return this.stores.balance.upsert({
+        address,
+        ...item
+      });
+    }
+  }
+  async removeFromBalanceStore(assets) {
+    return this.stores.balance.removeBySlugs(assets);
+  }
+
+  // Crowdloan
+  async updateCrowdloanStore(chain, address, item) {
+    if (item.state === _KoniTypes.APIItemState.READY && item.contribute !== '0') {
+      return this.stores.crowdloan.upsert({
+        chain,
+        address,
+        ...item
+      });
+    } else {
+      return this.stores.crowdloan.deleteByChainAndAddress(chain, address);
+    }
+  }
+
+  // Staking
+  async updateStaking(chain, address, item) {
+    if (item.state === _KoniTypes.APIItemState.READY) {
+      return this.stores.staking.upsert(item);
+    }
+  }
+  async getStakings(addresses, chains) {
+    return this.stores.staking.getStakings(addresses, chains);
+  }
+  async getStakingsByChains(chains) {
+    return this.stores.staking.getStakingsByChains(chains);
+  }
+  async getPooledStakings(addresses, chainHashes) {
+    return this.stores.staking.getPooledStakings(addresses, chainHashes);
+  }
+  subscribeStaking(addresses, chainList, callback) {
+    this.stakingSubscription && this.stakingSubscription.unsubscribe();
+    this.stakingSubscription = this.stores.staking.subscribeStaking(addresses, chainList).subscribe({
+      next: stakings => callback && callback(stakings)
+    });
+    return this.stakingSubscription;
+  }
+  subscribeChainStakingMetadata(chains, callback) {
+    this.stores.chainStakingMetadata.subscribeByChain(chains).subscribe({
+      next: data => callback && callback(data)
+    });
+  }
+  subscribeNominatorMetadata(addresses, callback) {
+    return this.stores.nominatorMetadata.subscribeByAddresses(addresses).subscribe({
+      next: data => callback && callback(data)
+    });
+  }
+
+  // Transaction histories
+  async getHistories(query) {
+    return this.stores.transaction.queryHistory(query);
+  }
+  async upsertHistory(histories) {
+    const cleanedHistory = histories.filter(x => x && x.address && x.chain && x.extrinsicHash);
+    return this.stores.transaction.bulkUpsert(cleanedHistory);
+  }
+  async updateHistoryByExtrinsicHash(extrinsicHash, updateData) {
+    const canUpdate = updateData && extrinsicHash;
+    if (!canUpdate) {
+      return;
+    }
+    return this.stores.transaction.updateWithQuery({
+      extrinsicHash
+    }, updateData);
+  }
+
+  // NFT Collection
+  async addNftCollection(collection) {
+    return this.stores.nftCollection.upsert(collection);
+  }
+  async deleteNftCollection(chain, collectionId) {
+    await this.stores.nftCollection.removeCollection(chain, collectionId);
+    await this.stores.nft.deleteNftsByCollection(chain, collectionId);
+  }
+  getAllNftCollection(chainHashes) {
+    return this.stores.nftCollection.getNftCollection(chainHashes);
+  }
+
+  // NFT
+  subscribeNft(addresses, chainHashes, callback) {
+    this.nftSubscription && this.nftSubscription.unsubscribe();
+    this.nftSubscription = this.stores.nft.subscribeNft(addresses, chainHashes).subscribe({
+      next: nfts => callback && callback(nfts)
+    });
+    return this.nftSubscription;
+  }
+  async cleanUpNft(chain, owner, collectionIds, nftIds, ownNothing) {
+    if (ownNothing) {
+      return this.stores.nft.deleteNftsByChainAndOwner(chain, (0, _utils.reformatAddress)(owner, 42), collectionIds);
+    }
+    return this.stores.nft.cleanUpNfts(chain, (0, _utils.reformatAddress)(owner, 42), collectionIds, nftIds);
+  }
+  async getNft(addresses, chainHashes) {
+    return this.stores.nft.getNft(addresses, chainHashes);
+  }
+  async addNft(address, nft) {
+    return this.stores.nft.upsert({
+      ...nft,
+      address
+    });
+  }
+  handleNftTransfer(chain, addresses, nftItem) {
+    return this.stores.nft.deleteNftItem(chain, addresses, nftItem);
+  }
+  removeNfts(chain, address, collectionId, nftIds) {
+    return this.stores.nft.removeNfts(chain, address, collectionId, nftIds);
+  }
+
+  // Chain
+  async updateChainStore(item) {
+    return this.stores.chain.upsert(item);
+  }
+  async bulkUpdateChainStore(data) {
+    return this.stores.chain.bulkUpsert(data);
+  }
+  async removeFromChainStore(chains) {
+    return this.stores.chain.removeChains(chains);
+  }
+  async getAllChainStore() {
+    return this.stores.chain.getAll();
+  }
+
+  // Asset
+  async updateAssetStore(item) {
+    return this.stores.asset.upsert(item);
+  }
+  async getAllAssetStore() {
+    return this.stores.asset.getAll();
+  }
+  async removeFromAssetStore(items) {
+    return this.stores.asset.removeAssets(items);
+  }
+
+  // Staking
+  async updateChainStakingMetadata(item, changes) {
+    const existingRecord = await this.stores.chainStakingMetadata.getByChainAndType(item.chain, item.type);
+    if (existingRecord && changes) {
+      return this.stores.chainStakingMetadata.updateByChainAndType(item.chain, item.type, changes);
+    }
+    return this.stores.chainStakingMetadata.upsert(item);
+  }
+  async getChainStakingMetadata() {
+    return this.stores.chainStakingMetadata.getAll();
+  }
+  async getStakingMetadataByChain(chain) {
+    let type = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : _KoniTypes.StakingType.NOMINATED;
+    return this.stores.chainStakingMetadata.getByChainAndType(chain, type);
+  }
+  async updateNominatorMetadata(item) {
+    return this.stores.nominatorMetadata.upsert(item);
+  }
+  async getNominatorMetadata() {
+    return this.stores.nominatorMetadata.getAll();
+  }
+  async resetWallet(resetAll) {
+    return new Promise((resolve, reject) => {
+      const stores = [this.stores.balance, this.stores.nft, this.stores.nftCollection, this.stores.crowdloan, this.stores.staking, this.stores.transaction, this.stores.nominatorMetadata];
+      if (resetAll) {
+        stores.push(this.stores.chain, this.stores.asset);
+      }
+      const promises = stores.map(store => store.clear());
+      Promise.all(promises).then(() => {
+        resolve();
+      }).catch(e => {
+        reject(e);
+      });
+    });
+  }
+}
+exports.DatabaseService = DatabaseService;