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

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

@@ -19,6 +19,7 @@ require('../../base/connector/constants.js');
 require('jwt-decode');
 require('../../base/plugin/errors.js');
 require('../../base/plugin/IPlugin.js');
+var useChain = require('../composables/useChain.js');
 var useWeb3Auth = require('../composables/useWeb3Auth.js');
 var constants = require('./constants.js');
 
@@ -45,58 +46,81 @@ const SolanaProvider = vue.defineComponent({
       connection,
       web3Auth
     } = useWeb3Auth.useWeb3Auth();
+    const {
+      chainId
+    } = useChain.useChain();
     const clientRef = vue.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
     vue.provide(constants.SOLANA_CLIENT_KEY, clientRef);
-    // watch for changes in the connection and chain namespace
-    vue.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) !== baseControllers.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) === baseControllers.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 === baseControllers.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$1 = null;
       try {
         // create a wallet standard connector from connected wallet
-        const solanaWalletId = "wallet-standard:" + connection.value.connectorName;
-        const connector = client.createWalletStandardConnector(connection.value.solanaWallet, {
+        const solanaWalletId = "wallet-standard:" + newConnection.connectorName;
+        const connector = client.createWalletStandardConnector(newConnection.solanaWallet, {
           id: solanaWalletId,
-          name: connection.value.connectorName
+          name: newConnection.connectorName
         });
         // create a solana client
         const {
           rpcTarget,
           wsTarget
-        } = chainConfig;
-        const client$1 = client.createClient({
+        } = currentChain;
+        client$1 = client.createClient({
           endpoint: rpcTarget,
           websocketEndpoint: wsTarget,
           walletConnectors: [connector]
         });
-        clientRef.value = client$1;
-        if (prevClient) await disposeClient(prevClient);
         // connect the client to the wallet
         await client$1.actions.connectWallet(solanaWalletId, {
           autoConnect: true
         });
+        // If another sync started while connectWallet was in flight, this client is stale.
+        if (activeSyncToken !== syncToken) {
+          await disposeClient(client$1);
+          return;
+        }
+        clientRef.value = client$1;
       } catch (err) {
+        if (client$1) {
+          await disposeClient(client$1);
+        }
         loglevel.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
+    vue.watch([isConnected, connection, chainId], () => {
+      void syncClient();
     }, {
       immediate: true
     });

package/dist/lib.cjs/vue/wagmi/provider.js

@@ -89,7 +89,8 @@ const Web3AuthWagmiProvider = vue.defineComponent({
   setup() {
     const {
       isConnected,
-      connection
+      connection,
+      chainNamespace
     } = useWeb3Auth.useWeb3Auth();
     const {
       disconnect
@@ -98,11 +99,15 @@ const Web3AuthWagmiProvider = vue.defineComponent({
     const {
       mutate: reconnect
     } = vue$1.useReconnect();
-    const lastSyncedWeb3AuthConnection = vue.shallowRef(null);
+    const lastSyncedProvider = vue.shallowRef(null);
+    const lastSyncedConnectorName = vue.ref(null);
+    const suppressWagmiDisconnect = vue.ref(false);
     vue$1.useConnectionEffect({
       onDisconnect: async () => {
         loglevel.log.info("Disconnected from wagmi");
-        if (isConnected.value) await disconnect();
+        const isSuppressed = suppressWagmiDisconnect.value;
+        suppressWagmiDisconnect.value = false;
+        if (!isSuppressed && isConnected.value) await disconnect();
         const connector = getWeb3authConnector(wagmiConfig);
         // reset wagmi connector state if the provider handles disconnection because of the accountsChanged event
         // from the connected provider
@@ -111,30 +116,41 @@ const Web3AuthWagmiProvider = vue.defineComponent({
         }
       }
     });
-    vue.watch([isConnected, connection], async () => {
+    vue.watch([isConnected, connection, chainNamespace], async () => {
       var _newConnection$ethere;
       const newIsConnected = isConnected.value;
       const newConnection = connection.value;
       const newEth = (_newConnection$ethere = newConnection === null || newConnection === void 0 ? void 0 : newConnection.ethereumProvider) !== null && _newConnection$ethere !== void 0 ? _newConnection$ethere : null;
-      if (newIsConnected && newConnection && newEth) {
-        // Linked-account switches can reuse or replace the underlying wallet provider,
-        // so key wagmi resyncs off the Web3Auth connection object instead of provider identity.
-        if (lastSyncedWeb3AuthConnection.value !== newConnection) {
-          if (getWeb3authConnector(wagmiConfig)) {
+      const shouldBindToWagmi = newIsConnected && chainNamespace.value === baseControllers.CHAIN_NAMESPACES.EIP155 && Boolean(newConnection && newEth);
+      if (shouldBindToWagmi && newConnection && newEth) {
+        const hasSameBinding = lastSyncedProvider.value === newEth && lastSyncedConnectorName.value === newConnection.connectorName;
+        if (hasSameBinding && wagmiConfig.state.status === "connected") {
+          return;
+        }
+        if (!hasSameBinding && getWeb3authConnector(wagmiConfig)) {
+          if (wagmiConfig.state.status === "connected") {
+            suppressWagmiDisconnect.value = true;
+            await disconnectWeb3AuthFromWagmi(wagmiConfig);
+          } else {
             resetConnectorState(wagmiConfig);
           }
-          lastSyncedWeb3AuthConnection.value = newConnection;
-          const connector = await setupConnector(newEth, wagmiConfig);
-          if (!connector) {
-            throw new Error("Failed to setup connector");
-          }
-          await connectWeb3AuthWithWagmi(connector, wagmiConfig);
-          reconnect();
         }
-      } else if (!newIsConnected) {
-        lastSyncedWeb3AuthConnection.value = null;
+        const connector = await setupConnector(newEth, wagmiConfig);
+        if (!connector) {
+          throw new Error("Failed to setup connector");
+        }
+        await connectWeb3AuthWithWagmi(connector, wagmiConfig);
+        lastSyncedProvider.value = newEth;
+        lastSyncedConnectorName.value = newConnection.connectorName;
+        reconnect();
+      } else {
+        lastSyncedProvider.value = null;
+        lastSyncedConnectorName.value = null;
         if (wagmiConfig.state.status === "connected") {
+          suppressWagmiDisconnect.value = true;
           await disconnectWeb3AuthFromWagmi(wagmiConfig);
+        } else if (getWeb3authConnector(wagmiConfig)) {
+          resetConnectorState(wagmiConfig);
         }
       }
     }, {

package/dist/lib.esm/base/utils.js

@@ -149,7 +149,7 @@ const getWalletServicesAnalyticsProperties = walletServicesConfig => {
     ws_default_portfolio: walletServicesConfig === null || walletServicesConfig === void 0 || (_walletServicesConfig10 = walletServicesConfig.whiteLabel) === null || _walletServicesConfig10 === void 0 ? void 0 : _walletServicesConfig10.defaultPortfolio
   };
 };
-const sdkVersion = "11.0.0-beta.1";
+const sdkVersion = "11.0.0-beta.2";
 const getErrorAnalyticsProperties = error => {
   try {
     const code = error instanceof Web3AuthError ? error.code : error === null || error === void 0 ? void 0 : error.code;

package/dist/lib.esm/connectors/auth-connector/authConnector.js

@@ -6,6 +6,7 @@ import { SecurePubSub } from '@toruslabs/secure-pub-sub';
 import { BUILD_ENV, UX_MODE, Auth, SDK_MODE, SUPPORTED_KEY_CURVES, generateRecordId, version, createHandler, PopupHandler, getUserId } from '@web3auth/auth';
 import { WS_EMBED_LOGIN_MODE } from '@web3auth/ws-embed';
 import deepmerge from 'deepmerge';
+import { numberToHex } from 'viem';
 import { generateNonce, parseToken } from '../utils.js';
 import { AuthSolanaWallet } from './authSolanaWallet.js';
 import { WalletLoginError, WalletInitializationError, Web3AuthError, AccountLinkingError } from '../../base/errors/index.js';
@@ -13,13 +14,22 @@ import { WALLET_CONNECTORS } from '../../base/wallet/index.js';
 import { BaseConnector } from '../../base/connector/baseConnector.js';
 import { CONNECTOR_NAMESPACES } from '../../base/chain/IChainInterface.js';
 import { CONNECTOR_CATEGORY, CONNECTOR_STATUS, CONNECTOR_EVENTS } from '../../base/connector/constants.js';
-import { Analytics, ANALYTICS_EVENTS } from '../../base/analytics.js';
-import { log } from '../../base/loglevel.js';
-import { citadelServerUrl, getCaipChainId, getErrorAnalyticsProperties, parseChainNamespaceFromCitadelResponse } from '../../base/utils.js';
 import { CONNECTED_STATUSES } from '../../base/connector/connectorStatus.js';
+import { log } from '../../base/loglevel.js';
+import { Analytics, ANALYTICS_EVENTS } from '../../base/analytics.js';
+import { citadelServerUrl, getErrorAnalyticsProperties, parseChainNamespaceFromCitadelResponse } from '../../base/utils.js';
 import { makeAccountLinkingRequest, makeAccountUnlinkingRequest } from '../../account-linking/rest.js';
 import { CHAIN_NAMESPACES, cloneDeep } from '@toruslabs/base-controllers';
 
+// Auth connections that have been deprecated and are no longer supported by the SDK.
+// Passing any of these as `authConnection` results in a hard error so consumers
+// migrate off the removed providers instead of silently continuing.
+const DEPRECATED_AUTH_CONNECTIONS = new Set(["farcaster"]);
+function assertAuthConnectionSupported(authConnection) {
+  if (DEPRECATED_AUTH_CONNECTIONS.has(authConnection)) {
+    throw WalletInitializationError.invalidParams(`Auth connection "${authConnection}" has been deprecated and is no longer supported by the Web3Auth SDKs. ` + `Please use a different authConnection value.`);
+  }
+}
 class AuthConnector extends BaseConnector {
   constructor(params) {
     super(params);
@@ -37,8 +47,22 @@ class AuthConnector extends BaseConnector {
     _defineProperty(this, "wsEmbedInstance", null);
     _defineProperty(this, "authConnectionConfig", []);
     _defineProperty(this, "wsEmbedInstancePromise", null);
+    _defineProperty(this, "wsEmbedProviderListenerTarget", null);
     _defineProperty(this, "_solanaWallet", null);
     _defineProperty(this, "analytics", void 0);
+    _defineProperty(this, "handleWsEmbedAccountsChanged", accounts => {
+      if (accounts.length === 0) {
+        if (!CONNECTED_STATUSES.includes(this.status)) {
+          return;
+        }
+        log.info("No accounts found in the wallet, disconnecting");
+        void this.disconnect({
+          cleanup: true
+        }).catch(error => {
+          log.error("Failed to disconnect auth connector after wallet accounts changed", error);
+        });
+      }
+    });
     this.authOptions = params.connectorSettings;
     this.loginSettings = params.loginSettings || {
       authConnection: ""
@@ -51,10 +75,8 @@ class AuthConnector extends BaseConnector {
   }
   get provider() {
     if (this.status !== CONNECTOR_STATUS.NOT_READY) {
-      var _this$wsEmbedInstance;
-      if ((_this$wsEmbedInstance = this.wsEmbedInstance) !== null && _this$wsEmbedInstance !== void 0 && _this$wsEmbedInstance.provider) {
-        return this.wsEmbedInstance.provider;
-      } else if (this.privateKeyProvider) return this.privateKeyProvider;
+      const wsEmbedProvider = this.getWsEmbedProvider();
+      return wsEmbedProvider || this.privateKeyProvider;
     }
     return null;
   }
@@ -123,6 +145,7 @@ class AuthConnector extends BaseConnector {
               buildEnv: this.authOptions.buildEnv,
               whiteLabel: _objectSpread(_objectSpread({}, this.authOptions.whiteLabel), this.wsSettings.whiteLabel)
             })).then(() => {
+              this.bindWsEmbedProviderEvents();
               this.wsEmbedInstancePromise = null;
               return;
             });
@@ -172,6 +195,7 @@ class AuthConnector extends BaseConnector {
     }
   }
   async connect(params) {
+    assertAuthConnectionSupported(params === null || params === void 0 ? void 0 : params.authConnection);
     super.checkConnectionRequirements();
     this.status = CONNECTOR_STATUS.CONNECTING;
     this.emit(CONNECTOR_EVENTS.CONNECTING, _objectSpread(_objectSpread({}, params), {}, {
@@ -201,6 +225,7 @@ class AuthConnector extends BaseConnector {
   async enableMFA(params = {
     authConnection: ""
   }) {
+    assertAuthConnectionSupported(params === null || params === void 0 ? void 0 : params.authConnection);
     if (!this.connected) throw WalletLoginError.notConnectedError("Not connected with wallet");
     if (!this.authInstance) throw WalletInitializationError.notReady("authInstance is not ready");
     try {
@@ -218,6 +243,7 @@ class AuthConnector extends BaseConnector {
   async manageMFA(params = {
     authConnection: ""
   }) {
+    assertAuthConnectionSupported(params === null || params === void 0 ? void 0 : params.authConnection);
     if (!this.connected) throw WalletLoginError.notConnectedError("Not connected with wallet");
     if (!this.authInstance) throw WalletInitializationError.notReady("authInstance is not ready");
     try {
@@ -249,6 +275,7 @@ class AuthConnector extends BaseConnector {
     }
     this.rehydrated = false;
     this._solanaWallet = null;
+    this.unbindWsEmbedProviderEvents();
     this.emit(CONNECTOR_EVENTS.DISCONNECTED, {
       connector: WALLET_CONNECTORS.AUTH
     });
@@ -310,13 +337,15 @@ class AuthConnector extends BaseConnector {
     const newChainConfig = this.coreOptions.chains.find(c => c.chainId === newChainId);
     if (!newChainConfig) throw WalletInitializationError.invalidParams("Chain config is not available");
     if (newChainConfig.chainNamespace === CHAIN_NAMESPACES.SOLANA || newChainConfig.chainNamespace === CHAIN_NAMESPACES.EIP155) {
-      var _this$wsEmbedInstance2;
-      if (!((_this$wsEmbedInstance2 = this.wsEmbedInstance) !== null && _this$wsEmbedInstance2 !== void 0 && _this$wsEmbedInstance2.provider)) throw WalletInitializationError.notReady("Wallet embed is not ready");
-      const fullChainId = getCaipChainId(newChainConfig);
+      var _this$wsEmbedInstance;
+      if (!((_this$wsEmbedInstance = this.wsEmbedInstance) !== null && _this$wsEmbedInstance !== void 0 && _this$wsEmbedInstance.provider)) throw WalletInitializationError.notReady("Wallet embed is not ready");
+      const chainIdNum = parseInt(newChainConfig.chainId, 16);
+      // WsEmbed expects the chainId in hex format
+      const chainIdHex = numberToHex(chainIdNum);
       await this.wsEmbedInstance.provider.request({
         method: "wallet_switchChain",
         params: {
-          chainId: fullChainId
+          chainId: chainIdHex
         }
       });
     } else {
@@ -330,6 +359,8 @@ class AuthConnector extends BaseConnector {
     if (this.wsEmbedInstance) {
       this.wsEmbedInstance.clearInit();
     }
+    this._solanaWallet = null;
+    this.unbindWsEmbedProviderEvents();
   }
   getOAuthProviderConfig(params) {
     const {
@@ -416,11 +447,11 @@ class AuthConnector extends BaseConnector {
     const {
       connectorName,
       chainId,
-      walletConnector
+      connectorToLink
     } = params;
     try {
-      if (!walletConnector.connected) {
-        const connection = await walletConnector.connect({
+      if (!connectorToLink.connected) {
+        const connection = await connectorToLink.connect({
           chainId,
           isAccountLinking: true
         });
@@ -445,7 +476,7 @@ class AuthConnector extends BaseConnector {
         accessToken,
         idToken
       } = await this.getPrimaryAuthSession(params.authSessionTokens);
-      const walletProof = await this.createWalletLinkingProof(params.walletConnector);
+      const walletProof = await this.createWalletLinkingProof(params.connectorToLink);
       const authServerUrl = citadelServerUrl(this.coreOptions.authBuildEnv);
       const result = await makeAccountLinkingRequest(authServerUrl, accessToken, {
         idToken,
@@ -466,9 +497,11 @@ class AuthConnector extends BaseConnector {
 
       // disconnect the wallet connector to avoid any leftover state
       try {
-        await walletConnector.disconnect({
-          cleanup: true
-        });
+        if (connectorToLink.connected) {
+          await connectorToLink.disconnect({
+            cleanup: true
+          });
+        }
       } catch (disconnectError) {
         log.debug("Failed to disconnect wallet connector after linking failure", disconnectError);
       }
@@ -690,9 +723,35 @@ class AuthConnector extends BaseConnector {
     }
     return accounts[0];
   }
+  getWsEmbedProvider() {
+    var _ref, _this$wsEmbedInstance2;
+    return (_ref = (_this$wsEmbedInstance2 = this.wsEmbedInstance) === null || _this$wsEmbedInstance2 === void 0 ? void 0 : _this$wsEmbedInstance2.provider) !== null && _ref !== void 0 ? _ref : null;
+  }
+  bindWsEmbedProviderEvents() {
+    const rawProvider = this.getWsEmbedProvider();
+    if (this.wsEmbedProviderListenerTarget === rawProvider) {
+      return;
+    }
+    this.unbindWsEmbedProviderEvents();
+    if (!rawProvider) {
+      return;
+    }
+    rawProvider.on("accountsChanged", this.handleWsEmbedAccountsChanged);
+    this.wsEmbedProviderListenerTarget = rawProvider;
+  }
+  unbindWsEmbedProviderEvents() {
+    if (!this.wsEmbedProviderListenerTarget) {
+      return;
+    }
+    this.wsEmbedProviderListenerTarget.removeListener("accountsChanged", this.handleWsEmbedAccountsChanged);
+    this.wsEmbedProviderListenerTarget = null;
+  }
   setupSolanaWallet() {
     const solanaChains = this.coreOptions.chains.filter(c => c.chainNamespace === CHAIN_NAMESPACES.SOLANA);
     if (solanaChains.length === 0 || !this.provider) return;
+    if (this._solanaWallet instanceof AuthSolanaWallet) {
+      return;
+    }
     this._solanaWallet = new AuthSolanaWallet(this.provider, solanaChains);
   }
   _getFinalPrivKey() {
@@ -755,13 +814,13 @@ class AuthConnector extends BaseConnector {
       } = this.authInstance || {};
       if (sessionId) {
         this.wsEmbedInstance.setAccessTokenProvider(this.accessTokenProvider.bind(this));
+        this.bindWsEmbedProviderEvents();
         const isLoggedIn = await this.wsEmbedInstance.connectWithSession({
           sessionId,
           sessionNamespace,
           idToken: await this.getIdToken()
         });
         if (isLoggedIn) {
-          var _this$wsEmbedInstance3;
           this.setupSolanaWallet();
           // if getAuthTokenInfo is true, then get auth token info
           // No need to get auth token info for auth connector as it is already handled
@@ -775,12 +834,6 @@ class AuthConnector extends BaseConnector {
           if (params.getAuthTokenInfo) {
             await this.getAuthTokenInfo();
           }
-          // handle disconnect from ws embed
-          (_this$wsEmbedInstance3 = this.wsEmbedInstance) === null || _this$wsEmbedInstance3 === void 0 || _this$wsEmbedInstance3.provider.on("accountsChanged", (accounts = []) => {
-            if (accounts.length === 0 && CONNECTED_STATUSES.includes(this.status)) this.disconnect({
-              cleanup: false
-            });
-          });
         }
       }
     } else {
@@ -882,9 +935,7 @@ class AuthConnector extends BaseConnector {
       }).catch(error => {
         // swallow the error, dont need to throw.
         log.error("Error during login with social", error);
-        this.auditOAuditProgress(loginParams, "failed").catch(error => {
-          log.error("Error reporting `oauthFailed` audit progress", error);
-        });
+        this.reportFailedOauthAudit(loginParams);
       });
       verifierWindow.once("close", () => {
         if (!isClosedWindow) {
@@ -894,9 +945,7 @@ class AuthConnector extends BaseConnector {
         }
       });
       this.authInstance.postLoginInitiatedMessage(loginParams, nonce).then(resolve).catch(error => {
-        this.auditOAuditProgress(loginParams, "failed").catch(error => {
-          log.error("Error reporting `oauthFailed` audit progress", error);
-        });
+        this.reportFailedOauthAudit(loginParams);
         if (error instanceof Web3AuthError) {
           throw error;
         }
@@ -1012,6 +1061,11 @@ class AuthConnector extends BaseConnector {
     }
     await put(auditServerUrl, auditPayload);
   }
+  reportFailedOauthAudit(loginParams) {
+    void this.auditOAuditProgress(loginParams, "failed").catch(error => {
+      log.error("Error reporting `oauthFailed` audit progress", error);
+    });
+  }
 }
 const authConnector = params => {
   return ({

package/dist/lib.esm/noModal.js

@@ -925,7 +925,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 +949,15 @@ 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
       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)) {
@@ -989,23 +989,36 @@ 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
         }));
       }
     });
@@ -1381,12 +1394,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 +1408,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 +1588,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/react/context/useWeb3AuthInnerContextValue.js

@@ -148,6 +148,13 @@ function useWeb3AuthInnerContextValue({
     const mfaEnabledListener = nextIsMFAEnabled => {
       if (typeof nextIsMFAEnabled === "boolean") setIsMFAEnabled(nextIsMFAEnabled);
     };
+    const connectionUpdatedListener = () => {
+      var _web3Auth$currentChai9, _web3Auth$currentChai0;
+      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);
+    };
     if (web3Auth) {
       web3Auth.on(CONNECTOR_EVENTS.NOT_READY, notReadyListener);
       web3Auth.on(CONNECTOR_EVENTS.READY, readyListener);
@@ -158,6 +165,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 +181,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) {