@tokenops/sdk 1.0.0

package/dist/fhe-disperse/react/index.js

@@ -0,0 +1,522 @@
+import { resolveEncryptor, createConfidentialDisperseClient } from '../../chunk-QIHZVLIK.js';
+export { AlreadyRegisteredError, DEFAULT_ADMIN_ROLE, DisperseEncryptedReserveNotGrantedError, DisperseSubwalletNotFoundError, FEE_COLLECTOR_ROLE, FEE_MANAGER_ROLE, NotRegisteredError, PAUSER_ROLE, WITHDRAWER_ROLE, computeSubtotals, encryptUint64, encryptUint64Batch, resolveEncryptor } from '../../chunk-QIHZVLIK.js';
+import '../../chunk-WRCUDSUJ.js';
+import '../../chunk-7VELUOMI.js';
+import '../../chunk-ZXCOJY2Z.js';
+import '../../chunk-FYQ2UW4T.js';
+import '../../chunk-JFLEEXKP.js';
+import { getFheDisperseSingletonAddress } from '../../chunk-COPFW5Z4.js';
+import '../../chunk-BE2AIZ3K.js';
+import '../../chunk-Q2GP5UDC.js';
+import '../../chunk-KWFFIJYX.js';
+import { MissingClientError, DeploymentAddressUnavailableError } from '../../chunk-IVE3QEGD.js';
+export { AccessDeniedError, AlreadyInitializedError, BatchTooLargeError, ContractRevertError, DecryptionFailedError, DeploymentAddressUnavailableError, EncryptionFailedError, FeatureDisabledError, FheHandleNotAllowedError, InsufficientBalanceError, InsufficientFeeError, InsufficientGasFundsError, InvalidArgumentError, InvalidSignatureError, MissingAccountError, MissingClientError, MissingEncryptorError, MissingPublicClientError, MissingWalletClientError, NetworkError, PausedError, ReceiptEventAmbiguousError, ReceiptEventNotFoundError, ReentrancyError, RelayerUnreachableError, SigningFailedError, TokenOpsSdkError, TransferFailedError, UnknownWriteFailureError, UnsupportedChainError, UserDecryptNotAllowedError, UserRejectedSignatureError, WalletChainMismatchError, WalletRejectedError, isTokenOpsSdkError } from '../../chunk-IVE3QEGD.js';
+import { useQuery, useMutation } from '@tanstack/react-query';
+import { useRef, useMemo } from 'react';
+import { usePublicClient, useWalletClient } from 'wagmi';
+
+var FHE_DISPERSE_KEY = "tokenops-sdk";
+var FHE_DISPERSE_NAMESPACE = "fhe-disperse";
+function tryResolveSingletonAddress(override, chainId) {
+  if (override) return override;
+  if (chainId === void 0) return void 0;
+  return getFheDisperseSingletonAddress(chainId);
+}
+function useMemoDisperseClient(opts = {}) {
+  const publicClient = usePublicClient({ chainId: opts.chainId });
+  const { data: walletClient } = useWalletClient({ chainId: opts.chainId });
+  const chainId = opts.chainId ?? publicClient?.chain?.id;
+  const resolvedAddress = tryResolveSingletonAddress(opts.address, chainId);
+  const resolutionError = computeSingletonResolutionError(opts.address, chainId);
+  const encryptorSourceRef = useRef(opts.encryptor);
+  encryptorSourceRef.current = opts.encryptor;
+  const client = useMemo(() => {
+    if (!publicClient) return void 0;
+    if (!resolvedAddress) return void 0;
+    return createConfidentialDisperseClient({
+      publicClient,
+      ...walletClient ? { walletClient } : {},
+      address: resolvedAddress,
+      ...chainId !== void 0 ? { chainId } : {},
+      // Lazy — invoked per-encryption inside the headless client. Picks up
+      // whichever EncryptorSource the consumer last passed in.
+      encryptor: () => resolveEncryptor(encryptorSourceRef.current),
+      ...opts.aclAddress ? { aclAddress: opts.aclAddress } : {}
+    });
+  }, [publicClient, walletClient, resolvedAddress, chainId, opts.aclAddress]);
+  return {
+    client,
+    resolutionError,
+    publicClient,
+    walletClient: walletClient ?? void 0,
+    chainId,
+    resolvedAddress
+  };
+}
+function computeSingletonResolutionError(override, chainId) {
+  if (override) return void 0;
+  if (chainId === void 0) {
+    return new DeploymentAddressUnavailableError({
+      reason: "chain-id-missing",
+      product: "fheDisperse",
+      contract: "disperseConfidentialSingleton",
+      clientLabel: "ConfidentialDisperseClient"
+    });
+  }
+  const resolved = getFheDisperseSingletonAddress(chainId);
+  if (!resolved) {
+    return new DeploymentAddressUnavailableError({
+      reason: "registry-not-deployed",
+      product: "fheDisperse",
+      contract: "disperseConfidentialSingleton",
+      chainId,
+      clientLabel: "ConfidentialDisperseClient"
+    });
+  }
+  return void 0;
+}
+function buildQueryKey(method, chainId, address, ...args) {
+  return [
+    FHE_DISPERSE_KEY,
+    FHE_DISPERSE_NAMESPACE,
+    method,
+    chainId ?? null,
+    address ? address.toLowerCase() : null,
+    ...args.map(normalizeKeyArg)
+  ];
+}
+function normalizeKeyArg(value) {
+  if (typeof value === "bigint") return value.toString();
+  if (Array.isArray(value)) return value.map(normalizeKeyArg);
+  if (value && typeof value === "object") {
+    return Object.fromEntries(
+      Object.entries(value).map(([k, v]) => [k, normalizeKeyArg(v)])
+    );
+  }
+  if (typeof value === "string" && value.startsWith("0x")) return value.toLowerCase();
+  return value;
+}
+
+// src/fhe-disperse/react/useIsRegistered.ts
+function useIsRegistered(args = {}) {
+  const { user, ...base } = args;
+  const { client, chainId, resolvedAddress } = useMemoDisperseClient(base);
+  return useQuery({
+    queryKey: buildQueryKey("disperse:isRegistered", chainId, resolvedAddress, user),
+    queryFn: () => client.isRegistered(user),
+    enabled: !!client && !!user,
+    staleTime: 0
+  });
+}
+function useGetWallets(args = {}) {
+  const { user, ...base } = args;
+  const { client, chainId, resolvedAddress } = useMemoDisperseClient(base);
+  return useQuery({
+    queryKey: buildQueryKey("disperse:getWallets", chainId, resolvedAddress, user),
+    queryFn: () => client.getWallets(user),
+    enabled: !!client && !!user,
+    staleTime: 0
+  });
+}
+function usePredictWallets(args = {}) {
+  const { user, ...base } = args;
+  const { client, chainId, resolvedAddress } = useMemoDisperseClient(base);
+  return useQuery({
+    queryKey: buildQueryKey("disperse:predictWallets", chainId, resolvedAddress, user),
+    queryFn: () => client.predictWallets(user),
+    enabled: !!client && !!user,
+    staleTime: 0
+  });
+}
+function useGetFees(args = {}) {
+  const { user, ...base } = args;
+  const { client, chainId, resolvedAddress } = useMemoDisperseClient(base);
+  return useQuery({
+    queryKey: buildQueryKey("disperse:getFees", chainId, resolvedAddress, user),
+    queryFn: () => client.getFees(user),
+    enabled: !!client && !!user,
+    staleTime: 0
+  });
+}
+function useGetFeeConfig(options = {}) {
+  const { client, chainId, resolvedAddress } = useMemoDisperseClient(options);
+  return useQuery({
+    queryKey: buildQueryKey("disperse:getFeeConfig", chainId, resolvedAddress),
+    queryFn: () => client.getFeeConfig(),
+    enabled: !!client,
+    staleTime: 0
+  });
+}
+function useGetBatchLimits(options = {}) {
+  const { client, chainId, resolvedAddress } = useMemoDisperseClient(options);
+  return useQuery({
+    queryKey: buildQueryKey("disperse:getBatchLimits", chainId, resolvedAddress),
+    queryFn: () => client.getBatchLimits(),
+    enabled: !!client,
+    staleTime: 0
+  });
+}
+function useCalculateFee(args = {}) {
+  const { user, mode, recipients, totalTokens, ...base } = args;
+  const { client, chainId, resolvedAddress } = useMemoDisperseClient(base);
+  return useQuery({
+    queryKey: buildQueryKey(
+      "disperse:calculateFee",
+      chainId,
+      resolvedAddress,
+      user,
+      mode,
+      recipients,
+      totalTokens
+    ),
+    queryFn: () => {
+      const callArgs = {
+        user,
+        mode,
+        recipients,
+        ...totalTokens !== void 0 ? { totalTokens } : {}
+      };
+      return client.calculateFee(callArgs);
+    },
+    enabled: !!client && !!user && !!mode && recipients !== void 0,
+    staleTime: 0
+  });
+}
+function useHasApprovedSubwallets(args = {}) {
+  const { user, token, ...base } = args;
+  const { client, chainId, resolvedAddress } = useMemoDisperseClient(base);
+  return useQuery({
+    queryKey: buildQueryKey(
+      "disperse:hasApprovedSubwallets",
+      chainId,
+      resolvedAddress,
+      user,
+      token
+    ),
+    queryFn: () => client.hasApprovedSubwallets({ user, token }),
+    enabled: !!client && !!user && !!token,
+    staleTime: 0
+  });
+}
+function useHasRole(args = {}) {
+  const { role, account, ...base } = args;
+  const { client, chainId, resolvedAddress } = useMemoDisperseClient(base);
+  return useQuery({
+    queryKey: buildQueryKey("disperse:hasRole", chainId, resolvedAddress, role, account),
+    queryFn: () => client.hasRole(role, account),
+    enabled: !!client && !!role && !!account,
+    staleTime: 0
+  });
+}
+function useIsPaused(options = {}) {
+  const { client, chainId, resolvedAddress } = useMemoDisperseClient(options);
+  return useQuery({
+    queryKey: buildQueryKey("disperse:paused", chainId, resolvedAddress),
+    queryFn: () => client.paused(),
+    enabled: !!client,
+    staleTime: 0
+  });
+}
+function useDeploymentBlockNumber(options = {}) {
+  const { client, chainId, resolvedAddress } = useMemoDisperseClient(options);
+  return useQuery({
+    queryKey: buildQueryKey("disperse:deploymentBlockNumber", chainId, resolvedAddress),
+    queryFn: () => client.deploymentBlockNumber(),
+    enabled: !!client,
+    staleTime: 0
+  });
+}
+function useWalletImplementation(options = {}) {
+  const { client, chainId, resolvedAddress } = useMemoDisperseClient(options);
+  return useQuery({
+    queryKey: buildQueryKey("disperse:walletImplementation", chainId, resolvedAddress),
+    queryFn: () => client.walletImplementation(),
+    enabled: !!client,
+    staleTime: 0
+  });
+}
+function usePreflightDisperse(args = {}) {
+  const { user, token, recipients, amounts, mode, ...base } = args;
+  const { client, chainId, resolvedAddress } = useMemoDisperseClient(base);
+  return useQuery({
+    queryKey: buildQueryKey(
+      "disperse:preflightDisperse",
+      chainId,
+      resolvedAddress,
+      user,
+      token,
+      recipients,
+      amounts,
+      mode
+    ),
+    queryFn: () => client.preflightDisperse({
+      user,
+      token,
+      recipients,
+      amounts,
+      mode
+    }),
+    // Empty arrays must surface as headless `EmptyRecipientsError` / `EmptyAmountsError`
+    // blockers, so the gate enables once each input is *defined* (even if empty).
+    // The SDK explains the invalid state; the UI shouldn't sit in an idle query.
+    enabled: !!client && !!user && !!token && !!mode && !!recipients && !!amounts,
+    staleTime: 0
+  });
+}
+function useRegister(options = {}) {
+  const { client, resolutionError } = useMemoDisperseClient(options);
+  return useMutation({
+    mutationFn: async (args) => {
+      if (!client) {
+        throw resolutionError ?? new MissingClientError("useRegister", "disperse");
+      }
+      return client.register(args);
+    }
+  });
+}
+function useApproveTokenOnWallets(options = {}) {
+  const { client, resolutionError } = useMemoDisperseClient(options);
+  return useMutation({
+    mutationFn: async (args) => {
+      if (!client) {
+        throw resolutionError ?? new MissingClientError("useApproveTokenOnWallets", "disperse");
+      }
+      return client.approveTokenOnWallets(args);
+    }
+  });
+}
+function useRevokeTokenOnWallets(options = {}) {
+  const { client, resolutionError } = useMemoDisperseClient(options);
+  return useMutation({
+    mutationFn: async (args) => {
+      if (!client) {
+        throw resolutionError ?? new MissingClientError("useRevokeTokenOnWallets", "disperse");
+      }
+      return client.revokeTokenOnWallets(args);
+    }
+  });
+}
+function useRecoverFromWallets(options = {}) {
+  const { client, resolutionError } = useMemoDisperseClient(options);
+  return useMutation({
+    mutationFn: async (args) => {
+      if (!client) {
+        throw resolutionError ?? new MissingClientError("useRecoverFromWallets", "disperse");
+      }
+      return client.recoverFromWallets(args);
+    }
+  });
+}
+function useRecoverERC20FromWallets(options = {}) {
+  const { client, resolutionError } = useMemoDisperseClient(options);
+  return useMutation({
+    mutationFn: async (args) => {
+      if (!client) {
+        throw resolutionError ?? new MissingClientError("useRecoverERC20FromWallets", "disperse");
+      }
+      return client.recoverERC20FromWallets(args);
+    }
+  });
+}
+function useDisperse(options = {}) {
+  const { client, resolutionError } = useMemoDisperseClient(options);
+  return useMutation({
+    mutationFn: async (args) => {
+      if (!client) {
+        throw resolutionError ?? new MissingClientError("useDisperse", "disperse");
+      }
+      return client.disperse(args);
+    }
+  });
+}
+function useAccessEncryptedFeeReserve(options = {}) {
+  const { client, resolutionError } = useMemoDisperseClient(options);
+  return useMutation({
+    mutationFn: async (args) => {
+      if (!client) {
+        throw resolutionError ?? new MissingClientError("useAccessEncryptedFeeReserve", "disperse");
+      }
+      return client.getEncryptedFeeReserve(args);
+    }
+  });
+}
+var useGetEncryptedFeeReserve = useAccessEncryptedFeeReserve;
+function useDiscloseHandleToParty(options = {}) {
+  const { client, resolutionError } = useMemoDisperseClient(options);
+  return useMutation({
+    mutationFn: async (args) => {
+      if (!client) {
+        throw resolutionError ?? new MissingClientError("useDiscloseHandleToParty", "disperse");
+      }
+      return client.discloseHandleToParty(args);
+    }
+  });
+}
+function useBatchDiscloseHandlesToParty(options = {}) {
+  const { client, resolutionError } = useMemoDisperseClient(options);
+  return useMutation({
+    mutationFn: async (args) => {
+      if (!client) {
+        throw resolutionError ?? new MissingClientError("useBatchDiscloseHandlesToParty", "disperse");
+      }
+      return client.batchDiscloseHandlesToParty(args);
+    }
+  });
+}
+function usePause(options = {}) {
+  const { client, resolutionError } = useMemoDisperseClient(options);
+  return useMutation({
+    mutationFn: async ({ account }) => {
+      if (!client) throw resolutionError ?? new MissingClientError("usePause", "disperse");
+      return client.pause(account);
+    }
+  });
+}
+function useUnpause(options = {}) {
+  const { client, resolutionError } = useMemoDisperseClient(options);
+  return useMutation({
+    mutationFn: async ({ account }) => {
+      if (!client) throw resolutionError ?? new MissingClientError("useUnpause", "disperse");
+      return client.unpause(account);
+    }
+  });
+}
+function useSetFeeConfig(options = {}) {
+  const { client, resolutionError } = useMemoDisperseClient(options);
+  return useMutation({
+    mutationFn: async ({ config, account }) => {
+      if (!client) throw resolutionError ?? new MissingClientError("useSetFeeConfig", "disperse");
+      return client.setFeeConfig(config, account);
+    }
+  });
+}
+function useSetCustomFee(options = {}) {
+  const { client, resolutionError } = useMemoDisperseClient(options);
+  return useMutation({
+    mutationFn: async ({ user, gasFee, tokenFee, account }) => {
+      if (!client) throw resolutionError ?? new MissingClientError("useSetCustomFee", "disperse");
+      return client.setCustomFee(user, gasFee, tokenFee, account);
+    }
+  });
+}
+function useDisableCustomFee(options = {}) {
+  const { client, resolutionError } = useMemoDisperseClient(options);
+  return useMutation({
+    mutationFn: async ({ user, account }) => {
+      if (!client) {
+        throw resolutionError ?? new MissingClientError("useDisableCustomFee", "disperse");
+      }
+      return client.disableCustomFee(user, account);
+    }
+  });
+}
+function useSetMaxBatchSizeHolding(options = {}) {
+  const { client, resolutionError } = useMemoDisperseClient(options);
+  return useMutation({
+    mutationFn: async ({ size, account }) => {
+      if (!client) {
+        throw resolutionError ?? new MissingClientError("useSetMaxBatchSizeHolding", "disperse");
+      }
+      return client.setMaxBatchSizeHolding(size, account);
+    }
+  });
+}
+function useSetMaxBatchSizeDirect(options = {}) {
+  const { client, resolutionError } = useMemoDisperseClient(options);
+  return useMutation({
+    mutationFn: async ({ size, account }) => {
+      if (!client) {
+        throw resolutionError ?? new MissingClientError("useSetMaxBatchSizeDirect", "disperse");
+      }
+      return client.setMaxBatchSizeDirect(size, account);
+    }
+  });
+}
+function useSetMaxBatchSizeTokenFee(options = {}) {
+  const { client, resolutionError } = useMemoDisperseClient(options);
+  return useMutation({
+    mutationFn: async ({ size, account }) => {
+      if (!client) {
+        throw resolutionError ?? new MissingClientError("useSetMaxBatchSizeTokenFee", "disperse");
+      }
+      return client.setMaxBatchSizeTokenFee(size, account);
+    }
+  });
+}
+function useWithdrawGasFee(options = {}) {
+  const { client, resolutionError } = useMemoDisperseClient(options);
+  return useMutation({
+    mutationFn: async ({ to, amount, account }) => {
+      if (!client) throw resolutionError ?? new MissingClientError("useWithdrawGasFee", "disperse");
+      return client.withdrawGasFee(to, amount, account);
+    }
+  });
+}
+function useWithdrawTokenFee(options = {}) {
+  const { client, resolutionError } = useMemoDisperseClient(options);
+  return useMutation({
+    mutationFn: async (args) => {
+      if (!client) {
+        throw resolutionError ?? new MissingClientError("useWithdrawTokenFee", "disperse");
+      }
+      if (args.encryptedInput !== void 0) {
+        const { token: token2, to: to2, encryptedInput, account: account2 } = args;
+        return client.withdrawTokenFee({
+          token: token2,
+          to: to2,
+          encryptedInput,
+          ...account2 !== void 0 ? { account: account2 } : {}
+        });
+      }
+      const { token, to, amount, encryptor: encryptorSource, account } = args;
+      const eager = encryptorSource ? resolveEncryptor(encryptorSource) : void 0;
+      return client.withdrawTokenFee({
+        token,
+        to,
+        amount,
+        ...eager ? { encryptor: eager } : {},
+        ...account !== void 0 ? { account } : {}
+      });
+    }
+  });
+}
+function useRescueConfidentialTokens(options = {}) {
+  const { client, resolutionError } = useMemoDisperseClient(options);
+  return useMutation({
+    mutationFn: async ({ token, to, account }) => {
+      if (!client) {
+        throw resolutionError ?? new MissingClientError("useRescueConfidentialTokens", "disperse");
+      }
+      return client.rescueConfidentialTokens(token, to, account);
+    }
+  });
+}
+function useRescueERC20(options = {}) {
+  const { client, resolutionError } = useMemoDisperseClient(options);
+  return useMutation({
+    mutationFn: async ({ token, to, account }) => {
+      if (!client) throw resolutionError ?? new MissingClientError("useRescueERC20", "disperse");
+      return client.rescueERC20(token, to, account);
+    }
+  });
+}
+function useGrantRole(options = {}) {
+  const { client, resolutionError } = useMemoDisperseClient(options);
+  return useMutation({
+    mutationFn: async ({ role, accountTarget, account }) => {
+      if (!client) throw resolutionError ?? new MissingClientError("useGrantRole", "disperse");
+      return client.grantRole(role, accountTarget, account);
+    }
+  });
+}
+function useRevokeRole(options = {}) {
+  const { client, resolutionError } = useMemoDisperseClient(options);
+  return useMutation({
+    mutationFn: async ({ role, accountTarget, account }) => {
+      if (!client) throw resolutionError ?? new MissingClientError("useRevokeRole", "disperse");
+      return client.revokeRole(role, accountTarget, account);
+    }
+  });
+}
+
+export { FHE_DISPERSE_KEY, FHE_DISPERSE_NAMESPACE, useAccessEncryptedFeeReserve, useApproveTokenOnWallets, useBatchDiscloseHandlesToParty, useCalculateFee, useDeploymentBlockNumber, useDisableCustomFee, useDiscloseHandleToParty, useDisperse, useGetBatchLimits, useGetEncryptedFeeReserve, useGetFeeConfig, useGetFees, useGetWallets, useGrantRole, useHasApprovedSubwallets, useHasRole, useIsPaused, useIsRegistered, usePause, usePredictWallets, usePreflightDisperse, useRecoverERC20FromWallets, useRecoverFromWallets, useRegister, useRescueConfidentialTokens, useRescueERC20, useRevokeRole, useRevokeTokenOnWallets, useSetCustomFee, useSetFeeConfig, useSetMaxBatchSizeDirect, useSetMaxBatchSizeHolding, useSetMaxBatchSizeTokenFee, useUnpause, useWalletImplementation, useWithdrawGasFee, useWithdrawTokenFee };

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

