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

package/dist/lib.cjs/noModal.js

@@ -5,43 +5,53 @@ var _objectSpread = require('@babel/runtime/helpers/objectSpread2');
 var _defineProperty = require('@babel/runtime/helpers/defineProperty');
 var auth = require('@web3auth/auth');
 var deepmerge = require('deepmerge');
-var authConnector = require('./connectors/auth-connector/authConnector.js');
 var IChainInterface = require('./base/chain/IChainInterface.js');
 var index = require('./base/errors/index.js');
 var index$1 = require('./base/wallet/index.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');
 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');
 var baseControllers = require('@toruslabs/base-controllers');
 require('./providers/base-provider/utils.js');
 var CommonJRPCProvider = require('./providers/base-provider/CommonJRPCProvider.js');
 require('./providers/base-provider/commonPrivateKeyProvider.js');
-var metamaskConnector = require('./connectors/metamask-connector/metamaskConnector.js');
 
 const _excluded = ["walletScope"];
-const CONNECTOR_CACHE_KEY = "Web3Auth-cachedConnector";
-const CURRENT_CHAIN_CACHE_KEY = "Web3Auth-currentChain";
 class Web3AuthNoModal extends auth.SafeEventEmitter {
-  constructor(options) {
+  constructor(options, initialState) {
     super();
     _defineProperty(this, "coreOptions", void 0);
-    _defineProperty(this, "connectedConnectorName", null);
     _defineProperty(this, "status", constants.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", 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 === "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 = constants.CONNECTOR_STATUS.CONNECTED;
+    }
   }
   get currentChain() {
     var _this$coreOptions$cha;
@@ -56,14 +66,29 @@ class Web3AuthNoModal extends auth.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 {
@@ -75,30 +100,37 @@ class Web3AuthNoModal extends auth.SafeEventEmitter {
         authBuildEnv: this.coreOptions.authBuildEnv
       });
     } catch (e) {
-      loglevel.log.error("Failed to fetch project configurations", e);
-      throw index.WalletInitializationError.notReady("failed to fetch project configurations", e);
+      const error = await auth.serializeError(e);
+      loglevel.log.error("Failed to fetch project configurations", error);
+      throw index.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 utils.withAbort(() => this.setupCommonJRPCProvider(), signal);
     // initialize connectors
     this.on(constants.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 utils.withAbort(() => Promise.all(newConnectors.map(this.setupConnector.bind(this))), signal, onAbortHandler);
       // emit connector ready event
       if (this.status === constants.CONNECTOR_STATUS.NOT_READY) {
         this.status = constants.CONNECTOR_STATUS.READY;
         this.emit(constants.CONNECTOR_EVENTS.READY);
       }
     });
-    await this.loadConnectors({
+    await utils.withAbort(() => this.loadConnectors({
       projectConfig
-    });
-    await this.initPlugins();
+    }), signal);
+    await utils.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) {
@@ -112,10 +144,17 @@ class Web3AuthNoModal extends auth.SafeEventEmitter {
     }) || null;
   }
   clearCache() {
-    if (!utils$1.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;
@@ -138,11 +177,12 @@ class Web3AuthNoModal extends auth.SafeEventEmitter {
    * 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 index.WalletInitializationError.notFound(`Please add wallet connector for ${connectorName} wallet, before connecting`);
     return new Promise((resolve, reject) => {
-      this.once(constants.CONNECTOR_EVENTS.CONNECTED, _ => {
+      this.once(constants.CONNECTOR_EVENTS.CONNECTED, async _ => {
         resolve(this.provider);
       });
       this.once(constants.CONNECTOR_EVENTS.ERRORED, err => {
@@ -222,6 +262,10 @@ class Web3AuthNoModal extends auth.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) {
+        loglevel.log.error("Please configure chains for smart accounts on dashboard at https://dashboard.web3auth.io");
+        throw index.WalletInitializationError.invalidParams("Please configure chains for smart accounts on dashboard at https://dashboard.web3auth.io");
+      }
       for (const chain of this.coreOptions.accountAbstractionConfig.chains) {
         if (!utils.isHexStrict(chain.chainId)) {
           loglevel.log.error(`Please provide a valid chainId in accountAbstractionConfig.chains for chain ${chain.chainId}`);
@@ -254,27 +298,38 @@ class Web3AuthNoModal extends auth.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 === constants$1.SMART_ACCOUNT_WALLET_SCOPE.ALL;
     }
   }
   initCachedConnectorAndChainId() {
-    this.cachedConnector = utils$1.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 = utils$1.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 && !utils.isHexStrict(this.coreOptions.defaultChainId)) throw index.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.CommonJRPCProvider.getProviderInstance({
@@ -297,7 +352,8 @@ class Web3AuthNoModal extends auth.SafeEventEmitter {
     }
   }
   async loadConnectors({
-    projectConfig
+    projectConfig,
+    modalMode
   }) {
     var _this$coreOptions$mul;
     // always add auth connector
@@ -310,7 +366,7 @@ class Web3AuthNoModal extends auth.SafeEventEmitter {
     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 && utils.isBrowser()) {
       // Solana chains
       if (chainNamespaces.has(baseControllers.CHAIN_NAMESPACES.SOLANA)) {
         const {
@@ -342,9 +398,14 @@ class Web3AuthNoModal extends auth.SafeEventEmitter {
       }
     }
     // it's safe to add it here as if there is a MetaMask injected provider, this won't override it
-    connectorFns.push(metamaskConnector.metaMaskConnector());
+    // only set headless to true if modal SDK is used, otherwise just use the modal from native Metamask SDK
+    if (utils.isBrowser() && (chainNamespaces.has(baseControllers.CHAIN_NAMESPACES.EIP155) || chainNamespaces.has(baseControllers.CHAIN_NAMESPACES.SOLANA))) {
+      connectorFns.push(metamaskConnector.metaMaskConnector(modalMode ? {
+        headless: true
+      } : undefined));
+    }
     // add WalletConnectV2 connector if external wallets are enabled
-    if (isExternalWalletEnabled && (chainNamespaces.has(baseControllers.CHAIN_NAMESPACES.SOLANA) || chainNamespaces.has(baseControllers.CHAIN_NAMESPACES.EIP155))) {
+    if (utils.isBrowser() && isExternalWalletEnabled && (chainNamespaces.has(baseControllers.CHAIN_NAMESPACES.SOLANA) || chainNamespaces.has(baseControllers.CHAIN_NAMESPACES.EIP155))) {
       const {
         walletConnectV2Connector
       } = await Promise.resolve().then(function () { return require('./connectors/wallet-connect-v2-connector/index.js'); });
@@ -354,7 +415,15 @@ class Web3AuthNoModal extends auth.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 === baseControllers.CHAIN_NAMESPACES.EIP155 || x.chainNamespace === baseControllers.CHAIN_NAMESPACES.SOLANA);
+    if (isWsSupportedChain) {
+      pluginFns.push(plugin.walletServicesPlugin());
+    }
     for (const pluginFn of pluginFns) {
       const plugin = pluginFn();
       if (!this.plugins[plugin.name]) this.plugins[plugin.name] = plugin;
@@ -384,50 +453,77 @@ class Web3AuthNoModal extends auth.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 index.WalletLoginError.connectionError("No idToken found");
+          this.setState({
+            idToken: data.idToken
+          });
+        } catch (error) {
+          loglevel.log.error(error);
+          this.status = constants.CONNECTOR_STATUS.ERRORED;
+          this.emit(constants.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) === baseControllers.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) === 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);
       }));
-      const isExternalWalletAndAAEnabled = data.connector !== index$1.WALLET_CONNECTORS.AUTH && this.coreOptions.useAAWithExternalWallet;
-      if (isExternalWalletAndAAEnabled && doesAASupportCurrentChain) {
+      if (isAaSupportedForCurrentChain && (data.connector === index$1.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 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,
+          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 !== index$1.WALLET_CONNECTORS.AUTH && this.coreOptions.useAAWithExternalWallet) {
+          finalProvider = this.aaProvider;
+        }
       }
       this.commonJRPCProvider.updateProviderEngineProxy(finalProvider);
-      this.connectedConnectorName = data.connector;
-      this.status = constants.CONNECTOR_STATUS.CONNECTED;
+      this.setState({
+        connectedConnectorName: data.connector
+      });
       this.cacheWallet(data.connector);
+      this.status = constants.CONNECTOR_STATUS.CONNECTED;
       loglevel.log.debug("connected", this.status, this.connectedConnectorName);
       this.connectToPlugins(data);
-      this.emit(constants.CONNECTOR_EVENTS.CONNECTED, _objectSpread({}, data));
+      this.emit(constants.CONNECTOR_EVENTS.CONNECTED, _objectSpread(_objectSpread({}, data), {}, {
+        loginMode: this.loginMode
+      }));
     });
     connector.on(constants.CONNECTOR_EVENTS.DISCONNECTED, async () => {
+      // re-setup commonJRPCProvider
+      this.commonJRPCProvider.removeAllListeners();
+      this.setupCommonJRPCProvider();
       // get back to ready state for rehydrating.
       this.status = constants.CONNECTOR_STATUS.READY;
-      if (utils$1.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();
       }
       loglevel.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 !== IPlugin.PLUGIN_STATUS.CONNECTED) return;
         return plugin.disconnect().catch(error => {
           // swallow error if connector doesn't supports this plugin.
@@ -438,7 +534,9 @@ class Web3AuthNoModal extends auth.SafeEventEmitter {
           loglevel.log.error(error);
         });
       }));
-      this.connectedConnectorName = null;
+      this.setState({
+        connectedConnectorName: null
+      });
       this.emit(constants.CONNECTOR_EVENTS.DISCONNECTED);
     });
     connector.on(constants.CONNECTOR_EVENTS.CONNECTING, data => {
@@ -452,20 +550,25 @@ class Web3AuthNoModal extends auth.SafeEventEmitter {
       this.emit(constants.CONNECTOR_EVENTS.ERRORED, data);
       loglevel.log.debug("errored", this.status, this.connectedConnectorName);
     });
+    connector.on(constants.CONNECTOR_EVENTS.REHYDRATION_ERROR, error => {
+      this.status = constants.CONNECTOR_STATUS.READY;
+      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 => {
       loglevel.log.debug("connector cache clear", data);
-      if (utils$1.storageAvailable(this.storage)) {
-        this.clearCache();
-      }
+      this.clearCache();
+    });
+    connector.on(constants.CONNECTOR_EVENTS.MFA_ENABLED, isMFAEnabled => {
+      loglevel.log.debug("mfa enabled", isMFAEnabled);
+      this.emit(constants.CONNECTOR_EVENTS.MFA_ENABLED, isMFAEnabled);
     });
   }
   checkInitRequirements() {
-    if (this.status === constants.CONNECTOR_STATUS.CONNECTING) throw index.WalletInitializationError.notReady("Already pending connection");
-    if (this.status === constants.CONNECTOR_STATUS.CONNECTED) throw index.WalletInitializationError.notReady("Already connected");
     if (this.status === constants.CONNECTOR_STATUS.READY) throw index.WalletInitializationError.notReady("Connector is already initialized");
   }
   /**
@@ -482,28 +585,24 @@ class Web3AuthNoModal extends auth.SafeEventEmitter {
     return initialChain;
   }
   cacheWallet(walletName) {
-    if (!utils$1.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 index.WalletInitializationError.invalidParams(`Invalid chainId: ${chainId}`);
-    this.currentChainId = chainId;
-    this.cacheCurrentChain(chainId);
-  }
-  cacheCurrentChain(chainId) {
-    if (!utils$1.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 !== IPlugin.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
@@ -519,6 +618,28 @@ class Web3AuthNoModal extends auth.SafeEventEmitter {
       }
     });
   }
+  setState(newState) {
+    this.state = _objectSpread(_objectSpread({}, this.state), newState);
+    this.storage.setItem(constants$1.WEB3AUTH_STATE_STORAGE_KEY, JSON.stringify(this.state));
+  }
+  loadState(initialState) {
+    if (initialState) {
+      this.state = initialState;
+      return;
+    }
+    const state = this.storage.getItem(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
+    });
+    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();
+  }
 }
 
 exports.Web3AuthNoModal = Web3AuthNoModal;

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

@@ -4,7 +4,7 @@ var _defineProperty = require('@babel/runtime/helpers/defineProperty');
 var auth = require('@web3auth/auth');
 require('@toruslabs/base-controllers');
 require('../../base/errors/index.js');
-require('../../base/wallet/index.js');
+var index = require('../../base/wallet/index.js');
 var constants = require('../../base/connector/constants.js');
 require('jwt-decode');
 require('../../base/loglevel.js');
@@ -19,7 +19,7 @@ class NFTCheckoutPlugin extends auth.SafeEventEmitter {
     super();
     _defineProperty(this, "name", IPlugin.EVM_PLUGINS.NFT_CHECKOUT);
     _defineProperty(this, "status", IPlugin.PLUGIN_STATUS.DISCONNECTED);
-    _defineProperty(this, "SUPPORTED_CONNECTORS", ["all"]);
+    _defineProperty(this, "SUPPORTED_CONNECTORS", Object.values(index.WALLET_CONNECTORS));
     _defineProperty(this, "pluginNamespace", IPlugin.PLUGIN_NAMESPACES.EIP155);
     _defineProperty(this, "web3auth", null);
     _defineProperty(this, "nftCheckoutEmbedInstance", null);

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

@@ -20,7 +20,7 @@ class WalletServicesPlugin extends auth.SafeEventEmitter {
     super(...args);
     _defineProperty(this, "name", IPlugin.EVM_PLUGINS.WALLET_SERVICES);
     _defineProperty(this, "status", IPlugin.PLUGIN_STATUS.DISCONNECTED);
-    _defineProperty(this, "SUPPORTED_CONNECTORS", [index.WALLET_CONNECTORS.AUTH, index.WALLET_CONNECTORS.SFA]);
+    _defineProperty(this, "SUPPORTED_CONNECTORS", [index.WALLET_CONNECTORS.AUTH]);
     _defineProperty(this, "pluginNamespace", IPlugin.PLUGIN_NAMESPACES.MULTICHAIN);
     _defineProperty(this, "wsEmbedInstance", void 0);
     _defineProperty(this, "provider", null);

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

@@ -6,6 +6,7 @@ var ethereumControllers = require('@toruslabs/ethereum-controllers');
 
 
 exports.accountAbstractionProvider = AccountAbstractionProvider.accountAbstractionProvider;
+exports.toEoaProvider = AccountAbstractionProvider.toEoaProvider;
 Object.defineProperty(exports, "BiconomySmartAccount", {
 	enumerable: true,
 	get: function () { return ethereumControllers.BiconomySmartAccount; }
@@ -14,6 +15,10 @@ Object.defineProperty(exports, "KernelSmartAccount", {
 	enumerable: true,
 	get: function () { return ethereumControllers.KernelSmartAccount; }
 });
+Object.defineProperty(exports, "MetamaskSmartAccount", {
+	enumerable: true,
+	get: function () { return ethereumControllers.MetamaskSmartAccount; }
+});
 Object.defineProperty(exports, "NexusSmartAccount", {
 	enumerable: true,
 	get: function () { return ethereumControllers.NexusSmartAccount; }

package/dist/lib.cjs/providers/account-abstraction-provider/providers/AccountAbstractionProvider.js

@@ -107,8 +107,16 @@ class AccountAbstractionProvider extends baseProvider.BaseProvider {
       chain,
       transport: viem.http(currentChain.rpcTarget)
     });
+    const [eoaAddress] = await eoaProvider.request({
+      method: ethereumControllers.METHOD_TYPES.ETH_REQUEST_ACCOUNTS
+    });
+    const walletClient = viem.createWalletClient({
+      account: eoaAddress,
+      chain,
+      transport: viem.custom(eoaProvider)
+    });
     this._smartAccount = await this.config.smartAccountInit.getSmartAccount({
-      owner: eoaProvider,
+      walletClient,
       client: this._publicClient
     });
     // setup bundler and paymaster
@@ -137,7 +145,7 @@ class AccountAbstractionProvider extends baseProvider.BaseProvider {
       handlers: providerHandlers
     });
     engine.push(aaMiddleware);
-    const eoaMiddleware = ethRpcMiddlewares.eoaProviderAsMiddleware(eoaProvider);
+    const eoaMiddleware = ethRpcMiddlewares.providerAsMiddleware(eoaProvider);
     engine.push(eoaMiddleware);
     const provider = auth.providerFromEngine(engine);
     this.updateProviderEngineProxy(provider);
@@ -228,6 +236,14 @@ const accountAbstractionProvider = async ({
         smartAccountInit = new TrustSmartAccount(smartAccountConfig);
         break;
       }
+    case ethereumControllers.SMART_ACCOUNT.METAMASK:
+      {
+        const {
+          MetamaskSmartAccount
+        } = await import('@toruslabs/ethereum-controllers');
+        smartAccountInit = new MetamaskSmartAccount(smartAccountConfig);
+        break;
+      }
     default:
       throw new Error("Smart account type not supported");
   }
@@ -239,9 +255,20 @@ const accountAbstractionProvider = async ({
     smartAccountChainsConfig
   });
 };
+const toEoaProvider = async aaProvider => {
+  // derive EOA provider from AA provider
+  const engine = new auth.JRPCEngine();
+  const eoaMiddleware = await ethRpcMiddlewares.createEoaMiddleware({
+    aaProvider
+  });
+  engine.push(eoaMiddleware);
+  engine.push(ethRpcMiddlewares.providerAsMiddleware(aaProvider));
+  return auth.providerFromEngine(engine);
+};
 
 Object.defineProperty(exports, "SMART_ACCOUNT", {
     enumerable: true,
     get: function () { return ethereumControllers.SMART_ACCOUNT; }
 });
 exports.accountAbstractionProvider = accountAbstractionProvider;
+exports.toEoaProvider = toEoaProvider;

package/dist/lib.cjs/providers/account-abstraction-provider/rpc/ethRpcMiddlewares.js

@@ -1,6 +1,7 @@
 'use strict';
 
 var _objectSpread = require('@babel/runtime/helpers/objectSpread2');
+var ethereumControllers = require('@toruslabs/ethereum-controllers');
 var auth = require('@web3auth/auth');
 
 async function createAaMiddleware({
@@ -8,7 +9,7 @@ async function createAaMiddleware({
   handlers
 }) {
   const [eoaAddress] = await eoaProvider.request({
-    method: "eth_accounts"
+    method: ethereumControllers.METHOD_TYPES.GET_ACCOUNTS
   });
   /**
    * Validates the keyholder address, and returns a normalized (i.e. lowercase)
@@ -155,7 +156,27 @@ async function createAaMiddleware({
     personal_sign: auth.createAsyncMiddleware(personalSign)
   });
 }
-function eoaProviderAsMiddleware(provider) {
+async function createEoaMiddleware({
+  aaProvider
+}) {
+  async function getAccounts(_req, res) {
+    const [, eoaAddress] = await aaProvider.request({
+      method: ethereumControllers.METHOD_TYPES.GET_ACCOUNTS
+    });
+    res.result = [eoaAddress];
+  }
+  async function requestAccounts(_req, res) {
+    const [, eoaAddress] = await aaProvider.request({
+      method: ethereumControllers.METHOD_TYPES.ETH_REQUEST_ACCOUNTS
+    });
+    res.result = [eoaAddress];
+  }
+  return auth.createScaffoldMiddleware({
+    eth_accounts: auth.createAsyncMiddleware(getAccounts),
+    eth_requestAccounts: auth.createAsyncMiddleware(requestAccounts)
+  });
+}
+function providerAsMiddleware(provider) {
   return async (req, res, _next, end) => {
     // send request to provider
     try {
@@ -169,4 +190,5 @@ function eoaProviderAsMiddleware(provider) {
 }
 
 exports.createAaMiddleware = createAaMiddleware;
-exports.eoaProviderAsMiddleware = eoaProviderAsMiddleware;
+exports.createEoaMiddleware = createEoaMiddleware;
+exports.providerAsMiddleware = providerAsMiddleware;

package/dist/lib.cjs/providers/base-provider/baseProvider.js

@@ -106,6 +106,8 @@ class BaseProvider extends baseControllers.BaseController {
       // we want events to propagate from Ethereum provider -> wrapper provider (e.g. CommonJRPC provider) -> SDK -> dapp
       // ensure that only one handler is added for each event
       const reEmitHandler = event => {
+        // skip newListener event
+        if (event === "newListener") return;
         // listen to the event from the Ethereum provider
         provider.on(event, (...args) => {
           // handle chainChanged event: update chainId state