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

package/services/chain-service/types.d.ts

@@ -0,0 +1,110 @@
+import { _AssetRef, _AssetType, _ChainAsset, _ChainInfo } from '@subwallet/chain-list/types';
+import Web3 from 'web3';
+import { ApiPromise } from '@polkadot/api';
+import { SubmittableExtrinsicFunction } from '@polkadot/api/promise/types';
+import { ChainProperties, ChainType } from '@polkadot/types/interfaces';
+import { Registry } from '@polkadot/types/types';
+export interface _DataMap {
+    chainInfoMap: Record<string, _ChainInfo>;
+    chainStateMap: Record<string, _ChainState>;
+    assetRegistry: Record<string, _ChainAsset>;
+    assetRefMap: Record<string, _AssetRef>;
+}
+export declare enum _ChainConnectionStatus {
+    CONNECTED = "CONNECTED",
+    DISCONNECTED = "DISCONNECTED",
+    UNSTABLE = "UNSTABLE",
+    CONNECTING = "CONNECTING"
+}
+export interface _ChainState {
+    slug: string;
+    active: boolean;
+    currentProvider: string;
+    connectionStatus: _ChainConnectionStatus;
+}
+export interface _SubstrateDefaultFormatBalance {
+    decimals?: number[] | number;
+    unit?: string[] | string;
+}
+export interface _ChainBaseApi {
+    chainSlug: string;
+    apiUrl: string;
+    providerName?: string;
+    apiError?: string;
+    apiRetry?: number;
+    isApiReady: boolean;
+    isApiReadyOnce: boolean;
+    isApiConnected: boolean;
+    isApiInitialized: boolean;
+    isDevelopment?: boolean;
+    recoverConnect?: () => void;
+    isReady: Promise<any>;
+}
+export interface _SubstrateChainMetadata {
+    properties: ChainProperties;
+    systemChain: string;
+    systemChainType: ChainType;
+    systemName: string;
+    systemVersion: string;
+}
+export interface _SubstrateApiState {
+    apiDefaultTx?: SubmittableExtrinsicFunction;
+    apiDefaultTxSudo?: SubmittableExtrinsicFunction;
+    defaultFormatBalance?: _SubstrateDefaultFormatBalance;
+}
+export interface _SubstrateApi extends _SubstrateApiState, _ChainBaseApi {
+    api: ApiPromise;
+    isNotSupport?: boolean;
+    isReady: Promise<_SubstrateApi>;
+    specName: string;
+    specVersion: string;
+    systemChain: string;
+    systemName: string;
+    systemVersion: string;
+    registry: Registry;
+}
+export interface _EvmApi extends _ChainBaseApi {
+    api: Web3;
+    isReady: Promise<_EvmApi>;
+}
+export declare type _NetworkUpsertParams = {
+    mode: 'update' | 'insert';
+    chainEditInfo: {
+        chainType?: string;
+        currentProvider: string;
+        name?: string;
+        providers: Record<string, string>;
+        slug: string;
+        symbol?: string;
+        blockExplorer?: string;
+        crowdloanUrl?: string;
+        priceId?: string;
+    };
+    chainSpec?: {
+        genesisHash: string;
+        paraId: number | null;
+        addressPrefix: number;
+        evmChainId: number | null;
+        existentialDeposit: string;
+        decimals: number;
+    };
+};
+export declare const _CUSTOM_PREFIX = "custom-";
+export interface _ValidateCustomAssetRequest {
+    contractAddress: string;
+    originChain: string;
+    type: _AssetType;
+    contractCaller?: string;
+}
+export interface _SmartContractTokenInfo {
+    name: string;
+    symbol: string;
+    decimals: number;
+    contractError: boolean;
+}
+export interface _ValidateCustomAssetResponse extends _SmartContractTokenInfo {
+    isExist: boolean;
+}
+export declare const _FUNGIBLE_CONTRACT_STANDARDS: _AssetType[];
+export declare const _NFT_CONTRACT_STANDARDS: _AssetType[];
+export declare const _SMART_CONTRACT_STANDARDS: _AssetType[];

package/services/chain-service/types.js

