@zama-fhe/react-sdk 3.0.1 → 3.1.0-alpha.10

package/dist/index.d.ts

@@ -1,86 +1,42 @@
 "use client";
 
-import * as _$_zama_fhe_sdk0 from "@zama-fhe/sdk";
-import { ACL_TOPICS, AclEvent, AclPausedError, ActivityAmount, ActivityDirection, ActivityItem, ActivityItem as ActivityItem$1, ActivityLogMetadata, ActivityLogMetadata as ActivityLogMetadata$1, ActivityType, Address, Address as Address$1, ApprovalFailedError, ApproveSubmittedEvent, ApproveUnderlyingSubmittedEvent, BalanceCheckUnavailableError, BaseEvent, BatchBalancesResult, BatchBalancesResult as BatchBalancesResult$1, BatchDecryptAsOptions, ChromeSessionStorage, ClearValueType, ClearValueType as ClearValueType$1, ConfidentialTransferEvent, ConfigurationError, ContractAbi, CredentialsAllowedEvent, CredentialsCachedEvent, CredentialsCreatedEvent, CredentialsCreatingEvent, CredentialsExpiredEvent, CredentialsLoadingEvent, CredentialsManager, CredentialsManagerConfig, CredentialsRevokedEvent, DecryptEndEvent, DecryptErrorEvent, DecryptStartEvent, DecryptionFailedError, DefaultRegistryAddresses, DelegatedCredentialsManager, DelegatedCredentialsManagerConfig, DelegatedForUserDecryptionEvent, DelegatedStoredCredentials, DelegatedUserDecryptParams, DelegatedUserDecryptParams as DelegatedUserDecryptParams$1, DelegationContractIsSelfError, DelegationCooldownError, DelegationDelegateEqualsContractError, DelegationExpirationTooSoonError, DelegationExpiredError, DelegationExpiryUnchangedError, DelegationNotFoundError, DelegationNotPropagatedError, DelegationSelfNotAllowedError, EIP712TypedData, EIP712TypedData as EIP712TypedData$1, ERC20ReadFailedError, ERC7984_INTERFACE_ID, ERC7984_WRAPPER_INTERFACE_ID, EncryptEndEvent, EncryptErrorEvent, EncryptInput, EncryptParams, EncryptParams as EncryptParams$1, EncryptResult, EncryptResult as EncryptResult$1, EncryptStartEvent, EncryptionFailedError, FheTypeName, FhevmInstanceConfig, FinalizeUnwrapSubmittedEvent, GenericSigner, GenericSigner as GenericSigner$1, GenericStorage, GenericStorage as GenericStorage$1, Handle, HardhatConfig, Hex, IndexedDBStorage, InputProofBytesType, InsufficientConfidentialBalanceError, InsufficientERC20BalanceError, InvalidKeypairError, KeypairExpiredError, KeypairType, KmsDelegatedUserDecryptEIP712Type, ListPairsOptions, MainnetConfig, MemoryStorage, NetworkType, NoCiphertextError, OnChainEvent, PaginatedResult, PaginatedResult as PaginatedResult$1, PublicDecryptResult, PublicDecryptResult as PublicDecryptResult$1, RawLog, RawLog as RawLog$1, ReadContractArgs, ReadContractConfig, ReadContractReturnType, ReadFunctionName, ReadonlyToken, ReadonlyToken as ReadonlyToken$1, RelayerRequestFailedError, RelayerSDK, RelayerSDK as RelayerSDK$1, RelayerSDKStatus, RelayerWeb, RelayerWebConfig, RelayerWebSecurityConfig, RevokedDelegationForUserDecryptionEvent, SepoliaConfig, SessionExpiredEvent, ShieldCallbacks, ShieldSubmittedEvent, SigningFailedError, SigningRejectedError, StoredCredentials, TOKEN_TOPICS, Token, TokenWrapperPair, TokenWrapperPair as TokenWrapperPair$1, TokenWrapperPairWithMetadata, TokenWrapperPairWithMetadata as TokenWrapperPairWithMetadata$1, Topics, TransactionErrorEvent, TransactionReceipt, TransactionResult, TransactionResult as TransactionResult$1, TransactionRevertedError, TransferCallbacks, TransferFromSubmittedEvent, TransferSubmittedEvent, UnshieldCallbacks, UnshieldPhase1SubmittedEvent, UnshieldPhase2StartedEvent, UnshieldPhase2SubmittedEvent, UnwrapRequestedEvent, UnwrapSubmittedEvent, UnwrappedFinalizedEvent, UnwrappedStartedEvent, UserDecryptParams, WrappedEvent, WrappersRegistry, WrappersRegistryConfig, 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, confidentialTotalSupplyContract, confidentialTransferContract, confidentialTransferFromContract, decimalsContract, decodeAclEvent, decodeAclEvents, decodeConfidentialTransfer, decodeDelegatedForUserDecryption, decodeOnChainEvent, decodeOnChainEvents, decodeRevokedDelegationForUserDecryption, decodeUnwrapRequested, decodeUnwrappedFinalized, decodeUnwrappedStarted, decodeWrapped, delegateForUserDecryptionContract, extractEncryptedHandles, finalizeUnwrapContract, findDelegatedForUserDecryption, findRevokedDelegationForUserDecryption, findUnwrapRequested, findWrapped, getDelegationExpiryContract, indexedDBStorage, inferredTotalSupplyContract, isConfidentialTokenContract, isConfidentialWrapperContract, isHandleDelegatedContract, isOperatorContract, isZeroHandle, loadPendingUnshield, matchAclRevert, matchZamaError, memoryStorage, nameContract, parseActivityFeed, rateContract, revokeDelegationContract, savePendingUnshield, setOperatorContract, sortByBlockNumber, supportsInterfaceContract, symbolContract, totalSupplyContract, underlyingContract, unwrapContract, unwrapFromBalanceContract, wrapContract } from "@zama-fhe/sdk";
-import { ApproveUnderlyingParams, ApproveUnderlyingParams as ApproveUnderlyingParams$1, BatchDecryptBalancesAsParams, BatchDecryptBalancesAsParams as BatchDecryptBalancesAsParams$1, ConfidentialApproveParams, ConfidentialApproveParams as ConfidentialApproveParams$1, ConfidentialTransferFromParams, ConfidentialTransferFromParams as ConfidentialTransferFromParams$1, ConfidentialTransferParams, ConfidentialTransferParams as ConfidentialTransferParams$1, CreateDelegatedUserDecryptEIP712Params, CreateEIP712Params, DecryptBalanceAsParams, DecryptBalanceAsParams as DecryptBalanceAsParams$1, DecryptHandle, DecryptResult, DecryptResult as DecryptResult$1, DelegateDecryptionParams, DelegateDecryptionParams as DelegateDecryptionParams$1, DelegationStatusData, DelegationStatusData as DelegationStatusData$1, DelegationStatusQueryConfig, FinalizeUnwrapParams, FinalizeUnwrapParams as FinalizeUnwrapParams$1, ListPairsQueryConfig, ResumeUnshieldParams, ResumeUnshieldParams as ResumeUnshieldParams$1, RevokeDelegationParams, RevokeDelegationParams as RevokeDelegationParams$1, ShieldParams, ShieldParams as ShieldParams$1, TokenMetadata, UnshieldAllParams, UnshieldAllParams as UnshieldAllParams$1, UnshieldParams, UnshieldParams as UnshieldParams$1, UnwrapParams, UnwrapParams as UnwrapParams$1, UserDecryptQueryConfig, UserDecryptQueryConfig as UserDecryptQueryConfig$1, activityFeedQueryOptions, allowMutationOptions, approveUnderlyingMutationOptions, batchDecryptBalancesAsMutationOptions, confidentialApproveMutationOptions, confidentialBalanceQueryOptions, confidentialBalancesQueryOptions, confidentialIsApprovedQueryOptions, confidentialTransferFromMutationOptions, confidentialTransferMutationOptions, createDelegatedUserDecryptEIP712MutationOptions, createEIP712MutationOptions, decryptBalanceAsMutationOptions, delegateDecryptionMutationOptions, delegatedUserDecryptMutationOptions, delegationStatusQueryOptions, encryptMutationOptions, filterQueryOptions, finalizeUnwrapMutationOptions, generateKeypairMutationOptions, hashFn, isAllowedQueryOptions, isConfidentialQueryOptions, isWrapperQueryOptions, listPairsQueryOptions, publicDecryptMutationOptions, publicKeyQueryOptions, publicParamsQueryOptions, requestZKProofVerificationMutationOptions, resumeUnshieldMutationOptions, revokeDelegationMutationOptions, revokeMutationOptions, revokeSessionMutationOptions, shieldMutationOptions, signerAddressQueryOptions, tokenMetadataQueryOptions, totalSupplyQueryOptions, underlyingAllowanceQueryOptions, unshieldAllMutationOptions, unshieldMutationOptions, unwrapAllMutationOptions, unwrapMutationOptions, userDecryptQueryOptions, wrapperDiscoveryQueryOptions, zamaQueryKeys } from "@zama-fhe/sdk/query";
-import * as _$_tanstack_react_query0 from "@tanstack/react-query";
-import { QueryKey, UseMutationOptions, UseMutationResult, UseQueryOptions } from "@tanstack/react-query";
+import { Address, BatchBalancesResult, EncryptParams, EncryptResult, PaginatedResult, Token, TokenWrapperPair, TokenWrapperPairWithMetadata, TransactionResult, WrappedToken, ZamaConfig, ZamaSDK } from "@zama-fhe/sdk";
+import { ApproveUnderlyingParams, BatchDecryptBalancesAsParams, ConfidentialSetOperatorParams, ConfidentialTransferFromParams, ConfidentialTransferParams, DecryptBalanceAsParams, DecryptResult, DelegateDecryptionParams, DelegatedDecryptValuesMutationParams, DelegationStatusData, FinalizeUnwrapParams, ResumeUnshieldParams, RevokeDelegationParams, ShieldParams, TokenMetadata, UnshieldAllParams, UnshieldParams, UnwrapParams } from "@zama-fhe/sdk/query";
+import { UseMutationOptions, UseMutationResult, 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 { EncryptedInput } from "@zama-fhe/sdk/query/user-decrypt";
 
 //#region src/provider.d.ts
 /** Props for {@link ZamaProvider}. */
 interface ZamaProviderProps extends PropsWithChildren {
-  /** 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;
-  /**
-   * Per-chain wrappers registry address overrides, merged on top of built-in defaults.
-   * Use this for custom or local chains (e.g. Hardhat) where no default registry exists.
-   */
-  registryAddresses?: Record<number, Address$1>;
-  /**
-   * How long cached registry results remain valid, in seconds.
-   * Default: `86400` (24 hours).
-   */
-  registryTTL?: number;
-  /** Callback invoked on SDK lifecycle events. */
-  onEvent?: ZamaSDKEventListener$1;
+  /** Configuration object created by {@link createConfig}. */
+  config: ZamaConfig;
 }
 /**
  * Provides a {@link ZamaSDK} instance to all descendant hooks.
  *
  * @example
  * ```tsx
- * <ZamaProvider relayer={relayer} signer={signer} storage={storage}>
+ * <ZamaProvider config={zamaConfig}>
  *   <App />
  * </ZamaProvider>
  * ```
  */
 declare function ZamaProvider({
   children,
-  relayer,
-  signer,
-  storage,
-  sessionStorage,
-  keypairTTL,
-  sessionTTL,
-  registryAddresses,
-  registryTTL,
-  onEvent
-}: ZamaProviderProps): _$react_jsx_runtime0.JSX.Element;
+  config
+}: ZamaProviderProps): import("react").JSX.Element;
 /**
  * Access the {@link ZamaSDK} instance from context.
- * Throws if called outside a {@link ZamaProvider} or when no signer is provided.
+ * Throws if called outside a {@link ZamaProvider}.
  *
  * @example
  * ```tsx
  * const sdk = useZamaSDK();
- * const token = sdk.createReadonlyToken("0x...");
+ * const token = sdk.createToken("0x...");
  * ```
  */
