@subwallet/extension-base 0.8.3-2 → 1.0.1

package/cjs/services/request-service/handler/SubstrateRequestHandler.js

@@ -0,0 +1,105 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _RequestExtrinsicSign = _interopRequireDefault(require("@subwallet/extension-base/background/RequestExtrinsicSign"));
+var _getId = require("@subwallet/extension-base/utils/getId");
+var _request = require("@subwallet/extension-base/utils/request");
+var _uiKeyring = _interopRequireDefault(require("@subwallet/ui-keyring"));
+var _rxjs = require("rxjs");
+var _logger = require("@polkadot/util/logger");
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+class SubstrateRequestHandler {
+  #logger;
+  #requestService;
+  #substrateRequests = {};
+  signSubject = new _rxjs.BehaviorSubject([]);
+  constructor(requestService) {
+    this.#requestService = requestService;
+    this.#logger = (0, _logger.logger)('SubstrateRequestHandler');
+  }
+  getSignRequest(id) {
+    return this.#substrateRequests[id];
+  }
+  get allSubstrateRequests() {
+    return Object.values(this.#substrateRequests).map(_ref => {
+      let {
+        account,
+        id,
+        request,
+        url
+      } = _ref;
+      return {
+        account,
+        id,
+        request,
+        url,
+        isInternal: (0, _request.isInternalRequest)(url)
+      };
+    });
+  }
+  updateIconSign(shouldClose) {
+    this.signSubject.next(this.allSubstrateRequests);
+    this.#requestService.updateIconV2(shouldClose);
+  }
+  signComplete = (id, resolve, reject) => {
+    const complete = () => {
+      delete this.#substrateRequests[id];
+      this.updateIconSign(true);
+    };
+    return {
+      reject: error => {
+        complete();
+        this.#logger.log(error);
+        reject(error);
+      },
+      resolve: result => {
+        complete();
+        resolve(result);
+      }
+    };
+  };
+  get numSubstrateRequests() {
+    return Object.keys(this.#substrateRequests).length;
+  }
+  sign(url, request, account) {
+    const id = (0, _getId.getId)();
+    return new Promise((resolve, reject) => {
+      this.#substrateRequests[id] = {
+        ...this.signComplete(id, resolve, reject),
+        account,
+        id,
+        request,
+        url
+      };
+      this.updateIconSign();
+      this.#requestService.popupOpen();
+    });
+  }
+  signTransaction(id, address, url, payload) {
+    return new Promise((resolve, reject) => {
+      const pair = _uiKeyring.default.getPair(address);
+      const account = {
+        address: pair.address,
+        ...pair.meta
+      };
+      this.#substrateRequests[id] = {
+        ...this.signComplete(id, resolve, reject),
+        account,
+        id,
+        request: new _RequestExtrinsicSign.default(payload),
+        url: url
+      };
+      this.updateIconSign();
+      if (!(0, _request.isInternalRequest)(url)) {
+        this.#requestService.popupOpen();
+      }
+    });
+  }
+}
+exports.default = SubstrateRequestHandler;

package/cjs/services/request-service/helper/index.js

