@web3auth/modal 9.6.0 → 10.0.0-alpha.0

package/dist/lib.esm/packages/modal/src/ui/loginModal.js

@@ -0,0 +1,307 @@
+import _defineProperty from '@babel/runtime/helpers/defineProperty';
+import './css/web3auth.css.js';
+import { SafeEventEmitter, LANGUAGES, applyWhiteLabelTheme } from '@web3auth/auth';
+import { log, WALLET_ADAPTERS, ADAPTER_EVENTS } from '@web3auth/no-modal';
+import { createRoot } from 'react-dom/client';
+import Modal from './components/Modal.js';
+import { ThemedContext } from './context/ThemeContext.js';
+import { MODAL_STATUS, LOGIN_MODAL_EVENTS, DEFAULT_LOGO_DARK, DEFAULT_LOGO_LIGHT } from './interfaces.js';
+import i18nInstance from './localeImport.js';
+import { getUserLanguage } from './utils.js';
+import { jsx } from 'react/jsx-runtime';
+
+function createWrapper(parentZIndex) {
+  const existingWrapper = document.getElementById("w3a-parent-container");
+  if (existingWrapper) existingWrapper.remove();
+  const parent = document.createElement("section");
+  parent.classList.add("w3a-parent-container");
+  parent.setAttribute("id", "w3a-parent-container");
+  parent.style.zIndex = parentZIndex;
+  parent.style.position = "relative";
+  const wrapper = document.createElement("section");
+  wrapper.setAttribute("id", "w3a-container");
+  parent.appendChild(wrapper);
+  document.body.appendChild(parent);
+  return wrapper;
+}
+class LoginModal extends SafeEventEmitter {
+  constructor(_uiConfig) {
+    super();
+    _defineProperty(this, "uiConfig", void 0);
+    _defineProperty(this, "stateEmitter", void 0);
+    _defineProperty(this, "chainNamespace", void 0);
+    _defineProperty(this, "walletRegistry", void 0);
+    _defineProperty(this, "initModal", async () => {
+      const darkState = {
+        isDark: this.isDark
+      };
+      const useLang = this.uiConfig.defaultLanguage || LANGUAGES.en;
+
+      // Load new language resource
+
+      if (useLang === LANGUAGES.de) {
+        import('./i18n/german.json.js').then(messages => {
+          i18nInstance.addResourceBundle(useLang, "translation", messages.default);
+          return i18nInstance.changeLanguage(useLang);
+        }).catch(error => {
+          log.error(error);
+        });
+      } else if (useLang === LANGUAGES.ja) {
+        import('./i18n/japanese.json.js').then(messages => {
+          i18nInstance.addResourceBundle(useLang, "translation", messages.default);
+          return i18nInstance.changeLanguage(useLang);
+        }).catch(error => {
+          log.error(error);
+        });
+      } else if (useLang === LANGUAGES.ko) {
+        import('./i18n/korean.json.js').then(messages => {
+          i18nInstance.addResourceBundle(useLang, "translation", messages.default);
+          return i18nInstance.changeLanguage(useLang);
+        }).catch(error => {
+          log.error(error);
+        });
+      } else if (useLang === LANGUAGES.zh) {
+        import('./i18n/mandarin.json.js').then(messages => {
+          i18nInstance.addResourceBundle(useLang, "translation", messages.default);
+          return i18nInstance.changeLanguage(useLang);
+        }).catch(error => {
+          log.error(error);
+        });
+      } else if (useLang === LANGUAGES.es) {
+        import('./i18n/spanish.json.js').then(messages => {
+          i18nInstance.addResourceBundle(useLang, "translation", messages.default);
+          return i18nInstance.changeLanguage(useLang);
+        }).catch(error => {
+          log.error(error);
+        });
+      } else if (useLang === LANGUAGES.fr) {
+        import('./i18n/french.json.js').then(messages => {
+          i18nInstance.addResourceBundle(useLang, "translation", messages.default);
+          return i18nInstance.changeLanguage(useLang);
+        }).catch(error => {
+          log.error(error);
+        });
+      } else if (useLang === LANGUAGES.pt) {
+        import('./i18n/portuguese.json.js').then(messages => {
+          i18nInstance.addResourceBundle(useLang, "translation", messages.default);
+          return i18nInstance.changeLanguage(useLang);
+        }).catch(error => {
+          log.error(error);
+        });
+      } else if (useLang === LANGUAGES.nl) {
+        import('./i18n/dutch.json.js').then(messages => {
+          i18nInstance.addResourceBundle(useLang, "translation", messages.default);
+          return i18nInstance.changeLanguage(useLang);
+        }).catch(error => {
+          log.error(error);
+        });
+      } else if (useLang === LANGUAGES.tr) {
+        import('./i18n/turkish.json.js').then(messages => {
+          i18nInstance.addResourceBundle(useLang, "translation", messages.default);
+          return i18nInstance.changeLanguage(useLang);
+        }).catch(error => {
+          log.error(error);
+        });
+      } else if (useLang === LANGUAGES.en) {
+        import('./i18n/english.json.js').then(messages => {
+          i18nInstance.addResourceBundle(useLang, "translation", messages.default);
+          return i18nInstance.changeLanguage(useLang);
+        }).catch(error => {
+          log.error(error);
+        });
+      }
+      return new Promise(resolve => {
+        var _this$uiConfig;
+        this.stateEmitter.once("MOUNTED", () => {
+          log.info("rendered");
+          this.setState({
+            status: MODAL_STATUS.INITIALIZED
+          });
+          return resolve();
+        });
+        const container = createWrapper(this.uiConfig.modalZIndex);
+        if (darkState.isDark) {
+          container.classList.add("w3a--dark");
+        } else {
+          container.classList.remove("w3a--dark");
+        }
+        const root = createRoot(container);
+        root.render(/*#__PURE__*/jsx(ThemedContext.Provider, {
+          value: darkState,
+          children: /*#__PURE__*/jsx(Modal, {
+            closeModal: this.closeModal,
+            stateListener: this.stateEmitter,
+            handleShowExternalWallets: this.handleShowExternalWallets,
+            handleExternalWalletClick: this.handleExternalWalletClick,
+            handleSocialLoginClick: this.handleSocialLoginClick,
+            appLogo: darkState.isDark ? this.uiConfig.logoDark : this.uiConfig.logoLight,
+            appName: this.uiConfig.appName,
+            chainNamespace: this.chainNamespace,
+            walletRegistry: this.walletRegistry
+          })
+        }));
+        if ((_this$uiConfig = this.uiConfig) !== null && _this$uiConfig !== void 0 && _this$uiConfig.theme) {
+          const rootElement = document.getElementById("w3a-parent-container");
+          applyWhiteLabelTheme(rootElement, this.uiConfig.theme);
+        }
+      });
+    });
+    _defineProperty(this, "addSocialLogins", (adapter, loginMethods, loginMethodsOrder, uiConfig) => {
+      this.setState({
+        socialLoginsConfig: {
+          adapter,
+          loginMethods,
+          loginMethodsOrder,
+          uiConfig
+        }
+      });
+      log.info("addSocialLogins", adapter, loginMethods, loginMethodsOrder, uiConfig);
+    });
+    _defineProperty(this, "addWalletLogins", (externalWalletsConfig, options) => {
+      this.setState({
+        externalWalletsConfig,
+        externalWalletsInitialized: true,
+        showExternalWalletsOnly: !!(options !== null && options !== void 0 && options.showExternalWalletsOnly),
+        externalWalletsVisibility: true
+      });
+    });
+    _defineProperty(this, "open", () => {
+      this.setState({
+        modalVisibility: true
+      });
+      this.emit(LOGIN_MODAL_EVENTS.MODAL_VISIBILITY, true);
+    });
+    _defineProperty(this, "closeModal", () => {
+      this.setState({
+        modalVisibility: false,
+        externalWalletsVisibility: false
+      });
+      this.emit(LOGIN_MODAL_EVENTS.MODAL_VISIBILITY, false);
+    });
+    _defineProperty(this, "initExternalWalletContainer", () => {
+      this.setState({
+        hasExternalWallets: true
+      });
+    });
+    _defineProperty(this, "handleShowExternalWallets", status => {
+      this.emit(LOGIN_MODAL_EVENTS.INIT_EXTERNAL_WALLETS, {
+        externalWalletsInitialized: status
+      });
+    });
+    _defineProperty(this, "handleExternalWalletClick", params => {
+      log.info("external wallet clicked", params);
+      const {
+        adapter
+      } = params;
+      this.emit(LOGIN_MODAL_EVENTS.LOGIN, {
+        adapter
+      });
+    });
+    _defineProperty(this, "handleSocialLoginClick", params => {
+      log.info("social login clicked", params);
+      const {
+        adapter,
+        loginParams
+      } = params;
+      this.emit(LOGIN_MODAL_EVENTS.LOGIN, {
+        adapter,
+        loginParams: {
+          loginProvider: loginParams.loginProvider,
+          login_hint: loginParams.login_hint,
+          name: loginParams.name
+        }
+      });
+    });
+    _defineProperty(this, "setState", newState => {
+      this.stateEmitter.emit("STATE_UPDATED", newState);
+    });
+    _defineProperty(this, "updateWalletConnect", walletConnectUri => {
+      if (!walletConnectUri) return;
+      this.setState({
+        walletConnectUri
+      });
+    });
+    _defineProperty(this, "handleAdapterData", adapterData => {
+      if (adapterData.adapterName === WALLET_ADAPTERS.WALLET_CONNECT_V2) {
+        const walletConnectData = adapterData.data;
+        this.updateWalletConnect(walletConnectData.uri);
+      }
+    });
+    _defineProperty(this, "subscribeCoreEvents", listener => {
+      listener.on(ADAPTER_EVENTS.CONNECTING, data => {
+        log.info("connecting with adapter", data);
+        // don't show loader in case of wallet connect, because currently it listens for incoming for incoming
+        // connections without any user interaction.
+        if ((data === null || data === void 0 ? void 0 : data.adapter) !== WALLET_ADAPTERS.WALLET_CONNECT_V2) {
+          // const provider = data?.loginProvider || "";
+
+          this.setState({
+            status: MODAL_STATUS.CONNECTING
+          });
+        }
+      });
+      listener.on(ADAPTER_EVENTS.CONNECTED, data => {
+        log.debug("connected with adapter", data);
+        // only show success if not being reconnected again.
+        if (!data.reconnected) {
+          this.setState({
+            status: MODAL_STATUS.CONNECTED,
+            modalVisibility: true,
+            postLoadingMessage: "modal.post-loading.connected"
+          });
+        } else {
+          this.setState({
+            status: MODAL_STATUS.CONNECTED
+          });
+        }
+      });
+      // TODO: send adapter name in error
+      listener.on(ADAPTER_EVENTS.ERRORED, error => {
+        log.error("error", error, error.message);
+        if (error.code === 5000) {
+          if (this.uiConfig.displayErrorsOnModal) this.setState({
+            modalVisibility: true,
+            postLoadingMessage: error.message || "modal.post-loading.something-wrong",
+            status: MODAL_STATUS.ERRORED
+          });else this.setState({
+            modalVisibility: false
+          });
+        } else {
+          this.setState({
+            modalVisibility: true,
+            status: MODAL_STATUS.INITIALIZED
+          });
+        }
+      });
+      listener.on(ADAPTER_EVENTS.DISCONNECTED, () => {
+        this.setState({
+          status: MODAL_STATUS.INITIALIZED,
+          externalWalletsVisibility: false
+        });
+        // this.toggleMessage("");
+      });
+      listener.on(ADAPTER_EVENTS.ADAPTER_DATA_UPDATED, adapterData => {
+        this.handleAdapterData(adapterData);
+      });
+    });
+    this.uiConfig = _uiConfig;
+    if (!_uiConfig.logoDark) this.uiConfig.logoDark = DEFAULT_LOGO_DARK;
+    if (!_uiConfig.logoLight) this.uiConfig.logoLight = DEFAULT_LOGO_LIGHT;
+    if (!_uiConfig.mode) this.uiConfig.mode = "light";
+    if (!_uiConfig.modalZIndex) this.uiConfig.modalZIndex = "99998";
+    if (typeof _uiConfig.displayErrorsOnModal === "undefined") this.uiConfig.displayErrorsOnModal = true;
+    if (!_uiConfig.appName) this.uiConfig.appName = "Web3Auth";
+    if (!_uiConfig.loginGridCol) this.uiConfig.loginGridCol = 3;
+    if (!_uiConfig.primaryButton) this.uiConfig.primaryButton = "socialLogin";
+    if (!_uiConfig.defaultLanguage) this.uiConfig.defaultLanguage = getUserLanguage(_uiConfig.defaultLanguage);
+    this.stateEmitter = new SafeEventEmitter();
+    this.chainNamespace = _uiConfig.chainNamespace;
+    this.walletRegistry = _uiConfig.walletRegistry;
+    this.subscribeCoreEvents(this.uiConfig.adapterListener);
+  }
+  get isDark() {
+    return this.uiConfig.mode === "dark" || this.uiConfig.mode === "auto" && window.matchMedia("(prefers-color-scheme: dark)").matches;
+  }
+}
+
+export { LoginModal };

