@getpara/react-sdk 2.0.0-dev.1 → 2.0.0-dev.3

package/dist/provider/hooks/queries/useAccount.d.ts

@@ -1,11 +1,90 @@
+import { useContext } from 'react';
+import { Account } from '../../actions/getEmbeddedAccount.js';
+import type { CosmosExternalWalletContextType, UseAccountParameters as UseCosmosAccountParameters } from '@getpara/cosmos-wallet-connectors';
+import type { EvmExternalWalletContextType } from '@getpara/evm-wallet-connectors';
+import type { Adapter } from '@getpara/solana-wallet-connectors';
 export declare const ACCOUNT_BASE_KEY = "PARA_ACCOUNT";
+type EVMAccountType = ReturnType<ReturnType<typeof useContext<EvmExternalWalletContextType>>['useAccount']>;
+type CosmosAccountType = Omit<ReturnType<ReturnType<typeof useContext<CosmosExternalWalletContextType>>['useAccount']>, 'reconnect'>;
+type SolanaAccountType = Pick<Adapter, 'publicKey' | 'name' | 'icon' | 'readyState' | 'supportedTransactionVersions' | 'url'> & {
+    isConnected?: boolean;
+    isConnecting?: boolean;
+};
+type ConnectionType = 'embedded' | 'external' | 'both' | 'none';
+type ExternalNetwork = 'evm' | 'cosmos' | 'solana';
 /**
- * Hook for retrieving a user account
+ * The return type for the useAccount hook.
+ *
+ * @property isConnected - Indicates whether there is a wallet connected (either embedded, external or both).
+ * @property isLoading - Indicates whether the account is currently loading.
+ * @property connectionType - The type of connection for the account:
+ * @property embedded - The embedded account object.
+ * @property external - An object containing connected external wallet account data:
+ *   - `evm`: The connected EVM wallet account (if any).
+ *   - `cosmos`: The connected Cosmos wallet account (if any), with the `reconnect` property omitted.
+ *   - `solana`: The connected Solana wallet adapter, with only allowed properties included.
  */
-export declare const useAccount: () => import("@tanstack/react-query").UseQueryResult<{
+export type UseAccountReturn = {
+    /**
+     *  Indicates whether there is a wallet connected (either embedded, external or both).
+     */
     isConnected: boolean;
-    email?: string;
-    phone?: string;
-    wallets?: Pick<import("@getpara/core-sdk").Wallet, "id" | "type" | "name" | "address" | "isExternal">[];
-    userId?: string;
-}, Error>;
+    /**
+     *  Indicates whether the account is currently loading.
+     */
+    isLoading: boolean;
+    /**
+     * The type of connection for the account.
+     * - 'embedded': Only the embedded account is connected.
+     * - 'external': Only an external wallet is connected.
+     * - 'both': Both embedded and external wallets are connected.
+     * - 'none': No wallets are connected.
+     */
+    connectionType: ConnectionType;
+    /**
+     * The embedded account object. Use this instead of the deprecated top-level properties.
+     */
+    embedded: Omit<Account, 'isConnected' | 'isGuestMode'> & {
+        isConnected: boolean;
+        isGuestMode?: boolean;
+    };
+    /**
+     * Connected external wallet account data.
+     */
+    external: {
+        /**
+         * The list of connected external networks, which can include 'evm', 'cosmos', and 'solana'.
+         */
+        connectedNetworks: ExternalNetwork[];
+        /**
+         * The connected EVM wallet (if any), with only allowed properties included.
+         */
+        evm: EVMAccountType;
+        /**
+         * The connected Cosmos wallet (if any), with only allowed properties included.
+         */
+        cosmos: CosmosAccountType;
+        /**
+         * The connected Solana wallet (if any), with only allowed properties included.
+         */
+        solana: SolanaAccountType;
+    };
+};
+export type UseAccountParameters = {
+    cosmos?: UseCosmosAccountParameters;
+};
+/**
+ * React Query hook for retrieving the current embedded account and connected external wallets.
+ *
+ * @returns {UseAccountReturn}
+ *   The account data object, or undefined while loading.
+ *
+ * The returned object contains:
+ * - `isConnected`: Indicates whether there is a wallet connected (either embedded, external or both).
+ * - `isLoading`: Indicates whether the account is currently loading.
+ * - `connectionType`: The type of connection for the account:
+ * - `embedded`: The embedded account object.
+ * - `external`: Connected external wallet data (EVM, Cosmos, Solana).
+ */
+export declare const useAccount: ({ cosmos }?: UseAccountParameters) => UseAccountReturn;
+export {};

