@subwallet/extension-base 0.7.10-0 → 0.8.1-wr2x

package/koni/api/xcm/substrateXcm.js

@@ -0,0 +1,206 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+import { FOUR_INSTRUCTIONS_WEIGHT, getMultiLocationFromParachain, getReceiverLocation, POLKADOT_UNLIMITED_WEIGHT } from '@subwallet/extension-base/koni/api/xcm/utils';
+import { _XCM_CHAIN_GROUP, _XCM_CHAIN_USE_LIMITED_WEIGHT } from '@subwallet/extension-base/services/chain-service/constants';
+import { _getSubstrateParaId, _getXcmAssetMultilocation, _isSubstrateParaChain } from '@subwallet/extension-base/services/chain-service/utils';
+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
+//   };
+// }
+
+export 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 = _getXcmAssetMultilocation(originTokenInfo);
+  const weightParam = _XCM_CHAIN_USE_LIMITED_WEIGHT.includes(originNetworkKey) ? POLKADOT_UNLIMITED_WEIGHT : FOUR_INSTRUCTIONS_WEIGHT;
+  try {
+    if (_isSubstrateParaChain(originChainInfo)) {
+      // Case ParaChain -> ParaChain && ParaChain -> RelayChain
+      const extrinsic = api.tx.xTokens.transfer(tokenIdentity, sendingValue, 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 = getReceiverLocation(originNetworkKey, destinationNetworkKey, chainInfoMap, recipient);
+      if (_XCM_CHAIN_GROUP.statemine.includes(destinationNetworkKey)) {
+        const extrinsic = api.tx.xcmPallet.limitedTeleportAssets({
+          V1: {
+            parents: 0,
+            interior: {
+              X1: {
+                Parachain: _getSubstrateParaId(destinationChainInfo)
+              }
+            }
+          }
+        }, {
+          V1: {
+            parents: 0,
+            interior: {
+              X1: receiverLocation
+            }
+          }
+        }, {
+          V1: [{
+            id: {
+              Concrete: {
+                parents: 0,
+                interior: 'Here'
+              }
+            },
+            fun: {
+              Fungible: sendingValue
+            }
+          }]
+        }, 0, 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: _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;
+}
+export function substrateGetXcmExtrinsic(originNetworkKey, destinationNetworkKey, recipient, sendingValue, api, originTokenInfo, chainInfoMap) {
+  // Case ParaChain -> RelayChain && Parachain -> Parachain
+  if (_isSubstrateParaChain(chainInfoMap[originNetworkKey])) {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+    const tokenIdentity = _getXcmAssetMultilocation(originTokenInfo);
+    const weightParam = NETWORK_USE_UNLIMITED_WEIGHT.includes(originNetworkKey) ? POLKADOT_UNLIMITED_WEIGHT : FOUR_INSTRUCTIONS_WEIGHT;
+    return api.tx.xTokens.transfer(tokenIdentity, sendingValue, getMultiLocationFromParachain(originNetworkKey, destinationNetworkKey, chainInfoMap, recipient), weightParam);
+  }
+
+  // Case RelayChain -> Parachain
+  const destinationChainInfo = chainInfoMap[destinationNetworkKey];
+  const receiverLocation = getReceiverLocation(originNetworkKey, destinationNetworkKey, chainInfoMap, recipient);
+  if (_XCM_CHAIN_GROUP.statemine.includes(destinationNetworkKey)) {
+    return api.tx.xcmPallet.limitedTeleportAssets({
+      V1: {
+        parents: 0,
+        interior: {
+          X1: {
+            Parachain: _getSubstrateParaId(destinationChainInfo)
+          }
+        }
+      }
+    }, {
+      V1: {
+        parents: 0,
+        interior: {
+          X1: receiverLocation
+        }
+      }
+    }, {
+      V1: [{
+        id: {
+          Concrete: {
+            parents: 0,
+            interior: 'Here'
+          }
+        },
+        fun: {
+          Fungible: sendingValue
+        }
+      }]
+    }, 0, POLKADOT_UNLIMITED_WEIGHT);
+  }
+  return api.tx.xcmPallet.reserveTransferAssets({
+    V1: {
+      // find the destination chain
+      parents: 0,
+      interior: {
+        X1: {
+          Parachain: _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/koni/api/xcm/utils.d.ts

@@ -0,0 +1,12 @@
+import { _ChainInfo } from '@subwallet/chain-list/types';
+export declare const FOUR_INSTRUCTIONS_WEIGHT = 5000000000;
+export declare const POLKADOT_LIMITED_WEIGHT = 1000000000;
+export declare const POLKADOT_UNLIMITED_WEIGHT = "Unlimited";
+export declare function getMultiLocationFromParachain(originChain: string, destinationChain: string, chainInfoMap: Record<string, _ChainInfo>, toAddress: string): {
+    V1: {
+        parents: number;
+        interior: Record<string, any>;
+    };
+};
+export declare function getReceiverLocation(originChain: string, destinationChain: string, chainInfoMap: Record<string, _ChainInfo>, toAddress: string): Record<string, any>;
+export declare const SupportedCrossChainsMap: {};

package/koni/api/xcm/utils.js

@@ -0,0 +1,68 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+import { _XCM_CHAIN_GROUP, _XCM_TYPE } from '@subwallet/extension-base/services/chain-service/constants';
+import { _getChainSubstrateAddressPrefix, _getSubstrateParaId, _getXcmTransferType, _isChainEvmCompatible } from '@subwallet/extension-base/services/chain-service/utils';
+import { decodeAddress, evmToAddress } from '@polkadot/util-crypto';
+export const FOUR_INSTRUCTIONS_WEIGHT = 5000000000;
+export const POLKADOT_LIMITED_WEIGHT = 1000000000;
+export const POLKADOT_UNLIMITED_WEIGHT = 'Unlimited';
+
+// get multilocation for destination chain from a parachain
+export function getMultiLocationFromParachain(originChain, destinationChain, chainInfoMap, toAddress) {
+  const xcmType = _getXcmTransferType(chainInfoMap[originChain], chainInfoMap[destinationChain]);
+  const paraId = _getSubstrateParaId(chainInfoMap[destinationChain]);
+  const receiverLocation = getReceiverLocation(originChain, destinationChain, chainInfoMap, toAddress);
+  if (xcmType === _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
+      }
+    }
+  };
+}
+export function getReceiverLocation(originChain, destinationChain, chainInfoMap, toAddress) {
+  if (_XCM_CHAIN_GROUP.astarEvm.includes(destinationChain)) {
+    const ss58Address = evmToAddress(toAddress, _getChainSubstrateAddressPrefix(chainInfoMap[destinationChain]));
+    return {
+      AccountId32: {
+        network: 'Any',
+        id: decodeAddress(ss58Address)
+      }
+    };
+  }
+  if (_isChainEvmCompatible(chainInfoMap[destinationChain])) {
+    return {
+      AccountKey20: {
+        network: 'Any',
+        key: toAddress
+      }
+    };
+  }
+  return {
+    AccountId32: {
+      network: 'Any',
+      id: decodeAddress(toAddress)
+    }
+  };
+}
+
+// Todo: Remove it after upgrade new UI
+export const SupportedCrossChainsMap = {};

package/koni/background/cron.d.ts

@@ -0,0 +1,39 @@
+import { _ChainAsset, _ChainInfo } from '@subwallet/chain-list/types';
+import { ApiMap, ServiceInfo } from '@subwallet/extension-base/background/KoniTypes';
+import { KoniSubscription } from '@subwallet/extension-base/koni/background/subscription';
+import { _ChainState, _SubstrateApi } from '@subwallet/extension-base/services/chain-service/types';
+import DatabaseService from '@subwallet/extension-base/services/storage-service/DatabaseService';
+import { Subject } from 'rxjs';
+import KoniState from './handlers/State';
+export declare class KoniCron {
+    subscriptions: KoniSubscription;
+    status: 'pending' | 'running' | 'stopped';
+    private serviceSubscription;
+    dbService: DatabaseService;
+    private state;
+    private logger;
+    constructor(state: KoniState, subscriptions: KoniSubscription, dbService: DatabaseService);
+    private cronMap;
+    private subjectMap;
+    getCron: (name: string) => any;
+    getSubjectMap: (name: string) => any;
+    addCron: (name: string, callback: (param?: any) => void, interval: number, runFirst?: boolean) => void;
+    addSubscribeCron: <T>(name: string, callback: (subject: Subject<T>) => void, interval: number) => void;
+    removeCron: (name: string) => void;
+    removeAllCrons: () => void;
+    init: () => void;
+    start: () => void;
+    stop: () => void;
+    recoverApiMap: () => void;
+    updateApiMapStatus: () => void;
+    refreshNft: (address: string, apiMap: ApiMap, smartContractNfts: _ChainAsset[], chainInfoMap: Record<string, _ChainInfo>) => () => void;
+    resetNft: (newAddress: string) => void;
+    resetStakingReward: () => void;
+    resetNftTransferMeta: () => void;
+    refreshStakingReward: (address: string) => () => void;
+    refreshStakingRewardFastInterval: (address: string) => () => void;
+    setStakingRewardReady: () => void;
+    checkNetworkAvailable: (serviceInfo: ServiceInfo) => boolean;
+    updateChainStakingMetadata: (chainInfoMap: Record<string, _ChainInfo>, chainStateMap: Record<string, _ChainState>, substrateApiMap: Record<string, _SubstrateApi>) => () => void;
+    updateNominatorMetadata: (address: string, chainInfoMap: Record<string, _ChainInfo>, chainStateMap: Record<string, _ChainState>, substrateApiMap: Record<string, _SubstrateApi>) => () => void;
+}

package/koni/background/cron.js

@@ -0,0 +1,236 @@
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { CRON_AUTO_RECOVER_DOTSAMA_INTERVAL, CRON_GET_API_MAP_STATUS, CRON_REFRESH_CHAIN_NOMINATOR_METADATA, CRON_REFRESH_CHAIN_STAKING_METADATA, CRON_REFRESH_NFT_INTERVAL, CRON_REFRESH_STAKING_REWARD_FAST_INTERVAL, CRON_REFRESH_STAKING_REWARD_INTERVAL } from '@subwallet/extension-base/constants';
+import { _ChainConnectionStatus } from '@subwallet/extension-base/services/chain-service/types';
+import { Subject } from 'rxjs';
+import { logger as createLogger } from '@polkadot/util';
+export class KoniCron {
+  status = 'pending';
+  constructor(state, subscriptions, dbService) {
+    this.subscriptions = subscriptions;
+    this.dbService = dbService;
+    this.state = state;
+    this.logger = createLogger('Cron');
+    // this.init();
+  }
+
+  cronMap = {};
+  subjectMap = {};
+  getCron = name => {
+    return this.cronMap[name];
+  };
+  getSubjectMap = name => {
+    return this.subjectMap[name];
+  };
+  addCron = (name, callback, interval, runFirst = true) => {
+    if (runFirst) {
+      callback();
+    }
+    this.cronMap[name] = setInterval(callback, interval);
+  };
+  addSubscribeCron = (name, callback, interval) => {
+    const sb = new 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(([key, interval]) => {
+      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.updateApiMapStatus();
+        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()), CRON_REFRESH_NFT_INTERVAL);
+        this.addCron('checkStatusApiMap', this.updateApiMapStatus, CRON_GET_API_MAP_STATUS);
+        this.addCron('recoverApiMap', this.recoverApiMap, CRON_AUTO_RECOVER_DOTSAMA_INTERVAL, false);
+        this.addCron('refreshStakingReward', this.refreshStakingReward(currentAccountInfo.address), CRON_REFRESH_STAKING_REWARD_INTERVAL);
+        this.addCron('refreshPoolingStakingReward', this.refreshStakingRewardFastInterval(currentAccountInfo.address), CRON_REFRESH_STAKING_REWARD_FAST_INTERVAL);
+        this.addCron('updateChainStakingMetadata', this.updateChainStakingMetadata(this.state.getChainInfoMap(), this.state.getChainStateMap(), this.state.getSubstrateApiMap()), CRON_REFRESH_CHAIN_STAKING_METADATA);
+        this.addCron('updateNominatorMetadata', this.updateNominatorMetadata(currentAccountInfo.address, this.state.getChainInfoMap(), this.state.getChainStateMap(), this.state.getSubstrateApiMap()), 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.resetNftTransferMeta();
+        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()), CRON_REFRESH_NFT_INTERVAL);
+          this.addCron('checkStatusApiMap', this.updateApiMapStatus, CRON_GET_API_MAP_STATUS);
+          this.addCron('recoverApiMap', this.recoverApiMap, CRON_AUTO_RECOVER_DOTSAMA_INTERVAL, false);
+          this.addCron('refreshStakingReward', this.refreshStakingReward(address), CRON_REFRESH_STAKING_REWARD_INTERVAL);
+          this.addCron('refreshPoolingStakingReward', this.refreshStakingRewardFastInterval(address), CRON_REFRESH_STAKING_REWARD_FAST_INTERVAL);
+          this.addCron('updateChainStakingMetadata', this.updateChainStakingMetadata(serviceInfo.chainInfoMap, serviceInfo.chainStateMap, serviceInfo.chainApiMap.substrate), CRON_REFRESH_CHAIN_STAKING_METADATA);
+          this.addCron('updateNominatorMetadata', this.updateNominatorMetadata(address, serviceInfo.chainInfoMap, serviceInfo.chainStateMap, serviceInfo.chainApiMap.substrate), 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(({
+      address
+    }) => {
+      var _this$subscriptions;
+      ((_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());
+    });
+  };
+  updateApiMapStatus = () => {
+    const apiMap = this.state.getApiMap();
+    const chainStateMap = this.state.getChainStateMap();
+    for (const [key, substrateApi] of Object.entries(apiMap.substrate)) {
+      let status = _ChainConnectionStatus.CONNECTING;
+      if (substrateApi.isApiConnected) {
+        status = _ChainConnectionStatus.CONNECTED;
+      }
+      if (!chainStateMap[key].connectionStatus) {
+        this.state.updateNetworkStatus(key, status);
+      } else if (chainStateMap[key].connectionStatus && chainStateMap[key].connectionStatus !== status) {
+        this.state.updateNetworkStatus(key, status);
+      }
+    }
+    for (const [key, evmApi] of Object.entries(apiMap.evm)) {
+      evmApi.api.eth.net.isListening().then(() => {
+        if (!chainStateMap[key].connectionStatus) {
+          this.state.updateNetworkStatus(key, _ChainConnectionStatus.CONNECTED);
+        } else if (chainStateMap[key].connectionStatus && chainStateMap[key].connectionStatus !== _ChainConnectionStatus.CONNECTED) {
+          this.state.updateNetworkStatus(key, _ChainConnectionStatus.CONNECTED);
+        }
+      }).catch(() => {
+        if (!chainStateMap[key].connectionStatus) {
+          this.state.updateNetworkStatus(key, _ChainConnectionStatus.CONNECTING);
+        } else if (chainStateMap[key].connectionStatus && chainStateMap[key].connectionStatus !== _ChainConnectionStatus.CONNECTING) {
+          this.state.updateNetworkStatus(key, _ChainConnectionStatus.CONNECTING);
+        }
+      });
+    }
+  };
+  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();
+  };
+  resetNftTransferMeta = () => {
+    this.state.setNftTransfer({
+      cronUpdate: false,
+      forceUpdate: false
+    });
+  };
+  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);
+    };
+  };
+}

package/koni/background/events.d.ts

@@ -0,0 +1 @@
+export declare const onExtensionInstall: () => void;

package/koni/background/events.js

@@ -0,0 +1,7 @@
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { state } from '@subwallet/extension-base/koni/background/handlers';
+export const onExtensionInstall = () => {
+  state.onInstall();
+};