@tokenops/sdk 1.0.0

package/dist/fhe-disperse/react/useSingletonDisableCustomFee.d.ts

@@ -0,0 +1,21 @@
+import { type UseMutationResult } from "@tanstack/react-query";
+import type { Account, Address } from "viem";
+import type { TxHash } from "../../core/brands.js";
+import { type DisperseHookOptions } from "./_shared.js";
+export interface UseSingletonDisableCustomFeeArgs {
+    user: Address;
+    /** Override signer account. Falls back to `walletClient.account`. */
+    account?: Account | Address;
+}
+/**
+ * Admin: remove a per-user fee override, falling back to the global
+ * defaults. Reverts with `CustomFeeNotSet` if no override exists. Requires
+ * `FEE_MANAGER_ROLE`.
+ *
+ * After success, invalidate {@link useGetFees}`({ user })`.
+ *
+ * @example
+ * const disableCustomFee = useSingletonDisableCustomFee();
+ * disableCustomFee.mutate({ user });
+ */
+export declare function useSingletonDisableCustomFee(options?: DisperseHookOptions): UseMutationResult<TxHash, Error, UseSingletonDisableCustomFeeArgs>;

package/dist/fhe-disperse/react/useSingletonDiscloseHandleToParty.d.ts

@@ -0,0 +1,17 @@
+import { type UseMutationResult } from "@tanstack/react-query";
+import { type DiscloseHandleArgs, type DisclosureResult } from "../types.js";
+import { type DisperseHookOptions } from "./_shared.js";
+/**
+ * Grant `party` persistent FHE ACL on a single `handle`. Caller must already
+ * hold ACL on the handle; FHEVM ACL is append-only — the grant cannot be
+ * revoked once committed.
+ *
+ * Common use: a fee-collector who decrypted the reserve handle via
+ * {@link useGetEncryptedFeeReserve} wants to delegate ongoing decrypt access
+ * to a downstream accounting service.
+ *
+ * @example
+ * const disclose = useSingletonDiscloseHandleToParty();
+ * disclose.mutate({ handle, party: accountingAddress });
+ */
+export declare function useSingletonDiscloseHandleToParty(options?: DisperseHookOptions): UseMutationResult<DisclosureResult, Error, DiscloseHandleArgs>;

package/dist/fhe-disperse/react/useSingletonFees.d.ts

@@ -0,0 +1,19 @@
+import { type UseQueryResult } from "@tanstack/react-query";
+import type { Address } from "viem";
+import { type UserFees } from "../types.js";
+import { type BaseHookOptions } from "./_shared.js";
+export interface UseSingletonFeesArgs extends BaseHookOptions {
+    /** The user whose resolved fees to read. Hook is disabled until set. */
+    user?: Address;
+}
+/**
+ * Read consolidated fee information for `user` — combines per-user resolved
+ * fees (`getFeeAmounts`) with the global `feeConfig` toggles in one read.
+ *
+ * UI code calls this to render the fee panel before the user submits.
+ *
+ * @example
+ * const { data: fees } = useSingletonFees({ user });
+ * // fees → { isCustom, gasFeeWei, tokenFeeBps, gasFeeEnabled, tokenFeeEnabled }
+ */
+export declare function useSingletonFees(args?: UseSingletonFeesArgs): UseQueryResult<UserFees, Error>;

package/dist/fhe-disperse/react/useSingletonGrantRole.d.ts