package/dist/provider/hooks/queries/useAccount.js

@@ -0,0 +1,135 @@
+"use client";
+import {
+  __async,
+  __objRest,
+  __spreadProps,
+  __spreadValues
+} from "../../../chunk-MMUBH76A.js";
+import { useQuery } from "@tanstack/react-query";
+import { useInternalClient } from "../utils/useInternalClient.js";
+import { useIsFullyLoggedIn } from "./useIsFullyLoggedIn.js";
+import { useStore } from "../../stores/useStore.js";
+import { useContext } from "react";
+import { getEmbeddedAccount } from "../../actions/getEmbeddedAccount.js";
+const ACCOUNT_BASE_KEY = "PARA_ACCOUNT";
+function pickSolanaAdapter(adapter) {
+  if (!adapter) return { isConnected: false };
+  const { connected, connecting, publicKey, name, icon, readyState, supportedTransactionVersions, url } = adapter;
+  return {
+    isConnected: connected,
+    isConnecting: connecting,
+    publicKey,
+    name,
+    icon,
+    readyState,
+    supportedTransactionVersions,
+    url
+  };
+}
+function pickCosmosAccount(account) {
+  if (!account) return { isConnected: false };
+  const _a = account, { reconnect: _ } = _a, rest = __objRest(_a, ["reconnect"]);
+  return rest;
+}
+const useAccount = ({ cosmos } = {}) => {
+  var _a, _b, _c, _d, _e, _f, _g;
+  const client = useInternalClient();
+  const { data: isFullyLoggedIn, isSuccess } = useIsFullyLoggedIn();
+  const evmContext = useStore((state) => state.evmContext);
+  const { useAccount: useEvmAccount } = useContext(evmContext);
+  const evmAccount = useEvmAccount();
+  const evmQueryKeys = [evmAccount == null ? void 0 : evmAccount.status, evmAccount == null ? void 0 : evmAccount.addresses, evmAccount == null ? void 0 : evmAccount.chainId];
+  const cosmosContext = useStore((state) => state.cosmosContext);
+  const { useAccount: useCosmosAccount } = useContext(cosmosContext);
+  const cosmosAccount = useCosmosAccount(cosmos);
+  const cosmosQueryKeys = [cosmosAccount == null ? void 0 : cosmosAccount.status, cosmosAccount == null ? void 0 : cosmosAccount.data];
+  const solanaContext = useStore((state) => state.solanaContext);
+  const { useWallet: useSolanaWallet } = useContext(solanaContext);
+  const solanaWallet = useSolanaWallet();
+  const solanaQueryKeys = [
+    (_b = (_a = solanaWallet == null ? void 0 : solanaWallet.wallet) == null ? void 0 : _a.adapter) == null ? void 0 : _b.connected,
+    (_d = (_c = solanaWallet == null ? void 0 : solanaWallet.wallet) == null ? void 0 : _c.adapter) == null ? void 0 : _d.connecting,
+    (_f = (_e = solanaWallet == null ? void 0 : solanaWallet.wallet) == null ? void 0 : _e.adapter) == null ? void 0 : _f.publicKey
+  ];
+  const solanaAdapter = (_g = solanaWallet == null ? void 0 : solanaWallet.wallet) == null ? void 0 : _g.adapter;
+  const { data, isLoading } = useQuery({
+    enabled: isSuccess && !!client,
+    queryKey: [ACCOUNT_BASE_KEY, isFullyLoggedIn != null ? isFullyLoggedIn : null, client == null ? void 0 : client.userId, evmQueryKeys, cosmosQueryKeys, solanaQueryKeys],
+    queryFn: () => __async(void 0, null, function* () {
+      const paraAccount = yield getEmbeddedAccount(client);
+      let connectionType = "none";
+      if (paraAccount.isConnected) {
+        connectionType = "embedded";
+        if (paraAccount.wallets.some((w) => w.isExternal)) {
+          connectionType = "both";
+        }
+        if (paraAccount.wallets.every((w) => w.isExternal) && ((evmAccount == null ? void 0 : evmAccount.isConnected) || (cosmosAccount == null ? void 0 : cosmosAccount.isConnected) || (solanaAdapter == null ? void 0 : solanaAdapter.connected))) {
+          connectionType = "external";
+        }
+      }
+      const isEmbeddedConnected = paraAccount.isConnected && (!!paraAccount.userId || paraAccount.isGuestMode);
+      const connectedNetworks = [];
+      if (evmAccount == null ? void 0 : evmAccount.isConnected) {
+        connectedNetworks.push("evm");
+      }
+      if (cosmosAccount == null ? void 0 : cosmosAccount.isConnected) {
+        connectedNetworks.push("cosmos");
+      }
+      if (solanaAdapter == null ? void 0 : solanaAdapter.connected) {
+        connectedNetworks.push("solana");
+      }
+      return {
+        isConnected: paraAccount.isConnected,
+        connectionType,
+        embedded: __spreadProps(__spreadValues({}, paraAccount), { isConnected: isEmbeddedConnected }),
+        external: {
+          connectedNetworks,
+          evm: evmAccount != null ? evmAccount : {
+            address: void 0,
+            addresses: void 0,
+            chain: void 0,
+            chainId: void 0,
+            connector: void 0,
+            isConnected: false,
+            isReconnecting: false,
+            isConnecting: false,
+            isDisconnected: true,
+            status: "disconnected"
+          },
+          cosmos: pickCosmosAccount(cosmosAccount),
+          solana: pickSolanaAdapter(solanaAdapter)
+        }
+      };
+    })
+  });
+  const defaultResp = {
+    isConnected: false,
+    connectionType: "none",
+    isLoading,
+    embedded: {
+      isConnected: false
+    },
+    external: {
+      connectedNetworks: [],
+      evm: {
+        address: void 0,
+        addresses: void 0,
+        chain: void 0,
+        chainId: void 0,
+        connector: void 0,
+        isConnected: false,
+        isReconnecting: false,
+        isConnecting: false,
+        isDisconnected: true,
+        status: "disconnected"
+      },
+      cosmos: { isConnected: false },
+      solana: { isConnected: false }
+    }
+  };
+  return __spreadProps(__spreadValues({}, data != null ? data : defaultResp), { isLoading });
+};
+export {
+  ACCOUNT_BASE_KEY,
+  useAccount
+};

