@subwallet/extension-base 1.0.1 → 1.0.2-1

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

@@ -108,10 +108,15 @@ export function parseSubsquidTransactionData(address, type, historyItem, chainIn
         to = autoFormatAddress(parsedArgs.to);
         from = autoFormatAddress(parsedArgs.from);
         extrinsicHash = parsedArgs.transactionHash;
-        amount = transaction.value;
+        amount = transaction.value || '0';
         fee = (parseInt(transaction.gasPrice) * parseInt(transaction.gasLimit)).toString();
         signature = generateSignature(transaction.signature);
         success = extrinsic.success;
+
+        // Special fix for moonbeam
+        if ((historyItem.chainId === 'moonbeam' || historyItem.chainId === 'moonriver') && typeof amount === 'object') {
+          amount = amount[0];
+        }
         break;
       }
 
@@ -156,7 +161,7 @@ export function parseSubsquidTransactionData(address, type, historyItem, chainIn
   }
   return {
     address,
-    origin: MULTI_CHAIN_URL,
+    origin: 'subsquid',
     time: toTimestamp(historyItem.timestamp),
     chainType,
     from,

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

@@ -0,0 +1,19 @@
+import { CurrentAccountInfo, KeyringState } from '@subwallet/extension-base/background/KoniTypes';
+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 readonly currentAccountStore;
+    readonly currentAccountSubject: BehaviorSubject<CurrentAccountInfo>;
+    readonly accountsSubject: 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 currentAccount(): CurrentAccountInfo;
+    setCurrentAccount(currentAccountData: CurrentAccountInfo): void;
+}

package/services/keyring-service/index.js

@@ -0,0 +1,93 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+import { CurrentAccountStore } from '@subwallet/extension-base/stores';
+import { keyring } from '@subwallet/ui-keyring';
+import { BehaviorSubject } from 'rxjs';
+export class KeyringService {
+  currentAccountStore = new CurrentAccountStore();
+  currentAccountSubject = new BehaviorSubject({
+    address: '',
+    currentGenesisHash: null
+  });
+  accountsSubject = keyring.accounts.subject;
+  beforeAccount = keyring.accounts.subject.value;
+  keyringStateSubject = new BehaviorSubject({
+    isReady: false,
+    hasMasterPassword: false,
+    isLocked: false
+  });
+  constructor(eventService) {
+    this.eventService = eventService;
+    this.currentAccountStore.get('CurrentAccountInfo', 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);
+    });
+    this.beforeAccount = {
+      ...this.accountsSubject.value
+    };
+    this.accountsSubject.subscribe(subjectInfo => {
+      // Check if accounts changed
+      const beforeAddresses = Object.keys(this.beforeAccount);
+      const afterAddresses = Object.keys(subjectInfo);
+      if (beforeAddresses.length > afterAddresses.length) {
+        const removedAddresses = beforeAddresses.filter(address => !afterAddresses.includes(address));
+
+        // Remove account
+        removedAddresses.forEach(address => {
+          console.log('account.remove', address);
+          this.eventService.emit('account.remove', address);
+        });
+      } else if (beforeAddresses.length < afterAddresses.length) {
+        const addedAddresses = afterAddresses.filter(address => !beforeAddresses.includes(address));
+
+        // Add account
+        addedAddresses.forEach(address => {
+          console.log('account.add', address);
+          this.eventService.emit('account.add', address);
+        });
+      } else {
+        // Handle case update later
+      }
+      this.beforeAccount = {
+        ...subjectInfo
+      };
+    });
+  }
+  get keyringState() {
+    return this.keyringStateSubject.value;
+  }
+  updateKeyringState(isReady = true) {
+    var _keyring$keyring, _keyring$keyring2;
+    if (!this.keyringState.isReady && isReady) {
+      this.eventService.emit('keyring.ready', true);
+      this.eventService.emit('account.ready', true);
+    }
+    this.keyringStateSubject.next({
+      hasMasterPassword: !!((_keyring$keyring = keyring.keyring) !== null && _keyring$keyring !== void 0 && _keyring$keyring.hasMasterPassword),
+      isLocked: !!((_keyring$keyring2 = keyring.keyring) !== null && _keyring$keyring2 !== void 0 && _keyring$keyring2.isLocked),
+      isReady: isReady
+    });
+  }
+  get accounts() {
+    return this.accountsSubject.value;
+  }
+  get currentAccount() {
+    return this.currentAccountSubject.value;
+  }
+  setCurrentAccount(currentAccountData) {
+    this.currentAccountSubject.next(currentAccountData);
+    this.eventService.emit('account.updateCurrent', currentAccountData);
+    this.currentAccountStore.set('CurrentAccountInfo', currentAccountData);
+  }
+}

