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

package/dist/index.d.ts

@@ -1,30 +1,46 @@
-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';
+"use client";
 
+import * as _zama_fhe_sdk0 from "@zama-fhe/sdk";
+import { ActivityAmount, ActivityDirection, ActivityItem, ActivityItem as ActivityItem$1, ActivityLogMetadata, ActivityLogMetadata as ActivityLogMetadata$1, ActivityType, Address, Address as Address$1, ApprovalFailedError, ApproveSubmittedEvent, ApproveUnderlyingSubmittedEvent, BATCH_SWAP_ABI, BaseEvent, BatchDecryptOptions, BatchTransferData, ChromeSessionStorage, ClearValueType, ClearValueType as ClearValueType$1, ConfidentialTransferEvent, ContractAbi, CredentialsAllowedEvent, CredentialsCachedEvent, CredentialsCreatedEvent, CredentialsCreatingEvent, CredentialsExpiredEvent, CredentialsLoadingEvent, CredentialsManager, CredentialsManagerConfig, CredentialsRevokedEvent, DEPLOYMENT_COORDINATOR_ABI, DecryptEndEvent, DecryptErrorEvent, DecryptStartEvent, DecryptionFailedError, DelegatedUserDecryptParams, DelegatedUserDecryptParams as DelegatedUserDecryptParams$1, EIP712TypedData, EIP712TypedData as EIP712TypedData$1, ENCRYPTION_ABI, ERC165_ABI, ERC20_ABI, ERC20_METADATA_ABI, ERC7984_INTERFACE_ID, ERC7984_WRAPPER_INTERFACE_ID, EncryptEndEvent, EncryptErrorEvent, EncryptInput, EncryptParams, EncryptParams as EncryptParams$1, EncryptResult, EncryptResult as EncryptResult$1, EncryptStartEvent, EncryptionFailedError, FEE_MANAGER_ABI, FheTypeName, FhevmInstanceConfig, FinalizeUnwrapSubmittedEvent, GenericSigner, GenericSigner as GenericSigner$1, GenericStorage, GenericStorage as GenericStorage$1, Handle, Handle as Handle$1, HardhatConfig, Hex, Hex as Hex$1, IndexedDBStorage, InputProofBytesType, InvalidKeypairError, KeypairExpiredError, KeypairType, KmsDelegatedUserDecryptEIP712Type, MainnetConfig, MemoryStorage, NetworkType, NoCiphertextError, OnChainEvent, PublicDecryptResult, PublicDecryptResult as PublicDecryptResult$1, RawLog, RawLog as RawLog$1, ReadContractArgs, ReadContractConfig, ReadContractReturnType, ReadFunctionName, ReadonlyToken, ReadonlyTokenConfig, RelayerRequestFailedError, RelayerSDK, RelayerSDK as RelayerSDK$1, RelayerSDKStatus, RelayerWeb, RelayerWebConfig, RelayerWebSecurityConfig, SepoliaConfig, SessionExpiredEvent, ShieldCallbacks, ShieldSubmittedEvent, SigningFailedError, SigningRejectedError, StoredCredentials, TOKEN_TOPICS, TRANSFER_BATCHER_ABI, Token, TokenConfig, Topics, TransactionErrorEvent, TransactionReceipt, TransactionResult, TransactionResult as TransactionResult$1, TransactionRevertedError, TransferCallbacks, TransferFromSubmittedEvent, TransferSubmittedEvent, UnshieldCallbacks, UnshieldPhase1SubmittedEvent, UnshieldPhase2StartedEvent, UnshieldPhase2SubmittedEvent, UnwrapRequestedEvent, UnwrapSubmittedEvent, UnwrappedFinalizedEvent, UnwrappedStartedEvent, UserDecryptParams, UserDecryptParams as UserDecryptParams$1, WRAPPER_ABI, WrappedEvent, WriteContractArgs, WriteContractConfig, WriteFunctionName, ZERO_HANDLE, ZKProofLike, ZKProofLike as ZKProofLike$1, ZamaError, ZamaErrorCode, ZamaSDK, ZamaSDK as ZamaSDK$1, ZamaSDKConfig, ZamaSDKEvent, ZamaSDKEventInput, ZamaSDKEventListener, ZamaSDKEventListener as ZamaSDKEventListener$1, ZamaSDKEventType, ZamaSDKEvents, allowanceContract, applyDecryptedValues, approveContract, balanceOfContract, chromeSessionStorage, 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 { ApproveUnderlyingParams, ApproveUnderlyingParams as ApproveUnderlyingParams$1, ConfidentialApproveParams, ConfidentialApproveParams as ConfidentialApproveParams$1, ConfidentialBalancesData, ConfidentialBalancesData as ConfidentialBalancesData$1, ConfidentialTransferFromParams, ConfidentialTransferFromParams as ConfidentialTransferFromParams$1, ConfidentialTransferParams, ConfidentialTransferParams as ConfidentialTransferParams$1, FinalizeUnwrapParams, FinalizeUnwrapParams as FinalizeUnwrapParams$1, ResumeUnshieldParams, ResumeUnshieldParams as ResumeUnshieldParams$1, ShieldETHParams, ShieldETHParams as ShieldETHParams$1, ShieldParams, ShieldParams as ShieldParams$1, TokenMetadata, UnshieldAllParams, UnshieldAllParams as UnshieldAllParams$1, UnshieldParams, UnshieldParams as UnshieldParams$1, UnwrapParams, UnwrapParams as UnwrapParams$1, activityFeedQueryOptions, allowMutationOptions, approveUnderlyingMutationOptions, batchTransferFeeQueryOptions, confidentialApproveMutationOptions, confidentialBalanceQueryOptions, confidentialBalancesQueryOptions, confidentialHandleQueryOptions, confidentialHandlesQueryOptions, confidentialIsApprovedQueryOptions, confidentialTransferFromMutationOptions, confidentialTransferMutationOptions, encryptMutationOptions, feeRecipientQueryOptions, filterQueryOptions, finalizeUnwrapMutationOptions, hashFn, isAllowedQueryOptions, isConfidentialQueryOptions, isWrapperQueryOptions, publicKeyQueryOptions, publicParamsQueryOptions, resumeUnshieldMutationOptions, revokeMutationOptions, revokeSessionMutationOptions, shieldETHMutationOptions, shieldFeeQueryOptions, shieldMutationOptions, signerAddressQueryOptions, tokenMetadataQueryOptions, totalSupplyQueryOptions, underlyingAllowanceQueryOptions, unshieldAllMutationOptions, unshieldFeeQueryOptions, unshieldMutationOptions, unwrapAllMutationOptions, unwrapMutationOptions, wrapperDiscoveryQueryOptions, zamaQueryKeys } from "@zama-fhe/sdk/query";
+import * as _tanstack_react_query0 from "@tanstack/react-query";
+import { QueryKey, UseMutationOptions, UseQueryOptions } from "@tanstack/react-query";
+import { PropsWithChildren } from "react";
+import * as react_jsx_runtime0 from "react/jsx-runtime";
+import * as _zama_fhe_relayer_sdk_web0 from "@zama-fhe/relayer-sdk/web";
+import * as _tanstack_query_core0 from "@tanstack/query-core";
+
+//#region src/provider.d.ts
 /** 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;
+  /** FHE relayer backend (RelayerWeb for browser, RelayerNode for server). */
+  relayer: RelayerSDK$1;
+  /** Wallet signer (`ViemSigner`, `EthersSigner`, or custom {@link GenericSigner}). */
+  signer: GenericSigner$1;
+  /** Credential storage backend (IndexedDBStorage for browser, MemoryStorage for tests). */
+  storage: GenericStorage$1;
+  /**
+   * Session storage for wallet signatures. Defaults to in-memory (lost on reload).
+   * Pass a `chrome.storage.session`-backed store for web extensions.
+   */
+  sessionStorage?: GenericStorage$1;
+  /**
+   * How long the ML-KEM re-encryption keypair remains valid, in seconds.
+   * Default: `86400` (1 day). Must be positive — `0` is rejected.
+   */
+  keypairTTL?: number;
+  /**
+   * Controls how long session signatures (EIP-712 wallet signatures) remain valid, in seconds.
+   * Default: `2592000` (30 days).
+   * - `0`: never persist — every operation triggers a signing prompt (high-security mode).
+   * - Positive number: seconds until the session signature expires and requires re-authentication.
+   */
+  sessionTTL?: number;
+  /** Callback invoked on SDK lifecycle events. */
+  onEvent?: ZamaSDKEventListener$1;
 }
 /**
  * Provides a {@link ZamaSDK} instance to all descendant hooks.
- * Terminates the relayer on unmount.
  *
  * @example
  * ```tsx
@@ -33,10 +49,19 @@ interface ZamaProviderProps extends PropsWithChildren {
  * </ZamaProvider>
  * ```
  */
-declare function ZamaProvider({ children, relayer, signer, storage, credentialDurationDays, onEvent, }: ZamaProviderProps): react_jsx_runtime.JSX.Element;
+declare function ZamaProvider({
+  children,
+  relayer,
+  signer,
+  storage,
+  sessionStorage,
+  keypairTTL,
+  sessionTTL,
+  onEvent
+}: ZamaProviderProps): react_jsx_runtime0.JSX.Element;
 /**
  * Access the {@link ZamaSDK} instance from context.
- * Must be used within a {@link ZamaProvider}.
+ * Throws if called outside a {@link ZamaProvider} or when no signer is provided.
  *
  * @example
  * ```tsx
@@ -44,18 +69,9 @@ declare function ZamaProvider({ children, relayer, signer, storage, credentialDu
  * 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>;
-};
+declare function useZamaSDK(): ZamaSDK$1;
+//#endregion
+//#region src/relayer/use-encrypt.d.ts
 /**
  * Encrypt a plaintext value using FHE.
  * Calls the relayer's `encrypt` method via a mutation.
@@ -68,8 +84,9 @@ declare function encryptMutationOptions(sdk: ZamaSDK): {
  * encrypt.mutate({ values: [1000n], bits: [64] });
  * ```
  */
