@tokenops/sdk 1.6.0 → 2.0.0-alpha.2

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

@@ -0,0 +1,67 @@
+import { type UseQueryResult } from "@tanstack/react-query";
+import type { Hex } from "viem";
+import type { DedupMode } from "../constants.js";
+import { type AirdropInstanceHookOptions } from "./_shared.js";
+/**
+ * The `bytes32` role identifiers an airdrop instance exposes - the eight every
+ * variant shares, plus whichever ninth belongs to the variant asked for.
+ *
+ * @alpha
+ */
+export interface AirdropRoleConstants {
+    /** Gates `pause` / `unpause`. */
+    PAUSER_ROLE: Hex;
+    /** Gates `extendClaimWindow`. */
+    WINDOW_ADMIN_ROLE: Hex;
+    /** Gates `withdrawConfidential`. */
+    TREASURY_ROLE: Hex;
+    /** Gates the ERC-20 / foreign-token rescue surface. */
+    RESCUER_ROLE: Hex;
+    /** Gates `withdrawGasFee`, and administers itself rather than being administered by `DEFAULT_ADMIN_ROLE`. */
+    FEE_COLLECTOR_ROLE: Hex;
+    /** Gates `upgradeToAndCall` on UUPS instances; inert on clones. */
+    UPGRADER_ROLE: Hex;
+    /** Gates the admin disclosure surface. */
+    DISCLOSURE_ADMIN_ROLE: Hex;
+    /** OpenZeppelin's root role, read off the instance rather than assumed to be `bytes32(0)`. */
+    DEFAULT_ADMIN_ROLE: Hex;
+    /** Gates `setMerkleRoot`. Present only when `variant: "merkle"` was requested. */
+    MERKLE_ADMIN_ROLE?: Hex;
+    /** The role whose holders may authorize an ECDSA claim. Present only when `variant: "ecdsa"` was requested. */
+    SIGNER_ROLE?: Hex;
+}
+/** @alpha */
+export interface UseAirdropRoleConstantsArgs extends AirdropInstanceHookOptions<AirdropRoleConstants> {
+    /**
+     * Also read the variant-only role: `MERKLE_ADMIN_ROLE` or `SIGNER_ROLE`.
+     * Omit it for the eight shared constants and neither extra read fires.
+     */
+    variant?: "ecdsa" | "merkle";
+    /**
+     * Only relevant with `variant: "ecdsa"`, and only to keep the client
+     * construction honest - no read here consumes it. Pass the campaign's real
+     * policy if you have it to hand.
+     */
+    dedupMode?: DedupMode;
+}
+/**
+ * Read an airdrop instance's role identifiers in one fan-out.
+ *
+ * Every value is a bytecode constant, so this is cacheable indefinitely
+ * (`staleTime: Infinity` by default, overridable through `query`). Feed the
+ * results into {@link useAirdropHasRole}, {@link useAirdropRoleMembers},
+ * {@link useAirdropRoleAdmin} and the role mutations - hand-hashing
+ * `keccak256("PAUSER_ROLE")` client-side would turn a constant renamed in a
+ * future contract version into a `grantRole` that silently grants a role
+ * nothing checks.
+ *
+ * One bundled hook rather than ten one-liners nobody would call separately: a
+ * UI needs the whole palette to render a role panel at all.
+ *
+ * @example
+ * const { data: roles } = useAirdropRoleConstants({ address, variant: "merkle" });
+ * const { data: isPauser } = useAirdropHasRole({ address, role: roles?.PAUSER_ROLE, holder });
+ *
+ * @alpha
+ */
+export declare function useAirdropRoleConstants(args: UseAirdropRoleConstantsArgs): UseQueryResult<AirdropRoleConstants, Error>;

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

