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

package/dist/lib.esm/noModal.js

@@ -2,48 +2,58 @@ import _objectWithoutProperties from '@babel/runtime/helpers/objectWithoutProper
 import _objectSpread from '@babel/runtime/helpers/objectSpread2';
 import _defineProperty from '@babel/runtime/helpers/defineProperty';
 import { CHAIN_NAMESPACES, BUTTON_POSITION, CONFIRMATION_STRATEGY } from '@toruslabs/base-controllers';
-import { SafeEventEmitter, serializeError, UX_MODE, cloneDeep, MemoryStore } from '@web3auth/auth';
+import { SMART_ACCOUNT_EIP_STANDARD, EIP7702_SUPPORTED_SMART_ACCOUNT_TYPES } from '@toruslabs/ethereum-controllers';
+import { SafeEventEmitter, serializeError, UX_MODE, cloneDeep, CookieStorage, LocalStorageAdapter, MemoryStorage } from '@web3auth/auth';
 import deepmerge from 'deepmerge';
-import { cookieStorage } from './base/cookie.js';
 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 { Analytics, ANALYTICS_INTEGRATION_TYPE, ANALYTICS_SDK_TYPE, ANALYTICS_EVENTS } from './base/analytics.js';
+import { log } from './base/loglevel.js';
 import { CONNECTOR_STATUS, CONNECTOR_INITIAL_AUTHENTICATION_MODE, CONNECTOR_EVENTS } from './base/connector/constants.js';
-import { sdkVersion, fetchProjectConfig, withAbort, getErrorAnalyticsProperties, getCaipChainId, isHexStrict, getHostname, getWhitelabelAnalyticsProperties, getAaAnalyticsProperties, getWalletServicesAnalyticsProperties, isBrowser } from './base/utils.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, 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 { CONNECTED_STATUSES, CAN_AUTHORIZE_STATUSES } from './base/connector/connectorStatus.js';
+import { storageAvailable } from './base/connector/utils.js';
 import { PLUGIN_STATUS, PLUGIN_NAMESPACES } from './base/plugin/IPlugin.js';
 
-const _excluded = ["walletScope"];
+const _excluded = ["walletScope", "eipStandard"];
+const PRIMARY_CONNECTED_WALLET_KEY = "__primary__";
 class Web3AuthNoModal extends SafeEventEmitter {
   constructor(options, initialState) {
     super();
     _defineProperty(this, "coreOptions", void 0);
     _defineProperty(this, "status", CONNECTOR_STATUS.NOT_READY);
+    _defineProperty(this, "loginMode", LOGIN_MODE.NO_MODAL);
     _defineProperty(this, "aaProvider", null);
     _defineProperty(this, "connectors", []);
     _defineProperty(this, "commonJRPCProvider", null);
     _defineProperty(this, "analytics", void 0);
     _defineProperty(this, "plugins", {});
+    _defineProperty(this, "consentRequired", false);
+    _defineProperty(this, "projectConfig", null);
     _defineProperty(this, "storage", void 0);
+    _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
+      idToken: null,
+      accessToken: null,
+      refreshToken: null,
+      activeAccount: null
     });
-    _defineProperty(this, "loginMode", LOGIN_MODE.NO_MODAL);
     if (!options.clientId) throw WalletInitializationError.invalidParams("Please provide a valid clientId in constructor");
     if (options.enableLogging) log.enableAll();else log.setLevel("error");
-    if (!options.storageType) options.storageType = "local";
+    if (!options.initialAuthenticationMode) options.initialAuthenticationMode = CONNECTOR_INITIAL_AUTHENTICATION_MODE.CONNECT_AND_SIGN;
     this.coreOptions = options;
     this.storage = this.getStorageMethod();
     this.analytics = new Analytics();
