@tokenops/sdk 1.0.0

package/dist/fhe-airdrop/react/useAirdropClaim.d.ts

@@ -0,0 +1,25 @@
+import { type UseMutationResult } from "@tanstack/react-query";
+import type { TxHash } from "../../core/brands.js";
+import type { ClaimArgs } from "../airdrop.js";
+import { type AirdropHookOptions } from "./_shared.js";
+/**
+ * Claim tokens from an airdrop using an EIP-712 admin signature. The SDK
+ * encrypts the plaintext `amount` into an `externalEuint64` and submits it
+ * with an input proof — callers never handle ciphertext. Attaches `GAS_FEE()`
+ * ETH automatically unless `args.value` is set.
+ *
+ * **Encryptor resolution.** The hook-level `encryptor` (from
+ * {@link AirdropHookOptions}) is forwarded lazily to the SDK client. You can
+ * also pass `encryptor` per-mutation via `args.encryptor` to override it. If
+ * neither is present, the SDK throws `Missing encryptor — pass encryptor…`
+ * verbatim.
+ *
+ * After a successful claim, invalidate
+ * `useAirdropIsSignatureClaimed({ user, encryptedAmountHandle })` and any
+ * UI counts you computed off it.
+ *
+ * @example
+ * const claim = useAirdropClaim({ address: airdropAddress, encryptor: () => useZamaSDK().relayer });
+ * claim.mutate({ amount: 1_000_000n, signature });
+ */
+export declare function useAirdropClaim(options: AirdropHookOptions): UseMutationResult<TxHash, Error, ClaimArgs>;

package/dist/fhe-airdrop/react/useAirdropClaimTypehash.d.ts

@@ -0,0 +1,10 @@
+import { type UseQueryResult } from "@tanstack/react-query";
+import type { Hex } from "viem";
+import { type AirdropHookOptions } from "./_shared.js";
+/**
+ * Read the EIP-712 type hash for `Claim(address recipient, bytes32 encryptedAmount)`.
+ * Useful for off-chain signers that assemble the typed-data payload manually
+ * (custom HSM-backed signers, ledger flows) instead of calling
+ * {@link signClaimAuthorization}.
+ */
+export declare function useAirdropClaimTypehash(options: AirdropHookOptions): UseQueryResult<Hex, Error>;

package/dist/fhe-airdrop/react/useAirdropClaimedSignatures.d.ts

@@ -0,0 +1,16 @@
+import { type UseQueryResult } from "@tanstack/react-query";
+import type { Hex } from "viem";
+import { type AirdropHookOptions } from "./_shared.js";
+export interface UseAirdropClaimedSignaturesArgs extends AirdropHookOptions {
+    /** EIP-712 struct hash of a `Claim`. Hook is disabled until set. */
+    signatureHash?: Hex;
+}
+/**
+ * Check whether a pre-computed claim struct hash has been consumed on this
+ * airdrop clone.
+ *
+ * Prefer {@link useAirdropIsSignatureClaimed} unless you already hold the
+ * pre-computed `bytes32` struct hash — that hook takes the more common
+ * `(user, encryptedAmountHandle)` shape and computes the hash for you.
+ */
+export declare function useAirdropClaimedSignatures(args: UseAirdropClaimedSignaturesArgs): UseQueryResult<boolean, Error>;

package/dist/fhe-airdrop/react/useAirdropDeploymentBlockNumber.d.ts

@@ -0,0 +1,6 @@
+import { type UseQueryResult } from "@tanstack/react-query";
+import { type AirdropHookOptions } from "./_shared.js";
+/**
+ * Read the block number at which this airdrop clone was deployed.
+ */
+export declare function useAirdropDeploymentBlockNumber(options: AirdropHookOptions): UseQueryResult<bigint, Error>;

package/dist/fhe-airdrop/react/useAirdropDomainSeparator.d.ts

@@ -0,0 +1,8 @@
+import { type UseQueryResult } from "@tanstack/react-query";
+import type { Hex } from "viem";
+import { type AirdropHookOptions } from "./_shared.js";
+/**
+ * Read the EIP-712 domain separator for this airdrop clone. Useful for
+ * off-chain signing tools that build claim authorizations server-side.
+ */
+export declare function useAirdropDomainSeparator(options: AirdropHookOptions): UseQueryResult<Hex, Error>;