-declare function useEncrypt(): _tanstack_react_query.UseMutationResult<EncryptResult, Error, EncryptParams, unknown>;
-
+declare function useEncrypt(): _tanstack_react_query0.UseMutationResult<EncryptResult$1, Error, EncryptParams$1, unknown>;
+//#endregion
+//#region src/relayer/use-user-decrypt.d.ts
 /**
  * Thin wrapper around sdk.userDecrypt().
  * Caller is responsible for providing all params (keypair, signature, etc.).
@@ -79,8 +96,9 @@ declare function useEncrypt(): _tanstack_react_query.UseMutationResult<EncryptRe
  * 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>;
-
+declare function useUserDecrypt(): _tanstack_react_query0.UseMutationResult<Record<`0x${string}`, ClearValueType$1>, Error, UserDecryptParams$1, unknown>;
+//#endregion
+//#region src/relayer/use-public-decrypt.d.ts
 /**
  * Decrypt FHE ciphertext handles using the network public key (no credential needed).
  * On success, populates the decryption cache so {@link useUserDecryptedValue} / {@link useUserDecryptedValues}
@@ -95,8 +113,9 @@ declare function useUserDecrypt(): _tanstack_react_query.UseMutationResult<Recor
  * // publicDecrypt.data?.clearValues => { "0xHandle1": 500n, ... }
  * ```
  */
-declare function usePublicDecrypt(): _tanstack_react_query.UseMutationResult<PublicDecryptResult, Error, string[], unknown>;
-
+declare function usePublicDecrypt(): _tanstack_react_query0.UseMutationResult<PublicDecryptResult$1, Error, `0x${string}`[], unknown>;
+//#endregion
+//#region src/relayer/use-generate-keypair.d.ts
 /**
  * Generate an FHE keypair via the relayer.
  * Returns a public/private key pair for use in decrypt authorization.
@@ -110,18 +129,19 @@ declare function usePublicDecrypt(): _tanstack_react_query.UseMutationResult<Pub
  * // generateKeypair.data?.publicKey, generateKeypair.data?.privateKey
  * ```
  */
-declare function useGenerateKeypair(): _tanstack_react_query.UseMutationResult<FHEKeypair, Error, void, unknown>;
-
+declare function useGenerateKeypair(): _tanstack_react_query0.UseMutationResult<_zama_fhe_sdk0.KeypairType<`0x${string}`>, Error, void, unknown>;
+//#endregion
+//#region src/relayer/use-create-eip712.d.ts
 /** 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;
+  /** The FHE public key (hex-encoded). */
+  publicKey: `0x${string}`;
+  /** Contract addresses the credential authorizes decryption for. */
+  contractAddresses: Address$1[];
+  /** 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.
@@ -139,20 +159,21 @@ interface CreateEIP712Params {
  * });
  * ```
  */
-declare function useCreateEIP712(): _tanstack_react_query.UseMutationResult<EIP712TypedData, Error, CreateEIP712Params, unknown>;
-
+declare function useCreateEIP712(): _tanstack_react_query0.UseMutationResult<EIP712TypedData$1, Error, CreateEIP712Params, unknown>;
+//#endregion
+//#region src/relayer/use-create-delegated-user-decrypt-eip712.d.ts
 /** 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;
+  /** The FHE public key (hex-encoded). */
+  publicKey: `0x${string}`;
+  /** Contract addresses the credential authorizes decryption for. */
+  contractAddresses: Address$1[];
+  /** Address of the wallet that delegated decrypt authority. */
+  delegatorAddress: Address$1;
+  /** 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.
@@ -171,13 +192,14 @@ interface CreateDelegatedUserDecryptEIP712Params {
  * });
  * ```
  */
-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;
+declare function useCreateDelegatedUserDecryptEIP712(): _tanstack_react_query0.UseMutationResult<Readonly<{
+  types: _zama_fhe_relayer_sdk_web0.KmsDelegatedUserDecryptEIP712TypesType;
+  primaryType: "DelegatedUserDecryptRequestVerification";
+  domain: _zama_fhe_relayer_sdk_web0.KmsEIP712DomainType;
+  message: _zama_fhe_relayer_sdk_web0.KmsDelegatedUserDecryptEIP712MessageType;
 }>, Error, CreateDelegatedUserDecryptEIP712Params, unknown>;
-
+//#endregion
+//#region src/relayer/use-delegated-user-decrypt.d.ts
 /**
  * Decrypt FHE ciphertext handles using delegated user credentials.
  * Returns a map of handle → plaintext bigint.
@@ -191,8 +213,9 @@ declare function useCreateDelegatedUserDecryptEIP712(): _tanstack_react_query.Us
  * // decrypt.data => { "0xHandle1": 1000n }
  * ```
  */
-declare function useDelegatedUserDecrypt(): _tanstack_react_query.UseMutationResult<Record<string, bigint>, Error, DelegatedUserDecryptParams, unknown>;
-
+declare function useDelegatedUserDecrypt(): _tanstack_react_query0.UseMutationResult<Record<`0x${string}`, ClearValueType$1>, Error, DelegatedUserDecryptParams$1, unknown>;
+//#endregion
+//#region src/relayer/use-request-zk-proof-verification.d.ts
 /**
  * Submit a ZK proof for on-chain verification.
  * Returns the input proof bytes for use in contract calls.
@@ -206,38 +229,19 @@ declare function useDelegatedUserDecrypt(): _tanstack_react_query.UseMutationRes
  * // 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"];
-};
+declare function useRequestZKProofVerification(): _tanstack_react_query0.UseMutationResult<Readonly<{
+  handles: Uint8Array[];
+  inputProof: Uint8Array;
+}>, Error, ZKProofLike$1, unknown>;
+//#endregion
+//#region src/relayer/use-public-key.d.ts
 /** 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;
+  /** 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.
@@ -250,38 +254,19 @@ declare function publicKeyQueryOptions(sdk: ZamaSDK): {
  * // 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];
-};
+declare function usePublicKey(): _tanstack_react_query0.UseQueryResult<{
+  publicKeyId: string;
+  publicKey: Uint8Array;
+} | null, Error>;
+//#endregion
+//#region src/relayer/use-public-params.d.ts
 /** 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;
+  /** 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.
@@ -295,33 +280,117 @@ declare function publicParamsQueryOptions(sdk: ZamaSDK, bits: number): {
  * // params?.publicParams, params?.publicParamsId
  * ```
  */
-declare function usePublicParams(bits: number): _tanstack_react_query.UseQueryResult<PublicParamsResult, Error>;
-
+declare function usePublicParams(bits: number): _tanstack_react_query0.UseQueryResult<{
+  publicParams: Uint8Array;
+  publicParamsId: string;
+} | null, Error>;
+//#endregion
+//#region src/relayer/use-user-decrypt-flow.d.ts
+/** A handle to decrypt, paired with its originating contract address. */
+interface DecryptHandle {
+  handle: Handle$1;
+  contractAddress: Address$1;
+}
+/** Parameters for {@link useUserDecryptFlow}. */
+interface UserDecryptFlowParams {
+  /** Encrypted handles to decrypt. */
+  handles: DecryptHandle[];
+  /** Number of days the credential remains valid. Default: 1. */
+  durationDays?: number;
+}
+/** Progress callbacks for each step of the decrypt flow. */
+interface UserDecryptFlowCallbacks {
+  /** Fired after the keypair is generated. */
+  onKeypairGenerated?: () => void;
+  /** Fired after the EIP-712 typed data is created, before wallet signing. */
+  onEIP712Created?: () => void;
+  /** Fired after the wallet signature is obtained. */
+  onSigned?: (signature: Hex$1) => void;
+  /** Fired after decryption completes. */
+  onDecrypted?: (values: Record<Handle$1, ClearValueType$1>) => void;
+}
+/** Configuration for {@link useUserDecryptFlow}. */
+interface UseUserDecryptFlowConfig {
+  /** Optional progress callbacks. */
+  callbacks?: UserDecryptFlowCallbacks;
+}
+/**
+ * High-level orchestration hook for user decryption.
+ * Handles the full flow: keypair generation → EIP-712 creation → wallet signature → decryption.
+ *
+ * On success, populates the decryption cache so `useUserDecryptedValue` / `useUserDecryptedValues`
+ * can read the results.
+ *
+ * @param config - Optional callbacks for step-by-step UX feedback.
+ * @returns A mutation whose `mutate` accepts {@link UserDecryptFlowParams}.
+ *
+ * @example
+ * ```tsx
+ * const decryptFlow = useUserDecryptFlow({
+ *   callbacks: { onSigned: () => setStep("decrypting") },
+ * });
+ * decryptFlow.mutate({
+ *   handles: [{ handle: "0xHandle", contractAddress: "0xContract" }],
+ *   durationDays: 7,
+ * });
+ * ```
+ */
+declare function useUserDecryptFlow(config?: UseUserDecryptFlowConfig): _tanstack_react_query0.UseMutationResult<Record<`0x${string}`, ClearValueType$1>, Error, UserDecryptFlowParams, unknown>;
+//#endregion
+//#region src/relayer/use-user-decrypted-value.d.ts
 /**
  * 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>;
-
+declare function useUserDecryptedValue(handle: Handle$1 | undefined): _tanstack_react_query0.UseQueryResult<ClearValueType$1, Error>;
+//#endregion
+//#region src/relayer/use-user-decrypted-values.d.ts
 /**
  * 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>[];
+declare function useUserDecryptedValues(handles: Handle$1[]): {
+  data: Partial<Record<`0x${string}`, ClearValueType$1 | undefined>>;
+  results: _tanstack_react_query0.UseQueryResult<never, Error>[];
 };
-
+//#endregion
+//#region src/relayer/decryption-cache.d.ts
 /**
  * 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];
+  value: (handle: Handle$1, contractAddress?: Address$1) => readonly ["zama.decryption", {
+    readonly contractAddress?: `0x${string}` | undefined;
+    readonly handle: string;
+  }];
 };
-
+//#endregion
+//#region src/token/use-token.d.ts
+/** Base configuration shared by all mutation hooks that need a Token instance. */
+interface UseZamaConfig {
+  /** Address of the confidential token contract. */
+  tokenAddress: Address$1;
+  /** Address of the wrapper contract (required for shield/unshield operations). */
+  wrapperAddress?: Address$1;
+}
+/**
+ * Get a {@link Token} instance, memoized by address pair.
+ * Reads signer and storage from the nearest {@link ZamaProvider}.
+ *
+ * @param config - Token and optional wrapper addresses.
+ * @returns A memoized `Token` instance.
+ *
+ * @example
+ * ```tsx
+ * const token = useToken({ tokenAddress: "0xToken", wrapperAddress: "0xWrapper" });
+ * ```
+ */
+declare function useToken(config: UseZamaConfig): _zama_fhe_sdk0.Token;
+//#endregion
+//#region src/token/use-readonly-token.d.ts
 /**
  * Get a {@link ReadonlyToken} instance, memoized by address.
  * Supports balance queries, ERC-165 checks, and authorization — no wrapper needed.
@@ -336,34 +405,479 @@ declare const decryptionKeys: {
  * // 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;
+declare function useReadonlyToken(address: Address$1): _zama_fhe_sdk0.ReadonlyToken;
+//#endregion
+//#region src/token/use-confidential-balance.d.ts
+/** Configuration for {@link useConfidentialBalance}. */
+interface UseConfidentialBalanceConfig {
+  /** Address of the confidential token contract. */
+  tokenAddress: Address$1;
+  /** Polling interval (ms) for the encrypted handle. Default: 10 000. */
+  handleRefetchInterval?: number;
 }
