@zama-fhe/react-sdk 1.0.0-alpha.2

package/dist/index.d.ts

@@ -0,0 +1,1082 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import * as _zama_fhe_sdk from '@zama-fhe/sdk';
+import { RelayerSDK, GenericSigner, GenericStringStorage, ZamaSDKEventListener, ZamaSDK, EncryptParams, EncryptResult, UserDecryptParams, PublicDecryptResult, FHEKeypair, EIP712TypedData, Address, DelegatedUserDecryptParams, ZKProofLike, Token, TransactionResult, ReadonlyToken } from '@zama-fhe/sdk';
+export { ActivityAmount, ActivityDirection, ActivityItem, ActivityLogMetadata, ActivityType, Address, ApprovalFailedError, ApproveSubmittedEvent, ApproveUnderlyingSubmittedEvent, BATCH_SWAP_ABI, BatchDecryptOptions, BatchTransferData, ConfidentialTransferEvent, ContractCallConfig, CredentialExpiredError, CredentialsCachedEvent, CredentialsCreatedEvent, CredentialsCreatingEvent, CredentialsExpiredEvent, CredentialsLoadingEvent, CredentialsManager, DEPLOYMENT_COORDINATOR_ABI, DecryptEndEvent, DecryptErrorEvent, DecryptStartEvent, DecryptionFailedError, DelegatedUserDecryptParams, EIP712TypedData, ENCRYPTION_ABI, ERC165_ABI, ERC20_ABI, ERC20_METADATA_ABI, ERC7984_INTERFACE_ID, ERC7984_WRAPPER_INTERFACE_ID, EncryptEndEvent, EncryptErrorEvent, EncryptParams, EncryptResult, EncryptStartEvent, EncryptionFailedError, FEE_MANAGER_ABI, FHEKeypair, FhevmInstanceConfig, FinalizeUnwrapSubmittedEvent, GenericSigner, GenericStringStorage, HardhatConfig, Hex, IndexedDBStorage, InputProofBytesType, InvalidCredentialsError, KmsDelegatedUserDecryptEIP712Type, MainnetConfig, MemoryStorage, NetworkType, NoCiphertextError, OnChainEvent, PublicDecryptResult, RawLog, ReadonlyToken, ReadonlyTokenConfig, RelayerRequestFailedError, RelayerSDK, RelayerSDKStatus, RelayerWeb, RelayerWebConfig, SepoliaConfig, ShieldSubmittedEvent, SigningFailedError, SigningRejectedError, StoredCredentials, TOKEN_TOPICS, TRANSFER_BATCHER_ABI, Token, TokenConfig, Topics, TransactionErrorEvent, TransactionReceipt, TransactionResult, TransactionRevertedError, TransferFromSubmittedEvent, TransferSubmittedEvent, UnshieldCallbacks, UnshieldPhase1SubmittedEvent, UnshieldPhase2StartedEvent, UnshieldPhase2SubmittedEvent, UnwrapRequestedEvent, UnwrapSubmittedEvent, UnwrappedFinalizedEvent, UnwrappedStartedEvent, UserDecryptParams, WRAPPER_ABI, WrappedEvent, ZERO_HANDLE, ZKProofLike, ZamaError, ZamaErrorCode, ZamaSDK, ZamaSDKConfig, ZamaSDKEvent, ZamaSDKEventInput, ZamaSDKEventListener, ZamaSDKEventType, ZamaSDKEvents, allowanceContract, applyDecryptedValues, approveContract, balanceOfContract, clearPendingUnshield, confidentialBalanceOfContract, confidentialBatchTransferContract, confidentialTotalSupplyContract, confidentialTransferContract, confidentialTransferFromContract, decimalsContract, decodeConfidentialTransfer, decodeOnChainEvent, decodeOnChainEvents, decodeUnwrapRequested, decodeUnwrappedFinalized, decodeUnwrappedStarted, decodeWrapped, deploymentCoordinatorContract, extractEncryptedHandles, finalizeUnwrapContract, findUnwrapRequested, findWrapped, getBatchTransferFeeContract, getFeeRecipientContract, getUnwrapFeeContract, getWrapFeeContract, getWrapperContract, indexedDBStorage, isConfidentialTokenContract, isConfidentialWrapperContract, isFinalizeUnwrapOperatorContract, isOperatorContract, loadPendingUnshield, matchZamaError, nameContract, parseActivityFeed, rateContract, savePendingUnshield, setFinalizeUnwrapOperatorContract, setOperatorContract, sortByBlockNumber, supportsInterfaceContract, symbolContract, totalSupplyContract, underlyingContract, unwrapContract, unwrapFromBalanceContract, wrapContract, wrapETHContract, wrapperExistsContract } from '@zama-fhe/sdk';
+import { PropsWithChildren } from 'react';
+import * as _tanstack_react_query from '@tanstack/react-query';
+import { UseMutationOptions, UseQueryOptions, UseQueryResult, UseSuspenseQueryResult } from '@tanstack/react-query';
+import * as _zama_fhe_relayer_sdk_web from '@zama-fhe/relayer-sdk/web';
+import { U as UseZamaConfig } from './use-approve-underlying-DAkxWhfm.js';
+export { A as ApproveUnderlyingParams, C as ConfidentialApproveParams, a as ConfidentialTransferFromParams, R as ResumeUnshieldParams, T as TokenMetadata, b as UnshieldAllParams, c as UnshieldParams, d as UseActivityFeedConfig, e as UseConfidentialBalanceConfig, f as UseConfidentialBalanceOptions, g as UseConfidentialBalancesConfig, h as UseConfidentialBalancesOptions, i as activityFeedQueryKeys, j as approveUnderlyingMutationOptions, k as authorizeAllMutationOptions, l as confidentialApproveMutationOptions, m as confidentialTransferFromMutationOptions, r as resumeUnshieldMutationOptions, t as tokenMetadataQueryKeys, n as tokenMetadataQueryOptions, u as unshieldAllMutationOptions, o as unshieldMutationOptions, p as unwrapAllMutationOptions, q as useActivityFeed, s as useApproveUnderlying, v as useAuthorizeAll, w as useConfidentialApprove, x as useConfidentialBalance, y as useConfidentialBalances, z as useConfidentialTransferFrom, B as useResumeUnshield, D as useToken, E as useTokenMetadata, F as useTokenMetadataSuspense, G as useUnshield, H as useUnshieldAll, I as useUnwrapAll } from './use-approve-underlying-DAkxWhfm.js';
+
+/** Props for {@link ZamaProvider}. */
+interface ZamaProviderProps extends PropsWithChildren {
+    /** FHE relayer backend (RelayerWeb for browser, RelayerNode for server). */
+    relayer: RelayerSDK;
+    /** Wallet signer (ViemSigner, EthersSigner, or custom GenericSigner). */
+    signer: GenericSigner;
+    /** Credential storage backend (IndexedDBStorage for browser, MemoryStorage for tests). */
+    storage: GenericStringStorage;
+    /** Number of days credentials remain valid (default: relayer default). */
+    credentialDurationDays?: number;
+    /** Callback invoked on SDK lifecycle events. */
+    onEvent?: ZamaSDKEventListener;
+}
+/**
+ * Provides a {@link ZamaSDK} instance to all descendant hooks.
+ * Terminates the relayer on unmount.
+ *
+ * @example
+ * ```tsx
+ * <ZamaProvider relayer={relayer} signer={signer} storage={storage}>
+ *   <App />
+ * </ZamaProvider>
+ * ```
+ */
+declare function ZamaProvider({ children, relayer, signer, storage, credentialDurationDays, onEvent, }: ZamaProviderProps): react_jsx_runtime.JSX.Element;
+/**
+ * Access the {@link ZamaSDK} instance from context.
+ * Must be used within a {@link ZamaProvider}.
+ *
+ * @example
+ * ```tsx
+ * const sdk = useZamaSDK();
+ * const token = sdk.createReadonlyToken("0x...");
+ * ```
+ */
+declare function useZamaSDK(): ZamaSDK;
+
+/**
+ * TanStack Query mutation options factory for FHE encrypt.
+ *
+ * @param sdk - A `ZamaSDK` instance.
+ * @returns Mutation options with `mutationKey` and `mutationFn`.
+ */
+declare function encryptMutationOptions(sdk: ZamaSDK): {
+    mutationKey: readonly ["encrypt"];
+    mutationFn: (params: EncryptParams) => Promise<EncryptResult>;
+};
+/**
+ * Encrypt a plaintext value using FHE.
+ * Calls the relayer's `encrypt` method via a mutation.
+ *
+ * @returns A mutation whose `mutate` accepts {@link EncryptParams}.
+ *
+ * @example
+ * ```tsx
+ * const encrypt = useEncrypt();
+ * encrypt.mutate({ values: [1000n], bits: [64] });
+ * ```
+ */
+declare function useEncrypt(): _tanstack_react_query.UseMutationResult<EncryptResult, Error, EncryptParams, unknown>;
+
+/**
+ * Thin wrapper around sdk.userDecrypt().
+ * Caller is responsible for providing all params (keypair, signature, etc.).
+ * For the full orchestration (signature management, EIP712 signing),
+ * see the app-level useUserDecryptFlow hook.
+ *
+ * On success, populates the decryption cache so useUserDecryptedValue/useUserDecryptedValues
+ * can read the results.
+ */
+declare function useUserDecrypt(): _tanstack_react_query.UseMutationResult<Record<string, bigint>, Error, UserDecryptParams, unknown>;
+
+/**
+ * Decrypt FHE ciphertext handles using the network public key (no credential needed).
+ * On success, populates the decryption cache so {@link useUserDecryptedValue} / {@link useUserDecryptedValues}
+ * can read the results.
+ *
+ * @returns A mutation whose `mutate` accepts an array of handle strings.
+ *
+ * @example
+ * ```tsx
+ * const publicDecrypt = usePublicDecrypt();
+ * publicDecrypt.mutate(["0xHandle1", "0xHandle2"]);
+ * // publicDecrypt.data?.clearValues => { "0xHandle1": 500n, ... }
+ * ```
+ */
+declare function usePublicDecrypt(): _tanstack_react_query.UseMutationResult<PublicDecryptResult, Error, string[], unknown>;
+
+/**
+ * Generate an FHE keypair via the relayer.
+ * Returns a public/private key pair for use in decrypt authorization.
+ *
+ * @returns A mutation whose `mutate` takes no parameters.
+ *
+ * @example
+ * ```tsx
+ * const generateKeypair = useGenerateKeypair();
+ * generateKeypair.mutate();
+ * // generateKeypair.data?.publicKey, generateKeypair.data?.privateKey
+ * ```
+ */
+declare function useGenerateKeypair(): _tanstack_react_query.UseMutationResult<FHEKeypair, Error, void, unknown>;
+
+/** Parameters for {@link useCreateEIP712}. */
+interface CreateEIP712Params {
+    /** The FHE public key (hex-encoded). */
+    publicKey: string;
+    /** Contract addresses the credential authorizes decryption for. */
+    contractAddresses: `0x${string}`[];
+    /** Unix timestamp (seconds) when the credential becomes valid. */
+    startTimestamp: number;
+    /** Number of days the credential remains valid. Default: 1. */
+    durationDays?: number;
+}
+/**
+ * Create EIP-712 typed data for signing an FHE decrypt credential.
+ * The returned typed data is signed by the wallet to authorize decryption.
+ *
+ * @returns A mutation whose `mutate` accepts {@link CreateEIP712Params}.
+ *
+ * @example
+ * ```tsx
+ * const createEIP712 = useCreateEIP712();
+ * createEIP712.mutate({
+ *   publicKey: keypair.publicKey,
+ *   contractAddresses: ["0xToken"],
+ *   startTimestamp: Math.floor(Date.now() / 1000),
+ * });
+ * ```
+ */
+declare function useCreateEIP712(): _tanstack_react_query.UseMutationResult<EIP712TypedData, Error, CreateEIP712Params, unknown>;
+
+/** Parameters for {@link useCreateDelegatedUserDecryptEIP712}. */
+interface CreateDelegatedUserDecryptEIP712Params {
+    /** The FHE public key (hex-encoded). */
+    publicKey: string;
+    /** Contract addresses the credential authorizes decryption for. */
+    contractAddresses: Address[];
+    /** Address of the wallet that delegated decrypt authority. */
+    delegatorAddress: string;
+    /** Unix timestamp (seconds) when the credential becomes valid. */
+    startTimestamp: number;
+    /** Number of days the credential remains valid. Default: 1. */
+    durationDays?: number;
+}
+/**
+ * Create EIP-712 typed data for a delegated user decrypt credential.
+ * Used when one wallet authorizes another to decrypt on its behalf.
+ *
+ * @returns A mutation whose `mutate` accepts {@link CreateDelegatedUserDecryptEIP712Params}.
+ *
+ * @example
+ * ```tsx
+ * const createEIP712 = useCreateDelegatedUserDecryptEIP712();
+ * createEIP712.mutate({
+ *   publicKey: keypair.publicKey,
+ *   contractAddresses: ["0xToken"],
+ *   delegatorAddress: "0xDelegator",
+ *   startTimestamp: Math.floor(Date.now() / 1000),
+ * });
+ * ```
+ */
+declare function useCreateDelegatedUserDecryptEIP712(): _tanstack_react_query.UseMutationResult<Readonly<{
+    types: _zama_fhe_relayer_sdk_web.KmsDelegatedUserDecryptEIP712TypesType;
+    primaryType: "DelegatedUserDecryptRequestVerification";
+    domain: _zama_fhe_relayer_sdk_web.KmsEIP712DomainType;
+    message: _zama_fhe_relayer_sdk_web.KmsDelegatedUserDecryptEIP712MessageType;
+}>, Error, CreateDelegatedUserDecryptEIP712Params, unknown>;
+
+/**
+ * Decrypt FHE ciphertext handles using delegated user credentials.
+ * Returns a map of handle → plaintext bigint.
+ *
+ * @returns A mutation whose `mutate` accepts {@link DelegatedUserDecryptParams}.
+ *
+ * @example
+ * ```tsx
+ * const decrypt = useDelegatedUserDecrypt();
+ * decrypt.mutate({ handles: ["0xHandle1"], ...credentials });
+ * // decrypt.data => { "0xHandle1": 1000n }
+ * ```
+ */
+declare function useDelegatedUserDecrypt(): _tanstack_react_query.UseMutationResult<Record<string, bigint>, Error, DelegatedUserDecryptParams, unknown>;
+
+/**
+ * Submit a ZK proof for on-chain verification.
+ * Returns the input proof bytes for use in contract calls.
+ *
+ * @returns A mutation whose `mutate` accepts a {@link ZKProofLike}.
+ *
+ * @example
+ * ```tsx
+ * const verify = useRequestZKProofVerification();
+ * verify.mutate(zkProof);
+ * // verify.data => Uint8Array (input proof bytes)
+ * ```
+ */
+declare function useRequestZKProofVerification(): _tanstack_react_query.UseMutationResult<Readonly<{
+    handles: Uint8Array[];
+    inputProof: Uint8Array;
+}>, Error, ZKProofLike, unknown>;
+
+/**
+ * Query key factory for the FHE public key query.
+ * Use with `queryClient.invalidateQueries()` / `resetQueries()`.
+ */
+declare const publicKeyQueryKeys: {
+    /** Match the public key query. */
+    readonly all: readonly ["publicKey"];
+};
+/** Shape of the FHE public key data returned by the relayer. */
+interface PublicKeyData {
+    /** Unique identifier for this public key version. */
+    publicKeyId: string;
+    /** The raw FHE public key bytes. */
+    publicKey: Uint8Array;
+}
+type PublicKeyResult = PublicKeyData | null;
+/**
+ * TanStack Query options factory for the FHE public key.
+ *
+ * @param sdk - A `ZamaSDK` instance.
+ * @returns Query options with `queryKey`, `queryFn`, and `staleTime`.
+ */
+declare function publicKeyQueryOptions(sdk: ZamaSDK): {
+    readonly queryKey: readonly ["publicKey"];
+    readonly queryFn: () => Promise<PublicKeyResult>;
+    readonly staleTime: number;
+};
+/**
+ * Fetch the FHE network public key from the relayer.
+ * Cached indefinitely since the key does not change during a session.
+ *
+ * @returns Query result with `data: PublicKeyData | null`.
+ *
+ * @example
+ * ```tsx
+ * const { data: publicKey } = usePublicKey();
+ * // publicKey?.publicKeyId, publicKey?.publicKey
+ * ```
+ */
+declare function usePublicKey(): _tanstack_react_query.UseQueryResult<PublicKeyResult, Error>;
+
+/**
+ * Query key factory for FHE public params queries.
+ * Use with `queryClient.invalidateQueries()` / `resetQueries()`.
+ */
+declare const publicParamsQueryKeys: {
+    /** Match all public params queries. */
+    readonly all: readonly ["publicParams"];
+    /** Match public params query for a specific bit size. */
+    readonly bits: (bits: number) => readonly ["publicParams", number];
+};
+/** Shape of the FHE public parameters returned by the relayer. */
+interface PublicParamsData {
+    /** The raw public parameters bytes (WASM-ready). */
+    publicParams: Uint8Array;
+    /** Unique identifier for this public params version. */
+    publicParamsId: string;
+}
+type PublicParamsResult = PublicParamsData | null;
+/**
+ * TanStack Query options factory for FHE public parameters.
+ *
+ * @param sdk - A `ZamaSDK` instance.
+ * @param bits - The FHE bit size to fetch parameters for (e.g. 2048).
+ * @returns Query options with `queryKey`, `queryFn`, and `staleTime`.
+ */
+declare function publicParamsQueryOptions(sdk: ZamaSDK, bits: number): {
+    readonly queryKey: readonly ["publicParams", number];
+    readonly queryFn: () => Promise<PublicParamsResult>;
+    readonly staleTime: number;
+};
+/**
+ * Fetch FHE public parameters for a given bit size from the relayer.
+ * Cached indefinitely since parameters do not change during a session.
+ *
+ * @param bits - The FHE bit size to fetch parameters for (e.g. 2048).
+ * @returns Query result with `data: PublicParamsData | null`.
+ *
+ * @example
+ * ```tsx
+ * const { data: params } = usePublicParams(2048);
+ * // params?.publicParams, params?.publicParamsId
+ * ```
+ */
+declare function usePublicParams(bits: number): _tanstack_react_query.UseQueryResult<PublicParamsResult, Error>;
+
+/**
+ * Look up a single cached decrypted value by its handle.
+ * Values are populated automatically when useUserDecrypt or usePublicDecrypt succeed.
+ * You can also populate manually via queryClient.setQueryData(decryptionKeys.value(handle), value).
+ */
+declare function useUserDecryptedValue(handle: string | undefined): _tanstack_react_query.UseQueryResult<bigint, Error>;
+
+/**
+ * Look up multiple cached decrypted values by their handles.
+ * Values are populated automatically when useUserDecrypt or usePublicDecrypt succeed.
+ */
+declare function useUserDecryptedValues(handles: string[]): {
+    data: Record<string, bigint | undefined>;
+    results: _tanstack_react_query.UseQueryResult<never, Error>[];
+};
+
+/**
+ * Query key helpers for the shared decryption cache.
+ * Used by useUserDecrypt/usePublicDecrypt to populate,
+ * and by useUserDecryptedValue to read.
+ */
+declare const decryptionKeys: {
+    value: (handle: string) => readonly ["decryptedValue", string];
+};
+
+/**
+ * Get a {@link ReadonlyToken} instance, memoized by address.
+ * Supports balance queries, ERC-165 checks, and authorization — no wrapper needed.
+ * Reads signer and storage from the nearest {@link ZamaProvider}.
+ *
+ * @param address - Address of the confidential token contract.
+ * @returns A memoized `ReadonlyToken` instance.
+ *
+ * @example
+ * ```tsx
+ * const token = useReadonlyToken("0xToken");
+ * // token.balanceOf(), token.isConfidential(), etc.
+ * ```
+ */
+declare function useReadonlyToken(address: Address): _zama_fhe_sdk.ReadonlyToken;
+
+/** Parameters passed to the `mutate` function of {@link useConfidentialTransfer}. */
+interface ConfidentialTransferParams {
+    /** Recipient address. */
+    to: Address;
+    /** Amount to transfer (plaintext — encrypted automatically). */
+    amount: bigint;
+}
+/** Configuration for {@link useConfidentialTransfer}. */
+interface UseConfidentialTransferConfig extends UseZamaConfig {
+    /**
+     * When `true`, optimistically subtracts the transfer amount from cached balance
+     * before the transaction confirms. Rolls back on error.
+     * @defaultValue false
+     */
+    optimistic?: boolean;
+}
+/**
+ * TanStack Query mutation options factory for confidential transfer.
+ *
+ * @param token - A `Token` instance.
+ * @returns Mutation options with `mutationKey` and `mutationFn`.
+ */
+declare function confidentialTransferMutationOptions(token: Token): {
+    mutationKey: readonly ["confidentialTransfer", `0x${string}`];
+    mutationFn: ({ to, amount }: ConfidentialTransferParams) => Promise<TransactionResult>;
+};
+/**
+ * Encrypt and send a confidential transfer. Invalidates balance caches on success.
+ *
+ * Errors are {@link ZamaError} subclasses — use `instanceof` to handle specific failures:
+ * - {@link SigningRejectedError} — user rejected the wallet prompt
+ * - {@link EncryptionFailedError} — FHE encryption failed
+ * - {@link TransactionRevertedError} — on-chain transaction reverted
+ *
+ * @param config - Token address (and optional wrapper) identifying the token.
+ *   Set `optimistic: true` to subtract the amount from the cached balance immediately.
+ * @param options - React Query mutation options.
+ *
+ * @example
+ * ```tsx
+ * const transfer = useConfidentialTransfer({
+ *   tokenAddress: "0x...",
+ *   optimistic: true,
+ * });
+ * transfer.mutate(
+ *   { to: "0xRecipient", amount: 1000n },
+ *   {
+ *     onError: (error) => {
+ *       if (error instanceof SigningRejectedError) {
+ *         // user cancelled — no action needed
+ *       }
+ *     },
+ *   },
+ * );
+ * ```
+ */
+declare function useConfidentialTransfer(config: UseConfidentialTransferConfig, options?: UseMutationOptions<TransactionResult, Error, ConfidentialTransferParams, Address>): _tanstack_react_query.UseMutationResult<TransactionResult, Error, ConfidentialTransferParams, `0x${string}`>;
+
+/**
+ * Query key factory for confidential approval queries.
+ * Use with `queryClient.invalidateQueries()` / `resetQueries()`.
+ */
+declare const confidentialIsApprovedQueryKeys: {
+    /** Match all approval queries. */
+    readonly all: readonly ["confidentialIsApproved"];
+    /** Match approval queries for a specific token. */
+    readonly token: (tokenAddress: string) => readonly ["confidentialIsApproved", string];
+    /** Match approval queries for a specific token + spender pair. */
+    readonly spender: (tokenAddress: string, spender: string) => readonly ["confidentialIsApproved", string, string];
+};
+/** Configuration for {@link useConfidentialIsApproved}. */
+interface UseConfidentialIsApprovedConfig extends UseZamaConfig {
+    /** Address to check approval for. Pass `undefined` to disable the query. */
+    spender: Address | undefined;
+}
+/** Configuration for {@link useConfidentialIsApprovedSuspense}. */
+interface UseConfidentialIsApprovedSuspenseConfig extends UseZamaConfig {
+    /** Address to check approval for. */
+    spender: Address;
+}
+/**
+ * TanStack Query options factory for confidential approval check.
+ *
+ * @param token - A `Token` instance.
+ * @param spender - Address to check approval for.
+ * @returns Query options with `queryKey`, `queryFn`, and `staleTime`.
+ */
+declare function confidentialIsApprovedQueryOptions(token: Token, spender: Address): {
+    readonly queryKey: readonly ["confidentialIsApproved", string, string];
+    readonly queryFn: () => Promise<boolean>;
+    readonly staleTime: 30000;
+};
+/**
+ * Check if a spender is an approved operator for the connected wallet.
+ *
+ * @param config - Token address and spender to check.
+ * @param options - React Query options (forwarded to `useQuery`).
+ * @returns Query result with `data: boolean`.
+ *
+ * @example
+ * ```tsx
+ * const { data: isApproved } = useConfidentialIsApproved({
+ *   tokenAddress: "0xToken",
+ *   spender: "0xSpender",
+ * });
+ * ```
+ */
+declare function useConfidentialIsApproved(config: UseConfidentialIsApprovedConfig, options?: Omit<UseQueryOptions<boolean, Error>, "queryKey" | "queryFn">): _tanstack_react_query.UseQueryResult<boolean, Error>;
+/**
+ * Suspense variant of {@link useConfidentialIsApproved}.
+ * Suspends rendering until the approval check resolves.
+ *
+ * @param config - Token address and spender to check.
+ * @returns Suspense query result with `data: boolean`.
+ *
+ * @example
+ * ```tsx
+ * const { data: isApproved } = useConfidentialIsApprovedSuspense({
+ *   tokenAddress: "0xToken",
+ *   spender: "0xSpender",
+ * });
+ * ```
+ */
+declare function useConfidentialIsApprovedSuspense(config: UseConfidentialIsApprovedSuspenseConfig): _tanstack_react_query.UseSuspenseQueryResult<boolean, Error>;
+
+/** Parameters passed to the `mutate` function of {@link useShield}. */
+interface ShieldParams {
+    /** Amount of underlying ERC-20 tokens to wrap. */
+    amount: bigint;
+    /** Optional fee amount (for native ETH wrapping with fees). */
+    fees?: bigint;
+    /** ERC-20 approval strategy: `"exact"` (default), `"max"`, or `"skip"`. */
+    approvalStrategy?: "max" | "exact" | "skip";
+}
+/** Configuration for {@link useShield}. */
+interface UseShieldConfig extends UseZamaConfig {
+    /**
+     * When `true`, optimistically adds the wrap amount to the cached confidential balance
+     * before the transaction confirms. Rolls back on error.
+     * @defaultValue false
+     */
+    optimistic?: boolean;
+}
+/**
+ * TanStack Query mutation options factory for shield.
+ *
+ * @param token - A `Token` instance.
+ * @returns Mutation options with `mutationKey` and `mutationFn`.
+ */
+declare function shieldMutationOptions(token: Token): {
+    mutationKey: readonly ["shield", `0x${string}`];
+    mutationFn: ({ amount, fees, approvalStrategy }: ShieldParams) => Promise<TransactionResult>;
+};
+/**
+ * Shield public ERC-20 tokens into confidential tokens.
+ * Handles ERC-20 approval automatically. Invalidates balance caches on success.
+ *
+ * Errors are {@link ZamaError} subclasses — use `instanceof` to handle specific failures:
+ * - {@link SigningRejectedError} — user rejected the wallet prompt
+ * - {@link ApprovalFailedError} — ERC-20 approval transaction failed
+ * - {@link TransactionRevertedError} — shield transaction reverted
+ *
+ * @param config - Token and wrapper addresses.
+ *   Set `optimistic: true` to add the amount to the cached balance immediately.
+ * @param options - React Query mutation options.
+ *
+ * @example
+ * ```tsx
+ * const shield = useShield({ tokenAddress: "0x...", wrapperAddress: "0x...", optimistic: true });
+ * shield.mutate({ amount: 1000n });
+ * ```
+ */
+declare function useShield(config: UseShieldConfig, options?: UseMutationOptions<TransactionResult, Error, ShieldParams, Address>): _tanstack_react_query.UseMutationResult<TransactionResult, Error, ShieldParams, `0x${string}`>;
+
+/** Parameters passed to the `mutate` function of {@link useShieldETH}. */
+interface ShieldETHParams {
+    /** Amount of ETH to wrap (in wei). */
+    amount: bigint;
+    /** ETH value to send with the transaction. Defaults to `amount`. */
+    value?: bigint;
+}
+/**
+ * TanStack Query mutation options factory for shield ETH.
+ *
+ * @param token - A `Token` instance.
+ * @returns Mutation options with `mutationKey` and `mutationFn`.
+ */
+declare function shieldETHMutationOptions(token: Token): {
+    mutationKey: readonly ["shieldETH", `0x${string}`];
+    mutationFn: ({ amount, value }: ShieldETHParams) => Promise<TransactionResult>;
+};
+/**
+ * Shield native ETH into confidential tokens.
+ * Invalidates balance caches on success.
+ *
+ * @param config - Token and wrapper addresses.
+ * @param options - React Query mutation options.
+ *
+ * @example
+ * ```tsx
+ * const shieldETH = useShieldETH({ tokenAddress: "0x...", wrapperAddress: "0x..." });
+ * shieldETH.mutate({ amount: 1000000000000000000n }); // 1 ETH
+ * ```
+ */
+declare function useShieldETH(config: UseZamaConfig, options?: UseMutationOptions<TransactionResult, Error, ShieldETHParams, Address>): _tanstack_react_query.UseMutationResult<TransactionResult, Error, ShieldETHParams, `0x${string}`>;
+
+/** Parameters passed to the `mutate` function of {@link useUnwrap}. */
+interface UnwrapParams {
+    /** Amount to unwrap (plaintext — encrypted automatically). */
+    amount: bigint;
+}
+/**
+ * TanStack Query mutation options factory for unwrap.
+ *
+ * @param token - A `Token` instance.
+ * @returns Mutation options with `mutationKey` and `mutationFn`.
+ */
+declare function unwrapMutationOptions(token: Token): {
+    mutationKey: readonly ["unwrap", `0x${string}`];
+    mutationFn: ({ amount }: UnwrapParams) => Promise<TransactionResult>;
+};
+/**
+ * Request an unwrap for a specific amount. Encrypts the amount first.
+ * Call {@link useFinalizeUnwrap} after the request is processed on-chain,
+ * or use {@link useUnshield} for a single-call orchestration.
+ *
+ * @param config - Token address (and optional wrapper) identifying the token.
+ * @param options - React Query mutation options.
+ *
+ * @example
+ * ```tsx
+ * const unwrap = useUnwrap({ tokenAddress: "0x..." });
+ * unwrap.mutate({ amount: 500n });
+ * ```
+ */
+declare function useUnwrap(config: UseZamaConfig, options?: UseMutationOptions<TransactionResult, Error, UnwrapParams, Address>): _tanstack_react_query.UseMutationResult<TransactionResult, Error, UnwrapParams, `0x${string}`>;
+
+/** Parameters passed to the `mutate` function of {@link useFinalizeUnwrap}. */
+interface FinalizeUnwrapParams {
+    /** Encrypted amount handle from the UnwrapRequested event. */
+    burnAmountHandle: Address;
+}
+/**
+ * TanStack Query mutation options factory for finalize-unwrap.
+ *
+ * @param token - A `Token` instance.
+ * @returns Mutation options with `mutationKey` and `mutationFn`.
+ */
+declare function finalizeUnwrapMutationOptions(token: Token): {
+    mutationKey: readonly ["finalizeUnwrap", `0x${string}`];
+    mutationFn: ({ burnAmountHandle }: FinalizeUnwrapParams) => Promise<TransactionResult>;
+};
+/**
+ * Complete an unwrap by providing the public decryption proof.
+ * Call this after an unwrap request has been processed on-chain.
+ *
+ * @param config - Token address (and optional wrapper) identifying the token.
+ * @param options - React Query mutation options.
+ *
+ * @example
+ * ```tsx
+ * const finalize = useFinalizeUnwrap({ tokenAddress: "0x..." });
+ * finalize.mutate({ burnAmountHandle: event.encryptedAmount });
+ * ```
+ */
+declare function useFinalizeUnwrap(config: UseZamaConfig, options?: UseMutationOptions<TransactionResult, Error, FinalizeUnwrapParams, Address>): _tanstack_react_query.UseMutationResult<TransactionResult, Error, FinalizeUnwrapParams, `0x${string}`>;
+
+/**
+ * Query key factory for underlying ERC-20 allowance queries.
+ * Use with `queryClient.invalidateQueries()` / `resetQueries()`.
+ */
+declare const underlyingAllowanceQueryKeys: {
+    /** Match all underlying allowance queries. */
+    readonly all: readonly ["underlyingAllowance"];
+    /** Match allowance query for a specific token + wrapper pair. */
+    readonly token: (tokenAddress: string, wrapper: string) => readonly ["underlyingAllowance", string, string];
+};
+/** Configuration for {@link useUnderlyingAllowance}. */
+interface UseUnderlyingAllowanceConfig {
+    /** Address of the underlying ERC-20 token. */
+    tokenAddress: Address;
+    /** Address of the wrapper contract (the spender). */
+    wrapperAddress: Address;
+}
+/**
+ * TanStack Query options factory for underlying ERC-20 allowance.
+ *
+ * @param token - A `ReadonlyToken` instance.
+ * @param wrapperAddress - Address of the wrapper contract (the spender).
+ * @returns Query options with `queryKey`, `queryFn`, and `staleTime`.
+ */
+declare function underlyingAllowanceQueryOptions(token: ReadonlyToken, wrapperAddress: Address): {
+    readonly queryKey: readonly ["underlyingAllowance", string, string];
+    readonly queryFn: () => Promise<bigint>;
+    readonly staleTime: 30000;
+};
+/**
+ * Read the underlying ERC-20 allowance granted to the wrapper contract.
+ * Useful to check if an approval is needed before shielding.
+ *
+ * @param config - Token and wrapper addresses.
+ * @param options - React Query options (forwarded to `useQuery`).
+ * @returns Query result with `data: bigint` (current allowance).
+ *
+ * @example
+ * ```tsx
+ * const { data: allowance } = useUnderlyingAllowance({
+ *   tokenAddress: "0xUnderlying",
+ *   wrapperAddress: "0xWrapper",
+ * });
+ * ```
+ */
+declare function useUnderlyingAllowance(config: UseUnderlyingAllowanceConfig, options?: Omit<UseQueryOptions<bigint, Error>, "queryKey" | "queryFn">): _tanstack_react_query.UseQueryResult<bigint, Error>;
+/**
+ * Suspense variant of {@link useUnderlyingAllowance}.
+ * Suspends rendering until the allowance is loaded.
+ *
+ * @param config - Token and wrapper addresses.
+ * @returns Suspense query result with `data: bigint`.
+ *
+ * @example
+ * ```tsx
+ * const { data: allowance } = useUnderlyingAllowanceSuspense({
+ *   tokenAddress: "0xUnderlying",
+ *   wrapperAddress: "0xWrapper",
+ * });
+ * ```
+ */
+declare function useUnderlyingAllowanceSuspense(config: UseUnderlyingAllowanceConfig): _tanstack_react_query.UseSuspenseQueryResult<bigint, Error>;
+
+/**
+ * Query key factories for confidential balance queries.
+ * Use with `queryClient.invalidateQueries()` / `resetQueries()` / `removeQueries()`.
+ *
+ * @example
+ * ```ts
+ * // Invalidate all balance queries
+ * queryClient.invalidateQueries({ queryKey: confidentialBalanceQueryKeys.all });
+ *
+ * // Reset balance for a specific token + owner
+ * queryClient.resetQueries({
+ *   queryKey: confidentialBalanceQueryKeys.owner("0xToken", "0xOwner"),
+ * });
+ * ```
+ */
+declare const confidentialBalanceQueryKeys: {
+    /** Match all single-token balance queries. */
+    readonly all: readonly ["confidentialBalance"];
+    /** Match balance queries for a specific token (any owner). */
+    readonly token: (tokenAddress: string) => readonly ["confidentialBalance", string];
+    /** Match balance query for a specific token + owner. */
+    readonly owner: (tokenAddress: string, owner: string) => readonly ["confidentialBalance", string, string];
+};
+/**
+ * Query key factory for batch balance queries (multiple tokens).
+ * Use with `queryClient.invalidateQueries()` / `resetQueries()`.
+ */
+declare const confidentialBalancesQueryKeys: {
+    /** Match all batch balance queries. */
+    readonly all: readonly ["confidentialBalances"];
+    /** Match batch balance query for a specific token set + owner. */
+    readonly tokens: (tokenAddresses: string[], owner: string) => readonly ["confidentialBalances", string[], string];
+};
+/**
+ * Query key factory for encrypted handle queries (Phase 1 of two-phase polling).
+ * Use with `queryClient.invalidateQueries()` / `resetQueries()`.
+ */
+declare const confidentialHandleQueryKeys: {
+    /** Match all single-token handle queries. */
+    readonly all: readonly ["confidentialHandle"];
+    /** Match handle queries for a specific token (any owner). */
+    readonly token: (tokenAddress: string) => readonly ["confidentialHandle", string];
+    /** Match handle query for a specific token + owner. */
+    readonly owner: (tokenAddress: string, owner: string) => readonly ["confidentialHandle", string, string];
+};
+/**
+ * Query key factory for batch encrypted handle queries (Phase 1, multiple tokens).
+ * Use with `queryClient.invalidateQueries()` / `resetQueries()`.
+ */
+declare const confidentialHandlesQueryKeys: {
+    /** Match all batch handle queries. */
+    readonly all: readonly ["confidentialHandles"];
+    /** Match batch handle query for a specific token set + owner. */
+    readonly tokens: (tokenAddresses: string[], owner: string) => readonly ["confidentialHandles", string[], string];
+};
+
+/**
+ * Query key factory for wrapper discovery queries.
+ * Use with `queryClient.invalidateQueries()` / `resetQueries()`.
+ */
+declare const wrapperDiscoveryQueryKeys: {
+    /** Match all wrapper discovery queries. */
+    readonly all: readonly ["wrapperDiscovery"];
+    /** Match wrapper discovery queries for a specific token. */
+    readonly token: (tokenAddress: string) => readonly ["wrapperDiscovery", string];
+    /** Match wrapper discovery query for a specific token + coordinator pair. */
+    readonly tokenCoordinator: (tokenAddress: string, coordinatorAddress: string) => readonly ["wrapperDiscovery", string, string];
+};
+/** Configuration for {@link useWrapperDiscovery}. */
+interface UseWrapperDiscoveryConfig {
+    /** Address of the underlying ERC-20 token. */
+    tokenAddress: Address;
+    /** Address of the wrapper coordinator. Pass `undefined` to disable the query. */
+    coordinatorAddress: Address | undefined;
+}
+/** Configuration for {@link useWrapperDiscoverySuspense}. */
+interface UseWrapperDiscoverySuspenseConfig {
+    /** Address of the underlying ERC-20 token. */
+    tokenAddress: Address;
+    /** Address of the wrapper coordinator. */
+    coordinatorAddress: Address;
+}
+/**
+ * TanStack Query options factory for wrapper discovery.
+ *
+ * @param token - A `ReadonlyToken` instance.
+ * @param coordinatorAddress - Address of the wrapper coordinator.
+ * @returns Query options with `queryKey`, `queryFn`, and `staleTime`.
+ */
+declare function wrapperDiscoveryQueryOptions(token: ReadonlyToken, coordinatorAddress: Address): {
+    readonly queryKey: readonly ["wrapperDiscovery", string, string];
+    readonly queryFn: () => Promise<`0x${string}` | null>;
+    readonly staleTime: number;
+};
+/**
+ * Discover the wrapper contract for an ERC-20 token.
+ * Returns the wrapper address if one exists, or `null` if not.
+ * Cached indefinitely since wrapper mappings are immutable.
+ *
+ * @param config - Token and coordinator addresses.
+ * @param options - React Query options (forwarded to `useQuery`).
+ * @returns Query result with `data: Address | null`.
+ *
+ * @example
+ * ```tsx
+ * const { data: wrapperAddress } = useWrapperDiscovery({
+ *   tokenAddress: "0xUnderlying",
+ *   coordinatorAddress: "0xCoordinator",
+ * });
+ * ```
+ */
+declare function useWrapperDiscovery(config: UseWrapperDiscoveryConfig, options?: Omit<UseQueryOptions<Address | null, Error>, "queryKey" | "queryFn">): UseQueryResult<Address | null, Error>;
+/**
+ * Suspense variant of {@link useWrapperDiscovery}.
+ * Suspends rendering until the wrapper address is resolved.
+ *
+ * @param config - Token and coordinator addresses.
+ * @returns Suspense query result with `data: Address | null`.
+ *
+ * @example
+ * ```tsx
+ * const { data: wrapperAddress } = useWrapperDiscoverySuspense({
+ *   tokenAddress: "0xUnderlying",
+ *   coordinatorAddress: "0xCoordinator",
+ * });
+ * ```
+ */
+declare function useWrapperDiscoverySuspense(config: UseWrapperDiscoverySuspenseConfig): UseSuspenseQueryResult<Address | null, Error>;
+
+/**
+ * Query key factory for ERC-165 confidential interface checks.
+ * Use with `queryClient.invalidateQueries()` / `resetQueries()`.
+ */
+declare const isConfidentialQueryKeys: {
+    /** Match all confidential interface queries. */
+    readonly all: readonly ["isConfidential"];
+    /** Match confidential interface query for a specific token. */
+    readonly token: (tokenAddress: string) => readonly ["isConfidential", string];
+};
+/**
+ * Query key factory for ERC-165 wrapper interface checks.
+ * Use with `queryClient.invalidateQueries()` / `resetQueries()`.
+ */
+declare const isWrapperQueryKeys: {
+    /** Match all wrapper interface queries. */
+    readonly all: readonly ["isWrapper"];
+    /** Match wrapper interface query for a specific token. */
+    readonly token: (tokenAddress: string) => readonly ["isWrapper", string];
+};
+/**
+ * TanStack Query options factory for ERC-165 confidential interface check.
+ *
+ * @param token - A `ReadonlyToken` instance.
+ * @returns Query options with `queryKey`, `queryFn`, and `staleTime`.
+ */
+declare function isConfidentialQueryOptions(token: ReadonlyToken): {
+    readonly queryKey: readonly ["isConfidential", string];
+    readonly queryFn: () => Promise<boolean>;
+    readonly staleTime: number;
+};
+/**
+ * TanStack Query options factory for ERC-165 wrapper interface check.
+ *
+ * @param token - A `ReadonlyToken` instance.
+ * @returns Query options with `queryKey`, `queryFn`, and `staleTime`.
+ */
+declare function isWrapperQueryOptions(token: ReadonlyToken): {
+    readonly queryKey: readonly ["isWrapper", string];
+    readonly queryFn: () => Promise<boolean>;
+    readonly staleTime: number;
+};
+/**
+ * Check if a token supports the ERC-7984 confidential interface via ERC-165.
+ * Result is cached indefinitely since interface support does not change.
+ *
+ * @param tokenAddress - Address of the token contract to check.
+ * @param options - React Query options (forwarded to `useQuery`).
+ * @returns Query result with `data: boolean`.
+ *
+ * @example
+ * ```tsx
+ * const { data: isConfidential } = useIsConfidential("0xToken");
+ * ```
+ */
+declare function useIsConfidential(tokenAddress: Address, options?: Omit<UseQueryOptions<boolean, Error>, "queryKey" | "queryFn">): UseQueryResult<boolean, Error>;
+/**
+ * Suspense variant of {@link useIsConfidential}.
+ * Suspends rendering until the ERC-165 check resolves.
+ *
+ * @param tokenAddress - Address of the token contract to check.
+ * @returns Suspense query result with `data: boolean`.
+ *
+ * @example
+ * ```tsx
+ * const { data: isConfidential } = useIsConfidentialSuspense("0xToken");
+ * ```
+ */
+declare function useIsConfidentialSuspense(tokenAddress: Address): UseSuspenseQueryResult<boolean, Error>;
+/**
+ * Check if a token supports the ERC-7984 wrapper interface via ERC-165.
+ * Result is cached indefinitely since interface support does not change.
+ *
+ * @param tokenAddress - Address of the token contract to check.
+ * @param options - React Query options (forwarded to `useQuery`).
+ * @returns Query result with `data: boolean`.
+ *
+ * @example
+ * ```tsx
+ * const { data: isWrapper } = useIsWrapper("0xToken");
+ * ```
+ */
+declare function useIsWrapper(tokenAddress: Address, options?: Omit<UseQueryOptions<boolean, Error>, "queryKey" | "queryFn">): UseQueryResult<boolean, Error>;
+/**
+ * Suspense variant of {@link useIsWrapper}.
+ * Suspends rendering until the ERC-165 check resolves.
+ *
+ * @param tokenAddress - Address of the token contract to check.
+ * @returns Suspense query result with `data: boolean`.
+ *
+ * @example
+ * ```tsx
+ * const { data: isWrapper } = useIsWrapperSuspense("0xToken");
+ * ```
+ */
+declare function useIsWrapperSuspense(tokenAddress: Address): UseSuspenseQueryResult<boolean, Error>;
+
+/**
+ * Query key factory for total supply queries.
+ * Use with `queryClient.invalidateQueries()` / `resetQueries()`.
+ */
+declare const totalSupplyQueryKeys: {
+    /** Match all total supply queries. */
+    readonly all: readonly ["totalSupply"];
+    /** Match total supply query for a specific token. */
+    readonly token: (tokenAddress: string) => readonly ["totalSupply", string];
+};
+/**
+ * TanStack Query options factory for total supply.
+ *
+ * @param token - A `ReadonlyToken` instance.
+ * @returns Query options with `queryKey`, `queryFn`, and `staleTime`.
+ */
+declare function totalSupplyQueryOptions(token: ReadonlyToken): {
+    readonly queryKey: readonly ["totalSupply", string];
+    readonly queryFn: () => Promise<bigint>;
+    readonly staleTime: 30000;
+};
+/**
+ * Read the total supply of a token.
+ * Stale after 30 seconds to balance freshness and RPC cost.
+ *
+ * @param tokenAddress - Address of the token contract.
+ * @param options - React Query options (forwarded to `useQuery`).
+ * @returns Query result with `data: bigint`.
+ *
+ * @example
+ * ```tsx
+ * const { data: totalSupply } = useTotalSupply("0xToken");
+ * ```
+ */
+declare function useTotalSupply(tokenAddress: Address, options?: Omit<UseQueryOptions<bigint, Error>, "queryKey" | "queryFn">): UseQueryResult<bigint, Error>;
+/**
+ * Suspense variant of {@link useTotalSupply}.
+ * Suspends rendering until the total supply is loaded.
+ *
+ * @param tokenAddress - Address of the token contract.
+ * @returns Suspense query result with `data: bigint`.
+ *
+ * @example
+ * ```tsx
+ * const { data: totalSupply } = useTotalSupplySuspense("0xToken");
+ * ```
+ */
+declare function useTotalSupplySuspense(tokenAddress: Address): UseSuspenseQueryResult<bigint, Error>;
+
+/**
+ * Query key factory for fee-related queries.
+ * Use with `queryClient.invalidateQueries()` / `resetQueries()`.
+ */
+declare const feeQueryKeys: {
+    /** Match shield fee query for given parameters. */
+    readonly shieldFee: (feeManagerAddress: string, amount?: string, from?: string, to?: string) => readonly ["shieldFee", string, ...(string | undefined)[]];
+    /** Match unshield fee query for given parameters. */
+    readonly unshieldFee: (feeManagerAddress: string, amount?: string, from?: string, to?: string) => readonly ["unshieldFee", string, ...(string | undefined)[]];
+    /** Match batch transfer fee query for a specific fee manager. */
+    readonly batchTransferFee: (feeManagerAddress: string) => readonly ["batchTransferFee", string];
+    /** Match fee recipient query for a specific fee manager. */
+    readonly feeRecipient: (feeManagerAddress: string) => readonly ["feeRecipient", string];
+};
+/** Configuration for {@link useShieldFee} and {@link useUnshieldFee}. */
+interface UseFeeConfig {
+    /** Address of the fee manager contract. */
+    feeManagerAddress: Address;
+    /** Amount to calculate the fee for. */
+    amount: bigint;
+    /** Sender address. */
+    from: Address;
+    /** Receiver address. */
+    to: Address;
+}
+/**
+ * TanStack Query options factory for shield fee.
+ *
+ * @param signer - A `GenericSigner` instance.
+ * @param config - {@link UseFeeConfig} with fee manager address, amount, from, and to.
+ * @returns Query options with `queryKey`, `queryFn`, and `staleTime`.
+ */
+declare function shieldFeeQueryOptions(signer: GenericSigner, config: UseFeeConfig): {
+    readonly queryKey: readonly ["shieldFee", string, ...(string | undefined)[]];
+    readonly queryFn: () => Promise<bigint>;
+    readonly staleTime: 30000;
+};
+/**
+ * TanStack Query options factory for unshield fee.
+ *
+ * @param signer - A `GenericSigner` instance.
+ * @param config - Fee manager address, amount, from, and to.
+ * @returns Query options with `queryKey`, `queryFn`, and `staleTime`.
+ */
+declare function unshieldFeeQueryOptions(signer: GenericSigner, config: UseFeeConfig): {
+    readonly queryKey: readonly ["unshieldFee", string, ...(string | undefined)[]];
+    readonly queryFn: () => Promise<bigint>;
+    readonly staleTime: 30000;
+};
+/**
+ * TanStack Query options factory for batch transfer fee.
+ *
+ * @param signer - A `GenericSigner` instance.
+ * @param feeManagerAddress - Address of the fee manager contract.
+ * @returns Query options with `queryKey`, `queryFn`, and `staleTime`.
+ */
+declare function batchTransferFeeQueryOptions(signer: GenericSigner, feeManagerAddress: Address): {
+    readonly queryKey: readonly ["batchTransferFee", string];
+    readonly queryFn: () => Promise<bigint>;
+    readonly staleTime: 30000;
+};
+/**
+ * TanStack Query options factory for fee recipient.
+ *
+ * @param signer - A `GenericSigner` instance.
+ * @param feeManagerAddress - Address of the fee manager contract.
+ * @returns Query options with `queryKey`, `queryFn`, and `staleTime`.
+ */
+declare function feeRecipientQueryOptions(signer: GenericSigner, feeManagerAddress: Address): {
+    readonly queryKey: readonly ["feeRecipient", string];
+    readonly queryFn: () => Promise<`0x${string}`>;
+    readonly staleTime: 30000;
+};
+/**
+ * Read the shield fee for a given amount and address pair.
+ *
+ * @param config - Fee manager address, amount, from, and to.
+ * @param options - React Query options (forwarded to `useQuery`).
+ * @returns Query result with `data: bigint` (the fee amount).
+ *
+ * @example
+ * ```tsx
+ * const { data: fee } = useShieldFee({
+ *   feeManagerAddress: "0xFeeManager",
+ *   amount: 1000n,
+ *   from: "0xSender",
+ *   to: "0xReceiver",
+ * });
+ * ```
+ */
+declare function useShieldFee(config: UseFeeConfig, options?: Omit<UseQueryOptions<bigint, Error>, "queryKey" | "queryFn">): UseQueryResult<bigint, Error>;
+/**
+ * Read the unshield fee for a given amount and address pair.
+ *
+ * @param config - Fee manager address, amount, from, and to.
+ * @param options - React Query options (forwarded to `useQuery`).
+ * @returns Query result with `data: bigint` (the fee amount).
+ *
+ * @example
+ * ```tsx
+ * const { data: fee } = useUnshieldFee({
+ *   feeManagerAddress: "0xFeeManager",
+ *   amount: 1000n,
+ *   from: "0xSender",
+ *   to: "0xReceiver",
+ * });
+ * ```
+ */
+declare function useUnshieldFee(config: UseFeeConfig, options?: Omit<UseQueryOptions<bigint, Error>, "queryKey" | "queryFn">): UseQueryResult<bigint, Error>;
+/**
+ * Read the batch transfer fee from the fee manager.
+ *
+ * @param feeManagerAddress - Address of the fee manager contract.
+ * @param options - React Query options (forwarded to `useQuery`).
+ * @returns Query result with `data: bigint` (the fee amount).
+ *
+ * @example
+ * ```tsx
+ * const { data: fee } = useBatchTransferFee("0xFeeManager");
+ * ```
+ */
+declare function useBatchTransferFee(feeManagerAddress: Address, options?: Omit<UseQueryOptions<bigint, Error>, "queryKey" | "queryFn">): UseQueryResult<bigint, Error>;
+/**
+ * Read the fee recipient address from the fee manager.
+ *
+ * @param feeManagerAddress - Address of the fee manager contract.
+ * @param options - React Query options (forwarded to `useQuery`).
+ * @returns Query result with `data: Address` (the fee recipient).
+ *
+ * @example
+ * ```tsx
+ * const { data: recipient } = useFeeRecipient("0xFeeManager");
+ * ```
+ */
+declare function useFeeRecipient(feeManagerAddress: Address, options?: Omit<UseQueryOptions<Address, Error>, "queryKey" | "queryFn">): UseQueryResult<Address, Error>;
+
+export { type ConfidentialTransferParams, type CreateDelegatedUserDecryptEIP712Params, type CreateEIP712Params, type FinalizeUnwrapParams, type PublicKeyData, type PublicParamsData, type ShieldETHParams, type ShieldParams, type UnwrapParams, type UseConfidentialIsApprovedConfig, type UseConfidentialIsApprovedSuspenseConfig, type UseConfidentialTransferConfig, type UseFeeConfig, type UseShieldConfig, type UseUnderlyingAllowanceConfig, type UseWrapperDiscoveryConfig, type UseWrapperDiscoverySuspenseConfig, UseZamaConfig, ZamaProvider, batchTransferFeeQueryOptions, confidentialBalanceQueryKeys, confidentialBalancesQueryKeys, confidentialHandleQueryKeys, confidentialHandlesQueryKeys, confidentialIsApprovedQueryKeys, confidentialIsApprovedQueryOptions, confidentialTransferMutationOptions, decryptionKeys, encryptMutationOptions, feeQueryKeys, feeRecipientQueryOptions, finalizeUnwrapMutationOptions, isConfidentialQueryKeys, isConfidentialQueryOptions, isWrapperQueryKeys, isWrapperQueryOptions, publicKeyQueryKeys, publicKeyQueryOptions, publicParamsQueryKeys, publicParamsQueryOptions, shieldETHMutationOptions, shieldFeeQueryOptions, shieldMutationOptions, totalSupplyQueryKeys, totalSupplyQueryOptions, underlyingAllowanceQueryKeys, underlyingAllowanceQueryOptions, unshieldFeeQueryOptions, unwrapMutationOptions, useBatchTransferFee, useConfidentialIsApproved, useConfidentialIsApprovedSuspense, useConfidentialTransfer, useCreateDelegatedUserDecryptEIP712, useCreateEIP712, useDelegatedUserDecrypt, useEncrypt, useFeeRecipient, useFinalizeUnwrap, useGenerateKeypair, useIsConfidential, useIsConfidentialSuspense, useIsWrapper, useIsWrapperSuspense, usePublicDecrypt, usePublicKey, usePublicParams, useReadonlyToken, useRequestZKProofVerification, useShield, useShieldETH, useShieldFee, useTotalSupply, useTotalSupplySuspense, useUnderlyingAllowance, useUnderlyingAllowanceSuspense, useUnshieldFee, useUnwrap, useUserDecrypt, useUserDecryptedValue, useUserDecryptedValues, useWrapperDiscovery, useWrapperDiscoverySuspense, useZamaSDK, wrapperDiscoveryQueryKeys, wrapperDiscoveryQueryOptions };