@@ -0,0 +1,49 @@
+import { type UseQueryResult } from "@tanstack/react-query";
+import type { Address, Hex } from "viem";
+import { type AirdropInstanceHookOptions } from "./_shared.js";
+/**
+ * One role's membership on an airdrop instance - the set and its size, read
+ * together.
+ *
+ * @alpha
+ */
+export interface AirdropRoleMembership {
+    /** Every account currently holding the role, in the contract's `EnumerableSet` order. */
+    members: readonly Address[];
+    /** How many accounts hold it. The variable the contract's own revoke floors are written against. */
+    count: bigint;
+}
+/** @alpha */
+export interface UseAirdropRoleMembersArgs extends AirdropInstanceHookOptions<AirdropRoleMembership> {
+    /** The role whose members to list - from {@link useAirdropRoleConstants}, not hand-hashed. */
+    role?: Hex;
+}
+/**
+ * List who holds `role` on an airdrop instance, with the member count.
+ *
+ * This is the supported way to discover a campaign's fee collectors: the
+ * contract deliberately ships no `feeCollectors()` view and points callers at
+ * `getRoleMembers(FEE_COLLECTOR_ROLE)` instead.
+ *
+ * `count` is bundled rather than split into its own hook because it is the
+ * variable the contract's revoke floors are written against - a revoke of
+ * `DEFAULT_ADMIN_ROLE` at count 1 reverts `LastAdmin`, and of
+ * `FEE_COLLECTOR_ROLE` at count 1 on a fee-charging campaign reverts
+ * `LastFeeCollector` - so a UI showing the list wants to know in the same
+ * render whether a revoke is possible at all.
+ *
+ * Unpaginated: role sets here are operator-sized, not user-sized.
+ *
+ * @remarks
+ * Invalidated by {@link useAirdropGrantRole}, {@link useAirdropRevokeRole},
+ * {@link useAirdropRenounceRole} and {@link useGrantInstanceRoles}. Member
+ * order is `EnumerableSet`'s and is not stable across grants and revokes -
+ * treat it as a set, not a list.
+ *
+ * @example
+ * const { data } = useAirdropRoleMembers({ address, role: roles?.FEE_COLLECTOR_ROLE });
+ * const canRevoke = (data?.count ?? 0n) > 1n;
+ *
+ * @alpha
+ */
+export declare function useAirdropRoleMembers(args: UseAirdropRoleMembersArgs): UseQueryResult<AirdropRoleMembership, Error>;

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

@@ -1,11 +1,18 @@
 import { type UseQueryResult } from "@tanstack/react-query";
 import type { Address } from "viem";
-import { type AirdropHookOptions } from "./_shared.js";
+import { type AirdropInstanceHookOptions } from "./_shared.js";
+/** @alpha */
+export type UseAirdropTokenArgs = AirdropInstanceHookOptions<Address>;
 /**
- * Read the airdrop clone's immutable `TOKEN`. Result is cacheable for the
- * clone's lifetime — the field is baked into the clone's bytecode.
+ * Read the ERC-7984 token an airdrop instance distributes.
+ *
+ * Works against either variant — `token` is declared on the shared
+ * `ConfidentialAirdropBase` surface, so this hook needs no ECDSA/Merkle
+ * distinction.
  *
  * @example
  * const { data: token } = useAirdropToken({ address: airdropAddress });
+ *
+ * @alpha
  */
-export declare function useAirdropToken(options: AirdropHookOptions): UseQueryResult<Address, Error>;
+export declare function useAirdropToken(args: UseAirdropTokenArgs): UseQueryResult<Address, Error>;

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