@@ -0,0 +1,26 @@
+import { type UseMutationResult } from "@tanstack/react-query";
+import type { Account, Address } from "viem";
+import type { TxHash } from "../../core/brands.js";
+import type { Role } from "../../core/brands.js";
+import { type DisperseHookOptions } from "./_shared.js";
+export interface UseSingletonGrantRoleArgs {
+    role: Role;
+    accountTarget: Address;
+    /** Override signer account. Falls back to `walletClient.account`. */
+    account?: Account | Address;
+}
+/**
+ * AccessControl: grant `role` to `accountTarget` on the singleton. Caller
+ * must hold the role's admin role (typically `DEFAULT_ADMIN_ROLE`, i.e. the
+ * all-zero hash). Non-zero role hashes are `keccak256(toBytes("<NAME>"))`.
+ *
+ * After success, invalidate
+ * {@link useHasRole}`({ role, account: accountTarget })`.
+ *
+ * @example
+ * import { keccak256, toBytes } from "viem";
+ * const FEE_MANAGER_ROLE = keccak256(toBytes("FEE_MANAGER_ROLE"));
+ * const grant = useSingletonGrantRole();
+ * grant.mutate({ role: FEE_MANAGER_ROLE, accountTarget: opsAddress });
+ */
+export declare function useSingletonGrantRole(options?: DisperseHookOptions): UseMutationResult<TxHash, Error, UseSingletonGrantRoleArgs>;

package/dist/fhe-disperse/react/useSingletonHasApprovedSubwallets.d.ts

@@ -0,0 +1,25 @@
+import { type UseQueryResult } from "@tanstack/react-query";
+import type { Address } from "viem";
+import { type SubwalletApprovalState } from "../types.js";
+import { type BaseHookOptions } from "./_shared.js";
+export interface UseSingletonHasApprovedSubwalletsArgs extends BaseHookOptions {
+    /** Address whose registered subwallets to check. Hook disabled until set. */
+    user?: Address;
+    /** ERC-7984 token address to check the operator approval against. Hook disabled until set. */
+    token?: Address;
+}
+/**
+ * Check whether a user's registered subwallets have approved the singleton
+ * as an ERC-7984 operator for `token`. Both must return `true` before a
+ * wallet-mode disperse will succeed.
+ *
+ * Returns `{ wallet0: false, wallet1: false, both: false }` if the user is
+ * not yet registered — for pre-registration approvals, use
+ * {@link usePredictWallets} and call `isOperator(predicted, singleton)` on
+ * the token directly.
+ *
+ * @example
+ * const { data: approvals } = useSingletonHasApprovedSubwallets({ user, token });
+ * if (!approvals?.both) { /* prompt user to approve *\/ }
+ */
+export declare function useSingletonHasApprovedSubwallets(args?: UseSingletonHasApprovedSubwalletsArgs): UseQueryResult<SubwalletApprovalState, Error>;

package/dist/fhe-disperse/react/useSingletonHasRole.d.ts

@@ -0,0 +1,23 @@
+import { type UseQueryResult } from "@tanstack/react-query";
+import type { Address } from "viem";
+import type { Role } from "../../core/brands.js";
+import { type BaseHookOptions } from "./_shared.js";
+export interface UseSingletonHasRoleArgs extends BaseHookOptions {
+    role?: Role;
+    /** The address to check role membership for. Hook disabled until set. */
+    account?: Address;
+}
+/**
+ * Read AccessControl: is `account` a member of `role` on the singleton?
+ *
+ * `DisperseConfidential` defines `DEFAULT_ADMIN_ROLE` (the all-zero hash),
+ * `FEE_MANAGER_ROLE`, `FEE_COLLECTOR_ROLE`, and `PAUSER_ROLE`. The non-zero
+ * role hashes are `keccak256(toBytes("<ROLE_NAME>"))` — compute them at the
+ * call site (the SDK does not export them as named constants).
+ *
+ * @example
+ * import { keccak256, toBytes } from "viem";
+ * const FEE_MANAGER_ROLE = keccak256(toBytes("FEE_MANAGER_ROLE"));
+ * const { data: isManager } = useSingletonHasRole({ role: FEE_MANAGER_ROLE, account: user });
+ */
+export declare function useSingletonHasRole(args?: UseSingletonHasRoleArgs): UseQueryResult<boolean, Error>;

package/dist/fhe-disperse/react/useSingletonIsPaused.d.ts

