@subwallet/extension-base 1.0.10-0 → 1.0.11-0

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

@@ -1,20 +1,21 @@
 "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 _AbstractChainHandler = require("@subwallet/extension-base/services/chain-service/handler/AbstractChainHandler");
+var _EvmApi2 = require("@subwallet/extension-base/services/chain-service/handler/EvmApi");
 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 {
+class EvmChainHandler extends _AbstractChainHandler.AbstractChainHandler {
   evmApiMap = {};
-  constructor() {
+  constructor(parent) {
+    super(parent);
     this.logger = (0, _logger.logger)('evm-chain-handler');
   }
   getEvmApiMap() {
@@ -23,47 +24,62 @@ class EvmChainHandler {
   getEvmApiByChain(chainSlug) {
     return this.evmApiMap[chainSlug];
   }
+  getApiByChain(chain) {
+    return this.getEvmApiByChain(chain);
+  }
   setEvmApi(chainSlug, evmApi) {
     this.evmApiMap[chainSlug] = evmApi;
   }
-  destroyEvmApi(chainSlug) {
-    // TODO: handle API destroy better
-    delete this.evmApiMap[chainSlug];
+  async initApi(chainSlug, apiUrl) {
+    let {
+      onUpdateStatus,
+      providerName
+    } = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+    const existed = this.getEvmApiByChain(chainSlug);
+    if (existed) {
+      existed.connect();
+      if (apiUrl !== existed.apiUrl) {
+        existed.updateApiUrl(apiUrl).catch(console.error);
+      }
+      return existed;
+    }
+    const apiObject = new _EvmApi2.EvmApi(chainSlug, apiUrl, {
+      providerName
+    });
+    apiObject.isApiConnectedSubject.subscribe(this.handleConnect.bind(this, chainSlug));
+    apiObject.isApiConnectedSubject.subscribe(onUpdateStatus);
+    return Promise.resolve(apiObject);
+  }
+  async recoverApi(chainSlug) {
+    const existed = this.getEvmApiByChain(chainSlug);
+    if (existed && !existed.isApiReadyOnce) {
+      console.log(`Reconnect ${existed.providerName || existed.chainSlug} at ${existed.apiUrl}`);
+      return existed.recoverConnect();
+    }
   }
-  refreshApi(slug, endpoint, providerName) {
-    this.evmApiMap[slug] = this.initApi(slug, endpoint, providerName);
+  destroyEvmApi(chain) {
+    const evmApi = this.getEvmApiByChain(chain);
+    evmApi === null || evmApi === void 0 ? void 0 : evmApi.destroy().catch(console.error);
   }
-  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));
+  async sleep() {
+    this.isSleeping = true;
+    this.cancelAllRecover();
+    await Promise.all(Object.values(this.getEvmApiMap()).map(evmApi => {
+      return evmApi.disconnect().catch(console.error);
+    }));
+    return Promise.resolve();
+  }
+  wakeUp() {
+    var _this$parent;
+    this.isSleeping = false;
+    const activeChains = ((_this$parent = this.parent) === null || _this$parent === void 0 ? void 0 : _this$parent.getActiveChains()) || [];
+    for (const chain of activeChains) {
+      const evmApi = this.getEvmApiByChain(chain);
+
+      // Not found evmApi mean it active with substrate interface
+      evmApi === null || evmApi === void 0 ? void 0 : evmApi.connect();
     }
-    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();
-      }
-    };
+    return Promise.resolve();
   }
   async getChainSpec(evmApi) {
     const chainId = await evmApi.api.eth.getChainId();

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

@@ -0,0 +1,212 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.SubstrateApi = void 0;
+require("@polkadot/types-augment");
+var _api = require("@acala-network/api");
+var _types = require("@oak-foundation/types");
+var _constants = require("@subwallet/extension-base/services/chain-service/constants");
+var _lightClient = require("@subwallet/extension-base/services/chain-service/handler/light-client");
+var _SubstrateChainHandler = require("@subwallet/extension-base/services/chain-service/handler/SubstrateChainHandler");
+var _promise = require("@subwallet/extension-base/utils/promise");
+var _rxjs = require("rxjs");
+var _api2 = require("@polkadot/api");
+var _api3 = require("@polkadot/apps-config/api");
+var _create = require("@polkadot/types/create");
+var _util = require("@polkadot/util");
+var _defaults = require("@polkadot/util-crypto/address/defaults");
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+class SubstrateApi {
+  useLightClient = false;
+  isApiReady = false;
+  isApiReadyOnce = false;
+  isApiConnectedSubject = new _rxjs.BehaviorSubject(false);
+  get isApiConnected() {
+    return this.isApiConnectedSubject.getValue();
+  }
+  updateConnectedStatus(isConnected) {
+    if (isConnected !== this.isApiConnectedSubject.value) {
+      this.isApiConnectedSubject.next(isConnected);
+    }
+  }
+  specName = '';
+  specVersion = '';
+  systemChain = '';
+  systemName = '';
+  systemVersion = '';
+  createProvider(apiUrl) {
+    if (apiUrl.startsWith('light://')) {
+      this.useLightClient = true;
+      return (0, _lightClient.getSubstrateConnectProvider)(apiUrl.replace('light://substrate-connect/', ''));
+    } else {
+      this.useLightClient = true;
+      return new _api2.WsProvider(apiUrl, _constants.API_AUTO_CONNECT_MS, {}, _constants.API_CONNECT_TIMEOUT);
+    }
+  }
+  createApi(provider) {
+    const apiOption = {
+      provider,
+      typesBundle: _api3.typesBundle,
+      registry: this.registry
+    };
+    if (this.metadata) {
+      const metadata = this.metadata;
+      apiOption.metadata = {
+        [`${metadata.genesisHash}-${metadata.specVersion}`]: metadata.hexValue
+      };
+    }
+    if (_constants._API_OPTIONS_CHAIN_GROUP.acala.includes(this.chainSlug)) {
+      return new _api2.ApiPromise((0, _api.options)({
+        provider
+      }));
+    } else if (_constants._API_OPTIONS_CHAIN_GROUP.turing.includes(this.chainSlug)) {
+      return new _api2.ApiPromise({
+        provider,
+        rpc: _types.rpc,
+        types: _types.types
+      });
+    } else {
+      return new _api2.ApiPromise(apiOption);
+    }
+  }
+  constructor(chainSlug, apiUrl) {
+    let {
+      metadata,
+      providerName
+    } = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+    this.chainSlug = chainSlug;
+    this.apiUrl = apiUrl;
+    this.providerName = providerName;
+    this.registry = new _create.TypeRegistry();
+    this.metadata = metadata;
+    this.provider = this.createProvider(apiUrl);
+    this.api = this.createApi(this.provider);
+    this.handleApiReady = (0, _promise.createPromiseHandler)();
+    this.api.on('ready', this.onReady.bind(this));
+    this.api.on('connected', this.onConnect.bind(this));
+    this.api.on('disconnected', this.onDisconnect.bind(this));
+    this.api.on('error', this.onError.bind(this));
+  }
+  get isReady() {
+    return this.handleApiReady.promise;
+  }
+  async updateApiUrl(apiUrl) {
+    if (this.apiUrl === apiUrl) {
+      return;
+    }
+
+    // Disconnect with old provider
+    await this.disconnect();
+    this.isApiReadyOnce = false;
+    this.api.off('ready', this.onReady.bind(this));
+    this.api.off('connected', this.onConnect.bind(this));
+    this.api.off('disconnected', this.onDisconnect.bind(this));
+    this.api.off('error', this.onError.bind(this));
+
+    // Create new provider and api
+    this.apiUrl = apiUrl;
+    this.provider = this.createProvider(apiUrl);
+    this.api = this.createApi(this.provider);
+    this.api.on('ready', this.onReady.bind(this));
+    this.api.on('connected', this.onConnect.bind(this));
+    this.api.on('disconnected', this.onDisconnect.bind(this));
+    this.api.on('error', this.onError.bind(this));
+  }
+  connect() {
+    if (this.api.isConnected) {
+      this.updateConnectedStatus(true);
+    } else {
+      this.api.connect().then(() => {
+        this.updateConnectedStatus(true);
+      }).catch(console.error);
+    }
+  }
+  async disconnect() {
+    try {
+      await this.api.disconnect();
+    } catch (e) {
+      console.error(e);
+    }
+    this.updateConnectedStatus(false);
+  }
+  async recoverConnect() {
+    await this.disconnect();
+    this.connect();
+    await this.handleApiReady.promise;
+  }
+  destroy() {
+    // Todo: implement this in the future
+    return this.disconnect();
+  }
+  onReady() {
+    this.fillApiInfo().then(() => {
+      this.handleApiReady.resolve(this);
+      this.isApiReady = true;
+      this.isApiReadyOnce = true;
+    }).catch(error => {
+      this.apiError = error === null || error === void 0 ? void 0 : error.message;
+      this.handleApiReady.reject(error);
+    });
+  }
+  onConnect() {
+    this.updateConnectedStatus(true);
+    console.log(`Connected to ${this.chainSlug || ''} at ${this.apiUrl}`);
+    if (this.isApiReadyOnce) {
+      this.handleApiReady.resolve(this);
+    }
+  }
+  onDisconnect() {
+    this.isApiReady = false;
+    console.log(`Disconnected from ${this.chainSlug} at ${this.apiUrl}`);
+    this.updateConnectedStatus(false);
+    this.handleApiReady = (0, _promise.createPromiseHandler)();
+  }
+  onError(e) {
+    console.warn(`${this.chainSlug} connection got error`, e);
+  }
+  async fillApiInfo() {
+    var _api$rpc$system, _api$rpc$system2, _api$rpc$system3;
+    const {
+      api,
+      registry
+    } = this;
+    const DEFAULT_DECIMALS = registry.createType('u32', 12);
+    const DEFAULT_SS58 = registry.createType('u32', _defaults.defaults.prefix);
+    this.specName = this.api.runtimeVersion.specName.toString();
+    this.specVersion = this.api.runtimeVersion.specVersion.toString();
+    const [systemChain, systemName, systemVersion] = await Promise.all([(_api$rpc$system = api.rpc.system) === null || _api$rpc$system === void 0 ? void 0 : _api$rpc$system.chain(), (_api$rpc$system2 = api.rpc.system) === null || _api$rpc$system2 === void 0 ? void 0 : _api$rpc$system2.name(), (_api$rpc$system3 = api.rpc.system) === null || _api$rpc$system3 === void 0 ? void 0 : _api$rpc$system3.version()]);
+    this.systemChain = systemChain.toString();
+    this.systemName = systemName.toString();
+    this.systemVersion = systemVersion.toString();
+    const properties = registry.createType('ChainProperties', {
+      ss58Format: api.registry.chainSS58,
+      tokenDecimals: api.registry.chainDecimals,
+      tokenSymbol: api.registry.chainTokens
+    });
+    const ss58Format = properties.ss58Format.unwrapOr(DEFAULT_SS58).toNumber();
+    const tokenSymbol = properties.tokenSymbol.unwrapOr([_util.formatBalance.getDefaults().unit, ..._SubstrateChainHandler.DEFAULT_AUX]);
+    const tokenDecimals = properties.tokenDecimals.unwrapOr([DEFAULT_DECIMALS]);
+    registry.setChainProperties(registry.createType('ChainProperties', {
+      ss58Format,
+      tokenDecimals,
+      tokenSymbol
+    }));
+
+    // first set up the UI helpers
+    this.defaultFormatBalance = {
+      decimals: tokenDecimals.map(b => {
+        return b.toNumber();
+      }),
+      unit: tokenSymbol[0].toString()
+    };
+    const defaultSection = Object.keys(api.tx)[0];
+    const defaultMethod = Object.keys(api.tx[defaultSection])[0];
+    this.apiDefaultTx = api.tx[defaultSection][defaultMethod];
+    this.apiDefaultTxSudo = api.tx.system && api.tx.system.setCode || this.apiDefaultTx;
+  }
+}
+exports.SubstrateApi = SubstrateApi;

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

@@ -4,28 +4,23 @@ 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 _types = require("@subwallet/chain-list/types");
 var _utils = require("@subwallet/extension-base/koni/api/tokens/wasm/utils");
-var _lightClient = require("@subwallet/extension-base/services/chain-service/handler/light-client");
-var _api2 = require("@polkadot/api");
+var _AbstractChainHandler = require("@subwallet/extension-base/services/chain-service/handler/AbstractChainHandler");
+var _SubstrateApi2 = require("@subwallet/extension-base/services/chain-service/handler/SubstrateApi");
 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 {
+class SubstrateChainHandler extends _AbstractChainHandler.AbstractChainHandler {
   substrateApiMap = {};
-  constructor() {
+  constructor(parent) {
+    super(parent);
     this.logger = (0, _logger.logger)('substrate-chain-handler');
   }
   getSubstrateApiMap() {
@@ -34,29 +29,45 @@ class SubstrateChainHandler {
   getSubstrateApiByChain(chainSlug) {
     return this.substrateApiMap[chainSlug];
   }
-  resumeAllApis() {
-    return Promise.all(Object.values(this.getSubstrateApiMap()).map(async substrateApi => {
-      if (!substrateApi.api.isConnected && substrateApi.api.connect) {
-        await substrateApi.api.connect();
-      }
-    }));
+  getApiByChain(chain) {
+    return this.getSubstrateApiByChain(chain);
   }
-  disconnectAllApis() {
-    return Promise.all(Object.values(this.getSubstrateApiMap()).map(async substrateApi => {
-      if (substrateApi.api.isConnected) {
-        var _substrateApi$api, _substrateApi$api2;
-        ((_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()));
+  async wakeUp() {
+    var _this$parent;
+    this.isSleeping = false;
+    const activeChains = ((_this$parent = this.parent) === null || _this$parent === void 0 ? void 0 : _this$parent.getActiveChains()) || [];
+    for (const chain of activeChains) {
+      const api = this.getSubstrateApiByChain(chain);
+
+      // Not found substrateInterface mean it active with evm interface
+      if (api) {
+        api === null || api === void 0 ? void 0 : api.connect();
+        if (!api.useLightClient) {
+          // Manual fire handle connect to avoid some chain can not reconnect
+          setTimeout(() => {
+            this.handleConnect(chain, api.isApiConnected);
+          }, _AbstractChainHandler.SHORT_RETRY_TIME);
+        }
       }
+    }
+    return Promise.resolve();
+  }
+  async sleep() {
+    this.isSleeping = true;
+    this.cancelAllRecover();
+    await Promise.all(Object.values(this.getSubstrateApiMap()).map(substrateApi => {
+      return substrateApi.disconnect().catch(console.error);
     }));
   }
-  refreshApi(slug) {
-    const substrateApi = this.getSubstrateApiByChain(slug);
-    if (substrateApi && !substrateApi.isApiConnected) {
-      substrateApi.recoverConnect && substrateApi.recoverConnect();
+  async recoverApi(chainSlug) {
+    const existed = this.getSubstrateApiByChain(chainSlug);
+    if (existed && !existed.isApiReadyOnce) {
+      console.log(`Reconnect ${existed.providerName || existed.chainSlug} at ${existed.apiUrl}`);
+      return existed.recoverConnect();
     }
   }
   async getChainSpec(substrateApi) {
-    var _substrateApi$api$gen, _substrateApi$api3, _substrateApi$api3$co, _substrateApi$api3$co2, _substrateApi$api3$co3;
+    var _substrateApi$api$gen, _substrateApi$api, _substrateApi$api$con, _substrateApi$api$con2, _substrateApi$api$con3;
     const result = {
       addressPrefix: -1,
       decimals: 0,
@@ -78,7 +89,7 @@ class SubstrateChainHandler {
     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.addressPrefix = (_substrateApi$api = substrateApi.api) === null || _substrateApi$api === void 0 ? void 0 : (_substrateApi$api$con = _substrateApi$api.consts) === null || _substrateApi$api$con === void 0 ? void 0 : (_substrateApi$api$con2 = _substrateApi$api$con.system) === null || _substrateApi$api$con2 === void 0 ? void 0 : (_substrateApi$api$con3 = _substrateApi$api$con2.ss58Prefix) === null || _substrateApi$api$con3 === void 0 ? void 0 : _substrateApi$api$con3.toPrimitive();
     result.existentialDeposit = substrateApi.api.consts.balances.existentialDeposit.toString();
     return result;
   }
@@ -90,7 +101,7 @@ class SubstrateChainHandler {
     let contractError = false;
     const substrateApi = this.getSubstrateApiByChain(originChain);
     try {
-      if (tokenType === _types2._AssetType.PSP22) {
+      if (tokenType === _types._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: (0, _utils.getDefaultWeightV2)(substrateApi.api)
@@ -165,182 +176,48 @@ class SubstrateChainHandler {
     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];
+    const substrateAPI = this.substrateApiMap[chainSlug];
+    substrateAPI === null || substrateAPI === void 0 ? void 0 : substrateAPI.destroy().catch(console.error);
   }
-  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
-    };
+  async initApi(chainSlug, apiUrl) {
+    var _this$parent2;
+    let {
+      onUpdateStatus,
+      providerName
+    } = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+    const existed = this.substrateApiMap[chainSlug];
 
-    // @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);
+    // Return existed to avoid re-init metadata
+    if (existed) {
+      existed.connect();
+      if (apiUrl !== existed.apiUrl) {
+        await existed.updateApiUrl(apiUrl);
+      }
+      return existed;
     }
-    const substrateApi = {
-      api,
+    const metadata = await ((_this$parent2 = this.parent) === null || _this$parent2 === void 0 ? void 0 : _this$parent2.getMetadata(chainSlug));
+    const apiObject = new _SubstrateApi2.SubstrateApi(chainSlug, apiUrl, {
       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;
-        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', () => {
-      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.loadOnReady(registry, api).then(rs => {
-        (0, _util.objectSpread)(substrateApi, rs);
-      }).catch(error => {
-        substrateApi.apiError = error.message;
-      });
+      metadata
     });
-    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(`Connected to ${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
-    }));
+    apiObject.isApiConnectedSubject.subscribe(this.handleConnect.bind(this, chainSlug));
+    onUpdateStatus && apiObject.isApiConnectedSubject.subscribe(onUpdateStatus);
 
-    // 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
-    };
+    // Update metadata to database with async methods
+    apiObject.isReady.then(api => {
+      var _this$parent3;
+      // Avoid date existed metadata
+      if (metadata && metadata.specVersion === api.specVersion && metadata.genesisHash === api.api.genesisHash.toHex()) {
+        return;
+      }
+      (_this$parent3 = this.parent) === null || _this$parent3 === void 0 ? void 0 : _this$parent3.upsertMetadata(chainSlug, {
+        chain: chainSlug,
+        genesisHash: api.api.genesisHash.toHex(),
+        specVersion: api.specVersion,
+        hexValue: api.api.runtimeMetadata.toHex()
+      }).catch(console.error);
+    }).catch(console.error);
+    return apiObject;
   }
 }
 exports.SubstrateChainHandler = SubstrateChainHandler;