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

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

@@ -12,11 +12,11 @@ import { getSiteName } from '../utils.js';
 import { CONNECTOR_NAMESPACES } from '../../base/chain/IChainInterface.js';
 import { WALLET_CONNECTORS } from '../../base/wallet/index.js';
 import { getCaipChainId, citadelServerUrl } from '../../base/utils.js';
-import { WalletLoginError, Web3AuthError } from '../../base/errors/index.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 { BaseConnector } from '../../base/connector/baseConnector.js';
 import { CONNECTOR_CATEGORY, CONNECTOR_STATUS, CONNECTOR_EVENTS } from '../../base/connector/constants.js';
-import { getSolanaChainByChainConfig, walletSignMessage } from '../../base/wallet/solana.js';
 
 /**
  * Configuration options for the MetaMask connector using \@metamask/connect-evm
@@ -113,7 +113,11 @@ class MetaMaskConnector extends BaseConnector {
           supportedNetworks: caipSupportedNetworks
         },
         ui,
-        debug: (_this$connectorSettin0 = this.connectorSettings) === null || _this$connectorSettin0 === void 0 ? void 0 : _this$connectorSettin0.debug
+        debug: (_this$connectorSettin0 = this.connectorSettings) === null || _this$connectorSettin0 === void 0 ? void 0 : _this$connectorSettin0.debug,
+        analytics: {
+          integrationType: "web3auth",
+          enabled: !this.coreOptions.disableAnalytics
+        }
       });
 
       // Listen for QR code URI from the multichain client (for mobile wallet connection)
@@ -133,19 +137,27 @@ class MetaMaskConnector extends BaseConnector {
           dapp,
           eventHandlers: {
             accountsChanged: _accounts => {
-              if (_accounts.length === 0) {
+              if (_accounts.length === 0 && this.connected) {
                 this.disconnect();
               }
             },
             chainChanged: _chainId => {},
             connect: _result => {},
-            disconnect: () => this.disconnect()
+            disconnect: () => {
+              if (this.connected) {
+                this.disconnect();
+              }
+            }
           },
           api: {
             supportedNetworks: hexSupportedNetworks
           },
           ui,
-          debug: (_this$connectorSettin1 = this.connectorSettings) === null || _this$connectorSettin1 === void 0 ? void 0 : _this$connectorSettin1.debug
+          debug: (_this$connectorSettin1 = this.connectorSettings) === null || _this$connectorSettin1 === void 0 ? void 0 : _this$connectorSettin1.debug,
+          analytics: {
+            integrationType: "web3auth",
+            enabled: !this.coreOptions.disableAnalytics
+          }
         });
         this.evmProvider = this.evmClient.getProvider();
       }
@@ -157,7 +169,11 @@ class MetaMaskConnector extends BaseConnector {
           api: {
             supportedNetworks: solanaSupportedNetworks
           },
-          skipAutoRegister: true
+          skipAutoRegister: true,
+          analytics: {
+            integrationType: "web3auth",
+            enabled: !this.coreOptions.disableAnalytics
+          }
         });
         this.solanaProvider = this.solanaClient.getWallet();
       }
@@ -172,32 +188,20 @@ class MetaMaskConnector extends BaseConnector {
       return;
     }
     const coreStatus = this.multichainClient.status;
-    if (coreStatus === "connected") {
+    // only connect if the multichain client is connected and autoConnect is true (i.e during the rehydration)
+    if (coreStatus === "connected" && options.autoConnect) {
       this.status = CONNECTOR_STATUS.CONNECTED;
       this.rehydrated = true;
-      if (options.autoConnect) {
-        this.emit(CONNECTOR_EVENTS.CONNECTED, {
-          connectorName: WALLET_CONNECTORS.METAMASK,
-          reconnected: this.rehydrated,
-          ethereumProvider: this.evmProvider,
-          solanaWallet: this.solanaProvider
-        });
-        if (options.getAuthTokenInfo) {
-          await this.getAuthTokenInfo();
-        }
-      }
-    } else if (coreStatus === "loaded" || coreStatus === "disconnected") {
-      this.status = CONNECTOR_STATUS.READY;
-      this.emit(CONNECTOR_EVENTS.READY, WALLET_CONNECTORS.METAMASK);
-    } else if (coreStatus === "pending") {
-      // 'pending' implies that a transport failed to resume the connection
-      // if (options.autoConnect) {
-      //   this.rehydrated = false;
-      //   this.emit(CONNECTOR_EVENTS.REHYDRATION_ERROR, new Error("Failed to resume existing MetaMask Connect session.") as Web3AuthError);
-      // } else {
+      this.emit(CONNECTOR_EVENTS.CONNECTED, {
+        connectorName: WALLET_CONNECTORS.METAMASK,
+        reconnected: true,
+        ethereumProvider: this.evmProvider,
+        solanaWallet: this.solanaProvider
+      });
+      if (options.getAuthTokenInfo) await this.getAuthTokenInfo();
+    } else if (coreStatus === "connected" || coreStatus === "loaded" || coreStatus === "disconnected" || coreStatus === "pending") {
       this.status = CONNECTOR_STATUS.READY;
       this.emit(CONNECTOR_EVENTS.READY, WALLET_CONNECTORS.METAMASK);
-      // }
     } else {
       // Something unexpected happened
       this.status = CONNECTOR_STATUS.ERRORED;
@@ -234,11 +238,15 @@ class MetaMaskConnector extends BaseConnector {
           connector: WALLET_CONNECTORS.METAMASK
         });
         const evmConnectedPromise = new Promise(resolve => {
-          var _this$evmProvider;
-          // Wait for EVM provider to be ready
-          (_this$evmProvider = this.evmProvider) === null || _this$evmProvider === void 0 || _this$evmProvider.once("connect", () => {
+          if (this.evmClient.status === "connected") {
             resolve();
-          });
+          } else {
+            var _this$evmProvider;
+            // Wait for EVM provider to be ready
+            (_this$evmProvider = this.evmProvider) === null || _this$evmProvider === void 0 || _this$evmProvider.once("connect", () => {
+              resolve();
+            });
+          }
         });
 
         // Connect using the multichain client
@@ -308,6 +316,7 @@ class MetaMaskConnector extends BaseConnector {
           duration: Date.now() - startTime
         }));
       }
+      if (isUserRejectedError(error)) throw WalletOperationsError.userRejected();
       if (error instanceof Web3AuthError) throw error;
       throw WalletLoginError.connectionError("Failed to login with MetaMask wallet", error);
     }

package/dist/lib.esm/index.js

@@ -1,7 +1,7 @@
 export { Web3AuthNoModal } from './noModal.js';
 export { ANALYTICS_EVENTS, ANALYTICS_INTEGRATION_TYPE, ANALYTICS_SDK_TYPE, Analytics } from './base/analytics.js';
 export { AUTH_CONNECTION, MFA_FACTOR, MFA_LEVELS, UX_MODE, WEB3AUTH_NETWORK, getED25519Key } from '@web3auth/auth';
-export { AccountLinkingError, WalletInitializationError, WalletLoginError, WalletOperationsError, WalletProviderError, Web3AuthError } from './base/errors/index.js';
+export { AccountLinkingError, formatAccountLinkingErrorMessage, getAccountLinkingRequestError } from './account-linking/errors.js';
 export { BUTTON_POSITION, CONFIRMATION_STRATEGY } from '@web3auth/ws-embed';
 export { BaseConnector } from './base/connector/baseConnector.js';
 export { BaseEvmConnector } from './connectors/base-evm-connector/baseEvmConnector.js';
@@ -10,7 +10,7 @@ export { BaseSolanaConnector } from './connectors/base-solana-connector/baseSola
 export { BiconomySmartAccount, KernelSmartAccount, MetamaskSmartAccount, NexusSmartAccount, SMART_ACCOUNT, SafeSmartAccount, TrustSmartAccount } from '@toruslabs/ethereum-controllers';
 export { CAN_AUTHORIZE_STATUSES, CAN_LOGOUT_STATUSES, CONNECTED_STATUSES } from './base/connector/connectorStatus.js';
 export { CHAIN_NAMESPACES, cloneDeep } from '@toruslabs/base-controllers';
-export { CONNECTOR_CATEGORY, CONNECTOR_EVENTS, CONNECTOR_INITIAL_AUTHENTICATION_MODE, CONNECTOR_STATUS } from './base/connector/constants.js';
+export { CONNECTOR_CATEGORY, CONNECTOR_EVENTS, CONNECTOR_INITIAL_AUTHENTICATION_MODE, CONNECTOR_STATUS, WEB3AUTH_CONNECTOR_ID } from './base/connector/constants.js';
 export { CONNECTOR_NAMES, EVM_CONNECTORS, MULTI_CHAIN_CONNECTORS, SOLANA_CONNECTORS, WALLET_CONNECTORS, WEB3AUTH_ICON } from './base/wallet/index.js';
 export { CONNECTOR_NAMESPACES } from './base/chain/IChainInterface.js';
 export { CommonJRPCProvider } from './providers/base-provider/CommonJRPCProvider.js';
@@ -21,6 +21,7 @@ export { EIP_7702_SUPPORTED_SMART_ACCOUNTS, LOGIN_MODE, MODAL_SIGN_IN_METHODS, S
 export { EVM_PLUGINS, PLUGIN_EVENTS, PLUGIN_NAMESPACES, PLUGIN_STATUS, SOLANA_PLUGINS, WALLET_PLUGINS } from './base/plugin/IPlugin.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';
 export { WalletServicesPluginError } from './base/plugin/errors.js';
 export { Web3AuthContextKey } from './base/composables/index.js';
 export { accountAbstractionProvider, toEoaProvider } from './providers/account-abstraction-provider/providers/AccountAbstractionProvider.js';

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) {
@@ -952,7 +955,8 @@ class Web3AuthNoModal extends SafeEventEmitter {
         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);
@@ -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);
@@ -1014,12 +1019,19 @@ class Web3AuthNoModal extends SafeEventEmitter {
             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,
           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 => {
@@ -1239,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);

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);
         }
@@ -149,11 +156,11 @@ function useWeb3AuthInnerContextValue({
       if (typeof nextIsMFAEnabled === "boolean") setIsMFAEnabled(nextIsMFAEnabled);
     };
     const connectionUpdatedListener = () => {
-      var _web3Auth$currentChai9, _web3Auth$currentChai0;
+      var _web3Auth$currentChai1, _web3Auth$currentChai10;
       setStatus(web3Auth.status);
       setConnection(web3Auth.connection);
       setChainId(web3Auth.currentChainId);
-      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);
+      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);

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, useRef, 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 { 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,6 +95,7 @@ async function disconnectWeb3AuthFromWagmi(config) {
 function Web3AuthWagmiProvider({
   children
 }) {
+  var _connection$ethereumP, _connection$connector;
   const {
     isConnected,
     connection,
@@ -89,59 +109,56 @@ function Web3AuthWagmiProvider({
     mutate: reconnect
   } = useReconnect();
   const suppressWagmiDisconnect = useRef(false);
-  const lastSyncedBinding = useRef({
-    provider: null,
-    connectorName: null
-  });
+  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");
       const isSuppressed = suppressWagmiDisconnect.current;
       suppressWagmiDisconnect.current = false;
       if (!isSuppressed && isConnected) await disconnect();
-      const connector = getWeb3authConnector(wagmiConfig);
+
       // 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 () => {
-      const shouldBindToWagmi = isConnected && chainNamespace === CHAIN_NAMESPACES.EIP155 && Boolean(connection === null || connection === void 0 ? void 0 : connection.ethereumProvider);
+    (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 = lastSyncedBinding.current.provider === connection.ethereumProvider && lastSyncedBinding.current.connectorName === connection.connectorName;
-        if (hasSameBinding && wagmiConfig.state.status === "connected") {
+        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;
         }
-        if (!hasSameBinding && getWeb3authConnector(wagmiConfig)) {
-          if (wagmiConfig.state.status === "connected") {
-            suppressWagmiDisconnect.current = true;
-            await disconnectWeb3AuthFromWagmi(wagmiConfig);
-          } else {
-            resetConnectorState(wagmiConfig);
-          }
+
+        // `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);
         }
-        const connector = await setupConnector(connection.ethereumProvider, 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);
-        lastSyncedBinding.current = {
-          provider: connection.ethereumProvider,
-          connectorName: connection.connectorName
-        };
         reconnect();
       } else {
-        lastSyncedBinding.current = {
-          provider: null,
-          connectorName: null
-        };
+        lastSyncedProvider.current = null;
+        lastSyncedConnectorName.current = null;
         if (wagmiConfig.state.status === "connected") {
           suppressWagmiDisconnect.current = true;
           await disconnectWeb3AuthFromWagmi(wagmiConfig);
-        } else if (getWeb3authConnector(wagmiConfig)) {
+        } else if (w3aWagmiConnector) {
           resetConnectorState(wagmiConfig);
         }
       }
@@ -240,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/useWeb3AuthInnerContextValue.js

@@ -99,20 +99,27 @@ function useWeb3AuthInnerContextValue({
     };
     const authorizedListener = () => {
       status.value = web3Auth.value.status;
+      // 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.
       if (web3Auth.value.status === CONNECTOR_STATUS.AUTHORIZED) {
+        var _currentChain$chainNa2, _currentChain2;
+        if (!isInitialized.value) isInitialized.value = true;
         isAuthorized.value = true;
         isConnected.value = true;
+        connection.value = web3Auth.value.connection;
+        chainId.value = web3Auth.value.currentChainId;
+        chainNamespace.value = (_currentChain$chainNa2 = (_currentChain2 = web3Auth.value.currentChain) === null || _currentChain2 === void 0 ? void 0 : _currentChain2.chainNamespace) !== null && _currentChain$chainNa2 !== void 0 ? _currentChain$chainNa2 : null;
       }
     };
     const consentAcceptedListener = () => {
       status.value = web3Auth.value.status;
       if (web3Auth.value.status === CONNECTOR_STATUS.CONNECTED || web3Auth.value.status === CONNECTOR_STATUS.AUTHORIZED) {
-        var _currentChain$chainNa2, _currentChain2;
+        var _currentChain$chainNa3, _currentChain3;
         if (!isInitialized.value) isInitialized.value = true;
         isConnected.value = true;
         connection.value = web3Auth.value.connection;
         chainId.value = web3Auth.value.currentChainId;
-        chainNamespace.value = (_currentChain$chainNa2 = (_currentChain2 = web3Auth.value.currentChain) === null || _currentChain2 === void 0 ? void 0 : _currentChain2.chainNamespace) !== null && _currentChain$chainNa2 !== void 0 ? _currentChain$chainNa2 : null;
+        chainNamespace.value = (_currentChain$chainNa3 = (_currentChain3 = web3Auth.value.currentChain) === null || _currentChain3 === void 0 ? void 0 : _currentChain3.chainNamespace) !== null && _currentChain$chainNa3 !== void 0 ? _currentChain$chainNa3 : null;
         if (web3Auth.value.status === CONNECTOR_STATUS.AUTHORIZED) {
           isAuthorized.value = true;
         }
@@ -135,11 +142,11 @@ function useWeb3AuthInnerContextValue({
       isMFAEnabled.value = true;
     };
     const connectionUpdatedListener = () => {
-      var _currentChain$chainNa3, _currentChain3;
+      var _currentChain$chainNa4, _currentChain4;
       status.value = web3Auth.value.status;
       connection.value = web3Auth.value.connection;
       chainId.value = web3Auth.value.currentChainId;
-      chainNamespace.value = (_currentChain$chainNa3 = (_currentChain3 = web3Auth.value.currentChain) === null || _currentChain3 === void 0 ? void 0 : _currentChain3.chainNamespace) !== null && _currentChain$chainNa3 !== void 0 ? _currentChain$chainNa3 : null;
+      chainNamespace.value = (_currentChain$chainNa4 = (_currentChain4 = web3Auth.value.currentChain) === null || _currentChain4 === void 0 ? void 0 : _currentChain4.chainNamespace) !== null && _currentChain$chainNa4 !== void 0 ? _currentChain$chainNa4 : null;
     };
     if (prevWeb3Auth && newWeb3Auth !== prevWeb3Auth) {
       prevWeb3Auth.removeListener(CONNECTOR_EVENTS.NOT_READY, notReadyListener);

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

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