@tokenops/sdk 1.0.0

package/dist/fhe-airdrop/react/index.d.cts

@@ -0,0 +1,90 @@
+/**
+ * React/wagmi hooks for `@tokenops/sdk/fhe-airdrop`.
+ *
+ * Every public method on the headless `ConfidentialAirdropFactoryClient` and
+ * `ConfidentialAirdropClient` is wrapped as a hook here. Hooks compose with
+ * wagmi (`usePublicClient`, `useWalletClient`) and TanStack Query
+ * (`useQuery`, `useMutation`) — no extra provider needed beyond the standard
+ * wagmi `<WagmiProvider>` + `<QueryClientProvider>`.
+ *
+ * **Encryptor.** For *factory* methods that submit encrypted inputs
+ * (`useCreateAndFundConfidentialAirdrop`, `useFundConfidentialAirdrop`), pass
+ * an explicit `encryptor` source (eager `Encryptor` or
+ * `() => Encryptor | undefined`) at hook construction. `useZamaSDK()` returns
+ * `ZamaSDK`; the encrypt-capable interface lives on `.relayer`. Wire it as a
+ * lazy factory so the SDK picks up the live React context at submit time
+ * (CLAUDE.md Pitfall #3):
+ *
+ * ```ts
+ * import { useZamaSDK } from "@zama-fhe/react-sdk";
+ *
+ * function Component({ token }) {
+ *   const zamaSDK = useZamaSDK();
+ *   const create = useCreateAndFundConfidentialAirdrop({
+ *     encryptor: () => zamaSDK.relayer,
+ *   });
+ *   ...
+ * }
+ * ```
+ *
+ * Airdrop *clone* hooks (`useClaim`, `useGetClaimAmount`) take no `encryptor`
+ * — the recipient submits the admin-issued `{ encryptedInput, signature }`
+ * payload verbatim. The signature commits to a specific handle; re-encrypting
+ * client-side would invalidate it.
+ *
+ * `@zama-fhe/react-sdk` is an **OPTIONAL** peer dep — install it explicitly
+ * (`pnpm add @zama-fhe/react-sdk`) for FHE flows. The hook surface here never
+ * imports it at top level; consumers without FHE pay no cost.
+ *
+ * Mutations do NOT auto-invalidate read queries — that's a consumer decision.
+ * Each mutation's TSDoc documents the recommended `queryClient.invalidateQueries`.
+ */
+export { useConfidentialAirdropFactoryImplementation } from "./useConfidentialAirdropFactoryImplementation.js";
+export { useFactoryDefaultGasFee } from "./useFactoryDefaultGasFee.js";
+export { useFactoryFeeCollector } from "./useFactoryFeeCollector.js";
+export { useFactoryCustomFee, type UseFactoryCustomFeeArgs } from "./useFactoryCustomFee.js";
+export { useFactoryInitCodeHash, type UseFactoryInitCodeHashArgs, } from "./useFactoryInitCodeHash.js";
+export { useCreateConfidentialAirdropAndGetAddress } from "./useCreateConfidentialAirdropAndGetAddress.js";
+export { useCreateConfidentialAirdrop } from "./useCreateConfidentialAirdrop.js";
+export { useCreateAndFundConfidentialAirdrop } from "./useCreateAndFundConfidentialAirdrop.js";
+export { useCreateAndFundConfidentialAirdropAndGetAddress } from "./useCreateAndFundConfidentialAirdropAndGetAddress.js";
+export { useFundConfidentialAirdrop } from "./useFundConfidentialAirdrop.js";
+export { useSetFeeCollector, type UseSetFeeCollectorArgs } from "./useSetFeeCollector.js";
+export { useSetDefaultGasFee, type UseSetDefaultGasFeeArgs } from "./useSetDefaultGasFee.js";
+export { useSetCustomFee, type UseSetCustomFeeArgs } from "./useSetCustomFee.js";
+export { useDisableCustomFee, type UseDisableCustomFeeArgs } from "./useDisableCustomFee.js";
+export { useAirdropToken } from "./useAirdropToken.js";
+export { useAirdropGasFee } from "./useAirdropGasFee.js";
+export { useAirdropStartTime } from "./useAirdropStartTime.js";
+export { useAirdropCanExtendClaimWindow } from "./useAirdropCanExtendClaimWindow.js";
+export { useAirdropEndTime } from "./useAirdropEndTime.js";
+export { useAirdropIsPaused } from "./useAirdropIsPaused.js";
+export { useAirdropDeploymentBlockNumber } from "./useAirdropDeploymentBlockNumber.js";
+export { useAirdropDomainSeparator } from "./useAirdropDomainSeparator.js";
+export { useAirdropClaimTypehash } from "./useAirdropClaimTypehash.js";
+export { useAirdropIsClaimWindowActive } from "./useAirdropIsClaimWindowActive.js";
+export { useAirdropHasClaimStarted } from "./useAirdropHasClaimStarted.js";
+export { useAirdropHasClaimEnded } from "./useAirdropHasClaimEnded.js";
+export { useAirdropClaimedSignatures, type UseAirdropClaimedSignaturesArgs, } from "./useAirdropClaimedSignatures.js";
+export { useAirdropIsSignatureClaimed, type UseAirdropIsSignatureClaimedArgs, } from "./useAirdropIsSignatureClaimed.js";
+export { useAirdropIsSignatureValid, type UseAirdropIsSignatureValidArgs, } from "./useAirdropIsSignatureValid.js";
+export { useAirdropHasRole, type UseAirdropHasRoleArgs } from "./useAirdropHasRole.js";
+export { useClaim } from "./useClaim.js";
+export { useGetClaimAmount } from "./useGetClaimAmount.js";
+export { useWithdraw, type UseWithdrawArgs } from "./useWithdraw.js";
+export { useSetPaused, type UseSetPausedArgs } from "./useSetPaused.js";
+export { useExtendClaimWindow, type UseExtendClaimWindowArgs } from "./useExtendClaimWindow.js";
+export { useWithdrawOtherToken, type UseWithdrawOtherTokenArgs } from "./useWithdrawOtherToken.js";
+export { useWithdrawOtherConfidentialToken, type UseWithdrawOtherConfidentialTokenArgs, } from "./useWithdrawOtherConfidentialToken.js";
+export { useAirdropWithdrawGasFee, type UseAirdropWithdrawGasFeeArgs, } from "./useAirdropWithdrawGasFee.js";
+export { useAirdropGrantRole, type UseAirdropGrantRoleArgs } from "./useAirdropGrantRole.js";
+export { useAirdropRevokeRole, type UseAirdropRevokeRoleArgs } from "./useAirdropRevokeRole.js";
+export { useSignClaimAuthorization, type UseSignClaimAuthorizationArgs, type UseSignClaimAuthorizationOptions, } from "./useSignClaimAuthorization.js";
+export type { BaseHookOptions, AirdropHookOptions, FactoryHookOptions } from "./_shared.js";
+export { encryptUint64, encryptUint64Batch, resolveEncryptor, signClaimAuthorization, type Encryptor, type EncryptorSource, type EncryptUint64Args, type EncryptUint64BatchArgs, type FheValueInput, } from "../encryption.js";
+export { type AirdropParams, type CustomFee, type EncryptedInput, type EncryptedInputs, } from "../types.js";
+export type { ClaimArgs, EncryptedViewResult, GetClaimAmountArgs, IsSignatureValidArgs, } from "../airdrop.js";
+export type { CreateAirdropResult, CreateAirdropArgs, CreateAndFundAirdropArgs, FundAirdropArgs, PredictAirdropArgs, } from "../factory.js";
+export { TokenOpsSdkError, isTokenOpsSdkError, DeploymentAddressUnavailableError, UnsupportedChainError, MissingAccountError, MissingClientError, MissingEncryptorError, MissingPublicClientError, MissingWalletClientError, InvalidArgumentError, ReceiptEventAmbiguousError, ReceiptEventNotFoundError, ContractRevertError, PausedError, AccessDeniedError, InsufficientFeeError, InsufficientBalanceError, BatchTooLargeError, FeatureDisabledError, TransferFailedError, FheHandleNotAllowedError, AlreadyInitializedError, ReentrancyError, InvalidSignatureError, WalletRejectedError, WalletChainMismatchError, NetworkError, InsufficientGasFundsError, UnknownWriteFailureError, UserRejectedSignatureError, SigningFailedError, RelayerUnreachableError, EncryptionFailedError, DecryptionFailedError, UserDecryptNotAllowedError, type DeploymentAddressUnavailableReason, type TokenOpsSdkErrorCode, } from "../../core/errors.js";
+export { type PreflightResult } from "../../core/preflight.js";
+export { AlreadyClaimedError, ClaimNotStartedError, ClaimWindowClosedError } from "../errors.js";

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

