@dynamic-labs-sdk/react-hooks 1.3.0 → 1.5.0

package/dist/index.esm.js

@@ -1,11 +1,13 @@
 import { assertPackageVersion } from "@dynamic-labs-sdk/assert-package-version";
-import { BaseError, getAvailableWalletProvidersData, getUserSocialAccounts, getWalletAccounts, onEvent } from "@dynamic-labs-sdk/client";
-import { createContext, useContext, useEffect, useRef, useSyncExternalStore } from "react";
+import { BaseError, authenticateTotpMfaDevice, createNewMfaRecoveryCodes, deleteMfaDevice, deletePasskey, getAvailableWalletProvidersData, getMfaDevices, getMultichainTokenBalances, getNativeBalance, getNetworksData, getRegisteredDevices, getTokenBalances, getTransactionHistory, getUserSocialAccounts, getWalletAccounts, isCaptchaRequired, isUserMissingMfaAuth, isUserOnboardingComplete, logout, onEvent, registerPasskey, registerTotpMfaDevice, removeWalletAccount, revokeRegisteredDevice, sendEmailOTP, sendSmsOTP, setDefaultMfaDevice, signInWithPasskey, signMessage, switchActiveNetwork, unlinkSocialAccount, updateUser, verifyOTP, verifyWalletAccount, waitForClientInitialized } from "@dynamic-labs-sdk/client";
+import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+import { createContext, useContext, useEffect, useMemo, useRef } from "react";
 import { jsx } from "react/jsx-runtime";
+import { getCore } from "@dynamic-labs-sdk/client/core";
 
 //#region package.json
 var name = "@dynamic-labs-sdk/react-hooks";
-var version = "1.3.0";
+var version = "1.5.0";
 
 //#endregion
 //#region src/modules/DynamicContext/DynamicContext.ts
@@ -53,6 +55,248 @@ const useDynamicClient = () => {
 	return client;
 };
 
