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

package/dist/lib.cjs/noModal.js

@@ -4,22 +4,23 @@ var _objectWithoutProperties = require('@babel/runtime/helpers/objectWithoutProp
 var _objectSpread = require('@babel/runtime/helpers/objectSpread2');
 var _defineProperty = require('@babel/runtime/helpers/defineProperty');
 var baseControllers = require('@toruslabs/base-controllers');
+var ethereumControllers = require('@toruslabs/ethereum-controllers');
 var auth = require('@web3auth/auth');
 var deepmerge = require('deepmerge');
 var analytics = require('./base/analytics.js');
 var IChainInterface = require('./base/chain/IChainInterface.js');
+require('@toruslabs/session-manager');
 var index = require('./base/errors/index.js');
+var loglevel = require('./base/loglevel.js');
+var utils = require('./base/utils.js');
 var index$1 = require('./base/wallet/index.js');
 var connectorStatus = require('./base/connector/connectorStatus.js');
 var constants = require('./base/connector/constants.js');
 var utils$1 = require('./base/connector/utils.js');
 var constants$1 = require('./base/constants.js');
-var cookie = require('./base/cookie.js');
-var loglevel = require('./base/loglevel.js');
+var deserialize = require('./base/deserialize.js');
 require('./base/plugin/errors.js');
 var IPlugin = require('./base/plugin/IPlugin.js');
-var utils = require('./base/utils.js');
-var deserialize = require('./base/deserialize.js');
 var authConnector = require('./connectors/auth-connector/authConnector.js');
 var metamaskConnector = require('./connectors/metamask-connector/metamaskConnector.js');
 var plugin = require('./plugins/wallet-services-plugin/plugin.js');
@@ -27,39 +28,45 @@ require('./providers/base-provider/utils.js');
 var CommonJRPCProvider = require('./providers/base-provider/CommonJRPCProvider.js');
 require('./providers/base-provider/commonPrivateKeyProvider.js');
 
-const _excluded = ["walletScope"];
+const _excluded = ["walletScope", "eipStandard"];
 class Web3AuthNoModal extends auth.SafeEventEmitter {
   constructor(options, initialState) {
     super();
     _defineProperty(this, "coreOptions", void 0);
     _defineProperty(this, "status", constants.CONNECTOR_STATUS.NOT_READY);
+    _defineProperty(this, "loginMode", constants$1.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", constants$1.LOGIN_MODE.NO_MODAL);
     if (!options.clientId) throw index.WalletInitializationError.invalidParams("Please provide a valid clientId in constructor");
     if (options.enableLogging) loglevel.log.enableAll();else loglevel.log.setLevel("error");
-    if (!options.storageType) options.storageType = "local";
+    if (!options.initialAuthenticationMode) options.initialAuthenticationMode = constants.CONNECTOR_INITIAL_AUTHENTICATION_MODE.CONNECT_AND_SIGN;
     this.coreOptions = options;
     this.storage = this.getStorageMethod();
     this.analytics = new analytics.Analytics();
     this.analytics.setGlobalProperties({
       integration_type: analytics.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 === constants.CONNECTOR_INITIAL_AUTHENTICATION_MODE.CONNECT_AND_SIGN ? constants.CONNECTOR_STATUS.AUTHORIZED : constants.CONNECTOR_STATUS.CONNECTED;
-    }
+    this.loadState(initialState).then(() => {
+      if (this.state.idToken && this.coreOptions.ssr && !this.consentRequired) {
+        this.status = this.coreOptions.initialAuthenticationMode === constants.CONNECTOR_INITIAL_AUTHENTICATION_MODE.CONNECT_AND_SIGN ? constants.CONNECTOR_STATUS.AUTHORIZED : constants.CONNECTOR_STATUS.CONNECTED;
+      }
+      return undefined;
+    }).catch(() => {});
   }
   get currentChain() {
     var _this$coreOptions$cha;
@@ -69,11 +76,8 @@ class Web3AuthNoModal extends auth.SafeEventEmitter {
   get connected() {
     return Boolean(this.connectedConnector);
   }
-  get provider() {
-    if (this.status !== constants.CONNECTOR_STATUS.NOT_READY && this.commonJRPCProvider) {
-      return this.commonJRPCProvider;
-    }
-    return null;
+  get connection() {
+    return this.currentConnection;
   }
   get connectedConnectorName() {
     return this.state.connectedConnectorName;
@@ -138,7 +142,7 @@ class Web3AuthNoModal extends auth.SafeEventEmitter {
       // init config
       this.initAccountAbstractionConfig(projectConfig);
       this.initChainsConfig(projectConfig);
-      this.initCachedConnectorAndChainId();
+      await this.initCachedConnectorAndChainId();
       this.initUIConfig(projectConfig);
       this.initWalletServicesConfig(projectConfig);
       this.initSessionTimeConfig(projectConfig);
@@ -200,12 +204,15 @@ class Web3AuthNoModal extends auth.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() {
@@ -219,6 +226,12 @@ class Web3AuthNoModal extends auth.SafeEventEmitter {
     const newChainConfig = this.coreOptions.chains.find(x => x.chainId === params.chainId);
     if (!newChainConfig) throw index.WalletInitializationError.invalidParams("Invalid chainId");
     if (connectorStatus.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 !== IChainInterface.CONNECTOR_NAMESPACES.MULTICHAIN && ((_this$currentChain3 = this.currentChain) === null || _this$currentChain3 === void 0 ? void 0 : _this$currentChain3.chainNamespace) !== newChainConfig.chainNamespace) {
+        throw index.WalletLoginError.connectionError(`Cannot switch between chain namespaces with ${this.connectedConnector.name}. Disconnect and reconnect with the target chain.`);
+      }
       await this.connectedConnector.switchChain(params);
       return;
     }
@@ -239,7 +252,7 @@ class Web3AuthNoModal extends auth.SafeEventEmitter {
     const initialChain = this.getInitialChainIdForConnector(connector);
     const finalLoginParams = _objectSpread(_objectSpread({}, loginParams), {}, {
       chainId: initialChain.chainId,
-      getIdentityToken: this.coreOptions.initialAuthenticationMode === constants.CONNECTOR_INITIAL_AUTHENTICATION_MODE.CONNECT_AND_SIGN
+      getAuthTokenInfo: this.coreOptions.initialAuthenticationMode === constants.CONNECTOR_INITIAL_AUTHENTICATION_MODE.CONNECT_AND_SIGN
     });
     // track connection started event
     const startTime = Date.now();
@@ -293,15 +306,12 @@ class Web3AuthNoModal extends auth.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 () => {
@@ -313,7 +323,7 @@ class Web3AuthNoModal extends auth.SafeEventEmitter {
             duration: Date.now() - startTime
           }));
           cleanup();
-          resolve(this.provider);
+          resolve(this.connection);
         } catch (error) {
           cleanup();
           reject(error);
@@ -336,7 +346,7 @@ class Web3AuthNoModal extends auth.SafeEventEmitter {
         reject(err);
       };
       this.once(constants.CONNECTOR_EVENTS.CONNECTED, onConnected);
-      if (finalLoginParams.getIdentityToken) {
+      if (finalLoginParams.getAuthTokenInfo) {
         this.once(constants.CONNECTOR_EVENTS.AUTHORIZED, onAuthorized);
       }
       this.once(constants.CONNECTOR_EVENTS.ERRORED, onErrored);
@@ -347,7 +357,7 @@ class Web3AuthNoModal extends auth.SafeEventEmitter {
   async logout(options = {
     cleanup: false
   }) {
-    if (!connectorStatus.CONNECTED_STATUSES.includes(this.status) || !this.connectedConnector) throw index.WalletLoginError.notConnectedError(`No wallet is connected`);
+    if (!connectorStatus.CAN_LOGOUT_STATUSES.includes(this.status) || !this.connectedConnector) throw index.WalletLoginError.notConnectedError(`No wallet is connected`);
     if (this.connectedConnector.status === constants.CONNECTOR_STATUS.DISCONNECTING) return;
     await this.connectedConnector.disconnect(options);
   }
@@ -391,16 +401,18 @@ class Web3AuthNoModal extends auth.SafeEventEmitter {
       throw error;
     }
   }
-  async getIdentityToken() {
+  async getAuthTokenInfo() {
     if (!connectorStatus.CAN_AUTHORIZE_STATUSES.includes(this.status) || !this.connectedConnector) throw index.WalletLoginError.notConnectedError(`No wallet is connected`);
     const trackData = {
       connector: this.connectedConnector.name
     };
     try {
       this.analytics.track(analytics.ANALYTICS_EVENTS.IDENTITY_TOKEN_STARTED, trackData);
-      const identityToken = await this.connectedConnector.getIdentityToken();
+      const authTokenInfo = await this.connectedConnector.getAuthTokenInfo();
       this.analytics.track(analytics.ANALYTICS_EVENTS.IDENTITY_TOKEN_COMPLETED, trackData);
-      return identityToken;
+      return {
+        idToken: authTokenInfo.idToken
+      };
     } catch (error) {
       this.analytics.track(analytics.ANALYTICS_EVENTS.IDENTITY_TOKEN_FAILED, _objectSpread(_objectSpread({}, trackData), utils.getErrorAnalyticsProperties(error)));
       throw error;
@@ -413,6 +425,7 @@ class Web3AuthNoModal extends auth.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 || [])];
@@ -446,8 +459,9 @@ class Web3AuthNoModal extends auth.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) === ethereumControllers.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) {
         loglevel.log.error("Please configure chains for smart accounts on dashboard at https://dashboard.web3auth.io");
@@ -485,24 +499,36 @@ class Web3AuthNoModal extends auth.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 === ethereumControllers.SMART_ACCOUNT_EIP_STANDARD.EIP_7702;
+    if (is7702SmartAccount && smartAccountType && !ethereumControllers.EIP7702_SUPPORTED_SMART_ACCOUNT_TYPES.includes(smartAccountType)) {
+      throw index.WalletInitializationError.invalidParams(`Smart account type "${smartAccountType}" does not support EIP-7702. Supported: ${ethereumControllers.EIP7702_SUPPORTED_SMART_ACCOUNT_TYPES.join(", ")}`);
+    }
     // determine if we should use AA with external wallet
     if (this.coreOptions.useAAWithExternalWallet === undefined) {
       this.coreOptions.useAAWithExternalWallet = walletScope === constants$1.SMART_ACCOUNT_WALLET_SCOPE.ALL;
@@ -518,13 +544,13 @@ class Web3AuthNoModal extends auth.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 && !utils.isHexStrict(this.coreOptions.defaultChainId)) throw index.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
     });
   }
@@ -584,7 +610,7 @@ class Web3AuthNoModal extends auth.SafeEventEmitter {
         default_chain_id: defaultChain ? utils.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,
@@ -607,7 +633,7 @@ class Web3AuthNoModal extends auth.SafeEventEmitter {
       chains: this.coreOptions.chains
     });
     // 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);
@@ -617,7 +643,7 @@ class Web3AuthNoModal extends auth.SafeEventEmitter {
       await connector.init({
         autoConnect,
         chainId: initialChain.chainId,
-        getIdentityToken: this.coreOptions.initialAuthenticationMode === constants.CONNECTOR_INITIAL_AUTHENTICATION_MODE.CONNECT_AND_SIGN
+        getAuthTokenInfo: this.coreOptions.initialAuthenticationMode === constants.CONNECTOR_INITIAL_AUTHENTICATION_MODE.CONNECT_AND_SIGN
       });
     } catch (e) {
       loglevel.log.error(e, connector.name);
@@ -643,7 +669,9 @@ class Web3AuthNoModal extends auth.SafeEventEmitter {
     if (utils.isBrowser() && chainNamespaces.has(baseControllers.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.metaMaskConnector(modalMode ? {
-        headless: true
+        ui: {
+          headless: true
+        }
       } : undefined));
     }
     if (isMipdEnabled && utils.isBrowser()) {
@@ -721,79 +749,101 @@ class Web3AuthNoModal extends auth.SafeEventEmitter {
   }
   subscribeToConnectorEvents(connector) {
     connector.on(constants.CONNECTOR_EVENTS.CONNECTED, async data => {
-      var _this$currentChain3, _accountAbstractionCo;
       if (!this.commonJRPCProvider) throw index.WalletInitializationError.notFound(`CommonJrpcProvider not found`);
       const {
-        provider,
-        identityTokenInfo
+        ethereumProvider,
+        solanaWallet
       } = data;
-      if (identityTokenInfo) {
-        this.setState({
-          idToken: identityTokenInfo.idToken
-        });
-      }
+      const isSolanaOnly = connector.connectorNamespace === baseControllers.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 index.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) {
           loglevel.log.error(error);
+          this.currentConnection = null;
           this.status = constants.CONNECTOR_STATUS.ERRORED;
           this.emit(constants.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) === baseControllers.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 === index$1.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 Promise.resolve().then(function () { return require('./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 === index$1.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 === index$1.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 !== index$1.WALLET_CONNECTORS.AUTH && this.coreOptions.useAAWithExternalWallet) {
-          finalProvider = this.aaProvider;
+          accountAbstractionConfig
+        } = this.coreOptions;
+        const is7702 = (accountAbstractionConfig === null || accountAbstractionConfig === void 0 ? void 0 : accountAbstractionConfig.smartAccountEipStandard) === ethereumControllers.SMART_ACCOUNT_EIP_STANDARD["EIP_7702"];
+        const isAaSupportedForCurrentChain = ((_this$currentChain4 = this.currentChain) === null || _this$currentChain4 === void 0 ? void 0 : _this$currentChain4.chainNamespace) === baseControllers.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 === index$1.WALLET_CONNECTORS.AUTH || this.coreOptions.useAAWithExternalWallet)) {
+          var _accountAbstractionCo2;
+          const {
+            accountAbstractionProvider,
+            toEoaProvider
+          } = await Promise.resolve().then(function () { return require('./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 === index$1.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 === index$1.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.connectorName !== index$1.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 = constants.CONNECTOR_STATUS.CONNECTED;
-      loglevel.log.debug("connected", this.status, this.connectedConnectorName);
-      this.connectToPlugins(_objectSpread(_objectSpread({}, data), {}, {
-        connector: data.connector
-      }));
-      this.emit(constants.CONNECTOR_EVENTS.CONNECTED, _objectSpread(_objectSpread({}, data), {}, {
-        loginMode: this.loginMode
-      }));
+      this.cacheWallet(data.connectorName);
+      const isConnectAndSign = this.coreOptions.initialAuthenticationMode === constants.CONNECTOR_INITIAL_AUTHENTICATION_MODE.CONNECT_AND_SIGN;
+      if (this.consentRequired && !isConnectAndSign && !this.state.hasUserConsent) {
+        this.status = constants.CONNECTOR_STATUS.CONSENT_REQUIRING;
+        this.emit(constants.CONNECTOR_EVENTS.CONSENT_REQUIRING);
+        loglevel.log.debug("consent_requiring", this.status, this.connectedConnectorName);
+      } else {
+        this.status = constants.CONNECTOR_STATUS.CONNECTED;
+        loglevel.log.debug("connected", this.status, this.connectedConnectorName);
+        this.connectToPlugins(_objectSpread(_objectSpread({}, data), {}, {
+          connector: data.connectorName
+        }));
+        this.emit(constants.CONNECTOR_EVENTS.CONNECTED, _objectSpread(_objectSpread({}, data), {}, {
+          loginMode: this.loginMode
+        }));
+      }
     });
     connector.on(constants.CONNECTOR_EVENTS.DISCONNECTED, async () => {
+      this.currentConnection = null;
+      this.currentConnectionReconnected = false;
       // re-setup commonJRPCProvider
       this.commonJRPCProvider.removeAllListeners();
       this.setupCommonJRPCProvider();
@@ -801,7 +851,7 @@ class Web3AuthNoModal extends auth.SafeEventEmitter {
       this.status = constants.CONNECTOR_STATUS.READY;
       const cachedConnector = this.state.cachedConnector;
       if (this.connectedConnectorName === cachedConnector) {
-        this.clearCache();
+        await this.clearCache();
       }
       loglevel.log.debug("disconnected", this.status, this.connectedConnectorName);
       await Promise.all(Object.values(this.plugins).map(async plugin => {
@@ -816,8 +866,9 @@ class Web3AuthNoModal extends auth.SafeEventEmitter {
           loglevel.log.error(error);
         });
       }));
-      this.setState({
-        connectedConnectorName: null
+      await this.setState({
+        connectedConnectorName: null,
+        hasUserConsent: undefined
       });
       this.emit(constants.CONNECTOR_EVENTS.DISCONNECTED);
     });
@@ -826,24 +877,24 @@ class Web3AuthNoModal extends auth.SafeEventEmitter {
       this.emit(constants.CONNECTOR_EVENTS.CONNECTING, data);
       loglevel.log.debug("connecting", this.status, this.connectedConnectorName);
     });
-    connector.on(constants.CONNECTOR_EVENTS.ERRORED, data => {
+    connector.on(constants.CONNECTOR_EVENTS.ERRORED, async data => {
       this.status = constants.CONNECTOR_STATUS.ERRORED;
-      this.clearCache();
+      await this.clearCache();
       this.emit(constants.CONNECTOR_EVENTS.ERRORED, data, this.loginMode);
       loglevel.log.debug("errored", this.status, this.connectedConnectorName);
     });
-    connector.on(constants.CONNECTOR_EVENTS.REHYDRATION_ERROR, error => {
+    connector.on(constants.CONNECTOR_EVENTS.REHYDRATION_ERROR, async error => {
       this.status = constants.CONNECTOR_STATUS.READY;
-      this.clearCache();
+      await this.clearCache();
       this.emit(constants.CONNECTOR_EVENTS.REHYDRATION_ERROR, error);
     });
     connector.on(constants.CONNECTOR_EVENTS.CONNECTOR_DATA_UPDATED, data => {
       loglevel.log.debug("connector data updated", data);
       this.emit(constants.CONNECTOR_EVENTS.CONNECTOR_DATA_UPDATED, data);
     });
-    connector.on(constants.CONNECTOR_EVENTS.CACHE_CLEAR, data => {
+    connector.on(constants.CONNECTOR_EVENTS.CACHE_CLEAR, async data => {
       loglevel.log.debug("connector cache clear", data);
-      this.clearCache();
+      await this.clearCache();
     });
     connector.on(constants.CONNECTOR_EVENTS.MFA_ENABLED, isMFAEnabled => {
       var _authConnector$authIn4;
@@ -863,22 +914,32 @@ class Web3AuthNoModal extends auth.SafeEventEmitter {
       this.emit(constants.CONNECTOR_EVENTS.AUTHORIZING, data);
       loglevel.log.debug("authorizing", this.status, this.connectedConnectorName);
     });
-    connector.on(constants.CONNECTOR_EVENTS.AUTHORIZED, data => {
-      this.status = constants.CONNECTOR_STATUS.AUTHORIZED;
-      this.setState({
-        idToken: data.identityTokenInfo.idToken
+    connector.on(constants.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(constants.CONNECTOR_EVENTS.AUTHORIZED, data);
-      loglevel.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 = constants.CONNECTOR_STATUS.CONSENT_REQUIRING;
+        this.emit(constants.CONNECTOR_EVENTS.CONSENT_REQUIRING);
+        loglevel.log.debug("consent_requiring", this.status, this.connectedConnectorName);
+      } else {
+        this.status = constants.CONNECTOR_STATUS.AUTHORIZED;
+        this.emit(constants.CONNECTOR_EVENTS.AUTHORIZED, data);
+        loglevel.log.debug("authorized", this.status, this.connectedConnectorName);
+      }
     });
   }
   checkInitRequirements() {
     if (this.status === constants.CONNECTOR_STATUS.READY) throw index.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 === IChainInterface.CONNECTOR_NAMESPACES.MULTICHAIN) autoConnect = true;else autoConnect = connector.connectorNamespace === this.currentChain.chainNamespace;
     }
     return autoConnect;
@@ -896,27 +957,56 @@ class Web3AuthNoModal extends auth.SafeEventEmitter {
     }
     return initialChain;
   }
-  cacheWallet(walletName) {
-    this.setState({
+  async completeConsentAcceptance() {
+    const connection = this.currentConnection;
+    if (!connection) {
+      throw index.WalletLoginError.connectionError("Cannot accept consent: no active connection");
+    }
+    if (this.status !== constants.CONNECTOR_STATUS.CONSENT_REQUIRING) {
+      throw index.WalletLoginError.connectionError("Cannot accept consent: not in consent_requiring state");
+    }
+    await this.setState({
+      hasUserConsent: true
+    });
+    const isConnectAndSign = this.coreOptions.initialAuthenticationMode === constants.CONNECTOR_INITIAL_AUTHENTICATION_MODE.CONNECT_AND_SIGN;
+    if (isConnectAndSign && this.state.idToken) {
+      this.status = constants.CONNECTOR_STATUS.AUTHORIZED;
+      loglevel.log.debug("consent accepted, authorized", this.status, this.connectedConnectorName);
+    } else {
+      this.status = constants.CONNECTOR_STATUS.CONNECTED;
+      loglevel.log.debug("consent accepted, connected", this.status, this.connectedConnectorName);
+    }
+    // connect to wallet-service plugin
+    if (this.connectedConnectorName === index$1.WALLET_CONNECTORS.AUTH) {
+      this.connectToPlugins({
+        connector: this.connectedConnectorName
+      });
+    }
+    this.emit(constants.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 index.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 !== IPlugin.PLUGIN_NAMESPACES.MULTICHAIN && plugin.pluginNamespace !== ((_this$currentChain6 = this.currentChain) === null || _this$currentChain6 === void 0 ? void 0 : _this$currentChain6.chainNamespace)) return;
+        if (plugin.pluginNamespace !== IPlugin.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 === IPlugin.PLUGIN_STATUS.CONNECTED) return;
         await plugin.initWithWeb3Auth(this, this.coreOptions.uiConfig, this.analytics);
@@ -930,27 +1020,27 @@ class Web3AuthNoModal extends auth.SafeEventEmitter {
       }
     });
   }
-  setState(newState) {
+  async setState(newState) {
     this.state = _objectSpread(_objectSpread({}, this.state), newState);
-    this.storage.setItem(constants$1.WEB3AUTH_STATE_STORAGE_KEY, JSON.stringify(this.state));
+    await this.storage.set(constants$1.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(constants$1.WEB3AUTH_STATE_STORAGE_KEY);
+    const state = await this.storage.get(constants$1.WEB3AUTH_STATE_STORAGE_KEY);
     if (!state) return;
     this.state = deserialize.deserialize(state);
   }
   getStorageMethod() {
-    if (this.coreOptions.ssr || this.coreOptions.storageType === "cookies") return cookie.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 auth.CookieStorage({
+      maxAge: this.coreOptions.sessionTime
     });
-    if (this.coreOptions.storageType === "session" && utils$1.storageAvailable("sessionStorage")) return window.sessionStorage;
-    if (this.coreOptions.storageType === "local" && utils$1.storageAvailable("localStorage")) return window.localStorage;
-    // If no storage is available, use a memory store.
-    return new auth.MemoryStore();
+    if (utils$1.storageAvailable("localStorage")) return new auth.LocalStorageAdapter();
+    return new auth.MemoryStorage();
   }
 }