@subwallet/extension-base 1.1.22-0 → 1.1.24-0

package/koni/background/handlers/Mobile.js

@@ -1,6 +1,7 @@
 // Copyright 2019-2022 @subwallet/extension-koni authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
+import { createPromiseHandler } from '@subwallet/extension-base/utils/promise';
 const DEFAULT_SERVICE_MAP = {
   subscription: {
     chainRegistry: true,
@@ -20,6 +21,7 @@ const DEFAULT_SERVICE_MAP = {
 export default class Mobile {
   // @ts-ignore
 
+  restoreHandler = createPromiseHandler();
   constructor(state) {
     this.state = state;
   }
@@ -92,6 +94,31 @@ export default class Mobile {
   restartSubscriptionServices(services) {
     console.log('restartSubscriptionServices');
   }
+  async mobileBackup() {
+    const indexedDB = await this.state.dbService.exportDB();
+    return {
+      storage: JSON.stringify(localStorage),
+      indexedDB
+    };
+  }
+  async mobileRestore({
+    indexedDB,
+    storage
+  }) {
+    if (storage) {
+      const storageData = JSON.parse(storage);
+      for (const key in storageData) {
+        localStorage.setItem(key, JSON.stringify(storageData[key]));
+      }
+    }
+    if (indexedDB) {
+      await this.state.dbService.importDB(indexedDB);
+    }
+    this.restoreHandler.resolve();
+  }
+  waitRestore() {
+    return this.restoreHandler.promise;
+  }
 
   // eslint-disable-next-line @typescript-eslint/require-await
   async handle(id, type, request, port) {
@@ -120,6 +147,10 @@ export default class Mobile {
         return this.stopSubscriptionServices(request);
       case 'mobile(subscription.restart)':
         return this.restartSubscriptionServices(request);
+      case 'mobile(storage.restore)':
+        return this.mobileRestore(request);
+      case 'mobile(storage.backup)':
+        return this.mobileBackup();
       default:
         throw new Error(`Unable to handle message of type ${type}`);
     }

package/koni/background/handlers/State.d.ts

@@ -84,6 +84,7 @@ export default class KoniState {
     sign(url: string, request: RequestSign, account: AccountJson): Promise<ResponseSigning>;
     get authSubjectV2(): BehaviorSubject<import("@subwallet/extension-base/background/types").AuthorizeRequest[]>;
     generateDefaultBalanceMap(): Record<string, BalanceItem>;
+    private afterChainServiceInit;
     init(): Promise<void>;
     initMantaPay(password: string): Promise<void>;
     private startSubscription;

package/koni/background/handlers/State.js

@@ -23,11 +23,11 @@ import RequestService from '@subwallet/extension-base/services/request-service';
 import SettingService from '@subwallet/extension-base/services/setting-service/SettingService';
 import DatabaseService from '@subwallet/extension-base/services/storage-service/DatabaseService';
 import { SubscanService } from '@subwallet/extension-base/services/subscan-service';
-import { SUBSCAN_CHAIN_MAP_REVERSE } from '@subwallet/extension-base/services/subscan-service/subscan-chain-map';
+import { SUBSCAN_API_CHAIN_MAP, SUBSCAN_BALANCE_CHAIN_MAP_REVERSE } from '@subwallet/extension-base/services/subscan-service/subscan-chain-map';
 import TransactionService from '@subwallet/extension-base/services/transaction-service';
 import WalletConnectService from '@subwallet/extension-base/services/wallet-connect-service';
 import AccountRefStore from '@subwallet/extension-base/stores/AccountRef';
-import { stripUrl } from '@subwallet/extension-base/utils';
+import { stripUrl, TARGET_ENV } from '@subwallet/extension-base/utils';
 import { isContractAddress, parseContractInput } from '@subwallet/extension-base/utils/eth/parseTransaction';
 import { createPromiseHandler } from '@subwallet/extension-base/utils/promise';
 import { decodePair } from '@subwallet/keyring/pair/decode';
@@ -84,14 +84,14 @@ export default class KoniState {
     this.eventService = new EventService();
     this.dbService = new DatabaseService(this.eventService);
     this.keyringService = new KeyringService(this.eventService);
-    this.subscanService = new SubscanService();
     this.notificationService = new NotificationService();
     this.chainService = new ChainService(this.dbService, this.eventService);
+    this.subscanService = new SubscanService(SUBSCAN_API_CHAIN_MAP);
     this.settingService = new SettingService();
     this.requestService = new RequestService(this.chainService, this.settingService, this.keyringService);
     this.priceService = new PriceService(this.dbService, this.eventService, this.chainService);
     this.balanceService = new BalanceService(this.chainService);
-    this.historyService = new HistoryService(this.dbService, this.chainService, this.eventService, this.keyringService);
+    this.historyService = new HistoryService(this.dbService, this.chainService, this.eventService, this.keyringService, this.subscanService);
     this.transactionService = new TransactionService(this.chainService, this.eventService, this.requestService, this.balanceService, this.historyService, this.notificationService, this.dbService);
     this.walletConnectService = new WalletConnectService(this, this.requestService);
     this.migrationService = new MigrationService(this, this.eventService);
@@ -102,7 +102,9 @@ export default class KoniState {
     this.logger = createLogger('State');
 
     // Init state
-    this.init().catch(console.error);
+    if (TARGET_ENV !== 'mobile') {
+      this.init().catch(console.error);
+    }
   }
 
   // Clone from polkadot.js
@@ -198,9 +200,13 @@ export default class KoniState {
     });
     return balanceMap;
   }
+  afterChainServiceInit() {
+    this.subscanService.setSubscanChainMap(this.chainService.getSubscanChainMap());
+  }
   async init() {
     await this.eventService.waitCryptoReady;
     await this.chainService.init();
+    this.afterChainServiceInit();
     await this.migrationService.run();
     this.eventService.emit('chain.ready', true);
     this.onReady();
@@ -1469,7 +1475,7 @@ export default class KoniState {
         symbol
       }) => {
         var _currentAssetSettings;
-        const chain = SUBSCAN_CHAIN_MAP_REVERSE[network];
+        const chain = SUBSCAN_BALANCE_CHAIN_MAP_REVERSE[network];
         const chainInfo = chain ? chainMap[chain] : null;
         const balanceIsEmpty = (!balance || balance === '0') && (!locked || locked === '0') && (!bonded || bonded === '0');
 
@@ -1478,10 +1484,11 @@ export default class KoniState {
           return;
         }
         const tokenKey = `${chain}-${category === 'native' ? 'NATIVE' : 'LOCAL'}-${symbol.toUpperCase()}`;
-        if (assetMap[tokenKey] && !((_currentAssetSettings = currentAssetSettings[tokenKey]) !== null && _currentAssetSettings !== void 0 && _currentAssetSettings.visible)) {
+        const existedKey = Object.keys(assetMap).find(v => v.toLowerCase() === tokenKey.toLowerCase());
+        if (existedKey && !((_currentAssetSettings = currentAssetSettings[existedKey]) !== null && _currentAssetSettings !== void 0 && _currentAssetSettings.visible)) {
           needEnableChains.push(chain);
-          needActiveTokens.push(tokenKey);
-          currentAssetSettings[tokenKey] = {
+          needActiveTokens.push(existedKey);
+          currentAssetSettings[existedKey] = {
             visible: true
           };
         }
@@ -1553,6 +1560,7 @@ export default class KoniState {
     this.chainService.resetWallet(resetAll);
     await this.walletConnectService.resetWallet(resetAll);
     await this.chainService.init();
+    this.afterChainServiceInit();
   }
   async enableMantaPay(updateStore, address, password, seedPhrase) {
     var _this$chainService3, _this$chainService3$m, _this$chainService4, _this$chainService4$m, _this$chainService4$m2, _this$chainService11, _this$chainService11$, _this$chainService11$2;

package/koni/background/subscription.js

@@ -163,7 +163,7 @@ export class KoniSubscription {
   initCrowdloanSubscription(addresses, substrateApiMap, onlyRunOnFirstTime) {
     const subscriptionPromise = subscribeCrowdloan(addresses, substrateApiMap, (networkKey, rs) => {
       this.state.setCrowdloanItem(networkKey, rs);
-    }, this.state.getChainInfoMap());
+    });
     if (onlyRunOnFirstTime) {
       subscriptionPromise.then(unsub => {
         unsub && unsub();

package/package.json

@@ -17,7 +17,7 @@
     "./cjs/detectPackage.js"
   ],
   "type": "module",
-  "version": "1.1.22-0",
+  "version": "1.1.24-0",
   "main": "./cjs/index.js",
   "module": "./index.js",
   "types": "./index.d.ts",
@@ -673,6 +673,16 @@
       "require": "./cjs/services/history-service/helpers/recoverHistoryStatus.js",
       "default": "./services/history-service/helpers/recoverHistoryStatus.js"
     },
+    "./services/history-service/helpers/subscan-extrinsic-parser-helper": {
+      "types": "./services/history-service/helpers/subscan-extrinsic-parser-helper.d.ts",
+      "require": "./cjs/services/history-service/helpers/subscan-extrinsic-parser-helper.js",
+      "default": "./services/history-service/helpers/subscan-extrinsic-parser-helper.js"
+    },
+    "./services/history-service/subscan-history": {
+      "types": "./services/history-service/subscan-history.d.ts",
+      "require": "./cjs/services/history-service/subscan-history.js",
+      "default": "./services/history-service/subscan-history.js"
+    },
     "./services/history-service/subsquid-multi-chain-history": {
       "types": "./services/history-service/subsquid-multi-chain-history.d.ts",
       "require": "./cjs/services/history-service/subsquid-multi-chain-history.js",
@@ -1312,11 +1322,11 @@
     "@reduxjs/toolkit": "^1.9.1",
     "@sora-substrate/type-definitions": "^1.17.7",
     "@substrate/connect": "^0.7.26",
-    "@subwallet/chain-list": "0.2.25",
-    "@subwallet/extension-base": "^1.1.22-0",
-    "@subwallet/extension-chains": "^1.1.22-0",
-    "@subwallet/extension-dapp": "^1.1.22-0",
-    "@subwallet/extension-inject": "^1.1.22-0",
+    "@subwallet/chain-list": "0.2.26",
+    "@subwallet/extension-base": "^1.1.24-0",
+    "@subwallet/extension-chains": "^1.1.24-0",
+    "@subwallet/extension-dapp": "^1.1.24-0",
+    "@subwallet/extension-inject": "^1.1.24-0",
     "@subwallet/keyring": "^0.1.1",
     "@subwallet/ui-keyring": "^0.1.1",
     "@walletconnect/sign-client": "^2.8.4",
@@ -1331,6 +1341,7 @@
     "buffer": "^6.0.3",
     "cross-fetch": "^3.1.5",
     "dexie": "^3.2.2",
+    "dexie-export-import": "^4.0.7",
     "eth-simple-keyring": "^4.2.0",
     "ethereumjs-tx": "^2.1.2",
     "ethereumjs-util": "^7.1.5",

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.1.22-0'
+  version: '1.1.24-0'
 };

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

@@ -17,6 +17,7 @@ export declare const _BALANCE_CHAIN_GROUP: {
     bifrost: string[];
     statemine: string[];
     kusama: string[];
+    centrifuge: string[];
 };
 export declare const _BALANCE_TOKEN_GROUP: {
     crab: string[];
@@ -71,6 +72,7 @@ export declare const _TRANSFER_CHAIN_GROUP: {
     sora_substrate: string[];
     avail: string[];
     pendulum: string[];
+    centrifuge: string[];
 };
 export declare const _BALANCE_PARSING_CHAIN_GROUP: {
     bobabeam: string[];

package/services/chain-service/constants.js

@@ -30,9 +30,10 @@ export const _BALANCE_CHAIN_GROUP = {
   equilibrium_parachain: ['equilibrium_parachain'],
   bifrost: ['bifrost', 'acala', 'karura', 'acala_testnet', 'pioneer', 'bitcountry', 'bifrost_dot', 'hydradx_main', 'pendulum', 'amplitude'],
   statemine: ['statemine', 'astar', 'shiden', 'statemint', 'moonbeam', 'moonbase', 'moonriver', 'crabParachain', 'darwinia2', 'parallel', 'calamari'],
-  kusama: ['kusama', 'kintsugi', 'kintsugi_test', 'interlay', 'acala', 'statemint', 'karura', 'bifrost'] // perhaps there are some runtime updates
+  kusama: ['kusama', 'kintsugi', 'kintsugi_test', 'interlay', 'acala', 'statemint', 'karura', 'bifrost'],
+  // perhaps there are some runtime updates
+  centrifuge: ['centrifuge']
 };
-
 export const _BALANCE_TOKEN_GROUP = {
   crab: ['CKTON', 'PKTON'],
   bitcountry: ['BIT']
@@ -194,7 +195,8 @@ export const _TRANSFER_CHAIN_GROUP = {
   riochain: ['riochain'],
   sora_substrate: ['sora_substrate'],
   avail: ['kate', 'goldberg_testnet'],
-  pendulum: ['pendulum', 'amplitude', 'amplitude_test']
+  pendulum: ['pendulum', 'amplitude', 'amplitude_test'],
+  centrifuge: ['centrifuge']
 };
 export const _BALANCE_PARSING_CHAIN_GROUP = {
   bobabeam: ['bobabeam', 'bobabase']

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

@@ -113,4 +113,5 @@ export declare class ChainService {
     getMetadata(chain: string): import("dexie").PromiseExtended<IMetadataItem | undefined>;
     upsertMetadata(chain: string, metadata: IMetadataItem): import("dexie").PromiseExtended<unknown>;
     getMetadataByHash(hash: string): import("dexie").PromiseExtended<IMetadataItem | undefined>;
+    getSubscanChainMap(reverse?: boolean): Record<string, string>;
 }

package/services/chain-service/index.js

@@ -1381,4 +1381,22 @@ export class ChainService {
   getMetadataByHash(hash) {
     return this.dbService.stores.metadata.getMetadataByGenesisHash(hash);
   }
+  getSubscanChainMap(reverse) {
+    const result = {};
+    const chainInfoMap = this.getChainInfoMap();
+    Object.values(chainInfoMap).forEach(i => {
+      var _i$extraInfo;
+      if (!((_i$extraInfo = i.extraInfo) !== null && _i$extraInfo !== void 0 && _i$extraInfo.subscanSlug)) {
+        return;
+      }
+      if (!reverse) {
+        var _i$extraInfo2;
+        result[i.slug] = (_i$extraInfo2 = i.extraInfo) === null || _i$extraInfo2 === void 0 ? void 0 : _i$extraInfo2.subscanSlug;
+      } else {
+        var _i$extraInfo3;
+        result[(_i$extraInfo3 = i.extraInfo) === null || _i$extraInfo3 === void 0 ? void 0 : _i$extraInfo3.subscanSlug] = i.slug;
+      }
+    });
+    return result;
+  }
 }

package/services/history-service/helpers/subscan-extrinsic-parser-helper.d.ts

@@ -0,0 +1,6 @@
+import { TransactionHistoryItem } from '@subwallet/extension-base/background/KoniTypes';
+import { ExtrinsicItem } from '@subwallet/extension-base/services/subscan-service/types';
+export declare type ExtrinsicParserFunction = (item: TransactionHistoryItem) => TransactionHistoryItem | null;
+export declare function getExtrinsicParserKey(extrinsicItem: ExtrinsicItem): string;
+export declare const subscanExtrinsicParserMap: Record<string, ExtrinsicParserFunction>;
+export declare const supportedExtrinsicParser: string[];

package/services/history-service/helpers/subscan-extrinsic-parser-helper.js

@@ -0,0 +1,44 @@
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { ExtrinsicType } from '@subwallet/extension-base/background/KoniTypes';
+import { encodeAddress } from '@polkadot/util-crypto';
+export function getExtrinsicParserKey(extrinsicItem) {
+  return `${extrinsicItem.call_module}.${extrinsicItem.call_module_function}`;
+}
+function paramJsonParse(item) {
+  try {
+    return JSON.parse(item.data || '[]');
+  } catch (e) {
+    return [];
+  }
+}
+function balanceTransferParserFunction(item) {
+  const params = paramJsonParse(item);
+  params.forEach(p => {
+    if (p.name === 'dest') {
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+      const toPublicKey = p.value.id || p.value.Id;
+      if (toPublicKey) {
+        item.to = encodeAddress(toPublicKey, 42);
+      }
+    } else if (p.name === 'value') {
+      if (item.amount) {
+        item.amount.value = p.value;
+      }
+    }
+  });
+  item.type = ExtrinsicType.TRANSFER_BALANCE;
+  if (!item.to) {
+    return null;
+  }
+  return item;
+}
+
+// todo: will support other type later
+export const subscanExtrinsicParserMap = {
+  'balances.transfer': balanceTransferParserFunction,
+  'balances.transfer_keep_alive': balanceTransferParserFunction,
+  'balances.transfer_allow_death': balanceTransferParserFunction
+};
+export const supportedExtrinsicParser = Object.keys(subscanExtrinsicParserMap);

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

@@ -1,24 +1,30 @@
 import { TransactionHistoryItem } from '@subwallet/extension-base/background/KoniTypes';
-import { CronServiceInterface, PersistDataServiceInterface, ServiceStatus, StoppableServiceInterface } from '@subwallet/extension-base/services/base/types';
+import { PersistDataServiceInterface, ServiceStatus, StoppableServiceInterface } from '@subwallet/extension-base/services/base/types';
 import { ChainService } from '@subwallet/extension-base/services/chain-service';
 import { EventService } from '@subwallet/extension-base/services/event-service';
 import { KeyringService } from '@subwallet/extension-base/services/keyring-service';
 import DatabaseService from '@subwallet/extension-base/services/storage-service/DatabaseService';
+import { SubscanService } from '@subwallet/extension-base/services/subscan-service';
 import { BehaviorSubject } from 'rxjs';
-export declare class HistoryService implements StoppableServiceInterface, PersistDataServiceInterface, CronServiceInterface {
+export declare class HistoryService implements StoppableServiceInterface, PersistDataServiceInterface {
     #private;
     private dbService;
     private chainService;
     private eventService;
     private keyringService;
+    private subscanService;
     private historySubject;
-    constructor(dbService: DatabaseService, chainService: ChainService, eventService: EventService, keyringService: KeyringService);
+    constructor(dbService: DatabaseService, chainService: ChainService, eventService: EventService, keyringService: KeyringService, subscanService: SubscanService);
     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>[]>>;
+    private fetchSubscanTransactionHistory;
+    subscribeHistories(chain: string, address: string, cb: (items: TransactionHistoryItem[]) => void): {
+        unsubscribe: () => void;
+        value: TransactionHistoryItem<import("@subwallet/extension-base/background/KoniTypes").ExtrinsicType.TRANSFER_BALANCE>[];
+    };
     updateHistories(chain: string, extrinsicHash: string, updateData: Partial<TransactionHistoryItem>): Promise<void>;
     updateHistoryByExtrinsicHash(extrinsicHash: string, updateData: Partial<TransactionHistoryItem>): Promise<void>;
     insertHistories(historyItems: TransactionHistoryItem[]): Promise<void>;
@@ -27,8 +33,6 @@ export declare class HistoryService implements StoppableServiceInterface, Persis
     status: ServiceStatus;
     loadData(): Promise<void>;
     persistData(): Promise<void>;
-    startCron(): Promise<void>;
-    stopCron(): Promise<void>;
     startRecoverHistories(): Promise<void>;
     stopRecoverHistories(): Promise<void>;
     recoverHistories(): Promise<void>;

package/services/history-service/index.js

@@ -2,24 +2,32 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import { ExtrinsicStatus } from '@subwallet/extension-base/background/KoniTypes';
-import { CRON_RECOVER_HISTORY_INTERVAL, CRON_REFRESH_HISTORY_INTERVAL } from '@subwallet/extension-base/constants';
+import { CRON_RECOVER_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 { getExtrinsicParserKey } from '@subwallet/extension-base/services/history-service/helpers/subscan-extrinsic-parser-helper';
+import { parseSubscanExtrinsicData, parseSubscanTransferData } from '@subwallet/extension-base/services/history-service/subscan-history';
+import { reformatAddress } from '@subwallet/extension-base/utils';
 import { createPromiseHandler } from '@subwallet/extension-base/utils/promise';
 import { keyring } from '@subwallet/ui-keyring';
 import { BehaviorSubject } from 'rxjs';
+function filterHistoryItemByAddressAndChain(chain, address) {
+  return item => {
+    return item.chain === chain && item.address === address;
+  };
+}
 export class HistoryService {
   historySubject = new BehaviorSubject([]);
   #needRecoveryHistories = {};
-  constructor(dbService, chainService, eventService, keyringService) {
+  constructor(dbService, chainService, eventService, keyringService, subscanService) {
     this.dbService = dbService;
     this.chainService = chainService;
     this.eventService = eventService;
     this.keyringService = keyringService;
+    this.subscanService = subscanService;
     this.init().catch(console.error);
   }
   fetchPromise = null;
-  interval = undefined;
   recoverInterval = undefined;
   async fetchAndLoadHistories(addresses) {
     if (!addresses || addresses.length === 0) {
@@ -60,6 +68,74 @@ export class HistoryService {
     await this.getHistories();
     return this.historySubject;
   }
+  fetchSubscanTransactionHistory(chain, address) {
+    if (!this.subscanService.checkSupportedSubscanChain(chain)) {
+      return;
+    }
+    const chainInfo = this.chainService.getChainInfoByKey(chain);
+    const excludeExtrinsicParserKeys = ['balances.transfer_all'];
+
+    // Note: fetchAllPossibleExtrinsicItems and fetchAllPossibleTransferItems-receive can run parallelly
+    // Hover, fetchAllPossibleTransferItems-sent must run after fetchAllPossibleExtrinsicItems,
+    // to avoid "duplicate Extrinsic Hash between items" problem
+
+    this.subscanService.fetchAllPossibleExtrinsicItems(chain, address, extrinsicItems => {
+      const result = [];
+      extrinsicItems.forEach(x => {
+        const item = parseSubscanExtrinsicData(address, x, chainInfo);
+        if (item) {
+          result.push(item);
+        }
+      });
+      this.addHistoryItems(result).catch(e => {
+        console.log('addHistoryItems in fetchAllPossibleExtrinsicItems error', e);
+      });
+    }).then(extrinsicItems => {
+      const excludeTransferExtrinsicHash = [];
+      extrinsicItems.forEach(x => {
+        if (!excludeExtrinsicParserKeys.includes(getExtrinsicParserKey(x))) {
+          excludeTransferExtrinsicHash.push(x.extrinsic_hash);
+        }
+      });
+      this.subscanService.fetchAllPossibleTransferItems(chain, address, 'sent', transferItems => {
+        const result = [];
+        transferItems.forEach(t => {
+          if (!excludeTransferExtrinsicHash.includes(t.hash)) {
+            result.push(parseSubscanTransferData(address, t, chainInfo));
+          }
+        });
+        this.addHistoryItems(result).catch(e => {
+          console.log('addHistoryItems in fetchAllPossibleTransferItems-sent error', e);
+        });
+      }).catch(e => {
+        console.log('fetchAllPossibleTransferItems-sent error', e);
+      });
+    }).catch(e => {
+      console.log('fetchAllPossibleExtrinsicItems error', e);
+    });
+    this.subscanService.fetchAllPossibleTransferItems(chain, address, 'received', transferItems => {
+      const result = [];
+      transferItems.forEach(t => {
+        result.push(parseSubscanTransferData(address, t, chainInfo));
+      });
+      this.addHistoryItems(result).catch(e => {
+        console.log('addHistoryItems in fetchAllPossibleTransferItems-receive error', e);
+      });
+    }).catch(e => {
+      console.log('fetchAllPossibleTransferItems-receive error', e);
+    });
+  }
+  subscribeHistories(chain, address, cb) {
+    const _address = reformatAddress(address);
+    const subscription = this.historySubject.subscribe(items => {
+      cb(items.filter(filterHistoryItemByAddressAndChain(chain, _address)));
+    });
+    this.fetchSubscanTransactionHistory(chain, _address);
+    return {
+      unsubscribe: subscription.unsubscribe,
+      value: this.historySubject.getValue().filter(filterHistoryItemByAddressAndChain(chain, _address))
+    };
+  }
   async updateHistories(chain, extrinsicHash, updateData) {
     const existedRecords = await this.dbService.getHistories({
       chain,
@@ -110,17 +186,6 @@ export class HistoryService {
   async persistData() {
     await this.dbService.upsertHistory(this.historySubject.value);
   }
-  async startCron() {
-    await this.getHistories();
-    this.interval = setInterval(() => {
-      this.getHistories().catch(console.error);
-    }, CRON_REFRESH_HISTORY_INTERVAL);
-  }
-  stopCron() {
-    clearTimeout(this.interval);
-    this.fetchPromise = null;
-    return Promise.resolve();
-  }
   async startRecoverHistories() {
     await this.recoverHistories();
     this.recoverInterval = setInterval(() => {
@@ -175,12 +240,6 @@ export class HistoryService {
     Promise.all([this.eventService.waitKeyringReady, this.eventService.waitChainReady]).then(() => {
       this.getHistories().catch(console.log);
       this.recoverProcessingHistory().catch(console.error);
-      this.eventService.on('account.add', () => {
-        (async () => {
-          await this.stopCron();
-          await this.startCron();
-        })().catch(console.error);
-      });
       this.eventService.on('account.remove', address => {
         this.removeHistoryByAddress(address).catch(console.error);
       });
@@ -209,7 +268,6 @@ export class HistoryService {
       await Promise.all([this.eventService.waitKeyringReady, this.eventService.waitChainReady]);
       this.startPromiseHandler = createPromiseHandler();
       this.status = ServiceStatus.STARTING;
-      await this.startCron();
       this.status = ServiceStatus.STARTED;
       this.startPromiseHandler.resolve();
     } catch (e) {
@@ -225,7 +283,6 @@ export class HistoryService {
       this.stopPromiseHandler = createPromiseHandler();
       this.status = ServiceStatus.STOPPING;
       await this.persistData();
-      await this.stopCron();
       await this.stopRecoverHistories();
       this.stopPromiseHandler.resolve();
       this.status = ServiceStatus.STOPPED;

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

@@ -0,0 +1,5 @@
+import { _ChainInfo } from '@subwallet/chain-list/types';
+import { TransactionHistoryItem } from '@subwallet/extension-base/background/KoniTypes';
+import { ExtrinsicItem, TransferItem } from '@subwallet/extension-base/services/subscan-service/types';
+export declare function parseSubscanExtrinsicData(address: string, extrinsicItem: ExtrinsicItem, chainInfo: _ChainInfo): TransactionHistoryItem | null;
+export declare function parseSubscanTransferData(address: string, transferItem: TransferItem, chainInfo: _ChainInfo): TransactionHistoryItem;

package/services/history-service/subscan-history.js

@@ -0,0 +1,100 @@
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { ChainType, ExtrinsicStatus, ExtrinsicType, TransactionDirection } from '@subwallet/extension-base/background/KoniTypes';
+import { getExtrinsicParserKey, subscanExtrinsicParserMap, supportedExtrinsicParser } from '@subwallet/extension-base/services/history-service/helpers/subscan-extrinsic-parser-helper';
+import { decodeAddress, encodeAddress, isEthereumAddress } from '@polkadot/util-crypto';
+function autoFormatAddress(address) {
+  try {
+    if (isEthereumAddress(address)) {
+      return address;
+    } else {
+      const decoded = decodeAddress(address);
+      return encodeAddress(decoded, 42);
+    }
+  } catch (e) {
+    return '';
+  }
+}
+export function parseSubscanExtrinsicData(address, extrinsicItem, chainInfo) {
+  var _chainInfo$substrateI, _chainInfo$evmInfo, _chainInfo$substrateI2, _chainInfo$evmInfo2;
+  const extrinsicParserKey = getExtrinsicParserKey(extrinsicItem);
+  if (!supportedExtrinsicParser.includes(extrinsicParserKey)) {
+    return null;
+  }
+  const chainType = chainInfo.substrateInfo ? ChainType.SUBSTRATE : ChainType.EVM;
+  const nativeDecimals = ((_chainInfo$substrateI = chainInfo.substrateInfo) === null || _chainInfo$substrateI === void 0 ? void 0 : _chainInfo$substrateI.decimals) || ((_chainInfo$evmInfo = chainInfo.evmInfo) === null || _chainInfo$evmInfo === void 0 ? void 0 : _chainInfo$evmInfo.decimals) || 18;
+  const nativeSymbol = ((_chainInfo$substrateI2 = chainInfo.substrateInfo) === null || _chainInfo$substrateI2 === void 0 ? void 0 : _chainInfo$substrateI2.symbol) || ((_chainInfo$evmInfo2 = chainInfo.evmInfo) === null || _chainInfo$evmInfo2 === void 0 ? void 0 : _chainInfo$evmInfo2.symbol) || '';
+  const initData = {
+    address,
+    origin: 'subscan',
+    time: extrinsicItem.block_timestamp * 1000,
+    chainType,
+    from: address,
+    signature: extrinsicItem.signature,
+    fromName: undefined,
+    direction: TransactionDirection.SEND,
+    blockNumber: extrinsicItem.block_num,
+    blockHash: '',
+    chain: chainInfo.slug,
+    type: ExtrinsicType.UNKNOWN,
+    to: '',
+    toName: undefined,
+    extrinsicHash: extrinsicItem.extrinsic_hash,
+    amount: {
+      value: '0',
+      decimals: nativeDecimals,
+      symbol: nativeSymbol
+    },
+    data: extrinsicItem.params,
+    fee: {
+      value: extrinsicItem.fee,
+      decimals: nativeDecimals,
+      symbol: nativeSymbol
+    },
+    status: extrinsicItem.success ? ExtrinsicStatus.SUCCESS : ExtrinsicStatus.FAIL,
+    nonce: extrinsicItem.nonce
+  };
+  try {
+    return subscanExtrinsicParserMap[extrinsicParserKey](initData);
+  } catch (e) {
+    console.log('parseSubscanExtrinsicData error:', e, initData);
+    return null;
+  }
+}
+export function parseSubscanTransferData(address, transferItem, chainInfo) {
+  var _chainInfo$substrateI3, _chainInfo$evmInfo3, _chainInfo$substrateI4, _chainInfo$evmInfo4;
+  const chainType = chainInfo.substrateInfo ? ChainType.SUBSTRATE : ChainType.EVM;
+  const nativeDecimals = ((_chainInfo$substrateI3 = chainInfo.substrateInfo) === null || _chainInfo$substrateI3 === void 0 ? void 0 : _chainInfo$substrateI3.decimals) || ((_chainInfo$evmInfo3 = chainInfo.evmInfo) === null || _chainInfo$evmInfo3 === void 0 ? void 0 : _chainInfo$evmInfo3.decimals) || 18;
+  const nativeSymbol = ((_chainInfo$substrateI4 = chainInfo.substrateInfo) === null || _chainInfo$substrateI4 === void 0 ? void 0 : _chainInfo$substrateI4.symbol) || ((_chainInfo$evmInfo4 = chainInfo.evmInfo) === null || _chainInfo$evmInfo4 === void 0 ? void 0 : _chainInfo$evmInfo4.symbol) || '';
+  const from = autoFormatAddress(transferItem.from);
+  const to = autoFormatAddress(transferItem.to);
+  return {
+    address,
+    origin: 'subscan',
+    time: transferItem.block_timestamp * 1000,
+    chainType,
+    from,
+    fromName: transferItem.from_account_display.display,
+    direction: address === from ? TransactionDirection.SEND : TransactionDirection.RECEIVED,
+    blockNumber: transferItem.block_num,
+    blockHash: '',
+    chain: chainInfo.slug,
+    type: ExtrinsicType.TRANSFER_BALANCE,
+    to,
+    toName: transferItem.to_account_display.display,
+    extrinsicHash: transferItem.hash,
+    amount: {
+      value: transferItem.amount,
+      decimals: 0,
+      symbol: transferItem.asset_symbol
+    },
+    fee: {
+      value: transferItem.fee,
+      decimals: nativeDecimals,
+      symbol: nativeSymbol
+    },
+    status: transferItem.success ? ExtrinsicStatus.SUCCESS : ExtrinsicStatus.FAIL,
+    nonce: transferItem.nonce
+  };
+}