@subwallet/extension-base 1.2.14-0 → 1.2.16-0

package/services/chain-service/handler/SubstrateChainHandler.js

@@ -6,9 +6,8 @@ import { _AssetType } from '@subwallet/chain-list/types';
 import { getDefaultWeightV2 } from '@subwallet/extension-base/koni/api/contract-handler/wasm/utils';
 import { AbstractChainHandler } from '@subwallet/extension-base/services/chain-service/handler/AbstractChainHandler';
 import { SubstrateApi } from '@subwallet/extension-base/services/chain-service/handler/SubstrateApi';
-import { DEFAULT_GEAR_ADDRESS, getGRC20ContractPromise } from '@subwallet/extension-base/utils';
+import { cacheMetadata, GEAR_DEFAULT_ADDRESS, getGRC20ContractPromise, getVFTContractPromise } from '@subwallet/extension-base/utils';
 import { ContractPromise } from '@polkadot/api-contract';
-import { getSpecExtensions, getSpecTypes } from '@polkadot/types-known';
 import { BN } from '@polkadot/util';
 import { logger as createLogger } from '@polkadot/util/logger';
 import { _PSP22_ABI, _PSP34_ABI } from "../../../koni/api/contract-handler/utils/index.js";
@@ -137,12 +136,26 @@ export class SubstrateChainHandler extends AbstractChainHandler {
   }
   async getGrc20TokenInfo(apiPromise, contractAddress) {
     if (!(apiPromise instanceof GearApi)) {
-      console.warn('Cannot subscribe VFT balance without GearApi instance');
+      console.warn('Cannot subscribe GRC20 balance without GearApi instance');
       return ['', -1, '', true];
     }
     let contractError = false;
     const tokenContract = getGRC20ContractPromise(apiPromise, contractAddress);
-    const [nameRes, symbolRes, decimalsRes] = await Promise.all([tokenContract.name(DEFAULT_GEAR_ADDRESS.ALICE), tokenContract.symbol(DEFAULT_GEAR_ADDRESS.ALICE), tokenContract.decimals(DEFAULT_GEAR_ADDRESS.ALICE)]);
+    const [nameRes, symbolRes, decimalsRes] = await Promise.all([tokenContract.service.name(GEAR_DEFAULT_ADDRESS), tokenContract.service.symbol(GEAR_DEFAULT_ADDRESS), tokenContract.service.decimals(GEAR_DEFAULT_ADDRESS)]);
+    const decimals = typeof decimalsRes === 'string' ? parseInt(decimalsRes) : decimalsRes;
+    if (!nameRes || !symbolRes) {
+      contractError = true;
+    }
+    return [nameRes, decimals, symbolRes, contractError];
+  }
+  async getVftTokenInfo(apiPromise, contractAddress) {
+    if (!(apiPromise instanceof GearApi)) {
+      console.warn('Cannot subscribe VFT balance without GearApi instance');
+      return ['', -1, '', true];
+    }
+    let contractError = false;
+    const tokenContract = getVFTContractPromise(apiPromise, contractAddress);
+    const [nameRes, symbolRes, decimalsRes] = await Promise.all([tokenContract.service.name(GEAR_DEFAULT_ADDRESS), tokenContract.service.symbol(GEAR_DEFAULT_ADDRESS), tokenContract.service.decimals(GEAR_DEFAULT_ADDRESS)]);
     const decimals = typeof decimalsRes === 'string' ? parseInt(decimalsRes) : decimalsRes;
     if (!nameRes || !symbolRes) {
       contractError = true;
@@ -168,6 +181,9 @@ export class SubstrateChainHandler extends AbstractChainHandler {
         case _AssetType.GRC20:
           [name, decimals, symbol, contractError] = await this.getGrc20TokenInfo(apiPromise, contractAddress);
           break;
+        case _AssetType.VFT:
+          [name, decimals, symbol, contractError] = await this.getVftTokenInfo(apiPromise, contractAddress);
+          break;
       }
       return {
         name,
@@ -199,31 +215,9 @@ export class SubstrateChainHandler extends AbstractChainHandler {
   } = {}) {
     var _this$parent2;
     const existed = this.substrateApiMap[chainSlug];
-    const metadata = await ((_this$parent2 = this.parent) === null || _this$parent2 === void 0 ? void 0 : _this$parent2.getMetadata(chainSlug));
     const updateMetadata = substrateApi => {
       // Update metadata to database with async methods
-      substrateApi.api.isReady.then(async api => {
-        var _this$parent3;
-        const currentSpecVersion = api.runtimeVersion.specVersion.toString();
-        const genesisHash = api.genesisHash.toHex();
-
-        // Avoid date existed metadata
-        if (metadata && metadata.specVersion === currentSpecVersion && metadata.genesisHash === genesisHash) {
-          return;
-        }
-        const systemChain = await api.rpc.system.chain();
-        // const _metadata: Option<OpaqueMetadata> = await api.call.metadata.metadataAtVersion(15);
-        // const metadataHex = _metadata.isSome ? _metadata.unwrap().toHex().slice(2) : ''; // Need unwrap to create metadata object
-
-        (_this$parent3 = this.parent) === null || _this$parent3 === void 0 ? void 0 : _this$parent3.upsertMetadata(chainSlug, {
-          chain: chainSlug,
-          genesisHash: genesisHash,
-          specVersion: currentSpecVersion,
-          hexValue: api.runtimeMetadata.toHex(),
-          types: getSpecTypes(api.registry, systemChain, api.runtimeVersion.specName, api.runtimeVersion.specVersion),
-          userExtensions: getSpecExtensions(api.registry, systemChain, api.runtimeVersion.specName)
-        }).catch(console.error);
-      }).catch(console.error);
+      cacheMetadata(chainSlug, substrateApi, this.parent);
     };
 
     // Return existed to avoid re-init metadata
@@ -237,6 +231,7 @@ export class SubstrateChainHandler extends AbstractChainHandler {
       updateMetadata(existed);
       return existed;
     }
+    const metadata = await ((_this$parent2 = this.parent) === null || _this$parent2 === void 0 ? void 0 : _this$parent2.getMetadata(chainSlug));
     const apiObject = new SubstrateApi(chainSlug, apiUrl, {
       providerName,
       metadata,

package/services/chain-service/health-check/constants/index.js

@@ -4,11 +4,11 @@
 import BigN from 'bignumber.js';
 export const chainProvider = {
   default: 0,
-  ethereum: 1,
+  ethereum: 0,
   polygon: 2,
-  shidenEvm: 2,
-  shiden: 2,
-  ajunaPolkadot: 1,
+  shidenEvm: 1,
+  shiden: 1,
+  ajunaPolkadot: 0,
   crabParachain: 1,
   astarEvm: 1,
   shibuya: 1,

package/services/chain-service/health-check/utils/asset-info.d.ts

@@ -12,3 +12,4 @@ export declare const getPsp22AssetInfo: (asset: _ChainAsset, api: ApiPromise) =>
 export declare const getEvmNativeInfo: (api: _EvmApi) => Promise<AssetSpec>;
 export declare const getErc20AssetInfo: (asset: _ChainAsset, api: _EvmApi) => Promise<AssetSpec>;
 export declare const compareAsset: (assetInfo: AssetSpec, asset: _ChainAsset, errors: string[]) => void;
+export declare const validateAsset: (onchainAsset: AssetSpec, chainlistAsset: _ChainAsset) => boolean;

package/services/chain-service/health-check/utils/asset-info.js

@@ -109,13 +109,12 @@ const getByAssetManagerWithAssetIdPallet = async (asset, api) => {
   };
 };
 const getByAssetRegistryWithAssetIdPallet = async (asset, api) => {
-  const [_info, _metadata] = await api.queryMulti([[api.query.assetRegistry.assets, _getTokenOnChainAssetId(asset)], [api.query.assetRegistry.assetMetadataMap, _getTokenOnChainAssetId(asset)]]);
+  const [_info] = await api.queryMulti([[api.query.assetRegistry.assets, _getTokenOnChainAssetId(asset)]]);
   const info = _info.toPrimitive();
-  const metadata = _metadata.toPrimitive();
   return {
-    decimals: metadata.decimals,
+    decimals: info.decimals,
     minAmount: info.existentialDeposit.toString(),
-    symbol: metadata.symbol
+    symbol: info.symbol
   };
 };
 export const getLocalAssetInfo = async (chain, asset, api) => {
@@ -264,4 +263,21 @@ export const compareAsset = (assetInfo, asset, errors) => {
     var _asset$decimals;
     errors.push(`Wrong decimals: current - ${(_asset$decimals = asset.decimals) !== null && _asset$decimals !== void 0 ? _asset$decimals : 'null'}, onChain - ${decimals}`);
   }
+};
+export const validateAsset = (onchainAsset, chainlistAsset) => {
+  const {
+    decimals,
+    minAmount,
+    symbol
+  } = onchainAsset;
+  const chainlistMinAmount = chainlistAsset.minAmount || '0';
+  const chainlistDecimals = chainlistAsset.decimals || 0;
+  const chainlistSymbol = chainlistAsset.symbol;
+  console.log(`[i] minAmount: current - ${chainlistMinAmount}, onchain - ${minAmount}`);
+  console.log(`[i] decimals: current - ${chainlistDecimals}, onchain - ${decimals}`);
+  console.log(`[i] symbol: current - ${chainlistSymbol}, onchain - ${symbol}`);
+  const isValidSymbol = symbol === chainlistSymbol ? true : 'zk' + symbol === chainlistSymbol;
+  const isValidMinAmount = minAmount === chainlistMinAmount;
+  const isValidDecimal = decimals === chainlistDecimals;
+  return isValidSymbol && isValidMinAmount && isValidDecimal;
 };

package/services/chain-service/health-check/utils/chain-info.d.ts

@@ -1,8 +1,10 @@
 import { AssetSpec } from '@subwallet/extension-base/services/chain-service/health-check/utils/asset-info';
-interface NativeAssetInfo {
+export interface NativeAssetInfo {
     decimals: number;
     existentialDeposit: string;
     symbol: string;
 }
 export declare const compareNativeAsset: (assetInfo: AssetSpec, nativeAsset: NativeAssetInfo, errors: string[]) => void;
-export {};
+export declare const checkNativeAsset: (assetInfo: AssetSpec, nativeAsset: NativeAssetInfo) => boolean;
+export declare const checkSs58Prefix: (onchainPrefix: number, chainlistPrefix: number) => boolean;
+export declare const checkParachainId: (onchainPrefix: number | null, chainlistPrefix: number | null) => boolean;

package/services/chain-service/health-check/utils/chain-info.js

@@ -3,6 +3,7 @@
 
 import { BIG_TEN } from '@subwallet/extension-base/services/chain-service/health-check/constants';
 import BigN from 'bignumber.js';
+// function for old health-check chain
 export const compareNativeAsset = (assetInfo, nativeAsset, errors) => {
   const {
     decimals: _decimals,
@@ -25,4 +26,23 @@ export const compareNativeAsset = (assetInfo, nativeAsset, errors) => {
   if (decimals !== _decimals) {
     errors.push(`Wrong decimals: current - ${_decimals}, onChain - ${decimals}`);
   }
+};
+export const checkNativeAsset = (assetInfo, nativeAsset) => {
+  const {
+    decimals: _decimals,
+    existentialDeposit: _minAmount,
+    symbol: _symbol
+  } = nativeAsset;
+  const {
+    decimals,
+    minAmount,
+    symbol
+  } = assetInfo;
+  return minAmount === _minAmount && symbol === _symbol && decimals === _decimals;
+};
+export const checkSs58Prefix = (onchainPrefix, chainlistPrefix) => {
+  return onchainPrefix === chainlistPrefix;
+};
+export const checkParachainId = (onchainPrefix, chainlistPrefix) => {
+  return onchainPrefix === chainlistPrefix;
 };

package/services/chain-service/health-check/utils/new-utils/asset-asset-validate.d.ts

@@ -0,0 +1,10 @@
+import { _AssetRef, _ChainAsset, _ChainInfo, _MultiChainAsset } from '@subwallet/chain-list/types';
+export declare function validateAssetGroupPrice(multiChainAsset: _MultiChainAsset, chainAsset: _ChainAsset): boolean;
+export declare function validateAssetsGroupPrice(chainAsset1: _ChainAsset, chainAsset2: _ChainAsset): boolean;
+export declare function checkMultichainAssetValid(chainAsset: _ChainAsset): boolean;
+export declare function checkSwapAssetRef(slug: string, assetRef: _AssetRef): boolean;
+export declare function validateNotDuplicateSmartcontract(chainAsset: _ChainAsset): boolean;
+export declare function validateNativeLocalTransferMetadata(chainAsset: _ChainAsset): boolean;
+export declare function validateSwapAlterAsset(assetRef: _AssetRef): boolean;
+export declare function validateXcmMetadata(assetRef: _AssetRef): {};
+export declare function checkValidSupportStaking(chainInfo: _ChainInfo): true | undefined;

package/services/chain-service/health-check/utils/new-utils/asset-asset-validate.js

@@ -0,0 +1,146 @@
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { ChainAssetMap, MultiChainAssetMap } from '@subwallet/chain-list';
+import { _TRANSFER_CHAIN_GROUP } from '@subwallet/extension-base/services/chain-service/constants';
+
+// Check priceId valid in group asset
+
+export function validateAssetGroupPrice(multiChainAsset, chainAsset) {
+  if (chainAsset.multiChainAsset !== multiChainAsset.slug) {
+    throw new Error(`Asset ${chainAsset.slug} are not in ${multiChainAsset.slug} group asset`);
+  }
+  return multiChainAsset.priceId === chainAsset.priceId;
+}
+export function validateAssetsGroupPrice(chainAsset1, chainAsset2) {
+  if (chainAsset1.multiChainAsset !== chainAsset2.multiChainAsset) {
+    throw new Error(`Asset ${chainAsset1.slug} and asset ${chainAsset2.slug} are not in a group asset`);
+  }
+  return chainAsset1.priceId === chainAsset2.priceId;
+}
+
+// Check priceId valid in group asset
+
+// Check multichainAsset valid
+
+export function checkMultichainAssetValid(chainAsset) {
+  if (!chainAsset.multiChainAsset) {
+    return true;
+  }
+  return Object.keys(MultiChainAssetMap).includes(chainAsset.multiChainAsset);
+}
+
+// Check multichainAsset valid
+
+// Check slug asset ref
+
+export function checkSwapAssetRef(slug, assetRef) {
+  return slug === `${assetRef.srcAsset}___${assetRef.destAsset}`;
+}
+
+// Check slug asset ref
+
+// Check duplicate smartcontract
+
+export function validateNotDuplicateSmartcontract(chainAsset) {
+  if (!['ERC20', 'ERC721', 'PSP22', 'PSP34', 'GRC20', 'GRC721'].includes(chainAsset.assetType)) {
+    throw new Error(`${chainAsset.slug} is not smart contract asset`);
+  }
+  const slug = chainAsset.slug;
+  const isDuplicate = Object.entries(ChainAssetMap).some(([key, tokenInfo]) => {
+    var _chainAsset$metadata, _tokenInfo$metadata;
+    return slug !== key && (chainAsset === null || chainAsset === void 0 ? void 0 : (_chainAsset$metadata = chainAsset.metadata) === null || _chainAsset$metadata === void 0 ? void 0 : _chainAsset$metadata.contractAddress) === (tokenInfo === null || tokenInfo === void 0 ? void 0 : (_tokenInfo$metadata = tokenInfo.metadata) === null || _tokenInfo$metadata === void 0 ? void 0 : _tokenInfo$metadata.contractAddress);
+  });
+  return !isDuplicate;
+}
+
+// Check duplicate smartcontract
+
+// ---------------------
+
+// TRANSFER
+
+export function validateNativeLocalTransferMetadata(chainAsset) {
+  if (!chainAsset.metadata) {
+    // recheck this
+    throw new Error(`Asset ${chainAsset.slug} is lack of metadata`);
+  }
+  const moonbeamGroup = ['moonbeam, moonbase, moonriver'];
+  const onChainInfoLocalGroup = [_TRANSFER_CHAIN_GROUP.centrifuge, ..._TRANSFER_CHAIN_GROUP.bitcountry, ..._TRANSFER_CHAIN_GROUP.acala, ..._TRANSFER_CHAIN_GROUP.kintsugi, 'pendulum', 'amplitude'];
+  const onChainInfoNativeGroup = [_TRANSFER_CHAIN_GROUP.centrifuge, ..._TRANSFER_CHAIN_GROUP.acala, ..._TRANSFER_CHAIN_GROUP.kintsugi];
+  const assetIdLocalGroup = [..._TRANSFER_CHAIN_GROUP.statemine, ..._TRANSFER_CHAIN_GROUP.genshiro, ...moonbeamGroup, 'hydradx'];
+  const assetIdNativeGroup = [..._TRANSFER_CHAIN_GROUP.sora_substrate, 'hydradx'];
+  const chain = chainAsset.originChain;
+  const isLocal = chainAsset.assetType === 'LOCAL';
+  const isNative = chainAsset.assetType === 'NATIVE';
+  if (isLocal && onChainInfoLocalGroup.includes(chain)) {
+    return !!chainAsset.metadata.onChainInfo;
+  }
+  if (isNative && onChainInfoNativeGroup.includes(chain)) {
+    return !!chainAsset.metadata.onChainInfo;
+  }
+  if (isLocal && assetIdLocalGroup.includes(chain)) {
+    return !!chainAsset.metadata.assetId;
+  }
+  if (isNative && assetIdNativeGroup.includes(chain)) {
+    return !!chainAsset.metadata.assetId;
+  }
+  throw new Error(`${chainAsset.slug} is not local or native asset`);
+}
+
+// TRANSFER
+
+// SWAP
+
+export function validateSwapAlterAsset(assetRef) {
+  var _assetRef$metadata;
+  if (assetRef.path !== 'SWAP') {
+    throw new Error(`${assetRef.srcAsset}___${assetRef.destAsset} is not SWAP`);
+  }
+  const srcAsset = assetRef.srcAsset;
+  const alterAsset = (_assetRef$metadata = assetRef.metadata) === null || _assetRef$metadata === void 0 ? void 0 : _assetRef$metadata.alternativeAsset;
+  if (!alterAsset) {
+    throw new Error(`${assetRef.srcAsset}___${assetRef.destAsset} does not has alternativeAsset`);
+  }
+  if (!ChainAssetMap[srcAsset] || !ChainAssetMap[alterAsset]) {
+    throw new Error(`${srcAsset} or ${alterAsset} do not exist`);
+  }
+  return ChainAssetMap[srcAsset].multiChainAsset === ChainAssetMap[alterAsset].multiChainAsset;
+}
+
+// SWAP
+
+// XCM
+
+export function validateXcmMetadata(assetRef) {
+  var _ChainAssetMap$srcAss, _ChainAssetMap$destAs;
+  if (assetRef.path !== 'XCM') {
+    throw new Error(`${assetRef.srcAsset}___${assetRef.destAsset} is not XCM`);
+  }
+  const srcAsset = assetRef.srcAsset;
+  const destAsset = assetRef.destAsset;
+  if (!ChainAssetMap[srcAsset] || !ChainAssetMap[destAsset]) {
+    throw new Error(`${srcAsset} or ${destAsset} do not exist`);
+  }
+  return ((_ChainAssetMap$srcAss = ChainAssetMap[srcAsset].metadata) === null || _ChainAssetMap$srcAss === void 0 ? void 0 : _ChainAssetMap$srcAss.multilocation) && ((_ChainAssetMap$destAs = ChainAssetMap[destAsset].metadata) === null || _ChainAssetMap$destAs === void 0 ? void 0 : _ChainAssetMap$destAs.multilocation) || false;
+}
+
+// XCM
+
+// EARNING
+
+// @ts-ignore
+export function checkValidSupportStaking(chainInfo) {
+  if (!chainInfo.substrateInfo) {
+    throw new Error(`chain ${chainInfo.slug} is not substrate chain`);
+  }
+  if (!chainInfo.substrateInfo.supportStaking) {
+    return true;
+  }
+
+  // todo: check has related pallet staking
+}
+
+// todo: check alternativeAsset
+
+// EARNING

package/services/chain-service/health-check/utils/new-utils/asset-validate.d.ts

@@ -0,0 +1,3 @@
+import { _ChainAsset } from '@subwallet/chain-list/types';
+export declare function validateAssetSlug(chainAsset: _ChainAsset): boolean;
+export declare function validateBrigeToken(chainAsset: _ChainAsset): boolean;

package/services/chain-service/health-check/utils/new-utils/asset-validate.js

@@ -0,0 +1,38 @@
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { _AssetType } from '@subwallet/chain-list/types';
+export function validateAssetSlug(chainAsset) {
+  const slug = chainAsset.slug;
+  const originChain = chainAsset.originChain;
+  const assetType = chainAsset.assetType;
+  const symbol = chainAsset.symbol;
+  if ([_AssetType.LOCAL, _AssetType.NATIVE, _AssetType.BRC20].includes(assetType)) {
+    return slug === `${originChain}-${assetType}-${symbol}`;
+  }
+  if ([_AssetType.RUNE].includes(assetType)) {
+    var _chainAsset$metadata;
+    const runeId = (_chainAsset$metadata = chainAsset.metadata) === null || _chainAsset$metadata === void 0 ? void 0 : _chainAsset$metadata.runeId;
+    if (!runeId) {
+      throw new Error(`${slug} is ${assetType} but lack of runeId metadata`);
+    }
+    return slug === `${originChain}-${assetType}-${symbol}-${runeId}`;
+  }
+  if ([_AssetType.ERC20, _AssetType.ERC721, _AssetType.PSP22, _AssetType.PSP34, _AssetType.GRC20, _AssetType.GRC721].includes(assetType)) {
+    var _chainAsset$metadata2;
+    const contractAddress = (_chainAsset$metadata2 = chainAsset.metadata) === null || _chainAsset$metadata2 === void 0 ? void 0 : _chainAsset$metadata2.contractAddress;
+    if (!contractAddress) {
+      throw new Error(`${slug} is ${assetType} but lack of contractAddress metadata`);
+    }
+    return slug === `${originChain}-${assetType}-${symbol}-${contractAddress}`;
+  }
+  throw new Error(`${slug} has unknown token type ${assetType}`);
+}
+export function validateBrigeToken(chainAsset) {
+  var _chainAsset$metadata3, _chainAsset$metadata4;
+  const isBridged = (_chainAsset$metadata3 = chainAsset.metadata) === null || _chainAsset$metadata3 === void 0 ? void 0 : _chainAsset$metadata3.isBridged;
+  if (!isBridged) {
+    throw new Error(`${chainAsset.slug} is not bridged token`);
+  }
+  return !!((_chainAsset$metadata4 = chainAsset.metadata) !== null && _chainAsset$metadata4 !== void 0 && _chainAsset$metadata4.onChainInfo);
+}

package/services/chain-service/health-check/utils/new-utils/chain-asset-validate.d.ts

@@ -0,0 +1,5 @@
+import { _ChainAsset } from '@subwallet/chain-list/types';
+export declare function validateTokenHasValueByChain(chainAsset: _ChainAsset): boolean;
+export declare function validateNativeInfoByChain(chainAsset: _ChainAsset): boolean;
+export declare function validateAssetTypeSupportByChain(chainAsset: _ChainAsset): boolean;
+export declare function validateChainDisableEvmTransfer(chainAsset: _ChainAsset): boolean | undefined;

package/services/chain-service/health-check/utils/new-utils/chain-asset-validate.js

@@ -0,0 +1,64 @@
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { ChainInfoMap } from '@subwallet/chain-list';
+import { _AssetType } from '@subwallet/chain-list/types';
+export function validateTokenHasValueByChain(chainAsset) {
+  const chainInfo = ChainInfoMap[chainAsset.originChain];
+  const isTestnet = chainInfo && chainInfo.isTestnet;
+  if (!chainInfo) {
+    throw new Error(`${chainAsset.originChain} is not existed`);
+  }
+  return isTestnet !== chainAsset.hasValue; // todo: also check multichainAsset hasValue if has.
+}
+
+export function validateNativeInfoByChain(chainAsset) {
+  var _chainInfo$evmInfo, _chainInfo$substrateI, _chainInfo$bitcoinInf, _chainInfo$evmInfo2, _chainInfo$substrateI2, _chainInfo$bitcoinInf2, _chainInfo$evmInfo3, _chainInfo$substrateI3, _chainInfo$bitcoinInf3;
+  const chainInfo = ChainInfoMap[chainAsset.originChain];
+  if (!chainInfo) {
+    throw new Error(`${chainAsset.originChain} is not existed`);
+  }
+  const nativeSymbol = chainInfo !== null && chainInfo !== void 0 && chainInfo.evmInfo ? chainInfo === null || chainInfo === void 0 ? void 0 : (_chainInfo$evmInfo = chainInfo.evmInfo) === null || _chainInfo$evmInfo === void 0 ? void 0 : _chainInfo$evmInfo.symbol : chainInfo !== null && chainInfo !== void 0 && chainInfo.substrateInfo ? chainInfo === null || chainInfo === void 0 ? void 0 : (_chainInfo$substrateI = chainInfo.substrateInfo) === null || _chainInfo$substrateI === void 0 ? void 0 : _chainInfo$substrateI.symbol : chainInfo === null || chainInfo === void 0 ? void 0 : (_chainInfo$bitcoinInf = chainInfo.bitcoinInfo) === null || _chainInfo$bitcoinInf === void 0 ? void 0 : _chainInfo$bitcoinInf.symbol;
+  const nativeDecimal = chainInfo !== null && chainInfo !== void 0 && chainInfo.evmInfo ? chainInfo === null || chainInfo === void 0 ? void 0 : (_chainInfo$evmInfo2 = chainInfo.evmInfo) === null || _chainInfo$evmInfo2 === void 0 ? void 0 : _chainInfo$evmInfo2.decimals : chainInfo !== null && chainInfo !== void 0 && chainInfo.substrateInfo ? chainInfo === null || chainInfo === void 0 ? void 0 : (_chainInfo$substrateI2 = chainInfo.substrateInfo) === null || _chainInfo$substrateI2 === void 0 ? void 0 : _chainInfo$substrateI2.decimals : chainInfo === null || chainInfo === void 0 ? void 0 : (_chainInfo$bitcoinInf2 = chainInfo.bitcoinInfo) === null || _chainInfo$bitcoinInf2 === void 0 ? void 0 : _chainInfo$bitcoinInf2.decimals;
+  const nativeED = chainInfo !== null && chainInfo !== void 0 && chainInfo.evmInfo ? chainInfo === null || chainInfo === void 0 ? void 0 : (_chainInfo$evmInfo3 = chainInfo.evmInfo) === null || _chainInfo$evmInfo3 === void 0 ? void 0 : _chainInfo$evmInfo3.existentialDeposit : chainInfo !== null && chainInfo !== void 0 && chainInfo.substrateInfo ? chainInfo === null || chainInfo === void 0 ? void 0 : (_chainInfo$substrateI3 = chainInfo.substrateInfo) === null || _chainInfo$substrateI3 === void 0 ? void 0 : _chainInfo$substrateI3.existentialDeposit : chainInfo === null || chainInfo === void 0 ? void 0 : (_chainInfo$bitcoinInf3 = chainInfo.bitcoinInfo) === null || _chainInfo$bitcoinInf3 === void 0 ? void 0 : _chainInfo$bitcoinInf3.existentialDeposit;
+  // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
+  const nativeTokenSlug = `${chainInfo.slug}-NATIVE-${nativeSymbol}`;
+  return nativeSymbol === chainAsset.symbol && nativeDecimal === chainAsset.decimals && nativeED === chainAsset.minAmount && nativeTokenSlug === chainAsset.slug;
+}
+export function validateAssetTypeSupportByChain(chainAsset) {
+  const chainInfo = ChainInfoMap[chainAsset.originChain];
+  if (!chainInfo) {
+    throw new Error(`${chainAsset.originChain} is not existed`);
+  }
+  const bitcoinSupportAssetTypes = [_AssetType.NATIVE, _AssetType.RUNE, _AssetType.BRC20];
+  const evmSupportAssetTypes = [_AssetType.NATIVE, _AssetType.ERC20, _AssetType.ERC721];
+  const substrateSupportAssetTypes = [_AssetType.NATIVE, _AssetType.LOCAL, _AssetType.PSP22, _AssetType.PSP34, _AssetType.GRC20, _AssetType.GRC721];
+
+  // recheck chain with two types.
+  if (chainInfo.substrateInfo) {
+    return substrateSupportAssetTypes.includes(chainAsset.assetType);
+  }
+  if (chainInfo.evmInfo) {
+    return evmSupportAssetTypes.includes(chainAsset.assetType);
+  }
+  if (chainInfo.bitcoinInfo) {
+    return bitcoinSupportAssetTypes.includes(chainAsset.assetType);
+  }
+  throw new Error(`${chainAsset.originChain} does not has a suitable chainInfo`);
+}
+export function validateChainDisableEvmTransfer(chainAsset) {
+  var _chainInfo$evmInfo4;
+  const chainInfo = ChainInfoMap[chainAsset.originChain];
+  if (!chainInfo) {
+    throw new Error(`${chainAsset.originChain} is not existed`);
+  }
+  if (!chainInfo.evmInfo) {
+    throw new Error(`${chainAsset.originChain} is not Evm chain`);
+  }
+  const isChainMatchCondition = ((_chainInfo$evmInfo4 = chainInfo.evmInfo) === null || _chainInfo$evmInfo4 === void 0 ? void 0 : _chainInfo$evmInfo4.evmChainId) === -1 && chainInfo.substrateInfo;
+  if (isChainMatchCondition) {
+    var _chainAsset$metadata;
+    return (_chainAsset$metadata = chainAsset.metadata) === null || _chainAsset$metadata === void 0 ? void 0 : _chainAsset$metadata.disableEvmTransfer;
+  }
+  return false;
+}

package/services/chain-service/health-check/utils/new-utils/chain-validate.d.ts

@@ -0,0 +1,4 @@
+import { _ChainInfo } from '@subwallet/chain-list/types';
+export declare function validateChainHasProvider(chainInfo: _ChainInfo): boolean;
+export declare function validateParaId(chainInfo: _ChainInfo): boolean;
+export declare function checkEvmSupportSmartContract(chainInfo: _ChainInfo): boolean;

package/services/chain-service/health-check/utils/new-utils/chain-validate.js

@@ -0,0 +1,26 @@
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { _ChainStatus, _SubstrateChainType } from '@subwallet/chain-list/types';
+export function validateChainHasProvider(chainInfo) {
+  const chainStatus = chainInfo.chainStatus;
+  const providers = Object.keys(chainInfo.providers);
+  const validChainLive = chainStatus === _ChainStatus.ACTIVE && providers.length > 0;
+  const chainNotLive = chainStatus !== _ChainStatus.ACTIVE;
+  return validChainLive || chainNotLive;
+}
+export function validateParaId(chainInfo) {
+  if (!chainInfo.substrateInfo) {
+    throw new Error('Not substrate chain');
+  }
+  const paraId = chainInfo.substrateInfo.paraId;
+  const chainType = chainInfo.substrateInfo.chainType;
+  const relaySlug = chainInfo.substrateInfo.relaySlug;
+  return paraId ? chainType === _SubstrateChainType.PARACHAIN && !!relaySlug : chainType === _SubstrateChainType.RELAYCHAIN && !relaySlug;
+}
+export function checkEvmSupportSmartContract(chainInfo) {
+  if (!chainInfo.evmInfo) {
+    throw new Error('Not Evm chain');
+  }
+  return !!chainInfo.evmInfo.supportSmartContract;
+}

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

@@ -7,6 +7,7 @@ import { EventService } from '@subwallet/extension-base/services/event-service';
 import { IMetadataItem } from '@subwallet/extension-base/services/storage-service/databases';
 import DatabaseService from '@subwallet/extension-base/services/storage-service/DatabaseService';
 import { BehaviorSubject, Subject } from 'rxjs';
+import { ExtraInfo } from '@polkadot-api/merkleize-metadata';
 export declare class ChainService {
     private dataMap;
     private dbService;
@@ -141,6 +142,9 @@ export declare class ChainService {
     getMetadata(chain: string): import("dexie").PromiseExtended<IMetadataItem | undefined>;
     upsertMetadata(chain: string, metadata: IMetadataItem): import("dexie").PromiseExtended<unknown>;
     getMetadataByHash(hash: string): import("dexie").PromiseExtended<IMetadataItem | undefined>;
+    getExtraInfo(chain: string): Omit<ExtraInfo, 'specVersion' | 'specName'>;
+    calculateMetadataHash(chain: string): Promise<string | undefined>;
+    shortenMetadata(chain: string, txBlob: string): Promise<string | undefined>;
     getSubscanChainMap(reverse?: boolean): Record<string, string>;
     get detectBalanceChainSlugMap(): Record<string, string>;
     getFeeTokensByChain(chainSlug: string): string[];