@@ -0,0 +1,82 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getOS = exports.extractMetadata = void 0;
+var _extensionChains = require("@subwallet/extension-chains");
+var _defaults = require("@polkadot/networks/defaults");
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+const extractMetadata = store => {
+  store.allMap(map => {
+    const knownEntries = Object.entries(_defaults.knownGenesis);
+    const defs = {};
+    const removals = [];
+    Object.entries(map).forEach(_ref => {
+      let [key, def] = _ref;
+      const entry = knownEntries.find(_ref2 => {
+        let [, hashes] = _ref2;
+        return hashes.includes(def.genesisHash);
+      });
+      if (entry) {
+        const [name, hashes] = entry;
+        const index = hashes.indexOf(def.genesisHash);
+
+        // flatten the known metadata based on the genesis index
+        // (lower is better/newer)
+        if (!defs[name] || defs[name].index > index) {
+          if (defs[name]) {
+            // remove the old version of the metadata
+            removals.push(defs[name].key);
+          }
+          defs[name] = {
+            def,
+            index,
+            key
+          };
+        }
+      } else {
+        // this is not a known entry, so we will just apply it
+        defs[key] = {
+          def,
+          index: 0,
+          key
+        };
+      }
+    });
+    removals.forEach(key => store.remove(key));
+    Object.values(defs).forEach(_ref3 => {
+      let {
+        def
+      } = _ref3;
+      return (0, _extensionChains.addMetadata)(def);
+    });
+  });
+};
+exports.extractMetadata = extractMetadata;
+const getOS = () => {
+  var _window$navigator, _window$navigator$use;
+  const userAgent = window.navigator.userAgent;
+  // @ts-ignore
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access,@typescript-eslint/no-unsafe-assignment
+  const platform = ((_window$navigator = window.navigator) === null || _window$navigator === void 0 ? void 0 : (_window$navigator$use = _window$navigator.userAgentData) === null || _window$navigator$use === void 0 ? void 0 : _window$navigator$use.platform) || window.navigator.platform;
+  const macosPlatforms = ['Macintosh', 'MacIntel', 'MacPPC', 'Mac68K'];
+  const windowsPlatforms = ['Win32', 'Win64', 'Windows', 'WinCE'];
+  const iosPlatforms = ['iPhone', 'iPad', 'iPod'];
+  let os = 'Unknown';
+  if (macosPlatforms.indexOf(platform) !== -1) {
+    os = 'Mac OS';
+  } else if (iosPlatforms.indexOf(platform) !== -1) {
+    os = 'iOS';
+  } else if (windowsPlatforms.indexOf(platform) !== -1) {
+    os = 'Windows';
+  } else if (/Android/.test(userAgent)) {
+    os = 'Android';
+  } else if (/Linux/.test(platform)) {
+    os = 'Linux';
+  }
+  return os;
+};
+exports.getOS = getOS;

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

