@subwallet/extension-base 0.8.3-2 → 1.0.1

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

@@ -0,0 +1,213 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.substrateEstimateCrossChainFee = substrateEstimateCrossChainFee;
+exports.substrateGetXcmExtrinsic = substrateGetXcmExtrinsic;
+var _utils = require("@subwallet/extension-base/koni/api/xcm/utils");
+var _constants = require("@subwallet/extension-base/services/chain-service/constants");
+var _utils2 = require("@subwallet/extension-base/services/chain-service/utils");
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+const NETWORK_USE_UNLIMITED_WEIGHT = ['acala', 'karura', 'statemint'];
+
+// function getTokenIdentity (originNetworkKey: string, tokenInfo: TokenInfo) {
+//   // TODO: find a better way to handle kUSD on karura
+//   const tokenSymbol = tokenInfo.symbol.toUpperCase() === 'AUSD' && originNetworkKey === 'karura' ? 'KUSD' : tokenInfo.symbol.toUpperCase();
+//
+//   if (originNetworkKey === 'bifrost') {
+//     return tokenInfo.specialOption as Record<string, any>;
+//   } else if (originNetworkKey === 'pioneer' && tokenSymbol.toUpperCase() === 'NEER') {
+//     return {
+//       NativeToken: 0
+//     };
+//   } else if (originNetworkKey === 'karura' && tokenSymbol.toUpperCase() === 'NEER') { // TODO: modify later with different assets on Karura
+//     return tokenInfo.specialOption as Record<string, any>;
+//   } else if (originNetworkKey === 'acala' && tokenSymbol.toUpperCase() === 'GLMR') { // TODO: modify later with different assets on Acala
+//     return tokenInfo.specialOption as Record<string, any>;
+//   }
+//
+//   return {
+//     Token: tokenSymbol
+//   };
+// }
+
+async function substrateEstimateCrossChainFee(originNetworkKey, destinationNetworkKey, recipient, sender, sendingValue, substrateApiMap, originTokenInfo, chainInfoMap) {
+  const substrateApi = await substrateApiMap[originNetworkKey].isReady;
+  const api = substrateApi.api;
+  let fee = '0';
+  const originChainInfo = chainInfoMap[originNetworkKey];
+  const destinationChainInfo = chainInfoMap[destinationNetworkKey];
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+  const tokenIdentity = (0, _utils2._getXcmAssetMultilocation)(originTokenInfo);
+  const weightParam = _constants._XCM_CHAIN_USE_LIMITED_WEIGHT.includes(originNetworkKey) ? _utils.POLKADOT_UNLIMITED_WEIGHT : _utils.FOUR_INSTRUCTIONS_WEIGHT;
+  try {
+    if ((0, _utils2._isSubstrateParaChain)(originChainInfo)) {
+      // Case ParaChain -> ParaChain && ParaChain -> RelayChain
+      const extrinsic = api.tx.xTokens.transfer(tokenIdentity, sendingValue, (0, _utils.getMultiLocationFromParachain)(originNetworkKey, destinationNetworkKey, chainInfoMap, recipient), weightParam);
+      try {
+        const paymentInfo = await extrinsic.paymentInfo(sender.address);
+        fee = paymentInfo.partialFee.toString();
+      } catch (e) {
+        console.error(e);
+      }
+      console.log('substrate xcm tx p-p or p-r here', extrinsic.toHex());
+    } else {
+      // Case RelayChain -> ParaChain
+      const receiverLocation = (0, _utils.getReceiverLocation)(originNetworkKey, destinationNetworkKey, chainInfoMap, recipient);
+      if (_constants._XCM_CHAIN_GROUP.statemine.includes(destinationNetworkKey)) {
+        const extrinsic = api.tx.xcmPallet.limitedTeleportAssets({
+          V1: {
+            parents: 0,
+            interior: {
+              X1: {
+                Parachain: (0, _utils2._getSubstrateParaId)(destinationChainInfo)
+              }
+            }
+          }
+        }, {
+          V1: {
+            parents: 0,
+            interior: {
+              X1: receiverLocation
+            }
+          }
+        }, {
+          V1: [{
+            id: {
+              Concrete: {
+                parents: 0,
+                interior: 'Here'
+              }
+            },
+            fun: {
+              Fungible: sendingValue
+            }
+          }]
+        }, 0, _utils.POLKADOT_UNLIMITED_WEIGHT);
+        const paymentInfo = await extrinsic.paymentInfo(sender);
+        fee = paymentInfo.partialFee.toString();
+        console.log('substrate xcm teleport asset tx r-p here', extrinsic.toHex());
+      } else {
+        const extrinsic = api.tx.xcmPallet.reserveTransferAssets({
+          V1: {
+            // find the destination chain
+            parents: 0,
+            interior: {
+              X1: {
+                Parachain: (0, _utils2._getSubstrateParaId)(destinationChainInfo)
+              }
+            }
+          }
+        }, {
+          V1: {
+            // find the receiver
+            parents: 0,
+            interior: {
+              X1: receiverLocation
+            }
+          }
+        }, {
+          V1: [
+          // find the asset
+          {
+            id: {
+              Concrete: {
+                parents: 0,
+                interior: 'Here'
+              }
+            },
+            fun: {
+              Fungible: sendingValue
+            }
+          }]
+        }, 0);
+        const paymentInfo = await extrinsic.paymentInfo(sender);
+        fee = paymentInfo.partialFee.toString();
+        console.log('substrate xcm reserve transfer tx r-p here', extrinsic.toHex());
+      }
+    }
+  } catch (e) {
+    console.error('error parsing xcm transaction', e);
+  }
+  return fee;
+}
+function substrateGetXcmExtrinsic(originNetworkKey, destinationNetworkKey, recipient, sendingValue, api, originTokenInfo, chainInfoMap) {
+  // Case ParaChain -> RelayChain && Parachain -> Parachain
+  if ((0, _utils2._isSubstrateParaChain)(chainInfoMap[originNetworkKey])) {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+    const tokenIdentity = (0, _utils2._getXcmAssetMultilocation)(originTokenInfo);
+    const weightParam = NETWORK_USE_UNLIMITED_WEIGHT.includes(originNetworkKey) ? _utils.POLKADOT_UNLIMITED_WEIGHT : _utils.FOUR_INSTRUCTIONS_WEIGHT;
+    return api.tx.xTokens.transfer(tokenIdentity, sendingValue, (0, _utils.getMultiLocationFromParachain)(originNetworkKey, destinationNetworkKey, chainInfoMap, recipient), weightParam);
+  }
+
+  // Case RelayChain -> Parachain
+  const destinationChainInfo = chainInfoMap[destinationNetworkKey];
+  const receiverLocation = (0, _utils.getReceiverLocation)(originNetworkKey, destinationNetworkKey, chainInfoMap, recipient);
+  if (_constants._XCM_CHAIN_GROUP.statemine.includes(destinationNetworkKey)) {
+    return api.tx.xcmPallet.limitedTeleportAssets({
+      V1: {
+        parents: 0,
+        interior: {
+          X1: {
+            Parachain: (0, _utils2._getSubstrateParaId)(destinationChainInfo)
+          }
+        }
+      }
+    }, {
+      V1: {
+        parents: 0,
+        interior: {
+          X1: receiverLocation
+        }
+      }
+    }, {
+      V1: [{
+        id: {
+          Concrete: {
+            parents: 0,
+            interior: 'Here'
+          }
+        },
+        fun: {
+          Fungible: sendingValue
+        }
+      }]
+    }, 0, _utils.POLKADOT_UNLIMITED_WEIGHT);
+  }
+  return api.tx.xcmPallet.reserveTransferAssets({
+    V1: {
+      // find the destination chain
+      parents: 0,
+      interior: {
+        X1: {
+          Parachain: (0, _utils2._getSubstrateParaId)(destinationChainInfo)
+        }
+      }
+    }
+  }, {
+    V1: {
+      // find the receiver
+      parents: 0,
+      interior: {
+        X1: receiverLocation
+      }
+    }
+  }, {
+    V1: [
+    // find the asset
+    {
+      id: {
+        Concrete: {
+          parents: 0,
+          interior: 'Here'
+        }
+      },
+      fun: {
+        Fungible: sendingValue
+      }
+    }]
+  }, 0);
+}

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

