@web3auth/no-modal 11.0.0-beta.1 → 11.0.0

package/dist/lib.esm/noModal.js

@@ -3,11 +3,11 @@ import _objectSpread from '@babel/runtime/helpers/objectSpread2';
 import _defineProperty from '@babel/runtime/helpers/defineProperty';
 import { CHAIN_NAMESPACES, BUTTON_POSITION, CONFIRMATION_STRATEGY } from '@toruslabs/base-controllers';
 import { SMART_ACCOUNT_EIP_STANDARD, EIP7702_SUPPORTED_SMART_ACCOUNT_TYPES } from '@toruslabs/ethereum-controllers';
-import { SafeEventEmitter, serializeError, UX_MODE, cloneDeep, CookieStorage, LocalStorageAdapter, MemoryStorage } from '@web3auth/auth';
+import { SafeEventEmitter, BUILD_ENV, serializeError, UX_MODE, cloneDeep, CookieStorage, LocalStorageAdapter, MemoryStorage } from '@web3auth/auth';
 import deepmerge from 'deepmerge';
 import { deserialize } from './base/deserialize.js';
-import { WalletInitializationError, WalletLoginError, AccountLinkingError } from './base/errors/index.js';
 import { LOGIN_MODE, SMART_ACCOUNT_WALLET_SCOPE, WEB3AUTH_STATE_STORAGE_KEY } from './base/constants.js';
+import { WalletInitializationError, WalletLoginError } from './base/errors/index.js';
 import { log } from './base/loglevel.js';
 import { CONNECTOR_STATUS, CONNECTOR_INITIAL_AUTHENTICATION_MODE, CONNECTOR_EVENTS } from './base/connector/constants.js';
 import { Analytics, ANALYTICS_INTEGRATION_TYPE, ANALYTICS_SDK_TYPE, ANALYTICS_EVENTS } from './base/analytics.js';
@@ -16,6 +16,7 @@ import { WALLET_CONNECTORS } from './base/wallet/index.js';
 import { CONNECTOR_NAMESPACES } from './base/chain/IChainInterface.js';
 import { CONNECTED_STATUSES, CAN_LOGOUT_STATUSES, CAN_AUTHORIZE_STATUSES } from './base/connector/connectorStatus.js';
 import { assertAuthConnector, authConnector, isAuthConnector } from './connectors/auth-connector/authConnector.js';
+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';
@@ -54,7 +55,9 @@ class Web3AuthNoModal extends SafeEventEmitter {
     if (!options.clientId) throw WalletInitializationError.invalidParams("Please provide a valid clientId in constructor");
     if (options.enableLogging) log.enableAll();else log.setLevel("error");
     if (!options.initialAuthenticationMode) options.initialAuthenticationMode = CONNECTOR_INITIAL_AUTHENTICATION_MODE.CONNECT_AND_SIGN;
-    this.coreOptions = options;
+    this.coreOptions = _objectSpread(_objectSpread({}, options), {}, {
+      authBuildEnv: options.authBuildEnv || BUILD_ENV.PRODUCTION
+    });
     this.storage = this.getStorageMethod();
     this.analytics = new Analytics();
     if (options.disableAnalytics) {
@@ -925,7 +928,6 @@ class Web3AuthNoModal extends SafeEventEmitter {
       }));
       this.setActiveWalletConnectorKey();
       this.connectionReconnected = data.reconnected;