@@ -0,0 +1,158 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _AuthRequestHandler = _interopRequireDefault(require("@subwallet/extension-base/services/request-service/handler/AuthRequestHandler"));
+var _EvmRequestHandler = _interopRequireDefault(require("@subwallet/extension-base/services/request-service/handler/EvmRequestHandler"));
+var _MetadataRequestHandler = _interopRequireDefault(require("@subwallet/extension-base/services/request-service/handler/MetadataRequestHandler"));
+var _PopupHandler = _interopRequireDefault(require("@subwallet/extension-base/services/request-service/handler/PopupHandler"));
+var _SubstrateRequestHandler = _interopRequireDefault(require("@subwallet/extension-base/services/request-service/handler/SubstrateRequestHandler"));
+var _accounts = require("@subwallet/ui-keyring/observable/accounts");
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+class RequestService {
+  // Common
+  #chainService;
+  #popupHandler;
+  #metadataRequestHandler;
+  #authRequestHandler;
+  #substrateRequestHandler;
+  #evmRequestHandler;
+
+  // Common
+  constructor(chainService, settingService) {
+    this.#chainService = chainService;
+    this.settingService = settingService;
+    this.#popupHandler = new _PopupHandler.default(this);
+    this.#metadataRequestHandler = new _MetadataRequestHandler.default(this);
+    this.#authRequestHandler = new _AuthRequestHandler.default(this, this.#chainService);
+    this.#substrateRequestHandler = new _SubstrateRequestHandler.default(this);
+    this.#evmRequestHandler = new _EvmRequestHandler.default(this);
+
+    // Reset icon on start service
+    this.updateIconV2();
+  }
+  get numAllRequests() {
+    return this.allSubstrateRequests.length + this.numEvmRequests;
+  }
+  updateIconV2(shouldClose) {
+    this.#popupHandler.updateIconV2(shouldClose);
+  }
+  getAddressList() {
+    let value = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
+    const addressList = Object.keys(_accounts.accounts.subject.value);
+    return addressList.reduce((addressList, v) => ({
+      ...addressList,
+      [v]: value
+    }), {});
+  }
+
+  // Popup
+  get popup() {
+    return this.#popupHandler.popup;
+  }
+  popupClose() {
+    this.#popupHandler.popupClose();
+  }
+  popupOpen() {
+    this.#popupHandler.popupOpen();
+  }
+
+  // Metadata
+  get metaSubject() {
+    return this.#metadataRequestHandler.metaSubject;
+  }
+  get knownMetadata() {
+    return this.#metadataRequestHandler.knownMetadata;
+  }
+  get numMetaRequests() {
+    return this.#metadataRequestHandler.numMetaRequests;
+  }
+  injectMetadata(url, request) {
+    return this.#metadataRequestHandler.injectMetadata(url, request);
+  }
+  getMetaRequest(id) {
+    return this.#metadataRequestHandler.getMetaRequest(id);
+  }
+  saveMetadata(meta) {
+    this.#metadataRequestHandler.saveMetadata(meta);
+  }
+
+  // Auth
+  get authSubjectV2() {
+    return this.#authRequestHandler.authSubjectV2;
+  }
+  get numAuthRequests() {
+    return this.#authRequestHandler.numAuthRequestsV2;
+  }
+  setAuthorize(data, callback) {
+    this.#authRequestHandler.setAuthorize(data, callback);
+  }
+  getAuthorize(update) {
+    this.#authRequestHandler.getAuthorize(update);
+  }
+  getAuthList() {
+    return this.#authRequestHandler.getAuthList();
+  }
+  async authorizeUrlV2(url, request) {
+    return this.#authRequestHandler.authorizeUrlV2(url, request);
+  }
+  getAuthRequestV2(id) {
+    return this.#authRequestHandler.getAuthRequestV2(id);
+  }
+  get subscribeEvmChainChange() {
+    return this.#authRequestHandler.subscribeEvmChainChange;
+  }
+  get subscribeAuthorizeUrlSubject() {
+    return this.#authRequestHandler.subscribeAuthorizeUrlSubject;
+  }
+  ensureUrlAuthorizedV2(url) {
+    return this.#authRequestHandler.ensureUrlAuthorizedV2(url);
+  }
+
+  // Substrate requests
+  get signSubject() {
+    return this.#substrateRequestHandler.signSubject;
+  }
+  get allSubstrateRequests() {
+    return this.#substrateRequestHandler.allSubstrateRequests;
+  }
+  sign(url, request, account) {
+    return this.#substrateRequestHandler.sign(url, request, account);
+  }
+  get numSubstrateRequests() {
+    return this.#substrateRequestHandler.numSubstrateRequests;
+  }
+
+  // Evm requests
+  get numEvmRequests() {
+    return this.#evmRequestHandler.numEvmRequests;
+  }
+  get confirmationsQueueSubject() {
+    return this.#evmRequestHandler.getConfirmationsQueueSubject();
+  }
+  getSignRequest(id) {
+    return this.#substrateRequestHandler.getSignRequest(id);
+  }
+  async signInternalTransaction(id, address, url, payload) {
+    return this.#substrateRequestHandler.signTransaction(id, address, url, payload);
+  }
+  addConfirmation(id, url, type, payload) {
+    let options = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : {};
+    let validator = arguments.length > 5 ? arguments[5] : undefined;
+    return this.#evmRequestHandler.addConfirmation(id, url, type, payload, options, validator);
+  }
+  async completeConfirmation(request) {
+    return await this.#evmRequestHandler.completeConfirmation(request);
+  }
+
+  // General methods
+  get numRequests() {
+    return this.numMetaRequests + this.numAuthRequests + this.numSubstrateRequests + this.numEvmRequests;
+  }
+}
+exports.default = RequestService;

package/cjs/services/request-service/types.js

@@ -0,0 +1 @@
+"use strict";

package/cjs/services/setting-service/SettingService.js