-/** 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;
+/** Query options for the decrypt phase of {@link useConfidentialBalance}. */
+type UseConfidentialBalanceOptions = Omit<UseQueryOptions<bigint, Error>, "queryKey" | "queryFn">;
+/**
+ * Declarative hook to read the connected wallet's confidential token balance.
+ * Uses two-phase polling: cheaply polls the encrypted handle, then only
+ * decrypts when the handle changes (new balance).
+ *
+ * @param config - Token address and optional polling interval.
+ * @param options - React Query options forwarded to the decrypt query.
+ * @returns The decrypt query result plus `handleQuery` for Phase 1 state.
+ *
+ * @example
+ * ```tsx
+ * const { data: balance, isLoading, handleQuery } = useConfidentialBalance({
+ *   tokenAddress: "0x...",
+ * });
+ * ```
+ */
+declare function useConfidentialBalance(config: UseConfidentialBalanceConfig, options?: UseConfidentialBalanceOptions): {
+  handleQuery: _tanstack_react_query0.UseQueryResult<`0x${string}`, Error>;
+  data: bigint;
+  error: Error;
+  isError: true;
+  isPending: false;
+  isLoading: false;
+  isLoadingError: false;
+  isRefetchError: true;
+  isSuccess: false;
+  isPlaceholderData: false;
+  status: "error";
+  dataUpdatedAt: number;
+  errorUpdatedAt: number;
+  failureCount: number;
+  failureReason: Error | null;
+  errorUpdateCount: number;
+  isFetched: boolean;
+  isFetchedAfterMount: boolean;
+  isFetching: boolean;
+  isInitialLoading: boolean;
+  isPaused: boolean;
+  isRefetching: boolean;
+  isStale: boolean;
+  isEnabled: boolean;
+  refetch: (options?: _tanstack_query_core0.RefetchOptions) => Promise<_tanstack_query_core0.QueryObserverResult<bigint, Error>>;
+  fetchStatus: _tanstack_query_core0.FetchStatus;
+  promise: Promise<bigint>;
+} | {
+  handleQuery: _tanstack_react_query0.UseQueryResult<`0x${string}`, Error>;
+  data: bigint;
+  error: null;
+  isError: false;
+  isPending: false;
+  isLoading: false;
+  isLoadingError: false;
+  isRefetchError: false;
+  isSuccess: true;
+  isPlaceholderData: false;
+  status: "success";
+  dataUpdatedAt: number;
+  errorUpdatedAt: number;
+  failureCount: number;
+  failureReason: Error | null;
+  errorUpdateCount: number;
+  isFetched: boolean;
+  isFetchedAfterMount: boolean;
+  isFetching: boolean;
+  isInitialLoading: boolean;
+  isPaused: boolean;
+  isRefetching: boolean;
+  isStale: boolean;
+  isEnabled: boolean;
+  refetch: (options?: _tanstack_query_core0.RefetchOptions) => Promise<_tanstack_query_core0.QueryObserverResult<bigint, Error>>;
+  fetchStatus: _tanstack_query_core0.FetchStatus;
+  promise: Promise<bigint>;
+} | {
+  handleQuery: _tanstack_react_query0.UseQueryResult<`0x${string}`, Error>;
+  data: undefined;
+  error: Error;
+  isError: true;
+  isPending: false;
+  isLoading: false;
+  isLoadingError: true;
+  isRefetchError: false;
+  isSuccess: false;
+  isPlaceholderData: false;
+  status: "error";
+  dataUpdatedAt: number;
+  errorUpdatedAt: number;
+  failureCount: number;
+  failureReason: Error | null;
+  errorUpdateCount: number;
+  isFetched: boolean;
+  isFetchedAfterMount: boolean;
+  isFetching: boolean;
+  isInitialLoading: boolean;
+  isPaused: boolean;
+  isRefetching: boolean;
+  isStale: boolean;
+  isEnabled: boolean;
+  refetch: (options?: _tanstack_query_core0.RefetchOptions) => Promise<_tanstack_query_core0.QueryObserverResult<bigint, Error>>;
+  fetchStatus: _tanstack_query_core0.FetchStatus;
+  promise: Promise<bigint>;
+} | {
+  handleQuery: _tanstack_react_query0.UseQueryResult<`0x${string}`, Error>;
+  data: undefined;
+  error: null;
+  isError: false;
+  isPending: true;
+  isLoading: true;
+  isLoadingError: false;
+  isRefetchError: false;
+  isSuccess: false;
+  isPlaceholderData: false;
+  status: "pending";
+  dataUpdatedAt: number;
+  errorUpdatedAt: number;
+  failureCount: number;
+  failureReason: Error | null;
+  errorUpdateCount: number;
+  isFetched: boolean;
+  isFetchedAfterMount: boolean;
+  isFetching: boolean;
+  isInitialLoading: boolean;
+  isPaused: boolean;
+  isRefetching: boolean;
+  isStale: boolean;
+  isEnabled: boolean;
+  refetch: (options?: _tanstack_query_core0.RefetchOptions) => Promise<_tanstack_query_core0.QueryObserverResult<bigint, Error>>;
+  fetchStatus: _tanstack_query_core0.FetchStatus;
+  promise: Promise<bigint>;
+} | {
+  handleQuery: _tanstack_react_query0.UseQueryResult<`0x${string}`, Error>;
+  data: undefined;
+  error: null;
+  isError: false;
+  isPending: true;
+  isLoadingError: false;
+  isRefetchError: false;
+  isSuccess: false;
+  isPlaceholderData: false;
+  status: "pending";
+  dataUpdatedAt: number;
+  errorUpdatedAt: number;
+  failureCount: number;
+  failureReason: Error | null;
+  errorUpdateCount: number;
+  isFetched: boolean;
+  isFetchedAfterMount: boolean;
+  isFetching: boolean;
+  isLoading: boolean;
+  isInitialLoading: boolean;
+  isPaused: boolean;
+  isRefetching: boolean;
+  isStale: boolean;
+  isEnabled: boolean;
+  refetch: (options?: _tanstack_query_core0.RefetchOptions) => Promise<_tanstack_query_core0.QueryObserverResult<bigint, Error>>;
+  fetchStatus: _tanstack_query_core0.FetchStatus;
+  promise: Promise<bigint>;
+} | {
+  handleQuery: _tanstack_react_query0.UseQueryResult<`0x${string}`, Error>;
+  data: bigint;
+  isError: false;
+  error: null;
+  isPending: false;
+  isLoading: false;
+  isLoadingError: false;
+  isRefetchError: false;
+  isSuccess: true;
+  isPlaceholderData: true;
+  status: "success";
+  dataUpdatedAt: number;
+  errorUpdatedAt: number;
+  failureCount: number;
+  failureReason: Error | null;
+  errorUpdateCount: number;
+  isFetched: boolean;
+  isFetchedAfterMount: boolean;
+  isFetching: boolean;
+  isInitialLoading: boolean;
+  isPaused: boolean;
+  isRefetching: boolean;
+  isStale: boolean;
+  isEnabled: boolean;
+  refetch: (options?: _tanstack_query_core0.RefetchOptions) => Promise<_tanstack_query_core0.QueryObserverResult<bigint, Error>>;
+  fetchStatus: _tanstack_query_core0.FetchStatus;
+  promise: Promise<bigint>;
+};
+//#endregion
+//#region src/token/use-confidential-balances.d.ts
+/** Configuration for {@link useConfidentialBalances}. */
+interface UseConfidentialBalancesConfig {
+  /** Addresses of the confidential token contracts to batch-query. */
+  tokenAddresses: Address$1[];
+  /** Polling interval (ms) for the encrypted handles. Default: 10 000. */
+  handleRefetchInterval?: number;
+  /** Maximum number of concurrent decrypt calls. Default: `Infinity` (no limit). */
+  maxConcurrency?: number;
 }
