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

package/cjs/services/chain-service/types.js

@@ -0,0 +1,26 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports._SMART_CONTRACT_STANDARDS = exports._NFT_CONTRACT_STANDARDS = exports._FUNGIBLE_CONTRACT_STANDARDS = exports._ChainConnectionStatus = exports._CUSTOM_PREFIX = void 0;
+var _types = require("@subwallet/chain-list/types");
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+/* eslint @typescript-eslint/no-empty-interface: "off" */
+let _ChainConnectionStatus;
+exports._ChainConnectionStatus = _ChainConnectionStatus;
+(function (_ChainConnectionStatus) {
+  _ChainConnectionStatus["CONNECTED"] = "CONNECTED";
+  _ChainConnectionStatus["DISCONNECTED"] = "DISCONNECTED";
+  _ChainConnectionStatus["UNSTABLE"] = "UNSTABLE";
+  _ChainConnectionStatus["CONNECTING"] = "CONNECTING";
+})(_ChainConnectionStatus || (exports._ChainConnectionStatus = _ChainConnectionStatus = {}));
+const _CUSTOM_PREFIX = 'custom-';
+exports._CUSTOM_PREFIX = _CUSTOM_PREFIX;
+const _FUNGIBLE_CONTRACT_STANDARDS = [_types._AssetType.ERC20, _types._AssetType.PSP22];
+exports._FUNGIBLE_CONTRACT_STANDARDS = _FUNGIBLE_CONTRACT_STANDARDS;
+const _NFT_CONTRACT_STANDARDS = [_types._AssetType.PSP34, _types._AssetType.ERC721];
+exports._NFT_CONTRACT_STANDARDS = _NFT_CONTRACT_STANDARDS;
+const _SMART_CONTRACT_STANDARDS = [..._FUNGIBLE_CONTRACT_STANDARDS, ..._NFT_CONTRACT_STANDARDS];
+exports._SMART_CONTRACT_STANDARDS = _SMART_CONTRACT_STANDARDS;

package/cjs/services/chain-service/utils.js

