@web3auth/no-modal 8.0.1 → 8.1.0

package/dist/noModal.cjs.js

@@ -68,6 +68,274 @@ const base_namespaceObject = require("@web3auth/base");
 const base_plugin_namespaceObject = require("@web3auth/base-plugin");
 ;// CONCATENATED MODULE: external "@web3auth/base-provider"
 const base_provider_namespaceObject = require("@web3auth/base-provider");
+;// CONCATENATED MODULE: external "@toruslabs/openlogin-utils"
+const openlogin_utils_namespaceObject = require("@toruslabs/openlogin-utils");
+;// CONCATENATED MODULE: external "@toruslabs/openlogin"
+const openlogin_namespaceObject = require("@toruslabs/openlogin");
+var openlogin_default = /*#__PURE__*/__webpack_require__.n(openlogin_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: ../adapters/openlogin-adapter/dist/openloginAdapter.esm.js
+
+
+
+
+
+
+
+const getOpenloginDefaultOptions = () => {
+  return {
+    adapterSettings: {
+      network: openlogin_utils_namespaceObject.OPENLOGIN_NETWORK.SAPPHIRE_MAINNET,
+      clientId: "",
+      uxMode: openlogin_utils_namespaceObject.UX_MODE.POPUP
+    },
+    loginSettings: {},
+    privateKeyProvider: undefined
+  };
+};
+class OpenloginAdapter extends base_namespaceObject.BaseAdapter {
+  constructor() {
+    let params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    super(params);
+    defineProperty_default()(this, "name", base_namespaceObject.WALLET_ADAPTERS.OPENLOGIN);
+    defineProperty_default()(this, "adapterNamespace", base_namespaceObject.ADAPTER_NAMESPACES.MULTICHAIN);
+    defineProperty_default()(this, "type", base_namespaceObject.ADAPTER_CATEGORY.IN_APP);
+    defineProperty_default()(this, "openloginInstance", null);
+    defineProperty_default()(this, "status", base_namespaceObject.ADAPTER_STATUS.NOT_READY);
+    defineProperty_default()(this, "currentChainNamespace", base_namespaceObject.CHAIN_NAMESPACES.EIP155);
+    defineProperty_default()(this, "privateKeyProvider", null);
+    defineProperty_default()(this, "openloginOptions", void 0);
+    defineProperty_default()(this, "loginSettings", {
+      loginProvider: ""
+    });
+    this.setAdapterSettings(objectSpread2_default()(objectSpread2_default()({}, params.adapterSettings), {}, {
+      chainConfig: params.chainConfig,
+      clientId: params.clientId || "",
+      sessionTime: params.sessionTime,
+      web3AuthNetwork: params.web3AuthNetwork,
+      useCoreKitKey: params.useCoreKitKey,
+      privateKeyProvider: params.privateKeyProvider
+    }));
+    this.loginSettings = params.loginSettings || {
+      loginProvider: ""
+    };
+    this.privateKeyProvider = params.privateKeyProvider || null;
+  }
+  get chainConfigProxy() {
+    return this.chainConfig ? objectSpread2_default()({}, this.chainConfig) : null;
+  }
+  get provider() {
+    if (this.status !== base_namespaceObject.ADAPTER_STATUS.NOT_READY && this.privateKeyProvider) {
+      return this.privateKeyProvider;
+    }
+    return null;
+  }
+  set provider(_) {
+    throw new Error("Not implemented");
+  }
+  async init(options) {
+    super.checkInitializationRequirements();
+    if (!this.clientId) throw base_namespaceObject.WalletInitializationError.invalidParams("clientId is required before openlogin's initialization");
+    if (!this.openloginOptions) throw base_namespaceObject.WalletInitializationError.invalidParams("openloginOptions is required before openlogin's initialization");
+    const isRedirectResult = this.openloginOptions.uxMode === openlogin_utils_namespaceObject.UX_MODE.REDIRECT;
+    this.openloginOptions = objectSpread2_default()(objectSpread2_default()({}, this.openloginOptions), {}, {
+      replaceUrlOnRedirect: isRedirectResult
+    });
+    this.openloginInstance = new (openlogin_default())(objectSpread2_default()(objectSpread2_default()({}, this.openloginOptions), {}, {
+      clientId: this.clientId,
+      network: this.openloginOptions.network || this.web3AuthNetwork || openlogin_utils_namespaceObject.OPENLOGIN_NETWORK.SAPPHIRE_MAINNET
+    }));
+    base_namespaceObject.log.debug("initializing openlogin adapter init");
+    await this.openloginInstance.init();
+    if (!this.chainConfig) throw base_namespaceObject.WalletInitializationError.invalidParams("chainConfig is required before initialization");
+    this.status = base_namespaceObject.ADAPTER_STATUS.READY;
+    this.emit(base_namespaceObject.ADAPTER_EVENTS.READY, base_namespaceObject.WALLET_ADAPTERS.OPENLOGIN);
+    try {
+      base_namespaceObject.log.debug("initializing openlogin adapter");
+      const finalPrivKey = this._getFinalPrivKey();
+      // connect only if it is redirect result or if connect (adapter is cached/already connected in same session) is true
+      if (finalPrivKey && (options.autoConnect || isRedirectResult)) {
+        this.rehydrated = true;
+        await this.connect();
+      }
+    } catch (error) {
+      base_namespaceObject.log.error("Failed to connect with cached openlogin provider", error);
+      this.emit("ERRORED", error);
+    }
+  }
+  async connect() {
+    let params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {
+      loginProvider: ""
+    };
+    super.checkConnectionRequirements();
+    this.status = base_namespaceObject.ADAPTER_STATUS.CONNECTING;
+    this.emit(base_namespaceObject.ADAPTER_EVENTS.CONNECTING, objectSpread2_default()(objectSpread2_default()({}, params), {}, {
+      adapter: base_namespaceObject.WALLET_ADAPTERS.OPENLOGIN
+    }));
+    try {
+      await this.connectWithProvider(params);
+      return this.provider;
+    } catch (error) {
+      base_namespaceObject.log.error("Failed to connect with openlogin provider", error);
+      // ready again to be connected
+      this.status = base_namespaceObject.ADAPTER_STATUS.READY;
+      this.emit(base_namespaceObject.ADAPTER_EVENTS.ERRORED, error);
+      if (error !== null && error !== void 0 && error.message.includes("user closed popup")) {
+        throw base_namespaceObject.WalletLoginError.popupClosed();
+      } else if (error instanceof base_namespaceObject.Web3AuthError) {
+        throw error;
+      }
+      throw base_namespaceObject.WalletLoginError.connectionError("Failed to login with openlogin");
+    }
+  }
+  async enableMFA() {
+    let params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {
+      loginProvider: ""
+    };
+    if (this.status !== base_namespaceObject.ADAPTER_STATUS.CONNECTED) throw base_namespaceObject.WalletLoginError.notConnectedError("Not connected with wallet");
+    if (!this.openloginInstance) throw base_namespaceObject.WalletInitializationError.notReady("openloginInstance is not ready");
+    try {
+      await this.openloginInstance.enableMFA(params);
+    } catch (error) {
+      base_namespaceObject.log.error("Failed to enable MFA with openlogin provider", error);
+      if (error instanceof base_namespaceObject.Web3AuthError) {
+        throw error;
+      }
+      throw base_namespaceObject.WalletLoginError.connectionError(error.message || "Failed to enable MFA with openlogin");
+    }
+  }
+  async disconnect() {
+    let options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {
+      cleanup: false
+    };
+    if (this.status !== base_namespaceObject.ADAPTER_STATUS.CONNECTED) throw base_namespaceObject.WalletLoginError.notConnectedError("Not connected with wallet");
+    if (!this.openloginInstance) throw base_namespaceObject.WalletInitializationError.notReady("openloginInstance is not ready");
+    await this.openloginInstance.logout();
+    if (options.cleanup) {
+      this.status = base_namespaceObject.ADAPTER_STATUS.NOT_READY;
+      this.openloginInstance = null;
+      this.privateKeyProvider = null;
+    } else {
+      // ready to be connected again
+      this.status = base_namespaceObject.ADAPTER_STATUS.READY;
+    }
+    this.rehydrated = false;
+    this.emit(base_namespaceObject.ADAPTER_EVENTS.DISCONNECTED);
+  }
+  async authenticateUser() {
+    if (this.status !== base_namespaceObject.ADAPTER_STATUS.CONNECTED) throw base_namespaceObject.WalletLoginError.notConnectedError("Not connected with wallet, Please login/connect first");
+    const userInfo = await this.getUserInfo();
+    return {
+      idToken: userInfo.idToken
+    };
+  }
+  async getUserInfo() {
+    if (this.status !== base_namespaceObject.ADAPTER_STATUS.CONNECTED) throw base_namespaceObject.WalletLoginError.notConnectedError("Not connected with wallet");
+    if (!this.openloginInstance) throw base_namespaceObject.WalletInitializationError.notReady("openloginInstance is not ready");
+    const userInfo = this.openloginInstance.getUserInfo();
+    return userInfo;
+  }
+
+  // should be called only before initialization.
+  setAdapterSettings(adapterSettings) {
+    super.setAdapterSettings(adapterSettings);
+    const defaultOptions = getOpenloginDefaultOptions();
+    base_namespaceObject.log.info("setting adapter settings", adapterSettings);
+    this.openloginOptions = objectSpread2_default()(objectSpread2_default()(objectSpread2_default()({}, defaultOptions.adapterSettings), this.openloginOptions), adapterSettings);
+    if (adapterSettings.web3AuthNetwork) {
+      this.openloginOptions.network = adapterSettings.web3AuthNetwork;
+    }
+    if (adapterSettings.privateKeyProvider) {
+      this.privateKeyProvider = adapterSettings.privateKeyProvider;
+    }
+  }
+  async addChain(chainConfig) {
+    var _this$privateKeyProvi;
+    let init = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+    super.checkAddChainRequirements(chainConfig, init);
+    (_this$privateKeyProvi = this.privateKeyProvider) === null || _this$privateKeyProvi === void 0 || _this$privateKeyProvi.addChain(chainConfig);
+    this.addChainConfig(chainConfig);
+  }
+  async switchChain(params) {
+    var _this$privateKeyProvi2;
+    let init = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+    super.checkSwitchChainRequirements(params, init);
+    await ((_this$privateKeyProvi2 = this.privateKeyProvider) === null || _this$privateKeyProvi2 === void 0 ? void 0 : _this$privateKeyProvi2.switchChain(params));
+    this.setAdapterSettings({
+      chainConfig: this.getChainConfig(params.chainId)
+    });
+  }
+  _getFinalPrivKey() {
+    if (!this.openloginInstance) return "";
+    let finalPrivKey = this.openloginInstance.privKey;
+    // coreKitKey is available only for custom verifiers by default
+    if (this.useCoreKitKey) {
+      // this is to check if the user has already logged in but coreKitKey is not available.
+      // when useCoreKitKey is set to true.
+      // This is to ensure that when there is no user session active, we don't throw an exception.
+      if (this.openloginInstance.privKey && !this.openloginInstance.coreKitKey) {
+        throw base_namespaceObject.WalletLoginError.coreKitKeyNotFound();
+      }
+      finalPrivKey = this.openloginInstance.coreKitKey;
+    }
+    return finalPrivKey;
+  }
+  _getFinalEd25519PrivKey() {
+    if (!this.openloginInstance) return "";
+    let finalPrivKey = this.openloginInstance.ed25519PrivKey;
+    // coreKitKey is available only for custom verifiers by default
+    if (this.useCoreKitKey) {
+      // this is to check if the user has already logged in but coreKitKey is not available.
+      // when useCoreKitKey is set to true.
+      // This is to ensure that when there is no user session active, we don't throw an exception.
+      if (this.openloginInstance.ed25519PrivKey && !this.openloginInstance.coreKitEd25519Key) {
+        throw base_namespaceObject.WalletLoginError.coreKitKeyNotFound();
+      }
+      finalPrivKey = this.openloginInstance.coreKitEd25519Key;
+    }
+    return finalPrivKey;
+  }
+  async connectWithProvider() {
+    var _params$extraLoginOpt;
+    let params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {
+      loginProvider: ""
+    };
+    if (!this.privateKeyProvider) throw base_namespaceObject.WalletInitializationError.invalidParams("PrivateKey Provider is required before initialization");
+    if (!this.openloginInstance) throw base_namespaceObject.WalletInitializationError.notReady("openloginInstance is not ready");
+    const keyAvailable = this._getFinalPrivKey();
+    // if not logged in then login
+    if (!keyAvailable || (_params$extraLoginOpt = params.extraLoginOptions) !== null && _params$extraLoginOpt !== void 0 && _params$extraLoginOpt.id_token) {
+      var _params$extraLoginOpt2;
+      if (!this.loginSettings.curve) {
+        this.loginSettings.curve = this.currentChainNamespace === base_namespaceObject.CHAIN_NAMESPACES.SOLANA ? openlogin_utils_namespaceObject.SUPPORTED_KEY_CURVES.ED25519 : openlogin_utils_namespaceObject.SUPPORTED_KEY_CURVES.SECP256K1;
+      }
+      if (!params.loginProvider && !this.loginSettings.loginProvider) throw base_namespaceObject.WalletInitializationError.invalidParams("loginProvider is required for login");
+      await this.openloginInstance.login(external_lodash_merge_default()(this.loginSettings, params, {
+        extraLoginOptions: objectSpread2_default()(objectSpread2_default()({}, params.extraLoginOptions || {}), {}, {
+          login_hint: params.login_hint || ((_params$extraLoginOpt2 = params.extraLoginOptions) === null || _params$extraLoginOpt2 === void 0 ? void 0 : _params$extraLoginOpt2.login_hint)
+        })
+      }));
+    }
+    let finalPrivKey = this._getFinalPrivKey();
+    if (finalPrivKey) {
+      if (this.currentChainNamespace === base_namespaceObject.CHAIN_NAMESPACES.SOLANA) {
+        finalPrivKey = this._getFinalEd25519PrivKey();
+      }
+      await this.privateKeyProvider.setupProvider(finalPrivKey);
+      this.status = base_namespaceObject.ADAPTER_STATUS.CONNECTED;
+      this.emit(base_namespaceObject.ADAPTER_EVENTS.CONNECTED, {
+        adapter: base_namespaceObject.WALLET_ADAPTERS.OPENLOGIN,
+        reconnected: this.rehydrated
+      });
+    }
+  }
+}
+
+;// 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: ./src/noModal.ts
 
 
@@ -75,6 +343,9 @@ const base_provider_namespaceObject = require("@web3auth/base-provider");
 
 
 
+
+
+
 const ADAPTER_CACHE_KEY = "Web3Auth-cachedAdapter";
 class Web3AuthNoModal extends openlogin_jrpc_namespaceObject.SafeEventEmitter {
   constructor(options) {
@@ -118,9 +389,13 @@ class Web3AuthNoModal extends openlogin_jrpc_namespaceObject.SafeEventEmitter {
     this.commonJRPCProvider = await base_provider_namespaceObject.CommonJRPCProvider.getProviderInstance({
       chainConfig: this.coreOptions.chainConfig
     });
-    // TODO: get stuff from dashboard here
-    // disable sms login
-    const initPromises = Object.keys(this.walletAdapters).map(adapterName => {
+    let projectConfig;
+    try {
+      projectConfig = await (0,base_namespaceObject.fetchProjectConfig)(this.coreOptions.clientId);
+    } catch (e) {
+      throw base_namespaceObject.WalletInitializationError.notReady("failed to fetch project configurations");
+    }
+    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.
@@ -144,6 +419,25 @@ class Web3AuthNoModal extends openlogin_jrpc_namespaceObject.SafeEventEmitter {
       }
       if (adapterName === base_namespaceObject.WALLET_ADAPTERS.OPENLOGIN) {
         const openloginAdapter = this.walletAdapters[adapterName];
+        const {
+          whitelabel
+        } = projectConfig;
+        this.coreOptions.uiConfig = external_lodash_merge_default()(external_lodash_clonedeep_default()(whitelabel), this.coreOptions.uiConfig);
+        const {
+          sms_otp_enabled: smsOtpEnabled
+        } = projectConfig;
+        if (smsOtpEnabled !== undefined) {
+          openloginAdapter.setAdapterSettings({
+            loginConfig: {
+              [openlogin_utils_namespaceObject.LOGIN_PROVIDER.SMS_PASSWORDLESS]: {
+                showOnModal: smsOtpEnabled,
+                showOnDesktop: smsOtpEnabled,
+                showOnMobile: smsOtpEnabled,
+                showOnSocialBackupFactor: smsOtpEnabled
+              }
+            }
+          });
+        }
         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");
@@ -160,11 +454,18 @@ class Web3AuthNoModal extends openlogin_jrpc_namespaceObject.SafeEventEmitter {
         }
       } else if (adapterName === base_namespaceObject.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 base_namespaceObject.WalletInitializationError.invalidParams("Please enable wallet connect v2 addon on dashboard");
+        }
+        if (!walletConnectProjectId) throw base_namespaceObject.WalletInitializationError.invalidParams("Invalid wallet connect project id. Please configure it on the dashboard");
         walletConnectAdapter.setAdapterSettings({
           adapterSettings: {
             walletConnectInitOptions: {
-              // Using a default wallet connect project id for web3auth modal integration
-              projectId: "d3c63f19f9582f8ba48e982057eb096b" // TODO: get from dashboard
+              projectId: walletConnectProjectId
             }
           }
         });
@@ -173,8 +474,8 @@ class Web3AuthNoModal extends openlogin_jrpc_namespaceObject.SafeEventEmitter {
         autoConnect: this.cachedAdapter === adapterName
       }).catch(e => base_namespaceObject.log.error(e));
     });
-    this.status = base_namespaceObject.ADAPTER_STATUS.READY;
     await Promise.all(initPromises);
+    this.status = base_namespaceObject.ADAPTER_STATUS.READY;
   }
   getAdapter(adapterName) {
     return this.walletAdapters[adapterName] || null;
@@ -340,5 +641,4 @@ class Web3AuthNoModal extends openlogin_jrpc_namespaceObject.SafeEventEmitter {
 
 module.exports = __webpack_exports__;
 /******/ })()
-;
-//# sourceMappingURL=noModal.cjs.js.map
+;

package/dist/noModal.esm.js

@@ -1,9 +1,12 @@
 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, WALLET_ADAPTERS, ADAPTER_NAMESPACES, WalletLoginError, ADAPTER_EVENTS } from '@web3auth/base';
+import { ADAPTER_STATUS, WalletInitializationError, log, CHAIN_NAMESPACES, storageAvailable, getChainConfig, fetchProjectConfig, WALLET_ADAPTERS, ADAPTER_NAMESPACES, WalletLoginError, ADAPTER_EVENTS } from '@web3auth/base';
 import { PLUGIN_NAMESPACES } from '@web3auth/base-plugin';
 import { CommonJRPCProvider } from '@web3auth/base-provider';
+import { LOGIN_PROVIDER } from '@web3auth/openlogin-adapter';
+import clonedeep from 'lodash.clonedeep';
+import merge from 'lodash.merge';
 
 const ADAPTER_CACHE_KEY = "Web3Auth-cachedAdapter";
 class Web3AuthNoModal extends SafeEventEmitter {
@@ -48,9 +51,13 @@ class Web3AuthNoModal extends SafeEventEmitter {
     this.commonJRPCProvider = await CommonJRPCProvider.getProviderInstance({
       chainConfig: this.coreOptions.chainConfig
     });
-    // TODO: get stuff from dashboard here
-    // disable sms login
-    const initPromises = Object.keys(this.walletAdapters).map(adapterName => {
+    let projectConfig;
+    try {
+      projectConfig = await fetchProjectConfig(this.coreOptions.clientId);
+    } catch (e) {
+      throw WalletInitializationError.notReady("failed to fetch project configurations");
+    }
+    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.
@@ -74,6 +81,25 @@ class Web3AuthNoModal extends SafeEventEmitter {
       }
       if (adapterName === WALLET_ADAPTERS.OPENLOGIN) {
         const openloginAdapter = this.walletAdapters[adapterName];
+        const {
+          whitelabel
+        } = projectConfig;
+        this.coreOptions.uiConfig = merge(clonedeep(whitelabel), this.coreOptions.uiConfig);
+        const {
+          sms_otp_enabled: smsOtpEnabled
+        } = projectConfig;
+        if (smsOtpEnabled !== undefined) {
+          openloginAdapter.setAdapterSettings({
+            loginConfig: {
+              [LOGIN_PROVIDER.SMS_PASSWORDLESS]: {
+                showOnModal: smsOtpEnabled,
+                showOnDesktop: smsOtpEnabled,
+                showOnMobile: smsOtpEnabled,
+                showOnSocialBackupFactor: smsOtpEnabled
+              }
+            }
+          });
+        }
         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");
@@ -90,11 +116,18 @@ class Web3AuthNoModal extends SafeEventEmitter {
         }
       } 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: {
-              // Using a default wallet connect project id for web3auth modal integration
-              projectId: "d3c63f19f9582f8ba48e982057eb096b" // TODO: get from dashboard
+              projectId: walletConnectProjectId
             }
           }
         });
@@ -103,8 +136,8 @@ class Web3AuthNoModal extends SafeEventEmitter {
         autoConnect: this.cachedAdapter === adapterName
       }).catch(e => log.error(e));
     });
-    this.status = ADAPTER_STATUS.READY;
     await Promise.all(initPromises);
+    this.status = ADAPTER_STATUS.READY;
   }
   getAdapter(adapterName) {
     return this.walletAdapters[adapterName] || null;
@@ -268,4 +301,3 @@ class Web3AuthNoModal extends SafeEventEmitter {
 }
 
 export { Web3AuthNoModal };
-//# sourceMappingURL=noModal.esm.js.map