package/dist/provider/hooks/queries/useIsFullyLoggedIn.d.ts

@@ -0,0 +1,5 @@
+export declare const IS_FULLY_LOGGED_IN_BASE_KEY = "PARA_FULLY_LOGGED_IN";
+/**
+ * Hook for returning whether the user is fully logged in with Para
+ */
+export declare const useIsFullyLoggedIn: () => import("@tanstack/react-query").UseQueryResult<boolean, Error>;

package/dist/provider/hooks/queries/useIsFullyLoggedIn.js

@@ -0,0 +1,24 @@
+"use client";
+import {
+  __async
+} from "../../../chunk-MMUBH76A.js";
+import { useQuery } from "@tanstack/react-query";
+import { useInternalClient } from "../utils/useInternalClient.js";
+const IS_FULLY_LOGGED_IN_BASE_KEY = "PARA_FULLY_LOGGED_IN";
+const useIsFullyLoggedIn = () => {
+  var _a;
+  const client = useInternalClient();
+  return useQuery({
+    enabled: !!client,
+    staleTime: 5e3,
+    queryKey: [IS_FULLY_LOGGED_IN_BASE_KEY, (_a = client == null ? void 0 : client.userId) != null ? _a : null],
+    queryFn: () => __async(void 0, null, function* () {
+      var _a2;
+      return (_a2 = yield client == null ? void 0 : client.isFullyLoggedIn()) != null ? _a2 : false;
+    })
+  });
+};
+export {
+  IS_FULLY_LOGGED_IN_BASE_KEY,
+  useIsFullyLoggedIn
+};

