@tokenops/sdk 1.0.0

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

@@ -0,0 +1,28 @@
+import { type UseMutationResult } from "@tanstack/react-query";
+import { type DisperseArgs, type DisperseResult } from "../types.js";
+import { type DisperseHookOptions } from "./_shared.js";
+/**
+ * Disperse confidential tokens to multiple recipients. The SDK validates
+ * inputs, computes the wallet-mode subtotal split, encrypts all amounts +
+ * subtotals in a single proof batch, computes `msg.value` for gas-fee modes,
+ * and dispatches to the correct contract entry point based on `mode`.
+ *
+ * **Encryptor resolution.** The hook-level `encryptor` (from
+ * {@link DisperseHookOptions}) is forwarded lazily to the SDK client. If
+ * missing when the mutation runs, the SDK throws
+ * `Missing encryptor — pass encryptor…` verbatim. Capture `useZamaSDK()` once
+ * at the top of your component and forward `() => zamaSDK.relayer` — never
+ * `() => useZamaSDK().relayer` inline (calls a React hook inside a mutation
+ * body, violating the rules of hooks; see CLAUDE.md Pitfall #3).
+ *
+ * After success, invalidate `useGetFees`, `useHasApprovedSubwallets`, and any
+ * downstream token-balance queries owned by the consumer.
+ *
+ * @example
+ * function Component() {
+ *   const zamaSDK = useZamaSDK();
+ *   const disperse = useDisperse({ encryptor: () => zamaSDK.relayer });
+ *   disperse.mutate({ token, mode: "direct", recipients, amounts });
+ * }
+ */
+export declare function useDisperse(options?: DisperseHookOptions): UseMutationResult<DisperseResult, Error, DisperseArgs>;

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

@@ -0,0 +1,12 @@
+import { type UseQueryResult } from "@tanstack/react-query";
+import { type BatchLimits } from "../types.js";
+import { type BaseHookOptions } from "./_shared.js";
+/**
+ * Read the maximum batch size for each of the three disperse modes
+ * (`"wallet"`, `"direct"`, `"wallet-token-fee"`). `0n` means no limit.
+ *
+ * @example
+ * const { data: limits } = useGetBatchLimits();
+ * // limits → { holding, direct, tokenFee }
+ */
+export declare function useGetBatchLimits(options?: BaseHookOptions): UseQueryResult<BatchLimits, Error>;

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

@@ -0,0 +1,15 @@
+import { type UseQueryResult } from "@tanstack/react-query";
+import { type FeeConfig } from "../types.js";
+import { type BaseHookOptions } from "./_shared.js";
+/**
+ * Read the on-chain global fee configuration (`feeConfig` getter).
+ *
+ * Returns the {@link FeeConfig} struct the contract stores — pass the result
+ * straight back to {@link useSetFeeConfig} to flip one toggle without
+ * re-stating the others.
+ *
+ * @example
+ * const { data: cfg } = useGetFeeConfig();
+ * // cfg → { gasFeeEnabled, tokenFeeEnabled, defaultGasFee, defaultTokenFee }
+ */
+export declare function useGetFeeConfig(options?: BaseHookOptions): UseQueryResult<FeeConfig, Error>;

package/dist/fhe-disperse/react/useGetFees.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 UseGetFeesArgs 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 } = useGetFees({ user });
+ * // fees → { isCustom, gasFeeWei, tokenFeeBps, gasFeeEnabled, tokenFeeEnabled }
+ */
+export declare function useGetFees(args?: UseGetFeesArgs): UseQueryResult<UserFees, Error>;

package/dist/fhe-disperse/react/useGetWallets.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 UseGetWalletsArgs 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 } = useGetWallets({ user });
+ * if (wallets) { ... wallets[0], wallets[1] ... }
+ */
+export declare function useGetWallets(args?: UseGetWalletsArgs): UseQueryResult<[Address, Address] | null, Error>;

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

