@web3auth/no-modal 10.0.0-beta.1 → 10.0.0-beta.10

package/dist/lib.esm/noModal.js

@@ -1,45 +1,52 @@
 import _objectWithoutProperties from '@babel/runtime/helpers/objectWithoutProperties';
 import _objectSpread from '@babel/runtime/helpers/objectSpread2';
 import _defineProperty from '@babel/runtime/helpers/defineProperty';
-import { SafeEventEmitter } from '@web3auth/auth';
+import { SafeEventEmitter, serializeError, MemoryStore } 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 { fetchProjectConfig, withAbort, isHexStrict, isBrowser } from './base/utils.js';
+import { CommonJRPCProvider } from './providers/base-provider/CommonJRPCProvider.js';
 import { authConnector } from './connectors/auth-connector/authConnector.js';
-import { CONNECTOR_NAMESPACES } from './base/chain/IChainInterface.js';
-import { WalletInitializationError, WalletLoginError } from './base/errors/index.js';
-import { WALLET_CONNECTORS } from './base/wallet/index.js';
-import { CONNECTOR_STATUS, CONNECTOR_EVENTS } from './base/connector/constants.js';
+import { metaMaskConnector } from './connectors/metamask-connector/metamaskConnector.js';
+import { walletServicesPlugin } from './plugins/wallet-services-plugin/plugin.js';
 import { storageAvailable } from './base/connector/utils.js';
-import { SMART_ACCOUNT_WALLET_SCOPE } from './base/constants.js';
+import { CONNECTOR_STATUS, CONNECTOR_EVENTS } from './base/connector/constants.js';
+import { WalletInitializationError, WalletLoginError } from './base/errors/index.js';
 import { log } from './base/loglevel.js';
-import './base/plugin/errors.js';
-import { PLUGIN_STATUS, PLUGIN_NAMESPACES } from './base/plugin/IPlugin.js';
-import { fetchProjectConfig, isHexStrict } from './base/utils.js';
+import { CONNECTOR_NAMESPACES } from './base/chain/IChainInterface.js';
+import { WALLET_CONNECTORS } from './base/wallet/index.js';
 import { CHAIN_NAMESPACES } from '@toruslabs/base-controllers';
-import './providers/base-provider/utils.js';
-import { CommonJRPCProvider } from './providers/base-provider/CommonJRPCProvider.js';
-import './providers/base-provider/commonPrivateKeyProvider.js';
-import { metaMaskConnector } from './connectors/metamask-connector/metamaskConnector.js';
+import { PLUGIN_STATUS, PLUGIN_NAMESPACES } from './base/plugin/IPlugin.js';
 
 const _excluded = ["walletScope"];