@@ -0,0 +1,11 @@
+import { type UseQueryResult } from "@tanstack/react-query";
+import { type BaseHookOptions } from "./_shared.js";
+/**
+ * Read the singleton's `paused` flag. When `true`, all disperse operations
+ * revert until a `PAUSER_ROLE` member calls `unpause()`.
+ *
+ * @example
+ * const { data: paused } = useSingletonIsPaused();
+ * if (paused) { /* disable submit button *\/ }
+ */
+export declare function useSingletonIsPaused(options?: BaseHookOptions): UseQueryResult<boolean, Error>;

package/dist/fhe-disperse/react/useSingletonIsRegistered.d.ts

@@ -0,0 +1,15 @@
+import { type UseQueryResult } from "@tanstack/react-query";
+import type { Address } from "viem";
+import { type BaseHookOptions } from "./_shared.js";
+export interface UseSingletonIsRegisteredArgs extends BaseHookOptions {
+    /** The user to check registration for. Hook is disabled until set. */
+    user?: Address;
+}
+/**
+ * Check whether a user has already called `register(token)` and has a
+ * deployed wallet pair on the singleton.
+ *
+ * @example
+ * const { data: isRegistered } = useSingletonIsRegistered({ user });
+ */
+export declare function useSingletonIsRegistered(args?: UseSingletonIsRegisteredArgs): UseQueryResult<boolean, Error>;

package/dist/fhe-disperse/react/useSingletonPause.d.ts

@@ -0,0 +1,19 @@
+import { type UseMutationResult } from "@tanstack/react-query";
+import type { Account, Address } from "viem";
+import type { TxHash } from "../../core/brands.js";
+import { type DisperseHookOptions } from "./_shared.js";
+export interface UseSingletonPauseArgs {
+    /** Override signer account. Falls back to `walletClient.account`. */
+    account?: Account | Address;
+}
+/**
+ * Admin: pause all disperse operations on the singleton. Requires
+ * `PAUSER_ROLE`.
+ *
+ * After success, invalidate {@link useIsPaused}.
+ *
+ * @example
+ * const pause = useSingletonPause();
+ * pause.mutate({});
+ */
+export declare function useSingletonPause(options?: DisperseHookOptions): UseMutationResult<TxHash, Error, UseSingletonPauseArgs>;

package/dist/fhe-disperse/react/useSingletonPredictWallets.d.ts

@@ -0,0 +1,19 @@
+import { type UseQueryResult } from "@tanstack/react-query";
+import type { Address } from "viem";
+import { type BaseHookOptions } from "./_shared.js";
+export interface UseSingletonPredictWalletsArgs extends BaseHookOptions {
+    /** The user whose wallet pair to predict. Hook is disabled until set. */
+    user?: Address;
+}
+/**
+ * Deterministically predict the wallet addresses a user would get after
+ * calling `register()`, **without requiring the user to be registered**.
+ *
+ * Use this to compute the addresses that need ERC-7984 operator approval
+ * before the user calls `register()` — set approvals on the predicted
+ * addresses first so the first disperse works without a follow-up tx.
+ *
+ * @example
+ * const { data: predicted } = useSingletonPredictWallets({ user });
+ */
+export declare function useSingletonPredictWallets(args?: UseSingletonPredictWalletsArgs): UseQueryResult<[Address, Address], Error>;

package/dist/fhe-disperse/react/useSingletonRevokeRole.d.ts