package/dist/provider/hooks/queries/useWallet.d.ts

@@ -2,4 +2,4 @@ export declare const WALLET_BASE_KEY = "PARA_WALLET";
 /**
  * Hook for retrieving the selected wallet
  */
-export declare const useWallet: () => import("@tanstack/react-query").UseQueryResult<Omit<import("@getpara/core-sdk").Wallet, "signer"> | null | undefined, Error>;
+export declare const useWallet: () => import("@tanstack/react-query").UseQueryResult<Omit<import("@getpara/core-sdk").Wallet, "signer"> | null, Error>;

package/dist/provider/hooks/queries/useWallet.js

@@ -0,0 +1,26 @@
+"use client";
+import {
+  __async
+} from "../../../chunk-MMUBH76A.js";
+import { useQuery } from "@tanstack/react-query";
+import { useClient, useWalletState } from "../index.js";
+import { getWallet } from "../../actions/getWallet.js";
+import { useIsFullyLoggedIn } from "./useIsFullyLoggedIn.js";
+const WALLET_BASE_KEY = "PARA_WALLET";
+const useWallet = () => {
+  var _a, _b;
+  const client = useClient();
+  const { selectedWallet } = useWalletState();
+  const { data: isFullyLoggedIn, isSuccess } = useIsFullyLoggedIn();
+  return useQuery({
+    enabled: !!client && !!selectedWallet && isSuccess,
+    queryKey: [WALLET_BASE_KEY, isFullyLoggedIn != null ? isFullyLoggedIn : null, (_a = selectedWallet.id) != null ? _a : null, (_b = selectedWallet.type) != null ? _b : null],
+    queryFn: () => __async(void 0, null, function* () {
+      return yield getWallet(client, selectedWallet, isFullyLoggedIn);
+    })
+  });
+};
+export {
+  WALLET_BASE_KEY,
+  useWallet
+};

package/dist/provider/hooks/queries/useWalletBalance.d.ts

@@ -0,0 +1,6 @@
+import { GetWalletBalanceParams } from '@getpara/web-sdk';
+export declare const WALLET_BALANCE_BASE_KEY = "PARA_WALLET_BALANCE";
+/**
+ * Hook for retrieving a wallet balance
+ */
+export declare const useWalletBalance: (args?: Partial<GetWalletBalanceParams>) => import("@tanstack/react-query").UseQueryResult<string | null, Error>;

package/dist/provider/hooks/queries/useWalletBalance.js

