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

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.js

@@ -18,7 +18,7 @@ import { logger as createLogger } from '@polkadot/util/logger';
 const filterChainInfoMap = (data, ignoredChains) => {
   return Object.fromEntries(Object.entries(data).filter(([slug, info]) => !info.bitcoinInfo && !ignoredChains.includes(slug)));
 };
-const ignoredList = ['bevm', 'bevmTest', 'bevm_testnet', 'layerEdge_testnet', 'merlinEvm', 'botanixEvmTest', 'syscoin_evm', 'rollux_evm'];
+const ignoredList = ['bevm', 'bevmTest', 'bevm_testnet', 'layerEdge_testnet', 'merlinEvm', 'botanixEvmTest', 'syscoin_evm', 'syscoin_evm_testnet', 'rollux_evm', 'rollux_testnet', 'boolAlpha', 'boolBeta_testnet'];
 const filterAssetInfoMap = (chainInfo, assets) => {
   return Object.fromEntries(Object.entries(assets).filter(([, info]) => chainInfo[info.originChain]));
 };
@@ -655,6 +655,34 @@ export class ChainService {
     }
     const onUpdateStatus = status => {
       const slug = chainInfo.slug;
+      const isActive = this.getChainStateByKey(slug).active;
+      const isConnectProblem = status !== _ChainConnectionStatus.CONNECTING && status !== _ChainConnectionStatus.CONNECTED;
+      const isLightRpc = endpoint.startsWith('light');
+      if (isActive && isConnectProblem && !isLightRpc) {
+        const reportApiUrl = 'https://api-cache.subwallet.app/api/health-check/report-rpc';
+        const requestBody = {
+          chainSlug: slug,
+          chainStatus: status,
+          rpcReport: {
+            [providerName]: endpoint
+          },
+          configStatus: {
+            countUnstable: 10,
+            countDie: 20
+          }
+        };
+        fetch(reportApiUrl, {
+          // can get status from this response
+          method: 'POST',
+          headers: {
+            'X-API-KEY': '9b1c94a5e1f3a2d9f8b2a4d6e1f3a2d9',
+            'Content-Type': 'application/json'
+          },
+          body: JSON.stringify(requestBody)
+        })
+        // eslint-disable-next-line @typescript-eslint/no-empty-function
+        .then(() => {}).catch(error => console.error('Error connecting to the report API:', error));
+      }
       this.updateChainConnectionStatus(slug, status);
     };
     if (chainInfo.substrateInfo !== null && chainInfo.substrateInfo !== undefined) {
@@ -664,6 +692,7 @@ export class ChainService {
       //
       //   this.substrateChainHandler.setSubstrateApi(chainInfo.slug, chainApi);
       // } else {
+
       const chainApi = await this.substrateChainHandler.initApi(chainInfo.slug, endpoint, {
         providerName,
         onUpdateStatus

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

@@ -18,6 +18,11 @@ export declare enum _ChainConnectionStatus {
     UNSTABLE = "UNSTABLE",
     CONNECTING = "CONNECTING"
 }
+export interface ReportRpc {
+    runningRpc: Record<string, string>;
+    unstableRpc: Record<string, string>;
+    dieRpc: Record<string, string>;
+}
 export interface _ChainState {
     slug: string;
     active: boolean;

package/services/earning-service/handlers/liquid-staking/acala.js

@@ -2,6 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import { ChainType, ExtrinsicType } from '@subwallet/extension-base/background/KoniTypes';
+import { _STAKING_ERA_LENGTH_MAP } from '@subwallet/extension-base/services/chain-service/constants';
 import { _getTokenOnChainInfo } from '@subwallet/extension-base/services/chain-service/utils';
 import { fakeAddress } from '@subwallet/extension-base/services/earning-service/constants';
 import { EarningStatus, UnstakingStatus, YieldStepType } from '@subwallet/extension-base/types';
@@ -9,6 +10,9 @@ import { BN, BN_TEN, BN_ZERO } from '@polkadot/util';
 import BaseLiquidStakingPoolHandler from "./base.js";
 const GRAPHQL_API = 'https://api.polkawallet.io/acala-liquid-staking-subql';
 const EXCHANGE_RATE_REQUEST = 'query { dailySummaries(first:30, orderBy:TIMESTAMP_DESC) {nodes { exchangeRate timestamp }}}';
+function convertDerivativeToken(amount, exchangeRate, decimals) {
+  return amount.mul(new BN(exchangeRate)).div(BN_TEN.pow(new BN(decimals)));
+}
 export default class AcalaLiquidStakingPoolHandler extends BaseLiquidStakingPoolHandler {
   altInputAsset = 'polkadot-NATIVE-DOT';
   derivativeAssets = ['acala-LOCAL-LDOT'];
@@ -22,8 +26,7 @@ export default class AcalaLiquidStakingPoolHandler extends BaseLiquidStakingPool
     defaultUnstake: true,
     fastUnstake: true,
     cancelUnstake: false,
-    withdraw: false,
-    // TODO: Change after verify unstake info
+    withdraw: true,
     claimReward: false
   };
   constructor(state, chain) {
@@ -111,30 +114,55 @@ export default class AcalaLiquidStakingPoolHandler extends BaseLiquidStakingPool
         return;
       }
       const balances = _balances;
-      const redeemRequests = await substrateApi.api.query.homa.redeemRequests.multi(useAddresses);
-      // This rate is multiple with decimals
-      const exchangeRate = await this.getExchangeRate();
-      const decimals = BN_TEN.pow(new BN(this.rateDecimals));
+      const [redeemRequests, exchangeRate, _currentEra] = await Promise.all([substrateApi.api.query.homa.redeemRequests.multi(useAddresses), this.getExchangeRate(), substrateApi.api.query.homa.relayChainCurrentEra()]);
+      const currentEra = _currentEra.toPrimitive();
       for (let i = 0; i < balances.length; i++) {
         const balanceItem = balances[i];
         const address = useAddresses[i];
         const activeTotalBalance = balanceItem.free || BN_ZERO;
-        let totalBalance = activeTotalBalance.mul(new BN(exchangeRate)).div(decimals);
+        let totalBalance = convertDerivativeToken(activeTotalBalance, exchangeRate, this.rateDecimals);
         let unlockingBalance = BN_ZERO;
         const unstakings = [];
+
+        // Handle redeem request
         const redeemRequest = redeemRequests[i].toPrimitive();
         if (redeemRequest) {
-          // If withdrawable = false, redeem request is claimed
-          const [redeemAmount, withdrawable] = redeemRequest;
-
-          // Redeem amount in derivative token
-          const amount = new BN(redeemAmount).mul(new BN(exchangeRate)).div(decimals);
-          totalBalance = totalBalance.add(amount);
-          unlockingBalance = unlockingBalance.add(amount);
+          const [derivativeRedeemAmount, _] = redeemRequest;
+          const redeemAmount = convertDerivativeToken(new BN(derivativeRedeemAmount), exchangeRate, this.rateDecimals);
+          totalBalance = totalBalance.add(redeemAmount);
+          unlockingBalance = unlockingBalance.add(redeemAmount);
           unstakings.push({
             chain: this.chain,
-            status: withdrawable ? UnstakingStatus.CLAIMABLE : UnstakingStatus.UNLOCKING,
-            claimable: amount.toString()
+            status: UnstakingStatus.UNLOCKING,
+            claimable: redeemAmount.toString(),
+            waitingTime: 28 * _STAKING_ERA_LENGTH_MAP.polkadot // up to 29 day (in case non-fast-match
+          });
+        }
+
+        // Handle unbondings
+        const unbondings = await substrateApi.api.query.homa.unbondings.entries(address);
+        if (unbondings.length > 0) {
+          unbondings.forEach(([unbondingInfo, unbondingValue]) => {
+            // @ts-ignore
+            const _targetEra = unbondingInfo.toHuman()[1];
+            const targetEra = parseInt(_targetEra.replaceAll(',', ''));
+            const amount = new BN(unbondingValue.toPrimitive());
+            totalBalance = totalBalance.add(amount);
+            unlockingBalance = unlockingBalance.add(amount);
+            if (targetEra > currentEra) {
+              unstakings.push({
+                chain: this.chain,
+                status: UnstakingStatus.UNLOCKING,
+                claimable: amount.toString(),
+                waitingTime: (targetEra - currentEra) * _STAKING_ERA_LENGTH_MAP.polkadot // Todo: Handle exact timestamp?
+              });
+            } else {
+              unstakings.push({
+                chain: this.chain,
+                status: UnstakingStatus.CLAIMABLE,
+                claimable: amount.toString()
+              });
+            }
           });
         }
         const result = {
@@ -225,7 +253,8 @@ export default class AcalaLiquidStakingPoolHandler extends BaseLiquidStakingPool
   }
   async handleYieldUnstake(amount, address, selectedTarget) {
     const chainApi = await this.substrateApi.isReady;
-    const extrinsic = chainApi.api.tx.homa.requestRedeem(amount, false);
+    const extrinsic = chainApi.api.tx.homa.requestRedeem(amount, true); // set true to allow fast match
+
     return [ExtrinsicType.UNSTAKE_LDOT, extrinsic];
   }
   async handleYieldWithdraw(address, unstakingInfo) {