+/** Query options for the decrypt phase of {@link useConfidentialBalances}. */
+type UseConfidentialBalancesOptions = Omit<UseQueryOptions<ConfidentialBalancesData$1, Error>, "queryKey" | "queryFn">;
 /**
- * TanStack Query mutation options factory for confidential transfer.
+ * Declarative hook to read multiple confidential token balances in batch.
+ * Uses two-phase polling: cheaply polls encrypted handles, then only
+ * decrypts when any handle changes.
+ *
+ * Returns partial results when some tokens fail — successful balances are
+ * always returned alongside per-token error information.
+ *
+ * @param config - Token addresses and optional polling interval.
+ * @param options - React Query options forwarded to the decrypt query.
+ * @returns The decrypt query result plus `handlesQuery` for Phase 1 state.
  *
- * @param token - A `Token` instance.
- * @returns Mutation options with `mutationKey` and `mutationFn`.
+ * @example
+ * ```tsx
+ * const { data } = useConfidentialBalances({
+ *   tokenAddresses: ["0xTokenA", "0xTokenB"],
+ * });
+ * const balance = data?.balances.get("0xTokenA");
+ * if (data?.isPartialError) {
+ *   // some tokens failed — check data.errors
+ * }
+ * ```
  */
-declare function confidentialTransferMutationOptions(token: Token): {
-    mutationKey: readonly ["confidentialTransfer", `0x${string}`];
-    mutationFn: ({ to, amount }: ConfidentialTransferParams) => Promise<TransactionResult>;
+declare function useConfidentialBalances(config: UseConfidentialBalancesConfig, options?: UseConfidentialBalancesOptions): {
+  handlesQuery: _tanstack_react_query0.UseQueryResult<`0x${string}`[], Error>;
+  data: ConfidentialBalancesData$1;
+  error: Error;
+  isError: true;
+  isPending: false;
+  isLoading: false;
+  isLoadingError: false;
+  isRefetchError: true;
+  isSuccess: false;
+  isPlaceholderData: false;
+  status: "error";
+  dataUpdatedAt: number;
+  errorUpdatedAt: number;
+  failureCount: number;
+  failureReason: Error | null;
+  errorUpdateCount: number;
+  isFetched: boolean;
+  isFetchedAfterMount: boolean;
+  isFetching: boolean;
+  isInitialLoading: boolean;
+  isPaused: boolean;
+  isRefetching: boolean;
+  isStale: boolean;
+  isEnabled: boolean;
+  refetch: (options?: _tanstack_query_core0.RefetchOptions) => Promise<_tanstack_query_core0.QueryObserverResult<ConfidentialBalancesData$1, Error>>;
+  fetchStatus: _tanstack_query_core0.FetchStatus;
+  promise: Promise<ConfidentialBalancesData$1>;
+} | {
+  handlesQuery: _tanstack_react_query0.UseQueryResult<`0x${string}`[], Error>;
+  data: ConfidentialBalancesData$1;
+  error: null;
+  isError: false;
+  isPending: false;
+  isLoading: false;
+  isLoadingError: false;
+  isRefetchError: false;
+  isSuccess: true;
+  isPlaceholderData: false;
+  status: "success";
+  dataUpdatedAt: number;
+  errorUpdatedAt: number;
+  failureCount: number;
+  failureReason: Error | null;
+  errorUpdateCount: number;
+  isFetched: boolean;
+  isFetchedAfterMount: boolean;
+  isFetching: boolean;
+  isInitialLoading: boolean;
+  isPaused: boolean;
+  isRefetching: boolean;
+  isStale: boolean;
+  isEnabled: boolean;
+  refetch: (options?: _tanstack_query_core0.RefetchOptions) => Promise<_tanstack_query_core0.QueryObserverResult<ConfidentialBalancesData$1, Error>>;
+  fetchStatus: _tanstack_query_core0.FetchStatus;
+  promise: Promise<ConfidentialBalancesData$1>;
+} | {
+  handlesQuery: _tanstack_react_query0.UseQueryResult<`0x${string}`[], Error>;
+  data: undefined;
+  error: Error;
+  isError: true;
+  isPending: false;
+  isLoading: false;
+  isLoadingError: true;
+  isRefetchError: false;
+  isSuccess: false;
+  isPlaceholderData: false;
+  status: "error";
+  dataUpdatedAt: number;
+  errorUpdatedAt: number;
+  failureCount: number;
+  failureReason: Error | null;
+  errorUpdateCount: number;
+  isFetched: boolean;
+  isFetchedAfterMount: boolean;
+  isFetching: boolean;
+  isInitialLoading: boolean;
+  isPaused: boolean;
+  isRefetching: boolean;
+  isStale: boolean;
+  isEnabled: boolean;
+  refetch: (options?: _tanstack_query_core0.RefetchOptions) => Promise<_tanstack_query_core0.QueryObserverResult<ConfidentialBalancesData$1, Error>>;
+  fetchStatus: _tanstack_query_core0.FetchStatus;
+  promise: Promise<ConfidentialBalancesData$1>;
+} | {
+  handlesQuery: _tanstack_react_query0.UseQueryResult<`0x${string}`[], Error>;
+  data: undefined;
+  error: null;
+  isError: false;
+  isPending: true;
+  isLoading: true;
+  isLoadingError: false;
+  isRefetchError: false;
+  isSuccess: false;
+  isPlaceholderData: false;
+  status: "pending";
+  dataUpdatedAt: number;
+  errorUpdatedAt: number;
+  failureCount: number;
+  failureReason: Error | null;
+  errorUpdateCount: number;
+  isFetched: boolean;
+  isFetchedAfterMount: boolean;
+  isFetching: boolean;
+  isInitialLoading: boolean;
+  isPaused: boolean;
+  isRefetching: boolean;
+  isStale: boolean;
+  isEnabled: boolean;
+  refetch: (options?: _tanstack_query_core0.RefetchOptions) => Promise<_tanstack_query_core0.QueryObserverResult<ConfidentialBalancesData$1, Error>>;
+  fetchStatus: _tanstack_query_core0.FetchStatus;
+  promise: Promise<ConfidentialBalancesData$1>;
+} | {
+  handlesQuery: _tanstack_react_query0.UseQueryResult<`0x${string}`[], Error>;
+  data: undefined;
+  error: null;
+  isError: false;
+  isPending: true;
+  isLoadingError: false;
+  isRefetchError: false;
+  isSuccess: false;
+  isPlaceholderData: false;
+  status: "pending";
+  dataUpdatedAt: number;
+  errorUpdatedAt: number;
+  failureCount: number;
+  failureReason: Error | null;
+  errorUpdateCount: number;
+  isFetched: boolean;
+  isFetchedAfterMount: boolean;
+  isFetching: boolean;
+  isLoading: boolean;
+  isInitialLoading: boolean;
+  isPaused: boolean;
+  isRefetching: boolean;
+  isStale: boolean;
+  isEnabled: boolean;
+  refetch: (options?: _tanstack_query_core0.RefetchOptions) => Promise<_tanstack_query_core0.QueryObserverResult<ConfidentialBalancesData$1, Error>>;
+  fetchStatus: _tanstack_query_core0.FetchStatus;
+  promise: Promise<ConfidentialBalancesData$1>;
+} | {
+  handlesQuery: _tanstack_react_query0.UseQueryResult<`0x${string}`[], Error>;
+  data: ConfidentialBalancesData$1;
+  isError: false;
+  error: null;
+  isPending: false;
+  isLoading: false;
+  isLoadingError: false;
+  isRefetchError: false;
+  isSuccess: true;
+  isPlaceholderData: true;
+  status: "success";
+  dataUpdatedAt: number;
+  errorUpdatedAt: number;
+  failureCount: number;
+  failureReason: Error | null;
+  errorUpdateCount: number;
+  isFetched: boolean;
+  isFetchedAfterMount: boolean;
+  isFetching: boolean;
+  isInitialLoading: boolean;
+  isPaused: boolean;
+  isRefetching: boolean;
+  isStale: boolean;
+  isEnabled: boolean;
+  refetch: (options?: _tanstack_query_core0.RefetchOptions) => Promise<_tanstack_query_core0.QueryObserverResult<ConfidentialBalancesData$1, Error>>;
+  fetchStatus: _tanstack_query_core0.FetchStatus;
+  promise: Promise<ConfidentialBalancesData$1>;
 };
+//#endregion
+//#region src/token/use-allow.d.ts
+/**
+ * Pre-authorize FHE decrypt credentials for a list of token addresses.
+ * A single wallet signature covers all addresses, so subsequent decrypt
+ * operations on any of these tokens reuse cached credentials.
+ *
+ * @example
+ * ```tsx
+ * const { mutateAsync: allow, isPending } = useAllow();
+ * // Call allow(allTokenAddresses) before any individual reveal
+ * ```
+ */
+declare function useAllow(options?: UseMutationOptions<void, Error, Address$1[]>): _tanstack_react_query0.UseMutationResult<void, Error, `0x${string}`[], unknown>;
+//#endregion
+//#region src/token/use-is-allowed.d.ts
+/**
+ * Check whether a session signature is cached for the connected wallet.
+ * Returns `true` if decrypt operations can proceed without a wallet prompt.
+ *
+ * @example
+ * ```tsx
+ * const { data: allowed } = useIsAllowed();
+ * ```
+ */
+declare function useIsAllowed(): _tanstack_react_query0.UseQueryResult<unknown, Error>;
+//#endregion
+//#region src/token/use-revoke.d.ts
+/**
+ * Revoke stored FHE credentials for a list of token addresses.
+ * The next decrypt operation will require a fresh wallet signature.
+ *
+ * @example
+ * ```tsx
+ * const { mutate: revoke } = useRevoke();
+ * revoke(["0xTokenA", "0xTokenB"]);
+ * ```
+ */
+declare function useRevoke(options?: UseMutationOptions<void, Error, Address$1[]>): _tanstack_react_query0.UseMutationResult<void, Error, `0x${string}`[], unknown>;
+//#endregion
+//#region src/token/use-revoke-session.d.ts
+/**
+ * Revoke the session signature for the connected wallet without
+ * specifying contract addresses. Useful for wallet disconnect handlers.
+ *
+ * @example
+ * ```tsx
+ * const { mutate: revokeSession } = useRevokeSession();
+ * revokeSession();
+ * ```
+ */
+declare function useRevokeSession(options?: UseMutationOptions<void, Error, void>): _tanstack_react_query0.UseMutationResult<void, Error, void, unknown>;
+//#endregion
+//#region src/token/optimistic-balance-update.d.ts
+type OptimisticBalanceSnapshot = Array<[QueryKey, bigint | undefined]>;
+/** Combined context returned by optimistic `onMutate`. */
+interface OptimisticMutateContext {
+  snapshot: OptimisticBalanceSnapshot;
+  callerContext?: unknown;
+}
+//#endregion
+//#region src/token/use-confidential-transfer.d.ts
+/** 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;
+}
 /**
  * Encrypt and send a confidential transfer. Invalidates balance caches on success.
  *
@@ -394,46 +908,62 @@ declare function confidentialTransferMutationOptions(token: Token): {
  * );
  * ```
  */
-declare function useConfidentialTransfer(config: UseConfidentialTransferConfig, options?: UseMutationOptions<TransactionResult, Error, ConfidentialTransferParams, Address>): _tanstack_react_query.UseMutationResult<TransactionResult, Error, ConfidentialTransferParams, `0x${string}`>;
-
+declare function useConfidentialTransfer(config: UseConfidentialTransferConfig, options?: UseMutationOptions<TransactionResult$1, Error, ConfidentialTransferParams$1, OptimisticMutateContext>): _tanstack_react_query0.UseMutationResult<TransactionResult$1, Error, ConfidentialTransferParams$1, OptimisticMutateContext>;
+//#endregion
+//#region src/token/use-confidential-transfer-from.d.ts
+/**
+ * Operator transfer on behalf of another address. Caller must be an approved operator.
+ * Invalidates balance caches on success.
+ *
+ * @param config - Token address (and optional wrapper) identifying the token.
+ * @param options - React Query mutation options.
+ *
+ * @example
+ * ```tsx
+ * const transferFrom = useConfidentialTransferFrom({ tokenAddress: "0x..." });
+ * transferFrom.mutate({ from: "0xOwner", to: "0xRecipient", amount: 500n });
+ * ```
+ */
+declare function useConfidentialTransferFrom(config: UseZamaConfig, options?: UseMutationOptions<TransactionResult$1, Error, ConfidentialTransferFromParams$1, Address$1>): _tanstack_react_query0.UseMutationResult<TransactionResult$1, Error, ConfidentialTransferFromParams$1, `0x${string}`>;
+//#endregion
+//#region src/token/use-confidential-approve.d.ts
 /**
- * Query key factory for confidential approval queries.
- * Use with `queryClient.invalidateQueries()` / `resetQueries()`.
+ * Set operator approval for a confidential token. Defaults to 1 hour.
+ *
+ * Errors are {@link ZamaError} subclasses — use `instanceof` to handle specific failures:
+ * - {@link SigningRejectedError} — user rejected the wallet prompt
+ * - {@link TransactionRevertedError} — on-chain transaction reverted
+ *
+ * @param config - Token address (and optional wrapper) identifying the token.
+ * @param options - React Query mutation options.
+ *
+ * @example
+ * ```tsx
+ * const approve = useConfidentialApprove({ tokenAddress: "0x..." });
+ * approve.mutate({ spender: "0xOperator" });
+ * ```
  */
-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];
-};
+declare function useConfidentialApprove(config: UseZamaConfig, options?: UseMutationOptions<TransactionResult$1, Error, ConfidentialApproveParams$1, Address$1>): _tanstack_react_query0.UseMutationResult<TransactionResult$1, Error, ConfidentialApproveParams$1, `0x${string}`>;
+//#endregion
+//#region src/token/use-confidential-is-approved.d.ts
 /** Configuration for {@link useConfidentialIsApproved}. */
 interface UseConfidentialIsApprovedConfig extends UseZamaConfig {
-    /** Address to check approval for. Pass `undefined` to disable the query. */
-    spender: Address | undefined;
+  /** Address to check approval for. Pass `undefined` to disable the query. */
+  spender: Address$1 | undefined;
+  /** Token holder address. Defaults to the connected wallet. */
+  holder?: Address$1;
 }
 /** Configuration for {@link useConfidentialIsApprovedSuspense}. */
 interface UseConfidentialIsApprovedSuspenseConfig extends UseZamaConfig {
-    /** Address to check approval for. */
-    spender: Address;
+  /** Address to check approval for. */
+  spender: Address$1;
+  /** Token holder address. Defaults to the connected wallet. */
+  holder?: Address$1;
 }
 /**
- * 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.
+ * Check if a spender is an approved operator for a given holder (defaults to connected wallet).
  *
- * @param config - Token address and spender to check.
+ * @param config - Token address, spender, and optional holder to check.
  * @param options - React Query options (forwarded to `useQuery`).
  * @returns Query result with `data: boolean`.
  *
@@ -442,15 +972,16 @@ declare function confidentialIsApprovedQueryOptions(token: Token, spender: Addre
  * const { data: isApproved } = useConfidentialIsApproved({
  *   tokenAddress: "0xToken",
  *   spender: "0xSpender",
+ *   holder: "0xHolder", // optional
  * });
  * ```
  */
