@web3auth/no-modal 8.12.4 → 9.0.0-alpha.1

package/dist/lib.esm/noModal.js

@@ -0,0 +1,341 @@
+import _objectSpread from '@babel/runtime/helpers/objectSpread2';
+import _defineProperty from '@babel/runtime/helpers/defineProperty';
+import { SafeEventEmitter } from '@web3auth/auth';
+import { LOGIN_PROVIDER } from '@web3auth/auth-adapter';
+import { ADAPTER_STATUS, WalletInitializationError, log, CHAIN_NAMESPACES, storageAvailable, getChainConfig, fetchProjectConfig, WALLET_ADAPTERS, cloneDeep, ADAPTER_EVENTS, ADAPTER_NAMESPACES, WalletLoginError, PLUGIN_NAMESPACES, PLUGIN_STATUS } from '@web3auth/base';
+import { CommonJRPCProvider } from '@web3auth/base-provider';
+import deepmerge from 'deepmerge';
+
+const ADAPTER_CACHE_KEY = "Web3Auth-cachedAdapter";
+class Web3AuthNoModal extends SafeEventEmitter {
+  constructor(options) {
+    var _options$chainConfig, _options$chainConfig2, _options$chainConfig3, _options$chainConfig4;
+    super();
+    _defineProperty(this, "coreOptions", void 0);
+    _defineProperty(this, "connectedAdapterName", null);
+    _defineProperty(this, "status", ADAPTER_STATUS.NOT_READY);
+    _defineProperty(this, "cachedAdapter", null);
+    _defineProperty(this, "walletAdapters", {});
+    _defineProperty(this, "commonJRPCProvider", null);
+    _defineProperty(this, "plugins", {});
+    _defineProperty(this, "storage", "localStorage");
+    if (!options.clientId) throw WalletInitializationError.invalidParams("Please provide a valid clientId in constructor");
+    if (options.enableLogging) log.enableAll();else log.setLevel("error");
+    if (!options.privateKeyProvider && !options.chainConfig) {
+      throw WalletInitializationError.invalidParams("Please provide chainConfig or privateKeyProvider");
+    }
+    options.chainConfig = options.chainConfig || options.privateKeyProvider.currentChainConfig;
+    if (!((_options$chainConfig = options.chainConfig) !== null && _options$chainConfig !== void 0 && _options$chainConfig.chainNamespace) || !Object.values(CHAIN_NAMESPACES).includes((_options$chainConfig2 = options.chainConfig) === null || _options$chainConfig2 === void 0 ? void 0 : _options$chainConfig2.chainNamespace)) throw WalletInitializationError.invalidParams("Please provide a valid chainNamespace in chainConfig");
+    if (options.storageKey === "session") this.storage = "sessionStorage";
+    this.cachedAdapter = storageAvailable(this.storage) ? window[this.storage].getItem(ADAPTER_CACHE_KEY) : null;
+    this.coreOptions = _objectSpread(_objectSpread({}, options), {}, {
+      chainConfig: _objectSpread(_objectSpread({}, getChainConfig((_options$chainConfig3 = options.chainConfig) === null || _options$chainConfig3 === void 0 ? void 0 : _options$chainConfig3.chainNamespace, (_options$chainConfig4 = options.chainConfig) === null || _options$chainConfig4 === void 0 ? void 0 : _options$chainConfig4.chainId) || {}), options.chainConfig)
+    });
+    this.subscribeToAdapterEvents = this.subscribeToAdapterEvents.bind(this);
+  }
+  get connected() {
+    return Boolean(this.connectedAdapterName);
+  }
+  get provider() {
+    if (this.status !== ADAPTER_STATUS.NOT_READY && this.commonJRPCProvider) {
+      return this.commonJRPCProvider;
+    }
+    return null;
+  }
+  set provider(_) {
+    throw new Error("Not implemented");
+  }
+  async init() {
+    this.commonJRPCProvider = await CommonJRPCProvider.getProviderInstance({
+      chainConfig: this.coreOptions.chainConfig
+    });
+    let projectConfig;
+    try {
+      projectConfig = await fetchProjectConfig(this.coreOptions.clientId, this.coreOptions.web3AuthNetwork);
+    } catch (e) {
+      log.error("Failed to fetch project configurations", e);
+      throw WalletInitializationError.notReady("failed to fetch project configurations", e);
+    }
+    const initPromises = Object.keys(this.walletAdapters).map(async adapterName => {
+      this.subscribeToAdapterEvents(this.walletAdapters[adapterName]);
+      // if adapter doesn't have any chain config yet then set it based on provided namespace and chainId.
+      // if no chainNamespace or chainId is being provided, it will connect with mainnet.
+      if (!this.walletAdapters[adapterName].chainConfigProxy) {
+        const providedChainConfig = this.coreOptions.chainConfig;
+        if (!providedChainConfig.chainNamespace) throw WalletInitializationError.invalidParams("Please provide chainNamespace in chainConfig");
+        this.walletAdapters[adapterName].setAdapterSettings({
+          chainConfig: providedChainConfig,
+          sessionTime: this.coreOptions.sessionTime,
+          clientId: this.coreOptions.clientId,
+          web3AuthNetwork: this.coreOptions.web3AuthNetwork,
+          useCoreKitKey: this.coreOptions.useCoreKitKey
+        });
+      } else {
+        this.walletAdapters[adapterName].setAdapterSettings({
+          sessionTime: this.coreOptions.sessionTime,
+          clientId: this.coreOptions.clientId,
+          web3AuthNetwork: this.coreOptions.web3AuthNetwork,
+          useCoreKitKey: this.coreOptions.useCoreKitKey
+        });
+      }
+      if (adapterName === WALLET_ADAPTERS.AUTH) {
+        const authAdapter = this.walletAdapters[adapterName];
+        const {
+          whitelabel
+        } = projectConfig;
+        this.coreOptions.uiConfig = deepmerge(cloneDeep(whitelabel), this.coreOptions.uiConfig);
+        if (!this.coreOptions.uiConfig.mode) this.coreOptions.uiConfig.mode = "light";
+        const {
+          sms_otp_enabled: smsOtpEnabled,
+          whitelist,
+          key_export_enabled: keyExportEnabled
+        } = projectConfig;
+        if (smsOtpEnabled !== undefined) {
+          authAdapter.setAdapterSettings({
+            loginConfig: {
+              [LOGIN_PROVIDER.SMS_PASSWORDLESS]: {
+                showOnModal: smsOtpEnabled,
+                showOnDesktop: smsOtpEnabled,
+                showOnMobile: smsOtpEnabled,
+                showOnSocialBackupFactor: smsOtpEnabled
+              }
+            }
+          });
+        }
+        if (whitelist) {
+          authAdapter.setAdapterSettings({
+            originData: whitelist.signed_urls
+          });
+        }
+        if (typeof keyExportEnabled === "boolean") {
+          this.coreOptions.privateKeyProvider.setKeyExportFlag(keyExportEnabled);
+          // dont know if this is required or not.
+          this.commonJRPCProvider.setKeyExportFlag(keyExportEnabled);
+        }
+        if (this.coreOptions.privateKeyProvider) {
+          if (authAdapter.currentChainNamespace !== this.coreOptions.privateKeyProvider.currentChainConfig.chainNamespace) {
+            throw WalletInitializationError.incompatibleChainNameSpace("private key provider is not compatible with provided chainNamespace for auth adapter");
+          }
+          authAdapter.setAdapterSettings({
+            privateKeyProvider: this.coreOptions.privateKeyProvider
+          });
+        }
+        authAdapter.setAdapterSettings({
+          whiteLabel: this.coreOptions.uiConfig
+        });
+        if (!authAdapter.privateKeyProvider) {
+          throw WalletInitializationError.invalidParams("privateKeyProvider is required for auth adapter");
+        }
+      } else if (adapterName === WALLET_ADAPTERS.WALLET_CONNECT_V2) {
+        const walletConnectAdapter = this.walletAdapters[adapterName];
+        const {
+          wallet_connect_enabled: walletConnectEnabled,
+          wallet_connect_project_id: walletConnectProjectId
+        } = projectConfig;
+        if (walletConnectEnabled === false) {
+          throw WalletInitializationError.invalidParams("Please enable wallet connect v2 addon on dashboard");
+        }
+        if (!walletConnectProjectId) throw WalletInitializationError.invalidParams("Invalid wallet connect project id. Please configure it on the dashboard");
+        walletConnectAdapter.setAdapterSettings({
+          adapterSettings: {
+            walletConnectInitOptions: {
+              projectId: walletConnectProjectId
+            }
+          }
+        });
+      }
+      return this.walletAdapters[adapterName].init({
+        autoConnect: this.cachedAdapter === adapterName
+      }).catch(e => log.error(e, adapterName));
+    });
+    await Promise.all(initPromises);
+    if (this.status === ADAPTER_STATUS.NOT_READY) {
+      this.status = ADAPTER_STATUS.READY;
+      this.emit(ADAPTER_EVENTS.READY);
+    }
+  }
+  getAdapter(adapterName) {
+    return this.walletAdapters[adapterName] || null;
+  }
+  configureAdapter(adapter) {
+    this.checkInitRequirements();
+    const providedChainConfig = this.coreOptions.chainConfig;
+    if (!providedChainConfig.chainNamespace) throw WalletInitializationError.invalidParams("Please provide chainNamespace in chainConfig");
+    const adapterAlreadyExists = this.walletAdapters[adapter.name];
+    if (adapterAlreadyExists) throw WalletInitializationError.duplicateAdapterError(`Wallet adapter for ${adapter.name} already exists`);
+    if (adapter.adapterNamespace !== ADAPTER_NAMESPACES.MULTICHAIN && adapter.adapterNamespace !== providedChainConfig.chainNamespace) throw WalletInitializationError.incompatibleChainNameSpace(`This wallet adapter belongs to ${adapter.adapterNamespace} which is incompatible with currently used namespace: ${providedChainConfig.chainNamespace}`);
+    if (adapter.adapterNamespace === ADAPTER_NAMESPACES.MULTICHAIN && adapter.currentChainNamespace && providedChainConfig.chainNamespace !== adapter.currentChainNamespace) {
+      // chainConfig checks are already validated in constructor so using typecast is safe here.
+      adapter.setAdapterSettings({
+        chainConfig: providedChainConfig
+      });
+    }
+    this.walletAdapters[adapter.name] = adapter;
+    return this;
+  }
+  clearCache() {
+    if (!storageAvailable(this.storage)) return;
+    window[this.storage].removeItem(ADAPTER_CACHE_KEY);
+    this.cachedAdapter = null;
+  }
+  async addChain(chainConfig) {
+    if (this.status === ADAPTER_STATUS.CONNECTED && this.connectedAdapterName) return this.walletAdapters[this.connectedAdapterName].addChain(chainConfig);
+    if (this.commonJRPCProvider) {
+      return this.commonJRPCProvider.addChain(chainConfig);
+    }
+    throw WalletInitializationError.notReady(`No wallet is ready`);
+  }
+  async switchChain(params) {
+    if (this.status === ADAPTER_STATUS.CONNECTED && this.connectedAdapterName) return this.walletAdapters[this.connectedAdapterName].switchChain(params);
+    if (this.commonJRPCProvider) {
+      return this.commonJRPCProvider.switchChain(params);
+    }
+    throw WalletInitializationError.notReady(`No wallet is ready`);
+  }
+
+  /**
+   * Connect to a specific wallet adapter
+   * @param walletName - Key of the walletAdapter to use.
+   */
+  async connectTo(walletName, loginParams) {
+    if (!this.walletAdapters[walletName] || !this.commonJRPCProvider) throw WalletInitializationError.notFound(`Please add wallet adapter for ${walletName} wallet, before connecting`);
+    const provider = await this.walletAdapters[walletName].connect(loginParams);
+    this.commonJRPCProvider.updateProviderEngineProxy(provider.provider || provider);
+    return this.provider;
+  }
+  async logout(options = {
+    cleanup: false
+  }) {
+    if (this.status !== ADAPTER_STATUS.CONNECTED || !this.connectedAdapterName) throw WalletLoginError.notConnectedError(`No wallet is connected`);
+    await this.walletAdapters[this.connectedAdapterName].disconnect(options);
+  }
+  async getUserInfo() {
+    log.debug("Getting user info", this.status, this.connectedAdapterName);
+    if (this.status !== ADAPTER_STATUS.CONNECTED || !this.connectedAdapterName) throw WalletLoginError.notConnectedError(`No wallet is connected`);
+    return this.walletAdapters[this.connectedAdapterName].getUserInfo();
+  }
+  async enableMFA(loginParams) {
+    if (this.status !== ADAPTER_STATUS.CONNECTED || !this.connectedAdapterName) throw WalletLoginError.notConnectedError(`No wallet is connected`);
+    if (this.connectedAdapterName !== WALLET_ADAPTERS.AUTH) throw WalletLoginError.unsupportedOperation(`EnableMFA is not supported for this adapter.`);
+    return this.walletAdapters[this.connectedAdapterName].enableMFA(loginParams);
+  }
+  async authenticateUser() {
+    if (this.status !== ADAPTER_STATUS.CONNECTED || !this.connectedAdapterName) throw WalletLoginError.notConnectedError(`No wallet is connected`);
+    return this.walletAdapters[this.connectedAdapterName].authenticateUser();
+  }
+  addPlugin(plugin) {
+    if (this.plugins[plugin.name]) throw WalletInitializationError.duplicateAdapterError(`Plugin ${plugin.name} already exist`);
+    if (plugin.pluginNamespace !== PLUGIN_NAMESPACES.MULTICHAIN && plugin.pluginNamespace !== this.coreOptions.chainConfig.chainNamespace) throw WalletInitializationError.incompatibleChainNameSpace(`This plugin belongs to ${plugin.pluginNamespace} namespace which is incompatible with currently used namespace: ${this.coreOptions.chainConfig.chainNamespace}`);
+    this.plugins[plugin.name] = plugin;
+    if (this.status === ADAPTER_STATUS.CONNECTED && this.connectedAdapterName) {
+      // web3auth is already connected. can initialize plugins
+      this.connectToPlugins({
+        adapter: this.connectedAdapterName
+      });
+    }
+    return this;
+  }
+  getPlugin(name) {
+    return this.plugins[name] || null;
+  }
+  subscribeToAdapterEvents(walletAdapter) {
+    walletAdapter.on(ADAPTER_EVENTS.CONNECTED, async data => {
+      if (!this.commonJRPCProvider) throw WalletInitializationError.notFound(`CommonJrpcProvider not found`);
+      const {
+        provider
+      } = data;
+      this.commonJRPCProvider.updateProviderEngineProxy(provider.provider || provider);
+      this.status = ADAPTER_STATUS.CONNECTED;
+      this.connectedAdapterName = data.adapter;
+      this.cacheWallet(data.adapter);
+      log.debug("connected", this.status, this.connectedAdapterName);
+      this.connectToPlugins(data);
+      this.emit(ADAPTER_EVENTS.CONNECTED, _objectSpread({}, data));
+    });
+    walletAdapter.on(ADAPTER_EVENTS.DISCONNECTED, async () => {
+      // get back to ready state for rehydrating.
+      this.status = ADAPTER_STATUS.READY;
+      if (storageAvailable(this.storage)) {
+        const cachedAdapter = window[this.storage].getItem(ADAPTER_CACHE_KEY);
+        if (this.connectedAdapterName === cachedAdapter) {
+          this.clearCache();
+        }
+      }
+      log.debug("disconnected", this.status, this.connectedAdapterName);
+      await Promise.all(Object.values(this.plugins).map(plugin => {
+        return plugin.disconnect().catch(error => {
+          // swallow error if adapter doesn't supports this plugin.
+          if (error.code === 5211) {
+            return;
+          }
+          // throw error;
+          log.error(error);
+        });
+      }));
+      this.connectedAdapterName = null;
+      this.emit(ADAPTER_EVENTS.DISCONNECTED);
+    });
+    walletAdapter.on(ADAPTER_EVENTS.CONNECTING, data => {
+      this.status = ADAPTER_STATUS.CONNECTING;
+      this.emit(ADAPTER_EVENTS.CONNECTING, data);
+      log.debug("connecting", this.status, this.connectedAdapterName);
+    });
+    walletAdapter.on(ADAPTER_EVENTS.ERRORED, data => {
+      this.status = ADAPTER_STATUS.ERRORED;
+      this.clearCache();
+      this.emit(ADAPTER_EVENTS.ERRORED, data);
+      log.debug("errored", this.status, this.connectedAdapterName);
+    });
+    walletAdapter.on(ADAPTER_EVENTS.ADAPTER_DATA_UPDATED, data => {
+      log.debug("adapter data updated", data);
+      this.emit(ADAPTER_EVENTS.ADAPTER_DATA_UPDATED, data);
+    });
+    walletAdapter.on(ADAPTER_EVENTS.CACHE_CLEAR, data => {
+      log.debug("adapter cache clear", data);
+      if (storageAvailable(this.storage)) {
+        this.clearCache();
+      }
+    });
+  }
+  checkInitRequirements() {
+    if (this.status === ADAPTER_STATUS.CONNECTING) throw WalletInitializationError.notReady("Already pending connection");
+    if (this.status === ADAPTER_STATUS.CONNECTED) throw WalletInitializationError.notReady("Already connected");
+    if (this.status === ADAPTER_STATUS.READY) throw WalletInitializationError.notReady("Adapter is already initialized");
+  }
+  cacheWallet(walletName) {
+    if (!storageAvailable(this.storage)) return;
+    window[this.storage].setItem(ADAPTER_CACHE_KEY, walletName);
+    this.cachedAdapter = walletName;
+  }
+  connectToPlugins(data) {
+    Object.values(this.plugins).map(async plugin => {
+      try {
+        if (!plugin.SUPPORTED_ADAPTERS.includes(data.adapter)) {
+          return;
+        }
+        if (plugin.status === PLUGIN_STATUS.CONNECTED) return;
+        const {
+          authInstance
+        } = this.walletAdapters[this.connectedAdapterName];
+        const {
+          options,
+          sessionId,
+          sessionNamespace
+        } = authInstance || {};
+        await plugin.initWithWeb3Auth(this, options.whiteLabel);
+        await plugin.connect({
+          sessionId,
+          sessionNamespace
+        });
+      } catch (error) {
+        // swallow error if connector adapter doesn't supports this plugin.
+        if (error.code === 5211) {
+          return;
+        }
+        log.error(error);
+      }
+    });
+  }
+}
+
+export { Web3AuthNoModal };

