@subwallet/extension-base 1.0.2-1 → 1.0.2-1b

package/cjs/koni/api/tokens/wasm/utils.js

@@ -0,0 +1,63 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getDefaultWeightV2 = getDefaultWeightV2;
+exports.getWasmContractGasLimit = getWasmContractGasLimit;
+var _util = require("@polkadot/util");
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+const MAX_CALL_WEIGHT = '5000000000000';
+const DEFAULT_REF_TIME = '1000000000000';
+const toContractAbiMessage = (contractPromise, message) => {
+  const value = contractPromise.abi.messages.find(m => m.method === message);
+  if (!value) {
+    const messages = contractPromise === null || contractPromise === void 0 ? void 0 : contractPromise.abi.messages.map(m => m.method).join(', ');
+    const error = `"${message}" not found in metadata.spec.messages: [${messages}]`;
+    console.error(error);
+    return {
+      ok: false,
+      error
+    };
+  }
+  return {
+    ok: true,
+    value
+  };
+};
+async function getWasmContractGasLimit(api, callerAddress, message, contract) {
+  let options = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : {};
+  let args = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : [];
+  try {
+    var _abiMessage$value;
+    const abiMessage = toContractAbiMessage(contract, message);
+    if (!abiMessage.ok) {
+      return getDefaultWeightV2(api, true);
+    }
+
+    // @ts-ignore
+    const {
+      gasLimit,
+      storageDepositLimit,
+      value
+    } = options;
+
+    // @ts-ignore
+    const {
+      gasRequired
+    } = await api.call.contractsApi.call(callerAddress, contract.address, value !== null && value !== void 0 ? value : new _util.BN(0), gasLimit !== null && gasLimit !== void 0 ? gasLimit : null, storageDepositLimit !== null && storageDepositLimit !== void 0 ? storageDepositLimit : null, abiMessage === null || abiMessage === void 0 ? void 0 : (_abiMessage$value = abiMessage.value) === null || _abiMessage$value === void 0 ? void 0 : _abiMessage$value.toU8a(args));
+    return gasRequired;
+  } catch {
+    return getDefaultWeightV2(api, true);
+  }
+}
+function getDefaultWeightV2(apiPromise, isFallback) {
+  const proofSize = isFallback ? 3407872 : MAX_CALL_WEIGHT; // TODO: handle error better
+  const refTime = isFallback ? 32490000000 : DEFAULT_REF_TIME;
+  return apiPromise.registry.createType('WeightV2', {
+    refTime,
+    proofSize
+  });
+}

package/cjs/koni/api/xcm/polkadotXcm.js

