@subwallet/extension-base 0.8.4-0 → 1.0.1

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

@@ -0,0 +1,340 @@
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { options as acalaOptions } from '@acala-network/api';
+import { rpc as oakRpc, types as oakTypes } from '@oak-foundation/types';
+import { _AssetType } from '@subwallet/chain-list/types';
+import { getSubstrateConnectProvider } from '@subwallet/extension-base/services/chain-service/handler/light-client';
+import { ApiPromise, WsProvider } from '@polkadot/api';
+import { ContractPromise } from '@polkadot/api-contract';
+import { TypeRegistry } from '@polkadot/types/create';
+import { formatBalance, isTestChain, objectSpread, stringify } from '@polkadot/util';
+import { logger as createLogger } from '@polkadot/util/logger';
+import { defaults as addressDefaults } from '@polkadot/util-crypto/address/defaults';
+import { _API_OPTIONS_CHAIN_GROUP, API_AUTO_CONNECT_MS, API_MAX_RETRY } from "../constants.js";
+import { _PSP22_ABI, _PSP34_ABI } from "../helper/index.js";
+import { typesBundle, typesChain } from "../helper/api-helper/index.js";
+export const DEFAULT_AUX = ['Aux1', 'Aux2', 'Aux3', 'Aux4', 'Aux5', 'Aux6', 'Aux7', 'Aux8', 'Aux9'];
+export class SubstrateChainHandler {
+  substrateApiMap = {};
+  constructor() {
+    this.logger = createLogger('substrate-chain-handler');
+  }
+  getSubstrateApiMap() {
+    return this.substrateApiMap;
+  }
+  getSubstrateApiByChain(chainSlug) {
+    return this.substrateApiMap[chainSlug];
+  }
+  resumeAllApis() {
+    return Promise.all(Object.values(this.getSubstrateApiMap()).map(async substrateApi => {
+      if (!substrateApi.api.isConnected && substrateApi.api.connect) {
+        this.logger.log(`[Substrate] Resuming network [${substrateApi.specName}]`);
+        await substrateApi.api.connect();
+      }
+    }));
+  }
+  disconnectAllApis() {
+    return Promise.all(Object.values(this.getSubstrateApiMap()).map(async substrateApi => {
+      if (substrateApi.api.isConnected) {
+        var _substrateApi$api, _substrateApi$api2;
+        this.logger.log(`[Substrate] Stopping network [${substrateApi.chainSlug}]`);
+        ((_substrateApi$api = substrateApi.api) === null || _substrateApi$api === void 0 ? void 0 : _substrateApi$api.disconnect) && (await ((_substrateApi$api2 = substrateApi.api) === null || _substrateApi$api2 === void 0 ? void 0 : _substrateApi$api2.disconnect()));
+      }
+    }));
+  }
+  refreshApi(slug) {
+    const substrateApi = this.getSubstrateApiByChain(slug);
+    if (substrateApi && !substrateApi.isApiConnected) {
+      substrateApi.recoverConnect && substrateApi.recoverConnect();
+    }
+  }
+  async getChainSpec(substrateApi) {
+    var _substrateApi$api$gen, _substrateApi$api3, _substrateApi$api3$co, _substrateApi$api3$co2, _substrateApi$api3$co3;
+    const result = {
+      addressPrefix: -1,
+      decimals: 0,
+      existentialDeposit: '',
+      genesisHash: (_substrateApi$api$gen = substrateApi.api.genesisHash) === null || _substrateApi$api$gen === void 0 ? void 0 : _substrateApi$api$gen.toHex(),
+      name: '',
+      symbol: '',
+      paraId: null
+    };
+    const {
+      chainDecimals,
+      chainTokens
+    } = substrateApi.api.registry;
+    if (substrateApi.api.query.parachainInfo) {
+      result.paraId = (await substrateApi.api.query.parachainInfo.parachainId()).toPrimitive();
+    }
+
+    // get first token by default, might change
+    result.name = (await substrateApi.api.rpc.system.chain()).toPrimitive();
+    result.symbol = chainTokens[0];
+    result.decimals = chainDecimals[0];
+    result.addressPrefix = (_substrateApi$api3 = substrateApi.api) === null || _substrateApi$api3 === void 0 ? void 0 : (_substrateApi$api3$co = _substrateApi$api3.consts) === null || _substrateApi$api3$co === void 0 ? void 0 : (_substrateApi$api3$co2 = _substrateApi$api3$co.system) === null || _substrateApi$api3$co2 === void 0 ? void 0 : (_substrateApi$api3$co3 = _substrateApi$api3$co2.ss58Prefix) === null || _substrateApi$api3$co3 === void 0 ? void 0 : _substrateApi$api3$co3.toPrimitive();
+    result.existentialDeposit = substrateApi.api.consts.balances.existentialDeposit.toString();
+    return result;
+  }
+  async getSmartContractTokenInfo(contractAddress, tokenType, originChain, contractCaller) {
+    let tokenContract;
+    let name = '';
+    let decimals = -1;
+    let symbol = '';
+    let contractError = false;
+    const substrateApi = this.getSubstrateApiByChain(originChain);
+    try {
+      if (tokenType === _AssetType.PSP22) {
+        tokenContract = new ContractPromise(substrateApi.api, _PSP22_ABI, contractAddress);
+        const [nameResp, symbolResp, decimalsResp] = await Promise.all([tokenContract.query['psp22Metadata::tokenName'](contractCaller || contractAddress, {
+          gasLimit: -1
+        }),
+        // read-only operation so no gas limit
+        tokenContract.query['psp22Metadata::tokenSymbol'](contractCaller || contractAddress, {
+          gasLimit: -1
+        }), tokenContract.query['psp22Metadata::tokenDecimals'](contractCaller || contractAddress, {
+          gasLimit: -1
+        })]);
+        if (!(nameResp.result.isOk && symbolResp.result.isOk && decimalsResp.result.isOk) || !nameResp.output || !decimalsResp.output || !symbolResp.output) {
+          this.logger.error('Error response while validating WASM contract');
+          return {
+            name: '',
+            decimals: -1,
+            symbol: '',
+            contractError: true
+          };
+        } else {
+          var _symbolResp$output, _decimalsResp$output, _symbolResp$output2;
+          name = (_symbolResp$output = symbolResp.output) === null || _symbolResp$output === void 0 ? void 0 : _symbolResp$output.toHuman();
+          decimals = parseInt((_decimalsResp$output = decimalsResp.output) === null || _decimalsResp$output === void 0 ? void 0 : _decimalsResp$output.toHuman());
+          symbol = (_symbolResp$output2 = symbolResp.output) === null || _symbolResp$output2 === void 0 ? void 0 : _symbolResp$output2.toHuman();
+          if (name === '' || symbol === '') {
+            contractError = true;
+          }
+        }
+      } else {
+        tokenContract = new ContractPromise(substrateApi.api, _PSP34_ABI, contractAddress);
+        const collectionIdResp = await tokenContract.query['psp34::collectionId'](contractCaller || contractAddress, {
+          gasLimit: -1
+        }); // read-only operation so no gas limit
+
+        if (!collectionIdResp.result.isOk || !collectionIdResp.output) {
+          this.logger.error('Error response while validating WASM contract');
+          return {
+            name: '',
+            decimals: -1,
+            symbol: '',
+            contractError: true
+          };
+        } else {
+          var _collectionIdResp$out;
+          const collectionIdDict = (_collectionIdResp$out = collectionIdResp.output) === null || _collectionIdResp$out === void 0 ? void 0 : _collectionIdResp$out.toHuman();
+          if (collectionIdDict.Bytes === '') {
+            contractError = true;
+          } else {
+            name = ''; // no function to get collection name, let user manually put in the name
+          }
+        }
+      }
+
+      return {
+        name,
+        decimals,
+        symbol,
+        contractError
+      };
+    } catch (e) {
+      this.logger.error('Error validating WASM contract', e);
+      return {
+        name: '',
+        decimals: -1,
+        symbol: '',
+        contractError: true
+      };
+    }
+  }
+  setSubstrateApi(chainSlug, substrateApi) {
+    this.substrateApiMap[chainSlug] = substrateApi;
+  }
+  destroySubstrateApi(chainSlug) {
+    if (!(chainSlug in this.substrateApiMap)) {
+      return;
+    }
+    this.substrateApiMap[chainSlug].api.disconnect && this.substrateApiMap[chainSlug].api.disconnect().then().catch(console.error);
+    delete this.substrateApiMap[chainSlug];
+  }
+  initApi(chainSlug, apiUrl, providerName) {
+    const registry = new TypeRegistry();
+    const provider = apiUrl.startsWith('light://') ? getSubstrateConnectProvider(apiUrl.replace('light://substrate-connect/', '')) : new WsProvider(apiUrl, API_AUTO_CONNECT_MS);
+    const apiOption = {
+      provider,
+      typesBundle,
+      typesChain: typesChain
+    };
+
+    // @ts-ignore
+    apiOption.registry = registry;
+    let api;
+    if (_API_OPTIONS_CHAIN_GROUP.acala.includes(chainSlug)) {
+      api = new ApiPromise(acalaOptions({
+        provider
+      }));
+    } else if (_API_OPTIONS_CHAIN_GROUP.turing.includes(chainSlug)) {
+      api = new ApiPromise({
+        provider,
+        rpc: oakRpc,
+        types: oakTypes
+      });
+    } else {
+      api = new ApiPromise(apiOption);
+    }
+    const substrateApi = {
+      api,
+      providerName,
+      chainSlug,
+      apiUrl,
+      apiError: undefined,
+      apiRetry: 0,
+      isApiReady: false,
+      isApiReadyOnce: false,
+      isApiConnected: false,
+      isApiInitialized: true,
+      registry,
+      specName: '',
+      specVersion: '',
+      systemChain: '',
+      systemName: '',
+      systemVersion: '',
+      apiDefaultTx: undefined,
+      apiDefaultTxSudo: undefined,
+      defaultFormatBalance: undefined,
+      recoverConnect: () => {
+        substrateApi.apiRetry = 0;
+        this.logger.log('Recover connect to ', apiUrl);
+        provider.connect().then(this.logger.log).catch(this.logger.error);
+      },
+      get isReady() {
+        const self = this;
+        async function f() {
+          if (!substrateApi.isApiReadyOnce) {
+            await self.api.isReady;
+          }
+          return new Promise((resolve, reject) => {
+            (function wait() {
+              if (self.isApiReady) {
+                return resolve(self);
+              }
+              setTimeout(wait, 10);
+            })();
+          });
+        }
+        return f();
+      }
+    };
+    api.on('connected', () => {
+      this.logger.log('Substrate API connected to ', apiUrl);
+      substrateApi.apiRetry = 0;
+      if (substrateApi.isApiReadyOnce) {
+        substrateApi.isApiReady = true;
+      }
+      substrateApi.isApiConnected = true;
+    });
+    api.on('disconnected', () => {
+      substrateApi.isApiConnected = false;
+      substrateApi.isApiReady = false;
+      substrateApi.apiRetry = (substrateApi.apiRetry || 0) + 1;
+      this.logger.log(`Substrate API disconnected from ${JSON.stringify(apiUrl)} ${JSON.stringify(substrateApi.apiRetry)} times`);
+      if (substrateApi.apiRetry > API_MAX_RETRY) {
+        this.logger.log(`Disconnect from provider ${JSON.stringify(apiUrl)} because retry maxed out`);
+        provider.disconnect().then(this.logger.log).catch(this.logger.error);
+      }
+    });
+    api.on('ready', () => {
+      this.logger.log('Substrate API ready with', apiUrl);
+      this.loadOnReady(registry, api).then(rs => {
+        objectSpread(substrateApi, rs);
+      }).catch(error => {
+        substrateApi.apiError = error.message;
+      });
+    });
+    return substrateApi;
+  }
+  async getChainMetadata(registry, api) {
+    var _api$rpc$system, _api$rpc$system2, _api$rpc$system3, _api$rpc$system4, _api$rpc$system5;
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+    const [systemChain, systemChainType, systemName, systemVersion] = await Promise.all([// eslint-disable-next-line @typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-member-access
+    (_api$rpc$system = api.rpc.system) === null || _api$rpc$system === void 0 ? void 0 : _api$rpc$system.chain(),
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+    (_api$rpc$system2 = api.rpc.system) !== null && _api$rpc$system2 !== void 0 && _api$rpc$system2.chainType // eslint-disable-next-line @typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-member-access
+    ? (_api$rpc$system3 = api.rpc.system) === null || _api$rpc$system3 === void 0 ? void 0 : _api$rpc$system3.chainType() : Promise.resolve(registry.createType('ChainType', 'Live')), // eslint-disable-next-line @typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-member-access
+    (_api$rpc$system4 = api.rpc.system) === null || _api$rpc$system4 === void 0 ? void 0 : _api$rpc$system4.name(), // eslint-disable-next-line @typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-member-access
+    (_api$rpc$system5 = api.rpc.system) === null || _api$rpc$system5 === void 0 ? void 0 : _api$rpc$system5.version()]);
+    return {
+      // @ts-ignore
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+      properties: registry.createType('ChainProperties', {
+        ss58Format: api.registry.chainSS58,
+        tokenDecimals: api.registry.chainDecimals,
+        tokenSymbol: api.registry.chainTokens
+      }),
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-assignment,@typescript-eslint/no-unsafe-member-access
+      systemChain: (systemChain || '<unknown>').toString(),
+      // @ts-ignore
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+      systemChainType,
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment,@typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-member-access
+      systemName: systemName.toString(),
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment,@typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-member-access
+      systemVersion: systemVersion.toString()
+    };
+  }
+  async loadOnReady(registry, api) {
+    const DEFAULT_DECIMALS = registry.createType('u32', 12);
+    const DEFAULT_SS58 = registry.createType('u32', addressDefaults.prefix);
+    const {
+      properties,
+      systemChain,
+      systemChainType,
+      systemName,
+      systemVersion
+    } = await this.getChainMetadata(registry, api);
+    const ss58Format = properties.ss58Format.unwrapOr(DEFAULT_SS58).toNumber();
+    const tokenSymbol = properties.tokenSymbol.unwrapOr([formatBalance.getDefaults().unit, ...DEFAULT_AUX]);
+    const tokenDecimals = properties.tokenDecimals.unwrapOr([DEFAULT_DECIMALS]);
+    const isDevelopment = systemChainType.isDevelopment || systemChainType.isLocal || isTestChain(systemChain);
+    this.logger.log(`chain: ${systemChain} (${systemChainType.toString()}), ${stringify(properties)}`);
+
+    // explicitly override the ss58Format as specified
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+    registry.setChainProperties(registry.createType('ChainProperties', {
+      ss58Format,
+      tokenDecimals,
+      tokenSymbol
+    }));
+
+    // first set up the UI helpers
+    const defaultFormatBalance = {
+      decimals: tokenDecimals.map(b => b.toNumber()),
+      unit: tokenSymbol[0].toString()
+    };
+    const defaultSection = Object.keys(api.tx)[0];
+    const defaultMethod = Object.keys(api.tx[defaultSection])[0];
+    const apiDefaultTx = api.tx[defaultSection][defaultMethod];
+    const apiDefaultTxSudo = api.tx.system && api.tx.system.setCode || apiDefaultTx;
+    return {
+      defaultFormatBalance,
+      registry,
+      apiDefaultTx,
+      apiDefaultTxSudo,
+      isApiReady: true,
+      isApiReadyOnce: true,
+      isDevelopment: isDevelopment,
+      specName: api.runtimeVersion.specName.toString(),
+      specVersion: api.runtimeVersion.specVersion.toString(),
+      systemChain,
+      systemName,
+      systemVersion
+    };
+  }
+}

