@subwallet/extension-base 1.0.2-2 → 1.0.2-3

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

@@ -19,7 +19,6 @@ export declare class ChainService {
     private store;
     private assetSettingSubject;
     private logger;
-    private refreshChainStateTimeout;
     constructor(dbService: DatabaseService, eventService: EventService);
     getXcmRefMap(): Record<string, _AssetRef>;
     getEvmApi(slug: string): _EvmApi;
@@ -92,8 +91,10 @@ export declare class ChainService {
     refreshEvmApi(slug: string): void;
     stopAllChainApis(): Promise<void[]>;
     resumeAllChainApis(): Promise<void[]>;
+    private refreshChainStateTimeout;
+    private refreshChainStateTimes;
     private refreshChainStateInterval;
-    private updateApiMapStatus;
+    updateApiMapStatus(): Promise<void>;
     initAssetSettings(): Promise<void>;
     setAssetSettings(assetSettings: Record<string, AssetSetting>, emitEvent?: boolean): void;
     getStoreAssetSettings(): Promise<Record<string, AssetSetting>>;

package/services/chain-service/index.js

@@ -3,7 +3,6 @@
 
 import { AssetRefMap, ChainAssetMap, ChainInfoMap, MultiChainAssetMap } from '@subwallet/chain-list';
 import { _AssetRefPath, _AssetType, _ChainStatus, _SubstrateChainType } from '@subwallet/chain-list/types';
-import { CRON_GET_API_MAP_STATUS } from '@subwallet/extension-base/constants';
 import { _DEFAULT_ACTIVE_CHAINS } from '@subwallet/extension-base/services/chain-service/constants';
 import { EvmChainHandler } from '@subwallet/extension-base/services/chain-service/handler/EvmChainHandler';
 import { SubstrateChainHandler } from '@subwallet/extension-base/services/chain-service/handler/SubstrateChainHandler';
@@ -44,7 +43,7 @@ export class ChainService {
     this.multiChainAssetMapSubject.next(MultiChainAssetMap);
     this.xcmRefMapSubject.next(this.getXcmRefMap());
     this.logger = createLogger('chain-service');
-    this.refreshChainStateInterval(3000);
+    this.refreshChainStateInterval(3000, 6);
   }
 
   // Getter
@@ -277,7 +276,7 @@ export class ChainService {
     this.dbService.removeFromChainStore([slug]).catch(console.error);
     this.updateChainSubscription();
     this.lockChainInfoMap = false;
-    this.eventService.emit('chain.remove', slug);
+    this.eventService.emit('chain.updateState', slug);
     return true;
   }
   resetChainInfoMap(excludedChains) {
@@ -343,7 +342,7 @@ export class ChainService {
     this.dbService.removeFromAssetStore(targetAssets).catch(e => this.logger.error(e));
     this.assetRegistrySubject.next(assetRegistry);
     targetAssets.forEach(assetSlug => {
-      this.eventService.emit('asset.remove', assetSlug);
+      this.eventService.emit('asset.updateState', assetSlug);
     });
   }
 
@@ -407,14 +406,14 @@ export class ChainService {
     this.lockChainInfoMap = true;
     chainStateMap[chainSlug].active = true;
     this.initApiForChain(chainInfo);
-    this.refreshChainStateInterval(1000);
+    this.refreshChainStateInterval(3000, 6);
     this.dbService.updateChainStore({
       ...chainInfo,
       active: true,
       currentProvider: chainStateMap[chainSlug].currentProvider
     }).catch(console.error);
     this.lockChainInfoMap = false;
-    this.eventService.emit('chain.enable', chainSlug);
+    this.eventService.emit('chain.updateState', chainSlug);
     return true;
   }
   enableChain(chainSlug) {
@@ -449,7 +448,7 @@ export class ChainService {
     }).catch(console.error);
     this.updateChainStateMapSubscription();
     this.lockChainInfoMap = false;
-    this.eventService.emit('chain.disable', chainSlug);
+    this.eventService.emit('chain.updateState', chainSlug);
     return true;
   }
   checkExistedPredefinedChain(genesisHash, evmChainId) {
@@ -672,7 +671,7 @@ export class ChainService {
       active: targetChainState.active,
       currentProvider: targetChainState.currentProvider
     }).then(() => {
-      this.eventService.emit('chain.update', chainSlug);
+      this.eventService.emit('chain.updateState', chainSlug);
     }).catch(e => this.logger.error(e));
   }
   insertChain(params) {
@@ -961,21 +960,23 @@ export class ChainService {
   }
   async validateCustomToken(data) {
     const assetRegistry = this.getSmartContractTokens();
-    let isExist = false;
+    let existedToken;
     for (const token of Object.values(assetRegistry)) {
       var _token$metadata2;
       const contractAddress = token === null || token === void 0 ? void 0 : (_token$metadata2 = token.metadata) === null || _token$metadata2 === void 0 ? void 0 : _token$metadata2.contractAddress;
       if (_isEqualContractAddress(contractAddress, data.contractAddress) && token.assetType === data.type && token.originChain === data.originChain) {
-        isExist = true;
+        existedToken = token;
         break;
       }
     }
-    if (isExist) {
+    if (existedToken) {
+      var _existedToken;
       return {
-        decimals: -1,
-        name: '',
-        symbol: '',
-        isExist,
+        decimals: existedToken.decimals || 0,
+        name: existedToken.name,
+        symbol: existedToken.symbol,
+        isExist: !!existedToken,
+        existedSlug: (_existedToken = existedToken) === null || _existedToken === void 0 ? void 0 : _existedToken.slug,
         contractError: false
       };
     }
@@ -989,7 +990,7 @@ export class ChainService {
       name,
       decimals,
       symbol,
-      isExist,
+      isExist: !!existedToken,
       contractError
     };
   }
@@ -1039,19 +1040,26 @@ export class ChainService {
 
     return this.substrateChainHandler.resumeAllApis();
   }
-
-  // Interval update api status
-  refreshChainStateInterval(delay = 0) {
+  refreshChainStateTimeout = undefined;
+  refreshChainStateTimes = 0;
+  refreshChainStateInterval(delay = 0, times) {
     clearTimeout(this.refreshChainStateTimeout);
     setTimeout(() => {
-      this.updateApiMapStatus();
+      if (times) {
+        this.refreshChainStateTimes = times;
+      }
+      this.refreshChainStateTimes -= 1;
+      if (this.refreshChainStateTimes < 0) {
+        return;
+      }
+      this.updateApiMapStatus().catch(console.error);
       this.refreshChainStateTimeout = setTimeout(() => {
-        this.updateApiMapStatus();
-        this.refreshChainStateInterval();
-      }, CRON_GET_API_MAP_STATUS);
+        this.updateApiMapStatus().catch(console.error);
+        this.refreshChainStateInterval(0);
+      }, 3000);
     }, delay);
   }
-  updateApiMapStatus() {
+  async updateApiMapStatus() {
     const substrateApiMap = this.getSubstrateApiMap();
     const evmApiMap = this.getEvmApiMap();
     const chainStateMap = this.getChainStateMap();
@@ -1062,24 +1070,30 @@ export class ChainService {
         update = true;
       }
     }
-    Object.entries(chainStateMap).forEach(([chain, chainState]) => {
-      if (chainState.active) {
-        if (substrateApiMap[chain]) {
-          const api = substrateApiMap[chain];
-          if (api) {
-            updateState(chainState, _ChainConnectionStatus.CONNECTED);
-            return;
-          }
-        } else if (evmApiMap[chain]) {
-          const api = evmApiMap[chain];
-          if (api) {
-            updateState(chainState, _ChainConnectionStatus.CONNECTED);
-            return;
+    const promiseList = Object.entries(chainStateMap).map(async ([chain, chainState]) => {
+      try {
+        if (chainState.active) {
+          if (substrateApiMap[chain]) {
+            const api = substrateApiMap[chain];
+            if (api.isApiConnected) {
+              updateState(chainState, _ChainConnectionStatus.CONNECTED);
+              return;
+            }
+          } else if (evmApiMap[chain]) {
+            var _api$api;
+            const api = evmApiMap[chain];
+            if (await (api === null || api === void 0 ? void 0 : (_api$api = api.api) === null || _api$api === void 0 ? void 0 : _api$api.eth.net.isListening())) {
+              updateState(chainState, _ChainConnectionStatus.CONNECTED);
+              return;
+            }
           }
         }
+        updateState(chainState, _ChainConnectionStatus.DISCONNECTED);
+      } catch (e) {
+        updateState(chainState, _ChainConnectionStatus.DISCONNECTED);
       }
-      updateState(chainState, _ChainConnectionStatus.DISCONNECTED);
     });
+    await Promise.all(promiseList);
     if (update) {
       console.log('Update chain connection state');
       this.chainStateMapSubject.next(chainStateMap);
@@ -1105,7 +1119,6 @@ export class ChainService {
       this.setAssetSettings(assetSettings, false);
     }
     this.eventService.emit('asset.ready', true);
-    console.log('Done init asset settings');
   }
   setAssetSettings(assetSettings, emitEvent = true) {
     const updateAssets = [];
@@ -1119,7 +1132,7 @@ export class ChainService {
     }
     this.assetSettingSubject.next(assetSettings);
     updateAssets.forEach(slug => {
-      this.eventService.emit(assetSettings[slug].visible ? 'asset.enable' : 'asset.disable', slug);
+      this.eventService.emit('asset.updateState', slug);
     });
     this.store.set('AssetSetting', assetSettings);
   }

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

@@ -104,6 +104,7 @@ export interface _SmartContractTokenInfo {
 }
 export interface _ValidateCustomAssetResponse extends _SmartContractTokenInfo {
     isExist: boolean;
+    existedSlug?: string;
 }
 export declare const _FUNGIBLE_CONTRACT_STANDARDS: _AssetType[];
 export declare const _NFT_CONTRACT_STANDARDS: _AssetType[];

package/services/event-service/index.js

@@ -34,7 +34,11 @@ export class EventService extends EventEmitter {
     }, this.lazyTime);
   }
   emitLazy() {
-    this.lazyEmitter.emit('lazy', this.pendingEvents, this.pendingEvents.map(e => e.type));
+    try {
+      this.lazyEmitter.emit('lazy', this.pendingEvents, this.pendingEvents.map(e => e.type));
+    } catch (e) {
+      console.error('Get error in some listener of lazy event', e);
+    }
     this.pendingEvents = [];
     this.timeoutId = null;
   }

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

@@ -9,20 +9,16 @@ export interface EventRegistry {
     'account.remove': [string];
     'chain.ready': [boolean];
     'chain.add': [string];
-    'chain.update': [string];
-    'chain.disable': [string];
-    'chain.enable': [string];
-    'chain.remove': [string];
+    'chain.updateState': [string];
     'asset.ready': [boolean];
-    'asset.add': [string];
-    'asset.update': [string];
-    'asset.enable': [string];
-    'asset.disable': [string];
-    'asset.remove': [string];
+    'asset.updateState': [string];
     'transaction.done': [SWTransaction];
     'transaction.failed': [SWTransaction | undefined];
+    'transaction.submitStaking': [string];
+    'transaction.transferNft': [SWTransaction | undefined];
 }
 export declare type EventType = keyof EventRegistry;
+export declare const COMMON_RELOAD_EVENTS: EventType[];
 export interface EventItem<T extends EventType> {
     type: T;
     data: EventRegistry[T];

package/services/event-service/types.js

@@ -1 +1,4 @@
-export {};
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+export const COMMON_RELOAD_EVENTS = ['account.updateCurrent', 'asset.updateState', 'account.add', 'chain.updateState', 'account.remove', 'chain.add'];

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

@@ -1,14 +1,16 @@
 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 { KeyringService } from '@subwallet/extension-base/services/keyring-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 keyringService;
     private historySubject;
-    constructor(dbService: DatabaseService, chainService: ChainService, eventService: EventService);
+    constructor(dbService: DatabaseService, chainService: ChainService, eventService: EventService, keyringService: KeyringService);
     private fetchPromise;
     private nextFetch;
     private fetchAndLoadHistories;
@@ -17,8 +19,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>[]>>;
-    insertHistories(historyItems: TransactionHistoryItem[]): Promise<void>;
     updateHistories(chain: string, extrinsicHash: string, updateData: Partial<TransactionHistoryItem>): Promise<void>;
+    insertHistories(historyItems: TransactionHistoryItem[]): Promise<void>;
     addHistoryItems(historyItems: TransactionHistoryItem[]): Promise<void>;
     removeHistoryByAddress(address: string): Promise<void>;
 }

package/services/history-service/index.js

@@ -2,17 +2,16 @@
 // 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, eventService) {
+  constructor(dbService, chainService, eventService, keyringService) {
     this.dbService = dbService;
     this.chainService = chainService;
     this.eventService = eventService;
+    this.keyringService = keyringService;
     // Load history from database
     this.dbService.getHistories().then(histories => {
       this.historySubject.next(histories);
@@ -41,7 +40,7 @@ export class HistoryService {
     const historyRecords = await fetchMultiChainHistories(addresses, chainMap);
 
     // Fill additional info
-    const accountMap = Object.entries(accounts.subject.value).reduce((map, [address, account]) => {
+    const accountMap = Object.entries(this.keyringService.accounts).reduce((map, [address, account]) => {
       map[address.toLowerCase()] = account.json.meta.name || address;
       return map;
     }, {});
@@ -50,7 +49,7 @@ 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()];
     });
-    this.dbService.upsertHistory(historyRecords).catch(console.error);
+    await this.addHistoryItems(historyRecords);
     return historyRecords;
   }
   async fetchHistories(addresses) {
@@ -75,8 +74,8 @@ export class HistoryService {
     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);
+      await this.fetchHistories(addressList);
+      this.historySubject.next(await this.dbService.getHistories());
     }
     return this.historySubject.getValue();
   }
@@ -84,10 +83,6 @@ export class HistoryService {
     await this.getHistories();
     return this.historySubject;
   }
-  async insertHistories(historyItems) {
-    await this.dbService.upsertHistory(historyItems);
-    this.historySubject.next(await this.dbService.getHistories());
-  }
   async updateHistories(chain, extrinsicHash, updateData) {
     const existedRecords = await this.dbService.getHistories({
       chain,
@@ -101,14 +96,25 @@ export class HistoryService {
     });
     await this.addHistoryItems(updatedRecords);
   }
+
+  // Insert history without check override origin 'app'
+  async insertHistories(historyItems) {
+    await this.dbService.upsertHistory(historyItems);
+    this.historySubject.next(await this.dbService.getHistories());
+  }
+
+  // Insert history with check override origin 'app'
   async addHistoryItems(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}`;
+      return `${item.chain}-${item.extrinsicHash}`;
     });
     const updateRecords = historyItems.filter(item => {
-      const key = `${item.chain}-${quickFormatAddressToCompare(item.address) || ''}-${item.extrinsicHash}`;
+      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);

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

@@ -57,11 +57,15 @@ function autoFormatAddress(address) {
     return '';
   }
 }
-function generateSignature({
-  r,
-  s,
-  v
-}) {
+function generateSignature(input) {
+  if (!input) {
+    return '';
+  }
+  const {
+    r,
+    s,
+    v
+  } = input;
   const rHex = r.startsWith('0x') ? r.slice(2) : r;
   const sHex = s.startsWith('0x') ? s.slice(2) : s;
   const vHex = parseInt(v).toString(16);
@@ -107,7 +111,7 @@ export function parseSubsquidTransactionData(address, type, historyItem, chainIn
         const transaction = data.call.data.args.transaction.value;
         to = autoFormatAddress(parsedArgs.to);
         from = autoFormatAddress(parsedArgs.from);
-        extrinsicHash = parsedArgs.transactionHash;
+        extrinsicHash = parsedArgs.transactionHash || extrinsic.hash;
         amount = transaction.value || '0';
         fee = (parseInt(transaction.gasPrice) * parseInt(transaction.gasLimit)).toString();
         signature = generateSignature(transaction.signature);
@@ -243,14 +247,14 @@ export async function fetchMultiChainHistories(addresses, chainMap, maxPage = 25
       console.warn(`Not found chain info for chain id: ${chainId}`);
       return;
     }
-    try {
-      usedAddresses.forEach(address => {
+    usedAddresses.forEach(address => {
+      try {
         const transactionData = parseSubsquidTransactionData(address, name, historyItem, chainInfo, parseData(args), parseData(_data));
         histories.push(transactionData);
-      });
-    } catch (e) {
-      console.warn('Parse transaction data failed', e);
-    }
+      } catch (e) {
+        console.warn('Parse transaction data failed', address, e);
+      }
+    });
   });
   return histories;
 }

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

@@ -3,17 +3,19 @@ import { EventService } from '@subwallet/extension-base/services/event-service';
 import { SubjectInfo } from '@subwallet/ui-keyring/observable/types';
 import { BehaviorSubject } from 'rxjs';
 export declare class KeyringService {
+    private eventService;
     private readonly currentAccountStore;
     readonly currentAccountSubject: BehaviorSubject<CurrentAccountInfo>;
-    readonly accountsSubject: BehaviorSubject<SubjectInfo>;
+    readonly addressesSubject: BehaviorSubject<SubjectInfo>;
+    readonly accountSubject: BehaviorSubject<SubjectInfo>;
     private beforeAccount;
     readonly keyringStateSubject: BehaviorSubject<KeyringState>;
-    private eventService;
     constructor(eventService: EventService);
     private subscribeAccounts;
     get keyringState(): KeyringState;
     updateKeyringState(isReady?: boolean): void;
     get accounts(): SubjectInfo;
+    get addresses(): SubjectInfo;
     get currentAccount(): CurrentAccountInfo;
     setCurrentAccount(currentAccountData: CurrentAccountInfo): void;
 }

package/services/keyring-service/index.js

@@ -10,8 +10,9 @@ export class KeyringService {
     address: '',
     currentGenesisHash: null
   });
-  accountsSubject = keyring.accounts.subject;
-  beforeAccount = keyring.accounts.subject.value;
+  addressesSubject = keyring.addresses.subject;
+  accountSubject = keyring.accounts.subject;
+  beforeAccount = this.accountSubject.value;
   keyringStateSubject = new BehaviorSubject({
     isReady: false,
     hasMasterPassword: false,
@@ -20,23 +21,17 @@ export class KeyringService {
   constructor(eventService) {
     this.eventService = eventService;
     this.currentAccountStore.get('CurrentAccountInfo', rs => {
-      this.currentAccountSubject.next(rs);
+      rs && this.currentAccountSubject.next(rs);
     });
     this.subscribeAccounts().catch(console.error);
   }
   async subscribeAccounts() {
     // Wait until account ready
-    await new Promise(resolve => {
-      const onReady = () => {
-        this.eventService.off('account.ready', onReady);
-        resolve(true);
-      };
-      this.eventService.on('account.ready', onReady);
-    });
+    await this.eventService.waitAccountReady;
     this.beforeAccount = {
-      ...this.accountsSubject.value
+      ...this.accountSubject.value
     };
-    this.accountsSubject.subscribe(subjectInfo => {
+    this.accountSubject.subscribe(subjectInfo => {
       // Check if accounts changed
       const beforeAddresses = Object.keys(this.beforeAccount);
       const afterAddresses = Object.keys(subjectInfo);
@@ -80,7 +75,10 @@ export class KeyringService {
     });
   }
   get accounts() {
-    return this.accountsSubject.value;
+    return this.accountSubject.value;
+  }
+  get addresses() {
+    return this.addressesSubject.value;
   }
   get currentAccount() {
     return this.currentAccountSubject.value;

package/services/price-service/coingecko.js

@@ -16,7 +16,6 @@ export const getTokenPrice = async (priceIds, currency = 'usd') => {
       }
     }
     if (useBackupApi || ((_res = res) === null || _res === void 0 ? void 0 : _res.status) !== 200) {
-      console.log('Use backup api for price');
       useBackupApi = true;
       res = await axios.get(`https://chain-data.subwallet.app/api/price/get?ids=${idStr}`);
     }

package/services/price-service/index.js

@@ -31,8 +31,8 @@ export class PriceService {
     };
     this.eventService.waitAssetReady.then(() => {
       this.refreshPriceData();
-      this.eventService.on('asset.enable', eventHandler);
-      this.eventService.on('asset.update', eventHandler);
+      this.eventService.on('asset.updateState', eventHandler);
+      this.eventService.on('asset.updateState', eventHandler);
     }).catch(console.error);
   }
   async getPrice() {
@@ -62,7 +62,6 @@ export class PriceService {
         ready: true
       });
       this.dbService.updatePriceStore(rs).catch(console.error);
-      console.log('Get Token Price From CoinGecko');
     }).catch(console.error);
     this.refreshTimeout = setTimeout(this.refreshPriceData.bind(this), CRON_REFRESH_PRICE_INTERVAL);
   }

package/services/request-service/handler/AuthRequestHandler.d.ts

@@ -2,17 +2,19 @@ import { _ChainInfo } from '@subwallet/chain-list/types';
 import { AuthRequestV2 } from '@subwallet/extension-base/background/KoniTypes';
 import { AccountAuthType, AuthorizeRequest, RequestAuthorizeTab } from '@subwallet/extension-base/background/types';
 import { ChainService } from '@subwallet/extension-base/services/chain-service';
+import { KeyringService } from '@subwallet/extension-base/services/keyring-service';
 import RequestService from '@subwallet/extension-base/services/request-service';
 import { AuthUrls } from '@subwallet/extension-base/services/request-service/types';
 import { BehaviorSubject, Subject } from 'rxjs';
 export default class AuthRequestHandler {
     #private;
+    private keyringService;
     private readonly authorizeStore;
     private authorizeCached;
     private readonly authorizeUrlSubject;
     private readonly evmChainSubject;
     readonly authSubjectV2: BehaviorSubject<AuthorizeRequest[]>;
-    constructor(requestService: RequestService, chainService: ChainService);
+    constructor(requestService: RequestService, chainService: ChainService, keyringService: KeyringService);
     private stripUrl;
     private getAddressList;
     get numAuthRequestsV2(): number;

package/services/request-service/handler/AuthRequestHandler.js

@@ -6,7 +6,6 @@ import { PREDEFINED_CHAIN_DAPP_CHAIN_MAP } from '@subwallet/extension-base/servi
 import AuthorizeStore from '@subwallet/extension-base/stores/Authorize';
 import { getDomainFromUrl } from '@subwallet/extension-base/utils';
 import { getId } from '@subwallet/extension-base/utils/getId';
-import { accounts } from '@subwallet/ui-keyring/observable/accounts';
 import { BehaviorSubject, Subject } from 'rxjs';
 import { assert } from '@polkadot/util';
 import { isEthereumAddress } from '@polkadot/util-crypto';
@@ -20,7 +19,8 @@ export default class AuthRequestHandler {
   authorizeUrlSubject = new Subject();
   evmChainSubject = new Subject();
   authSubjectV2 = new BehaviorSubject([]);
-  constructor(requestService, chainService) {
+  constructor(requestService, chainService, keyringService) {
+    this.keyringService = keyringService;
     this.#requestService = requestService;
     this.#chainService = chainService;
   }
@@ -30,7 +30,7 @@ export default class AuthRequestHandler {
     return parts[2];
   }
   getAddressList(value = false) {
-    const addressList = Object.keys(accounts.subject.value);
+    const addressList = Object.keys(this.keyringService.accounts);
     return addressList.reduce((addressList, v) => ({
       ...addressList,
       [v]: value
@@ -84,11 +84,11 @@ export default class AuthRequestHandler {
     const chainInfoMaps = this.#chainService.getChainInfoMap();
     const chainStateMap = this.#chainService.getChainStateMap();
     let defaultChain = options.defaultChain;
-    const needEnableChains = [];
+    let needEnableChains = [];
     if (options.url) {
       const domain = getDomainFromUrl(options.url);
       const predefinedSupportChains = PREDEFINED_CHAIN_DAPP_CHAIN_MAP[domain];
-      if (predefinedSupportChains) {
+      if (!defaultChain && predefinedSupportChains) {
         defaultChain = predefinedSupportChains[0];
         options.autoActive && needEnableChains.push(...predefinedSupportChains);
       }
@@ -101,11 +101,17 @@ export default class AuthRequestHandler {
         return (_chainStateMap$chain$ = chainStateMap[chain.slug]) === null || _chainStateMap$chain$ === void 0 ? void 0 : _chainStateMap$chain$.active;
       })) || evmChains[0];
       if (options.autoActive) {
-        if (!needEnableChains.includes(chainInfo.slug)) {
-          needEnableChains.push(chainInfo.slug);
+        var _chainInfo;
+        if (!needEnableChains.includes((_chainInfo = chainInfo) === null || _chainInfo === void 0 ? void 0 : _chainInfo.slug)) {
+          var _chainInfo2;
+          needEnableChains.push((_chainInfo2 = chainInfo) === null || _chainInfo2 === void 0 ? void 0 : _chainInfo2.slug);
         }
       }
     }
+    needEnableChains = needEnableChains.filter(slug => {
+      var _chainStateMap$slug;
+      return !((_chainStateMap$slug = chainStateMap[slug]) !== null && _chainStateMap$slug !== void 0 && _chainStateMap$slug.active);
+    });
     needEnableChains.length > 0 && this.#chainService.enableChains(needEnableChains);
     return chainInfo;
   }