package/dist/fhe-airdrop/react/useAirdropEndTime.d.ts

@@ -0,0 +1,10 @@
+import { type UseQueryResult } from "@tanstack/react-query";
+import { type AirdropHookOptions } from "./_shared.js";
+/**
+ * Read the airdrop clone's `endTime` — the unix timestamp when claims close.
+ * Mutable: the admin can extend it via `useExtendClaimWindow` when
+ * `canExtendClaimWindow()` is `true`.
+ *
+ * After a successful `useExtendClaimWindow`, invalidate this query.
+ */
+export declare function useAirdropEndTime(options: AirdropHookOptions): UseQueryResult<number, Error>;

package/dist/fhe-airdrop/react/useAirdropFactoryCustomFee.d.ts

@@ -0,0 +1,17 @@
+import { type UseQueryResult } from "@tanstack/react-query";
+import type { Address } from "viem";
+import { type CustomFee } from "../types.js";
+import { type BaseHookOptions } from "./_shared.js";
+export interface UseAirdropFactoryCustomFeeArgs extends BaseHookOptions {
+    /** Address whose per-creator fee override to read. Hook is disabled until set. */
+    creator?: Address;
+}
+/**
+ * Read the per-creator fee override set on the factory for `creator`. Returns
+ * `{ enabled: false, gasFee: 0n }` when no override exists.
+ *
+ * @example
+ * const { data: customFee } = useAirdropFactoryCustomFee({ creator });
+ * if (customFee?.enabled) { ... use customFee.gasFee ... }
+ */
+export declare function useAirdropFactoryCustomFee(args?: UseAirdropFactoryCustomFeeArgs): UseQueryResult<CustomFee, Error>;

package/dist/fhe-airdrop/react/useAirdropFactoryDefaultGasFee.d.ts

@@ -0,0 +1,10 @@
+import { type UseQueryResult } from "@tanstack/react-query";
+import { type BaseHookOptions } from "./_shared.js";
+/**
+ * Read the factory-wide default per-claim gas fee (in wei) — applied to new
+ * airdrop clones at deployment when the creator has no custom override.
+ *
+ * @example
+ * const { data: defaultGasFee } = useAirdropFactoryDefaultGasFee();
+ */
+export declare function useAirdropFactoryDefaultGasFee(options?: BaseHookOptions): UseQueryResult<bigint, Error>;

package/dist/fhe-airdrop/react/useAirdropFactoryDisableCustomFee.d.ts

@@ -0,0 +1,15 @@
+import { type UseMutationResult } from "@tanstack/react-query";
+import type { Account, Address } from "viem";
+import type { TxHash } from "../../core/brands.js";
+import { type BaseHookOptions } from "./_shared.js";
+export interface UseAirdropFactoryDisableCustomFeeArgs {
+    campaignCreator: Address;
+    account?: Account | Address;
+}
+/**
+ * Admin: remove a per-creator fee override, reverting to `defaultGasFee`.
+ * Requires `FEE_MANAGER_ROLE`.
+ *
+ * After success, invalidate `useFactoryCustomFee({ creator: campaignCreator })`.
+ */
+export declare function useAirdropFactoryDisableCustomFee(options?: BaseHookOptions): UseMutationResult<TxHash, Error, UseAirdropFactoryDisableCustomFeeArgs>;

package/dist/fhe-airdrop/react/useAirdropFactoryFeeCollector.d.ts

@@ -0,0 +1,11 @@
+import { type UseQueryResult } from "@tanstack/react-query";
+import type { Address } from "viem";
+import { type BaseHookOptions } from "./_shared.js";
+/**
+ * Read the factory's current fee collector address — the account authorized to
+ * call `withdrawGasFee` on each deployed airdrop clone.
+ *
+ * @example
+ * const { data: feeCollector } = useAirdropFactoryFeeCollector();
+ */
+export declare function useAirdropFactoryFeeCollector(options?: BaseHookOptions): UseQueryResult<Address, Error>;

