@web3auth/no-modal 11.0.2 → 11.2.0

package/dist/lib.esm/connectors/metamask-connector/metamaskConnector.js

@@ -15,6 +15,7 @@ import { getCaipChainId, citadelServerUrl } from '../../base/utils.js';
 import { WalletLoginError, isUserRejectedError, WalletOperationsError, Web3AuthError } from '../../base/errors/index.js';
 import { ANALYTICS_EVENTS } from '../../base/analytics.js';
 import { getSolanaChainByChainConfig, walletSignMessage } from '../../base/wallet/solana.js';
+import { log } from '../../base/loglevel.js';
 import { BaseConnector } from '../../base/connector/baseConnector.js';
 import { CONNECTOR_CATEGORY, CONNECTOR_STATUS, CONNECTOR_EVENTS } from '../../base/connector/constants.js';
 
@@ -22,6 +23,11 @@ import { CONNECTOR_CATEGORY, CONNECTOR_STATUS, CONNECTOR_EVENTS } from '../../ba
  * Configuration options for the MetaMask connector using \@metamask/connect-evm
  */
 
+// `@metamask/connect-evm` announces its SDK-backed provider over EIP-6963 with this
+// RDNS value. Web3Auth uses the dedicated `metaMaskConnector` for MetaMask, so MIPD
+// discovery should ignore this provider to avoid treating the QR/deeplink transport
+// as a native injected wallet.
+const METAMASK_ERC_6963_PROVIDER_RDNS = "io.metamask.mmc";
 class MetaMaskConnector extends BaseConnector {
   constructor(connectorOptions) {
     super(connectorOptions);
@@ -197,13 +203,25 @@ class MetaMaskConnector extends BaseConnector {
     if (coreStatus === "connected" && options.autoConnect) {
       this.status = CONNECTOR_STATUS.CONNECTED;
       this.rehydrated = true;
+
+      // Force sync the chain state before connect with rehydrated state.
+      // during rehydration, `createEVMClient` (from above) cause re-creating session for connected the evm provider,
+      // triggering `switchChain` internally and unintentionally update the connector data with the new chain id.
+      // This creates issue in rehydration flow, where Web3Auth connects to the incorrect chain id, not the rehydrated chain id.
+      // Force sync the chain state with the rehydrated chain id to avoid this issue.
+      await this.forceSyncChainState(chainConfig);
       this.emit(CONNECTOR_EVENTS.CONNECTED, {
         connectorName: WALLET_CONNECTORS.METAMASK,
         reconnected: true,
         ethereumProvider: this.evmProvider,
-        solanaWallet: this.solanaProvider
+        solanaWallet: this.solanaProvider,
+        connectorNamespace: this.connectorNamespace
       });
-      if (options.getAuthTokenInfo) await this.getAuthTokenInfo(options.chainId);
+      try {
+        await this.authorizeOrDisconnect(options.getAuthTokenInfo, options.chainId);
+      } catch (error) {
+        this.emit(CONNECTOR_EVENTS.REHYDRATION_ERROR, error);
+      }
     } else if (coreStatus === "connected" || coreStatus === "loaded" || coreStatus === "disconnected" || coreStatus === "pending") {
       this.status = CONNECTOR_STATUS.READY;
       this.emit(CONNECTOR_EVENTS.READY, WALLET_CONNECTORS.METAMASK);
@@ -273,7 +291,7 @@ class MetaMaskConnector extends BaseConnector {
 
       // sync the chain state after connect
       // metamask might not be connected to the requested chain, so we need to sync the chain state to/from Web3Auth state after connect.
-      await this.syncChainStateAfterConnect(chainConfig);
+      await this.forceSyncChainState(chainConfig);
 
       // check if connected
       if (this.multichainClient.status !== "connected") {
@@ -293,15 +311,15 @@ class MetaMaskConnector extends BaseConnector {
         connectorName: WALLET_CONNECTORS.METAMASK,
         reconnected: this.rehydrated,
         ethereumProvider: this.evmProvider,
-        solanaWallet: this.solanaProvider
+        solanaWallet: this.solanaProvider,
+        connectorNamespace: this.connectorNamespace
       });
-      if (getAuthTokenInfo) {
-        await this.getAuthTokenInfo(chainId);
-      }
+      await this.authorizeOrDisconnect(getAuthTokenInfo, chainId);
       return {
         ethereumProvider: this.evmProvider,
         solanaWallet: this.solanaProvider,
-        connectorName: this.name
+        connectorName: this.name,
+        connectorNamespace: this.connectorNamespace
       };
     } catch (error) {
       // Ready again to be connected
@@ -327,10 +345,12 @@ class MetaMaskConnector extends BaseConnector {
   }) {
     if (!this.multichainClient) throw WalletLoginError.connectionError("Multichain client is not available");
     this.checkDisconnectionRequirements();
-    await this.clearWalletSession();
+    await this.clearMultichainWalletSessions();
 
     // Disconnect using the multichain client
-    await this.multichainClient.disconnect();
+    if (this.multichainClient.status === "connected") {
+      await this.multichainClient.disconnect();
+    }
     if (options.cleanup) {
       this.status = CONNECTOR_STATUS.NOT_READY;
       this.initializationPromise = null;
@@ -386,32 +406,41 @@ class MetaMaskConnector extends BaseConnector {
   }
   async switchChain(params, init = false) {
     super.checkSwitchChainRequirements(params, init);
+    await this.ensureInitialized();
     const targetChainConfig = this.coreOptions.chains.find(c => c.chainId === params.chainId);
-    if ((targetChainConfig === null || targetChainConfig === void 0 ? void 0 : targetChainConfig.chainNamespace) === CHAIN_NAMESPACES.SOLANA) {
-      // no need to switch chain for Solana
+    if (!targetChainConfig) throw WalletLoginError.connectionError("Chain config is not available");
+    if (targetChainConfig.chainNamespace === CHAIN_NAMESPACES.SOLANA) {
+      if (!this.solanaWallet) {
+        throw WalletLoginError.unsupportedOperation("switchChain requires a Solana client, but no Solana chains are configured.");
+      }
+
+      // For solana case, we don't have the `switchChain` method like `evmClient`.
+      // So, we just need to sync with the connected solana chain to the Web3Auth state.
+      await this.forceSyncChainState(targetChainConfig);
       return;
     }
-    await this.ensureInitialized();
     if (!this.evmClient) {
       throw WalletLoginError.unsupportedOperation("switchChain requires an EVM client, but no EVM chains are configured.");
     }
-    const chainConfig = this.coreOptions.chains.find(x => x.chainId === params.chainId && [CHAIN_NAMESPACES.EIP155].includes(x.chainNamespace));
-    const chainConfiguration = chainConfig ? {
+    const chainConfiguration = targetChainConfig ? {
       chainId: params.chainId,
-      chainName: chainConfig.displayName,
-      rpcUrls: [chainConfig.rpcTarget],
-      blockExplorerUrls: chainConfig.blockExplorerUrl ? [chainConfig.blockExplorerUrl] : undefined,
+      chainName: targetChainConfig.displayName,
+      rpcUrls: [targetChainConfig.rpcTarget],
+      blockExplorerUrls: targetChainConfig.blockExplorerUrl ? [targetChainConfig.blockExplorerUrl] : undefined,
       nativeCurrency: {
-        name: chainConfig.tickerName,
-        symbol: chainConfig.ticker,
-        decimals: chainConfig.decimals || 18
+        name: targetChainConfig.tickerName,
+        symbol: targetChainConfig.ticker,
+        decimals: targetChainConfig.decimals || 18
       },
-      iconUrls: chainConfig.logo ? [chainConfig.logo] : undefined
+      iconUrls: targetChainConfig.logo ? [targetChainConfig.logo] : undefined
     } : undefined;
     await this.evmClient.switchChain({
       chainId: params.chainId,
       chainConfiguration
     });
+    this.updateConnectorData({
+      chainId: params.chainId
+    });
   }
   async generateChallengeAndSign(authServerUrl, accounts, chainId) {
     const activeChainConfig = this.resolveAuthChainConfig(chainId);
@@ -470,7 +499,12 @@ class MetaMaskConnector extends BaseConnector {
     }
     await this.initializationPromise;
   }
-  async syncChainStateAfterConnect(chainConfig) {
+
+  /**
+   * Syncs the chain state with the Web3Auth state.
+   * @param chainConfig - The chain config to sync.
+   */
+  async forceSyncChainState(chainConfig) {
     var _this$evmProvider2;
     // EVM connectors can switch chains, so align the wallet with the requested chain
     // before Web3Auth persists the active chain in controller state.
@@ -491,13 +525,9 @@ class MetaMaskConnector extends BaseConnector {
         if (!connectedChainConfig) {
           throw WalletLoginError.connectionError("Connected chain is not available in the chains config");
         }
-        if (connectedChainConfig.chainId !== chainConfig.chainId) {
-          // since, switchChain is not supported for solana (in metamask connect),
-          // we will make use of the connector data to update the Web3Auth state.
-          this.updateConnectorData({
-            chainId: connectedChainConfig.chainId
-          });
-        }
+        this.updateConnectorData({
+          chainId: chainConfig.chainId
+        });
       }
     }
   }
@@ -512,6 +542,31 @@ class MetaMaskConnector extends BaseConnector {
     // Keep the old fallback for callers that do not pass a chainId yet.
     return isSolanaOnly ? this.coreOptions.chains.find(x => x.chainNamespace === CHAIN_NAMESPACES.SOLANA) : this.evmProvider ? this.coreOptions.chains.find(x => x.chainId === evmChainId) : undefined;
   }
+  async clearMultichainWalletSessions() {
+    const addresses = new Set();
+    if (this.evmProvider) {
+      const evmAccounts = await this.evmProvider.request({
+        method: EVM_METHOD_TYPES.GET_ACCOUNTS
+      });
+      evmAccounts.forEach(account => addresses.add(account));
+    }
+    if (this.solanaProvider) {
+      this.solanaProvider.accounts.forEach(account => addresses.add(account.address));
+    }
+    if (addresses.size === 0) {
+      await this.clearWalletSession();
+      return;
+    }
+
+    // MetaMask can authorize both EVM and Solana accounts in one session, but BaseConnector
+    // caches SIWW tokens under one address at a time. Clear every connected address on disconnect.
+    for (const address of addresses) {
+      this.initSessionManager(address);
+      await this.clearWalletSession().catch(error => {
+        log.error("Failed to clear multichain wallet session", error);
+      });
+    }
+  }
 }
 
 /**
@@ -541,4 +596,4 @@ const metaMaskConnector = params => {
   };
 };
 
-export { metaMaskConnector };
+export { METAMASK_ERC_6963_PROVIDER_RDNS, metaMaskConnector };

package/dist/lib.esm/connectors/wallet-connect-v2-connector/config.js

@@ -14,9 +14,6 @@ let DEFAULT_EIP155_METHODS = /*#__PURE__*/function (DEFAULT_EIP155_METHODS) {
   DEFAULT_EIP155_METHODS["SWITCH_ETHEREUM_CHAIN"] = "wallet_switchEthereumChain";
   return DEFAULT_EIP155_METHODS;
 }({});
-
-// methods that return `null` on success
-const NULL_ON_SUCCESS_METHODS = [DEFAULT_EIP155_METHODS.SWITCH_ETHEREUM_CHAIN, DEFAULT_EIP155_METHODS.ADD_ETHEREUM_CHAIN];
 let DEFAULT_SOLANA_METHODS = /*#__PURE__*/function (DEFAULT_SOLANA_METHODS) {
   DEFAULT_SOLANA_METHODS["SIGN_TRANSACTION"] = "solana_signTransaction";
   DEFAULT_SOLANA_METHODS["SIGN_MESSAGE"] = "solana_signMessage";
@@ -110,4 +107,4 @@ const getWalletConnectV2Settings = async (chains, projectID) => {
   };
 };
 
-export { DEFAULT_EIP155_METHODS, DEFAULT_EIP_155_EVENTS, DEFAULT_SOLANA_EVENTS, DEFAULT_SOLANA_METHODS, NULL_ON_SUCCESS_METHODS, getNamespacesFromChains, getRequiredNamespaces, getSupportedEventsByNamespace, getSupportedMethodsByNamespace, getWalletConnectV2Settings };
+export { DEFAULT_EIP155_METHODS, DEFAULT_EIP_155_EVENTS, DEFAULT_SOLANA_EVENTS, DEFAULT_SOLANA_METHODS, getNamespacesFromChains, getRequiredNamespaces, getSupportedEventsByNamespace, getSupportedMethodsByNamespace, getWalletConnectV2Settings };

package/dist/lib.esm/connectors/wallet-connect-v2-connector/index.js

@@ -1,4 +1,4 @@
-export { DEFAULT_EIP155_METHODS, DEFAULT_EIP_155_EVENTS, DEFAULT_SOLANA_EVENTS, DEFAULT_SOLANA_METHODS, NULL_ON_SUCCESS_METHODS, getNamespacesFromChains, getRequiredNamespaces, getSupportedEventsByNamespace, getSupportedMethodsByNamespace, getWalletConnectV2Settings } from './config.js';
+export { DEFAULT_EIP155_METHODS, DEFAULT_EIP_155_EVENTS, DEFAULT_SOLANA_EVENTS, DEFAULT_SOLANA_METHODS, getNamespacesFromChains, getRequiredNamespaces, getSupportedEventsByNamespace, getSupportedMethodsByNamespace, getWalletConnectV2Settings } from './config.js';
 import { walletConnectV2Connector } from './walletConnectV2Connector.js';
 export { WalletConnectV2Provider } from './WalletConnectV2Provider.js';
 

package/dist/lib.esm/connectors/wallet-connect-v2-connector/walletConnectV2Connector.js

@@ -169,7 +169,7 @@ class WalletConnectV2Connector extends BaseConnector {
           }));
         }
       };
-
+      const connectorNamespace = this.connectorNamespace;
       // if already connected
       if (this.connected) {
         await this.onConnectHandler({
@@ -179,7 +179,8 @@ class WalletConnectV2Connector extends BaseConnector {
         return {
           ethereumProvider: this.provider,
           solanaWallet: this._solanaWallet,
-          connectorName: this.name
+          connectorName: this.name,
+          connectorNamespace
         };
       }
       if (this.status !== CONNECTOR_STATUS.CONNECTING) {
@@ -192,7 +193,8 @@ class WalletConnectV2Connector extends BaseConnector {
       return {
         ethereumProvider: this.provider,
         solanaWallet: this._solanaWallet,
-        connectorName: this.name
+        connectorName: this.name,
+        connectorNamespace
       };
     } catch (error) {
       log.error("Wallet connect v2 connector error while connecting", error);
@@ -473,11 +475,10 @@ class WalletConnectV2Connector extends BaseConnector {
       connectorName: WALLET_CONNECTORS.WALLET_CONNECT_V2,
       reconnected: this.rehydrated,
       ethereumProvider: this.provider,
-      solanaWallet: this._solanaWallet
+      solanaWallet: this._solanaWallet,
+      connectorNamespace: this.connectorNamespace
     });
-    if (getAuthTokenInfo) {
-      await this.getAuthTokenInfo();
-    }
+    await this.authorizeOrDisconnect(getAuthTokenInfo);
   }
   subscribeEvents() {
     if (!this.connector) throw WalletInitializationError.notReady("Wallet connector is not ready yet");

package/dist/lib.esm/index.js

@@ -15,10 +15,11 @@ export { CONNECTOR_NAMES, EVM_CONNECTORS, MULTI_CHAIN_CONNECTORS, SOLANA_CONNECT
 export { CONNECTOR_NAMESPACES } from './base/chain/IChainInterface.js';
 export { CommonJRPCProvider } from './providers/base-provider/CommonJRPCProvider.js';
 export { CommonPrivateKeyProvider } from './providers/base-provider/commonPrivateKeyProvider.js';
-export { DEFAULT_EIP155_METHODS, DEFAULT_EIP_155_EVENTS, DEFAULT_SOLANA_EVENTS, DEFAULT_SOLANA_METHODS, NULL_ON_SUCCESS_METHODS, getNamespacesFromChains, getRequiredNamespaces, getSupportedEventsByNamespace, getSupportedMethodsByNamespace, getWalletConnectV2Settings } from './connectors/wallet-connect-v2-connector/config.js';
+export { DEFAULT_EIP155_METHODS, DEFAULT_EIP_155_EVENTS, DEFAULT_SOLANA_EVENTS, DEFAULT_SOLANA_METHODS, getNamespacesFromChains, getRequiredNamespaces, getSupportedEventsByNamespace, getSupportedMethodsByNamespace, getWalletConnectV2Settings } from './connectors/wallet-connect-v2-connector/config.js';
 export { EIP1193_EVENTS } from './providers/base-provider/utils.js';
 export { EIP_7702_SUPPORTED_SMART_ACCOUNTS, LOGIN_MODE, MODAL_SIGN_IN_METHODS, SMART_ACCOUNT_WALLET_SCOPE, SOLANA_CAIP_CHAIN_MAP, WALLET_REGISTRY_URL, WEB3AUTH_STATE_STORAGE_KEY, WIDGET_TYPE } from './base/constants.js';
 export { EVM_PLUGINS, PLUGIN_EVENTS, PLUGIN_NAMESPACES, PLUGIN_STATUS, SOLANA_PLUGINS, WALLET_PLUGINS } from './base/plugin/IPlugin.js';
+export { METAMASK_ERC_6963_PROVIDER_RDNS, metaMaskConnector } from './connectors/metamask-connector/metamaskConnector.js';
 export { PROVIDER_EVENTS } from './base/provider/IProvider.js';
 export { WalletConnectV2Provider } from './connectors/wallet-connect-v2-connector/WalletConnectV2Provider.js';
 export { WalletInitializationError, WalletLoginError, WalletOperationsError, WalletProviderError, Web3AuthError, isUserRejectedError } from './base/errors/index.js';
@@ -39,7 +40,6 @@ export { hasSolanaWalletStandardFeatures } from './connectors/injected-solana-co
 export { injectedEvmConnector } from './connectors/injected-evm-connector/injectedEvmConnector.js';
 export { log } from './base/loglevel.js';
 export { makeAccountLinkingRequest, makeAccountUnlinkingRequest } from './account-linking/rest.js';
-export { metaMaskConnector } from './connectors/metamask-connector/metamaskConnector.js';
 export { walletConnectV2Connector } from './connectors/wallet-connect-v2-connector/walletConnectV2Connector.js';
 export { walletServicesPlugin } from './plugins/wallet-services-plugin/plugin.js';
 export { walletStandardConnector } from './connectors/injected-solana-connector/walletStandardConnector.js';

package/dist/lib.esm/noModal.js

@@ -19,7 +19,7 @@ import { assertAuthConnector, authConnector, isAuthConnector } from './connector
 import { AccountLinkingError } from './account-linking/errors.js';
 import { CommonJRPCProvider } from './providers/base-provider/CommonJRPCProvider.js';
 import { walletServicesPlugin } from './plugins/wallet-services-plugin/plugin.js';
-import { metaMaskConnector } from './connectors/metamask-connector/metamaskConnector.js';
+import { metaMaskConnector, METAMASK_ERC_6963_PROVIDER_RDNS } from './connectors/metamask-connector/metamaskConnector.js';
 import { storageAvailable } from './base/connector/utils.js';
 import { PLUGIN_STATUS, PLUGIN_NAMESPACES } from './base/plugin/IPlugin.js';
 
@@ -50,7 +50,8 @@ class Web3AuthNoModal extends SafeEventEmitter {
       idToken: null,
       accessToken: null,
       refreshToken: null,
-      activeAccount: null
+      activeAccount: null,
+      cachedConnectorNamespace: null
     });
     if (!options.clientId) throw WalletInitializationError.invalidParams("Please provide a valid clientId in constructor");
     if (options.enableLogging) log.enableAll();else log.setLevel("error");
@@ -251,6 +252,7 @@ class Web3AuthNoModal extends SafeEventEmitter {
     await this.setState({
       primaryConnectorName: null,
       cachedConnector: null,
+      cachedConnectorNamespace: null,
       currentChainId: null,
       idToken: null,
       accessToken: null,
@@ -261,7 +263,10 @@ class Web3AuthNoModal extends SafeEventEmitter {
   }
   async cleanup() {
     for (const connector of this.connectors) {
-      if (connector.cleanup) await connector.cleanup();
+      // if the connector is not ready, we don't need to cleanup
+      // this means that we load the connector (coz of the dashboard config) but the clients did not use it (i.e. with `showOnModal` set to false)
+      // example use case: external wallet **ONLY** login mode but the ClientID has enabled Auth connection in dashboard.
+      if (connector.cleanup && connector.status !== CONNECTOR_STATUS.NOT_READY) await connector.cleanup();
     }
   }
   async switchChain(params) {
@@ -794,7 +799,9 @@ class Web3AuthNoModal extends SafeEventEmitter {
     });
 
     // sync chainId
-    this.commonJRPCProvider.on("chainChanged", async chainId => this.setCurrentChain(chainId));
+    this.commonJRPCProvider.on("chainChanged", async chainId => {
+      await this.setCurrentChain(chainId);
+    });
   }
   async setupConnector(connector) {
     this.subscribeToConnectorEvents(connector);
@@ -860,12 +867,19 @@ class Web3AuthNoModal extends SafeEventEmitter {
           injectedEvmConnector
         } = await import('./connectors/injected-evm-connector/index.js');
         const evmMipd = createMipd();
+        // `@metamask/connect-evm` SDK announces its own EIP-6963 provider (`io.metamask.mmc`) so
+        // it can be discovered by generic wallet pickers. We already register MetaMask via
+        // `metaMaskConnector`, so we must exclude the SDK-announced provider here; otherwise
+        // it is misclassified as an injected wallet and the modal shows MetaMask as installed,
+        // even when the user does not have the extension installed.
+        const isNonSdkAnnouncedProvider = providerDetail => providerDetail.info.rdns !== METAMASK_ERC_6963_PROVIDER_RDNS;
         // subscribe to new injected connectors
         evmMipd.subscribe(providerDetails => {
-          const newConnectors = providerDetails.map(providerDetail => injectedEvmConnector(providerDetail)(config));
+          const filteredProviderDetails = providerDetails.filter(isNonSdkAnnouncedProvider);
+          const newConnectors = filteredProviderDetails.map(providerDetail => injectedEvmConnector(providerDetail)(config));
           this.setConnectors(newConnectors);
         });
-        connectorFns.push(...evmMipd.getProviders().map(injectedEvmConnector));
+        connectorFns.push(...evmMipd.getProviders().filter(isNonSdkAnnouncedProvider).map(injectedEvmConnector));
       }
     }
 
@@ -1000,7 +1014,7 @@ class Web3AuthNoModal extends SafeEventEmitter {
       await this.setState({
         primaryConnectorName: data.connectorName
       });
-      this.cacheWallet(data.connectorName);
+      this.cacheWallet(data.connectorName, data.connectorNamespace);
       const isConnectAndSign = this.coreOptions.initialAuthenticationMode === CONNECTOR_INITIAL_AUTHENTICATION_MODE.CONNECT_AND_SIGN;
       const pendingUserConsent = this.consentRequired && !this.state.hasUserConsent;
       if (pendingUserConsent && !isConnectAndSign) {
@@ -1015,7 +1029,6 @@ class Web3AuthNoModal extends SafeEventEmitter {
         if (this.status !== CONNECTOR_STATUS.CONSENT_REQUIRING && this.status !== CONNECTOR_STATUS.AUTHORIZED) {
           this.status = CONNECTOR_STATUS.CONNECTED;
         }
-        log.debug("connected", this.status, this.primaryConnectorName);
         // Defer plugin connection until consent is accepted; otherwise plugins would start before the consent step completes.
         // `completeConsentAcceptance` connects the plugins once the user accepts the consent.
         if (!pendingUserConsent) {
@@ -1133,7 +1146,14 @@ class Web3AuthNoModal extends SafeEventEmitter {
       // External wallets can resolve to a different active chain than the requested one,
       // so let connector-reported chain updates reconcile Web3Auth state after connect.
       if (typeof (data === null || data === void 0 ? void 0 : data.data) === "object" && (data === null || data === void 0 ? void 0 : data.data) !== null && "chainId" in data.data && typeof data.data.chainId === "string") {
+        const previousChain = this.currentChain;
         await this.setCurrentChain(data.data.chainId);
+        const currentChain = this.currentChain;
+        const connectorEthereumProvider = connector.provider;
+        if ((previousChain === null || previousChain === void 0 ? void 0 : previousChain.chainNamespace) !== (currentChain === null || currentChain === void 0 ? void 0 : currentChain.chainNamespace) && (currentChain === null || currentChain === void 0 ? void 0 : currentChain.chainNamespace) === CHAIN_NAMESPACES.EIP155 && connectorEthereumProvider) {
+          // from sol -> evm namespace switch, we need to re-create AccountAbstractionProvider
+          await this.bindPrimaryEthereumSigningProxy(connectorEthereumProvider, connector.name);
+        }
       }
       log.debug("connector data updated", data);
       this.emit(CONNECTOR_EVENTS.CONNECTOR_DATA_UPDATED, data);
@@ -1188,7 +1208,7 @@ class Web3AuthNoModal extends SafeEventEmitter {
   }
   checkIfAutoConnect(connector) {
     var _this$currentChain3;
-    let autoConnect = this.cachedConnector === connector.name;
+    let autoConnect = this.cachedConnector === connector.name && this.state.cachedConnectorNamespace === connector.connectorNamespace;
     if (autoConnect && (_this$currentChain3 = this.currentChain) !== null && _this$currentChain3 !== void 0 && _this$currentChain3.chainNamespace) {
       if (connector.connectorNamespace === CONNECTOR_NAMESPACES.MULTICHAIN) autoConnect = true;else autoConnect = connector.connectorNamespace === this.currentChain.chainNamespace;
     }
@@ -1202,10 +1222,16 @@ class Web3AuthNoModal extends SafeEventEmitter {
   getInitialChainIdForConnector(connector) {
     var _initialChain;
     let initialChain = this.currentChain;
-    if (((_initialChain = initialChain) === null || _initialChain === void 0 ? void 0 : _initialChain.chainNamespace) !== connector.connectorNamespace && connector.connectorNamespace !== CONNECTOR_NAMESPACES.MULTICHAIN) {
+    const defaultChainId = this.coreOptions.defaultChainId;
+    const isMultiChainConnector = connector.connectorNamespace === CONNECTOR_NAMESPACES.MULTICHAIN;
+
+    // if the connector is a multi-chain connector and a default chain id is set, use the default chain id
+    if (isMultiChainConnector && defaultChainId) {
+      initialChain = this.coreOptions.chains.find(chain => chain.chainId === defaultChainId) || this.currentChain;
+    } else if (((_initialChain = initialChain) === null || _initialChain === void 0 ? void 0 : _initialChain.chainNamespace) !== connector.connectorNamespace && connector.connectorNamespace !== CONNECTOR_NAMESPACES.MULTICHAIN) {
       initialChain = this.coreOptions.chains.find(x => x.chainNamespace === connector.connectorNamespace);
-      if (!initialChain) throw WalletInitializationError.invalidParams(`No chain found for ${connector.connectorNamespace}`);
     }
+    if (!initialChain) throw WalletInitializationError.invalidParams(`No chain found for ${connector.connectorNamespace}`);
     return initialChain;
   }
   async completeConsentAcceptance() {
@@ -1391,7 +1417,8 @@ class Web3AuthNoModal extends SafeEventEmitter {
     return {
       ethereumProvider: connectedWallet.signingProvider,
       solanaWallet: (_connectedWallet$sola = connectedWallet.solanaWallet) !== null && _connectedWallet$sola !== void 0 ? _connectedWallet$sola : null,
-      connectorName: connectedWallet.connector.name
+      connectorName: connectedWallet.connector.name,
+      connectorNamespace: connectedWallet.connector.connectorNamespace
     };
   }
   buildImmediateConnectedWalletConnectorState(params) {
@@ -1529,11 +1556,7 @@ class Web3AuthNoModal extends SafeEventEmitter {
     if (!connection) {
       throw WalletLoginError.connectionError("Failed to resolve the active connection after switching accounts.");
     }
-    this.emit(CONNECTOR_EVENTS.CONNECTION_UPDATED, {
-      ethereumProvider: connection.ethereumProvider,
-      solanaWallet: connection.solanaWallet,
-      connectorName: connection.connectorName
-    });
+    this.emit(CONNECTOR_EVENTS.CONNECTION_UPDATED, connection);
   }
   isActiveConnectorEventSource(connector) {
     if (!this.primaryConnectorName) return true;
@@ -1616,9 +1639,10 @@ class Web3AuthNoModal extends SafeEventEmitter {
       log.debug("Failed to cache connected linked wallet connector", error);
     }
   }
-  async cacheWallet(walletName) {
+  async cacheWallet(walletName, connectorNamespace) {
     await this.setState({
-      cachedConnector: walletName
+      cachedConnector: walletName,
+      cachedConnectorNamespace: connectorNamespace
     });
   }
   async setCurrentChain(chainId) {
@@ -1654,9 +1678,11 @@ class Web3AuthNoModal extends SafeEventEmitter {
     });
   }
   async bindPrimaryEthereumSigningProxy(ethereumProvider, connectorName) {
-    var _this$currentChain5, _accountAbstractionCo;
+    var _this$primaryConnecto2, _this$currentChain5, _accountAbstractionCo;
     if (!this.commonJRPCProvider) throw WalletInitializationError.notFound(`CommonJrpcProvider not found`);
-    let finalProvider = (ethereumProvider === null || ethereumProvider === void 0 ? void 0 : ethereumProvider.provider) || ethereumProvider;
+    const primaryConnectorProvider = connectorName === this.primaryConnectorName ? (_this$primaryConnecto2 = this.primaryConnector) === null || _this$primaryConnecto2 === void 0 ? void 0 : _this$primaryConnecto2.provider : null;
+    const baseEthereumProvider = ethereumProvider === this.commonJRPCProvider || ethereumProvider === this.aaProvider ? primaryConnectorProvider !== null && primaryConnectorProvider !== void 0 ? primaryConnectorProvider : ethereumProvider : ethereumProvider;
+    let finalProvider = (baseEthereumProvider === null || baseEthereumProvider === void 0 ? void 0 : baseEthereumProvider.provider) || baseEthereumProvider;
     const {
       accountAbstractionConfig
     } = this.coreOptions;
@@ -1673,7 +1699,7 @@ class Web3AuthNoModal extends SafeEventEmitter {
         accountAbstractionProvider,
         toEoaProvider
       } = await import('./providers/account-abstraction-provider/index.js');
-      const eoaProvider = connectorName === WALLET_CONNECTORS.AUTH ? await toEoaProvider(ethereumProvider) : ethereumProvider;
+      const eoaProvider = connectorName === WALLET_CONNECTORS.AUTH ? await toEoaProvider(baseEthereumProvider) : baseEthereumProvider;
       const aaChainIds = new Set((accountAbstractionConfig === null || accountAbstractionConfig === void 0 || (_accountAbstractionCo2 = accountAbstractionConfig.chains) === null || _accountAbstractionCo2 === void 0 ? void 0 : _accountAbstractionCo2.map(chain => chain.chainId)) || []);
       const aaProvider = await accountAbstractionProvider({
         accountAbstractionConfig,

package/dist/lib.esm/providers/account-abstraction-provider/providers/AccountAbstractionProvider.js

@@ -54,7 +54,7 @@ class AccountAbstractionProvider extends BaseProvider {
     });
   }
   async setupProvider(eoaProvider) {
-    var _bundlerConfig$transp;
+    var _ref, _bundlerConfig$transp;
     const currentChain = this.currentChain;
     if (!currentChain) {
       throw WalletInitializationError.invalidProviderConfigError(`AA chain config not found for chain ${this.chainId}`);
@@ -97,7 +97,14 @@ class AccountAbstractionProvider extends BaseProvider {
       chain,
       transport: http(currentChain.rpcTarget)
     });
-    const [eoaAddress] = await eoaProvider.request({
+    // Firstly, try to get the accounts from the existing connected provider with `eth_accounts` method.
+    // We don't wanna do `eth_requestAccounts` method here, coz if the wallet is already connected, it will trigger chainChanged event and unintentionally update the AaProvider re-bind and
+    // re-bind run this again, so we will end up in infinite loop.
+    const existingAccounts = (_ref = await eoaProvider.request({
+      method: METHOD_TYPES.GET_ACCOUNTS
+    })) !== null && _ref !== void 0 ? _ref : [];
+    // only if the existing accounts are not found (that means wallet isn't connected), then we will trigger `eth_requestAccounts` method to get the accounts.
+    const [eoaAddress] = existingAccounts.length > 0 ? existingAccounts : await eoaProvider.request({
       method: METHOD_TYPES.ETH_REQUEST_ACCOUNTS
     });
     const walletClient = createWalletClient({

package/dist/lib.esm/providers/account-abstraction-provider/rpc/ethRpcMiddlewares.js

@@ -1,7 +1,6 @@
 import _objectSpread from '@babel/runtime/helpers/objectSpread2';
 import { METHOD_TYPES, EIP_5792_METHODS, EIP_7702_METHODS } from '@toruslabs/ethereum-controllers';
 import { createScaffoldMiddlewareV2, providerErrors, rpcErrors } from '@web3auth/auth';
-import { NULL_ON_SUCCESS_METHODS } from '../../../connectors/wallet-connect-v2-connector/config.js';
 
 async function createAaMiddleware({
   eoaProvider,
@@ -200,17 +199,10 @@ function providerAsMiddleware(provider) {
   return async ({
     request
   }) => {
-    const result = await provider.request({
+    return provider.request({
       method: request.method,
       params: request.params
     });
-    if (result === undefined && NULL_ON_SUCCESS_METHODS.includes(request.method)) {
-      // For some RPC requests, such as `wallet_switchEthereumChain`, the standard rpc result is `null`.
-      // However, some wallet providers might return `undefined` instead and causing the JRPCEngineV2 to throw `Nothing ended the request` error.
-      // So, we handle this case by returning `null` instead, so that JRPCEngineV2 won't throw `Nothing ended the request` error
-      return null;
-    }
-    return result;
   };
 }
 

package/dist/lib.esm/react/context/useWeb3AuthInnerContextValue.js

@@ -162,6 +162,14 @@ function useWeb3AuthInnerContextValue({
       setChainId(web3Auth.currentChainId);
       setChainNamespace((_web3Auth$currentChai1 = (_web3Auth$currentChai10 = web3Auth.currentChain) === null || _web3Auth$currentChai10 === void 0 ? void 0 : _web3Auth$currentChai10.chainNamespace) !== null && _web3Auth$currentChai1 !== void 0 ? _web3Auth$currentChai1 : null);
     };
+    const connectorDataUpdatedListener = data => {
+      const updatedData = data.data;
+      if (updatedData.chainId) {
+        var _web3Auth$currentChai11;
+        setChainId(updatedData.chainId);
+        setChainNamespace((_web3Auth$currentChai11 = web3Auth.currentChain) === null || _web3Auth$currentChai11 === void 0 ? void 0 : _web3Auth$currentChai11.chainNamespace);
+      }
+    };
     if (web3Auth) {
       web3Auth.on(CONNECTOR_EVENTS.NOT_READY, notReadyListener);
       web3Auth.on(CONNECTOR_EVENTS.READY, readyListener);
@@ -173,6 +181,7 @@ function useWeb3AuthInnerContextValue({
       web3Auth.on(CONNECTOR_EVENTS.REHYDRATION_ERROR, rehydrationErrorListener);
       web3Auth.on(CONNECTOR_EVENTS.MFA_ENABLED, mfaEnabledListener);
       web3Auth.on(CONNECTOR_EVENTS.CONNECTION_UPDATED, connectionUpdatedListener);
+      web3Auth.on(CONNECTOR_EVENTS.CONNECTOR_DATA_UPDATED, connectorDataUpdatedListener);
       if (web3Auth.loginMode === LOGIN_MODE.MODAL) {
         web3Auth.on(CONNECTOR_EVENTS.CONSENT_ACCEPTED, consentAcceptedListener);
       }
@@ -189,6 +198,7 @@ function useWeb3AuthInnerContextValue({
       web3Auth.removeListener(CONNECTOR_EVENTS.MFA_ENABLED, mfaEnabledListener);
       web3Auth.removeListener(CONNECTOR_EVENTS.AUTHORIZED, authorizedListener);
       web3Auth.removeListener(CONNECTOR_EVENTS.CONNECTION_UPDATED, connectionUpdatedListener);
+      web3Auth.removeListener(CONNECTOR_EVENTS.CONNECTOR_DATA_UPDATED, connectorDataUpdatedListener);
       if (web3Auth.loginMode === LOGIN_MODE.MODAL) {
         web3Auth.removeListener(CONNECTOR_EVENTS.CONSENT_ACCEPTED, consentAcceptedListener);
       }