package/dist/lib.esm/packages/modal/src/ui/utils.js

@@ -0,0 +1,65 @@
+import _objectSpread from '@babel/runtime/helpers/objectSpread2';
+import { post, get } from '@toruslabs/http-helpers';
+import { LANGUAGES, LANGUAGE_MAP } from '@web3auth/auth';
+import { WALLET_ADAPTERS, log, WalletInitializationError } from '@web3auth/no-modal';
+import { AUTH_PROVIDERS, AUTH_PROVIDERS_NAMES } from './config.js';
+
+const getAdapterSocialLogins = (adapterName, loginMethodsConfig = {}) => {
+  const finalLoginMethodsConfig = {};
+  if (adapterName === WALLET_ADAPTERS.AUTH) {
+    AUTH_PROVIDERS.forEach(loginMethod => {
+      const currentLoginMethodConfig = loginMethodsConfig[loginMethod] || {
+        name: AUTH_PROVIDERS_NAMES[loginMethod],
+        showOnMobile: true,
+        showOnModal: true,
+        showOnDesktop: true
+      };
+      finalLoginMethodsConfig[loginMethod] = _objectSpread({}, currentLoginMethodConfig);
+    });
+    log.debug("auth login method ui config", finalLoginMethodsConfig);
+  } else {
+    throw WalletInitializationError.invalidParams(`${adapterName} is not a valid adapter`);
+  }
+  return finalLoginMethodsConfig;
+};
+const passwordlessBackendUrl = "https://api-passwordless.web3auth.io";
+const getUserCountry = async () => {
+  try {
+    const result = await get(`${passwordlessBackendUrl}/api/v3/user/location`);
+    if (result && result.data.country) return {
+      country: result.data.country,
+      dialCode: result.data.dial_code
+    };
+    return null;
+  } catch (error) {
+    log.error("error getting user country", error);
+    return null;
+  }
+};
+const validatePhoneNumber = async phoneNumber => {
+  try {
+    const result = await post(`${passwordlessBackendUrl}/api/v3/phone_number/validate`, {
+      phone_number: phoneNumber
+    });
+    if (result && result.success) return result.parsed_number;
+    return false;
+  } catch (error) {
+    log.error("error validating phone number", error);
+    if (error.status === 400) {
+      return false;
+    }
+    // sending true because we don't want the user to be stuck on a flow
+    // if there is an error with the api or something went wrong.
+    return true;
+  }
+};
+const getUserLanguage = defaultLanguage => {
+  let userLanguage = defaultLanguage;
+  if (!userLanguage) {
+    const browserLanguage = typeof window !== "undefined" ? window.navigator.userLanguage || window.navigator.language || "en-US" : "en-US";
+    userLanguage = browserLanguage.split("-")[0];
+  }
+  return Object.prototype.hasOwnProperty.call(LANGUAGE_MAP, userLanguage) ? userLanguage : LANGUAGES.en;
+};
+
+export { getAdapterSocialLogins, getUserCountry, getUserLanguage, passwordlessBackendUrl, validatePhoneNumber };

