@dynamic-labs-sdk/react-hooks 1.17.0 → 1.18.0

package/dist/index.cjs

@@ -7,7 +7,7 @@ let _dynamic_labs_sdk_client_core = require("@dynamic-labs-sdk/client/core");
 
 //#region package.json
 var name = "@dynamic-labs-sdk/react-hooks";
-var version = "1.17.0";
+var version = "1.18.0";
 
 //#endregion
 //#region src/modules/DynamicContext/DynamicContext.ts
@@ -132,8 +132,8 @@ const QUERY_KEY_PREFIX = [HOOK_KEY_NAMESPACE, "query"];
 //#endregion
 //#region src/foundation/useBaseQuery/useBaseQuery.ts
 /**
-* Stable empty default for the `middlewares` param so the common (ungated)
-* case never allocates a fresh array per render.
+* Stable empty default for the `middlewares` param so the common case never
+* allocates a fresh array per render.
 */
 const EMPTY_MIDDLEWARES = [];
 /**
@@ -147,24 +147,117 @@ const EMPTY_MIDDLEWARES = [];
 *   so consumers can opt into retries / custom staleTime / etc.
 * - Callers pass `enabled: false` (typically derived from whether their
 *   pseudo-required arguments are present) to short-circuit fetches.
-* - Callers pass `middlewares` (named hooks that gate the query and/or run
-*   reactive subscriptions) and the query only runs when every one returns
-*   `true`.
+* - Callers pass `middlewares` (named hooks that run reactive subscriptions
+*   such as cache invalidation); each runs on every render.
 *
 * Returns the full `useQuery` result — `data`, `error`, `isLoading`,
 * `isFetching`, `isSuccess`, `refetch`, `status`, etc.
 */
 const useBaseQuery = ({ enabled = true, middlewares = EMPTY_MIDDLEWARES, queryFn, queryKey, queryParams }) => {
 	const client = useDynamicClient();
-	const middlewaresAllow = middlewares.map((useMiddleware) => useMiddleware()).every(Boolean);
+	const fullQueryKey = (0, react.useMemo)(() => [...QUERY_KEY_PREFIX, ...queryKey], [queryKey]);
+	middlewares.forEach((useMiddleware) => useMiddleware({ queryKey: fullQueryKey }));
 	return (0, _tanstack_react_query.useQuery)({
 		queryFn: async () => {
 			await (0, _dynamic_labs_sdk_client.waitForClientInitialized)(client);
 			return queryFn(client);
 		},
-		queryKey: (0, react.useMemo)(() => [...QUERY_KEY_PREFIX, ...queryKey], [queryKey]),
+		queryKey: fullQueryKey,
 		...queryParams,
-		enabled: enabled && middlewaresAllow && queryParams?.enabled !== false
+		enabled: enabled && queryParams?.enabled !== false
+	});
+};
+
+//#endregion
+//#region src/hooks/wrappers/functions/useOnWalletProviderEvent/useOnWalletProviderEvent.ts
+/**
+* Subscribes to an event emitted by a specific wallet provider.
+*
+* Wraps `onWalletProviderEvent` from `@dynamic-labs-sdk/client`. Uses a ref to
+* always call the latest callback without re-subscribing, and cleans up the
+* subscription on unmount or when `event` / `walletProviderKey` change. When
+* `walletProviderKey` is `undefined` the hook subscribes to nothing. When the
+* provider cannot be subscribed to (not registered on this client, or it does
+* not expose `events`), the hook logs and subscribes to nothing rather than
+* throwing — an effect throw would unmount the entire app.
+*
+* @example
+* ```tsx
+* useOnWalletProviderEvent({
+*   walletProviderKey: 'metamaskevm',
+*   event: 'accountsChanged',
+*   callback: ({ addresses }) => console.log(addresses),
+* });
+* ```
+*/
+const useOnWalletProviderEvent = ({ callback, event, walletProviderKey }) => {
+	const client = useDynamicClient();
+	const callbackRef = (0, react.useRef)(callback);
+	callbackRef.current = callback;
+	(0, react.useEffect)(() => {
+		if (walletProviderKey === void 0) return;
+		try {
+			return (0, _dynamic_labs_sdk_client.onWalletProviderEvent)({
+				callback: ((...args) => {
+					callbackRef.current(...args);
+				}),
+				event,
+				walletProviderKey
+			}, client);
+		} catch (error) {
+			(0, _dynamic_labs_sdk_client_core.getCore)(client).logger.debug("[useOnWalletProviderEvent] failed to subscribe to wallet provider event", {
+				error,
+				event,
+				walletProviderKey
+			});
+			return;
+		}
+	}, [
+		event,
+		walletProviderKey,
+		client
+	]);
+};
+
+//#endregion
+//#region src/middlewares/invalidateOnWalletProviderEvent/invalidateOnWalletProviderEvent.ts
+/**
+* Query middleware factory that refetches the query whenever the given wallet
+* account's provider emits `event` (e.g. `networkChanged`).
+*
+* It only wires up the subscription, invalidating the query's own cache key so
+* any mounted consumer refetches. This replaces the manual
+* `useOnWalletProviderEvent` + `refetch` boilerplate consumers would otherwise
+* pair with the hook. When `walletAccount` is undefined the subscription is a
+* no-op. The subscription lives here, not in `useBaseQuery`.
+*
+* @example
+* ```ts
+* useBaseQuery({
+*   middlewares: [
+*     invalidateOnWalletProviderEvent({ event: 'networkChanged', walletAccount }),
+*   ],
+*   queryFn: (client) => getActiveNetworkData({ walletAccount }, client),
+*   queryKey: ['useGetActiveNetworkData', walletAccount],
+* });
+* ```
+*/
+const invalidateOnWalletProviderEvent = ({ event, walletAccount }) => (context) => {
+	const client = useDynamicClient();
+	const queryClient = (0, _tanstack_react_query.useQueryClient)();
+	useOnWalletProviderEvent({
+		callback: () => {
+			if (!context) return;
+			queryClient.invalidateQueries({ queryKey: context.queryKey }).catch((error) => {
+				(0, _dynamic_labs_sdk_client_core.getCore)(client).logger.debug("[invalidateOnWalletProviderEvent] failed to invalidate query", {
+					error,
+					queryKey: context.queryKey,
+					stack: error instanceof Error ? error.stack : void 0
+				});
+			});
+		},
+		event,
+		walletProviderKey: walletAccount?.walletProviderKey
 	});
 };
 
