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

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

@@ -1,46 +1,51 @@
-import { Connection } from '@solana/web3.js';
-import { useState, useMemo, useEffect } from 'react';
+import { createSolanaRpc } from '@solana/kit';
+import { SOLANA_METHOD_TYPES } from '@web3auth/ws-embed';
+import { useMemo, useCallback } from 'react';
 import { CHAIN_NAMESPACES } from '@toruslabs/base-controllers';
-import { useWeb3Auth } from '../../hooks/useWeb3Auth.js';
+import { WALLET_CONNECTORS } from '../../../base/wallet/index.js';
 import { useChain } from '../../hooks/useChain.js';
-import { SolanaWallet } from '../../../providers/solana-provider/solanaWallet.js';
+import { useWeb3Auth } from '../../hooks/useWeb3Auth.js';
 
 const useSolanaWallet = () => {
   const {
-    provider,
+    connection,
     web3Auth
   } = useWeb3Auth();
   const {
     chainNamespace
   } = useChain();
-  const [accounts, setAccounts] = useState(null);
   const solanaWallet = useMemo(() => {
-    if (!provider) return null;
-    if (chainNamespace !== CHAIN_NAMESPACES.SOLANA) return null;
-    return new SolanaWallet(provider);
-  }, [provider, chainNamespace]);
-  const connection = useMemo(() => {
-    if (!web3Auth || !provider || chainNamespace !== CHAIN_NAMESPACES.SOLANA) return null;
-    return new Connection(web3Auth.currentChain.rpcTarget);
-  }, [web3Auth, provider, chainNamespace]);
-  useEffect(() => {
-    const init = async () => {
-      if (chainNamespace !== CHAIN_NAMESPACES.SOLANA) {
-        setAccounts(null);
-        return;
-      }
-      if (!solanaWallet) return;
-      const accounts = await solanaWallet.getAccounts();
-      if ((accounts === null || accounts === void 0 ? void 0 : accounts.length) > 0) {
-        setAccounts(accounts);
-      }
-    };
-    if (solanaWallet) init();
+    var _connection$solanaWal;
+    return (_connection$solanaWal = connection === null || connection === void 0 ? void 0 : connection.solanaWallet) !== null && _connection$solanaWal !== void 0 ? _connection$solanaWal : null;
+  }, [connection]);
+  const accounts = useMemo(() => {
+    if (chainNamespace !== CHAIN_NAMESPACES.SOLANA || !solanaWallet) return null;
+    const accts = solanaWallet.accounts.map(a => a.address);
+    return accts.length > 0 ? accts : null;
   }, [solanaWallet, chainNamespace]);
+  const rpc = useMemo(() => {
+    if (!web3Auth || !solanaWallet || chainNamespace !== CHAIN_NAMESPACES.SOLANA) return null;
+    return createSolanaRpc(web3Auth.currentChain.rpcTarget);
+  }, [web3Auth, solanaWallet, chainNamespace]);
+  const getPrivateKey = useCallback(async () => {
+    var _web3Auth$connectedCo;
+    if (!web3Auth) throw new Error("Web3Auth not initialized");
+    if ((connection === null || connection === void 0 ? void 0 : connection.connectorName) !== WALLET_CONNECTORS.AUTH) {
+      throw new Error("getPrivateKey is only supported with the Auth connector");
+    }
+    const provider = (_web3Auth$connectedCo = web3Auth.connectedConnector) === null || _web3Auth$connectedCo === void 0 ? void 0 : _web3Auth$connectedCo.provider;
+    if (!provider) throw new Error("Provider not available");
+    const privateKey = await provider.request({
+      method: SOLANA_METHOD_TYPES.SOLANA_PRIVATE_KEY
+    });
+    if (!privateKey) throw new Error("Failed to retrieve private key");
+    return privateKey;
+  }, [web3Auth, connection]);
   return {
     solanaWallet,
     accounts,
-    connection
+    rpc,
+    getPrivateKey
   };
 };
 

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

