@subwallet/extension-base 1.0.1 → 1.0.2-1

package/package.json

@@ -17,7 +17,7 @@
     "./cjs/detectPackage.js"
   ],
   "type": "module",
-  "version": "1.0.1",
+  "version": "1.0.2-1",
   "main": "./cjs/index.js",
   "module": "./index.js",
   "types": "./index.d.ts",
@@ -434,16 +434,6 @@
       "require": "./cjs/koni/background/subscription.js",
       "default": "./koni/background/subscription.js"
     },
-    "./koni/page": {
-      "types": "./koni/page/index.d.ts",
-      "require": "./cjs/koni/page/index.js",
-      "default": "./koni/page/index.js"
-    },
-    "./koni/page/SubWalleEvmProvider": {
-      "types": "./koni/page/SubWalleEvmProvider.d.ts",
-      "require": "./cjs/koni/page/SubWalleEvmProvider.js",
-      "default": "./koni/page/SubWalleEvmProvider.js"
-    },
     "./package.json": "./package.json",
     "./packageInfo.js": {
       "types": "./packageInfo.d.ts",
@@ -485,6 +475,11 @@
       "require": "./cjs/page/Signer.js",
       "default": "./page/Signer.js"
     },
+    "./page/SubWalleEvmProvider": {
+      "types": "./page/SubWalleEvmProvider.d.ts",
+      "require": "./cjs/page/SubWalleEvmProvider.js",
+      "default": "./page/SubWalleEvmProvider.js"
+    },
     "./page/types": {
       "types": "./page/types.d.ts",
       "require": "./cjs/page/types.js",
@@ -1170,6 +1165,16 @@
       "require": "./cjs/services/chain-service/utils.js",
       "default": "./services/chain-service/utils.js"
     },
+    "./services/event-service": {
+      "types": "./services/event-service/index.d.ts",
+      "require": "./cjs/services/event-service/index.js",
+      "default": "./services/event-service/index.js"
+    },
+    "./services/event-service/types": {
+      "types": "./services/event-service/types.d.ts",
+      "require": "./cjs/services/event-service/types.js",
+      "default": "./services/event-service/types.js"
+    },
     "./services/history-service": {
       "types": "./services/history-service/index.d.ts",
       "require": "./cjs/services/history-service/index.js",
@@ -1180,6 +1185,11 @@
       "require": "./cjs/services/history-service/subsquid-multi-chain-history.js",
       "default": "./services/history-service/subsquid-multi-chain-history.js"
     },
+    "./services/keyring-service": {
+      "types": "./services/keyring-service/index.d.ts",
+      "require": "./cjs/services/keyring-service/index.js",
+      "default": "./services/keyring-service/index.js"
+    },
     "./services/migration-service": {
       "types": "./services/migration-service/index.d.ts",
       "require": "./cjs/services/migration-service/index.js",
@@ -1195,6 +1205,11 @@
       "require": "./cjs/services/migration-service/scripts/index.js",
       "default": "./services/migration-service/scripts/index.js"
     },
+    "./services/migration-service/scripts/AutoEnableChainsTokens": {
+      "types": "./services/migration-service/scripts/AutoEnableChainsTokens.d.ts",
+      "require": "./cjs/services/migration-service/scripts/AutoEnableChainsTokens.js",
+      "default": "./services/migration-service/scripts/AutoEnableChainsTokens.js"
+    },
     "./services/migration-service/scripts/ClearOldStorage": {
       "types": "./services/migration-service/scripts/ClearOldStorage.d.ts",
       "require": "./cjs/services/migration-service/scripts/ClearOldStorage.js",
@@ -1210,6 +1225,16 @@
       "require": "./cjs/services/migration-service/scripts/MigrateNetworkSettings.js",
       "default": "./services/migration-service/scripts/MigrateNetworkSettings.js"
     },
