@subwallet/extension-base 1.1.28-0 → 1.1.28-beta.1

package/cjs/services/mint-campaign-service/campaigns/UnlockDotCampaign.js

@@ -0,0 +1,149 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _utils = require("@subwallet/extension-base/utils");
+var _axios = _interopRequireDefault(require("axios"));
+var _rxjs = require("rxjs");
+var _constants = require("../constants");
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+class UnlockDotCampaign {
+  #host = _constants.MINT_HOST;
+  #campaignId = 4;
+  #state;
+  #transactionNftSubject = new _rxjs.BehaviorSubject({});
+  #transactionNftState = {};
+  constructor(state) {
+    this.#state = state;
+  }
+  async mintNft(_ref) {
+    var _result;
+    let {
+      address,
+      extrinsicHash,
+      network,
+      slug,
+      transactionId
+    } = _ref;
+    this.#transactionNftState[transactionId] = undefined;
+    this.#transactionNftSubject.next(this.#transactionNftState);
+    const requestId = await this.checkMint({
+      address,
+      extrinsicHash,
+      network,
+      slug
+    });
+    let result;
+    if (requestId) {
+      result = await this.submitNft(address, requestId);
+      await this.#state.reloadNft();
+      // } else {
+      //   result = await this.getMinted(address, slug);
+    }
+
+    this.#transactionNftState[transactionId] = (_result = result) !== null && _result !== void 0 ? _result : {
+      nftImage: ''
+    };
+    this.#transactionNftSubject.next(this.#transactionNftState);
+  }
+  async checkMint(_ref2) {
+    let {
+      address,
+      extrinsicHash,
+      network,
+      slug
+    } = _ref2;
+    const data = {
+      address,
+      campaignId: this.#campaignId,
+      category: slug,
+      additionalData: {
+        slug,
+        extrinsicHash,
+        network
+      }
+    };
+    const response = await _axios.default.request({
+      baseURL: this.#host,
+      url: '/api/mint/check',
+      method: 'POST',
+      data
+    });
+    const respData = response.data;
+    if (respData.inMintingTime && respData.hasBalance && respData.validCampaign && respData.validCategory && respData.validUser && respData.notDuplicated && respData.requestId && respData.requestId > 1) {
+      return respData.requestId;
+    }
+    return null;
+  }
+  async submitNft(address, id) {
+    const data = {
+      requestId: id,
+      recipient: address
+    };
+    const response = await _axios.default.request({
+      baseURL: this.#host,
+      url: '/api/mint/submit',
+      method: 'POST',
+      data
+    });
+    return response.data;
+  }
+
+  // @ts-ignore
+  async getMinted(address, slug) {
+    const params = {
+      address
+    };
+    const response = await _axios.default.request({
+      baseURL: this.#host,
+      url: '/api/mint/fetch',
+      method: 'GET',
+      params: params
+    });
+    const data = response.data;
+    for (const item of data) {
+      if ((0, _utils.isSameAddress)(item.address, address) && slug === item.mintCategory && item.status === 'success' && item.campaignId === this.#campaignId) {
+        return item;
+      }
+    }
+    return undefined;
+  }
+  async canMint(address, slug, network) {
+    const data = {
+      address,
+      campaignId: this.#campaignId,
+      category: slug,
+      additionalData: {
+        slug,
+        network
+      }
+    };
+    const response = await _axios.default.request({
+      baseURL: this.#host,
+      url: '/api/mint/check',
+      method: 'POST',
+      data
+    });
+    const respData = response.data;
+    if (respData.inMintingTime && respData.validCampaign && respData.validCategory && respData.validUser && respData.notDuplicated) {
+      return true;
+    }
+    return false;
+  }
+  subscribeMintedNft(transactionId, cb) {
+    return this.#transactionNftSubject.subscribe({
+      next: map => {
+        cb(map[transactionId]);
+      }
+    });
+  }
+  getMintedNft(transactionId) {
+    return this.#transactionNftSubject.value[transactionId];
+  }
+}
+exports.default = UnlockDotCampaign;

package/cjs/services/mint-campaign-service/campaigns/index.js

@@ -0,0 +1,13 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "UnlockDotCampaign", {
+  enumerable: true,
+  get: function () {
+    return _UnlockDotCampaign.default;
+  }
+});
+var _UnlockDotCampaign = _interopRequireDefault(require("./UnlockDotCampaign"));

package/cjs/services/mint-campaign-service/constants.js

@@ -0,0 +1,11 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.MINT_HOST = void 0;
+// Copyright 2019-2022 @polkadot/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+const MINT_HOST = process.env.NFT_MINTING_HOST || '';
+exports.MINT_HOST = MINT_HOST;

package/cjs/services/mint-campaign-service/index.js

