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

package/packageInfo.js

@@ -7,5 +7,5 @@ export const packageInfo = {
   name: '@subwallet/extension-base',
   path: (import.meta && import.meta.url) ? new URL(import.meta.url).pathname.substring(0, new URL(import.meta.url).pathname.lastIndexOf('/') + 1) : 'auto',
   type: 'esm',
-  version: '1.0.10-0'
+  version: '1.0.11-0'
 };

package/services/chain-service/constants.d.ts

@@ -1,5 +1,6 @@
 import { SingleModeJson } from '@subwallet/extension-base/background/KoniTypes';
 export declare const API_AUTO_CONNECT_MS = 3000;
+export declare const API_CONNECT_TIMEOUT = 30000;
 export declare const API_MAX_RETRY = 2;
 export declare const _API_OPTIONS_CHAIN_GROUP: {
     acala: string[];

package/services/chain-service/constants.js

@@ -5,6 +5,7 @@ import { _DEFAULT_CHAINS } from '@subwallet/chain-list';
 import { _SubstrateChainType } from '@subwallet/chain-list/types';
 import { ThemeNames } from '@subwallet/extension-base/background/KoniTypes';
 export const API_AUTO_CONNECT_MS = 3000;
+export const API_CONNECT_TIMEOUT = 30000;
 export const API_MAX_RETRY = 2;
 export const _API_OPTIONS_CHAIN_GROUP = {
   acala: ['acala', 'karura', 'origintrail', 'kintsugi'],

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

@@ -0,0 +1,29 @@
+/// <reference types="node" />
+import { ChainService } from '@subwallet/extension-base/services/chain-service';
+import { _ApiOptions } from '@subwallet/extension-base/services/chain-service/handler/types';
+import { _ChainBaseApi } from '@subwallet/extension-base/services/chain-service/types';
+import { BehaviorSubject } from 'rxjs';
+export declare const FIRST_RECONNECT_TIME = 3000;
+export declare const SHORT_RETRY_TIME = 15000;
+export declare const LONG_RETRY_TIME = 60000;
+interface RetryObject {
+    retryTimes: number;
+    timeout?: NodeJS.Timer;
+}
+export declare abstract class AbstractChainHandler {
+    protected parent?: ChainService | undefined;
+    readonly apiStateMapSubject: BehaviorSubject<Record<string, boolean>>;
+    protected recoverMap: Record<string, RetryObject>;
+    protected isSleeping: boolean;
+    protected constructor(parent?: ChainService | undefined);
+    abstract getApiByChain(chain: string): _ChainBaseApi | undefined;
+    abstract initApi(chainSlug: string, apiUrl: string, options: Omit<_ApiOptions, 'metadata'>): Promise<_ChainBaseApi>;
+    abstract recoverApi(chainSlug: string): void;
+    abstract sleep(): Promise<void>;
+    abstract wakeUp(): Promise<void>;
+    handleConnect(chain: string, isConnected: boolean): void;
+    protected handleRecover(chain: string): void;
+    protected cancelRecover(chain: string): void;
+    cancelAllRecover(): void;
+}
+export {};

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

@@ -0,0 +1,83 @@
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { BehaviorSubject } from 'rxjs';
+const SHORT_RECOVER_RETRY = 3;
+export const FIRST_RECONNECT_TIME = 3000;
+export const SHORT_RETRY_TIME = 15000;
+export const LONG_RETRY_TIME = 60000;
+export class AbstractChainHandler {
+  apiStateMapSubject = new BehaviorSubject({});
+  // Recover retry times
+
+  isSleeping = false;
+  constructor(parent) {
+    this.parent = parent;
+    this.recoverMap = {};
+  }
+  handleConnect(chain, isConnected) {
+    const currentMap = this.apiStateMapSubject.getValue();
+    const currentStatus = currentMap[chain];
+
+    // Update api state
+    if (currentStatus !== isConnected) {
+      this.apiStateMapSubject.next({
+        ...currentMap,
+        [chain]: isConnected
+      });
+    }
+
+    // Handle connection change
+    if (!isConnected) {
+      this.handleRecover(chain);
+    }
+  }
+
+  // Recover api if it is disconnected
+  handleRecover(chain) {
+    var _this$parent, _this$parent$getChain;
+    // Not recover inactive chain
+    if (!((_this$parent = this.parent) !== null && _this$parent !== void 0 && (_this$parent$getChain = _this$parent.getChainStateByKey(chain)) !== null && _this$parent$getChain !== void 0 && _this$parent$getChain.active)) {
+      this.cancelRecover(chain);
+      return;
+    }
+
+    // Get retry record
+    const retryRecord = this.recoverMap[chain] || {
+      retryTimes: 0
+    };
+    clearTimeout(retryRecord.timeout);
+    const retryTimes = retryRecord.retryTimes;
+    // Slow down recover frequency if increasing recover times
+    const retryTimeout = retryTimes === 0 ? FIRST_RECONNECT_TIME : retryTimes >= SHORT_RECOVER_RETRY ? LONG_RETRY_TIME : SHORT_RETRY_TIME;
+
+    // Recover api after retry timeout
+    const timeout = setTimeout(() => {
+      var _this$getApiByChain;
+      if ((_this$getApiByChain = this.getApiByChain(chain)) !== null && _this$getApiByChain !== void 0 && _this$getApiByChain.isApiConnected || this.isSleeping) {
+        // Cancel recover if api is connected
+        this.cancelRecover(chain);
+      } else {
+        this.recoverApi(chain);
+        this.handleRecover(chain); // This will be cancel if api is connected
+      }
+    }, retryTimeout);
+    this.recoverMap[chain] = {
+      ...retryRecord,
+      retryTimes: retryTimes + 1,
+      timeout
+    };
+  }
+  cancelRecover(chain) {
+    const retryRecord = this.recoverMap[chain];
+    if (retryRecord) {
+      clearTimeout(retryRecord.timeout);
+      delete this.recoverMap[chain];
+    }
+  }
+  cancelAllRecover() {
+    Object.keys(this.recoverMap).forEach(chain => {
+      this.cancelRecover(chain);
+    });
+  }
+}

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

@@ -0,0 +1,36 @@
+/// <reference types="node" />
+import '@polkadot/types-augment';
+import { _ApiOptions } from '@subwallet/extension-base/services/chain-service/handler/types';
+import { _EvmApi } from '@subwallet/extension-base/services/chain-service/types';
+import { PromiseHandler } from '@subwallet/extension-base/utils/promise';
+import { BehaviorSubject } from 'rxjs';
+import Web3 from 'web3';
+import { HttpProvider, WebsocketProvider } from 'web3-core';
+export declare class EvmApi implements _EvmApi {
+    chainSlug: string;
+    api: Web3;
+    apiUrl: string;
+    provider: HttpProvider | WebsocketProvider;
+    apiError?: string;
+    apiRetry: number;
+    readonly isApiConnectedSubject: BehaviorSubject<boolean>;
+    isApiReady: boolean;
+    isApiReadyOnce: boolean;
+    isReadyHandler: PromiseHandler<_EvmApi>;
+    intervalCheckApi: NodeJS.Timer;
+    providerName: string;
+    get isApiConnected(): boolean;
+    private updateConnectedStatus;
+    get isReady(): Promise<_EvmApi>;
+    updateApiUrl(apiUrl: string): Promise<void>;
+    recoverConnect(): Promise<void>;
+    private createProvider;
+    constructor(chainSlug: string, apiUrl: string, { providerName }?: _ApiOptions);
+    createIntervalCheckApi(): NodeJS.Timer;
+    clearIntervalCheckApi(): void;
+    connect(): void;
+    disconnect(): Promise<void>;
+    destroy(): Promise<void>;
+    onConnect(): void;
+    onDisconnect(): void;
+}

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

@@ -0,0 +1,122 @@
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import '@polkadot/types-augment';
+import { createPromiseHandler } from '@subwallet/extension-base/utils/promise';
+import { BehaviorSubject } from 'rxjs';
+import Web3 from 'web3';
+export class EvmApi {
+  apiRetry = 0;
+  isApiConnectedSubject = new 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 Web3.providers.HttpProvider(apiUrl);
+    } else {
+      return new Web3.providers.WebsocketProvider(apiUrl);
+    }
+  }
+  constructor(chainSlug, apiUrl, {
+    providerName
+  } = {}) {
+    this.chainSlug = chainSlug;
+    this.apiUrl = apiUrl;
+    this.providerName = providerName || 'unknown';
+    this.provider = this.createProvider(apiUrl);
+    this.api = new Web3(this.provider);
+    this.isReadyHandler = 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 = createPromiseHandler();
+    }
+  }
+}

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

