@web3auth/modal 10.0.0-beta.0 → 10.0.0-beta.11

package/dist/lib.cjs/packages/modal/src/react/context/WalletServicesInnerContext.js

@@ -0,0 +1,72 @@
+'use strict';
+
+var noModal = require('@web3auth/no-modal');
+var react = require('react');
+
+const WalletServicesContext = /*#__PURE__*/react.createContext(null);
+function WalletServicesContextProvider({
+  children,
+  context
+}) {
+  const web3AuthContext = react.useContext(context);
+  const {
+    getPlugin,
+    isInitialized,
+    isConnected
+  } = web3AuthContext;
+  const [ready, setReady] = react.useState(false);
+  const [connecting, setConnecting] = react.useState(false);
+  const [walletServicesPlugin, setWalletServicesPlugin] = react.useState(null);
+  react.useEffect(() => {
+    if (isInitialized) {
+      const plugin = getPlugin(noModal.EVM_PLUGINS.WALLET_SERVICES);
+      setWalletServicesPlugin(plugin);
+    }
+  }, [isInitialized, getPlugin]);
+  react.useEffect(() => {
+    if (isConnected) {
+      const plugin = getPlugin(noModal.EVM_PLUGINS.WALLET_SERVICES);
+      setWalletServicesPlugin(plugin);
+      // when rehydrating, the connectedListener may be registered after the connected event is emitted, we need to check the status here
+      if ((plugin === null || plugin === void 0 ? void 0 : plugin.status) === noModal.CONNECTOR_STATUS.CONNECTED) setReady(true);
+    }
+  }, [isConnected, getPlugin, walletServicesPlugin]);
+  react.useEffect(() => {
+    const connectedListener = () => {
+      setReady(true);
+      setConnecting(false);
+    };
+    const disconnectedListener = () => {
+      setReady(false);
+      setConnecting(false);
+    };
+    const connectingListener = () => {
+      setConnecting(true);
+    };
+    if (walletServicesPlugin) {
+      walletServicesPlugin.on(noModal.PLUGIN_EVENTS.CONNECTED, connectedListener);
+      walletServicesPlugin.on(noModal.PLUGIN_EVENTS.DISCONNECTED, disconnectedListener);
+      walletServicesPlugin.on(noModal.PLUGIN_EVENTS.CONNECTING, connectingListener);
+    }
+    return () => {
+      if (walletServicesPlugin) {
+        walletServicesPlugin.off(noModal.PLUGIN_EVENTS.CONNECTED, connectedListener);
+        walletServicesPlugin.off(noModal.PLUGIN_EVENTS.DISCONNECTED, disconnectedListener);
+        walletServicesPlugin.off(noModal.PLUGIN_EVENTS.CONNECTING, connectingListener);
+      }
+    };
+  }, [walletServicesPlugin]);
+  const value = react.useMemo(() => {
+    return {
+      plugin: walletServicesPlugin,
+      ready,
+      connecting
+    };
+  }, [walletServicesPlugin, ready, connecting]);
+  return /*#__PURE__*/react.createElement(WalletServicesContext.Provider, {
+    value
+  }, children);
+}
+
+exports.WalletServicesContext = WalletServicesContext;
+exports.WalletServicesContextProvider = WalletServicesContextProvider;

package/dist/lib.cjs/packages/modal/src/react/context/Web3AuthInnerContext.js

@@ -1,93 +1,43 @@
 'use strict';
 
 var noModal = require('@web3auth/no-modal');
-var React = require('react');
+var react = require('react');
 var modalManager = require('../../modalManager.js');
 