package/dist/noModal.cjs.js

@@ -60,20 +60,17 @@ var objectSpread2_default = /*#__PURE__*/__webpack_require__.n(objectSpread2_nam
 ;// CONCATENATED MODULE: external "@babel/runtime/helpers/defineProperty"
 const defineProperty_namespaceObject = require("@babel/runtime/helpers/defineProperty");
 var defineProperty_default = /*#__PURE__*/__webpack_require__.n(defineProperty_namespaceObject);
-;// CONCATENATED MODULE: external "@toruslabs/openlogin-jrpc"
-const openlogin_jrpc_namespaceObject = require("@toruslabs/openlogin-jrpc");
+;// CONCATENATED MODULE: external "@web3auth/auth"
+const auth_namespaceObject = require("@web3auth/auth");
+;// CONCATENATED MODULE: external "@web3auth/auth-adapter"
+const auth_adapter_namespaceObject = require("@web3auth/auth-adapter");
 ;// CONCATENATED MODULE: external "@web3auth/base"
 const base_namespaceObject = require("@web3auth/base");
 ;// CONCATENATED MODULE: external "@web3auth/base-provider"
 const base_provider_namespaceObject = require("@web3auth/base-provider");
-;// CONCATENATED MODULE: external "@web3auth/openlogin-adapter"
-const openlogin_adapter_namespaceObject = require("@web3auth/openlogin-adapter");
-;// CONCATENATED MODULE: external "lodash.clonedeep"
-const external_lodash_clonedeep_namespaceObject = require("lodash.clonedeep");
-var external_lodash_clonedeep_default = /*#__PURE__*/__webpack_require__.n(external_lodash_clonedeep_namespaceObject);
-;// CONCATENATED MODULE: external "lodash.merge"
-const external_lodash_merge_namespaceObject = require("lodash.merge");
-var external_lodash_merge_default = /*#__PURE__*/__webpack_require__.n(external_lodash_merge_namespaceObject);
+;// CONCATENATED MODULE: external "deepmerge"
+const external_deepmerge_namespaceObject = require("deepmerge");
+var external_deepmerge_default = /*#__PURE__*/__webpack_require__.n(external_deepmerge_namespaceObject);
 ;// CONCATENATED MODULE: ./src/noModal.ts
 
 
@@ -82,9 +79,8 @@ var external_lodash_merge_default = /*#__PURE__*/__webpack_require__.n(external_
 
 
 
-
 const ADAPTER_CACHE_KEY = "Web3Auth-cachedAdapter";
-class Web3AuthNoModal extends openlogin_jrpc_namespaceObject.SafeEventEmitter {
+class Web3AuthNoModal extends auth_namespaceObject.SafeEventEmitter {
   constructor(options) {
     var _options$chainConfig, _options$chainConfig2, _options$chainConfig3, _options$chainConfig4;
     super();
@@ -155,21 +151,22 @@ class Web3AuthNoModal extends openlogin_jrpc_namespaceObject.SafeEventEmitter {
           useCoreKitKey: this.coreOptions.useCoreKitKey
         });
       }
-      if (adapterName === base_namespaceObject.WALLET_ADAPTERS.OPENLOGIN) {
-        const openloginAdapter = this.walletAdapters[adapterName];
+      if (adapterName === base_namespaceObject.WALLET_ADAPTERS.AUTH) {
+        const authAdapter = this.walletAdapters[adapterName];
         const {
           whitelabel
         } = projectConfig;
-        this.coreOptions.uiConfig = external_lodash_merge_default()(external_lodash_clonedeep_default()(whitelabel), this.coreOptions.uiConfig);
+        this.coreOptions.uiConfig = external_deepmerge_default()((0,base_namespaceObject.cloneDeep)(whitelabel), this.coreOptions.uiConfig);
         if (!this.coreOptions.uiConfig.mode) this.coreOptions.uiConfig.mode = "light";
         const {
           sms_otp_enabled: smsOtpEnabled,
-          whitelist
+          whitelist,
+          key_export_enabled: keyExportEnabled
         } = projectConfig;
         if (smsOtpEnabled !== undefined) {
-          openloginAdapter.setAdapterSettings({
+          authAdapter.setAdapterSettings({
             loginConfig: {
-              [openlogin_adapter_namespaceObject.LOGIN_PROVIDER.SMS_PASSWORDLESS]: {
+              [auth_adapter_namespaceObject.LOGIN_PROVIDER.SMS_PASSWORDLESS]: {
                 showOnModal: smsOtpEnabled,
                 showOnDesktop: smsOtpEnabled,
                 showOnMobile: smsOtpEnabled,
@@ -179,23 +176,28 @@ class Web3AuthNoModal extends openlogin_jrpc_namespaceObject.SafeEventEmitter {
           });
         }
         if (whitelist) {
-          openloginAdapter.setAdapterSettings({
+          authAdapter.setAdapterSettings({
             originData: whitelist.signed_urls
           });
         }
+        if (typeof keyExportEnabled === "boolean") {
+          this.coreOptions.privateKeyProvider.setKeyExportFlag(keyExportEnabled);
+          // dont know if this is required or not.
+          this.commonJRPCProvider.setKeyExportFlag(keyExportEnabled);
+        }
         if (this.coreOptions.privateKeyProvider) {
-          if (openloginAdapter.currentChainNamespace !== this.coreOptions.privateKeyProvider.currentChainConfig.chainNamespace) {
-            throw base_namespaceObject.WalletInitializationError.incompatibleChainNameSpace("private key provider is not compatible with provided chainNamespace for openlogin adapter");
+          if (authAdapter.currentChainNamespace !== this.coreOptions.privateKeyProvider.currentChainConfig.chainNamespace) {
+            throw base_namespaceObject.WalletInitializationError.incompatibleChainNameSpace("private key provider is not compatible with provided chainNamespace for auth adapter");
           }
-          openloginAdapter.setAdapterSettings({
+          authAdapter.setAdapterSettings({
             privateKeyProvider: this.coreOptions.privateKeyProvider
           });
         }
-        openloginAdapter.setAdapterSettings({
+        authAdapter.setAdapterSettings({
           whiteLabel: this.coreOptions.uiConfig
         });
-        if (!openloginAdapter.privateKeyProvider) {
-          throw base_namespaceObject.WalletInitializationError.invalidParams("privateKeyProvider is required for openlogin adapter");
+        if (!authAdapter.privateKeyProvider) {
+          throw base_namespaceObject.WalletInitializationError.invalidParams("privateKeyProvider is required for auth adapter");
         }
       } else if (adapterName === base_namespaceObject.WALLET_ADAPTERS.WALLET_CONNECT_V2) {
         const walletConnectAdapter = this.walletAdapters[adapterName];
@@ -287,7 +289,7 @@ class Web3AuthNoModal extends openlogin_jrpc_namespaceObject.SafeEventEmitter {
   }
   async enableMFA(loginParams) {
     if (this.status !== base_namespaceObject.ADAPTER_STATUS.CONNECTED || !this.connectedAdapterName) throw base_namespaceObject.WalletLoginError.notConnectedError(`No wallet is connected`);
-    if (this.connectedAdapterName !== base_namespaceObject.WALLET_ADAPTERS.OPENLOGIN) throw base_namespaceObject.WalletLoginError.unsupportedOperation(`EnableMFA is not supported for this adapter.`);
+    if (this.connectedAdapterName !== base_namespaceObject.WALLET_ADAPTERS.AUTH) throw base_namespaceObject.WalletLoginError.unsupportedOperation(`EnableMFA is not supported for this adapter.`);
     return this.walletAdapters[this.connectedAdapterName].enableMFA(loginParams);
   }
   async authenticateUser() {
@@ -323,7 +325,7 @@ class Web3AuthNoModal extends openlogin_jrpc_namespaceObject.SafeEventEmitter {
       this.connectToPlugins(data);
       this.emit(base_namespaceObject.ADAPTER_EVENTS.CONNECTED, objectSpread2_default()({}, data));
     });
-    walletAdapter.on(base_namespaceObject.ADAPTER_EVENTS.DISCONNECTED, async data => {
+    walletAdapter.on(base_namespaceObject.ADAPTER_EVENTS.DISCONNECTED, async () => {
       // get back to ready state for rehydrating.
       this.status = base_namespaceObject.ADAPTER_STATUS.READY;
       if ((0,base_namespaceObject.storageAvailable)(this.storage)) {
@@ -344,7 +346,7 @@ class Web3AuthNoModal extends openlogin_jrpc_namespaceObject.SafeEventEmitter {
         });
       }));
       this.connectedAdapterName = null;
-      this.emit(base_namespaceObject.ADAPTER_EVENTS.DISCONNECTED, data);
+      this.emit(base_namespaceObject.ADAPTER_EVENTS.DISCONNECTED);
     });
     walletAdapter.on(base_namespaceObject.ADAPTER_EVENTS.CONNECTING, data => {
       this.status = base_namespaceObject.ADAPTER_STATUS.CONNECTING;
@@ -386,13 +388,13 @@ class Web3AuthNoModal extends openlogin_jrpc_namespaceObject.SafeEventEmitter {
         }
         if (plugin.status === base_namespaceObject.PLUGIN_STATUS.CONNECTED) return;
         const {
-          openloginInstance
+          authInstance
         } = this.walletAdapters[this.connectedAdapterName];
         const {
           options,
           sessionId,
           sessionNamespace
-        } = openloginInstance || {};
+        } = authInstance || {};
         await plugin.initWithWeb3Auth(this, options.whiteLabel);
         await plugin.connect({
           sessionId,

package/dist/noModal.esm.js

@@ -1,11 +1,10 @@
 import _objectSpread from '@babel/runtime/helpers/objectSpread2';
 import _defineProperty from '@babel/runtime/helpers/defineProperty';
-import { SafeEventEmitter } from '@toruslabs/openlogin-jrpc';
-import { ADAPTER_STATUS, WalletInitializationError, log, CHAIN_NAMESPACES, storageAvailable, getChainConfig, fetchProjectConfig, WALLET_ADAPTERS, ADAPTER_EVENTS, ADAPTER_NAMESPACES, WalletLoginError, PLUGIN_NAMESPACES, PLUGIN_STATUS } from '@web3auth/base';
+import { SafeEventEmitter } from '@web3auth/auth';
+import { LOGIN_PROVIDER } from '@web3auth/auth-adapter';
+import { ADAPTER_STATUS, WalletInitializationError, log, CHAIN_NAMESPACES, storageAvailable, getChainConfig, fetchProjectConfig, WALLET_ADAPTERS, cloneDeep, ADAPTER_EVENTS, ADAPTER_NAMESPACES, WalletLoginError, PLUGIN_NAMESPACES, PLUGIN_STATUS } from '@web3auth/base';
 import { CommonJRPCProvider } from '@web3auth/base-provider';
-import { LOGIN_PROVIDER } from '@web3auth/openlogin-adapter';
-import clonedeep from 'lodash.clonedeep';
-import merge from 'lodash.merge';
+import deepmerge from 'deepmerge';
 
 const ADAPTER_CACHE_KEY = "Web3Auth-cachedAdapter";
 class Web3AuthNoModal extends SafeEventEmitter {
@@ -79,19 +78,20 @@ class Web3AuthNoModal extends SafeEventEmitter {
           useCoreKitKey: this.coreOptions.useCoreKitKey
         });
       }
-      if (adapterName === WALLET_ADAPTERS.OPENLOGIN) {
-        const openloginAdapter = this.walletAdapters[adapterName];
+      if (adapterName === WALLET_ADAPTERS.AUTH) {
+        const authAdapter = this.walletAdapters[adapterName];
         const {
           whitelabel
         } = projectConfig;
-        this.coreOptions.uiConfig = merge(clonedeep(whitelabel), this.coreOptions.uiConfig);
+        this.coreOptions.uiConfig = deepmerge(cloneDeep(whitelabel), this.coreOptions.uiConfig);
         if (!this.coreOptions.uiConfig.mode) this.coreOptions.uiConfig.mode = "light";
         const {
           sms_otp_enabled: smsOtpEnabled,
-          whitelist
+          whitelist,
+          key_export_enabled: keyExportEnabled
         } = projectConfig;
         if (smsOtpEnabled !== undefined) {
-          openloginAdapter.setAdapterSettings({
+          authAdapter.setAdapterSettings({
             loginConfig: {
               [LOGIN_PROVIDER.SMS_PASSWORDLESS]: {
                 showOnModal: smsOtpEnabled,
@@ -103,23 +103,28 @@ class Web3AuthNoModal extends SafeEventEmitter {
           });
         }
         if (whitelist) {
-          openloginAdapter.setAdapterSettings({
+          authAdapter.setAdapterSettings({
             originData: whitelist.signed_urls
           });
         }
+        if (typeof keyExportEnabled === "boolean") {
+          this.coreOptions.privateKeyProvider.setKeyExportFlag(keyExportEnabled);
+          // dont know if this is required or not.
+          this.commonJRPCProvider.setKeyExportFlag(keyExportEnabled);
+        }
         if (this.coreOptions.privateKeyProvider) {
-          if (openloginAdapter.currentChainNamespace !== this.coreOptions.privateKeyProvider.currentChainConfig.chainNamespace) {
-            throw WalletInitializationError.incompatibleChainNameSpace("private key provider is not compatible with provided chainNamespace for openlogin adapter");
+          if (authAdapter.currentChainNamespace !== this.coreOptions.privateKeyProvider.currentChainConfig.chainNamespace) {
+            throw WalletInitializationError.incompatibleChainNameSpace("private key provider is not compatible with provided chainNamespace for auth adapter");
           }
-          openloginAdapter.setAdapterSettings({
+          authAdapter.setAdapterSettings({
             privateKeyProvider: this.coreOptions.privateKeyProvider
           });
         }
-        openloginAdapter.setAdapterSettings({
+        authAdapter.setAdapterSettings({
           whiteLabel: this.coreOptions.uiConfig
         });
-        if (!openloginAdapter.privateKeyProvider) {
-          throw WalletInitializationError.invalidParams("privateKeyProvider is required for openlogin adapter");
+        if (!authAdapter.privateKeyProvider) {
+          throw WalletInitializationError.invalidParams("privateKeyProvider is required for auth adapter");
         }
       } else if (adapterName === WALLET_ADAPTERS.WALLET_CONNECT_V2) {
         const walletConnectAdapter = this.walletAdapters[adapterName];
@@ -211,7 +216,7 @@ class Web3AuthNoModal extends SafeEventEmitter {
   }
   async enableMFA(loginParams) {
     if (this.status !== ADAPTER_STATUS.CONNECTED || !this.connectedAdapterName) throw WalletLoginError.notConnectedError(`No wallet is connected`);
-    if (this.connectedAdapterName !== WALLET_ADAPTERS.OPENLOGIN) throw WalletLoginError.unsupportedOperation(`EnableMFA is not supported for this adapter.`);
+    if (this.connectedAdapterName !== WALLET_ADAPTERS.AUTH) throw WalletLoginError.unsupportedOperation(`EnableMFA is not supported for this adapter.`);
     return this.walletAdapters[this.connectedAdapterName].enableMFA(loginParams);
   }
   async authenticateUser() {
@@ -247,7 +252,7 @@ class Web3AuthNoModal extends SafeEventEmitter {
       this.connectToPlugins(data);
       this.emit(ADAPTER_EVENTS.CONNECTED, _objectSpread({}, data));
     });
-    walletAdapter.on(ADAPTER_EVENTS.DISCONNECTED, async data => {
+    walletAdapter.on(ADAPTER_EVENTS.DISCONNECTED, async () => {
       // get back to ready state for rehydrating.
       this.status = ADAPTER_STATUS.READY;
       if (storageAvailable(this.storage)) {
@@ -268,7 +273,7 @@ class Web3AuthNoModal extends SafeEventEmitter {
         });
       }));
       this.connectedAdapterName = null;
-      this.emit(ADAPTER_EVENTS.DISCONNECTED, data);
+      this.emit(ADAPTER_EVENTS.DISCONNECTED);
     });
     walletAdapter.on(ADAPTER_EVENTS.CONNECTING, data => {
       this.status = ADAPTER_STATUS.CONNECTING;
@@ -310,13 +315,13 @@ class Web3AuthNoModal extends SafeEventEmitter {
         }
         if (plugin.status === PLUGIN_STATUS.CONNECTED) return;
         const {
-          openloginInstance
+          authInstance
         } = this.walletAdapters[this.connectedAdapterName];
         const {
           options,
           sessionId,
           sessionNamespace
-        } = openloginInstance || {};
+        } = authInstance || {};
         await plugin.initWithWeb3Auth(this, options.whiteLabel);
         await plugin.connect({
           sessionId,