@dynamic-labs-sdk/react-hooks 1.16.1 → 1.17.1

package/dist/index.esm.js

@@ -7,7 +7,7 @@ import { getCore } from "@dynamic-labs-sdk/client/core";
 
 //#region package.json
 var name = "@dynamic-labs-sdk/react-hooks";
-var version = "1.16.1";
+var version = "1.17.1";
 
 //#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,23 +147,105 @@ 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 gating hooks like `requiresUser`) 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 = useMemo(() => [...QUERY_KEY_PREFIX, ...queryKey], [queryKey]);
+	middlewares.forEach((useMiddleware) => useMiddleware({ queryKey: fullQueryKey }));
 	return useQuery({
 		queryFn: async () => {
 			await waitForClientInitialized(client);
 			return queryFn(client);
 		},
-		queryKey: 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.
+*
+* @example
+* ```tsx
+* useOnWalletProviderEvent({
+*   walletProviderKey: 'metamaskevm',
+*   event: 'accountsChanged',
+*   callback: ({ addresses }) => console.log(addresses),
+* });
+* ```
+*/
+const useOnWalletProviderEvent = ({ callback, event, walletProviderKey }) => {
+	const client = useDynamicClient();
+	const callbackRef = useRef(callback);
+	callbackRef.current = callback;
+	useEffect(() => {
+		if (walletProviderKey === void 0) return;
+		return onWalletProviderEvent({
+			callback: ((...args) => {
+				callbackRef.current(...args);
+			}),
+			event,
+			walletProviderKey
+		}, client);
+	}, [
+		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 = useQueryClient();
+	useOnWalletProviderEvent({
+		callback: () => {
+			if (!context) return;
+			queryClient.invalidateQueries({ queryKey: context.queryKey }).catch((error) => {
+				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
 	});
 };
 
@@ -178,6 +260,10 @@ const useBaseQuery = ({ enabled = true, middlewares = EMPTY_MIDDLEWARES, queryFn
 * ```
 */
 const useGetActiveNetworkData = ({ queryParams, ...args }) => useBaseQuery({
+	middlewares: [invalidateOnWalletProviderEvent({
+		event: "networkChanged",
+		walletAccount: args.walletAccount
+	})],
 	queryFn: (client) => getActiveNetworkData(args, client),
 	queryKey: ["useGetActiveNetworkData", args],
 	queryParams
@@ -191,6 +277,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) => getActiveNetworkId(args, client),
 	queryKey: ["useGetActiveNetworkId", args],
 	queryParams
@@ -302,6 +392,48 @@ const useAuthenticatePasskeyMFA = ({ mutateParams } = {}) => useBaseMutation({
 	mutationFn: ({ client, variables }) => authenticatePasskeyMFA(variables, client)
 });
 
+//#endregion
+//#region src/middlewares/invalidatesQueries/invalidatesQueries.ts
+/**
+* Mutation middleware factory that invalidates one or more query hooks when
+* the mutation succeeds, so any mounted consumer of those queries refetches.
+*
+* Pass the query hooks' names (their `queryKey` leaf, e.g. `'useGetMfaDevices'`);
+* each is namespaced under `QUERY_KEY_PREFIX` to match the keys `useBaseQuery`
+* creates. The invalidation loop lives here, not in `useBaseMutation`.
+*
+* @example
+* ```ts
+* useBaseMutation({
+*   middlewares: [invalidatesQueries('useGetMfaDevices')],
+*   mutationFn: ({ client, variables }) => deleteMfaDevice(variables, client),
+* });
+* ```
+*/
+const invalidatesQueries = (...queryKeys) => () => {
+	const queryClient = useQueryClient();
+	const client = useDynamicClient();
+	/**
+	* Swallows an `invalidateQueries` rejection so a failed refetch never
+	* surfaces as an unhandled rejection nor rejects the combined invalidation
+	* promise, while still logging it at debug level so internal devs can see
+	* which query failed to refetch. Curried over the query key and extracted
+	* to a named handler so the invalidation map stays within the
+	* function-nesting limit.
+	*/
+	const debugInvalidationFailure = (queryKey) => (error) => {
+		getCore(client).logger.debug("[invalidatesQueries] failed to invalidate query", {
+			error,
+			queryKey,
+			stack: error instanceof Error ? error.stack : void 0
+		});
+	};
+	return { onSuccess: () => Promise.all(queryKeys.map((key) => {
+		const queryKey = [...QUERY_KEY_PREFIX, key];
+		return queryClient.invalidateQueries({ queryKey }).catch(debugInvalidationFailure(queryKey));
+	})) };
+};
+
 //#endregion
 //#region src/hooks/wrappers/functions/useAuthenticateTotpMfaDevice/useAuthenticateTotpMfaDevice.ts
 /**
@@ -319,10 +451,13 @@ const useAuthenticatePasskeyMFA = ({ mutateParams } = {}) => useBaseMutation({
 * </button>
 * ```
 */
-const useAuthenticateTotpMfaDevice = ({ mutateParams } = {}) => useBaseMutation({
-	mutateParams,
-	mutationFn: ({ client, variables }) => authenticateTotpMfaDevice(variables, client)
-});
+const useAuthenticateTotpMfaDevice = ({ mutateParams } = {}) => {
+	return useBaseMutation({
+		middlewares: [invalidatesQueries("useGetMfaDevices")],
+		mutateParams,
+		mutationFn: ({ client, variables }) => authenticateTotpMfaDevice(variables, client)
+	});
+};
 
 //#endregion
 //#region src/foundation/useBaseState/useBaseState.ts
@@ -438,11 +573,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) => getAvailableWalletProvidersData(client)
 });
@@ -584,6 +725,7 @@ const useAddCoinbaseOnrampOrderEventListener = ({ listener }) => {
 * ```
 */
 const useCompleteDeviceRegistration = ({ mutateParams } = {}) => useBaseMutation({
+	middlewares: [invalidatesQueries("useGetRegisteredDevices")],
 	mutateParams,
 	mutationFn: ({ client, variables }) => completeDeviceRegistration(variables, client)
 });
@@ -651,14 +793,82 @@ const useConnectAndVerifyWithWalletProvider = ({ mutateParams } = {}) => useBase
 	mutationFn: ({ client, variables }) => 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 = useRef(listener);
+	callbackRef.current = listener;
+	useEffect(() => 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 = useQueryClient();
+	const client = useDynamicClient();
+	useOnEvent({
+		event,
+		listener: (() => {
+			if (!context) return;
+			getCore(client).logger.debug("[invalidateOnEvent] invalidating query on event", {
+				event,
+				queryKey: context.queryKey
+			});
+			queryClient.invalidateQueries({ queryKey: context.queryKey }).catch((error) => {
+				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) => getConnectedAddresses(args, client),
 	queryKey: ["useGetConnectedAddresses", args],
 	queryParams
@@ -764,10 +974,13 @@ const useCreateNewMfaRecoveryCodes = ({ mutateParams } = {}) => useBaseMutation(
 * </button>
 * ```
 */
-const useDeleteMfaDevice = ({ mutateParams } = {}) => useBaseMutation({
-	mutateParams,
-	mutationFn: ({ client, variables }) => deleteMfaDevice(variables, client)
-});
+const useDeleteMfaDevice = ({ mutateParams } = {}) => {
+	return useBaseMutation({
+		middlewares: [invalidatesQueries("useGetMfaDevices")],
+		mutateParams,
+		mutationFn: ({ client, variables }) => deleteMfaDevice(variables, client)
+	});
+};
 
 //#endregion
 //#region src/hooks/wrappers/functions/useDeletePasskey/useDeletePasskey.ts
@@ -787,6 +1000,7 @@ const useDeleteMfaDevice = ({ mutateParams } = {}) => useBaseMutation({
 * ```
 */
 const useDeletePasskey = ({ mutateParams } = {}) => useBaseMutation({
+	middlewares: [invalidatesQueries("useGetPasskeys")],
 	mutateParams,
 	mutationFn: ({ client, variables }) => deletePasskey(variables, client)
 });
@@ -813,26 +1027,6 @@ const useDeleteUser = ({ mutateParams } = {}) => useBaseMutation({
 	mutationFn: ({ 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 = useRef(listener);
-	callbackRef.current = listener;
-	useEffect(() => onEvent({
-		event,
-		listener: (...args) => {
-			callbackRef.current(...args);
-		}
-	}, client), [event, client]);
-};
-
 //#endregion
 //#region src/hooks/wrappers/functions/useExecuteSwapTransaction/useExecuteSwapTransaction.ts
 /**
@@ -911,17 +1105,73 @@ const usePrepareFlowSigning = ({ mutateParams } = {}) => useBaseMutation({
 	mutationFn: ({ client, variables }) => 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 = useQueryClient();
+	const previousUserIdRef = 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;
+			getCore(client).logger.debug("[invalidateOnUserSwitch] invalidating query on new user", { queryKey: context.queryKey });
+			queryClient.invalidateQueries({ queryKey: context.queryKey }).catch((error) => {
+				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) => getGoogleDriveBackupReadiness(client),
 	queryKey: ["useGetGoogleDriveBackupReadiness"],
 	queryParams
@@ -945,12 +1195,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) => getKrakenAccounts(args, client),
 	queryKey: ["useGetKrakenAccounts", args],
 	queryParams
@@ -977,12 +1232,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) => getKrakenWhitelistedAddresses(client),
 	queryKey: ["useGetKrakenWhitelistedAddresses"],
 	queryParams
@@ -1015,12 +1275,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) => getMfaDevices(client),
 	queryKey: ["useGetMfaDevices"],
 	queryParams
@@ -1034,12 +1299,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) => getMfaMethods(client),
 	queryKey: ["useGetMfaMethods"],
 	queryParams
@@ -1052,12 +1322,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) => getMfaRecoveryCodes(client),
 	queryKey: ["useGetMfaRecoveryCodes"],
 	queryParams
@@ -1135,6 +1410,10 @@ const useGetMultichainTokenBalances = ({ balanceRequest, queryParams }) => useBa
 */
 const useGetNativeBalance = ({ walletAccount, queryParams }) => useBaseQuery({
 	enabled: walletAccount !== void 0,
+	middlewares: [invalidateOnWalletProviderEvent({
+		event: "networkChanged",
+		walletAccount
+	})],
 	queryFn: (client) => getNativeBalance({ walletAccount }, client),
 	queryKey: ["useGetNativeBalance", walletAccount?.id],
 	queryParams
@@ -1176,12 +1455,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) => getPasskeys(client),
 	queryKey: ["useGetPasskeys"],
 	queryParams
@@ -1231,12 +1515,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) => getRegisteredDevices(client),
 	queryKey: ["useGetRegisteredDevices"],
 	queryParams
@@ -1260,6 +1549,7 @@ const useGetRegisteredDevices = ({ queryParams } = {}) => useBaseQuery({
 * ```
 */
 const useRegisterPasskey = ({ mutateParams } = {}) => useBaseMutation({
+	middlewares: [invalidatesQueries("useGetPasskeys")],
 	mutateParams,
 	mutationFn: ({ client, variables }) => registerPasskey(variables, client)
 });
@@ -1282,6 +1572,7 @@ const useRegisterPasskey = ({ mutateParams } = {}) => useBaseMutation({
 * ```
 */
 const useRegisterTotpMfaDevice = ({ mutateParams } = {}) => useBaseMutation({
+	middlewares: [invalidatesQueries("useGetMfaDevices")],
 	mutateParams,
 	mutationFn: ({ client }) => registerTotpMfaDevice(client)
 });
@@ -1342,10 +1633,13 @@ const useRequestExternalAuthElevatedToken = ({ mutateParams } = {}) => useBaseMu
 * </button>
 * ```
 */
-const useRevokeAllRegisteredDevices = ({ mutateParams } = {}) => useBaseMutation({
-	mutateParams,
-	mutationFn: ({ client }) => revokeAllRegisteredDevices(client)
-});
+const useRevokeAllRegisteredDevices = ({ mutateParams } = {}) => {
+	return useBaseMutation({
+		middlewares: [invalidatesQueries("useGetRegisteredDevices")],
+		mutateParams,
+		mutationFn: ({ client }) => revokeAllRegisteredDevices(client)
+	});
+};
 
 //#endregion
 //#region src/hooks/wrappers/functions/useRevokeRegisteredDevice/useRevokeRegisteredDevice.ts
@@ -1368,10 +1662,13 @@ const useRevokeAllRegisteredDevices = ({ mutateParams } = {}) => useBaseMutation
 * </button>
 * ```
 */
-const useRevokeRegisteredDevice = ({ mutateParams } = {}) => useBaseMutation({
-	mutateParams,
-	mutationFn: ({ client, variables }) => revokeRegisteredDevice(variables, client)
-});
+const useRevokeRegisteredDevice = ({ mutateParams } = {}) => {
+	return useBaseMutation({
+		middlewares: [invalidatesQueries("useGetRegisteredDevices")],
+		mutateParams,
+		mutationFn: ({ client, variables }) => revokeRegisteredDevice(variables, client)
+	});
+};
 
 //#endregion
 //#region src/hooks/wrappers/functions/useSendEmailOTP/useSendEmailOTP.ts
@@ -1446,6 +1743,7 @@ const useSendSmsOTP = ({ mutateParams } = {}) => useBaseMutation({
 * ```
 */
 const useSetDefaultMfaDevice = ({ mutateParams } = {}) => useBaseMutation({
+	middlewares: [invalidatesQueries("useGetMfaDevices")],
 	mutateParams,
 	mutationFn: ({ client, variables }) => setDefaultMfaDevice(variables, client)
 });
@@ -1622,6 +1920,7 @@ const useGetSwapStatus = ({ queryParams, ...args }) => useBaseQuery({
 * ```
 */
 const useSwitchActiveNetwork = ({ mutateParams } = {}) => useBaseMutation({
+	middlewares: [invalidatesQueries("useGetActiveNetworkData", "useGetActiveNetworkId")],
 	mutateParams,
 	mutationFn: ({ client, variables }) => switchActiveNetwork(variables, client)
 });
@@ -1645,6 +1944,10 @@ const useSwitchActiveNetwork = ({ mutateParams } = {}) => useBaseMutation({
 */
 const useGetTokenBalances = ({ walletAccount, queryParams, ...rest }) => useBaseQuery({
 	enabled: walletAccount !== void 0,
+	middlewares: [invalidateOnWalletProviderEvent({
+		event: "networkChanged",
+		walletAccount
+	})],
 	queryFn: (client) => getTokenBalances({
 		walletAccount,
 		...rest
@@ -1907,54 +2210,43 @@ 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) => 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
-/**
-* 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.
-*
-* @example
-* ```tsx
-* useOnWalletProviderEvent({
-*   walletProviderKey: 'metamaskevm',
-*   event: 'accountsChanged',
-*   callback: ({ addresses }) => console.log(addresses),
-* });
-* ```
-*/
-const useOnWalletProviderEvent = ({ callback, event, walletProviderKey }) => {
-	const client = useDynamicClient();
-	const callbackRef = useRef(callback);
-	callbackRef.current = callback;
-	useEffect(() => onWalletProviderEvent({
-		callback: ((...args) => {
-			callbackRef.current(...args);
-		}),
-		event,
-		walletProviderKey
-	}, client), [
-		event,
-		walletProviderKey,
-		client
-	]);
-};
-
 //#endregion
 //#region src/hooks/wrappers/state/useInitStatus/useInitStatus.ts
 /**