package/services/migration-service/index.js

@@ -2,7 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import { logger as createLogger } from '@polkadot/util';
-import MigrationScripts from "./scripts/index.js";
+import MigrationScripts, { EVERYTIME } from "./scripts/index.js";
 export default class MigrationService {
   constructor(state) {
     this.state = state;
@@ -14,23 +14,25 @@ export default class MigrationService {
     try {
       for (let i = 0; i < keys.length; i++) {
         const JobClass = MigrationScripts[keys[i]];
+        const key = keys[i];
+        const name = JobClass.name;
         const check = await this.state.dbService.stores.migration.table.where({
-          name: JobClass.name,
-          key: keys[i]
+          name,
+          key
         }).first();
-        if (!check) {
-          const job = new JobClass(this.state);
+        if (!check || key.startsWith(EVERYTIME)) {
           this.logger.log('Running script: ', JobClass.name);
+          const job = new JobClass(this.state);
           await job.run();
           await this.state.dbService.stores.migration.table.put({
-            key: keys[i],
-            name: JobClass.name,
-            timestamp: +new Date()
+            key,
+            name,
+            timestamp: new Date().getTime()
           });
         }
       }
     } catch (error) {
-      this.logger.warn('Migration error: ', error);
+      this.logger.error('Migration error: ', error);
     }
     this.logger.log('Migration done.');
   }

package/services/migration-service/scripts/AutoEnableChainsTokens.d.ts

@@ -0,0 +1,4 @@
+import BaseMigrationJob from '@subwallet/extension-base/services/migration-service/Base';
+export default class AutoEnableChainsTokens extends BaseMigrationJob {
+    run(): Promise<void>;
+}

package/services/migration-service/scripts/AutoEnableChainsTokens.js

@@ -0,0 +1,13 @@
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import BaseMigrationJob from '@subwallet/extension-base/services/migration-service/Base';
+import { keyring } from '@subwallet/ui-keyring';
+export default class AutoEnableChainsTokens extends BaseMigrationJob {
+  async run() {
+    const accounts = keyring.getAccounts();
+    await this.state.autoEnableChains(accounts.map(({
+      address
+    }) => address));
+  }
+}

package/services/migration-service/scripts/MigrateNetworkSettings.js

@@ -1,30 +1,49 @@
 // Copyright 2019-2022 @subwallet/extension-koni authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
+import { _AssetType } from '@subwallet/chain-list/types';
 import BaseMigrationJob from '@subwallet/extension-base/services/migration-service/Base';
 export default class MigrateNetworkSettings extends BaseMigrationJob {
   async run() {
     const state = this.state;
-    return new Promise((resolve, reject) => {
-      chrome.storage.local.get('NetworkMap', function (items) {
-        if (items && items.NetworkMap) {
-          const networkMap = items.NetworkMap;
-          const enableList = [];
-          const stateMap = state.getChainStateMap();
-          Object.entries(networkMap).forEach(([slug, chain]) => {
-            if (chain.active) {
-              const currentState = stateMap[slug];
+    const items = await new Promise(resolve => {
+      chrome.storage.local.get('NetworkMap', items => {
+        resolve(items);
+      });
+    });
+    const oldNetworkMap = items.NetworkMap;
+    const enableList = [];
+    const stateMap = state.getChainStateMap();
+    if (!oldNetworkMap) {
+      return;
+    }
+    Object.entries(oldNetworkMap).forEach(([slug, chain]) => {
+      if (chain.active) {
+        const currentState = stateMap[slug];
+
+        // Ensure chain in the list and is not active
+        currentState && enableList.push(slug);
+      }
+    });
+    if (enableList.length > 0) {
+      state.chainService.enableChains(enableList);
 
-              // Ensure chain in the list and is not active
-              currentState && !currentState.active && enableList.push(slug);
-            }
-          });
-          if (enableList.length > 0) {
-            state.chainService.enableChains(enableList);
-          }
+      // Enable native token of these chains
+      const currentAssetSettings = await state.chainService.getAssetSettings();
+      const assetInfoMap = state.chainService.getAssetRegistry();
+      Object.entries(assetInfoMap).forEach(([slug, assetInfo]) => {
+        const assetSetting = currentAssetSettings[slug] || {};
+
+        // Enable native token of these chains
+        if (assetInfo.name && assetInfo.assetType === _AssetType.NATIVE && enableList.includes(assetInfo.originChain) && !assetSetting.visible) {
+          currentAssetSettings[slug] = {
+            visible: true
+          };
         }
-        resolve();
       });
-    });
+      state.chainService.setAssetSettings({
+        ...currentAssetSettings
+      });
+    }
   }
 }

package/services/migration-service/scripts/MigrateSettings.d.ts

@@ -0,0 +1,4 @@
+import BaseMigrationJob from '@subwallet/extension-base/services/migration-service/Base';
+export default class MigrateSettings extends BaseMigrationJob {
+    run(): Promise<void>;
+}

package/services/migration-service/scripts/MigrateSettings.js

@@ -0,0 +1,23 @@
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import BaseMigrationJob from '@subwallet/extension-base/services/migration-service/Base';
+import uiSettings from '@polkadot/ui-settings';
+export default class MigrateSettings extends BaseMigrationJob {
+  async run() {
+    try {
+      return new Promise(resolve => {
+        this.state.settingService.getSettings(currentSettings => {
+          const isAccessCamera = uiSettings.camera === 'on';
+          this.state.settingService.setSettings({
+            ...currentSettings,
+            camera: isAccessCamera
+          });
+          resolve();
+        });
+      });
+    } catch (e) {
+      console.error(e);
+    }
+  }
+}

package/services/migration-service/scripts/MigrateTransactionHistory.d.ts

@@ -0,0 +1,4 @@
+import BaseMigrationJob from '@subwallet/extension-base/services/migration-service/Base';
+export default class MigrateTransactionHistory extends BaseMigrationJob {
+    run(): Promise<void>;
+}

package/services/migration-service/scripts/MigrateTransactionHistory.js

@@ -0,0 +1,64 @@
+// 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 { _getChainNativeTokenBasicInfo } from '@subwallet/extension-base/services/chain-service/utils';
+import BaseMigrationJob from '@subwallet/extension-base/services/migration-service/Base';
+import Dexie from 'dexie';
+import { isEthereumAddress } from '@polkadot/util-crypto';
+export default class MigrateTransactionHistory extends BaseMigrationJob {
+  async run() {
+    const state = this.state;
+    const chainInfoMap = state.getChainInfoMap();
+    const assetList = Object.values(state.getAssetRegistry());
+    try {
+      const db = new Dexie('SubWalletDB');
+      const dexieDB = await db.open();
+      const transactionTable = dexieDB.table('transactions');
+      const oldTransactionData = await transactionTable.toArray();
+      const newTransactionItems = [];
+      oldTransactionData.forEach(item => {
+        const chainInfo = chainInfoMap[item.networkKey];
+        if (!chainInfo) {
+          return;
+        }
+        const direction = item.action === 'send' ? TransactionDirection.SEND : TransactionDirection.RECEIVED;
+        const extrinsicType = item.changeSymbol === item.feeSymbol ? ExtrinsicType.TRANSFER_BALANCE : ExtrinsicType.TRANSFER_TOKEN;
+        const nativeAsset = _getChainNativeTokenBasicInfo(chainInfo);
+        const transferAsset = assetList.find(a => a.originChain === item.networkKey && a.symbol === item.changeSymbol) || nativeAsset;
+        const newItem = {
+          chain: item.networkKey,
+          origin: 'migration',
+          type: extrinsicType,
+          address: item.address,
+          extrinsicHash: item.extrinsicHash,
+          time: item.time,
+          status: item.isSuccess ? ExtrinsicStatus.SUCCESS : ExtrinsicStatus.FAIL,
+          from: direction === TransactionDirection.SEND ? item.address : '',
+          to: direction === TransactionDirection.RECEIVED ? item.address : '',
+          amount: {
+            value: item.change,
+            decimals: transferAsset.decimals || 18,
+            symbol: transferAsset.symbol
+          },
+          fee: {
+            value: item.fee,
+            decimals: nativeAsset.decimals,
+            symbol: nativeAsset.symbol
+          },
+          direction: direction,
+          chainType: isEthereumAddress(item.address) ? ChainType.EVM : ChainType.SUBSTRATE,
+          chainName: chainInfo.name,
+          blockNumber: 0,
+          blockHash: '',
+          data: '',
+          signature: ''
+        };
+        newTransactionItems.push(newItem);
+      });
+      await state.historyService.addHistoryItems(newTransactionItems);
+    } catch (e) {
+      this.logger.error(e);
+    }
+  }
+}

package/services/migration-service/scripts/index.d.ts

@@ -1,3 +1,4 @@
 import BaseMigrationJob from '../Base';
+export declare const EVERYTIME = "__everytime__";
 declare const _default: Record<string, typeof BaseMigrationJob>;
 export default _default;

package/services/migration-service/scripts/index.js

@@ -1,10 +1,17 @@
 // Copyright 2019-2022 @subwallet/extension-koni authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
+import AutoEnableChainsTokens from '@subwallet/extension-base/services/migration-service/scripts/AutoEnableChainsTokens';
 import MigrateImportedToken from '@subwallet/extension-base/services/migration-service/scripts/MigrateImportedToken';
 import MigrateNetworkSettings from '@subwallet/extension-base/services/migration-service/scripts/MigrateNetworkSettings';
+import MigrateSettings from '@subwallet/extension-base/services/migration-service/scripts/MigrateSettings';
+import MigrateTransactionHistory from '@subwallet/extension-base/services/migration-service/scripts/MigrateTransactionHistory';
+export const EVERYTIME = '__everytime__';
 export default {
-  '1.0.1-1': MigrateNetworkSettings,
-  '1.0.1-2': MigrateImportedToken
-  // '1.0.1-0': ClearOldStorage
+  '1.0.1-11': MigrateNetworkSettings,
+  '1.0.1-20': MigrateImportedToken,
+  '1.0.1-30': MigrateTransactionHistory,
+  '1.0.1-40': AutoEnableChainsTokens,
+  '1.0.1-50': MigrateSettings
+  // [`${EVERYTIME}-1`]: AutoEnableChainsTokens
 };

package/services/price-service/coingecko.js

@@ -2,15 +2,28 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import axios from 'axios';
+let useBackupApi = false;
 export const getTokenPrice = async (priceIds, currency = 'usd') => {
   try {
+    var _res;
     const idStr = Array.from(priceIds).join(',');
-    // const res = await axios.get(`https://api.coingecko.com/api/v3/coins/markets?vs_currency=${currency}&per_page=250&ids=${idStr}`);
-    const res = await axios.get(`https://chain-data.subwallet.app/api/price/get?ids=${idStr}`);
+    let res;
+    if (!useBackupApi) {
+      try {
+        res = await axios.get(`https://api.coingecko.com/api/v3/coins/markets?vs_currency=${currency}&per_page=250&ids=${idStr}`);
+      } catch (err) {
+        useBackupApi = true;
+      }
+    }
+    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}`);
+    }
     if (res.status !== 200) {
       console.warn('Failed to get token price');
     }
-    const responseData = res.data;
+    const responseData = res.data || [];
     const priceMap = {};
     const price24hMap = {};
     responseData.forEach(val => {

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

@@ -1,14 +1,16 @@
-import { PriceJson, ServiceInfo } from '@subwallet/extension-base/background/KoniTypes';
+import { PriceJson } 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, Subject } from 'rxjs';
+import { BehaviorSubject } from 'rxjs';
 export declare class PriceService {
     private dbService;
+    private eventService;
     private chainService;
     private priceSubject;
     private refreshTimeout;
     private priceIds;
-    constructor(serviceInfoSubject: Subject<ServiceInfo>, dbService: DatabaseService, chainService: ChainService);
+    constructor(dbService: DatabaseService, eventService: EventService, chainService: ChainService);
     getPrice(): Promise<PriceJson>;
     getPriceSubject(): BehaviorSubject<PriceJson>;
     getPriceIds(): Set<string>;

package/services/price-service/index.js

@@ -13,27 +13,27 @@ const DEFAULT_PRICE_SUBJECT = {
 export class PriceService {
   priceSubject = new BehaviorSubject(DEFAULT_PRICE_SUBJECT);
   priceIds = new Set();
-  constructor(serviceInfoSubject, dbService, chainService) {
+  constructor(dbService, eventService, chainService) {
     this.dbService = dbService;
+    this.eventService = eventService;
     this.chainService = chainService;
 
     // Fetch data from storage
     this.getPrice().catch(console.error);
+    const eventHandler = () => {
+      const newPriceIds = this.getPriceIds();
 
-    // Add some delay to avoid fetching many times when start extension background
-    // Subscribe service info to update price list
-    setTimeout(() => {
+      // Compare two set newPriceIds and this.priceIds
+      if (newPriceIds.size !== this.priceIds.size || !Array.from(newPriceIds).every(v => this.priceIds.has(v))) {
+        this.priceIds = newPriceIds;
+        this.refreshPriceData(this.priceIds);
+      }
+    };
+    this.eventService.waitAssetReady.then(() => {
       this.refreshPriceData();
-      serviceInfoSubject.subscribe(serviceInfo => {
-        const newPriceIds = this.getPriceIds();
-
-        // Compare two set newPriceIds and this.priceIds
-        if (newPriceIds.size !== this.priceIds.size || !Array.from(newPriceIds).every(v => this.priceIds.has(v))) {
-          this.priceIds = newPriceIds;
-          this.refreshPriceData(this.priceIds);
-        }
-      });
-    }, 3000);
+      this.eventService.on('asset.enable', eventHandler);
+      this.eventService.on('asset.update', eventHandler);
+    }).catch(console.error);
   }
   async getPrice() {
     const isReady = this.priceSubject.value.ready;
@@ -63,9 +63,7 @@ export class PriceService {
       });
       this.dbService.updatePriceStore(rs).catch(console.error);
       console.log('Get Token Price From CoinGecko');
-    }).catch(e => {
-      // Pass
-    });
+    }).catch(console.error);
     this.refreshTimeout = setTimeout(this.refreshPriceData.bind(this), CRON_REFRESH_PRICE_INTERVAL);
   }
 }

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

@@ -1 +1,2 @@
 export declare const EXTENSION_REQUEST_URL = "extension";
+export declare const PREDEFINED_CHAIN_DAPP_CHAIN_MAP: Record<string, string[]>;

package/services/request-service/constants.js

@@ -1,4 +1,9 @@
 // Copyright 2019-2022 @subwallet/extension-base authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-export const EXTENSION_REQUEST_URL = 'extension';
+export const EXTENSION_REQUEST_URL = 'extension';
+export const PREDEFINED_CHAIN_DAPP_CHAIN_MAP = {
+  'portal.astar.network': ['astar', 'astarEvm'],
+  'apps.moonbeam.network': ['moonbeam', 'moonriver'],
+  'app.stellaswap.com': ['moonbeam']
+};

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

@@ -1,5 +1,6 @@
+import { _ChainInfo } from '@subwallet/chain-list/types';
 import { AuthRequestV2 } from '@subwallet/extension-base/background/KoniTypes';
-import { AuthorizeRequest, RequestAuthorizeTab } from '@subwallet/extension-base/background/types';
+import { AccountAuthType, AuthorizeRequest, RequestAuthorizeTab } from '@subwallet/extension-base/background/types';
 import { ChainService } from '@subwallet/extension-base/services/chain-service';
 import RequestService from '@subwallet/extension-base/services/request-service';
 import { AuthUrls } from '@subwallet/extension-base/services/request-service/types';
@@ -20,6 +21,12 @@ export default class AuthRequestHandler {
     setAuthorize(data: AuthUrls, callback?: () => void): void;
     getAuthorize(update: (value: AuthUrls) => void): void;
     getAuthList(): Promise<AuthUrls>;
+    getDAppChainInfo(options: {
+        accessType: AccountAuthType;
+        autoActive?: boolean;
+        defaultChain?: string;
+        url?: string;
+    }): _ChainInfo | undefined;
     private authCompleteV2;
     authorizeUrlV2(url: string, request: RequestAuthorizeTab): Promise<boolean>;
     getAuthRequestV2(id: string): AuthRequestV2;

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

@@ -1,8 +1,10 @@
 // Copyright 2019-2022 @subwallet/extension-base authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import { _isChainEnabled, _isChainEvmCompatible } from '@subwallet/extension-base/services/chain-service/utils';
+import { _isChainEvmCompatible } from '@subwallet/extension-base/services/chain-service/utils';
+import { PREDEFINED_CHAIN_DAPP_CHAIN_MAP } from '@subwallet/extension-base/services/request-service/constants';
 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';
@@ -78,9 +80,39 @@ export default class AuthRequestHandler {
       });
     });
   }
-  authCompleteV2 = (id, resolve, reject) => {
+  getDAppChainInfo(options) {
+    const chainInfoMaps = this.#chainService.getChainInfoMap();
+    const chainStateMap = this.#chainService.getChainStateMap();
+    let defaultChain = options.defaultChain;
+    const needEnableChains = [];
+    if (options.url) {
+      const domain = getDomainFromUrl(options.url);
+      const predefinedSupportChains = PREDEFINED_CHAIN_DAPP_CHAIN_MAP[domain];
+      if (predefinedSupportChains) {
+        defaultChain = predefinedSupportChains[0];
+        options.autoActive && needEnableChains.push(...predefinedSupportChains);
+      }
+    }
+    let chainInfo;
+    if (['both', 'evm'].includes(options.accessType)) {
+      const evmChains = Object.values(chainInfoMaps).filter(_isChainEvmCompatible);
+      chainInfo = (defaultChain ? chainInfoMaps[defaultChain] : evmChains.find(chain => {
+        var _chainStateMap$chain$;
+        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);
+        }
+      }
+    }
+    needEnableChains.length > 0 && this.#chainService.enableChains(needEnableChains);
+    return chainInfo;
+  }
+  authCompleteV2 = (id, url, resolve, reject) => {
     const isAllowedMap = this.getAddressList();
     const complete = (result, cb, accounts) => {
+      var _this$getDAppChainInf;
       const isAllowed = result === true;
       let isCancelled = false;
       if (!isAllowed && typeof result === 'object' && result.message === 'Cancelled') {
@@ -113,16 +145,11 @@ export default class AuthRequestHandler {
           isAllowedMap[acc] = true;
         });
       }
-      let defaultEvmNetworkKey;
-      if (accountAuthType === 'both' || accountAuthType === 'evm') {
-        const defaultChain = Object.values(this.#chainService.getChainInfoMap()).find(chainInfo => {
-          const chainState = this.#chainService.getChainStateByKey(chainInfo.slug);
-          return _isChainEvmCompatible(chainInfo) && _isChainEnabled(chainState);
-        });
-        if (defaultChain) {
-          defaultEvmNetworkKey = defaultChain.slug;
-        }
-      }
+      const defaultEvmNetworkKey = (_this$getDAppChainInf = this.getDAppChainInfo({
+        accessType: accountAuthType,
+        url,
+        autoActive: !isCancelled && isAllowed
+      })) === null || _this$getDAppChainInf === void 0 ? void 0 : _this$getDAppChainInf.slug;
       this.getAuthorize(value => {
         let authorizeList = {};
         if (value) {
@@ -209,7 +236,7 @@ export default class AuthRequestHandler {
     return new Promise((resolve, reject) => {
       const id = getId();
       this.#authRequestsV2[id] = {
-        ...this.authCompleteV2(id, resolve, reject),
+        ...this.authCompleteV2(id, url, resolve, reject),
         id,
         idStr,
         request,

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

@@ -1,5 +1,5 @@
 import { AuthRequestV2, ConfirmationDefinitions, ConfirmationsQueue, ConfirmationsQueueItemOptions, ConfirmationType, RequestConfirmationComplete } from '@subwallet/extension-base/background/KoniTypes';
-import { AccountJson, AuthorizeRequest, MetadataRequest, RequestAuthorizeTab, RequestSign, ResponseSigning, SigningRequest } from '@subwallet/extension-base/background/types';
+import { AccountAuthType, AccountJson, AuthorizeRequest, MetadataRequest, RequestAuthorizeTab, RequestSign, ResponseSigning, SigningRequest } from '@subwallet/extension-base/background/types';
 import { ChainService } from '@subwallet/extension-base/services/chain-service';
 import { AuthUrls, MetaRequest } from '@subwallet/extension-base/services/request-service/types';
 import SettingService from '@subwallet/extension-base/services/setting-service/SettingService';
@@ -29,6 +29,12 @@ export default class RequestService {
     getAuthList(): Promise<AuthUrls>;
     authorizeUrlV2(url: string, request: RequestAuthorizeTab): Promise<boolean>;
     getAuthRequestV2(id: string): AuthRequestV2;
+    getDAppChainInfo(options: {
+        accessType: AccountAuthType;
+        autoActive?: boolean;
+        defaultChain?: string;
+        url?: string;
+    }): import("@subwallet/chain-list/types")._ChainInfo | undefined;
     get subscribeEvmChainChange(): Subject<AuthUrls>;
     get subscribeAuthorizeUrlSubject(): Subject<AuthUrls>;
     ensureUrlAuthorizedV2(url: string): Promise<boolean>;