@subwallet/extension-base 0.8.3-2 → 1.0.1

package/packageInfo.js

@@ -7,5 +7,5 @@ export const packageInfo = {
   name: '@subwallet/extension-base',
   path: (import.meta && import.meta.url) ? new URL(import.meta.url).pathname.substring(0, new URL(import.meta.url).pathname.lastIndexOf('/') + 1) : 'auto',
   type: 'esm',
-  version: '0.8.3-2'
+  version: '1.0.1'
 };

package/page/index.js

@@ -1,7 +1,8 @@
 // Copyright 2019-2022 @polkadot/extension authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import { SubWalletProviderError } from '@subwallet/extension-base/errors/SubWalletProviderError';
+import { ProviderError } from '@subwallet/extension-base/background/errors/ProviderError';
+import { ProviderErrorType } from '@subwallet/extension-base/background/KoniTypes';
 import { MESSAGE_ORIGIN_PAGE } from "../defaults.js";
 import { getId } from "../utils/getId.js";
 import Injected from "./Injected.js";
@@ -55,7 +56,7 @@ export function handleResponse(data) {
     // eslint-disable-next-line @typescript-eslint/ban-types
     handler.subscriber(data.subscription);
   } else if (data.error) {
-    handler.reject(new SubWalletProviderError(data.error, data.errorCode, data.errorData));
+    handler.reject(new ProviderError(ProviderErrorType.INTERNAL_ERROR, data.error, data.errorCode));
   } else {
     handler.resolve(data.response);
   }

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

@@ -0,0 +1,9 @@
+import { AmountData, BalanceItem } from '@subwallet/extension-base/background/KoniTypes';
+import { ChainService } from '@subwallet/extension-base/services/chain-service';
+export declare class BalanceService {
+    private chainService;
+    constructor(chainService: ChainService);
+    subscribeTokenFreeBalance(address: string, chain: string, tokenSlug: string | undefined, callback?: (rs: AmountData) => void): Promise<[() => void, AmountData]>;
+    getTokenFreeBalance(address: string, chain: string, tokenSlug?: string): Promise<AmountData>;
+    subscribeBalance(addresses: string[], chains: string[] | null, callback: (rs: BalanceItem) => void): () => void;
+}

package/services/balance-service/index.js