package/dist/fhe-airdrop/react/useAirdropFactoryInitCodeHash.d.ts

@@ -0,0 +1,17 @@
+import { type UseQueryResult } from "@tanstack/react-query";
+import type { Hex } from "viem";
+import { type AirdropParams } from "../types.js";
+import { type BaseHookOptions } from "./_shared.js";
+export interface UseAirdropFactoryInitCodeHashArgs extends BaseHookOptions {
+    params?: AirdropParams;
+    gasFee?: bigint;
+}
+/**
+ * Read the init-code hash the factory would use to CREATE2 an airdrop clone
+ * with the given `params` + `gasFee`. Mirrors Solidity's `getInitCodeHash`
+ * selector.
+ *
+ * @example
+ * const { data: initCodeHash } = useAirdropFactoryInitCodeHash({ params, gasFee });
+ */
+export declare function useAirdropFactoryInitCodeHash(args?: UseAirdropFactoryInitCodeHashArgs): UseQueryResult<Hex, Error>;

package/dist/fhe-airdrop/react/useAirdropFactorySetCustomFee.d.ts

@@ -0,0 +1,17 @@
+import { type UseMutationResult } from "@tanstack/react-query";
+import type { Account, Address } from "viem";
+import type { TxHash } from "../../core/brands.js";
+import { type BaseHookOptions } from "./_shared.js";
+export interface UseAirdropFactorySetCustomFeeArgs {
+    campaignCreator: Address;
+    gasFee: bigint;
+    account?: Account | Address;
+}
+/**
+ * Admin: install a per-creator gas-fee override on the factory. Takes
+ * precedence over `defaultGasFee` for all airdrops `campaignCreator` deploys
+ * after the override. Requires `FEE_MANAGER_ROLE`.
+ *
+ * After success, invalidate `useFactoryCustomFee({ creator: campaignCreator })`.
+ */
+export declare function useAirdropFactorySetCustomFee(options?: BaseHookOptions): UseMutationResult<TxHash, Error, UseAirdropFactorySetCustomFeeArgs>;

package/dist/fhe-airdrop/react/useAirdropFactorySetDefaultGasFee.d.ts

@@ -0,0 +1,16 @@
+import { type UseMutationResult } from "@tanstack/react-query";
+import type { Account, Address } from "viem";
+import type { TxHash } from "../../core/brands.js";
+import { type BaseHookOptions } from "./_shared.js";
+export interface UseAirdropFactorySetDefaultGasFeeArgs {
+    newGasFee: bigint;
+    account?: Account | Address;
+}
+/**
+ * Admin: change the factory-wide default per-claim gas fee. Requires
+ * `FEE_MANAGER_ROLE`. Only affects airdrops deployed AFTER this call — already
+ * deployed clones carry the gas fee as an immutable arg.
+ *
+ * After success, invalidate `useFactoryDefaultGasFee()`.
+ */
+export declare function useAirdropFactorySetDefaultGasFee(options?: BaseHookOptions): UseMutationResult<TxHash, Error, UseAirdropFactorySetDefaultGasFeeArgs>;

package/dist/fhe-airdrop/react/useAirdropFactorySetFeeCollector.d.ts

@@ -0,0 +1,15 @@
+import { type UseMutationResult } from "@tanstack/react-query";
+import type { Account, Address } from "viem";
+import type { TxHash } from "../../core/brands.js";
+import { type BaseHookOptions } from "./_shared.js";
+export interface UseAirdropFactorySetFeeCollectorArgs {
+    newFeeCollector: Address;
+    account?: Account | Address;
+}
+/**
+ * Admin: change the factory's fee collector address. Requires
+ * `FEE_MANAGER_ROLE`.
+ *
+ * After success, invalidate `useFactoryFeeCollector()`.
+ */
+export declare function useAirdropFactorySetFeeCollector(options?: BaseHookOptions): UseMutationResult<TxHash, Error, UseAirdropFactorySetFeeCollectorArgs>;

package/dist/fhe-airdrop/react/useAirdropGasFee.d.ts

