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

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

@@ -145,7 +145,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 index.Web3AuthError ? error.code : error === null || error === void 0 ? void 0 : error.code;

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

@@ -8,7 +8,7 @@ var securePubSub = require('@toruslabs/secure-pub-sub');
 var auth = require('@web3auth/auth');
 var wsEmbed = require('@web3auth/ws-embed');
 var deepmerge = require('deepmerge');
-var rest = require('../../account-linking/rest.js');
+var viem = require('viem');
 var analytics = require('../../base/analytics.js');
 var IChainInterface = require('../../base/chain/IChainInterface.js');
 var baseConnector = require('../../base/connector/baseConnector.js');
@@ -24,8 +24,18 @@ var utils = require('../../base/utils.js');
 var index$1 = require('../../base/wallet/index.js');
 var utils$1 = require('../utils.js');
 var authSolanaWallet = require('./authSolanaWallet.js');
+var rest = require('../../account-linking/rest.js');
 var baseControllers = require('@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 index.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.BaseConnector {
   constructor(params) {
     super(params);
@@ -43,8 +53,22 @@ class AuthConnector extends baseConnector.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 (!connectorStatus.CONNECTED_STATUSES.includes(this.status)) {
+          return;
+        }
+        loglevel.log.info("No accounts found in the wallet, disconnecting");
+        void this.disconnect({
+          cleanup: true
+        }).catch(error => {
+          loglevel.log.error("Failed to disconnect auth connector after wallet accounts changed", error);
+        });
+      }
+    });
     this.authOptions = params.connectorSettings;
     this.loginSettings = params.loginSettings || {
       authConnection: ""
@@ -57,10 +81,8 @@ class AuthConnector extends baseConnector.BaseConnector {
   }
   get provider() {
     if (this.status !== constants.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;
   }
@@ -127,6 +149,7 @@ class AuthConnector extends baseConnector.BaseConnector {
               buildEnv: this.authOptions.buildEnv,
               whiteLabel: _objectSpread(_objectSpread({}, this.authOptions.whiteLabel), this.wsSettings.whiteLabel)
             })).then(() => {
+              this.bindWsEmbedProviderEvents();
               this.wsEmbedInstancePromise = null;
               return;
             });
