@web3auth/modal 9.7.0 → 10.0.0-alpha.1

package/dist/lib.cjs/node_modules/style-inject/dist/style-inject.es.js

@@ -0,0 +1,28 @@
+'use strict';
+
+function styleInject(css, ref) {
+  if (ref === void 0) ref = {};
+  var insertAt = ref.insertAt;
+  if (!css || typeof document === 'undefined') {
+    return;
+  }
+  var head = document.head || document.getElementsByTagName('head')[0];
+  var style = document.createElement('style');
+  style.type = 'text/css';
+  if (insertAt === 'top') {
+    if (head.firstChild) {
+      head.insertBefore(style, head.firstChild);
+    } else {
+      head.appendChild(style);
+    }
+  } else {
+    head.appendChild(style);
+  }
+  if (style.styleSheet) {
+    style.styleSheet.cssText = css;
+  } else {
+    style.appendChild(document.createTextNode(css));
+  }
+}
+
+module.exports = styleInject;

package/dist/lib.cjs/{config.js → packages/modal/src/config.js}

@@ -1,17 +1,11 @@
 'use strict';
 
-var base = require('@web3auth/base');
+var noModal = require('@web3auth/no-modal');
 
 const defaultSolanaDappModalConfig = {
-  chainNamespace: base.CHAIN_NAMESPACES.SOLANA,
-  adapters: {
-    [base.SOLANA_ADAPTERS.TORUS_SOLANA]: {
-      label: "Torus Wallet",
-      showOnModal: true,
-      showOnMobile: true,
-      showOnDesktop: true
-    },
-    [base.SOLANA_ADAPTERS.AUTH]: {
+  chainNamespace: noModal.CHAIN_NAMESPACES.SOLANA,
+  connectors: {
+    [noModal.SOLANA_CONNECTORS.AUTH]: {
       label: "Auth",
       showOnModal: true,
       showOnMobile: true,
@@ -20,21 +14,15 @@ const defaultSolanaDappModalConfig = {
   }
 };
 const defaultEvmDappModalConfig = {
-  chainNamespace: base.CHAIN_NAMESPACES.EIP155,
-  adapters: {
-    [base.EVM_ADAPTERS.TORUS_EVM]: {
-      label: "Torus Wallet",
-      showOnModal: true,
-      showOnMobile: true,
-      showOnDesktop: true
-    },
-    [base.EVM_ADAPTERS.AUTH]: {
+  chainNamespace: noModal.CHAIN_NAMESPACES.EIP155,
+  connectors: {
+    [noModal.EVM_CONNECTORS.AUTH]: {
       label: "Auth",
       showOnModal: true,
       showOnMobile: true,
       showOnDesktop: true
     },
-    [base.EVM_ADAPTERS.WALLET_CONNECT_V2]: {
+    [noModal.EVM_CONNECTORS.WALLET_CONNECT_V2]: {
       label: "Wallet Connect",
       showOnModal: true,
       showOnMobile: true,
@@ -43,9 +31,9 @@ const defaultEvmDappModalConfig = {
   }
 };
 const defaultSolanaWalletModalConfig = {
-  chainNamespace: base.CHAIN_NAMESPACES.SOLANA,
-  adapters: {
-    [base.SOLANA_ADAPTERS.AUTH]: {
+  chainNamespace: noModal.CHAIN_NAMESPACES.SOLANA,
+  connectors: {
+    [noModal.SOLANA_CONNECTORS.AUTH]: {
       label: "Auth",
       showOnModal: true,
       showOnMobile: true,
@@ -54,9 +42,9 @@ const defaultSolanaWalletModalConfig = {
   }
 };
 const defaultEvmWalletModalConfig = {
-  chainNamespace: base.CHAIN_NAMESPACES.EIP155,
-  adapters: {
-    [base.EVM_ADAPTERS.AUTH]: {
+  chainNamespace: noModal.CHAIN_NAMESPACES.EIP155,
+  connectors: {
+    [noModal.EVM_CONNECTORS.AUTH]: {
       label: "Auth",
       showOnModal: true,
       showOnMobile: true,
@@ -65,9 +53,9 @@ const defaultEvmWalletModalConfig = {
   }
 };
 const defaultOtherModalConfig = {
-  chainNamespace: base.CHAIN_NAMESPACES.OTHER,
-  adapters: {
-    [base.EVM_ADAPTERS.AUTH]: {
+  chainNamespace: noModal.CHAIN_NAMESPACES.OTHER,
+  connectors: {
+    [noModal.EVM_CONNECTORS.AUTH]: {
       label: "Auth",
       showOnModal: true,
       showOnMobile: true,

package/dist/lib.cjs/{index.js → packages/modal/src/index.js}

@@ -2,6 +2,7 @@
 
 var config = require('./config.js');
 var modalManager = require('./modalManager.js');
+var noModal = require('@web3auth/no-modal');
 
 
 
@@ -12,3 +13,9 @@ exports.defaultSolanaDappModalConfig = config.defaultSolanaDappModalConfig;
 exports.defaultSolanaWalletModalConfig = config.defaultSolanaWalletModalConfig;
 exports.walletRegistryUrl = config.walletRegistryUrl;
 exports.Web3Auth = modalManager.Web3Auth;
+Object.keys(noModal).forEach(function (k) {
+	if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+		enumerable: true,
+		get: function () { return noModal[k]; }
+	});
+});

package/dist/lib.cjs/packages/modal/src/modalManager.js

@@ -0,0 +1,376 @@
+'use strict';
+
+var _objectSpread = require('@babel/runtime/helpers/objectSpread2');
+var _defineProperty = require('@babel/runtime/helpers/defineProperty');
+var noModal = require('@web3auth/no-modal');
+var deepmerge = require('deepmerge');
+var config = require('./config.js');
+var config$1 = require('./ui/config.js');
+var interfaces = require('./ui/interfaces.js');
+var loginModal = require('./ui/loginModal.js');
+var utils = require('./ui/utils.js');
+
+class Web3Auth extends noModal.Web3AuthNoModal {
+  constructor(options) {
+    super(options);
+    _defineProperty(this, "loginModal", void 0);
+    _defineProperty(this, "options", void 0);
+    _defineProperty(this, "modalConfig", noModal.cloneDeep(config.defaultOtherModalConfig));
+    this.options = _objectSpread({}, options);
+    if (!this.options.uiConfig) this.options.uiConfig = {};
+  }
+  setModalConfig(modalConfig) {
+    super.checkInitRequirements();
+    this.modalConfig = modalConfig;
+  }
+  async initModal(params) {
+    super.checkInitRequirements();
+    super.initCachedConnectorAndChainId();
+    // get project config and wallet registry
+    const {
+      projectConfig,
+      walletRegistry
+    } = await this.getProjectAndWalletConfig(params);
+    this.options.uiConfig = deepmerge(noModal.cloneDeep(projectConfig.whitelabel || {}), this.options.uiConfig || {});
+    if (!this.options.uiConfig.defaultLanguage) this.options.uiConfig.defaultLanguage = utils.getUserLanguage(this.options.uiConfig.defaultLanguage);
+    if (!this.options.uiConfig.mode) this.options.uiConfig.mode = "light";
+
+    // init login modal
+    this.loginModal = new loginModal.LoginModal(_objectSpread(_objectSpread({}, this.options.uiConfig), {}, {
+      connectorListener: this,
+      chainNamespace: this.currentChain.chainNamespace,
+      walletRegistry
+    }));
+    this.subscribeToLoginModalEvents();
+    await this.loginModal.initModal();
+
+    // setup common JRPC provider
+    await this.setupCommonJRPCProvider();
+
+    // initialize connectors
+    this.on(noModal.CONNECTOR_EVENTS.CONNECTORS_UPDATED, ({
+      connectors: newConnectors
+    }) => this.initConnectors({
+      connectors: newConnectors,
+      projectConfig,
+      modalConfig: params
+    }));
+    await this.loadConnectors({
+      projectConfig
+    });
+
+    // initialize plugins
+    await this.initPlugins();
+  }
+  async connect() {
+    if (!this.loginModal) throw noModal.WalletInitializationError.notReady("Login modal is not initialized");
+    // if already connected return provider
+    if (this.connectedConnectorName && this.status === noModal.CONNECTOR_STATUS.CONNECTED && this.provider) return this.provider;
+    this.loginModal.open();
+    return new Promise((resolve, reject) => {
+      this.once(noModal.CONNECTOR_EVENTS.CONNECTED, () => {
+        return resolve(this.provider);
+      });
+      this.once(noModal.CONNECTOR_EVENTS.ERRORED, err => {
+        return reject(err);
+      });
+      this.once(interfaces.LOGIN_MODAL_EVENTS.MODAL_VISIBILITY, visibility => {
+        // modal is closed but user is not connected to any wallet.
+        if (!visibility && this.status !== noModal.CONNECTOR_STATUS.CONNECTED) {
+          return reject(new Error("User closed the modal"));
+        }
+      });
+    });
+  }
+  async getProjectAndWalletConfig(params) {
+    // get project config
+    let projectConfig;
+    try {
+      var _this$options$account;
+      projectConfig = await noModal.fetchProjectConfig(this.options.clientId, this.options.web3AuthNetwork, (_this$options$account = this.options.accountAbstractionConfig) === null || _this$options$account === void 0 ? void 0 : _this$options$account.smartAccountType);
+    } catch (e) {
+      noModal.log.error("Failed to fetch project configurations", e);
+      throw noModal.WalletInitializationError.notReady("failed to fetch project configurations", e);
+    }
+
+    // get wallet registry
+    let walletRegistry = {
+      others: {},
+      default: {}
+    };
+    if (!(params !== null && params !== void 0 && params.hideWalletDiscovery)) {
+      try {
+        walletRegistry = await noModal.fetchWalletRegistry(config.walletRegistryUrl);
+      } catch (e) {
+        noModal.log.error("Failed to fetch wallet registry", e);
+      }
+    }
+    return {
+      projectConfig,
+      walletRegistry
+    };
+  }
+  async initConnectors({
+    connectors,
+    projectConfig,
+    modalConfig
+  }) {
+    // filter connectors based on config
+    const filteredConnectorNames = await this.filterConnectors(modalConfig, projectConfig);
+
+    // initialize connectors based on availability
+    const {
+      hasInAppConnectors,
+      hasExternalConnectors
+    } = await this.checkConnectorAvailability(filteredConnectorNames, modalConfig);
+    if (hasInAppConnectors) {
+      await this.initInAppAndCachedConnectors(connectors, filteredConnectorNames);
+      // show connect button if external wallets are available
+      if (hasExternalConnectors) this.loginModal.initExternalWalletContainer();
+    } else if (hasExternalConnectors) {
+      // if no in app wallet is available then initialize external wallets in modal
+      await this.initExternalConnectors(connectors, false, {
+        showExternalWalletsOnly: true
+      });
+    }
+
+    // emit ready event if connector is ready
+    if (this.status === noModal.CONNECTOR_STATUS.NOT_READY) {
+      this.status = noModal.CONNECTOR_STATUS.READY;
+      this.emit(noModal.CONNECTOR_EVENTS.READY);
+    }
+  }
+  async filterConnectors(params, projectConfig) {
+    // update auth connector config
+    const {
+      sms_otp_enabled: smsOtpEnabled
+    } = projectConfig;
+    if (smsOtpEnabled !== undefined) {
+      var _params, _params$modalConfig$W;
+      // TODO: use the new login config method
+      const connectorConfig = {
+        [noModal.WALLET_CONNECTORS.AUTH]: {
+          label: noModal.WALLET_CONNECTORS.AUTH,
+          loginMethods: {
+            [noModal.LOGIN_PROVIDER.SMS_PASSWORDLESS]: {
+              name: noModal.LOGIN_PROVIDER.SMS_PASSWORDLESS,
+              showOnModal: smsOtpEnabled,
+              showOnDesktop: smsOtpEnabled,
+              showOnMobile: smsOtpEnabled
+            }
+          }
+        }
+      };
+      if (!((_params = params) !== null && _params !== void 0 && _params.modalConfig)) params = {
+        modalConfig: {}
+      };
+      const localSmsOtpEnabled = (_params$modalConfig$W = params.modalConfig[noModal.WALLET_CONNECTORS.AUTH]) === null || _params$modalConfig$W === void 0 || (_params$modalConfig$W = _params$modalConfig$W.loginMethods) === null || _params$modalConfig$W === void 0 || (_params$modalConfig$W = _params$modalConfig$W[noModal.LOGIN_PROVIDER.SMS_PASSWORDLESS]) === null || _params$modalConfig$W === void 0 ? void 0 : _params$modalConfig$W.showOnModal;
+      if (localSmsOtpEnabled === true && smsOtpEnabled === false) {
+        throw noModal.WalletInitializationError.invalidParams("must enable sms otp on dashboard in order to utilise it");
+      }
+      params.modalConfig = deepmerge(connectorConfig, noModal.cloneDeep(params.modalConfig));
+    }
+
+    // merge default connectors with the custom configured connectors.
+    const allConnectorNames = [...new Set([...Object.keys(this.modalConfig.connectors || {}), ...this.connectors.map(connector => connector.name)])];
+    const connectorConfigurationPromises = allConnectorNames.map(async connectorName => {
+      var _this$modalConfig$con, _params2, _this$modalConfig$con2, _this$modalConfig$con3;
+      // start with the default config of connector.
+      let connectorConfig = ((_this$modalConfig$con = this.modalConfig.connectors) === null || _this$modalConfig$con === void 0 ? void 0 : _this$modalConfig$con[connectorName]) || {
+        label: noModal.CONNECTOR_NAMES[connectorName] || connectorName.split("-").map(config$1.capitalizeFirstLetter).join(" "),
+        showOnModal: true,
+        showOnMobile: true,
+        showOnDesktop: true
+      };
+      // override the default config of connector if some config is being provided by the user.
+      if ((_params2 = params) !== null && _params2 !== void 0 && (_params2 = _params2.modalConfig) !== null && _params2 !== void 0 && _params2[connectorName]) {
+        connectorConfig = _objectSpread(_objectSpread({}, connectorConfig), params.modalConfig[connectorName]);
+      }
+      this.modalConfig.connectors[connectorName] = connectorConfig;
+
+      // check if connector is configured/added by user and exist in connectors map.
+      const connector = this.getConnector(connectorName);
+      noModal.log.debug("connector config", connectorName, (_this$modalConfig$con2 = this.modalConfig.connectors) === null || _this$modalConfig$con2 === void 0 ? void 0 : _this$modalConfig$con2[connectorName].showOnModal, connector);
+
+      // if connector is not custom configured then check if it is available in default connectors.
+      // and if connector is not hidden by user
+      if (!connector && (_this$modalConfig$con3 = this.modalConfig.connectors) !== null && _this$modalConfig$con3 !== void 0 && _this$modalConfig$con3[connectorName].showOnModal) {
+        throw noModal.WalletInitializationError.invalidParams(`Connector ${connectorName} is not configured`);
+      } else if ((connector === null || connector === void 0 ? void 0 : connector.type) === noModal.CONNECTOR_CATEGORY.IN_APP || (connector === null || connector === void 0 ? void 0 : connector.type) === noModal.CONNECTOR_CATEGORY.EXTERNAL || connectorName === this.cachedConnector) {
+        var _this$modalConfig$con4;
+        if (!((_this$modalConfig$con4 = this.modalConfig.connectors) !== null && _this$modalConfig$con4 !== void 0 && _this$modalConfig$con4[connectorName].showOnModal)) return;
+        if (connectorName === noModal.WALLET_CONNECTORS.WALLET_CONNECT_V2) {
+          const {
+            wallet_connect_enabled: walletConnectEnabled
+          } = projectConfig;
+          if (walletConnectEnabled === false) {
+            var _this$modalConfig$con5, _this$modalConfig$con6, _this$modalConfig$con7;
+            // override user specified config by hiding wallet connect
+            this.modalConfig.connectors = _objectSpread(_objectSpread({}, (_this$modalConfig$con5 = this.modalConfig.connectors) !== null && _this$modalConfig$con5 !== void 0 ? _this$modalConfig$con5 : {}), {}, {
+              [noModal.WALLET_CONNECTORS.WALLET_CONNECT_V2]: _objectSpread(_objectSpread({}, (_this$modalConfig$con6 = (_this$modalConfig$con7 = this.modalConfig.connectors) === null || _this$modalConfig$con7 === void 0 ? void 0 : _this$modalConfig$con7[noModal.WALLET_CONNECTORS.WALLET_CONNECT_V2]) !== null && _this$modalConfig$con6 !== void 0 ? _this$modalConfig$con6 : {}), {}, {
+                showOnModal: false
+              })
+            });
+            this.modalConfig.connectors[noModal.WALLET_CONNECTORS.WALLET_CONNECT_V2].showOnModal = false;
+          }
+        }
+        return connectorName;
+      }
+    });
+    const connectorNames = await Promise.all(connectorConfigurationPromises);
+    return connectorNames.filter(name => name !== undefined);
+  }
+  async checkConnectorAvailability(connectorNames, modalConfig) {
+    // currently all default in app and external wallets can be hidden or shown based on config.
+    // check if in app connectors are available
+    const hasInAppConnectors = this.connectors.some(connector => {
+      var _this$modalConfig$con8, _this$modalConfig$con9, _connector$name;
+      if (connector.type !== noModal.CONNECTOR_CATEGORY.IN_APP) return false;
+      if (((_this$modalConfig$con8 = this.modalConfig.connectors) === null || _this$modalConfig$con8 === void 0 || (_this$modalConfig$con8 = _this$modalConfig$con8[connector.name]) === null || _this$modalConfig$con8 === void 0 ? void 0 : _this$modalConfig$con8.showOnModal) !== true) return false;
+      if (!((_this$modalConfig$con9 = this.modalConfig.connectors) !== null && _this$modalConfig$con9 !== void 0 && (_this$modalConfig$con9 = _this$modalConfig$con9[connector.name]) !== null && _this$modalConfig$con9 !== void 0 && _this$modalConfig$con9.loginMethods)) return true;
+      const mergedLoginMethods = utils.getConnectorSocialLogins(connector.name, (_connector$name = this.modalConfig.connectors[connector.name]) === null || _connector$name === void 0 ? void 0 : _connector$name.loginMethods);
+      if (Object.values(mergedLoginMethods).some(method => method.showOnModal)) return true;
+      return false;
+    });
+    noModal.log.debug(hasInAppConnectors, this.connectors, connectorNames, "hasInAppWallets");
+
+    // check if external connectors are available
+    const hasExternalConnectors = connectorNames.some(connectorName => {
+      var _this$getConnector, _this$modalConfig$con10;
+      // if wallet connect connector is available but hideWalletDiscovery is true then don't consider it as external wallet
+      if (connectorName === noModal.WALLET_CONNECTORS.WALLET_CONNECT_V2 && modalConfig !== null && modalConfig !== void 0 && modalConfig.hideWalletDiscovery) return false;
+      return ((_this$getConnector = this.getConnector(connectorName)) === null || _this$getConnector === void 0 ? void 0 : _this$getConnector.type) === noModal.CONNECTOR_CATEGORY.EXTERNAL && ((_this$modalConfig$con10 = this.modalConfig.connectors) === null || _this$modalConfig$con10 === void 0 ? void 0 : _this$modalConfig$con10[connectorName].showOnModal);
+    });
+    return {
+      hasInAppConnectors,
+      hasExternalConnectors
+    };
+  }
+  async initInAppAndCachedConnectors(connectors, connectorNames) {
+    await Promise.all(connectorNames.map(async connectorName => {
+      const connector = connectors.find(x => x.name === connectorName);
+      if (!connector) return;
+      try {
+        // skip if connector is already initialized
+        if (connector.status !== noModal.CONNECTOR_STATUS.NOT_READY) return;
+
+        // only initialize a external connectors here if it is a cached connector.
+        if (this.cachedConnector !== connectorName && connector.type === noModal.CONNECTOR_CATEGORY.EXTERNAL) return;
+
+        // in-app wallets or cached wallet (being connected or already connected) are initialized first.
+        // if connector is configured then only initialize in app or cached connector.
+        // external wallets are initialized on INIT_EXTERNAL_WALLET event.
+        this.subscribeToConnectorEvents(connector);
+        const initialChain = this.getInitialChainIdForConnector(connector);
+        await connector.init({
+          autoConnect: this.cachedConnector === connectorName,
+          chainId: initialChain.chainId
+        });
+
+        // note: not adding cachedWallet to modal if it is external wallet.
+        // adding it later if no in-app wallets are available.
+        if (connector.type === noModal.CONNECTOR_CATEGORY.IN_APP) {
+          var _connectorName, _this$options$uiConfi, _this$options$uiConfi2, _this$options$uiConfi3;
+          noModal.log.info("connectorInitResults", connectorName);
+          const loginMethods = utils.getConnectorSocialLogins(connectorName, (_connectorName = this.modalConfig.connectors[connectorName]) === null || _connectorName === void 0 ? void 0 : _connectorName.loginMethods);
+          this.loginModal.addSocialLogins(connectorName, loginMethods, ((_this$options$uiConfi = this.options.uiConfig) === null || _this$options$uiConfi === void 0 ? void 0 : _this$options$uiConfi.loginMethodsOrder) || config$1.AUTH_PROVIDERS, _objectSpread(_objectSpread({}, this.options.uiConfig), {}, {
+            loginGridCol: ((_this$options$uiConfi2 = this.options.uiConfig) === null || _this$options$uiConfi2 === void 0 ? void 0 : _this$options$uiConfi2.loginGridCol) || 3,
+            primaryButton: ((_this$options$uiConfi3 = this.options.uiConfig) === null || _this$options$uiConfi3 === void 0 ? void 0 : _this$options$uiConfi3.primaryButton) || "socialLogin"
+          }));
+        }
+      } catch (error) {
+        noModal.log.error(error, "error while initializing connector ", connectorName);
+      }
+    }));
+  }
+  async initExternalConnectors(connectors, externalWalletsInitialized, options) {
+    if (externalWalletsInitialized) return;
+    const connectorsConfig = {};
+    // we do it like this because we don't want one slow connector to delay the load of the entire external wallet section.
+    connectors.forEach(async connector => {
+      const connectorName = connector.name;
+      if ((connector === null || connector === void 0 ? void 0 : connector.type) === noModal.CONNECTOR_CATEGORY.EXTERNAL) {
+        noModal.log.debug("init external wallet", this.cachedConnector, connectorName, connector.status);
+        this.subscribeToConnectorEvents(connector);
+        // we are not initializing cached connector here as it is already being initialized in initModal before.
+        if (this.cachedConnector === connectorName) {
+          return;
+        }
+        if (connector.status === noModal.CONNECTOR_STATUS.NOT_READY) {
+          try {
+            const initialChain = this.getInitialChainIdForConnector(connector);
+            await connector.init({
+              autoConnect: this.cachedConnector === connectorName,
+              chainId: initialChain.chainId
+            });
+            const connectorModalConfig = this.modalConfig.connectors[connectorName];
+            connectorsConfig[connectorName] = _objectSpread(_objectSpread({}, connectorModalConfig), {}, {
+              isInjected: connector.isInjected
+            });
+            this.loginModal.addWalletLogins(connectorsConfig, {
+              showExternalWalletsOnly: !!(options !== null && options !== void 0 && options.showExternalWalletsOnly)
+            });
+          } catch (error) {
+            noModal.log.error(error, "error while initializing connector", connectorName);
+          }
+        } else if (connector.status === noModal.CONNECTOR_STATUS.READY || connector.status === noModal.CONNECTOR_STATUS.CONNECTING) {
+          // we use connecting status for wallet connect
+          const connectorModalConfig = this.modalConfig.connectors[connectorName];
+          connectorsConfig[connectorName] = _objectSpread(_objectSpread({}, connectorModalConfig), {}, {
+            isInjected: connector.isInjected
+          });
+          this.loginModal.addWalletLogins(connectorsConfig, {
+            showExternalWalletsOnly: !!(options !== null && options !== void 0 && options.showExternalWalletsOnly)
+          });
+        }
+      }
+    });
+  }
+  subscribeToLoginModalEvents() {
+    this.loginModal.on(interfaces.LOGIN_MODAL_EVENTS.LOGIN, async params => {
+      try {
+        await this.connectTo(params.connector, params.loginParams);
+      } catch (error) {
+        noModal.log.error(`Error while connecting to connector: ${params.connector}`, error);
+      }
+    });
+    this.loginModal.on(interfaces.LOGIN_MODAL_EVENTS.INIT_EXTERNAL_WALLETS, async params => {
+      await this.initExternalConnectors(this.connectors, params.externalWalletsInitialized);
+    });
+    this.loginModal.on(interfaces.LOGIN_MODAL_EVENTS.DISCONNECT, async () => {
+      try {
+        await this.logout();
+      } catch (error) {
+        noModal.log.error(`Error while disconnecting`, error);
+      }
+    });
+    this.loginModal.on(interfaces.LOGIN_MODAL_EVENTS.MODAL_VISIBILITY, async visibility => {
+      noModal.log.debug("is login modal visible", visibility);
+      this.emit(interfaces.LOGIN_MODAL_EVENTS.MODAL_VISIBILITY, visibility);
+      const wcConnector = this.getConnector(noModal.WALLET_CONNECTORS.WALLET_CONNECT_V2);
+      if (wcConnector) {
+        const walletConnectStatus = wcConnector === null || wcConnector === void 0 ? void 0 : wcConnector.status;
+        noModal.log.debug("trying refreshing wc session", visibility, walletConnectStatus);
+        if (visibility && (walletConnectStatus === noModal.CONNECTOR_STATUS.READY || walletConnectStatus === noModal.CONNECTOR_STATUS.CONNECTING)) {
+          noModal.log.debug("refreshing wc session");
+
+          // refreshing session for wallet connect whenever modal is opened.
+          try {
+            const initialChain = this.getInitialChainIdForConnector(wcConnector);
+            wcConnector.connect({
+              chainId: initialChain.chainId
+            });
+          } catch (error) {
+            noModal.log.error(`Error while disconnecting to wallet connect in core`, error);
+          }
+        }
+        if (!visibility && this.status === noModal.CONNECTOR_STATUS.CONNECTED && (walletConnectStatus === noModal.CONNECTOR_STATUS.READY || walletConnectStatus === noModal.CONNECTOR_STATUS.CONNECTING)) {
+          noModal.log.debug("this stops wc connector from trying to reconnect once proposal expires");
+          wcConnector.status = noModal.CONNECTOR_STATUS.READY;
+        }
+      }
+    });
+  }
+}
+
+exports.Web3Auth = Web3Auth;

package/dist/lib.cjs/packages/modal/src/react/Web3AuthProvider.js

@@ -0,0 +1,15 @@
+'use strict';
+
+var React = require('react');
+var Web3AuthInnerContext = require('./context/Web3AuthInnerContext.js');
+
+function Web3AuthProvider({
+  config,
+  children
+}) {
+  return /*#__PURE__*/React.createElement(Web3AuthInnerContext.Web3AuthInnerProvider, {
+    config
+  }, children);
+}
+
+exports.Web3AuthProvider = Web3AuthProvider;