@@ -0,0 +1,45 @@
+import { type UseMutationResult } from "@tanstack/react-query";
+import type { Address, Hex } from "viem";
+import type { WriteAccountOverride } from "../airdrop-base.js";
+import { type AirdropInstanceClientOptions } from "./_shared.js";
+/** @alpha */
+export interface AirdropUpgradeToAndCallArgs extends WriteAccountOverride {
+    /** The new implementation the proxy should point at. */
+    newImplementation: Address;
+    /**
+     * Initializer calldata to run against the new implementation, or `"0x"`
+     * (the default) for a plain swap. A non-empty payload is a `delegatecall`:
+     * the new implementation's code executes against THIS instance's storage.
+     */
+    data?: Hex;
+    /**
+     * Wei to attach. Leave unset for a plain swap — ERC-1967 reverts
+     * `ERC1967NonPayable` when value is sent with empty `data`.
+     */
+    value?: bigint;
+}
+/**
+ * Point an airdrop instance's ERC-1967 proxy at a new implementation,
+ * optionally calling into it in the same transaction. Requires
+ * `UPGRADER_ROLE`.
+ *
+ * **Inert on clone-mode instances** — a clone has no implementation slot to
+ * rewrite. Gate the UI on `useAirdropDeploymentMode().data === "uups"`;
+ * `proxiableUUID` cannot tell the two shells apart. Merkle campaigns never
+ * reach this at all, because the SDK refuses to create one in `uups` mode
+ * (`MerkleUupsUnsupportedError`).
+ *
+ * **Non-empty `data` runs as a delegatecall against this instance's own
+ * storage** — a wrong payload can brick the campaign irrecoverably.
+ *
+ * **Invalidates:** nothing. No hook in this subpath reads the instance's
+ * implementation pointer, and `deploymentMode` does not change across an
+ * upgrade.
+ *
+ * @example
+ * const upgrade = useAirdropUpgradeToAndCall({ address: airdropAddress });
+ * await upgrade.mutateAsync({ newImplementation: nextImpl });
+ *
+ * @alpha
+ */
+export declare function useAirdropUpgradeToAndCall(options: AirdropInstanceClientOptions): UseMutationResult<Hex, Error, AirdropUpgradeToAndCallArgs>;

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

@@ -0,0 +1,37 @@
+import { type UseQueryResult } from "@tanstack/react-query";
+import { type AirdropInstanceHookOptions } from "./_shared.js";
+/**
+ * Plaintext claim-window snapshot — combines five `AirdropBaseClient` reads into one.
+ *
+ * @alpha
+ */
+export interface AirdropWindow {
+    /** Claim-window open, Unix seconds. */
+    startTime: number;
+    /** Claim-window close, Unix seconds. Movable forward via `useExtendClaimWindow`. */
+    endTime: number;
+    /** Whether `startTime` has passed. Says nothing about the pause flag. */
+    hasStarted: boolean;
+    /** Whether `endTime` has passed. Says nothing about the pause flag. */
+    hasEnded: boolean;
+    /** In window AND not paused — the actual "would a claim be accepted right now" answer. */
+    isActive: boolean;
+}
+/** @alpha */
+export type UseAirdropWindowArgs = AirdropInstanceHookOptions<AirdropWindow>;
+/**
+ * Read an airdrop instance's claim-window snapshot in one round trip.
+ *
+ * Bundles `startTime` / `endTime` / `hasClaimStarted` / `hasClaimEnded` /
+ * `isClaimWindowActive` — five independent contract reads a UI almost always
+ * wants together (e.g. "claim opens at X, closes at Y, currently active: Z")
+ * — rather than shipping five near-identical one-line hooks nobody would call
+ * separately (the v1 mistake this cutover is deliberately not repeating).
+ *
+ * @example
+ * const { data: window } = useAirdropWindow({ address: airdropAddress });
+ * if (window?.isActive) { ... }
+ *
+ * @alpha
+ */
+export declare function useAirdropWindow(args: UseAirdropWindowArgs): UseQueryResult<AirdropWindow, Error>;

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