@@ -0,0 +1,35 @@
+import { type UseMutationResult } from "@tanstack/react-query";
+import { type EncryptedViewResult, type GetEncryptedFeeReserveArgs } from "../types.js";
+import { type DisperseHookOptions } from "./_shared.js";
+/**
+ * **MUTATION — submits a transaction (costs gas).** Mirrors the on-chain
+ * `accessEncryptedFeeReserve(token)` function: grants the caller persistent
+ * decrypt access to the encrypted token fee reserve as an `euint64` handle.
+ *
+ * The handle is granted persistent ACL on-chain via
+ * `FHE.allow(handle, msg.sender)`; the SDK extracts it from the receipt's
+ * `ACL.Allowed` event (NOT from simulation — that returns a divergent,
+ * ACL-less handle; see CLAUDE.md Pitfall #1).
+ *
+ * Pass `data.handle` to the Zama relayer's `userDecrypt` to obtain the
+ * plaintext reserve amount.
+ *
+ * **Throws {@link DisperseEncryptedReserveNotGrantedError}** when no ACL
+ * event is found — typically means the reserve is uninitialised (no fees
+ * accrued for this token yet). The SDK does not silently return a zero handle
+ * because Zama's relayer cannot decrypt an uninitialised handle.
+ *
+ * Requires `FEE_COLLECTOR_ROLE` or `DEFAULT_ADMIN_ROLE` on the singleton.
+ *
+ * @example
+ * const view = useAccessEncryptedFeeReserve();
+ * view.mutate({ token });
+ * // view.data → { handle: "0x...", hash: "0x..." }
+ */
+export declare function useAccessEncryptedFeeReserve(options?: DisperseHookOptions): UseMutationResult<EncryptedViewResult, Error, GetEncryptedFeeReserveArgs>;
+/**
+ * @deprecated Renamed to {@link useAccessEncryptedFeeReserve} to mirror the
+ *   contract function and signal that this is a mutation (not a query). The
+ *   old name remains as a re-export and will be removed in the next major.
+ */
+export declare const useGetEncryptedFeeReserve: typeof useAccessEncryptedFeeReserve;

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