@@ -0,0 +1,391 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports._checkSmartContractSupportByChain = _checkSmartContractSupportByChain;
+exports._generateCustomProviderKey = _generateCustomProviderKey;
+exports._getAssetDecimals = _getAssetDecimals;
+exports._getAssetOriginChain = _getAssetOriginChain;
+exports._getAssetPriceId = _getAssetPriceId;
+exports._getAssetSymbol = _getAssetSymbol;
+exports._getBlockExplorerFromChain = _getBlockExplorerFromChain;
+exports._getChainName = _getChainName;
+exports._getChainNativeTokenBasicInfo = _getChainNativeTokenBasicInfo;
+exports._getChainNativeTokenSlug = _getChainNativeTokenSlug;
+exports._getChainSubstrateAddressPrefix = _getChainSubstrateAddressPrefix;
+exports._getContractAddressOfToken = _getContractAddressOfToken;
+exports._getCrowdloanUrlFromChain = _getCrowdloanUrlFromChain;
+exports._getCustomAssets = _getCustomAssets;
+exports._getEvmAbiExplorer = _getEvmAbiExplorer;
+exports._getEvmChainId = _getEvmChainId;
+exports._getMultiChainAsset = _getMultiChainAsset;
+exports._getMultiChainAssetPriceId = _getMultiChainAssetPriceId;
+exports._getMultiChainAssetSymbol = _getMultiChainAssetSymbol;
+exports._getNftTypesSupportedByChain = _getNftTypesSupportedByChain;
+exports._getOriginChainOfAsset = _getOriginChainOfAsset;
+exports._getSubstrateGenesisHash = _getSubstrateGenesisHash;
+exports._getSubstrateParaId = _getSubstrateParaId;
+exports._getSubstrateRelayParent = _getSubstrateRelayParent;
+exports._getTokenMinAmount = _getTokenMinAmount;
+exports._getTokenOnChainAssetId = _getTokenOnChainAssetId;
+exports._getTokenOnChainInfo = _getTokenOnChainInfo;
+exports._getTokenTypesSupportedByChain = _getTokenTypesSupportedByChain;
+exports._getXcmAssetId = _getXcmAssetId;
+exports._getXcmAssetMultilocation = _getXcmAssetMultilocation;
+exports._getXcmAssetType = _getXcmAssetType;
+exports._getXcmTransferType = _getXcmTransferType;
+exports._isAssetFungibleToken = _isAssetFungibleToken;
+exports._isAssetSmartContractNft = _isAssetSmartContractNft;
+exports._isAssetValuable = _isAssetValuable;
+exports._isChainEnabled = _isChainEnabled;
+exports._isChainEvmCompatible = _isChainEvmCompatible;
+exports._isChainSupportEvmNft = _isChainSupportEvmNft;
+exports._isChainSupportNativeNft = _isChainSupportNativeNft;
+exports._isChainSupportSubstrateStaking = _isChainSupportSubstrateStaking;
+exports._isChainSupportWasmNft = _isChainSupportWasmNft;
+exports._isChainTestNet = _isChainTestNet;
+exports._isCustomAsset = _isCustomAsset;
+exports._isCustomChain = _isCustomChain;
+exports._isCustomProvider = _isCustomProvider;
+exports._isEqualContractAddress = _isEqualContractAddress;
+exports._isEqualSmartContractAsset = _isEqualSmartContractAsset;
+exports._isLocalToken = _isLocalToken;
+exports._isNativeToken = _isNativeToken;
+exports._isNativeTokenBySlug = _isNativeTokenBySlug;
+exports._isPureEvmChain = _isPureEvmChain;
+exports._isPureSubstrateChain = _isPureSubstrateChain;
+exports._isSmartContractToken = _isSmartContractToken;
+exports._isSubstrateChain = _isSubstrateChain;
+exports._isSubstrateParaChain = _isSubstrateParaChain;
+exports._isSubstrateParachain = _isSubstrateParachain;
+exports._isSubstrateRelayChain = _isSubstrateRelayChain;
+exports._isTokenEvmSmartContract = _isTokenEvmSmartContract;
+exports._isTokenWasmSmartContract = _isTokenWasmSmartContract;
+exports._isXcmPathSupported = _isXcmPathSupported;
+exports._parseAssetRefKey = _parseAssetRefKey;
+exports._parseMetadataForSmartContractAsset = _parseMetadataForSmartContractAsset;
+var _types = require("@subwallet/chain-list/types");
+var _types2 = require("@subwallet/extension-base/services/chain-service/types");
+var _utilCrypto = require("@polkadot/util-crypto");
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+function _isCustomChain(slug) {
+  if (slug.length === 0) {
+    return true;
+  }
+  return slug.startsWith(_types2._CUSTOM_PREFIX);
+}
+function _isCustomAsset(slug) {
+  // might be different from _isCustomNetwork
+  if (slug.length === 0) {
+    return true;
+  }
+  return slug.startsWith(_types2._CUSTOM_PREFIX);
+}
+function _getCustomAssets(assetRegistry) {
+  const filteredAssetMap = {};
+  Object.values(assetRegistry).forEach(chainAsset => {
+    if (_isCustomAsset(chainAsset.slug)) {
+      filteredAssetMap[chainAsset.slug] = chainAsset;
+    }
+  });
+  return filteredAssetMap;
+}
+function _isEqualContractAddress(address1, address2) {
+  if ((0, _utilCrypto.isEthereumAddress)(address1) && (0, _utilCrypto.isEthereumAddress)(address2)) {
+    return address1.toLowerCase() === address2.toLowerCase(); // EVM address is case-insensitive
+  }
+
+  return address2 === address1;
+}
+function _isEqualSmartContractAsset(asset1, asset2) {
+  var _asset1$metadata, _asset2$metadata;
+  const contract1 = ((_asset1$metadata = asset1.metadata) === null || _asset1$metadata === void 0 ? void 0 : _asset1$metadata.contractAddress) || undefined || null;
+  const contract2 = ((_asset2$metadata = asset2.metadata) === null || _asset2$metadata === void 0 ? void 0 : _asset2$metadata.contractAddress) || undefined || null;
+  if (!contract1 || !contract2) {
+    return false;
+  }
+  if (_isEqualContractAddress(contract1, contract2) && asset1.assetType === asset2.assetType && asset1.originChain === asset2.originChain) {
+    return true;
+  }
+  return false;
+}
+function _isPureEvmChain(chainInfo) {
+  return chainInfo.evmInfo !== null && chainInfo.substrateInfo === null;
+}
+function _isPureSubstrateChain(chainInfo) {
+  return chainInfo.evmInfo === null && chainInfo.substrateInfo !== null;
+}
+function _getOriginChainOfAsset(assetSlug) {
+  if (assetSlug.startsWith(_types2._CUSTOM_PREFIX)) {
+    return assetSlug.split('-')[1];
+  }
+  return assetSlug.split('-')[0];
+}
+function _getContractAddressOfToken(tokenInfo) {
+  var _tokenInfo$metadata;
+  return ((_tokenInfo$metadata = tokenInfo.metadata) === null || _tokenInfo$metadata === void 0 ? void 0 : _tokenInfo$metadata.contractAddress) || '';
+}
+function _checkSmartContractSupportByChain(chainInfo, contractType) {
+  // EVM chains support smart contract by default so just checking Substrate chains
+  if (chainInfo.substrateInfo === null || chainInfo.substrateInfo && chainInfo.substrateInfo.supportSmartContract === null) {
+    return false;
+  }
+  return chainInfo.substrateInfo.supportSmartContract !== null && chainInfo.substrateInfo.supportSmartContract.includes(contractType);
+}
+
+// Utils for balance functions
+function _getTokenOnChainAssetId(tokenInfo) {
+  var _tokenInfo$metadata2;
+  return ((_tokenInfo$metadata2 = tokenInfo.metadata) === null || _tokenInfo$metadata2 === void 0 ? void 0 : _tokenInfo$metadata2.assetId) || '-1';
+}
+function _getTokenOnChainInfo(tokenInfo) {
+  var _tokenInfo$metadata3;
+  return (_tokenInfo$metadata3 = tokenInfo.metadata) === null || _tokenInfo$metadata3 === void 0 ? void 0 : _tokenInfo$metadata3.onChainInfo;
+}
+function _getTokenMinAmount(tokenInfo) {
+  return tokenInfo.minAmount || '0';
+}
+function _isChainEvmCompatible(chainInfo) {
+  return chainInfo.evmInfo !== undefined && chainInfo.evmInfo !== null;
+}
+function _isNativeToken(tokenInfo) {
+  return tokenInfo.assetType === _types._AssetType.NATIVE;
+}
+function _isNativeTokenBySlug(tokenSlug) {
+  return tokenSlug.includes(_types._AssetType.NATIVE);
+}
+function _isSmartContractToken(tokenInfo) {
+  return _types2._SMART_CONTRACT_STANDARDS.includes(tokenInfo.assetType);
+}
+function _isSubstrateChain(chainInfo) {
+  return !!chainInfo.substrateInfo; // fallback to Ethereum
+}
+
+function _getEvmChainId(chainInfo) {
+  var _chainInfo$evmInfo;
+  return ((_chainInfo$evmInfo = chainInfo.evmInfo) === null || _chainInfo$evmInfo === void 0 ? void 0 : _chainInfo$evmInfo.evmChainId) || 1; // fallback to Ethereum
+}
+
+function _getSubstrateParaId(chainInfo) {
+  var _chainInfo$substrateI;
+  return ((_chainInfo$substrateI = chainInfo.substrateInfo) === null || _chainInfo$substrateI === void 0 ? void 0 : _chainInfo$substrateI.paraId) || -1;
+}
+function _getSubstrateRelayParent(chainInfo) {
+  var _chainInfo$substrateI2;
+  return ((_chainInfo$substrateI2 = chainInfo.substrateInfo) === null || _chainInfo$substrateI2 === void 0 ? void 0 : _chainInfo$substrateI2.relaySlug) || '';
+}
+function _getSubstrateGenesisHash(chainInfo) {
+  var _chainInfo$substrateI3;
+  return ((_chainInfo$substrateI3 = chainInfo.substrateInfo) === null || _chainInfo$substrateI3 === void 0 ? void 0 : _chainInfo$substrateI3.genesisHash) || '';
+}
+function _isChainSupportSubstrateStaking(chainInfo) {
+  var _chainInfo$substrateI4;
+  return ((_chainInfo$substrateI4 = chainInfo.substrateInfo) === null || _chainInfo$substrateI4 === void 0 ? void 0 : _chainInfo$substrateI4.supportStaking) || false;
+}
+function _isChainEnabled(chainState) {
+  return chainState.active;
+}
+function _isSubstrateParachain(chainInfo) {
+  return chainInfo.substrateInfo !== null && chainInfo.substrateInfo.paraId !== null;
+}
+function _getChainSubstrateAddressPrefix(chainInfo) {
+  var _chainInfo$substrateI5, _chainInfo$substrateI6;
+  return (_chainInfo$substrateI5 = chainInfo === null || chainInfo === void 0 ? void 0 : (_chainInfo$substrateI6 = chainInfo.substrateInfo) === null || _chainInfo$substrateI6 === void 0 ? void 0 : _chainInfo$substrateI6.addressPrefix) !== null && _chainInfo$substrateI5 !== void 0 ? _chainInfo$substrateI5 : -1;
+}
+function _isChainSupportNativeNft(chainInfo) {
+  var _chainInfo$substrateI7;
+  return ((_chainInfo$substrateI7 = chainInfo.substrateInfo) === null || _chainInfo$substrateI7 === void 0 ? void 0 : _chainInfo$substrateI7.hasNativeNft) || false;
+}
+function _isChainSupportEvmNft(chainInfo) {
+  var _chainInfo$evmInfo2, _chainInfo$evmInfo2$s;
+  return ((_chainInfo$evmInfo2 = chainInfo.evmInfo) === null || _chainInfo$evmInfo2 === void 0 ? void 0 : (_chainInfo$evmInfo2$s = _chainInfo$evmInfo2.supportSmartContract) === null || _chainInfo$evmInfo2$s === void 0 ? void 0 : _chainInfo$evmInfo2$s.includes(_types._AssetType.ERC721)) || false;
+}
+function _isChainSupportWasmNft(chainInfo) {
+  var _chainInfo$substrateI8, _chainInfo$substrateI9;
+  return ((_chainInfo$substrateI8 = chainInfo.substrateInfo) === null || _chainInfo$substrateI8 === void 0 ? void 0 : (_chainInfo$substrateI9 = _chainInfo$substrateI8.supportSmartContract) === null || _chainInfo$substrateI9 === void 0 ? void 0 : _chainInfo$substrateI9.includes(_types._AssetType.PSP34)) || false;
+}
+function _getNftTypesSupportedByChain(chainInfo) {
+  const result = [];
+  if (chainInfo.substrateInfo && chainInfo.substrateInfo.supportSmartContract) {
+    chainInfo.substrateInfo.supportSmartContract.forEach(assetType => {
+      if ([_types._AssetType.PSP34].includes(assetType)) {
+        result.push(assetType);
+      }
+    });
+  }
+  if (chainInfo.evmInfo && chainInfo.evmInfo.supportSmartContract) {
+    chainInfo.evmInfo.supportSmartContract.forEach(assetType => {
+      if ([_types._AssetType.ERC721].includes(assetType)) {
+        result.push(assetType);
+      }
+    });
+  }
+  return result;
+}
+function _getTokenTypesSupportedByChain(chainInfo) {
+  const result = [];
+  if (chainInfo.substrateInfo && chainInfo.substrateInfo.supportSmartContract) {
+    chainInfo.substrateInfo.supportSmartContract.forEach(assetType => {
+      if ([_types._AssetType.PSP22].includes(assetType)) {
+        result.push(assetType);
+      }
+    });
+  }
+  if (chainInfo.evmInfo && chainInfo.evmInfo.supportSmartContract) {
+    chainInfo.evmInfo.supportSmartContract.forEach(assetType => {
+      if ([_types._AssetType.ERC20].includes(assetType)) {
+        result.push(assetType);
+      }
+    });
+  }
+  return result;
+}
+function _getChainNativeTokenBasicInfo(chainInfo) {
+  if (!chainInfo) {
+    return {
+      symbol: '',
+      decimals: -1
+    };
+  }
+  if (chainInfo.substrateInfo !== null) {
+    // substrate by default
+    return {
+      symbol: chainInfo.substrateInfo.symbol,
+      decimals: chainInfo.substrateInfo.decimals
+    };
+  } else if (chainInfo.evmInfo !== null) {
+    return {
+      symbol: chainInfo.evmInfo.symbol,
+      decimals: chainInfo.evmInfo.decimals
+    };
+  }
+  return {
+    symbol: '',
+    decimals: -1
+  };
+}
+function _getChainNativeTokenSlug(chainInfo) {
+  if (_isCustomChain(chainInfo.slug)) {
+    return `${_types2._CUSTOM_PREFIX}${chainInfo.slug}-${_types._AssetType.NATIVE}-${_getChainNativeTokenBasicInfo(chainInfo).symbol}`;
+  }
+  return `${chainInfo.slug}-${_types._AssetType.NATIVE}-${_getChainNativeTokenBasicInfo(chainInfo).symbol}`;
+}
+function _isLocalToken(tokenInfo) {
+  return tokenInfo.assetType === _types._AssetType.LOCAL;
+}
+function _isTokenEvmSmartContract(tokenInfo) {
+  return [_types._AssetType.ERC721, _types._AssetType.ERC20].includes(tokenInfo.assetType);
+}
+function _isTokenWasmSmartContract(tokenInfo) {
+  return [_types._AssetType.PSP22, _types._AssetType.PSP34].includes(tokenInfo.assetType);
+}
+function _isAssetSmartContractNft(assetInfo) {
+  return [_types._AssetType.PSP34, _types._AssetType.ERC721].includes(assetInfo.assetType);
+}
+function _parseAssetRefKey(originTokenSlug, destinationTokenSlug) {
+  return `${originTokenSlug}___${destinationTokenSlug}`;
+}
+function _isXcmPathSupported(originTokenSlug, destinationTokenSlug, assetRefMap) {
+  const assetRef = assetRefMap[_parseAssetRefKey(originTokenSlug, destinationTokenSlug)];
+  if (!assetRef) {
+    return false;
+  }
+  return assetRef.path === _types._AssetRefPath.XCM;
+}
+function _getXcmAssetType(tokenInfo) {
+  var _tokenInfo$metadata4;
+  return ((_tokenInfo$metadata4 = tokenInfo.metadata) === null || _tokenInfo$metadata4 === void 0 ? void 0 : _tokenInfo$metadata4.assetType) || '';
+}
+function _getXcmAssetId(tokenInfo) {
+  var _tokenInfo$metadata5;
+  return ((_tokenInfo$metadata5 = tokenInfo.metadata) === null || _tokenInfo$metadata5 === void 0 ? void 0 : _tokenInfo$metadata5.assetId) || '-1';
+}
+function _getXcmAssetMultilocation(tokenInfo) {
+  var _tokenInfo$metadata6;
+  return (_tokenInfo$metadata6 = tokenInfo.metadata) === null || _tokenInfo$metadata6 === void 0 ? void 0 : _tokenInfo$metadata6.multilocation;
+}
+function _getXcmTransferType(originChainInfo, destinationChainInfo) {
+  var _originChainInfo$subs, _destinationChainInfo;
+  return `${((_originChainInfo$subs = originChainInfo.substrateInfo) === null || _originChainInfo$subs === void 0 ? void 0 : _originChainInfo$subs.chainType) || ''}-${((_destinationChainInfo = destinationChainInfo.substrateInfo) === null || _destinationChainInfo === void 0 ? void 0 : _destinationChainInfo.chainType) || ''}`;
+}
+function _isSubstrateRelayChain(chainInfo) {
+  var _chainInfo$substrateI10;
+  return ((_chainInfo$substrateI10 = chainInfo.substrateInfo) === null || _chainInfo$substrateI10 === void 0 ? void 0 : _chainInfo$substrateI10.chainType) === _types._SubstrateChainType.RELAYCHAIN;
+}
+function _isSubstrateParaChain(chainInfo) {
+  var _chainInfo$substrateI11;
+  return ((_chainInfo$substrateI11 = chainInfo.substrateInfo) === null || _chainInfo$substrateI11 === void 0 ? void 0 : _chainInfo$substrateI11.chainType) === _types._SubstrateChainType.PARACHAIN;
+}
+function _getEvmAbiExplorer(chainInfo) {
+  var _chainInfo$evmInfo3;
+  return ((_chainInfo$evmInfo3 = chainInfo.evmInfo) === null || _chainInfo$evmInfo3 === void 0 ? void 0 : _chainInfo$evmInfo3.abiExplorer) || '';
+}
+function _isAssetValuable(assetInfo) {
+  return assetInfo.hasValue;
+}
+function _getMultiChainAsset(assetInfo) {
+  return (assetInfo === null || assetInfo === void 0 ? void 0 : assetInfo.multiChainAsset) || '';
+}
+function _getAssetPriceId(assetInfo) {
+  return (assetInfo === null || assetInfo === void 0 ? void 0 : assetInfo.priceId) || '';
+}
+function _getMultiChainAssetPriceId(multiChainAsset) {
+  return (multiChainAsset === null || multiChainAsset === void 0 ? void 0 : multiChainAsset.priceId) || '';
+}
+function _getAssetSymbol(assetInfo) {
+  return (assetInfo === null || assetInfo === void 0 ? void 0 : assetInfo.symbol) || '';
+}
+function _getMultiChainAssetSymbol(multiChainAsset) {
+  return multiChainAsset.symbol;
+}
+function _getAssetOriginChain(assetInfo) {
+  return assetInfo.originChain;
+}
+function _getChainName(chainInfo) {
+  return chainInfo.name;
+}
+function _getAssetDecimals(assetInfo) {
+  return assetInfo.decimals || 0;
+}
+function _getBlockExplorerFromChain(chainInfo) {
+  let blockExplorer;
+  if (_isPureEvmChain(chainInfo)) {
+    var _chainInfo$evmInfo4;
+    blockExplorer = chainInfo === null || chainInfo === void 0 ? void 0 : (_chainInfo$evmInfo4 = chainInfo.evmInfo) === null || _chainInfo$evmInfo4 === void 0 ? void 0 : _chainInfo$evmInfo4.blockExplorer;
+  } else {
+    var _chainInfo$substrateI12;
+    blockExplorer = chainInfo === null || chainInfo === void 0 ? void 0 : (_chainInfo$substrateI12 = chainInfo.substrateInfo) === null || _chainInfo$substrateI12 === void 0 ? void 0 : _chainInfo$substrateI12.blockExplorer;
+  }
+  if (!blockExplorer) {
+    return undefined;
+  }
+  if (blockExplorer !== '' && !blockExplorer.endsWith('/')) {
+    return `${blockExplorer}/`;
+  } else {
+    return blockExplorer;
+  }
+}
+function _parseMetadataForSmartContractAsset(contractAddress) {
+  return {
+    contractAddress
+  };
+}
+function _isChainTestNet(chainInfo) {
+  return chainInfo.isTestnet || false;
+}
+function _isAssetFungibleToken(chainAsset) {
+  return ![_types._AssetType.ERC721, _types._AssetType.PSP34, _types._AssetType.UNKNOWN].includes(chainAsset.assetType);
+}
+function _getCrowdloanUrlFromChain(chainInfo) {
+  var _chainInfo$substrateI13;
+  return (chainInfo === null || chainInfo === void 0 ? void 0 : (_chainInfo$substrateI13 = chainInfo.substrateInfo) === null || _chainInfo$substrateI13 === void 0 ? void 0 : _chainInfo$substrateI13.crowdloanUrl) || '';
+}
+function _isCustomProvider(providerKey) {
+  return providerKey.startsWith(_types2._CUSTOM_PREFIX);
+}
+function _generateCustomProviderKey(index) {
+  return `${_types2._CUSTOM_PREFIX}provider-${index}`;
+}

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