package/services/chain-service/handler/light-client/index.d.ts

@@ -0,0 +1,4 @@
+import { ProviderInterface } from '@polkadot/rpc-provider/types';
+export declare const relayChainSpecs: Record<string, string>;
+export declare const paraChainSpecs: Record<string, string>;
+export declare function getSubstrateConnectProvider(specLink: string): ProviderInterface;

package/services/chain-service/handler/light-client/index.js

@@ -0,0 +1,111 @@
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { ScProvider } from '@polkadot/rpc-provider';
+export const relayChainSpecs = {
+  kusama: ScProvider.WellKnownChain.ksmcc3,
+  polkadot: ScProvider.WellKnownChain.polkadot,
+  rococo: ScProvider.WellKnownChain.rococo_v2_2,
+  westend: ScProvider.WellKnownChain.westend2
+};
+
+// Direct get spec data from @polkadot/react-api repository
+const sourceFolderUrl = 'https://raw.githubusercontent.com/polkadot-js/apps/master/packages/react-api/src/light/';
+export const paraChainSpecs = {
+  'kusama/shiden': `${sourceFolderUrl}kusama/shiden.json`,
+  'kusama/tinkernet': `${sourceFolderUrl}kusama/tinkernet.json`,
+  'polkadot/astar': `${sourceFolderUrl}polkadot/astar.json`
+};
+class ProviderPlaceholder {
+  constructor(providerPromise) {
+    this.providerPromise = providerPromise;
+    providerPromise.then(provider => {
+      this.provider = provider;
+    }).catch(console.error);
+  }
+  get hasSubscriptions() {
+    return true;
+  }
+  get isClonable() {
+    if (this.provider) {
+      return this.provider.isClonable;
+    } else {
+      return false;
+    }
+  }
+  get isConnected() {
+    if (this.provider) {
+      return this.provider.isConnected;
+    } else {
+      return false;
+    }
+  }
+  clone() {
+    var _this$provider;
+    // @ts-ignore
+    return (_this$provider = this.provider) === null || _this$provider === void 0 ? void 0 : _this$provider.clone();
+  }
+  async connect() {
+    var _this$provider2;
+    await this.providerPromise;
+    await ((_this$provider2 = this.provider) === null || _this$provider2 === void 0 ? void 0 : _this$provider2.connect());
+  }
+  async disconnect() {
+    var _this$provider3;
+    await this.providerPromise;
+    await ((_this$provider3 = this.provider) === null || _this$provider3 === void 0 ? void 0 : _this$provider3.disconnect());
+  }
+  on(type, sub) {
+    let cancel = false;
+    let unsub = () => {
+      cancel = false;
+    };
+    this.providerPromise.then(provider => {
+      if (!cancel) {
+        unsub = provider.on(type, sub);
+      }
+    }).catch(console.error);
+    return () => {
+      unsub();
+    };
+  }
+  send(method, params, isCacheable) {
+    if (this.provider) {
+      return this.provider.send(method, params);
+    }
+    return this.providerPromise.then(provider => {
+      return provider.send(method, params);
+    });
+  }
+  subscribe(type, method, params, cb) {
+    if (this.provider) {
+      return this.provider.subscribe(type, method, params, cb);
+    }
+    return this.providerPromise.then(provider => {
+      return provider.subscribe(type, method, params, cb);
+    });
+  }
+  unsubscribe(type, method, id) {
+    if (this.provider) {
+      return this.provider.unsubscribe(type, method, id);
+    }
+    return this.providerPromise.then(provider => {
+      return provider.unsubscribe(type, method, id);
+    });
+  }
+}
+export function getSubstrateConnectProvider(specLink) {
+  const [relayName, paraName] = specLink.split('/');
+  const relaySpec = relayChainSpecs[relayName];
+  const relayProvider = new ScProvider(relaySpec);
+  if (!paraName) {
+    return relayProvider;
+  }
+  const paraChainData = paraChainSpecs[specLink];
+  let scProvider;
+  const scPromise = fetch(paraChainData).then(rs => rs.text()).then(spec => {
+    scProvider = new ScProvider(spec, relayProvider);
+    return scProvider;
+  }).catch(console.error);
+  return new ProviderPlaceholder(scPromise);
+}

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

