@web3auth/modal 10.0.0-beta.3 → 10.0.0-beta.5

package/dist/lib.esm/packages/modal/src/react/hooks/useSwitchChain.js

@@ -0,0 +1,30 @@
+import { useState, useCallback } from 'react';
+import { useWeb3AuthInner } from './useWeb3AuthInner.js';
+
+const useSwitchChain = () => {
+  const {
+    web3Auth
+  } = useWeb3AuthInner();
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState(null);
+  const switchChain = useCallback(async chainId => {
+    setLoading(true);
+    setError(null);
+    try {
+      await web3Auth.switchChain({
+        chainId
+      });
+    } catch (error) {
+      setError(error);
+    } finally {
+      setLoading(false);
+    }
+  }, [web3Auth]);
+  return {
+    loading,
+    error,
+    switchChain
+  };
+};
+
+export { useSwitchChain };

package/dist/lib.esm/packages/modal/src/react/hooks/useWalletConnectScanner.js

@@ -0,0 +1,32 @@
+import { WalletServicesPluginError } from '@web3auth/no-modal';
+import { useState, useCallback } from 'react';
+import { useWalletServicesPlugin } from './useWalletServicesPlugin.js';
+
+const useWalletConnectScanner = () => {
+  const {
+    plugin,
+    ready
+  } = useWalletServicesPlugin();
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState(null);
+  const showWalletConnectScanner = useCallback(async showWalletConnectScannerParams => {
+    setLoading(true);
+    setError(null);
+    try {
+      if (!plugin) throw WalletServicesPluginError.notInitialized();
+      if (!ready) throw WalletServicesPluginError.walletPluginNotConnected();
+      await plugin.showWalletConnectScanner(showWalletConnectScannerParams);
+    } catch (error) {
+      setError(error);
+    } finally {
+      setLoading(false);
+    }
+  }, [plugin, ready]);
+  return {
+    loading,
+    error,
+    showWalletConnectScanner
+  };
+};
+
+export { useWalletConnectScanner };

package/dist/lib.esm/packages/modal/src/react/hooks/useWalletServicesPlugin.js

@@ -0,0 +1,10 @@
+import { useContext } from 'react';
+import { WalletServicesContext } from '../context/WalletServicesInnerContext.js';
+
+const useWalletServicesPlugin = () => {
+  const context = useContext(WalletServicesContext);
+  if (!context) throw new Error("WalletServicesContext not found");
+  return context;
+};
+
+export { useWalletServicesPlugin };

package/dist/lib.esm/packages/modal/src/react/hooks/useWalletUI.js

@@ -0,0 +1,32 @@
+import { WalletServicesPluginError } from '@web3auth/no-modal';
+import { useState, useCallback } from 'react';
+import { useWalletServicesPlugin } from './useWalletServicesPlugin.js';
+
+const useWalletUI = () => {
+  const {
+    plugin,
+    ready
+  } = useWalletServicesPlugin();
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState(null);
+  const showWalletUI = useCallback(async showWalletUiParams => {
+    setLoading(true);
+    setError(null);
+    try {
+      if (!plugin) throw WalletServicesPluginError.notInitialized();
+      if (!ready) throw WalletServicesPluginError.walletPluginNotConnected();
+      await plugin.showWalletUi(showWalletUiParams);
+    } catch (error) {
+      setError(error);
+    } finally {
+      setLoading(false);
+    }
+  }, [plugin, ready]);
+  return {
+    loading,
+    error,
+    showWalletUI
+  };
+};
+
+export { useWalletUI };

package/dist/lib.esm/packages/modal/src/react/hooks/useWeb3Auth.js

@@ -1,13 +1,26 @@
-import { WalletInitializationError } from '@web3auth/no-modal';
-import { useContext } from 'react';
-import { Web3AuthInnerContext } from '../context/Web3AuthInnerContext.js';
+import { useWeb3AuthInner } from './useWeb3AuthInner.js';
 
 const useWeb3Auth = () => {
-  const context = useContext(Web3AuthInnerContext);
-  if (!context) {
-    throw WalletInitializationError.fromCode(1000, "usage of useWeb3Auth not wrapped in `Web3AuthContextProvider`.");
-  }
-  return context;
+  const {
+    initError,
+    isConnected,
+    isInitialized,
+    isInitializing,
+    provider,
+    status,
+    web3Auth,
+    getPlugin
+  } = useWeb3AuthInner();
+  return {
+    initError,
+    isConnected,
+    isInitialized,
+    isInitializing,
+    provider,
+    status,
+    web3Auth,
+    getPlugin
+  };
 };
 
 export { useWeb3Auth };