@@ -0,0 +1,32 @@
+import { type UseMutationResult } from "@tanstack/react-query";
+import type { Address, Hex } from "viem";
+import type { WriteAccountOverride } from "../airdrop-base.js";
+import { type AirdropInstanceClientOptions } from "./_shared.js";
+/** @alpha */
+export interface UseBatchDiscloseHandlesToPartyArgs extends WriteAccountOverride {
+    /** Existing `euint64` handles - public pointers, not values. */
+    handles: readonly Hex[];
+    /** The single address granted decrypt access on every handle. */
+    party: Address;
+}
+/**
+ * Grants one `party` decrypt access to several handles you already hold, in a
+ * single transaction. Produces no new handles, so it returns the transaction
+ * hash.
+ *
+ * The same two gates as `useDiscloseHandleToParty` apply per handle - the
+ * caller allowed on it (unless it holds `DISCLOSURE_ADMIN_ROLE`) and the
+ * instance allowed on it - and the first failure reverts the whole batch,
+ * naming the offending handle. It is all-or-nothing: a partial grant is never
+ * left behind.
+ *
+ * **Invalidates:** nothing. ACL is append-only and no read hook in this
+ * subpath caches who is allowed on a handle.
+ *
+ * @example
+ * const disclose = useBatchDiscloseHandlesToParty({ address: airdropAddress });
+ * await disclose.mutateAsync({ handles: [balanceHandle, claimHandle], party: auditor });
+ *
+ * @alpha
+ */
+export declare function useBatchDiscloseHandlesToParty(options: AirdropInstanceClientOptions): UseMutationResult<Hex, Error, UseBatchDiscloseHandlesToPartyArgs>;

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

@@ -0,0 +1,68 @@
+import { type UseMutationResult } from "@tanstack/react-query";
+import type { Address } from "viem";
+import { type CampaignSubmitterOption } from "../campaign.js";
+import { type EncryptorSource } from "../encryption.js";
+import type { BuiltCampaign, CampaignRecipient } from "../types.js";
+/**
+ * Hook-level config for {@link useBuildMerkleCampaign}. The instance already
+ * exists on the mutable-root path, so no chain client is needed — only the
+ * encryptor.
+ *
+ * @alpha
+ */
+export interface UseBuildMerkleCampaignOptions {
+    /**
+     * Eager or lazy encryptor. Wire it lazily so the live React context is read
+     * at submit time rather than captured at mount (CLAUDE.md Pitfall #3):
+     * `const sdk = useZamaSDK()` once, then `encryptor: () => sdk.relayer`.
+     */
+    encryptor?: EncryptorSource;
+}
+/**
+ * Variables for {@link useBuildMerkleCampaign}.
+ *
+ * @alpha
+ */
+export interface UseBuildMerkleCampaignArgs extends CampaignSubmitterOption {
+    /** The LIVE `MerkleConfidentialAirdrop` instance every input is bound to. Not the factory, not the implementation. */
+    instance: Address;
+    /** CUMULATIVE totals per account, never per-drop tranches. */
+    recipients: readonly CampaignRecipient[];
+}
+/**
+ * Encrypt a roster and build the Merkle tree those ciphertexts belong to, for
+ * an instance that already exists — the **mutable-root** path. Publish the
+ * returned `root` with {@link useSetMerkleRoot}, or let
+ * {@link useRotateMerkleRoot} build and publish in one call. For an instance
+ * whose root is fixed at create time use {@link usePlanMerkleCampaign}: there
+ * is no address to encrypt against yet.
+ *
+ * **The returned `entries` ARE the campaign — persist them before the
+ * component unmounts.** The instance stores only the 32-byte root; there is no
+ * getter and no event that maps an account to its handle, input proof or
+ * Merkle branch. A recipient who does not hold their own
+ * `(handle, inputProof, merkleProof)` triple can never claim, and no on-chain
+ * data reconstructs it. Losing this result to a re-render is the likeliest way
+ * to brick a campaign.
+ *
+ * A mutation rather than a query: encryption is randomised, so the same roster
+ * builds a different root every call and there is no cache identity to key.
+ *
+ * Each entry is `{ account, boundTo, handle, inputProof, merkleProof }` —
+ * `account` selects the leaf and the cumulative accounting, `boundTo` is the
+ * only address the coprocessor accepts as sender. They are equal unless
+ * `submitter` was set.
+ *
+ * **Invalidates:** nothing. Off-chain work only; the root is not published here.
+ *
+ * @throws {@link InvalidArgumentError} on a duplicate, zero-address or out-of-`uint64`-range roster entry, or a zero `instance`.
+ * @throws {@link MissingEncryptorError} when `encryptor` resolves to `undefined`.
+ *
+ * @example
+ * const build = useBuildMerkleCampaign({ encryptor: () => sdk.relayer });
+ * const { root, entries } = await build.mutateAsync({ instance: airdrop, recipients });
+ * await persist(entries); // before anything else
+ *
+ * @alpha
+ */
+export declare function useBuildMerkleCampaign(options?: UseBuildMerkleCampaignOptions): UseMutationResult<BuiltCampaign, Error, UseBuildMerkleCampaignArgs>;

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

