@web3auth/no-modal 10.15.0 → 11.0.0-beta.0

package/dist/lib.esm/react/context/Web3AuthInnerContext.js

@@ -1,8 +1,6 @@
-import { createContext, useMemo, useState, useCallback, useEffect, createElement } from 'react';
+import { createContext, createElement } from 'react';
 import { Web3AuthNoModal } from '../../noModal.js';
-import { WalletInitializationError } from '../../base/errors/index.js';
-import { CONNECTOR_EVENTS, CONNECTOR_STATUS } from '../../base/connector/constants.js';
-import { ANALYTICS_INTEGRATION_TYPE } from '../../base/analytics.js';
+import { useWeb3AuthInnerContextValue } from './useWeb3AuthInnerContextValue.js';
 
 const Web3AuthInnerContext = createContext(null);
 function Web3AuthInnerProvider(params) {
@@ -14,154 +12,11 @@ function Web3AuthInnerProvider(params) {
   const {
     web3AuthOptions
   } = config;
-  const web3Auth = useMemo(() => {
-    setProvider(null);
-    return new Web3AuthNoModal(web3AuthOptions, initialState);
-  }, [web3AuthOptions, initialState]);
-  const [chainId, setChainId] = useState(null);
-  const [chainNamespace, setChainNamespace] = useState(null);
-  const [isInitializing, setIsInitializing] = useState(false);
-  const [initError, setInitError] = useState(null);
-  const [isConnected, setIsConnected] = useState(false);
-  const [provider, setProvider] = useState(null);
-  const [isInitialized, setIsInitialized] = useState(false);
-  const [status, setStatus] = useState(null);
-  const [isMFAEnabled, setIsMFAEnabled] = useState(false);
-  const [isAuthorized, setIsAuthorized] = useState(false);
-  const getPlugin = useCallback(name => {
-    if (!web3Auth) throw WalletInitializationError.notReady();
-    return web3Auth.getPlugin(name);
-  }, [web3Auth]);
-  useEffect(() => {
-    const controller = new AbortController();
-    async function init() {
-      try {
-        var _web3Auth$currentChai;
-        setInitError(null);
-        setIsInitializing(true);
-        web3Auth.setAnalyticsProperties({
-          integration_type: ANALYTICS_INTEGRATION_TYPE.REACT_HOOKS
-        });
-        await web3Auth.init({
-          signal: controller.signal
-        });
-        setChainId(web3Auth.currentChainId);
-        setChainNamespace((_web3Auth$currentChai = web3Auth.currentChain) === null || _web3Auth$currentChai === void 0 ? void 0 : _web3Auth$currentChai.chainNamespace);
-      } catch (error) {
-        setInitError(error);
-      } finally {
-        setIsInitializing(false);
-      }
-    }
-    if (web3Auth) init();
-    return () => {
-      controller.abort();
-    };
-  }, [web3Auth]);
-  useEffect(() => {
-    const handleChainChange = async chainId => {
-      var _web3Auth$currentChai2;
-      setChainId(chainId);
-      setChainNamespace(web3Auth === null || web3Auth === void 0 || (_web3Auth$currentChai2 = web3Auth.currentChain) === null || _web3Auth$currentChai2 === void 0 ? void 0 : _web3Auth$currentChai2.chainNamespace);
-    };
-    if (provider) {
-      provider.on("chainChanged", handleChainChange);
-      return () => {
-        if (provider) {
-          provider.removeListener("chainChanged", handleChainChange);
-        }
-      };
-    }
-  }, [web3Auth, provider]);
-  useEffect(() => {
-    const notReadyListener = () => setStatus(CONNECTOR_STATUS.NOT_READY);
-    const readyListener = () => {
-      setStatus(web3Auth.status);
-      setIsInitialized(true);
-    };
-    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);
-      setIsAuthorized(false);
-      setProvider(null);
-    };
-    const connectingListener = () => {
-      setStatus(web3Auth.status);
-    };
-    const errorListener = () => {
-      setStatus(web3Auth.status);
-    };
-    const rehydrationErrorListener = () => {
-      setStatus(web3Auth.status);
-      setIsConnected(false);
-      setIsAuthorized(false);
-      setProvider(null);
-    };
-    const authorizedListener = () => {
-      setStatus(web3Auth.status);
-      if (web3Auth.status === CONNECTOR_STATUS.AUTHORIZED) {
-        setIsConnected(true);
-        setIsAuthorized(true);
-      }
-    };
-    const mfaEnabledListener = isMFAEnabled => {
-      if (typeof isMFAEnabled === "boolean") setIsMFAEnabled(isMFAEnabled);
-    };
-
-    // TODO: In strict mode, web3auth becomes null and .off throws an error sometimes.
-    if (web3Auth) {
-      // web3Auth is initialized here.
-      setStatus(web3Auth.status);
-      web3Auth.on(CONNECTOR_EVENTS.NOT_READY, notReadyListener);
-      web3Auth.on(CONNECTOR_EVENTS.READY, readyListener);
-      web3Auth.on(CONNECTOR_EVENTS.CONNECTED, connectedListener);
-      web3Auth.on(CONNECTOR_EVENTS.AUTHORIZED, authorizedListener);
-      web3Auth.on(CONNECTOR_EVENTS.DISCONNECTED, disconnectedListener);
-      web3Auth.on(CONNECTOR_EVENTS.CONNECTING, connectingListener);
-      web3Auth.on(CONNECTOR_EVENTS.ERRORED, errorListener);
-      web3Auth.on(CONNECTOR_EVENTS.REHYDRATION_ERROR, rehydrationErrorListener);
-      web3Auth.on(CONNECTOR_EVENTS.MFA_ENABLED, mfaEnabledListener);
-    }
-    return () => {
-      if (web3Auth) {
-        web3Auth.removeListener(CONNECTOR_EVENTS.NOT_READY, notReadyListener);
-        web3Auth.removeListener(CONNECTOR_EVENTS.READY, readyListener);
-        web3Auth.removeListener(CONNECTOR_EVENTS.CONNECTED, connectedListener);
-        web3Auth.removeListener(CONNECTOR_EVENTS.DISCONNECTED, disconnectedListener);
-        web3Auth.removeListener(CONNECTOR_EVENTS.CONNECTING, connectingListener);
-        web3Auth.removeListener(CONNECTOR_EVENTS.ERRORED, errorListener);
-        web3Auth.removeListener(CONNECTOR_EVENTS.REHYDRATION_ERROR, rehydrationErrorListener);
-        web3Auth.removeListener(CONNECTOR_EVENTS.MFA_ENABLED, mfaEnabledListener);
-        web3Auth.removeListener(CONNECTOR_EVENTS.AUTHORIZED, authorizedListener);
-      }
-    };
-  }, [web3Auth]);
-  const value = useMemo(() => {
-    return {
-      web3Auth,
-      isConnected,
-      isInitialized,
-      provider,
-      status,
-      isInitializing,
-      initError,
-      isMFAEnabled,
-      chainId,
-      chainNamespace,
-      getPlugin,
-      setIsMFAEnabled,
-      isAuthorized
-    };
-  }, [web3Auth, isConnected, isInitialized, provider, status, getPlugin, isInitializing, initError, isMFAEnabled, setIsMFAEnabled, chainId, chainNamespace, isAuthorized]);
+  const value = useWeb3AuthInnerContextValue({
+    Web3AuthConstructor: Web3AuthNoModal,
+    web3AuthOptions,
+    initialState
+  });
   return createElement(Web3AuthInnerContext.Provider, {
     value
   }, children);

