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

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;

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

@@ -252,5 +252,21 @@ class SubscanService {
     await _getTransferItems(0);
     return resultMap;
   }
+  getRewardHistoryList(chain, address) {
+    let page = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
+    return this.addRequest(async () => {
+      const rs = await this.postRequest(this.getApiUrl(chain, 'api/scan/account/reward_slash'), {
+        page,
+        category: 'Reward',
+        row: 10,
+        address
+      });
+      if (rs.status !== 200) {
+        throw new _SWError.SWError('SubscanService.getRewardHistoryList', await rs.text());
+      }
+      const jsonData = await rs.json();
+      return jsonData.data;
+    });
+  }
 }
 exports.SubscanService = SubscanService;

package/cjs/services/transaction-service/event-parser/index.js

@@ -3,8 +3,11 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+exports.parseLiquidStakingEvents = parseLiquidStakingEvents;
+exports.parseLiquidStakingFastUnstakeEvents = parseLiquidStakingFastUnstakeEvents;
 exports.parseTransferEventLogs = parseTransferEventLogs;
 exports.parseXcmEventLogs = parseXcmEventLogs;
+var _KoniTypes = require("@subwallet/extension-base/background/KoniTypes");
 var _utils = require("@subwallet/extension-base/services/chain-service/utils");
 // Copyright 2019-2022 @subwallet/extension-base authors & contributors
 // SPDX-License-Identifier: Apache-2.0
@@ -72,4 +75,59 @@ function parseTransferEventLogs(historyItem, eventLogs, chain, sendingTokenInfo,
       }
     }
   }
+}
+function parseLiquidStakingEvents(historyItem, eventLogs, inputTokenInfo, chainInfo, feePaidWithInputAsset, extrinsicType) {
+  if (feePaidWithInputAsset) {
+    historyItem.fee = {
+      value: '0',
+      // TODO
+      symbol: (0, _utils._getAssetSymbol)(inputTokenInfo),
+      decimals: (0, _utils._getAssetDecimals)(inputTokenInfo)
+    };
+  } else {
+    for (let index = 0; index < eventLogs.length; index++) {
+      const record = eventLogs[index];
+      const {
+        decimals: nativeDecimals,
+        symbol: nativeSymbol
+      } = (0, _utils._getChainNativeTokenBasicInfo)(chainInfo);
+      const section = extrinsicType === _KoniTypes.ExtrinsicType.REDEEM_QDOT ? 'tokens' : 'balances';
+      const eventMethod = extrinsicType === _KoniTypes.ExtrinsicType.REDEEM_QDOT ? 'withdrawn' : 'withdraw';
+      if (record.event.section === section && record.event.method.toLowerCase() === eventMethod) {
+        var _record$event$data$9;
+        if ((_record$event$data$9 = record.event.data[2]) !== null && _record$event$data$9 !== void 0 && _record$event$data$9.toString()) {
+          var _record$event$data$10;
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+          historyItem.fee = {
+            value: ((_record$event$data$10 = record.event.data[2]) === null || _record$event$data$10 === void 0 ? void 0 : _record$event$data$10.toString()) || '0',
+            symbol: nativeSymbol,
+            decimals: nativeDecimals
+          };
+        }
+      }
+    }
+  }
+}
+function parseLiquidStakingFastUnstakeEvents(historyItem, eventLogs, chainInfo, extrinsicType) {
+  for (let index = 0; index < eventLogs.length; index++) {
+    const record = eventLogs[index];
+    const {
+      decimals: nativeDecimals,
+      symbol: nativeSymbol
+    } = (0, _utils._getChainNativeTokenBasicInfo)(chainInfo);
+    const section = extrinsicType === _KoniTypes.ExtrinsicType.REDEEM_QDOT ? 'tokens' : 'balances';
+    const eventMethod = extrinsicType === _KoniTypes.ExtrinsicType.REDEEM_QDOT ? 'withdrawn' : 'withdraw';
+    if (record.event.section === section && record.event.method.toLowerCase() === eventMethod) {
+      var _record$event$data$11;
+      if ((_record$event$data$11 = record.event.data[2]) !== null && _record$event$data$11 !== void 0 && _record$event$data$11.toString()) {
+        var _record$event$data$12;
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+        historyItem.fee = {
+          value: ((_record$event$data$12 = record.event.data[2]) === null || _record$event$data$12 === void 0 ? void 0 : _record$event$data$12.toString()) || '0',
+          symbol: nativeSymbol,
+          decimals: nativeDecimals
+        };
+      }
+    }
+  }
 }

package/cjs/services/transaction-service/helpers/index.js

@@ -40,7 +40,7 @@ const typeName = type => {
     case _KoniTypes.ExtrinsicType.STAKING_BOND:
       return 'Bond';
     case _KoniTypes.ExtrinsicType.STAKING_UNBOND:
-      return 'Unbond';
+      return 'Unstake';
     case _KoniTypes.ExtrinsicType.STAKING_CLAIM_REWARD:
       return 'Claim reward';
     case _KoniTypes.ExtrinsicType.STAKING_WITHDRAW:
@@ -55,6 +55,8 @@ const typeName = type => {
       return 'Cancel compounding';
     case _KoniTypes.ExtrinsicType.STAKING_POOL_WITHDRAW:
       return 'Withdraw pool';
+    case _KoniTypes.ExtrinsicType.JOIN_YIELD_POOL:
+      return 'Start earning';
     case _KoniTypes.ExtrinsicType.UNKNOWN:
     default:
       return 'unknown';