@subwallet/extension-base 1.0.4-0 → 1.0.5-1

package/services/chain-service/index.js

@@ -358,7 +358,6 @@ export class ChainService {
     this.assetRegistrySubject.next(this.getAssetRegistry());
     this.initApis();
     await this.initAssetSettings();
-    this.logger.log('Initiated chains, assets and APIs');
   }
   initApis() {
     // TODO: this might be async
@@ -471,31 +470,43 @@ export class ChainService {
     return duplicatedSlug;
   }
   async fetchLatestData(src, defaultValue) {
-    try {
-      const timeout = await new Promise(resolve => {
-        const id = setTimeout(() => {
-          clearTimeout(id);
-          resolve(null);
-        }, 1000);
-      });
-      let result = defaultValue;
-      const resp = (await Promise.race([timeout, fetch(src)])) || null;
-      if (!resp) {
-        return result;
-      }
-      if (resp.ok) {
-        try {
-          result = await resp.json();
-        } catch (err) {
-          console.warn('Error parsing latest data', src, err);
-        }
-      }
-      return result;
-    } catch (e) {
-      console.warn('Error fetching latest data', src, e);
-      return defaultValue;
-    }
+    return Promise.resolve(defaultValue);
+    // try {
+    //   const timeout = new Promise((resolve) => {
+    //     const id = setTimeout(() => {
+    //       clearTimeout(id);
+    //       resolve(null);
+    //     }, 1500);
+    //   });
+    //   let result = defaultValue;
+    //   const resp = await Promise.race([
+    //     timeout,
+    //     fetch(src)
+    //   ]) as Response || null;
+    //
+    //   if (!resp) {
+    //     console.warn('Error fetching latest data', src);
+    //
+    //     return result;
+    //   }
+    //
+    //   if (resp.ok) {
+    //     try {
+    //       result = await resp.json();
+    //       console.log('Fetched latest data', src);
+    //     } catch (err) {
+    //       console.warn('Error parsing latest data', src, err);
+    //     }
+    //   }
+    //
+    //   return result;
+    // } catch (e) {
+    //   console.warn('Error fetching latest data', src, e);
+    //
+    //   return defaultValue;
+    // }
   }
+
   async initChains() {
     const storedChainSettings = await this.dbService.getAllChainStore();
     const latestChainInfoMap = await this.fetchLatestData(_CHAIN_INFO_SRC, ChainInfoMap);
@@ -1128,7 +1139,6 @@ export class ChainService {
     });
     await Promise.all(promiseList);
     if (update) {
-      console.log('Update chain connection state');
       this.chainStateMapSubject.next(chainStateMap);
     }
   }
@@ -1181,13 +1191,12 @@ export class ChainService {
     }
     return this.assetSettingSubject.value;
   }