+    "./services/migration-service/scripts/MigrateSettings": {
+      "types": "./services/migration-service/scripts/MigrateSettings.d.ts",
+      "require": "./cjs/services/migration-service/scripts/MigrateSettings.js",
+      "default": "./services/migration-service/scripts/MigrateSettings.js"
+    },
+    "./services/migration-service/scripts/MigrateTransactionHistory": {
+      "types": "./services/migration-service/scripts/MigrateTransactionHistory.d.ts",
+      "require": "./cjs/services/migration-service/scripts/MigrateTransactionHistory.js",
+      "default": "./services/migration-service/scripts/MigrateTransactionHistory.js"
+    },
     "./services/notification-service/NotificationService": {
       "types": "./services/notification-service/NotificationService.d.ts",
       "require": "./cjs/services/notification-service/NotificationService.js",
@@ -1375,6 +1400,21 @@
       "require": "./cjs/services/storage-service/db-stores/Transaction.js",
       "default": "./services/storage-service/db-stores/Transaction.js"
     },
+    "./services/subscan-service": {
+      "types": "./services/subscan-service/index.d.ts",
+      "require": "./cjs/services/subscan-service/index.js",
+      "default": "./services/subscan-service/index.js"
+    },
+    "./services/subscan-service/subscan-chain-map": {
+      "types": "./services/subscan-service/subscan-chain-map.d.ts",
+      "require": "./cjs/services/subscan-service/subscan-chain-map.js",
+      "default": "./services/subscan-service/subscan-chain-map.js"
+    },
+    "./services/subscan-service/types": {
+      "types": "./services/subscan-service/types.d.ts",
+      "require": "./cjs/services/subscan-service/types.js",
+      "default": "./services/subscan-service/types.js"
+    },
     "./services/transaction-service": {
       "types": "./services/transaction-service/index.d.ts",
       "require": "./cjs/services/transaction-service/index.js",
@@ -1611,11 +1651,11 @@
     "@sora-substrate/type-definitions": "^1.12.4",
     "@subsocial/types": "^0.6.8",
     "@substrate/connect": "^0.7.18",
-    "@subwallet/chain-list": "^0.0.21",
-    "@subwallet/extension-base": "^1.0.1",
-    "@subwallet/extension-chains": "^1.0.1",
-    "@subwallet/extension-dapp": "^1.0.1",
-    "@subwallet/extension-inject": "^1.0.1",
+    "@subwallet/chain-list": "^0.0.27",
+    "@subwallet/extension-base": "^1.0.2-1",
+    "@subwallet/extension-chains": "^1.0.2-1",
+    "@subwallet/extension-dapp": "^1.0.2-1",
+    "@subwallet/extension-inject": "^1.0.2-1",
     "@subwallet/keyring": "^0.0.4",
     "@subwallet/ui-keyring": "^0.0.3",
     "@unique-nft/types": "^0.6.0-4",

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.1'
+  version: '1.0.2-1'
 };

package/page/index.d.ts

@@ -1,4 +1,5 @@
 import type { MessageTypes, MessageTypesWithNoSubscriptions, MessageTypesWithNullRequest, MessageTypesWithSubscriptions, RequestTypes, ResponseTypes, SubscriptionMessageTypes, TransportResponseMessage } from '../background/types';
+import { EvmProvider } from '@subwallet/extension-inject/types';
 import Injected from './Injected';
 export interface Handler {
     resolve: (data?: any) => void;
@@ -13,3 +14,4 @@ export declare function enable(origin: string): Promise<Injected>;
 export declare function handleResponse<TMessageType extends MessageTypes>(data: TransportResponseMessage<TMessageType> & {
     subscription?: string;
 }): void;
+export declare function initEvmProvider(version: string): EvmProvider;

package/page/index.js

@@ -3,6 +3,7 @@
 
 import { ProviderError } from '@subwallet/extension-base/background/errors/ProviderError';
 import { ProviderErrorType } from '@subwallet/extension-base/background/KoniTypes';
+import { SubWalletEvmProvider } from '@subwallet/extension-base/page/SubWalleEvmProvider';
 import { MESSAGE_ORIGIN_PAGE } from "../defaults.js";
 import { getId } from "../utils/getId.js";
 import Injected from "./Injected.js";
@@ -60,4 +61,7 @@ export function handleResponse(data) {
   } else {
     handler.resolve(data.response);
   }
+}
+export function initEvmProvider(version) {
+  return new SubWalletEvmProvider(sendMessage, version);
 }

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