@@ -0,0 +1,25 @@
+import { type UseMutationResult } from "@tanstack/react-query";
+import type { Account, Address, Hex } from "viem";
+import { type DisperseHookOptions } from "./_shared.js";
+export interface UseApproveTokenOnWalletsArgs {
+    /** ERC-7984 token to approve as operator on the caller's wallets. */
+    token: Address;
+    /** Override signer account. Falls back to `walletClient.account`. */
+    account?: Account | Address;
+}
+/**
+ * Approve the caller's existing registered wallets as ERC-7984 operators for
+ * `token`. Required for wallet-mode disperses on a token different from the
+ * one passed at registration.
+ *
+ * **Prerequisite:** call {@link useRegister} first — this hook reverts with
+ * `UserNotRegistered` if the caller has no wallet pair on the singleton.
+ *
+ * After success, invalidate
+ * {@link useHasApprovedSubwallets}`({ user, token })`.
+ *
+ * @example
+ * const approve = useApproveTokenOnWallets();
+ * approve.mutate({ token });
+ */
+export declare function useApproveTokenOnWallets(options?: DisperseHookOptions): UseMutationResult<Hex, Error, UseApproveTokenOnWalletsArgs>;

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

@@ -0,0 +1,16 @@
+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.
+ *
+ * Returns `{ hash, discloser, party, disclosedHandles }` parsed from the
+ * `HandlesDisclosedToParty` event.
+ *
+ * @example
+ * const batchDisclose = useBatchDiscloseHandlesToParty();
+ * batchDisclose.mutate({ handles, party: accountingAddress });
+ */
+export declare function useBatchDiscloseHandlesToParty(options?: DisperseHookOptions): UseMutationResult<DisclosureResult, Error, BatchDiscloseHandlesArgs>;