@@ -0,0 +1,55 @@
+"use client";
+import {
+  __async,
+  __spreadValues
+} from "../../../chunk-MMUBH76A.js";
+import { useQuery } from "@tanstack/react-query";
+import { useAccount, useClient, useWallet, useWalletState } from "../index.js";
+import { useStore } from "../../stores/useStore.js";
+import { getWalletBalance } from "../../actions/index.js";
+import { useExternalWallets } from "../../providers/ExternalWalletProvider.js";
+import { useCallback } from "react";
+const WALLET_BALANCE_BASE_KEY = "PARA_WALLET_BALANCE";
+const useWalletBalance = (args) => {
+  const client = useClient();
+  const { data: selectedWallet } = useWallet();
+  const {
+    selectedWallet: { type: selectedWalletType }
+  } = useWalletState();
+  const { embedded } = useAccount();
+  const rpcUrl = useStore((state) => state.rpcUrl);
+  const { getWalletBalance: getExternalWalletBalance, chainId } = useExternalWallets();
+  const queryFn = useCallback(() => __async(void 0, null, function* () {
+    var _a, _b, _c;
+    const skipGetBalance = !selectedWallet || selectedWalletType && ["COSMOS", "SOLANA"].includes(selectedWalletType);
+    if (skipGetBalance) {
+      return null;
+    }
+    try {
+      if (selectedWallet.isExternal) {
+        return (_a = yield getExternalWalletBalance()) != null ? _a : null;
+      } else {
+        const completeArgs = __spreadValues({ walletId: (_b = selectedWallet == null ? void 0 : selectedWallet.id) != null ? _b : "", rpcUrl }, args);
+        return (_c = yield getWalletBalance(client, completeArgs)) != null ? _c : null;
+      }
+    } catch (err) {
+      console.error("Error fetching wallet balance: ", err);
+      return null;
+    }
+  }), [embedded, selectedWallet, selectedWalletType, rpcUrl, getExternalWalletBalance]);
+  return useQuery({
+    queryKey: [
+      WALLET_BALANCE_BASE_KEY,
+      client == null ? void 0 : client.userId,
+      selectedWallet == null ? void 0 : selectedWallet.id,
+      selectedWallet == null ? void 0 : selectedWallet.type,
+      (selectedWallet == null ? void 0 : selectedWallet.isExternal) ? chainId : ""
+    ],
+    queryFn,
+    enabled: !!client && !!selectedWallet && !!rpcUrl && !!(embedded == null ? void 0 : embedded.isConnected)
+  });
+};
+export {
+  WALLET_BALANCE_BASE_KEY,
+  useWalletBalance
+};

package/dist/provider/hooks/queries/utils.d.ts

@@ -0,0 +1,7 @@
+import { CoreMethodName, CoreMethodParams, CoreMethods } from '@getpara/web-sdk';
+import { CoreMethodQueryHook } from '../../types/utils.js';
+import { CoreAction } from '../../actions/utils.js';
+export declare function generateCoreQueryHook<const method extends CoreMethodName & keyof CoreMethods>(method: method, action: CoreAction<method>, { isGetter, defaultParams }?: {
+    isGetter?: boolean;
+    defaultParams?: CoreMethodParams<method>;
+}): (params?: CoreMethodParams<method>) => CoreMethodQueryHook<method>;

package/dist/provider/hooks/queries/utils.js

@@ -0,0 +1,25 @@
+"use client";
+import {
+  __async
+} from "../../../chunk-MMUBH76A.js";
+import { useClient } from "../utils/index.js";
+import { useQuery } from "@tanstack/react-query";
+function generateCoreQueryHook(method, action, { isGetter = false, defaultParams } = {}) {
+  return (params = defaultParams) => {
+    var _a;
+    const para = useClient();
+    return useQuery({
+      queryKey: [method, params != null ? params : null, isGetter ? (_a = para == null ? void 0 : para[method]) != null ? _a : null : null],
+      queryFn: (_0) => __async(this, [_0], function* ({ queryKey: [_, params2] }) {
+        if (!para) {
+          return null;
+        }
+        const result = params2 ? yield action(para, params2) : defaultParams ? yield action(para, defaultParams) : yield action(para);
+        return result != null ? result : null;
+      })
+    });
+  };
+}
+export {
+  generateCoreQueryHook
+};

package/dist/provider/hooks/utils/index.js

@@ -0,0 +1,10 @@
+"use client";
+import "../../../chunk-MMUBH76A.js";
+import { useClient } from "./useClient.js";
+import { useModal } from "./useModal.js";
+import { useWalletState } from "./useWalletState.js";
+export {
+  useClient,
+  useModal,
+  useWalletState
+};

package/dist/provider/hooks/utils/useAutoSessionKeepAlive.js