@@ -0,0 +1,18 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _campaigns = require("./campaigns");
+// Copyright 2019-2022 @polkadot/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+class MintCampaignService {
+  #state;
+  constructor(state) {
+    this.#state = state;
+    this.unlockDotCampaign = new _campaigns.UnlockDotCampaign(this.#state);
+  }
+}
+exports.default = MintCampaignService;

package/cjs/services/notification-service/NotificationService.js

@@ -39,7 +39,7 @@ class NotificationService {
       type: 'basic',
       title,
       message,
-      iconUrl: './images/icon-128.png',
+      iconUrl: '/images/icon-128.png',
       priority: 2,
       isClickable: !!link || !!onClick,
       buttons

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

@@ -12,6 +12,8 @@ var _Campaign = _interopRequireDefault(require("@subwallet/extension-base/servic
 var _ChainStakingMetadata = _interopRequireDefault(require("@subwallet/extension-base/services/storage-service/db-stores/ChainStakingMetadata"));
 var _MantaPay = _interopRequireDefault(require("@subwallet/extension-base/services/storage-service/db-stores/MantaPay"));
 var _NominatorMetadata = _interopRequireDefault(require("@subwallet/extension-base/services/storage-service/db-stores/NominatorMetadata"));
+var _YieldPoolStore = _interopRequireDefault(require("@subwallet/extension-base/services/storage-service/db-stores/YieldPoolStore"));
+var _YieldPositionStore = _interopRequireDefault(require("@subwallet/extension-base/services/storage-service/db-stores/YieldPositionStore"));
 var _utils = require("@subwallet/extension-base/utils");
 var _dexieExportImport = require("dexie-export-import");
 var _util = require("@polkadot/util");
@@ -42,6 +44,9 @@ class DatabaseService {
       metadata: new _dbStores.MetadataStore(this._db.metadata),
       chain: new _dbStores.ChainStore(this._db.chain),
       asset: new _dbStores.AssetStore(this._db.asset),
+      // yield
+      yieldPoolInfo: new _YieldPoolStore.default(this._db.yieldPoolInfo),
+      yieldPosition: new _YieldPositionStore.default(this._db.yieldPosition),
       // staking
       chainStakingMetadata: new _ChainStakingMetadata.default(this._db.chainStakingMetadata),
       nominatorMetadata: new _NominatorMetadata.default(this._db.nominatorMetadata),
@@ -281,6 +286,48 @@ class DatabaseService {
     return this.stores.mantaPay.getFirstConfig(chain);
   }
 
+  /* Earning */
+
+  async updateYieldPoolStore(data) {
+    await this.stores.yieldPoolInfo.upsert(data);
+  }
+  async deleteYieldPoolInfo(slugs) {
+    await this.stores.yieldPoolInfo.bulkDelete(slugs);
+  }
+  async getYieldPools() {
+    return this.stores.yieldPoolInfo.getAll();
+  }
+  async getYieldPoolStakingInfo(chain, poolType) {
+    return this.stores.yieldPoolInfo.getByChainAndType(chain, poolType);
+  }
+  async getYieldPool(slug) {
+    return this.stores.yieldPoolInfo.getBySlug(slug);
+  }
+  async getYieldPositionByAddressAndSlug(address, slug) {
+    return this.stores.yieldPosition.getByAddressAndSlug(address, slug);
+  }
+  subscribeYieldPoolInfo(chains, callback) {
+    this.yieldInfoSubscription && this.yieldInfoSubscription.unsubscribe();
+    this.yieldInfoSubscription = this.stores.yieldPoolInfo.subscribeYieldPoolInfo(chains).subscribe({
+      next: data => callback && callback(data)
+    });
+    return this.yieldInfoSubscription;
+  }
+  async updateYieldPosition(data) {
+    await this.stores.yieldPosition.upsert(data);
+  }
+  async getYieldPositionByAddress(addresses) {
+    return this.stores.yieldPosition.getByAddress(addresses);
+  }
+  subscribeYieldPosition(addresses, callback) {
+    return this.stores.yieldPosition.subscribeYieldPositions(addresses).subscribe({
+      next: data => callback && callback(data)
+    });
+  }
+  async getYieldNominationPoolPosition(addresses, chains) {
+    return this.stores.yieldPosition.getByAddressAndChains(addresses, chains);
+  }
+
   /* Campaign */
 
   subscribeProcessingCampaign() {

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

@@ -40,6 +40,10 @@ class KoniDatabase extends _dexie.default {
       mantaPay: 'key, chain'
     });
     this.conditionalVersion(4, {
+      yieldPoolInfo: 'slug, chain, type',
+      yieldPosition: '[slug+chain+address], [address+slug], address, chain'
+    });
+    this.conditionalVersion(5, {
       campaign: 'slug'
     });
   }

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

@@ -5,15 +5,15 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = void 0;
-var _KoniTypes = require("@subwallet/extension-base/background/KoniTypes");
 var _BaseStoreWithAddressAndChain = _interopRequireDefault(require("@subwallet/extension-base/services/storage-service/db-stores/BaseStoreWithAddressAndChain"));
+var _types = require("@subwallet/extension-base/types");
 var _dexie = require("dexie");
 // Copyright 2019-2022 @subwallet/extension-base authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
 class NominatorMetadataStore extends _BaseStoreWithAddressAndChain.default {
   async getAll() {
-    return this.table.filter(item => item.status !== _KoniTypes.StakingStatus.NOT_STAKING).toArray();
+    return this.table.filter(item => item.status !== _types.EarningStatus.NOT_STAKING).toArray();
   }
   subscribeByAddresses(addresses) {
     return (0, _dexie.liveQuery)(() => this.getByAddress(addresses));
@@ -22,7 +22,7 @@ class NominatorMetadataStore extends _BaseStoreWithAddressAndChain.default {
     return (0, _dexie.liveQuery)(() => this.getAll());
   }
   getByAddress(addresses) {
-    return this.table.where('address').anyOfIgnoreCase(addresses).and(item => item.status !== _KoniTypes.StakingStatus.NOT_STAKING).toArray();
+    return this.table.where('address').anyOfIgnoreCase(addresses).and(item => item.status !== _types.EarningStatus.NOT_STAKING).toArray();
   }
   async removeByAddress(address) {
     return this.table.where('address').anyOfIgnoreCase(address).delete();

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

@@ -0,0 +1,36 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _BaseStore = _interopRequireDefault(require("@subwallet/extension-base/services/storage-service/db-stores/BaseStore"));
+var _dexie = require("dexie");
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+class YieldPoolStore extends _BaseStore.default {
+  async getAll() {
+    return this.table.toArray();
+  }
+  async getByChains(chains) {
+    if (chains.length === 0) {
+      return this.getAll();
+    }
+    return this.table.where('chain').anyOfIgnoreCase(chains).toArray();
+  }
+  async getByChainAndType(chain, poolType) {
+    return this.table.where('chain').equals(chain).and(item => item.type === poolType).first();
+  }
+  async bulkDelete(slugs) {
+    return this.table.bulkDelete(slugs);
+  }
+  async getBySlug(slug) {
+    return this.table.get(slug);
+  }
+  subscribeYieldPoolInfo(chains) {
+    return (0, _dexie.liveQuery)(() => this.getByChains(chains));
+  }
+}
+exports.default = YieldPoolStore;

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

@@ -0,0 +1,65 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _BaseStore = _interopRequireDefault(require("@subwallet/extension-base/services/storage-service/db-stores/BaseStore"));
+var _dexie = require("dexie");
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+class YieldPositionStore extends _BaseStore.default {
+  async getAll() {
+    return this.table
+    // .filter((item) => {
+    //   let isValidLiquidStaking = false;
+    //
+    //   if (item.type === YieldPoolType.LIQUID_STAKING) {
+    //     const nominatorMetadata = item.metadata as NominatorMetadata;
+    //
+    //     if (nominatorMetadata.unstakings.length > 0) {
+    //       console.log('true', item);
+    //       isValidLiquidStaking = true;
+    //     }
+    //   }
+    //
+    //   return parseInt(item.balance[0].activeBalance) > 0 || isValidLiquidStaking;
+    // })
+    .toArray();
+  }
+  async getByAddress(addresses) {
+    if (addresses.length === 0) {
+      return this.getAll();
+    }
+    return this.table.where('address').anyOfIgnoreCase(addresses)
+    // .filter((item) => {
+    //   let isValidLiquidStaking = false;
+    //
+    //   if (item.type === YieldPoolType.LIQUID_STAKING) {
+    //     const nominatorMetadata = item.metadata as NominatorMetadata;
+    //
+    //     if (nominatorMetadata && nominatorMetadata?.unstakings?.length > 0) {
+    //       isValidLiquidStaking = true;
+    //     }
+    //   }
+    //
+    //   return parseInt(item.balance[0].activeBalance) > 0 || isValidLiquidStaking;
+    // })
+    .toArray();
+  }
+  async getByAddressAndChains(addresses, chains) {
+    return this.table.where('address').anyOfIgnoreCase(addresses).filter(item => chains.includes(item.chain)).toArray();
+  }
+  getByAddressAndSlug(address, slug) {
+    return this.table.get({
+      address,
+      slug
+    });
+  }
+  subscribeYieldPositions(addresses) {
+    return (0, _dexie.liveQuery)(() => this.getByAddress(addresses));
+  }
+}
+exports.default = YieldPositionStore;

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;