@@ -0,0 +1,63 @@
+"use strict";
+
+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.getBeneficiary = getBeneficiary;
+exports.getReceiverLocation = getReceiverLocation;
+var _chainList = require("@subwallet/chain-list");
+var _utils = require("@subwallet/extension-base/services/chain-service/utils");
+var _utilCrypto = require("@polkadot/util-crypto");
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+const FOUR_INSTRUCTIONS_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;
+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));
+    return {
+      AccountId32: {
+        network: 'Any',
+        id: (0, _utilCrypto.decodeAddress)(ss58Address)
+      }
+    };
+  }
+  if ((0, _utils._isChainEvmCompatible)(destinationChainInfo)) {
+    return {
+      AccountKey20: {
+        network: 'Any',
+        key: toAddress
+      }
+    };
+  }
+  return {
+    AccountId32: {
+      network: 'Any',
+      id: (0, _utilCrypto.decodeAddress)(toAddress)
+    }
+  };
+}
+function getBeneficiary(originChainInfo, destinationChainInfo, recipientAddress) {
+  const receiverLocation = getReceiverLocation(originChainInfo, destinationChainInfo, recipientAddress);
+  return {
+    V1: {
+      parents: 0,
+      interior: {
+        X1: receiverLocation
+      }
+    }
+  };
+}
+const NETWORK_USE_UNLIMITED_WEIGHT = ['acala', 'karura', 'statemint', 'moonriver'];
+exports.NETWORK_USE_UNLIMITED_WEIGHT = NETWORK_USE_UNLIMITED_WEIGHT;

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