@@ -179,6 +272,10 @@ const useBaseQuery = ({ enabled = true, middlewares = EMPTY_MIDDLEWARES, queryFn
 * ```
 */
 const useGetActiveNetworkData = ({ queryParams, ...args }) => useBaseQuery({
+	middlewares: [invalidateOnWalletProviderEvent({
+		event: "networkChanged",
+		walletAccount: args.walletAccount
+	})],
 	queryFn: (client) => (0, _dynamic_labs_sdk_client.getActiveNetworkData)(args, client),
 	queryKey: ["useGetActiveNetworkData", args],
 	queryParams
@@ -192,6 +289,10 @@ const useGetActiveNetworkData = ({ queryParams, ...args }) => useBaseQuery({
 * Wraps `getActiveNetworkId` from `@dynamic-labs-sdk/client`.
 */
 const useGetActiveNetworkId = ({ queryParams, ...args }) => useBaseQuery({
+	middlewares: [invalidateOnWalletProviderEvent({
+		event: "networkChanged",
+		walletAccount: args.walletAccount
+	})],
 	queryFn: (client) => (0, _dynamic_labs_sdk_client.getActiveNetworkId)(args, client),
 	queryKey: ["useGetActiveNetworkId", args],
 	queryParams
@@ -484,11 +585,17 @@ const useBaseState = ({ event, queryKey, queryParams, selector, defaultValue, sk
 /**
 * Returns the available wallet providers and their data.
 *
-* Re-renders when a wallet provider changes (e.g. network switch).
+* Re-renders when the wallet provider registry changes. `walletProviderChanged`
+* fires on register / priority update but NOT on removal, so
+* `walletProviderUnregistered` is wired too — otherwise a removed provider
+* would linger in the returned list.
 */
 const useGetAvailableWalletProvidersData = () => useBaseState({
 	defaultValue: [],
-	event: "walletProviderChanged",
+	event: {
+		walletProviderChanged: true,
+		walletProviderUnregistered: true
+	},
 	queryKey: ["useGetAvailableWalletProvidersData"],
 	selector: (client) => (0, _dynamic_labs_sdk_client.getAvailableWalletProvidersData)(client)
 });
@@ -698,14 +805,82 @@ const useConnectAndVerifyWithWalletProvider = ({ mutateParams } = {}) => useBase
 	mutationFn: ({ client, variables }) => (0, _dynamic_labs_sdk_client.connectAndVerifyWithWalletProvider)(variables, client)
 });
 
+//#endregion
+//#region src/hooks/wrappers/functions/useOnEvent/useOnEvent.ts
+/**
+* Subscribes to a Dynamic client event.
+*
+* Uses a ref to always call the latest listener without re-subscribing,
+* and cleans up the subscription on unmount or event name change.
+*/
+const useOnEvent = ({ event, listener }) => {
+	const client = useDynamicClient();
+	const callbackRef = (0, react.useRef)(listener);
+	callbackRef.current = listener;
+	(0, react.useEffect)(() => (0, _dynamic_labs_sdk_client.onEvent)({
+		event,
+		listener: (...args) => {
+			callbackRef.current(...args);
+		}
+	}, client), [event, client]);
+};
+
+//#endregion
+//#region src/middlewares/invalidateOnEvent/invalidateOnEvent.ts
+/**
+* Query middleware factory that refetches the query whenever the given client
+* event fires (e.g. `walletAccountsChanged`).
+*
+* It only wires up the subscription, invalidating the query's own cache key so
+* any mounted consumer refetches. This replaces the manual `useOnEvent` +
+* `refetch` boilerplate consumers would otherwise pair with the hook. It is the
+* client-event counterpart to `invalidateOnWalletProviderEvent` (which listens
+* on a single wallet account's provider). The subscription lives here, not in
+* `useBaseQuery`.
+*
+* @example
+* ```ts
+* useBaseQuery({
+*   middlewares: [invalidateOnEvent({ event: 'walletAccountsChanged' })],
+*   queryFn: (client) => getConnectedAddresses(args, client),
+*   queryKey: ['useGetConnectedAddresses', args],
+* });
+* ```
+*/
+const invalidateOnEvent = ({ event }) => (context) => {
+	const queryClient = (0, _tanstack_react_query.useQueryClient)();
+	const client = useDynamicClient();
+	useOnEvent({
+		event,
+		listener: (() => {
+			if (!context) return;
+			(0, _dynamic_labs_sdk_client_core.getCore)(client).logger.debug("[invalidateOnEvent] invalidating query on event", {
+				event,
+				queryKey: context.queryKey
+			});
+			queryClient.invalidateQueries({ queryKey: context.queryKey }).catch((error) => {
+				(0, _dynamic_labs_sdk_client_core.getCore)(client).logger.debug("[invalidateOnEvent] failed to invalidate query", {
+					error,
+					queryKey: context.queryKey,
+					stack: error instanceof Error ? error.stack : void 0
+				});
+			});
+		})
+	});
+};
+
 //#endregion
 //#region src/hooks/wrappers/functions/useGetConnectedAddresses/useGetConnectedAddresses.ts
 /**
 * Returns the connected addresses for the given wallet provider.
 *
-* Wraps `getConnectedAddresses` from `@dynamic-labs-sdk/client`.
+* Wraps `getConnectedAddresses` from `@dynamic-labs-sdk/client`. Automatically
+* refetches when wallet accounts change (connect / disconnect / verify), so
+* consumers don't have to pair it with a manual `walletAccountsChanged`
+* listener.
 */
 const useGetConnectedAddresses = ({ queryParams, ...args }) => useBaseQuery({
+	middlewares: [invalidateOnEvent({ event: "walletAccountsChanged" })],
 	queryFn: (client) => (0, _dynamic_labs_sdk_client.getConnectedAddresses)(args, client),
 	queryKey: ["useGetConnectedAddresses", args],
 	queryParams
@@ -837,6 +1012,7 @@ const useDeleteMfaDevice = ({ mutateParams } = {}) => {
 * ```
 */
 const useDeletePasskey = ({ mutateParams } = {}) => useBaseMutation({
+	middlewares: [invalidatesQueries("useGetPasskeys")],
 	mutateParams,
 	mutationFn: ({ client, variables }) => (0, _dynamic_labs_sdk_client.deletePasskey)(variables, client)
 });
@@ -863,26 +1039,6 @@ const useDeleteUser = ({ mutateParams } = {}) => useBaseMutation({
 	mutationFn: ({ client }) => (0, _dynamic_labs_sdk_client.deleteUser)(client)
 });
 
-//#endregion
-//#region src/hooks/wrappers/functions/useOnEvent/useOnEvent.ts
-/**
-* Subscribes to a Dynamic client event.
-*
-* Uses a ref to always call the latest listener without re-subscribing,
-* and cleans up the subscription on unmount or event name change.
-*/
-const useOnEvent = ({ event, listener }) => {
-	const client = useDynamicClient();
-	const callbackRef = (0, react.useRef)(listener);
-	callbackRef.current = listener;
-	(0, react.useEffect)(() => (0, _dynamic_labs_sdk_client.onEvent)({
-		event,
-		listener: (...args) => {
-			callbackRef.current(...args);
-		}
-	}, client), [event, client]);
-};
-
 //#endregion
 //#region src/hooks/wrappers/functions/useExecuteSwapTransaction/useExecuteSwapTransaction.ts
 /**
@@ -961,17 +1117,73 @@ const usePrepareFlowSigning = ({ mutateParams } = {}) => useBaseMutation({
 	mutationFn: ({ client, variables }) => (0, _dynamic_labs_sdk_client.prepareFlowSigning)(variables, client)
 });
 
+//#endregion
+//#region src/middlewares/invalidateOnUserSwitch/invalidateOnUserSwitch.ts
+const USER_CHANGED_EVENT = "userChanged";
+/**
+* Query middleware factory that refetches the query when a *different* user
+* becomes the current user (login or account switch).
+*
+* Unlike `invalidateOnEvent({ event: 'userChanged' })`, this never invalidates
+* on:
+* - logout (the user becomes `undefined`) — the refetch would just 401 and the
+*   cleared session leaves nothing to refetch; and
+* - same-user `userChanged` fires (e.g. linking a credential or a profile
+*   update) — the data still belongs to the same user, whose own mutations
+*   already invalidate it within the session.
+*
+* It tracks the previous user id across renders (seeded from the user present
+* at mount) and only invalidates when the new id is defined and differs.
+*
+* @example
+* ```ts
+* useBaseQuery({
+*   middlewares: [invalidateOnUserSwitch()],
+*   queryFn: (client) => getMfaDevices(client),
+*   queryKey: ['useGetMfaDevices'],
+* });
+* ```
+*/
+const invalidateOnUserSwitch = () => (context) => {
+	const client = useDynamicClient();
+	const queryClient = (0, _tanstack_react_query.useQueryClient)();
+	const previousUserIdRef = (0, react.useRef)(client.user?.id);
+	useOnEvent({
+		event: USER_CHANGED_EVENT,
+		listener: ((args) => {
+			const nextUserId = args.user?.id;
+			const previousUserId = previousUserIdRef.current;
+			previousUserIdRef.current = nextUserId;
+			if (nextUserId === void 0 || nextUserId === previousUserId) return;
+			if (!context) return;
+			(0, _dynamic_labs_sdk_client_core.getCore)(client).logger.debug("[invalidateOnUserSwitch] invalidating query on new user", { queryKey: context.queryKey });
+			queryClient.invalidateQueries({ queryKey: context.queryKey }).catch((error) => {
+				(0, _dynamic_labs_sdk_client_core.getCore)(client).logger.debug("[invalidateOnUserSwitch] failed to invalidate query", {
+					error,
+					queryKey: context.queryKey,
+					stack: error instanceof Error ? error.stack : void 0
+				});
+			});
+		})
+	});
+};
+
 //#endregion
 //#region src/hooks/wrappers/functions/useGetGoogleDriveBackupReadiness/useGetGoogleDriveBackupReadiness.ts
 /**
 * Wraps `getGoogleDriveBackupReadiness` from `@dynamic-labs-sdk/client`. Reports whether the user's Google Drive backup is set up and available.
 *
+* Automatically refetches when a different user becomes current (login or
+* account switch), so consumers don't have to pair it with a manual
+* `userChanged` listener.
+*
 * @example
 * ```tsx
 * const { data: readiness, isLoading } = useGetGoogleDriveBackupReadiness();
 * ```
 */
 const useGetGoogleDriveBackupReadiness = ({ queryParams } = {}) => useBaseQuery({
+	middlewares: [invalidateOnUserSwitch()],
 	queryFn: (client) => (0, _dynamic_labs_sdk_client.getGoogleDriveBackupReadiness)(client),
 	queryKey: ["useGetGoogleDriveBackupReadiness"],
 	queryParams
@@ -995,12 +1207,17 @@ const useIsMfaRequiredForAction = ({ queryParams, ...args }) => useBaseQuery({
 /**
 * Wraps `getKrakenAccounts` from `@dynamic-labs-sdk/client`. Returns the authenticated user's Kraken accounts (with balances), optionally filtered by chain/network.
 *
+* Automatically refetches when a different user becomes current (login or
+* account switch), so consumers don't have to pair it with a manual
+* `userChanged` listener.
+*
 * @example
 * ```tsx
 * const { data: accounts, isLoading } = useGetKrakenAccounts();
 * ```
 */
 const useGetKrakenAccounts = ({ queryParams, ...args } = {}) => useBaseQuery({
+	middlewares: [invalidateOnUserSwitch()],
 	queryFn: (client) => (0, _dynamic_labs_sdk_client.getKrakenAccounts)(args, client),
 	queryKey: ["useGetKrakenAccounts", args],
 	queryParams
@@ -1027,12 +1244,17 @@ const useCreateKrakenExchangeTransfer = ({ mutateParams } = {}) => useBaseMutati
 /**
 * Wraps `getKrakenWhitelistedAddresses` from `@dynamic-labs-sdk/client`. Returns the destination addresses whitelisted for Kraken withdrawals.
 *
+* Automatically refetches when a different user becomes current (login or
+* account switch), so consumers don't have to pair it with a manual
+* `userChanged` listener.
+*
 * @example
 * ```tsx
 * const { data: addresses, isLoading } = useGetKrakenWhitelistedAddresses();
 * ```
 */
 const useGetKrakenWhitelistedAddresses = ({ queryParams } = {}) => useBaseQuery({
+	middlewares: [invalidateOnUserSwitch()],
 	queryFn: (client) => (0, _dynamic_labs_sdk_client.getKrakenWhitelistedAddresses)(client),
 	queryKey: ["useGetKrakenWhitelistedAddresses"],
 	queryParams
@@ -1065,12 +1287,17 @@ const useLogout = ({ mutateParams } = {}) => useBaseMutation({
 *
 * Wraps `getMfaDevices` from `@dynamic-labs-sdk/client`.
 *
+* Automatically refetches when a different user becomes current (login or
+* account switch), so consumers don't have to pair it with a manual
+* `userChanged` listener.
+*
 * @example
 * ```tsx
 * const { data: mfaDevices, isLoading, refetch } = useGetMfaDevices();
 * ```
 */
 const useGetMfaDevices = ({ queryParams } = {}) => useBaseQuery({
+	middlewares: [invalidateOnUserSwitch()],
 	queryFn: (client) => (0, _dynamic_labs_sdk_client.getMfaDevices)(client),
 	queryKey: ["useGetMfaDevices"],
 	queryParams
@@ -1084,12 +1311,17 @@ const useGetMfaDevices = ({ queryParams } = {}) => useBaseQuery({
 *
 * Wraps `getMfaMethods` from `@dynamic-labs-sdk/client`.
 *
+* Automatically refetches when a different user becomes current (login or
+* account switch), so consumers don't have to pair it with a manual
+* `userChanged` listener.
+*
 * @example
 * ```tsx
 * const { data: mfaMethods, isLoading, refetch } = useGetMfaMethods();
 * ```
 */
 const useGetMfaMethods = ({ queryParams } = {}) => useBaseQuery({
+	middlewares: [invalidateOnUserSwitch()],
 	queryFn: (client) => (0, _dynamic_labs_sdk_client.getMfaMethods)(client),
 	queryKey: ["useGetMfaMethods"],
 	queryParams
@@ -1102,12 +1334,17 @@ const useGetMfaMethods = ({ queryParams } = {}) => useBaseQuery({
 *
 * Wraps `getMfaRecoveryCodes` from `@dynamic-labs-sdk/client`.
 *
+* Automatically refetches when a different user becomes current (login or
+* account switch), so consumers don't have to pair it with a manual
+* `userChanged` listener.
+*
 * @example
 * ```tsx
 * const { data: recoveryCodes, isLoading, refetch } = useGetMfaRecoveryCodes();
 * ```
 */
 const useGetMfaRecoveryCodes = ({ queryParams } = {}) => useBaseQuery({
+	middlewares: [invalidateOnUserSwitch()],
 	queryFn: (client) => (0, _dynamic_labs_sdk_client.getMfaRecoveryCodes)(client),
 	queryKey: ["useGetMfaRecoveryCodes"],
 	queryParams
@@ -1185,6 +1422,10 @@ const useGetMultichainTokenBalances = ({ balanceRequest, queryParams }) => useBa
 */
 const useGetNativeBalance = ({ walletAccount, queryParams }) => useBaseQuery({
 	enabled: walletAccount !== void 0,
+	middlewares: [invalidateOnWalletProviderEvent({
+		event: "networkChanged",
+		walletAccount
+	})],
 	queryFn: (client) => (0, _dynamic_labs_sdk_client.getNativeBalance)({ walletAccount }, client),
 	queryKey: ["useGetNativeBalance", walletAccount?.id],
 	queryParams
@@ -1226,12 +1467,17 @@ const useOnceEvent = ({ event, listener }) => {
 *
 * Wraps `getPasskeys` from `@dynamic-labs-sdk/client`.
 *
+* Automatically refetches when a different user becomes current (login or
+* account switch), so consumers don't have to pair it with a manual
+* `userChanged` listener.
+*
 * @example
 * ```tsx
 * const { data: passkeys, isLoading, refetch } = useGetPasskeys();
 * ```
 */
 const useGetPasskeys = ({ queryParams } = {}) => useBaseQuery({
+	middlewares: [invalidateOnUserSwitch()],
 	queryFn: (client) => (0, _dynamic_labs_sdk_client.getPasskeys)(client),
 	queryKey: ["useGetPasskeys"],
 	queryParams
@@ -1281,12 +1527,17 @@ const useRefreshAuth = ({ mutateParams } = {}) => useBaseMutation({
 * {@link useRevokeRegisteredDevice} to let users revoke a device from the
 * list.
 *
+* Automatically refetches when a different user becomes current (login or
+* account switch), so consumers don't have to pair it with a manual
+* `userChanged` listener.
+*
 * @example
 * ```tsx
 * const { data: devices, isLoading, refetch } = useGetRegisteredDevices();
 * ```
 */
 const useGetRegisteredDevices = ({ queryParams } = {}) => useBaseQuery({
+	middlewares: [invalidateOnUserSwitch()],
 	queryFn: (client) => (0, _dynamic_labs_sdk_client.getRegisteredDevices)(client),
 	queryKey: ["useGetRegisteredDevices"],
 	queryParams
@@ -1310,6 +1561,7 @@ const useGetRegisteredDevices = ({ queryParams } = {}) => useBaseQuery({
 * ```
 */
 const useRegisterPasskey = ({ mutateParams } = {}) => useBaseMutation({
+	middlewares: [invalidatesQueries("useGetPasskeys")],
 	mutateParams,
 	mutationFn: ({ client, variables }) => (0, _dynamic_labs_sdk_client.registerPasskey)(variables, client)
 });
@@ -1680,6 +1932,7 @@ const useGetSwapStatus = ({ queryParams, ...args }) => useBaseQuery({
 * ```
 */
 const useSwitchActiveNetwork = ({ mutateParams } = {}) => useBaseMutation({
+	middlewares: [invalidatesQueries("useGetActiveNetworkData", "useGetActiveNetworkId")],
 	mutateParams,
 	mutationFn: ({ client, variables }) => (0, _dynamic_labs_sdk_client.switchActiveNetwork)(variables, client)
 });
@@ -1703,6 +1956,10 @@ const useSwitchActiveNetwork = ({ mutateParams } = {}) => useBaseMutation({
 */
 const useGetTokenBalances = ({ walletAccount, queryParams, ...rest }) => useBaseQuery({
 	enabled: walletAccount !== void 0,
+	middlewares: [invalidateOnWalletProviderEvent({
+		event: "networkChanged",
+		walletAccount
+	})],
 	queryFn: (client) => (0, _dynamic_labs_sdk_client.getTokenBalances)({
 		walletAccount,
 		...rest
@@ -1845,13 +2102,15 @@ const useUpdateUser = ({ mutateParams } = {}) => useBaseMutation({
 /**
 * Returns the current user's linked social accounts.
 *
-* Re-renders when the user changes.
+* Re-renders when the user changes. Resolves to an empty list while no user is
+* authenticated — the guard is required because the selector runs synchronously
+* and `getUserSocialAccounts` throws (`assertDefined`) when there is no user.
 */
 const useGetUserSocialAccounts = () => useBaseState({
 	defaultValue: [],
 	event: "userChanged",
 	queryKey: ["useGetUserSocialAccounts"],
-	selector: (client) => (0, _dynamic_labs_sdk_client.getUserSocialAccounts)(client)
+	selector: (client) => client.user ? (0, _dynamic_labs_sdk_client.getUserSocialAccounts)(client) : []
 });
 
 //#endregion
@@ -1965,53 +2224,136 @@ const useGetWalletConnectCatalogWalletByWalletProviderKey = ({ queryParams, ...a
 //#endregion
 //#region src/hooks/wrappers/functions/useGetWalletOptionsCatalogue/useGetWalletOptionsCatalogue.ts
 /**
+* Freshness window for the catalogue, in milliseconds.
+*
+* The catalogue is derived from two near-static sources: the in-memory wallet
+* provider registry and the wallet-book document served from a CDN. With
+* react-query's default `staleTime: 0` the data is stale the instant it
+* arrives, so every new mount/observer (e.g. reopening the wallet list)
+* refetches the CDN document even though nothing changed — needlessly
+* hammering the CDN. A 1h window serves cached data to remounts; the registry
+* event middlewares below still force an immediate refetch on any real change,
+* so reactivity is preserved.
+*/
+const CATALOGUE_STALE_TIME_MS = 36e5;
+/**
 * Wraps `getWalletOptionsCatalogue` from `@dynamic-labs-sdk/client`. Returns the catalogue of wallet options the project supports.
 *
+* Automatically refetches when the wallet provider registry changes: EIP-6963
+* wallets fill the registry asynchronously after mount, and the registry emits
+* `walletProviderChanged` (on register / priority update) and
+* `walletProviderUnregistered` (on removal). Wiring both keeps the catalogue in
+* sync without consumers pairing the hook with a manual listener.
+*
 * @example
 * ```tsx
 * const { data: catalogue, isLoading } = useGetWalletOptionsCatalogue();
 * ```
 */
 const useGetWalletOptionsCatalogue = ({ queryParams, ...args } = {}) => useBaseQuery({
+	middlewares: [invalidateOnEvent({ event: "walletProviderChanged" }), invalidateOnEvent({ event: "walletProviderUnregistered" })],
 	queryFn: (client) => (0, _dynamic_labs_sdk_client.getWalletOptionsCatalogue)(args, client),
 	queryKey: ["useGetWalletOptionsCatalogue", args],
-	queryParams
+	queryParams: {
+		retry: false,
+		staleTime: CATALOGUE_STALE_TIME_MS,
+		...queryParams
+	}
 });
 
 //#endregion
-//#region src/hooks/wrappers/functions/useOnWalletProviderEvent/useOnWalletProviderEvent.ts
+//#region src/hooks/wrappers/functions/useGetWalletProviderDataByKey/useGetWalletProviderDataByKey.ts
 /**
-* Subscribes to an event emitted by a specific wallet provider.
+* Wraps `getWalletProviderDataByKey` from `@dynamic-labs-sdk/client`. Returns
+* the display/connection data for a single wallet provider, by key.
 *
-* Wraps `onWalletProviderEvent` from `@dynamic-labs-sdk/client`. Uses a ref to
-* always call the latest callback without re-subscribing, and cleans up the
-* subscription on unmount or when `event` / `walletProviderKey` change.
+* The underlying data is read from the in-memory wallet provider registry,
+* which EIP-6963 wallets fill asynchronously after mount. The registry emits
+* `walletProviderChanged` on register / priority update, so wiring it keeps the
+* provider data in sync without consumers pairing the hook with a manual
+* `useOnEvent` + `refetch` listener.
+*
+* `walletProviderUnregistered` is intentionally not wired here: this hook reads
+* a single key, and once that key is removed there is no replacement data to
+* fetch — refetching would only make `getWalletProviderDataByKey` throw
+* `NoWalletProviderFoundError`. Skipping it keeps the last-known data instead of
+* forcing the query into an error state.
 *
 * @example
 * ```tsx
-* useOnWalletProviderEvent({
-*   walletProviderKey: 'metamaskevm',
-*   event: 'accountsChanged',
-*   callback: ({ addresses }) => console.log(addresses),
+* const { data: walletProviderData } = useGetWalletProviderDataByKey({
+*   walletProviderKey,
 * });
 * ```
 */
-const useOnWalletProviderEvent = ({ callback, event, walletProviderKey }) => {
-	const client = useDynamicClient();
-	const callbackRef = (0, react.useRef)(callback);
-	callbackRef.current = callback;
-	(0, react.useEffect)(() => (0, _dynamic_labs_sdk_client.onWalletProviderEvent)({
-		callback: ((...args) => {
-			callbackRef.current(...args);
-		}),
-		event,
-		walletProviderKey
-	}, client), [
-		event,
-		walletProviderKey,
-		client
-	]);
-};
+const useGetWalletProviderDataByKey = ({ queryParams, ...args }) => useBaseQuery({
+	middlewares: [invalidateOnEvent({ event: "walletProviderChanged" })],
+	queryFn: (client) => Promise.resolve((0, _dynamic_labs_sdk_client.getWalletProviderDataByKey)(args, client)),
+	queryKey: ["useGetWalletProviderDataByKey", args],
+	queryParams
+});
+
+//#endregion
+//#region src/hooks/wrappers/functions/useIsDeviceRegistrationRequired/useIsDeviceRegistrationRequired.ts
+/**
+* Returns whether the current user still needs to register this device.
+*
+* Re-renders when the user changes (login, logout, completing device
+* registration). Resolves to `false` while no user is authenticated.
+*/
+const useIsDeviceRegistrationRequired = () => useBaseState({
+	defaultValue: false,
+	event: "userChanged",
+	queryKey: ["useIsDeviceRegistrationRequired"],
+	selector: (client) => client.user ? (0, _dynamic_labs_sdk_client.isDeviceRegistrationRequired)(client.user) : false
+});
+
+//#endregion
+//#region src/hooks/wrappers/functions/useIsUserMissingMfaAuth/useIsUserMissingMfaAuth.ts
+/**
+* Returns whether the current user still needs to complete an MFA challenge.
+*
+* Re-renders when the user changes (login, logout, completing the MFA
+* challenge). Resolves to `false` while no user is authenticated.
+*/
+const useIsUserMissingMfaAuth = () => useBaseState({
+	defaultValue: false,
+	event: "userChanged",
+	queryKey: ["useIsUserMissingMfaAuth"],
+	selector: (client) => client.user ? (0, _dynamic_labs_sdk_client.isUserMissingMfaAuth)(client) : false
+});
+
+//#endregion
+//#region src/hooks/wrappers/functions/useIsPendingRecoveryCodesAcknowledgment/useIsPendingRecoveryCodesAcknowledgment.ts
+/**
+* Returns whether the current user still needs to acknowledge their MFA
+* recovery codes.
+*
+* Re-renders when the user changes (login, logout, acknowledging the recovery
+* codes). Resolves to `false` while no user is authenticated.
+*/
+const useIsPendingRecoveryCodesAcknowledgment = () => useBaseState({
+	defaultValue: false,
+	event: "userChanged",
+	queryKey: ["useIsPendingRecoveryCodesAcknowledgment"],
+	selector: (client) => client.user ? (0, _dynamic_labs_sdk_client.isPendingRecoveryCodesAcknowledgment)(client) : false
+});
+
+//#endregion
+//#region src/hooks/wrappers/functions/useIsUserOnboardingComplete/useIsUserOnboardingComplete.ts
+/**
+* Returns whether the current user has completed every onboarding requirement
+* (KYC fields, MFA, recovery codes acknowledgment, device registration).
+*
+* Re-renders when the user changes (login, logout, completing any onboarding
+* step). Resolves to `false` while no user is authenticated.
+*/
+const useIsUserOnboardingComplete = () => useBaseState({
+	defaultValue: false,
+	event: "userChanged",
+	queryKey: ["useIsUserOnboardingComplete"],
+	selector: (client) => client.user ? (0, _dynamic_labs_sdk_client.isUserOnboardingComplete)(client) : false
+});
 
 //#endregion
 //#region src/hooks/wrappers/state/useInitStatus/useInitStatus.ts
@@ -2144,8 +2486,13 @@ exports.useGetWalletAccounts = useGetWalletAccounts;
 exports.useGetWalletConnectCatalog = useGetWalletConnectCatalog;
 exports.useGetWalletConnectCatalogWalletByWalletProviderKey = useGetWalletConnectCatalogWalletByWalletProviderKey;
 exports.useGetWalletOptionsCatalogue = useGetWalletOptionsCatalogue;
+exports.useGetWalletProviderDataByKey = useGetWalletProviderDataByKey;
 exports.useInitStatus = useInitStatus;
+exports.useIsDeviceRegistrationRequired = useIsDeviceRegistrationRequired;
 exports.useIsMfaRequiredForAction = useIsMfaRequiredForAction;
+exports.useIsPendingRecoveryCodesAcknowledgment = useIsPendingRecoveryCodesAcknowledgment;
+exports.useIsUserMissingMfaAuth = useIsUserMissingMfaAuth;
+exports.useIsUserOnboardingComplete = useIsUserOnboardingComplete;
 exports.useLogout = useLogout;
 exports.useOnEvent = useOnEvent;
 exports.useOnWalletProviderEvent = useOnWalletProviderEvent;