@@ -0,0 +1,29 @@
+import { type UseQueryResult } from "@tanstack/react-query";
+import type { Address } from "viem";
+import type { EncryptedHandle } from "../../core/brands.js";
+import { type AirdropInstanceHookOptions } from "./_shared.js";
+/** @alpha */
+export interface UseClaimedAmountArgs extends AirdropInstanceHookOptions<EncryptedHandle> {
+    /** The account whose cumulative delivered total to read. */
+    account?: Address;
+}
+/**
+ * Read `account`'s cumulative delivered total on a `MerkleConfidentialAirdrop`
+ * instance, as an encrypted handle — pass it to the Zama relayer's
+ * `userDecrypt` to see the plaintext.
+ *
+ * **Caller-specific — `account` is part of the cache key.** Switching the
+ * connected account (or checking a different address) never serves a value
+ * cached for the previous account; see {@link airdropQueryKey}.
+ *
+ * @remarks
+ * This is the recipient's CUMULATIVE total delivered so far, not a per-claim
+ * amount — see {@link MerkleAirdropClient.getClaimedAmount}'s TSDoc for the
+ * root-rotation and one-leaf-per-recipient consequences of that.
+ *
+ * @example
+ * const { data: claimedHandle } = useClaimedAmount({ address, account });
+ *
+ * @alpha
+ */
+export declare function useClaimedAmount(args: UseClaimedAmountArgs): UseQueryResult<EncryptedHandle, Error>;

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

@@ -0,0 +1,32 @@
+import { type UseMutationResult } from "@tanstack/react-query";
+import type { Address, Hex } from "viem";
+import type { WriteAccountOverride } from "../airdrop-base.js";
+import { type AirdropInstanceClientOptions } from "./_shared.js";
+/** @alpha */
+export interface ComplianceGrantRoleArgs extends WriteAccountOverride {
+    /** A `bytes32` role identifier - from {@link useComplianceRoleConstants}, never hand-hashed. */
+    role: Hex;
+    /** The account receiving the role. Distinct from `account`, which is who sends the transaction. */
+    holder: Address;
+}
+/**
+ * Grant one role on a compliance-manager clone. `options.address` is the
+ * CLONE. Requires the role's admin role, which is `DEFAULT_ADMIN_ROLE` for
+ * both roles this contract defines.
+ *
+ * This is how a campaign owner hands delegate administration to a compliance
+ * team without giving them anything on the airdrop instance itself - the two
+ * contracts keep separate role sets, and a grant here confers no pause,
+ * treasury or disclosure power over the campaign.
+ *
+ * **Invalidates:** this clone's {@link useComplianceHasRole} entry for exactly
+ * `(role, holder)` and its {@link useComplianceRoleMembers} entry for `role`
+ * (the list and the count both move). Scoped to this clone.
+ *
+ * @example
+ * const grant = useComplianceGrantRole({ address: managerAddress });
+ * await grant.mutateAsync({ role: roles.DELEGATION_ADMIN_ROLE, holder: complianceTeam });
+ *
+ * @alpha
+ */
+export declare function useComplianceGrantRole(options: AirdropInstanceClientOptions): UseMutationResult<Hex, Error, ComplianceGrantRoleArgs>;

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

