@subwallet/extension-base 0.8.3-2 → 1.0.1

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

@@ -0,0 +1,144 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.EvmChainHandler = void 0;
+var _types = require("@subwallet/chain-list/types");
+var _helper = require("@subwallet/extension-base/services/chain-service/helper");
+var _web = _interopRequireDefault(require("web3"));
+var _logger = require("@polkadot/util/logger");
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+class EvmChainHandler {
+  evmApiMap = {};
+  constructor() {
+    this.logger = (0, _logger.logger)('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 _web.default(new _web.default.providers.HttpProvider(apiUrl));
+    } else {
+      api = new _web.default(new _web.default.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 === _types._AssetType.ERC721) {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument,@typescript-eslint/no-unsafe-member-access
+        tokenContract = new evmApi.api.eth.Contract(_helper._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(_helper._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
+      };
+    }
+  }
+}
+exports.EvmChainHandler = EvmChainHandler;

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

@@ -0,0 +1,348 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.SubstrateChainHandler = exports.DEFAULT_AUX = void 0;
+var _api = require("@acala-network/api");
+var _types = require("@oak-foundation/types");
+var _types2 = require("@subwallet/chain-list/types");
+var _lightClient = require("@subwallet/extension-base/services/chain-service/handler/light-client");
+var _api2 = require("@polkadot/api");
+var _apiContract = require("@polkadot/api-contract");
+var _create = require("@polkadot/types/create");
+var _util = require("@polkadot/util");
+var _logger = require("@polkadot/util/logger");
+var _defaults = require("@polkadot/util-crypto/address/defaults");
+var _constants = require("../constants");
+var _helper = require("../helper");
+var _apiHelper = require("../helper/api-helper");
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+const DEFAULT_AUX = ['Aux1', 'Aux2', 'Aux3', 'Aux4', 'Aux5', 'Aux6', 'Aux7', 'Aux8', 'Aux9'];
+exports.DEFAULT_AUX = DEFAULT_AUX;
+class SubstrateChainHandler {
+  substrateApiMap = {};
+  constructor() {
+    this.logger = (0, _logger.logger)('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 === _types2._AssetType.PSP22) {
+        tokenContract = new _apiContract.ContractPromise(substrateApi.api, _helper._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 _apiContract.ContractPromise(substrateApi.api, _helper._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 _create.TypeRegistry();
+    const provider = apiUrl.startsWith('light://') ? (0, _lightClient.getSubstrateConnectProvider)(apiUrl.replace('light://substrate-connect/', '')) : new _api2.WsProvider(apiUrl, _constants.API_AUTO_CONNECT_MS);
+    const apiOption = {
+      provider,
+      typesBundle: _apiHelper.typesBundle,
+      typesChain: _apiHelper.typesChain
+    };
+
+    // @ts-ignore
+    apiOption.registry = registry;
+    let api;
+    if (_constants._API_OPTIONS_CHAIN_GROUP.acala.includes(chainSlug)) {
+      api = new _api2.ApiPromise((0, _api.options)({
+        provider
+      }));
+    } else if (_constants._API_OPTIONS_CHAIN_GROUP.turing.includes(chainSlug)) {
+      api = new _api2.ApiPromise({
+        provider,
+        rpc: _types.rpc,
+        types: _types.types
+      });
+    } else {
+      api = new _api2.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 > _constants.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 => {
+        (0, _util.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', _defaults.defaults.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([_util.formatBalance.getDefaults().unit, ...DEFAULT_AUX]);
+    const tokenDecimals = properties.tokenDecimals.unwrapOr([DEFAULT_DECIMALS]);
+    const isDevelopment = systemChainType.isDevelopment || systemChainType.isLocal || (0, _util.isTestChain)(systemChain);
+    this.logger.log(`chain: ${systemChain} (${systemChainType.toString()}), ${(0, _util.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
+    };
+  }
+}
+exports.SubstrateChainHandler = SubstrateChainHandler;

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

@@ -0,0 +1,120 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getSubstrateConnectProvider = getSubstrateConnectProvider;
+exports.relayChainSpecs = exports.paraChainSpecs = void 0;
+var _rpcProvider = require("@polkadot/rpc-provider");
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+const relayChainSpecs = {
+  kusama: _rpcProvider.ScProvider.WellKnownChain.ksmcc3,
+  polkadot: _rpcProvider.ScProvider.WellKnownChain.polkadot,
+  rococo: _rpcProvider.ScProvider.WellKnownChain.rococo_v2_2,
+  westend: _rpcProvider.ScProvider.WellKnownChain.westend2
+};
+
+// Direct get spec data from @polkadot/react-api repository
+exports.relayChainSpecs = relayChainSpecs;
+const sourceFolderUrl = 'https://raw.githubusercontent.com/polkadot-js/apps/master/packages/react-api/src/light/';
+const paraChainSpecs = {
+  'kusama/shiden': `${sourceFolderUrl}kusama/shiden.json`,
+  'kusama/tinkernet': `${sourceFolderUrl}kusama/tinkernet.json`,
+  'polkadot/astar': `${sourceFolderUrl}polkadot/astar.json`
+};
+exports.paraChainSpecs = paraChainSpecs;
+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);
+    });
+  }
+}
+function getSubstrateConnectProvider(specLink) {
+  const [relayName, paraName] = specLink.split('/');
+  const relaySpec = relayChainSpecs[relayName];
+  const relayProvider = new _rpcProvider.ScProvider(relaySpec);
+  if (!paraName) {
+    return relayProvider;
+  }
+  const paraChainData = paraChainSpecs[specLink];
+  let scProvider;
+  const scPromise = fetch(paraChainData).then(rs => rs.text()).then(spec => {
+    scProvider = new _rpcProvider.ScProvider(spec, relayProvider);
+    return scProvider;
+  }).catch(console.error);
+  return new ProviderPlaceholder(scPromise);
+}

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

@@ -0,0 +1,20 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports._CHAIN_VALIDATION_ERROR = void 0;
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+let _CHAIN_VALIDATION_ERROR;
+exports._CHAIN_VALIDATION_ERROR = _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 || (exports._CHAIN_VALIDATION_ERROR = _CHAIN_VALIDATION_ERROR = {}));

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

@@ -0,0 +1,60 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.checkEvmEndpoint = checkEvmEndpoint;
+exports.checkProviders = checkProviders;
+exports.checkSubstrateEndpoint = checkSubstrateEndpoint;
+var _web = _interopRequireDefault(require("web3"));
+var _api = require("@polkadot/api");
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+async function checkSubstrateEndpoint(endpoint, timeout) {
+  const wsProvider = new _api.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
+  }
+}
+
+async function checkEvmEndpoint(endpoint, timeout) {
+  try {
+    const web3 = new _web.default(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;
+  }
+}
+async function checkProviders(providers) {
+  let timeout = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 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;
+}