@@ -0,0 +1,90 @@
+/**
+ * React/wagmi hooks for `@tokenops/sdk/fhe-airdrop`.
+ *
+ * Every public method on the headless `ConfidentialAirdropFactoryClient` and
+ * `ConfidentialAirdropClient` is wrapped as a hook here. Hooks compose with
+ * wagmi (`usePublicClient`, `useWalletClient`) and TanStack Query
+ * (`useQuery`, `useMutation`) — no extra provider needed beyond the standard
+ * wagmi `<WagmiProvider>` + `<QueryClientProvider>`.
+ *
+ * **Encryptor.** For *factory* methods that submit encrypted inputs
+ * (`useCreateAndFundConfidentialAirdrop`, `useFundConfidentialAirdrop`), pass
+ * an explicit `encryptor` source (eager `Encryptor` or
+ * `() => Encryptor | undefined`) at hook construction. `useZamaSDK()` returns
+ * `ZamaSDK`; the encrypt-capable interface lives on `.relayer`. Wire it as a
+ * lazy factory so the SDK picks up the live React context at submit time
+ * (CLAUDE.md Pitfall #3):
+ *
+ * ```ts
+ * import { useZamaSDK } from "@zama-fhe/react-sdk";
+ *
+ * function Component({ token }) {
+ *   const zamaSDK = useZamaSDK();
+ *   const create = useCreateAndFundConfidentialAirdrop({
+ *     encryptor: () => zamaSDK.relayer,
+ *   });
+ *   ...
+ * }
+ * ```
+ *
+ * Airdrop *clone* hooks (`useClaim`, `useGetClaimAmount`) take no `encryptor`
+ * — the recipient submits the admin-issued `{ encryptedInput, signature }`
+ * payload verbatim. The signature commits to a specific handle; re-encrypting
+ * client-side would invalidate it.
+ *
+ * `@zama-fhe/react-sdk` is an **OPTIONAL** peer dep — install it explicitly
+ * (`pnpm add @zama-fhe/react-sdk`) for FHE flows. The hook surface here never
+ * imports it at top level; consumers without FHE pay no cost.
+ *
+ * Mutations do NOT auto-invalidate read queries — that's a consumer decision.
+ * Each mutation's TSDoc documents the recommended `queryClient.invalidateQueries`.
+ */
+export { useConfidentialAirdropFactoryImplementation } from "./useConfidentialAirdropFactoryImplementation.js";
+export { useFactoryDefaultGasFee } from "./useFactoryDefaultGasFee.js";
+export { useFactoryFeeCollector } from "./useFactoryFeeCollector.js";
+export { useFactoryCustomFee, type UseFactoryCustomFeeArgs } from "./useFactoryCustomFee.js";
+export { useFactoryInitCodeHash, type UseFactoryInitCodeHashArgs, } from "./useFactoryInitCodeHash.js";
+export { useCreateConfidentialAirdropAndGetAddress } from "./useCreateConfidentialAirdropAndGetAddress.js";
+export { useCreateConfidentialAirdrop } from "./useCreateConfidentialAirdrop.js";
+export { useCreateAndFundConfidentialAirdrop } from "./useCreateAndFundConfidentialAirdrop.js";
+export { useCreateAndFundConfidentialAirdropAndGetAddress } from "./useCreateAndFundConfidentialAirdropAndGetAddress.js";
+export { useFundConfidentialAirdrop } from "./useFundConfidentialAirdrop.js";
+export { useSetFeeCollector, type UseSetFeeCollectorArgs } from "./useSetFeeCollector.js";
+export { useSetDefaultGasFee, type UseSetDefaultGasFeeArgs } from "./useSetDefaultGasFee.js";
+export { useSetCustomFee, type UseSetCustomFeeArgs } from "./useSetCustomFee.js";
+export { useDisableCustomFee, type UseDisableCustomFeeArgs } from "./useDisableCustomFee.js";
+export { useAirdropToken } from "./useAirdropToken.js";
+export { useAirdropGasFee } from "./useAirdropGasFee.js";
+export { useAirdropStartTime } from "./useAirdropStartTime.js";
+export { useAirdropCanExtendClaimWindow } from "./useAirdropCanExtendClaimWindow.js";
+export { useAirdropEndTime } from "./useAirdropEndTime.js";
+export { useAirdropIsPaused } from "./useAirdropIsPaused.js";
+export { useAirdropDeploymentBlockNumber } from "./useAirdropDeploymentBlockNumber.js";
+export { useAirdropDomainSeparator } from "./useAirdropDomainSeparator.js";
+export { useAirdropClaimTypehash } from "./useAirdropClaimTypehash.js";
+export { useAirdropIsClaimWindowActive } from "./useAirdropIsClaimWindowActive.js";
+export { useAirdropHasClaimStarted } from "./useAirdropHasClaimStarted.js";
+export { useAirdropHasClaimEnded } from "./useAirdropHasClaimEnded.js";
+export { useAirdropClaimedSignatures, type UseAirdropClaimedSignaturesArgs, } from "./useAirdropClaimedSignatures.js";
+export { useAirdropIsSignatureClaimed, type UseAirdropIsSignatureClaimedArgs, } from "./useAirdropIsSignatureClaimed.js";
+export { useAirdropIsSignatureValid, type UseAirdropIsSignatureValidArgs, } from "./useAirdropIsSignatureValid.js";
+export { useAirdropHasRole, type UseAirdropHasRoleArgs } from "./useAirdropHasRole.js";
+export { useClaim } from "./useClaim.js";
+export { useGetClaimAmount } from "./useGetClaimAmount.js";
+export { useWithdraw, type UseWithdrawArgs } from "./useWithdraw.js";
+export { useSetPaused, type UseSetPausedArgs } from "./useSetPaused.js";
+export { useExtendClaimWindow, type UseExtendClaimWindowArgs } from "./useExtendClaimWindow.js";
+export { useWithdrawOtherToken, type UseWithdrawOtherTokenArgs } from "./useWithdrawOtherToken.js";
+export { useWithdrawOtherConfidentialToken, type UseWithdrawOtherConfidentialTokenArgs, } from "./useWithdrawOtherConfidentialToken.js";
+export { useAirdropWithdrawGasFee, type UseAirdropWithdrawGasFeeArgs, } from "./useAirdropWithdrawGasFee.js";
+export { useAirdropGrantRole, type UseAirdropGrantRoleArgs } from "./useAirdropGrantRole.js";
+export { useAirdropRevokeRole, type UseAirdropRevokeRoleArgs } from "./useAirdropRevokeRole.js";
+export { useSignClaimAuthorization, type UseSignClaimAuthorizationArgs, type UseSignClaimAuthorizationOptions, } from "./useSignClaimAuthorization.js";
+export type { BaseHookOptions, AirdropHookOptions, FactoryHookOptions } from "./_shared.js";
+export { encryptUint64, encryptUint64Batch, resolveEncryptor, signClaimAuthorization, type Encryptor, type EncryptorSource, type EncryptUint64Args, type EncryptUint64BatchArgs, type FheValueInput, } from "../encryption.js";
+export { type AirdropParams, type CustomFee, type EncryptedInput, type EncryptedInputs, } from "../types.js";
+export type { ClaimArgs, EncryptedViewResult, GetClaimAmountArgs, IsSignatureValidArgs, } from "../airdrop.js";
+export type { CreateAirdropResult, CreateAirdropArgs, CreateAndFundAirdropArgs, FundAirdropArgs, PredictAirdropArgs, } from "../factory.js";
+export { TokenOpsSdkError, isTokenOpsSdkError, DeploymentAddressUnavailableError, UnsupportedChainError, MissingAccountError, MissingClientError, MissingEncryptorError, MissingPublicClientError, MissingWalletClientError, InvalidArgumentError, ReceiptEventAmbiguousError, ReceiptEventNotFoundError, ContractRevertError, PausedError, AccessDeniedError, InsufficientFeeError, InsufficientBalanceError, BatchTooLargeError, FeatureDisabledError, TransferFailedError, FheHandleNotAllowedError, AlreadyInitializedError, ReentrancyError, InvalidSignatureError, WalletRejectedError, WalletChainMismatchError, NetworkError, InsufficientGasFundsError, UnknownWriteFailureError, UserRejectedSignatureError, SigningFailedError, RelayerUnreachableError, EncryptionFailedError, DecryptionFailedError, UserDecryptNotAllowedError, type DeploymentAddressUnavailableReason, type TokenOpsSdkErrorCode, } from "../../core/errors.js";
+export { type PreflightResult } from "../../core/preflight.js";
+export { AlreadyClaimedError, ClaimNotStartedError, ClaimWindowClosedError } from "../errors.js";

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