+//#endregion
+//#region src/foundation/useBaseMutation/useBaseMutation.ts
+/**
+* Internal hook that wraps a react-query `useMutation` with the conventions
+* used by every async-write hook in this package:
+*
+* - `mutationFn` receives the resolved `DynamicClient` from context plus
+*   the caller-supplied `variables`, and is gated behind
+*   `waitForClientInitialized`.
+* - Callers pass `mutateParams` to override any default
+*   `UseMutationOptions`, so consumers can wire `onSuccess` / `onError` /
+*   etc.
+*
+* Returns the full `useMutation` result — `mutate`, `mutateAsync`, `data`,
+* `error`, `isPending`, `isSuccess`, `reset`, `status`, etc.
+*/
+const useBaseMutation = ({ mutationFn, mutateParams }) => {
+	const client = useDynamicClient();
+	return useMutation({
+		mutationFn: async (variables) => {
+			await waitForClientInitialized(client);
+			return mutationFn({
+				client,
+				variables
+			});
+		},
+		...mutateParams
+	});
+};
+
+//#endregion
+//#region src/hooks/useAuthenticateTotpMfaDevice/useAuthenticateTotpMfaDevice.ts
+/**
+* Authenticates the current user with a TOTP code from an authenticator app.
+*
+* Wraps `authenticateTotpMfaDevice` from `@dynamic-labs-sdk/client`. Call
+* `mutate({ code })` with the 6-digit code; the resolved `data` is the MFA
+* authentication response.
+*
+* @example
+* ```tsx
+* const { mutate: authenticateTotp, isPending } = useAuthenticateTotpMfaDevice();
+* <button onClick={() => authenticateTotp({ code })} disabled={isPending}>
+*   Verify code
+* </button>
+* ```
+*/
+const useAuthenticateTotpMfaDevice = ({ mutateParams } = {}) => useBaseMutation({
+	mutateParams,
+	mutationFn: ({ client, variables }) => authenticateTotpMfaDevice(variables, client)
+});
+
+//#endregion
+//#region src/foundation/useBaseState/useBaseState.ts
+/**
+* Internal hook that bridges Dynamic client event-driven state to React via
+* react-query.
+*
+* - `queryFn` waits for the client to finish initializing (so the first
+*   render never sees a half-built client) and then runs `selector`. Init
+*   failures surface on `error`.
+* - The supplied `event`(s) invalidate the query whenever they fire — a
+*   per-event predicate can narrow this so unrelated fires don't refetch.
+* - Returns the full `useQuery` result so consumers can read every field
+*   react-query exposes (`data`, `error`, `isLoading`, `isFetching`,
+*   `refetch`, `status`, ...).
+*/
+const normalizeEvents = (event) => {
+	if (typeof event !== "string") return event;
+	const map = {};
+	map[event] = true;
+	return map;
+};
+/**
+* Per-event subscription wrapper. Extracted from `useBaseState` so the
+* listener generics resolve at the per-event call site rather than as the
+* intersection across all events.
+*/
+const subscribeWithPredicate = ({ event, predicate, onMatch }, client) => {
+	const listener = (args) => {
+		if (predicate === true || predicate(args)) onMatch();
+	};
+	return onEvent({
+		event,
+		listener
+	}, client);
+};
+const useBaseState = ({ event, queryKey, queryParams, selector, defaultValue, skipWaitForInit = false }) => {
+	const client = useDynamicClient();
+	const queryClient = useQueryClient();
+	/**
+	* Normalize the `event` shorthand into an events map. `useMemo` keyed
+	* on a stable JSON shape so callers can pass an inline literal each
+	* render without churning the event-subscription effect.
+	*/
+	const eventsMapJson = useMemo(() => {
+		const map = normalizeEvents(event);
+		const sortedKeys = Object.keys(map).sort((a, b) => a.localeCompare(b));
+		return JSON.stringify(sortedKeys.map((k) => ({
+			event: k,
+			predicate: map[k] === true ? "__always__" : "__fn__"
+		})));
+	}, [event]);
+	/**
+	* Per-event predicates resolved from the latest render. The effect
+	* stays subscribed across re-renders (its deps are stable), so it
+	* reads predicates through this ref to pick up the most recent
+	* functions a caller passed inline.
+	*/
+	const eventsMapRef = useRef(normalizeEvents(event));
+	eventsMapRef.current = normalizeEvents(event);
+	/**
+	* Stable list of event names the effect needs to subscribe to. Driven
+	* by `eventsMapJson` so callers can swap predicate identities each
+	* render without re-subscribing.
+	*/
+	const eventNames = useMemo(() => {
+		const map = eventsMapRef.current;
+		return Object.keys(map).sort((a, b) => a.localeCompare(b));
+	}, [eventsMapJson]);
+	const fullQueryKey = useMemo(() => [
+		"@dynamic-labs-sdk/react-hooks",
+		"state",
+		...queryKey
+	], [JSON.stringify(queryKey)]);
+	useEffect(() => {
+		const core = getCore(client);
+		const invalidate = () => {
+			queryClient.invalidateQueries({ queryKey: fullQueryKey }).catch((invalidateError) => {
+				core.logger.error("[useBaseState] invalidateQueries failed", invalidateError);
+			});
+		};
+		const unsubscribers = eventNames.map((eventName) => subscribeWithPredicate({
+			event: eventName,
+			onMatch: invalidate,
+			predicate: (args) => {
+				const predicate = eventsMapRef.current[eventName];
+				if (predicate === void 0) return false;
+				return predicate === true || predicate(args);
+			}
+		}, client));
+		return () => {
+			for (const unsubscribe of unsubscribers) unsubscribe();
+		};
+	}, [
+		client,
+		eventNames,
+		queryClient,
+		fullQueryKey
+	]);
+	return useQuery({
+		...queryParams,
+		placeholderData: defaultValue,
+		queryFn: skipWaitForInit ? () => selector(client) : async () => {
+			await waitForClientInitialized(client);
+			return selector(client);
+		},
+		queryKey: fullQueryKey
+	});
+};
+
+//#endregion
+//#region src/hooks/useAvailableWalletProvidersData/useAvailableWalletProvidersData.ts
+/**
+* Returns the available wallet providers and their data.
+*
+* Re-renders when a wallet provider changes (e.g. network switch).
+*/
+const useAvailableWalletProvidersData = () => useBaseState({
+	defaultValue: [],
+	event: "walletProviderChanged",
+	queryKey: ["useAvailableWalletProvidersData"],
+	selector: (client) => getAvailableWalletProvidersData(client)
+});
+
+//#endregion
+//#region src/hooks/useCreateNewMfaRecoveryCodes/useCreateNewMfaRecoveryCodes.ts
+/**
+* Regenerates the current user's MFA recovery codes.
+*
+* Wraps `createNewMfaRecoveryCodes` from `@dynamic-labs-sdk/client`. Takes
+* no arguments — call `mutate()` to issue a fresh set of codes (invalidating
+* the previous set); the resolved `data` is the new recovery codes.
+*
+* @example
+* ```tsx
+* const { mutate: regenerateCodes, data, isPending } =
+*   useCreateNewMfaRecoveryCodes();
+* <button onClick={() => regenerateCodes()} disabled={isPending}>
+*   Regenerate recovery codes
+* </button>
+* ```
+*/
+const useCreateNewMfaRecoveryCodes = ({ mutateParams } = {}) => useBaseMutation({
+	mutateParams,
+	mutationFn: ({ client }) => createNewMfaRecoveryCodes(client)
+});
+
+//#endregion
+//#region src/hooks/useDeleteMfaDevice/useDeleteMfaDevice.ts
+/**
+* Deletes one of the current user's MFA devices.
+*
+* Wraps `deleteMfaDevice` from `@dynamic-labs-sdk/client`. Call
+* `mutate({ deviceId })` to remove the device; when no elevated access
+* token is available, also pass `mfaAuthToken`.
+*
+* @example
+* ```tsx
+* const { mutate: deleteDevice, isPending } = useDeleteMfaDevice();
+* <button onClick={() => deleteDevice({ deviceId })} disabled={isPending}>
+*   Remove device
+* </button>
+* ```
+*/
+const useDeleteMfaDevice = ({ mutateParams } = {}) => useBaseMutation({
+	mutateParams,
+	mutationFn: ({ client, variables }) => deleteMfaDevice(variables, client)
+});
+
+//#endregion
+//#region src/hooks/useDeletePasskey/useDeletePasskey.ts
+/**
+* Deletes one of the current user's passkeys.
+*
+* Wraps `deletePasskey` from `@dynamic-labs-sdk/client`. Call
+* `mutate({ passkeyId })` to remove the passkey; the resolved `data` is
+* `void`.
+*
+* @example
+* ```tsx
+* const { mutate: deletePasskey, isPending } = useDeletePasskey();
+* <button onClick={() => deletePasskey({ passkeyId })} disabled={isPending}>
+*   Remove passkey
+* </button>
+* ```
+*/
+const useDeletePasskey = ({ mutateParams } = {}) => useBaseMutation({
+	mutateParams,
+	mutationFn: ({ client, variables }) => deletePasskey(variables, client)
+});
+
 //#endregion
 //#region src/hooks/useEvent/useEvent.ts
 /**
@@ -74,33 +318,385 @@ const useEvent = ({ event, listener }) => {
 };
 
 //#endregion
-//#region src/foundation/useClientState/useClientState.ts
+//#region src/hooks/useInitStatus/useInitStatus.ts
+/**
+* Returns the current initialization status of the Dynamic client.
+*
+* Possible values: 'uninitialized', 'in-progress', 'finished', 'failed'.
+*/
+const useInitStatus = () => useBaseState({
+	defaultValue: "uninitialized",
+	event: "initStatusChanged",
+	queryKey: ["useInitStatus"],
+	selector: (client) => client.initStatus,
+	skipWaitForInit: true
+});
+
+//#endregion
+//#region src/hooks/useIsCaptchaRequired/useIsCaptchaRequired.ts
+/**
+* Returns whether hCaptcha is required by the current project settings.
+*
+* Re-renders whenever project settings change (e.g. after the first
+* settings fetch or a live settings update).
+*
+* Returns `false` whenever project settings have not loaded yet — callers
+* that need to distinguish "still resolving" from "settings loaded, captcha
+* really not required" can read `isPlaceholderData` / `isFetching` on the
+* result.
+*/
+const useIsCaptchaRequired = () => useBaseState({
+	defaultValue: false,
+	event: "projectSettingsChanged",
+	queryKey: ["useIsCaptchaRequired"],
+	selector: (client) => client.projectSettings === null ? false : isCaptchaRequired(client)
+});
+
+//#endregion
+//#region src/hooks/useIsUserMissingMfaAuth/useIsUserMissingMfaAuth.ts
+/**
+* Returns whether the current user still needs to complete additional MFA
+* authentication (i.e. their session scope contains `requiresAdditionalAuth`).
+*
+* Re-renders whenever the user changes (login, logout, scope refresh).
+*
+* Returns `false` whenever no user is signed in — a signed-out user
+* trivially has nothing pending. Callers that need to distinguish "still
+* resolving" from "really nothing pending" can read `isPlaceholderData` /
+* `isFetching` on the result.
+*/
+const useIsUserMissingMfaAuth = () => useBaseState({
+	defaultValue: false,
+	event: "userChanged",
+	queryKey: ["useIsUserMissingMfaAuth"],
+	selector: (client) => client.user === null ? false : isUserMissingMfaAuth(client)
+});
+
+//#endregion
+//#region src/hooks/useIsUserOnboardingComplete/useIsUserOnboardingComplete.ts
 /**
-* Internal hook that bridges Dynamic client event-driven state to React.
+* Returns whether the current user has completed onboarding (no missing KYC
+* fields, MFA enrollment, or pending recovery-code acknowledgement).
 *
-* Subscribes to a client event and re-derives a snapshot via the selector
-* each time the event fires, using useSyncExternalStore for tear-free reads.
+* Re-renders whenever the user changes (login, logout, profile update) or
+* project settings change (which affects what counts as a missing field).
+*
+* Returns `false` whenever no user is signed in, mirroring the "not yet
+* complete" semantics — callers should use the loading flags on the result
+* (`isPlaceholderData`, `isFetching`) to distinguish "still resolving" from
+* "really not complete".
+*/
+const useIsUserOnboardingComplete = () => useBaseState({
+	defaultValue: false,
+	event: {
+		projectSettingsChanged: true,
+		userChanged: true
+	},
+	queryKey: ["useIsUserOnboardingComplete"],
+	selector: (client) => client.user === null ? false : isUserOnboardingComplete(client)
+});
+
+//#endregion
+//#region src/hooks/useLogout/useLogout.ts
+/**
+* Logs the current user out.
+*
+* Wraps `logout` from `@dynamic-labs-sdk/client`. Takes no required
+* arguments — call `mutate()` to trigger the logout.
+*
+* @example
+* ```tsx
+* const { mutate: logOut, isPending } = useLogout();
+* <button onClick={() => logOut()} disabled={isPending}>Logout</button>
+* ```
 */
