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

package/dist/index.esm.js

@@ -1,5 +1,5 @@
 import { assertPackageVersion } from "@dynamic-labs-sdk/assert-package-version";
-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 { BaseError, acknowledgeRecoveryCodes, addNetwork, authenticateMfaRecoveryCode, authenticatePasskeyMFA, authenticateTotpMfaDevice, completeDeviceRegistration, completeSocialRedirect, confirmTransaction, consumeMfaToken, createCoinbaseOnrampOrder, createCryptoDotComPayment, createNewMfaRecoveryCodes, deleteMfaDevice, deletePasskey, deleteUser, executeSwapTransaction, getActiveNetworkData, getAvailableWalletProvidersData, getBalanceForAddress, getCoinbaseBuyUrl, getGoogleDriveBackupReadiness, getKrakenWhitelistedAddresses, getMfaDevices, getMfaMethods, getMfaRecoveryCodes, getMultichainTokenBalances, getNativeBalance, getNetworksData, getPasskeys, getRegisteredDevices, getTokenBalances, getTransactionHistory, getUserSocialAccounts, getWalletAccounts, isCaptchaRequired, isUserMissingMfaAuth, isUserOnboardingComplete, logout, onEvent, proveWalletAccountOwnership, refreshAuth, registerPasskey, registerTotpMfaDevice, removeWalletAccount, requestExternalAuthElevatedToken, revokeAllRegisteredDevices, revokeRegisteredDevice, sendEmailOTP, sendSmsOTP, setDefaultMfaDevice, signInWithExternalJwt, signInWithPasskey, signInWithSocialPopUp, signInWithSocialRedirect, signMessage, switchActiveNetwork, transferAmount, transferWalletAccount, 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";
@@ -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.5.0";
+var version = "1.7.0";
 
 //#endregion
 //#region src/modules/DynamicContext/DynamicContext.ts
@@ -85,6 +85,145 @@ const useBaseMutation = ({ mutationFn, mutateParams }) => {
 	});
 };
 