@@ -69,7 +69,6 @@ export declare const _XCM_CHAIN_GROUP: {
     polkadotXcm: string[];
     xcmPallet: string[];
 };
-export declare const _XCM_CHAIN_USE_LIMITED_WEIGHT: string[];
 export declare const _XCM_TYPE: {
     RP: string;
     PP: string;

package/services/chain-service/constants.js

@@ -191,17 +191,8 @@ export const _XCM_CHAIN_GROUP = {
   polkadotXcm: ['astar', 'shiden', 'statemine', 'statemint'],
   xcmPallet: ['polkadot', 'kusama']
   // default is xTokens pallet
-  // moonbeam: ['moonbeam', 'moonriver', 'moonbase'],
-  // astar: ['astar', 'shiden'],
-  // statemine: ['statemint', 'statemine'],
-  // bifrost: ['bifrost'],
-  // genshiro: ['genshiro_testnet', 'genshiro', 'equilibrium_parachain'],
-  // kintsugi: ['kintsugi', 'kintsugi_test', 'interlay'],
-  // acala: ['karura', 'acala', 'acala_testnet'],
-  // astarEvm: ['astarEvm', 'shidenEvm']
 };
 
-export const _XCM_CHAIN_USE_LIMITED_WEIGHT = ['acala', 'karura', 'statemint'];
 export const _XCM_TYPE = {
   RP: `${_SubstrateChainType.RELAYCHAIN}-${_SubstrateChainType.PARACHAIN}`,
   // DMP

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

@@ -1,11 +1,13 @@
 import { _AssetRef, _AssetType, _ChainAsset, _ChainInfo, _MultiChainAsset } from '@subwallet/chain-list/types';
 import { AssetSetting, ValidateNetworkResponse } from '@subwallet/extension-base/background/KoniTypes';
 import { _ChainConnectionStatus, _ChainState, _EvmApi, _NetworkUpsertParams, _SubstrateApi, _ValidateCustomAssetRequest, _ValidateCustomAssetResponse } from '@subwallet/extension-base/services/chain-service/types';
+import { EventService } from '@subwallet/extension-base/services/event-service';
 import DatabaseService from '@subwallet/extension-base/services/storage-service/DatabaseService';
 import { BehaviorSubject, Subject } from 'rxjs';
 export declare class ChainService {
     private dataMap;
     private dbService;
+    private eventService;
     private lockChainInfoMap;
     private substrateChainHandler;
     private evmChainHandler;
@@ -18,7 +20,7 @@ export declare class ChainService {
     private assetSettingSubject;
     private logger;
     private refreshChainStateTimeout;
-    constructor(dbService: DatabaseService);
+    constructor(dbService: DatabaseService, eventService: EventService);
     getXcmRefMap(): Record<string, _AssetRef>;
     getEvmApi(slug: string): _EvmApi;
     getEvmApiMap(): Record<string, _EvmApi>;
@@ -50,7 +52,7 @@ export declare class ChainService {
     getChainInfoByKey(key: string): _ChainInfo;
     getActiveChainInfos(): Record<string, _ChainInfo>;
     getAssetBySlug(slug: string): _ChainAsset;
-    getFungibleTokensByChain(chainSlug: string): Record<string, _ChainAsset>;
+    getFungibleTokensByChain(chainSlug: string, checkActive?: boolean): Record<string, _ChainAsset>;
     getXcmEqualAssetByChain(destinationChainSlug: string, originTokenSlug: string): _ChainAsset | undefined;
     getAssetByChainAndType(chainSlug: string, assetTypes: _AssetType[]): Record<string, _ChainAsset>;
     getSmartContractNfts(): _ChainAsset[];
@@ -93,10 +95,10 @@ export declare class ChainService {
     private refreshChainStateInterval;
     private updateApiMapStatus;
     initAssetSettings(): Promise<void>;
-    setAssetSettings(assetSettings: Record<string, AssetSetting>): void;
+    setAssetSettings(assetSettings: Record<string, AssetSetting>, emitEvent?: boolean): void;
     getStoreAssetSettings(): Promise<Record<string, AssetSetting>>;
     getAssetSettings(): Promise<Record<string, AssetSetting>>;
-    updateAssetSetting(assetSlug: string, assetSetting: AssetSetting): Promise<void>;
+    updateAssetSetting(assetSlug: string, assetSetting: AssetSetting): Promise<boolean | undefined>;
     updateAssetSettingByChain(chainSlug: string, visible: boolean): Promise<void>;
     subscribeAssetSettings(): BehaviorSubject<Record<string, AssetSetting>>;
 }

package/services/chain-service/index.js

@@ -21,8 +21,6 @@ export class ChainService {
     assetRegistry: {},
     assetRefMap: {}
   };
-  // to save chain, token settings from user
-
   lockChainInfoMap = false; // prevent unwanted changes (edit, enable, disable) to chainInfoMap
 
   // TODO: consider BehaviorSubject
@@ -35,8 +33,9 @@ export class ChainService {
   // Todo: Update to new store indexed DB
   store = new AssetSettingStore();
   assetSettingSubject = new BehaviorSubject({});
-  constructor(dbService) {
+  constructor(dbService, eventService) {
     this.dbService = dbService;
+    this.eventService = eventService;
     this.substrateChainHandler = new SubstrateChainHandler();
     this.evmChainHandler = new EvmChainHandler();
     this.chainInfoMapSubject.next(this.dataMap.chainInfoMap);
@@ -208,10 +207,13 @@ export class ChainService {
   getAssetBySlug(slug) {
     return this.getAssetRegistry()[slug];
   }
-  getFungibleTokensByChain(chainSlug) {
+  getFungibleTokensByChain(chainSlug, checkActive = false) {
     const result = {};
+    const assetSettings = this.assetSettingSubject.value;
     Object.values(this.getAssetRegistry()).forEach(chainAsset => {
-      if (chainAsset.originChain === chainSlug && _isAssetFungibleToken(chainAsset)) {
+      var _assetSettings$chainA;
+      const _filterActive = !checkActive || ((_assetSettings$chainA = assetSettings[chainAsset.slug]) === null || _assetSettings$chainA === void 0 ? void 0 : _assetSettings$chainA.visible);
+      if (chainAsset.originChain === chainSlug && _isAssetFungibleToken(chainAsset) && _filterActive) {
         result[chainAsset.slug] = chainAsset;
       }
     });
@@ -275,6 +277,7 @@ export class ChainService {
     this.dbService.removeFromChainStore([slug]).catch(console.error);
     this.updateChainSubscription();
     this.lockChainInfoMap = false;
+    this.eventService.emit('chain.remove', slug);
     return true;
   }
   resetChainInfoMap(excludedChains) {
@@ -308,6 +311,10 @@ export class ChainService {
         token.slug = `${_CUSTOM_PREFIX}${defaultSlug}`;
       }
     }
+    if (token.originChain && _isAssetFungibleToken(token)) {
+      var _this$getChainInfoByK;
+      token.hasValue = !((_this$getChainInfoByK = this.getChainInfoByKey(token.originChain)) !== null && _this$getChainInfoByK !== void 0 && _this$getChainInfoByK.isTestnet);
+    }
     const assetRegistry = this.getAssetRegistry();
     assetRegistry[token.slug] = token;
     this.dbService.updateAssetStore(token).catch(e => this.logger.error(e));
@@ -335,6 +342,9 @@ export class ChainService {
     this.dbService.removeFromBalanceStore(targetAssets).catch(e => this.logger.error(e));
     this.dbService.removeFromAssetStore(targetAssets).catch(e => this.logger.error(e));
     this.assetRegistrySubject.next(assetRegistry);
+    targetAssets.forEach(assetSlug => {
+      this.eventService.emit('asset.remove', assetSlug);
+    });
   }
 
   // Business logic
@@ -404,6 +414,7 @@ export class ChainService {
       currentProvider: chainStateMap[chainSlug].currentProvider
     }).catch(console.error);
     this.lockChainInfoMap = false;
+    this.eventService.emit('chain.enable', chainSlug);
     return true;
   }
   enableChain(chainSlug) {
@@ -438,6 +449,7 @@ export class ChainService {
     }).catch(console.error);
     this.updateChainStateMapSubscription();
     this.lockChainInfoMap = false;
+    this.eventService.emit('chain.disable', chainSlug);
     return true;
   }
   checkExistedPredefinedChain(genesisHash, evmChainId) {
@@ -659,6 +671,8 @@ export class ChainService {
       ...targetChainInfo,
       active: targetChainState.active,
       currentProvider: targetChainState.currentProvider
+    }).then(() => {
+      this.eventService.emit('chain.update', chainSlug);
     }).catch(e => this.logger.error(e));
   }
   insertChain(params) {
@@ -743,6 +757,8 @@ export class ChainService {
       active: true,
       currentProvider: params.chainEditInfo.currentProvider,
       ...chainInfo
+    }).then(() => {
+      this.eventService.emit('chain.add', newChainSlug);
     }).catch(e => this.logger.error(e));
     return nativeTokenSlug;
   }
@@ -1086,12 +1102,25 @@ export class ChainService {
           };
         }
       });
-      this.setAssetSettings(assetSettings);
+      this.setAssetSettings(assetSettings, false);
     }
+    this.eventService.emit('asset.ready', true);
     console.log('Done init asset settings');
   }
-  setAssetSettings(assetSettings) {
+  setAssetSettings(assetSettings, emitEvent = true) {
+    const updateAssets = [];
+    if (emitEvent) {
+      Object.keys(assetSettings).forEach(slug => {
+        var _this$assetSettingSub;
+        if (((_this$assetSettingSub = this.assetSettingSubject.value[slug]) === null || _this$assetSettingSub === void 0 ? void 0 : _this$assetSettingSub.visible) !== assetSettings[slug].visible) {
+          updateAssets.push(slug);
+        }
+      });
+    }
     this.assetSettingSubject.next(assetSettings);
+    updateAssets.forEach(slug => {
+      this.eventService.emit(assetSettings[slug].visible ? 'asset.enable' : 'asset.disable', slug);
+    });
     this.store.set('AssetSetting', assetSettings);
   }
   async getStoreAssetSettings() {
@@ -1108,6 +1137,7 @@ export class ChainService {
   }
   async updateAssetSetting(assetSlug, assetSetting) {
     const currentAssetSettings = await this.getAssetSettings();
+    let needUpdateSubject;
 
     // Update settings
     currentAssetSettings[assetSlug] = assetSetting;
@@ -1119,8 +1149,10 @@ export class ChainService {
       // if chain not enabled, then automatically enable
       if (chainState && !chainState.active) {
         this.enableChain(chainState.slug);
+        needUpdateSubject = true;
       }
     }
+    return needUpdateSubject;
   }
   async updateAssetSettingByChain(chainSlug, visible) {
     const storedAssetSettings = await this.getAssetSettings();

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

@@ -34,6 +34,7 @@ export declare function _getNftTypesSupportedByChain(chainInfo: _ChainInfo): _As
 export declare function _getTokenTypesSupportedByChain(chainInfo: _ChainInfo): _AssetType[];
 export declare function _getChainNativeTokenBasicInfo(chainInfo: _ChainInfo): BasicTokenInfo;
 export declare function _getChainNativeTokenSlug(chainInfo: _ChainInfo): string;
+export declare function _isLocalToken(tokenInfo: _ChainAsset): boolean;
 export declare function _isTokenEvmSmartContract(tokenInfo: _ChainAsset): boolean;
 export declare function _isTokenWasmSmartContract(tokenInfo: _ChainAsset): boolean;
 export declare function _isAssetSmartContractNft(assetInfo: _ChainAsset): boolean;

package/services/chain-service/utils.js

@@ -206,6 +206,9 @@ export function _getChainNativeTokenSlug(chainInfo) {
   }
   return `${chainInfo.slug}-${_AssetType.NATIVE}-${_getChainNativeTokenBasicInfo(chainInfo).symbol}`;
 }
+export function _isLocalToken(tokenInfo) {
+  return tokenInfo.assetType === _AssetType.LOCAL;
+}
 export function _isTokenEvmSmartContract(tokenInfo) {
   return [_AssetType.ERC721, _AssetType.ERC20].includes(tokenInfo.assetType);
 }

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

@@ -0,0 +1,22 @@
+import { EventItem, EventRegistry, EventType } from '@subwallet/extension-base/services/event-service/types';
+import EventEmitter from 'eventemitter3';
+export declare class EventService extends EventEmitter<EventRegistry> {
+    private lazyTime;
+    private timeoutId;
+    private pendingEvents;
+    private lazyEmitter;
+    readonly waitKeyringReady: Promise<boolean>;
+    readonly waitAccountReady: Promise<boolean>;
+    readonly waitChainReady: Promise<boolean>;
+    readonly waitAssetReady: Promise<boolean>;
+    constructor(options?: {
+        lazyTime: number;
+    });
+    private generateWaitPromise;
+    private setLazyTimeout;
+    private emitLazy;
+    onLazy(callback: (events: EventItem<EventType>[], eventTypes: EventType[]) => void): void;
+    offLazy(callback: (events: EventItem<EventType>[], eventTypes: EventType[]) => void): void;
+    onceLazy(callback: (events: EventItem<EventType>[], eventTypes: EventType[]) => void): void;
+    emit<T extends EventType>(eventType: T, ...args: EventEmitter.EventArgs<EventRegistry, T>): boolean;
+}

package/services/event-service/index.js

@@ -0,0 +1,59 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+// Stateless service handle runtime event on background
+
+import EventEmitter from 'eventemitter3';
+export class EventService extends EventEmitter {
+  pendingEvents = [];
+  lazyEmitter = new EventEmitter();
+  constructor(options = {
+    lazyTime: 300
+  }) {
+    super();
+    this.lazyTime = options.lazyTime;
+    this.timeoutId = null;
+    this.waitKeyringReady = this.generateWaitPromise('keyring.ready');
+    this.waitAccountReady = this.generateWaitPromise('account.ready');
+    this.waitChainReady = this.generateWaitPromise('chain.ready');
+    this.waitAssetReady = this.generateWaitPromise('asset.ready');
+  }
+  generateWaitPromise(eventType) {
+    return new Promise(resolve => {
+      this.once(eventType, isReady => {
+        resolve(isReady);
+      });
+    });
+  }
+  setLazyTimeout() {
+    if (this.timeoutId) {
+      clearTimeout(this.timeoutId);
+    }
+    this.timeoutId = setTimeout(() => {
+      this.emitLazy();
+    }, this.lazyTime);
+  }
+  emitLazy() {
+    this.lazyEmitter.emit('lazy', this.pendingEvents, this.pendingEvents.map(e => e.type));
+    this.pendingEvents = [];
+    this.timeoutId = null;
+  }
+  onLazy(callback) {
+    this.lazyEmitter.on('lazy', callback);
+  }
+  offLazy(callback) {
+    this.lazyEmitter.off('lazy', callback);
+  }
+  onceLazy(callback) {
+    this.lazyEmitter.once('lazy', callback);
+  }
+  emit(eventType, ...args) {
+    console.debug('Emit event: ', eventType, ...args);
+    this.pendingEvents.push({
+      type: eventType,
+      data: args
+    });
+    this.setLazyTimeout();
+    return super.emit(eventType, ...args);
+  }
+}

package/services/event-service/types.d.ts

@@ -0,0 +1,32 @@
+import { CurrentAccountInfo } from '@subwallet/extension-base/background/KoniTypes';
+import { SWTransaction } from '@subwallet/extension-base/services/transaction-service/types';
+export interface EventRegistry {
+    'keyring.ready': [boolean];
+    'account.updateCurrent': [CurrentAccountInfo];
+    'account.ready': [boolean];
+    'account.add': [string];
+    'account.update': [string];
+    'account.remove': [string];
+    'chain.ready': [boolean];
+    'chain.add': [string];
+    'chain.update': [string];
+    'chain.disable': [string];
+    'chain.enable': [string];
+    'chain.remove': [string];
+    'asset.ready': [boolean];
+    'asset.add': [string];
+    'asset.update': [string];
+    'asset.enable': [string];
+    'asset.disable': [string];
+    'asset.remove': [string];
+    'transaction.done': [SWTransaction];
+    'transaction.failed': [SWTransaction | undefined];
+}
+export declare type EventType = keyof EventRegistry;
+export interface EventItem<T extends EventType> {
+    type: T;
+    data: EventRegistry[T];
+}
+export interface EventEmitterRegistry extends EventRegistry {
+    lazy: EventItem<EventType>[];
+}

package/services/event-service/types.js

@@ -0,0 +1 @@
+export {};

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

@@ -1,12 +1,14 @@
 import { TransactionHistoryItem } from '@subwallet/extension-base/background/KoniTypes';
 import { ChainService } from '@subwallet/extension-base/services/chain-service';
+import { EventService } from '@subwallet/extension-base/services/event-service';
 import DatabaseService from '@subwallet/extension-base/services/storage-service/DatabaseService';
 import { BehaviorSubject } from 'rxjs';
 export declare class HistoryService {
     private dbService;
     private chainService;
+    private eventService;
     private historySubject;
-    constructor(dbService: DatabaseService, chainService: ChainService);
+    constructor(dbService: DatabaseService, chainService: ChainService, eventService: EventService);
     private fetchPromise;
     private nextFetch;
     private fetchAndLoadHistories;
@@ -15,8 +17,8 @@ export declare class HistoryService {
     refreshHistoryInterval(): void;
     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>[]>>;
-    insertHistory(historyItem: TransactionHistoryItem): Promise<void>;
-    updateHistory(chain: string, extrinsicHash: string, historyItem: Partial<TransactionHistoryItem>): Promise<void>;
+    insertHistories(historyItems: TransactionHistoryItem[]): Promise<void>;
+    updateHistories(chain: string, extrinsicHash: string, updateData: Partial<TransactionHistoryItem>): Promise<void>;
     addHistoryItems(historyItems: TransactionHistoryItem[]): Promise<void>;
     removeHistoryByAddress(address: string): Promise<void>;
 }

package/services/history-service/index.js

@@ -2,25 +2,32 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import { CRON_REFRESH_HISTORY_INTERVAL } from '@subwallet/extension-base/constants';
+import { quickFormatAddressToCompare } from '@subwallet/extension-base/utils/address';
+import { keyring } from '@subwallet/ui-keyring';
 import { accounts } from '@subwallet/ui-keyring/observable/accounts';
 import { BehaviorSubject } from 'rxjs';
 import { fetchMultiChainHistories } from "./subsquid-multi-chain-history.js";
 export class HistoryService {
   historySubject = new BehaviorSubject([]);
-  constructor(dbService, chainService) {
+  constructor(dbService, chainService, eventService) {
     this.dbService = dbService;
     this.chainService = chainService;
-
+    this.eventService = eventService;
     // Load history from database
     this.dbService.getHistories().then(histories => {
       this.historySubject.next(histories);
     }).catch(console.error);
 
-    // Add some delay to avoid fetching many times when start extension background
-    setTimeout(() => {
-      // Create history interval and refresh it if changes accounts list
-      accounts.subject.subscribe(this.refreshHistoryInterval.bind(this));
-    }, 3333);
+    // Wait for keyring and chain ready and start
+    Promise.all([this.eventService.waitKeyringReady, this.eventService.waitChainReady]).then(() => {
+      this.getHistories().catch(console.log);
+      this.eventService.on('account.add', () => {
+        this.refreshHistoryInterval();
+      });
+      this.eventService.on('account.remove', address => {
+        this.removeHistoryByAddress(address).catch(console.error);
+      });
+    }).catch(console.error);
   }
   fetchPromise = null;
   nextFetch = undefined;
@@ -43,8 +50,8 @@ export class HistoryService {
       record.fromName = accountMap[(_record$from = record.from) === null || _record$from === void 0 ? void 0 : _record$from.toLowerCase()];
       record.toName = accountMap[(_record$to = record.to) === null || _record$to === void 0 ? void 0 : _record$to.toLowerCase()];
     });
-    await this.dbService.upsertHistory(historyRecords);
-    return await this.dbService.getHistories();
+    this.dbService.upsertHistory(historyRecords).catch(console.error);
+    return historyRecords;
   }
   async fetchHistories(addresses) {
     if (!this.fetchPromise) {
@@ -60,11 +67,14 @@ export class HistoryService {
     clearTimeout(this.nextFetch);
     this.invalidCache();
     this.getHistories().catch(console.error);
-    this.nextFetch = setTimeout(this.refreshHistoryInterval.bind(this), CRON_REFRESH_HISTORY_INTERVAL);
+    this.nextFetch = setTimeout(() => {
+      this.refreshHistoryInterval();
+    }, CRON_REFRESH_HISTORY_INTERVAL);
   }
   async getHistories() {
-    const addressList = Object.keys(accounts.subject.value);
-    if (!this.fetchPromise) {
+    const addressList = keyring.getAccounts().map(a => a.address);
+    const currentHistories = this.historySubject.value;
+    if (!this.fetchPromise || currentHistories.length === 0) {
       const historyRecords = await this.fetchHistories(addressList);
       this.historySubject.next(historyRecords);
     }
@@ -74,11 +84,11 @@ export class HistoryService {
     await this.getHistories();
     return this.historySubject;
   }
-  async insertHistory(historyItem) {
-    await this.dbService.upsertHistory([historyItem]);
+  async insertHistories(historyItems) {
+    await this.dbService.upsertHistory(historyItems);
     this.historySubject.next(await this.dbService.getHistories());
   }
-  async updateHistory(chain, extrinsicHash, historyItem) {
+  async updateHistories(chain, extrinsicHash, updateData) {
     const existedRecords = await this.dbService.getHistories({
       chain,
       extrinsicHash
@@ -86,13 +96,22 @@ export class HistoryService {
     const updatedRecords = existedRecords.map(r => {
       return {
         ...r,
-        ...historyItem
+        ...updateData
       };
     });
     await this.addHistoryItems(updatedRecords);
   }
   async addHistoryItems(historyItems) {
-    await this.dbService.upsertHistory(historyItems);
+    // Prevent override record with original is 'app'
+    const appRecords = this.historySubject.value.filter(item => item.origin === 'app');
+    const excludeKeys = appRecords.map(item => {
+      return `${item.chain}-${quickFormatAddressToCompare(item.address) || ''}-${item.extrinsicHash}`;
+    });
+    const updateRecords = historyItems.filter(item => {
+      const key = `${item.chain}-${quickFormatAddressToCompare(item.address) || ''}-${item.extrinsicHash}`;
+      return item.origin === 'app' || !excludeKeys.includes(key);
+    });
+    await this.dbService.upsertHistory(updateRecords);
     this.historySubject.next(await this.dbService.getHistories());
   }
   async removeHistoryByAddress(address) {