@@ -0,0 +1,26 @@
+import { type UseMutationResult } from "@tanstack/react-query";
+import type { Account, Address } from "viem";
+import type { TxHash } from "../../core/brands.js";
+import type { Role } from "../../core/brands.js";
+import { type DisperseHookOptions } from "./_shared.js";
+export interface UseSingletonRevokeRoleArgs {
+    role: Role;
+    accountTarget: Address;
+    /** Override signer account. Falls back to `walletClient.account`. */
+    account?: Account | Address;
+}
+/**
+ * AccessControl: revoke `role` from `accountTarget` on the singleton. Caller
+ * must hold the role's admin role (typically `DEFAULT_ADMIN_ROLE`, i.e. the
+ * all-zero hash). Non-zero role hashes are `keccak256(toBytes("<NAME>"))`.
+ *
+ * After success, invalidate
+ * {@link useHasRole}`({ role, account: accountTarget })`.
+ *
+ * @example
+ * import { keccak256, toBytes } from "viem";
+ * const FEE_MANAGER_ROLE = keccak256(toBytes("FEE_MANAGER_ROLE"));
+ * const revoke = useSingletonRevokeRole();
+ * revoke.mutate({ role: FEE_MANAGER_ROLE, accountTarget: opsAddress });
+ */
+export declare function useSingletonRevokeRole(options?: DisperseHookOptions): UseMutationResult<TxHash, Error, UseSingletonRevokeRoleArgs>;

package/dist/fhe-disperse/react/useSingletonSetCustomFee.d.ts

@@ -0,0 +1,25 @@
+import { type UseMutationResult } from "@tanstack/react-query";
+import type { Account, Address } from "viem";
+import type { TxHash } from "../../core/brands.js";
+import { type DisperseHookOptions } from "./_shared.js";
+export interface UseSingletonSetCustomFeeArgs {
+    user: Address;
+    /** Per-user gas fee override in wei. */
+    gasFee: bigint;
+    /** Per-user token fee override in BPS. */
+    tokenFee: number;
+    /** Override signer account. Falls back to `walletClient.account`. */
+    account?: Account | Address;
+}
+/**
+ * Admin: install a per-user fee override (gas fee in wei, token fee in BPS).
+ * Takes precedence over the global `defaultGasFee` / `defaultTokenFee` for
+ * the targeted user. Requires `FEE_MANAGER_ROLE`.
+ *
+ * After success, invalidate {@link useGetFees}`({ user })`.
+ *
+ * @example
+ * const setCustomFee = useSingletonSetCustomFee();
+ * setCustomFee.mutate({ user, gasFee: 5_000_000_000_000_000n, tokenFee: 25 });
+ */
+export declare function useSingletonSetCustomFee(options?: DisperseHookOptions): UseMutationResult<TxHash, Error, UseSingletonSetCustomFeeArgs>;

package/dist/fhe-disperse/react/useSingletonUnpause.d.ts

@@ -0,0 +1,18 @@
+import { type UseMutationResult } from "@tanstack/react-query";
+import type { Account, Address } from "viem";
+import type { TxHash } from "../../core/brands.js";
+import { type DisperseHookOptions } from "./_shared.js";
+export interface UseSingletonUnpauseArgs {
+    /** Override signer account. Falls back to `walletClient.account`. */
+    account?: Account | Address;
+}
+/**
+ * Admin: unpause the singleton. Requires `PAUSER_ROLE`.
+ *
+ * After success, invalidate {@link useIsPaused}.
+ *
+ * @example
+ * const unpause = useSingletonUnpause();
+ * unpause.mutate({});
+ */
+export declare function useSingletonUnpause(options?: DisperseHookOptions): UseMutationResult<TxHash, Error, UseSingletonUnpauseArgs>;

package/dist/fhe-disperse/react/useSingletonWalletImplementation.d.ts

@@ -0,0 +1,12 @@
+import { type UseQueryResult } from "@tanstack/react-query";
+import type { Address } from "viem";
+import { type BaseHookOptions } from "./_shared.js";
+/**
+ * Read the `WALLET_IMPLEMENTATION` address — the singleton clones this
+ * deterministically (`Clones.cloneDeterministic`) for each registered user
+ * to derive their wallet pair.
+ *
+ * @example
+ * const { data: impl } = useSingletonWalletImplementation();
+ */
+export declare function useSingletonWalletImplementation(options?: BaseHookOptions): UseQueryResult<Address, Error>;

package/dist/fhe-disperse/react/useSingletonWallets.d.ts

