@web3auth/no-modal 10.0.0-beta.1 → 10.0.0-beta.10

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

@@ -0,0 +1,33 @@
+import { useState, useCallback } from 'react';
+import { useSolanaWallet } from './useSolanaWallet.js';
+
+const useSignAndSendTransaction = () => {
+  const {
+    solanaWallet
+  } = useSolanaWallet();
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState(null);
+  const [data, setData] = useState(null);
+  const signAndSendTransaction = useCallback(async transaction => {
+    setLoading(true);
+    setError(null);
+    try {
+      if (!solanaWallet) throw new Error("Solana wallet not found");
+      const signature = await solanaWallet.signAndSendTransaction(transaction);
+      setData(signature);
+      return signature;
+    } catch (error) {
+      setError(error);
+    } finally {
+      setLoading(false);
+    }
+  }, [solanaWallet]);
+  return {
+    loading,
+    error,
+    data,
+    signAndSendTransaction
+  };
+};
+
+export { useSignAndSendTransaction };

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

@@ -0,0 +1,34 @@
+import { useState, useCallback } from 'react';
+import { useSolanaWallet } from './useSolanaWallet.js';
+
+const useSignMessage = () => {
+  const {
+    solanaWallet,
+    accounts
+  } = useSolanaWallet();
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState(null);
+  const [data, setData] = useState(null);
+  const signMessage = useCallback(async (message, from) => {
+    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]);
+      setData(signature);
+      return signature;
+    } catch (error) {
+      setError(error);
+    } finally {
+      setLoading(false);
+    }
+  }, [solanaWallet, accounts]);
+  return {
+    loading,
+    error,
+    data,
+    signMessage
+  };
+};
+
+export { useSignMessage };

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

@@ -0,0 +1,32 @@
+import { useState, useCallback } from 'react';
+import { useSolanaWallet } from './useSolanaWallet.js';
+
+const useSignTransaction = () => {
+  const {
+    solanaWallet
+  } = useSolanaWallet();
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState(null);
+  const [data, setData] = useState(null);
+  const signTransaction = useCallback(async transaction => {
+    setLoading(true);
+    setError(null);
+    try {
+      const signedTransaction = await solanaWallet.signTransaction(transaction);
+      setData(signedTransaction);
+      return signedTransaction;
+    } catch (error) {
+      setError(error);
+    } finally {
+      setLoading(false);
+    }
+  }, [solanaWallet]);
+  return {
+    loading,
+    error,
+    data,
+    signTransaction
+  };
+};
+
+export { useSignTransaction };

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

@@ -0,0 +1,42 @@
+import { Connection } from '@solana/web3.js';
+import { useState, useMemo, useEffect } from 'react';
+import { CHAIN_NAMESPACES } from '@toruslabs/base-controllers';
+import { useWeb3Auth } from '../../hooks/useWeb3Auth.js';
+import { SolanaWallet } from '../../../providers/solana-provider/solanaWallet.js';
+
+const useSolanaWallet = () => {
+  const {
+    provider,
+    web3Auth
+  } = useWeb3Auth();
+  const [accounts, setAccounts] = useState(null);
+  const solanaWallet = useMemo(() => {
+    if (!provider) return null;
+    return new SolanaWallet(provider);
+  }, [provider]);
+  const connection = useMemo(() => {
+    if (!web3Auth || !provider) return null;
+    return new Connection(web3Auth.currentChain.rpcTarget);
+  }, [web3Auth, provider]);
+  useEffect(() => {
+    const init = async () => {
+      var _web3Auth$currentChai;
+      if (!solanaWallet) return;
+      if (!(web3Auth !== null && web3Auth !== void 0 && (_web3Auth$currentChai = web3Auth.currentChain) !== null && _web3Auth$currentChai !== void 0 && _web3Auth$currentChai.chainNamespace) || web3Auth.currentChain.chainNamespace !== CHAIN_NAMESPACES.SOLANA) {
+        return;
+      }
+      const accounts = await solanaWallet.requestAccounts();
+      if ((accounts === null || accounts === void 0 ? void 0 : accounts.length) > 0) {
+        setAccounts(accounts);
+      }
+    };
+    if (solanaWallet) init();
+  }, [solanaWallet]);
+  return {
+    solanaWallet,
+    accounts,
+    connection
+  };
+};
+
+export { useSolanaWallet };

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