-      const connectedChainId = ethereumProvider === null || ethereumProvider === void 0 ? void 0 : ethereumProvider.chainId;
 
       // when ssr is enabled, we need to get the idToken from the connector.
       if (this.coreOptions.ssr) {
@@ -950,14 +952,16 @@ class Web3AuthNoModal extends SafeEventEmitter {
       // The following block only hits during rehydration
 
       const {
-        activeAccount
+        activeAccount,
+        currentChainId
       } = this.state;
-      // if the active account is not the primary account, i.e. not `null`, create an isolated connector and connect to the chain
+      let rehydrateWithLinkedAccount = false;
+      // for rehydration, if the active account is not the primary account, i.e. not `null`, create an isolated connector and connect to the chain
       if (activeAccount && !activeAccount.isPrimary && activeAccount.connector !== WALLET_CONNECTORS.AUTH) {
         var _ref3, _walletConnector$prov, _linkedAccountConnect, _ref4, _walletConnector$sola, _linkedAccountConnect2;
         const accountLinkingConnector = isAuthConnector(connector) ? connector : this.getConnector(WALLET_CONNECTORS.AUTH);
         assertAuthConnector(accountLinkingConnector, "Account switching requires the AUTH connector to be available.");
-        const targetChainId = accountLinkingConnector.getChainIdForLinkedAccount(activeAccount, connectedChainId);
+        const targetChainId = accountLinkingConnector.getChainIdForLinkedAccount(activeAccount, currentChainId);
         const walletConnector = await this.createIsolatedWalletConnector(activeAccount.connector, targetChainId);
         let linkedAccountConnection = null;
         if (!this.hasUsableConnectedSwitchConnector(walletConnector)) {
@@ -977,6 +981,7 @@ class Web3AuthNoModal extends SafeEventEmitter {
         });
         this.setConnectedWalletConnectorState(connectedWalletState, activeAccount);
         this.setActiveWalletConnectorKey(activeAccount);
+        rehydrateWithLinkedAccount = true;
       }
       if (ethereumProvider) {
         await this.bindPrimaryEthereumSigningProxy(ethereumProvider, data.connectorName);
@@ -989,24 +994,44 @@ class Web3AuthNoModal extends SafeEventEmitter {
       });
       this.setConnectedWalletConnectorState(primaryConnectedWalletState);
       await this.setState({
-        primaryConnectorName: data.connectorName,
-        currentChainId: connectedChainId
+        primaryConnectorName: data.connectorName
       });
       this.cacheWallet(data.connectorName);
       const isConnectAndSign = this.coreOptions.initialAuthenticationMode === CONNECTOR_INITIAL_AUTHENTICATION_MODE.CONNECT_AND_SIGN;
-      if (this.consentRequired && !isConnectAndSign && !this.state.hasUserConsent) {
+      const pendingUserConsent = this.consentRequired && !this.state.hasUserConsent;
+      if (pendingUserConsent && !isConnectAndSign) {
         this.status = CONNECTOR_STATUS.CONSENT_REQUIRING;
         this.emit(CONNECTOR_EVENTS.CONSENT_REQUIRING);
         log.debug("consent_requiring", this.status, this.primaryConnectorName);
       } else {
-        this.status = CONNECTOR_STATUS.CONNECTED;
+        // In CONNECT_AND_SIGN mode the AUTHORIZED handler can run before this point (e.g. when `ssr=true`
+        // this handler `await`s `connector.getAuthTokenInfo()` which fires AUTHORIZED mid-execution).
+        // Don't downgrade an already-advanced status (CONSENT_REQUIRING or AUTHORIZED) back to CONNECTED;
+        // otherwise `acceptConsent` would throw "Cannot accept consent: not in consent_requiring state".
+        if (this.status !== CONNECTOR_STATUS.CONSENT_REQUIRING && this.status !== CONNECTOR_STATUS.AUTHORIZED) {
+          this.status = CONNECTOR_STATUS.CONNECTED;
+        }
         log.debug("connected", this.status, this.primaryConnectorName);
-        this.connectToPlugins(_objectSpread(_objectSpread({}, data), {}, {
-          connector: data.connectorName
-        }));
+        // 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) {
+          this.connectToPlugins(_objectSpread(_objectSpread({}, data), {}, {
+            connector: data.connectorName
+          }));
+        }
+
+        // `pendingUserConsent` signals listeners (LoginModal, React/Vue contexts) to skip processing this CONNECTED event,
+        // so the upcoming AUTHORIZED -> CONSENT_REQUIRING transition is not overridden by a late CONNECTED handler in CONNECT_AND_SIGN mode.
         this.emit(CONNECTOR_EVENTS.CONNECTED, _objectSpread(_objectSpread({}, data), {}, {
-          loginMode: this.loginMode
+          loginMode: this.loginMode,
+          pendingUserConsent
         }));
+
+        // if we're rehydrating with a linked account, we need to emit a CONNECTION_UPDATED event
+        // so that upstream listeners and context are updated with the linked connection.
+        if (rehydrateWithLinkedAccount) {
+          this.emit(CONNECTOR_EVENTS.CONNECTION_UPDATED, this.connection);
+        }
       }
     });
     connector.on(CONNECTOR_EVENTS.DISCONNECTED, async data => {
@@ -1226,7 +1251,15 @@ class Web3AuthNoModal extends SafeEventEmitter {
     return activeChainId;
   }
   async createLinkingWalletConnector(connectorName, chainId, config) {
-    return this.createIsolatedWalletConnector(connectorName, chainId, config);
+    try {
+      const linkingConnector = await this.createIsolatedWalletConnector(connectorName, chainId, config);
+      return linkingConnector;
+    } catch (error) {
+      if (error instanceof AccountLinkingError && error.code === 5405) {
+        throw error;
+      }
+      throw AccountLinkingError.walletProofFailed(error instanceof Error ? error.message : String(error), error);
+    }
   }
   async createSwitchingWalletConnector(connectorName, chainId, config) {
     return this.createIsolatedWalletConnector(connectorName, chainId, config);
@@ -1381,12 +1414,12 @@ class Web3AuthNoModal extends SafeEventEmitter {
       account
     });
   }
-  async linkAccountWithConnector(connectorName, chainId, walletConnector) {
+  async linkAccountWithConnector(connectorName, chainId, connectorToLink) {
     const authConnector = this.getMainAuthConnector();
     const result = await authConnector.linkAccount({
       connectorName,
       chainId,
-      walletConnector,
+      connectorToLink,
       authSessionTokens: {
         accessToken: this.accessToken,
         idToken: this.idToken
@@ -1395,7 +1428,7 @@ class Web3AuthNoModal extends SafeEventEmitter {
     await this.setState({
       idToken: result.idToken
     });
-    await this.cacheConnectedLinkedWalletConnector(authConnector, walletConnector);
+    await this.cacheConnectedLinkedWalletConnector(authConnector, connectorToLink);
     return result;
   }
   getMainAuthConnector() {
@@ -1575,7 +1608,10 @@ class Web3AuthNoModal extends SafeEventEmitter {
     });
   }
   async setCurrentChain(chainId) {
-    if (chainId === this.currentChainId) return;
+    const {
+      currentChainId
+    } = this.state;
+    if (chainId === currentChainId) return;
     const newChain = this.coreOptions.chains.find(chain => chain.chainId === chainId);
     if (!newChain) throw WalletInitializationError.invalidParams(`Invalid chainId: ${chainId}`);
     await this.setState({

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

@@ -5,7 +5,7 @@ export { SMART_ACCOUNT } from '@toruslabs/ethereum-controllers';
 import { JRPCEngineV2, providerFromEngineV2, providerErrors } from '@web3auth/auth';
 import { defineChain, createPublicClient, http, createWalletClient, custom } from 'viem';
 import { createPaymasterClient, createBundlerClient } from 'viem/account-abstraction';
-import { createEoaMiddleware, providerAsMiddleware, createAaMiddleware } from '../rpc/ethRpcMiddlewares.js';
+import { createEoaMiddleware, providerAsMiddleware, createAaMiddleware, createEip7702And5792MiddlewareForAaProvider } from '../rpc/ethRpcMiddlewares.js';
 import { getProviderHandlers } from './utils.js';
 import { BaseProvider } from '../../base-provider/baseProvider.js';
 import { CHAIN_NAMESPACES } from '@toruslabs/base-controllers';
@@ -55,9 +55,10 @@ class AccountAbstractionProvider extends BaseProvider {
   }
   async setupProvider(eoaProvider) {
     var _bundlerConfig$transp;
-    const {
-      currentChain
-    } = this;
+    const currentChain = this.currentChain;
+    if (!currentChain) {
+      throw WalletInitializationError.invalidProviderConfigError(`AA chain config not found for chain ${this.chainId}`);
+    }
     const {
       chainNamespace
     } = currentChain;
@@ -134,9 +135,13 @@ class AccountAbstractionProvider extends BaseProvider {
       eoaProvider,
       handlers: providerHandlers
     });
+
+    // middleware to handle EIP-7702 and EIP-5792 methods,
+    // currently, we do not support EIP-7702 and EIP-5792 methods for account abstraction provider
+    const eip7702And5792Middleware = await createEip7702And5792MiddlewareForAaProvider();
     const eoaMiddleware = providerAsMiddleware(eoaProvider);
     const engine = JRPCEngineV2.create({
-      middleware: [aaMiddleware, eoaMiddleware]
+      middleware: [aaMiddleware, eip7702And5792Middleware, eoaMiddleware]
     });
     const provider = providerFromEngineV2(engine);
     this.updateProviderEngineProxy(provider);

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

@@ -2,7 +2,6 @@ import _objectSpread from '@babel/runtime/helpers/objectSpread2';
 import { isHexString, add0x } from '@toruslabs/metadata-helpers';
 import { providerErrors } from '@web3auth/auth';
 import { createWalletClient, http } from 'viem';
-import { log } from '../../../base/loglevel.js';
 
 function getProviderHandlers({
   bundlerClient,
@@ -20,8 +19,6 @@ function getProviderHandlers({
       const [smartAccounts, eoaAccounts] = await Promise.all([smartAccount.getAddress(), eoaProvider.request({
         method: "eth_accounts"
       })]);
-      log.info("smartAccounts", smartAccounts);
-      log.info("eoaAccounts", eoaAccounts);
       return [smartAccounts, ...eoaAccounts];
     },
     getPrivateKey: async _ => {

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

@@ -1,6 +1,6 @@
 import _objectSpread from '@babel/runtime/helpers/objectSpread2';
-import { METHOD_TYPES } from '@toruslabs/ethereum-controllers';
-import { createScaffoldMiddlewareV2, rpcErrors } from '@web3auth/auth';
+import { METHOD_TYPES, EIP_5792_METHODS, EIP_7702_METHODS } from '@toruslabs/ethereum-controllers';
+import { createScaffoldMiddlewareV2, providerErrors, rpcErrors } from '@web3auth/auth';
 
 async function createAaMiddleware({
   eoaProvider,
@@ -181,6 +181,20 @@ async function createEoaMiddleware({
     eth_requestAccounts: requestAccounts
   });
 }
+async function createEip7702And5792MiddlewareForAaProvider() {
+  const eip5792Methods = Object.values(EIP_5792_METHODS);
+  const eip7702Methods = Object.values(EIP_7702_METHODS);
+  const eip7702And5792Methods = [...eip5792Methods, ...eip7702Methods];
+  return async ({
+    request,
+    next
+  }) => {
+    if (eip7702And5792Methods.includes(request.method)) {
+      throw providerErrors.unsupportedMethod(`${request.method} is not supported for account abstraction provider`);
+    }
+    return next(request);
+  };
+}
 function providerAsMiddleware(provider) {
   return async ({
     request
@@ -192,4 +206,4 @@ function providerAsMiddleware(provider) {
   };
 }
 
-export { createAaMiddleware, createEoaMiddleware, providerAsMiddleware };
+export { createAaMiddleware, createEip7702And5792MiddlewareForAaProvider, createEoaMiddleware, providerAsMiddleware };

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

@@ -127,19 +127,26 @@ function useWeb3AuthInnerContextValue({
     const authorizedListener = () => {
       setStatus(web3Auth.status);
       if (web3Auth.status === CONNECTOR_STATUS.AUTHORIZED) {
+        var _web3Auth$currentChai7, _web3Auth$currentChai8;
+        setIsInitialized(true);
         setIsConnected(true);
+        // on rehydration, `AUTHORIZED` event can be fired first in `CONNECT_AND_SIGN` mode, before `CONNECTED` event.
+        // Update the connection state here, so that clients can use the connection state immediately.
+        setConnection(web3Auth.connection);
+        setChainId(web3Auth.currentChainId);
+        setChainNamespace((_web3Auth$currentChai7 = (_web3Auth$currentChai8 = web3Auth.currentChain) === null || _web3Auth$currentChai8 === void 0 ? void 0 : _web3Auth$currentChai8.chainNamespace) !== null && _web3Auth$currentChai7 !== void 0 ? _web3Auth$currentChai7 : null);
         setIsAuthorized(true);
       }
     };
     const consentAcceptedListener = () => {
       setStatus(web3Auth.status);
       if (web3Auth.status === CONNECTOR_STATUS.CONNECTED || web3Auth.status === CONNECTOR_STATUS.AUTHORIZED) {
-        var _web3Auth$currentChai7, _web3Auth$currentChai8;
+        var _web3Auth$currentChai9, _web3Auth$currentChai0;
         setIsInitialized(true);
         setIsConnected(true);
         setConnection(web3Auth.connection);
         setChainId(web3Auth.currentChainId);
-        setChainNamespace((_web3Auth$currentChai7 = (_web3Auth$currentChai8 = web3Auth.currentChain) === null || _web3Auth$currentChai8 === void 0 ? void 0 : _web3Auth$currentChai8.chainNamespace) !== null && _web3Auth$currentChai7 !== void 0 ? _web3Auth$currentChai7 : null);
+        setChainNamespace((_web3Auth$currentChai9 = (_web3Auth$currentChai0 = web3Auth.currentChain) === null || _web3Auth$currentChai0 === void 0 ? void 0 : _web3Auth$currentChai0.chainNamespace) !== null && _web3Auth$currentChai9 !== void 0 ? _web3Auth$currentChai9 : null);
         if (web3Auth.status === CONNECTOR_STATUS.AUTHORIZED) {
           setIsAuthorized(true);
         }
@@ -148,6 +155,13 @@ function useWeb3AuthInnerContextValue({
     const mfaEnabledListener = nextIsMFAEnabled => {
       if (typeof nextIsMFAEnabled === "boolean") setIsMFAEnabled(nextIsMFAEnabled);
     };
+    const connectionUpdatedListener = () => {
+      var _web3Auth$currentChai1, _web3Auth$currentChai10;
+      setStatus(web3Auth.status);
+      setConnection(web3Auth.connection);
+      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);
+    };
     if (web3Auth) {
       web3Auth.on(CONNECTOR_EVENTS.NOT_READY, notReadyListener);
       web3Auth.on(CONNECTOR_EVENTS.READY, readyListener);
@@ -158,6 +172,7 @@ function useWeb3AuthInnerContextValue({
       web3Auth.on(CONNECTOR_EVENTS.ERRORED, errorListener);
       web3Auth.on(CONNECTOR_EVENTS.REHYDRATION_ERROR, rehydrationErrorListener);
       web3Auth.on(CONNECTOR_EVENTS.MFA_ENABLED, mfaEnabledListener);
+      web3Auth.on(CONNECTOR_EVENTS.CONNECTION_UPDATED, connectionUpdatedListener);
       if (web3Auth.loginMode === LOGIN_MODE.MODAL) {
         web3Auth.on(CONNECTOR_EVENTS.CONSENT_ACCEPTED, consentAcceptedListener);
       }
@@ -173,6 +188,7 @@ function useWeb3AuthInnerContextValue({
       web3Auth.removeListener(CONNECTOR_EVENTS.REHYDRATION_ERROR, rehydrationErrorListener);
       web3Auth.removeListener(CONNECTOR_EVENTS.MFA_ENABLED, mfaEnabledListener);
       web3Auth.removeListener(CONNECTOR_EVENTS.AUTHORIZED, authorizedListener);
+      web3Auth.removeListener(CONNECTOR_EVENTS.CONNECTION_UPDATED, connectionUpdatedListener);
       if (web3Auth.loginMode === LOGIN_MODE.MODAL) {
         web3Auth.removeListener(CONNECTOR_EVENTS.CONSENT_ACCEPTED, consentAcceptedListener);
       }

package/dist/lib.esm/react/solana/provider.js

@@ -52,6 +52,7 @@ function useFrameworkKitSolanaClient() {
     isInitialized
   } = useWeb3Auth();
   const {
+    chainId,
     chainNamespace
   } = useChain();
   const ref = useRef(null);
@@ -102,7 +103,10 @@ function useFrameworkKitSolanaClient() {
       }
 
       // only reconnect for the primary connector
-      if (conn.connectorName !== (web3Auth === null || web3Auth === void 0 ? void 0 : web3Auth.primaryConnectorName)) return;
+      if (conn.connectorName !== (web3Auth === null || web3Auth === void 0 ? void 0 : web3Auth.primaryConnectorName)) {
+        adopt(makePlaceholder(rpc));
+        return;
+      }
       try {
         const solanaWalletId = "wallet-standard:" + conn.connectorName;
         const connector = createWalletStandardConnector(solanaWallet, {
@@ -134,7 +138,7 @@ function useFrameworkKitSolanaClient() {
     return () => {
       stale = true;
     };
-  }, [isConnected, connection === null || connection === void 0 ? void 0 : connection.solanaWallet, chainNamespace, web3Auth, isInitialized, connection === null || connection === void 0 ? void 0 : connection.connectorName]);
+  }, [isConnected, connection === null || connection === void 0 ? void 0 : connection.solanaWallet, chainId, chainNamespace, web3Auth, isInitialized, connection === null || connection === void 0 ? void 0 : connection.connectorName]);
   return client;
 }
 function SolanaProvider(_ref) {

package/dist/lib.esm/react/wagmi/index.js

@@ -1 +1 @@
-export { WagmiProvider } from './provider.js';
+export { WagmiProvider, connectWeb3AuthWithWagmi, createWeb3AuthConnectorForWagmi, disconnectWeb3AuthFromWagmi, getWeb3authConnector, resetConnectorState, setupConnector } from './provider.js';

package/dist/lib.esm/react/wagmi/provider.js

@@ -1,42 +1,61 @@
 import _objectWithoutProperties from '@babel/runtime/helpers/objectWithoutProperties';
 import _objectSpread from '@babel/runtime/helpers/objectSpread2';
-import { useMemo, createElement, useEffect, Fragment } from 'react';
-import { defineChain } from 'viem';
-import { createConfig, WagmiProvider as WagmiProvider$1, webSocket, http, fallback, useConfig, useReconnect, useConnectionEffect } from 'wagmi';
-import { injected } from 'wagmi/connectors';
+import { useMemo, createElement, useRef, useEffect, Fragment } from 'react';
+import { defineChain, isAddress } from 'viem';
+import { createConfig, WagmiProvider as WagmiProvider$1, injected, webSocket, http, fallback, useConfig, useReconnect, useConnectionEffect } from 'wagmi';
 import { defaultWagmiConfig } from './constants.js';
 import { useWeb3Auth } from '../hooks/useWeb3Auth.js';
 import { CHAIN_NAMESPACES } from '@toruslabs/base-controllers';
 import { WalletInitializationError } from '../../base/errors/index.js';
-import { useWeb3AuthDisconnect } from '../hooks/useWeb3AuthDisconnect.js';
+import { WEB3AUTH_CONNECTOR_ID } from '../../base/connector/constants.js';
 import { log } from '../../base/loglevel.js';
+import { useWeb3AuthDisconnect } from '../hooks/useWeb3AuthDisconnect.js';
 
 const _excluded = ["children"];
-const WEB3AUTH_CONNECTOR_ID = "web3auth";
 function getWeb3authConnector(config) {
   return config.connectors.find(c => c.id === WEB3AUTH_CONNECTOR_ID);
 }
 
-// Helper to initialize connectors for the given wallets
+// Helper to create a Web3Auth connector to connect with wagmi
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
-async function setupConnector(provider, config) {
-  let connector = getWeb3authConnector(config);
-  if (connector) return connector;
-
-  // Create new connector if not already existing
-  connector = injected({
+function createWeb3AuthConnectorForWagmi(provider) {
+  const baseConnector = injected({
     target: {
       provider: provider,
       id: WEB3AUTH_CONNECTOR_ID,
       name: "Web3Auth"
     }
   });
+  return config => {
+    const connector = baseConnector(config);
+    const baseOnAccountsChanged = connector.onAccountsChanged.bind(connector);
+
+    // we need to handle the `accountsChanged` event emitted on the cross-namespace chain switch.
+    // on evm -> solana, the accountsChanged event is emitted with the solana address, which is not valid for evm.
+    // that causes the `invalid account address` error in wagmi. So, here, we're filtering out the solana addresses.
+    connector.onAccountsChanged = accounts => {
+      if (accounts.length > 0 && !accounts.every(account => typeof account === "string" && isAddress(account))) {
+        log.warn("onAccountsChanged::accountsChanged event received on non-EVM address");
+        return;
+      }
+      baseOnAccountsChanged(accounts);
+    };
+    return connector;
+  };
+}
+
+// Helper to initialize connectors for the given wallets
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function setupConnector(provider, config) {
+  let connector = getWeb3authConnector(config);
+  if (connector) return connector;
+
+  // Create new connector if not already existing
+  connector = createWeb3AuthConnectorForWagmi(provider);
   const result = config._internal.connectors.setup(connector);
   config._internal.connectors.setState(current => [...current, result]);
   return result;
 }
-
-// Helper to connect a wallet and update wagmi state
 async function connectWeb3AuthWithWagmi(connector, config) {
   var _config$storage, _config$storage2;
   await Promise.all([(_config$storage = config.storage) === null || _config$storage === void 0 ? void 0 : _config$storage.removeItem(`${connector.id}.disconnected`), (_config$storage2 = config.storage) === null || _config$storage2 === void 0 ? void 0 : _config$storage2.setItem("recentConnectorId", connector.id)]);
@@ -76,9 +95,11 @@ async function disconnectWeb3AuthFromWagmi(config) {
 function Web3AuthWagmiProvider({
   children
 }) {
+  var _connection$ethereumP, _connection$connector;
   const {
     isConnected,
-    connection
+    connection,
+    chainNamespace
   } = useWeb3Auth();
   const {
     disconnect
@@ -87,34 +108,62 @@ function Web3AuthWagmiProvider({
   const {
     mutate: reconnect
   } = useReconnect();
+  const suppressWagmiDisconnect = useRef(false);
+  const lastSyncedProvider = useRef((_connection$ethereumP = connection === null || connection === void 0 ? void 0 : connection.ethereumProvider) !== null && _connection$ethereumP !== void 0 ? _connection$ethereumP : null);
+  const lastSyncedConnectorName = useRef((_connection$connector = connection === null || connection === void 0 ? void 0 : connection.connectorName) !== null && _connection$connector !== void 0 ? _connection$connector : null);
   useConnectionEffect({
     onDisconnect: async () => {
       log.info("Disconnected from wagmi");
-      if (isConnected) await disconnect();
-      const connector = getWeb3authConnector(wagmiConfig);
+      const isSuppressed = suppressWagmiDisconnect.current;
+      suppressWagmiDisconnect.current = false;
+      if (!isSuppressed && isConnected) await disconnect();
+
       // reset wagmi connector state if the provider handles disconnection because of the accountsChanged event
       // from the connected provider
-      if (connector) {
+      if (getWeb3authConnector(wagmiConfig)) {
         resetConnectorState(wagmiConfig);
       }
     }
   });
   useEffect(() => {
-    (async () => {
-      if (isConnected && connection !== null && connection !== void 0 && connection.ethereumProvider) {
-        const connector = await setupConnector(connection.ethereumProvider, wagmiConfig);
+    (async _connection$ethereumP2 => {
+      const newConnection = connection !== null && connection !== void 0 ? connection : null;
+      const newEth = (_connection$ethereumP2 = connection === null || connection === void 0 ? void 0 : connection.ethereumProvider) !== null && _connection$ethereumP2 !== void 0 ? _connection$ethereumP2 : null;
+      const w3aWagmiConnector = getWeb3authConnector(wagmiConfig);
+      const shouldBindToWagmi = isConnected && chainNamespace === CHAIN_NAMESPACES.EIP155 && Boolean(newConnection && newEth);
+      if (shouldBindToWagmi) {
+        const hasSameBinding = lastSyncedProvider.current === newEth && lastSyncedConnectorName.current === newConnection.connectorName && wagmiConfig.state.status === "connected";
+        if (hasSameBinding) {
+          // rehydration: already connected to the same provider, so no need to reconnect
+          return;
+        }
+
+        // `ethereumProvider` is a stable proxy (`commonJRPCProvider`) across account switches,
+        // so key wagmi resyncs off the Web3Auth connection object instead of provider identity.
+        if (w3aWagmiConnector) {
+          resetConnectorState(wagmiConfig);
+        }
+        lastSyncedProvider.current = newEth;
+        lastSyncedConnectorName.current = newConnection.connectorName;
+        const connector = setupConnector(newEth, wagmiConfig);
         if (!connector) {
+          log.error("Failed to setup react wagmi connector");
           throw new Error("Failed to setup connector");
         }
         await connectWeb3AuthWithWagmi(connector, wagmiConfig);
         reconnect();
-      } else if (!isConnected) {
+      } else {
+        lastSyncedProvider.current = null;
+        lastSyncedConnectorName.current = null;
         if (wagmiConfig.state.status === "connected") {
+          suppressWagmiDisconnect.current = true;
           await disconnectWeb3AuthFromWagmi(wagmiConfig);
+        } else if (w3aWagmiConnector) {
+          resetConnectorState(wagmiConfig);
         }
       }
     })();
-  }, [isConnected, wagmiConfig, connection, reconnect]);
+  }, [chainNamespace, connection, isConnected, reconnect, wagmiConfig]);
   return createElement(Fragment, null, children);
 }
 function WagmiProvider(_ref) {
@@ -208,4 +257,4 @@ function WagmiProvider(_ref) {
   }), createElement(Web3AuthWagmiProvider, null, children));
 }
 
-export { WagmiProvider };
+export { WagmiProvider, connectWeb3AuthWithWagmi, createWeb3AuthConnectorForWagmi, disconnectWeb3AuthFromWagmi, getWeb3authConnector, resetConnectorState, setupConnector };

package/dist/lib.esm/vue/solana/provider.js

@@ -3,6 +3,7 @@ import { defineComponent, ref, provide, watch, h, Fragment } from 'vue';
 import { CHAIN_NAMESPACES } from '@toruslabs/base-controllers';
 import { SOLANA_CLIENT_KEY } from './constants.js';
 import { useWeb3Auth } from '../composables/useWeb3Auth.js';
+import { useChain } from '../composables/useChain.js';
 import { log } from '../../base/loglevel.js';
 
 const disposeClient = async client => {
@@ -29,63 +30,85 @@ const SolanaProvider = defineComponent({
       connection,
       web3Auth
     } = useWeb3Auth();
+    const {
+      chainId
+    } = useChain();
     const clientRef = ref(null);
+    // Holds the token for the newest requested sync run. Older async runs compare against it
+    // before publishing results so a slower reconnect cannot overwrite a newer chain/account update.
+    let activeSyncToken = null;
 
     // provide the client to the app
     provide(SOLANA_CLIENT_KEY, clientRef);
-
-    // watch for changes in the connection and chain namespace
-    watch([isConnected, connection], async ([newIsConnected, newConnection]) => {
-      var _web3Auth$value;
-      if (!newIsConnected || !(newConnection !== null && newConnection !== void 0 && newConnection.solanaWallet)) {
-        if (clientRef.value) {
-          await disposeClient(clientRef.value);
-          clientRef.value = null;
+    const syncClient = async () => {
+      var _web3Auth$value, _web3Auth$value2;
+      // Only the latest async, `syncing` run should be allowed to attach its client.
+      // A fresh Symbol gives each run a unique identity without relying on counters.
+      const syncToken = Symbol("solana-client-sync");
+      activeSyncToken = syncToken;
+      const newIsConnected = isConnected.value;
+      const newConnection = connection.value;
+      const currentChain = (_web3Auth$value = web3Auth.value) === null || _web3Auth$value === void 0 ? void 0 : _web3Auth$value.currentChain;
+      if (!newIsConnected || !(newConnection !== null && newConnection !== void 0 && newConnection.solanaWallet) || (currentChain === null || currentChain === void 0 ? void 0 : currentChain.chainNamespace) !== CHAIN_NAMESPACES.SOLANA ||
+      // only reconnect for the primary connector
+      newConnection.connectorName !== ((_web3Auth$value2 = web3Auth.value) === null || _web3Auth$value2 === void 0 ? void 0 : _web3Auth$value2.primaryConnectorName)) {
+        const prevClient = clientRef.value;
+        clientRef.value = null;
+        if (prevClient) {
+          await disposeClient(prevClient);
         }
         return;
       }
-      const currentChain = web3Auth.value.currentChain;
-      let chainConfig;
-      if ((currentChain === null || currentChain === void 0 ? void 0 : currentChain.chainNamespace) === CHAIN_NAMESPACES.SOLANA) {
-        chainConfig = currentChain;
-      } else {
-        // use the 1st Solana chain if current chain is not solana
-        chainConfig = web3Auth.value.coreOptions.chains.find(c => c.chainNamespace === CHAIN_NAMESPACES.SOLANA);
-        if (!chainConfig) return;
-      }
-
-      // only reconnect for the primary connector
-      if (newConnection.connectorName !== ((_web3Auth$value = web3Auth.value) === null || _web3Auth$value === void 0 ? void 0 : _web3Auth$value.primaryConnectorName)) return;
       const prevClient = clientRef.value;
+      clientRef.value = null;
+      if (prevClient) {
+        await disposeClient(prevClient);
+      }
+      let client = null;
       try {
         // create a wallet standard connector from connected wallet
-        const solanaWalletId = "wallet-standard:" + connection.value.connectorName;
-        const connector = createWalletStandardConnector(connection.value.solanaWallet, {
+        const solanaWalletId = "wallet-standard:" + newConnection.connectorName;
+        const connector = createWalletStandardConnector(newConnection.solanaWallet, {
           id: solanaWalletId,
-          name: connection.value.connectorName
+          name: newConnection.connectorName
         });
 
         // create a solana client
         const {
           rpcTarget,
           wsTarget
-        } = chainConfig;
-        const client = createClient({
+        } = currentChain;
+        client = createClient({
           endpoint: rpcTarget,
           websocketEndpoint: wsTarget,
           walletConnectors: [connector]
         });
-        clientRef.value = client;
-        if (prevClient) await disposeClient(prevClient);
 
         // connect the client to the wallet
         await client.actions.connectWallet(solanaWalletId, {
           autoConnect: true
         });
+        // If another sync started while connectWallet was in flight, this client is stale.
+        if (activeSyncToken !== syncToken) {
+          await disposeClient(client);
+          return;
+        }
+        clientRef.value = client;
       } catch (err) {
+        if (client) {
+          await disposeClient(client);
+        }
         log.error("Failed to create or connect Solana client", err);
-        clientRef.value = null;
+        // Only clear the shared ref when this failing run is still the newest one.
+        if (activeSyncToken === syncToken) {
+          clientRef.value = null;
+        }
       }
+    };
+
+    // watch for changes in the connection and active chain
+    watch([isConnected, connection, chainId], () => {
+      void syncClient();
     }, {
       immediate: true
     });