package/dist/lib.esm/packages/modal/src/vue/Web3AuthProvider.js

@@ -0,0 +1,232 @@
+import { ADAPTER_EVENTS, Web3AuthContextKey, ADAPTER_STATUS, WalletInitializationError, WalletLoginError } from '@web3auth/no-modal';
+import { defineComponent, h, shallowRef, ref, watch, provide } from 'vue';
+import { Web3Auth } from '../modalManager.js';
+
+const Web3AuthProvider = defineComponent({
+  name: "Web3AuthProvider",
+  props: {
+    config: {
+      type: Object,
+      required: true
+    }
+  },
+  setup(props) {
+    const web3Auth = shallowRef(null);
+    const provider = ref(null);
+    const userInfo = ref(null);
+    const isMFAEnabled = ref(false);
+    const status = ref(null);
+    const isInitializing = ref(false);
+    const initError = ref(null);
+    const isInitialized = ref(false);
+    const isConnecting = ref(false);
+    const connectError = ref(null);
+    const isConnected = ref(false);
+    const addPlugin = plugin => {
+      if (!web3Auth.value) throw WalletInitializationError.notReady();
+      return web3Auth.value.addPlugin(plugin);
+    };
+    const getPlugin = name => {
+      if (!web3Auth.value) throw WalletInitializationError.notReady();
+      return web3Auth.value.getPlugin(name);
+    };
+    const enableMFA = async loginParams => {
+      if (!web3Auth.value) throw WalletInitializationError.notReady();
+      if (!isConnected.value) throw WalletLoginError.notConnectedError();
+      await web3Auth.value.enableMFA(loginParams);
+      const localUserInfo = await web3Auth.value.getUserInfo();
+      userInfo.value = localUserInfo;
+      isMFAEnabled.value = localUserInfo.isMfaEnabled || false;
+    };
+    const manageMFA = async loginParams => {
+      if (!web3Auth.value) throw WalletInitializationError.notReady();
+      if (!isConnected.value) throw WalletLoginError.notConnectedError();
+      await web3Auth.value.manageMFA(loginParams);
+    };
+    const logout = async (logoutParams = {
+      cleanup: false
+    }) => {
+      if (!web3Auth.value) throw WalletInitializationError.notReady();
+      if (!isConnected.value) throw WalletLoginError.notConnectedError();
+      await web3Auth.value.logout(logoutParams);
+    };
+    const connect = async () => {
+      if (!web3Auth.value) throw WalletInitializationError.notReady();
+      try {
+        connectError.value = null;
+        isConnecting.value = true;
+        const localProvider = await web3Auth.value.connect();
+        return localProvider;
+      } catch (error) {
+        connectError.value = error;
+        return null;
+      } finally {
+        isConnecting.value = false;
+      }
+    };
+    const addAndSwitchChain = async chainConfig => {
+      if (!web3Auth.value) throw WalletInitializationError.notReady();
+      await web3Auth.value.addChain(chainConfig);
+      await web3Auth.value.switchChain({
+        chainId: chainConfig.chainId
+      });
+    };
+    const authenticateUser = async () => {
+      if (!web3Auth.value) throw WalletInitializationError.notReady();
+      return web3Auth.value.authenticateUser();
+    };
+    const addChain = async chainConfig => {
+      if (!web3Auth.value) throw WalletInitializationError.notReady();
+      return web3Auth.value.addChain(chainConfig);
+    };
+    const switchChain = chainParams => {
+      if (!web3Auth.value) throw WalletInitializationError.notReady();
+      return web3Auth.value.switchChain(chainParams);
+    };
+    watch(() => props.config, newConfig => {
+      const resetHookState = () => {
+        provider.value = null;
+        userInfo.value = null;
+        isMFAEnabled.value = false;
+        isConnected.value = false;
+        status.value = null;
+      };
+      resetHookState();
+      const {
+        web3AuthOptions,
+        adapters = [],
+        plugins = []
+      } = newConfig;
+      const web3AuthInstance = new Web3Auth(web3AuthOptions);
+      if (adapters.length) adapters.map(adapter => web3AuthInstance.configureAdapter(adapter));
+      if (plugins.length) {
+        plugins.forEach(plugin => {
+          web3AuthInstance.addPlugin(plugin);
+        });
+      }
+      web3Auth.value = web3AuthInstance;
+    }, {
+      immediate: true
+    });
+    watch(web3Auth, async newWeb3Auth => {
+      if (newWeb3Auth) {
+        try {
+          initError.value = null;
+          isInitializing.value = true;
+          const {
+            modalConfig,
+            hideWalletDiscovery
+          } = props.config;
+          if (modalConfig) {
+            await newWeb3Auth.initModal({
+              modalConfig,
+              hideWalletDiscovery
+            });
+          } else {
+            await newWeb3Auth.initModal();
+          }
+        } catch (error) {
+          initError.value = error;
+        } finally {
+          isInitializing.value = false;
+        }
+      }
+    }, {
+      immediate: true
+    });
+    watch(isConnected, newIsConnected => {
+      if (web3Auth.value) {
+        const addState = async web3AuthInstance => {
+          provider.value = web3AuthInstance.provider;
+          const userState = await web3AuthInstance.getUserInfo();
+          userInfo.value = userState;
+          isMFAEnabled.value = (userState === null || userState === void 0 ? void 0 : userState.isMfaEnabled) || false;
+        };
+        const resetState = () => {
+          provider.value = null;
+          userInfo.value = null;
+          isMFAEnabled.value = false;
+        };
+        if (newIsConnected) addState(web3Auth.value);else resetState();
+      }
+    });
+    watch(web3Auth, (newWeb3Auth, prevWeb3Auth) => {
+      const notReadyListener = () => {
+        status.value = web3Auth.value.status;
+      };
+      const readyListener = () => {
+        status.value = web3Auth.value.status;
+        isInitialized.value = true;
+      };
+      const connectedListener = () => {
+        status.value = web3Auth.value.status;
+        // we do this because of rehydration issues. status connected is fired first but web3auth sdk is not ready yet.
+        if (web3Auth.value.status === ADAPTER_STATUS.CONNECTED) {
+          isInitialized.value = true;
+          isConnected.value = true;
+        }
+      };
+      const disconnectedListener = () => {
+        status.value = web3Auth.value.status;
+        isConnected.value = false;
+      };
+      const connectingListener = () => {
+        status.value = web3Auth.value.status;
+      };
+      const errorListener = () => {
+        status.value = ADAPTER_EVENTS.ERRORED;
+      };
+
+      // unregister previous listeners
+      if (prevWeb3Auth && newWeb3Auth !== prevWeb3Auth) {
+        prevWeb3Auth.off(ADAPTER_EVENTS.NOT_READY, notReadyListener);
+        prevWeb3Auth.off(ADAPTER_EVENTS.READY, readyListener);
+        prevWeb3Auth.off(ADAPTER_EVENTS.CONNECTED, connectedListener);
+        prevWeb3Auth.off(ADAPTER_EVENTS.DISCONNECTED, disconnectedListener);
+        prevWeb3Auth.off(ADAPTER_EVENTS.CONNECTING, connectingListener);
+        prevWeb3Auth.off(ADAPTER_EVENTS.ERRORED, errorListener);
+      }
+      if (newWeb3Auth && newWeb3Auth !== prevWeb3Auth) {
+        status.value = newWeb3Auth.status;
+        // web3Auth is initialized here.
+        newWeb3Auth.on(ADAPTER_EVENTS.NOT_READY, notReadyListener);
+        newWeb3Auth.on(ADAPTER_EVENTS.READY, readyListener);
+        newWeb3Auth.on(ADAPTER_EVENTS.CONNECTED, connectedListener);
+        newWeb3Auth.on(ADAPTER_EVENTS.DISCONNECTED, disconnectedListener);
+        newWeb3Auth.on(ADAPTER_EVENTS.CONNECTING, connectingListener);
+        newWeb3Auth.on(ADAPTER_EVENTS.ERRORED, errorListener);
+      }
+    }, {
+      immediate: true
+    });
+    provide(Web3AuthContextKey, {
+      web3Auth,
+      isConnected,
+      isInitialized,
+      provider,
+      userInfo,
+      isMFAEnabled,
+      status,
+      getPlugin,
+      connect,
+      enableMFA,
+      manageMFA,
+      logout,
+      addAndSwitchChain,
+      addChain,
+      addPlugin,
+      authenticateUser,
+      switchChain,
+      isInitializing,
+      isConnecting,
+      initError,
+      connectError
+    });
+  },
+  render() {
+    var _this$$slots$default;
+    return h((_this$$slots$default = this.$slots.default) !== null && _this$$slots$default !== void 0 ? _this$$slots$default : "");
+  }
+});
+
+export { Web3AuthProvider };

package/dist/lib.esm/packages/modal/src/vue/composables/useWeb3Auth.js

@@ -0,0 +1,10 @@
+import { Web3AuthContextKey, WalletInitializationError } from '@web3auth/no-modal';
+import { inject } from 'vue';
+
+const useWeb3Auth = () => {
+  const context = inject(Web3AuthContextKey);
+  if (!context) throw WalletInitializationError.fromCode(1000, "usage of `useWeb3Auth` not wrapped in `Web3AuthProvider`.");
+  return context;
+};
+
+export { useWeb3Auth };

package/dist/lib.esm/packages/modal/src/vue/index.js

@@ -0,0 +1,2 @@
+export { useWeb3Auth } from './composables/useWeb3Auth.js';
+export { Web3AuthProvider } from './Web3AuthProvider.js';