@tokenops/sdk 1.6.0 → 2.0.0-alpha.2

package/dist/chunk-WO72UBQD.cjs

@@ -1,109 +0,0 @@
-'use strict';
-
-var chunkSPGSO5SO_cjs = require('./chunk-SPGSO5SO.cjs');
-var chunkLBWRFZR3_cjs = require('./chunk-LBWRFZR3.cjs');
-var chunkWUXUWTFW_cjs = require('./chunk-WUXUWTFW.cjs');
-var chunk2RNW4MIJ_cjs = require('./chunk-2RNW4MIJ.cjs');
-var react = require('react');
-var wagmi = require('wagmi');
-
-var FHE_AIRDROP_KEY = "tokenops-sdk";
-var FHE_AIRDROP_NAMESPACE = "fhe-airdrop";
-function tryResolveFactoryAddress(override, chainId) {
-  if (override) return override;
-  if (chainId === void 0) return void 0;
-  return chunkWUXUWTFW_cjs.getFheAirdropFactoryAddress(chainId);
-}
-function useMemoFactoryClient(opts = {}) {
-  const publicClient = wagmi.usePublicClient({ chainId: opts.chainId });
-  const { data: walletClient } = wagmi.useWalletClient({ chainId: opts.chainId });
-  const chainId = opts.chainId ?? publicClient?.chain?.id;
-  const resolvedAddress = tryResolveFactoryAddress(opts.address, chainId);
-  const resolutionError = computeFactoryResolutionError(opts.address, chainId);
-  const encryptorSourceRef = react.useRef(opts.encryptor);
-  encryptorSourceRef.current = opts.encryptor;
-  const client = react.useMemo(() => {
-    if (!publicClient) return void 0;
-    if (!resolvedAddress) return void 0;
-    return chunkLBWRFZR3_cjs.createConfidentialAirdropFactoryClient({
-      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: () => chunkLBWRFZR3_cjs.resolveEncryptor(encryptorSourceRef.current)
-    });
-  }, [publicClient, walletClient, resolvedAddress, chainId]);
-  return {
-    client,
-    resolutionError,
-    publicClient,
-    walletClient: walletClient ?? void 0,
-    chainId,
-    resolvedAddress
-  };
-}
-function computeFactoryResolutionError(override, chainId) {
-  if (override) return void 0;
-  if (chainId === void 0) {
-    return new chunk2RNW4MIJ_cjs.DeploymentAddressUnavailableError({
-      reason: "chain-id-missing",
-      product: "fheAirdrop",
-      contract: "confidentialAirdropFactory",
-      clientLabel: "ConfidentialAirdropFactoryClient"
-    });
-  }
-  const resolved = chunkWUXUWTFW_cjs.getFheAirdropFactoryAddress(chainId);
-  if (!resolved) {
-    return new chunk2RNW4MIJ_cjs.DeploymentAddressUnavailableError({
-      reason: "registry-not-deployed",
-      product: "fheAirdrop",
-      contract: "confidentialAirdropFactory",
-      chainId,
-      clientLabel: "ConfidentialAirdropFactoryClient"
-    });
-  }
-  return void 0;
-}
-function useMemoAirdropClient(opts) {
-  const publicClient = wagmi.usePublicClient({ chainId: opts.chainId });
-  const { data: walletClient } = wagmi.useWalletClient({ chainId: opts.chainId });
-  const chainId = opts.chainId ?? publicClient?.chain?.id;
-  const client = react.useMemo(() => {
-    if (!publicClient) return void 0;
-    if (!opts.address) return void 0;
-    return chunkSPGSO5SO_cjs.createConfidentialAirdropClient({
-      publicClient,
-      ...walletClient ? { walletClient } : {},
-      address: opts.address,
-      ...opts.aclAddress ? { aclAddress: opts.aclAddress } : {}
-    });
-  }, [publicClient, walletClient, opts.address, opts.aclAddress]);
-  return { client, publicClient, walletClient: walletClient ?? void 0, chainId };
-}
-function buildQueryKey(method, chainId, address, ...args) {
-  return [
-    FHE_AIRDROP_KEY,
-    FHE_AIRDROP_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;
-}
-
-exports.buildQueryKey = buildQueryKey;
-exports.useMemoAirdropClient = useMemoAirdropClient;
-exports.useMemoFactoryClient = useMemoFactoryClient;

package/dist/fhe-airdrop/advanced/factory-advanced.d.ts

@@ -1,53 +0,0 @@
-import type { Address } from "viem";
-import { ConfidentialAirdropFactoryClient, type ConfidentialAirdropFactoryClientConfig, type PredictAirdropArgs } from "../factory.js";
-/**
- * Advanced extension of {@link ConfidentialAirdropFactoryClient} that re-exposes
- * the CREATE2 address prediction read.
- *
- * **Why this is "advanced" surface.** Most consumers want one call back —
- * `createConfidentialAirdrop` (rich-return, `{ hash, airdrop }`). The factory
- * still emits
- * `ConfidentialAirdropCreated`, the SDK still parses it, so consumers never
- * need to ask "what address will this deploy to before mining?" Hoisting
- * `predictAirdropAddress` onto the headline client surface gave consumers a
- * footgun: pass the wrong `gasFee` and you predict an address that won't
- * match the deployed clone.
- *
- * For the genuinely-advanced cases — historical address recovery, same-tx
- * pre-confirmation flows — import this subclass from `@tokenops/sdk/fhe-airdrop/advanced`
- * and call it explicitly. The headline factory does not include this method.
- *
- * @example
- * import { createConfidentialAirdropFactoryAdvancedClient } from "@tokenops/sdk/fhe-airdrop/advanced";
- *
- * const factory = createConfidentialAirdropFactoryAdvancedClient({ publicClient });
- * const predicted = await factory.predictAirdropAddress({
- *   params, userSalt, deployer, gasFee: customGasFee,
- * });
- */
-export declare class ConfidentialAirdropFactoryAdvancedClient extends ConfidentialAirdropFactoryClient {
-    /**
-     * Compute the deterministic CREATE2 address for an airdrop clone without
-     * deploying it.
-     *
-     * Note: `gasFee` must match what the factory would charge the deployer at
-     * deploy time (custom fee if set, otherwise `defaultGasFee`). Use
-     * `getCustomFee(deployer)` and `defaultGasFee()` to resolve it correctly —
-     * a mismatch silently targets the wrong address.
-     *
-     * For the common "deploy a clone and learn its address" flow, use the
-     * headline `factory.createConfidentialAirdrop` instead — it parses the
-     * address from the tx receipt's `ConfidentialAirdropCreated` event without
-     * any `gasFee` guessing.
-     */
-    predictAirdropAddress(args: PredictAirdropArgs): Promise<Address>;
-}
-/**
- * Create a {@link ConfidentialAirdropFactoryAdvancedClient}. Mirrors viem's
- * `create*` convention.
- *
- * @example
- * const factory = createConfidentialAirdropFactoryAdvancedClient({ publicClient, walletClient, encryptor });
- * const predicted = await factory.predictAirdropAddress({ params, userSalt, deployer, gasFee });
- */
-export declare function createConfidentialAirdropFactoryAdvancedClient(config: ConfidentialAirdropFactoryClientConfig): ConfidentialAirdropFactoryAdvancedClient;

package/dist/fhe-airdrop/advanced/react/usePredictAirdropAddress.d.ts

@@ -1,49 +0,0 @@
-import { type UseQueryResult } from "@tanstack/react-query";
-import type { Address, Hex, PublicClient } from "viem";
-import { type EncryptorSource } from "../../encryption.js";
-import { type AirdropParams } from "../../types.js";
-export interface UsePredictAirdropAddressArgs {
-    params?: AirdropParams;
-    userSalt?: Hex;
-    deployer?: Address;
-    /**
-     * Gas fee in wei to embed into the CREATE2 salt computation. Must match the
-     * fee that will be (or was) active for `deployer` at deploy time:
-     * custom fee if `getCustomFee(deployer).enabled`, otherwise `defaultGasFee`.
-     *
-     * Passing the wrong value produces a different address than the deployed
-     * clone — use `useAirdropFactoryCustomFee` and `useAirdropFactoryDefaultGasFee`
-     * from the headline `@tokenops/sdk/fhe-airdrop/react` subpath to resolve it
-     * correctly.
-     */
-    gasFee?: bigint;
-    /** Override the on-chain factory address. Defaults to {@link DEPLOYED_ADDRESSES}. */
-    address?: Address | undefined;
-    /** Override the chain id used for default address resolution. Defaults to `usePublicClient().chain?.id`. */
-    chainId?: number | undefined;
-    /** Override the viem `PublicClient` — bypasses the wagmi context. */
-    publicClient?: PublicClient | undefined;
-    /** Lazy or eager encryptor source. Not required for predict reads, accepted for client-construction symmetry. */
-    encryptor?: EncryptorSource;
-}
-/**
- * Compute the deterministic CREATE2 address the factory would produce for an
- * airdrop clone without deploying it.
- *
- * **Advanced surface.** This hook lives on the advanced subpath because the
- * common "deploy and learn the address" flow is better served by
- * `useCreateConfidentialAirdropAndGetAddress` on the headline React subpath —
- * which parses the address from the `ConfidentialAirdropCreated` event and
- * never has to guess the `gasFee` that was active at deploy time.
- *
- * The hook is disabled until all four of `params`, `userSalt`, `deployer`, and
- * `gasFee` are set.
- *
- * @example
- * import { usePredictAirdropAddress } from "@tokenops/sdk/fhe-airdrop/advanced/react";
- *
- * const { data: predictedAddress } = usePredictAirdropAddress({
- *   params, userSalt, deployer, gasFee: defaultGasFee,
- * });
- */
-export declare function usePredictAirdropAddress(args?: UsePredictAirdropAddressArgs): UseQueryResult<Address, Error>;

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

@@ -1,317 +0,0 @@
-import type { Account, Address, Hex, PublicClient, WalletClient } from "viem";
-import type { EncryptedHandle, Role, TxHash } from "../core/brands.js";
-import { type PreflightResult } from "../core/preflight.js";
-import { type SdkTelemetry } from "../core/telemetry.js";
-import type { EncryptedInput, EncryptedViewResult } from "./types.js";
-export type { EncryptedViewResult } from "./types.js";
-export interface ConfidentialAirdropClientConfig {
-    publicClient: PublicClient;
-    walletClient?: WalletClient | undefined;
-    /** Deployed airdrop clone address. */
-    address: Address;
-    /**
-     * FHEVM ACL contract address override. When omitted, resolved from
-     * `publicClient.chain?.id` via the SDK's chain registry; the constructor
-     * throws `DeploymentAddressUnavailableError` if neither is available.
-     * Required because `getClaimAmount` filters the receipt for ACL grants
-     * to extract the returned handle.
-     */
-    aclAddress?: Address | undefined;
-    /**
-     * Optional telemetry sink. When provided, the SDK emits a `fhe-airdrop.client.init`
-     * event on construction and brackets public write methods with named spans
-     * (`fhe-airdrop.client.claim`, `…getClaimAmount`, …). Defaults to a no-op —
-     * zero overhead, zero leakage of consumer-side identifiers.
-     *
-     * The shape is structurally compatible with `NoopTelemetry` / `ConsoleTelemetry` /
-     * `TokenOpsTelemetry` exported from `@tokenops/sdk/telemetry`.
-     */
-    telemetry?: SdkTelemetry | undefined;
-}
-/**
- * Args for `claim()` / `getClaimAmount()`.
- *
- * The admin produces `{ encryptedInput, signature }` off-chain (typically
- * server-side) by encrypting the allocation with `userAddress: recipient`
- * (the Zama input proof MUST be bound to the recipient — the contract's
- * `FHE.fromExternal` rejects proofs bound to any other address) and then
- * signing the resulting handle with {@link signClaimAuthorization}. The
- * recipient submits exactly that pair — the SDK does not re-encrypt.
- *
- * The signature commits to a specific `bytes32` handle via EIP-712, so
- * re-encrypting the same plaintext locally would produce a different handle
- * and the signature would no longer match. That is why `encryptedInput` is
- * required and there is no plaintext `amount` field on this type.
- */
-export interface ClaimArgs {
-    /** Pre-encrypted external `euint64` input — must match the handle the admin signed. */
-    encryptedInput: EncryptedInput;
-    /** EIP-712 signature from an address with DEFAULT_ADMIN_ROLE on this clone. */
-    signature: Hex;
-    /**
-     * ETH value (in wei) to attach as `msg.value`. Defaults to `gasFee()` fetched
-     * live if omitted.
-     *
-     * Pre-fetch and cache with `await airdrop.gasFee()` when displaying the fee in
-     * the UI before the user clicks submit — this avoids an extra RPC round-trip and
-     * lets you present the exact cost upfront.
-     */
-    value?: bigint;
-    /** Override the submitting account. Defaults to `walletClient.account`. */
-    account?: Account | Address;
-}
-/** Args for {@link ConfidentialAirdropClient.getClaimAmount} — same shape as {@link ClaimArgs} minus `value` (the contract is not payable). */
-export interface GetClaimAmountArgs {
-    /** Pre-encrypted external `euint64` input — must match the handle the admin signed. */
-    encryptedInput: EncryptedInput;
-    /** EIP-712 signature from an address with DEFAULT_ADMIN_ROLE on this clone. */
-    signature: Hex;
-    /** Override the submitting account. Defaults to `walletClient.account`. */
-    account?: Account | Address;
-}
-/** Args for {@link ConfidentialAirdropClient.isSignatureValid}. */
-export interface IsSignatureValidArgs {
-    /** `externalEuint64` handle bytes32 — the same handle the admin signed. */
-    encryptedAmountHandle: Hex;
-    /** EIP-712 admin signature over `Claim(address recipient, bytes32 encryptedAmount)`. */
-    signature: Hex;
-    /**
-     * Address the contract will treat as `msg.sender` during the call.
-     * The on-chain check recomputes the struct hash over `(msg.sender, encryptedAmount)`,
-     * so the result varies per-caller — typically the wallet that intends to claim.
-     */
-    caller: Address;
-}
-/**
- * Typed wrapper around a deployed `ConfidentialAirdropCloneable` clone.
- *
- * The admin issues claims by encrypting the allocation **bound to the
- * recipient address** (Zama input proofs are bound to `(contractAddress,
- * userAddress)` — the contract's `FHE.fromExternal` will reject any other
- * binding) and signing the handle. The recipient calls
- * {@link ConfidentialAirdropClient.claim} with exactly that `{ encryptedInput,
- * signature }` pair; the SDK never re-encrypts on the recipient side because
- * the signature commits to a specific handle.
- *
- * @example
- * const airdrop = createConfidentialAirdropClient({
- *   publicClient, walletClient,
- *   address: airdropAddress,
- * });
- * await airdrop.claim({ encryptedInput, signature });
- */
-export declare class ConfidentialAirdropClient {
-    #private;
-    readonly publicClient: PublicClient;
-    readonly walletClient?: WalletClient;
-    readonly address: Address;
-    constructor(config: ConfidentialAirdropClientConfig);
-    /**
-     * The FHEVM ACL contract address used by encrypted-view methods to parse
-     * `ACL.Allowed` events. Resolved lazily on first access; throws
-     * `DeploymentAddressUnavailableError` if no override was passed and the
-     * SDK does not have an ACL deployed for the connected chain.
-     */
-    get aclAddress(): Address;
-    /** ERC-7984 confidential token this airdrop was deployed for. Immutable arg. */
-    token(): Promise<Address>;
-    /** Per-claim gas fee in wei. Immutable arg. Attached as `msg.value` by `claim()` automatically. */
-    gasFee(): Promise<bigint>;
-    /** Unix timestamp when claims become available. Immutable arg. */
-    startTime(): Promise<number>;
-    /** Whether the admin can extend the claim window past `endTime`. Immutable arg. */
-    canExtendClaimWindow(): Promise<boolean>;
-    /** Unix timestamp when claims end. Mutable — can be extended by admin if `canExtendClaimWindow`. */
-    endTime(): Promise<number>;
-    /** Whether claims are currently paused by the admin. */
-    isPaused(): Promise<boolean>;
-    /** Block number at which this clone was deployed. */
-    deploymentBlockNumber(): Promise<bigint>;
-    /**
-     * Check whether a pre-computed signature hash has been consumed.
-     *
-     * The contract keys claim replay-protection on
-     * `keccak256(abi.encode(CLAIM_TYPEHASH, recipient, bytes32(encryptedAmountHandle)))`.
-     * Use this when you already hold the struct hash (e.g. you computed it server-side
-     * while building the claim payload). For the more common case where you hold the
-     * user address and the encrypted handle, use {@link isSignatureClaimed} instead —
-     * it computes the hash for you.
-     *
-     * @param signatureHash `bytes32` storage key — the EIP-712 struct hash of the Claim.
-     */
-    claimedSignatures(signatureHash: Hex): Promise<boolean>;
-    /** `true` if within the claim time window and not paused. Free read — no gas. */
-    isClaimWindowActive(): Promise<boolean>;
-    /** `true` if the current timestamp is past `START_TIME`. */
-    hasClaimStarted(): Promise<boolean>;
-    /** `true` if the current timestamp is past `endTime`. */
-    hasClaimEnded(): Promise<boolean>;
-    /** EIP-712 domain separator for the clone. Useful for off-chain signing tools. */
-    domainSeparator(): Promise<Hex>;
-    /**
-     * EIP-712 type hash for the `Claim(address recipient, bytes32 encryptedAmount)`
-     * struct. Off-chain signers that don't use {@link signClaimAuthorization}
-     * (e.g. custom HSM-backed signers, ledger flows) need this to assemble the
-     * typed-data payload manually.
-     */
-    claimTypehash(): Promise<Hex>;
-    /**
-     * Check whether a claim has been consumed, given the user address and encrypted amount handle.
-     *
-     * This is the method most frontend developers want. Pass the same `user` and
-     * `encryptedAmountHandle` that appear in the admin-issued claim payload; the contract
-     * recomputes the struct hash internally and looks it up in storage.
-     *
-     * Prefer this over {@link claimedSignatures} unless you already hold the pre-computed
-     * `bytes32` struct hash (e.g. from a server-side indexer).
-     *
-     * @param user Recipient address from the claim authorization.
-     * @param encryptedAmountHandle The `externalEuint64` handle (as `Hex`) from the claim payload.
-     */
-    isSignatureClaimed(user: Address, encryptedAmountHandle: EncryptedHandle): Promise<boolean>;
-    /**
-     * Check whether an admin-issued claim authorization is valid for a specific caller,
-     * without consuming it.
-     *
-     * Returns `false` (not a revert) when the signature is **structurally valid** but
-     * fails one of the on-chain checks: already-claimed, claim window inactive, or the
-     * signer lacks `DEFAULT_ADMIN_ROLE`. The on-chain implementation recomputes the
-     * EIP-712 struct hash over `(msg.sender, encryptedAmount)`, so the result is
-     * caller-specific: a signature issued for recipient A is invalid when checked
-     * against caller B. Pass the address that will actually submit the claim.
-     *
-     * **Throws** {@link InvalidSignatureError} (code `TOKENOPS_INVALID_SIGNATURE`)
-     * when the signature bytes are **structurally malformed** — wrong length, invalid
-     * `s`-value range, or unparseable. The on-chain `ECDSA.recover` reverts before
-     * the boolean logic runs in that case, so consumer code must catch this
-     * separately from the `false` return:
-     *
-     * ```ts
-     * try {
-     *   const ok = await airdrop.isSignatureValid({ encryptedAmountHandle, signature, caller });
-     *   if (!ok) { /* signed by non-admin, window closed, or already claimed *\/ }
-     * } catch (err) {
-     *   if (err instanceof InvalidSignatureError) { /* malformed signature bytes *\/ }
-     * }
-     * ```
-     *
-     * Use this to show a pre-claim validation state in the UI before asking the user to
-     * pay gas.
-     */
-    isSignatureValid(args: IsSignatureValidArgs): Promise<boolean>;
-    /**
-     * Read-only preflight for {@link claim}. Runs the deterministic-from-off-chain
-     * checks in parallel and reports any blockers as typed {@link TokenOpsSdkError}s.
-     * Returns `{ ready: true, blockers: [] }` when the claim is safe to submit.
-     *
-     * Preflight is **opt-in**. Consumers who have already validated state can
-     * skip this call and invoke `claim` directly — they'll receive the same
-     * typed errors at write time via the revert mapper.
-     *
-     * Checks performed (all read-only, no gas):
-     * - Claim window started (`block.timestamp ≥ START_TIME`).
-     * - Claim window not closed (`block.timestamp ≤ endTime`).
-     * - Claims not paused.
-     * - Signature not already redeemed by this caller.
-     * - ETH balance covers `GAS_FEE()` (the `msg.value` the claim must attach).
-     *
-     * The EIP-712 admin-signature check is **not** preflight-detectable — the
-     * SDK cannot verify the signer's role without the contract round-trip — and
-     * will still surface as {@link InvalidSignatureError} at write time.
-     *
-     * Pool balance is also **not** preflight-detectable: the clone's confidential
-     * balance is an encrypted `euint64` handle that the SDK cannot read in
-     * plaintext. An unfunded clone will pass preflight and revert on-chain with
-     * {@link FheHandleNotAllowedError} (the FHEVM ACL rejects `FHE.allowTransient`
-     * on an uninitialized handle). Confirm the pool has been funded before
-     * showing `ready: true`.
-     *
-     * @returns `{ ready, blockers }` — same `code` shape the write would throw.
-     */
-    preflightClaim(args: {
-        caller: Address;
-        encryptedAmountHandle: Hex;
-    }): Promise<PreflightResult>;
-    /**
-     * Claim tokens using an EIP-712 admin signature. Sends `GAS_FEE()` ETH with the tx.
-     *
-     * The `encryptedInput` must be the exact handle the admin signed in
-     * {@link signClaimAuthorization}. The signature commits to that handle, so the SDK
-     * does NOT re-encrypt — submit the admin-issued payload as-is.
-     *
-     * **Silent-zero transfers.** ERC-7984 transfers do not revert when the sender's encrypted balance is insufficient — the transfer succeeds and moves an encrypted zero instead. This is by design: reverting would leak balance information. The transaction receipt alone cannot tell you whether value actually moved.
-     *
-     * **An unfunded pool is the opposite case — it reverts loudly.** Do not
-     * generalize the silent-zero rule above to a clone whose pool was never
-     * funded: that claim throws {@link FheHandleNotAllowedError} (the FHEVM ACL
-     * rejects `FHE.allowTransient` on an uninitialized handle), and
-     * {@link preflightClaim} cannot detect it because the pool balance is an
-     * encrypted `euint64` the SDK cannot read in plaintext.
-     *
-     * @returns Transaction hash.
-     * @example
-     * const fee = await airdrop.gasFee();
-     * const hash = await airdrop.claim({ encryptedInput, signature });
-     */
-    claim(args: ClaimArgs): Promise<Hex>;
-    /**
-     * **This is a write transaction, not a free view. It costs gas.**
-     *
-     * Verify the admin-signed claim allocation and grant the caller decrypt access
-     * to the encrypted amount. Budget gas and `await` the receipt before calling
-     * the Zama relayer's `userDecrypt` — the handle is only valid after the tx lands.
-     *
-     * Internally the contract calls `FHE.allow(handle, msg.sender)`, which persists
-     * the ACL grant on-chain. The handle is extracted from the receipt's ACL `Allowed`
-     * event — `simulateContract` would return a divergent handle and break decryption.
-     *
-     * Does **not** consume the claim (the `claimedSignatures` bit is not set). Call
-     * {@link claim} when the user is ready to transfer tokens.
-     *
-     * @returns `{ handle, hash }` — `handle` is a `euint64` granted to the caller;
-     *   pass it to the Zama relayer's `userDecrypt` to obtain the plaintext amount.
-     */
-    getClaimAmount(args: GetClaimAmountArgs): Promise<EncryptedViewResult>;
-    /**
-     * Withdraw all confidential tokens to `recipient`. `DEFAULT_ADMIN_ROLE` only.
-     *
-     * Calling on a clone whose pool was **never funded** throws
-     * {@link FheHandleNotAllowedError} (code `TOKENOPS_FHE_HANDLE_NOT_ALLOWED`).
-     * The contract calls `FHE.allowTransient` on the confidential balance handle;
-     * when the handle is uninitialized, the FHEVM ACL contract reverts with
-     * `SenderNotAllowed(address)`. Confirm the pool has been funded (e.g. via the
-     * factory's `createAndFund...` variant or a follow-up `confidentialTransfer`)
-     * before calling.
-     */
-    withdraw(recipient: Address, account?: Account | Address): Promise<Hex>;
-    /** Pause or unpause claims. DEFAULT_ADMIN_ROLE only. */
-    setPaused(paused: boolean, account?: Account | Address): Promise<TxHash>;
-    /**
-     * Extend the claim window end time. DEFAULT_ADMIN_ROLE only.
-     * Requires `CAN_EXTEND_CLAIM_WINDOW == true` or the contract reverts.
-     */
-    extendClaimWindow(newEndTime: number, account?: Account | Address): Promise<TxHash>;
-    /** Rescue accidentally sent ERC20 tokens. DEFAULT_ADMIN_ROLE only. */
-    withdrawOtherToken(tokenAddress: Address, recipient: Address, account?: Account | Address): Promise<Hex>;
-    /** Rescue accidentally sent ERC7984 confidential tokens. DEFAULT_ADMIN_ROLE only. */
-    withdrawOtherConfidentialToken(tokenAddress: Address, recipient: Address, account?: Account | Address): Promise<Hex>;
-    /**
-     * Withdraw collected ETH gas fees. FEE_COLLECTOR_ROLE only.
-     * Pass `amount = 0n` to withdraw the entire balance.
-     */
-    withdrawGasFee(recipient: Address, amount: bigint, account?: Account | Address): Promise<Hex>;
-    hasRole(role: Role, account: Address): Promise<boolean>;
-    grantRole(role: Role, accountTarget: Address, account?: Account | Address): Promise<TxHash>;
-    revokeRole(role: Role, accountTarget: Address, account?: Account | Address): Promise<TxHash>;
-}
-/**
- * Create a {@link ConfidentialAirdropClient}. Mirrors viem's `create*` convention.
- *
- * @example
- * const airdrop = createConfidentialAirdropClient({
- *   publicClient, walletClient,
- *   address: "0xYourAirdropClone",
- *   encryptor,
- * });
- */
-export declare function createConfidentialAirdropClient(config: ConfidentialAirdropClientConfig): ConfidentialAirdropClient;

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

@@ -1,37 +0,0 @@
-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 useClaim} when the user is ready to transfer tokens.
- *
- * Submits the admin-issued `{ encryptedInput, signature }` pair verbatim. The
- * SDK does NOT re-encrypt — the signature commits to the exact handle.
- *
- * @example
- * // `encryptedInput` + `signature` are the admin-issued payload delivered to
- * // the recipient (same pair the recipient passes to `useClaim`). Sourced
- * // from your server API or, for admin-dashboard flows, by combining
- * // `encryptUint64({ userAddress: recipient, ... })` with
- * // `useSignClaimAuthorization`.
- * const view = useAccessClaimAmount({ address: airdropAddress });
- * view.mutate({ encryptedInput, signature });
- * // view.data → { handle: "0x...", hash: "0x..." }
- */
-export declare function useAccessClaimAmount(options: AirdropHookOptions): UseMutationResult<EncryptedViewResult, Error, GetClaimAmountArgs>;
-/**
- * @deprecated Renamed to {@link useAccessClaimAmount}. Both submit a transaction, and the
- *   `useGet*` name reads as a free query — which misled bounty builders. This
- *   is the same function object, not a wrapper: behavior, argument types and
- *   thrown errors are identical. Removed in the next major.
- */
-export declare const useGetClaimAmount: typeof useAccessClaimAmount;

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

@@ -1,7 +0,0 @@
-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>;

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

@@ -1,10 +0,0 @@
-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

@@ -1,16 +0,0 @@
-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

@@ -1,6 +0,0 @@
-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

@@ -1,8 +0,0 @@
-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

@@ -1,10 +0,0 @@
-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

@@ -1,17 +0,0 @@
-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

@@ -1,10 +0,0 @@
-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>;