-declare function useConfidentialIsApproved(config: UseConfidentialIsApprovedConfig, options?: Omit<UseQueryOptions<boolean, Error>, "queryKey" | "queryFn">): _tanstack_react_query.UseQueryResult<boolean, Error>;
+declare function useConfidentialIsApproved(config: UseConfidentialIsApprovedConfig, options?: Omit<UseQueryOptions<boolean, Error>, "queryKey" | "queryFn">): _tanstack_react_query0.UseQueryResult<unknown, Error>;
 /**
  * Suspense variant of {@link useConfidentialIsApproved}.
  * Suspends rendering until the approval check resolves.
  *
- * @param config - Token address and spender to check.
+ * @param config - Token address, spender, and optional holder to check.
  * @returns Suspense query result with `data: boolean`.
  *
  * @example
@@ -458,39 +989,22 @@ declare function useConfidentialIsApproved(config: UseConfidentialIsApprovedConf
  * const { data: isApproved } = useConfidentialIsApprovedSuspense({
  *   tokenAddress: "0xToken",
  *   spender: "0xSpender",
+ *   holder: "0xHolder", // optional
  * });
  * ```
  */
-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";
-}
+declare function useConfidentialIsApprovedSuspense(config: UseConfidentialIsApprovedSuspenseConfig): _tanstack_react_query0.UseSuspenseQueryResult<boolean, Error>;
+//#endregion
+//#region src/token/use-shield.d.ts
 /** 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;
+  /**
+   * 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.
@@ -510,25 +1024,9 @@ declare function shieldMutationOptions(token: Token): {
  * 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>;
-};
+declare function useShield(config: UseShieldConfig, options?: UseMutationOptions<TransactionResult$1, Error, ShieldParams$1, OptimisticMutateContext>): _tanstack_react_query0.UseMutationResult<TransactionResult$1, Error, ShieldParams$1, OptimisticMutateContext>;
+//#endregion
+//#region src/token/use-shield-eth.d.ts
 /**
  * Shield native ETH into confidential tokens.
  * Invalidates balance caches on success.
@@ -542,23 +1040,9 @@ declare function shieldETHMutationOptions(token: Token): {
  * 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>;
-};
+declare function useShieldETH(config: UseZamaConfig, options?: UseMutationOptions<TransactionResult$1, Error, ShieldETHParams$1, Address$1>): _tanstack_react_query0.UseMutationResult<TransactionResult$1, Error, ShieldETHParams$1, `0x${string}`>;
+//#endregion
+//#region src/token/use-unwrap.d.ts
 /**
  * Request an unwrap for a specific amount. Encrypts the amount first.
  * Call {@link useFinalizeUnwrap} after the request is processed on-chain,
@@ -573,23 +1057,26 @@ declare function unwrapMutationOptions(token: Token): {
  * 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;
-}
+declare function useUnwrap(config: UseZamaConfig, options?: UseMutationOptions<TransactionResult$1, Error, UnwrapParams$1, Address$1>): _tanstack_react_query0.UseMutationResult<TransactionResult$1, Error, UnwrapParams$1, `0x${string}`>;
+//#endregion
+//#region src/token/use-unwrap-all.d.ts
 /**
- * TanStack Query mutation options factory for finalize-unwrap.
+ * Request an unwrap for the entire confidential balance.
+ * Uses the on-chain balance handle directly (no encryption needed).
+ * Call {@link useFinalizeUnwrap} after processing, or use {@link useUnshieldAll} for single-call orchestration.
+ *
+ * @param config - Token address (and optional wrapper) identifying the token.
+ * @param options - React Query mutation options.
  *
- * @param token - A `Token` instance.
- * @returns Mutation options with `mutationKey` and `mutationFn`.
+ * @example
+ * ```tsx
+ * const unwrapAll = useUnwrapAll({ tokenAddress: "0x..." });
+ * unwrapAll.mutate();
+ * ```
  */
