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

package/dist/lib.esm/noModal.js

@@ -6,23 +6,24 @@ import { SMART_ACCOUNT_EIP_STANDARD, EIP7702_SUPPORTED_SMART_ACCOUNT_TYPES } fro
 import { SafeEventEmitter, 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 { 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';
-import { sdkVersion, fetchProjectConfig, withAbort, getErrorAnalyticsProperties, getCaipChainId, isHexStrict, getHostname, getWhitelabelAnalyticsProperties, getAaAnalyticsProperties, getWalletServicesAnalyticsProperties, isBrowser } from './base/utils.js';
+import { sdkVersion, fetchProjectConfig, withAbort, getErrorAnalyticsProperties, getCaipChainId, isHexStrict, getHostname, getWhitelabelAnalyticsProperties, getAaAnalyticsProperties, getWalletServicesAnalyticsProperties, isBrowser, parseChainNamespaceFromCitadelResponse, normalizeWalletName } from './base/utils.js';
+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 { CommonJRPCProvider } from './providers/base-provider/CommonJRPCProvider.js';
-import { authConnector } from './connectors/auth-connector/authConnector.js';
 import { walletServicesPlugin } from './plugins/wallet-services-plugin/plugin.js';
-import { storageAvailable } from './base/connector/utils.js';
 import { metaMaskConnector } from './connectors/metamask-connector/metamaskConnector.js';
-import { WalletInitializationError, WalletLoginError } from './base/errors/index.js';
-import { log } from './base/loglevel.js';
-import { WALLET_CONNECTORS } from './base/wallet/index.js';
-import { CONNECTOR_NAMESPACES } from './base/chain/IChainInterface.js';
+import { storageAvailable } from './base/connector/utils.js';
 import { PLUGIN_STATUS, PLUGIN_NAMESPACES } from './base/plugin/IPlugin.js';
 
 const _excluded = ["walletScope", "eipStandard"];
+const PRIMARY_CONNECTED_WALLET_KEY = "__primary__";
 class Web3AuthNoModal extends SafeEventEmitter {
   constructor(options, initialState) {
     super();
@@ -35,16 +36,20 @@ class Web3AuthNoModal extends SafeEventEmitter {
     _defineProperty(this, "analytics", void 0);
     _defineProperty(this, "plugins", {});
     _defineProperty(this, "consentRequired", false);
+    _defineProperty(this, "projectConfig", null);
     _defineProperty(this, "storage", void 0);
-    _defineProperty(this, "currentConnection", null);
-    _defineProperty(this, "currentConnectionReconnected", false);
+    _defineProperty(this, "connectionReconnected", false);
+    /** Connected wallet state keyed by linked account id; the primary session uses a reserved key. */
+    _defineProperty(this, "connectedWalletConnectorMap", new Map());
+    _defineProperty(this, "activeWalletConnectorKey", PRIMARY_CONNECTED_WALLET_KEY);
     _defineProperty(this, "state", {
-      connectedConnectorName: null,
+      primaryConnectorName: null,
       cachedConnector: null,
       currentChainId: null,
       idToken: null,
       accessToken: null,
-      refreshToken: null
+      refreshToken: null,
+      activeAccount: null
     });
     if (!options.clientId) throw WalletInitializationError.invalidParams("Please provide a valid clientId in constructor");
     if (options.enableLogging) log.enableAll();else log.setLevel("error");
@@ -52,6 +57,9 @@ class Web3AuthNoModal extends SafeEventEmitter {
     this.coreOptions = options;
     this.storage = this.getStorageMethod();
     this.analytics = new Analytics();
+    if (options.disableAnalytics) {
+      this.analytics.disable();
+    }
     this.analytics.setGlobalProperties({
       integration_type: ANALYTICS_INTEGRATION_TYPE.NATIVE_SDK
     });
@@ -68,13 +76,13 @@ class Web3AuthNoModal extends SafeEventEmitter {
     return (_this$coreOptions$cha = this.coreOptions.chains) === null || _this$coreOptions$cha === void 0 ? void 0 : _this$coreOptions$cha.find(chain => chain.chainId === this.currentChainId);
   }
   get connected() {
-    return Boolean(this.connectedConnector);
+    return Boolean(this.primaryConnector);
   }
   get connection() {
-    return this.currentConnection;
+    return this.getConnectedWalletConnectionByKey(this.activeWalletConnectorKey);
   }
-  get connectedConnectorName() {
-    return this.state.connectedConnectorName;
+  get primaryConnectorName() {
+    return this.state.primaryConnectorName;
   }
   get cachedConnector() {
     return this.state.cachedConnector;
@@ -83,9 +91,13 @@ class Web3AuthNoModal extends SafeEventEmitter {
     var _this$coreOptions$cha2;
     return this.state.currentChainId || this.coreOptions.defaultChainId || ((_this$coreOptions$cha2 = this.coreOptions.chains) === null || _this$coreOptions$cha2 === void 0 || (_this$coreOptions$cha2 = _this$coreOptions$cha2[0]) === null || _this$coreOptions$cha2 === void 0 ? void 0 : _this$coreOptions$cha2.chainId) || null;
   }
-  get connectedConnector() {
+
+  /**
+   * This is always the primary connector that is connected to the user.
+   */
+  get primaryConnector() {
     var _this$currentChain;
-    return this.getConnector(this.connectedConnectorName, (_this$currentChain = this.currentChain) === null || _this$currentChain === void 0 ? void 0 : _this$currentChain.chainNamespace);
+    return this.getConnector(this.primaryConnectorName, (_this$currentChain = this.currentChain) === null || _this$currentChain === void 0 ? void 0 : _this$currentChain.chainNamespace);
   }
   get accountAbstractionProvider() {
     return this.aaProvider;
@@ -93,6 +105,29 @@ class Web3AuthNoModal extends SafeEventEmitter {
   get idToken() {
     return this.state.idToken || null;
   }
+  get accessToken() {
+    return this.state.accessToken || null;
+  }
+  get refreshToken() {
+    return this.state.refreshToken || null;
+  }
+  get activeAccount() {
+    return this.state.activeAccount;
+  }
+
+  /**
+   * This is the current active connector.
+   */
+  get activeConnector() {
+    const activeConnectedWallet = this.getConnectedWalletConnectorStateByKey(this.activeWalletConnectorKey);
+    if (activeConnectedWallet) {
+      return activeConnectedWallet.connector;
+    }
+    if (this.activeWalletConnectorKey !== PRIMARY_CONNECTED_WALLET_KEY) {
+      throw new Error(`Signing connector not found for account "${this.activeWalletConnectorKey}".`);
+    }
+    return this.primaryConnector;
+  }
   set provider(_) {
     throw new Error("Not implemented");
   }
@@ -135,6 +170,7 @@ class Web3AuthNoModal extends SafeEventEmitter {
       }
 
       // init config
+      this.projectConfig = projectConfig;
       this.initAccountAbstractionConfig(projectConfig);
       this.initChainsConfig(projectConfig);
       await this.initCachedConnectorAndChainId();
@@ -206,13 +242,17 @@ class Web3AuthNoModal extends SafeEventEmitter {
     }) || null;
   }
   async clearCache() {
+    this.connectedWalletConnectorMap.clear();
+    this.activeWalletConnectorKey = PRIMARY_CONNECTED_WALLET_KEY;
+    this.connectionReconnected = false;
     await this.setState({
-      connectedConnectorName: null,
+      primaryConnectorName: null,
       cachedConnector: null,
       currentChainId: null,
       idToken: null,
       accessToken: null,
       refreshToken: null,
+      activeAccount: null,
       hasUserConsent: undefined
     });
   }
@@ -226,14 +266,16 @@ class Web3AuthNoModal extends SafeEventEmitter {
     if (params.chainId === ((_this$currentChain2 = this.currentChain) === null || _this$currentChain2 === void 0 ? void 0 : _this$currentChain2.chainId)) return;
     const newChainConfig = this.coreOptions.chains.find(x => x.chainId === params.chainId);
     if (!newChainConfig) throw WalletInitializationError.invalidParams("Invalid chainId");
-    if (CONNECTED_STATUSES.includes(this.status) && this.connectedConnector) {
-      var _this$currentChain3;
+    if (CONNECTED_STATUSES.includes(this.status)) {
+      const activeConnector = this.activeConnector;
+      if (!activeConnector) throw WalletInitializationError.notReady("Active signing connector is not ready");
+
       // Single-namespace connectors cannot cross namespace boundaries — MULTICHAIN connectors
       // (Auth, WC) enforce their own switchChain policy internally.
-      if (this.connectedConnector.connectorNamespace !== CONNECTOR_NAMESPACES.MULTICHAIN && ((_this$currentChain3 = this.currentChain) === null || _this$currentChain3 === void 0 ? void 0 : _this$currentChain3.chainNamespace) !== newChainConfig.chainNamespace) {
-        throw WalletLoginError.connectionError(`Cannot switch between chain namespaces with ${this.connectedConnector.name}. Disconnect and reconnect with the target chain.`);
+      if (activeConnector.connectorNamespace !== CONNECTOR_NAMESPACES.MULTICHAIN && activeConnector.connectorNamespace !== newChainConfig.chainNamespace) {
+        throw WalletLoginError.connectionError(`Cannot switch between chain namespaces with ${activeConnector.name}. Disconnect and reconnect with the target chain.`);
       }
-      await this.connectedConnector.switchChain(params);
+      await activeConnector.switchChain(params);
       return;
     }
     if (this.commonJRPCProvider) {
@@ -321,7 +363,7 @@ class Web3AuthNoModal extends SafeEventEmitter {
       const completeConnection = async () => {
         try {
           // track connection completed event
-          const userInfo = await connector.getUserInfo();
+          const userInfo = await this.getUserInfo();
           this.analytics.track(ANALYTICS_EVENTS.CONNECTION_COMPLETED, _objectSpread(_objectSpread({}, eventData), {}, {
             is_mfa_enabled: userInfo === null || userInfo === void 0 ? void 0 : userInfo.isMfaEnabled,
             duration: Date.now() - startTime
@@ -361,28 +403,60 @@ class Web3AuthNoModal extends SafeEventEmitter {
   async logout(options = {
     cleanup: false
   }) {
-    if (!CAN_LOGOUT_STATUSES.includes(this.status) || !this.connectedConnector) throw WalletLoginError.notConnectedError(`No wallet is connected`);
-    if (this.connectedConnector.status === CONNECTOR_STATUS.DISCONNECTING) return;
-    await this.connectedConnector.disconnect(options);
+    if (!CAN_LOGOUT_STATUSES.includes(this.status) || !this.primaryConnector) throw WalletLoginError.notConnectedError(`No wallet is connected`);
+    if (this.primaryConnector.status === CONNECTOR_STATUS.DISCONNECTING) return;
+    await this.primaryConnector.disconnect(options);
   }
   async getUserInfo() {
-    var _this$connectedConnec;
-    log.debug("Getting user info", this.status, (_this$connectedConnec = this.connectedConnector) === null || _this$connectedConnec === void 0 ? void 0 : _this$connectedConnec.name);
-    if (!CAN_AUTHORIZE_STATUSES.includes(this.status) || !this.connectedConnector) throw WalletLoginError.notConnectedError(`No wallet is connected`);
-    return this.connectedConnector.getUserInfo();
+    var _this$primaryConnecto, _userInfo$linkedAccou, _userInfo$linkedAccou2;
+    log.debug("Getting user info", this.status, (_this$primaryConnecto = this.primaryConnector) === null || _this$primaryConnecto === void 0 ? void 0 : _this$primaryConnecto.name);
+    if (!CAN_AUTHORIZE_STATUSES.includes(this.status) || !this.primaryConnector) throw WalletLoginError.notConnectedError(`No wallet is connected`);
+    const userInfo = await this.primaryConnector.getUserInfo();
+    const linkedAccounts = (_userInfo$linkedAccou = (_userInfo$linkedAccou2 = userInfo.linkedAccounts) === null || _userInfo$linkedAccou2 === void 0 ? void 0 : _userInfo$linkedAccou2.map(account => _objectSpread(_objectSpread({}, account), {}, {
+      active: this.state.activeAccount ? account.id === this.state.activeAccount.id : account.isPrimary
+    }))) !== null && _userInfo$linkedAccou !== void 0 ? _userInfo$linkedAccou : [];
+    this.syncConnectedWalletLinkedAccounts(linkedAccounts);
+    return _objectSpread(_objectSpread({}, userInfo), {}, {
+      linkedAccounts
+    });
+  }
+  async getLinkedAccounts() {
+    if (!CAN_AUTHORIZE_STATUSES.includes(this.status) || !this.primaryConnector) throw WalletLoginError.notConnectedError(`No wallet is connected`);
+    assertAuthConnector(this.primaryConnector, "Linked accounts can only be fetched when connected with the AUTH connector.");
+    const linkedAccounts = await this.primaryConnector.getLinkedAccounts();
+    const resolvedLinkedAccounts = linkedAccounts.map(account => _objectSpread(_objectSpread({}, account), {}, {
+      active: this.state.activeAccount ? account.id === this.state.activeAccount.id : account.isPrimary
+    }));
+    this.syncConnectedWalletLinkedAccounts(resolvedLinkedAccounts);
+    return resolvedLinkedAccounts;
+  }
+  getConnectedAccountsWithProviders() {
+    if (!CONNECTED_STATUSES.includes(this.status) || !this.primaryConnector) throw WalletLoginError.notConnectedError(`No wallet is connected`);
+    if (this.status !== CONNECTOR_STATUS.AUTHORIZED) {
+      // before the wallet is authorized, we don't have the user info, so we return an empty array
+      return [];
+    }
+    const connectedAccounts = [];
+    for (const [, value] of this.connectedWalletConnectorMap.entries()) {
+      const hasWalletProvider = Boolean(value.signingProvider || value.solanaWallet);
+      if (hasWalletProvider && this.hasUsableConnectedSwitchConnector(value.connector)) {
+        connectedAccounts.push(value);
+      }
+    }
+    return connectedAccounts;
   }
   async enableMFA(loginParams) {
     var _authConnector$authIn2;
-    if (!CONNECTED_STATUSES.includes(this.status) || !this.connectedConnector) throw WalletLoginError.notConnectedError(`No wallet is connected`);
-    if (this.connectedConnector.name !== WALLET_CONNECTORS.AUTH) throw WalletLoginError.unsupportedOperation(`EnableMFA is not supported for this connector.`);
-    const authConnector = this.connectedConnector;
+    if (!CONNECTED_STATUSES.includes(this.status) || !this.primaryConnector) throw WalletLoginError.notConnectedError(`No wallet is connected`);
+    if (this.primaryConnector.name !== WALLET_CONNECTORS.AUTH) throw WalletLoginError.unsupportedOperation(`EnableMFA is not supported for this connector.`);
+    const authConnector = this.primaryConnector;
     const trackData = {
-      connector: this.connectedConnector.name,
+      connector: this.primaryConnector.name,
       auth_ux_mode: (_authConnector$authIn2 = authConnector.authInstance) === null || _authConnector$authIn2 === void 0 || (_authConnector$authIn2 = _authConnector$authIn2.options) === null || _authConnector$authIn2 === void 0 ? void 0 : _authConnector$authIn2.uxMode
     };
     try {
       this.analytics.track(ANALYTICS_EVENTS.MFA_ENABLEMENT_STARTED, trackData);
-      await this.connectedConnector.enableMFA(loginParams);
+      await this.primaryConnector.enableMFA(loginParams);
     } catch (error) {
       this.analytics.track(ANALYTICS_EVENTS.MFA_ENABLEMENT_FAILED, _objectSpread(_objectSpread({}, trackData), getErrorAnalyticsProperties(error)));
       throw error;
@@ -390,29 +464,29 @@ class Web3AuthNoModal extends SafeEventEmitter {
   }
   async manageMFA(loginParams) {
     var _authConnector$authIn3;
-    if (!CONNECTED_STATUSES.includes(this.status) || !this.connectedConnector) throw WalletLoginError.notConnectedError(`No wallet is connected`);
-    if (this.connectedConnector.name !== WALLET_CONNECTORS.AUTH) throw WalletLoginError.unsupportedOperation(`ManageMFA is not supported for this connector.`);
-    const authConnector = this.connectedConnector;
+    if (!CONNECTED_STATUSES.includes(this.status) || !this.primaryConnector) throw WalletLoginError.notConnectedError(`No wallet is connected`);
+    if (this.primaryConnector.name !== WALLET_CONNECTORS.AUTH) throw WalletLoginError.unsupportedOperation(`ManageMFA is not supported for this connector.`);
+    const authConnector = this.primaryConnector;
     const trackData = {
-      connector: this.connectedConnector.name,
+      connector: this.primaryConnector.name,
       auth_ux_mode: (_authConnector$authIn3 = authConnector.authInstance) === null || _authConnector$authIn3 === void 0 || (_authConnector$authIn3 = _authConnector$authIn3.options) === null || _authConnector$authIn3 === void 0 ? void 0 : _authConnector$authIn3.uxMode
     };
     try {
       this.analytics.track(ANALYTICS_EVENTS.MFA_MANAGEMENT_SELECTED, trackData);
-      await this.connectedConnector.manageMFA(loginParams);
+      await this.primaryConnector.manageMFA(loginParams);
     } catch (error) {
       this.analytics.track(ANALYTICS_EVENTS.MFA_MANAGEMENT_FAILED, _objectSpread(_objectSpread({}, trackData), getErrorAnalyticsProperties(error)));
       throw error;
     }
   }
   async getAuthTokenInfo() {
-    if (!CAN_AUTHORIZE_STATUSES.includes(this.status) || !this.connectedConnector) throw WalletLoginError.notConnectedError(`No wallet is connected`);
+    if (!CAN_AUTHORIZE_STATUSES.includes(this.status) || !this.primaryConnector) throw WalletLoginError.notConnectedError(`No wallet is connected`);
     const trackData = {
-      connector: this.connectedConnector.name
+      connector: this.primaryConnector.name
     };
     try {
       this.analytics.track(ANALYTICS_EVENTS.IDENTITY_TOKEN_STARTED, trackData);
-      const authTokenInfo = await this.connectedConnector.getAuthTokenInfo();
+      const authTokenInfo = await this.primaryConnector.getAuthTokenInfo();
       this.analytics.track(ANALYTICS_EVENTS.IDENTITY_TOKEN_COMPLETED, trackData);
       return {
         idToken: authTokenInfo.idToken
@@ -425,6 +499,76 @@ class Web3AuthNoModal extends SafeEventEmitter {
   getPlugin(name) {
     return this.plugins[name] || null;
   }
+  async switchAccount(account) {
+    const authConnector = this.getMainAuthConnector();
+    const switchResult = await authConnector.switchAccount(account, {
+      activeAccount: this.state.activeAccount,
+      currentChainId: this.currentChainId
+    });
+    if (!switchResult) {
+      return;
+    }
+    try {
+      var _this$projectConfig;
+      await this.processSwitchAccountResult(authConnector, switchResult, {
+        projectConfig: (_this$projectConfig = this.projectConfig) !== null && _this$projectConfig !== void 0 ? _this$projectConfig : undefined
+      });
+      await authConnector.trackSwitchAccountCompleted(switchResult.targetAccount);
+    } catch (error) {
+      await authConnector.trackSwitchAccountFailed(switchResult.targetAccount, error);
+      throw error;
+    }
+  }
+  async linkAccount(params) {
+    if (!(params !== null && params !== void 0 && params.connectorName)) {
+      throw WalletInitializationError.invalidParams("connectorName is required when calling linkAccount on the no-modal SDK");
+    }
+    const chainId = this.resolveLinkAccountChainId(params.chainId);
+    const isolatedConnector = await this.createLinkingWalletConnector(params.connectorName, chainId);
+    return this.linkAccountWithConnector(params.connectorName, chainId, isolatedConnector);
+  }
+  async unlinkAccount(address) {
+    var _await$authConnector$, _this$state$activeAcc;
+    const authConnector = this.getMainAuthConnector();
+    const linkedAccounts = (_await$authConnector$ = (await authConnector.getUserInfo()).linkedAccounts) !== null && _await$authConnector$ !== void 0 ? _await$authConnector$ : [];
+    const targetAccount = this.findLinkedAccountByAddress(linkedAccounts, address);
+    if (!targetAccount) {
+      throw AccountLinkingError.accountNotLinked(`Account with address "${address}" is not linked`);
+    }
+    if (targetAccount.connector === WALLET_CONNECTORS.AUTH || targetAccount.isPrimary) {
+      throw AccountLinkingError.cannotUnlinkPrimaryAccount();
+    }
+    if (((_this$state$activeAcc = this.state.activeAccount) === null || _this$state$activeAcc === void 0 ? void 0 : _this$state$activeAcc.id) === targetAccount.id) {
+      throw AccountLinkingError.cannotUnlinkActiveAccount();
+    }
+    const result = await authConnector.unlinkAccount({
+      address,
+      authSessionTokens: {
+        accessToken: this.accessToken,
+        idToken: this.idToken
+      }
+    });
+    await this.setState({
+      idToken: result.idToken
+    });
+
+    // disconnect the connector for unlinked account
+    const connectorToDisconnect = this.getConnectedWalletConnector(targetAccount);
+    if (connectorToDisconnect) {
+      try {
+        if (connectorToDisconnect.connected) {
+          await connectorToDisconnect.disconnect({
+            cleanup: true
+          });
+        }
+      } catch (error) {
+        log.debug(`Failed to disconnect linked account "${targetAccount.id}" during unlink`, error);
+      } finally {
+        this.deleteConnectedWalletConnector(targetAccount);
+      }
+    }
+    return result;
+  }
   setAnalyticsProperties(properties) {
     this.analytics.setGlobalProperties(properties);
   }
@@ -762,23 +906,25 @@ class Web3AuthNoModal extends SafeEventEmitter {
   }
   subscribeToConnectorEvents(connector) {
     connector.on(CONNECTOR_EVENTS.CONNECTED, async data => {
+      if (this.primaryConnectorName && this.primaryConnectorName !== data.connectorName) {
+        // Ignore registered connectors that are not the active primary session connector.
+        return;
+      }
       if (!this.commonJRPCProvider) throw WalletInitializationError.notFound(`CommonJrpcProvider not found`);
       const {
         ethereumProvider,
         solanaWallet
       } = data;
-      const isSolanaOnly = connector.connectorNamespace === CHAIN_NAMESPACES.SOLANA;
-
-      // Set connection and consent status SYNCHRONOUSLY before any await so the
-      // AUTHORIZED handler (which may fire during async work below) can detect the
-      // consent-required state. Create a deferred promise the AUTHORIZED handler
-      // will await to ensure consent userId + pre-approval are resolved first.
-      this.currentConnection = {
-        ethereumProvider: isSolanaOnly ? null : ethereumProvider ? this.commonJRPCProvider : null,
-        solanaWallet: solanaWallet !== null && solanaWallet !== void 0 ? solanaWallet : null,
-        connectorName: data.connectorName
-      };
-      this.currentConnectionReconnected = data.reconnected;
+      // Seed the primary connector synchronously so AUTHORIZED can resolve a connection
+      // even while we are still restoring a previously active linked wallet.
+      this.setConnectedWalletConnectorState(this.buildImmediateConnectedWalletConnectorState({
+        connector,
+        ethereumProvider,
+        solanaWallet,
+        usePrimaryProxy: true
+      }));
+      this.setActiveWalletConnectorKey();
+      this.connectionReconnected = data.reconnected;
 
       // when ssr is enabled, we need to get the idToken from the connector.
       if (this.coreOptions.ssr) {
@@ -793,74 +939,119 @@ class Web3AuthNoModal extends SafeEventEmitter {
           });
         } catch (error) {
           log.error(error);
-          this.currentConnection = null;
+          this.deleteConnectedWalletConnector();
+          this.setActiveWalletConnectorKey();
           this.status = CONNECTOR_STATUS.ERRORED;
           this.emit(CONNECTOR_EVENTS.ERRORED, error, this.loginMode);
           return;
         }
       }
+      // The following block only hits during rehydration
 
-      // setup AA provider if AA is enabled (skip for EIP-7702; 7702 uses EOA + 5792/7702 RPC only)
-      if (ethereumProvider) {
-        var _this$currentChain4, _accountAbstractionCo;
-        let finalProvider = (ethereumProvider === null || ethereumProvider === void 0 ? void 0 : ethereumProvider.provider) || ethereumProvider;
-        const {
-          accountAbstractionConfig
-        } = this.coreOptions;
-        const is7702 = (accountAbstractionConfig === null || accountAbstractionConfig === void 0 ? void 0 : accountAbstractionConfig.smartAccountEipStandard) === SMART_ACCOUNT_EIP_STANDARD["EIP_7702"];
-        const isAaSupportedForCurrentChain = ((_this$currentChain4 = this.currentChain) === null || _this$currentChain4 === void 0 ? void 0 : _this$currentChain4.chainNamespace) === CHAIN_NAMESPACES.EIP155 && (accountAbstractionConfig === null || accountAbstractionConfig === void 0 || (_accountAbstractionCo = accountAbstractionConfig.chains) === null || _accountAbstractionCo === void 0 ? void 0 : _accountAbstractionCo.some(chain => {
-          var _this$currentChain5;
-          return chain.chainId === ((_this$currentChain5 = this.currentChain) === null || _this$currentChain5 === void 0 ? void 0 : _this$currentChain5.chainId);
-        }));
-        if (!is7702 && isAaSupportedForCurrentChain && (data.connectorName === WALLET_CONNECTORS.AUTH || this.coreOptions.useAAWithExternalWallet)) {
-          var _accountAbstractionCo2;
-          const {
-            accountAbstractionProvider,
-            toEoaProvider
-          } = await import('./providers/account-abstraction-provider/index.js');
-          // for embedded wallets, we use ws-embed provider which is AA provider, need to derive EOA provider
-          const eoaProvider = data.connectorName === WALLET_CONNECTORS.AUTH ? await toEoaProvider(ethereumProvider) : ethereumProvider;
-          const aaChainIds = new Set((accountAbstractionConfig === null || accountAbstractionConfig === void 0 || (_accountAbstractionCo2 = accountAbstractionConfig.chains) === null || _accountAbstractionCo2 === void 0 ? void 0 : _accountAbstractionCo2.map(chain => chain.chainId)) || []);
-          const aaProvider = await accountAbstractionProvider({
-            accountAbstractionConfig,
-            provider: eoaProvider,
-            chain: this.currentChain,
-            chains: this.coreOptions.chains.filter(chain => aaChainIds.has(chain.chainId)),
-            useProviderAsTransport: data.connectorName === WALLET_CONNECTORS.AUTH
+      const {
+        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, currentChainId);
+        const walletConnector = await this.createIsolatedWalletConnector(activeAccount.connector, targetChainId);
+        let linkedAccountConnection = null;
+        if (!this.hasUsableConnectedSwitchConnector(walletConnector)) {
+          linkedAccountConnection = await walletConnector.connect({
+            chainId: targetChainId
           });
-          this.aaProvider = aaProvider;
-
-          // if external wallet is used and AA is enabled for external wallets, use AA provider
-          // for embedded wallets, we use ws-embed provider which already supports AA
-          if (data.connectorName !== WALLET_CONNECTORS.AUTH && this.coreOptions.useAAWithExternalWallet) {
-            finalProvider = this.aaProvider;
+          if (!linkedAccountConnection) {
+            throw AccountLinkingError.requestFailed(`Failed to connect isolated connector "${activeAccount.connector}" for account switch.`);
           }
         }
-        this.commonJRPCProvider.updateProviderEngineProxy(finalProvider);
+        const connectedWalletState = await this.resolveConnectedWalletConnectorState({
+          connector: walletConnector,
+          ethereumProvider: (_ref3 = (_walletConnector$prov = walletConnector.provider) !== null && _walletConnector$prov !== void 0 ? _walletConnector$prov : (_linkedAccountConnect = linkedAccountConnection) === null || _linkedAccountConnect === void 0 ? void 0 : _linkedAccountConnect.ethereumProvider) !== null && _ref3 !== void 0 ? _ref3 : null,
+          solanaWallet: (_ref4 = (_walletConnector$sola = walletConnector.solanaWallet) !== null && _walletConnector$sola !== void 0 ? _walletConnector$sola : (_linkedAccountConnect2 = linkedAccountConnection) === null || _linkedAccountConnect2 === void 0 ? void 0 : _linkedAccountConnect2.solanaWallet) !== null && _ref4 !== void 0 ? _ref4 : null,
+          usePrimaryProxy: false,
+          account: activeAccount
+        });
+        this.setConnectedWalletConnectorState(connectedWalletState, activeAccount);
+        this.setActiveWalletConnectorKey(activeAccount);
+      }
+      if (ethereumProvider) {
+        await this.bindPrimaryEthereumSigningProxy(ethereumProvider, data.connectorName);
       }
+      const primaryConnectedWalletState = await this.resolveConnectedWalletConnectorState({
+        connector,
+        ethereumProvider,
+        solanaWallet,
+        usePrimaryProxy: true
+      });
+      this.setConnectedWalletConnectorState(primaryConnectedWalletState);
       await this.setState({
-        connectedConnectorName: data.connectorName
+        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.connectedConnectorName);
+        log.debug("consent_requiring", this.status, this.primaryConnectorName);
       } else {
-        this.status = CONNECTOR_STATUS.CONNECTED;
-        log.debug("connected", this.status, this.connectedConnectorName);
-        this.connectToPlugins(_objectSpread(_objectSpread({}, data), {}, {
-          connector: data.connectorName
-        }));
+        // 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);
+        // 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
         }));
       }
     });
-    connector.on(CONNECTOR_EVENTS.DISCONNECTED, async () => {
-      this.currentConnection = null;
-      this.currentConnectionReconnected = false;
+    connector.on(CONNECTOR_EVENTS.DISCONNECTED, async data => {
+      if (this.shouldIgnoreInactiveConnectorEvent(connector, CONNECTOR_EVENTS.DISCONNECTED)) return;
+      const disconnectedConnector = data === null || data === void 0 ? void 0 : data.connector;
+      const {
+        activeAccount
+      } = this.state;
+      if (!activeAccount || activeAccount && activeAccount.isPrimary || disconnectedConnector === WALLET_CONNECTORS.AUTH) {
+        // If the primary session disconnects, tear down every other connected wallet connector
+        // and clear the entire map.
+        await Promise.all(Array.from(this.connectedWalletConnectorMap.entries()).map(async ([accountId, connectedWallet]) => {
+          if (connectedWallet.connector === connector) {
+            this.connectedWalletConnectorMap.delete(accountId);
+            return;
+          }
+          try {
+            if (connectedWallet.connected && connectedWallet.connector.connected) {
+              await connectedWallet.connector.disconnect({
+                cleanup: true
+              });
+            }
+          } catch (error) {
+            log.debug("Connected wallet connector disconnect on primary disconnect", error);
+          } finally {
+            this.connectedWalletConnectorMap.delete(accountId);
+          }
+        }));
+      }
+      this.connectedWalletConnectorMap.clear();
+      this.activeWalletConnectorKey = PRIMARY_CONNECTED_WALLET_KEY;
+      this.connectionReconnected = false;
       // re-setup commonJRPCProvider
       this.commonJRPCProvider.removeAllListeners();
       this.setupCommonJRPCProvider();
@@ -868,10 +1059,10 @@ class Web3AuthNoModal extends SafeEventEmitter {
       // get back to ready state for rehydrating.
       this.status = CONNECTOR_STATUS.READY;
       const cachedConnector = this.state.cachedConnector;
-      if (this.connectedConnectorName === cachedConnector) {
+      if (this.primaryConnectorName === cachedConnector) {
         await this.clearCache();
       }
-      log.debug("disconnected", this.status, this.connectedConnectorName);
+      log.debug("disconnected", this.status, this.primaryConnectorName);
       await Promise.all(Object.values(this.plugins).map(async plugin => {
         if (!plugin.SUPPORTED_CONNECTORS.includes(connector.name)) return;
         if (plugin.status !== PLUGIN_STATUS.CONNECTED) return;
@@ -885,23 +1076,38 @@ class Web3AuthNoModal extends SafeEventEmitter {
         });
       }));
       await this.setState({
-        connectedConnectorName: null,
-        hasUserConsent: undefined
+        primaryConnectorName: null,
+        hasUserConsent: undefined,
+        activeAccount: null
       });
       this.emit(CONNECTOR_EVENTS.DISCONNECTED);
     });
     connector.on(CONNECTOR_EVENTS.CONNECTING, data => {
       this.status = CONNECTOR_STATUS.CONNECTING;
       this.emit(CONNECTOR_EVENTS.CONNECTING, data);
-      log.debug("connecting", this.status, this.connectedConnectorName);
+      log.debug("connecting", this.status, this.primaryConnectorName);
     });
     connector.on(CONNECTOR_EVENTS.ERRORED, async data => {
+      if (this.shouldIgnoreInactiveConnectorEvent(connector, CONNECTOR_EVENTS.ERRORED)) {
+        log.error("Inactive connector emitted errored event", {
+          connector: connector.name,
+          error: data
+        });
+        return;
+      }
       this.status = CONNECTOR_STATUS.ERRORED;
       await this.clearCache();
       this.emit(CONNECTOR_EVENTS.ERRORED, data, this.loginMode);
-      log.debug("errored", this.status, this.connectedConnectorName);
+      log.debug("errored", this.status, this.primaryConnectorName);
     });
     connector.on(CONNECTOR_EVENTS.REHYDRATION_ERROR, async error => {
+      if (this.shouldIgnoreInactiveConnectorEvent(connector, CONNECTOR_EVENTS.REHYDRATION_ERROR)) {
+        log.error("Inactive connector emitted rehydration error", {
+          connector: connector.name,
+          error
+        });
+        return;
+      }
       this.status = CONNECTOR_STATUS.READY;
       await this.clearCache();
       this.emit(CONNECTOR_EVENTS.REHYDRATION_ERROR, error);
@@ -911,18 +1117,19 @@ class Web3AuthNoModal extends SafeEventEmitter {
       this.emit(CONNECTOR_EVENTS.CONNECTOR_DATA_UPDATED, data);
     });
     connector.on(CONNECTOR_EVENTS.CACHE_CLEAR, async data => {
+      if (this.shouldIgnoreInactiveConnectorEvent(connector, CONNECTOR_EVENTS.CACHE_CLEAR)) return;
       log.debug("connector cache clear", data);
       await this.clearCache();
     });
     connector.on(CONNECTOR_EVENTS.MFA_ENABLED, isMFAEnabled => {
       var _authConnector$authIn4;
       log.debug("mfa enabled", isMFAEnabled);
-      const authConnector = this.connectedConnector;
+      const authConnector = this.primaryConnector;
 
       // mfa_enabled event is only emitted when using "popup" ux_mode
       // TODO: handle mfa_enabled event when using "redirect" ux_mode
       this.analytics.track(ANALYTICS_EVENTS.MFA_ENABLEMENT_COMPLETED, {
-        connector: this.connectedConnector.name,
+        connector: this.primaryConnector.name,
         auth_ux_mode: (_authConnector$authIn4 = authConnector.authInstance) === null || _authConnector$authIn4 === void 0 || (_authConnector$authIn4 = _authConnector$authIn4.options) === null || _authConnector$authIn4 === void 0 ? void 0 : _authConnector$authIn4.uxMode,
         is_mfa_enabled: isMFAEnabled
       });
@@ -931,7 +1138,7 @@ class Web3AuthNoModal extends SafeEventEmitter {
     connector.on(CONNECTOR_EVENTS.AUTHORIZING, data => {
       this.status = CONNECTOR_STATUS.AUTHORIZING;
       this.emit(CONNECTOR_EVENTS.AUTHORIZING, data);
-      log.debug("authorizing", this.status, this.connectedConnectorName);
+      log.debug("authorizing", this.status, this.primaryConnectorName);
     });
     connector.on(CONNECTOR_EVENTS.AUTHORIZED, async data => {
       var _data$authTokenInfo$a, _data$authTokenInfo$r;
@@ -941,14 +1148,14 @@ class Web3AuthNoModal extends SafeEventEmitter {
         refreshToken: (_data$authTokenInfo$r = data.authTokenInfo.refreshToken) !== null && _data$authTokenInfo$r !== void 0 ? _data$authTokenInfo$r : null
       });
       // if the user has not consented yet, we will ask for consent
-      if (this.consentRequired && this.currentConnection && !this.state.hasUserConsent) {
+      if (this.consentRequired && this.connection && !this.state.hasUserConsent) {
         this.status = CONNECTOR_STATUS.CONSENT_REQUIRING;
         this.emit(CONNECTOR_EVENTS.CONSENT_REQUIRING);
-        log.debug("consent_requiring", this.status, this.connectedConnectorName);
+        log.debug("consent_requiring", this.status, this.primaryConnectorName);
       } else {
         this.status = CONNECTOR_STATUS.AUTHORIZED;
         this.emit(CONNECTOR_EVENTS.AUTHORIZED, data);
-        log.debug("authorized", this.status, this.connectedConnectorName);
+        log.debug("authorized", this.status, this.primaryConnectorName);
       }
     });
   }
@@ -956,9 +1163,9 @@ class Web3AuthNoModal extends SafeEventEmitter {
     if (this.status === CONNECTOR_STATUS.READY) throw WalletInitializationError.notReady("Connector is already initialized");
   }
   checkIfAutoConnect(connector) {
-    var _this$currentChain6;
+    var _this$currentChain3;
     let autoConnect = this.cachedConnector === connector.name;
-    if (autoConnect && (_this$currentChain6 = this.currentChain) !== null && _this$currentChain6 !== void 0 && _this$currentChain6.chainNamespace) {
+    if (autoConnect && (_this$currentChain3 = this.currentChain) !== null && _this$currentChain3 !== void 0 && _this$currentChain3.chainNamespace) {
       if (connector.connectorNamespace === CONNECTOR_NAMESPACES.MULTICHAIN) autoConnect = true;else autoConnect = connector.connectorNamespace === this.currentChain.chainNamespace;
     }
     return autoConnect;
@@ -978,7 +1185,7 @@ class Web3AuthNoModal extends SafeEventEmitter {
     return initialChain;
   }
   async completeConsentAcceptance() {
-    const connection = this.currentConnection;
+    const connection = this.connection;
     if (!connection) {
       throw WalletLoginError.connectionError("Cannot accept consent: no active connection");
     }
@@ -991,29 +1198,400 @@ class Web3AuthNoModal extends SafeEventEmitter {
     const isConnectAndSign = this.coreOptions.initialAuthenticationMode === CONNECTOR_INITIAL_AUTHENTICATION_MODE.CONNECT_AND_SIGN;
     if (isConnectAndSign && this.state.idToken) {
       this.status = CONNECTOR_STATUS.AUTHORIZED;
-      log.debug("consent accepted, authorized", this.status, this.connectedConnectorName);
+      log.debug("consent accepted, authorized", this.status, this.primaryConnectorName);
     } else {
       this.status = CONNECTOR_STATUS.CONNECTED;
-      log.debug("consent accepted, connected", this.status, this.connectedConnectorName);
+      log.debug("consent accepted, connected", this.status, this.primaryConnectorName);
     }
 
     // connect to wallet-service plugin
-    if (this.connectedConnectorName === WALLET_CONNECTORS.AUTH) {
+    if (this.primaryConnectorName === WALLET_CONNECTORS.AUTH) {
       this.connectToPlugins({
-        connector: this.connectedConnectorName
+        connector: this.primaryConnectorName
       });
     }
     this.emit(CONNECTOR_EVENTS.CONSENT_ACCEPTED, {
-      reconnected: this.currentConnectionReconnected
+      reconnected: this.connectionReconnected
     });
   }
+  resolveLinkAccountChainId(chainId) {
+    const finalChainId = chainId || this.state.currentChainId;
+    if (!finalChainId) {
+      throw AccountLinkingError.walletProofFailed("No chainId is available. Please specify chainId in LinkAccountParams or ensure the SDK has an active chain.");
+    }
+    return finalChainId;
+  }
+
+  /**
+   * Resolves the chain ID for a switch account operation.
+   * If the account's chain namespace is the same as the current chain namespace, return the current chain ID.
+   * If the account's chain namespace is different from the current chain namespace, return the chainId the account was linked in.
+   *
+   * @param account - The account to switch to.
+   * @param activeChainId - The current active chain ID.
+   * @returns The resolved chain ID.
+   */
+  resolveSwitchAccountChainId(account, activeChainId) {
+    const targetChainNamespace = account.chainNamespace ? parseChainNamespaceFromCitadelResponse(account.chainNamespace) : null;
+    if (targetChainNamespace && this.currentChain.chainNamespace === targetChainNamespace) {
+      return this.currentChain.chainId;
+    }
+    return activeChainId;
+  }
+  async createLinkingWalletConnector(connectorName, chainId, config) {
+    return this.createIsolatedWalletConnector(connectorName, chainId, config);
+  }
+  async createSwitchingWalletConnector(connectorName, chainId, config) {
+    return this.createIsolatedWalletConnector(connectorName, chainId, config);
+  }
+  getConnectedWalletConnector(account) {
+    var _this$getConnectedWal, _this$getConnectedWal2;
+    return (_this$getConnectedWal = (_this$getConnectedWal2 = this.getConnectedWalletConnectorState(account)) === null || _this$getConnectedWal2 === void 0 ? void 0 : _this$getConnectedWal2.connector) !== null && _this$getConnectedWal !== void 0 ? _this$getConnectedWal : null;
+  }
+  getConnectedWalletConnectorState(account) {
+    return this.getConnectedWalletConnectorStateByKey(this.getConnectedWalletConnectorKey(account));
+  }
+  setConnectedWalletConnectorState(connectedWallet, account) {
+    this.connectedWalletConnectorMap.set(this.getConnectedWalletConnectorKey(account), connectedWallet);
+  }
+  setConnectedWalletConnector(connector, account) {
+    var _connector$solanaWall;
+    this.setConnectedWalletConnectorState(_objectSpread(_objectSpread({}, this.getConnectedWalletLinkedAccountInfo(account)), {}, {
+      connector,
+      signingProvider: connector.provider,
+      solanaWallet: (_connector$solanaWall = connector.solanaWallet) !== null && _connector$solanaWall !== void 0 ? _connector$solanaWall : null,
+      connected: connector.connected || connector.status === CONNECTOR_STATUS.CONNECTED
+    }), account);
+  }
+  deleteConnectedWalletConnector(account) {
+    this.connectedWalletConnectorMap.delete(this.getConnectedWalletConnectorKey(account));
+  }
+  getConnectedWalletConnection(account) {
+    return this.getConnectedWalletConnectionByKey(this.getConnectedWalletConnectorKey(account));
+  }
+  hasUsableConnectedSwitchConnector(connector) {
+    if (!connector) return false;
+    const isConnected = connector.connected || connector.status === CONNECTOR_STATUS.CONNECTED;
+    return Boolean(isConnected && (connector.provider || connector.solanaWallet));
+  }
+  setActiveWalletConnectorKey(account) {
+    this.activeWalletConnectorKey = this.getConnectedWalletConnectorKey(account);
+  }
+  getConnectedWalletConnectorKey(account) {
+    return !account || account.isPrimary ? PRIMARY_CONNECTED_WALLET_KEY : account.id;
+  }
+  getConnectedWalletConnectorStateByKey(accountKey) {
+    var _this$connectedWallet;
+    return (_this$connectedWallet = this.connectedWalletConnectorMap.get(accountKey)) !== null && _this$connectedWallet !== void 0 ? _this$connectedWallet : null;
+  }
+  isLinkedAccountInfo(account) {
+    return Boolean(account && "connector" in account);
+  }
+  toConnectedWalletLinkedAccountInfo(account) {
+    return {
+      id: account.id,
+      isPrimary: account.isPrimary,
+      eoaAddress: account.eoaAddress,
+      aaAddress: account.aaAddress,
+      aaProvider: account.aaProvider,
+      active: account.active,
+      accountType: account.accountType,
+      address: account.address,
+      authConnectionId: account.authConnectionId,
+      groupedAuthConnectionId: account.groupedAuthConnectionId,
+      chainNamespace: account.chainNamespace
+    };
+  }
+  getConnectedWalletLinkedAccountInfo(account) {
+    const existingConnectedWallet = this.getConnectedWalletConnectorState(account);
+    const resolvedAccount = this.isLinkedAccountInfo(account) ? account : existingConnectedWallet;
+    if (resolvedAccount) {
+      return this.toConnectedWalletLinkedAccountInfo(resolvedAccount);
+    }
+    const isPrimaryAccount = !account || account.isPrimary;
+    const accountId = account && !account.isPrimary ? account.id : PRIMARY_CONNECTED_WALLET_KEY;
+    return {
+      id: accountId,
+      isPrimary: isPrimaryAccount,
+      eoaAddress: "",
+      aaAddress: undefined,
+      aaProvider: undefined,
+      active: this.state.activeAccount ? this.state.activeAccount.id === accountId : isPrimaryAccount,
+      accountType: "",
+      address: null,
+      authConnectionId: null,
+      groupedAuthConnectionId: null,
+      chainNamespace: null
+    };
+  }
+  syncConnectedWalletLinkedAccounts(linkedAccounts) {
+    for (const linkedAccount of linkedAccounts) {
+      const accountKey = this.getConnectedWalletConnectorKey(linkedAccount);
+      const connectedWallet = this.connectedWalletConnectorMap.get(accountKey);
+      if (!connectedWallet) {
+        continue;
+      }
+      this.connectedWalletConnectorMap.set(accountKey, _objectSpread(_objectSpread({}, connectedWallet), this.toConnectedWalletLinkedAccountInfo(linkedAccount)));
+    }
+  }
+  refreshConnectedWalletActiveStates(activeAccount) {
+    for (const [accountKey, connectedWallet] of this.connectedWalletConnectorMap.entries()) {
+      const isPrimaryAccount = accountKey === PRIMARY_CONNECTED_WALLET_KEY || connectedWallet.isPrimary;
+      this.connectedWalletConnectorMap.set(accountKey, _objectSpread(_objectSpread({}, connectedWallet), {}, {
+        active: activeAccount ? connectedWallet.id === activeAccount.id : isPrimaryAccount
+      }));
+    }
+  }
+  getConnectedWalletConnectionByKey(accountKey) {
+    const connectedWallet = this.getConnectedWalletConnectorStateByKey(accountKey);
+    if (!connectedWallet) {
+      return null;
+    }
+    if (!connectedWallet.signingProvider && !connectedWallet.solanaWallet) {
+      throw new Error(`Connected connector "${connectedWallet.connector.name}" is not ready.`);
+    }
+    return this.buildConnectionFromConnectedWalletConnectorState(connectedWallet);
+  }
+  buildConnectionFromConnectedWalletConnectorState(connectedWallet) {
+    var _connectedWallet$sola;
+    return {
+      ethereumProvider: connectedWallet.signingProvider,
+      solanaWallet: (_connectedWallet$sola = connectedWallet.solanaWallet) !== null && _connectedWallet$sola !== void 0 ? _connectedWallet$sola : null,
+      connectorName: connectedWallet.connector.name
+    };
+  }
+  buildImmediateConnectedWalletConnectorState(params) {
+    var _this$commonJRPCProvi;
+    const {
+      connector,
+      ethereumProvider,
+      solanaWallet,
+      usePrimaryProxy,
+      account
+    } = params;
+    const isSolanaOnly = connector.connectorNamespace === CHAIN_NAMESPACES.SOLANA;
+    const connectedWallet = _objectSpread(_objectSpread({}, this.getConnectedWalletLinkedAccountInfo(account)), {}, {
+      connector,
+      signingProvider: isSolanaOnly ? null : ethereumProvider ? usePrimaryProxy ? (_this$commonJRPCProvi = this.commonJRPCProvider) !== null && _this$commonJRPCProvi !== void 0 ? _this$commonJRPCProvi : ethereumProvider : ethereumProvider : null,
+      solanaWallet: solanaWallet !== null && solanaWallet !== void 0 ? solanaWallet : null,
+      connected: connector.connected || connector.status === CONNECTOR_STATUS.CONNECTED || connector.status === CONNECTOR_STATUS.AUTHORIZED
+    });
+    return connectedWallet;
+  }
+  async resolveConnectedWalletConnectorState(params) {
+    const {
+      connector,
+      ethereumProvider,
+      solanaWallet,
+      usePrimaryProxy,
+      account
+    } = params;
+    return this.buildImmediateConnectedWalletConnectorState({
+      connector,
+      ethereumProvider,
+      solanaWallet,
+      usePrimaryProxy,
+      account
+    });
+  }
+  async linkAccountWithConnector(connectorName, chainId, connectorToLink) {
+    const authConnector = this.getMainAuthConnector();
+    const result = await authConnector.linkAccount({
+      connectorName,
+      chainId,
+      connectorToLink,
+      authSessionTokens: {
+        accessToken: this.accessToken,
+        idToken: this.idToken
+      }
+    });
+    await this.setState({
+      idToken: result.idToken
+    });
+    await this.cacheConnectedLinkedWalletConnector(authConnector, connectorToLink);
+    return result;
+  }
+  getMainAuthConnector() {
+    if (!CONNECTED_STATUSES.includes(this.status) || !this.primaryConnector) {
+      throw WalletLoginError.notConnectedError("No wallet is connected. Connect with AUTH before unlinking an account.");
+    }
+    const mainConnector = this.primaryConnector;
+    assertAuthConnector(mainConnector, "Account linking is only supported when connected with the AUTH connector.");
+    return mainConnector;
+  }
+
+  /**
+   * Processes the result of a switch account operation.
+   *
+   * - If the target account is a primary account, we will switch back to the primary account.
+   * - If the target account is an external account and already connected (i.e. connector is available with connected state), we will just switch to it without re-connecting again.
+   * - If the target account is an external account and not connected (i.e. connector is not available with connected state), we will create a new isolated connector and connect to it.
+   * @param authConnector - The main auth connector to use.
+   * @param switchResult - The result of the switch account operation.
+   * @param options - The options for the switch account operation.
+   * @returns A promise that resolves when the switch account operation is complete.
+   */
+  async processSwitchAccountResult(authConnector, switchResult, options = {}) {
+    const resolvedSwitchChainId = this.resolveSwitchAccountChainId(switchResult.targetAccount, switchResult.activeChainId);
+    if (switchResult.kind === "primary") {
+      var _primaryConnectedWall, _this$commonJRPCProvi2, _switchResult$solanaW;
+      const existingPrimaryConnectedWalletState = this.getConnectedWalletConnectorState();
+      const primaryConnectedWalletState = existingPrimaryConnectedWalletState !== null && existingPrimaryConnectedWalletState !== void 0 ? existingPrimaryConnectedWalletState : await this.resolveConnectedWalletConnectorState({
+        connector: authConnector,
+        ethereumProvider: switchResult.ethereumProvider,
+        solanaWallet: switchResult.solanaWallet,
+        usePrimaryProxy: true,
+        account: switchResult.targetAccount
+      });
+      this.setConnectedWalletConnectorState(_objectSpread(_objectSpread({}, primaryConnectedWalletState), {}, {
+        connector: authConnector,
+        signingProvider: (_primaryConnectedWall = primaryConnectedWalletState.signingProvider) !== null && _primaryConnectedWall !== void 0 ? _primaryConnectedWall : switchResult.ethereumProvider ? (_this$commonJRPCProvi2 = this.commonJRPCProvider) !== null && _this$commonJRPCProvi2 !== void 0 ? _this$commonJRPCProvi2 : switchResult.ethereumProvider : null,
+        solanaWallet: (_switchResult$solanaW = switchResult.solanaWallet) !== null && _switchResult$solanaW !== void 0 ? _switchResult$solanaW : primaryConnectedWalletState.solanaWallet,
+        connected: authConnector.connected || authConnector.status === CONNECTOR_STATUS.CONNECTED
+      }));
+      this.setActiveWalletConnectorKey();
+    } else {
+      var _ref5, _options$walletConnec;
+      const walletConnector = (_ref5 = (_options$walletConnec = options.walletConnector) !== null && _options$walletConnec !== void 0 ? _options$walletConnec : this.getConnectedWalletConnector(switchResult.targetAccount)) !== null && _ref5 !== void 0 ? _ref5 : await this.createSwitchingWalletConnector(switchResult.targetAccount.connector, resolvedSwitchChainId, options.projectConfig);
+      let linkedAccountConnection = null;
+      try {
+        var _ref6, _walletConnector$prov2, _linkedAccountConnect3, _ref7, _walletConnector$sola2, _linkedAccountConnect4;
+        if (!this.hasUsableConnectedSwitchConnector(walletConnector)) {
+          const switchChainConfig = this.coreOptions.chains.find(c => c.chainId === resolvedSwitchChainId);
+          if (!switchChainConfig) {
+            throw WalletLoginError.connectionError(`Chain config is not available for chain ${resolvedSwitchChainId}`);
+          }
+          const caipChainId = getCaipChainId(switchChainConfig);
+          const caipAccountId = `${caipChainId}:${switchResult.targetAccount.eoaAddress}`;
+          linkedAccountConnection = await walletConnector.connect({
+            chainId: resolvedSwitchChainId,
+            caipAccountIds: [caipAccountId]
+          });
+          if (!linkedAccountConnection) {
+            throw AccountLinkingError.requestFailed(`Failed to connect isolated connector "${switchResult.targetAccount.connector}" for account switch.`);
+          }
+        }
+        await authConnector.assertSwitchAccountConnectorMatchesTarget(walletConnector, switchResult.targetAccount);
+        const connectedWalletState = await this.resolveConnectedWalletConnectorState({
+          connector: walletConnector,
+          ethereumProvider: (_ref6 = (_walletConnector$prov2 = walletConnector.provider) !== null && _walletConnector$prov2 !== void 0 ? _walletConnector$prov2 : (_linkedAccountConnect3 = linkedAccountConnection) === null || _linkedAccountConnect3 === void 0 ? void 0 : _linkedAccountConnect3.ethereumProvider) !== null && _ref6 !== void 0 ? _ref6 : null,
+          solanaWallet: (_ref7 = (_walletConnector$sola2 = walletConnector.solanaWallet) !== null && _walletConnector$sola2 !== void 0 ? _walletConnector$sola2 : (_linkedAccountConnect4 = linkedAccountConnection) === null || _linkedAccountConnect4 === void 0 ? void 0 : _linkedAccountConnect4.solanaWallet) !== null && _ref7 !== void 0 ? _ref7 : null,
+          usePrimaryProxy: false,
+          account: switchResult.targetAccount
+        });
+        this.setConnectedWalletConnectorState(connectedWalletState, switchResult.targetAccount);
+        this.setActiveWalletConnectorKey(switchResult.targetAccount);
+      } catch (error) {
+        throw authConnector.toSwitchAccountConnectorError(switchResult.targetAccount, error);
+      }
+    }
+    await this.setCurrentChain(resolvedSwitchChainId);
+    await this.setState({
+      activeAccount: switchResult.activeAccount
+    });
+    this.syncConnectedWalletLinkedAccounts([switchResult.targetAccount]);
+    this.refreshConnectedWalletActiveStates(switchResult.activeAccount);
+    const connection = this.connection;
+    if (!connection) {
+      throw WalletLoginError.connectionError("Failed to resolve the active connection after switching accounts.");
+    }
+    this.emit(CONNECTOR_EVENTS.CONNECTION_UPDATED, {
+      ethereumProvider: connection.ethereumProvider,
+      solanaWallet: connection.solanaWallet,
+      connectorName: connection.connectorName
+    });
+  }
+  isActiveConnectorEventSource(connector) {
+    if (!this.primaryConnectorName) return true;
+    const activeConnector = this.primaryConnector;
+    if (activeConnector) return activeConnector === connector;
+    return connector.name === this.primaryConnectorName;
+  }
+  shouldIgnoreInactiveConnectorEvent(connector, event) {
+    if (this.isActiveConnectorEventSource(connector)) return false;
+    log.debug("Ignoring connector lifecycle event from inactive connector", {
+      event,
+      sourceConnector: connector.name,
+      activeConnector: this.primaryConnectorName
+    });
+    return true;
+  }
+  findLinkedAccountByAddress(linkedAccounts, address) {
+    var _linkedAccounts$find;
+    const normalizedAddress = address.toLowerCase();
+    return (_linkedAccounts$find = linkedAccounts.find(account => {
+      var _account$address, _account$eoaAddress;
+      if (!account.chainNamespace || parseChainNamespaceFromCitadelResponse(account.chainNamespace) !== CHAIN_NAMESPACES.EIP155) {
+        return false;
+      }
+      return ((_account$address = account.address) === null || _account$address === void 0 ? void 0 : _account$address.toLowerCase()) === normalizedAddress || ((_account$eoaAddress = account.eoaAddress) === null || _account$eoaAddress === void 0 ? void 0 : _account$eoaAddress.toLowerCase()) === normalizedAddress;
+    })) !== null && _linkedAccounts$find !== void 0 ? _linkedAccounts$find : null;
+  }
+  findLinkedAccountByWalletAddress(linkedAccounts, address) {
+    var _linkedAccounts$find2;
+    return (_linkedAccounts$find2 = linkedAccounts.find(account => {
+      if (!account.chainNamespace) {
+        return false;
+      }
+      const chainNamespace = parseChainNamespaceFromCitadelResponse(account.chainNamespace);
+      if (chainNamespace === CHAIN_NAMESPACES.EIP155) {
+        var _account$address2, _account$eoaAddress2;
+        const normalizedAddress = address.toLowerCase();
+        return ((_account$address2 = account.address) === null || _account$address2 === void 0 ? void 0 : _account$address2.toLowerCase()) === normalizedAddress || ((_account$eoaAddress2 = account.eoaAddress) === null || _account$eoaAddress2 === void 0 ? void 0 : _account$eoaAddress2.toLowerCase()) === normalizedAddress;
+      }
+      if (chainNamespace === CHAIN_NAMESPACES.SOLANA) {
+        return account.address === address || account.eoaAddress === address;
+      }
+      return false;
+    })) !== null && _linkedAccounts$find2 !== void 0 ? _linkedAccounts$find2 : null;
+  }
+  async getConnectedWalletAddress(connector) {
+    var _connector$solanaWall2, _accounts$;
+    const solanaAddress = (_connector$solanaWall2 = connector.solanaWallet) === null || _connector$solanaWall2 === void 0 || (_connector$solanaWall2 = _connector$solanaWall2.accounts) === null || _connector$solanaWall2 === void 0 || (_connector$solanaWall2 = _connector$solanaWall2[0]) === null || _connector$solanaWall2 === void 0 ? void 0 : _connector$solanaWall2.address;
+    if (solanaAddress) {
+      return solanaAddress;
+    }
+    if (!connector.provider) {
+      return null;
+    }
+    const accounts = await connector.provider.request({
+      method: "eth_accounts"
+    });
+    return (_accounts$ = accounts === null || accounts === void 0 ? void 0 : accounts[0]) !== null && _accounts$ !== void 0 ? _accounts$ : null;
+  }
+  async cacheConnectedLinkedWalletConnector(authConnector, walletConnector) {
+    try {
+      var _await$authConnector$2;
+      const connectedWalletAddress = await this.getConnectedWalletAddress(walletConnector);
+      if (!connectedWalletAddress) {
+        return;
+      }
+      const linkedAccounts = (_await$authConnector$2 = await authConnector.getLinkedAccounts()) !== null && _await$authConnector$2 !== void 0 ? _await$authConnector$2 : [];
+      const linkedAccount = this.findLinkedAccountByWalletAddress(linkedAccounts, connectedWalletAddress);
+      if (linkedAccount && !linkedAccount.isPrimary) {
+        const connectedWalletState = await this.resolveConnectedWalletConnectorState({
+          connector: walletConnector,
+          ethereumProvider: walletConnector.provider,
+          solanaWallet: walletConnector.solanaWallet,
+          usePrimaryProxy: false,
+          account: linkedAccount
+        });
+        this.setConnectedWalletConnectorState(connectedWalletState, linkedAccount);
+      }
+    } catch (error) {
+      log.debug("Failed to cache connected linked wallet connector", error);
+    }
+  }
   async cacheWallet(walletName) {
     await this.setState({
       cachedConnector: walletName
     });
   }
   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({
@@ -1023,11 +1601,11 @@ class Web3AuthNoModal extends SafeEventEmitter {
   connectToPlugins(data) {
     Object.values(this.plugins).map(async plugin => {
       try {
-        var _this$currentChain7;
+        var _this$currentChain4;
         // skip if it's not compatible with the connector
         if (!plugin.SUPPORTED_CONNECTORS.includes(data.connector)) return;
         // skip if it's not compatible with the current chain
-        if (plugin.pluginNamespace !== PLUGIN_NAMESPACES.MULTICHAIN && plugin.pluginNamespace !== ((_this$currentChain7 = this.currentChain) === null || _this$currentChain7 === void 0 ? void 0 : _this$currentChain7.chainNamespace)) return;
+        if (plugin.pluginNamespace !== PLUGIN_NAMESPACES.MULTICHAIN && plugin.pluginNamespace !== ((_this$currentChain4 = this.currentChain) === null || _this$currentChain4 === void 0 ? void 0 : _this$currentChain4.chainNamespace)) return;
         // skip if it's already connected
         if (plugin.status === PLUGIN_STATUS.CONNECTED) return;
         await plugin.initWithWeb3Auth(this, this.coreOptions.uiConfig, this.analytics);
@@ -1041,6 +1619,153 @@ class Web3AuthNoModal extends SafeEventEmitter {
       }
     });
   }
+  async bindPrimaryEthereumSigningProxy(ethereumProvider, connectorName) {
+    var _this$currentChain5, _accountAbstractionCo;
+    if (!this.commonJRPCProvider) throw WalletInitializationError.notFound(`CommonJrpcProvider not found`);
+    let finalProvider = (ethereumProvider === null || ethereumProvider === void 0 ? void 0 : ethereumProvider.provider) || ethereumProvider;
+    const {
+      accountAbstractionConfig
+    } = this.coreOptions;
+    const is7702 = (accountAbstractionConfig === null || accountAbstractionConfig === void 0 ? void 0 : accountAbstractionConfig.smartAccountEipStandard) === SMART_ACCOUNT_EIP_STANDARD["EIP_7702"];
+    const isAaSupportedForCurrentChain = ((_this$currentChain5 = this.currentChain) === null || _this$currentChain5 === void 0 ? void 0 : _this$currentChain5.chainNamespace) === CHAIN_NAMESPACES.EIP155 && (accountAbstractionConfig === null || accountAbstractionConfig === void 0 || (_accountAbstractionCo = accountAbstractionConfig.chains) === null || _accountAbstractionCo === void 0 ? void 0 : _accountAbstractionCo.some(chain => {
+      var _this$currentChain6;
+      return chain.chainId === ((_this$currentChain6 = this.currentChain) === null || _this$currentChain6 === void 0 ? void 0 : _this$currentChain6.chainId);
+    }));
+
+    // setup AA provider if AA is enabled (skip for EIP-7702; 7702 uses EOA + 5792/7702 RPC only)
+    if (!is7702 && isAaSupportedForCurrentChain && (connectorName === WALLET_CONNECTORS.AUTH || this.coreOptions.useAAWithExternalWallet)) {
+      var _accountAbstractionCo2;
+      const {
+        accountAbstractionProvider,
+        toEoaProvider
+      } = await import('./providers/account-abstraction-provider/index.js');
+      const eoaProvider = connectorName === WALLET_CONNECTORS.AUTH ? await toEoaProvider(ethereumProvider) : ethereumProvider;
+      const aaChainIds = new Set((accountAbstractionConfig === null || accountAbstractionConfig === void 0 || (_accountAbstractionCo2 = accountAbstractionConfig.chains) === null || _accountAbstractionCo2 === void 0 ? void 0 : _accountAbstractionCo2.map(chain => chain.chainId)) || []);
+      const aaProvider = await accountAbstractionProvider({
+        accountAbstractionConfig,
+        provider: eoaProvider,
+        chain: this.currentChain,
+        chains: this.coreOptions.chains.filter(chain => aaChainIds.has(chain.chainId)),
+        useProviderAsTransport: connectorName === WALLET_CONNECTORS.AUTH
+      });
+      this.aaProvider = aaProvider;
+      if (connectorName !== WALLET_CONNECTORS.AUTH && this.coreOptions.useAAWithExternalWallet) {
+        finalProvider = this.aaProvider;
+      }
+    }
+    this.commonJRPCProvider.updateProviderEngineProxy(finalProvider);
+  }
+  getChainConfigForIsolatedConnector(chainId) {
+    const chainConfig = this.coreOptions.chains.find(chain => chain.chainId === chainId);
+    if (!chainConfig) {
+      throw WalletInitializationError.invalidParams(`Chain config is not available for chain ${chainId}`);
+    }
+    return chainConfig;
+  }
+  async resolveInstalledDiscoveredWalletConnector(params) {
+    const {
+      connectorName,
+      chainConfig,
+      config,
+      isMipdEnabled
+    } = params;
+    if (!isBrowser() || !isMipdEnabled) return null;
+    if (chainConfig.chainNamespace === CHAIN_NAMESPACES.EIP155) {
+      const {
+        createMipd,
+        injectedEvmConnector
+      } = await import('./connectors/injected-evm-connector/index.js');
+      const providerDetail = createMipd().getProviders().find(detail => normalizeWalletName(detail.info.name) === connectorName);
+      if (providerDetail) {
+        return injectedEvmConnector(providerDetail)(config);
+      }
+      return null;
+    }
+    if (chainConfig.chainNamespace === CHAIN_NAMESPACES.SOLANA) {
+      const {
+        createSolanaMipd,
+        hasSolanaWalletStandardFeatures,
+        walletStandardConnector
+      } = await import('./connectors/injected-solana-connector/index.js');
+      const wallet = createSolanaMipd().get().find(candidate => hasSolanaWalletStandardFeatures(candidate) && normalizeWalletName(candidate.name) === connectorName);
+      if (wallet) {
+        return walletStandardConnector(wallet)(config);
+      }
+    }
+    return null;
+  }
+  async resolveDiscoveredWalletConnector(connectorName, chainId, config, effectiveProjectConfig) {
+    var _this$coreOptions$mul2;
+    const chainConfig = this.getChainConfigForIsolatedConnector(chainId);
+    const isExternalWalletEnabled = Boolean(effectiveProjectConfig === null || effectiveProjectConfig === void 0 ? void 0 : effectiveProjectConfig.externalWalletAuth);
+    const isMipdEnabled = isExternalWalletEnabled && ((_this$coreOptions$mul2 = this.coreOptions.multiInjectedProviderDiscovery) !== null && _this$coreOptions$mul2 !== void 0 ? _this$coreOptions$mul2 : true);
+    const installedConnector = await this.resolveInstalledDiscoveredWalletConnector({
+      connectorName,
+      chainConfig,
+      config,
+      isMipdEnabled
+    });
+    if (installedConnector) {
+      return installedConnector;
+    }
+    const isBuiltInConnectorName = Object.values(WALLET_CONNECTORS).includes(connectorName);
+    const supportsWalletConnectFallback = chainConfig.chainNamespace === CHAIN_NAMESPACES.EIP155 || chainConfig.chainNamespace === CHAIN_NAMESPACES.SOLANA;
+
+    // Named discovered wallets (for example Phantom) can reuse WalletConnect as a transport fallback
+    // when an injected connector for the target chain namespace is unavailable.
+    if (!isBuiltInConnectorName && isExternalWalletEnabled && supportsWalletConnectFallback) {
+      const {
+        walletConnectV2Connector
+      } = await import('./connectors/wallet-connect-v2-connector/index.js');
+      return walletConnectV2Connector()(config);
+    }
+    throw AccountLinkingError.unsupportedConnector(`Connector "${connectorName}" does not support automatic wallet linking. ` + `Use ${WALLET_CONNECTORS.METAMASK}, ${WALLET_CONNECTORS.WALLET_CONNECT_V2}, or an installed compatible wallet.`);
+  }
+
+  /**
+   * Create a new connector instance that is NOT registered in this.connectors and NOT
+   * subscribed to the main SDK event loop. Its lifecycle events are therefore isolated
+   * and will not mutate any global SDK state (connectedConnectorName, connection, idToken).
+   */
+  async createIsolatedWalletConnector(connectorName, chainId, projectConfig) {
+    var _ref8;
+    const effectiveProjectConfig = (_ref8 = projectConfig !== null && projectConfig !== void 0 ? projectConfig : this.projectConfig) !== null && _ref8 !== void 0 ? _ref8 : undefined;
+    const config = {
+      projectConfig: effectiveProjectConfig,
+      coreOptions: this.coreOptions,
+      analytics: this.analytics
+    };
+    let connector;
+    switch (connectorName) {
+      case WALLET_CONNECTORS.METAMASK:
+        connector = metaMaskConnector()(config);
+        break;
+      case WALLET_CONNECTORS.WALLET_CONNECT_V2:
+        {
+          const {
+            walletConnectV2Connector
+          } = await import('./connectors/wallet-connect-v2-connector/index.js');
+          connector = walletConnectV2Connector()(config);
+          break;
+        }
+      case WALLET_CONNECTORS.AUTH:
+        throw AccountLinkingError.unsupportedConnector(`Connector "${connectorName}" does not support automatic wallet linking.`);
+      default:
+        {
+          connector = await this.resolveDiscoveredWalletConnector(connectorName, chainId, config, effectiveProjectConfig);
+          break;
+        }
+    }
+
+    // Init the isolated connector WITHOUT subscribing to the main event loop.
+    // This is the key difference from setupConnector(), which calls subscribeToConnectorEvents().
+    // autoConnect: false ensures the connector does not attempt to rehydrate a previous session.
+    await connector.init({
+      chainId,
+      autoConnect: false
+    });
+    return connector;
+  }
   async setState(newState) {
     this.state = _objectSpread(_objectSpread({}, this.state), newState);
     await this.storage.set(WEB3AUTH_STATE_STORAGE_KEY, JSON.stringify(this.state));