@@ -0,0 +1,11 @@
+import { type UseQueryResult } from "@tanstack/react-query";
+import { type AirdropHookOptions } from "./_shared.js";
+/**
+ * Read the airdrop clone's immutable per-claim gas fee (in wei). Attached as
+ * `msg.value` by `claim()` automatically when the consumer doesn't pass
+ * `value` explicitly.
+ *
+ * @example
+ * const { data: gasFee } = useAirdropGasFee({ address: airdropAddress });
+ */
+export declare function useAirdropGasFee(options: AirdropHookOptions): UseQueryResult<bigint, Error>;

package/dist/fhe-airdrop/react/useAirdropGrantRole.d.ts

@@ -0,0 +1,16 @@
+import { type UseMutationResult } from "@tanstack/react-query";
+import type { Account, Address, Hex } from "viem";
+import { type AirdropHookOptions } from "./_shared.js";
+export interface UseAirdropGrantRoleArgs {
+    role: Hex;
+    accountTarget: Address;
+    account?: Account | Address;
+}
+/**
+ * AccessControl: grant `role` to `accountTarget` on this airdrop clone.
+ * Caller must be a member of the role's admin role (typically
+ * `DEFAULT_ADMIN_ROLE`).
+ *
+ * After success, invalidate `useAirdropHasRole({ role, account: accountTarget })`.
+ */
+export declare function useAirdropGrantRole(options: AirdropHookOptions): UseMutationResult<Hex, Error, UseAirdropGrantRoleArgs>;

package/dist/fhe-airdrop/react/useAirdropHasClaimEnded.d.ts

@@ -0,0 +1,7 @@
+import { type UseQueryResult } from "@tanstack/react-query";
+import { type AirdropHookOptions } from "./_shared.js";
+/**
+ * Read whether the current chain timestamp is past `endTime` on this airdrop
+ * clone. Free chain read — no gas, no tx.
+ */
+export declare function useAirdropHasClaimEnded(options: AirdropHookOptions): UseQueryResult<boolean, Error>;

package/dist/fhe-airdrop/react/useAirdropHasClaimStarted.d.ts

@@ -0,0 +1,7 @@
+import { type UseQueryResult } from "@tanstack/react-query";
+import { type AirdropHookOptions } from "./_shared.js";
+/**
+ * Read whether the current chain timestamp is past `START_TIME` on this
+ * airdrop clone. Free chain read — no gas, no tx.
+ */
+export declare function useAirdropHasClaimStarted(options: AirdropHookOptions): UseQueryResult<boolean, Error>;

package/dist/fhe-airdrop/react/useAirdropHasRole.d.ts

@@ -0,0 +1,14 @@
+import { type UseQueryResult } from "@tanstack/react-query";
+import type { Address, Hex } from "viem";
+import { type AirdropHookOptions } from "./_shared.js";
+export interface UseAirdropHasRoleArgs extends AirdropHookOptions {
+    role?: Hex;
+    account?: Address;
+}
+/**
+ * Read AccessControl: is `account` a member of `role` on this airdrop clone?
+ *
+ * The role hashes are stable across deployments (DEFAULT_ADMIN_ROLE,
+ * FEE_COLLECTOR_ROLE, etc.).
+ */
+export declare function useAirdropHasRole(args: UseAirdropHasRoleArgs): UseQueryResult<boolean, Error>;

package/dist/fhe-airdrop/react/useAirdropIsClaimWindowActive.d.ts

@@ -0,0 +1,9 @@
+import { type UseQueryResult } from "@tanstack/react-query";
+import { type AirdropHookOptions } from "./_shared.js";
+/**
+ * Read whether the airdrop is currently within its claim window AND not paused.
+ * Free chain read — no gas, no tx.
+ *
+ * Use this as a pre-claim UI gate.
+ */
+export declare function useAirdropIsClaimWindowActive(options: AirdropHookOptions): UseQueryResult<boolean, Error>;

package/dist/fhe-airdrop/react/useAirdropIsPaused.d.ts

@@ -0,0 +1,8 @@
+import { type UseQueryResult } from "@tanstack/react-query";
+import { type AirdropHookOptions } from "./_shared.js";
+/**
+ * Read whether claims are currently paused by the admin on this airdrop clone.
+ *
+ * After a successful `useSetPaused`, invalidate this query.
+ */
+export declare function useAirdropIsPaused(options: AirdropHookOptions): UseQueryResult<boolean, Error>;