@@ -0,0 +1,26 @@
+export interface _EvmChainSpec {
+    evmChainId: number;
+    name: string;
+    symbol: string;
+    decimals: number;
+    existentialDeposit: string;
+}
+export interface _SubstrateChainSpec {
+    name: string;
+    addressPrefix: number;
+    genesisHash: string;
+    symbol: string;
+    decimals: number;
+    existentialDeposit: string;
+    paraId: number | null;
+}
+export declare enum _CHAIN_VALIDATION_ERROR {
+    INVALID_INFO_TYPE = "invalidInfoType",
+    INJECT_SCRIPT_DETECTED = "injectScriptDetected",
+    EXISTED_CHAIN = "existedChain",
+    EXISTED_PROVIDER = "existedProvider",
+    INVALID_PROVIDER = "invalidProvider",
+    NONE = "none",
+    CONNECTION_FAILURE = "connectionFailure",
+    PROVIDER_NOT_SAME_CHAIN = "providerNotSameChain"
+}

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

@@ -0,0 +1,14 @@
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+export let _CHAIN_VALIDATION_ERROR;
+(function (_CHAIN_VALIDATION_ERROR) {
+  _CHAIN_VALIDATION_ERROR["INVALID_INFO_TYPE"] = "invalidInfoType";
+  _CHAIN_VALIDATION_ERROR["INJECT_SCRIPT_DETECTED"] = "injectScriptDetected";
+  _CHAIN_VALIDATION_ERROR["EXISTED_CHAIN"] = "existedChain";
+  _CHAIN_VALIDATION_ERROR["EXISTED_PROVIDER"] = "existedProvider";
+  _CHAIN_VALIDATION_ERROR["INVALID_PROVIDER"] = "invalidProvider";
+  _CHAIN_VALIDATION_ERROR["NONE"] = "none";
+  _CHAIN_VALIDATION_ERROR["CONNECTION_FAILURE"] = "connectionFailure";
+  _CHAIN_VALIDATION_ERROR["PROVIDER_NOT_SAME_CHAIN"] = "providerNotSameChain";
+})(_CHAIN_VALIDATION_ERROR || (_CHAIN_VALIDATION_ERROR = {}));

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