@@ -0,0 +1,37 @@
+import { type UseQueryResult } from "@tanstack/react-query";
+import type { Address, Hex } from "viem";
+import { type AirdropInstanceHookOptions } from "./_shared.js";
+/** @alpha */
+export interface UseComplianceHasRoleArgs extends AirdropInstanceHookOptions<boolean> {
+    /** A `bytes32` role identifier - from {@link useComplianceRoleConstants}, not hand-hashed. */
+    role?: Hex;
+    /** The account to check. Distinct from a delegate: this is who may MANAGE delegates. */
+    holder?: Address;
+}
+/**
+ * Whether `holder` holds `role` on a compliance-manager clone. `address` is
+ * the CLONE.
+ *
+ * With `DELEGATION_ADMIN_ROLE` this is the gate on the delegate surface -
+ * mount {@link useAddComplianceDelegate}'s and
+ * {@link useRevokeComplianceDelegate}'s controls behind it. Holding a role
+ * here grants nothing on the airdrop instance itself; the two contracts have
+ * separate role sets.
+ *
+ * Stays disabled until both `role` and `holder` are defined, so a UI can call
+ * it unconditionally while the role constants are still loading.
+ *
+ * @remarks
+ * Invalidated by {@link useComplianceGrantRole},
+ * {@link useComplianceRevokeRole} and {@link useComplianceRenounceRole}.
+ *
+ * @example
+ * const { data: canDelegate } = useComplianceHasRole({
+ *   address: managerAddress,
+ *   role: roles?.DELEGATION_ADMIN_ROLE,
+ *   holder: account,
+ * });
+ *
+ * @alpha
+ */
+export declare function useComplianceHasRole(args: UseComplianceHasRoleArgs): UseQueryResult<boolean, Error>;

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

@@ -0,0 +1,50 @@
+import { type UseQueryResult } from "@tanstack/react-query";
+import type { Address } from "viem";
+import { type AirdropInstanceHookOptions } from "./_shared.js";
+/**
+ * One compliance-manager clone's wiring - who it serves and who may decrypt
+ * through it, read together.
+ *
+ * @alpha
+ */
+export interface ComplianceInfo {
+    /** The one airdrop instance this clone serves. */
+    airdrop: Address;
+    /**
+     * The platform compliance delegate, or the zero address when this clone was
+     * created with the factory's compliance policy OFF. Never "not wired yet" -
+     * see the hook's TSDoc. Irrevocable when set.
+     */
+    platformDelegate: Address;
+    /** The mutable client-delegate set. Excludes `platformDelegate`. */
+    clientDelegates: readonly Address[];
+}
+/** @alpha */
+export type UseComplianceInfoArgs = AirdropInstanceHookOptions<ComplianceInfo>;
+/**
+ * Read a compliance-manager clone's whole wiring in one round trip - the
+ * airdrop it serves, its platform delegate, and its client-delegate set.
+ *
+ * `address` is the CLONE, not the airdrop instance: resolve it with
+ * {@link useComplianceManagerOf} or take it off `CreateAirdropResult.complianceManager`.
+ *
+ * A zero `platformDelegate` is unambiguous. The factory runs the clone's
+ * `initialize` atomically inside `createX`, so there is no observable
+ * "deployed but not yet wired" state - zero always means "created with the
+ * platform compliance policy off", never "not set up yet".
+ *
+ * `clientDelegates` deliberately omits the platform delegate, so it is not the
+ * answer to "may this address decrypt?" - use {@link useIsActiveDelegate},
+ * which reads the ACL directly and covers both slots.
+ *
+ * @remarks
+ * Invalidated by {@link useAddComplianceDelegate} and
+ * {@link useRevokeComplianceDelegate}.
+ *
+ * @example
+ * const { data } = useComplianceInfo({ address: complianceManagerAddress });
+ * const hasPlatformDelegate = data?.platformDelegate !== "0x0000000000000000000000000000000000000000";
+ *
+ * @alpha
+ */
+export declare function useComplianceInfo(args: UseComplianceInfoArgs): UseQueryResult<ComplianceInfo, Error>;

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

@@ -0,0 +1,16 @@
+import { type UseQueryResult } from "@tanstack/react-query";
+import type { Address } from "viem";
+import { type AirdropInstanceHookOptions } from "./_shared.js";
+/** @alpha */
+export type UseComplianceManagerArgs = AirdropInstanceHookOptions<Address>;
+/**
+ * Read an airdrop instance's own compliance-manager clone — the only
+ * contract, besides the caller, ever granted ACL on that instance's
+ * confidential handles.
+ *
+ * @example
+ * const { data: complianceManager } = useComplianceManager({ address: airdropAddress });
+ *
+ * @alpha
+ */
+export declare function useComplianceManager(args: UseComplianceManagerArgs): UseQueryResult<Address, Error>;

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