@@ -0,0 +1,4 @@
+export { useSignAndSendTransaction } from './hooks/useSignAndSendTransaction.js';
+export { useSignMessage } from './hooks/useSignMessage.js';
+export { useSignTransaction } from './hooks/useSignTransaction.js';
+export { useSolanaWallet } from './hooks/useSolanaWallet.js';

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

@@ -0,0 +1,14 @@
+import { createConfig, http } from 'wagmi';
+import { mainnet } from 'wagmi/chains';
+
+const defaultWagmiConfig = createConfig({
+  chains: [mainnet],
+  connectors: [],
+  // or your basic wallets
+  ssr: true,
+  transports: {
+    [mainnet.id]: http(mainnet.rpcUrls.default.http[0])
+  }
+});
+
+export { defaultWagmiConfig };

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

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

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

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

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

@@ -0,0 +1,71 @@
+import { defineComponent, h, shallowRef, ref, watch, provide } from 'vue';
+import { useWeb3AuthInner } from './composables/useWeb3AuthInner.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);
+        if (!walletServicesPlugin.value) 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.off(PLUGIN_EVENTS.CONNECTED, connectedListener);
+        prevWalletServicesPlugin.off(PLUGIN_EVENTS.DISCONNECTED, disconnectedListener);
+        prevWalletServicesPlugin.off(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
+    });
+  },
+  render() {
+    var _this$$slots$default;
+    return h((_this$$slots$default = this.$slots.default) !== null && _this$$slots$default !== void 0 ? _this$$slots$default : "");
+  }
+});
+
+export { WalletServicesInnerProvider };

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

@@ -0,0 +1,154 @@
+import { defineComponent, h, shallowRef, ref, watch, provide } from 'vue';
+import { Web3AuthNoModal } from '../noModal.js';
+import { WalletServicesInnerProvider } from './WalletServicesInnerProvider.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",
+  props: {
+    config: {
+      type: Object,
+      required: true
+    }
+  },
+  setup(props) {
+    const web3Auth = shallowRef(null);
+    const provider = ref(null);
+    const isMFAEnabled = ref(false);
+    const status = ref(null);
+    const isInitializing = ref(false);
+    const initError = ref(null);
+    const isInitialized = ref(false);
+    const isConnected = 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;
+        status.value = null;
+      };
+      onInvalidate(() => {
+        if (web3Auth.value) {
+          web3Auth.value.cleanup();
+        }
+      });
+      resetHookState();
+      const {
+        web3AuthOptions
+      } = newConfig;
+      const web3AuthInstance = new Web3AuthNoModal(web3AuthOptions);
+      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) {
+          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) {
+          if (!isInitialized.value) isInitialized.value = true;
+          isConnected.value = true;
+          provider.value = newWeb3Auth.provider;
+        }
+      };
+      const disconnectedListener = () => {
+        status.value = web3Auth.value.status;
+        isConnected.value = false;
+        provider.value = null;
+        isMFAEnabled.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.off(CONNECTOR_EVENTS.NOT_READY, notReadyListener);
+        prevWeb3Auth.off(CONNECTOR_EVENTS.READY, readyListener);
+        prevWeb3Auth.off(CONNECTOR_EVENTS.CONNECTED, connectedListener);
+        prevWeb3Auth.off(CONNECTOR_EVENTS.DISCONNECTED, disconnectedListener);
+        prevWeb3Auth.off(CONNECTOR_EVENTS.CONNECTING, connectingListener);
+        prevWeb3Auth.off(CONNECTOR_EVENTS.ERRORED, errorListener);
+        prevWeb3Auth.off(CONNECTOR_EVENTS.REHYDRATION_ERROR, errorListener);
+        prevWeb3Auth.off(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.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
+    });
+    provide(Web3AuthContextKey, {
+      web3Auth,
+      isConnected,
+      isInitialized,
+      provider,
+      status,
+      isInitializing,
+      initError,
+      isMFAEnabled,
+      getPlugin,
+      setIsMFAEnabled
+    });
+  },
+  render() {
+    var _this$$slots$default;
+    return h(WalletServicesInnerProvider, {}, (_this$$slots$default = this.$slots.default) !== null && _this$$slots$default !== void 0 ? _this$$slots$default : "");
+  }
+});
+
+export { Web3AuthProvider };

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