@@ -175,6 +198,7 @@ class AuthConnector extends baseConnector.BaseConnector {
     }
   }
   async connect(params) {
+    assertAuthConnectionSupported(params === null || params === void 0 ? void 0 : params.authConnection);
     super.checkConnectionRequirements();
     this.status = constants.CONNECTOR_STATUS.CONNECTING;
     this.emit(constants.CONNECTOR_EVENTS.CONNECTING, _objectSpread(_objectSpread({}, params), {}, {
@@ -204,6 +228,7 @@ class AuthConnector extends baseConnector.BaseConnector {
   async enableMFA(params = {
     authConnection: ""
   }) {
+    assertAuthConnectionSupported(params === null || params === void 0 ? void 0 : params.authConnection);
     if (!this.connected) throw index.WalletLoginError.notConnectedError("Not connected with wallet");
     if (!this.authInstance) throw index.WalletInitializationError.notReady("authInstance is not ready");
     try {
@@ -221,6 +246,7 @@ class AuthConnector extends baseConnector.BaseConnector {
   async manageMFA(params = {
     authConnection: ""
   }) {
+    assertAuthConnectionSupported(params === null || params === void 0 ? void 0 : params.authConnection);
     if (!this.connected) throw index.WalletLoginError.notConnectedError("Not connected with wallet");
     if (!this.authInstance) throw index.WalletInitializationError.notReady("authInstance is not ready");
     try {
@@ -252,6 +278,7 @@ class AuthConnector extends baseConnector.BaseConnector {
     }
     this.rehydrated = false;
     this._solanaWallet = null;
+    this.unbindWsEmbedProviderEvents();
     this.emit(constants.CONNECTOR_EVENTS.DISCONNECTED, {
       connector: index$1.WALLET_CONNECTORS.AUTH
     });
@@ -313,13 +340,15 @@ class AuthConnector extends baseConnector.BaseConnector {
     const newChainConfig = this.coreOptions.chains.find(c => c.chainId === newChainId);
     if (!newChainConfig) throw index.WalletInitializationError.invalidParams("Chain config is not available");
     if (newChainConfig.chainNamespace === baseControllers.CHAIN_NAMESPACES.SOLANA || newChainConfig.chainNamespace === baseControllers.CHAIN_NAMESPACES.EIP155) {
-      var _this$wsEmbedInstance2;
-      if (!((_this$wsEmbedInstance2 = this.wsEmbedInstance) !== null && _this$wsEmbedInstance2 !== void 0 && _this$wsEmbedInstance2.provider)) throw index.WalletInitializationError.notReady("Wallet embed is not ready");
-      const fullChainId = utils.getCaipChainId(newChainConfig);
+      var _this$wsEmbedInstance;
+      if (!((_this$wsEmbedInstance = this.wsEmbedInstance) !== null && _this$wsEmbedInstance !== void 0 && _this$wsEmbedInstance.provider)) throw index.WalletInitializationError.notReady("Wallet embed is not ready");
+      const chainIdNum = parseInt(newChainConfig.chainId, 16);
+      // WsEmbed expects the chainId in hex format
+      const chainIdHex = viem.numberToHex(chainIdNum);
       await this.wsEmbedInstance.provider.request({
         method: "wallet_switchChain",
         params: {
-          chainId: fullChainId
+          chainId: chainIdHex
         }
       });
     } else {
@@ -333,6 +362,8 @@ class AuthConnector extends baseConnector.BaseConnector {
     if (this.wsEmbedInstance) {
       this.wsEmbedInstance.clearInit();
     }
+    this._solanaWallet = null;
+    this.unbindWsEmbedProviderEvents();
   }
   getOAuthProviderConfig(params) {
     const {
@@ -419,11 +450,11 @@ class AuthConnector extends baseConnector.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
         });
@@ -448,7 +479,7 @@ class AuthConnector extends baseConnector.BaseConnector {
         accessToken,
         idToken
       } = await this.getPrimaryAuthSession(params.authSessionTokens);
-      const walletProof = await this.createWalletLinkingProof(params.walletConnector);
+      const walletProof = await this.createWalletLinkingProof(params.connectorToLink);
       const authServerUrl = utils.citadelServerUrl(this.coreOptions.authBuildEnv);
       const result = await rest.makeAccountLinkingRequest(authServerUrl, accessToken, {
         idToken,
@@ -468,9 +499,11 @@ class AuthConnector extends baseConnector.BaseConnector {
       this.analytics.track(analytics.ANALYTICS_EVENTS.ACCOUNT_LINKING_FAILED, _objectSpread(_objectSpread({}, trackData), utils.getErrorAnalyticsProperties(error)));
       // 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) {
         loglevel.log.debug("Failed to disconnect wallet connector after linking failure", disconnectError);
       }
@@ -692,9 +725,35 @@ class AuthConnector extends baseConnector.BaseConnector {
     }
     return accounts[0];
   }
+  getWsEmbedProvider() {
+    var _this$wsEmbedInstance2, _this$wsEmbedInstance3;
+    return (_this$wsEmbedInstance2 = (_this$wsEmbedInstance3 = this.wsEmbedInstance) === null || _this$wsEmbedInstance3 === void 0 ? void 0 : _this$wsEmbedInstance3.provider) !== null && _this$wsEmbedInstance2 !== void 0 ? _this$wsEmbedInstance2 : 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 === baseControllers.CHAIN_NAMESPACES.SOLANA);
     if (solanaChains.length === 0 || !this.provider) return;
+    if (this._solanaWallet instanceof authSolanaWallet.AuthSolanaWallet) {
+      return;
+    }
     this._solanaWallet = new authSolanaWallet.AuthSolanaWallet(this.provider, solanaChains);
   }
   _getFinalPrivKey() {
@@ -754,13 +813,13 @@ class AuthConnector extends baseConnector.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
@@ -774,12 +833,6 @@ class AuthConnector extends baseConnector.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 && connectorStatus.CONNECTED_STATUSES.includes(this.status)) this.disconnect({
-              cleanup: false
-            });
-          });
         }
       }
     } else {
@@ -879,9 +932,7 @@ class AuthConnector extends baseConnector.BaseConnector {
       }).catch(error => {
         // swallow the error, dont need to throw.
         loglevel.log.error("Error during login with social", error);
-        this.auditOAuditProgress(loginParams, "failed").catch(error => {
-          loglevel.log.error("Error reporting `oauthFailed` audit progress", error);
-        });
+        this.reportFailedOauthAudit(loginParams);
       });
       verifierWindow.once("close", () => {
         if (!isClosedWindow) {
@@ -891,9 +942,7 @@ class AuthConnector extends baseConnector.BaseConnector {
         }
       });
       this.authInstance.postLoginInitiatedMessage(loginParams, nonce).then(resolve).catch(error => {
-        this.auditOAuditProgress(loginParams, "failed").catch(error => {
-          loglevel.log.error("Error reporting `oauthFailed` audit progress", error);
-        });
+        this.reportFailedOauthAudit(loginParams);
         if (error instanceof index.Web3AuthError) {
           throw error;
         }
@@ -1007,6 +1056,11 @@ class AuthConnector extends baseConnector.BaseConnector {
     }
     await httpHelpers.put(auditServerUrl, auditPayload);
   }
+  reportFailedOauthAudit(loginParams) {
+    void this.auditOAuditProgress(loginParams, "failed").catch(error => {
+      loglevel.log.error("Error reporting `oauthFailed` audit progress", error);
+    });
+  }
 }
 const authConnector = params => {
   return ({

package/dist/lib.cjs/index.js

@@ -1,6 +1,5 @@
 'use strict';
 
-var rest = require('./account-linking/rest.js');
 var analytics = require('./base/analytics.js');
 var IChainInterface = require('./base/chain/IChainInterface.js');
 var index$2 = require('./base/composables/index.js');
@@ -43,12 +42,11 @@ var wsEmbed = require('@web3auth/ws-embed');
 var baseControllers = require('@toruslabs/base-controllers');
 var app = require('@wallet-standard/app');
 var solana = require('./base/wallet/solana.js');
+var rest = require('./account-linking/rest.js');
 var walletStandardConnector = require('./connectors/injected-solana-connector/walletStandardConnector.js');
 
 
 
-exports.makeAccountLinkingRequest = rest.makeAccountLinkingRequest;
-exports.makeAccountUnlinkingRequest = rest.makeAccountUnlinkingRequest;
 exports.ANALYTICS_EVENTS = analytics.ANALYTICS_EVENTS;
 exports.ANALYTICS_INTEGRATION_TYPE = analytics.ANALYTICS_INTEGRATION_TYPE;
 exports.ANALYTICS_SDK_TYPE = analytics.ANALYTICS_SDK_TYPE;
@@ -239,4 +237,6 @@ exports.getSolanaChainByChainConfig = solana.getSolanaChainByChainConfig;
 exports.walletSignAndSendTransaction = solana.walletSignAndSendTransaction;
 exports.walletSignMessage = solana.walletSignMessage;
 exports.walletSignTransaction = solana.walletSignTransaction;
+exports.makeAccountLinkingRequest = rest.makeAccountLinkingRequest;
+exports.makeAccountUnlinkingRequest = rest.makeAccountUnlinkingRequest;
 exports.walletStandardConnector = walletStandardConnector.walletStandardConnector;

package/dist/lib.cjs/noModal.js

@@ -908,7 +908,6 @@ class Web3AuthNoModal extends auth.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) {
         try {
@@ -931,14 +930,15 @@ class Web3AuthNoModal extends auth.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 !== index$1.WALLET_CONNECTORS.AUTH) {
         var _ref3, _walletConnector$prov, _linkedAccountConnect, _ref4, _walletConnector$sola, _linkedAccountConnect2;
         const accountLinkingConnector = authConnector.isAuthConnector(connector) ? connector : this.getConnector(index$1.WALLET_CONNECTORS.AUTH);
         authConnector.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)) {
@@ -970,23 +970,36 @@ class Web3AuthNoModal extends auth.SafeEventEmitter {
       });
       this.setConnectedWalletConnectorState(primaryConnectedWalletState);
       await this.setState({
-        primaryConnectorName: data.connectorName,
-        currentChainId: connectedChainId
+        primaryConnectorName: data.connectorName
       });
       this.cacheWallet(data.connectorName);
       const isConnectAndSign = this.coreOptions.initialAuthenticationMode === constants.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 = constants.CONNECTOR_STATUS.CONSENT_REQUIRING;
         this.emit(constants.CONNECTOR_EVENTS.CONSENT_REQUIRING);
         loglevel.log.debug("consent_requiring", this.status, this.primaryConnectorName);
       } else {
-        this.status = constants.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 !== constants.CONNECTOR_STATUS.CONSENT_REQUIRING && this.status !== constants.CONNECTOR_STATUS.AUTHORIZED) {
+          this.status = constants.CONNECTOR_STATUS.CONNECTED;
+        }
         loglevel.log.debug("connected", this.status, this.primaryConnectorName);
-        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(constants.CONNECTOR_EVENTS.CONNECTED, _objectSpread(_objectSpread({}, data), {}, {
-          loginMode: this.loginMode
+          loginMode: this.loginMode,
+          pendingUserConsent
         }));
       }
     });
@@ -1357,12 +1370,12 @@ class Web3AuthNoModal extends auth.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
@@ -1371,7 +1384,7 @@ class Web3AuthNoModal extends auth.SafeEventEmitter {
     await this.setState({
       idToken: result.idToken
     });
-    await this.cacheConnectedLinkedWalletConnector(authConnector, walletConnector);
+    await this.cacheConnectedLinkedWalletConnector(authConnector, connectorToLink);
     return result;
   }
   getMainAuthConnector() {
@@ -1550,7 +1563,10 @@ class Web3AuthNoModal extends auth.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 index.WalletInitializationError.invalidParams(`Invalid chainId: ${chainId}`);
     await this.setState({

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

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

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

@@ -69,6 +69,7 @@ function useFrameworkKitSolanaClient() {
     isInitialized
   } = useWeb3Auth.useWeb3Auth();
   const {
+    chainId,
     chainNamespace
   } = useChain.useChain();
   const ref = react.useRef(null);
@@ -118,7 +119,10 @@ function useFrameworkKitSolanaClient() {
         return;
       }
       // 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 = client.createWalletStandardConnector(solanaWallet, {
@@ -150,7 +154,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$1;
 }
 function SolanaProvider(_ref) {

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

@@ -92,7 +92,8 @@ function Web3AuthWagmiProvider({
 }) {
   const {
     isConnected,
-    connection
+    connection,
+    chainNamespace
   } = useWeb3Auth.useWeb3Auth();
   const {
     disconnect
@@ -101,10 +102,17 @@ function Web3AuthWagmiProvider({
   const {
     mutate: reconnect
   } = wagmi.useReconnect();
+  const suppressWagmiDisconnect = react.useRef(false);
+  const lastSyncedBinding = react.useRef({
+    provider: null,
+    connectorName: null
+  });
   wagmi.useConnectionEffect({
     onDisconnect: async () => {
       loglevel.log.info("Disconnected from wagmi");
-      if (isConnected) await disconnect();
+      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
@@ -115,20 +123,44 @@ function Web3AuthWagmiProvider({
   });
   react.useEffect(() => {
     (async () => {
-      if (isConnected && connection !== null && connection !== void 0 && connection.ethereumProvider) {
+      const shouldBindToWagmi = isConnected && chainNamespace === baseControllers.CHAIN_NAMESPACES.EIP155 && Boolean(connection === null || connection === void 0 ? void 0 : connection.ethereumProvider);
+      if (shouldBindToWagmi) {
+        const hasSameBinding = lastSyncedBinding.current.provider === connection.ethereumProvider && lastSyncedBinding.current.connectorName === connection.connectorName;
+        if (hasSameBinding && wagmiConfig.state.status === "connected") {
+          return;
+        }
+        if (!hasSameBinding && getWeb3authConnector(wagmiConfig)) {
+          if (wagmiConfig.state.status === "connected") {
+            suppressWagmiDisconnect.current = true;
+            await disconnectWeb3AuthFromWagmi(wagmiConfig);
+          } else {
+            resetConnectorState(wagmiConfig);
+          }
+        }
         const connector = await setupConnector(connection.ethereumProvider, wagmiConfig);
         if (!connector) {
           throw new Error("Failed to setup connector");
         }
         await connectWeb3AuthWithWagmi(connector, wagmiConfig);
+        lastSyncedBinding.current = {
+          provider: connection.ethereumProvider,
+          connectorName: connection.connectorName
+        };
         reconnect();
-      } else if (!isConnected) {
+      } else {
+        lastSyncedBinding.current = {
+          provider: null,
+          connectorName: null
+        };
         if (wagmiConfig.state.status === "connected") {
+          suppressWagmiDisconnect.current = true;
           await disconnectWeb3AuthFromWagmi(wagmiConfig);
+        } else if (getWeb3authConnector(wagmiConfig)) {
+          resetConnectorState(wagmiConfig);
         }
       }
     })();
-  }, [isConnected, wagmiConfig, connection, reconnect]);
+  }, [chainNamespace, connection, isConnected, reconnect, wagmiConfig]);
   return react.createElement(react.Fragment, null, children);
 }
 function WagmiProvider(_ref) {

package/dist/lib.cjs/types/connectors/auth-connector/authConnector.d.ts

@@ -18,6 +18,7 @@ declare class AuthConnector extends BaseConnector<AuthLoginParams> implements IA
     private wsEmbedInstance;
     private authConnectionConfig;
     private wsEmbedInstancePromise;
+    private wsEmbedProviderListenerTarget;
     private _solanaWallet;
     private analytics;
     constructor(params: AuthConnectorOptions);
@@ -60,6 +61,9 @@ declare class AuthConnector extends BaseConnector<AuthLoginParams> implements IA
     private getNetworkForUnlinkAddress;
     private createWalletLinkingProof;
     private getLinkingWalletAddress;
+    private getWsEmbedProvider;
+    private bindWsEmbedProviderEvents;
+    private unbindWsEmbedProviderEvents;
     private setupSolanaWallet;
     private _getFinalPrivKey;
     private connectWithProvider;
@@ -69,6 +73,8 @@ declare class AuthConnector extends BaseConnector<AuthLoginParams> implements IA
     private getOriginData;
     private connectWithJwtLogin;
     private auditOAuditProgress;
+    private reportFailedOauthAudit;
+    private readonly handleWsEmbedAccountsChanged;
 }
 type AuthConnectorFuncParams = Omit<AuthConnectorOptions, "coreOptions" | "authConnectionConfig" | "connectorSettings"> & {
     connectorSettings?: Omit<AuthConnectorOptions["connectorSettings"], "buildEnv">;

package/dist/lib.cjs/types/connectors/auth-connector/interface.d.ts

@@ -14,7 +14,7 @@ export interface AuthConnectorSessionTokens {
 }
 export interface AuthConnectorLinkAccountParams {
     authSessionTokens: AuthConnectorSessionTokens;
-    walletConnector: IConnector<unknown>;
+    connectorToLink: IConnector<unknown>;
     connectorName: WALLET_CONNECTOR_TYPE | string;
     chainId?: string;
 }

package/dist/lib.cjs/types/noModal.d.ts

@@ -139,7 +139,7 @@ export declare class Web3AuthNoModal extends SafeEventEmitter<Web3AuthNoModalEve
         usePrimaryProxy: boolean;
         account?: ConnectedWalletAccountRef;
     }): Promise<ConnectedAccountsWithProviders>;
-    protected linkAccountWithConnector(connectorName: WALLET_CONNECTOR_TYPE | string, chainId: string, walletConnector: IConnector<unknown>): Promise<LinkAccountResult>;
+    protected linkAccountWithConnector(connectorName: WALLET_CONNECTOR_TYPE | string, chainId: string, connectorToLink: IConnector<unknown>): Promise<LinkAccountResult>;
     protected getMainAuthConnector(): AuthConnectorType;
     /**
      * Processes the result of a switch account operation.