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

package/dist/lib.esm/noModal.js

@@ -2,14 +2,15 @@ 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 { 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 { 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 { CONNECTED_STATUSES, CAN_LOGOUT_STATUSES, CAN_AUTHORIZE_STATUSES } from './base/connector/connectorStatus.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';
@@ -19,42 +20,47 @@ import { WalletInitializationError, WalletLoginError } from './base/errors/index
 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 { PLUGIN_STATUS, PLUGIN_NAMESPACES } from './base/plugin/IPlugin.js';
 
-const _excluded = ["walletScope"];
+const _excluded = ["walletScope", "eipStandard"];
 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, "storage", void 0);
+    _defineProperty(this, "currentConnection", null);
+    _defineProperty(this, "currentConnectionReconnected", false);
     _defineProperty(this, "state", {
       connectedConnectorName: null,
       cachedConnector: null,
       currentChainId: null,
-      idToken: null
+      idToken: null,
+      accessToken: null,
+      refreshToken: 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();
     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;
@@ -64,11 +70,8 @@ class Web3AuthNoModal extends SafeEventEmitter {
   get connected() {
     return Boolean(this.connectedConnector);
   }
-  get provider() {
-    if (this.status !== CONNECTOR_STATUS.NOT_READY && this.commonJRPCProvider) {
-      return this.commonJRPCProvider;
-    }
-    return null;
+  get connection() {
+    return this.currentConnection;
   }
   get connectedConnectorName() {
     return this.state.connectedConnectorName;
@@ -134,7 +137,7 @@ class Web3AuthNoModal extends SafeEventEmitter {
       // init config
       this.initAccountAbstractionConfig(projectConfig);
       this.initChainsConfig(projectConfig);
-      this.initCachedConnectorAndChainId();
+      await this.initCachedConnectorAndChainId();
       this.initUIConfig(projectConfig);
       this.initWalletServicesConfig(projectConfig);
       this.initSessionTimeConfig(projectConfig);
@@ -202,12 +205,15 @@ class Web3AuthNoModal extends SafeEventEmitter {
       return true;
     }) || null;
   }
-  clearCache() {
-    this.setState({
+  async clearCache() {
+    await this.setState({
       connectedConnectorName: null,
       cachedConnector: null,
       currentChainId: null,
-      idToken: null
+      idToken: null,
+      accessToken: null,
+      refreshToken: null,
+      hasUserConsent: undefined
     });
   }
   async cleanup() {
@@ -221,6 +227,12 @@ class Web3AuthNoModal extends SafeEventEmitter {
     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;
+      // 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.`);
+      }
       await this.connectedConnector.switchChain(params);
       return;
     }
@@ -242,7 +254,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
@@ -298,15 +310,12 @@ 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 () => {
@@ -318,7 +327,7 @@ class Web3AuthNoModal extends SafeEventEmitter {
             duration: Date.now() - startTime
           }));
           cleanup();
-          resolve(this.provider);
+          resolve(this.connection);
         } catch (error) {
           cleanup();
           reject(error);
@@ -341,7 +350,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);
@@ -352,7 +361,7 @@ 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 (!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);
   }
@@ -396,16 +405,18 @@ class Web3AuthNoModal extends SafeEventEmitter {
       throw error;
     }
   }
-  async getIdentityToken() {
+  async getAuthTokenInfo() {
     if (!CAN_AUTHORIZE_STATUSES.includes(this.status) || !this.connectedConnector) throw WalletLoginError.notConnectedError(`No wallet is connected`);
     const trackData = {
       connector: this.connectedConnector.name
     };
     try {
       this.analytics.track(ANALYTICS_EVENTS.IDENTITY_TOKEN_STARTED, trackData);
-      const identityToken = await this.connectedConnector.getIdentityToken();
+      const authTokenInfo = await this.connectedConnector.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;
@@ -418,6 +429,7 @@ class Web3AuthNoModal extends SafeEventEmitter {
     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 || [])];
@@ -453,8 +465,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");
@@ -492,26 +505,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;
@@ -527,13 +553,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
     });
   }
@@ -593,7 +619,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,
@@ -617,7 +643,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);
@@ -627,7 +653,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);
@@ -655,7 +681,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()) {
@@ -734,82 +762,105 @@ class Web3AuthNoModal extends SafeEventEmitter {
   }
   subscribeToConnectorEvents(connector) {
     connector.on(CONNECTOR_EVENTS.CONNECTED, async data => {
-      var _this$currentChain3, _accountAbstractionCo;
       if (!this.commonJRPCProvider) throw WalletInitializationError.notFound(`CommonJrpcProvider not found`);
       const {
-        provider,
-        identityTokenInfo
+        ethereumProvider,
+        solanaWallet
       } = data;
-      if (identityTokenInfo) {
-        this.setState({
-          idToken: identityTokenInfo.idToken
-        });
-      }
+      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;
 
       // 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.currentConnection = null;
           this.status = CONNECTOR_STATUS.ERRORED;
           this.emit(CONNECTOR_EVENTS.ERRORED, error, this.loginMode);
           return;
         }
       }
-      let finalProvider = provider.provider || provider;
 
-      // 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;
+      // 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 {
-          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;
+          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
+          });
+          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;
+          // 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;
+          }
         }
+        this.commonJRPCProvider.updateProviderEngineProxy(finalProvider);
       }
