@web3auth/no-modal 10.0.0-beta.3 → 10.0.0-beta.4

package/dist/lib.esm/react/{no-modal → context}/Web3AuthInnerContext.js

@@ -2,7 +2,7 @@ import { createContext, useState, useCallback, useEffect, useMemo, createElement
 import '@toruslabs/base-controllers';
 import '@babel/runtime/helpers/defineProperty';
 import '@web3auth/auth';
-import { WalletInitializationError, WalletLoginError } from '../../base/errors/index.js';
+import { WalletInitializationError } from '../../base/errors/index.js';
 import '../../base/wallet/index.js';
 import { CONNECTOR_EVENTS, CONNECTOR_STATUS } from '../../base/connector/constants.js';
 import 'jwt-decode';
@@ -20,16 +20,13 @@ function Web3AuthInnerProvider(params) {
     config
   } = params;
   const [web3Auth, setWeb3Auth] = useState(null);
-  const [isConnecting, setIsConnecting] = useState(false);
   const [isInitializing, setIsInitializing] = useState(false);
   const [initError, setInitError] = useState(null);
-  const [connectError, setConnectError] = useState(null);
   const [isConnected, setIsConnected] = useState(false);
   const [provider, setProvider] = useState(null);
-  const [userInfo, setUserInfo] = useState(null);
-  const [isMFAEnabled, setIsMFAEnabled] = useState(false);
   const [isInitialized, setIsInitialized] = useState(false);
   const [status, setStatus] = useState(null);
+  const [isMFAEnabled, setIsMFAEnabled] = useState(false);
   const getPlugin = useCallback(name => {
     if (!web3Auth) throw WalletInitializationError.notReady();
     return web3Auth.getPlugin(name);
@@ -37,8 +34,6 @@ function Web3AuthInnerProvider(params) {
   useEffect(() => {
     const resetHookState = () => {
       setProvider(null);
-      setUserInfo(null);
-      setIsMFAEnabled(false);
       setIsConnected(false);
       setStatus(null);
     };
@@ -69,40 +64,25 @@ function Web3AuthInnerProvider(params) {
       controller.abort();
     };
   }, [web3Auth]);
-  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);
-    };
-    if (web3Auth) {
-      if (isConnected) addState();else resetState();
-    }
-  }, [web3Auth, isConnected]);
-  // TODO: don't throw error in init, connect in v9
   useEffect(() => {
     const notReadyListener = () => setStatus(CONNECTOR_STATUS.NOT_READY);
     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 === CONNECTOR_STATUS.CONNECTED) {
         setIsInitialized(true);
         setIsConnected(true);
+        setProvider(data.provider);
       }
     };
     const disconnectedListener = () => {
       setStatus(web3Auth.status);
       setIsConnected(false);
+      setProvider(null);
     };
     const connectingListener = () => {
       setStatus(web3Auth.status);
@@ -110,6 +90,9 @@ function Web3AuthInnerProvider(params) {
     const errorListener = () => {
       setStatus(CONNECTOR_STATUS.ERRORED);
     };
+    const mfaEnabledListener = isMFAEnabled => {
+      if (typeof isMFAEnabled === "boolean") setIsMFAEnabled(isMFAEnabled);
+    };
     if (web3Auth) {
       // web3Auth is initialized here.
       setStatus(web3Auth.status);
@@ -119,6 +102,7 @@ function Web3AuthInnerProvider(params) {
       web3Auth.on(CONNECTOR_EVENTS.DISCONNECTED, disconnectedListener);
       web3Auth.on(CONNECTOR_EVENTS.CONNECTING, connectingListener);
       web3Auth.on(CONNECTOR_EVENTS.ERRORED, errorListener);
+      web3Auth.on(CONNECTOR_EVENTS.MFA_ENABLED, mfaEnabledListener);
     }
     return () => {
       if (web3Auth) {
@@ -128,73 +112,24 @@ function Web3AuthInnerProvider(params) {
         web3Auth.off(CONNECTOR_EVENTS.DISCONNECTED, disconnectedListener);
         web3Auth.off(CONNECTOR_EVENTS.CONNECTING, connectingListener);
         web3Auth.off(CONNECTOR_EVENTS.ERRORED, errorListener);
+        web3Auth.off(CONNECTOR_EVENTS.MFA_ENABLED, mfaEnabledListener);
       }
     };
   }, [web3Auth]);
-  const enableMFA = useCallback(async loginParams => {
-    if (!web3Auth) throw WalletInitializationError.notReady();
-    if (!isConnected) throw WalletLoginError.notConnectedError();
-    await web3Auth.enableMFA(loginParams);
-    const localUserInfo = await web3Auth.getUserInfo();
-    setUserInfo(localUserInfo);
-    setIsMFAEnabled(localUserInfo.isMfaEnabled || false);
-  }, [web3Auth, isConnected]);
-  const manageMFA = useCallback(async loginParams => {
-    if (!web3Auth) throw WalletInitializationError.notReady();
-    if (!isConnected) throw WalletLoginError.notConnectedError();
-    await web3Auth.manageMFA(loginParams);
-  }, [web3Auth, isConnected]);
-  const logout = useCallback(async (logoutParams = {
-    cleanup: false
-  }) => {
-    if (!web3Auth) throw WalletInitializationError.notReady();
-    if (!isConnected) throw WalletLoginError.notConnectedError();
-    await web3Auth.logout(logoutParams);
-  }, [web3Auth, isConnected]);
-  const connectTo = useCallback(async (walletName, loginParams) => {
-    if (!web3Auth) throw WalletInitializationError.notReady();
-    try {
-      setConnectError(null);
-      setIsConnecting(true);
-      const localProvider = await web3Auth.connectTo(walletName, loginParams);
-      return localProvider;
-    } catch (error) {
-      setConnectError(error);
-      throw error;
-    } finally {
-      setIsConnecting(false);
-    }
-  }, [web3Auth]);
-  const authenticateUser = useCallback(async () => {
-    if (!web3Auth) throw WalletInitializationError.notReady();
-    return web3Auth.authenticateUser();
-  }, [web3Auth]);
-  const switchChain = useCallback(chainParams => {
-    if (!web3Auth) throw WalletInitializationError.notReady();
-    return web3Auth.switchChain(chainParams);
-  }, [web3Auth]);
   const value = useMemo(() => {
     return {
       web3Auth,
       isConnected,
       isInitialized,
       provider,
-      userInfo,
-      isMFAEnabled,
       status,
-      getPlugin,
-      connectTo,
-      enableMFA,
-      manageMFA,
-      logout,
-      authenticateUser,
-      switchChain,
       isInitializing,
-      isConnecting,
       initError,
-      connectError
+      isMFAEnabled,
+      getPlugin,
+      setIsMFAEnabled
     };
-  }, [web3Auth, isConnected, isInitialized, provider, userInfo, isMFAEnabled, status, connectTo, getPlugin, enableMFA, manageMFA, logout, authenticateUser, switchChain, isConnecting, isInitializing, initError, connectError]);
+  }, [web3Auth, isConnected, isInitialized, provider, status, getPlugin, isInitializing, initError, isMFAEnabled, setIsMFAEnabled]);
   return createElement(Web3AuthInnerContext.Provider, {
     value
   }, children);