@@ -0,0 +1,39 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _Settings = _interopRequireDefault(require("@subwallet/extension-base/stores/Settings"));
+var _constants = require("./constants");
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+class SettingService {
+  settingsStore = new _Settings.default();
+  getSubject() {
+    return this.settingsStore.getSubject();
+  }
+  getSettings(update) {
+    this.settingsStore.get('Settings', value => {
+      if (!value) {
+        update({
+          // language: 'en',
+          browserConfirmationType: _constants.DEFAULT_NOTIFICATION_TYPE,
+          // isShowZeroBalance: true,
+          isShowBalance: false,
+          accountAllLogo: '',
+          theme: _constants.DEFAULT_THEME,
+          camera: false
+        });
+      } else {
+        update(value);
+      }
+    });
+  }
+  setSettings(data, callback) {
+    this.settingsStore.set('Settings', data, callback);
+  }
+}
+exports.default = SettingService;

package/cjs/services/setting-service/constants.js

@@ -0,0 +1,14 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.DEFAULT_THEME = exports.DEFAULT_NOTIFICATION_TYPE = void 0;
+var _KoniTypes = require("@subwallet/extension-base/background/KoniTypes");
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+const DEFAULT_THEME = _KoniTypes.ThemeNames.DARK;
+exports.DEFAULT_THEME = DEFAULT_THEME;
+const DEFAULT_NOTIFICATION_TYPE = 'popup';
+exports.DEFAULT_NOTIFICATION_TYPE = DEFAULT_NOTIFICATION_TYPE;

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

@@ -0,0 +1,228 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = 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 _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() {
+    this.logger = (0, _util.logger)('DB-Service');
+    this._db = new _databases.default();
+    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),
+      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) {
+      return undefined;
+    }
+  }
+
+  // Balance
+  async getStoredBalance() {
+    return this.stores.balance.table.toArray();
+  }
+  async updateBalanceStore(address, item) {
+    if (item.state === _KoniTypes.APIItemState.READY) {
+      this.logger.log(`Updating balance for [${item.tokenSlug}]`);
+      return this.stores.balance.upsert({
+        address,
+        ...item
+      });
+    }
+  }
+  async removeFromBalanceStore(assets) {
+    this.logger.log('Bulk removing AssetStore');
+    return this.stores.balance.removeBySlugs(assets);
+  }
+
+  // Crowdloan
+  async updateCrowdloanStore(chain, address, item) {
+    if (item.state === _KoniTypes.APIItemState.READY && item.contribute !== '0') {
+      this.logger.log(`Updating crowdloan for [${chain}]`);
+      return this.stores.crowdloan.upsert({
+        chain,
+        address,
+        ...item
+      });
+    } else {
+      this.logger.debug(`Removing crowdloan for [${chain}]`);
+      return this.stores.crowdloan.deleteByChainAndAddress(chain, address);
+    }
+  }
+
+  // Staking
+  async updateStaking(chain, address, item) {
+    if (item.state === _KoniTypes.APIItemState.READY) {
+      this.logger.log(`Updating staking for [${chain}]`);
+      return this.stores.staking.upsert(item);
+    }
+  }
+  async getStakings(addresses, chains) {
+    const stakings = await this.stores.staking.getStakings(addresses, chains);
+    this.logger.log('Get Stakings: ', stakings);
+    return stakings;
+  }
+  async getStakingsByChains(chains) {
+    return this.stores.staking.getStakingsByChains(chains);
+  }
+  async getPooledStakings(addresses, chainHashes) {
+    const stakings = await this.stores.staking.getPooledStakings(addresses, chainHashes);
+    this.logger.log('Get Pooled Stakings: ', stakings);
+    return stakings;
+  }
+  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(callback) {
+    this.stores.nominatorMetadata.subscribeAll().subscribe({
+      next: data => callback && callback(data)
+    });
+  }
+
+  // Transaction histories
+  async getHistories(query) {
+    const histories = await this.stores.transaction.queryHistory(query);
+    this.logger.log('Get histories: ', histories);
+    return histories;
+  }
+  async upsertHistory(histories) {
+    this.logger.log('Updating transaction histories');
+    return this.stores.transaction.bulkUpsert(histories);
+  }
+
+  // NFT Collection
+  async addNftCollection(collection) {
+    this.logger.log(`Updating NFT collection for [${collection.chain}]`);
+    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 getNft(addresses, chainHashes) {
+    const nfts = await this.stores.nft.getNft(addresses, chainHashes);
+    this.logger.log('Get NFTs: ', nfts);
+    return nfts;
+  }
+  async addNft(address, nft) {
+    this.logger.log(`Updating NFT for [${nft.chain}]`);
+    return this.stores.nft.upsert({
+      ...nft,
+      address
+    });
+  }
+  handleNftTransfer(chain, addresses, nftItem) {
+    return this.stores.nft.deleteNftByAddresses(chain, addresses, nftItem);
+  }
+  removeNfts(chain, address, collectionId, nftIds) {
+    this.logger.log(`Remove NFTs [${nftIds.join(', ')}]`);
+    return this.stores.nft.removeNfts(chain, address, collectionId, nftIds);
+  }
+
+  // Chain
+  async updateChainStore(item) {
+    this.logger.log(`Updating storageInfo for chain [${item.slug}]`);
+    return this.stores.chain.upsert(item);
+  }
+  async bulkUpdateChainStore(data) {
+    this.logger.log('Bulk updating ChainStore');
+    return this.stores.chain.bulkUpsert(data);
+  }
+  async removeFromChainStore(chains) {
+    this.logger.log('Bulk removing ChainStore');
+    return this.stores.chain.removeChains(chains);
+  }
+  async getAllChainStore() {
+    const allChains = await this.stores.chain.getAll();
+    this.logger.log('Get all chains: ', allChains);
+    return allChains;
+  }
+
+  // Asset
+  async updateAssetStore(item) {
+    this.logger.log(`Updating storageInfo for chainAsset [${item.originChain}]`);
+    return this.stores.asset.upsert(item);
+  }
+  async getAllAssetStore() {
+    const allAssets = await this.stores.asset.getAll();
+    this.logger.log('Get all stored assets: ', allAssets);
+    return allAssets;
+  }
+  async removeFromAssetStore(items) {
+    this.logger.log('Bulk removing AssetStore');
+    return this.stores.asset.removeAssets(items);
+  }
+
+  // Staking
+  async updateChainStakingMetadata(item) {
+    this.logger.log('Update ChainStakingMetadata: ', item.chain);
+    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) {
+    this.logger.log('Update NominatorMetadata: ', item.address, item.chain);
+    return this.stores.nominatorMetadata.upsert(item);
+  }
+  async getNominatorMetadata() {
+    return this.stores.nominatorMetadata.getAll();
+  }
+}
+exports.default = DatabaseService;

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