package/dist/lib.esm/packages/modal/src/react/hooks/useWeb3AuthConnect.js

@@ -0,0 +1,41 @@
+import { useState, useEffect, useCallback } from 'react';
+import { useWeb3AuthInner } from './useWeb3AuthInner.js';
+
+const useWeb3AuthConnect = () => {
+  const {
+    web3Auth,
+    isConnected
+  } = useWeb3AuthInner();
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState(null);
+  const [connectorName, setConnectorName] = useState(null);
+  useEffect(() => {
+    if (!isConnected && connectorName) {
+      setConnectorName(null);
+    }
+  }, [isConnected, connectorName]);
+  const connect = useCallback(async () => {
+    setLoading(true);
+    setError(null);
+    try {
+      const provider = await web3Auth.connect();
+      if (provider) {
+        setConnectorName(web3Auth.connectedConnectorName);
+      }
+      return provider;
+    } catch (error) {
+      setError(error);
+    } finally {
+      setLoading(false);
+    }
+  }, [web3Auth]);
+  return {
+    isConnected,
+    loading,
+    error,
+    connectorName,
+    connect
+  };
+};
+
+export { useWeb3AuthConnect };

package/dist/lib.esm/packages/modal/src/react/hooks/useWeb3AuthDisconnect.js

@@ -0,0 +1,28 @@
+import { useState, useCallback } from 'react';
+import { useWeb3AuthInner } from './useWeb3AuthInner.js';
+
+const useWeb3AuthDisconnect = () => {
+  const {
+    web3Auth
+  } = useWeb3AuthInner();
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState(null);
+  const disconnect = useCallback(async options => {
+    setLoading(true);
+    setError(null);
+    try {
+      await web3Auth.logout(options);
+    } catch (error) {
+      setError(error);
+    } finally {
+      setLoading(false);
+    }
+  }, [web3Auth]);
+  return {
+    loading,
+    error,
+    disconnect
+  };
+};
+
+export { useWeb3AuthDisconnect };

package/dist/lib.esm/packages/modal/src/react/hooks/useWeb3AuthInner.js

@@ -0,0 +1,13 @@
+import { WalletInitializationError } from '@web3auth/no-modal';
+import { useContext } from 'react';
+import { Web3AuthInnerContext } from '../context/Web3AuthInnerContext.js';
+
+const useWeb3AuthInner = () => {
+  const context = useContext(Web3AuthInnerContext);
+  if (!context) {
+    throw WalletInitializationError.fromCode(1000, "usage of useWeb3Auth not wrapped in `Web3AuthContextProvider`.");
+  }
+  return context;
+};
+
+export { useWeb3AuthInner };

package/dist/lib.esm/packages/modal/src/react/hooks/useWeb3AuthUser.js

@@ -0,0 +1,48 @@
+import { useState, useCallback, useEffect } from 'react';
+import { useWeb3AuthInner } from './useWeb3AuthInner.js';
+
+const useWeb3AuthUser = () => {
+  const {
+    web3Auth,
+    isConnected,
+    isMFAEnabled,
+    setIsMFAEnabled
+  } = useWeb3AuthInner();
+  const [userInfo, setUserInfo] = useState(null);
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState(null);
+  const getUserInfo = useCallback(async () => {
+    setLoading(true);
+    setError(null);
+    try {
+      const userInfo = await web3Auth.getUserInfo();
+      setUserInfo(userInfo);
+      return userInfo;
+    } catch (error) {
+      setError(error);
+    } finally {
+      setLoading(false);
+    }
+  }, [web3Auth]);
+  useEffect(() => {
+    const saveUserInfo = async () => {
+      const userInfo = await getUserInfo();
+      setUserInfo(userInfo);
+      setIsMFAEnabled((userInfo === null || userInfo === void 0 ? void 0 : userInfo.isMfaEnabled) || false);
+    };
+    if (isConnected && !userInfo) saveUserInfo();
+    if (!isConnected && userInfo) {
+      setUserInfo(null);
+      setIsMFAEnabled(false);
+    }
+  }, [isConnected, userInfo, getUserInfo, setIsMFAEnabled]);
+  return {
+    loading,
+    error,
+    userInfo,
+    isMFAEnabled,
+    getUserInfo
+  };
+};
+
+export { useWeb3AuthUser };

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