package/dist/fhe-airdrop/react/useAirdropIsSignatureClaimed.d.ts

@@ -0,0 +1,22 @@
+import { type UseQueryResult } from "@tanstack/react-query";
+import type { Address, Hex } from "viem";
+import { type AirdropHookOptions } from "./_shared.js";
+export interface UseAirdropIsSignatureClaimedArgs extends AirdropHookOptions {
+    /** Recipient address from the claim authorization. */
+    user?: Address;
+    /** `externalEuint64` handle (as `Hex`) from the claim payload. */
+    encryptedAmountHandle?: Hex;
+}
+/**
+ * Check whether a claim has been consumed for a `(user, encryptedAmountHandle)`
+ * pair on this airdrop clone. The contract recomputes the struct hash
+ * internally and looks it up in storage.
+ *
+ * Most frontends want this hook over {@link useAirdropClaimedSignatures} —
+ * pass the same `user` + `encryptedAmountHandle` that appear in the
+ * admin-issued claim payload.
+ *
+ * After a successful {@link useClaim}, invalidate this query for the claimed
+ * `(user, encryptedAmountHandle)` pair.
+ */
+export declare function useAirdropIsSignatureClaimed(args: UseAirdropIsSignatureClaimedArgs): UseQueryResult<boolean, Error>;

package/dist/fhe-airdrop/react/useAirdropIsSignatureValid.d.ts

@@ -0,0 +1,50 @@
+import { type UseQueryResult } from "@tanstack/react-query";
+import type { Address, Hex } from "viem";
+import { type AirdropHookOptions } from "./_shared.js";
+export interface UseAirdropIsSignatureValidArgs extends AirdropHookOptions {
+    /** `externalEuint64` handle (as `Hex`) from the claim payload. */
+    encryptedAmountHandle?: Hex;
+    /** EIP-712 admin signature over `Claim(address recipient, bytes32 encryptedAmount)`. */
+    signature?: Hex;
+    /**
+     * Caller address — the contract recomputes the struct hash over
+     * `(msg.sender, encryptedAmount)`, so validity is caller-specific.
+     * Defaults to the connected wallet via `wagmi`'s `useAccount()`; pass
+     * explicitly to check on behalf of another address.
+     */
+    caller?: Address;
+}
+/**
+ * Check whether an admin-issued claim authorization is valid for a specific
+ * caller, without consuming it.
+ *
+ * The query has **two distinct failure shapes** that must be handled separately:
+ *
+ * - `data === false`: the signature is structurally valid but fails the on-chain
+ *   check — already claimed, claim window inactive, or signer lacks
+ *   `DEFAULT_ADMIN_ROLE`.
+ * - `error?.code === "TOKENOPS_INVALID_SIGNATURE"`: the signature bytes are
+ *   structurally malformed (wrong length, invalid `s`-value range, unparseable).
+ *   The on-chain `ECDSA.recover` reverts before the boolean logic runs, so this
+ *   shows up on `error`, not on `data`.
+ *
+ * ```ts
+ * const sig = useAirdropIsSignatureValid({ address, encryptedAmountHandle, signature, caller });
+ * if (sig.error?.code === "TOKENOPS_INVALID_SIGNATURE") {
+ *   // malformed signature bytes
+ * } else if (sig.data === false) {
+ *   // wrong signer, already claimed, or window closed
+ * } else if (sig.data === true) {
+ *   // ready to claim
+ * }
+ * ```
+ *
+ * The result is caller-specific (the on-chain check binds to `msg.sender`).
+ * `caller` defaults to the connected wallet; the query stays disabled until
+ * a caller is available, and the caller is part of the query key so cached
+ * results don't bleed across account switches.
+ *
+ * Use this to show a pre-claim validation state in the UI before asking the
+ * user to pay gas.
+ */
+export declare function useAirdropIsSignatureValid(args: UseAirdropIsSignatureValidArgs): UseQueryResult<boolean, Error>;

package/dist/fhe-airdrop/react/useAirdropRevokeRole.d.ts

