@subwallet/extension-base 0.8.4-0 → 1.0.2-1

package/koni/api/xcm/polkadotXcm.js

@@ -0,0 +1,52 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+import { FOUR_INSTRUCTIONS_WEIGHT, getBeneficiary, NETWORK_USE_UNLIMITED_WEIGHT, POLKADOT_UNLIMITED_WEIGHT } from '@subwallet/extension-base/koni/api/xcm/utils';
+import { _getSubstrateParaId, _getXcmAssetMultilocation, _isSubstrateParaChain, _isSubstrateRelayChain } from '@subwallet/extension-base/services/chain-service/utils';
+function getDestinationChainLocation(destinationChainInfo) {
+  if (_isSubstrateParaChain(destinationChainInfo)) {
+    return {
+      V1: {
+        parents: 1,
+        interior: {
+          X1: {
+            Parachain: _getSubstrateParaId(destinationChainInfo)
+          }
+        }
+      }
+    };
+  }
+  return {
+    // to relaychain by default
+    V1: {
+      parents: 1,
+      interior: 'Here'
+    }
+  };
+}
+function getAssetLocation(tokenInfo, sendingValue) {
+  const multilocation = _getXcmAssetMultilocation(tokenInfo);
+  return {
+    V1: [{
+      id: multilocation,
+      fun: {
+        Fungible: sendingValue
+      }
+    }]
+  };
+}
+export function getExtrinsicByPolkadotXcmPallet(tokenInfo, originChainInfo, destinationChainInfo, recipientAddress, value, api) {
+  const weightParam = NETWORK_USE_UNLIMITED_WEIGHT.includes(originChainInfo.slug) ? POLKADOT_UNLIMITED_WEIGHT : FOUR_INSTRUCTIONS_WEIGHT;
+  const beneficiary = getBeneficiary(originChainInfo, destinationChainInfo, recipientAddress);
+  const destination = getDestinationChainLocation(destinationChainInfo);
+  const assetLocation = getAssetLocation(tokenInfo, value);
+  let method = 'limitedReserveTransferAssets';
+  if (['astar', 'shiden'].includes(originChainInfo.slug)) {
+    method = 'limitedReserveWithdrawAssets';
+  } else if (_isSubstrateRelayChain(destinationChainInfo)) {
+    method = 'limitedTeleportAssets';
+  }
+  return api.tx.polkadotXcm[method](destination, beneficiary, assetLocation, 0,
+  // FeeAssetItem
+  weightParam);
+}

package/koni/api/xcm/utils.d.ts

@@ -0,0 +1,16 @@
+import { _ChainInfo } from '@subwallet/chain-list/types';
+export declare const FOUR_INSTRUCTIONS_WEIGHT: {
+    Limited: number;
+};
+export declare const POLKADOT_LIMITED_WEIGHT = 1000000000;
+export declare const POLKADOT_UNLIMITED_WEIGHT = "Unlimited";
+export declare function getReceiverLocation(originChainInfo: _ChainInfo, destinationChainInfo: _ChainInfo, toAddress: string): Record<string, any>;
+export declare function getBeneficiary(originChainInfo: _ChainInfo, destinationChainInfo: _ChainInfo, recipientAddress: string): {
+    V1: {
+        parents: number;
+        interior: {
+            X1: Record<string, any>;
+        };
+    };
+};
+export declare const NETWORK_USE_UNLIMITED_WEIGHT: string[];

package/koni/api/xcm/utils.js

@@ -0,0 +1,52 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+import { COMMON_CHAIN_SLUGS } from '@subwallet/chain-list';
+import { _getChainSubstrateAddressPrefix, _isChainEvmCompatible } from '@subwallet/extension-base/services/chain-service/utils';
+import { decodeAddress, evmToAddress } from '@polkadot/util-crypto';
+export const FOUR_INSTRUCTIONS_WEIGHT = {
+  Limited: 5000000000
+};
+export const POLKADOT_LIMITED_WEIGHT = 1000000000;
+export const POLKADOT_UNLIMITED_WEIGHT = 'Unlimited';
+
+// get multilocation for destination chain from a parachain
+
+export function getReceiverLocation(originChainInfo, destinationChainInfo, toAddress) {
+  // @ts-ignore
+  if (destinationChainInfo.slug === COMMON_CHAIN_SLUGS.ASTAR_EVM || destinationChainInfo.slug === 'astarEvm') {
+    const ss58Address = evmToAddress(toAddress, _getChainSubstrateAddressPrefix(destinationChainInfo));
+    return {
+      AccountId32: {
+        network: 'Any',
+        id: decodeAddress(ss58Address)
+      }
+    };
+  }
+  if (_isChainEvmCompatible(destinationChainInfo)) {
+    return {
+      AccountKey20: {
+        network: 'Any',
+        key: toAddress
+      }
+    };
+  }
+  return {
+    AccountId32: {
+      network: 'Any',
+      id: decodeAddress(toAddress)
+    }
+  };
+}
+export function getBeneficiary(originChainInfo, destinationChainInfo, recipientAddress) {
+  const receiverLocation = getReceiverLocation(originChainInfo, destinationChainInfo, recipientAddress);
+  return {
+    V1: {
+      parents: 0,
+      interior: {
+        X1: receiverLocation
+      }
+    }
+  };
+}
+export const NETWORK_USE_UNLIMITED_WEIGHT = ['acala', 'karura', 'statemint', 'moonriver'];