@@ -1,3 +1,14 @@
-export { Web3AuthInnerContext, Web3AuthInnerProvider } from './context/Web3AuthInnerContext.js';
+export { useCheckout } from './hooks/useCheckout.js';
+export { useEnableMFA } from './hooks/useEnableMFA.js';
+export { useIdentityToken } from './hooks/useIdentityToken.js';
+export { useManageMFA } from './hooks/useManageMFA.js';
+export { useSwap } from './hooks/useSwap.js';
+export { useSwitchChain } from './hooks/useSwitchChain.js';
+export { useWalletConnectScanner } from './hooks/useWalletConnectScanner.js';
+export { useWalletServicesPlugin } from './hooks/useWalletServicesPlugin.js';
+export { useWalletUI } from './hooks/useWalletUI.js';
 export { useWeb3Auth } from './hooks/useWeb3Auth.js';
+export { useWeb3AuthConnect } from './hooks/useWeb3AuthConnect.js';
+export { useWeb3AuthDisconnect } from './hooks/useWeb3AuthDisconnect.js';
+export { useWeb3AuthUser } from './hooks/useWeb3AuthUser.js';
 export { Web3AuthProvider } from './Web3AuthProvider.js';

package/dist/lib.esm/packages/modal/src/react/wagmi/index.js

@@ -0,0 +1 @@
+export { WagmiProvider } from './provider.js';

package/dist/lib.esm/packages/modal/src/react/wagmi/provider.js