@@ -0,0 +1,32 @@
+import { type UseQueryResult } from "@tanstack/react-query";
+import type { Address } from "viem";
+import { type AirdropHookOptions } from "./_shared.js";
+/** @alpha */
+export interface UseComplianceManagerOfArgs extends AirdropHookOptions<Address> {
+    /** The airdrop instance whose compliance-manager clone to resolve. */
+    airdrop?: Address;
+}
+/**
+ * Resolve the `ComplianceRoleManager` clone bound to an airdrop instance, by
+ * asking the factory. This is the entry point for every other compliance
+ * hook: they are all scoped to the CLONE address, not the instance address.
+ *
+ * **Also a provenance check.** The factory records this mapping only for
+ * instances it deployed, so a zero address means the instance did not come
+ * from this factory - do not mount the compliance hooks on it.
+ *
+ * Cached indefinitely (`staleTime: Infinity`, overridable through `query`):
+ * the mapping is written once, inside `createX`, and never changes.
+ *
+ * @remarks
+ * {@link useComplianceManager} answers the same question from the other side,
+ * by asking the instance for its own clone. Prefer this hook when you hold no
+ * instance client, or when you want the provenance answer as well.
+ *
+ * @example
+ * const { data: manager } = useComplianceManagerOf({ airdrop: airdropAddress });
+ * const { data: info } = useComplianceInfo({ address: manager! });
+ *
+ * @alpha
+ */
+export declare function useComplianceManagerOf(args?: UseComplianceManagerOfArgs): UseQueryResult<Address, Error>;

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

@@ -0,0 +1,38 @@
+import { type UseMutationResult } from "@tanstack/react-query";
+import type { Hex } from "viem";
+import type { WriteAccountOverride } from "../airdrop-base.js";
+import { type AirdropInstanceClientOptions } from "./_shared.js";
+/** @alpha */
+export interface ComplianceRenounceRoleArgs extends WriteAccountOverride {
+    /** A `bytes32` role identifier - from {@link useComplianceRoleConstants}, never hand-hashed. */
+    role: Hex;
+}
+/**
+ * Give up a role on a compliance-manager clone yourself. `options.address` is
+ * the CLONE.
+ *
+ * Self-only by construction: the contract's
+ * `renounceRole(role, callerConfirmation)` reverts
+ * `AccessControlBadConfirmation` unless the confirmation is the sender, so
+ * there is no holder to pass - the headless client fills it from the resolved
+ * sending account. To remove somebody else's role use
+ * {@link useComplianceRevokeRole}.
+ *
+ * No last-admin floor guards this: the sole `DEFAULT_ADMIN_ROLE` holder CAN
+ * renounce, and doing so freezes the clone's delegate set permanently.
+ *
+ * **Invalidates:** every {@link useComplianceHasRole} entry for this clone
+ * (prefix, all role/holder pairs), plus its
+ * {@link useComplianceRoleMembers} entry for `role`. The prefix is
+ * deliberate - the holder here is whichever account the wallet client resolves
+ * at submit time, which need not match any `(role, holder)` pair a component
+ * happens to have cached, and a narrower key would invalidate nothing while
+ * throwing nothing. Still scoped to this clone.
+ *
+ * @example
+ * const renounce = useComplianceRenounceRole({ address: managerAddress });
+ * await renounce.mutateAsync({ role: roles.DELEGATION_ADMIN_ROLE });
+ *
+ * @alpha
+ */
+export declare function useComplianceRenounceRole(options: AirdropInstanceClientOptions): UseMutationResult<Hex, Error, ComplianceRenounceRoleArgs>;

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