-declare function useZamaSDK(): ZamaSDK$1;
+declare function useZamaSDK(): ZamaSDK;
 //#endregion
 //#region src/relayer/use-encrypt.d.ts
 /**
@@ -98,178 +54,55 @@ declare function useZamaSDK(): ZamaSDK$1;
  * encrypt.mutate({ values: [{ value: 1000n, type: "euint64" }], contractAddress: "0x...", userAddress: "0x..." });
  * ```
  */
-declare function useEncrypt(): _$_tanstack_react_query0.UseMutationResult<EncryptResult$1, Error, EncryptParams$1, unknown>;
+declare function useEncrypt(): import("@tanstack/react-query").UseMutationResult<EncryptResult, Error, EncryptParams, unknown>;
 //#endregion
-//#region src/relayer/use-user-decrypt.d.ts
+//#region src/decrypt/use-user-decrypt.d.ts
 /**
  * React hook for FHE user decryption. Thin wrapper around
- * `userDecryptQueryOptions` with `useQuery` semantics.
+ * `decryptValuesQueryOptions` with `useQuery` semantics.
  */
-declare function useUserDecrypt(config: UserDecryptQueryConfig$1, options?: Omit<UseQueryOptions<DecryptResult$1>, "queryKey" | "queryFn">): _$_tanstack_react_query0.UseQueryResult<DecryptResult$1, Error>;
-/** Return type of {@link useUserDecrypt}. */
-type UseUserDecryptResult = ReturnType<typeof useUserDecrypt>;
+declare function useDecryptValues(encryptedInputs: EncryptedInput[], options?: Omit<UseQueryOptions<DecryptResult>, "queryKey" | "queryFn">): import("@tanstack/react-query").UseQueryResult<Readonly<Record<`0x${string}`, import("@zama-fhe/relayer-sdk/web").ClearValueType>>, Error>;
+/** Return type of {@link useDecryptValues}. */
+type UseDecryptValuesResult = ReturnType<typeof useDecryptValues>;
 //#endregion
-//#region src/relayer/use-public-decrypt.d.ts
+//#region src/decrypt/use-public-decrypt.d.ts
 /**
- * Decrypt FHE ciphertext handles using the network public key (no credential needed).
+ * Decrypt FHE encrypted values using the network public key (no credential needed).
  * On success, results are available via `data.clearValues` and written to the
  * persistent decrypt cache.
  *
- * @returns A mutation whose `mutate` accepts an array of handle strings.
- *
- * @example
- * ```tsx
- * const publicDecrypt = usePublicDecrypt();
- * publicDecrypt.mutate(["0xHandle1", "0xHandle2"]);
- * // publicDecrypt.data?.clearValues => { "0xHandle1": 500n, ... }
- * ```
- */
-declare function usePublicDecrypt(): _$_tanstack_react_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.
- *
- * Errors are {@link ZamaError} subclasses — use `instanceof` to handle specific failures:
- * - {@link RelayerRequestFailedError} — relayer keypair generation request failed
- *
- * @returns A mutation whose `mutate` takes no parameters.
- *
- * @example
- * ```tsx
- * const generateKeypair = useGenerateKeypair();
- * generateKeypair.mutate();
- * // generateKeypair.data?.publicKey, generateKeypair.data?.privateKey
- * ```
- */
-declare function useGenerateKeypair(): _$_tanstack_react_query0.UseMutationResult<_$_zama_fhe_sdk0.KeypairType<`0x${string}`>, Error, void, unknown>;
-//#endregion
-//#region src/relayer/use-create-eip712.d.ts
-/**
- * Create EIP-712 typed data for signing an FHE decrypt credential.
- * The returned typed data is signed by the wallet to authorize decryption.
- *
- * @returns A mutation whose `mutate` accepts {@link CreateEIP712Params}.
- *
- * @example
- * ```tsx
- * const createEIP712 = useCreateEIP712();
- * createEIP712.mutate({
- *   publicKey: keypair.publicKey,
- *   contractAddresses: ["0xToken"],
- *   startTimestamp: Math.floor(Date.now() / 1000),
- * });
- * ```
- */
-declare function useCreateEIP712(): _$_tanstack_react_query0.UseMutationResult<EIP712TypedData$1, Error, CreateEIP712Params, unknown>;
-//#endregion
-//#region src/relayer/use-create-delegated-user-decrypt-eip712.d.ts
-/**
- * Create EIP-712 typed data for a delegated user decrypt credential.
- * Used when one wallet authorizes another to decrypt on its behalf.
- *
- * @returns A mutation whose `mutate` accepts {@link CreateDelegatedUserDecryptEIP712Params}.
- *
- * @example
- * ```tsx
- * const createEIP712 = useCreateDelegatedUserDecryptEIP712();
- * createEIP712.mutate({
- *   publicKey: keypair.publicKey,
- *   contractAddresses: ["0xToken"],
- *   delegatorAddress: "0xDelegator",
- *   startTimestamp: Math.floor(Date.now() / 1000),
- * });
- * ```
- */
-declare function useCreateDelegatedUserDecryptEIP712(): _$_tanstack_react_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.
- *
- * @returns A mutation whose `mutate` accepts {@link DelegatedUserDecryptParams}.
- *
- * @example
- * ```tsx
- * const decrypt = useDelegatedUserDecrypt();
- * decrypt.mutate({ handles: ["0xHandle1"], ...credentials });
- * // decrypt.data => { "0xHandle1": 1000n }
- * ```
- */
-declare function useDelegatedUserDecrypt(): _$_tanstack_react_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.
- *
- * @returns A mutation whose `mutate` accepts a {@link ZKProofLike}.
- *
- * @example
- * ```tsx
- * const verify = useRequestZKProofVerification();
- * verify.mutate(zkProof);
- * // verify.data => Uint8Array (input proof bytes)
- * ```
- */
-declare function useRequestZKProofVerification(): _$_tanstack_react_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;
-}
-/**
- * Fetch the FHE network public key from the relayer.
- * Cached indefinitely since the key does not change during a session.
- *
- * @returns Query result with `data: PublicKeyData | null`.
+ * @returns A mutation whose `mutate` accepts an array of encrypted values.
  *
  * @example
  * ```tsx
- * const { data: publicKey } = usePublicKey();
- * // publicKey?.publicKeyId, publicKey?.publicKey
+ * const decryptPublicValues = useDecryptPublicValues();
+ * decryptPublicValues.mutate(["0xEncryptedValue1", "0xEncryptedValue2"]);
+ * // decryptPublicValues.data?.clearValues => { "0xEncryptedValue1": 500n, ... }
  * ```
  */
-declare function usePublicKey(): _$_tanstack_react_query0.UseQueryResult<PublicKeyData | null, Error>;
+declare function useDecryptPublicValues(): import("@tanstack/react-query").UseMutationResult<Readonly<{
+  clearValues: import("@zama-fhe/relayer-sdk/web").ClearValues;
+  abiEncodedClearValues: `0x${string}`;
+  decryptionProof: `0x${string}`;
+}>, Error, `0x${string}`[], unknown>;
 //#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;
-}
+//#region src/decrypt/use-delegated-decrypt.d.ts
 /**
- * Fetch FHE public parameters for a given bit size from the relayer.
- * Cached indefinitely since parameters do not change during a session.
+ * Decrypt FHE encrypted values using delegated user credentials.
+ * Returns a map of encrypted value → plaintext bigint.
  *
- * @param bits - The FHE bit size to fetch parameters for (e.g. 2048).
- * @returns Query result with `data: PublicParamsData | null`.
+ * @returns A mutation whose `mutate` accepts {@link DelegatedDecryptValuesMutationParams}.
  *
  * @example
  * ```tsx
- * const { data: params } = usePublicParams(2048);
- * // params?.publicParams, params?.publicParamsId
+ * const decrypt = useDelegatedDecryptValues();
+ * decrypt.mutate({ encryptedInputs: [{ encryptedValue: "0xEncryptedValue1", contractAddress: "0x..." }], delegatorAddress: "0x..." });
+ * // decrypt.data => { "0xEncryptedValue1": 1000n }
  * ```
  */
-declare function usePublicParams(bits: number): _$_tanstack_react_query0.UseQueryResult<PublicParamsData | null, Error>;
+declare function useDelegatedDecryptValues(): import("@tanstack/react-query").UseMutationResult<Record<`0x${string}`, import("@zama-fhe/relayer-sdk/web").ClearValueType>, Error, DelegatedDecryptValuesMutationParams, unknown>;
 //#endregion
