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

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

@@ -1,241 +0,0 @@
-"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;

package/cjs/types.js

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

package/cjs/utils/address.js

@@ -1,34 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.convertSubjectInfoToAddresses = void 0;
-exports.quickFormatAddressToCompare = quickFormatAddressToCompare;
-exports.simpleAddress = void 0;
-var _index = require("@subwallet/extension-base/utils/index");
-var _utilCrypto = require("@polkadot/util-crypto");
-// Copyright 2019-2022 @subwallet/extension-base authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-const simpleAddress = address => {
-  if ((0, _utilCrypto.isEthereumAddress)(address)) {
-    return address;
-  }
-  return (0, _utilCrypto.encodeAddress)((0, _utilCrypto.decodeAddress)(address));
-};
-exports.simpleAddress = simpleAddress;
-function quickFormatAddressToCompare(address) {
-  if (!(0, _utilCrypto.isAddress)(address)) {
-    return address;
-  }
-  return (0, _index.reformatAddress)(address, 42).toLowerCase();
-}
-const convertSubjectInfoToAddresses = subjectInfo => {
-  return Object.values(subjectInfo).map(info => ({
-    address: info.json.address,
-    type: info.type,
-    ...info.json.meta
-  }));
-};
-exports.convertSubjectInfoToAddresses = convertSubjectInfoToAddresses;

package/cjs/utils/keyring.js

@@ -1,57 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.extractPrivateKey = extractPrivateKey;
-exports.unlockAccount = exports.lockAccount = void 0;
-var _uiKeyring = require("@subwallet/ui-keyring");
-// Copyright 2019-2022 @subwallet/extension-base
-// SPDX-License-Identifier: Apache-2.0
-
-// import _decode from '@polkadot/keyring/pair/decode';
-
-function extract(address) {
-  // @ts-ignore
-  // eslint-disable-next-line @typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-member-access,@typescript-eslint/no-unsafe-assignment
-  const rs = this.getPair(address);
-
-  // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-  console.log(rs.publicKey);
-}
-function extractPrivateKey(keyring, address, password) {
-  extract.call(keyring, address);
-}
-const unlockAccount = signAddress => {
-  let publicKey;
-  try {
-    publicKey = _uiKeyring.keyring.decodeAddress(signAddress);
-  } catch (error) {
-    console.error(error);
-    return 'Unable to decode address';
-  }
-  const pair = _uiKeyring.keyring.getPair(publicKey);
-  if (!pair) {
-    return 'Unable to find pair';
-  }
-  if (pair.isLocked) {
-    try {
-      _uiKeyring.keyring.unlockPair(pair.address);
-    } catch (e) {
-      return e.message;
-    }
-  }
-  return null;
-};
-exports.unlockAccount = unlockAccount;
-const lockAccount = address => {
-  try {
-    const pair = _uiKeyring.keyring.getPair(address);
-    if (pair) {
-      pair.lock();
-    }
-  } catch (error) {
-    console.error('Unable to lock account', error);
-  }
-};
-exports.lockAccount = lockAccount;