@@ -0,0 +1,3 @@
+export declare function checkSubstrateEndpoint(endpoint: string, timeout: number): Promise<boolean>;
+export declare function checkEvmEndpoint(endpoint: string, timeout: number): Promise<boolean>;
+export declare function checkProviders(providers: Record<string, string>, timeout?: number): Promise<Record<string, boolean>>;

package/services/chain-service/heath-check/index.js

@@ -0,0 +1,50 @@
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import Web3 from 'web3';
+import { WsProvider } from '@polkadot/api';
+export async function checkSubstrateEndpoint(endpoint, timeout) {
+  const wsProvider = new WsProvider(endpoint, false, undefined, timeout);
+  try {
+    await wsProvider.connect();
+    return await new Promise(resolve => {
+      wsProvider.on('connected', () => {
+        wsProvider.send('system_health', []).then(systemHealth => {
+          resolve(true);
+        }).catch(console.log);
+      });
+    });
+  } catch (error) {
+    console.log(`${endpoint}: fail to check health`);
+    return false; // if there is an error, return false
+  } finally {
+    await wsProvider.disconnect(); // disconnect from the endpoint after the health check is complete
+  }
+}
+
+export async function checkEvmEndpoint(endpoint, timeout) {
+  try {
+    const web3 = new Web3(endpoint);
+    const timeoutPromise = new Promise(resolve => setTimeout(() => resolve(false), timeout));
+    const blockNumber = await Promise.race([web3.eth.getBlockNumber(), timeoutPromise]);
+    return !!blockNumber;
+  } catch (error) {
+    console.log(error);
+    return false;
+  }
+}
+export async function checkProviders(providers, timeout = 5000) {
+  const healthMap = await Promise.all(Object.keys(providers).map(async providerKey => {
+    const endpoint = providers[providerKey];
+
+    // Allow light client success by default
+    if (endpoint.startsWith('light://')) {
+      return [providerKey, true];
+    }
+    const checkPromise = endpoint.startsWith('wss://') ? checkSubstrateEndpoint(endpoint, timeout) : checkEvmEndpoint(endpoint, timeout);
+    const timeoutPromise = new Promise(resolve => setTimeout(() => resolve(false), timeout));
+    const health = await Promise.race([checkPromise, timeoutPromise]);
+    return [providerKey, health];
+  })).then(res => Object.fromEntries(res));
+  return healthMap;
+}