@@ -0,0 +1,47 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _dexie = _interopRequireDefault(require("dexie"));
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+const DEFAULT_DATABASE = 'SubWalletDB_v2';
+class KoniDatabase extends _dexie.default {
+  constructor() {
+    let name = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : DEFAULT_DATABASE;
+    let schemaVersion = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 9;
+    super(name);
+    this.schemaVersion = schemaVersion;
+    this.conditionalVersion(1, {
+      // DO NOT declare all columns, only declare properties to be indexed
+      // Read more: https://dexie.org/docs/Version/Version.stores()
+      // Primary key is always the first entry
+      chain: 'slug',
+      asset: 'slug',
+      price: 'currency',
+      balances: '[tokenSlug+address], tokenSlug, address',
+      nfts: '[chain+address+collectionId+id], [address+chain], chain, id, address, collectionId, name',
+      nftCollections: '[chain+collectionId], chain, collectionId, collectionName',
+      crowdloans: '[chain+address], chain, address',
+      stakings: '[chain+address+type], [chain+address], chain, address, type',
+      transactions: '[chain+address+extrinsicHash], &[chain+address+extrinsicHash], chain, address, extrinsicHash, action',
+      migrations: '[key+name]',
+      chainStakingMetadata: '[chain+type], chain, type',
+      nominatorMetadata: '[chain+address+type], [chain+address], chain, address, type'
+    });
+  }
+  conditionalVersion(version, schema, upgrade) {
+    if (this.schemaVersion != null && this.schemaVersion < version) {
+      return;
+    }
+    const dexieVersion = this.version(version).stores(schema);
+    if (upgrade != null) {
+      dexieVersion.upgrade(upgrade);
+    }
+  }
+}
+exports.default = KoniDatabase;