@@ -0,0 +1,61 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getExtrinsicByXtokensPallet = getExtrinsicByXtokensPallet;
+var _utils = require("@subwallet/extension-base/koni/api/xcm/utils");
+var _constants = require("@subwallet/extension-base/services/chain-service/constants");
+var _utils2 = require("@subwallet/extension-base/services/chain-service/utils");
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+function getCurrencyId(tokenInfo) {
+  var _tokenInfo$metadata2;
+  if (['acala', 'karura'].includes(tokenInfo.originChain) && (0, _utils2._isNativeToken)(tokenInfo)) {
+    return (0, _utils2._getXcmAssetMultilocation)(tokenInfo);
+  } else if (['moonbeam', 'moonbase', 'moonriver'].includes(tokenInfo.originChain)) {
+    const tokenType = (0, _utils2._getXcmAssetType)(tokenInfo);
+    const assetId = (0, _utils2._getXcmAssetId)(tokenInfo);
+    return {
+      [tokenType]: assetId
+    };
+  } else if (['pioneer'].includes(tokenInfo.originChain)) {
+    var _tokenInfo$metadata;
+    return (_tokenInfo$metadata = tokenInfo.metadata) === null || _tokenInfo$metadata === void 0 ? void 0 : _tokenInfo$metadata.multilocation;
+  }
+  return (_tokenInfo$metadata2 = tokenInfo.metadata) === null || _tokenInfo$metadata2 === void 0 ? void 0 : _tokenInfo$metadata2.onChainInfo;
+}
+function getMultiLocationForXtokensPallet(originChainInfo, destinationChainInfo, toAddress) {
+  const xcmType = (0, _utils2._getXcmTransferType)(originChainInfo, destinationChainInfo);
+  const paraId = (0, _utils2._getSubstrateParaId)(destinationChainInfo);
+  const receiverLocation = (0, _utils.getReceiverLocation)(originChainInfo, destinationChainInfo, toAddress);
+  if (xcmType === _constants._XCM_TYPE.PP) {
+    // parachain -> parachain
+    const interior = {
+      X2: [{
+        Parachain: paraId
+      }, receiverLocation]
+    };
+    return {
+      V1: {
+        parents: 1,
+        interior
+      }
+    };
+  }
+
+  // parachain -> relaychain by default
+  return {
+    V1: {
+      parents: 1,
+      interior: {
+        X1: receiverLocation
+      }
+    }
+  };
+}
+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;
+  return api.tx.xTokens.transfer(getCurrencyId(tokenInfo), value, getMultiLocationForXtokensPallet(originChainInfo, destinationChainInfo, recipientAddress), weightParam);
+}

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