@@ -0,0 +1,101 @@
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { BalanceError } from '@subwallet/extension-base/background/errors/BalanceError';
+import { BalanceErrorType } from '@subwallet/extension-base/background/KoniTypes';
+import { subscribeEVMBalance, subscribeSubstrateBalance } from '@subwallet/extension-base/koni/api/dotsama/balance';
+import { state } from '@subwallet/extension-base/koni/background/handlers';
+import { _PURE_EVM_CHAINS } from '@subwallet/extension-base/services/chain-service/constants';
+import { _getChainNativeTokenSlug, _isChainEvmCompatible, _isPureEvmChain } from '@subwallet/extension-base/services/chain-service/utils';
+import { categoryAddresses } from '@subwallet/extension-base/utils';
+export class BalanceService {
+  constructor(chainService) {
+    this.chainService = chainService;
+
+    // Todo: Load data from db to balanceSubject
+    // Todo: Start  subscribe balance and data
+    // Todo: Listen change and apply to balanceSubject
+    // Todo: Active/Chain
+    // Todo: Add/remove account
+    // Todo: Add new account
+    // Todo: Optimize get balance for single account and chain with cache
+    // Todo: Move everything of fetching balance to this service
+  }
+
+  async subscribeTokenFreeBalance(address, chain, tokenSlug, callback) {
+    const chainInfo = this.chainService.getChainInfoByKey(chain);
+    const chainState = this.chainService.getChainStateByKey(chain);
+    if (!chainInfo || !chainState || !chainState.active) {
+      return Promise.reject(new BalanceError(BalanceErrorType.NETWORK_ERROR, `Chain ${chain} is not active`));
+    }
+    const tSlug = tokenSlug || _getChainNativeTokenSlug(chainInfo);
+    const tokenInfo = this.chainService.getAssetBySlug(tSlug);
+    if (!tokenInfo) {
+      return Promise.reject(new BalanceError(BalanceErrorType.TOKEN_ERROR, `Token ${tSlug} is not supported`));
+    }
+    return new Promise((resolve, reject) => {
+      let hasError = true;
+      const unsub = this.subscribeBalance([address], [chain], rs => {
+        if (rs.tokenSlug === tSlug) {
+          hasError = false;
+          const balance = {
+            value: rs.free,
+            decimals: tokenInfo.decimals || 0,
+            symbol: tokenInfo.symbol
+          };
+          if (callback) {
+            callback(balance);
+          } else {
+            // Auto unsubscribe if no callback
+            unsub();
+          }
+          resolve([unsub, balance]);
+        }
+      });
+      setTimeout(() => {
+        if (hasError) {
+          unsub();
+          reject(new Error('Get Balance Timeout'));
+        }
+      }, 9999);
+    });
+  }
+  async getTokenFreeBalance(address, chain, tokenSlug) {
+    const [, balance] = await this.subscribeTokenFreeBalance(address, chain, tokenSlug);
+    return balance;
+  }
+  subscribeBalance(addresses, chains, callback) {
+    const [substrateAddresses, evmAddresses] = categoryAddresses(addresses);
+    const chainInfoMap = this.chainService.getChainInfoMap();
+    const chainStateMap = this.chainService.getChainStateMap();
+    const substrateApiMap = this.chainService.getSubstrateApiMap();
+    const evmApiMap = this.chainService.getEvmApiMap();
+
+    // Get data from chain or all chains
+    const chainList = chains || Object.keys(chainInfoMap);
+    // Filter active chain only
+    const useChainInfos = chainList.filter(c => chainStateMap[c] && chainStateMap[c].active).map(c => chainInfoMap[c]);
+
+    // Looping over each chain
+    const unsubList = useChainInfos.map(async chainInfo => {
+      const chainSlug = chainInfo.slug;
+      const useAddresses = _isChainEvmCompatible(chainInfo) ? evmAddresses : substrateAddresses;
+      if (_isPureEvmChain(chainInfo)) {
+        const nativeTokenInfo = state.getNativeTokenInfo(chainSlug);
+        return subscribeEVMBalance(chainSlug, useAddresses, evmApiMap, callback, nativeTokenInfo);
+      }
+      if (!useAddresses || useAddresses.length === 0 || _PURE_EVM_CHAINS.indexOf(chainSlug) > -1) {
+        return undefined;
+      }
+      const networkAPI = await substrateApiMap[chainSlug].isReady;
+      return subscribeSubstrateBalance(useAddresses, chainInfo, chainSlug, networkAPI, evmApiMap, callback);
+    });
+    return () => {
+      unsubList.forEach(subProm => {
+        subProm.then(unsub => {
+          unsub && unsub();
+        }).catch(console.error);
+      });
+    };
+  }
+}

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

@@ -0,0 +1,78 @@
+import { SingleModeJson } from '@subwallet/extension-base/background/KoniTypes';
+export declare const API_AUTO_CONNECT_MS = 3000;
+export declare const API_MAX_RETRY = 2;
+export declare const _API_OPTIONS_CHAIN_GROUP: {
+    acala: string[];
+    turing: string[];
+};
+export declare const _PREDEFINED_SINGLE_MODES: Record<string, SingleModeJson>;
+export declare const _PURE_EVM_CHAINS: string[];
+export declare const _BALANCE_CHAIN_GROUP: {
+    kintsugi: string[];
+    genshiro: string[];
+    equilibrium_parachain: string[];
+    bifrost: string[];
+    statemine: string[];
+    kusama: string[];
+};
+export declare const _BALANCE_TOKEN_GROUP: {
+    crab: string[];
+    bitcountry: string[];
+};
+export declare const _NFT_CHAIN_GROUP: {
+    acala: string[];
+    karura: string[];
+    rmrk: string[];
+    statemine: string[];
+    unique_network: string[];
+    bitcountry: string[];
+};
+export declare const _STAKING_CHAIN_GROUP: {
+    relay: string[];
+    para: string[];
+    astar: string[];
+    amplitude: string[];
+    kilt: string[];
+    nominationPool: string[];
+    bifrost: string[];
+    aleph: string[];
+};
+export declare const _STAKING_ERA_LENGTH_MAP: Record<string, number>;
+export declare const _PARACHAIN_INFLATION_DISTRIBUTION: Record<string, Record<string, number>>;
+export interface _SubstrateInflationParams {
+    auctionAdjust: number;
+    auctionMax: number;
+    falloff: number;
+    maxInflation: number;
+    minInflation: number;
+    stakeTarget: number;
+    yearlyInflationInTokens?: number;
+}
+export interface _SubstrateUniformEraPayoutInflationParams extends _SubstrateInflationParams {
+    yearlyInflationInTokens: number;
+}
+export declare const _SUBSTRATE_DEFAULT_INFLATION_PARAMS: _SubstrateInflationParams;
+export declare const _KNOWN_CHAIN_INFLATION_PARAMS: Record<string, _SubstrateInflationParams>;
+export declare const _TRANSFER_NOT_SUPPORTED_CHAINS: string[];
+export declare const _TRANSFER_CHAIN_GROUP: {
+    acala: string[];
+    kintsugi: string[];
+    genshiro: string[];
+    crab: string[];
+    bitcountry: string[];
+    statemine: string[];
+};
+export declare const _BALANCE_PARSING_CHAIN_GROUP: {
+    bobabeam: string[];
+};
+export declare const _XCM_CHAIN_GROUP: {
+    polkadotXcm: string[];
+    xcmPallet: string[];
+};
+export declare const _XCM_CHAIN_USE_LIMITED_WEIGHT: string[];
+export declare const _XCM_TYPE: {
+    RP: string;
+    PP: string;
+    PR: string;
+};
+export declare const _DEFAULT_ACTIVE_CHAINS: string[];