@@ -0,0 +1,17 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+/* eslint @typescript-eslint/no-empty-interface: "off" */
+
+import { _AssetType } from '@subwallet/chain-list/types';
+export let _ChainConnectionStatus;
+(function (_ChainConnectionStatus) {
+  _ChainConnectionStatus["CONNECTED"] = "CONNECTED";
+  _ChainConnectionStatus["DISCONNECTED"] = "DISCONNECTED";
+  _ChainConnectionStatus["UNSTABLE"] = "UNSTABLE";
+  _ChainConnectionStatus["CONNECTING"] = "CONNECTING";
+})(_ChainConnectionStatus || (_ChainConnectionStatus = {}));
+export const _CUSTOM_PREFIX = 'custom-';
+export const _FUNGIBLE_CONTRACT_STANDARDS = [_AssetType.ERC20, _AssetType.PSP22];
+export const _NFT_CONTRACT_STANDARDS = [_AssetType.PSP34, _AssetType.ERC721];
+export const _SMART_CONTRACT_STANDARDS = [..._FUNGIBLE_CONTRACT_STANDARDS, ..._NFT_CONTRACT_STANDARDS];

package/services/chain-service/utils.d.ts

@@ -0,0 +1,65 @@
+import { _AssetRef, _AssetType, _ChainAsset, _ChainInfo, _MultiChainAsset } from '@subwallet/chain-list/types';
+import { BasicTokenInfo } from '@subwallet/extension-base/background/KoniTypes';
+import { _ChainState } from '@subwallet/extension-base/services/chain-service/types';
+export declare function _isCustomChain(slug: string): boolean;
+export declare function _isCustomAsset(slug: string): boolean;
+export declare function _getCustomAssets(assetRegistry: Record<string, _ChainAsset>): Record<string, _ChainAsset>;
+export declare function _isEqualContractAddress(address1: string, address2: string): boolean;
+export declare function _isEqualSmartContractAsset(asset1: _ChainAsset, asset2: _ChainAsset): boolean;
+export declare function _isPureEvmChain(chainInfo: _ChainInfo): boolean;
+export declare function _isPureSubstrateChain(chainInfo: _ChainInfo): boolean;
+export declare function _getOriginChainOfAsset(assetSlug: string): string;
+export declare function _getContractAddressOfToken(tokenInfo: _ChainAsset): string;
+export declare function _checkSmartContractSupportByChain(chainInfo: _ChainInfo, contractType: _AssetType): boolean;
+export declare function _getTokenOnChainAssetId(tokenInfo: _ChainAsset): string;
+export declare function _getTokenOnChainInfo(tokenInfo: _ChainAsset): Record<string, any>;
+export declare function _getTokenMinAmount(tokenInfo: _ChainAsset): string;
+export declare function _isChainEvmCompatible(chainInfo: _ChainInfo): boolean;
+export declare function _isNativeToken(tokenInfo: _ChainAsset): boolean;
+export declare function _isNativeTokenBySlug(tokenSlug: string): boolean;
+export declare function _isSmartContractToken(tokenInfo: _ChainAsset): boolean;
+export declare function _isSubstrateChain(chainInfo: _ChainInfo): boolean;
+export declare function _getEvmChainId(chainInfo: _ChainInfo): number;
+export declare function _getSubstrateParaId(chainInfo: _ChainInfo): number;
+export declare function _getSubstrateRelayParent(chainInfo: _ChainInfo): string;
+export declare function _getSubstrateGenesisHash(chainInfo: _ChainInfo): string;
+export declare function _isChainSupportSubstrateStaking(chainInfo: _ChainInfo): boolean;
+export declare function _isChainEnabled(chainState: _ChainState): boolean;
+export declare function _isSubstrateParachain(chainInfo: _ChainInfo): boolean;
+export declare function _getChainSubstrateAddressPrefix(chainInfo: _ChainInfo): number;
+export declare function _isChainSupportNativeNft(chainInfo: _ChainInfo): boolean;
+export declare function _isChainSupportEvmNft(chainInfo: _ChainInfo): boolean;
+export declare function _isChainSupportWasmNft(chainInfo: _ChainInfo): boolean;
+export declare function _getNftTypesSupportedByChain(chainInfo: _ChainInfo): _AssetType[];
+export declare function _getTokenTypesSupportedByChain(chainInfo: _ChainInfo): _AssetType[];
+export declare function _getChainNativeTokenBasicInfo(chainInfo: _ChainInfo): BasicTokenInfo;
+export declare function _getChainNativeTokenSlug(chainInfo: _ChainInfo): string;
+export declare function _isLocalToken(tokenInfo: _ChainAsset): boolean;
+export declare function _isTokenEvmSmartContract(tokenInfo: _ChainAsset): boolean;
+export declare function _isTokenWasmSmartContract(tokenInfo: _ChainAsset): boolean;
+export declare function _isAssetSmartContractNft(assetInfo: _ChainAsset): boolean;
+export declare function _parseAssetRefKey(originTokenSlug: string, destinationTokenSlug: string): string;
+export declare function _isXcmPathSupported(originTokenSlug: string, destinationTokenSlug: string, assetRefMap: Record<string, _AssetRef>): boolean;
+export declare function _getXcmAssetType(tokenInfo: _ChainAsset): string;
+export declare function _getXcmAssetId(tokenInfo: _ChainAsset): string;
+export declare function _getXcmAssetMultilocation(tokenInfo: _ChainAsset): Record<string, any>;
+export declare function _getXcmTransferType(originChainInfo: _ChainInfo, destinationChainInfo: _ChainInfo): string;
+export declare function _isSubstrateRelayChain(chainInfo: _ChainInfo): boolean;
+export declare function _isSubstrateParaChain(chainInfo: _ChainInfo): boolean;
+export declare function _getEvmAbiExplorer(chainInfo: _ChainInfo): string;
+export declare function _isAssetValuable(assetInfo: _ChainAsset): boolean;
+export declare function _getMultiChainAsset(assetInfo: _ChainAsset): string;
+export declare function _getAssetPriceId(assetInfo: _ChainAsset): string;
+export declare function _getMultiChainAssetPriceId(multiChainAsset: _MultiChainAsset): string;
+export declare function _getAssetSymbol(assetInfo: _ChainAsset): string;
+export declare function _getMultiChainAssetSymbol(multiChainAsset: _MultiChainAsset): string;
+export declare function _getAssetOriginChain(assetInfo: _ChainAsset): string;
+export declare function _getChainName(chainInfo: _ChainInfo): string;
+export declare function _getAssetDecimals(assetInfo: _ChainAsset): number;
+export declare function _getBlockExplorerFromChain(chainInfo: _ChainInfo): string | undefined;
+export declare function _parseMetadataForSmartContractAsset(contractAddress: string): Record<string, string>;
+export declare function _isChainTestNet(chainInfo: _ChainInfo): boolean;
+export declare function _isAssetFungibleToken(chainAsset: _ChainAsset): boolean;
+export declare function _getCrowdloanUrlFromChain(chainInfo: _ChainInfo): string;
+export declare function _isCustomProvider(providerKey: string): boolean;
+export declare function _generateCustomProviderKey(index: number): string;