package/services/chain-service/helper/api-helper/chain/crust-maxwell.d.ts

@@ -0,0 +1,98 @@
+declare const _default: {
+    AccountInfo: string;
+    Address: string;
+    AddressInfo: string;
+    LookupSource: string;
+    EraBenefits: {
+        total_benefits: string;
+        total_funds: string;
+        used_benefits: string;
+        active_era: string;
+    };
+    FeeReductionBenefit: {
+        funds: string;
+        total_fee_reduction_count: string;
+        used_fee_reduction_quota: string;
+        used_fee_reduction_count: string;
+        refreshed_at: string;
+    };
+    CsmBalance: string;
+    CsmBalanceOf: string;
+    ETHAddress: string;
+    EthereumTxHash: string;
+    CSMLedger: {
+        total: string;
+        active: string;
+        unlocking: string;
+    };
+    CSMUnlockChunk: {
+        value: string;
+        bn: string;
+    };
+    FileInfo: {
+        file_size: string;
+        expired_on: string;
+        calculated_at: string;
+        amount: string;
+        prepaid: string;
+        reported_replica_count: string;
+        replicas: string;
+    };
+    MerchantLedger: {
+        reward: string;
+        collateral: string;
+    };
+    Releases: {
+        _enum: string[];
+    };
+    Replica: {
+        who: string;
+        valid_at: string;
+        anchor: string;
+        is_reported: string;
+    };
+    Status: {
+        _enum: string[];
+    };
+    UsedInfo: {
+        used_size: string;
+        reported_group_count: string;
+        groups: string;
+    };
+    Guarantee: {
+        targets: string;
+        total: string;
+        submitted_in: string;
+        suppressed: string;
+    };
+    ValidatorPrefs: {
+        guarantee_fee: string;
+    };
+    IASSig: string;
+    Identity: {
+        anchor: string;
+        punishment_deadline: string;
+        group: string;
+    };
+    ISVBody: string;
+    MerkleRoot: string;
+    ReportSlot: string;
+    PKInfo: {
+        code: string;
+        anchor: string;
+    };
+    SworkerAnchor: string;
+    SworkerCert: string;
+    SworkerCode: string;
+    SworkerPubKey: string;
+    SworkerSignature: string;
+    WorkReport: {
+        report_slot: string;
+        used: string;
+        free: string;
+        reported_files_size: string;
+        reported_srd_root: string;
+        reported_files_root: string;
+    };
+};
+export default _default;