@@ -0,0 +1,24 @@
+import { type UseMutationResult } from "@tanstack/react-query";
+import type { Account, Address, Hex } from "viem";
+import { type DisperseHookOptions } from "./_shared.js";
+export interface UseGrantRoleArgs {
+    role: Hex;
+    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 = useGrantRole();
+ * grant.mutate({ role: FEE_MANAGER_ROLE, accountTarget: opsAddress });
+ */
+export declare function useGrantRole(options?: DisperseHookOptions): UseMutationResult<Hex, Error, UseGrantRoleArgs>;

package/dist/fhe-disperse/react/useHasApprovedSubwallets.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 UseHasApprovedSubwalletsArgs 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 } = useHasApprovedSubwallets({ user, token });
+ * if (!approvals?.both) { /* prompt user to approve *\/ }
+ */
+export declare function useHasApprovedSubwallets(args?: UseHasApprovedSubwalletsArgs): UseQueryResult<SubwalletApprovalState, Error>;

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

@@ -0,0 +1,22 @@
+import { type UseQueryResult } from "@tanstack/react-query";
+import type { Address, Hex } from "viem";
+import { type BaseHookOptions } from "./_shared.js";
+export interface UseHasRoleArgs extends BaseHookOptions {
+    role?: Hex;
+    /** 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 } = useHasRole({ role: FEE_MANAGER_ROLE, account: user });
+ */
+export declare function useHasRole(args?: UseHasRoleArgs): UseQueryResult<boolean, Error>;

package/dist/fhe-disperse/react/useIsPaused.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 } = useIsPaused();
+ * if (paused) { /* disable submit button *\/ }
+ */
+export declare function useIsPaused(options?: BaseHookOptions): UseQueryResult<boolean, Error>;

package/dist/fhe-disperse/react/useIsRegistered.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 UseIsRegisteredArgs 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 } = useIsRegistered({ user });
+ */
+export declare function useIsRegistered(args?: UseIsRegisteredArgs): UseQueryResult<boolean, Error>;

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

@@ -0,0 +1,18 @@
+import { type UseMutationResult } from "@tanstack/react-query";
+import type { Account, Address, Hex } from "viem";
+import { type DisperseHookOptions } from "./_shared.js";
+export interface UsePauseArgs {
+    /** 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 = usePause();
+ * pause.mutate({});
+ */
+export declare function usePause(options?: DisperseHookOptions): UseMutationResult<Hex, Error, UsePauseArgs>;

package/dist/fhe-disperse/react/usePredictWallets.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 UsePredictWalletsArgs 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 } = usePredictWallets({ user });
+ */
+export declare function usePredictWallets(args?: UsePredictWalletsArgs): UseQueryResult<[Address, Address], Error>;

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

@@ -0,0 +1,37 @@
+import { type UseQueryResult } from "@tanstack/react-query";
+import type { Address } from "viem";
+import { type DisperseMode, type PreflightReport } from "../types.js";
+import { type BaseHookOptions } from "./_shared.js";
+export interface UsePreflightDisperseArgs extends BaseHookOptions {
+    user?: Address;
+    token?: Address;
+    recipients?: Address[];
+    amounts?: bigint[];
+    mode?: DisperseMode;
+}
+/**
+ * Comprehensive pre-flight report — one call gives a UI everything it needs
+ * to render a "ready to disperse" checklist: registration state, wallet
+ * approvals, fee preview, batch-limit check, per-recipient validation,
+ * pre-computed wallet-mode subtotals, and a `ready` flag plus structured
+ * `blockers` list.
+ *
+ * Hook is disabled until `user`, `token`, `recipients`, `amounts`, and `mode`
+ * are all set.
+ *
+ * For live dashboards, set `refetchInterval` so the report stays current as
+ * the user toggles approvals in a wallet UI:
+ *
+ * ```ts
+ * const preflight = usePreflightDisperse({ user, token, recipients, amounts, mode });
+ * // pass through TanStack Query options via queryClient.setQueryDefaults or a
+ * // wrapping useQuery, e.g. refetchInterval: 5_000.
+ * ```
+ *
+ * @example
+ * const { data: report } = usePreflightDisperse({
+ *   user, token, recipients, amounts, mode: "direct",
+ * });
+ * if (report?.ready) { /* enable submit *\/ }
+ */
+export declare function usePreflightDisperse(args?: UsePreflightDisperseArgs): UseQueryResult<PreflightReport, Error>;

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

@@ -0,0 +1,21 @@
+import { type UseMutationResult } from "@tanstack/react-query";
+import type { Account, Address, Hex } from "viem";
+import { type DisperseHookOptions } from "./_shared.js";
+export interface UseRecoverERC20FromWalletsArgs {
+    /** ERC-20 token to recover from the caller's wallets. */
+    token: Address;
+    /** Address to receive the recovered tokens. */
+    to: Address;
+    /** Override signer account. Falls back to `walletClient.account`. */
+    account?: Account | Address;
+}
+/**
+ * Recover ERC-20 tokens accidentally sent to the caller's registered wallets.
+ * Mirrors {@link useRecoverFromWallets} but for plain (non-confidential)
+ * ERC-20 balances stranded in the subwallets.
+ *
+ * @example
+ * const recover = useRecoverERC20FromWallets();
+ * recover.mutate({ token, to: address });
+ */
+export declare function useRecoverERC20FromWallets(options?: DisperseHookOptions): UseMutationResult<Hex, Error, UseRecoverERC20FromWalletsArgs>;

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

@@ -0,0 +1,21 @@
+import { type UseMutationResult } from "@tanstack/react-query";
+import type { Account, Address, Hex } from "viem";
+import { type DisperseHookOptions } from "./_shared.js";
+export interface UseRecoverFromWalletsArgs {
+    /** ERC-7984 token to recover from the caller's wallets. */
+    token: Address;
+    /** Address to receive the recovered tokens. */
+    to: Address;
+    /** Override signer account. Falls back to `walletClient.account`. */
+    account?: Account | Address;
+}
+/**
+ * Recover residual confidential ERC-7984 tokens from the caller's registered
+ * wallets to `to`. Useful after a wallet-mode disperse where subtotals were
+ * inflated and tokens remain locked in the subwallets.
+ *
+ * @example
+ * const recover = useRecoverFromWallets();
+ * recover.mutate({ token, to: address });
+ */
+export declare function useRecoverFromWallets(options?: DisperseHookOptions): UseMutationResult<Hex, Error, UseRecoverFromWalletsArgs>;

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

@@ -0,0 +1,40 @@
+import { type UseMutationResult } from "@tanstack/react-query";
+import type { Account, Address } from "viem";
+import { type RegisterResult } from "../types.js";
+import { type DisperseHookOptions } from "./_shared.js";
+export interface UseRegisterArgs {
+    /** ERC-7984 token to approve the new subwallets for. */
+    token: Address;
+    /** Override signer account. Falls back to `walletClient.account`. */
+    account?: Account | Address;
+}
+/**
+ * Deploy the caller's dedicated wallet pair via `register(token)` and parse
+ * the resulting `UserRegistered` event to return both subwallet addresses.
+ *
+ * Can only be called once per user — subsequent calls revert with
+ * `UserAlreadyRegistered`. Use {@link useIsRegistered} to gate this in your
+ * UI.
+ *
+ * **Throws {@link DisperseSubwalletNotFoundError}** if the receipt has no
+ * `UserRegistered` event from the singleton — typically means the tx reverted
+ * silently or you're reading the wrong singleton address.
+ *
+ * After success, invalidate every disperse query for this user:
+ *
+ * ```ts
+ * const queryClient = useQueryClient();
+ * const register = useRegister();
+ * register.mutate({ token }, {
+ *   onSuccess: () => {
+ *     queryClient.invalidateQueries({ queryKey: ["tokenops-sdk", "fhe-disperse"] });
+ *   },
+ * });
+ * ```
+ *
+ * @example
+ * const register = useRegister();
+ * register.mutate({ token });
+ * // register.data → { hash, wallets: [wallet0, wallet1] }
+ */
+export declare function useRegister(options?: DisperseHookOptions): UseMutationResult<RegisterResult, Error, UseRegisterArgs>;

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

@@ -0,0 +1,21 @@
+import { type UseMutationResult } from "@tanstack/react-query";
+import type { Account, Address, Hex } from "viem";
+import { type DisperseHookOptions } from "./_shared.js";
+export interface UseRescueConfidentialTokensArgs {
+    /** ERC-7984 token to rescue. */
+    token: Address;
+    /** Recipient of the rescued tokens. */
+    to: Address;
+    /** Override signer account. Falls back to `walletClient.account`. */
+    account?: Account | Address;
+}
+/**
+ * Admin: rescue accidentally-sent ERC-7984 confidential tokens from the
+ * singleton contract itself (NOT the per-user subwallets — for those, use
+ * {@link useRecoverFromWallets}). Requires `WITHDRAWER_ROLE`.
+ *
+ * @example
+ * const rescue = useRescueConfidentialTokens();
+ * rescue.mutate({ token, to: treasury });
+ */
+export declare function useRescueConfidentialTokens(options?: DisperseHookOptions): UseMutationResult<Hex, Error, UseRescueConfidentialTokensArgs>;

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

@@ -0,0 +1,21 @@
+import { type UseMutationResult } from "@tanstack/react-query";
+import type { Account, Address, Hex } from "viem";
+import { type DisperseHookOptions } from "./_shared.js";
+export interface UseRescueERC20Args {
+    /** ERC-20 token to rescue. */
+    token: Address;
+    /** Recipient of the rescued tokens. */
+    to: Address;
+    /** Override signer account. Falls back to `walletClient.account`. */
+    account?: Account | Address;
+}
+/**
+ * Admin: rescue accidentally-sent ERC-20 tokens from the singleton contract
+ * itself (NOT the per-user subwallets — for those, use
+ * {@link useRecoverERC20FromWallets}). Requires `WITHDRAWER_ROLE`.
+ *
+ * @example
+ * const rescue = useRescueERC20();
+ * rescue.mutate({ token, to: treasury });
+ */
+export declare function useRescueERC20(options?: DisperseHookOptions): UseMutationResult<Hex, Error, UseRescueERC20Args>;

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

@@ -0,0 +1,24 @@
+import { type UseMutationResult } from "@tanstack/react-query";
+import type { Account, Address, Hex } from "viem";
+import { type DisperseHookOptions } from "./_shared.js";
+export interface UseRevokeRoleArgs {
+    role: Hex;
+    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 = useRevokeRole();
+ * revoke.mutate({ role: FEE_MANAGER_ROLE, accountTarget: opsAddress });
+ */
+export declare function useRevokeRole(options?: DisperseHookOptions): UseMutationResult<Hex, Error, UseRevokeRoleArgs>;

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

@@ -0,0 +1,24 @@
+import { type UseMutationResult } from "@tanstack/react-query";
+import type { Account, Address, Hex } from "viem";
+import { type DisperseHookOptions } from "./_shared.js";
+export interface UseRevokeTokenOnWalletsArgs {
+    /** ERC-7984 token to revoke operator approval on. */
+    token: Address;
+    /** Override signer account. Falls back to `walletClient.account`. */
+    account?: Account | Address;
+}
+/**
+ * Revoke the operator approval on `token` for the caller's registered
+ * wallets. Re-approve later with {@link useApproveTokenOnWallets}.
+ *
+ * **Prerequisite:** the caller must already be registered via
+ * {@link useRegister}.
+ *
+ * After success, invalidate
+ * {@link useHasApprovedSubwallets}`({ user, token })`.
+ *
+ * @example
+ * const revoke = useRevokeTokenOnWallets();
+ * revoke.mutate({ token });
+ */
+export declare function useRevokeTokenOnWallets(options?: DisperseHookOptions): UseMutationResult<Hex, Error, UseRevokeTokenOnWalletsArgs>;

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

@@ -0,0 +1,24 @@
+import { type UseMutationResult } from "@tanstack/react-query";
+import type { Account, Address, Hex } from "viem";
+import { type DisperseHookOptions } from "./_shared.js";
+export interface UseSetCustomFeeArgs {
+    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 = useSetCustomFee();
+ * setCustomFee.mutate({ user, gasFee: 5_000_000_000_000_000n, tokenFee: 25 });
+ */
+export declare function useSetCustomFee(options?: DisperseHookOptions): UseMutationResult<Hex, Error, UseSetCustomFeeArgs>;

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

@@ -0,0 +1,23 @@
+import { type UseMutationResult } from "@tanstack/react-query";
+import type { Account, Address, Hex } from "viem";
+import { type DisperseHookOptions } from "./_shared.js";
+import type { FeeConfig } from "../types.js";
+export interface UseSetFeeConfigArgs {
+    config: FeeConfig;
+    /** Override signer account. Falls back to `walletClient.account`. */
+    account?: Account | Address;
+}
+/**
+ * Admin: update the global fee configuration — enable/disable gas and token
+ * fees, set the defaults. Requires `FEE_MANAGER_ROLE`.
+ *
+ * After success, invalidate {@link useGetFees} for every user and any UI
+ * panels showing the global config.
+ *
+ * @example
+ * const setFeeConfig = useSetFeeConfig();
+ * setFeeConfig.mutate({
+ *   config: { gasFeeEnabled: true, tokenFeeEnabled: false, defaultGasFee: 10_000_000_000_000_000n, defaultTokenFee: 0 },
+ * });
+ */
+export declare function useSetFeeConfig(options?: DisperseHookOptions): UseMutationResult<Hex, Error, UseSetFeeConfigArgs>;

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

@@ -0,0 +1,20 @@
+import { type UseMutationResult } from "@tanstack/react-query";
+import type { Account, Address, Hex } from "viem";
+import { type DisperseHookOptions } from "./_shared.js";
+export interface UseSetMaxBatchSizeDirectArgs {
+    /** Max recipients in a single `"direct"` mode call. `0n` = no limit. */
+    size: bigint;
+    /** Override signer account. Falls back to `walletClient.account`. */
+    account?: Account | Address;
+}
+/**
+ * Admin: set the maximum batch size for `"direct"` mode disperses. `0n` = no
+ * limit. Requires `DEFAULT_ADMIN_ROLE`.
+ *
+ * After success, invalidate {@link useGetBatchLimits}.
+ *
+ * @example
+ * const setLimit = useSetMaxBatchSizeDirect();
+ * setLimit.mutate({ size: 128n });
+ */
+export declare function useSetMaxBatchSizeDirect(options?: DisperseHookOptions): UseMutationResult<Hex, Error, UseSetMaxBatchSizeDirectArgs>;

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

@@ -0,0 +1,20 @@
+import { type UseMutationResult } from "@tanstack/react-query";
+import type { Account, Address, Hex } from "viem";
+import { type DisperseHookOptions } from "./_shared.js";
+export interface UseSetMaxBatchSizeHoldingArgs {
+    /** Max recipients in a single `"wallet"` mode call. `0n` = no limit. */
+    size: bigint;
+    /** Override signer account. Falls back to `walletClient.account`. */
+    account?: Account | Address;
+}
+/**
+ * Admin: set the maximum batch size for `"wallet"` mode disperses. `0n` = no
+ * limit. Requires `DEFAULT_ADMIN_ROLE`.
+ *
+ * After success, invalidate {@link useGetBatchLimits}.
+ *
+ * @example
+ * const setLimit = useSetMaxBatchSizeHolding();
+ * setLimit.mutate({ size: 256n });
+ */
+export declare function useSetMaxBatchSizeHolding(options?: DisperseHookOptions): UseMutationResult<Hex, Error, UseSetMaxBatchSizeHoldingArgs>;

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

@@ -0,0 +1,20 @@
+import { type UseMutationResult } from "@tanstack/react-query";
+import type { Account, Address, Hex } from "viem";
+import { type DisperseHookOptions } from "./_shared.js";
+export interface UseSetMaxBatchSizeTokenFeeArgs {
+    /** Max recipients in a single `"wallet-token-fee"` mode call. `0n` = no limit. */
+    size: bigint;
+    /** Override signer account. Falls back to `walletClient.account`. */
+    account?: Account | Address;
+}
+/**
+ * Admin: set the maximum batch size for `"wallet-token-fee"` mode
+ * disperses. `0n` = no limit. Requires `DEFAULT_ADMIN_ROLE`.
+ *
+ * After success, invalidate {@link useGetBatchLimits}.
+ *
+ * @example
+ * const setLimit = useSetMaxBatchSizeTokenFee();
+ * setLimit.mutate({ size: 64n });
+ */
+export declare function useSetMaxBatchSizeTokenFee(options?: DisperseHookOptions): UseMutationResult<Hex, Error, UseSetMaxBatchSizeTokenFeeArgs>;

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

@@ -0,0 +1,13 @@
+import { type UseMutationResult } from "@tanstack/react-query";
+import { type BatchDiscloseHandlesArgs, type DisclosureResult } from "../types.js";
+import { type DisperseHookOptions } from "./_shared.js";
+/**
+ * Batch variant of {@link useDiscloseHandleToParty} — atomically grant
+ * `party` persistent ACL on all `handles`. Reverts on the first handle that
+ * fails caller-ACL or contract-ACL checks.
+ *
+ * @example
+ * const batchDisclose = useSingletonBatchDiscloseHandlesToParty();
+ * batchDisclose.mutate({ handles, party: accountingAddress });
+ */
+export declare function useSingletonBatchDiscloseHandlesToParty(options?: DisperseHookOptions): UseMutationResult<DisclosureResult, Error, BatchDiscloseHandlesArgs>;

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

@@ -0,0 +1,12 @@
+import { type UseQueryResult } from "@tanstack/react-query";
+import { type BatchLimits } from "../types.js";
+import { type BaseHookOptions } from "./_shared.js";
+/**
+ * Read the maximum batch size for each of the three disperse modes
+ * (`"wallet"`, `"direct"`, `"wallet-token-fee"`). `0n` means no limit.
+ *
+ * @example
+ * const { data: limits } = useSingletonBatchLimits();
+ * // limits → { holding, direct, tokenFee }
+ */
+export declare function useSingletonBatchLimits(options?: BaseHookOptions): UseQueryResult<BatchLimits, Error>;

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

@@ -0,0 +1,26 @@
+import { type UseQueryResult } from "@tanstack/react-query";
+import type { Address } from "viem";
+import { type CalculatedFee, type DisperseMode } from "../types.js";
+import { type BaseHookOptions } from "./_shared.js";
+export interface UseSingletonCalculateFeeArgs extends BaseHookOptions {
+    user?: Address;
+    mode?: DisperseMode;
+    recipients?: number;
+    /** Required for `"wallet-token-fee"` mode. */
+    totalTokens?: bigint;
+}
+/**
+ * Compute the exact fee for a disperse call before submitting — reads live
+ * fee data via `getFees(user)` and applies the mode-specific formula.
+ *
+ * - `"wallet"` / `"direct"`: `ethValue = recipients * gasFeeWei`, no token fee.
+ * - `"wallet-token-fee"`: `ethValue = 0n`, `tokenFeeAmount = totalTokens * tokenFeeBps / 10_000n`.
+ *
+ * Hook is disabled until `user`, `mode`, and `recipients` are set.
+ *
+ * @example
+ * const { data: fee } = useSingletonCalculateFee({
+ *   user, mode: "direct", recipients: 100,
+ * });
+ */
+export declare function useSingletonCalculateFee(args?: UseSingletonCalculateFeeArgs): UseQueryResult<CalculatedFee, Error>;

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

@@ -0,0 +1,11 @@
+import { type UseQueryResult } from "@tanstack/react-query";
+import { type BaseHookOptions } from "./_shared.js";
+/**
+ * Read the block number at which the singleton was deployed — useful as the
+ * `fromBlock` argument to `getLogs` when subscribing to events.
+ *
+ * @example
+ * const { data: deployBlock } = useSingletonDeploymentBlockNumber();
+ * publicClient.getLogs({ fromBlock: deployBlock, ... });
+ */
+export declare function useSingletonDeploymentBlockNumber(options?: BaseHookOptions): UseQueryResult<bigint, Error>;