package/dist/lib.esm/react/hooks/useCheckout.js

@@ -0,0 +1,43 @@
+import { useState, useCallback } from 'react';
+import '@toruslabs/base-controllers';
+import '@babel/runtime/helpers/defineProperty';
+import '@web3auth/auth';
+import '../../base/errors/index.js';
+import '../../base/wallet/index.js';
+import '../../base/connector/constants.js';
+import 'jwt-decode';
+import '../../base/loglevel.js';
+import { WalletServicesPluginError } from '../../base/plugin/errors.js';
+import '../../base/plugin/IPlugin.js';
+import '@toruslabs/constants';
+import '@toruslabs/http-helpers';
+import { useWalletServicesPlugin } from './useWalletServicesPlugin.js';
+
+const useCheckout = () => {
+  const {
+    plugin,
+    ready
+  } = useWalletServicesPlugin();
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState(null);
+  const showCheckout = useCallback(async showCheckoutParams => {
+    setLoading(true);
+    setError(null);
+    try {
+      if (!plugin) throw WalletServicesPluginError.notInitialized();
+      if (!ready) throw WalletServicesPluginError.walletPluginNotConnected();
+      await plugin.showCheckout(showCheckoutParams);
+    } catch (error) {
+      setError(error);
+    } finally {
+      setLoading(false);
+    }
+  }, [plugin, ready]);
+  return {
+    loading,
+    error,
+    showCheckout
+  };
+};
+
+export { useCheckout };