-const CONNECTOR_CACHE_KEY = "Web3Auth-cachedConnector";
-const CURRENT_CHAIN_CACHE_KEY = "Web3Auth-currentChain";
 class Web3AuthNoModal extends SafeEventEmitter {
-  constructor(options) {
+  constructor(options, initialState) {
     super();
     _defineProperty(this, "coreOptions", void 0);
-    _defineProperty(this, "connectedConnectorName", null);
     _defineProperty(this, "status", CONNECTOR_STATUS.NOT_READY);
-    _defineProperty(this, "cachedConnector", null);
-    _defineProperty(this, "currentChainId", void 0);
+    _defineProperty(this, "aaProvider", null);
     _defineProperty(this, "connectors", []);
     _defineProperty(this, "commonJRPCProvider", null);
     _defineProperty(this, "plugins", {});
-    _defineProperty(this, "storage", "localStorage");
+    _defineProperty(this, "storage", void 0);
+    _defineProperty(this, "state", {
+      connectedConnectorName: null,
+      cachedConnector: null,
+      currentChainId: null,
+      idToken: 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 === "session") this.storage = "sessionStorage";
+    if (!options.storageType) options.storageType = "local";
     this.coreOptions = options;
-    this.currentChainId = options.defaultChainId;
+    this.storage = this.getStorageMethod();
+    this.loadState(initialState);
+    if (this.state.idToken && this.coreOptions.ssr) {
+      this.status = CONNECTOR_STATUS.CONNECTED;
+    }
   }
   get currentChain() {
     var _this$coreOptions$cha;
@@ -54,14 +61,29 @@ class Web3AuthNoModal extends SafeEventEmitter {
     }
     return null;
   }
+  get connectedConnectorName() {
+    return this.state.connectedConnectorName;
+  }
+  get cachedConnector() {
+    return this.state.cachedConnector;
+  }
+  get currentChainId() {
+    return this.state.currentChainId || this.coreOptions.defaultChainId || this.coreOptions.chains[0].chainId;
+  }
   get connectedConnector() {
     var _this$currentChain;
     return this.getConnector(this.connectedConnectorName, (_this$currentChain = this.currentChain) === null || _this$currentChain === void 0 ? void 0 : _this$currentChain.chainNamespace);
   }
+  get accountAbstractionProvider() {
+    return this.aaProvider;
+  }
   set provider(_) {
     throw new Error("Not implemented");
   }
-  async init() {
+  async init(options) {
+    const {
+      signal
+    } = options || {};
     // get project config
     let projectConfig;
     try {
@@ -73,31 +95,43 @@ class Web3AuthNoModal extends SafeEventEmitter {
         authBuildEnv: this.coreOptions.authBuildEnv
       });
     } catch (e) {
-      log.error("Failed to fetch project configurations", e);
-      throw WalletInitializationError.notReady("failed to fetch project configurations", e);
+      const error = await serializeError(e);
+      log.error("Failed to fetch project configurations", error);
+      throw WalletInitializationError.notReady("failed to fetch project configurations", error);
     }
+
     // init config
     this.initAccountAbstractionConfig(projectConfig);
     this.initChainsConfig(projectConfig);
     this.initCachedConnectorAndChainId();
+
     // setup common JRPC provider
-    await this.setupCommonJRPCProvider();
+    await withAbort(() => this.setupCommonJRPCProvider(), signal);
+
     // initialize connectors
     this.on(CONNECTOR_EVENTS.CONNECTORS_UPDATED, async ({
       connectors: newConnectors
     }) => {
-      await Promise.all(newConnectors.map(this.setupConnector.bind(this)));
+      const onAbortHandler = () => {
+        var _this$connectors;
+        if (((_this$connectors = this.connectors) === null || _this$connectors === void 0 ? void 0 : _this$connectors.length) > 0) {
+          this.cleanup();
+        }
+      };
+      await withAbort(() => Promise.all(newConnectors.map(this.setupConnector.bind(this))), signal, onAbortHandler);
+
       // emit connector ready event
       if (this.status === CONNECTOR_STATUS.NOT_READY) {
         this.status = CONNECTOR_STATUS.READY;
         this.emit(CONNECTOR_EVENTS.READY);
       }
     });
-    await this.loadConnectors({
+    await withAbort(() => this.loadConnectors({
       projectConfig
-    });
-    await this.initPlugins();
+    }), signal);
+    await withAbort(() => this.initPlugins(), signal);
   }
+
   // we need to take into account the chainNamespace as for external connectors, same connector name can be used for multiple chain namespaces
   getConnector(connectorName, chainNamespace) {
     return this.connectors.find(connector => {
@@ -110,10 +144,17 @@ class Web3AuthNoModal extends SafeEventEmitter {
     }) || null;
   }
   clearCache() {
-    if (!storageAvailable(this.storage)) return;
-    window[this.storage].removeItem(CONNECTOR_CACHE_KEY);
-    window[this.storage].removeItem(CURRENT_CHAIN_CACHE_KEY);
-    this.cachedConnector = null;
+    this.setState({
+      connectedConnectorName: null,
+      cachedConnector: null,
+      currentChainId: null,
+      idToken: null
+    });
+  }
+  async cleanup() {
+    for (const connector of this.connectors) {
+      if (connector.cleanup) await connector.cleanup();
+    }
   }
   async switchChain(params) {
     var _this$currentChain2;
@@ -132,15 +173,17 @@ class Web3AuthNoModal extends SafeEventEmitter {
     }
     throw WalletInitializationError.notReady(`No wallet is ready`);
   }
+
   /**
    * Connect to a specific wallet connector
    * @param connectorName - Key of the wallet connector to use.
    */
-  async connectTo(connectorName, loginParams) {
+  async connectTo(connectorName, loginParams, loginMode) {
+    this.loginMode = loginMode || "no-modal";
     const connector = this.getConnector(connectorName, loginParams === null || loginParams === void 0 ? void 0 : loginParams.chainNamespace);
     if (!connector || !this.commonJRPCProvider) throw WalletInitializationError.notFound(`Please add wallet connector for ${connectorName} wallet, before connecting`);
     return new Promise((resolve, reject) => {
-      this.once(CONNECTOR_EVENTS.CONNECTED, _ => {
+      this.once(CONNECTOR_EVENTS.CONNECTED, async _ => {
         resolve(this.provider);
       });
       this.once(CONNECTOR_EVENTS.ERRORED, err => {
@@ -192,6 +235,7 @@ class Web3AuthNoModal extends SafeEventEmitter {
       if (!existingChain) chainMap.set(chain.chainId, chain);else chainMap.set(chain.chainId, _objectSpread(_objectSpread({}, existingChain), chain));
     }
     this.coreOptions.chains = Array.from(chainMap.values());
+
     // validate chains and namespaces
     if (this.coreOptions.chains.length === 0) {
       log.error("chain info not found. Please configure chains on dashboard at https://dashboard.web3auth.io");
@@ -217,9 +261,14 @@ class Web3AuthNoModal extends SafeEventEmitter {
         }
       }
     }
+
     // if AA is enabled, filter out chains that are not AA-supported
     if (this.coreOptions.accountAbstractionConfig) {
       // 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");
+        throw WalletInitializationError.invalidParams("Please configure chains for smart accounts on dashboard at https://dashboard.web3auth.io");
+      }
       for (const chain of this.coreOptions.accountAbstractionConfig.chains) {
         if (!isHexStrict(chain.chainId)) {
           log.error(`Please provide a valid chainId in accountAbstractionConfig.chains for chain ${chain.chainId}`);
@@ -252,33 +301,47 @@ class Web3AuthNoModal extends SafeEventEmitter {
     }
   }
   initAccountAbstractionConfig(projectConfig) {
+    var _this$coreOptions$acc2;
     const isAAEnabled = Boolean(this.coreOptions.accountAbstractionConfig || (projectConfig === null || projectConfig === void 0 ? void 0 : projectConfig.smartAccounts));
     if (!isAAEnabled) return;
-    // merge project config with core options, code config take precedence over project config
+
+    // 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
       } = _ref,
       configWithoutWalletScope = _objectWithoutProperties(_ref, _excluded);
-    this.coreOptions.accountAbstractionConfig = deepmerge(configWithoutWalletScope || {}, this.coreOptions.accountAbstractionConfig || {});
+    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) || [])];
+    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 || {})), {}, {
+      chains: Array.from(aaChainMap.values())
+    });
+
     // determine if we should use AA with external wallet
     if (this.coreOptions.useAAWithExternalWallet === undefined) {
       this.coreOptions.useAAWithExternalWallet = walletScope === SMART_ACCOUNT_WALLET_SCOPE.ALL;
     }
   }
   initCachedConnectorAndChainId() {
-    this.cachedConnector = storageAvailable(this.storage) ? window[this.storage].getItem(CONNECTOR_CACHE_KEY) : null;
     // init chainId using cached chainId if it exists and is valid, otherwise use the defaultChainId or the first chain
-    const cachedChainId = storageAvailable(this.storage) ? window[this.storage].getItem(CURRENT_CHAIN_CACHE_KEY) : null;
+    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");
-    this.currentChainId = isCachedChainIdValid ? cachedChainId : this.coreOptions.defaultChainId || this.coreOptions.chains[0].chainId;
+    const currentChainId = isCachedChainIdValid ? cachedChainId : this.coreOptions.defaultChainId || this.coreOptions.chains[0].chainId;
+    this.setState({
+      currentChainId
+    });
   }
   async setupCommonJRPCProvider() {
     this.commonJRPCProvider = await CommonJRPCProvider.getProviderInstance({
       chain: this.currentChain,
       chains: this.coreOptions.chains
     });
+
     // sync chainId
     this.commonJRPCProvider.on("chainChanged", chainId => this.setCurrentChain(chainId));
   }
@@ -295,7 +358,8 @@ class Web3AuthNoModal extends SafeEventEmitter {
     }
   }
   async loadConnectors({
-    projectConfig
+    projectConfig,
+    modalMode
   }) {
     var _this$coreOptions$mul;
     // always add auth connector
@@ -304,11 +368,12 @@ class Web3AuthNoModal extends SafeEventEmitter {
       projectConfig,
       coreOptions: this.coreOptions
     };
+
     // add injected connectors
     const isExternalWalletEnabled = Boolean(projectConfig.externalWalletAuth);
     const isMipdEnabled = isExternalWalletEnabled && ((_this$coreOptions$mul = this.coreOptions.multiInjectedProviderDiscovery) !== null && _this$coreOptions$mul !== void 0 ? _this$coreOptions$mul : true);
     const chainNamespaces = new Set(this.coreOptions.chains.map(chain => chain.chainNamespace));
-    if (isMipdEnabled) {
+    if (isMipdEnabled && isBrowser()) {
       // Solana chains
       if (chainNamespaces.has(CHAIN_NAMESPACES.SOLANA)) {
         const {
@@ -339,10 +404,17 @@ class Web3AuthNoModal extends SafeEventEmitter {
         connectorFns.push(...evmMipd.getProviders().map(injectedEvmConnector));
       }
     }
+
     // it's safe to add it here as if there is a MetaMask injected provider, this won't override it
-    connectorFns.push(metaMaskConnector());
+    // only set headless to true if modal SDK is used, otherwise just use the modal from native Metamask SDK
+    if (isBrowser() && (chainNamespaces.has(CHAIN_NAMESPACES.EIP155) || chainNamespaces.has(CHAIN_NAMESPACES.SOLANA))) {
+      connectorFns.push(metaMaskConnector(modalMode ? {
+        headless: true
+      } : undefined));
+    }
+
     // add WalletConnectV2 connector if external wallets are enabled
-    if (isExternalWalletEnabled && (chainNamespaces.has(CHAIN_NAMESPACES.SOLANA) || chainNamespaces.has(CHAIN_NAMESPACES.EIP155))) {
+    if (isBrowser() && isExternalWalletEnabled && (chainNamespaces.has(CHAIN_NAMESPACES.SOLANA) || chainNamespaces.has(CHAIN_NAMESPACES.EIP155))) {
       const {
         walletConnectV2Connector
       } = await import('./connectors/wallet-connect-v2-connector/index.js');
@@ -352,7 +424,15 @@ class Web3AuthNoModal extends SafeEventEmitter {
     this.setConnectors(connectors);
   }
   async initPlugins() {
-    const pluginFns = this.coreOptions.plugins || [];
+    const {
+      chains,
+      plugins
+    } = this.coreOptions;
+    const pluginFns = plugins || [];
+    const isWsSupportedChain = chains.some(x => x.chainNamespace === CHAIN_NAMESPACES.EIP155 || x.chainNamespace === CHAIN_NAMESPACES.SOLANA);
+    if (isWsSupportedChain) {
+      pluginFns.push(walletServicesPlugin());
+    }
     for (const pluginFn of pluginFns) {
       const plugin = pluginFn();
       if (!this.plugins[plugin.name]) this.plugins[plugin.name] = plugin;
@@ -382,50 +462,81 @@ class Web3AuthNoModal extends SafeEventEmitter {
       const {
         provider
       } = data;
+
+      // when ssr is enabled, we need to get the idToken from the connector.
+      if (this.coreOptions.ssr) {
+        try {
+          const data = await connector.authenticateUser();
+          if (!data.idToken) throw WalletLoginError.connectionError("No idToken found");
+          this.setState({
+            idToken: data.idToken
+          });
+        } catch (error) {
+          log.error(error);
+          this.status = CONNECTOR_STATUS.ERRORED;
+          this.emit(CONNECTOR_EVENTS.ERRORED, error);
+          return;
+        }
+      }
       let finalProvider = provider.provider || provider;
-      // setup AA provider for external wallets on EVM chains, no need for app wallet as it uses WS provider which already supports AA
+
+      // setup AA provider if AA is enabled
       const {
         accountAbstractionConfig
       } = this.coreOptions;
-      const doesAASupportCurrentChain = ((_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 => {
+      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);
       }));
-      const isExternalWalletAndAAEnabled = data.connector !== WALLET_CONNECTORS.AUTH && this.coreOptions.useAAWithExternalWallet;
-      if (isExternalWalletAndAAEnabled && doesAASupportCurrentChain) {
+      if (isAaSupportedForCurrentChain && (data.connector === WALLET_CONNECTORS.AUTH || this.coreOptions.useAAWithExternalWallet)) {
         var _accountAbstractionCo2;
-        const aaChainIds = new Set((accountAbstractionConfig === null || accountAbstractionConfig === void 0 || (_accountAbstractionCo2 = accountAbstractionConfig.chains) === null || _accountAbstractionCo2 === void 0 ? void 0 : _accountAbstractionCo2.map(chain => chain.chainId)) || []);
         const {
-          accountAbstractionProvider
+          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,
+          provider: eoaProvider,
           chain: this.currentChain,
           chains: this.coreOptions.chains.filter(chain => aaChainIds.has(chain.chainId))
         });
-        finalProvider = aaProvider;
+        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;
+        }
       }
       this.commonJRPCProvider.updateProviderEngineProxy(finalProvider);
-      this.connectedConnectorName = data.connector;
-      this.status = CONNECTOR_STATUS.CONNECTED;
+      this.setState({
+        connectedConnectorName: data.connector
+      });
       this.cacheWallet(data.connector);
+      this.status = CONNECTOR_STATUS.CONNECTED;
       log.debug("connected", this.status, this.connectedConnectorName);
       this.connectToPlugins(data);
-      this.emit(CONNECTOR_EVENTS.CONNECTED, _objectSpread({}, data));
+      this.emit(CONNECTOR_EVENTS.CONNECTED, _objectSpread(_objectSpread({}, data), {}, {
+        loginMode: this.loginMode
+      }));
     });
     connector.on(CONNECTOR_EVENTS.DISCONNECTED, async () => {
+      // re-setup commonJRPCProvider
+      this.commonJRPCProvider.removeAllListeners();
+      this.setupCommonJRPCProvider();
+
       // get back to ready state for rehydrating.
       this.status = CONNECTOR_STATUS.READY;
-      if (storageAvailable(this.storage)) {
-        const cachedConnector = window[this.storage].getItem(CONNECTOR_CACHE_KEY);
-        if (this.connectedConnectorName === cachedConnector) {
-          this.clearCache();
-        }
+      const cachedConnector = this.state.cachedConnector;
+      if (this.connectedConnectorName === cachedConnector) {
+        this.clearCache();
       }
       log.debug("disconnected", this.status, this.connectedConnectorName);
       await Promise.all(Object.values(this.plugins).map(async plugin => {
-        if (!plugin.SUPPORTED_CONNECTORS.includes("all") && !plugin.SUPPORTED_CONNECTORS.includes(connector.name)) return;
+        if (!plugin.SUPPORTED_CONNECTORS.includes(connector.name)) return;
         if (plugin.status !== PLUGIN_STATUS.CONNECTED) return;
         return plugin.disconnect().catch(error => {
           // swallow error if connector doesn't supports this plugin.
@@ -436,7 +547,9 @@ class Web3AuthNoModal extends SafeEventEmitter {
           log.error(error);
         });
       }));
-      this.connectedConnectorName = null;
+      this.setState({
+        connectedConnectorName: null
+      });
       this.emit(CONNECTOR_EVENTS.DISCONNECTED);
     });
     connector.on(CONNECTOR_EVENTS.CONNECTING, data => {
@@ -450,22 +563,28 @@ class Web3AuthNoModal extends SafeEventEmitter {
       this.emit(CONNECTOR_EVENTS.ERRORED, data);
       log.debug("errored", this.status, this.connectedConnectorName);
     });
+    connector.on(CONNECTOR_EVENTS.REHYDRATION_ERROR, error => {
+      this.status = CONNECTOR_STATUS.READY;
+      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 => {
       log.debug("connector cache clear", data);
-      if (storageAvailable(this.storage)) {
-        this.clearCache();
-      }
+      this.clearCache();
+    });
+    connector.on(CONNECTOR_EVENTS.MFA_ENABLED, isMFAEnabled => {
+      log.debug("mfa enabled", isMFAEnabled);
+      this.emit(CONNECTOR_EVENTS.MFA_ENABLED, isMFAEnabled);
     });
   }
   checkInitRequirements() {
-    if (this.status === CONNECTOR_STATUS.CONNECTING) throw WalletInitializationError.notReady("Already pending connection");
-    if (this.status === CONNECTOR_STATUS.CONNECTED) throw WalletInitializationError.notReady("Already connected");
     if (this.status === CONNECTOR_STATUS.READY) throw WalletInitializationError.notReady("Connector is already initialized");
   }
+
   /**
    * Gets the initial chain configuration for a connector
    * @throws WalletInitializationError If no chain is found for the connector's namespace
@@ -480,28 +599,24 @@ class Web3AuthNoModal extends SafeEventEmitter {
     return initialChain;
   }
   cacheWallet(walletName) {
-    if (!storageAvailable(this.storage)) return;
-    // TODO: use the key from user + this
-    window[this.storage].setItem(CONNECTOR_CACHE_KEY, walletName);
-    this.cachedConnector = walletName;
+    this.setState({
+      cachedConnector: walletName
+    });
   }
   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.currentChainId = chainId;
-    this.cacheCurrentChain(chainId);
-  }
-  cacheCurrentChain(chainId) {
-    if (!storageAvailable(this.storage)) return;
-    window[this.storage].setItem(CURRENT_CHAIN_CACHE_KEY, chainId);
+    this.setState({
+      currentChainId: chainId
+    });
   }
   connectToPlugins(data) {
     Object.values(this.plugins).map(async plugin => {
       try {
         var _this$currentChain5;
         // skip if it's not compatible with the connector
-        if (!plugin.SUPPORTED_CONNECTORS.includes("all") && !plugin.SUPPORTED_CONNECTORS.includes(data.connector)) return;
+        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$currentChain5 = this.currentChain) === null || _this$currentChain5 === void 0 ? void 0 : _this$currentChain5.chainNamespace)) return;
         // skip if it's already connected
@@ -517,6 +632,28 @@ class Web3AuthNoModal extends SafeEventEmitter {
       }
     });
   }
+  setState(newState) {
+    this.state = _objectSpread(_objectSpread({}, this.state), newState);
+    this.storage.setItem(WEB3AUTH_STATE_STORAGE_KEY, JSON.stringify(this.state));
+  }
+  loadState(initialState) {
+    if (initialState) {
+      this.state = initialState;
+      return;
+    }
+    const state = this.storage.getItem(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
+    });
+    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();
+  }
 }
 
 export { Web3AuthNoModal };

package/dist/lib.esm/plugins/nft-checkout-plugin/embed.js

@@ -2,7 +2,7 @@ import _defineProperty from '@babel/runtime/helpers/defineProperty';
 import { randomId } from '@toruslabs/base-controllers';
 import { THEME_MODES } from '@web3auth/auth';
 import loglevel from 'loglevel';
-import { NFT_CHECKOUT_URLS, NFT_CHECKOUT_BUILD_ENV, NFT_CHECKOUT_EMBED_MESSAGE_TYPES } from './enums.js';
+import { NFT_CHECKOUT_BUILD_ENV, NFT_CHECKOUT_URLS, NFT_CHECKOUT_EMBED_MESSAGE_TYPES } from './enums.js';
 import { getTheme, htmlToElement } from './utils.js';
 
 // preload for iframe doesn't work https://bugs.chromium.org/p/chromium/issues/detail?id=593267
@@ -47,11 +47,13 @@ class NFTCheckoutEmbed {
       whiteLabel
     } = params || {};
     this.buildEnv = buildEnv;
+
     // construct nft checkout url
     const nftCheckoutIframeUrl = new URL(NFT_CHECKOUT_URLS[this.buildEnv]);
     const hashParams = new URLSearchParams();
     hashParams.append("origin", window.location.origin);
     nftCheckoutIframeUrl.hash = hashParams.toString();
+
     // create iframe
     const colorScheme = getTheme((whiteLabel === null || whiteLabel === void 0 ? void 0 : whiteLabel.mode) || THEME_MODES.light);
     const nftCheckoutIframe = htmlToElement(`<iframe
@@ -95,6 +97,7 @@ class NFTCheckoutEmbed {
     if (!this.isInitialized) throw new Error("Call init() first");
     const nftCheckoutIframe = this.getIframe();
     if (!nftCheckoutIframe) throw new Error("Iframe is not initialized");
+
     // send message to iframe
     const nftCheckoutOrigin = new URL(NFT_CHECKOUT_URLS[this.buildEnv]).origin;
     nftCheckoutIframe.contentWindow.postMessage({

package/dist/lib.esm/plugins/nft-checkout-plugin/plugin.js

@@ -1,23 +1,17 @@
 import _defineProperty from '@babel/runtime/helpers/defineProperty';
 import { SafeEventEmitter } from '@web3auth/auth';
-import '@toruslabs/base-controllers';
-import '../../base/errors/index.js';
-import '../../base/wallet/index.js';
-import { CONNECTOR_STATUS } from '../../base/connector/constants.js';
-import 'jwt-decode';
-import '../../base/loglevel.js';
+import { NFTCheckoutEmbed } from './embed.js';
 import { NFTCheckoutPluginError } from '../../base/plugin/errors.js';
 import { EVM_PLUGINS, PLUGIN_STATUS, PLUGIN_NAMESPACES, PLUGIN_EVENTS } from '../../base/plugin/IPlugin.js';
-import '@toruslabs/constants';
-import '@toruslabs/http-helpers';
-import { NFTCheckoutEmbed } from './embed.js';
+import { WALLET_CONNECTORS } from '../../base/wallet/index.js';
+import { CONNECTOR_STATUS } from '../../base/connector/constants.js';
 
 class NFTCheckoutPlugin extends SafeEventEmitter {
   constructor(params) {
     super();
     _defineProperty(this, "name", EVM_PLUGINS.NFT_CHECKOUT);
     _defineProperty(this, "status", PLUGIN_STATUS.DISCONNECTED);
-    _defineProperty(this, "SUPPORTED_CONNECTORS", ["all"]);
+    _defineProperty(this, "SUPPORTED_CONNECTORS", Object.values(WALLET_CONNECTORS));
     _defineProperty(this, "pluginNamespace", PLUGIN_NAMESPACES.EIP155);
     _defineProperty(this, "web3auth", null);
     _defineProperty(this, "nftCheckoutEmbedInstance", null);

package/dist/lib.esm/plugins/wallet-services-plugin/plugin.js

@@ -1,16 +1,12 @@
 import _defineProperty from '@babel/runtime/helpers/defineProperty';
 import { SafeEventEmitter } from '@web3auth/auth';
-import { CHAIN_NAMESPACES } from '@toruslabs/base-controllers';
-import '../../base/errors/index.js';
+export { BUTTON_POSITION, CONFIRMATION_STRATEGY } from '@web3auth/ws-embed';
+import { EVM_PLUGINS, PLUGIN_STATUS, PLUGIN_NAMESPACES, PLUGIN_EVENTS } from '../../base/plugin/IPlugin.js';
+import { WalletServicesPluginError } from '../../base/plugin/errors.js';
 import { WALLET_CONNECTORS } from '../../base/wallet/index.js';
+import { CHAIN_NAMESPACES } from '@toruslabs/base-controllers';
 import { CONNECTOR_STATUS } from '../../base/connector/constants.js';
-import 'jwt-decode';
 import { log } from '../../base/loglevel.js';
-import { WalletServicesPluginError } from '../../base/plugin/errors.js';
-import { EVM_PLUGINS, PLUGIN_STATUS, PLUGIN_NAMESPACES, PLUGIN_EVENTS } from '../../base/plugin/IPlugin.js';
-import '@toruslabs/constants';
-import '@toruslabs/http-helpers';
-export { BUTTON_POSITION, CONFIRMATION_STRATEGY } from '@web3auth/ws-embed';
 
 // TODO: support project config items here. incl. key export flag, multiple chains
 class WalletServicesPlugin extends SafeEventEmitter {
@@ -18,7 +14,7 @@ class WalletServicesPlugin extends SafeEventEmitter {
     super(...args);
     _defineProperty(this, "name", EVM_PLUGINS.WALLET_SERVICES);
     _defineProperty(this, "status", PLUGIN_STATUS.DISCONNECTED);
-    _defineProperty(this, "SUPPORTED_CONNECTORS", [WALLET_CONNECTORS.AUTH, WALLET_CONNECTORS.SFA]);
+    _defineProperty(this, "SUPPORTED_CONNECTORS", [WALLET_CONNECTORS.AUTH]);
     _defineProperty(this, "pluginNamespace", PLUGIN_NAMESPACES.MULTICHAIN);
     _defineProperty(this, "wsEmbedInstance", void 0);
     _defineProperty(this, "provider", null);
@@ -35,11 +31,13 @@ class WalletServicesPlugin extends SafeEventEmitter {
     if (web3auth.provider && !this.SUPPORTED_CONNECTORS.includes(web3auth.connectedConnectorName)) throw WalletServicesPluginError.notInitialized();
     const currentChainConfig = web3auth.currentChain;
     if (![CHAIN_NAMESPACES.EIP155, CHAIN_NAMESPACES.SOLANA].includes(currentChainConfig === null || currentChainConfig === void 0 ? void 0 : currentChainConfig.chainNamespace)) throw WalletServicesPluginError.unsupportedChainNamespace();
+
     // Not connected yet to auth
     if (web3auth.provider) {
       this.provider = web3auth.provider;
     }
     this.web3auth = web3auth;
+
     // Auth connector uses WS embed
     const authInstance = web3auth.getConnector(WALLET_CONNECTORS.AUTH);
     if (!authInstance || !authInstance.wsEmbed) throw WalletServicesPluginError.web3AuthNotConnected();

package/dist/lib.esm/providers/account-abstraction-provider/index.js

@@ -1,2 +1,2 @@
-export { accountAbstractionProvider } from './providers/AccountAbstractionProvider.js';
-export { BiconomySmartAccount, KernelSmartAccount, NexusSmartAccount, SMART_ACCOUNT, SafeSmartAccount, TrustSmartAccount } from '@toruslabs/ethereum-controllers';
+export { accountAbstractionProvider, toEoaProvider } from './providers/AccountAbstractionProvider.js';
+export { BiconomySmartAccount, KernelSmartAccount, MetamaskSmartAccount, NexusSmartAccount, SMART_ACCOUNT, SafeSmartAccount, TrustSmartAccount } from '@toruslabs/ethereum-controllers';