@@ -0,0 +1,32 @@
+import { ref } from 'vue';
+import { useWalletServicesPlugin } from './useWalletServicesPlugin.js';
+import { WalletServicesPluginError } from '../../base/plugin/errors.js';
+
+const useCheckout = () => {
+  const {
+    plugin,
+    ready
+  } = useWalletServicesPlugin();
+  const loading = ref(false);
+  const error = ref(null);
+  const showCheckout = async showCheckoutParams => {
+    loading.value = true;
+    error.value = null;
+    try {
+      if (!plugin) throw WalletServicesPluginError.notInitialized();
+      if (!ready) throw WalletServicesPluginError.walletPluginNotConnected();
+      await plugin.value.showCheckout(showCheckoutParams);
+    } catch (err) {
+      error.value = err;
+    } finally {
+      loading.value = false;
+    }
+  };
+  return {
+    loading,
+    error,
+    showCheckout
+  };
+};
+
+export { useCheckout };

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

@@ -0,0 +1,30 @@
+import { ref } from 'vue';
+import { useWeb3AuthInner } from './useWeb3AuthInner.js';
+import { WalletInitializationError } from '../../base/errors/index.js';
+
+const useEnableMFA = () => {
+  const {
+    web3Auth
+  } = useWeb3AuthInner();
+  const loading = ref(false);
+  const error = ref(null);
+  const enableMFA = async () => {
+    try {
+      if (!web3Auth.value) throw WalletInitializationError.notReady();
+      error.value = null;
+      loading.value = true;
+      await web3Auth.value.enableMFA();
+    } catch (err) {
+      error.value = err;
+    } finally {
+      loading.value = false;
+    }
+  };
+  return {
+    loading,
+    error,
+    enableMFA
+  };
+};
+
+export { useEnableMFA };

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

@@ -0,0 +1,42 @@
+import { ref, watch } from 'vue';
+import { useWeb3AuthInner } from './useWeb3AuthInner.js';
+import { WalletInitializationError } from '../../base/errors/index.js';
+
+const useIdentityToken = () => {
+  const {
+    web3Auth,
+    isConnected
+  } = useWeb3AuthInner();
+  const loading = ref(false);
+  const error = ref(null);
+  const token = ref(null);
+  const authenticateUser = async () => {
+    try {
+      if (!web3Auth.value) throw WalletInitializationError.notReady();
+      error.value = null;
+      loading.value = true;
+      const result = await web3Auth.value.authenticateUser();
+      if (result !== null && result !== void 0 && result.idToken) {
+        token.value = result.idToken;
+      }
+      return result === null || result === void 0 ? void 0 : result.idToken;
+    } catch (err) {
+      error.value = err;
+    } finally {
+      loading.value = false;
+    }
+  };
+  watch(isConnected, newIsConnected => {
+    if (!newIsConnected && token.value) {
+      token.value = null;
+    }
+  });
+  return {
+    loading,
+    error,
+    token,
+    authenticateUser
+  };
+};
+
+export { useIdentityToken };