package/dist/fhe-disperse/react/useCalculateFee.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 UseCalculateFeeArgs 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 } = useCalculateFee({
+ *   user, mode: "direct", recipients: 100,
+ * });
+ */
+export declare function useCalculateFee(args?: UseCalculateFeeArgs): UseQueryResult<CalculatedFee, Error>;

package/dist/fhe-disperse/react/useDeploymentBlockNumber.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 } = useDeploymentBlockNumber();
+ * publicClient.getLogs({ fromBlock: deployBlock, ... });
+ */
+export declare function useDeploymentBlockNumber(options?: BaseHookOptions): UseQueryResult<bigint, Error>;

package/dist/fhe-disperse/react/useDisableCustomFee.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 UseDisableCustomFeeArgs {
+    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 = useDisableCustomFee();
+ * disableCustomFee.mutate({ user });
+ */
+export declare function useDisableCustomFee(options?: DisperseHookOptions): UseMutationResult<Hex, Error, UseDisableCustomFeeArgs>;

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

@@ -0,0 +1,20 @@
+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.
+ *
+ * Returns `{ hash, discloser, party, disclosedHandles }` parsed from the
+ * `HandlesDisclosedToParty` event.
+ *
+ * @example
+ * const disclose = useDiscloseHandleToParty();
+ * disclose.mutate({ handle, party: accountingAddress });
+ */
+export declare function useDiscloseHandleToParty(options?: DisperseHookOptions): UseMutationResult<DisclosureResult, Error, DiscloseHandleArgs>;