package/dist/lib.esm/react/hooks/useEnableMFA.js

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

package/dist/lib.esm/react/hooks/useIdentityToken.js

@@ -0,0 +1,40 @@
+import { useState, useCallback, useEffect } from 'react';
+import { useWeb3AuthInner } from './useWeb3AuthInner.js';
+
+const useIdentityToken = () => {
+  const {
+    web3Auth,
+    isConnected
+  } = useWeb3AuthInner();
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState(null);
+  const [token, setToken] = useState(null);
+  const authenticateUser = 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]);
+  useEffect(() => {
+    if (!isConnected && token) {
+      setToken(null);
+    }
+  }, [isConnected, token]);
+  return {
+    loading,
+    error,
+    token,
+    authenticateUser
+  };
+};
+
+export { useIdentityToken };

package/dist/lib.esm/react/hooks/useManageMFA.js

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

package/dist/lib.esm/react/hooks/useSwap.js

@@ -0,0 +1,43 @@
+import { useState, useCallback } from 'react';
+import '@toruslabs/base-controllers';
+import '@babel/runtime/helpers/defineProperty';
+import '@web3auth/auth';
+import '../../base/errors/index.js';
+import '../../base/wallet/index.js';
+import '../../base/connector/constants.js';
+import 'jwt-decode';
+import '../../base/loglevel.js';
+import { WalletServicesPluginError } from '../../base/plugin/errors.js';
+import '../../base/plugin/IPlugin.js';
+import '@toruslabs/constants';
+import '@toruslabs/http-helpers';
+import { useWalletServicesPlugin } from './useWalletServicesPlugin.js';
+
+const useSwap = () => {
+  const {
+    plugin,
+    ready
+  } = useWalletServicesPlugin();
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState(null);
+  const showSwap = useCallback(async showSwapParams => {
+    setLoading(true);
+    setError(null);
+    try {
+      if (!plugin) throw WalletServicesPluginError.notInitialized();
+      if (!ready) throw WalletServicesPluginError.walletPluginNotConnected();
+      await plugin.showSwap(showSwapParams);
+    } catch (error) {
+      setError(error);
+    } finally {
+      setLoading(false);
+    }
+  }, [plugin, ready]);
+  return {
+    loading,
+    error,
+    showSwap
+  };
+};
+
+export { useSwap };

package/dist/lib.esm/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/react/hooks/useWalletConnectScanner.js

@@ -0,0 +1,43 @@
+import { useState, useCallback } from 'react';
+import '@toruslabs/base-controllers';
+import '@babel/runtime/helpers/defineProperty';
+import '@web3auth/auth';
+import '../../base/errors/index.js';
+import '../../base/wallet/index.js';
+import '../../base/connector/constants.js';
+import 'jwt-decode';
+import '../../base/loglevel.js';
+import { WalletServicesPluginError } from '../../base/plugin/errors.js';
+import '../../base/plugin/IPlugin.js';
+import '@toruslabs/constants';
+import '@toruslabs/http-helpers';
+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 => {
+    if (!plugin) throw WalletServicesPluginError.notInitialized();
+    if (!ready) throw WalletServicesPluginError.walletPluginNotConnected();
+    setLoading(true);
+    setError(null);
+    try {
+      await plugin.showWalletConnectScanner(showWalletConnectScannerParams);
+    } catch (error) {
+      setError(error);
+    } finally {
+      setLoading(false);
+    }
+  }, [plugin, ready]);
+  return {
+    loading,
+    error,
+    showWalletConnectScanner
+  };
+};
+
+export { useWalletConnectScanner };

