@web3auth/no-modal 10.0.0-beta.8 → 10.0.0

package/dist/lib.cjs/noModal.js

@@ -3,47 +3,58 @@
 var _objectWithoutProperties = require('@babel/runtime/helpers/objectWithoutProperties');
 var _objectSpread = require('@babel/runtime/helpers/objectSpread2');
 var _defineProperty = require('@babel/runtime/helpers/defineProperty');
+var baseControllers = require('@toruslabs/base-controllers');
 var auth = require('@web3auth/auth');
 var deepmerge = require('deepmerge');
+var analytics = require('./base/analytics.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');
 
 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, "aaProvider", null);
-    _defineProperty(this, "currentChainId", void 0);
     _defineProperty(this, "connectors", []);
     _defineProperty(this, "commonJRPCProvider", null);
+    _defineProperty(this, "analytics", void 0);
     _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.analytics = new analytics.Analytics();
+    this.loadState(initialState);
+    if (this.state.idToken && this.coreOptions.ssr) {
+      this.status = constants.CONNECTOR_STATUS.CONNECTED;
+    }
   }
   get currentChain() {
     var _this$coreOptions$cha;
@@ -58,6 +69,15 @@ 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);
@@ -69,51 +89,88 @@ class Web3AuthNoModal extends auth.SafeEventEmitter {
     throw new Error("Not implemented");
   }
   async init(options) {
-    const {
-      signal
-    } = options || {};
-    // get project config
-    let projectConfig;
+    // init analytics
+    const startTime = Date.now();
+    this.analytics.init();
+    this.analytics.identify(this.coreOptions.clientId, {
+      web3auth_client_id: this.coreOptions.clientId,
+      web3auth_network: this.coreOptions.web3AuthNetwork
+    });
+    this.analytics.setGlobalProperties({
+      dapp_url: window.location.origin,
+      sdk_name: analytics.ANALYTICS_SDK_TYPE.WEB_NO_MODAL,
+      sdk_version: utils.sdkVersion
+    });
+    let trackData = {};
     try {
-      var _this$coreOptions$acc;
-      projectConfig = await utils.fetchProjectConfig({
-        clientId: this.coreOptions.clientId,
-        web3AuthNetwork: this.coreOptions.web3AuthNetwork,
-        aaProvider: (_this$coreOptions$acc = this.coreOptions.accountAbstractionConfig) === null || _this$coreOptions$acc === void 0 ? void 0 : _this$coreOptions$acc.smartAccountType,
-        authBuildEnv: this.coreOptions.authBuildEnv
+      var _authConnector$authIn, _this$coreOptions$uiC;
+      const {
+        signal
+      } = options || {};
+      // get project config
+      let projectConfig;
+      try {
+        var _this$coreOptions$acc;
+        projectConfig = await utils.fetchProjectConfig({
+          clientId: this.coreOptions.clientId,
+          web3AuthNetwork: this.coreOptions.web3AuthNetwork,
+          aaProvider: (_this$coreOptions$acc = this.coreOptions.accountAbstractionConfig) === null || _this$coreOptions$acc === void 0 ? void 0 : _this$coreOptions$acc.smartAccountType,
+          authBuildEnv: this.coreOptions.authBuildEnv
+        });
+      } catch (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();
+      this.initUIConfig(projectConfig);
+      this.initWalletServicesConfig(projectConfig);
+      trackData = this.getInitializationTrackData();
+      // setup common JRPC provider
+      await utils.withAbort(() => this.setupCommonJRPCProvider(), signal);
+      // initialize connectors
+      this.on(constants.CONNECTOR_EVENTS.CONNECTORS_UPDATED, async ({
+        connectors: newConnectors
+      }) => {
+        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);
+        }
       });
-    } catch (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);
+      await utils.withAbort(() => this.loadConnectors({
+        projectConfig
+      }), signal);
+      await utils.withAbort(() => this.initPlugins(), signal);
+      // track completion event
+      const authConnector = this.getConnector(index$1.WALLET_CONNECTORS.AUTH);
+      trackData = _objectSpread(_objectSpread({}, trackData), {}, {
+        connectors: this.connectors.map(connector => connector.name),
+        plugins: Object.keys(this.plugins),
+        auth_ux_mode: (authConnector === null || authConnector === void 0 || (_authConnector$authIn = authConnector.authInstance) === null || _authConnector$authIn === void 0 || (_authConnector$authIn = _authConnector$authIn.options) === null || _authConnector$authIn === void 0 ? void 0 : _authConnector$authIn.uxMode) || ((_this$coreOptions$uiC = this.coreOptions.uiConfig) === null || _this$coreOptions$uiC === void 0 ? void 0 : _this$coreOptions$uiC.uxMode)
+      });
+      this.analytics.track(analytics.ANALYTICS_EVENTS.SDK_INITIALIZATION_COMPLETED, _objectSpread(_objectSpread({}, trackData), {}, {
+        duration: Date.now() - startTime
+      }));
+    } catch (error) {
+      if (error instanceof DOMException && error.name === "AbortError") return;
+      // track failure event
+      this.analytics.track(analytics.ANALYTICS_EVENTS.SDK_INITIALIZATION_FAILED, _objectSpread(_objectSpread(_objectSpread({}, trackData), utils.getErrorAnalyticsProperties(error)), {}, {
+        duration: Date.now() - startTime
+      }));
+      loglevel.log.error("Failed to initialize modal", error);
+      throw error;
     }
-    // init config
-    this.initAccountAbstractionConfig(projectConfig);
-    this.initChainsConfig(projectConfig);
-    this.initCachedConnectorAndChainId();
-    // setup common JRPC provider
-    await utils.withAbort(() => this.setupCommonJRPCProvider(), signal);
-    // initialize connectors
-    this.on(constants.CONNECTOR_EVENTS.CONNECTORS_UPDATED, async ({
-      connectors: newConnectors
-    }) => {
-      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 utils.withAbort(() => this.loadConnectors({
-      projectConfig
-    }), 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) {
@@ -127,10 +184,12 @@ 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) {
@@ -158,20 +217,62 @@ 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`);
+    const initialChain = this.getInitialChainIdForConnector(connector);
+    const finalLoginParams = _objectSpread(_objectSpread({}, loginParams), {}, {
+      chainId: initialChain.chainId
+    });
+    // track connection started event
+    const startTime = Date.now();
+    let eventData;
+    if (connectorName === index$1.WALLET_CONNECTORS.AUTH) {
+      var _connector$authInstan;
+      const authLoginParams = loginParams;
+      eventData = {
+        connector: connectorName,
+        connector_type: connector.type,
+        chain_id: utils.getCaipChainId(initialChain),
+        chain_namespace: initialChain.chainNamespace,
+        auth_connection: authLoginParams.authConnection,
+        auth_connection_id: authLoginParams.authConnectionId,
+        group_auth_connection_id: authLoginParams.groupedAuthConnectionId,
+        mfa_level: authLoginParams.mfaLevel,
+        wallet_key_enabled: authLoginParams.getWalletKey,
+        extra_login_options_enabled: Boolean(authLoginParams.extraLoginOptions),
+        dapp_share_enabled: Boolean(authLoginParams.dappShare),
+        curve: authLoginParams.curve,
+        auth_dapp_url: authLoginParams.dappUrl,
+        is_sfa: Boolean(authLoginParams.idToken),
+        auth_ux_mode: (_connector$authInstan = connector.authInstance) === null || _connector$authInstan === void 0 || (_connector$authInstan = _connector$authInstan.options) === null || _connector$authInstan === void 0 ? void 0 : _connector$authInstan.uxMode
+      };
+    } else {
+      eventData = {
+        connector: connectorName,
+        connector_type: connector.type,
+        is_injected: connector.isInjected,
+        chain_id: utils.getCaipChainId(initialChain),
+        chain_namespace: initialChain.chainNamespace
+      };
+    }
+    this.analytics.track(analytics.ANALYTICS_EVENTS.CONNECTION_STARTED, eventData);
     return new Promise((resolve, reject) => {
-      this.once(constants.CONNECTOR_EVENTS.CONNECTED, _ => {
+      this.once(constants.CONNECTOR_EVENTS.CONNECTED, async _ => {
+        // track connection completed event
+        this.analytics.track(analytics.ANALYTICS_EVENTS.CONNECTION_COMPLETED, _objectSpread(_objectSpread({}, eventData), {}, {
+          duration: Date.now() - startTime
+        }));
         resolve(this.provider);
       });
-      this.once(constants.CONNECTOR_EVENTS.ERRORED, err => {
+      this.once(constants.CONNECTOR_EVENTS.ERRORED, async err => {
+        // track connection failed event
+        this.analytics.track(analytics.ANALYTICS_EVENTS.CONNECTION_FAILED, _objectSpread(_objectSpread(_objectSpread({}, eventData), utils.getErrorAnalyticsProperties(err)), {}, {
+          duration: Date.now() - startTime
+        }));
         reject(err);
       });
-      const initialChain = this.getInitialChainIdForConnector(connector);
-      const finalLoginParams = _objectSpread(_objectSpread({}, loginParams), {}, {
-        chainId: initialChain.chainId
-      });
       connector.connect(finalLoginParams);
       this.setCurrentChain(initialChain.chainId);
     });
@@ -189,22 +290,60 @@ class Web3AuthNoModal extends auth.SafeEventEmitter {
     return this.connectedConnector.getUserInfo();
   }
   async enableMFA(loginParams) {
+    var _authConnector$authIn2;
     if (this.status !== constants.CONNECTOR_STATUS.CONNECTED || !this.connectedConnector) throw index.WalletLoginError.notConnectedError(`No wallet is connected`);
     if (this.connectedConnector.name !== index$1.WALLET_CONNECTORS.AUTH) throw index.WalletLoginError.unsupportedOperation(`EnableMFA is not supported for this connector.`);
-    return this.connectedConnector.enableMFA(loginParams);
+    const authConnector = this.connectedConnector;
+    const trackData = {
+      connector: this.connectedConnector.name,
+      auth_ux_mode: (_authConnector$authIn2 = authConnector.authInstance) === null || _authConnector$authIn2 === void 0 || (_authConnector$authIn2 = _authConnector$authIn2.options) === null || _authConnector$authIn2 === void 0 ? void 0 : _authConnector$authIn2.uxMode
+    };
+    try {
+      this.analytics.track(analytics.ANALYTICS_EVENTS.MFA_ENABLEMENT_STARTED, trackData);
+      await this.connectedConnector.enableMFA(loginParams);
+    } catch (error) {
+      this.analytics.track(analytics.ANALYTICS_EVENTS.MFA_ENABLEMENT_FAILED, _objectSpread(_objectSpread({}, trackData), utils.getErrorAnalyticsProperties(error)));
+      throw error;
+    }
   }
   async manageMFA(loginParams) {
+    var _authConnector$authIn3;
     if (this.status !== constants.CONNECTOR_STATUS.CONNECTED || !this.connectedConnector) throw index.WalletLoginError.notConnectedError(`No wallet is connected`);
     if (this.connectedConnector.name !== index$1.WALLET_CONNECTORS.AUTH) throw index.WalletLoginError.unsupportedOperation(`ManageMFA is not supported for this connector.`);
-    return this.connectedConnector.manageMFA(loginParams);
+    const authConnector = this.connectedConnector;
+    const trackData = {
+      connector: this.connectedConnector.name,
+      auth_ux_mode: (_authConnector$authIn3 = authConnector.authInstance) === null || _authConnector$authIn3 === void 0 || (_authConnector$authIn3 = _authConnector$authIn3.options) === null || _authConnector$authIn3 === void 0 ? void 0 : _authConnector$authIn3.uxMode
+    };
+    try {
+      this.analytics.track(analytics.ANALYTICS_EVENTS.MFA_MANAGEMENT_SELECTED, trackData);
+      await this.connectedConnector.manageMFA(loginParams);
+    } catch (error) {
+      this.analytics.track(analytics.ANALYTICS_EVENTS.MFA_MANAGEMENT_FAILED, _objectSpread(_objectSpread({}, trackData), utils.getErrorAnalyticsProperties(error)));
+      throw error;
+    }
   }
-  async authenticateUser() {
+  async getIdentityToken() {
     if (this.status !== constants.CONNECTOR_STATUS.CONNECTED || !this.connectedConnector) throw index.WalletLoginError.notConnectedError(`No wallet is connected`);
-    return this.connectedConnector.authenticateUser();
+    const trackData = {
+      connector: this.connectedConnector.name
+    };
+    try {
+      this.analytics.track(analytics.ANALYTICS_EVENTS.IDENTITY_TOKEN_STARTED, trackData);
+      const identityToken = await this.connectedConnector.getIdentityToken();
+      this.analytics.track(analytics.ANALYTICS_EVENTS.IDENTITY_TOKEN_COMPLETED, trackData);
+      return identityToken;
+    } catch (error) {
+      this.analytics.track(analytics.ANALYTICS_EVENTS.IDENTITY_TOKEN_FAILED, _objectSpread(_objectSpread({}, trackData), utils.getErrorAnalyticsProperties(error)));
+      throw error;
+    }
   }
   getPlugin(name) {
     return this.plugins[name] || null;
   }
+  setAnalyticsProperties(properties) {
+    this.analytics.setGlobalProperties(properties);
+  }
   initChainsConfig(projectConfig) {
     // merge chains from project config with core options, core options chains will take precedence over project config chains
     const chainMap = new Map();
@@ -301,13 +440,90 @@ class Web3AuthNoModal extends auth.SafeEventEmitter {
       this.coreOptions.useAAWithExternalWallet = walletScope === constants$1.SMART_ACCOUNT_WALLET_SCOPE.ALL;
     }
   }
+  initUIConfig(projectConfig) {
+    this.coreOptions.uiConfig = deepmerge.all([{
+      mode: "light",
+      uxMode: auth.UX_MODE.POPUP
+    }, auth.cloneDeep(projectConfig.whitelabel || {}), this.coreOptions.uiConfig || {}]);
+  }
   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
+    });
+  }
+  initWalletServicesConfig(projectConfig) {
+    var _this$coreOptions$wal, _this$coreOptions$wal2, _this$coreOptions$wal3, _ref2, _this$coreOptions$wal4, _this$coreOptions$wal5;
+    const {
+      enableKeyExport,
+      walletUi
+    } = projectConfig;
+    const {
+      enablePortfolioWidget = false,
+      enableTokenDisplay = true,
+      enableNftDisplay = true,
+      enableWalletConnect = true,
+      enableBuyButton = true,
+      enableSendButton = true,
+      enableSwapButton = true,
+      enableReceiveButton = true,
+      enableShowAllTokensButton = true,
+      enableConfirmationModal = false,
+      portfolioWidgetPosition = baseControllers.BUTTON_POSITION.BOTTOM_LEFT,
+      defaultPortfolio = "token"
+    } = walletUi || {};
+    const projectConfigWhiteLabel = {
+      showWidgetButton: enablePortfolioWidget,
+      hideNftDisplay: !enableNftDisplay,
+      hideTokenDisplay: !enableTokenDisplay,
+      hideTransfers: !enableSendButton,
+      hideTopup: !enableBuyButton,
+      hideReceive: !enableReceiveButton,
+      hideSwap: !enableSwapButton,
+      hideShowAllTokens: !enableShowAllTokensButton,
+      hideWalletConnect: !enableWalletConnect,
+      buttonPosition: portfolioWidgetPosition,
+      defaultPortfolio
+    };
+    const whiteLabel = deepmerge.all([projectConfigWhiteLabel, ((_this$coreOptions$wal = this.coreOptions.walletServicesConfig) === null || _this$coreOptions$wal === void 0 ? void 0 : _this$coreOptions$wal.whiteLabel) || {}]);
+    const confirmationStrategy = (_this$coreOptions$wal2 = (_this$coreOptions$wal3 = this.coreOptions.walletServicesConfig) === null || _this$coreOptions$wal3 === void 0 ? void 0 : _this$coreOptions$wal3.confirmationStrategy) !== null && _this$coreOptions$wal2 !== void 0 ? _this$coreOptions$wal2 : enableConfirmationModal ? baseControllers.CONFIRMATION_STRATEGY.MODAL : baseControllers.CONFIRMATION_STRATEGY.AUTO_APPROVE;
+    const isKeyExportEnabled = (_ref2 = (_this$coreOptions$wal4 = (_this$coreOptions$wal5 = this.coreOptions.walletServicesConfig) === null || _this$coreOptions$wal5 === void 0 ? void 0 : _this$coreOptions$wal5.enableKeyExport) !== null && _this$coreOptions$wal4 !== void 0 ? _this$coreOptions$wal4 : enableKeyExport) !== null && _ref2 !== void 0 ? _ref2 : true;
+    this.coreOptions.walletServicesConfig = _objectSpread(_objectSpread({}, this.coreOptions.walletServicesConfig), {}, {
+      confirmationStrategy,
+      whiteLabel,
+      enableKeyExport: isKeyExportEnabled
+    });
+  }
+  getInitializationTrackData() {
+    try {
+      var _this$coreOptions$cha2, _this$coreOptions$cha3, _this$coreOptions$cha4, _this$coreOptions$uiC2;
+      const defaultChain = (_this$coreOptions$cha2 = this.coreOptions.chains) === null || _this$coreOptions$cha2 === void 0 ? void 0 : _this$coreOptions$cha2.find(chain => chain.chainId === this.coreOptions.defaultChainId);
+      const rpcHostnames = Array.from(new Set((_this$coreOptions$cha3 = this.coreOptions.chains) === null || _this$coreOptions$cha3 === void 0 ? void 0 : _this$coreOptions$cha3.map(chain => utils.getHostname(chain.rpcTarget)))).filter(Boolean);
+      return _objectSpread(_objectSpread(_objectSpread({
+        chain_ids: (_this$coreOptions$cha4 = this.coreOptions.chains) === null || _this$coreOptions$cha4 === void 0 ? void 0 : _this$coreOptions$cha4.map(chain => utils.getCaipChainId(chain)),
+        chain_rpc_targets: rpcHostnames,
+        default_chain_id: defaultChain ? utils.getCaipChainId(defaultChain) : undefined,
+        logging_enabled: this.coreOptions.enableLogging,
+        storage_type: this.coreOptions.storageType,
+        session_time: this.coreOptions.sessionTime,
+        sfa_key_enabled: this.coreOptions.useSFAKey,
+        mipd_enabled: this.coreOptions.multiInjectedProviderDiscovery,
+        private_key_provider_enabled: Boolean(this.coreOptions.privateKeyProvider),
+        ssr_enabled: this.coreOptions.ssr,
+        auth_build_env: this.coreOptions.authBuildEnv,
+        auth_ux_mode: (_this$coreOptions$uiC2 = this.coreOptions.uiConfig) === null || _this$coreOptions$uiC2 === void 0 ? void 0 : _this$coreOptions$uiC2.uxMode,
+        auth_mfa_level: this.coreOptions.mfaLevel,
+        auth_mfa_settings: Object.keys(this.coreOptions.mfaSettings || {}),
+        aa_enabled_for_external_wallets: this.coreOptions.accountAbstractionConfig ? this.coreOptions.useAAWithExternalWallet : undefined
+      }, utils.getWhitelabelAnalyticsProperties(this.coreOptions.uiConfig)), utils.getAaAnalyticsProperties(this.coreOptions.accountAbstractionConfig)), utils.getWalletServicesAnalyticsProperties(this.coreOptions.walletServicesConfig));
+    } catch (error) {
+      loglevel.log.error("Failed to get initialization track data", error);
+      return {};
+    }
   }
   async setupCommonJRPCProvider() {
     this.commonJRPCProvider = await CommonJRPCProvider.CommonJRPCProvider.getProviderInstance({
@@ -344,7 +560,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 {
@@ -377,11 +593,13 @@ 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
     // 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
-    } : undefined));
+    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'); });
@@ -429,6 +647,21 @@ 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.getIdentityToken();
+          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, this.loginMode);
+          return;
+        }
+      }
       let finalProvider = provider.provider || provider;
       // setup AA provider if AA is enabled
       const {
@@ -451,7 +684,8 @@ class Web3AuthNoModal extends auth.SafeEventEmitter {
           accountAbstractionConfig,
           provider: eoaProvider,
           chain: this.currentChain,
-          chains: this.coreOptions.chains.filter(chain => aaChainIds.has(chain.chainId))
+          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
@@ -461,12 +695,16 @@ class Web3AuthNoModal extends auth.SafeEventEmitter {
         }
       }
       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
@@ -474,11 +712,9 @@ class Web3AuthNoModal extends auth.SafeEventEmitter {
       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 => {
@@ -493,7 +729,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 => {
@@ -504,27 +742,37 @@ class Web3AuthNoModal extends auth.SafeEventEmitter {
     connector.on(constants.CONNECTOR_EVENTS.ERRORED, data => {
       this.status = constants.CONNECTOR_STATUS.ERRORED;
       this.clearCache();
-      this.emit(constants.CONNECTOR_EVENTS.ERRORED, data);
+      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 => {
+      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 => {
+      var _authConnector$authIn4;
       loglevel.log.debug("mfa enabled", isMFAEnabled);
+      const authConnector = this.connectedConnector;
+      // mfa_enabled event is only emitted when using "popup" ux_mode
+      // TODO: handle mfa_enabled event when using "redirect" ux_mode
+      this.analytics.track(analytics.ANALYTICS_EVENTS.MFA_ENABLEMENT_COMPLETED, {
+        connector: this.connectedConnector.name,
+        auth_ux_mode: (_authConnector$authIn4 = authConnector.authInstance) === null || _authConnector$authIn4 === void 0 || (_authConnector$authIn4 = _authConnector$authIn4.options) === null || _authConnector$authIn4 === void 0 ? void 0 : _authConnector$authIn4.uxMode,
+        is_mfa_enabled: isMFAEnabled
+      });
       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");
   }
   /**
@@ -541,21 +789,17 @@ 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 => {
@@ -578,6 +822,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;