@@ -53,11 +63,12 @@ class Web3AuthNoModal extends SafeEventEmitter {
     this.analytics.setGlobalProperties({
       integration_type: ANALYTICS_INTEGRATION_TYPE.NATIVE_SDK
     });
-    this.loadState(initialState);
-    if (this.state.idToken && this.coreOptions.ssr) {
-      // connect-only is the default authentication mode, so we need to set the status to connected if the idToken is present and ssr is enabled
-      this.status = this.coreOptions.initialAuthenticationMode === CONNECTOR_INITIAL_AUTHENTICATION_MODE.CONNECT_AND_SIGN ? CONNECTOR_STATUS.AUTHORIZED : CONNECTOR_STATUS.CONNECTED;
-    }
+    this.loadState(initialState).then(() => {
+      if (this.state.idToken && this.coreOptions.ssr && !this.consentRequired) {
+        this.status = this.coreOptions.initialAuthenticationMode === CONNECTOR_INITIAL_AUTHENTICATION_MODE.CONNECT_AND_SIGN ? CONNECTOR_STATUS.AUTHORIZED : CONNECTOR_STATUS.CONNECTED;
+      }
+      return undefined;
+    }).catch(() => {});
   }
   get currentChain() {
     var _this$coreOptions$cha;
@@ -65,16 +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 provider() {
-    if (this.status !== CONNECTOR_STATUS.NOT_READY && this.commonJRPCProvider) {
-      return this.commonJRPCProvider;
-    }
-    return null;
+  get connection() {
+    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,9 +170,10 @@ class Web3AuthNoModal extends SafeEventEmitter {
       }
 
       // init config
+      this.projectConfig = projectConfig;
       this.initAccountAbstractionConfig(projectConfig);
       this.initChainsConfig(projectConfig);
-      this.initCachedConnectorAndChainId();
+      await this.initCachedConnectorAndChainId();
       this.initUIConfig(projectConfig);
       this.initWalletServicesConfig(projectConfig);
       this.initSessionTimeConfig(projectConfig);
@@ -205,12 +241,19 @@ class Web3AuthNoModal extends SafeEventEmitter {
       return true;
     }) || null;
   }
-  clearCache() {
-    this.setState({
-      connectedConnectorName: null,
+  async clearCache() {
+    this.connectedWalletConnectorMap.clear();
+    this.activeWalletConnectorKey = PRIMARY_CONNECTED_WALLET_KEY;
+    this.connectionReconnected = false;
+    await this.setState({
+      primaryConnectorName: null,
       cachedConnector: null,
       currentChainId: null,
-      idToken: null
+      idToken: null,
+      accessToken: null,
+      refreshToken: null,
+      activeAccount: null,
+      hasUserConsent: undefined
     });
   }
   async cleanup() {
@@ -223,8 +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) {
-      await this.connectedConnector.switchChain(params);
+    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 (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 activeConnector.switchChain(params);
       return;
     }
     if (this.commonJRPCProvider) {
@@ -245,7 +296,7 @@ class Web3AuthNoModal extends SafeEventEmitter {
     const initialChain = this.getInitialChainIdForConnector(connector);
     const finalLoginParams = _objectSpread(_objectSpread({}, loginParams), {}, {
       chainId: initialChain.chainId,
-      getIdentityToken: this.coreOptions.initialAuthenticationMode === CONNECTOR_INITIAL_AUTHENTICATION_MODE.CONNECT_AND_SIGN
+      getAuthTokenInfo: this.coreOptions.initialAuthenticationMode === CONNECTOR_INITIAL_AUTHENTICATION_MODE.CONNECT_AND_SIGN
     });
 
     // track connection started event
@@ -301,27 +352,24 @@ class Web3AuthNoModal extends SafeEventEmitter {
       };
       const checkCompletion = async () => {
         // In CONNECT_AND_SIGN mode, wait for both connected event and authorized event
-        if (finalLoginParams.getIdentityToken) {
+        if (finalLoginParams.getAuthTokenInfo) {
           if (connectedEventCompleted && authorizedEventReceived) {
             await completeConnection();
           }
-        } else {
-          // In CONNECT_ONLY mode, just wait for connected event
-          if (connectedEventCompleted) {
-            await completeConnection();
-          }
+        } else if (connectedEventCompleted) {
+          await completeConnection();
         }
       };
       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
           }));
           cleanup();
-          resolve(this.provider);
+          resolve(this.connection);
         } catch (error) {
           cleanup();
           reject(error);
@@ -344,7 +392,7 @@ class Web3AuthNoModal extends SafeEventEmitter {
         reject(err);
       };
       this.once(CONNECTOR_EVENTS.CONNECTED, onConnected);
-      if (finalLoginParams.getIdentityToken) {
+      if (finalLoginParams.getAuthTokenInfo) {
         this.once(CONNECTOR_EVENTS.AUTHORIZED, onAuthorized);
       }
       this.once(CONNECTOR_EVENTS.ERRORED, onErrored);
@@ -355,28 +403,60 @@ class Web3AuthNoModal extends SafeEventEmitter {
   async logout(options = {
     cleanup: false
   }) {
-    if (!CONNECTED_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;
@@ -384,31 +464,33 @@ 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 getIdentityToken() {
-    if (!CAN_AUTHORIZE_STATUSES.includes(this.status) || !this.connectedConnector) throw WalletLoginError.notConnectedError(`No wallet is connected`);
+  async getAuthTokenInfo() {
+    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 identityToken = await this.connectedConnector.getIdentityToken();
+      const authTokenInfo = await this.primaryConnector.getAuthTokenInfo();
       this.analytics.track(ANALYTICS_EVENTS.IDENTITY_TOKEN_COMPLETED, trackData);
-      return identityToken;
+      return {
+        idToken: authTokenInfo.idToken
+      };
     } catch (error) {
       this.analytics.track(ANALYTICS_EVENTS.IDENTITY_TOKEN_FAILED, _objectSpread(_objectSpread({}, trackData), getErrorAnalyticsProperties(error)));
       throw error;
@@ -417,10 +499,81 @@ 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);
   }
   initChainsConfig(projectConfig) {
+    var _this$coreOptions$acc2;
     // merge chains from project config with core options, core options chains will take precedence over project config chains
     const chainMap = new Map();
     const allChains = [...(projectConfig.chains || []), ...(this.coreOptions.chains || [])];
@@ -456,8 +609,9 @@ class Web3AuthNoModal extends SafeEventEmitter {
       }
     }
 
-    // if AA is enabled, filter out chains that are not AA-supported
-    if (this.coreOptions.accountAbstractionConfig) {
+    // if AA is enabled and smart account is not 7702, filter out chains that are not AA-supported
+    const is7702SmartAccount = ((_this$coreOptions$acc2 = this.coreOptions.accountAbstractionConfig) === null || _this$coreOptions$acc2 === void 0 ? void 0 : _this$coreOptions$acc2.smartAccountEipStandard) === SMART_ACCOUNT_EIP_STANDARD.EIP_7702;
+    if (this.coreOptions.accountAbstractionConfig && !is7702SmartAccount) {
       // write a for loop over accountAbstractionConfig.chains and check if the chainId is valid
       if (this.coreOptions.accountAbstractionConfig.chains.length === 0) {
         log.error("Please configure chains for smart accounts on dashboard at https://dashboard.web3auth.io");
@@ -495,26 +649,39 @@ class Web3AuthNoModal extends SafeEventEmitter {
     }
   }
   initAccountAbstractionConfig(projectConfig) {
-    var _this$coreOptions$acc2;
+    var _this$coreOptions$acc3;
     const isAAEnabled = Boolean(this.coreOptions.accountAbstractionConfig || (projectConfig === null || projectConfig === void 0 ? void 0 : projectConfig.smartAccounts));
     if (!isAAEnabled) return;
 
     // merge smart account config from project config with core options, core options will take precedence over project config
     const _ref = (projectConfig === null || projectConfig === void 0 ? void 0 : projectConfig.smartAccounts) || {},
       {
-        walletScope
+        walletScope,
+        eipStandard
       } = _ref,
       configWithoutWalletScope = _objectWithoutProperties(_ref, _excluded);
     const aaChainMap = new Map();
-    const allAaChains = [...((configWithoutWalletScope === null || configWithoutWalletScope === void 0 ? void 0 : configWithoutWalletScope.chains) || []), ...(((_this$coreOptions$acc2 = this.coreOptions.accountAbstractionConfig) === null || _this$coreOptions$acc2 === void 0 ? void 0 : _this$coreOptions$acc2.chains) || [])];
+    const allAaChains = [...((configWithoutWalletScope === null || configWithoutWalletScope === void 0 ? void 0 : configWithoutWalletScope.chains) || []), ...(((_this$coreOptions$acc3 = this.coreOptions.accountAbstractionConfig) === null || _this$coreOptions$acc3 === void 0 ? void 0 : _this$coreOptions$acc3.chains) || [])];
     for (const chain of allAaChains) {
       const existingChain = aaChainMap.get(chain.chainId);
       if (!existingChain) aaChainMap.set(chain.chainId, chain);else aaChainMap.set(chain.chainId, _objectSpread(_objectSpread({}, existingChain), chain));
     }
-    this.coreOptions.accountAbstractionConfig = _objectSpread(_objectSpread({}, deepmerge(configWithoutWalletScope || {}, this.coreOptions.accountAbstractionConfig || {})), {}, {
+    this.coreOptions.accountAbstractionConfig = _objectSpread(_objectSpread({
+      smartAccountEipStandard: eipStandard
+    }, deepmerge(configWithoutWalletScope || {}, this.coreOptions.accountAbstractionConfig || {})), {}, {
       chains: Array.from(aaChainMap.values())
     });
 
+    // if eipStandard is 7702, validate smart account type
+    const {
+      smartAccountEipStandard,
+      smartAccountType
+    } = this.coreOptions.accountAbstractionConfig;
+    const is7702SmartAccount = smartAccountEipStandard === SMART_ACCOUNT_EIP_STANDARD.EIP_7702;
+    if (is7702SmartAccount && smartAccountType && !EIP7702_SUPPORTED_SMART_ACCOUNT_TYPES.includes(smartAccountType)) {
+      throw WalletInitializationError.invalidParams(`Smart account type "${smartAccountType}" does not support EIP-7702. Supported: ${EIP7702_SUPPORTED_SMART_ACCOUNT_TYPES.join(", ")}`);
+    }
+
     // determine if we should use AA with external wallet
     if (this.coreOptions.useAAWithExternalWallet === undefined) {
       this.coreOptions.useAAWithExternalWallet = walletScope === SMART_ACCOUNT_WALLET_SCOPE.ALL;
@@ -530,13 +697,13 @@ class Web3AuthNoModal extends SafeEventEmitter {
     if (this.coreOptions.sessionTime) return;
     if (projectConfig.sessionTime) this.coreOptions.sessionTime = projectConfig.sessionTime;
   }
-  initCachedConnectorAndChainId() {
+  async initCachedConnectorAndChainId() {
     // init chainId using cached chainId if it exists and is valid, otherwise use the defaultChainId or the first chain
     const cachedChainId = this.state.currentChainId;
     const isCachedChainIdValid = cachedChainId && this.coreOptions.chains.some(chain => chain.chainId === cachedChainId);
     if (this.coreOptions.defaultChainId && !isHexStrict(this.coreOptions.defaultChainId)) throw WalletInitializationError.invalidParams("Please provide a valid defaultChainId in constructor");
     const currentChainId = isCachedChainIdValid ? cachedChainId : this.coreOptions.defaultChainId || this.coreOptions.chains[0].chainId;
-    this.setState({
+    await this.setState({
       currentChainId
     });
   }
@@ -596,7 +763,7 @@ class Web3AuthNoModal extends SafeEventEmitter {
         default_chain_id: defaultChain ? getCaipChainId(defaultChain) : undefined,
         default_chain_name: defaultChain === null || defaultChain === void 0 ? void 0 : defaultChain.displayName,
         logging_enabled: this.coreOptions.enableLogging,
-        storage_type: this.coreOptions.storageType,
+        custom_storage: Boolean(this.coreOptions.storage),
         session_time: this.coreOptions.sessionTime,
         sfa_key_enabled: this.coreOptions.useSFAKey,
         mipd_enabled: this.coreOptions.multiInjectedProviderDiscovery,
@@ -620,7 +787,7 @@ class Web3AuthNoModal extends SafeEventEmitter {
     });
 
     // sync chainId
-    this.commonJRPCProvider.on("chainChanged", chainId => this.setCurrentChain(chainId));
+    this.commonJRPCProvider.on("chainChanged", async chainId => this.setCurrentChain(chainId));
   }
   async setupConnector(connector) {
     this.subscribeToConnectorEvents(connector);
@@ -630,7 +797,7 @@ class Web3AuthNoModal extends SafeEventEmitter {
       await connector.init({
         autoConnect,
         chainId: initialChain.chainId,
-        getIdentityToken: this.coreOptions.initialAuthenticationMode === CONNECTOR_INITIAL_AUTHENTICATION_MODE.CONNECT_AND_SIGN
+        getAuthTokenInfo: this.coreOptions.initialAuthenticationMode === CONNECTOR_INITIAL_AUTHENTICATION_MODE.CONNECT_AND_SIGN
       });
     } catch (e) {
       log.error(e, connector.name);
@@ -658,7 +825,9 @@ class Web3AuthNoModal extends SafeEventEmitter {
     if (isBrowser() && chainNamespaces.has(CHAIN_NAMESPACES.EIP155)) {
       // only set headless to true if modal SDK is used, otherwise just use the modal from native Metamask SDK
       connectorFns.push(metaMaskConnector(modalMode ? {
-        headless: true
+        ui: {
+          headless: true
+        }
       } : undefined));
     }
     if (isMipdEnabled && isBrowser()) {
@@ -737,82 +906,139 @@ class Web3AuthNoModal extends SafeEventEmitter {
   }
   subscribeToConnectorEvents(connector) {
     connector.on(CONNECTOR_EVENTS.CONNECTED, async data => {
-      var _this$currentChain3, _accountAbstractionCo;
+      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 {
-        provider,
-        identityTokenInfo
+        ethereumProvider,
+        solanaWallet
       } = data;
-      if (identityTokenInfo) {
-        this.setState({
-          idToken: identityTokenInfo.idToken
-        });
-      }
+      // 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;
+      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 {
-          const data = await connector.getIdentityToken();
+          var _data$accessToken, _data$refreshToken;
+          const data = await connector.getAuthTokenInfo();
           if (!data.idToken) throw WalletLoginError.connectionError("No idToken found");
-          this.setState({
-            idToken: data.idToken
+          await this.setState({
+            idToken: data.idToken,
+            accessToken: (_data$accessToken = data.accessToken) !== null && _data$accessToken !== void 0 ? _data$accessToken : null,
+            refreshToken: (_data$refreshToken = data.refreshToken) !== null && _data$refreshToken !== void 0 ? _data$refreshToken : null
           });
         } catch (error) {
           log.error(error);
+          this.deleteConnectedWalletConnector();
+          this.setActiveWalletConnectorKey();
           this.status = CONNECTOR_STATUS.ERRORED;
           this.emit(CONNECTOR_EVENTS.ERRORED, error, this.loginMode);
           return;
         }
       }
-      let finalProvider = provider.provider || provider;
+      // The following block only hits during rehydration
 
-      // setup AA provider if AA is enabled
       const {
-        accountAbstractionConfig
-      } = this.coreOptions;
-      const isAaSupportedForCurrentChain = ((_this$currentChain3 = this.currentChain) === null || _this$currentChain3 === void 0 ? void 0 : _this$currentChain3.chainNamespace) === CHAIN_NAMESPACES.EIP155 && (accountAbstractionConfig === null || accountAbstractionConfig === void 0 || (_accountAbstractionCo = accountAbstractionConfig.chains) === null || _accountAbstractionCo === void 0 ? void 0 : _accountAbstractionCo.some(chain => {
-        var _this$currentChain4;
-        return chain.chainId === ((_this$currentChain4 = this.currentChain) === null || _this$currentChain4 === void 0 ? void 0 : _this$currentChain4.chainId);
-      }));
-      if (isAaSupportedForCurrentChain && (data.connector === 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.connector === WALLET_CONNECTORS.AUTH ? await toEoaProvider(provider) : provider;
-        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.connector === WALLET_CONNECTORS.AUTH
-        });
-        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.connector !== WALLET_CONNECTORS.AUTH && this.coreOptions.useAAWithExternalWallet) {
-          finalProvider = this.aaProvider;
+        activeAccount
+      } = this.state;
+      // if the active account is not the primary account, i.e. not `null`, create an isolated connector and connect to the chain
+      if (activeAccount && !activeAccount.isPrimary && activeAccount.connector !== WALLET_CONNECTORS.AUTH) {
+        var _ref3, _walletConnector$prov, _linkedAccountConnect, _ref4, _walletConnector$sola, _linkedAccountConnect2;
+        const accountLinkingConnector = isAuthConnector(connector) ? connector : this.getConnector(WALLET_CONNECTORS.AUTH);
+        assertAuthConnector(accountLinkingConnector, "Account switching requires the AUTH connector to be available.");
+        const targetChainId = accountLinkingConnector.getChainIdForLinkedAccount(activeAccount, connectedChainId);
+        const walletConnector = await this.createIsolatedWalletConnector(activeAccount.connector, targetChainId);
+        let linkedAccountConnection = null;
+        if (!this.hasUsableConnectedSwitchConnector(walletConnector)) {
+          linkedAccountConnection = await walletConnector.connect({
+            chainId: targetChainId
+          });
+          if (!linkedAccountConnection) {
+            throw AccountLinkingError.requestFailed(`Failed to connect isolated connector "${activeAccount.connector}" for account switch.`);
+          }
         }
+        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);
       }
-      this.commonJRPCProvider.updateProviderEngineProxy(finalProvider);
-      this.setState({
-        connectedConnectorName: data.connector
+      if (ethereumProvider) {
+        await this.bindPrimaryEthereumSigningProxy(ethereumProvider, data.connectorName);
+      }
+      const primaryConnectedWalletState = await this.resolveConnectedWalletConnectorState({
+        connector,
+        ethereumProvider,
+        solanaWallet,
+        usePrimaryProxy: true
       });
-      this.cacheWallet(data.connector);
-      this.status = CONNECTOR_STATUS.CONNECTED;
-      log.debug("connected", this.status, this.connectedConnectorName);
-      this.connectToPlugins(_objectSpread(_objectSpread({}, data), {}, {
-        connector: data.connector
-      }));
-      this.emit(CONNECTOR_EVENTS.CONNECTED, _objectSpread(_objectSpread({}, data), {}, {
-        loginMode: this.loginMode
-      }));
+      this.setConnectedWalletConnectorState(primaryConnectedWalletState);
+      await this.setState({
+        primaryConnectorName: data.connectorName,
+        currentChainId: connectedChainId
+      });
+      this.cacheWallet(data.connectorName);
+      const isConnectAndSign = this.coreOptions.initialAuthenticationMode === CONNECTOR_INITIAL_AUTHENTICATION_MODE.CONNECT_AND_SIGN;
+      if (this.consentRequired && !isConnectAndSign && !this.state.hasUserConsent) {
+        this.status = CONNECTOR_STATUS.CONSENT_REQUIRING;
+        this.emit(CONNECTOR_EVENTS.CONSENT_REQUIRING);
+        log.debug("consent_requiring", this.status, this.primaryConnectorName);
+      } else {
+        this.status = CONNECTOR_STATUS.CONNECTED;
+        log.debug("connected", this.status, this.primaryConnectorName);
+        this.connectToPlugins(_objectSpread(_objectSpread({}, data), {}, {
+          connector: data.connectorName
+        }));
+        this.emit(CONNECTOR_EVENTS.CONNECTED, _objectSpread(_objectSpread({}, data), {}, {
+          loginMode: this.loginMode
+        }));
+      }
     });
-    connector.on(CONNECTOR_EVENTS.DISCONNECTED, async () => {
+    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();
@@ -820,10 +1046,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) {
-        this.clearCache();
+      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;
@@ -836,44 +1062,61 @@ class Web3AuthNoModal extends SafeEventEmitter {
           log.error(error);
         });
       }));
-      this.setState({
-        connectedConnectorName: null
+      await this.setState({
+        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, data => {
+    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;
-      this.clearCache();
+      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, error => {
+    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;
-      this.clearCache();
+      await this.clearCache();
       this.emit(CONNECTOR_EVENTS.REHYDRATION_ERROR, error);
     });
     connector.on(CONNECTOR_EVENTS.CONNECTOR_DATA_UPDATED, data => {
       log.debug("connector data updated", data);
       this.emit(CONNECTOR_EVENTS.CONNECTOR_DATA_UPDATED, data);
     });
-    connector.on(CONNECTOR_EVENTS.CACHE_CLEAR, data => {
+    connector.on(CONNECTOR_EVENTS.CACHE_CLEAR, async data => {
+      if (this.shouldIgnoreInactiveConnectorEvent(connector, CONNECTOR_EVENTS.CACHE_CLEAR)) return;
       log.debug("connector cache clear", data);
-      this.clearCache();
+      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
       });
@@ -882,24 +1125,34 @@ 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, data => {
-      this.status = CONNECTOR_STATUS.AUTHORIZED;
-      this.setState({
-        idToken: data.identityTokenInfo.idToken
+    connector.on(CONNECTOR_EVENTS.AUTHORIZED, async data => {
+      var _data$authTokenInfo$a, _data$authTokenInfo$r;
+      await this.setState({
+        idToken: data.authTokenInfo.idToken,
+        accessToken: (_data$authTokenInfo$a = data.authTokenInfo.accessToken) !== null && _data$authTokenInfo$a !== void 0 ? _data$authTokenInfo$a : null,
+        refreshToken: (_data$authTokenInfo$r = data.authTokenInfo.refreshToken) !== null && _data$authTokenInfo$r !== void 0 ? _data$authTokenInfo$r : null
       });
-      this.emit(CONNECTOR_EVENTS.AUTHORIZED, data);
-      log.debug("authorized", this.status, this.connectedConnectorName);
+      // if the user has not consented yet, we will ask for consent
+      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.primaryConnectorName);
+      } else {
+        this.status = CONNECTOR_STATUS.AUTHORIZED;
+        this.emit(CONNECTOR_EVENTS.AUTHORIZED, data);
+        log.debug("authorized", this.status, this.primaryConnectorName);
+      }
     });
   }
   checkInitRequirements() {
     if (this.status === CONNECTOR_STATUS.READY) throw WalletInitializationError.notReady("Connector is already initialized");
   }
   checkIfAutoConnect(connector) {
-    var _this$currentChain5;
+    var _this$currentChain3;
     let autoConnect = this.cachedConnector === connector.name;
-    if (autoConnect && (_this$currentChain5 = this.currentChain) !== null && _this$currentChain5 !== void 0 && _this$currentChain5.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;
@@ -918,27 +1171,425 @@ class Web3AuthNoModal extends SafeEventEmitter {
     }
     return initialChain;
   }
-  cacheWallet(walletName) {
-    this.setState({
+  async completeConsentAcceptance() {
+    const connection = this.connection;
+    if (!connection) {
+      throw WalletLoginError.connectionError("Cannot accept consent: no active connection");
+    }
+    if (this.status !== CONNECTOR_STATUS.CONSENT_REQUIRING) {
+      throw WalletLoginError.connectionError("Cannot accept consent: not in consent_requiring state");
+    }
+    await this.setState({
+      hasUserConsent: true
+    });
+    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.primaryConnectorName);
+    } else {
+      this.status = CONNECTOR_STATUS.CONNECTED;
+      log.debug("consent accepted, connected", this.status, this.primaryConnectorName);
+    }
+
+    // connect to wallet-service plugin
+    if (this.primaryConnectorName === WALLET_CONNECTORS.AUTH) {
+      this.connectToPlugins({
+        connector: this.primaryConnectorName
+      });
+    }
+    this.emit(CONNECTOR_EVENTS.CONSENT_ACCEPTED, {
+      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, walletConnector) {
+    const authConnector = this.getMainAuthConnector();
+    const result = await authConnector.linkAccount({
+      connectorName,
+      chainId,
+      walletConnector,
+      authSessionTokens: {
+        accessToken: this.accessToken,
+        idToken: this.idToken
+      }
+    });
+    await this.setState({
+      idToken: result.idToken
+    });
+    await this.cacheConnectedLinkedWalletConnector(authConnector, walletConnector);
+    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
     });
   }
-  setCurrentChain(chainId) {
+  async setCurrentChain(chainId) {
     if (chainId === this.currentChainId) return;
     const newChain = this.coreOptions.chains.find(chain => chain.chainId === chainId);
     if (!newChain) throw WalletInitializationError.invalidParams(`Invalid chainId: ${chainId}`);
-    this.setState({
+    await this.setState({
       currentChainId: chainId
     });
   }
   connectToPlugins(data) {
     Object.values(this.plugins).map(async plugin => {
       try {
-        var _this$currentChain6;
+        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$currentChain6 = this.currentChain) === null || _this$currentChain6 === void 0 ? void 0 : _this$currentChain6.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);
@@ -952,27 +1603,174 @@ class Web3AuthNoModal extends SafeEventEmitter {
       }
     });
   }
-  setState(newState) {
+  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);
-    this.storage.setItem(WEB3AUTH_STATE_STORAGE_KEY, JSON.stringify(this.state));
+    await this.storage.set(WEB3AUTH_STATE_STORAGE_KEY, JSON.stringify(this.state));
   }
-  loadState(initialState) {
+  async loadState(initialState) {
     if (initialState) {
-      this.state = initialState;
+      this.state = _objectSpread(_objectSpread({}, this.state), initialState);
       return;
     }
-    const state = this.storage.getItem(WEB3AUTH_STATE_STORAGE_KEY);
+    const state = await this.storage.get(WEB3AUTH_STATE_STORAGE_KEY);
     if (!state) return;
     this.state = deserialize(state);
   }
   getStorageMethod() {
-    if (this.coreOptions.ssr || this.coreOptions.storageType === "cookies") return cookieStorage({
-      expiry: this.coreOptions.sessionTime
+    var _this$coreOptions$sto;
+    if ((_this$coreOptions$sto = this.coreOptions.storage) !== null && _this$coreOptions$sto !== void 0 && _this$coreOptions$sto.sessionId) return this.coreOptions.storage.sessionId;
+    if (this.coreOptions.ssr) return new CookieStorage({
+      maxAge: this.coreOptions.sessionTime
     });
-    if (this.coreOptions.storageType === "session" && storageAvailable("sessionStorage")) return window.sessionStorage;
-    if (this.coreOptions.storageType === "local" && storageAvailable("localStorage")) return window.localStorage;
-    // If no storage is available, use a memory store.
-    return new MemoryStore();
+    if (storageAvailable("localStorage")) return new LocalStorageAdapter();
+    return new MemoryStorage();
   }
 }