package/services/chain-service/constants.js

@@ -0,0 +1,213 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+import { _DEFAULT_CHAINS } from '@subwallet/chain-list';
+import { _SubstrateChainType } from '@subwallet/chain-list/types';
+import { ThemeNames } from '@subwallet/extension-base/background/KoniTypes';
+export const API_AUTO_CONNECT_MS = 3000;
+export const API_MAX_RETRY = 2;
+export const _API_OPTIONS_CHAIN_GROUP = {
+  acala: ['acala', 'karura', 'origintrail', 'kintsugi'],
+  turing: ['turingStaging', 'turing']
+};
+export const _PREDEFINED_SINGLE_MODES = {
+  subspace: {
+    networkKeys: ['subspace_gemini_2a', 'subspace_test', 'subspace_gemini_3a'],
+    theme: ThemeNames.SUBSPACE,
+    autoTriggerDomain: 'subspace.network'
+  }
+};
+export const _PURE_EVM_CHAINS = ['binance', 'binance_test', 'ethereum', 'ethereum_goerli', 'astarEvm', 'shidenEvm', 'shibuyaEvm', 'crabEvm', 'pangolinEvm', 'cloverEvm', 'boba_rinkeby', 'boba', 'bobabase', 'bobabeam', 'watr_network_evm'];
+
+// Get balance----------------------------------------------------------------------------------------------------------
+
+export const _BALANCE_CHAIN_GROUP = {
+  kintsugi: ['kintsugi', 'interlay', 'kintsugi_test'],
+  genshiro: ['genshiro_testnet', 'genshiro'],
+  equilibrium_parachain: ['equilibrium_parachain'],
+  bifrost: ['bifrost', 'acala', 'karura', 'acala_testnet', 'pioneer', 'bitcountry'],
+  statemine: ['statemine', 'astar', 'shiden', 'statemint', 'moonbeam', 'moonbase', 'moonriver', 'crabParachain'],
+  kusama: ['kusama', 'kintsugi', 'kintsugi_test', 'interlay', 'acala', 'statemint', 'karura', 'bifrost'] // perhaps there are some runtime updates
+};
+
+export const _BALANCE_TOKEN_GROUP = {
+  crab: ['CKTON', 'PKTON'],
+  bitcountry: ['BIT']
+};
+export const _NFT_CHAIN_GROUP = {
+  acala: ['acala'],
+  karura: ['karura'],
+  // TODO: karura and acala should be the same
+  rmrk: ['kusama'],
+  statemine: ['statemine', 'statemint'],
+  unique_network: ['unique_network'],
+  bitcountry: ['bitcountry', 'pioneer']
+};
+
+// Staking--------------------------------------------------------------------------------------------------------------
+
+export const _STAKING_CHAIN_GROUP = {
+  relay: ['polkadot', 'kusama', 'aleph', 'polkadex', 'ternoa', 'ternoa_alphanet', 'alephTest', 'polkadexTest', 'westend'],
+  para: ['moonbeam', 'moonriver', 'moonbase', 'turing', 'turingStaging', 'bifrost', 'bifrost_testnet', 'calamari_test', 'calamari'],
+  astar: ['astar', 'shiden', 'shibuya'],
+  amplitude: ['amplitude', 'amplitude_test', 'kilt', 'kilt_peregrine'],
+  // amplitude and kilt only share some common logic
+  kilt: ['kilt', 'kilt_peregrine'],
+  nominationPool: ['polkadot', 'kusama', 'westend', 'alephTest', 'aleph'],
+  bifrost: ['bifrost', 'bifrost_testnet'],
+  aleph: ['aleph, alephTest'] // A0 has distinct tokenomics
+};
+
+export const _STAKING_ERA_LENGTH_MAP = {
+  // in hours
+  alephTest: 24,
+  aleph: 24,
+  polkadot: 24,
+  kusama: 6,
+  westend: 6,
+  hydradx: 24,
+  default: 24,
+  moonbeam: 6,
+  moonriver: 2,
+  moonbase: 2,
+  turing: 2,
+  turingStaging: 2,
+  astar: 24,
+  shiden: 24,
+  shibuya: 24,
+  bifrost_testnet: 0.5,
+  bifrost: 2,
+  ternoa: 24,
+  calamari: 6,
+  calamari_test: 6,
+  amplitude: 2,
+  amplitude_test: 2,
+  kilt: 2,
+  kilt_peregrine: 2
+};
+export const _PARACHAIN_INFLATION_DISTRIBUTION = {
+  moonbeam: {
+    // https://docs.moonbeam.network/learn/features/staking/#annual-inflation
+    reward: 0.5,
+    collatorCommission: 0.2,
+    bondReserve: 0.3
+  },
+  moonriver: {
+    reward: 0.5,
+    collatorCommission: 0.2,
+    bondReserve: 0.3
+  },
+  moonbase: {
+    reward: 0.5,
+    collatorCommission: 0.2,
+    bondReserve: 0.3
+  },
+  turing: {
+    // https://docs.oak.tech/docs/delegators/
+    reward: 0.5
+  },
+  turingStaging: {
+    // https://docs.oak.tech/docs/delegators/
+    reward: 0.5
+  },
+  bifrost: {
+    reward: 0
+  },
+  bifrost_testnet: {
+    reward: 0
+  },
+  calamari_test: {
+    reward: 0.9
+  },
+  calamari: {
+    reward: 0.9
+  },
+  default: {
+    reward: 0
+  }
+};
+export const _SUBSTRATE_DEFAULT_INFLATION_PARAMS = {
+  auctionAdjust: 0,
+  auctionMax: 0,
+  // 5% for falloff, as per the defaults, see
+  // https://github.com/paritytech/polkadot/blob/816cb64ea16102c6c79f6be2a917d832d98df757/runtime/kusama/src/lib.rs#L534
+  falloff: 0.05,
+  // 10% max, 0.25% min, see
+  // https://github.com/paritytech/polkadot/blob/816cb64ea16102c6c79f6be2a917d832d98df757/runtime/kusama/src/lib.rs#L523
+  maxInflation: 0.1,
+  minInflation: 0.025,
+  stakeTarget: 0.5
+};
+const _ALEPH_DEFAULT_UNIFORM_ERA_PAYOUT_PARAMS = {
+  ..._SUBSTRATE_DEFAULT_INFLATION_PARAMS,
+  yearlyInflationInTokens: 30000000
+};
+export const _KNOWN_CHAIN_INFLATION_PARAMS = {
+  aleph: _ALEPH_DEFAULT_UNIFORM_ERA_PAYOUT_PARAMS,
+  alephTest: _ALEPH_DEFAULT_UNIFORM_ERA_PAYOUT_PARAMS,
+  dock_pos: {
+    ..._SUBSTRATE_DEFAULT_INFLATION_PARAMS,
+    stakeTarget: 0.75
+  },
+  kusama: {
+    ..._SUBSTRATE_DEFAULT_INFLATION_PARAMS,
+    auctionAdjust: 0.3 / 60,
+    auctionMax: 60,
+    stakeTarget: 0.75
+  },
+  neatcoin: {
+    ..._SUBSTRATE_DEFAULT_INFLATION_PARAMS,
+    stakeTarget: 0.75
+  },
+  nft_mart: {
+    ..._SUBSTRATE_DEFAULT_INFLATION_PARAMS,
+    falloff: 0.04,
+    stakeTarget: 0.60
+  },
+  polkadot: {
+    ..._SUBSTRATE_DEFAULT_INFLATION_PARAMS,
+    stakeTarget: 0.75
+  }
+};
+
+// Send fund------------------------------------------------------------------------------------------------------------
+
+export const _TRANSFER_NOT_SUPPORTED_CHAINS = ['subspace_gemini_3a', 'kulupu', 'joystream', 'equilibrium_parachain', 'genshiro_testnet', 'genshiro'];
+export const _TRANSFER_CHAIN_GROUP = {
+  acala: ['karura', 'acala', 'acala_testnet'],
+  kintsugi: ['kintsugi', 'kintsugi_test', 'interlay'],
+  genshiro: ['genshiro_testnet', 'genshiro', 'equilibrium_parachain'],
+  crab: ['crab', 'pangolin'],
+  bitcountry: ['pioneer', 'bitcountry'],
+  statemine: ['statemint', 'statemine']
+};
+export const _BALANCE_PARSING_CHAIN_GROUP = {
+  bobabeam: ['bobabeam', 'bobabase']
+};
+
+// XCM------------------------------------------------------------------------------------------------------------------
+
+export const _XCM_CHAIN_GROUP = {
+  polkadotXcm: ['astar', 'shiden', 'statemine', 'statemint'],
+  xcmPallet: ['polkadot', 'kusama']
+  // default is xTokens pallet
+  // moonbeam: ['moonbeam', 'moonriver', 'moonbase'],
+  // astar: ['astar', 'shiden'],
+  // statemine: ['statemint', 'statemine'],
+  // bifrost: ['bifrost'],
+  // genshiro: ['genshiro_testnet', 'genshiro', 'equilibrium_parachain'],
+  // kintsugi: ['kintsugi', 'kintsugi_test', 'interlay'],
+  // acala: ['karura', 'acala', 'acala_testnet'],
+  // astarEvm: ['astarEvm', 'shidenEvm']
+};
+
+export const _XCM_CHAIN_USE_LIMITED_WEIGHT = ['acala', 'karura', 'statemint'];
+export const _XCM_TYPE = {
+  RP: `${_SubstrateChainType.RELAYCHAIN}-${_SubstrateChainType.PARACHAIN}`,
+  // DMP
+  PP: `${_SubstrateChainType.PARACHAIN}-${_SubstrateChainType.PARACHAIN}`,
+  // HRMP
+  PR: `${_SubstrateChainType.PARACHAIN}-${_SubstrateChainType.RELAYCHAIN}` // UMP
+};
+
+export const _DEFAULT_ACTIVE_CHAINS = [..._DEFAULT_CHAINS];