@@ -42,7 +42,7 @@ function getAssetLocation(tokenInfo, sendingValue) {
   };
 }
 function getExtrinsicByPolkadotXcmPallet(tokenInfo, originChainInfo, destinationChainInfo, recipientAddress, value, api) {
-  const weightParam = _utils.NETWORK_USE_UNLIMITED_WEIGHT.includes(originChainInfo.slug) ? _utils.POLKADOT_UNLIMITED_WEIGHT : _utils.FOUR_INSTRUCTIONS_WEIGHT;
+  const weightParam = (0, _utils.getDestWeight)();
   const beneficiary = (0, _utils.getBeneficiary)(originChainInfo, destinationChainInfo, recipientAddress);
   const destination = getDestinationChainLocation(destinationChainInfo);
   const assetLocation = getAssetLocation(tokenInfo, value);

package/cjs/koni/api/xcm/utils.js

@@ -3,8 +3,9 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.POLKADOT_UNLIMITED_WEIGHT = exports.POLKADOT_LIMITED_WEIGHT = exports.NETWORK_USE_UNLIMITED_WEIGHT = exports.FOUR_INSTRUCTIONS_WEIGHT = void 0;
+exports.FOUR_INSTRUCTIONS_WEIGHT = exports.FOUR_INSTRUCTIONS_LIMITED_WEIGHT = void 0;
 exports.getBeneficiary = getBeneficiary;
+exports.getDestWeight = getDestWeight;
 exports.getReceiverLocation = getReceiverLocation;
 var _chainList = require("@subwallet/chain-list");
 var _utils = require("@subwallet/extension-base/services/chain-service/utils");
@@ -12,20 +13,18 @@ var _utilCrypto = require("@polkadot/util-crypto");
 // Copyright 2019-2022 @subwallet/extension-base
 // SPDX-License-Identifier: Apache-2.0
 
-const FOUR_INSTRUCTIONS_WEIGHT = {
+const FOUR_INSTRUCTIONS_WEIGHT = 5000000000;
+exports.FOUR_INSTRUCTIONS_WEIGHT = FOUR_INSTRUCTIONS_WEIGHT;
+const FOUR_INSTRUCTIONS_LIMITED_WEIGHT = {
   Limited: 5000000000
 };
-exports.FOUR_INSTRUCTIONS_WEIGHT = FOUR_INSTRUCTIONS_WEIGHT;
-const POLKADOT_LIMITED_WEIGHT = 1000000000;
-exports.POLKADOT_LIMITED_WEIGHT = POLKADOT_LIMITED_WEIGHT;
-const POLKADOT_UNLIMITED_WEIGHT = 'Unlimited';
 
 // get multilocation for destination chain from a parachain
-exports.POLKADOT_UNLIMITED_WEIGHT = POLKADOT_UNLIMITED_WEIGHT;
+exports.FOUR_INSTRUCTIONS_LIMITED_WEIGHT = FOUR_INSTRUCTIONS_LIMITED_WEIGHT;
 function getReceiverLocation(originChainInfo, destinationChainInfo, toAddress) {
-  // @ts-ignore
-  if (destinationChainInfo.slug === _chainList.COMMON_CHAIN_SLUGS.ASTAR_EVM || destinationChainInfo.slug === 'astarEvm') {
-    const ss58Address = (0, _utilCrypto.evmToAddress)(toAddress, (0, _utils._getChainSubstrateAddressPrefix)(destinationChainInfo));
+  if (destinationChainInfo.slug === _chainList.COMMON_CHAIN_SLUGS.ASTAR_EVM) {
+    const ss58Address = (0, _utilCrypto.evmToAddress)(toAddress, 2006); // TODO: shouldn't pass addressPrefix directly
+
     return {
       AccountId32: {
         network: 'Any',
@@ -49,9 +48,10 @@ function getReceiverLocation(originChainInfo, destinationChainInfo, toAddress) {
   };
 }
 function getBeneficiary(originChainInfo, destinationChainInfo, recipientAddress) {
+  let version = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 'V1';
   const receiverLocation = getReceiverLocation(originChainInfo, destinationChainInfo, recipientAddress);
   return {
-    V1: {
+    [version]: {
       parents: 0,
       interior: {
         X1: receiverLocation
@@ -59,5 +59,10 @@ function getBeneficiary(originChainInfo, destinationChainInfo, recipientAddress)
     }
   };
 }
-const NETWORK_USE_UNLIMITED_WEIGHT = ['acala', 'karura', 'statemint', 'moonriver'];
-exports.NETWORK_USE_UNLIMITED_WEIGHT = NETWORK_USE_UNLIMITED_WEIGHT;
+function getDestWeight() {
+  return 'Unlimited';
+  // return api.tx.xTokens.transfer.meta.args[3].type.toString() ===
+  // 'XcmV2WeightLimit'
+  //   ? 'Unlimited'
+  //   : FOUR_INSTRUCTIONS_WEIGHT;
+}

package/cjs/koni/api/xcm/xTokens.js

@@ -54,6 +54,6 @@ function getMultiLocationForXtokensPallet(originChainInfo, destinationChainInfo,
   };
 }
 function getExtrinsicByXtokensPallet(tokenInfo, originChainInfo, destinationChainInfo, recipientAddress, value, api) {
-  const weightParam = _utils.NETWORK_USE_UNLIMITED_WEIGHT.includes(originChainInfo.slug) ? _utils.POLKADOT_UNLIMITED_WEIGHT : _utils.FOUR_INSTRUCTIONS_WEIGHT;
+  const weightParam = ['pioneer'].includes(originChainInfo.slug) ? _utils.FOUR_INSTRUCTIONS_WEIGHT : (0, _utils.getDestWeight)();
   return api.tx.xTokens.transfer(getCurrencyId(tokenInfo), value, getMultiLocationForXtokensPallet(originChainInfo, destinationChainInfo, recipientAddress), weightParam);
 }

package/cjs/koni/api/xcm/xcmPallet.js

@@ -10,8 +10,9 @@ var _utils2 = require("@subwallet/extension-base/services/chain-service/utils");
 // SPDX-License-Identifier: Apache-2.0
 
 function getDestinationChainLocation(destinationChainInfo) {
+  let version = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'V1';
   return {
-    V1: {
+    [version]: {
       parents: 0,
       interior: {
         X1: {
@@ -22,9 +23,10 @@ function getDestinationChainLocation(destinationChainInfo) {
   };
 }
 function getTokenLocation(sendingValue) {
+  let version = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'V2';
   return {
     // always native token of relaychain
-    V1: [{
+    [version]: [{
       id: {
         Concrete: {
           parents: 0,
@@ -40,10 +42,11 @@ function getTokenLocation(sendingValue) {
 
 // this pallet is only used by Relaychains
 function getExtrinsicByXcmPalletPallet(tokenInfo, originChainInfo, destinationChainInfo, recipientAddress, value, api) {
-  const weightParam = _utils.NETWORK_USE_UNLIMITED_WEIGHT.includes(originChainInfo.slug) ? _utils.POLKADOT_UNLIMITED_WEIGHT : _utils.FOUR_INSTRUCTIONS_WEIGHT;
-  const destination = getDestinationChainLocation(destinationChainInfo);
-  const beneficiary = (0, _utils.getBeneficiary)(originChainInfo, destinationChainInfo, recipientAddress);
-  const tokenLocation = getTokenLocation(value);
+  const weightParam = (0, _utils.getDestWeight)();
+  const xcmVer = ['kusama'].includes(originChainInfo.slug) ? 'V2' : 'V1';
+  const destination = getDestinationChainLocation(destinationChainInfo, xcmVer);
+  const beneficiary = (0, _utils.getBeneficiary)(originChainInfo, destinationChainInfo, recipientAddress, xcmVer);
+  const tokenLocation = getTokenLocation(value, xcmVer);
   let method = 'limitedReserveTransferAssets';
   if (['statemint', 'statemine'].includes(destinationChainInfo.slug)) {
     method = 'limitedTeleportAssets';

package/cjs/koni/background/cron.js

@@ -5,6 +5,9 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.KoniCron = void 0;
 var _constants = require("@subwallet/extension-base/constants");
+var _types = require("@subwallet/extension-base/services/chain-service/types");
+var _utils = require("@subwallet/extension-base/services/chain-service/utils");
+var _utils2 = require("@subwallet/extension-base/utils");
 var _rxjs = require("rxjs");
 var _util = require("@polkadot/util");
 // Copyright 2019-2022 @subwallet/extension-koni authors & contributors
@@ -58,21 +61,26 @@ class KoniCron {
       delete this.cronMap[key];
     });
   };
-  init = () => {
-    const currentAccountInfo = this.state.keyringService.currentAccount;
-    if (!(currentAccountInfo !== null && currentAccountInfo !== void 0 && currentAccountInfo.address)) {
-      return;
-    }
-    if (Object.keys(this.state.getSubstrateApiMap()).length !== 0 || Object.keys(this.state.getEvmApiMap()).length !== 0) {
-      this.refreshNft(currentAccountInfo.address, this.state.getApiMap(), this.state.getSmartContractNfts(), this.state.getActiveChainInfoMap());
-      this.refreshStakingReward(currentAccountInfo.address);
-      this.refreshStakingRewardFastInterval(currentAccountInfo.address);
-      this.updateChainStakingMetadata(this.state.getChainInfoMap(), this.state.getChainStateMap(), this.state.getSubstrateApiMap());
-      this.updateNominatorMetadata(currentAccountInfo.address, this.state.getChainInfoMap(), this.state.getChainStateMap(), this.state.getSubstrateApiMap());
-    } else {
-      this.setStakingRewardReady();
-    }
-  };
+
+  // init = () => {
+  //   const currentAccountInfo = this.state.keyringService.currentAccount;
+  //
+  //   if (!currentAccountInfo?.address) {
+  //     return;
+  //   }
+  //
+  //   if (Object.keys(this.state.getSubstrateApiMap()).length !== 0 || Object.keys(this.state.getEvmApiMap()).length !== 0) {
+  //     this.refreshNft(currentAccountInfo.address, this.state.getApiMap(), this.state.getSmartContractNfts(), this.state.getActiveChainInfoMap());
+  //     this.updateApiMapStatus();
+  //     this.refreshStakingReward(currentAccountInfo.address);
+  //     this.refreshStakingRewardFastInterval(currentAccountInfo.address);
+  //     // this.updateChainStakingMetadata(this.state.getChainInfoMap(), this.state.getChainStateMap(), this.state.getSubstrateApiMap());
+  //     this.updateNominatorMetadata(currentAccountInfo.address, this.state.getChainInfoMap(), this.state.getChainStateMap(), this.state.getSubstrateApiMap());
+  //   } else {
+  //     this.setStakingRewardReady();
+  //   }
+  // };
+
   start = () => {
     if (this.status === 'running') {
       return;
@@ -85,6 +93,7 @@ class KoniCron {
     if (Object.keys(this.state.getSubstrateApiMap()).length !== 0 || Object.keys(this.state.getEvmApiMap()).length !== 0) {
       this.resetNft(currentAccountInfo.address);
       this.addCron('refreshNft', this.refreshNft(currentAccountInfo.address, this.state.getApiMap(), this.state.getSmartContractNfts(), this.state.getActiveChainInfoMap()), _constants.CRON_REFRESH_NFT_INTERVAL);
+      this.addCron('checkStatusApiMap', this.updateApiMapStatus, _constants.CRON_GET_API_MAP_STATUS);
       this.addCron('recoverApiMap', this.recoverApiMap, _constants.CRON_AUTO_RECOVER_DOTSAMA_INTERVAL, false);
       this.addCron('refreshStakingReward', this.refreshStakingReward(currentAccountInfo.address), _constants.CRON_REFRESH_STAKING_REWARD_INTERVAL);
       this.addCron('refreshPoolingStakingReward', this.refreshStakingRewardFastInterval(currentAccountInfo.address), _constants.CRON_REFRESH_STAKING_REWARD_FAST_INTERVAL);
@@ -93,46 +102,74 @@ class KoniCron {
     } else {
       this.setStakingRewardReady();
     }
-    const reloadEvents = ['account.add', 'account.remove', 'account.updateCurrent', 'chain.add', 'chain.update', 'chain.enable', 'asset.update', 'asset.enable', 'transaction.done', 'transaction.failed'];
-    this.state.eventService.onLazy((events, eventTypes) => {
+    const commonReloadEvents = ['account.add', 'account.remove', 'account.updateCurrent', 'chain.add', 'asset.updateState'];
+    this.eventHandler = (events, eventTypes) => {
       var _serviceInfo$currentA;
       const serviceInfo = this.state.getServiceInfo();
-      const needReload = eventTypes.some(eT => reloadEvents.includes(eT));
-      if (!needReload) {
+      const commonReload = eventTypes.some(eventType => commonReloadEvents.includes(eventType));
+      const chainUpdated = eventTypes.includes('chain.updateState');
+      const stakingSubmitted = eventTypes.includes('transaction.submitStaking');
+      const updatedChains = [];
+      if (chainUpdated) {
+        events.forEach(event => {
+          if (event.type === 'chain.updateState') {
+            const updatedData = event.data;
+            updatedChains.push(updatedData[0]);
+          }
+        });
+      }
+      if (!commonReload && !chainUpdated && !stakingSubmitted) {
         return;
       }
-      this.logger.log('ServiceInfo updated, restarting...');
+      this.logger.log('ServiceInfo updated, Cron restarting...', eventTypes);
       const address = (_serviceInfo$currentA = serviceInfo.currentAccountInfo) === null || _serviceInfo$currentA === void 0 ? void 0 : _serviceInfo$currentA.address;
       if (!address) {
         return;
       }
-      this.resetStakingReward();
-      this.resetNft(address);
-      this.removeCron('refreshNft');
-      this.removeCron('refreshStakingReward');
-      this.removeCron('refreshPoolingStakingReward');
-      this.removeCron('checkStatusApiMap');
-      this.removeCron('recoverApiMap');
-      this.removeCron('updateChainStakingMetadata');
-      this.removeCron('updateNominatorMetadata');
+      const chainInfoMap = serviceInfo.chainInfoMap;
+      const needUpdateNft = this.needUpdateNft(chainInfoMap, updatedChains);
+      const needUpdateStaking = this.needUpdateStaking(chainInfoMap, updatedChains);
+
+      // NFT
+      (commonReload || needUpdateNft) && this.resetNft(address);
+      (commonReload || needUpdateNft) && this.removeCron('refreshNft');
+
+      // Staking
+      (commonReload || needUpdateStaking || stakingSubmitted) && this.resetStakingReward();
+      (commonReload || needUpdateStaking || stakingSubmitted) && this.removeCron('refreshStakingReward');
+      (commonReload || needUpdateStaking || stakingSubmitted) && this.removeCron('refreshPoolingStakingReward');
+      (commonReload || needUpdateStaking || stakingSubmitted) && this.removeCron('updateNominatorMetadata');
+      needUpdateStaking && this.removeCron('updateChainStakingMetadata');
+
+      // Chains
+      chainUpdated && this.removeCron('checkStatusApiMap');
+      chainUpdated && this.removeCron('recoverApiMap');
       if (this.checkNetworkAvailable(serviceInfo)) {
         // only add cron job if there's at least 1 active network
-        this.addCron('refreshNft', this.refreshNft(address, serviceInfo.chainApiMap, this.state.getSmartContractNfts(), this.state.getActiveChainInfoMap()), _constants.CRON_REFRESH_NFT_INTERVAL);
-        this.addCron('recoverApiMap', this.recoverApiMap, _constants.CRON_AUTO_RECOVER_DOTSAMA_INTERVAL, false);
-        this.addCron('refreshStakingReward', this.refreshStakingReward(address), _constants.CRON_REFRESH_STAKING_REWARD_INTERVAL);
-        this.addCron('refreshPoolingStakingReward', this.refreshStakingRewardFastInterval(address), _constants.CRON_REFRESH_STAKING_REWARD_FAST_INTERVAL);
-        this.addCron('updateChainStakingMetadata', this.updateChainStakingMetadata(serviceInfo.chainInfoMap, serviceInfo.chainStateMap, serviceInfo.chainApiMap.substrate), _constants.CRON_REFRESH_CHAIN_STAKING_METADATA);
-        this.addCron('updateNominatorMetadata', this.updateNominatorMetadata(address, serviceInfo.chainInfoMap, serviceInfo.chainStateMap, serviceInfo.chainApiMap.substrate), _constants.CRON_REFRESH_CHAIN_NOMINATOR_METADATA);
+        (commonReload || needUpdateNft) && this.addCron('refreshNft', this.refreshNft(address, serviceInfo.chainApiMap, this.state.getSmartContractNfts(), this.state.getActiveChainInfoMap()), _constants.CRON_REFRESH_NFT_INTERVAL);
+        chainUpdated && this.addCron('checkStatusApiMap', this.updateApiMapStatus, _constants.CRON_GET_API_MAP_STATUS);
+        chainUpdated && this.addCron('recoverApiMap', this.recoverApiMap, _constants.CRON_AUTO_RECOVER_DOTSAMA_INTERVAL, false);
+        (commonReload || needUpdateStaking || stakingSubmitted) && this.addCron('refreshStakingReward', this.refreshStakingReward(address), _constants.CRON_REFRESH_STAKING_REWARD_INTERVAL);
+        (commonReload || needUpdateStaking || stakingSubmitted) && this.addCron('refreshPoolingStakingReward', this.refreshStakingRewardFastInterval(address), _constants.CRON_REFRESH_STAKING_REWARD_FAST_INTERVAL);
+        (commonReload || needUpdateStaking || stakingSubmitted) && this.addCron('updateNominatorMetadata', this.updateNominatorMetadata(address, serviceInfo.chainInfoMap, serviceInfo.chainStateMap, serviceInfo.chainApiMap.substrate), _constants.CRON_REFRESH_CHAIN_NOMINATOR_METADATA);
+        needUpdateStaking && this.addCron('updateChainStakingMetadata', this.updateChainStakingMetadata(serviceInfo.chainInfoMap, serviceInfo.chainStateMap, serviceInfo.chainApiMap.substrate), _constants.CRON_REFRESH_CHAIN_STAKING_METADATA);
       } else {
         this.setStakingRewardReady();
       }
-    });
+    };
+    this.state.eventService.onLazy(this.eventHandler);
     this.status = 'running';
   };
   stop = () => {
     if (this.status === 'stopped') {
       return;
     }
+
+    // Unsubscribe events
+    if (this.eventHandler) {
+      this.state.eventService.offLazy(this.eventHandler);
+      this.eventHandler = undefined;
+    }
     if (this.serviceSubscription) {
       this.serviceSubscription.unsubscribe();
       this.serviceSubscription = undefined;
@@ -141,6 +178,36 @@ class KoniCron {
     this.removeAllCrons();
     this.status = 'stopped';
   };
+  updateApiMapStatus = () => {
+    const apiMap = this.state.getApiMap();
+    const networkMap = this.state.getChainStateMap();
+    for (const [key, substrateApi] of Object.entries(apiMap.substrate)) {
+      let status = _types._ChainConnectionStatus.CONNECTING;
+      if (substrateApi.isApiConnected) {
+        status = _types._ChainConnectionStatus.CONNECTED;
+      }
+      if (!networkMap[key].connectionStatus) {
+        this.state.updateChainConnectionStatus(key, status);
+      } else if (networkMap[key].connectionStatus && networkMap[key].connectionStatus !== status) {
+        this.state.updateChainConnectionStatus(key, status);
+      }
+    }
+    for (const [key, evmApi] of Object.entries(apiMap.evm)) {
+      evmApi.api.eth.net.isListening().then(() => {
+        if (!networkMap[key].connectionStatus) {
+          this.state.updateChainConnectionStatus(key, _types._ChainConnectionStatus.CONNECTED);
+        } else if (networkMap[key].connectionStatus && networkMap[key].connectionStatus !== _types._ChainConnectionStatus.CONNECTED) {
+          this.state.updateChainConnectionStatus(key, _types._ChainConnectionStatus.CONNECTED);
+        }
+      }).catch(() => {
+        if (!networkMap[key].connectionStatus) {
+          this.state.updateChainConnectionStatus(key, _types._ChainConnectionStatus.CONNECTING);
+        } else if (networkMap[key].connectionStatus && networkMap[key].connectionStatus !== _types._ChainConnectionStatus.CONNECTING) {
+          this.state.updateChainConnectionStatus(key, _types._ChainConnectionStatus.CONNECTING);
+        }
+      });
+    }
+  };
   recoverApiMap = () => {
     var _this$subscriptions;
     const apiMap = this.state.getApiMap();
@@ -161,28 +228,26 @@ class KoniCron {
   };
   refreshNft = (address, apiMap, smartContractNfts, chainInfoMap) => {
     return () => {
-      this.logger.log('Refresh Nft state');
+      console.debug('Refresh NFT state');
       this.subscriptions.subscribeNft(address, apiMap.substrate, apiMap.evm, smartContractNfts, chainInfoMap);
     };
   };
   resetNft = newAddress => {
-    this.logger.log('Reset Nft state');
     this.state.resetNft(newAddress);
   };
   resetStakingReward = () => {
-    this.logger.log('Reset Staking Reward State');
     this.state.resetStakingReward();
   };
   refreshStakingReward = address => {
     return () => {
-      this.logger.log('Fetching staking reward data');
-      this.subscriptions.subscribeStakingReward(address).then(() => this.logger.log('Refresh staking reward state')).catch(this.logger.error);
+      console.debug('Refresh staking reward state');
+      this.subscriptions.subscribeStakingReward(address).catch(this.logger.error);
     };
   };
   refreshStakingRewardFastInterval = address => {
     return () => {
-      this.logger.log('Fetching staking reward data with fast interval');
-      this.subscriptions.subscribeStakingRewardFastInterval(address).then(() => this.logger.log('Refresh staking reward state with fast interval')).catch(this.logger.error);
+      console.debug('Refresh staking reward data with fast interval');
+      this.subscriptions.subscribeStakingRewardFastInterval(address).catch(this.logger.error);
     };
   };
   setStakingRewardReady = () => {
@@ -193,15 +258,53 @@ class KoniCron {
   };
   updateChainStakingMetadata = (chainInfoMap, chainStateMap, substrateApiMap) => {
     return () => {
-      this.logger.log('Fetching chain staking metadata');
-      this.subscriptions.fetchChainStakingMetadata(chainInfoMap, chainStateMap, substrateApiMap).then(() => this.logger.log('Updated chain staking metadata')).catch(this.logger.error);
+      console.debug('Fetching chain staking metadata');
+      this.subscriptions.fetchChainStakingMetadata(chainInfoMap, chainStateMap, substrateApiMap).catch(this.logger.error);
     };
   };
   updateNominatorMetadata = (address, chainInfoMap, chainStateMap, substrateApiMap) => {
     return () => {
-      this.logger.log('Fetching nominator data', address);
-      this.subscriptions.fetchNominatorMetadata(address, chainInfoMap, chainStateMap, substrateApiMap).then(() => this.logger.log('Updated nominator data', address)).catch(this.logger.error);
+      console.debug('Fetching nominator data for', address);
+      this.subscriptions.fetchNominatorMetadata(address, chainInfoMap, chainStateMap, substrateApiMap).catch(this.logger.error);
     };
   };
+  async reloadNft() {
+    const address = this.state.keyringService.currentAccount.address;
+    const serviceInfo = this.state.getServiceInfo();
+    console.debug('Hard refresh NFT for', address);
+    this.resetNft(address);
+    this.removeCron('refreshNft');
+    this.addCron('refreshNft', this.refreshNft(address, serviceInfo.chainApiMap, this.state.getSmartContractNfts(), this.state.getActiveChainInfoMap()), _constants.CRON_REFRESH_NFT_INTERVAL);
+    await (0, _utils2.waitTimeout)(1800);
+    return true;
+  }
+  async reloadStaking() {
+    const address = this.state.keyringService.currentAccount.address;
+    console.debug('Hard refresh staking meta for', address);
+    this.resetStakingReward();
+    this.removeCron('refreshStakingReward');
+    this.removeCron('refreshPoolingStakingReward');
+    this.removeCron('updateNominatorMetadata');
+    this.addCron('refreshStakingReward', this.refreshStakingReward(address), _constants.CRON_REFRESH_STAKING_REWARD_INTERVAL);
+    this.addCron('refreshPoolingStakingReward', this.refreshStakingRewardFastInterval(address), _constants.CRON_REFRESH_STAKING_REWARD_FAST_INTERVAL);
+    this.addCron('updateNominatorMetadata', this.updateNominatorMetadata(address, this.state.getChainInfoMap(), this.state.getChainStateMap(), this.state.getSubstrateApiMap()), _constants.CRON_REFRESH_CHAIN_NOMINATOR_METADATA);
+    await (0, _utils2.waitTimeout)(1800);
+    return true;
+  }
+  needUpdateNft(chainInfoMap, updatedChains) {
+    if (updatedChains && updatedChains.length > 0) {
+      return updatedChains.some(updatedChain => {
+        const chainInfo = chainInfoMap[updatedChain];
+        return (0, _utils._isChainSupportNativeNft)(chainInfo) || (0, _utils._isChainSupportEvmNft)(chainInfo) || (0, _utils._isChainSupportWasmNft)(chainInfo);
+      });
+    }
+    return false;
+  }
+  needUpdateStaking(chainInfoMap, updatedChains) {
+    if (updatedChains && updatedChains.length > 0) {
+      return updatedChains.some(updatedChain => (0, _utils._isChainSupportSubstrateStaking)(chainInfoMap[updatedChain]));
+    }
+    return false;
+  }
 }
 exports.KoniCron = KoniCron;