@@ -0,0 +1,74 @@
+"use client";
+import {
+  __async
+} from "../../../chunk-MMUBH76A.js";
+import { useEffect, useRef } from "react";
+import { useAccount, useKeepSessionAlive, useLogout } from "../index.js";
+import { useInternalClient } from "./useInternalClient.js";
+const SESSION_CHECK_INTERVAL = 6e4;
+const SESSION_REFRESH_THRESHOLD = 3e5;
+const useAutoSessionKeepAlive = ({ disabled }) => {
+  const client = useInternalClient();
+  const { embedded } = useAccount();
+  const { logoutAsync } = useLogout();
+  const { keepSessionAliveAsync } = useKeepSessionAlive();
+  const sessionCheckInterval = useRef(null);
+  useEffect(() => {
+    if (!client || disabled) {
+      clearSessionMonitoring();
+      return;
+    }
+    if ((embedded == null ? void 0 : embedded.isConnected) && !embedded.isGuestMode && client.externalWalletConnectionType !== "CONNECTION_ONLY") {
+      setupSessionMonitoring();
+    } else {
+      clearSessionMonitoring();
+    }
+    return () => clearSessionMonitoring();
+  }, [client, embedded, disabled]);
+  const getSessionExpiry = () => __async(void 0, null, function* () {
+    try {
+      const sessionCookie = yield client == null ? void 0 : client.retrieveSessionCookie();
+      if (!sessionCookie) return null;
+      const expiresMatch = sessionCookie.match(/Expires=([^;]+)/);
+      return expiresMatch ? new Date(expiresMatch[1]) : null;
+    } catch (err) {
+      return null;
+    }
+  });
+  const setupSessionMonitoring = () => {
+    clearSessionMonitoring();
+    sessionCheckInterval.current = setInterval(() => __async(void 0, null, function* () {
+      const expiry = yield getSessionExpiry();
+      if (!expiry) {
+        yield logoutAsync({});
+        clearSessionMonitoring();
+        return;
+      }
+      const timeUntilExpiry = expiry.getTime() - Date.now();
+      if (timeUntilExpiry <= 0) {
+        yield logoutAsync({});
+        clearSessionMonitoring();
+        return;
+      }
+      if (timeUntilExpiry <= SESSION_REFRESH_THRESHOLD) {
+        try {
+          yield keepSessionAliveAsync();
+          setupSessionMonitoring();
+        } catch (err) {
+          console.error("Failed to keep session alive:", err);
+          yield logoutAsync({});
+          clearSessionMonitoring();
+        }
+        return;
+      }
+    }), SESSION_CHECK_INTERVAL);
+  };
+  const clearSessionMonitoring = () => {
+    if (sessionCheckInterval.current) {
+      clearInterval(sessionCheckInterval.current);
+    }
+  };
+};
+export {
+  useAutoSessionKeepAlive
+};

package/dist/provider/hooks/utils/useClient.d.ts

@@ -2,4 +2,4 @@ import ParaWeb from '@getpara/web-sdk';
 /**
  * Hook for retrieving the Para client
  */
-export declare const useClient: () => ParaWeb | undefined;
+export declare const useClient: <Para extends ParaWeb = ParaWeb>() => Para | undefined;

package/dist/provider/hooks/utils/useClient.js

@@ -0,0 +1,10 @@
+"use client";
+import "../../../chunk-MMUBH76A.js";
+import { useStore } from "../../stores/useStore.js";
+const useClient = () => {
+  const client = useStore((state) => state.client);
+  return client;
+};
+export {
+  useClient
+};

package/dist/provider/hooks/utils/useEventListeners.d.ts

@@ -1,2 +1,2 @@
 import { Callbacks } from '../../types/provider.js';
-export declare const useEventListeners: ({ onLogin, onLogout, onAccountSetup, onAccountCreation, onSignMessage, onSignTransaction, onWalletCreated, onPregenWalletClaimed, onExternalWalletChange, onWalletsChange, }?: Callbacks) => void;
+export declare const useEventListeners: ({ onLogin, onLogout, onAccountSetup, onAccountCreation, onSignMessage, onSignTransaction, onWalletCreated, onPregenWalletClaimed, onExternalWalletChange, onWalletsChange, onGuestWalletsCreated, }?: Callbacks) => void;

package/dist/provider/hooks/utils/useEventListeners.js