@@ -1,3 +1,4 @@
+export { SolanaProvider } from './provider.js';
 export { useSignAndSendTransaction } from './hooks/useSignAndSendTransaction.js';
 export { useSignMessage } from './hooks/useSignMessage.js';
 export { useSignTransaction } from './hooks/useSignTransaction.js';

package/dist/lib.esm/react/solana/provider.js

@@ -0,0 +1,150 @@
+import _objectSpread from '@babel/runtime/helpers/objectSpread2';
+import _objectWithoutProperties from '@babel/runtime/helpers/objectWithoutProperties';
+import { createWalletStandardConnector, createClient } from '@solana/client';
+import { SolanaProvider as SolanaProvider$1 } from '@solana/react-hooks';
+import { createElement, useRef, useState, useEffect } from 'react';
+import { useChain } from '../hooks/useChain.js';
+import { useWeb3Auth } from '../hooks/useWeb3Auth.js';
+import { CHAIN_NAMESPACES } from '@toruslabs/base-controllers';
+import { log } from '../../base/loglevel.js';
+
+const _excluded = ["children"];
+const DEVNET_ENDPOINT = "https://api.devnet.solana.com";
+function placeholderRpc(isInitialized, web3Auth) {
+  var _web3Auth$coreOptions;
+  if (!isInitialized || !(web3Auth !== null && web3Auth !== void 0 && (_web3Auth$coreOptions = web3Auth.coreOptions) !== null && _web3Auth$coreOptions !== void 0 && _web3Auth$coreOptions.chains)) {
+    return {
+      rpcTarget: DEVNET_ENDPOINT
+    };
+  }
+  const solanaChains = web3Auth.coreOptions.chains.filter(c => c.chainNamespace === CHAIN_NAMESPACES.SOLANA);
+  const current = web3Auth.currentChain;
+  const chain = (current === null || current === void 0 ? void 0 : current.chainNamespace) === CHAIN_NAMESPACES.SOLANA ? current : solanaChains[0];
+  if (!chain) return {
+    rpcTarget: DEVNET_ENDPOINT
+  };
+  return {
+    rpcTarget: chain.rpcTarget,
+    wsTarget: chain.wsTarget
+  };
+}
+function makePlaceholder(rpc) {
+  return createClient({
+    endpoint: rpc.rpcTarget,
+    websocketEndpoint: rpc.wsTarget,
+    walletConnectors: []
+  });
+}
+function dispose(client) {
+  void client.actions.disconnectWallet().catch(() => {});
+  client.destroy();
+}
+
+/**
+ * Builds the SolanaClient for Framework Kit React hooks: placeholder when idle, Web3Auth-backed when
+ * connected on Solana. Ref + state so React re-renders on swap and effects dispose the right instance.
+ */
+function useFrameworkKitSolanaClient() {
+  const {
+    isConnected,
+    connection,
+    web3Auth,
+    isInitialized
+  } = useWeb3Auth();
+  const {
+    chainNamespace
+  } = useChain();
+  const ref = useRef(null);
+  const [client, setClient] = useState(() => {
+    const c = makePlaceholder({
+      rpcTarget: DEVNET_ENDPOINT
+    });
+    ref.current = c;
+    return c;
+  });
+  useEffect(() => {
+    if (isInitialized) web3Auth === null || web3Auth === void 0 || web3Auth.setAnalyticsProperties({
+      solana_framework_kit_enabled: true
+    });
+  }, [isInitialized, web3Auth]);
+  useEffect(() => () => {
+    const c = ref.current;
+    if (c) {
+      dispose(c);
+      ref.current = null;
+    }
+  }, []);
+  useEffect(() => {
+    let stale = false;
+    const adopt = next => {
+      if (stale) {
+        dispose(next);
+        return;
+      }
+      const prev = ref.current;
+      if (prev === next) return;
+      if (prev) dispose(prev);
+      ref.current = next;
+      setClient(next);
+    };
+    (async _web3Auth$currentChai => {
+      const rpc = placeholderRpc(isInitialized, web3Auth);
+      const solanaWallet = connection === null || connection === void 0 ? void 0 : connection.solanaWallet;
+      const onSolana = isConnected && Boolean(solanaWallet) && chainNamespace === CHAIN_NAMESPACES.SOLANA && (web3Auth === null || web3Auth === void 0 || (_web3Auth$currentChai = web3Auth.currentChain) === null || _web3Auth$currentChai === void 0 ? void 0 : _web3Auth$currentChai.chainNamespace) === CHAIN_NAMESPACES.SOLANA;
+      if (!onSolana) {
+        adopt(makePlaceholder(rpc));
+        return;
+      }
+      const conn = connection;
+      if (!conn || !solanaWallet) {
+        adopt(makePlaceholder(rpc));
+        return;
+      }
+      try {
+        const solanaWalletId = "wallet-standard:" + conn.connectorName;
+        const connector = createWalletStandardConnector(solanaWallet, {
+          id: solanaWalletId,
+          name: conn.connectorName
+        });
+        const {
+          rpcTarget,
+          wsTarget
+        } = web3Auth.currentChain;
+        const wired = createClient({
+          endpoint: rpcTarget,
+          websocketEndpoint: wsTarget,
+          walletConnectors: [connector]
+        });
+        await wired.actions.connectWallet(solanaWalletId, {
+          autoConnect: true
+        });
+        if (stale) {
+          dispose(wired);
+          return;
+        }
+        adopt(wired);
+      } catch (e) {
+        log.error("Failed to create or connect Solana client", e);
+        adopt(makePlaceholder(rpc));
+      }
+    })();
+    return () => {
+      stale = true;
+    };
+  }, [isConnected, connection === null || connection === void 0 ? void 0 : connection.solanaWallet, chainNamespace, web3Auth, isInitialized, connection === null || connection === void 0 ? void 0 : connection.connectorName]);
+  return client;
+}
+function SolanaProvider(_ref) {
+  let {
+      children
+    } = _ref,
+    props = _objectWithoutProperties(_ref, _excluded);
+  const client = useFrameworkKitSolanaClient();
+  return createElement(SolanaProvider$1, _objectSpread(_objectSpread({}, props), {}, {
+    client,
+    walletPersistence: false,
+    children
+  }));
+}
+
+export { SolanaProvider };