-const useClientState = (eventName, getSnapshot) => {
+const useLogout = ({ mutateParams } = {}) => useBaseMutation({
+	mutateParams,
+	mutationFn: ({ client }) => logout(client)
+});
+
+//#endregion
+//#region src/foundation/useBaseQuery/useBaseQuery.ts
+/**
+* Internal hook that wraps a react-query `useQuery` with the conventions used
+* by every async-read hook in this package:
+*
+* - `queryFn` receives the resolved `DynamicClient` from context, and is
+*   gated behind `waitForClientInitialized` so customers never see "client
+*   not ready" errors on first render.
+* - Callers pass `queryParams` to override any default `UseQueryOptions`,
+*   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.
+*
+* Returns the full `useQuery` result — `data`, `error`, `isLoading`,
+* `isFetching`, `isSuccess`, `refetch`, `status`, etc.
+*/
+const useBaseQuery = ({ queryFn, queryKey, queryParams, enabled = true }) => {
 	const client = useDynamicClient();
-	const valueRef = useRef(getSnapshot(client));
-	return useSyncExternalStore((onStoreChange) => onEvent({
-		event: eventName,
-		listener: () => {
-			valueRef.current = getSnapshot(client);
-			onStoreChange();
-		}
-	}, client), () => valueRef.current, () => valueRef.current);
+	return useQuery({
+		queryFn: async () => {
+			await waitForClientInitialized(client);
+			return queryFn(client);
+		},
+		queryKey: useMemo(() => [
+			"@dynamic-labs-sdk/react-hooks",
+			"query",
+			...queryKey
+		], [queryKey]),
+		...queryParams,
+		enabled: enabled && queryParams?.enabled !== false
+	});
 };
 
 //#endregion
-//#region src/hooks/useInitStatus/useInitStatus.ts
+//#region src/hooks/useMfaDevices/useMfaDevices.ts
 /**
-* Returns the current initialization status of the Dynamic client.
+* Returns the multi-factor authentication devices registered for the
+* current user.
 *
-* Possible values: 'uninitialized', 'in-progress', 'finished', 'failed'.
+* Wraps `getMfaDevices` from `@dynamic-labs-sdk/client`.
+*
+* @example
+* ```tsx
+* const { data: mfaDevices, isLoading, refetch } = useMfaDevices();
+* ```
+*/
+const useMfaDevices = ({ queryParams } = {}) => useBaseQuery({
+	queryFn: (client) => getMfaDevices(client),
+	queryKey: ["useMfaDevices"],
+	queryParams
+});
+
+//#endregion
+//#region src/hooks/useMultichainTokenBalances/useMultichainTokenBalances.ts
+/**
+* Returns token balances across multiple chains, networks, and addresses
+* in a single batched API request.
+*
+* Wraps `getMultichainTokenBalances` from `@dynamic-labs-sdk/client`. The
+* hook stays disabled until `balanceRequest` is defined. Use this for
+* portfolio-style views; for a single account on one chain prefer
+* {@link useTokenBalances}.
+*
+* @example
+* ```tsx
+* const { data, isLoading, refetch } = useMultichainTokenBalances({
+*   balanceRequest,
+* });
+* ```
+*/
+const useMultichainTokenBalances = ({ balanceRequest, queryParams }) => useBaseQuery({
+	enabled: balanceRequest !== void 0,
+	queryFn: (client) => getMultichainTokenBalances({ balanceRequest }, client),
+	queryKey: ["useMultichainTokenBalances", balanceRequest],
+	queryParams
+});
+
+//#endregion
+//#region src/hooks/useNativeBalance/useNativeBalance.ts
+/**
+* Returns the native token balance for a wallet account.
+*
+* Calls `getNativeBalance` from `@dynamic-labs-sdk/client`. The hook stays
+* disabled until `walletAccount` is defined.
+*
+* @example
+* ```tsx
+* const { data, isLoading, refetch } = useNativeBalance({ walletAccount });
+* ```
+*/
+const useNativeBalance = ({ walletAccount, queryParams }) => useBaseQuery({
+	enabled: walletAccount !== void 0,
+	queryFn: (client) => getNativeBalance({ walletAccount }, client),
+	queryKey: ["useNativeBalance", walletAccount?.id],
+	queryParams
+});
+
+//#endregion
+//#region src/hooks/useNetworksData/useNetworksData.ts
+/**
+* Returns the network configurations for all networks enabled in the Dynamic project.
+*
+* Re-renders when project settings change.
+*/
+const useNetworksData = () => useBaseState({
+	defaultValue: [],
+	event: "projectSettingsChanged",
+	queryKey: ["useNetworksData"],
+	selector: (client) => getNetworksData(client)
+});
+
+//#endregion
+//#region src/hooks/useRegisteredDevices/useRegisteredDevices.ts
+/**
+* Returns the devices registered for the current user.
+*
+* Wraps `getRegisteredDevices` from `@dynamic-labs-sdk/client`. Pair with
+* {@link useRevokeRegisteredDevice} to let users revoke a device from the
+* list.
+*
+* @example
+* ```tsx
+* const { data: devices, isLoading, refetch } = useRegisteredDevices();
+* ```
 */
-const useInitStatus = () => useClientState("initStatusChanged", (client) => client.initStatus);
+const useRegisteredDevices = ({ queryParams } = {}) => useBaseQuery({
+	queryFn: (client) => getRegisteredDevices(client),
+	queryKey: ["useRegisteredDevices"],
+	queryParams
+});
+
+//#endregion
+//#region src/hooks/useRegisterPasskey/useRegisterPasskey.ts
+/**
+* Registers a new passkey for the current user.
+*
+* Wraps `registerPasskey` from `@dynamic-labs-sdk/client`. Call `mutate()`
+* to prompt the device's WebAuthn flow; the resolved `data` is the
+* registration response.
+*
+* @example
+* ```tsx
+* const { mutate: registerPasskey, isPending } = useRegisterPasskey();
+* <button onClick={() => registerPasskey()} disabled={isPending}>
+*   Add passkey
+* </button>
+* ```
+*/
+const useRegisterPasskey = ({ mutateParams } = {}) => useBaseMutation({
+	mutateParams,
+	mutationFn: ({ client, variables }) => registerPasskey(variables, client)
+});
+
+//#endregion
+//#region src/hooks/useRegisterTotpMfaDevice/useRegisterTotpMfaDevice.ts
+/**
+* Registers a new TOTP MFA device for the current user.
+*
+* Wraps `registerTotpMfaDevice` from `@dynamic-labs-sdk/client`. Takes no
+* arguments — call `mutate()` to start enrollment; the resolved `data`
+* contains the secret/URI used to render the authenticator QR code.
+*
+* @example
+* ```tsx
+* const { mutate: registerTotp, data, isPending } = useRegisterTotpMfaDevice();
+* <button onClick={() => registerTotp()} disabled={isPending}>
+*   Add authenticator app
+* </button>
+* ```
+*/
+const useRegisterTotpMfaDevice = ({ mutateParams } = {}) => useBaseMutation({
+	mutateParams,
+	mutationFn: ({ client }) => registerTotpMfaDevice(client)
+});
+
+//#endregion
+//#region src/hooks/useRemoveWalletAccount/useRemoveWalletAccount.ts
+/**
+* Removes a wallet account from the current user.
+*
+* Wraps `removeWalletAccount` from `@dynamic-labs-sdk/client`. Call
+* `mutate({ walletAccount })` to disconnect/unlink the account; the
+* resolved `data` is `void`.
+*
+* @example
+* ```tsx
+* const { mutate: removeWallet, isPending } = useRemoveWalletAccount();
+* <button
+*   onClick={() => removeWallet({ walletAccount })}
+*   disabled={isPending}
+* >
+*   Remove wallet
+* </button>
+* ```
+*/
+const useRemoveWalletAccount = ({ mutateParams } = {}) => useBaseMutation({
+	mutateParams,
+	mutationFn: ({ client, variables }) => removeWalletAccount(variables, client)
+});
+
+//#endregion
+//#region src/hooks/useRevokeRegisteredDevice/useRevokeRegisteredDevice.ts
+/**
+* Revokes a previously registered device.
+*
+* Wraps `revokeRegisteredDevice` from `@dynamic-labs-sdk/client`. Call
+* `mutate({ deviceRegistrationId })` with the id of the device to revoke
+* (e.g. one returned by {@link useRegisteredDevices}); the resolved `data`
+* is `void`.
+*
+* @example
+* ```tsx
+* const { mutate: revokeDevice, isPending } = useRevokeRegisteredDevice();
+* <button
+*   onClick={() => revokeDevice({ deviceRegistrationId })}
+*   disabled={isPending}
+* >
+*   Revoke device
+* </button>
+* ```
+*/
+const useRevokeRegisteredDevice = ({ mutateParams } = {}) => useBaseMutation({
+	mutateParams,
+	mutationFn: ({ client, variables }) => revokeRegisteredDevice(variables, client)
+});
+
+//#endregion
+//#region src/hooks/useSendEmailOtp/useSendEmailOtp.ts
+/**
+* Sends a one-time password to an email address.
+*
+* Wraps `sendEmailOTP` from `@dynamic-labs-sdk/client`. Call
+* `mutate({ email })` to dispatch the code; the resolved `data` is the
+* `OTPVerification` payload to hand to {@link useVerifyOtp} once the user
+* enters the code they received.
+*
+* @example
+* ```tsx
+* const { mutate: sendEmailOtp, data: otpVerification, isPending } =
+*   useSendEmailOtp();
+* <button
+*   onClick={() => sendEmailOtp({ email: 'velma@mystery.inc' })}
+*   disabled={isPending}
+* >
+*   Email me a code
+* </button>
+* ```
+*/
+const useSendEmailOtp = ({ mutateParams } = {}) => useBaseMutation({
+	mutateParams,
+	mutationFn: ({ client, variables }) => sendEmailOTP(variables, client)
+});
+
+//#endregion
+//#region src/hooks/useSendSmsOtp/useSendSmsOtp.ts
+/**
+* Sends a one-time password to a phone number via SMS.
+*
+* Wraps `sendSmsOTP` from `@dynamic-labs-sdk/client`. Call
+* `mutate({ isoCountryCode, phoneNumber })` to dispatch the code; the
+* resolved `data` is the `OTPVerification` payload to hand to
+* {@link useVerifyOtp} once the user enters the code they received.
+*
+* @example
+* ```tsx
+* const { mutate: sendSmsOtp, data: otpVerification, isPending } =
+*   useSendSmsOtp();
+* <button
+*   onClick={() =>
+*     sendSmsOtp({ isoCountryCode: 'US', phoneNumber: '5550100' })
+*   }
+*   disabled={isPending}
+* >
+*   Text me a code
+* </button>
+* ```
+*/
+const useSendSmsOtp = ({ mutateParams } = {}) => useBaseMutation({
+	mutateParams,
+	mutationFn: ({ client, variables }) => sendSmsOTP(variables, client)
+});
 
 //#endregion
 //#region src/hooks/useSessionExpiresAt/useSessionExpiresAt.ts
@@ -109,16 +705,229 @@ const useInitStatus = () => useClientState("initStatusChanged", (client) => clie
 *
 * Re-renders when the user changes (which includes session updates).
 */
-const useSessionExpiresAt = () => useClientState("userChanged", (client) => client.sessionExpiresAt);
+const useSessionExpiresAt = () => useBaseState({
+	defaultValue: null,
+	event: "userChanged",
+	queryKey: ["useSessionExpiresAt"],
+	selector: (client) => client.sessionExpiresAt
+});
 
 //#endregion
-//#region src/hooks/useSocialAccounts/useSocialAccounts.ts
+//#region src/hooks/useSetDefaultMfaDevice/useSetDefaultMfaDevice.ts
 /**
-* Returns the current user's linked social accounts.
+* Sets the current user's default MFA device.
 *
-* Re-renders when the user changes.
+* Wraps `setDefaultMfaDevice` from `@dynamic-labs-sdk/client`. Call
+* `mutate({ deviceId })` to designate the device used for MFA challenges.
+*
+* @example
+* ```tsx
+* const { mutate: setDefaultDevice, isPending } = useSetDefaultMfaDevice();
+* <button onClick={() => setDefaultDevice({ deviceId })} disabled={isPending}>
+*   Make default
+* </button>
+* ```
+*/
+const useSetDefaultMfaDevice = ({ mutateParams } = {}) => useBaseMutation({
+	mutateParams,
+	mutationFn: ({ client, variables }) => setDefaultMfaDevice(variables, client)
+});
+
+//#endregion
+//#region src/hooks/useSignInWithPasskey/useSignInWithPasskey.ts
+/**
+* Signs the user in with a previously registered passkey.
+*
+* Wraps `signInWithPasskey` from `@dynamic-labs-sdk/client`. Call `mutate()`
+* to start the WebAuthn authentication; the resolved `data` is the
+* authentication response.
+*
+* @example
+* ```tsx
+* const { mutate: signInWithPasskey, isPending } = useSignInWithPasskey();
+* <button onClick={() => signInWithPasskey()} disabled={isPending}>
+*   Sign in with passkey
+* </button>
+* ```
+*/
+const useSignInWithPasskey = ({ mutateParams } = {}) => useBaseMutation({
+	mutateParams,
+	mutationFn: ({ client, variables }) => signInWithPasskey(variables, client)
+});
+
+//#endregion
+//#region src/hooks/useSignMessage/useSignMessage.ts
+/**
+* Signs an arbitrary message with a wallet account.
+*
+* Wraps `signMessage` from `@dynamic-labs-sdk/client`. Call
+* `mutate({ walletAccount, message })` to trigger the signature flow —
+* the wallet provider will prompt the user via its native UI.
+*
+* @example
+* ```tsx
+* const { mutate: signMessage, data, isPending } = useSignMessage();
+* <button
+*   onClick={() => signMessage({ message: 'gm', walletAccount })}
+*   disabled={isPending}
+* >
+*   Sign
+* </button>
+* ```
+*/
+const useSignMessage = ({ mutateParams } = {}) => useBaseMutation({
+	mutateParams,
+	mutationFn: ({ client, variables }) => signMessage(variables, client)
+});
+
+//#endregion
+//#region src/hooks/useSwitchActiveNetwork/useSwitchActiveNetwork.ts
+/**
+* Switches the active network for a wallet account.
+*
+* Wraps `switchActiveNetwork` from `@dynamic-labs-sdk/client`. Call
+* `mutate({ networkId, walletAccount })` to request the switch — the
+* wallet provider may prompt the user to approve adding/changing the
+* chain via its native UI.
+*
+* @example
+* ```tsx
+* const { mutate: switchNetwork, isPending } = useSwitchActiveNetwork();
+* <button
+*   onClick={() => switchNetwork({ networkId: 1, walletAccount })}
+*   disabled={isPending}
+* >
+*   Switch to Ethereum
+* </button>
+* ```
+*/
+const useSwitchActiveNetwork = ({ mutateParams } = {}) => useBaseMutation({
+	mutateParams,
+	mutationFn: ({ client, variables }) => switchActiveNetwork(variables, client)
+});
+
+//#endregion
+//#region src/hooks/useTokenBalances/useTokenBalances.ts
+/**
+* Returns the ERC-20-style token balances for a wallet account on a single
+* chain.
+*
+* Wraps `getTokenBalances` from `@dynamic-labs-sdk/client`. The hook stays
+* disabled until `walletAccount` is defined.
+*
+* For native-only balance use {@link useNativeBalance}; for a multi-chain
+* portfolio use {@link useMultichainTokenBalances}.
+*
+* @example
+* ```tsx
+* const { data, isLoading, refetch } = useTokenBalances({ walletAccount });
+* ```
+*/
+const useTokenBalances = ({ walletAccount, queryParams, ...rest }) => useBaseQuery({
+	enabled: walletAccount !== void 0,
+	queryFn: (client) => getTokenBalances({
+		walletAccount,
+		...rest
+	}, client),
+	queryKey: [
+		"useTokenBalances",
+		walletAccount?.id,
+		rest
+	],
+	queryParams
+});
+
+//#endregion
+//#region src/hooks/useTransactionHistory/useTransactionHistory.ts
+/**
+* Returns the transaction history for a given wallet address, chain, and
+* network.
+*
+* Wraps `getTransactionHistory` from `@dynamic-labs-sdk/client`. The hook
+* stays disabled until `address`, `chain`, and `networkId` are all
+* defined. Pagination is driven by `offset` — callers can swap in a new
+* `offset` to fetch the next page (each unique key produces its own cache
+* entry).
+*
+* @example
+* ```tsx
+* const { data, isLoading, refetch } = useTransactionHistory({
+*   address,
+*   chain,
+*   networkId,
+* });
+* ```
+*/
+const useTransactionHistory = ({ address, chain, networkId, queryParams, ...rest }) => useBaseQuery({
+	enabled: address !== void 0 && chain !== void 0 && networkId !== void 0,
+	queryFn: (client) => getTransactionHistory({
+		address,
+		chain,
+		networkId,
+		...rest
+	}, client),
+	queryKey: [
+		"useTransactionHistory",
+		address,
+		chain,
+		networkId,
+		rest
+	],
+	queryParams
+});
+
+//#endregion
+//#region src/hooks/useUnlinkSocialAccount/useUnlinkSocialAccount.ts
+/**
+* Unlinks a social account from the current user.
+*
+* Wraps `unlinkSocialAccount` from `@dynamic-labs-sdk/client`. Call
+* `mutate({ verifiedCredentialId })` with the id of the social credential
+* to remove (e.g. from {@link useUserSocialAccounts}); the resolved `data`
+* is the updated `VerifyResponse`.
+*
+* @example
+* ```tsx
+* const { mutate: unlinkSocial, isPending } = useUnlinkSocialAccount();
+* <button
+*   onClick={() => unlinkSocial({ verifiedCredentialId })}
+*   disabled={isPending}
+* >
+*   Disconnect
+* </button>
+* ```
 */
-const useSocialAccounts = () => useClientState("userChanged", (client) => getUserSocialAccounts(client));
+const useUnlinkSocialAccount = ({ mutateParams } = {}) => useBaseMutation({
+	mutateParams,
+	mutationFn: ({ client, variables }) => unlinkSocialAccount(variables, client)
+});
+
+//#endregion
+//#region src/hooks/useUpdateUser/useUpdateUser.ts
+/**
+* Updates the current user's profile information.
+*
+* Wraps `updateUser` from `@dynamic-labs-sdk/client`. Call
+* `mutate({ userFields })` to push the new values; if a sensitive field
+* (email, phone) changed the resolved `data` will contain an
+* `OTPVerification` payload the caller needs to follow up on, otherwise
+* `data` is `undefined`.
+*
+* @example
+* ```tsx
+* const { mutate: updateUser, data: otp, isPending } = useUpdateUser();
+* <button
+*   onClick={() => updateUser({ userFields: { firstName: 'Velma' } })}
+*   disabled={isPending}
+* >
+*   Save
+* </button>
+* ```
+*/
+const useUpdateUser = ({ mutateParams } = {}) => useBaseMutation({
+	mutateParams,
+	mutationFn: ({ client, variables }) => updateUser(variables, client)
+});
 
 //#endregion
 //#region src/hooks/useUser/useUser.ts
@@ -127,30 +936,107 @@ const useSocialAccounts = () => useClientState("userChanged", (client) => getUse
 *
 * Re-renders when the user changes (login, logout, profile update).
 */
-const useUser = () => useClientState("userChanged", (client) => client.user);
+const useUser = () => useBaseState({
+	defaultValue: null,
+	event: "userChanged",
+	queryKey: ["useUser"],
+	selector: (client) => client.user
+});
 
 //#endregion
-//#region src/hooks/useWalletAccounts/useWalletAccounts.ts
+//#region src/hooks/useUserSocialAccounts/useUserSocialAccounts.ts
 /**
-* Returns all wallet accounts connected to the current user.
+* Returns the current user's linked social accounts.
 *
-* Re-renders when wallet accounts change (connect, disconnect, verify).
+* Re-renders when the user changes.
 */
-const useWalletAccounts = () => useClientState("walletAccountsChanged", (client) => getWalletAccounts(client));
+const useUserSocialAccounts = () => useBaseState({
+	defaultValue: [],
+	event: "userChanged",
+	queryKey: ["useUserSocialAccounts"],
+	selector: (client) => getUserSocialAccounts(client)
+});
 
 //#endregion
-//#region src/hooks/useWalletProviders/useWalletProviders.ts
+//#region src/hooks/useVerifyOtp/useVerifyOtp.ts
 /**
-* Returns the available wallet providers and their data.
+* Verifies a one-time password the user received via email or SMS.
 *
-* Re-renders when a wallet provider changes (e.g. network switch).
+* Wraps `verifyOTP` from `@dynamic-labs-sdk/client`. Call
+* `mutate({ otpVerification, verificationToken })` with the
+* `OTPVerification` returned by {@link useSendEmailOtp} /
+* {@link useSendSmsOtp} and the code the user entered. A single hook
+* covers both flows — `verifyOTP` resolves sign-in vs. user-update
+* internally based on the current session.
+*
+* @example
+* ```tsx
+* const { mutate: verifyOtp, isPending } = useVerifyOtp();
+* <button
+*   onClick={() => verifyOtp({ otpVerification, verificationToken: code })}
+*   disabled={isPending}
+* >
+*   Verify
+* </button>
+* ```
 */
-const useWalletProviders = () => useClientState("walletProviderChanged", (client) => getAvailableWalletProvidersData(client));
+const useVerifyOtp = ({ mutateParams } = {}) => useBaseMutation({
+	mutateParams,
+	mutationFn: ({ client, variables }) => verifyOTP(variables, client)
+});
+
+//#endregion
+//#region src/hooks/useVerifyWalletAccount/useVerifyWalletAccount.ts
+/**
+* Verifies ownership of a wallet account and adds it to the user's profile.
+*
+* Wraps `verifyWalletAccount` from `@dynamic-labs-sdk/client`. Call
+* `mutate({ walletAccount })` to trigger the verification flow — the
+* wallet provider will prompt the user to sign a proof-of-ownership
+* message. On success, `data` resolves to the verified
+* {@link WalletAccount}.
+*
+* Throws `WalletAccountAlreadyVerifiedError` if the wallet is already
+* verified, or `WalletAlreadyLinkedToAnotherUserError` if the wallet is
+* linked to a different user — both surface through `error`.
+*
+* @example
+* ```tsx
+* const { mutate: verifyWalletAccount, isPending } = useVerifyWalletAccount();
+* <button
+*   onClick={() => verifyWalletAccount({ walletAccount })}
+*   disabled={isPending}
+* >
+*   Verify
+* </button>
+* ```
+*/
+const useVerifyWalletAccount = ({ mutateParams } = {}) => useBaseMutation({
+	mutateParams,
+	mutationFn: ({ client, variables }) => verifyWalletAccount(variables, client)
+});
+
+//#endregion
+//#region src/hooks/useWalletAccounts/useWalletAccounts.ts
+/**
+* Returns all wallet accounts connected to the current user.
+*
+* Re-renders when wallet accounts change (connect, disconnect, verify).
+*/
+const useWalletAccounts = () => useBaseState({
+	defaultValue: [],
+	event: {
+		userChanged: true,
+		walletAccountsChanged: true
+	},
+	queryKey: ["useWalletAccounts"],
+	selector: (client) => getWalletAccounts(client)
+});
 
 //#endregion
 //#region src/exports/index.ts
 assertPackageVersion(name, version);
 
 //#endregion
-export { DynamicProvider, useDynamicClient, useEvent, useInitStatus, useSessionExpiresAt, useSocialAccounts, useUser, useWalletAccounts, useWalletProviders };
+export { DynamicProvider, useAuthenticateTotpMfaDevice, useAvailableWalletProvidersData, useCreateNewMfaRecoveryCodes, useDeleteMfaDevice, useDeletePasskey, useDynamicClient, useEvent, useInitStatus, useIsCaptchaRequired, useIsUserMissingMfaAuth, useIsUserOnboardingComplete, useLogout, useMfaDevices, useMultichainTokenBalances, useNativeBalance, useNetworksData, useRegisterPasskey, useRegisterTotpMfaDevice, useRegisteredDevices, useRemoveWalletAccount, useRevokeRegisteredDevice, useSendEmailOtp, useSendSmsOtp, useSessionExpiresAt, useSetDefaultMfaDevice, useSignInWithPasskey, useSignMessage, useSwitchActiveNetwork, useTokenBalances, useTransactionHistory, useUnlinkSocialAccount, useUpdateUser, useUser, useUserSocialAccounts, useVerifyOtp, useVerifyWalletAccount, useWalletAccounts };
 //# sourceMappingURL=index.esm.js.map