+//#endregion
+//#region src/hooks/useAcknowledgeRecoveryCodes/useAcknowledgeRecoveryCodes.ts
+/**
+* Marks the current user's MFA recovery codes as acknowledged. Takes no arguments — call `mutate()` after the user confirms they have stored the codes shown by {@link useMfaRecoveryCodes}.
+*
+* @example
+* ```tsx
+* const { mutate: acknowledge, isPending } = useAcknowledgeRecoveryCodes();
+* <button onClick={() => acknowledge()} disabled={isPending}>
+*   I've saved my recovery codes
+* </button>
+* ```
+*/
+const useAcknowledgeRecoveryCodes = ({ mutateParams } = {}) => useBaseMutation({
+	mutateParams,
+	mutationFn: ({ client }) => acknowledgeRecoveryCodes(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();
+	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/useActiveNetworkData/useActiveNetworkData.ts
+/**
+* Wraps `getActiveNetworkData` from `@dynamic-labs-sdk/client`. Returns the network the given wallet account is currently on.
+*
+* @example
+* ```tsx
+* const { data: network, isLoading } = useActiveNetworkData({ walletAccount });
+* ```
+*/
+const useActiveNetworkData = ({ queryParams, ...args }) => useBaseQuery({
+	queryFn: (client) => getActiveNetworkData(args, client),
+	queryKey: ["useActiveNetworkData", args],
+	queryParams
+});
+
+//#endregion
+//#region src/hooks/useAddNetwork/useAddNetwork.ts
+/**
+* Wraps `addNetwork` from `@dynamic-labs-sdk/client`. Call `mutate({ networkData, walletAccount })` to register a custom network on the given wallet account.
+*
+* @example
+* ```tsx
+* const { mutate: addNetwork, isPending } = useAddNetwork();
+* <button
+*   onClick={() => addNetwork({ networkData, walletAccount })}
+*   disabled={isPending}
+* >
+*   Add network
+* </button>
+* ```
+*/
+const useAddNetwork = ({ mutateParams } = {}) => useBaseMutation({
+	mutateParams,
+	mutationFn: ({ client, variables }) => addNetwork(variables, client)
+});
+
+//#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 }) => 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 }) => authenticatePasskeyMFA(variables, client)
+});
+
 //#endregion
 //#region src/hooks/useAuthenticateTotpMfaDevice/useAuthenticateTotpMfaDevice.ts
 /**
@@ -230,6 +369,142 @@ const useAvailableWalletProvidersData = () => useBaseState({
 	selector: (client) => getAvailableWalletProvidersData(client)
 });
 
+//#endregion
+//#region src/hooks/useBalanceForAddress/useBalanceForAddress.ts
+/**
+* Wraps `getBalanceForAddress` from `@dynamic-labs-sdk/client`. Returns the native-token balance for an arbitrary address on the given chain/network.
+*
+* @example
+* ```tsx
+* const { data, isLoading } = useBalanceForAddress({ address, chain, networkId });
+* ```
+*/
+const useBalanceForAddress = ({ queryParams, ...args }) => useBaseQuery({
+	queryFn: (client) => getBalanceForAddress(args, client),
+	queryKey: ["useBalanceForAddress", args],
+	queryParams
+});
+
+//#endregion
+//#region src/hooks/useCoinbaseBuyUrl/useCoinbaseBuyUrl.ts
+/**
+* Wraps `getCoinbaseBuyUrl` from `@dynamic-labs-sdk/client`. Returns a Coinbase onramp buy URL for the given parameters.
+*
+* @example
+* ```tsx
+* const { data: buyUrl, isLoading } = useCoinbaseBuyUrl(buyUrlParams);
+* ```
+*/
+const useCoinbaseBuyUrl = ({ queryParams, ...args }) => useBaseQuery({
+	queryFn: (client) => getCoinbaseBuyUrl(args, client),
+	queryKey: ["useCoinbaseBuyUrl", args],
+	queryParams
+});
+
+//#endregion
+//#region src/hooks/useCompleteDeviceRegistration/useCompleteDeviceRegistration.ts
+/**
+* Wraps `completeDeviceRegistration` from `@dynamic-labs-sdk/client`. Call `mutate({ deviceToken })` with the device token parsed from the redirect URL; the resolved `data` is a `VerifyResponse`.
+*
+* @example
+* ```tsx
+* const { mutate: completeRegistration, isPending } =
+*   useCompleteDeviceRegistration();
+* completeRegistration({ deviceToken });
+* ```
+*/
+const useCompleteDeviceRegistration = ({ mutateParams } = {}) => useBaseMutation({
+	mutateParams,
+	mutationFn: ({ client, variables }) => completeDeviceRegistration(variables, client)
+});
+
+//#endregion
+//#region src/hooks/useCompleteSocialRedirect/useCompleteSocialRedirect.ts
+/**
+* Wraps `completeSocialRedirect` from `@dynamic-labs-sdk/client`. Call `mutate(params)` with the OAuth callback URL once the provider has redirected back to finish the sign-in; the resolved `data` is the signed-in `User` (or `null`).
+*
+* @example
+* ```tsx
+* const { mutate: completeSocialRedirect, data: user } =
+*   useCompleteSocialRedirect();
+* completeSocialRedirect({ url: new URL(window.location.href) });
+* ```
+*/
+const useCompleteSocialRedirect = ({ mutateParams } = {}) => useBaseMutation({
+	mutateParams,
+	mutationFn: ({ client, variables }) => completeSocialRedirect(variables, client)
+});
+
+//#endregion
+//#region src/hooks/useConfirmTransaction/useConfirmTransaction.ts
+/**
+* Wraps `confirmTransaction` from `@dynamic-labs-sdk/client`. Call `mutate({ walletAccount, transactionHash })` to await confirmation of a submitted transaction; the resolved `data` is `void`.
+*
+* @example
+* ```tsx
+* const { mutate: confirmTransaction, isPending } = useConfirmTransaction();
+* confirmTransaction({ walletAccount, transactionHash });
+* ```
+*/
+const useConfirmTransaction = ({ mutateParams } = {}) => useBaseMutation({
+	mutateParams,
+	mutationFn: ({ client, variables }) => confirmTransaction(variables, 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(consumeMfaToken(client))
+});
+
+//#endregion
+//#region src/hooks/useCreateCoinbaseOnrampOrder/useCreateCoinbaseOnrampOrder.ts
+/**
+* Wraps `createCoinbaseOnrampOrder` from `@dynamic-labs-sdk/client`. Call `mutate(orderParams)` to create a Coinbase onramp order; the resolved `data` is the order response.
+*
+* @example
+* ```tsx
+* const { mutate: createOrder, data: order } = useCreateCoinbaseOnrampOrder();
+* createOrder(orderParams);
+* ```
+*/
+const useCreateCoinbaseOnrampOrder = ({ mutateParams } = {}) => useBaseMutation({
+	mutateParams,
+	mutationFn: ({ client, variables }) => createCoinbaseOnrampOrder(variables, client)
+});
+
+//#endregion
+//#region src/hooks/useCreateCryptoDotComPayment/useCreateCryptoDotComPayment.ts
+/**
+* Wraps `createCryptoDotComPayment` from `@dynamic-labs-sdk/client`. Call `mutate(paymentParams)` to create a Crypto.com Pay payment; the resolved `data` is the payment response.
+*
+* @example
+* ```tsx
+* const { mutate: createPayment, data: payment } =
+*   useCreateCryptoDotComPayment();
+* createPayment(paymentParams);
+* ```
+*/
+const useCreateCryptoDotComPayment = ({ mutateParams } = {}) => useBaseMutation({
+	mutateParams,
+	mutationFn: ({ client, variables }) => createCryptoDotComPayment(variables, client)
+});
+
 //#endregion
 //#region src/hooks/useCreateNewMfaRecoveryCodes/useCreateNewMfaRecoveryCodes.ts
 /**
@@ -297,6 +572,28 @@ const useDeletePasskey = ({ mutateParams } = {}) => useBaseMutation({
 	mutationFn: ({ client, variables }) => 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 }) => deleteUser(client)
+});
+
 //#endregion
 //#region src/hooks/useEvent/useEvent.ts
 /**
@@ -317,6 +614,38 @@ const useEvent = ({ event, listener }) => {
 	}, client), [event, client]);
 };
 
+//#endregion
+//#region src/hooks/useExecuteSwapTransaction/useExecuteSwapTransaction.ts
+/**
+* Wraps `executeSwapTransaction` from `@dynamic-labs-sdk/client`. Call `mutate({ walletAccount, signingPayload })` (using a payload from {@link useSwapQuote}) to execute a swap; the resolved `data` is `{ transactionHash }`.
+*
+* @example
+* ```tsx
+* const { mutate: executeSwap, data } = useExecuteSwapTransaction();
+* executeSwap({ walletAccount, signingPayload });
+* ```
+*/
+const useExecuteSwapTransaction = ({ mutateParams } = {}) => useBaseMutation({
+	mutateParams,
+	mutationFn: ({ client, variables }) => executeSwapTransaction(variables, client)
+});
+
+//#endregion
+//#region src/hooks/useGoogleDriveBackupReadiness/useGoogleDriveBackupReadiness.ts
+/**
+* Wraps `getGoogleDriveBackupReadiness` from `@dynamic-labs-sdk/client`. Reports whether the user's Google Drive backup is set up and available.
+*
+* @example
+* ```tsx
+* const { data: readiness, isLoading } = useGoogleDriveBackupReadiness();
+* ```
+*/
+const useGoogleDriveBackupReadiness = ({ queryParams } = {}) => useBaseQuery({
+	queryFn: (client) => getGoogleDriveBackupReadiness(client),
+	queryKey: ["useGoogleDriveBackupReadiness"],
+	queryParams
+});
+
 //#endregion
 //#region src/hooks/useInitStatus/useInitStatus.ts
 /**
@@ -396,6 +725,22 @@ const useIsUserOnboardingComplete = () => useBaseState({
 	selector: (client) => client.user === null ? false : isUserOnboardingComplete(client)
 });
 
+//#endregion
+//#region src/hooks/useKrakenWhitelistedAddresses/useKrakenWhitelistedAddresses.ts
+/**
+* Wraps `getKrakenWhitelistedAddresses` from `@dynamic-labs-sdk/client`. Returns the destination addresses whitelisted for Kraken withdrawals.
+*
+* @example
+* ```tsx
+* const { data: addresses, isLoading } = useKrakenWhitelistedAddresses();
+* ```
+*/
+const useKrakenWhitelistedAddresses = ({ queryParams } = {}) => useBaseQuery({
+	queryFn: (client) => getKrakenWhitelistedAddresses(client),
+	queryKey: ["useKrakenWhitelistedAddresses"],
+	queryParams
+});
+
 //#endregion
 //#region src/hooks/useLogout/useLogout.ts
 /**
@@ -415,40 +760,6 @@ const useLogout = ({ mutateParams } = {}) => useBaseMutation({
 	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();
-	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/useMfaDevices/useMfaDevices.ts
 /**
@@ -468,6 +779,43 @@ const useMfaDevices = ({ queryParams } = {}) => useBaseQuery({
 	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) => 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) => getMfaRecoveryCodes(client),
+	queryKey: ["useMfaRecoveryCodes"],
+	queryParams
+});
+
 //#endregion
 //#region src/hooks/useMultichainTokenBalances/useMultichainTokenBalances.ts
 /**
@@ -527,6 +875,59 @@ const useNetworksData = () => useBaseState({
 	selector: (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) => getPasskeys(client),
+	queryKey: ["usePasskeys"],
+	queryParams
+});
+
+//#endregion
+//#region src/hooks/useProveWalletAccountOwnership/useProveWalletAccountOwnership.ts
+/**
+* Wraps `proveWalletAccountOwnership` from `@dynamic-labs-sdk/client`. Call `mutate({ walletAccount })` to prove ownership of a connected wallet account by signing a challenge.
+*
+* @example
+* ```tsx
+* const { mutate: proveOwnership, isPending } =
+*   useProveWalletAccountOwnership();
+* proveOwnership({ walletAccount });
+* ```
+*/
+const useProveWalletAccountOwnership = ({ mutateParams } = {}) => useBaseMutation({
+	mutateParams,
+	mutationFn: ({ client, variables }) => proveWalletAccountOwnership(variables, client)
+});
+
+//#endregion
+//#region src/hooks/useRefreshAuth/useRefreshAuth.ts
+/**
+* Wraps `refreshAuth` from `@dynamic-labs-sdk/client`. Takes no arguments — call `mutate()` to refresh the session/JWT; the resolved `data` is a `VerifyResponse`.
+*
+* @example
+* ```tsx
+* const { mutate: refreshAuth, isPending } = useRefreshAuth();
+* <button onClick={() => refreshAuth()} disabled={isPending}>
+*   Refresh session
+* </button>
+* ```
+*/
+const useRefreshAuth = ({ mutateParams } = {}) => useBaseMutation({
+	mutateParams,
+	mutationFn: ({ client }) => refreshAuth(client)
+});
+
 //#endregion
 //#region src/hooks/useRegisteredDevices/useRegisteredDevices.ts
 /**
@@ -616,6 +1017,42 @@ const useRemoveWalletAccount = ({ mutateParams } = {}) => useBaseMutation({
 	mutationFn: ({ client, variables }) => removeWalletAccount(variables, client)
 });
 
+//#endregion
+//#region src/hooks/useRequestExternalAuthElevatedToken/useRequestExternalAuthElevatedToken.ts
+/**
+* Wraps `requestExternalAuthElevatedToken` from `@dynamic-labs-sdk/client`. Call `mutate({ externalJwt })` to exchange an externally issued JWT for an elevated-access token.
+*
+* @example
+* ```tsx
+* const { mutate: requestElevatedToken } =
+*   useRequestExternalAuthElevatedToken();
+* requestElevatedToken({ externalJwt });
+* ```
+*/
+const useRequestExternalAuthElevatedToken = ({ mutateParams } = {}) => useBaseMutation({
+	mutateParams,
+	mutationFn: ({ client, variables }) => requestExternalAuthElevatedToken(variables, client)
+});
+
+//#endregion
+//#region src/hooks/useRevokeAllRegisteredDevices/useRevokeAllRegisteredDevices.ts
+/**
+* Wraps `revokeAllRegisteredDevices` from `@dynamic-labs-sdk/client`. Takes no arguments — call `mutate()` to revoke every device registered to the current user; the resolved `data` is `void`.
+*
+* @example
+* ```tsx
+* const { mutate: revokeAllDevices, isPending } =
+*   useRevokeAllRegisteredDevices();
+* <button onClick={() => revokeAllDevices()} disabled={isPending}>
+*   Revoke all devices
+* </button>
+* ```
+*/
+const useRevokeAllRegisteredDevices = ({ mutateParams } = {}) => useBaseMutation({
+	mutateParams,
+	mutationFn: ({ client }) => revokeAllRegisteredDevices(client)
+});
+
 //#endregion
 //#region src/hooks/useRevokeRegisteredDevice/useRevokeRegisteredDevice.ts
 /**
@@ -733,6 +1170,22 @@ const useSetDefaultMfaDevice = ({ mutateParams } = {}) => useBaseMutation({
 	mutationFn: ({ client, variables }) => setDefaultMfaDevice(variables, client)
 });
 
+//#endregion
+//#region src/hooks/useSignInWithExternalJwt/useSignInWithExternalJwt.ts
+/**
+* Wraps `signInWithExternalJwt` from `@dynamic-labs-sdk/client`. Call `mutate({ externalJwt })` to authenticate the user with a JWT issued by an external auth provider.
+*
+* @example
+* ```tsx
+* const { mutate: signInWithJwt, isPending } = useSignInWithExternalJwt();
+* signInWithJwt({ externalJwt });
+* ```
+*/
+const useSignInWithExternalJwt = ({ mutateParams } = {}) => useBaseMutation({
+	mutateParams,
+	mutationFn: ({ client, variables }) => signInWithExternalJwt(variables, client)
+});
+
 //#endregion
 //#region src/hooks/useSignInWithPasskey/useSignInWithPasskey.ts
 /**
@@ -755,6 +1208,39 @@ const useSignInWithPasskey = ({ mutateParams } = {}) => useBaseMutation({
 	mutationFn: ({ client, variables }) => signInWithPasskey(variables, client)
 });
 
+//#endregion
+//#region src/hooks/useSignInWithSocialPopUp/useSignInWithSocialPopUp.ts
+/**
+* Wraps `signInWithSocialPopUp` from `@dynamic-labs-sdk/client`. Call `mutate({ provider })` to open the provider's OAuth popup; the resolved `data` is the signed-in `User` (or `null`).
+*
+* @example
+* ```tsx
+* const { mutate: signInWithPopUp, data: user } =
+*   useSignInWithSocialPopUp();
+* signInWithPopUp({ provider: 'google' });
+* ```
+*/
+const useSignInWithSocialPopUp = ({ mutateParams } = {}) => useBaseMutation({
+	mutateParams,
+	mutationFn: ({ client, variables }) => signInWithSocialPopUp(variables, client)
+});
+
+//#endregion
+//#region src/hooks/useSignInWithSocialRedirect/useSignInWithSocialRedirect.ts
+/**
+* Wraps `signInWithSocialRedirect` from `@dynamic-labs-sdk/client`. Call `mutate({ provider, redirectUrl })` to redirect the user to the provider's OAuth page; complete the flow with {@link useCompleteSocialAuthentication}.
+*
+* @example
+* ```tsx
+* const { mutate: signInWithRedirect } = useSignInWithSocialRedirect();
+* signInWithRedirect({ provider: 'google', redirectUrl });
+* ```
+*/
+const useSignInWithSocialRedirect = ({ mutateParams } = {}) => useBaseMutation({
+	mutateParams,
+	mutationFn: ({ client, variables }) => signInWithSocialRedirect(variables, client)
+});
+
 //#endregion
 //#region src/hooks/useSignMessage/useSignMessage.ts
 /**
@@ -876,6 +1362,39 @@ const useTransactionHistory = ({ address, chain, networkId, queryParams, ...rest
 	queryParams
 });
 
+//#endregion
+//#region src/hooks/useTransferAmount/useTransferAmount.ts
+/**
+* Wraps `transferAmount` from `@dynamic-labs-sdk/client`. Call `mutate({ walletAccount, amount, recipient, token })` to send tokens; the resolved `data` is `{ transactionHash }`.
+*
+* @example
+* ```tsx
+* const { mutate: transfer, data } = useTransferAmount();
+* transfer({ walletAccount, amount, recipient, token });
+* ```
+*/
+const useTransferAmount = ({ mutateParams } = {}) => useBaseMutation({
+	mutateParams,
+	mutationFn: ({ client, variables }) => transferAmount(variables, client)
+});
+
+//#endregion
+//#region src/hooks/useTransferWalletAccount/useTransferWalletAccount.ts
+/**
+* Wraps `transferWalletAccount` from `@dynamic-labs-sdk/client`. Call `mutate({ walletProviderKey })` to transfer (hand off) a wallet account to the given provider.
+*
+* @example
+* ```tsx
+* const { mutate: transferWalletAccount, isPending } =
+*   useTransferWalletAccount();
+* transferWalletAccount({ walletProviderKey });
+* ```
+*/
+const useTransferWalletAccount = ({ mutateParams } = {}) => useBaseMutation({
+	mutateParams,
+	mutationFn: ({ client, variables }) => transferWalletAccount(variables, client)
+});
+
 //#endregion
 //#region src/hooks/useUnlinkSocialAccount/useUnlinkSocialAccount.ts
 /**
@@ -1038,5 +1557,5 @@ const useWalletAccounts = () => useBaseState({
 assertPackageVersion(name, version);
 
 //#endregion
-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 };
+export { DynamicProvider, useAcknowledgeRecoveryCodes, useActiveNetworkData, useAddNetwork, useAuthenticateMfaRecoveryCode, useAuthenticatePasskeyMfa, useAuthenticateTotpMfaDevice, useAvailableWalletProvidersData, useBalanceForAddress, useCoinbaseBuyUrl, useCompleteDeviceRegistration, useCompleteSocialRedirect, useConfirmTransaction, useConsumeMfaToken, useCreateCoinbaseOnrampOrder, useCreateCryptoDotComPayment, useCreateNewMfaRecoveryCodes, useDeleteMfaDevice, useDeletePasskey, useDeleteUser, useDynamicClient, useEvent, useExecuteSwapTransaction, useGoogleDriveBackupReadiness, useInitStatus, useIsCaptchaRequired, useIsUserMissingMfaAuth, useIsUserOnboardingComplete, useKrakenWhitelistedAddresses, useLogout, useMfaDevices, useMfaMethods, useMfaRecoveryCodes, useMultichainTokenBalances, useNativeBalance, useNetworksData, usePasskeys, useProveWalletAccountOwnership, useRefreshAuth, useRegisterPasskey, useRegisterTotpMfaDevice, useRegisteredDevices, useRemoveWalletAccount, useRequestExternalAuthElevatedToken, useRevokeAllRegisteredDevices, useRevokeRegisteredDevice, useSendEmailOtp, useSendSmsOtp, useSessionExpiresAt, useSetDefaultMfaDevice, useSignInWithExternalJwt, useSignInWithPasskey, useSignInWithSocialPopUp, useSignInWithSocialRedirect, useSignMessage, useSwitchActiveNetwork, useTokenBalances, useTransactionHistory, useTransferAmount, useTransferWalletAccount, useUnlinkSocialAccount, useUpdateUser, useUser, useUserSocialAccounts, useVerifyOtp, useVerifyWalletAccount, useWalletAccounts };
 //# sourceMappingURL=index.esm.js.map