package/dist/lib.esm/react/context/useWalletServicesContextValue.js

@@ -0,0 +1,59 @@
+import { useState, useEffect, useMemo } from 'react';
+import { EVM_PLUGINS, PLUGIN_EVENTS } from '../../base/plugin/IPlugin.js';
+import { CONNECTED_STATUSES } from '../../base/connector/connectorStatus.js';
+
+function useWalletServicesContextValue(web3AuthContext) {
+  const {
+    getPlugin,
+    isInitialized,
+    isConnected
+  } = web3AuthContext;
+  const [ready, setReady] = useState(false);
+  const [connecting, setConnecting] = useState(false);
+  const [walletServicesPlugin, setWalletServicesPlugin] = useState(null);
+  useEffect(() => {
+    if (!isInitialized) return;
+    const plugin = getPlugin(EVM_PLUGINS.WALLET_SERVICES);
+    setWalletServicesPlugin(plugin);
+  }, [isInitialized, getPlugin]);
+  useEffect(() => {
+    if (!isConnected) return;
+    const plugin = getPlugin(EVM_PLUGINS.WALLET_SERVICES);
+    setWalletServicesPlugin(plugin);
+    // When rehydrating, the connected listener may be registered after the connected event is emitted.
+    if (CONNECTED_STATUSES.includes(plugin === null || plugin === void 0 ? void 0 : plugin.status)) setReady(true);
+  }, [isConnected, getPlugin]);
+  useEffect(() => {
+    const plugin = walletServicesPlugin;
+    if (!plugin) return undefined;
+    const connectedListener = () => {
+      setReady(true);
+      setConnecting(false);
+    };
+    const disconnectedListener = () => {
+      setReady(false);
+      setConnecting(false);
+    };
+    const connectingListener = () => {
+      setConnecting(true);
+    };
+    plugin.on(PLUGIN_EVENTS.CONNECTED, connectedListener);
+    plugin.on(PLUGIN_EVENTS.DISCONNECTED, disconnectedListener);
+    plugin.on(PLUGIN_EVENTS.CONNECTING, connectingListener);
+    return () => {
+      if (!plugin) return;
+      plugin.removeListener(PLUGIN_EVENTS.CONNECTED, connectedListener);
+      plugin.removeListener(PLUGIN_EVENTS.DISCONNECTED, disconnectedListener);
+      plugin.removeListener(PLUGIN_EVENTS.CONNECTING, connectingListener);
+    };
+  }, [walletServicesPlugin]);
+  return useMemo(() => {
+    return {
+      plugin: walletServicesPlugin,
+      ready,
+      connecting
+    };
+  }, [walletServicesPlugin, ready, connecting]);
+}
+
+export { useWalletServicesContextValue };