@@ -0,0 +1,19 @@
+import { type UseQueryResult } from "@tanstack/react-query";
+import type { Address } from "viem";
+import { type BaseHookOptions } from "./_shared.js";
+export interface UseSingletonWalletsArgs extends BaseHookOptions {
+    /** The user whose wallet pair to read. Hook is disabled until set. */
+    user?: Address;
+}
+/**
+ * Read the on-chain wallet pair for a registered user.
+ *
+ * Returns `null` if the user is not registered. For unregistered users, call
+ * {@link usePredictWallets} to get the deterministic addresses they would
+ * receive after `register()`.
+ *
+ * @example
+ * const { data: wallets } = useSingletonWallets({ user });
+ * if (wallets) { ... wallets[0], wallets[1] ... }
+ */
+export declare function useSingletonWallets(args?: UseSingletonWalletsArgs): UseQueryResult<[Address, Address] | null, Error>;

package/dist/fhe-disperse/react/useSingletonWithdrawGasFee.d.ts

@@ -0,0 +1,21 @@
+import { type UseMutationResult } from "@tanstack/react-query";
+import type { Account, Address } from "viem";
+import type { TxHash } from "../../core/brands.js";
+import { type DisperseHookOptions } from "./_shared.js";
+export interface UseSingletonWithdrawGasFeeArgs {
+    /** Recipient of the withdrawn ETH. */
+    to: Address;
+    /** Amount in wei to withdraw. Pass `0n` to drain the full balance. */
+    amount: bigint;
+    /** Override signer account. Falls back to `walletClient.account`. */
+    account?: Account | Address;
+}
+/**
+ * Fee-collector: withdraw accumulated ETH gas fees from the singleton. Pass
+ * `amount: 0n` to drain the full ETH balance. Requires `FEE_COLLECTOR_ROLE`.
+ *
+ * @example
+ * const withdraw = useSingletonWithdrawGasFee();
+ * withdraw.mutate({ to: collectorAddress, amount: 0n });
+ */
+export declare function useSingletonWithdrawGasFee(options?: DisperseHookOptions): UseMutationResult<TxHash, Error, UseSingletonWithdrawGasFeeArgs>;

package/dist/fhe-disperse/react/useSingletonWithdrawTokenFee.d.ts

@@ -0,0 +1,50 @@
+import { type UseMutationResult } from "@tanstack/react-query";
+import type { Account, Address } from "viem";
+import { type EncryptorSource } from "../encryption.js";
+import { type EncryptedInput, type WithdrawTokenFeeResult } from "../types.js";
+import { type DisperseHookOptions } from "./_shared.js";
+/**
+ * Hook-level args. The hook accepts an {@link EncryptorSource} (eager OR lazy),
+ * so this is broader than the SDK's {@link WithdrawTokenFeeArgs} discriminated
+ * union — we resolve the lazy factory in `mutationFn` and then dispatch into
+ * the discriminated SDK shape.
+ *
+ * `amount` and `encryptedInput` are XOR enforced by the underlying SDK call;
+ * the hook surface mirrors the relaxed pre-S-4 shape (callers had been writing
+ * it that way for two rounds) and the mutate body routes to the right branch.
+ */
+export interface UseSingletonWithdrawTokenFeeArgs {
+    /** ERC-7984 token whose accumulated fee reserve to withdraw from. */
+    token: Address;
+    /** Recipient of the withdrawn confidential tokens. */
+    to: Address;
+    /** Plaintext amount to withdraw. Mutually exclusive with `encryptedInput`. */
+    amount?: bigint;
+    /**
+     * Optional per-call encryptor override. Accepts an eager {@link Encryptor}
+     * or a lazy `() => Encryptor | undefined` factory — same shape as the
+     * hook-level {@link DisperseHookOptions}.`encryptor`.
+     */
+    encryptor?: EncryptorSource;
+    /** Optional pre-encrypted input — skips SDK-side encryption. */
+    encryptedInput?: EncryptedInput;
+    /** Override signer account. Falls back to `walletClient.account`. */
+    account?: Account | Address;
+}
+/**
+ * Fee-collector: withdraw accumulated encrypted token fees. The plaintext
+ * `amount` is encrypted by the SDK before submission; the contract caps the
+ * withdrawal at the available reserve via `FHE.min`.
+ *
+ * **Encryptor resolution.** Pass `encryptor` per-call, or supply it at hook
+ * construction via {@link DisperseHookOptions}.`encryptor`. If neither is
+ * present, the SDK throws `Missing encryptor — pass encryptor…` verbatim.
+ * Alternatively, pass a pre-encrypted `encryptedInput` to skip encryption.
+ *
+ * Requires `FEE_COLLECTOR_ROLE`.
+ *
+ * @example
+ * const withdraw = useSingletonWithdrawTokenFee({ encryptor: () => useZamaSDK().relayer });
+ * withdraw.mutate({ token, to: collector, amount: 1_000_000n });
+ */
+export declare function useSingletonWithdrawTokenFee(options?: DisperseHookOptions): UseMutationResult<WithdrawTokenFeeResult, Error, UseSingletonWithdrawTokenFeeArgs>;