package/dist/lib.esm/react/wagmi/provider.js

@@ -2,7 +2,7 @@ import _objectWithoutProperties from '@babel/runtime/helpers/objectWithoutProper
 import _objectSpread from '@babel/runtime/helpers/objectSpread2';
 import { useMemo, createElement, useEffect, Fragment } from 'react';
 import { defineChain } from 'viem';
-import { createConfig, WagmiProvider as WagmiProvider$1, webSocket, http, fallback, useConfig, useReconnect, useAccountEffect } from 'wagmi';
+import { createConfig, WagmiProvider as WagmiProvider$1, webSocket, http, fallback, useConfig, useReconnect, useConnectionEffect } from 'wagmi';
 import { injected } from 'wagmi/connectors';
 import { defaultWagmiConfig } from './constants.js';
 import { useWeb3Auth } from '../hooks/useWeb3Auth.js';
@@ -78,16 +78,16 @@ function Web3AuthWagmiProvider({
 }) {
   const {
     isConnected,
-    provider
+    connection
   } = useWeb3Auth();
   const {
     disconnect
   } = useWeb3AuthDisconnect();
   const wagmiConfig = useConfig();
   const {
-    reconnect
+    mutate: reconnect
   } = useReconnect();
-  useAccountEffect({
+  useConnectionEffect({
     onDisconnect: async () => {
       log.info("Disconnected from wagmi");
       if (isConnected) await disconnect();
@@ -101,8 +101,8 @@ function Web3AuthWagmiProvider({
   });
   useEffect(() => {
     (async () => {
-      if (isConnected && provider) {
-        const connector = await setupConnector(provider, wagmiConfig);
+      if (isConnected && connection !== null && connection !== void 0 && connection.ethereumProvider) {
+        const connector = await setupConnector(connection.ethereumProvider, wagmiConfig);
         if (!connector) {
           throw new Error("Failed to setup connector");
         }
@@ -114,7 +114,7 @@ function Web3AuthWagmiProvider({
         }
       }
     })();
-  }, [isConnected, wagmiConfig, provider, reconnect]);
+  }, [isConnected, wagmiConfig, connection, reconnect]);
   return createElement(Fragment, null, children);
 }
 function WagmiProvider(_ref) {

package/dist/lib.esm/vue/WalletServicesInnerProvider.js

@@ -1,66 +1,16 @@
-import { defineComponent, h, shallowRef, ref, watch, provide } from 'vue';
+import { defineComponent, h, provide } from 'vue';
 import { useWeb3AuthInner } from './composables/useWeb3AuthInner.js';
+import { useWalletServicesInnerContextValue } from './useWalletServicesInnerContextValue.js';
 import { WalletServicesContextKey } from './context/WalletServicesContext.js';
 import { WalletServicesPluginError } from '../base/plugin/errors.js';
-import { EVM_PLUGINS, PLUGIN_EVENTS } from '../base/plugin/IPlugin.js';
-import { CONNECTOR_STATUS } from '../base/connector/constants.js';
 
 const WalletServicesInnerProvider = defineComponent({
   name: "WalletServicesInnerProvider",
   setup() {
     const web3AuthContext = useWeb3AuthInner();
     if (!web3AuthContext) throw WalletServicesPluginError.fromCode(1000, "`WalletServicesProvider` must be wrapped by `Web3AuthProvider`");
-    const {
-      getPlugin,
-      isInitialized,
-      isConnected
-    } = web3AuthContext;
-    const walletServicesPlugin = shallowRef(null);
-    const ready = ref(false);
-    const connecting = ref(false);
-    watch(isInitialized, newIsInitialized => {
-      if (newIsInitialized) {
-        const plugin = getPlugin(EVM_PLUGINS.WALLET_SERVICES);
-        walletServicesPlugin.value = plugin;
-      }
-    });
-    watch(isConnected, newIsConnected => {
-      if (newIsConnected) {
-        var _walletServicesPlugin;
-        const plugin = getPlugin(EVM_PLUGINS.WALLET_SERVICES);
-        walletServicesPlugin.value = plugin;
-        // when rehydrating, the connectedListener may be registered after the connected event is emitted, we need to check the status here
-        if (((_walletServicesPlugin = walletServicesPlugin.value) === null || _walletServicesPlugin === void 0 ? void 0 : _walletServicesPlugin.status) === CONNECTOR_STATUS.CONNECTED) ready.value = true;
-      }
-    });
-    watch(walletServicesPlugin, (newWalletServicesPlugin, prevWalletServicesPlugin) => {
-      const connectedListener = () => {
-        ready.value = true;
-      };
-      const disconnectedListener = () => {
-        ready.value = false;
-      };
-      const connectingListener = () => {
-        connecting.value = true;
-      };
-
-      // unregister previous listeners
-      if (prevWalletServicesPlugin && newWalletServicesPlugin !== prevWalletServicesPlugin) {
-        prevWalletServicesPlugin.removeListener(PLUGIN_EVENTS.CONNECTED, connectedListener);
-        prevWalletServicesPlugin.removeListener(PLUGIN_EVENTS.DISCONNECTED, disconnectedListener);
-        prevWalletServicesPlugin.removeListener(PLUGIN_EVENTS.CONNECTING, connectingListener);
-      }
-      if (newWalletServicesPlugin && newWalletServicesPlugin !== prevWalletServicesPlugin) {
-        newWalletServicesPlugin.on(PLUGIN_EVENTS.CONNECTED, connectedListener);
-        newWalletServicesPlugin.on(PLUGIN_EVENTS.DISCONNECTED, disconnectedListener);
-        newWalletServicesPlugin.on(PLUGIN_EVENTS.CONNECTING, connectingListener);
-      }
-    });
-    provide(WalletServicesContextKey, {
-      plugin: walletServicesPlugin,
-      ready,
-      connecting
-    });
+    const value = useWalletServicesInnerContextValue(web3AuthContext);
+    provide(WalletServicesContextKey, value);
   },
   render() {
     var _this$$slots$default;

package/dist/lib.esm/vue/Web3AuthProvider.js

@@ -1,11 +1,8 @@
-import { defineComponent, h, shallowRef, ref, watch, provide } from 'vue';
+import { defineComponent, h, provide } from 'vue';
 import { Web3AuthNoModal } from '../noModal.js';
+import { useWeb3AuthInnerContextValue } from './useWeb3AuthInnerContextValue.js';
 import { WalletServicesInnerProvider } from './WalletServicesInnerProvider.js';
-import { ANALYTICS_INTEGRATION_TYPE } from '../base/analytics.js';
-import { log } from '../base/loglevel.js';
-import { CONNECTOR_EVENTS, CONNECTOR_STATUS } from '../base/connector/constants.js';
 import { Web3AuthContextKey } from '../base/composables/index.js';
-import { WalletInitializationError } from '../base/errors/index.js';
 
 const Web3AuthProvider = defineComponent({
   name: "Web3AuthProvider",
@@ -16,181 +13,12 @@ const Web3AuthProvider = defineComponent({
     }
   },
   setup(props) {
-    const web3Auth = shallowRef(null);
-    const provider = ref(null);
-    const isMFAEnabled = ref(false);
-    const status = ref(null);
-    const chainId = ref(null);
-    const chainNamespace = ref(null);
-    const isInitializing = ref(false);
-    const initError = ref(null);
-    const isInitialized = ref(false);
-    const isConnected = ref(false);
-    const isAuthorized = ref(false);
-    const getPlugin = name => {
-      if (!web3Auth.value) throw WalletInitializationError.notReady();
-      return web3Auth.value.getPlugin(name);
-    };
-    const setIsMFAEnabled = isMfaEnabled => {
-      isMFAEnabled.value = isMfaEnabled;
-    };
-    watch(() => props.config, (newConfig, _, onInvalidate) => {
-      const resetHookState = () => {
-        provider.value = null;
-        isMFAEnabled.value = false;
-        isConnected.value = false;
-        isAuthorized.value = false;
-        status.value = null;
-        chainId.value = null;
-        chainNamespace.value = null;
-      };
-      onInvalidate(() => {
-        if (web3Auth.value) {
-          web3Auth.value.cleanup();
-        }
-      });
-      resetHookState();
-      const {
-        web3AuthOptions
-      } = newConfig;
-      const web3AuthInstance = new Web3AuthNoModal(web3AuthOptions);
-      web3AuthInstance.setAnalyticsProperties({
-        integration_type: ANALYTICS_INTEGRATION_TYPE.VUE_COMPOSABLES
-      });
-      web3Auth.value = web3AuthInstance;
-    }, {
-      immediate: true
-    });
-    watch(web3Auth, async (newWeb3Auth, _, onInvalidate) => {
-      const controller = new AbortController();
-
-      // Invalidate the controller here before calling any async methods.
-      onInvalidate(() => {
-        controller.abort();
-      });
-      if (newWeb3Auth) {
-        try {
-          initError.value = null;
-          isInitializing.value = true;
-          await newWeb3Auth.init({
-            signal: controller.signal
-          });
-        } catch (error) {
-          log.error("Error initializing web3auth", error);
-          initError.value = error;
-        } finally {
-          isInitializing.value = false;
-        }
-      }
-    }, {
-      immediate: true
-    });
-    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 === CONNECTOR_STATUS.CONNECTED) {
-          var _currentChain$chainNa, _currentChain;
-          if (!isInitialized.value) isInitialized.value = true;
-          isConnected.value = true;
-          provider.value = newWeb3Auth.provider;
-          chainId.value = web3Auth.value.currentChainId;
-          chainNamespace.value = (_currentChain$chainNa = (_currentChain = web3Auth.value.currentChain) === null || _currentChain === void 0 ? void 0 : _currentChain.chainNamespace) !== null && _currentChain$chainNa !== void 0 ? _currentChain$chainNa : null;
-        }
-      };
-      const authorizedListener = () => {
-        status.value = web3Auth.value.status;
-        if (web3Auth.value.status === CONNECTOR_STATUS.AUTHORIZED) {
-          isAuthorized.value = true;
-          isConnected.value = true;
-        }
-      };
-      const disconnectedListener = () => {
-        status.value = web3Auth.value.status;
-        isConnected.value = false;
-        provider.value = null;
-        isMFAEnabled.value = false;
-        isAuthorized.value = false;
-      };
-      const connectingListener = () => {
-        status.value = web3Auth.value.status;
-      };
-      const errorListener = () => {
-        status.value = web3Auth.value.status;
-      };
-      const mfaEnabledListener = () => {
-        isMFAEnabled.value = true;
-      };
-
-      // unregister previous listeners
-      if (prevWeb3Auth && newWeb3Auth !== prevWeb3Auth) {
-        prevWeb3Auth.removeListener(CONNECTOR_EVENTS.NOT_READY, notReadyListener);
-        prevWeb3Auth.removeListener(CONNECTOR_EVENTS.READY, readyListener);
-        prevWeb3Auth.removeListener(CONNECTOR_EVENTS.CONNECTED, connectedListener);
-        prevWeb3Auth.removeListener(CONNECTOR_EVENTS.AUTHORIZED, authorizedListener);
-        prevWeb3Auth.removeListener(CONNECTOR_EVENTS.DISCONNECTED, disconnectedListener);
-        prevWeb3Auth.removeListener(CONNECTOR_EVENTS.CONNECTING, connectingListener);
-        prevWeb3Auth.removeListener(CONNECTOR_EVENTS.ERRORED, errorListener);
-        prevWeb3Auth.removeListener(CONNECTOR_EVENTS.REHYDRATION_ERROR, errorListener);
-        prevWeb3Auth.removeListener(CONNECTOR_EVENTS.MFA_ENABLED, mfaEnabledListener);
-      }
-      if (newWeb3Auth && newWeb3Auth !== prevWeb3Auth) {
-        status.value = newWeb3Auth.status;
-        // web3Auth is initialized here.
-        newWeb3Auth.on(CONNECTOR_EVENTS.NOT_READY, notReadyListener);
-        newWeb3Auth.on(CONNECTOR_EVENTS.READY, readyListener);
-        newWeb3Auth.on(CONNECTOR_EVENTS.CONNECTED, connectedListener);
-        newWeb3Auth.on(CONNECTOR_EVENTS.AUTHORIZED, authorizedListener);
-        newWeb3Auth.on(CONNECTOR_EVENTS.DISCONNECTED, disconnectedListener);
-        newWeb3Auth.on(CONNECTOR_EVENTS.CONNECTING, connectingListener);
-        newWeb3Auth.on(CONNECTOR_EVENTS.ERRORED, errorListener);
-        newWeb3Auth.on(CONNECTOR_EVENTS.REHYDRATION_ERROR, errorListener);
-        newWeb3Auth.on(CONNECTOR_EVENTS.MFA_ENABLED, mfaEnabledListener);
-      }
-    }, {
-      immediate: true
-    });
-
-    // Listen for chain changes on the provider
-    watch(provider, (newProvider, prevProvider) => {
-      const handleChainChange = newChainId => {
-        var _web3Auth$value$curre, _web3Auth$value;
-        chainId.value = newChainId;
-        chainNamespace.value = (_web3Auth$value$curre = (_web3Auth$value = web3Auth.value) === null || _web3Auth$value === void 0 || (_web3Auth$value = _web3Auth$value.currentChain) === null || _web3Auth$value === void 0 ? void 0 : _web3Auth$value.chainNamespace) !== null && _web3Auth$value$curre !== void 0 ? _web3Auth$value$curre : null;
-      };
-
-      // unregister previous listener
-      if (prevProvider && newProvider !== prevProvider) {
-        prevProvider.removeListener("chainChanged", handleChainChange);
-      }
-      if (newProvider && newProvider !== prevProvider) {
-        newProvider.on("chainChanged", handleChainChange);
-      }
-    }, {
-      immediate: true
-    });
-    provide(Web3AuthContextKey, {
-      web3Auth,
-      isConnected,
-      isInitialized,
-      provider,
-      status,
-      isInitializing,
-      initError,
-      isMFAEnabled,
-      chainId,
-      chainNamespace,
-      getPlugin,
-      setIsMFAEnabled,
-      isAuthorized
+    const value = useWeb3AuthInnerContextValue({
+      Web3AuthConstructor: Web3AuthNoModal,
+      watchSource: () => props.config,
+      getWeb3AuthOptions: config => config.web3AuthOptions
     });
+    provide(Web3AuthContextKey, value);
   },
   render() {
     var _this$$slots$default;

package/dist/lib.esm/vue/composables/{useIdentityToken.js → useAuthTokenInfo.js}

@@ -3,7 +3,7 @@ import { useWeb3AuthInner } from './useWeb3AuthInner.js';
 import { WalletInitializationError } from '../../base/errors/index.js';
 import { log } from '../../base/loglevel.js';
 
-const useIdentityToken = () => {
+const useAuthTokenInfo = () => {
   const {
     web3Auth,
     isAuthorized
@@ -11,18 +11,18 @@ const useIdentityToken = () => {
   const loading = ref(false);
   const error = ref(null);
   const token = ref(null);
-  const getIdentityToken = async () => {
+  const getAuthTokenInfo = async () => {
     try {
       if (!web3Auth.value) throw WalletInitializationError.notReady();
       error.value = null;
       loading.value = true;
-      const result = await web3Auth.value.getIdentityToken();
+      const result = await web3Auth.value.getAuthTokenInfo();
       if (result !== null && result !== void 0 && result.idToken) {
         token.value = result.idToken;
       }
       return result === null || result === void 0 ? void 0 : result.idToken;
     } catch (err) {
-      log.error("Error getting identity token", err);
+      log.error("Error getting auth token info", err);
       error.value = err;
     } finally {
       loading.value = false;
@@ -43,8 +43,8 @@ const useIdentityToken = () => {
     loading,
     error,
     token,
-    getIdentityToken
+    getAuthTokenInfo
   };
 };
 
-export { useIdentityToken };
+export { useAuthTokenInfo };

package/dist/lib.esm/vue/composables/useInjectedWeb3AuthInnerContext.js

@@ -0,0 +1,11 @@
+import { inject } from 'vue';
+import { Web3AuthContextKey } from '../../base/composables/index.js';
+import { WalletInitializationError } from '../../base/errors/index.js';
+
+function useInjectedWeb3AuthInnerContext() {
+  const context = inject(Web3AuthContextKey);
+  if (!context) throw WalletInitializationError.fromCode(1000, "usage of `useWeb3Auth` not wrapped in `Web3AuthProvider`.");
+  return context;
+}
+
+export { useInjectedWeb3AuthInnerContext };

package/dist/lib.esm/vue/composables/useWeb3Auth.js

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

package/dist/lib.esm/vue/composables/useWeb3AuthInner.js

@@ -1,11 +1,7 @@
-import { inject } from 'vue';
-import { Web3AuthContextKey } from '../../base/composables/index.js';
-import { WalletInitializationError } from '../../base/errors/index.js';
+import { useInjectedWeb3AuthInnerContext } from './useInjectedWeb3AuthInnerContext.js';
 
 const useWeb3AuthInner = () => {
-  const context = inject(Web3AuthContextKey);
-  if (!context) throw WalletInitializationError.fromCode(1000, "usage of `useWeb3Auth` not wrapped in `Web3AuthProvider`.");
-  return context;
+  return useInjectedWeb3AuthInnerContext();
 };
 
 export { useWeb3AuthInner };