package/dist/lib.esm/react/context/useWeb3AuthInnerContextValue.js

@@ -0,0 +1,188 @@
+import { useState, useMemo, useCallback, useEffect } from 'react';
+import { WalletInitializationError } from '../../base/errors/index.js';
+import { CONNECTOR_EVENTS, CONNECTOR_STATUS } from '../../base/connector/constants.js';
+import { LOGIN_MODE } from '../../base/constants.js';
+import { ANALYTICS_INTEGRATION_TYPE } from '../../base/analytics.js';
+
+function useWeb3AuthInnerContextValue({
+  Web3AuthConstructor,
+  web3AuthOptions,
+  initialState,
+  notReadyUsesCurrentStatus = false,
+  cleanupOnUnmount = false,
+  initEffectDependency
+}) {
+  const [chainId, setChainId] = useState(null);
+  const [chainNamespace, setChainNamespace] = useState(null);
+  const [isInitializing, setIsInitializing] = useState(false);
+  const [initError, setInitError] = useState(null);
+  const [connection, setConnection] = useState(null);
+  const [isInitialized, setIsInitialized] = useState(false);
+  const [isMFAEnabled, setIsMFAEnabled] = useState(false);
+  const web3Auth = useMemo(() => {
+    setConnection(null);
+    return new Web3AuthConstructor(web3AuthOptions, initialState);
+  }, [Web3AuthConstructor, web3AuthOptions, initialState]);
+  const [isConnected, setIsConnected] = useState(false);
+  const [status, setStatus] = useState(null);
+  const [isAuthorized, setIsAuthorized] = useState(false);
+  const getPlugin = useCallback(name => {
+    if (!web3Auth) throw WalletInitializationError.notReady();
+    return web3Auth.getPlugin(name);
+  }, [web3Auth]);
+  useEffect(() => {
+    const controller = new AbortController();
+    async function init() {
+      try {
+        var _web3Auth$currentChai;
+        setInitError(null);
+        setIsInitializing(true);
+        web3Auth.setAnalyticsProperties({
+          integration_type: ANALYTICS_INTEGRATION_TYPE.REACT_HOOKS
+        });
+        await web3Auth.init({
+          signal: controller.signal
+        });
+        setChainId(web3Auth.currentChainId);
+        setChainNamespace((_web3Auth$currentChai = web3Auth.currentChain) === null || _web3Auth$currentChai === void 0 ? void 0 : _web3Auth$currentChai.chainNamespace);
+      } catch (error) {
+        setInitError(error);
+      } finally {
+        setIsInitializing(false);
+      }
+    }
+    init();
+    return () => {
+      controller.abort();
+    };
+  }, [web3Auth, initEffectDependency]);
+  useEffect(() => {
+    var _connection$ethereumP;
+    const handleChainChange = async nextChainId => {
+      var _web3Auth$currentChai2;
+      setChainId(nextChainId);
+      setChainNamespace((_web3Auth$currentChai2 = web3Auth.currentChain) === null || _web3Auth$currentChai2 === void 0 ? void 0 : _web3Auth$currentChai2.chainNamespace);
+    };
+    const provider = (_connection$ethereumP = connection === null || connection === void 0 ? void 0 : connection.ethereumProvider) !== null && _connection$ethereumP !== void 0 ? _connection$ethereumP : null;
+    if (!provider) return undefined;
+    provider.on("chainChanged", handleChainChange);
+    return () => {
+      provider.removeListener("chainChanged", handleChainChange);
+    };
+  }, [web3Auth.currentChain, connection === null || connection === void 0 ? void 0 : connection.ethereumProvider]);
+  useEffect(() => {
+    const notReadyListener = () => {
+      setStatus(notReadyUsesCurrentStatus ? web3Auth.status : CONNECTOR_STATUS.NOT_READY);
+    };
+    const readyListener = () => {
+      setStatus(web3Auth.status);
+      setIsInitialized(true);
+    };
+    const connectedListener = data => {
+      if (data.pendingUserConsent) return;
+      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) {
+        var _web3Auth$currentChai3, _web3Auth$currentChai4;
+        setIsInitialized(true);
+        setIsConnected(true);
+        setConnection(web3Auth.connection);
+        setChainId(web3Auth.currentChainId);
+        setChainNamespace((_web3Auth$currentChai3 = (_web3Auth$currentChai4 = web3Auth.currentChain) === null || _web3Auth$currentChai4 === void 0 ? void 0 : _web3Auth$currentChai4.chainNamespace) !== null && _web3Auth$currentChai3 !== void 0 ? _web3Auth$currentChai3 : null);
+      }
+    };
+    const disconnectedListener = () => {
+      setStatus(web3Auth.status);
+      setIsConnected(false);
+      setIsAuthorized(false);
+      setConnection(null);
+    };
+    const connectingListener = () => {
+      setStatus(web3Auth.status);
+    };
+    const errorListener = () => {
+      setStatus(web3Auth.status);
+    };
+    const rehydrationErrorListener = () => {
+      setStatus(web3Auth.status);
+      setIsConnected(false);
+      setIsAuthorized(false);
+      setConnection(null);
+    };
+    const authorizedListener = () => {
+      setStatus(web3Auth.status);
+      if (web3Auth.status === CONNECTOR_STATUS.AUTHORIZED) {
+        setIsConnected(true);
+        setIsAuthorized(true);
+      }
+    };
+    const consentAcceptedListener = () => {
+      setStatus(web3Auth.status);
+      if (web3Auth.status === CONNECTOR_STATUS.CONNECTED || web3Auth.status === CONNECTOR_STATUS.AUTHORIZED) {
+        var _web3Auth$currentChai5, _web3Auth$currentChai6;
+        setIsInitialized(true);
+        setIsConnected(true);
+        setConnection(web3Auth.connection);
+        setChainId(web3Auth.currentChainId);
+        setChainNamespace((_web3Auth$currentChai5 = (_web3Auth$currentChai6 = web3Auth.currentChain) === null || _web3Auth$currentChai6 === void 0 ? void 0 : _web3Auth$currentChai6.chainNamespace) !== null && _web3Auth$currentChai5 !== void 0 ? _web3Auth$currentChai5 : null);
+        if (web3Auth.status === CONNECTOR_STATUS.AUTHORIZED) {
+          setIsAuthorized(true);
+        }
+      }
+    };
+    const mfaEnabledListener = nextIsMFAEnabled => {
+      if (typeof nextIsMFAEnabled === "boolean") setIsMFAEnabled(nextIsMFAEnabled);
+    };
+    if (web3Auth) {
+      web3Auth.on(CONNECTOR_EVENTS.NOT_READY, notReadyListener);
+      web3Auth.on(CONNECTOR_EVENTS.READY, readyListener);
+      web3Auth.on(CONNECTOR_EVENTS.CONNECTED, connectedListener);
+      web3Auth.on(CONNECTOR_EVENTS.AUTHORIZED, authorizedListener);
+      web3Auth.on(CONNECTOR_EVENTS.DISCONNECTED, disconnectedListener);
+      web3Auth.on(CONNECTOR_EVENTS.CONNECTING, connectingListener);
+      web3Auth.on(CONNECTOR_EVENTS.ERRORED, errorListener);
+      web3Auth.on(CONNECTOR_EVENTS.REHYDRATION_ERROR, rehydrationErrorListener);
+      web3Auth.on(CONNECTOR_EVENTS.MFA_ENABLED, mfaEnabledListener);
+      if (web3Auth.loginMode === LOGIN_MODE.MODAL) {
+        web3Auth.on(CONNECTOR_EVENTS.CONSENT_ACCEPTED, consentAcceptedListener);
+      }
+    }
+    return () => {
+      if (!web3Auth) return;
+      web3Auth.removeListener(CONNECTOR_EVENTS.NOT_READY, notReadyListener);
+      web3Auth.removeListener(CONNECTOR_EVENTS.READY, readyListener);
+      web3Auth.removeListener(CONNECTOR_EVENTS.CONNECTED, connectedListener);
+      web3Auth.removeListener(CONNECTOR_EVENTS.DISCONNECTED, disconnectedListener);
+      web3Auth.removeListener(CONNECTOR_EVENTS.CONNECTING, connectingListener);
+      web3Auth.removeListener(CONNECTOR_EVENTS.ERRORED, errorListener);
+      web3Auth.removeListener(CONNECTOR_EVENTS.REHYDRATION_ERROR, rehydrationErrorListener);
+      web3Auth.removeListener(CONNECTOR_EVENTS.MFA_ENABLED, mfaEnabledListener);
+      web3Auth.removeListener(CONNECTOR_EVENTS.AUTHORIZED, authorizedListener);
+      if (web3Auth.loginMode === LOGIN_MODE.MODAL) {
+        web3Auth.removeListener(CONNECTOR_EVENTS.CONSENT_ACCEPTED, consentAcceptedListener);
+      }
+      if (cleanupOnUnmount) {
+        web3Auth.cleanup();
+      }
+    };
+  }, [cleanupOnUnmount, notReadyUsesCurrentStatus, web3Auth]);
+  return useMemo(() => {
+    return {
+      web3Auth,
+      isConnected,
+      isInitialized,
+      connection,
+      status,
+      isInitializing,
+      initError,
+      isMFAEnabled,
+      chainId,
+      chainNamespace,
+      getPlugin,
+      setIsMFAEnabled,
+      isAuthorized
+    };
+  }, [web3Auth, isConnected, isInitialized, connection, status, getPlugin, isInitializing, initError, isMFAEnabled, setIsMFAEnabled, chainId, chainNamespace, isAuthorized]);
+}
+
+export { useWeb3AuthInnerContextValue };