-const Web3AuthInnerContext = /*#__PURE__*/React.createContext(null);
+const Web3AuthInnerContext = /*#__PURE__*/react.createContext(null);
 function Web3AuthInnerProvider(params) {
   const {
     children,
-    config
+    config,
+    initialState
   } = params;
-  const [web3Auth, setWeb3Auth] = React.useState(null);
-  const [isConnecting, setIsConnecting] = React.useState(false);
-  const [isInitializing, setIsInitializing] = React.useState(false);
-  const [initError, setInitError] = React.useState(null);
-  const [connectError, setConnectError] = React.useState(null);
-  const [isConnected, setIsConnected] = React.useState(false);
-  const [provider, setProvider] = React.useState(null);
-  const [userInfo, setUserInfo] = React.useState(null);
-  const [isMFAEnabled, setIsMFAEnabled] = React.useState(false);
-  const [isInitialized, setIsInitialized] = React.useState(false);
-  const [status, setStatus] = React.useState(null);
-  const getPlugin = React.useCallback(name => {
+  const {
+    web3AuthOptions
+  } = config;
+  const [isInitializing, setIsInitializing] = react.useState(false);
+  const [initError, setInitError] = react.useState(null);
+  const [provider, setProvider] = react.useState(null);
+  const [isInitialized, setIsInitialized] = react.useState(false);
+  const [isMFAEnabled, setIsMFAEnabled] = react.useState(false);
+  const web3Auth = react.useMemo(() => {
+    setProvider(null);
+    return new modalManager.Web3Auth(web3AuthOptions, initialState);
+  }, [web3AuthOptions, initialState]);
+  const [isConnected, setIsConnected] = react.useState(web3Auth.status === noModal.CONNECTOR_STATUS.CONNECTED);
+  const [status, setStatus] = react.useState(web3Auth.status);
+  const getPlugin = react.useCallback(name => {
     if (!web3Auth) throw noModal.WalletInitializationError.notReady();
     return web3Auth.getPlugin(name);
   }, [web3Auth]);
-  const enableMFA = React.useCallback(async loginParams => {
-    if (!web3Auth) throw noModal.WalletInitializationError.notReady();
-    if (!isConnected) throw noModal.WalletLoginError.notConnectedError();
-    await web3Auth.enableMFA(loginParams);
-    const localUserInfo = await web3Auth.getUserInfo();
-    setUserInfo(localUserInfo);
-    setIsMFAEnabled(localUserInfo.isMfaEnabled || false);
-  }, [web3Auth, isConnected]);
-  const manageMFA = React.useCallback(async loginParams => {
-    if (!web3Auth) throw noModal.WalletInitializationError.notReady();
-    if (!isConnected) throw noModal.WalletLoginError.notConnectedError();
-    await web3Auth.manageMFA(loginParams);
-  }, [web3Auth, isConnected]);
-  const logout = React.useCallback(async (logoutParams = {
-    cleanup: false
-  }) => {
-    if (!web3Auth) throw noModal.WalletInitializationError.notReady();
-    if (!isConnected) throw noModal.WalletLoginError.notConnectedError();
-    await web3Auth.logout(logoutParams);
-  }, [web3Auth, isConnected]);
-  const connect = React.useCallback(async () => {
-    if (!web3Auth) throw noModal.WalletInitializationError.notReady();
-    try {
-      setConnectError(null);
-      setIsConnecting(true);
-      const localProvider = await web3Auth.connect();
-      return localProvider;
-    } catch (error) {
-      setConnectError(error);
-      throw error;
-    } finally {
-      setIsConnecting(false);
-    }
-  }, [web3Auth]);
-  const authenticateUser = React.useCallback(async () => {
-    if (!web3Auth) throw noModal.WalletInitializationError.notReady();
-    return web3Auth.authenticateUser();
-  }, [web3Auth]);
-  const switchChain = React.useCallback(chainParams => {
-    if (!web3Auth) throw noModal.WalletInitializationError.notReady();
-    return web3Auth.switchChain(chainParams);
-  }, [web3Auth]);
-  React.useEffect(() => {
-    const resetHookState = () => {
-      setProvider(null);
-      setUserInfo(null);
-      setIsMFAEnabled(false);
-      setIsConnected(false);
-      setStatus(null);
-    };
-    resetHookState();
-    const {
-      web3AuthOptions
-    } = config;
-    const web3AuthInstance = new modalManager.Web3Auth(web3AuthOptions);
-    setWeb3Auth(web3AuthInstance);
-  }, [config]);
-  React.useEffect(() => {
+  react.useEffect(() => {
+    const controller = new AbortController();
     async function init() {
       try {
         setInitError(null);
         setIsInitializing(true);
-        await web3Auth.initModal();
+        await web3Auth.init({
+          signal: controller.signal
+        });
       } catch (error) {
         setInitError(error);
       } finally {
@@ -95,46 +45,43 @@ function Web3AuthInnerProvider(params) {
       }
     }
     if (web3Auth) init();
-  }, [web3Auth, config]);
-  React.useEffect(() => {
-    const addState = async () => {
-      setProvider(web3Auth.provider);
-      const userState = await web3Auth.getUserInfo();
-      setUserInfo(userState);
-      setIsMFAEnabled((userState === null || userState === void 0 ? void 0 : userState.isMfaEnabled) || false);
-    };
-    const resetState = () => {
-      setProvider(null);
-      setUserInfo(null);
-      setIsMFAEnabled(false);
+    return () => {
+      controller.abort();
     };
-    if (web3Auth) {
-      if (isConnected) addState();else resetState();
-    }
-  }, [web3Auth, isConnected]);
-  React.useEffect(() => {
+  }, [web3Auth, config]);
+  react.useEffect(() => {
     const notReadyListener = () => setStatus(web3Auth.status);
     const readyListener = () => {
       setStatus(web3Auth.status);
       setIsInitialized(true);
     };
-    const connectedListener = () => {
+    const connectedListener = data => {
       setStatus(web3Auth.status);
       // we do this because of rehydration issues. status connected is fired first but web3auth sdk is not ready yet.
       if (web3Auth.status === noModal.CONNECTOR_STATUS.CONNECTED) {
         setIsInitialized(true);
         setIsConnected(true);
+        setProvider(data.provider);
       }
     };
     const disconnectedListener = () => {
       setStatus(web3Auth.status);
       setIsConnected(false);
+      setProvider(null);
     };
     const connectingListener = () => {
       setStatus(web3Auth.status);
     };
     const errorListener = () => {
-      setStatus(noModal.CONNECTOR_STATUS.ERRORED);
+      setStatus(web3Auth.status);
+    };
+    const rehydrationErrorListener = () => {
+      setStatus(web3Auth.status);
+      setIsConnected(false);
+      setProvider(null);
+    };
+    const mfaEnabledListener = isMFAEnabled => {
+      if (typeof isMFAEnabled === "boolean") setIsMFAEnabled(isMFAEnabled);
     };
     if (web3Auth) {
       // web3Auth is initialized here.
@@ -145,6 +92,8 @@ function Web3AuthInnerProvider(params) {
       web3Auth.on(noModal.CONNECTOR_EVENTS.DISCONNECTED, disconnectedListener);
       web3Auth.on(noModal.CONNECTOR_EVENTS.CONNECTING, connectingListener);
       web3Auth.on(noModal.CONNECTOR_EVENTS.ERRORED, errorListener);
+      web3Auth.on(noModal.CONNECTOR_EVENTS.REHYDRATION_ERROR, rehydrationErrorListener);
+      web3Auth.on(noModal.CONNECTOR_EVENTS.MFA_ENABLED, mfaEnabledListener);
     }
     return () => {
       if (web3Auth) {
@@ -154,32 +103,27 @@ function Web3AuthInnerProvider(params) {
         web3Auth.off(noModal.CONNECTOR_EVENTS.DISCONNECTED, disconnectedListener);
         web3Auth.off(noModal.CONNECTOR_EVENTS.CONNECTING, connectingListener);
         web3Auth.off(noModal.CONNECTOR_EVENTS.ERRORED, errorListener);
+        web3Auth.off(noModal.CONNECTOR_EVENTS.REHYDRATION_ERROR, rehydrationErrorListener);
+        web3Auth.off(noModal.CONNECTOR_EVENTS.MFA_ENABLED, mfaEnabledListener);
+        web3Auth.cleanup();
       }
     };
   }, [web3Auth]);
-  const value = React.useMemo(() => {
+  const value = react.useMemo(() => {
     return {
       web3Auth,
       isConnected,
       isInitialized,
       provider,
-      userInfo,
-      isMFAEnabled,
       status,
-      connect,
-      enableMFA,
-      manageMFA,
-      logout,
-      authenticateUser,
-      switchChain,
-      getPlugin,
       isInitializing,
-      isConnecting,
       initError,
-      connectError
+      isMFAEnabled,
+      getPlugin,
+      setIsMFAEnabled
     };
-  }, [web3Auth, isConnected, isInitialized, provider, userInfo, isMFAEnabled, status, getPlugin, connect, enableMFA, manageMFA, logout, authenticateUser, switchChain, isInitializing, isConnecting, initError, connectError]);
-  return /*#__PURE__*/React.createElement(Web3AuthInnerContext.Provider, {
+  }, [web3Auth, isConnected, isMFAEnabled, setIsMFAEnabled, isInitialized, provider, status, getPlugin, isInitializing, initError]);
+  return /*#__PURE__*/react.createElement(Web3AuthInnerContext.Provider, {
     value
   }, children);
 }

package/dist/lib.cjs/packages/modal/src/react/hooks/useCheckout.js

@@ -0,0 +1,34 @@
+'use strict';
+
+var noModal = require('@web3auth/no-modal');
+var react = require('react');
+var useWalletServicesPlugin = require('./useWalletServicesPlugin.js');
+
+const useCheckout = () => {
+  const {
+    plugin,
+    ready
+  } = useWalletServicesPlugin.useWalletServicesPlugin();
+  const [loading, setLoading] = react.useState(false);
+  const [error, setError] = react.useState(null);
+  const showCheckout = react.useCallback(async showCheckoutParams => {
+    setLoading(true);
+    setError(null);
+    try {
+      if (!plugin) throw noModal.WalletServicesPluginError.notInitialized();
+      if (!ready) throw noModal.WalletServicesPluginError.walletPluginNotConnected();
+      await plugin.showCheckout(showCheckoutParams);
+    } catch (error) {
+      setError(error);
+    } finally {
+      setLoading(false);
+    }
+  }, [plugin, ready]);
+  return {
+    loading,
+    error,
+    showCheckout
+  };
+};
+
+exports.useCheckout = useCheckout;

package/dist/lib.cjs/packages/modal/src/react/hooks/useEnableMFA.js

@@ -0,0 +1,30 @@
+'use strict';
+
+var react = require('react');
+var useWeb3AuthInner = require('./useWeb3AuthInner.js');
+
+const useEnableMFA = () => {
+  const {
+    web3Auth
+  } = useWeb3AuthInner.useWeb3AuthInner();
+  const [loading, setLoading] = react.useState(false);
+  const [error, setError] = react.useState(null);
+  const enableMFA = react.useCallback(async params => {
+    setLoading(true);
+    setError(null);
+    try {
+      await web3Auth.enableMFA(params);
+    } catch (error) {
+      setError(error);
+    } finally {
+      setLoading(false);
+    }
+  }, [web3Auth]);
+  return {
+    loading,
+    error,
+    enableMFA
+  };
+};
+
+exports.useEnableMFA = useEnableMFA;

package/dist/lib.cjs/packages/modal/src/react/hooks/useIdentityToken.js

@@ -0,0 +1,42 @@
+'use strict';
+
+var react = require('react');
+var useWeb3AuthInner = require('./useWeb3AuthInner.js');
+
+const useIdentityToken = () => {
+  const {
+    web3Auth,
+    isConnected
+  } = useWeb3AuthInner.useWeb3AuthInner();
+  const [loading, setLoading] = react.useState(false);
+  const [error, setError] = react.useState(null);
+  const [token, setToken] = react.useState(null);
+  const authenticateUser = react.useCallback(async () => {
+    setLoading(true);
+    setError(null);
+    try {
+      const userAuthInfo = await web3Auth.authenticateUser();
+      if (userAuthInfo !== null && userAuthInfo !== void 0 && userAuthInfo.idToken) {
+        setToken(userAuthInfo.idToken);
+      }
+      return userAuthInfo === null || userAuthInfo === void 0 ? void 0 : userAuthInfo.idToken;
+    } catch (error) {
+      setError(error);
+    } finally {
+      setLoading(false);
+    }
+  }, [web3Auth]);
+  react.useEffect(() => {
+    if (!isConnected && token) {
+      setToken(null);
+    }
+  }, [isConnected, token]);
+  return {
+    loading,
+    error,
+    token,
+    authenticateUser
+  };
+};
+
+exports.useIdentityToken = useIdentityToken;

package/dist/lib.cjs/packages/modal/src/react/hooks/useManageMFA.js

@@ -0,0 +1,30 @@
+'use strict';
+
+var react = require('react');
+var useWeb3AuthInner = require('./useWeb3AuthInner.js');
+
+const useManageMFA = () => {
+  const {
+    web3Auth
+  } = useWeb3AuthInner.useWeb3AuthInner();
+  const [loading, setLoading] = react.useState(false);
+  const [error, setError] = react.useState(null);
+  const manageMFA = react.useCallback(async params => {
+    setLoading(true);
+    setError(null);
+    try {
+      await web3Auth.manageMFA(params);
+    } catch (error) {
+      setError(error);
+    } finally {
+      setLoading(false);
+    }
+  }, [web3Auth]);
+  return {
+    loading,
+    error,
+    manageMFA
+  };
+};
+
+exports.useManageMFA = useManageMFA;

package/dist/lib.cjs/packages/modal/src/react/hooks/useSwap.js

@@ -0,0 +1,34 @@
+'use strict';
+
+var noModal = require('@web3auth/no-modal');
+var react = require('react');
+var useWalletServicesPlugin = require('./useWalletServicesPlugin.js');
+
+const useSwap = () => {
+  const {
+    plugin,
+    ready
+  } = useWalletServicesPlugin.useWalletServicesPlugin();
+  const [loading, setLoading] = react.useState(false);
+  const [error, setError] = react.useState(null);
+  const showSwap = react.useCallback(async showSwapParams => {
+    setLoading(true);
+    setError(null);
+    try {
+      if (!plugin) throw noModal.WalletServicesPluginError.notInitialized();
+      if (!ready) throw noModal.WalletServicesPluginError.walletPluginNotConnected();
+      await plugin.showSwap(showSwapParams);
+    } catch (error) {
+      setError(error);
+    } finally {
+      setLoading(false);
+    }
+  }, [plugin, ready]);
+  return {
+    loading,
+    error,
+    showSwap
+  };
+};
+
+exports.useSwap = useSwap;

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

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

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

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

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

@@ -0,0 +1,13 @@
+'use strict';
+
+var noModal = require('@web3auth/no-modal');
+var react = require('react');
+var WalletServicesInnerContext = require('../context/WalletServicesInnerContext.js');
+
+const useWalletServicesPlugin = () => {
+  const context = react.useContext(WalletServicesInnerContext.WalletServicesContext);
+  if (!context) throw noModal.WalletInitializationError.fromCode(1000, "usage of useWalletServicesPlugin not wrapped in `WalletServicesContextProvider`.");
+  return context;
+};
+
+exports.useWalletServicesPlugin = useWalletServicesPlugin;

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

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

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

@@ -1,15 +1,28 @@
 'use strict';
 
-var noModal = require('@web3auth/no-modal');
-var React = require('react');
-var Web3AuthInnerContext = require('../context/Web3AuthInnerContext.js');
+var useWeb3AuthInner = require('./useWeb3AuthInner.js');
 
 const useWeb3Auth = () => {
-  const context = React.useContext(Web3AuthInnerContext.Web3AuthInnerContext);
-  if (!context) {
-    throw noModal.WalletInitializationError.fromCode(1000, "usage of useWeb3Auth not wrapped in `Web3AuthContextProvider`.");
-  }
-  return context;
+  const {
+    initError,
+    isConnected,
+    isInitialized,
+    isInitializing,
+    provider,
+    status,
+    web3Auth,
+    getPlugin
+  } = useWeb3AuthInner.useWeb3AuthInner();
+  return {
+    initError,
+    isConnected,
+    isInitialized,
+    isInitializing,
+    provider,
+    status,
+    web3Auth,
+    getPlugin
+  };
 };
 
 exports.useWeb3Auth = useWeb3Auth;