@@ -0,0 +1,71 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.EventService = void 0;
+var _eventemitter = _interopRequireDefault(require("eventemitter3"));
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+// Stateless service handle runtime event on background
+
+class EventService extends _eventemitter.default {
+  pendingEvents = [];
+  lazyEmitter = new _eventemitter.default();
+  constructor() {
+    let options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {
+      lazyTime: 300
+    };
+    super();
+    this.lazyTime = options.lazyTime;
+    this.timeoutId = null;
+    this.waitKeyringReady = this.generateWaitPromise('keyring.ready');
+    this.waitAccountReady = this.generateWaitPromise('account.ready');
+    this.waitChainReady = this.generateWaitPromise('chain.ready');
+    this.waitAssetReady = this.generateWaitPromise('asset.ready');
+  }
+  generateWaitPromise(eventType) {
+    return new Promise(resolve => {
+      this.once(eventType, isReady => {
+        resolve(isReady);
+      });
+    });
+  }
+  setLazyTimeout() {
+    if (this.timeoutId) {
+      clearTimeout(this.timeoutId);
+    }
+    this.timeoutId = setTimeout(() => {
+      this.emitLazy();
+    }, this.lazyTime);
+  }
+  emitLazy() {
+    this.lazyEmitter.emit('lazy', this.pendingEvents, this.pendingEvents.map(e => e.type));
+    this.pendingEvents = [];
+    this.timeoutId = null;
+  }
+  onLazy(callback) {
+    this.lazyEmitter.on('lazy', callback);
+  }
+  offLazy(callback) {
+    this.lazyEmitter.off('lazy', callback);
+  }
+  onceLazy(callback) {
+    this.lazyEmitter.once('lazy', callback);
+  }
+  emit(eventType) {
+    for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+      args[_key - 1] = arguments[_key];
+    }
+    console.debug('Emit event: ', eventType, ...args);
+    this.pendingEvents.push({
+      type: eventType,
+      data: args
+    });
+    this.setLazyTimeout();
+    return super.emit(eventType, ...args);
+  }
+}
+exports.EventService = EventService;