@@ -0,0 +1,36 @@
+import { type UseMutationResult } from "@tanstack/react-query";
+import type { Address, Hex } from "viem";
+import type { WriteAccountOverride } from "../airdrop-base.js";
+import { type AirdropInstanceClientOptions } from "./_shared.js";
+/** @alpha */
+export interface ComplianceRevokeRoleArgs extends WriteAccountOverride {
+    /** A `bytes32` role identifier - from {@link useComplianceRoleConstants}, never hand-hashed. */
+    role: Hex;
+    /** The account losing the role. Distinct from `account`, which is who sends the transaction. */
+    holder: Address;
+}
+/**
+ * Revoke one role from one holder on a compliance-manager clone.
+ * `options.address` is the CLONE. Requires the role's admin role.
+ *
+ * **Revoking a delegation admin revokes no delegation.** The FHEVM ACL is
+ * append-only, so every delegate that account already added keeps decrypting
+ * until {@link useRevokeComplianceDelegate} is called for it explicitly. This
+ * is the most likely wrong assumption about this button: it removes the power
+ * to add more delegates, nothing else.
+ *
+ * The contract enforces no last-admin floor either - revoking the sole
+ * `DEFAULT_ADMIN_ROLE` holder freezes the clone's delegate set permanently.
+ * Check {@link useComplianceRoleMembers}'s `count` first.
+ *
+ * **Invalidates:** this clone's {@link useComplianceHasRole} entry for exactly
+ * `(role, holder)` and its {@link useComplianceRoleMembers} entry for `role`.
+ * Scoped to this clone.
+ *
+ * @example
+ * const revoke = useComplianceRevokeRole({ address: managerAddress });
+ * await revoke.mutateAsync({ role: roles.DELEGATION_ADMIN_ROLE, holder: formerTeam });
+ *
+ * @alpha
+ */
+export declare function useComplianceRevokeRole(options: AirdropInstanceClientOptions): UseMutationResult<Hex, Error, ComplianceRevokeRoleArgs>;

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

@@ -0,0 +1,41 @@
+import { type UseQueryResult } from "@tanstack/react-query";
+import type { Hex } from "viem";
+import { type AirdropInstanceHookOptions } from "./_shared.js";
+/**
+ * The `bytes32` role identifiers a compliance-manager clone exposes.
+ *
+ * @alpha
+ */
+export interface ComplianceRoleConstants {
+    /** Gates `addDelegate` / `revokeDelegate`. */
+    DELEGATION_ADMIN_ROLE: Hex;
+    /** OpenZeppelin's root role, read off the clone rather than assumed to be `bytes32(0)`. It administers `DELEGATION_ADMIN_ROLE`. */
+    DEFAULT_ADMIN_ROLE: Hex;
+}
+/** @alpha */
+export type UseComplianceRoleConstantsArgs = AirdropInstanceHookOptions<ComplianceRoleConstants>;
+/**
+ * Read a compliance-manager clone's role identifiers. `address` is the CLONE.
+ *
+ * Both values are bytecode constants, so this is cacheable indefinitely
+ * (`staleTime: Infinity` by default, overridable through `query`). Feed them
+ * into {@link useComplianceHasRole}, {@link useComplianceRoleMembers} and the
+ * role mutations rather than hand-hashing `keccak256("DELEGATION_ADMIN_ROLE")`
+ * client-side, which would turn a constant renamed in a future contract
+ * version into a grant of a role nothing checks.
+ *
+ * Bundled despite being only two reads, so the shape matches
+ * {@link useAirdropRoleConstants} and the factory equivalent - and because two
+ * one-line hooks for two constants is the pattern this subpath avoids.
+ *
+ * @example
+ * const { data: roles } = useComplianceRoleConstants({ address: managerAddress });
+ * const { data: canDelegate } = useComplianceHasRole({
+ *   address: managerAddress,
+ *   role: roles?.DELEGATION_ADMIN_ROLE,
+ *   holder: account,
+ * });
+ *
+ * @alpha
+ */
+export declare function useComplianceRoleConstants(args: UseComplianceRoleConstantsArgs): UseQueryResult<ComplianceRoleConstants, Error>;