@@ -0,0 +1,430 @@
+import { useMemoFactoryClient, buildQueryKey, useMemoAirdropClient } from '../../chunk-HGXNRR25.js';
+export { AlreadyClaimedError, ClaimNotStartedError, ClaimWindowClosedError } from '../../chunk-XXXDQSHE.js';
+import { signClaimAuthorization } from '../../chunk-UOG4PJL5.js';
+export { encryptUint64, encryptUint64Batch, resolveEncryptor, signClaimAuthorization } from '../../chunk-UOG4PJL5.js';
+import '../../chunk-FYQ2UW4T.js';
+import '../../chunk-JFLEEXKP.js';
+import '../../chunk-COPFW5Z4.js';
+import '../../chunk-BE2AIZ3K.js';
+import '../../chunk-Q2GP5UDC.js';
+import '../../chunk-KWFFIJYX.js';
+import { MissingClientError, MissingWalletClientError } 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 { useAccount, useWalletClient } from 'wagmi';
+
+function useConfidentialAirdropFactoryImplementation(options = {}) {
+  const { client, chainId, resolvedAddress } = useMemoFactoryClient(options);
+  return useQuery({
+    queryKey: buildQueryKey("factory:implementation", chainId, resolvedAddress),
+    queryFn: () => client.implementation(),
+    enabled: !!client,
+    staleTime: 0
+  });
+}
+function useFactoryDefaultGasFee(options = {}) {
+  const { client, chainId, resolvedAddress } = useMemoFactoryClient(options);
+  return useQuery({
+    queryKey: buildQueryKey("factory:defaultGasFee", chainId, resolvedAddress),
+    queryFn: () => client.defaultGasFee(),
+    enabled: !!client,
+    staleTime: 0
+  });
+}
+function useFactoryFeeCollector(options = {}) {
+  const { client, chainId, resolvedAddress } = useMemoFactoryClient(options);
+  return useQuery({
+    queryKey: buildQueryKey("factory:feeCollector", chainId, resolvedAddress),
+    queryFn: () => client.feeCollector(),
+    enabled: !!client,
+    staleTime: 0
+  });
+}
+function useFactoryCustomFee(args = {}) {
+  const { creator, ...base } = args;
+  const { client, chainId, resolvedAddress } = useMemoFactoryClient(base);
+  return useQuery({
+    queryKey: buildQueryKey("factory:getCustomFee", chainId, resolvedAddress, creator),
+    queryFn: () => client.getCustomFee(creator),
+    enabled: !!client && !!creator,
+    staleTime: 0
+  });
+}
+function useFactoryInitCodeHash(args = {}) {
+  const { params, gasFee, ...base } = args;
+  const { client, chainId, resolvedAddress } = useMemoFactoryClient(base);
+  return useQuery({
+    queryKey: buildQueryKey("factory:getInitCodeHash", chainId, resolvedAddress, params, gasFee),
+    queryFn: () => client.getInitCodeHash({ params, gasFee }),
+    enabled: !!client && !!params && gasFee !== void 0,
+    staleTime: 0
+  });
+}
+function useCreateConfidentialAirdropAndGetAddress(options = {}) {
+  const { client, resolutionError } = useMemoFactoryClient(options);
+  return useMutation({
+    mutationFn: async (args) => {
+      if (!client) {
+        throw resolutionError ?? new MissingClientError("useCreateConfidentialAirdropAndGetAddress", "factory");
+      }
+      return client.createConfidentialAirdropAndGetAddress(args);
+    }
+  });
+}
+function useCreateConfidentialAirdrop(options = {}) {
+  const { client, resolutionError } = useMemoFactoryClient(options);
+  return useMutation({
+    mutationFn: async (args) => {
+      if (!client) {
+        throw resolutionError ?? new MissingClientError("useCreateConfidentialAirdrop", "factory");
+      }
+      return client.createConfidentialAirdrop(args);
+    }
+  });
+}
+function useCreateAndFundConfidentialAirdrop(options = {}) {
+  const { client, resolutionError } = useMemoFactoryClient(options);
+  return useMutation({
+    mutationFn: async (args) => {
+      if (!client) {
+        throw resolutionError ?? new MissingClientError("useCreateAndFundConfidentialAirdrop", "factory");
+      }
+      return client.createAndFundConfidentialAirdrop(args);
+    }
+  });
+}
+function useCreateAndFundConfidentialAirdropAndGetAddress(options = {}) {
+  const { client, resolutionError } = useMemoFactoryClient(options);
+  return useMutation({
+    mutationFn: async (args) => {
+      if (!client) {
+        throw resolutionError ?? new MissingClientError("useCreateAndFundConfidentialAirdropAndGetAddress", "factory");
+      }
+      return client.createAndFundConfidentialAirdropAndGetAddress(args);
+    }
+  });
+}
+function useFundConfidentialAirdrop(options = {}) {
+  const { client, resolutionError } = useMemoFactoryClient(options);
+  return useMutation({
+    mutationFn: async (args) => {
+      if (!client) {
+        throw resolutionError ?? new MissingClientError("useFundConfidentialAirdrop", "factory");
+      }
+      return client.fundConfidentialAirdrop(args);
+    }
+  });
+}
+function useSetFeeCollector(options = {}) {
+  const { client, resolutionError } = useMemoFactoryClient(options);
+  return useMutation({
+    mutationFn: async ({ newFeeCollector, account }) => {
+      if (!client) throw resolutionError ?? new MissingClientError("useSetFeeCollector", "factory");
+      return client.setFeeCollector(newFeeCollector, account);
+    }
+  });
+}
+function useSetDefaultGasFee(options = {}) {
+  const { client, resolutionError } = useMemoFactoryClient(options);
+  return useMutation({
+    mutationFn: async ({ newGasFee, account }) => {
+      if (!client)
+        throw resolutionError ?? new MissingClientError("useSetDefaultGasFee", "factory");
+      return client.setDefaultGasFee(newGasFee, account);
+    }
+  });
+}
+function useSetCustomFee(options = {}) {
+  const { client, resolutionError } = useMemoFactoryClient(options);
+  return useMutation({
+    mutationFn: async ({ campaignCreator, gasFee, account }) => {
+      if (!client) throw resolutionError ?? new MissingClientError("useSetCustomFee", "factory");
+      return client.setCustomFee(campaignCreator, gasFee, account);
+    }
+  });
+}
+function useDisableCustomFee(options = {}) {
+  const { client, resolutionError } = useMemoFactoryClient(options);
+  return useMutation({
+    mutationFn: async ({ campaignCreator, account }) => {
+      if (!client)
+        throw resolutionError ?? new MissingClientError("useDisableCustomFee", "factory");
+      return client.disableCustomFee(campaignCreator, account);
+    }
+  });
+}
+function useAirdropToken(options) {
+  const { client, chainId } = useMemoAirdropClient(options);
+  return useQuery({
+    queryKey: buildQueryKey("airdrop:TOKEN", chainId, options.address),
+    queryFn: () => client.token(),
+    enabled: !!client,
+    staleTime: 0
+  });
+}
+function useAirdropGasFee(options) {
+  const { client, chainId } = useMemoAirdropClient(options);
+  return useQuery({
+    queryKey: buildQueryKey("airdrop:GAS_FEE", chainId, options.address),
+    queryFn: () => client.gasFee(),
+    enabled: !!client,
+    staleTime: 0
+  });
+}
+function useAirdropStartTime(options) {
+  const { client, chainId } = useMemoAirdropClient(options);
+  return useQuery({
+    queryKey: buildQueryKey("airdrop:START_TIME", chainId, options.address),
+    queryFn: () => client.startTime(),
+    enabled: !!client,
+    staleTime: 0
+  });
+}
+function useAirdropCanExtendClaimWindow(options) {
+  const { client, chainId } = useMemoAirdropClient(options);
+  return useQuery({
+    queryKey: buildQueryKey("airdrop:CAN_EXTEND_CLAIM_WINDOW", chainId, options.address),
+    queryFn: () => client.canExtendClaimWindow(),
+    enabled: !!client,
+    staleTime: 0
+  });
+}
+function useAirdropEndTime(options) {
+  const { client, chainId } = useMemoAirdropClient(options);
+  return useQuery({
+    queryKey: buildQueryKey("airdrop:endTime", chainId, options.address),
+    queryFn: () => client.endTime(),
+    enabled: !!client,
+    staleTime: 0
+  });
+}
+function useAirdropIsPaused(options) {
+  const { client, chainId } = useMemoAirdropClient(options);
+  return useQuery({
+    queryKey: buildQueryKey("airdrop:isPaused", chainId, options.address),
+    queryFn: () => client.isPaused(),
+    enabled: !!client,
+    staleTime: 0
+  });
+}
+function useAirdropDeploymentBlockNumber(options) {
+  const { client, chainId } = useMemoAirdropClient(options);
+  return useQuery({
+    queryKey: buildQueryKey("airdrop:deploymentBlockNumber", chainId, options.address),
+    queryFn: () => client.deploymentBlockNumber(),
+    enabled: !!client,
+    staleTime: 0
+  });
+}
+function useAirdropDomainSeparator(options) {
+  const { client, chainId } = useMemoAirdropClient(options);
+  return useQuery({
+    queryKey: buildQueryKey("airdrop:DOMAIN_SEPARATOR", chainId, options.address),
+    queryFn: () => client.domainSeparator(),
+    enabled: !!client,
+    staleTime: 0
+  });
+}
+function useAirdropClaimTypehash(options) {
+  const { client, chainId } = useMemoAirdropClient(options);
+  return useQuery({
+    queryKey: buildQueryKey("airdrop:CLAIM_TYPEHASH", chainId, options.address),
+    queryFn: () => client.claimTypehash(),
+    enabled: !!client,
+    staleTime: 0
+  });
+}
+function useAirdropIsClaimWindowActive(options) {
+  const { client, chainId } = useMemoAirdropClient(options);
+  return useQuery({
+    queryKey: buildQueryKey("airdrop:isClaimWindowActive", chainId, options.address),
+    queryFn: () => client.isClaimWindowActive(),
+    enabled: !!client,
+    staleTime: 0
+  });
+}
+function useAirdropHasClaimStarted(options) {
+  const { client, chainId } = useMemoAirdropClient(options);
+  return useQuery({
+    queryKey: buildQueryKey("airdrop:hasClaimStarted", chainId, options.address),
+    queryFn: () => client.hasClaimStarted(),
+    enabled: !!client,
+    staleTime: 0
+  });
+}
+function useAirdropHasClaimEnded(options) {
+  const { client, chainId } = useMemoAirdropClient(options);
+  return useQuery({
+    queryKey: buildQueryKey("airdrop:hasClaimEnded", chainId, options.address),
+    queryFn: () => client.hasClaimEnded(),
+    enabled: !!client,
+    staleTime: 0
+  });
+}
+function useAirdropClaimedSignatures(args) {
+  const { signatureHash, ...base } = args;
+  const { client, chainId } = useMemoAirdropClient(base);
+  return useQuery({
+    queryKey: buildQueryKey("airdrop:claimedSignatures", chainId, base.address, signatureHash),
+    queryFn: () => client.claimedSignatures(signatureHash),
+    enabled: !!client && !!signatureHash,
+    staleTime: 0
+  });
+}
+function useAirdropIsSignatureClaimed(args) {
+  const { user, encryptedAmountHandle, ...base } = args;
+  const { client, chainId } = useMemoAirdropClient(base);
+  return useQuery({
+    queryKey: buildQueryKey(
+      "airdrop:isSignatureClaimed",
+      chainId,
+      base.address,
+      user,
+      encryptedAmountHandle
+    ),
+    queryFn: () => client.isSignatureClaimed(user, encryptedAmountHandle),
+    enabled: !!client && !!user && !!encryptedAmountHandle,
+    staleTime: 0
+  });
+}
+function useAirdropIsSignatureValid(args) {
+  const { encryptedAmountHandle, signature, caller, ...base } = args;
+  const { client, chainId } = useMemoAirdropClient(base);
+  const { address: connectedAddress } = useAccount();
+  const resolvedCaller = caller ?? connectedAddress;
+  return useQuery({
+    queryKey: buildQueryKey(
+      "airdrop:isSignatureValid",
+      chainId,
+      base.address,
+      encryptedAmountHandle,
+      signature,
+      resolvedCaller
+    ),
+    queryFn: () => client.isSignatureValid({
+      encryptedAmountHandle,
+      signature,
+      caller: resolvedCaller
+    }),
+    enabled: !!client && !!encryptedAmountHandle && !!signature && !!resolvedCaller,
+    staleTime: 0
+  });
+}
+function useAirdropHasRole(args) {
+  const { role, account, ...base } = args;
+  const { client, chainId } = useMemoAirdropClient(base);
+  return useQuery({
+    queryKey: buildQueryKey("airdrop:hasRole", chainId, base.address, role, account),
+    queryFn: () => client.hasRole(role, account),
+    enabled: !!client && !!role && !!account,
+    staleTime: 0
+  });
+}
+function useClaim(options) {
+  const { client } = useMemoAirdropClient(options);
+  return useMutation({
+    mutationFn: async (args) => {
+      if (!client) throw new MissingClientError("useClaim", "airdrop");
+      return client.claim(args);
+    }
+  });
+}
+function useGetClaimAmount(options) {
+  const { client } = useMemoAirdropClient(options);
+  return useMutation({
+    mutationFn: async (args) => {
+      if (!client) throw new MissingClientError("useGetClaimAmount", "airdrop");
+      return client.getClaimAmount(args);
+    }
+  });
+}
+function useWithdraw(options) {
+  const { client } = useMemoAirdropClient(options);
+  return useMutation({
+    mutationFn: async ({ recipient, account }) => {
+      if (!client) throw new MissingClientError("useWithdraw", "airdrop");
+      return client.withdraw(recipient, account);
+    }
+  });
+}
+function useSetPaused(options) {
+  const { client } = useMemoAirdropClient(options);
+  return useMutation({
+    mutationFn: async ({ paused, account }) => {
+      if (!client) throw new MissingClientError("useSetPaused", "airdrop");
+      return client.setPaused(paused, account);
+    }
+  });
+}
+function useExtendClaimWindow(options) {
+  const { client } = useMemoAirdropClient(options);
+  return useMutation({
+    mutationFn: async ({ newEndTime, account }) => {
+      if (!client) throw new MissingClientError("useExtendClaimWindow", "airdrop");
+      return client.extendClaimWindow(newEndTime, account);
+    }
+  });
+}
+function useWithdrawOtherToken(options) {
+  const { client } = useMemoAirdropClient(options);
+  return useMutation({
+    mutationFn: async ({ tokenAddress, recipient, account }) => {
+      if (!client) throw new MissingClientError("useWithdrawOtherToken", "airdrop");
+      return client.withdrawOtherToken(tokenAddress, recipient, account);
+    }
+  });
+}
+function useWithdrawOtherConfidentialToken(options) {
+  const { client } = useMemoAirdropClient(options);
+  return useMutation({
+    mutationFn: async ({ tokenAddress, recipient, account }) => {
+      if (!client) throw new MissingClientError("useWithdrawOtherConfidentialToken", "airdrop");
+      return client.withdrawOtherConfidentialToken(tokenAddress, recipient, account);
+    }
+  });
+}
+function useAirdropWithdrawGasFee(options) {
+  const { client } = useMemoAirdropClient(options);
+  return useMutation({
+    mutationFn: async ({ recipient, amount, account }) => {
+      if (!client) throw new MissingClientError("useAirdropWithdrawGasFee", "airdrop");
+      return client.withdrawGasFee(recipient, amount, account);
+    }
+  });
+}
+function useAirdropGrantRole(options) {
+  const { client } = useMemoAirdropClient(options);
+  return useMutation({
+    mutationFn: async ({ role, accountTarget, account }) => {
+      if (!client) throw new MissingClientError("useAirdropGrantRole", "airdrop");
+      return client.grantRole(role, accountTarget, account);
+    }
+  });
+}
+function useAirdropRevokeRole(options) {
+  const { client } = useMemoAirdropClient(options);
+  return useMutation({
+    mutationFn: async ({ role, accountTarget, account }) => {
+      if (!client) throw new MissingClientError("useAirdropRevokeRole", "airdrop");
+      return client.revokeRole(role, accountTarget, account);
+    }
+  });
+}
+function useSignClaimAuthorization(options = {}) {
+  const { data: walletClient } = useWalletClient({ chainId: options.chainId });
+  return useMutation({
+    mutationFn: async (args) => {
+      if (!walletClient) {
+        throw new MissingWalletClientError("useSignClaimAuthorization");
+      }
+      return signClaimAuthorization({
+        walletClient,
+        airdropAddress: args.airdropAddress,
+        recipient: args.recipient,
+        encryptedAmountHandle: args.encryptedAmountHandle
+      });
+    }
+  });
+}
+
+export { useAirdropCanExtendClaimWindow, useAirdropClaimTypehash, useAirdropClaimedSignatures, useAirdropDeploymentBlockNumber, useAirdropDomainSeparator, useAirdropEndTime, useAirdropGasFee, useAirdropGrantRole, useAirdropHasClaimEnded, useAirdropHasClaimStarted, useAirdropHasRole, useAirdropIsClaimWindowActive, useAirdropIsPaused, useAirdropIsSignatureClaimed, useAirdropIsSignatureValid, useAirdropRevokeRole, useAirdropStartTime, useAirdropToken, useAirdropWithdrawGasFee, useClaim, useConfidentialAirdropFactoryImplementation, useCreateAndFundConfidentialAirdrop, useCreateAndFundConfidentialAirdropAndGetAddress, useCreateConfidentialAirdrop, useCreateConfidentialAirdropAndGetAddress, useDisableCustomFee, useExtendClaimWindow, useFactoryCustomFee, useFactoryDefaultGasFee, useFactoryFeeCollector, useFactoryInitCodeHash, useFundConfidentialAirdrop, useGetClaimAmount, useSetCustomFee, useSetDefaultGasFee, useSetFeeCollector, useSetPaused, useSignClaimAuthorization, useWithdraw, useWithdrawOtherConfidentialToken, useWithdrawOtherToken };

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