package/koni/api/xcm/xTokens.d.ts

@@ -0,0 +1,3 @@
+import { _ChainAsset, _ChainInfo } from '@subwallet/chain-list/types';
+import { ApiPromise } from '@polkadot/api';
+export declare function getExtrinsicByXtokensPallet(tokenInfo: _ChainAsset, originChainInfo: _ChainInfo, destinationChainInfo: _ChainInfo, recipientAddress: string, value: string, api: ApiPromise): import("@polkadot/api-base/types").SubmittableExtrinsic<"promise", import("@polkadot/types/types").ISubmittableResult>;

package/koni/api/xcm/xTokens.js

@@ -0,0 +1,53 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+import { FOUR_INSTRUCTIONS_WEIGHT, getReceiverLocation, NETWORK_USE_UNLIMITED_WEIGHT, POLKADOT_UNLIMITED_WEIGHT } from '@subwallet/extension-base/koni/api/xcm/utils';
+import { _XCM_TYPE } from '@subwallet/extension-base/services/chain-service/constants';
+import { _getSubstrateParaId, _getTokenOnChainInfo, _getXcmAssetId, _getXcmAssetMultilocation, _getXcmAssetType, _getXcmTransferType, _isNativeToken } from '@subwallet/extension-base/services/chain-service/utils';
+function getCurrencyId(tokenInfo) {
+  if (['acala', 'karura'].includes(tokenInfo.originChain) && _isNativeToken(tokenInfo)) {
+    return _getXcmAssetMultilocation(tokenInfo);
+  } else if (['moonbeam', 'moonbase', 'moonriver'].includes(tokenInfo.originChain)) {
+    const tokenType = _getXcmAssetType(tokenInfo);
+    const assetId = _getXcmAssetId(tokenInfo);
+    return {
+      [tokenType]: assetId
+    };
+  } else if (['pioneer'].includes(tokenInfo.originChain)) {
+    return _getXcmAssetMultilocation(tokenInfo);
+  }
+  return _getTokenOnChainInfo(tokenInfo);
+}
+function getMultiLocationForXtokensPallet(originChainInfo, destinationChainInfo, toAddress) {
+  const xcmType = _getXcmTransferType(originChainInfo, destinationChainInfo);
+  const paraId = _getSubstrateParaId(destinationChainInfo);
+  const receiverLocation = getReceiverLocation(originChainInfo, destinationChainInfo, 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 getExtrinsicByXtokensPallet(tokenInfo, originChainInfo, destinationChainInfo, recipientAddress, value, api) {
+  const weightParam = NETWORK_USE_UNLIMITED_WEIGHT.includes(originChainInfo.slug) ? POLKADOT_UNLIMITED_WEIGHT : FOUR_INSTRUCTIONS_WEIGHT;
+  return api.tx.xTokens.transfer(getCurrencyId(tokenInfo), value, getMultiLocationForXtokensPallet(originChainInfo, destinationChainInfo, recipientAddress), weightParam);
+}

package/koni/api/xcm/xcmPallet.d.ts

@@ -0,0 +1,3 @@
+import { _ChainAsset, _ChainInfo } from '@subwallet/chain-list/types';
+import { ApiPromise } from '@polkadot/api';
+export declare function getExtrinsicByXcmPalletPallet(tokenInfo: _ChainAsset, originChainInfo: _ChainInfo, destinationChainInfo: _ChainInfo, recipientAddress: string, value: string, api: ApiPromise): import("@polkadot/api-base/types").SubmittableExtrinsic<"promise", import("@polkadot/types/types").ISubmittableResult>;

package/koni/api/xcm/xcmPallet.js

@@ -0,0 +1,46 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+import { FOUR_INSTRUCTIONS_WEIGHT, getBeneficiary, NETWORK_USE_UNLIMITED_WEIGHT, POLKADOT_UNLIMITED_WEIGHT } from '@subwallet/extension-base/koni/api/xcm/utils';
+import { _getSubstrateParaId } from '@subwallet/extension-base/services/chain-service/utils';
+function getDestinationChainLocation(destinationChainInfo) {
+  return {
+    V1: {
+      parents: 0,
+      interior: {
+        X1: {
+          Parachain: _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
+export function getExtrinsicByXcmPalletPallet(tokenInfo, originChainInfo, destinationChainInfo, recipientAddress, value, api) {
+  const weightParam = NETWORK_USE_UNLIMITED_WEIGHT.includes(originChainInfo.slug) ? POLKADOT_UNLIMITED_WEIGHT : FOUR_INSTRUCTIONS_WEIGHT;
+  const destination = getDestinationChainLocation(destinationChainInfo);
+  const beneficiary = 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/koni/background/cron.d.ts

@@ -0,0 +1,37 @@
+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;
+    refreshNft: (address: string, apiMap: ApiMap, smartContractNfts: _ChainAsset[], chainInfoMap: Record<string, _ChainInfo>) => () => void;
+    resetNft: (newAddress: string) => void;
+    resetStakingReward: () => 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,195 @@
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { CRON_AUTO_RECOVER_DOTSAMA_INTERVAL, 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 { 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 = () => {
+    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();
+    }
+  };
+  start = () => {
+    if (this.status === 'running') {
+      return;
+    }
+    this.logger.log('Starting cron jobs');
+    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.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('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();
+    }
+    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) => {
+      var _serviceInfo$currentA;
+      const serviceInfo = this.state.getServiceInfo();
+      const needReload = eventTypes.some(eT => reloadEvents.includes(eT));
+      if (!needReload) {
+        return;
+      }
+      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('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('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 = () => {
+    var _this$subscriptions;
+    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);
+      });
+    }
+    const {
+      address
+    } = this.state.keyringService.currentAccount;
+    ((_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);
+  };
+  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);
+    };
+  };
+}

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();
+};

package/koni/background/handlers/Extension.d.ts

@@ -0,0 +1,183 @@
+/// <reference types="chrome" />
+import { MessageTypes, RequestTypes, ResponseAuthorizeList, ResponseType } from '@subwallet/extension-base/background/types';
+import KoniState from '@subwallet/extension-base/koni/background/handlers/State';
+import { Prefix } from '@polkadot/util-crypto/types';
+export default class KoniExtension {
+    #private;
+    constructor(state: KoniState);
+    private accountsCreateExternal;
+    private accountsCreateHardware;
+    private accountsCreateSuri;
+    private accountsChangePassword;
+    private accountsEdit;
+    private accountsExport;
+    private accountsShow;
+    private accountsValidate;
+    private accountsSubscribe;
+    private metadataApprove;
+    private metadataGet;
+    private metadataList;
+    private metadataReject;
+    private metadataSubscribe;
+    private jsonRestore;
+    private batchRestore;
+    private jsonGetAccountInfo;
+    private seedCreate;
+    private seedValidate;
+    private signingApproveSignature;
+    private signingCancel;
+    private signingSubscribe;
+    private windowOpen;
+    private derive;
+    private derivationValidate;
+    private derivationCreate;
+    private cancelSubscription;
+    private createUnsubscriptionHandle;
+    decodeAddress: (key: string | Uint8Array, ignoreChecksum?: boolean, ss58Format?: Prefix) => Uint8Array;
+    encodeAddress: (key: string | Uint8Array, ss58Format?: Prefix) => string;
+    private accountExportPrivateKey;
+    private checkPublicAndSecretKey;
+    private accountsGetAllWithCurrentAddress;
+    private accountsGetAll;
+    private saveRecentAccountId;
+    private triggerAccountsSubscription;
+    private _getAuthListV2;
+    private authorizeSubscribeV2;
+    private getAuthListV2;
+    private authorizeApproveV2;
+    private authorizeRejectV2;
+    private authorizeCancelV2;
+    private _forgetSite;
+    private forgetSite;
+    private _forgetAllSite;
+    private forgetAllSite;
+    private getNonReadonlyAccounts;
+    private isAddressValidWithAuthType;
+    private filterAccountsByAccountAuthType;
+    private _changeAuthorizationAll;
+    private changeAuthorizationAll;
+    private _changeAuthorization;
+    toggleAuthorization2(url: string): Promise<ResponseAuthorizeList>;
+    private changeAuthorization;
+    private _changeAuthorizationPerAcc;
+    private _changeAuthorizationBlock;
+    private _changeAuthorizationPerSite;
+    private changeAuthorizationPerAcc;
+    private changeAuthorizationPerSite;
+    private changeAuthorizationBlock;
+    private getSettings;
+    private toggleBalancesVisibility;
+    private saveAccountAllLogo;
+    private saveTheme;
+    private setCamera;
+    private saveBrowserConfirmationType;
+    private subscribeSettings;
+    private subscribeAuthUrls;
+    private _saveCurrentAccountAddress;
+    private updateCurrentAccountAddress;
+    private saveCurrentAccountAddress;
+    private getAssetSetting;
+    private subscribeAssetSetting;
+    private updateAssetSetting;
+    private getPrice;
+    private subscribePrice;
+    private getBalance;
+    private subscribeBalance;
+    private getCrowdloan;
+    private subscribeCrowdloan;
+    private validatePassword;
+    private validatedAccountsPassword;
+    private _addAddressToAuthList;
+    private _addAddressesToAuthList;
+    private accountsCreateSuriV2;
+    private accountsForgetOverride;
+    private seedCreateV2;
+    private seedValidateV2;
+    private _checkValidatePrivateKey;
+    private metamaskPrivateKeyValidateV2;
+    private deriveV2;
+    private derivationCreateV2;
+    private jsonRestoreV2;
+    private batchRestoreV2;
+    private getNftCollection;
+    private subscribeNftCollection;
+    private getNft;
+    private subscribeNft;
+    private getStakingReward;
+    private subscribeStakingReward;
+    private getStaking;
+    private subscribeStaking;
+    private subscribeHistory;
+    private validateTransfer;
+    private makeTransfer;
+    private validateCrossChainTransfer;
+    private makeCrossChainTransfer;
+    private evmNftSubmitTransaction;
+    private upsertChain;
+    private removeCustomChain;
+    private disableChain;
+    private enableChain;
+    private validateNetwork;
+    private resetDefaultNetwork;
+    private recoverDotSamaApi;
+    private upsertCustomToken;
+    private deleteCustomAsset;
+    private validateCustomAsset;
+    private getAddressFreeBalance;
+    private subscribeAddressFreeBalance;
+    private transferCheckReferenceCount;
+    private transferCheckSupporting;
+    private transferGetExistentialDeposit;
+    private substrateNftSubmitTransaction;
+    private enableChains;
+    private getAccountMeta;
+    private accountsTie2;
+    private accountsCreateExternalV2;
+    private accountsCreateHardwareV2;
+    private accountsCreateHardwareMultiple;
+    private accountsCreateWithSecret;
+    private rejectExternalRequest;
+    private resolveQrTransfer;
+    private subscribeConfirmations;
+    private completeConfirmation;
+    private getNetworkJsonByChainId;
+    private parseSubstrateTransaction;
+    private parseEVMRLP;
+    private qrSignSubstrate;
+    private qrSignEVM;
+    private subscribeChainStakingMetadata;
+    private subscribeStakingNominatorMetadata;
+    private getBondingOptions;
+    private getNominationPoolOptions;
+    private submitBonding;
+    private submitUnbonding;
+    private submitStakeWithdrawal;
+    private submitStakeClaimReward;
+    private submitCancelStakeWithdrawal;
+    private submitPoolingBonding;
+    private submitPoolingUnbonding;
+    private parseContractInput;
+    private submitTuringStakeCompounding;
+    private submitTuringCancelStakeCompound;
+    private keyringStateSubscribe;
+    private keyringChangeMasterPassword;
+    private keyringMigrateMasterPassword;
+    private keyringUnlock;
+    private keyringLock;
+    private keyringExportMnemonic;
+    private signingApprovePasswordV2;
+    private derivationCreateMultiple;
+    private derivationCreateV3;
+    private validateDerivePath;
+    private getListDeriveAccounts;
+    private subscribeChainInfoMap;
+    private subscribeChainStateMap;
+    private subscribeAssetRegistry;
+    private subscribeMultiChainAssetMap;
+    private subscribeXcmRefMap;
+    private getSupportedSmartContractTypes;
+    private getTransaction;
+    private subscribeTransactions;
+    private subscribeNotifications;
+    handle<TMessageType extends MessageTypes>(id: string, type: TMessageType, request: RequestTypes[TMessageType], port: chrome.runtime.Port): Promise<ResponseType<TMessageType>>;
+}