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

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

@@ -0,0 +1,131 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.EvmApi = void 0;
+require("@polkadot/types-augment");
+var _promise = require("@subwallet/extension-base/utils/promise");
+var _rxjs = require("rxjs");
+var _web = _interopRequireDefault(require("web3"));
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+class EvmApi {
+  apiRetry = 0;
+  isApiConnectedSubject = new _rxjs.BehaviorSubject(false);
+  isApiReady = false;
+  isApiReadyOnce = false;
+  get isApiConnected() {
+    return this.isApiConnectedSubject.getValue();
+  }
+  updateConnectedStatus(isConnected) {
+    if (isConnected !== this.isApiConnectedSubject.value) {
+      this.isApiConnectedSubject.next(isConnected);
+    }
+  }
+  get isReady() {
+    return this.isReadyHandler.promise;
+  }
+  async updateApiUrl(apiUrl) {
+    this.apiUrl = apiUrl;
+    await this.disconnect();
+    this.api.setProvider(this.createProvider(apiUrl));
+    this.connect();
+  }
+  async recoverConnect() {
+    const wsProvider = this.provider;
+    if (wsProvider.reconnect) {
+      wsProvider.reconnect();
+    }
+    await this.isReadyHandler.promise;
+  }
+  createProvider(apiUrl) {
+    if (apiUrl.startsWith('http')) {
+      return new _web.default.providers.HttpProvider(apiUrl);
+    } else {
+      return new _web.default.providers.WebsocketProvider(apiUrl);
+    }
+  }
+  constructor(chainSlug, apiUrl) {
+    let {
+      providerName
+    } = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+    this.chainSlug = chainSlug;
+    this.apiUrl = apiUrl;
+    this.providerName = providerName || 'unknown';
+    this.provider = this.createProvider(apiUrl);
+    this.api = new _web.default(this.provider);
+    this.isReadyHandler = (0, _promise.createPromiseHandler)();
+
+    // Create it only to avoid undefined error, it will be overwrite in connect()
+    this.intervalCheckApi = this.createIntervalCheckApi();
+    this.connect();
+  }
+  createIntervalCheckApi() {
+    this.clearIntervalCheckApi();
+    return setInterval(() => {
+      this.api.eth.net.isListening().then(() => {
+        this.onConnect();
+      }).catch(() => {
+        this.onDisconnect();
+      });
+    }, 10000);
+  }
+  clearIntervalCheckApi() {
+    clearInterval(this.intervalCheckApi);
+  }
+  connect() {
+    // For websocket provider, connect it
+    const wsProvider = this.provider;
+    wsProvider.connect && wsProvider.connect();
+    // Check if api is ready
+    this.api.eth.net.isListening().then(() => {
+      this.isApiReadyOnce = true;
+      this.onConnect();
+    }).catch(error => {
+      this.isApiReadyOnce = false;
+      this.isApiReady = false;
+      this.isReadyHandler.reject(error);
+      this.updateConnectedStatus(false);
+      console.warn(`Can not connect to ${this.chainSlug} (EVM) at ${this.apiUrl}`);
+    });
+
+    // Interval to check connecting status
+    this.intervalCheckApi = this.createIntervalCheckApi();
+  }
+  async disconnect() {
+    this.clearIntervalCheckApi();
+    this.onDisconnect();
+
+    // For websocket provider, disconnect it
+    const wsProvider = this.provider;
+    wsProvider.disconnect && wsProvider.disconnect();
+    this.updateConnectedStatus(false);
+    return Promise.resolve();
+  }
+  destroy() {
+    // Todo: implement this in the future
+    return this.disconnect();
+  }
+  onConnect() {
+    if (!this.isApiConnected) {
+      console.log(`Connected to ${this.chainSlug} at ${this.apiUrl}`);
+      this.isApiReady = true;
+      if (this.isApiReadyOnce) {
+        this.isReadyHandler.resolve(this);
+      }
+    }
+    this.updateConnectedStatus(true);
+  }
+  onDisconnect() {
+    this.updateConnectedStatus(false);
+    if (this.isApiConnected) {
+      console.warn(`Disconnected from ${this.chainSlug} of ${this.apiUrl} (EVM)`);
+      this.isApiReady = false;
+      this.isReadyHandler = (0, _promise.createPromiseHandler)();
+    }
+  }
+}
+exports.EvmApi = EvmApi;

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;