package/services/chain-service/utils.js

@@ -0,0 +1,324 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+import { _AssetRefPath, _AssetType, _SubstrateChainType } from '@subwallet/chain-list/types';
+import { _CUSTOM_PREFIX, _SMART_CONTRACT_STANDARDS } from '@subwallet/extension-base/services/chain-service/types';
+import { isEthereumAddress } from '@polkadot/util-crypto';
+export function _isCustomChain(slug) {
+  if (slug.length === 0) {
+    return true;
+  }
+  return slug.startsWith(_CUSTOM_PREFIX);
+}
+export function _isCustomAsset(slug) {
+  // might be different from _isCustomNetwork
+  if (slug.length === 0) {
+    return true;
+  }
+  return slug.startsWith(_CUSTOM_PREFIX);
+}
+export function _getCustomAssets(assetRegistry) {
+  const filteredAssetMap = {};
+  Object.values(assetRegistry).forEach(chainAsset => {
+    if (_isCustomAsset(chainAsset.slug)) {
+      filteredAssetMap[chainAsset.slug] = chainAsset;
+    }
+  });
+  return filteredAssetMap;
+}
+export function _isEqualContractAddress(address1, address2) {
+  if (isEthereumAddress(address1) && isEthereumAddress(address2)) {
+    return address1.toLowerCase() === address2.toLowerCase(); // EVM address is case-insensitive
+  }
+
+  return address2 === address1;
+}
+export 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;
+}
+export function _isPureEvmChain(chainInfo) {
+  return chainInfo.evmInfo !== null && chainInfo.substrateInfo === null;
+}
+export function _isPureSubstrateChain(chainInfo) {
+  return chainInfo.evmInfo === null && chainInfo.substrateInfo !== null;
+}
+export function _getOriginChainOfAsset(assetSlug) {
+  if (assetSlug.startsWith(_CUSTOM_PREFIX)) {
+    return assetSlug.split('-')[1];
+  }
+  return assetSlug.split('-')[0];
+}
+export function _getContractAddressOfToken(tokenInfo) {
+  var _tokenInfo$metadata;
+  return ((_tokenInfo$metadata = tokenInfo.metadata) === null || _tokenInfo$metadata === void 0 ? void 0 : _tokenInfo$metadata.contractAddress) || '';
+}
+export 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
+export function _getTokenOnChainAssetId(tokenInfo) {
+  var _tokenInfo$metadata2;
+  return ((_tokenInfo$metadata2 = tokenInfo.metadata) === null || _tokenInfo$metadata2 === void 0 ? void 0 : _tokenInfo$metadata2.assetId) || '-1';
+}
+export function _getTokenOnChainInfo(tokenInfo) {
+  var _tokenInfo$metadata3;
+  return (_tokenInfo$metadata3 = tokenInfo.metadata) === null || _tokenInfo$metadata3 === void 0 ? void 0 : _tokenInfo$metadata3.onChainInfo;
+}
+export function _getTokenMinAmount(tokenInfo) {
+  return tokenInfo.minAmount || '0';
+}
+export function _isChainEvmCompatible(chainInfo) {
+  return chainInfo.evmInfo !== undefined && chainInfo.evmInfo !== null;
+}
+export function _isNativeToken(tokenInfo) {
+  return tokenInfo.assetType === _AssetType.NATIVE;
+}
+export function _isNativeTokenBySlug(tokenSlug) {
+  return tokenSlug.includes(_AssetType.NATIVE);
+}
+export function _isSmartContractToken(tokenInfo) {
+  return _SMART_CONTRACT_STANDARDS.includes(tokenInfo.assetType);
+}
+export function _isSubstrateChain(chainInfo) {
+  return !!chainInfo.substrateInfo; // fallback to Ethereum
+}
+
+export 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
+}
+
+export function _getSubstrateParaId(chainInfo) {
+  var _chainInfo$substrateI;
+  return ((_chainInfo$substrateI = chainInfo.substrateInfo) === null || _chainInfo$substrateI === void 0 ? void 0 : _chainInfo$substrateI.paraId) || -1;
+}
+export function _getSubstrateRelayParent(chainInfo) {
+  var _chainInfo$substrateI2;
+  return ((_chainInfo$substrateI2 = chainInfo.substrateInfo) === null || _chainInfo$substrateI2 === void 0 ? void 0 : _chainInfo$substrateI2.relaySlug) || '';
+}
+export function _getSubstrateGenesisHash(chainInfo) {
+  var _chainInfo$substrateI3;
+  return ((_chainInfo$substrateI3 = chainInfo.substrateInfo) === null || _chainInfo$substrateI3 === void 0 ? void 0 : _chainInfo$substrateI3.genesisHash) || '';
+}
+export function _isChainSupportSubstrateStaking(chainInfo) {
+  var _chainInfo$substrateI4;
+  return ((_chainInfo$substrateI4 = chainInfo.substrateInfo) === null || _chainInfo$substrateI4 === void 0 ? void 0 : _chainInfo$substrateI4.supportStaking) || false;
+}
+export function _isChainEnabled(chainState) {
+  return chainState.active;
+}
+export function _isSubstrateParachain(chainInfo) {
+  return chainInfo.substrateInfo !== null && chainInfo.substrateInfo.paraId !== null;
+}
+export 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;
+}
+export function _isChainSupportNativeNft(chainInfo) {
+  var _chainInfo$substrateI7;
+  return ((_chainInfo$substrateI7 = chainInfo.substrateInfo) === null || _chainInfo$substrateI7 === void 0 ? void 0 : _chainInfo$substrateI7.hasNativeNft) || false;
+}
+export 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(_AssetType.ERC721)) || false;
+}
+export 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(_AssetType.PSP34)) || false;
+}
+export function _getNftTypesSupportedByChain(chainInfo) {
+  const result = [];
+  if (chainInfo.substrateInfo && chainInfo.substrateInfo.supportSmartContract) {
+    chainInfo.substrateInfo.supportSmartContract.forEach(assetType => {
+      if ([_AssetType.PSP34].includes(assetType)) {
+        result.push(assetType);
+      }
+    });
+  }
+  if (chainInfo.evmInfo && chainInfo.evmInfo.supportSmartContract) {
+    chainInfo.evmInfo.supportSmartContract.forEach(assetType => {
+      if ([_AssetType.ERC721].includes(assetType)) {
+        result.push(assetType);
+      }
+    });
+  }
+  return result;
+}
+export function _getTokenTypesSupportedByChain(chainInfo) {
+  const result = [];
+  if (chainInfo.substrateInfo && chainInfo.substrateInfo.supportSmartContract) {
+    chainInfo.substrateInfo.supportSmartContract.forEach(assetType => {
+      if ([_AssetType.PSP22].includes(assetType)) {
+        result.push(assetType);
+      }
+    });
+  }
+  if (chainInfo.evmInfo && chainInfo.evmInfo.supportSmartContract) {
+    chainInfo.evmInfo.supportSmartContract.forEach(assetType => {
+      if ([_AssetType.ERC20].includes(assetType)) {
+        result.push(assetType);
+      }
+    });
+  }
+  return result;
+}
+export 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
+  };
+}
+export function _getChainNativeTokenSlug(chainInfo) {
+  if (_isCustomChain(chainInfo.slug)) {
+    return `${_CUSTOM_PREFIX}${chainInfo.slug}-${_AssetType.NATIVE}-${_getChainNativeTokenBasicInfo(chainInfo).symbol}`;
+  }
+  return `${chainInfo.slug}-${_AssetType.NATIVE}-${_getChainNativeTokenBasicInfo(chainInfo).symbol}`;
+}
+export function _isLocalToken(tokenInfo) {
+  return tokenInfo.assetType === _AssetType.LOCAL;
+}
+export function _isTokenEvmSmartContract(tokenInfo) {
+  return [_AssetType.ERC721, _AssetType.ERC20].includes(tokenInfo.assetType);
+}
+export function _isTokenWasmSmartContract(tokenInfo) {
+  return [_AssetType.PSP22, _AssetType.PSP34].includes(tokenInfo.assetType);
+}
+export function _isAssetSmartContractNft(assetInfo) {
+  return [_AssetType.PSP34, _AssetType.ERC721].includes(assetInfo.assetType);
+}
+export function _parseAssetRefKey(originTokenSlug, destinationTokenSlug) {
+  return `${originTokenSlug}___${destinationTokenSlug}`;
+}
+export function _isXcmPathSupported(originTokenSlug, destinationTokenSlug, assetRefMap) {
+  const assetRef = assetRefMap[_parseAssetRefKey(originTokenSlug, destinationTokenSlug)];
+  if (!assetRef) {
+    return false;
+  }
+  return assetRef.path === _AssetRefPath.XCM;
+}
+export function _getXcmAssetType(tokenInfo) {
+  var _tokenInfo$metadata4;
+  return ((_tokenInfo$metadata4 = tokenInfo.metadata) === null || _tokenInfo$metadata4 === void 0 ? void 0 : _tokenInfo$metadata4.assetType) || '';
+}
+export function _getXcmAssetId(tokenInfo) {
+  var _tokenInfo$metadata5;
+  return ((_tokenInfo$metadata5 = tokenInfo.metadata) === null || _tokenInfo$metadata5 === void 0 ? void 0 : _tokenInfo$metadata5.assetId) || '-1';
+}
+export function _getXcmAssetMultilocation(tokenInfo) {
+  var _tokenInfo$metadata6;
+  return (_tokenInfo$metadata6 = tokenInfo.metadata) === null || _tokenInfo$metadata6 === void 0 ? void 0 : _tokenInfo$metadata6.multilocation;
+}
+export 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) || ''}`;
+}
+export function _isSubstrateRelayChain(chainInfo) {
+  var _chainInfo$substrateI10;
+  return ((_chainInfo$substrateI10 = chainInfo.substrateInfo) === null || _chainInfo$substrateI10 === void 0 ? void 0 : _chainInfo$substrateI10.chainType) === _SubstrateChainType.RELAYCHAIN;
+}
+export function _isSubstrateParaChain(chainInfo) {
+  var _chainInfo$substrateI11;
+  return ((_chainInfo$substrateI11 = chainInfo.substrateInfo) === null || _chainInfo$substrateI11 === void 0 ? void 0 : _chainInfo$substrateI11.chainType) === _SubstrateChainType.PARACHAIN;
+}
+export function _getEvmAbiExplorer(chainInfo) {
+  var _chainInfo$evmInfo3;
+  return ((_chainInfo$evmInfo3 = chainInfo.evmInfo) === null || _chainInfo$evmInfo3 === void 0 ? void 0 : _chainInfo$evmInfo3.abiExplorer) || '';
+}
+export function _isAssetValuable(assetInfo) {
+  return assetInfo.hasValue;
+}
+export function _getMultiChainAsset(assetInfo) {
+  return (assetInfo === null || assetInfo === void 0 ? void 0 : assetInfo.multiChainAsset) || '';
+}
+export function _getAssetPriceId(assetInfo) {
+  return (assetInfo === null || assetInfo === void 0 ? void 0 : assetInfo.priceId) || '';
+}
+export function _getMultiChainAssetPriceId(multiChainAsset) {
+  return (multiChainAsset === null || multiChainAsset === void 0 ? void 0 : multiChainAsset.priceId) || '';
+}
+export function _getAssetSymbol(assetInfo) {
+  return (assetInfo === null || assetInfo === void 0 ? void 0 : assetInfo.symbol) || '';
+}
+export function _getMultiChainAssetSymbol(multiChainAsset) {
+  return multiChainAsset.symbol;
+}
+export function _getAssetOriginChain(assetInfo) {
+  return assetInfo.originChain;
+}
+export function _getChainName(chainInfo) {
+  return chainInfo.name;
+}
+export function _getAssetDecimals(assetInfo) {
+  return assetInfo.decimals || 0;
+}
+export 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;
+  }
+}
+export function _parseMetadataForSmartContractAsset(contractAddress) {
+  return {
+    contractAddress
+  };
+}
+export function _isChainTestNet(chainInfo) {
+  return chainInfo.isTestnet || false;
+}
+export function _isAssetFungibleToken(chainAsset) {
+  return ![_AssetType.ERC721, _AssetType.PSP34, _AssetType.UNKNOWN].includes(chainAsset.assetType);
+}
+export 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) || '';
+}
+export function _isCustomProvider(providerKey) {
+  return providerKey.startsWith(_CUSTOM_PREFIX);
+}
+export function _generateCustomProviderKey(index) {
+  return `${_CUSTOM_PREFIX}provider-${index}`;
+}

package/services/event-service/index.d.ts

@@ -0,0 +1,22 @@
+import { EventItem, EventRegistry, EventType } from '@subwallet/extension-base/services/event-service/types';
+import EventEmitter from 'eventemitter3';
+export declare class EventService extends EventEmitter<EventRegistry> {
+    private lazyTime;
+    private timeoutId;
+    private pendingEvents;
+    private lazyEmitter;
+    readonly waitKeyringReady: Promise<boolean>;
+    readonly waitAccountReady: Promise<boolean>;
+    readonly waitChainReady: Promise<boolean>;
+    readonly waitAssetReady: Promise<boolean>;
+    constructor(options?: {
+        lazyTime: number;
+    });
+    private generateWaitPromise;
+    private setLazyTimeout;
+    private emitLazy;
+    onLazy(callback: (events: EventItem<EventType>[], eventTypes: EventType[]) => void): void;
+    offLazy(callback: (events: EventItem<EventType>[], eventTypes: EventType[]) => void): void;
+    onceLazy(callback: (events: EventItem<EventType>[], eventTypes: EventType[]) => void): void;
+    emit<T extends EventType>(eventType: T, ...args: EventEmitter.EventArgs<EventRegistry, T>): boolean;
+}

package/services/event-service/index.js

@@ -0,0 +1,59 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+// Stateless service handle runtime event on background
+
+import EventEmitter from 'eventemitter3';
+export class EventService extends EventEmitter {
+  pendingEvents = [];
+  lazyEmitter = new EventEmitter();
+  constructor(options = {
+    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, ...args) {
+    console.debug('Emit event: ', eventType, ...args);
+    this.pendingEvents.push({
+      type: eventType,
+      data: args
+    });
+    this.setLazyTimeout();
+    return super.emit(eventType, ...args);
+  }
+}

package/services/event-service/types.d.ts

@@ -0,0 +1,32 @@
+import { CurrentAccountInfo } from '@subwallet/extension-base/background/KoniTypes';
+import { SWTransaction } from '@subwallet/extension-base/services/transaction-service/types';
+export interface EventRegistry {
+    'keyring.ready': [boolean];
+    'account.updateCurrent': [CurrentAccountInfo];
+    'account.ready': [boolean];
+    'account.add': [string];
+    'account.update': [string];
+    'account.remove': [string];
+    'chain.ready': [boolean];
+    'chain.add': [string];
+    'chain.update': [string];
+    'chain.disable': [string];
+    'chain.enable': [string];
+    'chain.remove': [string];
+    'asset.ready': [boolean];
+    'asset.add': [string];
+    'asset.update': [string];
+    'asset.enable': [string];
+    'asset.disable': [string];
+    'asset.remove': [string];
+    'transaction.done': [SWTransaction];
+    'transaction.failed': [SWTransaction | undefined];
+}
+export declare type EventType = keyof EventRegistry;
+export interface EventItem<T extends EventType> {
+    type: T;
+    data: EventRegistry[T];
+}
+export interface EventEmitterRegistry extends EventRegistry {
+    lazy: EventItem<EventType>[];
+}

package/services/event-service/types.js

@@ -0,0 +1 @@
+export {};

package/services/history-service/index.d.ts

@@ -0,0 +1,24 @@
+import { TransactionHistoryItem } from '@subwallet/extension-base/background/KoniTypes';
+import { ChainService } from '@subwallet/extension-base/services/chain-service';
+import { EventService } from '@subwallet/extension-base/services/event-service';
+import DatabaseService from '@subwallet/extension-base/services/storage-service/DatabaseService';
+import { BehaviorSubject } from 'rxjs';
+export declare class HistoryService {
+    private dbService;
+    private chainService;
+    private eventService;
+    private historySubject;
+    constructor(dbService: DatabaseService, chainService: ChainService, eventService: EventService);
+    private fetchPromise;
+    private nextFetch;
+    private fetchAndLoadHistories;
+    fetchHistories(addresses: string[]): Promise<TransactionHistoryItem<import("@subwallet/extension-base/background/KoniTypes").ExtrinsicType.TRANSFER_BALANCE>[]>;
+    invalidCache(): void;
+    refreshHistoryInterval(): void;
+    getHistories(): Promise<TransactionHistoryItem<import("@subwallet/extension-base/background/KoniTypes").ExtrinsicType.TRANSFER_BALANCE>[]>;
+    getHistorySubject(): Promise<BehaviorSubject<TransactionHistoryItem<import("@subwallet/extension-base/background/KoniTypes").ExtrinsicType.TRANSFER_BALANCE>[]>>;
+    insertHistories(historyItems: TransactionHistoryItem[]): Promise<void>;
+    updateHistories(chain: string, extrinsicHash: string, updateData: Partial<TransactionHistoryItem>): Promise<void>;
+    addHistoryItems(historyItems: TransactionHistoryItem[]): Promise<void>;
+    removeHistoryByAddress(address: string): Promise<void>;
+}