-//#region src/authorization/use-allow.d.ts
+//#region src/permits/use-grant-permit.d.ts
 /**
  * Sign an EIP-712 message authorizing decryption of confidential handles
  * for a list of contract addresses. This is not token-specific — any
@@ -283,151 +116,150 @@ declare function usePublicParams(bits: number): _$_tanstack_react_query0.UseQuer
  *
  * @example
  * ```tsx
- * const { mutateAsync: allow, isPending } = useAllow();
+ * const { mutateAsync: grantPermit, isPending } = useGrantPermit();
  *
  * // Authorize decryption for any contracts with encrypted state:
  * // confidential tokens, auction contracts, governance contracts, etc.
- * await allow([tokenAddress, auctionAddress, governanceAddress]);
+ * await grantPermit([tokenAddress, auctionAddress, governanceAddress]);
  * ```
  */
-declare function useAllow(options?: UseMutationOptions<void, Error, Address$1[]>): _$_tanstack_react_query0.UseMutationResult<void, Error, `0x${string}`[], unknown>;
+declare function useGrantPermit(options?: UseMutationOptions<void, Error, Address[]>): import("@tanstack/react-query").UseMutationResult<void, Error, `0x${string}`[], unknown>;
 //#endregion
-//#region src/authorization/use-is-allowed.d.ts
-/** Configuration for {@link useIsAllowed}. */
-interface UseIsAllowedConfig {
-  /** Contract addresses to check credentials against (at least one required). */
-  contractAddresses: [Address$1, ...Address$1[]];
+//#region src/permits/use-has-permit.d.ts
+/** Configuration for {@link useHasPermit}. */
+interface UseHasPermitConfig {
+  /** Contract addresses to check credentials against. */
+  contractAddresses: Address[];
 }
 /**
- * Check whether a session signature is cached for the connected wallet
- * and covers the given contract addresses.
- * Returns `true` if decrypt operations can proceed without a wallet prompt.
+ * Check whether stored permits cover the given contract addresses for the
+ * connected signer.
+ *
+ * @param config - Contract addresses to check credentials against. The query is
+ *   disabled while the list is empty or no signer is configured.
+ * @param options - React Query options (forwarded to `useQuery`).
+ * @returns Query result with `data: boolean`.
  *
  * @example
  * ```tsx
- * const { data: allowed } = useIsAllowed({ contractAddresses: ["0xToken"] });
+ * const { data: hasPermit } = useHasPermit({ contractAddresses: ["0xToken"] });
  * ```
  */
-declare function useIsAllowed(config: UseIsAllowedConfig): _$_tanstack_react_query0.UseQueryResult<boolean, Error>;
+declare function useHasPermit(config: UseHasPermitConfig, options?: Omit<UseQueryOptions<boolean>, "queryKey" | "queryFn">): import("@tanstack/react-query").UseQueryResult<boolean, Error>;
 //#endregion
-//#region src/authorization/use-revoke.d.ts
+//#region src/permits/use-revoke-permits.d.ts
 /**
- * Revoke stored FHE decrypt credentials for a list of contract addresses.
- * This is not token-specific — it revokes the EIP-712 authorization for
- * any contract that uses FHE-encrypted values. The next decrypt operation
- * on these contracts will require a fresh wallet signature.
+ * Revoke FHE permits for the current signer.
+ *
+ * - Called with no arguments: every permit is removed across all chains and
+ *   delegators. The keypair survives — use {@link useClearCredentials} to also
+ *   wipe the keypair.
+ * - Called with a contract list: only direct-decrypt permits on the current
+ *   chain whose payload touches a listed address are removed. Delegated
+ *   permits are not touched in this mode.
  *
  * @example
  * ```tsx
- * const { mutate: revoke } = useRevoke();
- *
- * // Revoke for any contracts: tokens, auctions, governance, etc.
- * revoke([tokenAddress, auctionAddress]);
+ * const { mutate: revokePermits } = useRevokePermits();
+ * revokePermits([tokenAddress]); // direct-decrypt scope, current chain
+ * revokePermits();               // every permit, all chains, all delegators
  * ```
  */
-declare function useRevoke(options?: UseMutationOptions<void, Error, Address$1[]>): _$_tanstack_react_query0.UseMutationResult<void, Error, `0x${string}`[], unknown>;
+declare function useRevokePermits(options?: UseMutationOptions<void, Error, Address[] | void>): import("@tanstack/react-query").UseMutationResult<void, Error, void | `0x${string}`[], unknown>;
 //#endregion
-//#region src/authorization/use-revoke-session.d.ts
+//#region src/permits/use-clear-credentials.d.ts
 /**
- * Revoke the session signature for the connected wallet without
- * specifying contract addresses. Useful for wallet disconnect handlers.
+ * Wipe the keypair for the current signer and cascade-delete every permit
+ * (across chains and delegators) referencing it. Useful for "log out"
+ * handlers that should leave no trace.
  *
  * @example
  * ```tsx
- * const { mutate: revokeSession } = useRevokeSession();
- * revokeSession();
+ * const { mutate: clearCredentials } = useClearCredentials();
+ * clearCredentials();
  * ```
  */
-declare function useRevokeSession(options?: UseMutationOptions<void>): _$_tanstack_react_query0.UseMutationResult<void, Error, void, unknown>;
+declare function useClearCredentials(options?: UseMutationOptions<void>): import("@tanstack/react-query").UseMutationResult<void, Error, void, unknown>;
 //#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}.
+ * Get a {@link Token} instance for an ERC-7984 confidential token, memoized by address.
+ * Supports balance queries, transfers, and operator approval.
  *
- * @param config - Token and optional wrapper addresses.
+ * For ERC-7984 wrappers (shield/unshield), use {@link useWrappedToken} instead.
+ *
+ * @param address - The confidential token contract address.
  * @returns A memoized `Token` instance.
  *
  * @example
  * ```tsx
- * const token = useToken({ tokenAddress: "0xToken", wrapperAddress: "0xWrapper" });
+ * const token = useToken("0xToken");
+ * // token.balanceOf(), token.confidentialTransfer(), etc.
  * ```
  */
-declare function useToken(config: UseZamaConfig): _$_zama_fhe_sdk0.Token;
+declare function useToken(address: Address): Token;
 //#endregion
-//#region src/token/use-readonly-token.d.ts
+//#region src/token/use-wrapped-token.d.ts
 /**
- * Get a {@link ReadonlyToken} instance, memoized by address.
- * Supports balance queries, ERC-165 checks, and authorization — no wrapper needed.
- * Reads signer and storage from the nearest {@link ZamaProvider}.
+ * Get a {@link WrappedToken} instance for an ERC-7984 ERC-20 wrapper,
+ * memoized by address. Adds wrapper-specific operations (shield, unshield,
+ * underlying, allowance) on top of the base {@link useToken} API.
  *
- * @param address - Address of the confidential token contract.
- * @returns A memoized `ReadonlyToken` instance.
+ * The address is the wrapper contract address itself — the wrapper IS the
+ * confidential token.
+ *
+ * @param address - The confidential wrapper contract address.
+ * @returns A memoized `WrappedToken` instance.
  *
  * @example
  * ```tsx
- * const token = useReadonlyToken("0xToken");
- * // token.balanceOf(), token.isConfidential(), etc.
+ * const wrapped = useWrappedToken("0xWrapper");
+ * // wrapped.shield(1000n), wrapped.unshield(500n), etc.
  * ```
  */
-declare function useReadonlyToken(address: Address$1): _$_zama_fhe_sdk0.ReadonlyToken;
+declare function useWrappedToken(address: Address): WrappedToken;
 //#endregion
 //#region src/balance/use-confidential-balance.d.ts
-/** Configuration for {@link useConfidentialBalance}. */
 interface UseConfidentialBalanceConfig {
   /** Address of the confidential token contract. */
-  tokenAddress: Address$1;
+  address: Address;
+  /** Account to fetch balance for. The query is disabled while `undefined`. */
+  account: Address | undefined;
 }
-/** Query options for {@link useConfidentialBalance}. */
 interface UseConfidentialBalanceOptions extends Omit<UseQueryOptions<bigint>, "queryKey" | "queryFn" | "enabled"> {
-  /** Whether the query is enabled. Callback form is not supported in composite hooks. */
+  /** Set this to `false` to disable this query from automatically running. */
   enabled?: boolean;
 }
 /**
- * Declarative hook to read the connected wallet's confidential token balance.
- * Calls `token.balanceOf(owner)` which reads the on-chain handle and decrypts
- * via the SDK. Cached values are returned instantly — the relayer is only hit
- * when the handle changes.
- *
- * @param config - Token address configuration.
- * @param options - React Query options forwarded to the balance query.
- * @returns The balance query result.
+ * Hook for fetching a confidential token balance. Reads the on-chain encrypted
+ * value and decrypts via the SDK; cached clear values are returned instantly
+ * and the relayer is only hit when the encrypted value changes.
  *
  * @example
  * ```tsx
- * const { data: balance, isLoading } = useConfidentialBalance({
- *   tokenAddress: "0x...",
+ * const { data: balance } = useConfidentialBalance({
+ *   address: "0xToken",
+ *   account: "0xAccount",
  * });
  * ```
  */
-declare function useConfidentialBalance(config: UseConfidentialBalanceConfig, options?: UseConfidentialBalanceOptions): _$_tanstack_react_query0.UseQueryResult<bigint, Error>;
+declare function useConfidentialBalance(config: UseConfidentialBalanceConfig, options?: UseConfidentialBalanceOptions): import("@tanstack/react-query").UseQueryResult<bigint, Error>;
 //#endregion
 //#region src/balance/use-confidential-balances.d.ts
-/** Configuration for {@link useConfidentialBalances}. */
 interface UseConfidentialBalancesConfig {
-  /** Addresses of the confidential token contracts to batch-query. */
-  tokenAddresses: Address$1[];
+  /** Addresses of the confidential token contracts to batch-query. The query is disabled while empty. */
+  addresses: Address[];
+  /** Account to fetch balances for. The query is disabled while `undefined`. */
+  account: Address | undefined;
 }
-/** Query options for {@link useConfidentialBalances}. */
-interface UseConfidentialBalancesOptions extends Omit<UseQueryOptions<BatchBalancesResult$1>, "queryKey" | "queryFn" | "enabled"> {
-  /** Whether the query is enabled. Callback form is not supported in composite hooks. */
+interface UseConfidentialBalancesOptions extends Omit<UseQueryOptions<BatchBalancesResult>, "queryKey" | "queryFn" | "enabled"> {
+  /** Set this to `false` to disable this query from automatically running. */
   enabled?: boolean;
 }
 /**
- * Declarative hook to read multiple confidential token balances in batch.
- * Calls `ReadonlyToken.batchBalancesOf()` which decrypts each token via the
- * SDK. Cached values are returned instantly — the relayer is only hit for
- * changed handles.
- *
- * Returns partial results when some tokens fail — successful balances are
- * always returned alongside per-token error information.
+ * Hook for fetching multiple confidential token balances in batch. Returns
+ * partial results when some tokens fail — successful balances are available
+ * alongside per-token error information.
  *
  * @param config - Token addresses configuration.
  * @param options - React Query options forwarded to the balance query.
@@ -436,7 +268,8 @@ interface UseConfidentialBalancesOptions extends Omit<UseQueryOptions<BatchBalan
  * @example
  * ```tsx
  * const { data } = useConfidentialBalances({
- *   tokenAddresses: ["0xTokenA", "0xTokenB"],
+ *   addresses: ["0xTokenA", "0xTokenB"],
+ *   account: "0xAccount",
  * });
  * const balance = data?.results.get("0xTokenA");
  * if (data && data.errors.size > 0) {
@@ -444,11 +277,13 @@ interface UseConfidentialBalancesOptions extends Omit<UseQueryOptions<BatchBalan
  * }
  * ```
  */
-declare function useConfidentialBalances(config: UseConfidentialBalancesConfig, options?: UseConfidentialBalancesOptions): _$_tanstack_react_query0.UseQueryResult<BatchBalancesResult$1, Error>;
+declare function useConfidentialBalances(config: UseConfidentialBalancesConfig, options?: UseConfidentialBalancesOptions): import("@tanstack/react-query").UseQueryResult<BatchBalancesResult, Error>;
 //#endregion
 //#region src/transfer/use-confidential-transfer.d.ts
 /** Configuration for {@link useConfidentialTransfer}. */
-interface UseConfidentialTransferConfig extends UseZamaConfig {
+interface UseConfidentialTransferConfig {
+  /** Address of the confidential token contract. */
+  address: Address;
   /**
    * When `true`, optimistically subtracts the transfer amount from cached balance
    * before the transaction confirms. Rolls back on error.
@@ -471,7 +306,7 @@ interface UseConfidentialTransferConfig extends UseZamaConfig {
  * @example
  * ```tsx
  * const transfer = useConfidentialTransfer({
- *   tokenAddress: "0x...",
+ *   address: "0xToken",
  *   optimistic: true,
  * });
  * transfer.mutate(
@@ -486,7 +321,7 @@ interface UseConfidentialTransferConfig extends UseZamaConfig {
  * );
  * ```
  */
-declare function useConfidentialTransfer<TContext = unknown>(config: UseConfidentialTransferConfig, options?: UseMutationOptions<TransactionResult$1, Error, ConfidentialTransferParams$1, TContext>): UseMutationResult<TransactionResult$1, Error, ConfidentialTransferParams$1, TContext>;
+declare function useConfidentialTransfer<TContext = unknown>(config: UseConfidentialTransferConfig, options?: UseMutationOptions<TransactionResult, Error, ConfidentialTransferParams, TContext>): UseMutationResult<TransactionResult, Error, ConfidentialTransferParams, TContext>;
 //#endregion
 //#region src/transfer/use-confidential-transfer-from.d.ts
 /**
@@ -498,18 +333,18 @@ declare function useConfidentialTransfer<TContext = unknown>(config: UseConfiden
  * - {@link EncryptionFailedError} — FHE encryption of the transfer amount failed
  * - {@link TransactionRevertedError} — on-chain transaction reverted
  *
- * @param config - Token address (and optional wrapper) identifying the token.
+ * @param address - Address of the confidential token contract.
  * @param options - React Query mutation options.
  *
  * @example
  * ```tsx
- * const transferFrom = useConfidentialTransferFrom({ tokenAddress: "0x..." });
+ * const transferFrom = useConfidentialTransferFrom("0xToken");
  * 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}`>;
+declare function useConfidentialTransferFrom(address: Address, options?: UseMutationOptions<TransactionResult, Error, ConfidentialTransferFromParams, Address>): import("@tanstack/react-query").UseMutationResult<TransactionResult, Error, ConfidentialTransferFromParams, `0x${string}`>;
 //#endregion
-//#region src/transfer/use-confidential-approve.d.ts
+//#region src/operator/use-confidential-set-operator.d.ts
 /**
  * Set operator approval for a confidential token. Defaults to 1 hour.
  *
@@ -517,72 +352,71 @@ declare function useConfidentialTransferFrom(config: UseZamaConfig, options?: Us
  * - {@link SigningRejectedError} — user rejected the wallet prompt
  * - {@link TransactionRevertedError} — on-chain transaction reverted
  *
- * @param config - Token address (and optional wrapper) identifying the token.
+ * @param address - Address of the confidential token contract.
  * @param options - React Query mutation options.
  *
  * @example
  * ```tsx
- * const approve = useConfidentialApprove({ tokenAddress: "0x..." });
- * approve.mutate({ spender: "0xOperator" });
+ * const setOperator = useConfidentialSetOperator("0xToken");
+ * setOperator.mutate({ operator: "0xOperator" });
  * ```
  */
-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}`>;
+declare function useConfidentialSetOperator(address: Address, options?: UseMutationOptions<TransactionResult, Error, ConfidentialSetOperatorParams, Address>): import("@tanstack/react-query").UseMutationResult<TransactionResult, Error, ConfidentialSetOperatorParams, `0x${string}`>;
 //#endregion
-//#region src/transfer/use-confidential-is-approved.d.ts
-/** Configuration for {@link useConfidentialIsApproved}. */
-interface UseConfidentialIsApprovedConfig {
-  /** Address of the confidential token contract. Pass `undefined` to disable the query. */
-  tokenAddress: Address$1 | 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;
+//#region src/operator/use-confidential-is-operator.d.ts
+interface UseConfidentialIsOperatorConfig {
+  /** Address of the confidential token contract. The query is disabled while `undefined`. */
+  address: Address | undefined;
+  /** Address to check operator status for. The query is disabled while `undefined`. */
+  spender: Address | undefined;
+  /** Token holder address. The query is disabled while `undefined`. */
+  holder: Address | undefined;
 }
-/** Configuration for {@link useConfidentialIsApprovedSuspense}. */
-interface UseConfidentialIsApprovedSuspenseConfig extends UseZamaConfig {
-  /** Address to check approval for. */
-  spender: Address$1;
-  /** Token holder address. Defaults to the connected wallet. */
-  holder?: Address$1;
+interface UseConfidentialIsOperatorSuspenseConfig {
+  /** Address of the confidential token contract. */
+  address: Address;
+  /** Address to check operator status for. */
+  spender: Address;
+  /** Token holder address. */
+  holder: Address;
 }
 /**
- * Check if a spender is an approved operator for a given holder (defaults to connected wallet).
+ * Check if a spender is an approved operator for a holder.
  *
- * @param config - Token address, spender, and optional holder to check.
+ * @param config - Token address, spender, and holder to check.
  * @param options - React Query options (forwarded to `useQuery`).
  * @returns Query result with `data: boolean`.
  *
  * @example
  * ```tsx
- * const { data: isApproved } = useConfidentialIsApproved({
- *   tokenAddress: "0xToken",
+ * const { data: isOperator } = useConfidentialIsOperator({
+ *   address: "0xToken",
  *   spender: "0xSpender",
- *   holder: "0xHolder", // optional
+ *   holder: "0xHolder",
  * });
  * ```
  */
-declare function useConfidentialIsApproved(config: UseConfidentialIsApprovedConfig, options?: Omit<UseQueryOptions<boolean>, "queryKey" | "queryFn">): _$_tanstack_react_query0.UseQueryResult<boolean, Error>;
+declare function useConfidentialIsOperator(config: UseConfidentialIsOperatorConfig, options?: Omit<UseQueryOptions<boolean>, "queryKey" | "queryFn">): import("@tanstack/react-query").UseQueryResult<boolean, Error>;
 /**
- * Suspense variant of {@link useConfidentialIsApproved}.
- * Suspends rendering until the approval check resolves.
- *
- * @param config - Token address, spender, and optional holder to check.
- * @returns Suspense query result with `data: boolean`.
+ * Suspense variant of {@link useConfidentialIsOperator}. Suspends rendering
+ * until the operator check resolves.
  *
  * @example
  * ```tsx
- * const { data: isApproved } = useConfidentialIsApprovedSuspense({
- *   tokenAddress: "0xToken",
+ * const { data: isOperator } = useConfidentialIsOperatorSuspense({
+ *   address: "0xToken",
  *   spender: "0xSpender",
- *   holder: "0xHolder", // optional
+ *   holder: "0xHolder",
  * });
  * ```
  */
-declare function useConfidentialIsApprovedSuspense(config: UseConfidentialIsApprovedSuspenseConfig): _$_tanstack_react_query0.UseSuspenseQueryResult<boolean, Error>;
+declare function useConfidentialIsOperatorSuspense(config: UseConfidentialIsOperatorSuspenseConfig): import("@tanstack/react-query").UseSuspenseQueryResult<boolean, Error>;
 //#endregion
 //#region src/shield/use-shield.d.ts
 /** Configuration for {@link useShield}. */
-interface UseShieldConfig extends UseZamaConfig {
+interface UseShieldConfig {
+  /** Address of the confidential wrapper contract. */
+  address: Address;
   /**
    * When `true`, optimistically adds the wrap amount to the cached confidential balance
    * before the transaction confirms. Rolls back on error.
@@ -596,20 +430,18 @@ interface UseShieldConfig extends UseZamaConfig {
  *
  * Errors are {@link ZamaError} subclasses — use `instanceof` to handle specific failures:
  * - {@link SigningRejectedError} — user rejected the wallet prompt
- * - {@link ApprovalFailedError} — ERC-20 approval transaction failed
- * - {@link TransactionRevertedError} — shield transaction reverted
+ * - {@link TransactionRevertedError} — approval or shield transaction reverted
  *
- * @param config - Token and wrapper addresses.
- *   Set `optimistic: true` to add the amount to the cached balance immediately.
+ * @param config - Wrapper address (and optional `optimistic` flag).
  * @param options - React Query mutation options.
  *
  * @example
  * ```tsx
- * const shield = useShield({ tokenAddress: "0x...", wrapperAddress: "0x...", optimistic: true });
+ * const shield = useShield({ address: "0xWrapper", optimistic: true });
  * shield.mutate({ amount: 1000n });
  * ```
  */
-declare function useShield<TContext = unknown>(config: UseShieldConfig, options?: UseMutationOptions<TransactionResult$1, Error, ShieldParams$1, TContext>): UseMutationResult<TransactionResult$1, Error, ShieldParams$1, TContext>;
+declare function useShield<TContext = unknown>(config: UseShieldConfig, options?: UseMutationOptions<TransactionResult, Error, ShieldParams, TContext>): UseMutationResult<TransactionResult, Error, ShieldParams, TContext>;
 //#endregion
 //#region src/unwrap/use-unwrap.d.ts
 /**
@@ -622,16 +454,16 @@ declare function useShield<TContext = unknown>(config: UseShieldConfig, options?
  * - {@link EncryptionFailedError} — FHE encryption of the unwrap amount failed
  * - {@link TransactionRevertedError} — on-chain transaction reverted
  *
- * @param config - Token address (and optional wrapper) identifying the token.
+ * @param address - Address of the confidential wrapper contract.
  * @param options - React Query mutation options.
  *
  * @example
  * ```tsx
- * const unwrap = useUnwrap({ tokenAddress: "0x..." });
+ * const unwrap = useUnwrap("0xWrapper");
  * unwrap.mutate({ amount: 500n });
  * ```
  */
-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}`>;
+declare function useUnwrap(address: Address, options?: UseMutationOptions<TransactionResult, Error, UnwrapParams, Address>): import("@tanstack/react-query").UseMutationResult<TransactionResult, Error, UnwrapParams, `0x${string}`>;
 //#endregion
 //#region src/unwrap/use-unwrap-all.d.ts
 /**
@@ -643,16 +475,16 @@ declare function useUnwrap(config: UseZamaConfig, options?: UseMutationOptions<T
  * - {@link SigningRejectedError} — user rejected the wallet prompt
  * - {@link TransactionRevertedError} — on-chain transaction reverted
  *
- * @param config - Token address (and optional wrapper) identifying the token.
+ * @param address - Address of the confidential wrapper contract.
  * @param options - React Query mutation options.
  *
  * @example
  * ```tsx
- * const unwrapAll = useUnwrapAll({ tokenAddress: "0x..." });
+ * const unwrapAll = useUnwrapAll("0xWrapper");
  * unwrapAll.mutate();
  * ```
  */
-declare function useUnwrapAll(config: UseZamaConfig, options?: UseMutationOptions<TransactionResult$1, Error, void, Address$1>): _$_tanstack_react_query0.UseMutationResult<TransactionResult$1, Error, void, `0x${string}`>;
+declare function useUnwrapAll(address: Address, options?: UseMutationOptions<TransactionResult, Error, void, Address>): import("@tanstack/react-query").UseMutationResult<TransactionResult, Error, void, `0x${string}`>;
 //#endregion
 //#region src/unwrap/use-finalize-unwrap.d.ts
 /**
@@ -664,16 +496,18 @@ declare function useUnwrapAll(config: UseZamaConfig, options?: UseMutationOption
  * - {@link DecryptionFailedError} — public decryption of the burn amount failed
  * - {@link TransactionRevertedError} — on-chain finalize transaction reverted
  *
- * @param config - Token address (and optional wrapper) identifying the token.
+ * @param address - Address of the confidential wrapper contract.
  * @param options - React Query mutation options.
  *
  * @example
  * ```tsx
- * const finalize = useFinalizeUnwrap({ tokenAddress: "0x..." });
- * finalize.mutate({ burnAmountHandle: event.encryptedAmount });
+ * const finalize = useFinalizeUnwrap("0xWrapper");
+ * const event = findUnwrapRequested(receipt.logs);
+ * if (!event?.unwrapRequestId) throw new Error("UnwrapRequested event missing");
+ * finalize.mutate({ unwrapRequestId: event.unwrapRequestId });
  * ```
  */
-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}`>;
+declare function useFinalizeUnwrap(address: Address, options?: UseMutationOptions<TransactionResult, Error, FinalizeUnwrapParams, Address>): import("@tanstack/react-query").UseMutationResult<TransactionResult, Error, FinalizeUnwrapParams, `0x${string}`>;
 //#endregion
 //#region src/unshield/use-unshield.d.ts
 /**
@@ -686,16 +520,16 @@ declare function useFinalizeUnwrap(config: UseZamaConfig, options?: UseMutationO
  * - {@link DecryptionFailedError} — public decryption failed during finalize
  * - {@link TransactionRevertedError} — on-chain transaction reverted
  *
- * @param config - Token and wrapper addresses.
+ * @param address - Address of the confidential wrapper contract.
  * @param options - React Query mutation options.
  *
  * @example
  * ```tsx
- * const unshield = useUnshield({ tokenAddress: "0x...", wrapperAddress: "0x..." });
+ * const unshield = useUnshield("0xWrapper");
  * unshield.mutate({ amount: 500n });
  * ```
  */
-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}`>;
+declare function useUnshield(address: Address, options?: UseMutationOptions<TransactionResult, Error, UnshieldParams, Address>): import("@tanstack/react-query").UseMutationResult<TransactionResult, Error, UnshieldParams, `0x${string}`>;
 //#endregion
 //#region src/unshield/use-unshield-all.d.ts
 /**
@@ -707,16 +541,16 @@ declare function useUnshield(config: UseZamaConfig, options?: UseMutationOptions
  * - {@link DecryptionFailedError} — public decryption failed during finalize
  * - {@link TransactionRevertedError} — on-chain transaction reverted
  *
- * @param config - Token and wrapper addresses.
+ * @param address - Address of the confidential wrapper contract.
  * @param options - React Query mutation options.
  *
  * @example
  * ```tsx
- * const unshieldAll = useUnshieldAll({ tokenAddress: "0x...", wrapperAddress: "0x..." });
+ * const unshieldAll = useUnshieldAll("0xWrapper");
  * 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}`>;
+declare function useUnshieldAll(address: Address, options?: UseMutationOptions<TransactionResult, Error, UnshieldAllParams | void, Address>): import("@tanstack/react-query").UseMutationResult<TransactionResult, Error, void | UnshieldAllParams, `0x${string}`>;
 //#endregion
 //#region src/unshield/use-resume-unshield.d.ts
 /**
@@ -728,58 +562,56 @@ declare function useUnshieldAll(config: UseZamaConfig, options?: UseMutationOpti
  * - {@link DecryptionFailedError} — public decryption failed during finalize
  * - {@link TransactionRevertedError} — on-chain transaction reverted
  *
- * @param config - Token and wrapper addresses.
+ * @param address - Address of the confidential wrapper contract.
  * @param options - React Query mutation options.
  *
  * @example
  * ```tsx
- * const resumeUnshield = useResumeUnshield({ tokenAddress: "0x...", wrapperAddress: "0x..." });
+ * const resumeUnshield = useResumeUnshield("0xWrapper");
  * resumeUnshield.mutate({ unwrapTxHash: "0xabc..." });
  * ```
  */
-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}`>;
+declare function useResumeUnshield(address: Address, options?: UseMutationOptions<TransactionResult, Error, ResumeUnshieldParams, Address>): import("@tanstack/react-query").UseMutationResult<TransactionResult, Error, ResumeUnshieldParams, `0x${string}`>;
 //#endregion
 //#region src/shield/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;
+  /** Address of the confidential wrapper contract. */
+  address: Address;
+  /** Owner to fetch allowance for. The query is disabled while `undefined`. */
+  owner: Address | undefined;
+}
+interface UseUnderlyingAllowanceSuspenseConfig {
+  /** Address of the confidential wrapper contract. */
+  address: Address;
+  /** Owner to fetch allowance for. */
+  owner: Address;
 }
 /**
- * Read the underlying ERC-20 allowance granted to the wrapper contract.
- * Useful to check if an approval is needed before shielding.
- *
- * @param config - Token and wrapper addresses.
- * @param options - React Query options (forwarded to `useQuery`).
- * @returns Query result with `data: bigint` (current allowance).
+ * Hook for fetching the underlying ERC-20 allowance granted to the wrapper
+ * contract. Useful to check if an approval is needed before shielding.
  *
  * @example
  * ```tsx
  * const { data: allowance } = useUnderlyingAllowance({
- *   tokenAddress: "0xConfidentialToken",
- *   wrapperAddress: "0xWrapper",
+ *   address: "0xWrapper",
+ *   owner: "0xOwner",
  * });
  * ```
  */
-declare function useUnderlyingAllowance(config: UseUnderlyingAllowanceConfig, options?: Omit<UseQueryOptions<bigint>, "queryKey" | "queryFn">): _$_tanstack_react_query0.UseQueryResult<bigint, Error>;
+declare function useUnderlyingAllowance(config: UseUnderlyingAllowanceConfig, options?: Omit<UseQueryOptions<bigint>, "queryKey" | "queryFn">): import("@tanstack/react-query").UseQueryResult<bigint, Error>;
 /**
- * Suspense variant of {@link useUnderlyingAllowance}.
- * Suspends rendering until the allowance is loaded.
- *
- * @param config - Token and wrapper addresses.
- * @returns Suspense query result with `data: bigint`.
+ * Suspense variant of {@link useUnderlyingAllowance}. Suspends rendering until
+ * the allowance resolves.
  *
  * @example
  * ```tsx
  * const { data: allowance } = useUnderlyingAllowanceSuspense({
- *   tokenAddress: "0xConfidentialToken",
- *   wrapperAddress: "0xWrapper",
+ *   address: "0xWrapper",
+ *   owner: "0xOwner",
  * });
  * ```
  */
-declare function useUnderlyingAllowanceSuspense(config: UseUnderlyingAllowanceConfig): _$_tanstack_react_query0.UseSuspenseQueryResult<bigint, Error>;
+declare function useUnderlyingAllowanceSuspense(config: UseUnderlyingAllowanceSuspenseConfig): import("@tanstack/react-query").UseSuspenseQueryResult<bigint, Error>;
 //#endregion
 //#region src/token/use-wrapper-discovery.d.ts
 /** Configuration for {@link useWrapperDiscovery}. */
@@ -789,9 +621,9 @@ interface UseWrapperDiscoveryConfig {
    * Used only to derive the signer context and to scope the query cache key —
    * it does not affect which wrapper the registry returns.
    */
-  tokenAddress: Address$1;
+  tokenAddress: Address;
   /** ERC-20 address to discover the wrapper for. Pass `undefined` to disable the query. */
-  erc20Address: Address$1 | undefined;
+  erc20Address: Address | undefined;
 }
 /** Configuration for {@link useWrapperDiscoverySuspense}. */
 interface UseWrapperDiscoverySuspenseConfig {
@@ -800,9 +632,9 @@ interface UseWrapperDiscoverySuspenseConfig {
    * Used only to derive the signer context and to scope the query cache key —
    * it does not affect which wrapper the registry returns.
    */
-  tokenAddress: Address$1;
+  tokenAddress: Address;
   /** ERC-20 address to discover the wrapper for. */
-  erc20Address: Address$1;
+  erc20Address: Address;
 }
 /**
  * Discover the confidential wrapper for an ERC-20 token via the on-chain registry.
@@ -821,7 +653,7 @@ interface UseWrapperDiscoverySuspenseConfig {
  * });
  * ```
  */
-declare function useWrapperDiscovery(config: UseWrapperDiscoveryConfig, options?: Omit<UseQueryOptions<Address$1 | null>, "queryKey" | "queryFn">): _$_tanstack_react_query0.UseQueryResult<`0x${string}` | null, Error>;
+declare function useWrapperDiscovery(config: UseWrapperDiscoveryConfig, options?: Omit<UseQueryOptions<Address | null>, "queryKey" | "queryFn">): import("@tanstack/react-query").UseQueryResult<`0x${string}` | null, Error>;
 /**
  * Suspense variant of {@link useWrapperDiscovery}.
  * Suspends rendering until the wrapper address is resolved.
@@ -837,7 +669,7 @@ declare function useWrapperDiscovery(config: UseWrapperDiscoveryConfig, options?
  * });
  * ```
  */
-declare function useWrapperDiscoverySuspense(config: UseWrapperDiscoverySuspenseConfig): _$_tanstack_react_query0.UseSuspenseQueryResult<`0x${string}` | null, Error>;
+declare function useWrapperDiscoverySuspense(config: UseWrapperDiscoverySuspenseConfig): import("@tanstack/react-query").UseSuspenseQueryResult<`0x${string}` | null, Error>;
 //#endregion
 //#region src/token/use-metadata.d.ts
 /**
@@ -854,7 +686,7 @@ declare function useWrapperDiscoverySuspense(config: UseWrapperDiscoverySuspense
  * // metadata?.name, metadata?.symbol, metadata?.decimals
  * ```
  */
-declare function useMetadata(tokenAddress: Address$1, options?: Omit<UseQueryOptions<TokenMetadata>, "queryKey" | "queryFn">): _$_tanstack_react_query0.UseQueryResult<TokenMetadata, Error>;
+declare function useMetadata(tokenAddress: Address, options?: Omit<UseQueryOptions<TokenMetadata>, "queryKey" | "queryFn">): import("@tanstack/react-query").UseQueryResult<TokenMetadata, Error>;
 /**
  * Suspense variant of {@link useMetadata}.
  * Suspends rendering until metadata is loaded.
@@ -867,105 +699,72 @@ declare function useMetadata(tokenAddress: Address$1, options?: Omit<UseQueryOpt
  * const { data: metadata } = useMetadataSuspense("0xToken");
  * ```
  */
-declare function useMetadataSuspense(tokenAddress: Address$1): _$_tanstack_react_query0.UseSuspenseQueryResult<TokenMetadata, Error>;
-//#endregion
-//#region src/balance/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;
-}
-/**
- * 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[]`.
- *
- * @example
- * ```tsx
- * const { data: activity } = useActivityFeed({
- *   tokenAddress: "0xToken",
- *   userAddress: "0xUser",
- *   logs: rawLogs,
- * });
- * ```
- */
-declare function useActivityFeed(config: UseActivityFeedConfig): _$_tanstack_react_query0.UseQueryResult<ActivityItem$1[], Error>;
+declare function useMetadataSuspense(tokenAddress: Address): import("@tanstack/react-query").UseSuspenseQueryResult<TokenMetadata, Error>;
 //#endregion
-//#region src/delegation/use-delegate-decryption.d.ts
+//#region src/delegations/use-delegate-decryption.d.ts
 /**
- * Delegate FHE decryption rights for a token to another address via the on-chain ACL.
+ * Delegate FHE decryption rights for a confidential contract to another address
+ * via the on-chain ACL.
  *
- * @param config - Token address identifying the confidential token.
+ * @param address - Confidential contract address to delegate on.
  * @param options - React Query mutation options.
  *
  * @example
  * ```tsx
- * const delegate = useDelegateDecryption({ tokenAddress: "0x..." });
+ * const delegate = useDelegateDecryption("0xToken");
  * delegate.mutate({ delegateAddress: "0xDelegate" });
  * ```
  */
-declare function useDelegateDecryption(config: UseZamaConfig, options?: UseMutationOptions<TransactionResult$1, Error, DelegateDecryptionParams$1>): _$_tanstack_react_query0.UseMutationResult<TransactionResult$1, Error, DelegateDecryptionParams$1, unknown>;
+declare function useDelegateDecryption(address: Address, options?: UseMutationOptions<TransactionResult, Error, DelegateDecryptionParams>): import("@tanstack/react-query").UseMutationResult<TransactionResult, Error, DelegateDecryptionParams, unknown>;
 //#endregion
-//#region src/delegation/use-revoke-delegation.d.ts
+//#region src/delegations/use-revoke-delegation.d.ts
 /**
- * Revoke FHE decryption delegation for a token from a delegate address.
+ * Revoke FHE decryption delegation for a confidential contract from a delegate address.
  *
- * @param config - Token address identifying the confidential token.
+ * @param address - Confidential contract address to revoke delegation on.
  * @param options - React Query mutation options.
  *
  * @example
  * ```tsx
- * const revoke = useRevokeDelegation({ tokenAddress: "0x..." });
+ * const revoke = useRevokeDelegation("0xToken");
  * revoke.mutate({ delegateAddress: "0xDelegate" });
  * ```
  */
-declare function useRevokeDelegation(config: UseZamaConfig, options?: UseMutationOptions<TransactionResult$1, Error, RevokeDelegationParams$1>): _$_tanstack_react_query0.UseMutationResult<TransactionResult$1, Error, RevokeDelegationParams$1, unknown>;
+declare function useRevokeDelegation(address: Address, options?: UseMutationOptions<TransactionResult, Error, RevokeDelegationParams>): import("@tanstack/react-query").UseMutationResult<TransactionResult, Error, RevokeDelegationParams, unknown>;
 //#endregion
-//#region src/delegation/use-delegation-status.d.ts
+//#region src/delegations/use-delegation-status.d.ts
 interface UseDelegationStatusConfig {
-  /** Address of the confidential token contract. Pass `undefined` to disable the query. */
-  tokenAddress: Address$1 | undefined;
+  /** Address of the confidential contract. Pass `undefined` to disable the query. */
+  contractAddress: Address | undefined;
   /** The address that granted the delegation. */
-  delegatorAddress?: Address$1;
+  delegatorAddress?: Address;
   /** The address that received delegation rights. */
-  delegateAddress?: Address$1;
+  delegateAddress?: Address;
 }
 /**
  * Query delegation status between a delegator and delegate for a token.
  *
  * @param config - Token address, delegator, and delegate addresses.
  * @param options - React Query options (forwarded to `useQuery`).
- * @returns `{ isDelegated, expiryTimestamp, isLoading, error }`.
+ * @returns `{ isActive, expiryTimestamp, isLoading, error }`.
  *
  * @example
  * ```tsx
  * const { data } = useDelegationStatus({
- *   tokenAddress: "0xToken",
+ *   contractAddress: "0xToken",
  *   delegatorAddress: "0xDelegator",
  *   delegateAddress: "0xDelegate",
  * });
- * // data?.isDelegated, data?.expiryTimestamp
+ * // data?.isActive, data?.expiryTimestamp
  * ```
  */
-declare function useDelegationStatus(config: UseDelegationStatusConfig, options?: Omit<UseQueryOptions<DelegationStatusData$1>, "queryKey" | "queryFn">): _$_tanstack_react_query0.UseQueryResult<DelegationStatusData$1, Error>;
+declare function useDelegationStatus(config: UseDelegationStatusConfig, options?: Omit<UseQueryOptions<DelegationStatusData>, "queryKey" | "queryFn">): import("@tanstack/react-query").UseQueryResult<DelegationStatusData, Error>;
 //#endregion
-//#region src/delegation/use-decrypt-balance-as.d.ts
+//#region src/delegations/use-decrypt-balance-as.d.ts
 /**
  * Decrypt another user's confidential balance as a delegate.
  *
- * @param tokenAddress - Address of the confidential token contract.
+ * @param address - Address of the confidential token contract.
  * @param options - React Query mutation options.
  *
  * @example
@@ -975,13 +774,13 @@ declare function useDelegationStatus(config: UseDelegationStatusConfig, options?
  * // decryptAs.data => 1000n
  * ```
  */
-declare function useDecryptBalanceAs(tokenAddress: Address$1, options?: UseMutationOptions<bigint, Error, DecryptBalanceAsParams$1>): _$_tanstack_react_query0.UseMutationResult<bigint, Error, DecryptBalanceAsParams$1, unknown>;
+declare function useDecryptBalanceAs(address: Address, options?: UseMutationOptions<bigint, Error, DecryptBalanceAsParams>): import("@tanstack/react-query").UseMutationResult<bigint, Error, DecryptBalanceAsParams, unknown>;
 //#endregion
-//#region src/delegation/use-batch-decrypt-balances-as.d.ts
+//#region src/delegations/use-batch-decrypt-balances-as.d.ts
 /**
  * Batch decrypt confidential balances as a delegate across multiple tokens.
  *
- * @param tokens - ReadonlyToken instances to decrypt balances for.
+ * @param tokens - {@link Token} instances to decrypt balances for.
  * @param options - React Query mutation options.
  *
  * @example
@@ -993,7 +792,7 @@ declare function useDecryptBalanceAs(tokenAddress: Address$1, options?: UseMutat
  * // batchDecryptAs.data => Map { "0xTokenA" => 100n, "0xTokenB" => 200n }
  * ```
  */
-declare function useBatchDecryptBalancesAs(tokens: ReadonlyToken$1[], options?: UseMutationOptions<Map<Address$1, bigint>, Error, BatchDecryptBalancesAsParams$1>): _$_tanstack_react_query0.UseMutationResult<Map<`0x${string}`, bigint>, Error, _$_zama_fhe_sdk0.BatchDecryptAsOptions, unknown>;
+declare function useBatchDecryptBalancesAs(tokens: Token[], options?: UseMutationOptions<Map<Address, bigint>, Error, BatchDecryptBalancesAsParams>): import("@tanstack/react-query").UseMutationResult<Map<`0x${string}`, bigint>, Error, import("@zama-fhe/sdk").BatchDecryptAsOptions, unknown>;
 //#endregion
 //#region src/shield/use-approve-underlying.d.ts
 /**
@@ -1005,17 +804,17 @@ declare function useBatchDecryptBalancesAs(tokens: ReadonlyToken$1[], options?:
  * - {@link SigningRejectedError} — user rejected the wallet prompt
  * - {@link TransactionRevertedError} — approval transaction reverted
  *
- * @param config - Token and wrapper addresses.
+ * @param address - Address of the confidential wrapper contract.
  * @param options - React Query mutation options.
  *
  * @example
  * ```tsx
- * const approve = useApproveUnderlying({ tokenAddress: "0x...", wrapperAddress: "0x..." });
+ * const approve = useApproveUnderlying("0xWrapper");
  * approve.mutate({}); // max approval
  * approve.mutate({ amount: 1000n }); // exact amount
  * ```
  */
-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}`>;
+declare function useApproveUnderlying(address: Address, options?: UseMutationOptions<TransactionResult, Error, ApproveUnderlyingParams, Address>): import("@tanstack/react-query").UseMutationResult<TransactionResult, Error, ApproveUnderlyingParams, `0x${string}`>;
 //#endregion
 //#region src/token/use-is-confidential.d.ts
 /**
@@ -1031,7 +830,7 @@ declare function useApproveUnderlying(config: UseZamaConfig, options?: UseMutati
  * const { data: isConfidential } = useIsConfidential("0xToken");
  * ```
  */
-declare function useIsConfidential(tokenAddress: Address$1, options?: Omit<UseQueryOptions<boolean>, "queryKey" | "queryFn">): _$_tanstack_react_query0.UseQueryResult<boolean, Error>;
+declare function useIsConfidential(tokenAddress: Address, options?: Omit<UseQueryOptions<boolean>, "queryKey" | "queryFn">): import("@tanstack/react-query").UseQueryResult<boolean, Error>;
 /**
  * Suspense variant of {@link useIsConfidential}.
  * Suspends rendering until the ERC-165 check resolves.
@@ -1044,7 +843,7 @@ declare function useIsConfidential(tokenAddress: Address$1, options?: Omit<UseQu
  * const { data: isConfidential } = useIsConfidentialSuspense("0xToken");
  * ```
  */
-declare function useIsConfidentialSuspense(tokenAddress: Address$1): _$_tanstack_react_query0.UseSuspenseQueryResult<boolean, Error>;
+declare function useIsConfidentialSuspense(tokenAddress: Address): import("@tanstack/react-query").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.
@@ -1058,7 +857,7 @@ declare function useIsConfidentialSuspense(tokenAddress: Address$1): _$_tanstack
  * const { data: isWrapper } = useIsWrapper("0xToken");
  * ```
  */
-declare function useIsWrapper(tokenAddress: Address$1, options?: Omit<UseQueryOptions<boolean>, "queryKey" | "queryFn">): _$_tanstack_react_query0.UseQueryResult<boolean, Error>;
+declare function useIsWrapper(tokenAddress: Address, options?: Omit<UseQueryOptions<boolean>, "queryKey" | "queryFn">): import("@tanstack/react-query").UseQueryResult<boolean, Error>;
 /**
  * Suspense variant of {@link useIsWrapper}.
  * Suspends rendering until the ERC-165 check resolves.
@@ -1071,7 +870,7 @@ declare function useIsWrapper(tokenAddress: Address$1, options?: Omit<UseQueryOp
  * const { data: isWrapper } = useIsWrapperSuspense("0xToken");
  * ```
  */
-declare function useIsWrapperSuspense(tokenAddress: Address$1): _$_tanstack_react_query0.UseSuspenseQueryResult<boolean, Error>;
+declare function useIsWrapperSuspense(tokenAddress: Address): import("@tanstack/react-query").UseSuspenseQueryResult<boolean, Error>;
 //#endregion
 //#region src/token/use-total-supply.d.ts
 /**
@@ -1087,7 +886,7 @@ declare function useIsWrapperSuspense(tokenAddress: Address$1): _$_tanstack_reac
  * const { data: totalSupply } = useTotalSupply("0xToken");
  * ```
  */
-declare function useTotalSupply(tokenAddress: Address$1, options?: Omit<UseQueryOptions<bigint>, "queryKey" | "queryFn">): _$_tanstack_react_query0.UseQueryResult<bigint, Error>;
+declare function useTotalSupply(tokenAddress: Address, options?: Omit<UseQueryOptions<bigint>, "queryKey" | "queryFn">): import("@tanstack/react-query").UseQueryResult<bigint, Error>;
 /**
  * Suspense variant of {@link useTotalSupply}.
  * Suspends rendering until the total supply is loaded.
@@ -1100,13 +899,12 @@ declare function useTotalSupply(tokenAddress: Address$1, options?: Omit<UseQuery
  * const { data: totalSupply } = useTotalSupplySuspense("0xToken");
  * ```
  */
-declare function useTotalSupplySuspense(tokenAddress: Address$1): _$_tanstack_react_query0.UseSuspenseQueryResult<bigint, Error>;
+declare function useTotalSupplySuspense(tokenAddress: Address): import("@tanstack/react-query").UseSuspenseQueryResult<bigint, Error>;
 //#endregion
 //#region src/wrappers-registry/use-wrappers-registry-address.d.ts
 /**
  * Resolves the wrappers registry address for the current chain.
- * Uses the merged registry addresses from `sdk.registry` (built-in defaults
- * plus any `registryAddresses` overrides passed to `ZamaSDKConfig`).
+ * Uses the registry addresses from `sdk.registry` (built-in defaults from chain configs).
  *
  * Returns `undefined` when the chain ID hasn't been fetched yet
  * or when no registry is configured for the connected chain.
@@ -1114,20 +912,20 @@ declare function useTotalSupplySuspense(tokenAddress: Address$1): _$_tanstack_re
  * The chain ID is cached for 30 seconds (`staleTime`), so chain
  * switches may take up to 30s to reflect.
  */
-declare function useWrappersRegistryAddress(): Address$1 | undefined;
+declare function useWrappersRegistryAddress(): Address | undefined;
 //#endregion
 //#region src/wrappers-registry/use-token-pairs-registry.d.ts
 /**
  * Fetches all token wrapper pairs from the ConfidentialTokenWrappersRegistry
  * contract on the current chain.
  */
-declare function useTokenPairsRegistry(): _$_tanstack_react_query0.UseQueryResult<readonly TokenWrapperPair$1[], Error>;
+declare function useTokenPairsRegistry(): import("@tanstack/react-query").UseQueryResult<readonly TokenWrapperPair[], Error>;
 //#endregion
 //#region src/wrappers-registry/use-token-pairs-length.d.ts
 /**
  * Returns the total number of token wrapper pairs in the registry.
  */
-declare function useTokenPairsLength(): _$_tanstack_react_query0.UseQueryResult<bigint, Error>;
+declare function useTokenPairsLength(): import("@tanstack/react-query").UseQueryResult<bigint, Error>;
 //#endregion
 //#region src/wrappers-registry/use-token-pairs-slice.d.ts
 /**
@@ -1142,7 +940,7 @@ declare function useTokenPairsSlice({
 }: {
   fromIndex: bigint | undefined;
   toIndex: bigint | undefined;
-}): _$_tanstack_react_query0.UseQueryResult<readonly TokenWrapperPair$1[], Error>;
+}): import("@tanstack/react-query").UseQueryResult<readonly TokenWrapperPair[], Error>;
 //#endregion
 //#region src/wrappers-registry/use-token-pair.d.ts
 /**
@@ -1154,7 +952,7 @@ declare function useTokenPair({
   index
 }: {
   index: bigint | undefined;
-}): _$_tanstack_react_query0.UseQueryResult<TokenWrapperPair$1, Error>;
+}): import("@tanstack/react-query").UseQueryResult<TokenWrapperPair, Error>;
 //#endregion
 //#region src/wrappers-registry/use-confidential-token-address.d.ts
 /**
@@ -1163,8 +961,8 @@ declare function useTokenPair({
 declare function useConfidentialTokenAddress({
   tokenAddress
 }: {
-  tokenAddress: Address$1 | undefined;
-}): _$_tanstack_react_query0.UseQueryResult<readonly [boolean, `0x${string}`], Error>;
+  tokenAddress: Address | undefined;
+}): import("@tanstack/react-query").UseQueryResult<readonly [boolean, `0x${string}`], Error>;
 //#endregion
 //#region src/wrappers-registry/use-token-address.d.ts
 /**
@@ -1173,8 +971,8 @@ declare function useConfidentialTokenAddress({
 declare function useTokenAddress({
   confidentialTokenAddress
 }: {
-  confidentialTokenAddress: Address$1 | undefined;
-}): _$_tanstack_react_query0.UseQueryResult<readonly [boolean, `0x${string}`], Error>;
+  confidentialTokenAddress: Address | undefined;
+}): import("@tanstack/react-query").UseQueryResult<readonly [boolean, `0x${string}`], Error>;
 //#endregion
 //#region src/wrappers-registry/use-is-confidential-token-valid.d.ts
 /**
@@ -1186,8 +984,8 @@ declare function useTokenAddress({
 declare function useIsConfidentialTokenValid({
   confidentialTokenAddress
 }: {
-  confidentialTokenAddress: Address$1 | undefined;
-}): _$_tanstack_react_query0.UseQueryResult<boolean, Error>;
+  confidentialTokenAddress: Address | undefined;
+}): import("@tanstack/react-query").UseQueryResult<boolean, Error>;
 //#endregion
 //#region src/wrappers-registry/use-list-pairs.d.ts
 /**
@@ -1211,15 +1009,7 @@ declare function useListPairs({
   page?: number;
   pageSize?: number;
   metadata?: boolean;
-}): _$_tanstack_react_query0.UseQueryResult<PaginatedResult$1<TokenWrapperPair$1 | TokenWrapperPairWithMetadata$1>, Error>;
-//#endregion
-//#region src/balance/optimistic-balance-update.d.ts
-type OptimisticBalanceSnapshot = [QueryKey, bigint | undefined][];
-/** Combined context returned by optimistic `onMutate`. */
-interface OptimisticMutateContext {
-  snapshot: OptimisticBalanceSnapshot;
-  callerContext?: unknown;
-}
+}): import("@tanstack/react-query").UseQueryResult<PaginatedResult<TokenWrapperPair | TokenWrapperPairWithMetadata>, Error>;
 //#endregion
-export { ACL_TOPICS, type AclEvent, AclPausedError, type ActivityAmount, type ActivityDirection, type ActivityItem, type ActivityLogMetadata, type ActivityType, type Address, ApprovalFailedError, type ApproveSubmittedEvent, type ApproveUnderlyingParams, type ApproveUnderlyingSubmittedEvent, BalanceCheckUnavailableError, type BaseEvent, type BatchBalancesResult, type BatchDecryptAsOptions, type BatchDecryptBalancesAsParams, ChromeSessionStorage, type ClearValueType, type ConfidentialApproveParams, type ConfidentialTransferEvent, type ConfidentialTransferFromParams, type ConfidentialTransferParams, ConfigurationError, type ContractAbi, type CreateDelegatedUserDecryptEIP712Params, type CreateEIP712Params, type CredentialsAllowedEvent, type CredentialsCachedEvent, type CredentialsCreatedEvent, type CredentialsCreatingEvent, type CredentialsExpiredEvent, type CredentialsLoadingEvent, CredentialsManager, type CredentialsManagerConfig, type CredentialsRevokedEvent, type DecryptBalanceAsParams, type DecryptEndEvent, type DecryptErrorEvent, type DecryptHandle, type DecryptResult, type DecryptStartEvent, DecryptionFailedError, DefaultRegistryAddresses, type DelegateDecryptionParams, DelegatedCredentialsManager, type DelegatedCredentialsManagerConfig, type DelegatedForUserDecryptionEvent, type DelegatedStoredCredentials, type DelegatedUserDecryptParams, DelegationContractIsSelfError, DelegationCooldownError, DelegationDelegateEqualsContractError, DelegationExpirationTooSoonError, DelegationExpiredError, DelegationExpiryUnchangedError, DelegationNotFoundError, DelegationNotPropagatedError, DelegationSelfNotAllowedError, type DelegationStatusData, type DelegationStatusQueryConfig, type EIP712TypedData, ERC20ReadFailedError, ERC7984_INTERFACE_ID, ERC7984_WRAPPER_INTERFACE_ID, type EncryptEndEvent, type EncryptErrorEvent, type EncryptInput, type EncryptParams, type EncryptResult, type EncryptStartEvent, EncryptionFailedError, type FheTypeName, type FhevmInstanceConfig, type FinalizeUnwrapParams, type FinalizeUnwrapSubmittedEvent, type GenericSigner, type GenericStorage, type Handle, HardhatConfig, type Hex, IndexedDBStorage, type InputProofBytesType, InsufficientConfidentialBalanceError, InsufficientERC20BalanceError, InvalidKeypairError, KeypairExpiredError, type KeypairType, type KmsDelegatedUserDecryptEIP712Type, type ListPairsOptions, type ListPairsQueryConfig, MainnetConfig, MemoryStorage, type NetworkType, NoCiphertextError, type OnChainEvent, type OptimisticBalanceSnapshot, type OptimisticMutateContext, type PaginatedResult, type PublicDecryptResult, type PublicKeyData, type PublicParamsData, type RawLog, type ReadContractArgs, type ReadContractConfig, type ReadContractReturnType, type ReadFunctionName, ReadonlyToken, RelayerRequestFailedError, type RelayerSDK, type RelayerSDKStatus, RelayerWeb, type RelayerWebConfig, type RelayerWebSecurityConfig, type ResumeUnshieldParams, type RevokeDelegationParams, type RevokedDelegationForUserDecryptionEvent, SepoliaConfig, type SessionExpiredEvent, type ShieldCallbacks, type ShieldParams, type ShieldSubmittedEvent, SigningFailedError, SigningRejectedError, type StoredCredentials, TOKEN_TOPICS, Token, type TokenMetadata, type TokenWrapperPair, type TokenWrapperPairWithMetadata, 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 UseDelegationStatusConfig, type UseIsAllowedConfig, type UseShieldConfig, type UseUnderlyingAllowanceConfig, type UseUserDecryptResult, type UseWrapperDiscoveryConfig, type UseWrapperDiscoverySuspenseConfig, type UseZamaConfig, type UserDecryptParams, type UserDecryptQueryConfig, type WrappedEvent, WrappersRegistry, type WrappersRegistryConfig, 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, batchDecryptBalancesAsMutationOptions, chromeSessionStorage, clearPendingUnshield, confidentialApproveMutationOptions, confidentialBalanceOfContract, confidentialBalanceQueryOptions, confidentialBalancesQueryOptions, confidentialIsApprovedQueryOptions, confidentialTotalSupplyContract, confidentialTransferContract, confidentialTransferFromContract, confidentialTransferFromMutationOptions, confidentialTransferMutationOptions, createDelegatedUserDecryptEIP712MutationOptions, createEIP712MutationOptions, decimalsContract, decodeAclEvent, decodeAclEvents, decodeConfidentialTransfer, decodeDelegatedForUserDecryption, decodeOnChainEvent, decodeOnChainEvents, decodeRevokedDelegationForUserDecryption, decodeUnwrapRequested, decodeUnwrappedFinalized, decodeUnwrappedStarted, decodeWrapped, decryptBalanceAsMutationOptions, delegateDecryptionMutationOptions, delegateForUserDecryptionContract, delegatedUserDecryptMutationOptions, delegationStatusQueryOptions, encryptMutationOptions, extractEncryptedHandles, filterQueryOptions, finalizeUnwrapContract, finalizeUnwrapMutationOptions, findDelegatedForUserDecryption, findRevokedDelegationForUserDecryption, findUnwrapRequested, findWrapped, generateKeypairMutationOptions, getDelegationExpiryContract, hashFn, indexedDBStorage, inferredTotalSupplyContract, isAllowedQueryOptions, isConfidentialQueryOptions, isConfidentialTokenContract, isConfidentialWrapperContract, isHandleDelegatedContract, isOperatorContract, isWrapperQueryOptions, isZeroHandle, listPairsQueryOptions, loadPendingUnshield, matchAclRevert, matchZamaError, memoryStorage, nameContract, parseActivityFeed, publicDecryptMutationOptions, publicKeyQueryOptions, publicParamsQueryOptions, rateContract, requestZKProofVerificationMutationOptions, resumeUnshieldMutationOptions, revokeDelegationContract, revokeDelegationMutationOptions, revokeMutationOptions, revokeSessionMutationOptions, savePendingUnshield, setOperatorContract, shieldMutationOptions, signerAddressQueryOptions, sortByBlockNumber, supportsInterfaceContract, symbolContract, tokenMetadataQueryOptions, totalSupplyContract, totalSupplyQueryOptions, underlyingAllowanceQueryOptions, underlyingContract, unshieldAllMutationOptions, unshieldMutationOptions, unwrapAllMutationOptions, unwrapContract, unwrapFromBalanceContract, unwrapMutationOptions, useActivityFeed, useAllow, useApproveUnderlying, useBatchDecryptBalancesAs, useConfidentialApprove, useConfidentialBalance, useConfidentialBalances, useConfidentialIsApproved, useConfidentialIsApprovedSuspense, useConfidentialTokenAddress, useConfidentialTransfer, useConfidentialTransferFrom, useCreateDelegatedUserDecryptEIP712, useCreateEIP712, useDecryptBalanceAs, useDelegateDecryption, useDelegatedUserDecrypt, useDelegationStatus, useEncrypt, useFinalizeUnwrap, useGenerateKeypair, useIsAllowed, useIsConfidential, useIsConfidentialSuspense, useIsConfidentialTokenValid, useIsWrapper, useIsWrapperSuspense, useListPairs, useMetadata, useMetadataSuspense, usePublicDecrypt, usePublicKey, usePublicParams, useReadonlyToken, useRequestZKProofVerification, useResumeUnshield, useRevoke, useRevokeDelegation, useRevokeSession, useShield, useToken, useTokenAddress, useTokenPair, useTokenPairsLength, useTokenPairsRegistry, useTokenPairsSlice, useTotalSupply, useTotalSupplySuspense, useUnderlyingAllowance, useUnderlyingAllowanceSuspense, useUnshield, useUnshieldAll, useUnwrap, useUnwrapAll, useUserDecrypt, useWrapperDiscovery, useWrapperDiscoverySuspense, useWrappersRegistryAddress, useZamaSDK, userDecryptQueryOptions, wrapContract, wrapperDiscoveryQueryOptions, zamaQueryKeys };
+export { type UseConfidentialBalanceConfig, type UseConfidentialBalanceOptions, type UseConfidentialBalancesConfig, type UseConfidentialBalancesOptions, type UseConfidentialIsOperatorConfig, type UseConfidentialIsOperatorSuspenseConfig, type UseConfidentialTransferConfig, type UseDecryptValuesResult, type UseDelegationStatusConfig, type UseHasPermitConfig, type UseShieldConfig, type UseUnderlyingAllowanceConfig, type UseUnderlyingAllowanceSuspenseConfig, type UseWrapperDiscoveryConfig, type UseWrapperDiscoverySuspenseConfig, ZamaProvider, type ZamaProviderProps, useApproveUnderlying, useBatchDecryptBalancesAs, useClearCredentials, useConfidentialBalance, useConfidentialBalances, useConfidentialIsOperator, useConfidentialIsOperatorSuspense, useConfidentialSetOperator, useConfidentialTokenAddress, useConfidentialTransfer, useConfidentialTransferFrom, useDecryptBalanceAs, useDecryptPublicValues, useDecryptValues, useDelegateDecryption, useDelegatedDecryptValues, useDelegationStatus, useEncrypt, useFinalizeUnwrap, useGrantPermit, useHasPermit, useIsConfidential, useIsConfidentialSuspense, useIsConfidentialTokenValid, useIsWrapper, useIsWrapperSuspense, useListPairs, useMetadata, useMetadataSuspense, useResumeUnshield, useRevokeDelegation, useRevokePermits, useShield, useToken, useTokenAddress, useTokenPair, useTokenPairsLength, useTokenPairsRegistry, useTokenPairsSlice, useTotalSupply, useTotalSupplySuspense, useUnderlyingAllowance, useUnderlyingAllowanceSuspense, useUnshield, useUnshieldAll, useUnwrap, useUnwrapAll, useWrappedToken, useWrapperDiscovery, useWrapperDiscoverySuspense, useWrappersRegistryAddress, useZamaSDK };
 //# sourceMappingURL=index.d.ts.map