@dynamic-labs-sdk/react-hooks 1.4.0 → 1.6.0

package/dist/index.cjs

@@ -1,11 +1,13 @@
 let _dynamic_labs_sdk_assert_package_version = require("@dynamic-labs-sdk/assert-package-version");
 let _dynamic_labs_sdk_client = require("@dynamic-labs-sdk/client");
+let _tanstack_react_query = require("@tanstack/react-query");
 let react = require("react");
 let react_jsx_runtime = require("react/jsx-runtime");
+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.4.0";
+var version = "1.6.0";
 
 //#endregion
 //#region src/modules/DynamicContext/DynamicContext.ts
@@ -53,6 +55,341 @@ 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 (0, _tanstack_react_query.useMutation)({
+		mutationFn: async (variables) => {
+			await (0, _dynamic_labs_sdk_client.waitForClientInitialized)(client);
+			return mutationFn({
+				client,
+				variables
+			});
+		},
+		...mutateParams
+	});
+};
+
+//#endregion
+//#region src/hooks/useAuthenticateMfaRecoveryCode/useAuthenticateMfaRecoveryCode.ts
+/**
+* Authenticates the current user with one of their MFA recovery codes.
+*
+* Wraps `authenticateMfaRecoveryCode` from `@dynamic-labs-sdk/client`. Call
+* `mutate({ code })` with a backup recovery code when no registered MFA
+* method is available; the resolved `data` is the MFA authentication
+* response.
+*
+* @example
+* ```tsx
+* const { mutate: authenticateRecoveryCode, isPending } =
+*   useAuthenticateMfaRecoveryCode();
+* <button
+*   onClick={() => authenticateRecoveryCode({ code })}
+*   disabled={isPending}
+* >
+*   Use recovery code
+* </button>
+* ```
+*/
+const useAuthenticateMfaRecoveryCode = ({ mutateParams } = {}) => useBaseMutation({
+	mutateParams,
+	mutationFn: ({ client, variables }) => (0, _dynamic_labs_sdk_client.authenticateMfaRecoveryCode)(variables, client)
+});
+
+//#endregion
+//#region src/hooks/useAuthenticatePasskeyMfa/useAuthenticatePasskeyMfa.ts
+/**
+* Completes an MFA challenge using the current user's passkey.
+*
+* Wraps `authenticatePasskeyMFA` from `@dynamic-labs-sdk/client`. Call
+* `mutate()` to satisfy an MFA step-up with a passkey; the resolved `data`
+* is the MFA verification response.
+*
+* @example
+* ```tsx
+* const { mutate: authenticatePasskeyMfa, isPending } =
+*   useAuthenticatePasskeyMfa();
+* <button onClick={() => authenticatePasskeyMfa()} disabled={isPending}>
+*   Verify with passkey
+* </button>
+* ```
+*/
+const useAuthenticatePasskeyMfa = ({ mutateParams } = {}) => useBaseMutation({
+	mutateParams,
+	mutationFn: ({ client, variables }) => (0, _dynamic_labs_sdk_client.authenticatePasskeyMFA)(variables, client)
+});
+
+//#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 }) => (0, _dynamic_labs_sdk_client.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 (0, _dynamic_labs_sdk_client.onEvent)({
+		event,
+		listener
+	}, client);
+};
+const useBaseState = ({ event, queryKey, queryParams, selector, defaultValue, skipWaitForInit = false }) => {
+	const client = useDynamicClient();
+	const queryClient = (0, _tanstack_react_query.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 = (0, react.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 = (0, react.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 = (0, react.useMemo)(() => {
+		const map = eventsMapRef.current;
+		return Object.keys(map).sort((a, b) => a.localeCompare(b));
+	}, [eventsMapJson]);
+	const fullQueryKey = (0, react.useMemo)(() => [
+		"@dynamic-labs-sdk/react-hooks",
+		"state",
+		...queryKey
+	], [JSON.stringify(queryKey)]);
+	(0, react.useEffect)(() => {
+		const core = (0, _dynamic_labs_sdk_client_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 (0, _tanstack_react_query.useQuery)({
+		...queryParams,
+		placeholderData: defaultValue,
+		queryFn: skipWaitForInit ? () => selector(client) : async () => {
+			await (0, _dynamic_labs_sdk_client.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) => (0, _dynamic_labs_sdk_client.getAvailableWalletProvidersData)(client)
+});
+
+//#endregion
+//#region src/hooks/useConsumeMfaToken/useConsumeMfaToken.ts
+/**
+* Consumes and clears the current MFA token from client state.
+*
+* Wraps `consumeMfaToken` from `@dynamic-labs-sdk/client`. Takes no
+* arguments — call `mutate()` to read the token from a successful MFA
+* authentication and remove it so it can't be reused; the resolved `data`
+* is the consumed token.
+*
+* @example
+* ```tsx
+* const { mutate: consumeMfaToken, data: mfaToken } = useConsumeMfaToken();
+* <button onClick={() => consumeMfaToken()}>Consume MFA token</button>
+* ```
+*/
+const useConsumeMfaToken = ({ mutateParams } = {}) => useBaseMutation({
+	mutateParams,
+	mutationFn: ({ client }) => Promise.resolve((0, _dynamic_labs_sdk_client.consumeMfaToken)(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 }) => (0, _dynamic_labs_sdk_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 }) => (0, _dynamic_labs_sdk_client.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 }) => (0, _dynamic_labs_sdk_client.deletePasskey)(variables, client)
+});
+
+//#endregion
+//#region src/hooks/useDeleteUser/useDeleteUser.ts
+/**
+* Permanently deletes the current user's account and logs them out.
+*
+* Wraps `deleteUser` from `@dynamic-labs-sdk/client`. Takes no arguments —
+* call `mutate()` to hard-delete the account; the resolved `data` is `void`.
+* This is destructive and irreversible.
+*
+* @example
+* ```tsx
+* const { mutate: deleteUser, isPending } = useDeleteUser();
+* <button onClick={() => deleteUser()} disabled={isPending}>
+*   Delete my account
+* </button>
+* ```
+*/
+const useDeleteUser = ({ mutateParams } = {}) => useBaseMutation({
+	mutateParams,
+	mutationFn: ({ client }) => (0, _dynamic_labs_sdk_client.deleteUser)(client)
+});
+
 //#endregion
 //#region src/hooks/useEvent/useEvent.ts
 /**
@@ -74,33 +411,237 @@ const useEvent = ({ event, listener }) => {
 };
 
 //#endregion
-//#region src/foundation/useBaseState/useBaseState.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 : (0, _dynamic_labs_sdk_client.isCaptchaRequired)(client)
+});
+
+//#endregion
+//#region src/hooks/useIsUserMissingMfaAuth/useIsUserMissingMfaAuth.ts
 /**
-* Internal hook that bridges Dynamic client event-driven state to React.
+* 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).
 *
-* Subscribes to a client event and re-derives a snapshot via the selector
-* each time the event fires, using useSyncExternalStore for tear-free reads.
+* 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 useBaseState = (eventName, getSnapshot) => {
+const useIsUserMissingMfaAuth = () => useBaseState({
+	defaultValue: false,
+	event: "userChanged",
+	queryKey: ["useIsUserMissingMfaAuth"],
+	selector: (client) => client.user === null ? false : (0, _dynamic_labs_sdk_client.isUserMissingMfaAuth)(client)
+});
+
+//#endregion
+//#region src/hooks/useIsUserOnboardingComplete/useIsUserOnboardingComplete.ts
+/**
+* Returns whether the current user has completed onboarding (no missing KYC
+* fields, MFA enrollment, or pending recovery-code acknowledgement).
+*
+* 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 : (0, _dynamic_labs_sdk_client.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 useLogout = ({ mutateParams } = {}) => useBaseMutation({
+	mutateParams,
+	mutationFn: ({ client }) => (0, _dynamic_labs_sdk_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 = (0, react.useRef)(getSnapshot(client));
-	return (0, react.useSyncExternalStore)((onStoreChange) => (0, _dynamic_labs_sdk_client.onEvent)({
-		event: eventName,
-		listener: () => {
-			valueRef.current = getSnapshot(client);
-			onStoreChange();
-		}
-	}, client), () => valueRef.current, () => valueRef.current);
+	return (0, _tanstack_react_query.useQuery)({
+		queryFn: async () => {
+			await (0, _dynamic_labs_sdk_client.waitForClientInitialized)(client);
+			return queryFn(client);
+		},
+		queryKey: (0, react.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) => (0, _dynamic_labs_sdk_client.getMfaDevices)(client),
+	queryKey: ["useMfaDevices"],
+	queryParams
+});
+
+//#endregion
+//#region src/hooks/useMfaMethods/useMfaMethods.ts
+/**
+* Returns the multi-factor authentication methods available to the current
+* user.
+*
+* Wraps `getMfaMethods` from `@dynamic-labs-sdk/client`.
+*
+* @example
+* ```tsx
+* const { data: mfaMethods, isLoading, refetch } = useMfaMethods();
+* ```
+*/
+const useMfaMethods = ({ queryParams } = {}) => useBaseQuery({
+	queryFn: (client) => (0, _dynamic_labs_sdk_client.getMfaMethods)(client),
+	queryKey: ["useMfaMethods"],
+	queryParams
+});
+
+//#endregion
+//#region src/hooks/useMfaRecoveryCodes/useMfaRecoveryCodes.ts
+/**
+* Returns the current user's MFA recovery codes.
+*
+* Wraps `getMfaRecoveryCodes` from `@dynamic-labs-sdk/client`.
+*
+* @example
+* ```tsx
+* const { data: recoveryCodes, isLoading, refetch } = useMfaRecoveryCodes();
+* ```
+*/
+const useMfaRecoveryCodes = ({ queryParams } = {}) => useBaseQuery({
+	queryFn: (client) => (0, _dynamic_labs_sdk_client.getMfaRecoveryCodes)(client),
+	queryKey: ["useMfaRecoveryCodes"],
+	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) => (0, _dynamic_labs_sdk_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 useInitStatus = () => useBaseState("initStatusChanged", (client) => client.initStatus);
+const useNativeBalance = ({ walletAccount, queryParams }) => useBaseQuery({
+	enabled: walletAccount !== void 0,
+	queryFn: (client) => (0, _dynamic_labs_sdk_client.getNativeBalance)({ walletAccount }, client),
+	queryKey: ["useNativeBalance", walletAccount?.id],
+	queryParams
+});
 
 //#endregion
 //#region src/hooks/useNetworksData/useNetworksData.ts
@@ -109,7 +650,201 @@ const useInitStatus = () => useBaseState("initStatusChanged", (client) => client
 *
 * Re-renders when project settings change.
 */
-const useNetworksData = () => useBaseState("projectSettingsChanged", (client) => (0, _dynamic_labs_sdk_client.getNetworksData)(client));
+const useNetworksData = () => useBaseState({
+	defaultValue: [],
+	event: "projectSettingsChanged",
+	queryKey: ["useNetworksData"],
+	selector: (client) => (0, _dynamic_labs_sdk_client.getNetworksData)(client)
+});
+
+//#endregion
+//#region src/hooks/usePasskeys/usePasskeys.ts
+/**
+* Returns the passkeys registered for the current user.
+*
+* Wraps `getPasskeys` from `@dynamic-labs-sdk/client`.
+*
+* @example
+* ```tsx
+* const { data: passkeys, isLoading, refetch } = usePasskeys();
+* ```
+*/
+const usePasskeys = ({ queryParams } = {}) => useBaseQuery({
+	queryFn: (client) => (0, _dynamic_labs_sdk_client.getPasskeys)(client),
+	queryKey: ["usePasskeys"],
+	queryParams
+});
+
+//#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 useRegisteredDevices = ({ queryParams } = {}) => useBaseQuery({
+	queryFn: (client) => (0, _dynamic_labs_sdk_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 }) => (0, _dynamic_labs_sdk_client.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 }) => (0, _dynamic_labs_sdk_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 }) => (0, _dynamic_labs_sdk_client.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 }) => (0, _dynamic_labs_sdk_client.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 }) => (0, _dynamic_labs_sdk_client.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 }) => (0, _dynamic_labs_sdk_client.sendSmsOTP)(variables, client)
+});
 
 //#endregion
 //#region src/hooks/useSessionExpiresAt/useSessionExpiresAt.ts
@@ -118,16 +853,229 @@ const useNetworksData = () => useBaseState("projectSettingsChanged", (client) =>
 *
 * Re-renders when the user changes (which includes session updates).
 */
-const useSessionExpiresAt = () => useBaseState("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 }) => (0, _dynamic_labs_sdk_client.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 }) => (0, _dynamic_labs_sdk_client.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 }) => (0, _dynamic_labs_sdk_client.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 }) => (0, _dynamic_labs_sdk_client.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 useSocialAccounts = () => useBaseState("userChanged", (client) => (0, _dynamic_labs_sdk_client.getUserSocialAccounts)(client));
+const useTokenBalances = ({ walletAccount, queryParams, ...rest }) => useBaseQuery({
+	enabled: walletAccount !== void 0,
+	queryFn: (client) => (0, _dynamic_labs_sdk_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) => (0, _dynamic_labs_sdk_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 useUnlinkSocialAccount = ({ mutateParams } = {}) => useBaseMutation({
+	mutateParams,
+	mutationFn: ({ client, variables }) => (0, _dynamic_labs_sdk_client.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 }) => (0, _dynamic_labs_sdk_client.updateUser)(variables, client)
+});
 
 //#endregion
 //#region src/hooks/useUser/useUser.ts
@@ -136,25 +1084,102 @@ const useSocialAccounts = () => useBaseState("userChanged", (client) => (0, _dyn
 *
 * Re-renders when the user changes (login, logout, profile update).
 */
-const useUser = () => useBaseState("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 = () => useBaseState("walletAccountsChanged", (client) => (0, _dynamic_labs_sdk_client.getWalletAccounts)(client));
+const useUserSocialAccounts = () => useBaseState({
+	defaultValue: [],
+	event: "userChanged",
+	queryKey: ["useUserSocialAccounts"],
+	selector: (client) => (0, _dynamic_labs_sdk_client.getUserSocialAccounts)(client)
+});
 
 //#endregion
-//#region src/hooks/useAvailableWalletProvidersData/useAvailableWalletProvidersData.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 useAvailableWalletProvidersData = () => useBaseState("walletProviderChanged", (client) => (0, _dynamic_labs_sdk_client.getAvailableWalletProvidersData)(client));
+const useVerifyOtp = ({ mutateParams } = {}) => useBaseMutation({
+	mutateParams,
+	mutationFn: ({ client, variables }) => (0, _dynamic_labs_sdk_client.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 }) => (0, _dynamic_labs_sdk_client.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) => (0, _dynamic_labs_sdk_client.getWalletAccounts)(client)
+});
 
 //#endregion
 //#region src/exports/index.ts
@@ -162,13 +1187,48 @@ const useAvailableWalletProvidersData = () => useBaseState("walletProviderChange
 
 //#endregion
 exports.DynamicProvider = DynamicProvider;
+exports.useAuthenticateMfaRecoveryCode = useAuthenticateMfaRecoveryCode;
+exports.useAuthenticatePasskeyMfa = useAuthenticatePasskeyMfa;
+exports.useAuthenticateTotpMfaDevice = useAuthenticateTotpMfaDevice;
 exports.useAvailableWalletProvidersData = useAvailableWalletProvidersData;
+exports.useConsumeMfaToken = useConsumeMfaToken;
+exports.useCreateNewMfaRecoveryCodes = useCreateNewMfaRecoveryCodes;
+exports.useDeleteMfaDevice = useDeleteMfaDevice;
+exports.useDeletePasskey = useDeletePasskey;
+exports.useDeleteUser = useDeleteUser;
 exports.useDynamicClient = useDynamicClient;
 exports.useEvent = useEvent;
 exports.useInitStatus = useInitStatus;
+exports.useIsCaptchaRequired = useIsCaptchaRequired;
+exports.useIsUserMissingMfaAuth = useIsUserMissingMfaAuth;
+exports.useIsUserOnboardingComplete = useIsUserOnboardingComplete;
+exports.useLogout = useLogout;
+exports.useMfaDevices = useMfaDevices;
+exports.useMfaMethods = useMfaMethods;
+exports.useMfaRecoveryCodes = useMfaRecoveryCodes;
+exports.useMultichainTokenBalances = useMultichainTokenBalances;
+exports.useNativeBalance = useNativeBalance;
 exports.useNetworksData = useNetworksData;
+exports.usePasskeys = usePasskeys;
+exports.useRegisterPasskey = useRegisterPasskey;
+exports.useRegisterTotpMfaDevice = useRegisterTotpMfaDevice;
+exports.useRegisteredDevices = useRegisteredDevices;
+exports.useRemoveWalletAccount = useRemoveWalletAccount;
+exports.useRevokeRegisteredDevice = useRevokeRegisteredDevice;
+exports.useSendEmailOtp = useSendEmailOtp;
+exports.useSendSmsOtp = useSendSmsOtp;
 exports.useSessionExpiresAt = useSessionExpiresAt;
-exports.useSocialAccounts = useSocialAccounts;
+exports.useSetDefaultMfaDevice = useSetDefaultMfaDevice;
+exports.useSignInWithPasskey = useSignInWithPasskey;
+exports.useSignMessage = useSignMessage;
+exports.useSwitchActiveNetwork = useSwitchActiveNetwork;
+exports.useTokenBalances = useTokenBalances;
+exports.useTransactionHistory = useTransactionHistory;
+exports.useUnlinkSocialAccount = useUnlinkSocialAccount;
+exports.useUpdateUser = useUpdateUser;
 exports.useUser = useUser;
+exports.useUserSocialAccounts = useUserSocialAccounts;
+exports.useVerifyOtp = useVerifyOtp;
+exports.useVerifyWalletAccount = useVerifyWalletAccount;
 exports.useWalletAccounts = useWalletAccounts;
 //# sourceMappingURL=index.cjs.map