package/dist/lib.esm/react/hooks/{useIdentityToken.js → useAuthTokenInfo.js}

@@ -1,20 +1,19 @@
 import { useState, useCallback, useEffect } from 'react';
 import { useWeb3AuthInner } from './useWeb3AuthInner.js';
 
-const useIdentityToken = () => {
+const useAuthTokenInfo = () => {
   const {
     web3Auth,
-    isConnected,
     isAuthorized
   } = useWeb3AuthInner();
   const [loading, setLoading] = useState(false);
   const [error, setError] = useState(null);
   const [token, setToken] = useState(null);
-  const getIdentityToken = useCallback(async () => {
+  const getAuthTokenInfo = useCallback(async () => {
     setLoading(true);
     setError(null);
     try {
-      const userAuthInfo = await web3Auth.getIdentityToken();
+      const userAuthInfo = await web3Auth.getAuthTokenInfo();
       if (userAuthInfo !== null && userAuthInfo !== void 0 && userAuthInfo.idToken) {
         setToken(userAuthInfo.idToken);
       }
@@ -33,13 +32,13 @@ const useIdentityToken = () => {
     if (isAuthorized && !token) {
       setToken(web3Auth.idToken);
     }
-  }, [isConnected, isAuthorized, token]);
+  }, [isAuthorized, token, web3Auth]);
   return {
     loading,
     error,
     token,
-    getIdentityToken
+    getAuthTokenInfo
   };
 };
 
-export { useIdentityToken };
+export { useAuthTokenInfo };

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

@@ -2,16 +2,9 @@ import { useContext } from 'react';
 import { WalletServicesContext } from '../context/WalletServicesInnerContext.js';
 
 const useWalletServicesPlugin = () => {
-  const {
-    ready,
-    plugin,
-    connecting
-  } = useContext(WalletServicesContext);
-  return {
-    ready,
-    plugin,
-    connecting
-  };
+  const context = useContext(WalletServicesContext);
+  if (!context) throw new TypeError("WalletServicesContext not found");
+  return context;
 };
 
 export { useWalletServicesPlugin };

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

@@ -1,28 +1,7 @@
 import { useWeb3AuthInner } from './useWeb3AuthInner.js';
 
 const useWeb3Auth = () => {
-  const {
-    initError,
-    isConnected,
-    isAuthorized,
-    isInitialized,
-    isInitializing,
-    provider,
-    status,
-    web3Auth,
-    getPlugin
-  } = useWeb3AuthInner();
-  return {
-    initError,
-    isConnected,
-    isInitialized,
-    isInitializing,
-    provider,
-    status,
-    web3Auth,
-    isAuthorized,
-    getPlugin
-  };
+  return useWeb3AuthInner();
 };
 
 export { useWeb3Auth };

package/dist/lib.esm/react/index.js

@@ -1,17 +1,21 @@
 export { Web3AuthProvider } from './Web3AuthProvider.js';
+export { WalletServicesContext } from './context/WalletServicesInnerContext.js';
+export { Web3AuthInnerContext } from './context/Web3AuthInnerContext.js';
+export { useAuthTokenInfo } from './hooks/useAuthTokenInfo.js';
 export { useChain } from './hooks/useChain.js';
 export { useCheckout } from './hooks/useCheckout.js';
 export { useEnableMFA } from './hooks/useEnableMFA.js';
 export { useFunding } from './hooks/useFunding.js';
-export { useIdentityToken } from './hooks/useIdentityToken.js';
 export { useManageMFA } from './hooks/useManageMFA.js';
 export { useReceive } from './hooks/useReceive.js';
 export { useSwap } from './hooks/useSwap.js';
 export { useSwitchChain } from './hooks/useSwitchChain.js';
 export { useWalletConnectScanner } from './hooks/useWalletConnectScanner.js';
+export { useWalletServicesContextValue } from './context/useWalletServicesContextValue.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 { useWeb3AuthInnerContextValue } from './context/useWeb3AuthInnerContextValue.js';
 export { useWeb3AuthUser } from './hooks/useWeb3AuthUser.js';

package/dist/lib.esm/react/solana/hooks/useSignAndSendTransaction.js

@@ -1,5 +1,7 @@
 import { useState, useCallback } from 'react';
+import { WalletInitializationError } from '../../../base/errors/index.js';
 import { useSolanaWallet } from './useSolanaWallet.js';
+import { walletSignAndSendTransaction } from '../../../base/wallet/solana.js';
 
 const useSignAndSendTransaction = () => {
   const {
@@ -12,12 +14,12 @@ const useSignAndSendTransaction = () => {
     setLoading(true);
     setError(null);
     try {
-      if (!solanaWallet) throw new Error("Solana wallet not found");
-      const signature = await solanaWallet.signAndSendTransaction(transaction);
+      if (!solanaWallet) throw WalletInitializationError.notReady();
+      const signature = await walletSignAndSendTransaction(solanaWallet, transaction);
       setData(signature);
       return signature;
-    } catch (error) {
-      setError(error);
+    } catch (err) {
+      setError(err);
     } finally {
       setLoading(false);
     }

package/dist/lib.esm/react/solana/hooks/useSignMessage.js

@@ -1,5 +1,7 @@
 import { useState, useCallback } from 'react';
 import { useSolanaWallet } from './useSolanaWallet.js';
+import { WalletInitializationError } from '../../../base/errors/index.js';
+import { walletSignMessage } from '../../../base/wallet/solana.js';
 
 const useSignMessage = () => {
   const {
@@ -13,8 +15,8 @@ const useSignMessage = () => {
     setLoading(true);
     setError(null);
     try {
-      if (!solanaWallet) throw new Error("Solana wallet not found");
-      const signature = await solanaWallet.signMessage(message, from !== null && from !== void 0 ? from : accounts === null || accounts === void 0 ? void 0 : accounts[0]);
+      if (!solanaWallet) throw WalletInitializationError.notReady();
+      const signature = await walletSignMessage(solanaWallet, message, from !== null && from !== void 0 ? from : accounts === null || accounts === void 0 ? void 0 : accounts[0]);
       setData(signature);
       return signature;
     } catch (error) {

package/dist/lib.esm/react/solana/hooks/useSignTransaction.js

@@ -1,5 +1,7 @@
 import { useState, useCallback } from 'react';
+import { WalletInitializationError } from '../../../base/errors/index.js';
 import { useSolanaWallet } from './useSolanaWallet.js';
+import { walletSignTransaction } from '../../../base/wallet/solana.js';
 
 const useSignTransaction = () => {
   const {
@@ -12,11 +14,12 @@ const useSignTransaction = () => {
     setLoading(true);
     setError(null);
     try {
-      const signedTransaction = await solanaWallet.signTransaction(transaction);
+      if (!solanaWallet) throw WalletInitializationError.notReady();
+      const signedTransaction = await walletSignTransaction(solanaWallet, transaction);
       setData(signedTransaction);
       return signedTransaction;
-    } catch (error) {
-      setError(error);
+    } catch (err) {
+      setError(err);
     } finally {
       setLoading(false);
     }