package/services/chain-service/handler/EvmChainHandler.d.ts

@@ -0,0 +1,16 @@
+import { _AssetType } from '@subwallet/chain-list/types';
+import { _EvmChainSpec } from '@subwallet/extension-base/services/chain-service/handler/types';
+import { _EvmApi, _SmartContractTokenInfo } from '@subwallet/extension-base/services/chain-service/types';
+export declare class EvmChainHandler {
+    private evmApiMap;
+    private logger;
+    constructor();
+    getEvmApiMap(): Record<string, _EvmApi>;
+    getEvmApiByChain(chainSlug: string): _EvmApi;
+    setEvmApi(chainSlug: string, evmApi: _EvmApi): void;
+    destroyEvmApi(chainSlug: string): void;
+    refreshApi(slug: string, endpoint: string, providerName?: string): void;
+    initApi(chainSlug: string, apiUrl: string, providerName?: string): _EvmApi;
+    getChainSpec(evmApi: _EvmApi): Promise<_EvmChainSpec>;
+    getSmartContractTokenInfo(contractAddress: string, tokenType: _AssetType, originChain: string): Promise<_SmartContractTokenInfo>;
+}

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

@@ -0,0 +1,136 @@
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { _AssetType } from '@subwallet/chain-list/types';
+import { _ERC20_ABI, _ERC721_ABI } from '@subwallet/extension-base/services/chain-service/helper';
+import Web3 from 'web3';
+import { logger as createLogger } from '@polkadot/util/logger';
+export class EvmChainHandler {
+  evmApiMap = {};
+  constructor() {
+    this.logger = createLogger('evm-chain-handler');
+  }
+  getEvmApiMap() {
+    return this.evmApiMap;
+  }
+  getEvmApiByChain(chainSlug) {
+    return this.evmApiMap[chainSlug];
+  }
+  setEvmApi(chainSlug, evmApi) {
+    this.evmApiMap[chainSlug] = evmApi;
+  }
+  destroyEvmApi(chainSlug) {
+    // TODO: handle API destroy better
+    delete this.evmApiMap[chainSlug];
+  }
+  refreshApi(slug, endpoint, providerName) {
+    this.evmApiMap[slug] = this.initApi(slug, endpoint, providerName);
+  }
+  initApi(chainSlug, apiUrl, providerName) {
+    let api;
+    if (apiUrl.startsWith('http')) {
+      api = new Web3(new Web3.providers.HttpProvider(apiUrl));
+    } else {
+      api = new Web3(new Web3.providers.WebsocketProvider(apiUrl));
+    }
+    return {
+      api,
+      providerName,
+      chainSlug,
+      apiUrl,
+      isApiReady: true,
+      isApiReadyOnce: true,
+      isApiConnected: true,
+      isApiInitialized: true,
+      get isReady() {
+        const self = this;
+        async function f() {
+          return new Promise((resolve, reject) => {
+            (function wait() {
+              if (self.isApiReady) {
+                return resolve(self);
+              }
+              setTimeout(wait, 10);
+            })();
+          });
+        }
+        return f();
+      }
+    };
+  }
+  async getChainSpec(evmApi) {
+    const chainId = await evmApi.api.eth.getChainId();
+    let chainInfoList;
+    const result = {
+      evmChainId: chainId,
+      name: '',
+      symbol: '',
+      decimals: 18,
+      // by default, might change
+      existentialDeposit: '0'
+    };
+    await fetch('https://chainid.network/chains.json').then(resp => resp.json()).then(data => {
+      chainInfoList = data;
+    });
+    if (chainInfoList) {
+      chainInfoList.forEach(_chainInfo => {
+        const _chainId = _chainInfo.chainId;
+        if (chainId === _chainId) {
+          result.name = _chainInfo.name;
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+          result.symbol = _chainInfo.nativeCurrency.symbol;
+        }
+      });
+    }
+    return result;
+  }
+  async getSmartContractTokenInfo(contractAddress, tokenType, originChain) {
+    let tokenContract;
+    let name = '';
+    let decimals = -1;
+    let symbol = '';
+    let contractError = false;
+    const evmApi = this.getEvmApiByChain(originChain);
+    try {
+      if (tokenType === _AssetType.ERC721) {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument,@typescript-eslint/no-unsafe-member-access
+        tokenContract = new evmApi.api.eth.Contract(_ERC721_ABI, contractAddress);
+        const [_name, _symbol] = await Promise.all([
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-member-access
+        tokenContract.methods.name().call(),
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-member-access
+        tokenContract.methods.symbol().call()]);
+        name = _name;
+        symbol = _symbol;
+      } else {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument,@typescript-eslint/no-unsafe-member-access
+        tokenContract = new evmApi.api.eth.Contract(_ERC20_ABI, contractAddress);
+        const [_decimals, _symbol] = await Promise.all([
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-member-access
+        tokenContract.methods.decimals().call(),
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-member-access
+        tokenContract.methods.symbol().call()]);
+        name = _symbol;
+        decimals = _decimals;
+        symbol = _symbol;
+      }
+      if (name === '' || symbol === '') {
+        contractError = true;
+      }
+      return {
+        name,
+        decimals,
+        symbol,
+        contractError
+      };
+    } catch (e) {
+      this.logger.error('Error response while validating EVM contract', e);
+      return {
+        name,
+        decimals,
+        symbol,
+        contractError: true
+      };
+    }
+  }
+}

