@subwallet/extension-base 1.0.9-2 → 1.0.11-0

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

@@ -0,0 +1,204 @@
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import '@polkadot/types-augment';
+import { options as acalaOptions } from '@acala-network/api';
+import { rpc as oakRpc, types as oakTypes } from '@oak-foundation/types';
+import { _API_OPTIONS_CHAIN_GROUP, API_AUTO_CONNECT_MS, API_CONNECT_TIMEOUT } from '@subwallet/extension-base/services/chain-service/constants';
+import { getSubstrateConnectProvider } from '@subwallet/extension-base/services/chain-service/handler/light-client';
+import { DEFAULT_AUX } from '@subwallet/extension-base/services/chain-service/handler/SubstrateChainHandler';
+import { createPromiseHandler } from '@subwallet/extension-base/utils/promise';
+import { BehaviorSubject } from 'rxjs';
+import { ApiPromise, WsProvider } from '@polkadot/api';
+import { typesBundle } from '@polkadot/apps-config/api';
+import { TypeRegistry } from '@polkadot/types/create';
+import { formatBalance } from '@polkadot/util';
+import { defaults as addressDefaults } from '@polkadot/util-crypto/address/defaults';
+export class SubstrateApi {
+  useLightClient = false;
+  isApiReady = false;
+  isApiReadyOnce = false;
+  isApiConnectedSubject = new 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 getSubstrateConnectProvider(apiUrl.replace('light://substrate-connect/', ''));
+    } else {
+      this.useLightClient = true;
+      return new WsProvider(apiUrl, API_AUTO_CONNECT_MS, {}, API_CONNECT_TIMEOUT);
+    }
+  }
+  createApi(provider) {
+    const apiOption = {
+      provider,
+      typesBundle,
+      registry: this.registry
+    };
+    if (this.metadata) {
+      const metadata = this.metadata;
+      apiOption.metadata = {
+        [`${metadata.genesisHash}-${metadata.specVersion}`]: metadata.hexValue
+      };
+    }
+    if (_API_OPTIONS_CHAIN_GROUP.acala.includes(this.chainSlug)) {
+      return new ApiPromise(acalaOptions({
+        provider
+      }));
+    } else if (_API_OPTIONS_CHAIN_GROUP.turing.includes(this.chainSlug)) {
+      return new ApiPromise({
+        provider,
+        rpc: oakRpc,
+        types: oakTypes
+      });
+    } else {
+      return new ApiPromise(apiOption);
+    }
+  }
+  constructor(chainSlug, apiUrl, {
+    metadata,
+    providerName
+  } = {}) {
+    this.chainSlug = chainSlug;
+    this.apiUrl = apiUrl;
+    this.providerName = providerName;
+    this.registry = new TypeRegistry();
+    this.metadata = metadata;
+    this.provider = this.createProvider(apiUrl);
+    this.api = this.createApi(this.provider);
+    this.handleApiReady = 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 = 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', addressDefaults.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([formatBalance.getDefaults().unit, ...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;
+  }
+}

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

@@ -1,21 +1,23 @@
 import { _AssetType } from '@subwallet/chain-list/types';
-import { _SubstrateChainSpec } from '@subwallet/extension-base/services/chain-service/handler/types';
+import { ChainService } from '@subwallet/extension-base/services/chain-service';
+import { AbstractChainHandler } from '@subwallet/extension-base/services/chain-service/handler/AbstractChainHandler';
+import { SubstrateApi } from '@subwallet/extension-base/services/chain-service/handler/SubstrateApi';
+import { _ApiOptions, _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 {
+export declare class SubstrateChainHandler extends AbstractChainHandler {
     private substrateApiMap;
     private logger;
-    constructor();
-    getSubstrateApiMap(): Record<string, _SubstrateApi>;
-    getSubstrateApiByChain(chainSlug: string): _SubstrateApi;
-    resumeAllApis(): Promise<void[]>;
-    disconnectAllApis(): Promise<void[]>;
-    refreshApi(slug: string): void;
+    constructor(parent?: ChainService);
+    getSubstrateApiMap(): Record<string, SubstrateApi>;
+    getSubstrateApiByChain(chainSlug: string): SubstrateApi;
+    getApiByChain(chain: string): SubstrateApi;
+    wakeUp(): Promise<void>;
+    sleep(): Promise<void>;
+    recoverApi(chainSlug: string): Promise<void>;
     getChainSpec(substrateApi: _SubstrateApi): Promise<_SubstrateChainSpec>;
     getSmartContractTokenInfo(contractAddress: string, tokenType: _AssetType, originChain: string, contractCaller?: string): Promise<_SmartContractTokenInfo>;
-    setSubstrateApi(chainSlug: string, substrateApi: _SubstrateApi): void;
+    setSubstrateApi(chainSlug: string, substrateApi: SubstrateApi): void;
     destroySubstrateApi(chainSlug: string): void;
-    initApi(chainSlug: string, apiUrl: string, providerName?: string): _SubstrateApi;
-    private getChainMetadata;
-    private loadOnReady;
+    initApi(chainSlug: string, apiUrl: string, { onUpdateStatus, providerName }?: Omit<_ApiOptions, 'metadata'>): Promise<_SubstrateApi>;
 }

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

@@ -1,24 +1,19 @@
 // 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 { getDefaultWeightV2 } from '@subwallet/extension-base/koni/api/tokens/wasm/utils';
-import { getSubstrateConnectProvider } from '@subwallet/extension-base/services/chain-service/handler/light-client';
-import { ApiPromise, WsProvider } from '@polkadot/api';
+import { AbstractChainHandler, SHORT_RETRY_TIME } from '@subwallet/extension-base/services/chain-service/handler/AbstractChainHandler';
+import { SubstrateApi } from '@subwallet/extension-base/services/chain-service/handler/SubstrateApi';
 import { ContractPromise } from '@polkadot/api-contract';
-import { TypeRegistry } from '@polkadot/types/create';
-import { BN, formatBalance, isTestChain, objectSpread, stringify } from '@polkadot/util';
+import { BN } 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 {
+export class SubstrateChainHandler extends AbstractChainHandler {
   substrateApiMap = {};
-  constructor() {
+  constructor(parent) {
+    super(parent);
     this.logger = createLogger('substrate-chain-handler');
   }
   getSubstrateApiMap() {
@@ -27,29 +22,45 @@ export 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);
+          }, 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,
@@ -71,7 +82,7 @@ export 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;
   }
@@ -158,181 +169,46 @@ export 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 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
-    };
+  async initApi(chainSlug, apiUrl, {
+    onUpdateStatus,
+    providerName
+  } = {}) {
+    var _this$parent2;
+    const existed = this.substrateApiMap[chainSlug];
 
-    // @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);
+    // 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 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 > 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 => {
-        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', 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(`Connected to ${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
-    }));
+    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;
   }
 }

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

@@ -1,3 +1,4 @@
+import { MetadataItem } from '@subwallet/extension-base/background/KoniTypes';
 export interface _EvmChainSpec {
     evmChainId: number;
     name: string;
@@ -14,6 +15,11 @@ export interface _SubstrateChainSpec {
     existentialDeposit: string;
     paraId: number | null;
 }
+export interface _ApiOptions {
+    providerName?: string;
+    metadata?: MetadataItem;
+    onUpdateStatus?: (isConnected: boolean) => void;
+}
 export declare enum _CHAIN_VALIDATION_ERROR {
     INVALID_INFO_TYPE = "invalidInfoType",
     INJECT_SCRIPT_DETECTED = "injectScriptDetected",