@@ -1,16 +1,22 @@
 import { _AssetType } from '@subwallet/chain-list/types';
-import { _EvmChainSpec } 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 { EvmApi } from '@subwallet/extension-base/services/chain-service/handler/EvmApi';
+import { _ApiOptions, _EvmChainSpec } from '@subwallet/extension-base/services/chain-service/handler/types';
 import { _EvmApi, _SmartContractTokenInfo } from '@subwallet/extension-base/services/chain-service/types';
-export declare class EvmChainHandler {
+export declare class EvmChainHandler extends AbstractChainHandler {
     private evmApiMap;
     private logger;
-    constructor();
-    getEvmApiMap(): Record<string, _EvmApi>;
-    getEvmApiByChain(chainSlug: string): _EvmApi;
-    setEvmApi(chainSlug: string, evmApi: _EvmApi): void;
-    destroyEvmApi(chainSlug: string): void;
-    refreshApi(slug: string, endpoint: string, providerName?: string): void;
-    initApi(chainSlug: string, apiUrl: string, providerName?: string): _EvmApi;
+    constructor(parent?: ChainService);
+    getEvmApiMap(): Record<string, EvmApi>;
+    getEvmApiByChain(chainSlug: string): EvmApi;
+    getApiByChain(chain: string): EvmApi;
+    setEvmApi(chainSlug: string, evmApi: EvmApi): void;
+    initApi(chainSlug: string, apiUrl: string, { onUpdateStatus, providerName }?: Omit<_ApiOptions, 'metadata'>): Promise<EvmApi>;
+    recoverApi(chainSlug: string): Promise<void>;
+    destroyEvmApi(chain: string): void;
+    sleep(): Promise<void>;
+    wakeUp(): Promise<void>;
     getChainSpec(evmApi: _EvmApi): Promise<_EvmChainSpec>;
     getSmartContractTokenInfo(contractAddress: string, tokenType: _AssetType, originChain: string): Promise<_SmartContractTokenInfo>;
 }

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

@@ -2,12 +2,14 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import { _AssetType } from '@subwallet/chain-list/types';
+import { AbstractChainHandler } from '@subwallet/extension-base/services/chain-service/handler/AbstractChainHandler';
+import { EvmApi } from '@subwallet/extension-base/services/chain-service/handler/EvmApi';
 import { _ERC20_ABI, _ERC721_ABI } from '@subwallet/extension-base/services/chain-service/helper';
-import Web3 from 'web3';
 import { logger as createLogger } from '@polkadot/util/logger';
-export class EvmChainHandler {
+export class EvmChainHandler extends AbstractChainHandler {
   evmApiMap = {};
-  constructor() {
+  constructor(parent) {
+    super(parent);
     this.logger = createLogger('evm-chain-handler');
   }
   getEvmApiMap() {
@@ -16,47 +18,61 @@ export 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, {
+    onUpdateStatus,
+    providerName
+  } = {}) {
+    const existed = this.getEvmApiByChain(chainSlug);
+    if (existed) {
+      existed.connect();
+      if (apiUrl !== existed.apiUrl) {
+        existed.updateApiUrl(apiUrl).catch(console.error);
+      }
+      return existed;
+    }
+    const apiObject = new 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 Web3(new Web3.providers.HttpProvider(apiUrl));
-    } else {
-      api = new Web3(new Web3.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/services/chain-service/handler/SubstrateApi.d.ts

@@ -0,0 +1,48 @@
+import '@polkadot/types-augment';
+import { MetadataItem } from '@subwallet/extension-base/background/KoniTypes';
+import { _ApiOptions } from '@subwallet/extension-base/services/chain-service/handler/types';
+import { _SubstrateApi, _SubstrateDefaultFormatBalance } from '@subwallet/extension-base/services/chain-service/types';
+import { BehaviorSubject } from 'rxjs';
+import { ApiPromise } from '@polkadot/api';
+import { SubmittableExtrinsicFunction } from '@polkadot/api/promise/types';
+import { ProviderInterface } from '@polkadot/rpc-provider/types';
+import { Registry } from '@polkadot/types/types';
+export declare class SubstrateApi implements _SubstrateApi {
+    chainSlug: string;
+    api: ApiPromise;
+    providerName?: string;
+    provider: ProviderInterface;
+    apiUrl: string;
+    metadata?: MetadataItem;
+    useLightClient: boolean;
+    isApiReady: boolean;
+    isApiReadyOnce: boolean;
+    apiError?: string;
+    private handleApiReady;
+    readonly isApiConnectedSubject: BehaviorSubject<boolean>;
+    get isApiConnected(): boolean;
+    private updateConnectedStatus;
+    apiDefaultTx?: SubmittableExtrinsicFunction;
+    apiDefaultTxSudo?: SubmittableExtrinsicFunction;
+    defaultFormatBalance?: _SubstrateDefaultFormatBalance;
+    registry: Registry;
+    specName: string;
+    specVersion: string;
+    systemChain: string;
+    systemName: string;
+    systemVersion: string;
+    private createProvider;
+    private createApi;
+    constructor(chainSlug: string, apiUrl: string, { metadata, providerName }?: _ApiOptions);
+    get isReady(): Promise<_SubstrateApi>;
+    updateApiUrl(apiUrl: string): Promise<void>;
+    connect(): void;
+    disconnect(): Promise<void>;
+    recoverConnect(): Promise<void>;
+    destroy(): Promise<void>;
+    onReady(): void;
+    onConnect(): void;
+    onDisconnect(): void;
+    onError(e: Error): void;
+    fillApiInfo(): Promise<void>;
+}