@@ -0,0 +1,52 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getExtrinsicByXcmPalletPallet = getExtrinsicByXcmPalletPallet;
+var _utils = require("@subwallet/extension-base/koni/api/xcm/utils");
+var _utils2 = require("@subwallet/extension-base/services/chain-service/utils");
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+function getDestinationChainLocation(destinationChainInfo) {
+  return {
+    V1: {
+      parents: 0,
+      interior: {
+        X1: {
+          Parachain: (0, _utils2._getSubstrateParaId)(destinationChainInfo)
+        }
+      }
+    }
+  };
+}
+function getTokenLocation(sendingValue) {
+  return {
+    // always native token of relaychain
+    V1: [{
+      id: {
+        Concrete: {
+          parents: 0,
+          interior: 'Here'
+        }
+      },
+      fun: {
+        Fungible: 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);
+  let method = 'limitedReserveTransferAssets';
+  if (['statemint', 'statemine'].includes(destinationChainInfo.slug)) {
+    method = 'limitedTeleportAssets';
+  }
+  return api.tx.xcmPallet[method](destination, beneficiary, tokenLocation, 0, weightParam);
+}

package/cjs/koni/background/cron.js

@@ -0,0 +1,208 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.KoniCron = void 0;
+var _constants = require("@subwallet/extension-base/constants");
+var _rxjs = require("rxjs");
+var _util = require("@polkadot/util");
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+class KoniCron {
+  status = 'pending';
+  constructor(state, subscriptions, dbService) {
+    this.subscriptions = subscriptions;
+    this.dbService = dbService;
+    this.state = state;
+    this.logger = (0, _util.logger)('Cron');
+    // this.init();
+  }
+
+  cronMap = {};
+  subjectMap = {};
+  getCron = name => {
+    return this.cronMap[name];
+  };
+  getSubjectMap = name => {
+    return this.subjectMap[name];
+  };
+  addCron = (() => {
+    var _this = this;
+    return function (name, callback, interval) {
+      let runFirst = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : true;
+      if (runFirst) {
+        callback();
+      }
+      _this.cronMap[name] = setInterval(callback, interval);
+    };
+  })();
+  addSubscribeCron = (name, callback, interval) => {
+    const sb = new _rxjs.Subject();
+    callback(sb);
+    this.subjectMap[name] = sb;
+    this.cronMap[name] = setInterval(callback, interval);
+  };
+  removeCron = name => {
+    const interval = this.cronMap[name];
+    if (interval) {
+      clearInterval(interval);
+      delete this.cronMap[name];
+    }
+  };
+  removeAllCrons = () => {
+    Object.entries(this.cronMap).forEach(_ref => {
+      let [key, interval] = _ref;
+      clearInterval(interval);
+      delete this.cronMap[key];
+    });
+  };
+  init = () => {
+    this.state.getCurrentAccount(currentAccountInfo => {
+      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();
+      }
+    });
+  };
+  start = () => {
+    if (this.status === 'running') {
+      return;
+    }
+    this.logger.log('Starting cron jobs');
+    this.state.getCurrentAccount(currentAccountInfo => {
+      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.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('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);
+        this.addCron('updateChainStakingMetadata', this.updateChainStakingMetadata(this.state.getChainInfoMap(), this.state.getChainStateMap(), this.state.getSubstrateApiMap()), _constants.CRON_REFRESH_CHAIN_STAKING_METADATA);
+        this.addCron('updateNominatorMetadata', this.updateNominatorMetadata(currentAccountInfo.address, this.state.getChainInfoMap(), this.state.getChainStateMap(), this.state.getSubstrateApiMap()), _constants.CRON_REFRESH_CHAIN_NOMINATOR_METADATA);
+      } else {
+        this.setStakingRewardReady();
+      }
+    });
+    this.serviceSubscription = this.state.subscribeServiceInfo().subscribe({
+      next: serviceInfo => {
+        var _serviceInfo$currentA;
+        this.logger.log('ServiceInfo updated, restarting...');
+        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('refreshPrice');
+        this.removeCron('checkStatusApiMap');
+        this.removeCron('recoverApiMap');
+        this.removeCron('updateChainStakingMetadata');
+        this.removeCron('updateNominatorMetadata');
+        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);
+        } else {
+          this.setStakingRewardReady();
+        }
+      }
+    });
+    this.status = 'running';
+  };
+  stop = () => {
+    if (this.status === 'stopped') {
+      return;
+    }
+    if (this.serviceSubscription) {
+      this.serviceSubscription.unsubscribe();
+      this.serviceSubscription = undefined;
+    }
+    this.logger.log('Stopping cron jobs');
+    this.removeAllCrons();
+    this.status = 'stopped';
+  };
+  recoverApiMap = () => {
+    const apiMap = this.state.getApiMap();
+    for (const [networkKey, apiProp] of Object.entries(apiMap.substrate)) {
+      if (!apiProp.isApiConnected) {
+        this.state.refreshSubstrateApi(networkKey);
+      }
+    }
+    for (const [key, evmApi] of Object.entries(apiMap.evm)) {
+      evmApi.api.eth.net.isListening().catch(() => {
+        this.state.refreshWeb3Api(key);
+      });
+    }
+    this.state.getCurrentAccount(_ref2 => {
+      var _this$subscriptions;
+      let {
+        address
+      } = _ref2;
+      ((_this$subscriptions = this.subscriptions) === null || _this$subscriptions === void 0 ? void 0 : _this$subscriptions.subscribeBalancesAndCrowdloans) && this.subscriptions.subscribeBalancesAndCrowdloans(address, this.state.getChainInfoMap(), this.state.getChainStateMap(), this.state.getSubstrateApiMap(), this.state.getEvmApiMap());
+    });
+  };
+  refreshNft = (address, apiMap, smartContractNfts, chainInfoMap) => {
+    return () => {
+      this.logger.log('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).catch(e => this.logger.warn(e));
+  };
+  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);
+    };
+  };
+  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);
+    };
+  };
+  setStakingRewardReady = () => {
+    this.state.updateStakingRewardReady(true);
+  };
+  checkNetworkAvailable = serviceInfo => {
+    return Object.keys(serviceInfo.chainApiMap.substrate).length > 0 || Object.keys(serviceInfo.chainApiMap.evm).length > 0;
+  };
+  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);
+    };
+  };
+  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);
+    };
+  };
+}
+exports.KoniCron = KoniCron;

package/cjs/koni/background/events.js

@@ -0,0 +1,14 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.onExtensionInstall = void 0;
+var _handlers = require("@subwallet/extension-base/koni/background/handlers");
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+const onExtensionInstall = () => {
+  _handlers.state.onInstall();
+};
+exports.onExtensionInstall = onExtensionInstall;