-  async updateAssetSetting(assetSlug, assetSetting) {
+  async updateAssetSetting(assetSlug, assetSetting, autoEnableNativeToken) {
     const currentAssetSettings = await this.getAssetSettings();
     let needUpdateSubject;
 
     // Update settings
     currentAssetSettings[assetSlug] = assetSetting;
-    this.setAssetSettings(currentAssetSettings);
     if (assetSetting.visible) {
       const assetInfo = this.getAssetBySlug(assetSlug);
       const chainState = this.getChainStateByKey(assetInfo.originChain);
@@ -1196,8 +1205,15 @@ export class ChainService {
       if (chainState && !chainState.active) {
         this.enableChain(chainState.slug);
         needUpdateSubject = true;
+        if (autoEnableNativeToken) {
+          const nativeAsset = this.getNativeTokenInfo(assetInfo.originChain);
+          currentAssetSettings[nativeAsset.slug] = {
+            visible: true
+          };
+        }
       }
     }
+    this.setAssetSettings(currentAssetSettings);
     return needUpdateSubject;
   }
   async updateAssetSettingByChain(chainSlug, visible) {
@@ -1220,4 +1236,35 @@ export class ChainService {
   async getAssetLogoMap() {
     return await this.fetchLatestData(_ASSET_LOGO_MAP_SRC, AssetLogoMap);
   }
+  resetWallet(resetAll) {
+    if (resetAll) {
+      this.setAssetSettings({});
+
+      // Disconnect chain
+      const activeChains = this.getActiveChainInfos();
+      for (const chain of Object.keys(activeChains)) {
+        if (!_DEFAULT_ACTIVE_CHAINS.includes(chain)) {
+          this.disableChain(chain);
+        }
+      }
+
+      // Remove custom chain
+      const allChains = this.getChainInfoMap();
+      for (const chain of Object.keys(allChains)) {
+        if (_isCustomChain(chain)) {
+          this.removeCustomChain(chain);
+        }
+      }
+
+      // Remove custom asset
+      const assetSettings = this.getAssetSettings();
+      const customToken = [];
+      for (const asset of Object.keys(assetSettings)) {
+        if (_isCustomAsset(asset)) {
+          customToken.push(asset);
+        }
+      }
+      this.deleteCustomAssets(customToken);
+    }
+  }
 }

package/services/chain-service/utils.js

@@ -285,6 +285,9 @@ export function _getAssetDecimals(assetInfo) {
 }
 export function _getBlockExplorerFromChain(chainInfo) {
   let blockExplorer;
+  if (!chainInfo) {
+    return;
+  }
   if (_isPureEvmChain(chainInfo)) {
     var _chainInfo$evmInfo4;
     blockExplorer = chainInfo === null || chainInfo === void 0 ? void 0 : (_chainInfo$evmInfo4 = chainInfo.evmInfo) === null || _chainInfo$evmInfo4 === void 0 ? void 0 : _chainInfo$evmInfo4.blockExplorer;

package/services/history-service/helpers/recoverHistoryStatus.d.ts

@@ -0,0 +1,11 @@
+import { TransactionHistoryItem } from '@subwallet/extension-base/background/KoniTypes';
+import { ChainService } from '@subwallet/extension-base/services/chain-service';
+export declare enum HistoryRecoverStatus {
+    SUCCESS = "SUCCESS",
+    FAILED = "FAILED",
+    API_INACTIVE = "API_INACTIVE",
+    LACK_INFO = "LACK_INFO",
+    FAIL_DETECT = "FAIL_DETECT",
+    UNKNOWN = "UNKNOWN"
+}
+export declare const historyRecover: (history: TransactionHistoryItem, chainService: ChainService) => Promise<HistoryRecoverStatus>;

package/services/history-service/helpers/recoverHistoryStatus.js

@@ -0,0 +1,98 @@
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+export let HistoryRecoverStatus;
+(function (HistoryRecoverStatus) {
+  HistoryRecoverStatus["SUCCESS"] = "SUCCESS";
+  HistoryRecoverStatus["FAILED"] = "FAILED";
+  HistoryRecoverStatus["API_INACTIVE"] = "API_INACTIVE";
+  HistoryRecoverStatus["LACK_INFO"] = "LACK_INFO";
+  HistoryRecoverStatus["FAIL_DETECT"] = "FAIL_DETECT";
+  HistoryRecoverStatus["UNKNOWN"] = "UNKNOWN";
+})(HistoryRecoverStatus || (HistoryRecoverStatus = {}));
+const substrateRecover = async (history, chainService) => {
+  const {
+    blockHash,
+    chain,
+    extrinsicHash
+  } = history;
+  try {
+    const substrateApi = chainService.getSubstrateApi(chain);
+    if (substrateApi) {
+      const _api = await substrateApi.isReady;
+      const api = _api.api;
+      if (!blockHash) {
+        console.log(`Fail to find extrinsic ${extrinsicHash} on ${chain}: No block hash`);
+        return HistoryRecoverStatus.LACK_INFO;
+      }
+      const block = await api.rpc.chain.getBlock(blockHash);
+      const allEvents = await api.query.system.events.at(blockHash);
+      const extrinsics = block.block.extrinsics;
+      let index;
+      extrinsics.forEach((extrinsic, _idx) => {
+        if (extrinsicHash === extrinsic.hash.toHex()) {
+          index = _idx;
+        }
+      });
+      if (index === undefined) {
+        console.log(`Fail to find extrinsic ${extrinsicHash} on ${chain}`);
+        return HistoryRecoverStatus.FAIL_DETECT;
+      }
+      const events = allEvents.filter(({
+        phase
+      }) => phase.isApplyExtrinsic && phase.asApplyExtrinsic.eq(index));
+      for (const {
+        event
+      } of events) {
+        if (api.events.system.ExtrinsicSuccess.is(event)) {
+          return HistoryRecoverStatus.SUCCESS;
+        } else if (api.events.system.ExtrinsicFailed.is(event)) {
+          return HistoryRecoverStatus.FAILED;
+        }
+      }
+      return HistoryRecoverStatus.FAIL_DETECT;
+    } else {
+      console.error(`Fail to update history ${chain}-${extrinsicHash}: Api not active`);
+      return HistoryRecoverStatus.API_INACTIVE;
+    }
+  } catch (e) {
+    console.error(`Fail to update history ${chain}-${extrinsicHash}:`, e.message);
+    return HistoryRecoverStatus.UNKNOWN;
+  }
+};
+const evmRecover = async (history, chainService) => {
+  const {
+    chain,
+    extrinsicHash
+  } = history;
+  try {
+    const evmApi = chainService.getEvmApi(chain);
+    if (evmApi) {
+      const _api = await evmApi.isReady;
+      const api = _api.api;
+      const block = await api.eth.getTransactionReceipt(extrinsicHash);
+      return block.status ? HistoryRecoverStatus.SUCCESS : HistoryRecoverStatus.FAILED;
+    } else {
+      console.error(`Fail to update history ${chain}-${extrinsicHash}: Api not active`);
+      return HistoryRecoverStatus.API_INACTIVE;
+    }
+  } catch (e) {
+    console.error(`Fail to update history ${chain}-${extrinsicHash}:`, e.message);
+    return HistoryRecoverStatus.UNKNOWN;
+  }
+};
+
+// undefined: Cannot check status
+// true: Transaction success
+// false: Transaction failed
+export const historyRecover = async (history, chainService) => {
+  const {
+    chainType
+  } = history;
+  if (chainType) {
+    const checkFunction = chainType === 'substrate' ? substrateRecover : evmRecover;
+    return await checkFunction(history, chainService);
+  } else {
+    return HistoryRecoverStatus.LACK_INFO;
+  }
+};

package/services/history-service/index.d.ts

@@ -6,6 +6,7 @@ import { KeyringService } from '@subwallet/extension-base/services/keyring-servi
 import DatabaseService from '@subwallet/extension-base/services/storage-service/DatabaseService';
 import { BehaviorSubject } from 'rxjs';
 export declare class HistoryService implements StoppableServiceInterface, PersistDataServiceInterface, CronServiceInterface {
+    #private;
     private dbService;
     private chainService;
     private eventService;
@@ -14,6 +15,7 @@ export declare class HistoryService implements StoppableServiceInterface, Persis
     constructor(dbService: DatabaseService, chainService: ChainService, eventService: EventService, keyringService: KeyringService);
     private fetchPromise;
     private interval;
+    private recoverInterval;
     private fetchAndLoadHistories;
     getHistories(): Promise<TransactionHistoryItem<import("@subwallet/extension-base/background/KoniTypes").ExtrinsicType.TRANSFER_BALANCE>[]>;
     getHistorySubject(): Promise<BehaviorSubject<TransactionHistoryItem<import("@subwallet/extension-base/background/KoniTypes").ExtrinsicType.TRANSFER_BALANCE>[]>>;
@@ -27,12 +29,16 @@ export declare class HistoryService implements StoppableServiceInterface, Persis
     persistData(): Promise<void>;
     startCron(): Promise<void>;
     stopCron(): Promise<void>;
+    startRecoverHistories(): Promise<void>;
+    stopRecoverHistories(): Promise<void>;
+    recoverHistories(): Promise<void>;
     startPromiseHandler: {
         resolve: (value: void) => void;
         reject: (reason?: unknown) => void;
         promise: Promise<void>;
     };
     init(): Promise<void>;
+    getProcessingHistory(): Promise<void>;
     start(): Promise<void>;
     waitForStarted(): Promise<void>;
     stopPromiseHandler: {

package/services/history-service/index.js

@@ -1,14 +1,17 @@
 // Copyright 2019-2022 @subwallet/extension-base
 // SPDX-License-Identifier: Apache-2.0
 
-import { CRON_REFRESH_HISTORY_INTERVAL } from '@subwallet/extension-base/constants';
+import { ExtrinsicStatus } from '@subwallet/extension-base/background/KoniTypes';
+import { CRON_RECOVER_HISTORY_INTERVAL, CRON_REFRESH_HISTORY_INTERVAL } from '@subwallet/extension-base/constants';
 import { ServiceStatus } from '@subwallet/extension-base/services/base/types';
+import { historyRecover, HistoryRecoverStatus } from '@subwallet/extension-base/services/history-service/helpers/recoverHistoryStatus';
 import { createPromiseHandler } from '@subwallet/extension-base/utils/promise';
 import { keyring } from '@subwallet/ui-keyring';
 import { BehaviorSubject } from 'rxjs';
 import { fetchMultiChainHistories } from "./subsquid-multi-chain-history.js";
 export class HistoryService {
   historySubject = new BehaviorSubject([]);
+  #processingHistories = {};
   constructor(dbService, chainService, eventService, keyringService) {
     this.dbService = dbService;
     this.chainService = chainService;
@@ -18,6 +21,7 @@ export class HistoryService {
   }
   fetchPromise = null;
   interval = undefined;
+  recoverInterval = undefined;
   async fetchAndLoadHistories(addresses) {
     if (!addresses || addresses.length === 0) {
       return [];
@@ -88,9 +92,6 @@ export class HistoryService {
     });
     const updateRecords = historyItems.filter(item => {
       const key = `${item.chain}-${item.extrinsicHash}`;
-
-      // !excludeKeys.includes(key) && console.log('Cancel update', key);
-
       return item.origin === 'app' || !excludeKeys.includes(key);
     });
     await this.dbService.upsertHistory(updateRecords);
@@ -119,12 +120,56 @@ export class HistoryService {
     this.fetchPromise = null;
     return Promise.resolve();
   }
+  async startRecoverHistories() {
+    await this.recoverHistories();
+    this.recoverInterval = setInterval(() => {
+      this.recoverHistories().catch(console.error);
+    }, CRON_RECOVER_HISTORY_INTERVAL);
+  }
+  stopRecoverHistories() {
+    clearInterval(this.recoverInterval);
+    return Promise.resolve();
+  }
+  async recoverHistories() {
+    const list = [];
+    for (const processingHistory of Object.values(this.#processingHistories)) {
+      const chainState = this.chainService.getChainStateByKey(processingHistory.chain);
+      if (chainState.active) {
+        list.push(processingHistory);
+      }
+      if (list.length >= 10) {
+        break;
+      }
+    }
+    const promises = list.map(history => historyRecover(history, this.chainService));
+    const result = await Promise.all(promises);
+    result.forEach((status, index) => {
+      const extrinsicHash = list[index].extrinsicHash;
+      switch (status) {
+        case HistoryRecoverStatus.API_INACTIVE:
+          break;
+        case HistoryRecoverStatus.FAILED:
+        case HistoryRecoverStatus.SUCCESS:
+          this.updateHistoryByExtrinsicHash(extrinsicHash, {
+            status: status === HistoryRecoverStatus.SUCCESS ? ExtrinsicStatus.SUCCESS : ExtrinsicStatus.FAIL
+          }).catch(console.error);
+          delete this.#processingHistories[extrinsicHash];
+          break;
+        default:
+          delete this.#processingHistories[extrinsicHash];
+      }
+    });
+    if (!Object.keys(this.#processingHistories).length) {
+      await this.stopRecoverHistories();
+    }
+  }
   startPromiseHandler = createPromiseHandler();
   async init() {
     this.status = ServiceStatus.INITIALIZING;
     await this.loadData();
     Promise.all([this.eventService.waitKeyringReady, this.eventService.waitChainReady]).then(() => {
       this.getHistories().catch(console.log);
+      this.getProcessingHistory().catch(console.log);
       this.eventService.on('account.add', () => {
         (async () => {
           await this.stopCron();
@@ -137,12 +182,22 @@ export class HistoryService {
     }).catch(console.error);
     this.status = ServiceStatus.INITIALIZED;
   }
+  async getProcessingHistory() {
+    const histories = await this.dbService.getHistories();
+    this.#processingHistories = {};
+    histories.filter(history => {
+      return history.status === 'processing';
+    }).forEach(history => {
+      this.#processingHistories[history.extrinsicHash] = history;
+    });
+    this.startRecoverHistories().catch(console.error);
+  }
   async start() {
     try {
-      console.debug('Start history service');
       this.startPromiseHandler = createPromiseHandler();
       this.status = ServiceStatus.STARTING;
       await this.startCron();
+      await this.startRecoverHistories();
       this.status = ServiceStatus.STARTED;
       this.startPromiseHandler.resolve();
     } catch (e) {
@@ -154,12 +209,12 @@ export class HistoryService {
   }
   stopPromiseHandler = createPromiseHandler();
   async stop() {
-    console.debug('Stop history service');
     try {
       this.stopPromiseHandler = createPromiseHandler();
       this.status = ServiceStatus.STOPPING;
       await this.persistData();
       await this.stopCron();
+      await this.stopRecoverHistories();
       this.stopPromiseHandler.resolve();
       this.status = ServiceStatus.STOPPED;
     } catch (e) {

package/services/history-service/subsquid-multi-chain-history.js

@@ -110,7 +110,7 @@ export function parseSubsquidTransactionData(address, type, historyItem, chainIn
         const parsedArgs = args;
         const transaction = data.call.data.args.transaction.value;
         to = autoFormatAddress(parsedArgs.to);
-        from = autoFormatAddress(parsedArgs.from);
+        from = autoFormatAddress(parsedArgs.from || address);
         extrinsicHash = parsedArgs.transactionHash || extrinsic.hash;
         amount = transaction.value || '0';
         fee = (parseInt(transaction.gasPrice) * parseInt(transaction.gasLimit)).toString();
@@ -244,7 +244,8 @@ export async function fetchMultiChainHistories(addresses, chainMap, maxPage = 25
     const usedAddresses = relatedAddresses.filter(a => lowerAddresses.includes(a.toLowerCase()));
     const chainInfo = chainMap[chainId];
     if (chainInfo === undefined) {
-      console.warn(`Not found chain info for chain id: ${chainId}`);
+      console.warn(`Not found chain info for chain id: ${chainId}`); // TODO: resolve conflicting chainId
+
       return;
     }
     usedAddresses.forEach(address => {

package/services/history-service/testChainMap.d.ts

@@ -0,0 +1,3 @@
+import { _ChainInfo } from '@subwallet/chain-list/types';
+export declare const TEST_CHAIN_LIST: _ChainInfo[];
+export declare const TEST_CHAIN_MAP: Record<string, _ChainInfo>;