-declare function finalizeUnwrapMutationOptions(token: Token): {
-    mutationKey: readonly ["finalizeUnwrap", `0x${string}`];
-    mutationFn: ({ burnAmountHandle }: FinalizeUnwrapParams) => Promise<TransactionResult>;
-};
+declare function useUnwrapAll(config: UseZamaConfig, options?: UseMutationOptions<TransactionResult$1, Error, void, Address$1>): _tanstack_react_query0.UseMutationResult<TransactionResult$1, Error, void, `0x${string}`>;
+//#endregion
+//#region src/token/use-finalize-unwrap.d.ts
 /**
  * Complete an unwrap by providing the public decryption proof.
  * Call this after an unwrap request has been processed on-chain.
@@ -603,37 +1090,75 @@ declare function finalizeUnwrapMutationOptions(token: Token): {
  * 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}`>;
-
+declare function useFinalizeUnwrap(config: UseZamaConfig, options?: UseMutationOptions<TransactionResult$1, Error, FinalizeUnwrapParams$1, Address$1>): _tanstack_react_query0.UseMutationResult<TransactionResult$1, Error, FinalizeUnwrapParams$1, `0x${string}`>;
+//#endregion
+//#region src/token/use-unshield.d.ts
 /**
- * Query key factory for underlying ERC-20 allowance queries.
- * Use with `queryClient.invalidateQueries()` / `resetQueries()`.
+ * Unshield a specific amount and finalize in one call.
+ * Orchestrates: unwrap → wait for receipt → parse event → finalize.
+ *
+ * Errors are {@link ZamaError} subclasses — use `instanceof` to handle specific failures:
+ * - {@link SigningRejectedError} — user rejected the wallet prompt
+ * - {@link EncryptionFailedError} — FHE encryption failed during unwrap
+ * - {@link DecryptionFailedError} — public decryption failed during finalize
+ * - {@link TransactionRevertedError} — on-chain transaction reverted
+ *
+ * @param config - Token and wrapper addresses.
+ * @param options - React Query mutation options.
+ *
+ * @example
+ * ```tsx
+ * const unshield = useUnshield({ tokenAddress: "0x...", wrapperAddress: "0x..." });
+ * unshield.mutate({ amount: 500n });
+ * ```
  */
-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;
-}
+declare function useUnshield(config: UseZamaConfig, options?: UseMutationOptions<TransactionResult$1, Error, UnshieldParams$1, Address$1>): _tanstack_react_query0.UseMutationResult<TransactionResult$1, Error, UnshieldParams$1, `0x${string}`>;
+//#endregion
+//#region src/token/use-unshield-all.d.ts
+/**
+ * Unshield the entire balance and finalize in one call.
+ * Orchestrates: unwrapAll → wait for receipt → parse event → finalize.
+ *
+ * @param config - Token and wrapper addresses.
+ * @param options - React Query mutation options.
+ *
+ * @example
+ * ```tsx
+ * const unshieldAll = useUnshieldAll({ tokenAddress: "0x...", wrapperAddress: "0x..." });
+ * unshieldAll.mutate();
+ * ```
+ */
+declare function useUnshieldAll(config: UseZamaConfig, options?: UseMutationOptions<TransactionResult$1, Error, UnshieldAllParams$1 | void, Address$1>): _tanstack_react_query0.UseMutationResult<TransactionResult$1, Error, void | UnshieldAllParams$1, `0x${string}`>;
+//#endregion
+//#region src/token/use-resume-unshield.d.ts
 /**
- * TanStack Query options factory for underlying ERC-20 allowance.
+ * Resume an interrupted unshield from an existing unwrap tx hash.
+ * Useful when the user submitted the unwrap but the finalize step was
+ * interrupted (e.g. page reload, network error).
+ *
+ * Errors are {@link ZamaError} subclasses — use `instanceof` to handle specific failures:
+ * - {@link DecryptionFailedError} — public decryption failed during finalize
+ * - {@link TransactionRevertedError} — on-chain transaction reverted
+ *
+ * @param config - Token and wrapper addresses.
+ * @param options - React Query mutation options.
  *
- * @param token - A `ReadonlyToken` instance.
- * @param wrapperAddress - Address of the wrapper contract (the spender).
- * @returns Query options with `queryKey`, `queryFn`, and `staleTime`.
+ * @example
+ * ```tsx
+ * const resumeUnshield = useResumeUnshield({ tokenAddress: "0x...", wrapperAddress: "0x..." });
+ * resumeUnshield.mutate({ unwrapTxHash: "0xabc..." });
+ * ```
  */
-declare function underlyingAllowanceQueryOptions(token: ReadonlyToken, wrapperAddress: Address): {
-    readonly queryKey: readonly ["underlyingAllowance", string, string];
-    readonly queryFn: () => Promise<bigint>;
-    readonly staleTime: 30000;
-};
+declare function useResumeUnshield(config: UseZamaConfig, options?: UseMutationOptions<TransactionResult$1, Error, ResumeUnshieldParams$1, Address$1>): _tanstack_react_query0.UseMutationResult<TransactionResult$1, Error, ResumeUnshieldParams$1, `0x${string}`>;
+//#endregion
+//#region src/token/use-underlying-allowance.d.ts
+/** Configuration for {@link useUnderlyingAllowance}. */
+interface UseUnderlyingAllowanceConfig {
+  /** Address of the confidential token contract used to scope the query cache. */
+  tokenAddress: Address$1;
+  /** Address of the wrapper contract whose underlying ERC-20 allowance is checked. */
+  wrapperAddress: Address$1;
+}
 /**
  * Read the underlying ERC-20 allowance granted to the wrapper contract.
  * Useful to check if an approval is needed before shielding.
@@ -645,12 +1170,12 @@ declare function underlyingAllowanceQueryOptions(token: ReadonlyToken, wrapperAd
  * @example
  * ```tsx
  * const { data: allowance } = useUnderlyingAllowance({
- *   tokenAddress: "0xUnderlying",
+ *   tokenAddress: "0xConfidentialToken",
  *   wrapperAddress: "0xWrapper",
  * });
  * ```
  */
-declare function useUnderlyingAllowance(config: UseUnderlyingAllowanceConfig, options?: Omit<UseQueryOptions<bigint, Error>, "queryKey" | "queryFn">): _tanstack_react_query.UseQueryResult<bigint, Error>;
+declare function useUnderlyingAllowance(config: UseUnderlyingAllowanceConfig, options?: Omit<UseQueryOptions<bigint, Error>, "queryKey" | "queryFn">): _tanstack_react_query0.UseQueryResult<bigint, Error>;
 /**
  * Suspense variant of {@link useUnderlyingAllowance}.
  * Suspends rendering until the allowance is loaded.
@@ -661,107 +1186,28 @@ declare function useUnderlyingAllowance(config: UseUnderlyingAllowanceConfig, op
  * @example
  * ```tsx
  * const { data: allowance } = useUnderlyingAllowanceSuspense({
- *   tokenAddress: "0xUnderlying",
+ *   tokenAddress: "0xConfidentialToken",
  *   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];
-};
+declare function useUnderlyingAllowanceSuspense(config: UseUnderlyingAllowanceConfig): _tanstack_react_query0.UseSuspenseQueryResult<bigint, Error>;
+//#endregion
+//#region src/token/use-wrapper-discovery.d.ts
 /** 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;
+  /** Address of the underlying ERC-20 token. */
+  tokenAddress: Address$1;
+  /** Address of the wrapper coordinator. Pass `undefined` to disable the query. */
+  coordinatorAddress: Address$1 | undefined;
 }
 /** Configuration for {@link useWrapperDiscoverySuspense}. */
 interface UseWrapperDiscoverySuspenseConfig {
-    /** Address of the underlying ERC-20 token. */
-    tokenAddress: Address;
-    /** Address of the wrapper coordinator. */
-    coordinatorAddress: Address;
+  /** Address of the underlying ERC-20 token. */
+  tokenAddress: Address$1;
+  /** Address of the wrapper coordinator. */
+  coordinatorAddress: Address$1;
 }
-/**
- * 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.
@@ -779,7 +1225,7 @@ declare function wrapperDiscoveryQueryOptions(token: ReadonlyToken, coordinatorA
  * });
  * ```
  */
-declare function useWrapperDiscovery(config: UseWrapperDiscoveryConfig, options?: Omit<UseQueryOptions<Address | null, Error>, "queryKey" | "queryFn">): UseQueryResult<Address | null, Error>;
+declare function useWrapperDiscovery(config: UseWrapperDiscoveryConfig, options?: Omit<UseQueryOptions<Address$1 | null, Error>, "queryKey" | "queryFn">): _tanstack_react_query0.UseQueryResult<`0x${string}` | null, Error>;
 /**
  * Suspense variant of {@link useWrapperDiscovery}.
  * Suspends rendering until the wrapper address is resolved.
@@ -795,50 +1241,91 @@ declare function useWrapperDiscovery(config: UseWrapperDiscoveryConfig, options?
  * });
  * ```
  */
-declare function useWrapperDiscoverySuspense(config: UseWrapperDiscoverySuspenseConfig): UseSuspenseQueryResult<Address | null, Error>;
-
+declare function useWrapperDiscoverySuspense(config: UseWrapperDiscoverySuspenseConfig): _tanstack_react_query0.UseSuspenseQueryResult<`0x${string}` | null, Error>;
+//#endregion
+//#region src/token/use-metadata.d.ts
 /**
- * Query key factory for ERC-165 confidential interface checks.
- * Use with `queryClient.invalidateQueries()` / `resetQueries()`.
+ * Read ERC-20 token metadata (name, symbol, decimals).
+ * Fetches all three in parallel. Cached indefinitely since metadata is immutable.
+ *
+ * @param tokenAddress - Address of the token contract.
+ * @param options - React Query options (forwarded to `useQuery`).
+ * @returns Query result with `data: TokenMetadata`.
+ *
+ * @example
+ * ```tsx
+ * const { data: metadata } = useMetadata("0xToken");
+ * // metadata?.name, metadata?.symbol, metadata?.decimals
+ * ```
  */