@@ -0,0 +1,192 @@
+import _objectWithoutProperties from '@babel/runtime/helpers/objectWithoutProperties';
+import _objectSpread from '@babel/runtime/helpers/objectSpread2';
+import { log } from '@web3auth/no-modal';
+import { useMemo, createElement, useEffect, Fragment } from 'react';
+import { defineChain, http } from 'viem';
+import { createConfig, WagmiProvider as WagmiProvider$1, useConfig, useAccountEffect } from 'wagmi';
+import { injected } from 'wagmi/connectors';
+import '@babel/runtime/helpers/defineProperty';
+import 'deepmerge';
+import '../../config.js';
+import '../../ui/config.js';
+import '../../ui/css/index.css.js';
+import '@web3auth/auth';
+import 'react-dom/client';
+import '@toruslabs/http-helpers';
+import 'clsx';
+import 'tailwind-merge';
+import 'react/jsx-runtime';
+import 'bowser';
+import 'react-i18next';
+import '../../ui/localeImport.js';
+import 'classnames';
+import 'react-qrcode-logo';
+import '../../ui/components/Login/Login.js';
+import { useWeb3Auth } from '../hooks/useWeb3Auth.js';
+import { useWeb3AuthDisconnect } from '../hooks/useWeb3AuthDisconnect.js';
+
+const _excluded = ["children"];
+const WEB3AUTH_CONNECTOR_ID = "web3auth";
+
+// Helper to initialize connectors for the given wallets
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+async function setupConnector(provider, config) {
+  let connector = config.connectors.find(c => c.id === WEB3AUTH_CONNECTOR_ID);
+  if (connector) return connector;
+
+  // Create new connector if not already existing
+  connector = injected({
+    target: {
+      provider: provider,
+      id: WEB3AUTH_CONNECTOR_ID,
+      name: "Web3Auth"
+    }
+  });
+  const result = config._internal.connectors.setup(connector);
+  config._internal.connectors.setState(current => [...current, result]);
+  return result;
+}
+
+// Helper to connect a wallet and update wagmi state
+async function connectWeb3AuthWithWagmi(connector, config) {
+  var _config$storage, _config$storage2;
+  await Promise.all([(_config$storage = config.storage) === null || _config$storage === void 0 ? void 0 : _config$storage.removeItem(`${connector.id}.disconnected`), (_config$storage2 = config.storage) === null || _config$storage2 === void 0 ? void 0 : _config$storage2.setItem("recentConnectorId", connector.id)]);
+  let chainId = await connector.getChainId();
+  if (!config.chains.find(c => c.id === chainId)) {
+    chainId = config.chains[0].id;
+  }
+  const accounts = await connector.getAccounts();
+  const connections = new Map([[connector.uid, {
+    accounts: [accounts[0]],
+    chainId,
+    connector
+  }]]);
+  config.setState(state => _objectSpread(_objectSpread({}, state), {}, {
+    chainId,
+    connections,
+    current: connector.uid,
+    status: "connected"
+  }));
+}
+async function disconnectWeb3AuthFromWagmi(config) {
+  config._internal.connectors.setState(prev => prev.filter(c => c.id !== WEB3AUTH_CONNECTOR_ID));
+  config.setState(state => _objectSpread(_objectSpread({}, state), {}, {
+    chainId: state.chainId,
+    connections: new Map(),
+    current: undefined,
+    status: "disconnected"
+  }));
+}
+function Web3AuthWagmiProvider({
+  children
+}) {
+  const {
+    isConnected,
+    provider
+  } = useWeb3Auth();
+  const {
+    disconnect
+  } = useWeb3AuthDisconnect();
+  const wagmiConfig = useConfig();
+  useAccountEffect({
+    onDisconnect: async () => {
+      log.info("Disconnected from wagmi");
+      if (isConnected) await disconnect();
+    }
+  });
+  useEffect(() => {
+    (async () => {
+      if (isConnected && provider) {
+        const connector = await setupConnector(provider, wagmiConfig);
+        if (!connector) {
+          throw new Error("Failed to setup connector");
+        }
+        await connectWeb3AuthWithWagmi(connector, wagmiConfig);
+      } else if (!isConnected) {
+        if (wagmiConfig.state.status === "connected") {
+          await disconnectWeb3AuthFromWagmi(wagmiConfig);
+        }
+      }
+    })();
+  }, [isConnected, wagmiConfig, provider]);
+  return /*#__PURE__*/createElement(Fragment, null, children);
+}
+function WagmiProvider(_ref) {
+  let {
+      children
+    } = _ref,
+    props = _objectWithoutProperties(_ref, _excluded);
+  const {
+    config
+  } = props;
+  const {
+    web3Auth,
+    isInitialized
+  } = useWeb3Auth();
+  const finalConfig = useMemo(() => {
+    var _web3Auth$coreOptions;
+    const finalConfig = _objectSpread(_objectSpread({
+      ssr: true
+    }, config), {}, {
+      chains: undefined,
+      connectors: [],
+      transports: {},
+      multiInjectedProviderDiscovery: false,
+      client: undefined
+    });
+    const wagmiChains = [];
+    if (isInitialized && web3Auth !== null && web3Auth !== void 0 && (_web3Auth$coreOptions = web3Auth.coreOptions) !== null && _web3Auth$coreOptions !== void 0 && _web3Auth$coreOptions.chains) {
+      var _web3Auth$currentChai;
+      const defaultChainId = (_web3Auth$currentChai = web3Auth.currentChain) === null || _web3Auth$currentChai === void 0 ? void 0 : _web3Auth$currentChai.chainId;
+      const chains = web3Auth.coreOptions.chains;
+      chains.forEach(chain => {
+        const wagmiChain = defineChain({
+          id: Number.parseInt(chain.chainId, 16),
+          // id in number form
+          name: chain.displayName,
+          rpcUrls: {
+            default: {
+              http: [chain.rpcTarget],
+              webSocket: [chain.wsTarget]
+            }
+          },
+          blockExplorers: chain.blockExplorerUrl ? {
+            default: {
+              name: "explorer",
+              // TODO: correct name if chain config has it
+              url: chain.blockExplorerUrl
+            }
+          } : undefined,
+          nativeCurrency: {
+            name: chain.tickerName,
+            symbol: chain.ticker,
+            decimals: chain.decimals || 18
+          }
+        });
+        if (defaultChainId === chain.chainId) {
+          wagmiChains.unshift(wagmiChain);
+        } else {
+          wagmiChains.push(wagmiChain);
+        }
+        finalConfig.transports[wagmiChain.id] = http(chain.rpcTarget);
+      });
+      finalConfig.chains = [wagmiChains[0], ...wagmiChains.slice(1)];
+    }
+    if (!finalConfig.chains) return;
+    return createConfig(finalConfig);
+  }, [config, web3Auth, isInitialized]);
+
+  // WagmiProviderBase requires a config to initialize
+  // If no config is provided, it will throw an error.
+  if (!finalConfig) return null;
+  return /*#__PURE__*/createElement(WagmiProvider$1, // typecast to WagmiProviderPropsBase to avoid type error
+  // as we are omitting the config prop from WagmiProviderProps
+  // and creating a new config object with the finalConfig
+  _objectSpread(_objectSpread({
+    config: finalConfig
+  }, props), {}, {
+    reconnectOnMount: false
+  }), /*#__PURE__*/createElement(Web3AuthWagmiProvider, null, children));
+}
+
+export { WagmiProvider };