@@ -0,0 +1,31 @@
+import { type UseMutationResult } from "@tanstack/react-query";
+import type { EncryptedViewResult, GetClaimAmountArgs } from "../airdrop.js";
+import { type AirdropHookOptions } from "./_shared.js";
+/**
+ * **Submits a transaction (costs gas) to grant the caller decrypt access to
+ * the claim amount 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 amount. The handle is only valid after the tx lands.
+ *
+ * Does **not** consume the claim (the `claimedSignatures` bit is not set).
+ * Call {@link useAirdropClaim} when the user is ready to transfer tokens.
+ *
+ * **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.
+ *
+ * @example
+ * // `signature` is the EIP-712 admin signature delivered to the recipient
+ * // — same value the recipient passes to `useAirdropClaim`. Sourced from your
+ * // server API or, for admin-dashboard flows, from `useSignClaimAuthorization`.
+ * const view = useAccessClaimAmount({ address: airdropAddress, encryptor: () => useZamaSDK().relayer });
+ * view.mutate({ amount: 1_000_000n, signature });
+ * // view.data → { handle: "0x...", hash: "0x..." }
+ */
+export declare function useAccessClaimAmount(options: AirdropHookOptions): UseMutationResult<EncryptedViewResult, Error, GetClaimAmountArgs>;

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

@@ -0,0 +1,7 @@
+import { type UseQueryResult } from "@tanstack/react-query";
+import { type AirdropHookOptions } from "./_shared.js";
+/**
+ * Read whether the admin can extend the claim window past `endTime` on this
+ * airdrop clone. Immutable arg — set at deployment, never changes.
+ */
+export declare function useAirdropCanExtendClaimWindow(options: AirdropHookOptions): UseQueryResult<boolean, Error>;