@@ -0,0 +1,15 @@
+import { type UseMutationResult } from "@tanstack/react-query";
+import type { Account, Address, Hex } from "viem";
+import { type AirdropHookOptions } from "./_shared.js";
+export interface UseAirdropRevokeRoleArgs {
+    role: Hex;
+    accountTarget: Address;
+    account?: Account | Address;
+}
+/**
+ * AccessControl: revoke `role` from `accountTarget` on this airdrop clone.
+ * Caller must be a member of the role's admin role.
+ *
+ * After success, invalidate `useAirdropHasRole({ role, account: accountTarget })`.
+ */
+export declare function useAirdropRevokeRole(options: AirdropHookOptions): UseMutationResult<Hex, Error, UseAirdropRevokeRoleArgs>;

package/dist/fhe-airdrop/react/useAirdropStartTime.d.ts

@@ -0,0 +1,10 @@
+import { type UseQueryResult } from "@tanstack/react-query";
+import { type AirdropHookOptions } from "./_shared.js";
+/**
+ * Read the airdrop clone's immutable `START_TIME` — the unix timestamp when
+ * claims become available.
+ *
+ * @example
+ * const { data: startTime } = useAirdropStartTime({ address: airdropAddress });
+ */
+export declare function useAirdropStartTime(options: AirdropHookOptions): UseQueryResult<number, Error>;

package/dist/fhe-airdrop/react/useAirdropToken.d.ts

@@ -0,0 +1,11 @@
+import { type UseQueryResult } from "@tanstack/react-query";
+import type { Address } from "viem";
+import { type AirdropHookOptions } from "./_shared.js";
+/**
+ * Read the airdrop clone's immutable `TOKEN`. Result is cacheable for the
+ * clone's lifetime — the field is baked into the clone's bytecode.
+ *
+ * @example
+ * const { data: token } = useAirdropToken({ address: airdropAddress });
+ */
+export declare function useAirdropToken(options: AirdropHookOptions): UseQueryResult<Address, Error>;

package/dist/fhe-airdrop/react/useAirdropWithdrawGasFee.d.ts

@@ -0,0 +1,15 @@
+import { type UseMutationResult } from "@tanstack/react-query";
+import type { Account, Address, Hex } from "viem";
+import { type AirdropHookOptions } from "./_shared.js";
+export interface UseAirdropWithdrawGasFeeArgs {
+    recipient: Address;
+    /** Amount of ETH to withdraw (in wei). Pass `0n` to withdraw the entire balance. */
+    amount: bigint;
+    account?: Account | Address;
+}
+/**
+ * Fee collector: withdraw collected ETH gas fees from the airdrop clone.
+ * Requires `FEE_COLLECTOR_ROLE`. Pass `amount = 0n` to withdraw the entire
+ * balance.
+ */
+export declare function useAirdropWithdrawGasFee(options: AirdropHookOptions): UseMutationResult<Hex, Error, UseAirdropWithdrawGasFeeArgs>;

package/dist/fhe-airdrop/react/useAirdropWithdrawOtherConfidentialToken.d.ts

@@ -0,0 +1,14 @@
+import { type UseMutationResult } from "@tanstack/react-query";
+import type { Account, Address } from "viem";
+import type { TxHash } from "../../core/brands.js";
+import { type AirdropHookOptions } from "./_shared.js";
+export interface UseAirdropWithdrawOtherConfidentialTokenArgs {
+    tokenAddress: Address;
+    recipient: Address;
+    account?: Account | Address;
+}
+/**
+ * Admin: rescue accidentally sent ERC-7984 confidential tokens (other than
+ * this airdrop's configured `TOKEN`). Requires `DEFAULT_ADMIN_ROLE`.
+ */
+export declare function useAirdropWithdrawOtherConfidentialToken(options: AirdropHookOptions): UseMutationResult<TxHash, Error, UseAirdropWithdrawOtherConfidentialTokenArgs>;

package/dist/fhe-airdrop/react/useAirdropWithdrawOtherToken.d.ts