package/dist/lib.esm/packages/modal/src/ui/components/ConnectWallet/ConnectWallet.js

@@ -79,12 +79,12 @@ function ConnectWallet(props) {
   }, [allExternalButtons, customConnectorButtons, defaultButtonKeys, selectedChain]);
   const installedWalletButtons = useMemo(() => {
     const visibilityMap = connectorVisibilityMap;
-    return Object.keys(config).reduce((acc, adapter) => {
-      if (![WALLET_CONNECTORS.WALLET_CONNECT_V2].includes(adapter) && visibilityMap[adapter]) {
+    return Object.keys(config).reduce((acc, localConnector) => {
+      if (localConnector !== WALLET_CONNECTORS.WALLET_CONNECT_V2 && visibilityMap[localConnector]) {
         acc.push({
-          name: adapter,
-          displayName: config[adapter].label || adapter,
-          hasInjectedWallet: config[adapter].isInjected,
+          name: localConnector,
+          displayName: config[localConnector].label || localConnector,
+          hasInjectedWallet: config[localConnector].isInjected,
           hasWalletConnect: false,
           hasInstallLinks: false
         });

package/dist/lib.esm/packages/modal/src/ui/components/Login/Login.js

@@ -157,6 +157,7 @@ function Login(props) {
   }, [socialLoginsConfig, isDark, buttonRadius]);
   const handleCustomLogin = async (authConnection, loginHint) => {
     try {
+      var _captchaRef$current;
       const handler = createPasswordlessHandler(authConnection, {
         loginHint,
         web3authClientId,
@@ -165,17 +166,13 @@ function Login(props) {
         authConnection,
         authBuildEnv
       });
-      let token = "";
-      if (authConnection === AUTH_CONNECTION.SMS_PASSWORDLESS) {
-        var _captchaRef$current;
-        const res = await ((_captchaRef$current = captchaRef.current) === null || _captchaRef$current === void 0 ? void 0 : _captchaRef$current.execute({
-          async: true
-        }));
-        if (!res) {
-          throw WalletLoginError.connectionError("Captcha token is required");
-        }
-        token = res.response;
+      const res = await ((_captchaRef$current = captchaRef.current) === null || _captchaRef$current === void 0 ? void 0 : _captchaRef$current.execute({
+        async: true
+      }));
+      if (!res) {
+        throw WalletLoginError.connectionError("Captcha token is required");
       }
+      const token = res.response;
       const result = await handler.sendVerificationCode({
         captchaToken: token
       });
@@ -200,7 +197,7 @@ function Login(props) {
         const connectorConfig = socialLoginsConfig.loginMethods[AUTH_CONNECTION.EMAIL_PASSWORDLESS];
         if (connectorConfig.isDefault) {
           return handleSocialLoginClick({
-            connector: socialLoginsConfig.connector || "",
+            connector: socialLoginsConfig.connector,
             loginParams: {
               authConnection: AUTH_CONNECTION.EMAIL_PASSWORDLESS,
               authConnectionId: connectorConfig.authConnectionId,
@@ -223,7 +220,7 @@ function Login(props) {
         const connectorConfig = socialLoginsConfig.loginMethods[AUTH_CONNECTION.SMS_PASSWORDLESS];
         if (connectorConfig.isDefault) {
           return handleSocialLoginClick({
-            connector: socialLoginsConfig.connector || "",
+            connector: socialLoginsConfig.connector,
             loginParams: {
               authConnection: AUTH_CONNECTION.SMS_PASSWORDLESS,
               authConnectionId: connectorConfig.authConnectionId,
@@ -285,7 +282,7 @@ function Login(props) {
       if (result !== null && result !== void 0 && (_result$data = result.data) !== null && _result$data !== void 0 && _result$data.id_token) {
         var _result$data2;
         return handleSocialLoginClick({
-          connector: socialLoginsConfig.connector || "",
+          connector: socialLoginsConfig.connector,
           loginParams: {
             authConnection: authConnection,
             authConnectionId: connectorConfig.authConnectionId,

package/dist/lib.esm/packages/modal/src/ui/components/Root/Root.js

@@ -238,7 +238,7 @@ function Root(props) {
   }, [connectorVisibilityMap, chainNamespaces, config, deviceDetails.platform, isWalletConnectConnectorIncluded]);
   const installedConnectorButtons = useMemo(() => {
     const installedConnectors = Object.keys(config).reduce((acc, connector) => {
-      if ([WALLET_CONNECTORS.WALLET_CONNECT_V2].includes(connector) || !connectorVisibilityMap[connector]) return acc;
+      if (connector === WALLET_CONNECTORS.WALLET_CONNECT_V2 || !connectorVisibilityMap[connector]) return acc;
       const connectorConfig = config[connector];
       acc.push({
         name: connector,

package/dist/lib.esm/packages/modal/src/ui/handlers/AbstractHandler.js

@@ -2,6 +2,7 @@ import _defineProperty from '@babel/runtime/helpers/defineProperty';
 import { post } from '@toruslabs/http-helpers';
 import { BUILD_ENV, AUTH_CONNECTION, storageAvailable } from '@web3auth/auth';
 import { WalletInitializationError } from '@web3auth/no-modal';
+import { version } from '../../config.js';
 import { PASSWORDLESS_BUILD_ENV_MAP } from '../config.js';
 import { getErrorMessages } from '../utils.js';
 
@@ -10,6 +11,7 @@ class PasswordlessHandler {
     _defineProperty(this, "authBaseApiUrl", void 0);
     _defineProperty(this, "passwordlessParams", void 0);
     _defineProperty(this, "trackingIdentifier", void 0);
+    _defineProperty(this, "version", `web3auth-${version.split(".")[0]}`);
     if (!params.authConnection) throw WalletInitializationError.invalidParams("authConnection is required");
     if (!params.web3authClientId) throw WalletInitializationError.invalidParams("web3authClientId is required");
     if (!params.loginHint) throw WalletInitializationError.invalidParams("loginHint is required");

package/dist/lib.esm/packages/modal/src/ui/handlers/EmailPasswordlessHandler.js

@@ -10,7 +10,9 @@ class EmailPasswordlessHandler extends PasswordlessHandler {
     this.mailSent = false;
     if (this.sessionStorageAvailable) this.trackingId = (_window$sessionStorag = window.sessionStorage.getItem("trackingId")) !== null && _window$sessionStorag !== void 0 ? _window$sessionStorag : undefined;
   }
-  async sendVerificationCode() {
+  async sendVerificationCode({
+    captchaToken
+  }) {
     const {
       loginHint,
       network,
@@ -23,9 +25,10 @@ class EmailPasswordlessHandler extends PasswordlessHandler {
       login_hint: loginHint,
       tracking_id: this.trackingId,
       whitelabel: this.whiteLabelParams,
-      version: "",
+      version: this.version,
       network,
-      flow_type: EMAIL_FLOW.code
+      flow_type: EMAIL_FLOW.code,
+      captcha_token: captchaToken
     };
     return super.start(finalParams);
   }
@@ -41,7 +44,7 @@ class EmailPasswordlessHandler extends PasswordlessHandler {
       code,
       connection: "email",
       tracking_id: this.trackingId,
-      version: "",
+      version: this.version,
       network,
       flow_type: EMAIL_FLOW.code
     };

package/dist/lib.esm/packages/modal/src/ui/handlers/SmsPasswordlessHandler.js

@@ -27,7 +27,7 @@ class SmsPasswordlessHandler extends PasswordlessHandler {
       login_hint: loginHint,
       tracking_id: this.trackingId,
       whitelabel: this.whiteLabelParams,
-      version: "",
+      version: this.version,
       network,
       captcha_token: captchaToken
     };
@@ -45,7 +45,7 @@ class SmsPasswordlessHandler extends PasswordlessHandler {
       code,
       connection: this.connection,
       tracking_id: this.trackingId,
-      version: "",
+      version: this.version,
       network
     };
     return super.verify(params);