package/dist/fhe-disperse/react/useUnpause.d.ts

@@ -0,0 +1,17 @@
+import { type UseMutationResult } from "@tanstack/react-query";
+import type { Account, Address, Hex } from "viem";
+import { type DisperseHookOptions } from "./_shared.js";
+export interface UseUnpauseArgs {
+    /** Override signer account. Falls back to `walletClient.account`. */
+    account?: Account | Address;
+}
+/**
+ * Admin: unpause the singleton. Requires `PAUSER_ROLE`.
+ *
+ * After success, invalidate {@link useIsPaused}.
+ *
+ * @example
+ * const unpause = useUnpause();
+ * unpause.mutate({});
+ */
+export declare function useUnpause(options?: DisperseHookOptions): UseMutationResult<Hex, Error, UseUnpauseArgs>;

package/dist/fhe-disperse/react/useWalletImplementation.d.ts

@@ -0,0 +1,12 @@
+import { type UseQueryResult } from "@tanstack/react-query";
+import type { Address } from "viem";
+import { type BaseHookOptions } from "./_shared.js";
+/**
+ * Read the `WALLET_IMPLEMENTATION` address — the singleton clones this
+ * deterministically (`Clones.cloneDeterministic`) for each registered user
+ * to derive their wallet pair.
+ *
+ * @example
+ * const { data: impl } = useWalletImplementation();
+ */
+export declare function useWalletImplementation(options?: BaseHookOptions): UseQueryResult<Address, Error>;

package/dist/fhe-disperse/react/useWithdrawGasFee.d.ts

@@ -0,0 +1,26 @@
+import { type UseMutationResult } from "@tanstack/react-query";
+import type { Account, Address, Hex } from "viem";
+import { type DisperseHookOptions } from "./_shared.js";
+export interface UseWithdrawGasFeeArgs {
+    /** Recipient of the withdrawn ETH. */
+    to: Address;
+    /**
+     * Amount in wei to withdraw. The contract does not interpret `0n` as
+     * "drain" — passing `0n` succeeds with no ETH movement. Read the singleton
+     * balance with `publicClient.getBalance(singleton)` to drain.
+     */
+    amount: bigint;
+    /** Override signer account. Falls back to `walletClient.account`. */
+    account?: Account | Address;
+}
+/**
+ * Fee-collector: withdraw `amount` wei of accumulated ETH gas fees from the
+ * singleton to `to`. There is no "drain" sentinel — `amount: 0n` is a no-op
+ * that emits a zero-value `GasFeeWithdrawn` event. Requires
+ * `FEE_COLLECTOR_ROLE`.
+ *
+ * @example
+ * const withdraw = useWithdrawGasFee();
+ * withdraw.mutate({ to: collectorAddress, amount: 0n });
+ */
+export declare function useWithdrawGasFee(options?: DisperseHookOptions): UseMutationResult<Hex, Error, UseWithdrawGasFeeArgs>;