package/dist/lib.esm/react/hooks/useWalletServicesPlugin.js

@@ -0,0 +1,17 @@
+import { useContext } from 'react';
+import { WalletServicesContext } from '../context/WalletServicesInnerContext.js';
+
+const useWalletServicesPlugin = () => {
+  const {
+    ready,
+    plugin,
+    connecting
+  } = useContext(WalletServicesContext);
+  return {
+    ready,
+    plugin,
+    connecting
+  };
+};
+
+export { useWalletServicesPlugin };

package/dist/lib.esm/react/hooks/useWalletUI.js

@@ -0,0 +1,43 @@
+import { useState, useCallback } from 'react';
+import '@toruslabs/base-controllers';
+import '@babel/runtime/helpers/defineProperty';
+import '@web3auth/auth';
+import '../../base/errors/index.js';
+import '../../base/wallet/index.js';
+import '../../base/connector/constants.js';
+import 'jwt-decode';
+import '../../base/loglevel.js';
+import { WalletServicesPluginError } from '../../base/plugin/errors.js';
+import '../../base/plugin/IPlugin.js';
+import '@toruslabs/constants';
+import '@toruslabs/http-helpers';
+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/react/hooks/useWeb3Auth.js

@@ -0,0 +1,26 @@
+import { useWeb3AuthInner } from './useWeb3AuthInner.js';
+
+const useWeb3Auth = () => {
+  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/react/hooks/useWeb3AuthConnect.js

@@ -0,0 +1,42 @@
+import { useState, useEffect, useCallback } from 'react';
+import { useWeb3AuthInner } from './useWeb3AuthInner.js';
+
+const useWeb3AuthConnect = () => {
+  const context = useWeb3AuthInner();
+  const {
+    web3Auth,
+    isConnected
+  } = context;
+  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 (connector, params) => {
+    setLoading(true);
+    setError(null);
+    try {
+      const provider = await web3Auth.connectTo(connector, params);
+      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/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/react/{no-modal/hooks/useWeb3Auth.js → hooks/useWeb3AuthInner.js}

@@ -2,18 +2,18 @@ import { useContext } from 'react';
 import '@toruslabs/base-controllers';
 import '@babel/runtime/helpers/defineProperty';
 import '@web3auth/auth';
-import { WalletInitializationError } from '../../../base/errors/index.js';
-import '../../../base/wallet/index.js';
-import '../../../base/connector/constants.js';
+import { WalletInitializationError } from '../../base/errors/index.js';
+import '../../base/wallet/index.js';
+import '../../base/connector/constants.js';
 import 'jwt-decode';
-import '../../../base/loglevel.js';
-import '../../../base/plugin/errors.js';
-import '../../../base/plugin/IPlugin.js';
+import '../../base/loglevel.js';
+import '../../base/plugin/errors.js';
+import '../../base/plugin/IPlugin.js';
 import '@toruslabs/constants';
 import '@toruslabs/http-helpers';
-import { Web3AuthInnerContext } from '../Web3AuthInnerContext.js';
+import { Web3AuthInnerContext } from '../context/Web3AuthInnerContext.js';
 
-const useWeb3Auth = () => {
+const useWeb3AuthInner = () => {
   const context = useContext(Web3AuthInnerContext);
   if (!context) {
     throw WalletInitializationError.fromCode(1000, "usage of useWeb3Auth not wrapped in `Web3AuthContextProvider`.");
@@ -21,4 +21,4 @@ const useWeb3Auth = () => {
   return context;
 };
 
-export { useWeb3Auth };
+export { useWeb3AuthInner };

package/dist/lib.esm/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 };