@@ -0,0 +1,14 @@
+import { type UseMutationResult } from "@tanstack/react-query";
+import type { Account, Address } from "viem";
+import type { TxHash } from "../../core/brands.js";
+import { type AirdropHookOptions } from "./_shared.js";
+export interface UseAirdropWithdrawOtherTokenArgs {
+    tokenAddress: Address;
+    recipient: Address;
+    account?: Account | Address;
+}
+/**
+ * Admin: rescue accidentally sent ERC-20 (non-confidential) tokens. Requires
+ * `DEFAULT_ADMIN_ROLE`.
+ */
+export declare function useAirdropWithdrawOtherToken(options: AirdropHookOptions): UseMutationResult<TxHash, Error, UseAirdropWithdrawOtherTokenArgs>;

package/dist/fhe-airdrop/react/useClaim.d.ts

@@ -0,0 +1,29 @@
+import { type UseMutationResult } from "@tanstack/react-query";
+import type { Hex } from "viem";
+import type { ClaimArgs } from "../airdrop.js";
+import { type AirdropHookOptions } from "./_shared.js";
+/**
+ * Claim tokens from an airdrop using an EIP-712 admin signature. Submits the
+ * admin-issued `{ encryptedInput, signature }` pair verbatim — the SDK does
+ * NOT re-encrypt on the recipient side, because the signature commits to the
+ * exact `bytes32` handle and any re-encryption would invalidate it.
+ *
+ * Attaches `GAS_FEE()` ETH as `msg.value` automatically unless `args.value` is
+ * set.
+ *
+ * The admin builds `encryptedInput` server-side via
+ * {@link encryptUint64} with `userAddress: recipient` (Zama input proofs are
+ * bound to the recipient), then signs the resulting handle with
+ * {@link signClaimAuthorization}. Deliver `(encryptedInput, signature)` to
+ * the recipient via your channel of choice; the recipient passes the pair to
+ * this hook unchanged.
+ *
+ * After a successful claim, invalidate
+ * `useAirdropIsSignatureClaimed({ user, encryptedAmountHandle })` and any
+ * UI counts you computed off it.
+ *
+ * @example
+ * const claim = useClaim({ address: airdropAddress });
+ * claim.mutate({ encryptedInput, signature });
+ */
+export declare function useClaim(options: AirdropHookOptions): UseMutationResult<Hex, Error, ClaimArgs>;

package/dist/fhe-airdrop/react/useConfidentialAirdropFactoryImplementation.d.ts

@@ -0,0 +1,11 @@
+import { type UseQueryResult } from "@tanstack/react-query";
+import type { Address } from "viem";
+import { type BaseHookOptions } from "./_shared.js";
+/**
+ * Read the FHE-airdrop factory's current `implementation()` address — the
+ * LibClone target every new airdrop clone delegates to.
+ *
+ * @example
+ * const { data: implementation } = useConfidentialAirdropFactoryImplementation();
+ */
+export declare function useConfidentialAirdropFactoryImplementation(options?: BaseHookOptions): UseQueryResult<Address, Error>;

package/dist/fhe-airdrop/react/useCreateAndFundConfidentialAirdrop.d.ts

@@ -0,0 +1,33 @@
+import { type UseMutationResult } from "@tanstack/react-query";
+import type { CreateAirdropResult, CreateAndFundAirdropArgs } from "../factory.js";
+import { type FactoryHookOptions } from "./_shared.js";
+/**
+ * Deploy AND fund a new airdrop clone in a single transaction. The SDK
+ * encrypts the plaintext `amount` into an `externalEuint64` and submits it
+ * with an input proof — callers never handle ciphertext.
+ *
+ * **Encryptor resolution.** The hook-level `encryptor` (from
+ * {@link FactoryHookOptions}) is forwarded lazily to the SDK client. You can
+ * also pass `encryptor` per-mutation via `args.encryptor` to override it. If
+ * neither is present, the SDK throws `Missing encryptor — pass encryptor…`
+ * verbatim.
+ *
+ * **Prerequisites:** caller must have set the factory as an operator on the
+ * token: `token.setOperator(factoryAddress, deadline)`.
+ *
+ * After success, invalidate factory queries that depend on per-creator state:
+ *
+ * ```ts
+ * function Component() {
+ *   const queryClient = useQueryClient();
+ *   const zamaSDK = useZamaSDK();
+ *   const create = useCreateAndFundConfidentialAirdrop({ encryptor: () => zamaSDK.relayer });
+ *   create.mutate(args, {
+ *     onSuccess: () => {
+ *       queryClient.invalidateQueries({ queryKey: ["tokenops-sdk", "fhe-airdrop"] });
+ *     },
+ *   });
+ * }
+ * ```
+ */
+export declare function useCreateAndFundConfidentialAirdrop(options?: FactoryHookOptions): UseMutationResult<CreateAirdropResult, Error, CreateAndFundAirdropArgs>;