package/services/chain-service/handler/SubstrateChainHandler.d.ts

@@ -0,0 +1,21 @@
+import { _AssetType } from '@subwallet/chain-list/types';
+import { _SubstrateChainSpec } from '@subwallet/extension-base/services/chain-service/handler/types';
+import { _SmartContractTokenInfo, _SubstrateApi } from '@subwallet/extension-base/services/chain-service/types';
+export declare const DEFAULT_AUX: string[];
+export declare class SubstrateChainHandler {
+    private substrateApiMap;
+    private logger;
+    constructor();
+    getSubstrateApiMap(): Record<string, _SubstrateApi>;
+    getSubstrateApiByChain(chainSlug: string): _SubstrateApi;
+    resumeAllApis(): Promise<void[]>;
+    disconnectAllApis(): Promise<void[]>;
+    refreshApi(slug: string): void;
+    getChainSpec(substrateApi: _SubstrateApi): Promise<_SubstrateChainSpec>;
+    getSmartContractTokenInfo(contractAddress: string, tokenType: _AssetType, originChain: string, contractCaller?: string): Promise<_SmartContractTokenInfo>;
+    setSubstrateApi(chainSlug: string, substrateApi: _SubstrateApi): void;
+    destroySubstrateApi(chainSlug: string): void;
+    initApi(chainSlug: string, apiUrl: string, providerName?: string): _SubstrateApi;
+    private getChainMetadata;
+    private loadOnReady;
+}