-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];
-};
+declare function useMetadata(tokenAddress: Address$1, options?: Omit<UseQueryOptions<TokenMetadata, Error>, "queryKey" | "queryFn">): _tanstack_react_query0.UseQueryResult<TokenMetadata, Error>;
 /**
- * Query key factory for ERC-165 wrapper interface checks.
- * Use with `queryClient.invalidateQueries()` / `resetQueries()`.
+ * Suspense variant of {@link useMetadata}.
+ * Suspends rendering until metadata is loaded.
+ *
+ * @param tokenAddress - Address of the token contract.
+ * @returns Suspense query result with `data: TokenMetadata`.
+ *
+ * @example
+ * ```tsx
+ * const { data: metadata } = useMetadataSuspense("0xToken");
+ * ```
  */
-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];
-};
+declare function useMetadataSuspense(tokenAddress: Address$1): _tanstack_react_query0.UseSuspenseQueryResult<TokenMetadata, Error>;
+//#endregion
+//#region src/token/use-activity-feed.d.ts
+/** Configuration for {@link useActivityFeed}. */
+interface UseActivityFeedConfig {
+  /** Address of the confidential token contract. */
+  tokenAddress: Address$1;
+  /** Connected wallet address. Pass `undefined` to disable the query. */
+  userAddress: Address$1 | undefined;
+  /** Raw event logs from the provider (viem, ethers, etc.). Pass `undefined` to disable. */
+  logs: readonly (RawLog$1 & Partial<ActivityLogMetadata$1>)[] | undefined;
+  /** Whether to batch-decrypt encrypted transfer amounts. Default: `true`. */
+  decrypt?: boolean;
+}
 /**
- * TanStack Query options factory for ERC-165 confidential interface check.
+ * Two-phase activity feed hook.
+ * Phase 1: Instantly parses raw logs into classified {@link ActivityItem}s (sync, cheap).
+ * Phase 2: Batch-decrypts encrypted transfer amounts via the relayer (async).
+ *
+ * The wallet provides logs (from its own provider — viem, ethers, etc.)
+ * and this hook normalizes + decrypts them.
+ *
+ * @param config - Token address, user address, raw logs, and decrypt option.
+ * @returns Query result with `data: ActivityItem[]`.
  *
- * @param token - A `ReadonlyToken` instance.
- * @returns Query options with `queryKey`, `queryFn`, and `staleTime`.
+ * @example
+ * ```tsx
+ * const { data: activity } = useActivityFeed({
+ *   tokenAddress: "0xToken",
+ *   userAddress: "0xUser",
+ *   logs: rawLogs,
+ * });
+ * ```
  */
-declare function isConfidentialQueryOptions(token: ReadonlyToken): {
-    readonly queryKey: readonly ["isConfidential", string];
-    readonly queryFn: () => Promise<boolean>;
-    readonly staleTime: number;
-};
+declare function useActivityFeed(config: UseActivityFeedConfig): _tanstack_react_query0.UseQueryResult<ActivityItem$1[], Error>;
+//#endregion
+//#region src/token/use-approve-underlying.d.ts
 /**
- * TanStack Query options factory for ERC-165 wrapper interface check.
+ * Approve the wrapper contract to spend the underlying ERC-20.
+ * Defaults to max uint256. Resets to zero first if there's an existing
+ * non-zero allowance (required by tokens like USDT).
+ *
+ * @param config - Token and wrapper addresses.
+ * @param options - React Query mutation options.
  *
- * @param token - A `ReadonlyToken` instance.
- * @returns Query options with `queryKey`, `queryFn`, and `staleTime`.
+ * @example
+ * ```tsx
+ * const approve = useApproveUnderlying({ tokenAddress: "0x...", wrapperAddress: "0x..." });
+ * approve.mutate({}); // max approval
+ * approve.mutate({ amount: 1000n }); // exact amount
+ * ```
  */
-declare function isWrapperQueryOptions(token: ReadonlyToken): {
-    readonly queryKey: readonly ["isWrapper", string];
-    readonly queryFn: () => Promise<boolean>;
-    readonly staleTime: number;
-};
+declare function useApproveUnderlying(config: UseZamaConfig, options?: UseMutationOptions<TransactionResult$1, Error, ApproveUnderlyingParams$1, Address$1>): _tanstack_react_query0.UseMutationResult<TransactionResult$1, Error, ApproveUnderlyingParams$1, `0x${string}`>;
+//#endregion
+//#region src/token/use-is-confidential.d.ts
 /**
  * Check if a token supports the ERC-7984 confidential interface via ERC-165.
  * Result is cached indefinitely since interface support does not change.
@@ -852,7 +1339,7 @@ declare function isWrapperQueryOptions(token: ReadonlyToken): {
  * const { data: isConfidential } = useIsConfidential("0xToken");
  * ```
  */
-declare function useIsConfidential(tokenAddress: Address, options?: Omit<UseQueryOptions<boolean, Error>, "queryKey" | "queryFn">): UseQueryResult<boolean, Error>;
+declare function useIsConfidential(tokenAddress: Address$1, options?: Omit<UseQueryOptions<boolean, Error>, "queryKey" | "queryFn">): _tanstack_react_query0.UseQueryResult<boolean, Error>;
 /**
  * Suspense variant of {@link useIsConfidential}.
  * Suspends rendering until the ERC-165 check resolves.
@@ -865,7 +1352,7 @@ declare function useIsConfidential(tokenAddress: Address, options?: Omit<UseQuer
  * const { data: isConfidential } = useIsConfidentialSuspense("0xToken");
  * ```
  */
-declare function useIsConfidentialSuspense(tokenAddress: Address): UseSuspenseQueryResult<boolean, Error>;
+declare function useIsConfidentialSuspense(tokenAddress: Address$1): _tanstack_react_query0.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.
@@ -879,7 +1366,7 @@ declare function useIsConfidentialSuspense(tokenAddress: Address): UseSuspenseQu
  * const { data: isWrapper } = useIsWrapper("0xToken");
  * ```
  */
-declare function useIsWrapper(tokenAddress: Address, options?: Omit<UseQueryOptions<boolean, Error>, "queryKey" | "queryFn">): UseQueryResult<boolean, Error>;
+declare function useIsWrapper(tokenAddress: Address$1, options?: Omit<UseQueryOptions<boolean, Error>, "queryKey" | "queryFn">): _tanstack_react_query0.UseQueryResult<boolean, Error>;
 /**
  * Suspense variant of {@link useIsWrapper}.
  * Suspends rendering until the ERC-165 check resolves.
@@ -892,29 +1379,9 @@ declare function useIsWrapper(tokenAddress: Address, options?: Omit<UseQueryOpti
  * 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;
-};
+declare function useIsWrapperSuspense(tokenAddress: Address$1): _tanstack_react_query0.UseSuspenseQueryResult<boolean, Error>;
+//#endregion
+//#region src/token/use-total-supply.d.ts
 /**
  * Read the total supply of a token.
  * Stale after 30 seconds to balance freshness and RPC cost.
@@ -928,7 +1395,7 @@ declare function totalSupplyQueryOptions(token: ReadonlyToken): {
  * const { data: totalSupply } = useTotalSupply("0xToken");
  * ```
  */
-declare function useTotalSupply(tokenAddress: Address, options?: Omit<UseQueryOptions<bigint, Error>, "queryKey" | "queryFn">): UseQueryResult<bigint, Error>;
+declare function useTotalSupply(tokenAddress: Address$1, options?: Omit<UseQueryOptions<bigint, Error>, "queryKey" | "queryFn">): _tanstack_react_query0.UseQueryResult<bigint, Error>;
 /**
  * Suspense variant of {@link useTotalSupply}.
  * Suspends rendering until the total supply is loaded.
@@ -941,81 +1408,20 @@ declare function useTotalSupply(tokenAddress: Address, options?: Omit<UseQueryOp
  * 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];
-};
+declare function useTotalSupplySuspense(tokenAddress: Address$1): _tanstack_react_query0.UseSuspenseQueryResult<bigint, Error>;
+//#endregion
+//#region src/token/use-fees.d.ts
 /** 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;
+  /** Address of the fee manager contract. */
+  feeManagerAddress: Address$1;
+  /** Amount to calculate the fee for. */
+  amount: bigint;
+  /** Sender address. */
+  from: Address$1;
+  /** Receiver address. */
+  to: Address$1;
 }
-/**
- * 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.
  *
@@ -1033,7 +1439,7 @@ declare function feeRecipientQueryOptions(signer: GenericSigner, feeManagerAddre
  * });
  * ```
  */
-declare function useShieldFee(config: UseFeeConfig, options?: Omit<UseQueryOptions<bigint, Error>, "queryKey" | "queryFn">): UseQueryResult<bigint, Error>;
+declare function useShieldFee(config: UseFeeConfig, options?: Omit<UseQueryOptions<bigint, Error>, "queryKey" | "queryFn">): _tanstack_react_query0.UseQueryResult<bigint, Error>;
 /**
  * Read the unshield fee for a given amount and address pair.
  *
@@ -1051,7 +1457,7 @@ declare function useShieldFee(config: UseFeeConfig, options?: Omit<UseQueryOptio
  * });
  * ```
  */
-declare function useUnshieldFee(config: UseFeeConfig, options?: Omit<UseQueryOptions<bigint, Error>, "queryKey" | "queryFn">): UseQueryResult<bigint, Error>;
+declare function useUnshieldFee(config: UseFeeConfig, options?: Omit<UseQueryOptions<bigint, Error>, "queryKey" | "queryFn">): _tanstack_react_query0.UseQueryResult<bigint, Error>;
 /**
  * Read the batch transfer fee from the fee manager.
  *
@@ -1064,7 +1470,7 @@ declare function useUnshieldFee(config: UseFeeConfig, options?: Omit<UseQueryOpt
  * const { data: fee } = useBatchTransferFee("0xFeeManager");
  * ```
  */