package/dist/fhe-airdrop/react/useCreateAndFundConfidentialAirdropAndGetAddress.d.ts

@@ -0,0 +1,40 @@
+import { type UseMutationResult } from "@tanstack/react-query";
+import type { CreateAirdropResult, CreateAndFundAirdropArgs } from "../factory.js";
+import { type FactoryHookOptions } from "./_shared.js";
+/**
+ * **Recommended fund-on-create entry point.** Deploy AND fund a new airdrop
+ * clone in one tx, then resolve its address from the
+ * `ConfidentialAirdropCreated` event in the receipt.
+ *
+ * Use this in place of {@link useCreateAndFundConfidentialAirdrop} when you
+ * need the deployed clone address — for example to navigate to a detail page
+ * immediately after the deploy.
+ *
+ * Internally: `createAndFundConfidentialAirdrop` → `waitForTransactionReceipt`
+ * → `parseEventLogs({ eventName: "ConfidentialAirdropCreated" })`.
+ *
+ * After a successful create, invalidate factory queries that depend on
+ * per-creator state:
+ *
+ * ```ts
+ * function Component() {
+ *   const queryClient = useQueryClient();
+ *   const zamaSDK = useZamaSDK();
+ *   const create = useCreateAndFundConfidentialAirdropAndGetAddress({
+ *     encryptor: () => zamaSDK.relayer,
+ *   });
+ *   create.mutate(args, {
+ *     onSuccess: ({ airdrop }) => {
+ *       queryClient.invalidateQueries({ queryKey: ["tokenops-sdk", "fhe-airdrop"] });
+ *       navigate(`/airdrop/${airdrop}`);
+ *     },
+ *   });
+ * }
+ * ```
+ *
+ * @example
+ * const create = useCreateAndFundConfidentialAirdropAndGetAddress();
+ * create.mutate({ params, userSalt, amount });
+ * // create.data → { hash, airdrop }
+ */
+export declare function useCreateAndFundConfidentialAirdropAndGetAddress(options?: FactoryHookOptions): UseMutationResult<CreateAirdropResult, Error, CreateAndFundAirdropArgs>;

package/dist/fhe-airdrop/react/useCreateConfidentialAirdrop.d.ts

@@ -0,0 +1,29 @@
+import { type UseMutationResult } from "@tanstack/react-query";
+import type { CreateAirdropArgs, CreateAirdropResult } from "../factory.js";
+import { type FactoryHookOptions } from "./_shared.js";
+/**
+ * Deploy a new airdrop clone via the factory. Raw-hash-only variant — parse
+ * the `ConfidentialAirdropCreated` event yourself if you need the address.
+ *
+ * **For the common "deploy and learn the address" flow, prefer
+ * {@link useCreateConfidentialAirdropAndGetAddress}** — it's a one-call wrapper
+ * that returns `{ hash, airdrop }`.
+ *
+ * After a successful create, invalidate factory queries that depend on
+ * per-creator state:
+ *
+ * ```ts
+ * const queryClient = useQueryClient();
+ * const create = useCreateConfidentialAirdrop();
+ * create.mutate(args, {
+ *   onSuccess: () => {
+ *     queryClient.invalidateQueries({ queryKey: ["tokenops-sdk", "fhe-airdrop"] });
+ *   },
+ * });
+ * ```
+ *
+ * @example
+ * const create = useCreateConfidentialAirdrop();
+ * create.mutate({ params, userSalt });
+ */
+export declare function useCreateConfidentialAirdrop(options?: FactoryHookOptions): UseMutationResult<CreateAirdropResult, Error, CreateAirdropArgs>;