-      this.commonJRPCProvider.updateProviderEngineProxy(finalProvider);
-      this.setState({
-        connectedConnectorName: data.connector
+      await this.setState({
+        connectedConnectorName: data.connectorName
       });
-      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.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.connectedConnectorName);
+      } else {
+        this.status = CONNECTOR_STATUS.CONNECTED;
+        log.debug("connected", this.status, this.connectedConnectorName);
+        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 () => {
+      this.currentConnection = null;
+      this.currentConnectionReconnected = false;
       // re-setup commonJRPCProvider
       this.commonJRPCProvider.removeAllListeners();
       this.setupCommonJRPCProvider();
@@ -818,7 +869,7 @@ class Web3AuthNoModal extends SafeEventEmitter {
       this.status = CONNECTOR_STATUS.READY;
       const cachedConnector = this.state.cachedConnector;
       if (this.connectedConnectorName === cachedConnector) {
-        this.clearCache();
+        await this.clearCache();
       }
       log.debug("disconnected", this.status, this.connectedConnectorName);
       await Promise.all(Object.values(this.plugins).map(async plugin => {
@@ -833,8 +884,9 @@ class Web3AuthNoModal extends SafeEventEmitter {
           log.error(error);
         });
       }));
-      this.setState({
-        connectedConnectorName: null
+      await this.setState({
+        connectedConnectorName: null,
+        hasUserConsent: undefined
       });
       this.emit(CONNECTOR_EVENTS.DISCONNECTED);
     });
@@ -843,24 +895,24 @@ class Web3AuthNoModal extends SafeEventEmitter {
       this.emit(CONNECTOR_EVENTS.CONNECTING, data);
       log.debug("connecting", this.status, this.connectedConnectorName);
     });
-    connector.on(CONNECTOR_EVENTS.ERRORED, data => {
+    connector.on(CONNECTOR_EVENTS.ERRORED, async data => {
       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);
     });
-    connector.on(CONNECTOR_EVENTS.REHYDRATION_ERROR, error => {
+    connector.on(CONNECTOR_EVENTS.REHYDRATION_ERROR, async error => {
       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 => {
       log.debug("connector cache clear", data);
-      this.clearCache();
+      await this.clearCache();
     });
     connector.on(CONNECTOR_EVENTS.MFA_ENABLED, isMFAEnabled => {
       var _authConnector$authIn4;
@@ -881,22 +933,32 @@ class Web3AuthNoModal extends SafeEventEmitter {
       this.emit(CONNECTOR_EVENTS.AUTHORIZING, data);
       log.debug("authorizing", this.status, this.connectedConnectorName);
     });
-    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.currentConnection && !this.state.hasUserConsent) {
+        this.status = CONNECTOR_STATUS.CONSENT_REQUIRING;
+        this.emit(CONNECTOR_EVENTS.CONSENT_REQUIRING);
+        log.debug("consent_requiring", this.status, this.connectedConnectorName);
+      } else {
+        this.status = CONNECTOR_STATUS.AUTHORIZED;
+        this.emit(CONNECTOR_EVENTS.AUTHORIZED, data);
+        log.debug("authorized", this.status, this.connectedConnectorName);
+      }
     });
   }
   checkInitRequirements() {
     if (this.status === CONNECTOR_STATUS.READY) throw WalletInitializationError.notReady("Connector is already initialized");
   }
   checkIfAutoConnect(connector) {
-    var _this$currentChain5;
+    var _this$currentChain6;
     let autoConnect = this.cachedConnector === connector.name;
-    if (autoConnect && (_this$currentChain5 = this.currentChain) !== null && _this$currentChain5 !== void 0 && _this$currentChain5.chainNamespace) {
+    if (autoConnect && (_this$currentChain6 = this.currentChain) !== null && _this$currentChain6 !== void 0 && _this$currentChain6.chainNamespace) {
       if (connector.connectorNamespace === CONNECTOR_NAMESPACES.MULTICHAIN) autoConnect = true;else autoConnect = connector.connectorNamespace === this.currentChain.chainNamespace;
     }
     return autoConnect;
@@ -915,27 +977,57 @@ class Web3AuthNoModal extends SafeEventEmitter {
     }
     return initialChain;
   }
-  cacheWallet(walletName) {
-    this.setState({
+  async completeConsentAcceptance() {
+    const connection = this.currentConnection;
+    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.connectedConnectorName);
+    } else {
+      this.status = CONNECTOR_STATUS.CONNECTED;
+      log.debug("consent accepted, connected", this.status, this.connectedConnectorName);
+    }
+
+    // connect to wallet-service plugin
+    if (this.connectedConnectorName === WALLET_CONNECTORS.AUTH) {
+      this.connectToPlugins({
+        connector: this.connectedConnectorName
+      });
+    }
+    this.emit(CONNECTOR_EVENTS.CONSENT_ACCEPTED, {
+      reconnected: this.currentConnectionReconnected
+    });
+  }
+  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$currentChain7;
         // 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$currentChain7 = this.currentChain) === null || _this$currentChain7 === void 0 ? void 0 : _this$currentChain7.chainNamespace)) return;
         // skip if it's already connected
         if (plugin.status === PLUGIN_STATUS.CONNECTED) return;
         await plugin.initWithWeb3Auth(this, this.coreOptions.uiConfig, this.analytics);
@@ -949,27 +1041,27 @@ class Web3AuthNoModal extends SafeEventEmitter {
       }
     });
   }
-  setState(newState) {
+  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();
   }
 }