package/cjs/services/event-service/types.js

@@ -0,0 +1 @@
+"use strict";

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

@@ -0,0 +1,129 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.HistoryService = void 0;
+var _constants = require("@subwallet/extension-base/constants");
+var _address = require("@subwallet/extension-base/utils/address");
+var _uiKeyring = require("@subwallet/ui-keyring");
+var _accounts = require("@subwallet/ui-keyring/observable/accounts");
+var _rxjs = require("rxjs");
+var _subsquidMultiChainHistory = require("./subsquid-multi-chain-history");
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+class HistoryService {
+  historySubject = new _rxjs.BehaviorSubject([]);
+  constructor(dbService, chainService, eventService) {
+    this.dbService = dbService;
+    this.chainService = chainService;
+    this.eventService = eventService;
+    // Load history from database
+    this.dbService.getHistories().then(histories => {
+      this.historySubject.next(histories);
+    }).catch(console.error);
+
+    // Wait for keyring and chain ready and start
+    Promise.all([this.eventService.waitKeyringReady, this.eventService.waitChainReady]).then(() => {
+      this.getHistories().catch(console.log);
+      this.eventService.on('account.add', () => {
+        this.refreshHistoryInterval();
+      });
+      this.eventService.on('account.remove', address => {
+        this.removeHistoryByAddress(address).catch(console.error);
+      });
+    }).catch(console.error);
+  }
+  fetchPromise = null;
+  nextFetch = undefined;
+  async fetchAndLoadHistories(addresses) {
+    if (!addresses || addresses.length === 0) {
+      return [];
+    }
+    const chainMap = this.chainService.getChainInfoMap();
+
+    // Query data from subscan or any indexer
+    const historyRecords = await (0, _subsquidMultiChainHistory.fetchMultiChainHistories)(addresses, chainMap);
+
+    // Fill additional info
+    const accountMap = Object.entries(_accounts.accounts.subject.value).reduce((map, _ref) => {
+      let [address, account] = _ref;
+      map[address.toLowerCase()] = account.json.meta.name || address;
+      return map;
+    }, {});
+    historyRecords.forEach(record => {
+      var _record$from, _record$to;
+      record.fromName = accountMap[(_record$from = record.from) === null || _record$from === void 0 ? void 0 : _record$from.toLowerCase()];
+      record.toName = accountMap[(_record$to = record.to) === null || _record$to === void 0 ? void 0 : _record$to.toLowerCase()];
+    });
+    this.dbService.upsertHistory(historyRecords).catch(console.error);
+    return historyRecords;
+  }
+  async fetchHistories(addresses) {
+    if (!this.fetchPromise) {
+      // Fetch another histories data data indexer and merge it with stored in database
+      this.fetchPromise = this.fetchAndLoadHistories(addresses);
+    }
+    return this.fetchPromise;
+  }
+  invalidCache() {
+    this.fetchPromise = null;
+  }
+  refreshHistoryInterval() {
+    clearTimeout(this.nextFetch);
+    this.invalidCache();
+    this.getHistories().catch(console.error);
+    this.nextFetch = setTimeout(() => {
+      this.refreshHistoryInterval();
+    }, _constants.CRON_REFRESH_HISTORY_INTERVAL);
+  }
+  async getHistories() {
+    const addressList = _uiKeyring.keyring.getAccounts().map(a => a.address);
+    const currentHistories = this.historySubject.value;
+    if (!this.fetchPromise || currentHistories.length === 0) {
+      const historyRecords = await this.fetchHistories(addressList);
+      this.historySubject.next(historyRecords);
+    }
+    return this.historySubject.getValue();
+  }
+  async getHistorySubject() {
+    await this.getHistories();
+    return this.historySubject;
+  }
+  async insertHistories(historyItems) {
+    await this.dbService.upsertHistory(historyItems);
+    this.historySubject.next(await this.dbService.getHistories());
+  }
+  async updateHistories(chain, extrinsicHash, updateData) {
+    const existedRecords = await this.dbService.getHistories({
+      chain,
+      extrinsicHash
+    });
+    const updatedRecords = existedRecords.map(r => {
+      return {
+        ...r,
+        ...updateData
+      };
+    });
+    await this.addHistoryItems(updatedRecords);
+  }
+  async addHistoryItems(historyItems) {
+    // Prevent override record with original is 'app'
+    const appRecords = this.historySubject.value.filter(item => item.origin === 'app');
+    const excludeKeys = appRecords.map(item => {
+      return `${item.chain}-${(0, _address.quickFormatAddressToCompare)(item.address) || ''}-${item.extrinsicHash}`;
+    });
+    const updateRecords = historyItems.filter(item => {
+      const key = `${item.chain}-${(0, _address.quickFormatAddressToCompare)(item.address) || ''}-${item.extrinsicHash}`;
+      return item.origin === 'app' || !excludeKeys.includes(key);
+    });
+    await this.dbService.upsertHistory(updateRecords);
+    this.historySubject.next(await this.dbService.getHistories());
+  }
+  async removeHistoryByAddress(address) {
+    await this.dbService.stores.transaction.removeAllByAddress(address);
+    this.historySubject.next(await this.dbService.getHistories());
+  }
+}
+exports.HistoryService = HistoryService;