@web3auth/no-modal 11.1.0 → 11.3.0

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

@@ -19,7 +19,7 @@ require('@web3auth/auth');
 require('jwt-decode');
 require('../../base/constants.js');
 var index$1 = require('../../base/errors/index.js');
-require('../../base/loglevel.js');
+var loglevel = require('../../base/loglevel.js');
 require('../../base/plugin/errors.js');
 require('../../base/plugin/IPlugin.js');
 var utils = require('../../base/utils.js');
@@ -27,6 +27,11 @@ var index = require('../../base/wallet/index.js');
 var utils$1 = require('../utils.js');
 var solana = require('../../base/wallet/solana.js');
 
+// `@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.BaseConnector {
   constructor(connectorOptions) {
     super(connectorOptions);
@@ -195,13 +200,24 @@ class MetaMaskConnector extends baseConnector.BaseConnector {
     if (coreStatus === "connected" && options.autoConnect) {
       this.status = constants.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(constants.CONNECTOR_EVENTS.CONNECTED, {
         connectorName: index.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(constants.CONNECTOR_EVENTS.REHYDRATION_ERROR, error);
+      }
     } else if (coreStatus === "connected" || coreStatus === "loaded" || coreStatus === "disconnected" || coreStatus === "pending") {
       this.status = constants.CONNECTOR_STATUS.READY;
       this.emit(constants.CONNECTOR_EVENTS.READY, index.WALLET_CONNECTORS.METAMASK);
@@ -266,7 +282,7 @@ class MetaMaskConnector extends baseConnector.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") {
         throw index$1.WalletLoginError.notConnectedError("Failed to connect with MetaMask wallet");
@@ -284,15 +300,15 @@ class MetaMaskConnector extends baseConnector.BaseConnector {
         connectorName: index.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
@@ -317,9 +333,11 @@ class MetaMaskConnector extends baseConnector.BaseConnector {
   }) {
     if (!this.multichainClient) throw index$1.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 = constants.CONNECTOR_STATUS.NOT_READY;
       this.initializationPromise = null;
@@ -375,32 +393,40 @@ class MetaMaskConnector extends baseConnector.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) === baseControllers.CHAIN_NAMESPACES.SOLANA) {
-      // no need to switch chain for Solana
+    if (!targetChainConfig) throw index$1.WalletLoginError.connectionError("Chain config is not available");
+    if (targetChainConfig.chainNamespace === baseControllers.CHAIN_NAMESPACES.SOLANA) {
+      if (!this.solanaWallet) {
+        throw index$1.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 index$1.WalletLoginError.unsupportedOperation("switchChain requires an EVM client, but no EVM chains are configured.");
     }
-    const chainConfig = this.coreOptions.chains.find(x => x.chainId === params.chainId && [baseControllers.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);
@@ -458,7 +484,11 @@ class MetaMaskConnector extends baseConnector.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.
@@ -479,13 +509,9 @@ class MetaMaskConnector extends baseConnector.BaseConnector {
         if (!connectedChainConfig) {
           throw index$1.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
+        });
       }
     }
   }
@@ -499,6 +525,30 @@ class MetaMaskConnector extends baseConnector.BaseConnector {
     // Keep the old fallback for callers that do not pass a chainId yet.
     return isSolanaOnly ? this.coreOptions.chains.find(x => x.chainNamespace === baseControllers.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: wsEmbed.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 => {
+        loglevel.log.error("Failed to clear multichain wallet session", error);
+      });
+    }
+  }
 }
 /**
  * Factory function to create a MetaMask connector
@@ -527,4 +577,5 @@ const metaMaskConnector = params => {
   };
 };
 
+exports.METAMASK_ERC_6963_PROVIDER_RDNS = METAMASK_ERC_6963_PROVIDER_RDNS;
 exports.metaMaskConnector = metaMaskConnector;

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

@@ -175,6 +175,7 @@ class WalletConnectV2Connector extends baseConnector.BaseConnector {
           }));
         }
       };
+      const connectorNamespace = this.connectorNamespace;
       // if already connected
       if (this.connected) {
         await this.onConnectHandler({
@@ -184,7 +185,8 @@ class WalletConnectV2Connector extends baseConnector.BaseConnector {
         return {
           ethereumProvider: this.provider,
           solanaWallet: this._solanaWallet,
-          connectorName: this.name
+          connectorName: this.name,
+          connectorNamespace
         };
       }
       if (this.status !== constants.CONNECTOR_STATUS.CONNECTING) {
@@ -197,7 +199,8 @@ class WalletConnectV2Connector extends baseConnector.BaseConnector {
       return {
         ethereumProvider: this.provider,
         solanaWallet: this._solanaWallet,
-        connectorName: this.name
+        connectorName: this.name,
+        connectorNamespace
       };
     } catch (error) {
       loglevel.log.error("Wallet connect v2 connector error while connecting", error);
@@ -475,11 +478,10 @@ class WalletConnectV2Connector extends baseConnector.BaseConnector {
       connectorName: index.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 index$1.WalletInitializationError.notReady("Wallet connector is not ready yet");

package/dist/lib.cjs/index.js

@@ -148,6 +148,7 @@ Object.defineProperty(exports, "createMipd", {
 	get: function () { return mipd.createStore; }
 });
 exports.hasSolanaWalletStandardFeatures = index$3.hasSolanaWalletStandardFeatures;
+exports.METAMASK_ERC_6963_PROVIDER_RDNS = metamaskConnector.METAMASK_ERC_6963_PROVIDER_RDNS;
 exports.metaMaskConnector = metamaskConnector.metaMaskConnector;
 Object.defineProperty(exports, "DEFAULT_EIP155_METHODS", {
 	enumerable: true,

package/dist/lib.cjs/noModal.js

@@ -56,7 +56,8 @@ class Web3AuthNoModal extends auth.SafeEventEmitter {
       idToken: null,
       accessToken: null,
       refreshToken: null,
-      activeAccount: null
+      activeAccount: null,
+      cachedConnectorNamespace: null
     });
     if (!options.clientId) throw index.WalletInitializationError.invalidParams("Please provide a valid clientId in constructor");
     if (options.enableLogging) loglevel.log.enableAll();else loglevel.log.setLevel("error");
@@ -248,6 +249,7 @@ class Web3AuthNoModal extends auth.SafeEventEmitter {
     await this.setState({
       primaryConnectorName: null,
       cachedConnector: null,
+      cachedConnectorNamespace: null,
       currentChainId: null,
       idToken: null,
       accessToken: null,
@@ -783,7 +785,9 @@ class Web3AuthNoModal extends auth.SafeEventEmitter {
       chains: this.coreOptions.chains
     });
     // 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);
@@ -847,12 +851,19 @@ class Web3AuthNoModal extends auth.SafeEventEmitter {
           injectedEvmConnector
         } = await Promise.resolve().then(function () { return require('./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 !== metamaskConnector.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));
       }
     }
     // add WalletConnectV2 connector if external wallets are enabled
@@ -984,7 +995,7 @@ class Web3AuthNoModal extends auth.SafeEventEmitter {
       await this.setState({
         primaryConnectorName: data.connectorName
       });
-      this.cacheWallet(data.connectorName);
+      this.cacheWallet(data.connectorName, data.connectorNamespace);
       const isConnectAndSign = this.coreOptions.initialAuthenticationMode === constants.CONNECTOR_INITIAL_AUTHENTICATION_MODE.CONNECT_AND_SIGN;
       const pendingUserConsent = this.consentRequired && !this.state.hasUserConsent;
       if (pendingUserConsent && !isConnectAndSign) {
@@ -999,7 +1010,6 @@ class Web3AuthNoModal extends auth.SafeEventEmitter {
         if (this.status !== constants.CONNECTOR_STATUS.CONSENT_REQUIRING && this.status !== constants.CONNECTOR_STATUS.AUTHORIZED) {
           this.status = constants.CONNECTOR_STATUS.CONNECTED;
         }
-        loglevel.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) {
@@ -1114,7 +1124,14 @@ class Web3AuthNoModal extends auth.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) === baseControllers.CHAIN_NAMESPACES.EIP155 && connectorEthereumProvider) {
+          // from sol -> evm namespace switch, we need to re-create AccountAbstractionProvider
+          await this.bindPrimaryEthereumSigningProxy(connectorEthereumProvider, connector.name);
+        }
       }
       loglevel.log.debug("connector data updated", data);
       this.emit(constants.CONNECTOR_EVENTS.CONNECTOR_DATA_UPDATED, data);
@@ -1168,7 +1185,7 @@ class Web3AuthNoModal extends auth.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 === IChainInterface.CONNECTOR_NAMESPACES.MULTICHAIN) autoConnect = true;else autoConnect = connector.connectorNamespace === this.currentChain.chainNamespace;
     }
@@ -1181,10 +1198,15 @@ class Web3AuthNoModal extends auth.SafeEventEmitter {
   getInitialChainIdForConnector(connector) {
     var _initialChain;
     let initialChain = this.currentChain;
-    if (((_initialChain = initialChain) === null || _initialChain === void 0 ? void 0 : _initialChain.chainNamespace) !== connector.connectorNamespace && connector.connectorNamespace !== IChainInterface.CONNECTOR_NAMESPACES.MULTICHAIN) {
+    const defaultChainId = this.coreOptions.defaultChainId;
+    const isMultiChainConnector = connector.connectorNamespace === IChainInterface.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 !== IChainInterface.CONNECTOR_NAMESPACES.MULTICHAIN) {
       initialChain = this.coreOptions.chains.find(x => x.chainNamespace === connector.connectorNamespace);
-      if (!initialChain) throw index.WalletInitializationError.invalidParams(`No chain found for ${connector.connectorNamespace}`);
     }
+    if (!initialChain) throw index.WalletInitializationError.invalidParams(`No chain found for ${connector.connectorNamespace}`);
     return initialChain;
   }
   async completeConsentAcceptance() {
@@ -1368,7 +1390,8 @@ class Web3AuthNoModal extends auth.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) {
@@ -1505,11 +1528,7 @@ class Web3AuthNoModal extends auth.SafeEventEmitter {
     if (!connection) {
       throw index.WalletLoginError.connectionError("Failed to resolve the active connection after switching accounts.");
     }
-    this.emit(constants.CONNECTOR_EVENTS.CONNECTION_UPDATED, {
-      ethereumProvider: connection.ethereumProvider,
-      solanaWallet: connection.solanaWallet,
-      connectorName: connection.connectorName
-    });
+    this.emit(constants.CONNECTOR_EVENTS.CONNECTION_UPDATED, connection);
   }
   isActiveConnectorEventSource(connector) {
     if (!this.primaryConnectorName) return true;
@@ -1592,9 +1611,10 @@ class Web3AuthNoModal extends auth.SafeEventEmitter {
       loglevel.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) {
@@ -1630,9 +1650,11 @@ class Web3AuthNoModal extends auth.SafeEventEmitter {
     });
   }
   async bindPrimaryEthereumSigningProxy(ethereumProvider, connectorName) {
-    var _this$currentChain5, _accountAbstractionCo;
+    var _this$primaryConnecto2, _this$currentChain5, _accountAbstractionCo;
     if (!this.commonJRPCProvider) throw index.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;
@@ -1642,13 +1664,14 @@ class Web3AuthNoModal extends auth.SafeEventEmitter {
       return chain.chainId === ((_this$currentChain6 = this.currentChain) === null || _this$currentChain6 === void 0 ? void 0 : _this$currentChain6.chainId);
     }));
     // setup AA provider if AA is enabled (skip for EIP-7702; 7702 uses EOA + 5792/7702 RPC only)
-    if (!is7702 && isAaSupportedForCurrentChain && (connectorName === index$1.WALLET_CONNECTORS.AUTH || this.coreOptions.useAAWithExternalWallet)) {
+    // Skip AA wrapping for Base Account as it's already a smart account provider
+    if (!is7702 && isAaSupportedForCurrentChain && (connectorName === index$1.WALLET_CONNECTORS.AUTH || this.coreOptions.useAAWithExternalWallet && connectorName !== index$1.WALLET_CONNECTORS.BASE_ACCOUNT)) {
       var _accountAbstractionCo2;
       const {
         accountAbstractionProvider,
         toEoaProvider
       } = await Promise.resolve().then(function () { return require('./providers/account-abstraction-provider/index.js'); });
-      const eoaProvider = connectorName === index$1.WALLET_CONNECTORS.AUTH ? await toEoaProvider(ethereumProvider) : ethereumProvider;
+      const eoaProvider = connectorName === index$1.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.cjs/providers/account-abstraction-provider/providers/AccountAbstractionProvider.js

@@ -70,7 +70,7 @@ class AccountAbstractionProvider extends baseProvider.BaseProvider {
     });
   }
   async setupProvider(eoaProvider) {
-    var _bundlerConfig$transp;
+    var _await$eoaProvider$re, _bundlerConfig$transp;
     const currentChain = this.currentChain;
     if (!currentChain) {
       throw index.WalletInitializationError.invalidProviderConfigError(`AA chain config not found for chain ${this.chainId}`);
@@ -113,7 +113,14 @@ class AccountAbstractionProvider extends baseProvider.BaseProvider {
       chain,
       transport: viem.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 = (_await$eoaProvider$re = await eoaProvider.request({
+      method: ethereumControllers.METHOD_TYPES.GET_ACCOUNTS
+    })) !== null && _await$eoaProvider$re !== void 0 ? _await$eoaProvider$re : [];
+    // 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: ethereumControllers.METHOD_TYPES.ETH_REQUEST_ACCOUNTS
     });
     const walletClient = viem.createWalletClient({

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

@@ -175,6 +175,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(constants.CONNECTOR_EVENTS.NOT_READY, notReadyListener);
       web3Auth.on(constants.CONNECTOR_EVENTS.READY, readyListener);
@@ -186,6 +194,7 @@ function useWeb3AuthInnerContextValue({
       web3Auth.on(constants.CONNECTOR_EVENTS.REHYDRATION_ERROR, rehydrationErrorListener);
       web3Auth.on(constants.CONNECTOR_EVENTS.MFA_ENABLED, mfaEnabledListener);
       web3Auth.on(constants.CONNECTOR_EVENTS.CONNECTION_UPDATED, connectionUpdatedListener);
+      web3Auth.on(constants.CONNECTOR_EVENTS.CONNECTOR_DATA_UPDATED, connectorDataUpdatedListener);
       if (web3Auth.loginMode === constants$1.LOGIN_MODE.MODAL) {
         web3Auth.on(constants.CONNECTOR_EVENTS.CONSENT_ACCEPTED, consentAcceptedListener);
       }
@@ -202,6 +211,7 @@ function useWeb3AuthInnerContextValue({
       web3Auth.removeListener(constants.CONNECTOR_EVENTS.MFA_ENABLED, mfaEnabledListener);
       web3Auth.removeListener(constants.CONNECTOR_EVENTS.AUTHORIZED, authorizedListener);
       web3Auth.removeListener(constants.CONNECTOR_EVENTS.CONNECTION_UPDATED, connectionUpdatedListener);
+      web3Auth.removeListener(constants.CONNECTOR_EVENTS.CONNECTOR_DATA_UPDATED, connectorDataUpdatedListener);
       if (web3Auth.loginMode === constants$1.LOGIN_MODE.MODAL) {
         web3Auth.removeListener(constants.CONNECTOR_EVENTS.CONSENT_ACCEPTED, consentAcceptedListener);
       }