package/dist/fhe-disperse/react/useWithdrawTokenFee.d.ts

@@ -0,0 +1,70 @@
+import { type UseMutationResult } from "@tanstack/react-query";
+import type { Account, Address } from "viem";
+import { type EncryptorSource } from "../encryption.js";
+import { type EncryptedInput, type WithdrawTokenFeeResult } from "../types.js";
+import { type DisperseHookOptions } from "./_shared.js";
+interface WithdrawTokenFeeCommon {
+    /** ERC-7984 token whose accumulated fee reserve to withdraw from. */
+    token: Address;
+    /** Recipient of the withdrawn confidential tokens. */
+    to: Address;
+    /** Override signer account. Falls back to `walletClient.account`. */
+    account?: Account | Address;
+}
+/** Plaintext path: SDK encrypts `amount` before submission. */
+export interface UseWithdrawTokenFeePlaintextArgs extends WithdrawTokenFeeCommon {
+    /** Plaintext amount to withdraw. SDK encrypts via `encryptor` (or hook-level). */
+    amount: bigint;
+    /**
+     * Optional per-call encryptor override. Accepts an eager {@link Encryptor}
+     * or a lazy `() => Encryptor | undefined` factory — same shape as the
+     * hook-level {@link DisperseHookOptions}.`encryptor`.
+     */
+    encryptor?: EncryptorSource;
+    encryptedInput?: never;
+}
+/** Pre-encrypted path: caller already produced the `EncryptedInput`. */
+export interface UseWithdrawTokenFeePreEncryptedArgs extends WithdrawTokenFeeCommon {
+    /** Pre-encrypted input — skips SDK-side encryption. */
+    encryptedInput: EncryptedInput;
+    amount?: never;
+    encryptor?: never;
+}
+/**
+ * Mirrors the headless `withdrawTokenFee` invariant: exactly one of `amount`
+ * (plaintext, SDK encrypts) or `encryptedInput` (pre-encrypted). The
+ * discriminated union surfaces that requirement at compile time instead of as
+ * a runtime `InvalidArgumentError`.
+ */
+export type UseWithdrawTokenFeeArgs = UseWithdrawTokenFeePlaintextArgs | UseWithdrawTokenFeePreEncryptedArgs;
+/**
+ * Fee-collector: withdraw accumulated encrypted token fees. Pass either a
+ * plaintext `amount` (SDK encrypts) or a pre-encrypted `encryptedInput` —
+ * never both. The contract caps the withdrawal at the available reserve via
+ * `FHE.min`.
+ *
+ * Returns `{ hash, transferredHandle }` parsed from the `TokenFeeWithdrawn`
+ * event. The handle is decryptable by the caller via Zama's `userDecrypt`
+ * and reveals the actual transferred amount, which may be less than the
+ * requested amount when the reserve was lower.
+ *
+ * **Encryptor resolution** (plaintext path only). Pass `encryptor` per-call,
+ * or supply it at hook construction via {@link DisperseHookOptions}.`encryptor`.
+ * If neither is present, the SDK throws `Missing encryptor — pass encryptor…`
+ * verbatim.
+ *
+ * Requires `FEE_COLLECTOR_ROLE`.
+ *
+ * @example
+ * function Component() {
+ *   const zamaSDK = useZamaSDK();
+ *   const withdraw = useWithdrawTokenFee({ encryptor: () => zamaSDK.relayer });
+ *   withdraw.mutate({ token, to: collector, amount: 1_000_000n });
+ * }
+ *
+ * @example
+ * // Pre-encrypted path — no encryptor needed at call time.
+ * withdraw.mutate({ token, to: collector, encryptedInput });
+ */
+export declare function useWithdrawTokenFee(options?: DisperseHookOptions): UseMutationResult<WithdrawTokenFeeResult, Error, UseWithdrawTokenFeeArgs>;
+export {};