-declare function useBatchTransferFee(feeManagerAddress: Address, options?: Omit<UseQueryOptions<bigint, Error>, "queryKey" | "queryFn">): UseQueryResult<bigint, Error>;
+declare function useBatchTransferFee(feeManagerAddress: Address$1, options?: Omit<UseQueryOptions<bigint, Error>, "queryKey" | "queryFn">): _tanstack_react_query0.UseQueryResult<bigint, Error>;
 /**
  * Read the fee recipient address from the fee manager.
  *
@@ -1077,6 +1483,7 @@ declare function useBatchTransferFee(feeManagerAddress: Address, options?: Omit<
  * 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 };
+declare function useFeeRecipient(feeManagerAddress: Address$1, options?: Omit<UseQueryOptions<Address$1, Error>, "queryKey" | "queryFn">): _tanstack_react_query0.UseQueryResult<`0x${string}`, Error>;
+//#endregion
+export { type ActivityAmount, type ActivityDirection, type ActivityItem, type ActivityLogMetadata, type ActivityType, type Address, ApprovalFailedError, type ApproveSubmittedEvent, type ApproveUnderlyingParams, type ApproveUnderlyingSubmittedEvent, BATCH_SWAP_ABI, type BaseEvent, type BatchDecryptOptions, type BatchTransferData, ChromeSessionStorage, type ClearValueType, type ConfidentialApproveParams, type ConfidentialBalancesData, type ConfidentialTransferEvent, type ConfidentialTransferFromParams, type ConfidentialTransferParams, type ContractAbi, type CreateDelegatedUserDecryptEIP712Params, type CreateEIP712Params, type CredentialsAllowedEvent, type CredentialsCachedEvent, type CredentialsCreatedEvent, type CredentialsCreatingEvent, type CredentialsExpiredEvent, type CredentialsLoadingEvent, CredentialsManager, type CredentialsManagerConfig, type CredentialsRevokedEvent, DEPLOYMENT_COORDINATOR_ABI, type DecryptEndEvent, type DecryptErrorEvent, type DecryptHandle, type DecryptStartEvent, DecryptionFailedError, type DelegatedUserDecryptParams, type EIP712TypedData, ENCRYPTION_ABI, ERC165_ABI, ERC20_ABI, ERC20_METADATA_ABI, ERC7984_INTERFACE_ID, ERC7984_WRAPPER_INTERFACE_ID, type EncryptEndEvent, type EncryptErrorEvent, type EncryptInput, type EncryptParams, type EncryptResult, type EncryptStartEvent, EncryptionFailedError, FEE_MANAGER_ABI, type FheTypeName, type FhevmInstanceConfig, type FinalizeUnwrapParams, type FinalizeUnwrapSubmittedEvent, type GenericSigner, type GenericStorage, type Handle, HardhatConfig, type Hex, IndexedDBStorage, type InputProofBytesType, InvalidKeypairError, KeypairExpiredError, type KeypairType, type KmsDelegatedUserDecryptEIP712Type, MainnetConfig, MemoryStorage, type NetworkType, NoCiphertextError, type OnChainEvent, type OptimisticBalanceSnapshot, type OptimisticMutateContext, type PublicDecryptResult, type PublicKeyData, type PublicParamsData, type RawLog, type ReadContractArgs, type ReadContractConfig, type ReadContractReturnType, type ReadFunctionName, ReadonlyToken, type ReadonlyTokenConfig, RelayerRequestFailedError, type RelayerSDK, type RelayerSDKStatus, RelayerWeb, type RelayerWebConfig, type RelayerWebSecurityConfig, type ResumeUnshieldParams, SepoliaConfig, type SessionExpiredEvent, type ShieldCallbacks, type ShieldETHParams, type ShieldParams, type ShieldSubmittedEvent, SigningFailedError, SigningRejectedError, type StoredCredentials, TOKEN_TOPICS, TRANSFER_BATCHER_ABI, Token, type TokenConfig, type TokenMetadata, Topics, type TransactionErrorEvent, type TransactionReceipt, type TransactionResult, TransactionRevertedError, type TransferCallbacks, type TransferFromSubmittedEvent, type TransferSubmittedEvent, type UnshieldAllParams, type UnshieldCallbacks, type UnshieldParams, type UnshieldPhase1SubmittedEvent, type UnshieldPhase2StartedEvent, type UnshieldPhase2SubmittedEvent, type UnwrapParams, type UnwrapRequestedEvent, type UnwrapSubmittedEvent, type UnwrappedFinalizedEvent, type UnwrappedStartedEvent, type UseActivityFeedConfig, type UseConfidentialBalanceConfig, type UseConfidentialBalanceOptions, type UseConfidentialBalancesConfig, type UseConfidentialBalancesOptions, type UseConfidentialIsApprovedConfig, type UseConfidentialIsApprovedSuspenseConfig, type UseConfidentialTransferConfig, type UseFeeConfig, type UseShieldConfig, type UseUnderlyingAllowanceConfig, type UseUserDecryptFlowConfig, type UseWrapperDiscoveryConfig, type UseWrapperDiscoverySuspenseConfig, type UseZamaConfig, type UserDecryptFlowCallbacks, type UserDecryptFlowParams, type UserDecryptParams, WRAPPER_ABI, type WrappedEvent, type WriteContractArgs, type WriteContractConfig, type WriteFunctionName, ZERO_HANDLE, type ZKProofLike, ZamaError, ZamaErrorCode, ZamaProvider, type ZamaProviderProps, ZamaSDK, type ZamaSDKConfig, type ZamaSDKEvent, type ZamaSDKEventInput, type ZamaSDKEventListener, type ZamaSDKEventType, ZamaSDKEvents, activityFeedQueryOptions, allowMutationOptions, allowanceContract, applyDecryptedValues, approveContract, approveUnderlyingMutationOptions, balanceOfContract, batchTransferFeeQueryOptions, chromeSessionStorage, clearPendingUnshield, confidentialApproveMutationOptions, confidentialBalanceOfContract, confidentialBalanceQueryOptions, confidentialBalancesQueryOptions, confidentialBatchTransferContract, confidentialHandleQueryOptions, confidentialHandlesQueryOptions, confidentialIsApprovedQueryOptions, confidentialTotalSupplyContract, confidentialTransferContract, confidentialTransferFromContract, confidentialTransferFromMutationOptions, confidentialTransferMutationOptions, decimalsContract, decodeConfidentialTransfer, decodeOnChainEvent, decodeOnChainEvents, decodeUnwrapRequested, decodeUnwrappedFinalized, decodeUnwrappedStarted, decodeWrapped, decryptionKeys, deploymentCoordinatorContract, encryptMutationOptions, extractEncryptedHandles, feeRecipientQueryOptions, filterQueryOptions, finalizeUnwrapContract, finalizeUnwrapMutationOptions, findUnwrapRequested, findWrapped, getBatchTransferFeeContract, getFeeRecipientContract, getUnwrapFeeContract, getWrapFeeContract, getWrapperContract, hashFn, indexedDBStorage, isAllowedQueryOptions, isConfidentialQueryOptions, isConfidentialTokenContract, isConfidentialWrapperContract, isFinalizeUnwrapOperatorContract, isOperatorContract, isWrapperQueryOptions, loadPendingUnshield, matchZamaError, nameContract, parseActivityFeed, publicKeyQueryOptions, publicParamsQueryOptions, rateContract, resumeUnshieldMutationOptions, revokeMutationOptions, revokeSessionMutationOptions, savePendingUnshield, setFinalizeUnwrapOperatorContract, setOperatorContract, shieldETHMutationOptions, shieldFeeQueryOptions, shieldMutationOptions, signerAddressQueryOptions, sortByBlockNumber, supportsInterfaceContract, symbolContract, tokenMetadataQueryOptions, totalSupplyContract, totalSupplyQueryOptions, underlyingAllowanceQueryOptions, underlyingContract, unshieldAllMutationOptions, unshieldFeeQueryOptions, unshieldMutationOptions, unwrapAllMutationOptions, unwrapContract, unwrapFromBalanceContract, unwrapMutationOptions, useActivityFeed, useAllow, useApproveUnderlying, useBatchTransferFee, useConfidentialApprove, useConfidentialBalance, useConfidentialBalances, useConfidentialIsApproved, useConfidentialIsApprovedSuspense, useConfidentialTransfer, useConfidentialTransferFrom, useCreateDelegatedUserDecryptEIP712, useCreateEIP712, useDelegatedUserDecrypt, useEncrypt, useFeeRecipient, useFinalizeUnwrap, useGenerateKeypair, useIsAllowed, useIsConfidential, useIsConfidentialSuspense, useIsWrapper, useIsWrapperSuspense, useMetadata, useMetadataSuspense, usePublicDecrypt, usePublicKey, usePublicParams, useReadonlyToken, useRequestZKProofVerification, useResumeUnshield, useRevoke, useRevokeSession, useShield, useShieldETH, useShieldFee, useToken, useTotalSupply, useTotalSupplySuspense, useUnderlyingAllowance, useUnderlyingAllowanceSuspense, useUnshield, useUnshieldAll, useUnshieldFee, useUnwrap, useUnwrapAll, useUserDecrypt, useUserDecryptFlow, useUserDecryptedValue, useUserDecryptedValues, useWrapperDiscovery, useWrapperDiscoverySuspense, useZamaSDK, wrapContract, wrapETHContract, wrapperDiscoveryQueryOptions, wrapperExistsContract, zamaQueryKeys };
+//# sourceMappingURL=index.d.ts.map