@subwallet/extension-base 0.8.3-2 → 1.0.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,64 @@
+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 _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,321 @@
+// 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 _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/history-service/index.d.ts

@@ -0,0 +1,22 @@
+import { TransactionHistoryItem } from '@subwallet/extension-base/background/KoniTypes';
+import { ChainService } from '@subwallet/extension-base/services/chain-service';
+import DatabaseService from '@subwallet/extension-base/services/storage-service/DatabaseService';
+import { BehaviorSubject } from 'rxjs';
+export declare class HistoryService {
+    private dbService;
+    private chainService;
+    private historySubject;
+    constructor(dbService: DatabaseService, chainService: ChainService);
+    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>[]>>;
+    insertHistory(historyItem: TransactionHistoryItem): Promise<void>;
+    updateHistory(chain: string, extrinsicHash: string, historyItem: Partial<TransactionHistoryItem>): Promise<void>;
+    addHistoryItems(historyItems: TransactionHistoryItem[]): Promise<void>;
+    removeHistoryByAddress(address: string): Promise<void>;
+}

package/services/history-service/index.js

@@ -0,0 +1,102 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+import { CRON_REFRESH_HISTORY_INTERVAL } from '@subwallet/extension-base/constants';
+import { accounts } from '@subwallet/ui-keyring/observable/accounts';
+import { BehaviorSubject } from 'rxjs';
+import { fetchMultiChainHistories } from "./subsquid-multi-chain-history.js";
+export class HistoryService {
+  historySubject = new BehaviorSubject([]);
+  constructor(dbService, chainService) {
+    this.dbService = dbService;
+    this.chainService = chainService;
+
+    // Load history from database
+    this.dbService.getHistories().then(histories => {
+      this.historySubject.next(histories);
+    }).catch(console.error);
+
+    // Add some delay to avoid fetching many times when start extension background
+    setTimeout(() => {
+      // Create history interval and refresh it if changes accounts list
+      accounts.subject.subscribe(this.refreshHistoryInterval.bind(this));
+    }, 3333);
+  }
+  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 fetchMultiChainHistories(addresses, chainMap);
+
+    // Fill additional info
+    const accountMap = Object.entries(accounts.subject.value).reduce((map, [address, account]) => {
+      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()];
+    });
+    await this.dbService.upsertHistory(historyRecords);
+    return await this.dbService.getHistories();
+  }
+  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.bind(this), CRON_REFRESH_HISTORY_INTERVAL);
+  }
+  async getHistories() {
+    const addressList = Object.keys(accounts.subject.value);
+    if (!this.fetchPromise) {
+      const historyRecords = await this.fetchHistories(addressList);
+      this.historySubject.next(historyRecords);
+    }
+    return this.historySubject.getValue();
+  }
+  async getHistorySubject() {
+    await this.getHistories();
+    return this.historySubject;
+  }
+  async insertHistory(historyItem) {
+    await this.dbService.upsertHistory([historyItem]);
+    this.historySubject.next(await this.dbService.getHistories());
+  }
+  async updateHistory(chain, extrinsicHash, historyItem) {
+    const existedRecords = await this.dbService.getHistories({
+      chain,
+      extrinsicHash
+    });
+    const updatedRecords = existedRecords.map(r => {
+      return {
+        ...r,
+        ...historyItem
+      };
+    });
+    await this.addHistoryItems(updatedRecords);
+  }
+  async addHistoryItems(historyItems) {
+    await this.dbService.upsertHistory(historyItems);
+    this.historySubject.next(await this.dbService.getHistories());
+  }
+  async removeHistoryByAddress(address) {
+    await this.dbService.stores.transaction.removeAllByAddress(address);
+    this.historySubject.next(await this.dbService.getHistories());
+  }
+}

package/services/history-service/subsquid-multi-chain-history.d.ts

@@ -0,0 +1,30 @@
+import { _ChainInfo } from '@subwallet/chain-list/types';
+import { ExtrinsicType, TransactionHistoryItem } from '@subwallet/extension-base/background/KoniTypes';
+export interface MultiHistoryData {
+    _data: string;
+    args: string;
+    chainId: string;
+    id: string;
+    signer: string;
+    name: string;
+    timestamp: number | string;
+    blockNumber: number;
+    blockHash: string;
+    explorerUrl: string;
+    relatedAddresses: string[];
+}
+export declare enum SubsquidTransactionType {
+    BalanceTransfer = "Balances.Transfer",
+    EthereumExecuted = "Ethereum.Executed",
+    StakingBonded = "Staking.Bonded",
+    CrowdloanContributed = "Crowdloan.Contributed"
+}
+export interface ParseInputType {
+    type: SubsquidTransactionType;
+    data: MultiHistoryData;
+    chainInfo: _ChainInfo;
+}
+export declare type TransactionBasicData = Pick<TransactionHistoryItem, 'address' | 'origin' | 'time' | 'chainType' | 'from' | 'direction' | 'blockNumber' | 'blockHash' | 'chain' | 'data'>;
+export declare type TransactionSpecifyType = Pick<TransactionHistoryItem, 'to' | 'type' | 'status' | 'fee' | 'amount' | 'tip' | 'signature' | 'extrinsicHash'>;
+export declare function parseSubsquidTransactionData(address: string, type: SubsquidTransactionType, historyItem: MultiHistoryData, chainInfo: _ChainInfo, args: any, data: any): TransactionHistoryItem;
+export declare function fetchMultiChainHistories(addresses: string[], chainMap: Record<string, _ChainInfo>, maxPage?: number): Promise<TransactionHistoryItem<ExtrinsicType.TRANSFER_BALANCE>[]>;