@@ -0,0 +1,157 @@
+"use client";
+import "../../../chunk-MMUBH76A.js";
+import { useQueryClient } from "@tanstack/react-query";
+import { useCallback, useEffect } from "react";
+import { useWalletState } from "../index.js";
+import {
+  ParaEvent
+} from "@getpara/web-sdk";
+import { ACCOUNT_BASE_KEY } from "../queries/useAccount.js";
+import { useStore } from "../../stores/useStore.js";
+import { WALLET_BASE_KEY } from "../queries/useWallet.js";
+import { WALLET_BALANCE_BASE_KEY } from "../queries/useWalletBalance.js";
+import { IS_FULLY_LOGGED_IN_BASE_KEY } from "../queries/useIsFullyLoggedIn.js";
+const useEventListeners = ({
+  onLogin,
+  onLogout,
+  onAccountSetup,
+  onAccountCreation,
+  onSignMessage,
+  onSignTransaction,
+  onWalletCreated,
+  onPregenWalletClaimed,
+  onExternalWalletChange,
+  onWalletsChange,
+  onGuestWalletsCreated
+} = {}) => {
+  const queryClient = useQueryClient();
+  const clearSelectedWallet = useStore((state) => state.clearSelectedWallet);
+  const { updateSelectedWallet } = useWalletState();
+  const loginOrSetupListener = useCallback(() => {
+    queryClient.refetchQueries({ queryKey: [IS_FULLY_LOGGED_IN_BASE_KEY] });
+    queryClient.refetchQueries({ queryKey: [ACCOUNT_BASE_KEY] });
+    queryClient.refetchQueries({ queryKey: [WALLET_BASE_KEY] });
+    queryClient.invalidateQueries({ queryKey: [WALLET_BALANCE_BASE_KEY], exact: false });
+  }, [queryClient]);
+  const loginListener = useCallback(
+    (event) => {
+      loginOrSetupListener();
+      onLogin == null ? void 0 : onLogin(event);
+    },
+    [loginOrSetupListener, onLogin]
+  );
+  const accountSetupListener = useCallback(
+    (event) => {
+      loginOrSetupListener();
+      onAccountSetup == null ? void 0 : onAccountSetup(event);
+    },
+    [loginOrSetupListener, onAccountSetup]
+  );
+  const accountCreationListener = useCallback(
+    (event) => {
+      onAccountCreation == null ? void 0 : onAccountCreation(event);
+    },
+    [onAccountCreation]
+  );
+  const logoutListener = useCallback(
+    (event) => {
+      queryClient.refetchQueries({ queryKey: [IS_FULLY_LOGGED_IN_BASE_KEY] });
+      queryClient.refetchQueries({ queryKey: [ACCOUNT_BASE_KEY] });
+      clearSelectedWallet();
+      onLogout == null ? void 0 : onLogout(event);
+    },
+    [queryClient, clearSelectedWallet, onLogout]
+  );
+  const signMessageListener = useCallback(
+    (event) => {
+      onSignMessage == null ? void 0 : onSignMessage(event);
+    },
+    [onSignMessage]
+  );
+  const signTransactionListener = useCallback(
+    (event) => {
+      onSignTransaction == null ? void 0 : onSignTransaction(event);
+    },
+    [onSignTransaction]
+  );
+  const walletChangeListener = useCallback(
+    (event) => {
+      queryClient.refetchQueries({ queryKey: [IS_FULLY_LOGGED_IN_BASE_KEY] });
+      queryClient.refetchQueries({ queryKey: [ACCOUNT_BASE_KEY] });
+      updateSelectedWallet();
+      onWalletsChange == null ? void 0 : onWalletsChange(event);
+    },
+    [queryClient, updateSelectedWallet, onWalletsChange]
+  );
+  const externalWalletChangeListener = useCallback(
+    (event) => {
+      queryClient.refetchQueries({ queryKey: [IS_FULLY_LOGGED_IN_BASE_KEY] });
+      queryClient.refetchQueries({ queryKey: [ACCOUNT_BASE_KEY] });
+      updateSelectedWallet();
+      onExternalWalletChange == null ? void 0 : onExternalWalletChange(event);
+    },
+    [queryClient, updateSelectedWallet, onExternalWalletChange]
+  );
+  const walletCreatedListener = useCallback(
+    (event) => {
+      onWalletCreated == null ? void 0 : onWalletCreated(event);
+    },
+    [onWalletCreated]
+  );
+  const pregenWalletClaimedListener = useCallback(
+    (event) => {
+      onPregenWalletClaimed == null ? void 0 : onPregenWalletClaimed(event);
+    },
+    [onPregenWalletClaimed]
+  );
+  const guestWalletsCreatedListener = useCallback(
+    (event) => {
+      queryClient.refetchQueries({ queryKey: [IS_FULLY_LOGGED_IN_BASE_KEY] });
+      queryClient.refetchQueries({ queryKey: [ACCOUNT_BASE_KEY] });
+      updateSelectedWallet();
+      onGuestWalletsCreated == null ? void 0 : onGuestWalletsCreated(event);
+    },
+    [queryClient, updateSelectedWallet, onGuestWalletsCreated]
+  );
+  useEffect(() => {
+    window.addEventListener(ParaEvent.LOGIN_EVENT, loginListener);
+    window.addEventListener(ParaEvent.ACCOUNT_SETUP_EVENT, accountSetupListener);
+    window.addEventListener(ParaEvent.ACCOUNT_CREATION_EVENT, accountCreationListener);
+    window.addEventListener(ParaEvent.LOGOUT_EVENT, logoutListener);
+    window.addEventListener(ParaEvent.SIGN_MESSAGE_EVENT, signMessageListener);
+    window.addEventListener(ParaEvent.SIGN_TRANSACTION_EVENT, signTransactionListener);
+    window.addEventListener(ParaEvent.WALLETS_CHANGE_EVENT, walletChangeListener);
+    window.addEventListener(ParaEvent.EXTERNAL_WALLET_CHANGE_EVENT, externalWalletChangeListener);
+    window.addEventListener(ParaEvent.WALLET_CREATED, walletCreatedListener);
+    window.addEventListener(ParaEvent.PREGEN_WALLET_CLAIMED, pregenWalletClaimedListener);
+    window.addEventListener(ParaEvent.GUEST_WALLETS_CREATED, guestWalletsCreatedListener);
+    return () => {
+      window.removeEventListener(ParaEvent.LOGIN_EVENT, loginListener);
+      window.removeEventListener(ParaEvent.ACCOUNT_SETUP_EVENT, accountSetupListener);
+      window.removeEventListener(ParaEvent.ACCOUNT_CREATION_EVENT, accountCreationListener);
+      window.removeEventListener(ParaEvent.LOGOUT_EVENT, logoutListener);
+      window.removeEventListener(ParaEvent.SIGN_MESSAGE_EVENT, signMessageListener);
+      window.removeEventListener(ParaEvent.SIGN_TRANSACTION_EVENT, signTransactionListener);
+      window.removeEventListener(ParaEvent.WALLETS_CHANGE_EVENT, walletChangeListener);
+      window.removeEventListener(ParaEvent.EXTERNAL_WALLET_CHANGE_EVENT, externalWalletChangeListener);
+      window.removeEventListener(ParaEvent.WALLET_CREATED, walletCreatedListener);
+      window.removeEventListener(ParaEvent.PREGEN_WALLET_CLAIMED, pregenWalletClaimedListener);
+      window.removeEventListener(ParaEvent.GUEST_WALLETS_CREATED, guestWalletsCreatedListener);
+    };
+  }, [
+    loginListener,
+    accountSetupListener,
+    accountCreationListener,
+    logoutListener,
+    signMessageListener,
+    signTransactionListener,
+    walletChangeListener,
+    externalWalletChangeListener,
+    walletCreatedListener,
+    pregenWalletClaimedListener,
+    guestWalletsCreatedListener
+  ]);
+};
+export {
+  useEventListeners
+};

package/dist/provider/hooks/utils/useFormattedBiometricHints.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Hook for getting formatted biometric hints
+ */
+export declare const useFormattedBiometricHints: () => import("@tanstack/react-query").UseQueryResult<import("@getpara/react-common").BiometricHints | null, Error>;