@tokenops/sdk 1.6.0 → 2.0.0-alpha.2

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

@@ -0,0 +1,26 @@
+import { type UseMutationResult } from "@tanstack/react-query";
+import type { Address, Hex } from "viem";
+import type { WriteAccountOverride } from "../../airdrop-base.js";
+import { type AirdropClientOptions } from "../../react/_shared.js";
+/** @alpha */
+export interface ClearUpgradeabilityPolicyArgs extends WriteAccountOverride {
+    /** The creator whose override is dropped - not the admin sending the transaction. */
+    creator: Address;
+}
+/**
+ * Drop a creator's {@link useSetUpgradeabilityPolicy} override, reverting
+ * them to the factory default. Requires `UPGRADE_MANAGER_ROLE`.
+ *
+ * **Invalidates:** `fn "effectiveUpgradeable"` and `fn "upgradeabilityPolicy"`, both
+ * keyed on `args.creator`, plus the `fn "preflightCreate"` PREFIX. Reverting to the
+ * default flips `effectiveUpgradeable` exactly as setting an override does, and
+ * `preflightCreate` reads it to decide whether a `mode: "uups"` create is refused - so
+ * omitting the prefix here would leave a create form showing a stale allow/deny.
+ *
+ * @example
+ * const clearPolicy = useClearUpgradeabilityPolicy();
+ * await clearPolicy.mutateAsync({ creator });
+ *
+ * @alpha
+ */
+export declare function useClearUpgradeabilityPolicy(options?: AirdropClientOptions): UseMutationResult<Hex, Error, ClearUpgradeabilityPolicyArgs>;

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

@@ -0,0 +1,25 @@
+import { type UseMutationResult } from "@tanstack/react-query";
+import type { Address, Hex } from "viem";
+import type { WriteAccountOverride } from "../../airdrop-base.js";
+import { type AirdropClientOptions } from "../../react/_shared.js";
+/** @alpha */
+export interface DisableCustomFeeArgs extends WriteAccountOverride {
+    /** The creator whose override is dropped - NOT the admin sending the transaction. */
+    creator: Address;
+}
+/**
+ * Drop a creator's per-creator fee override, reverting them to the factory's
+ * `defaultGasFee`.
+ *
+ * Requires `FEE_MANAGER_ROLE`.
+ *
+ * **Invalidates:** `useFactoryCustomFee({ creator })` for the TARGET creator -
+ * `variables.creator`, never the sending admin.
+ *
+ * @example
+ * const disableCustomFee = useDisableCustomFee();
+ * await disableCustomFee.mutateAsync({ creator });
+ *
+ * @alpha
+ */
+export declare function useDisableCustomFee(options?: AirdropClientOptions): UseMutationResult<Hex, Error, DisableCustomFeeArgs>;

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

@@ -0,0 +1,30 @@
+import { type UseQueryResult } from "@tanstack/react-query";
+import type { Hex } from "viem";
+import type { DeploymentMode } from "../../constants.js";
+import { type AirdropHookOptions } from "../../react/_shared.js";
+import type { EcdsaAirdropParams } from "../../types.js";
+/** @alpha */
+export interface UseEcdsaInitCodeHashArgs extends AirdropHookOptions<Hex> {
+    params: EcdsaAirdropParams;
+    mode: DeploymentMode;
+}
+/**
+ * Init-code hash of the ECDSA proxy the factory would deploy for `mode`.
+ *
+ * The hash tracks the factory's current implementation pointer, so it exists
+ * to bracket a prediction for freshness: read it before a campaign build and
+ * again after, and a change between the two means an implementation swap
+ * landed mid-flight and every address derived from
+ * {@link usePredictEcdsaAirdropAddress} is stale. Feed the first observation
+ * to `usePreflightCreateAirdrop`'s `expectedInitCodeHash` to have the drift
+ * check made for you.
+ *
+ * Lives on `/advanced/react` beside the predict hooks rather than the
+ * headline subpath: on its own the hash answers nothing a UI can act on.
+ *
+ * @example
+ * const before = useEcdsaInitCodeHash({ params, mode: "clone" });
+ *
+ * @alpha
+ */
+export declare function useEcdsaInitCodeHash(args: UseEcdsaInitCodeHashArgs): UseQueryResult<Hex, Error>;

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

@@ -0,0 +1,25 @@
+import { type UseQueryResult } from "@tanstack/react-query";
+import type { Address } from "viem";
+import { type AirdropHookOptions } from "../../react/_shared.js";
+/** @alpha */
+export type UseFactoryComplianceDelegateArgs = AirdropHookOptions<Address>;
+/**
+ * The platform-designated compliance delegate the FACTORY wires into every
+ * new compliance-manager clone.
+ *
+ * Deliberately unbundled: its being set is what gates
+ * {@link useSetDefaultDelegateToCompliance} with `on: true` (that write
+ * reverts `ZeroComplianceDelegate` against the zero address), so an admin
+ * panel reads it alone to decide whether to enable the toggle at all.
+ *
+ * **Not** `ComplianceManagerClient.complianceDelegate()`. That method has the
+ * same name on a different contract and returns the delegate one already-
+ * deployed manager clone actually uses; this is the factory-level value
+ * applied to future clones.
+ *
+ * @example
+ * const { data: delegate } = useFactoryComplianceDelegate();
+ *
+ * @alpha
+ */
+export declare function useFactoryComplianceDelegate(args?: UseFactoryComplianceDelegateArgs): UseQueryResult<Address, Error>;

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

@@ -0,0 +1,38 @@
+import { type UseQueryResult } from "@tanstack/react-query";
+import type { Address } from "viem";
+import { type AirdropHookOptions } from "../../react/_shared.js";
+/**
+ * One creator's delegate-to-compliance override plus what actually applies.
+ *
+ * @alpha
+ */
+export interface FactoryCompliancePolicy {
+    /** Whether this creator has an override at all. `false` means the factory default applies. */
+    overridden: boolean;
+    /** The override's value. Meaningless while `overridden` is `false`. */
+    delegateToCompliance: boolean;
+    /** What the factory actually resolves for this creator - the override if `overridden`, else the default. */
+    effective: boolean;
+}
+/** @alpha */
+export interface UseFactoryCompliancePolicyArgs extends AirdropHookOptions<FactoryCompliancePolicy> {
+    /** The creator whose policy to inspect. */
+    creator?: Address;
+}
+/**
+ * The admin's per-creator compliance view: the stored override AND the value
+ * the factory resolves for that creator. Bundled because only the pair
+ * answers "is this creator's setting doing anything?" - an `overridden: true`
+ * whose `delegateToCompliance` already matches the default is a no-op a panel
+ * should show as such.
+ *
+ * Overlaps the creator-facing `useEffectiveDelegateToCompliance` by its
+ * `effective` field. Intentional: different subpath, different audience, same
+ * split as `useEffectiveUpgradeable` vs {@link useFactoryUpgradeabilityPolicy}.
+ *
+ * @example
+ * const { data: policy } = useFactoryCompliancePolicy({ creator });
+ *
+ * @alpha
+ */
+export declare function useFactoryCompliancePolicy(args?: UseFactoryCompliancePolicyArgs): UseQueryResult<FactoryCompliancePolicy, Error>;

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

@@ -0,0 +1,24 @@
+import { type UseQueryResult } from "@tanstack/react-query";
+import type { Address } from "viem";
+import type { CustomFee } from "../../factory.js";
+import { type AirdropHookOptions } from "../../react/_shared.js";
+/** @alpha */
+export interface UseFactoryCustomFeeArgs extends AirdropHookOptions<CustomFee> {
+    /** The creator whose override to read. Disabled until set. */
+    creator?: Address;
+}
+/**
+ * Read one creator's per-claim fee override. `enabled: false` means the
+ * factory's `defaultGasFee` (see `useFactoryFees`) applies to them instead.
+ *
+ * Kept out of the `useFactoryFees` bundle on purpose: this read is
+ * per-creator, and folding it in would put a creator address into that
+ * chain-wide fee key and fragment the cache one slot per creator.
+ *
+ * @example
+ * const { data: custom } = useFactoryCustomFee({ creator });
+ * const fee = custom?.enabled ? custom.gasFee : fees?.defaultGasFee;
+ *
+ * @alpha
+ */
+export declare function useFactoryCustomFee(args?: UseFactoryCustomFeeArgs): UseQueryResult<CustomFee, Error>;

package/dist/fhe-airdrop/advanced/react/useFactoryGrantRole.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 AirdropClientOptions } from "../../react/_shared.js";
+/** @alpha */
+export interface FactoryGrantRoleArgs extends WriteAccountOverride {
+    /** A `bytes32` role identifier - from {@link useFactoryRoleConstants}, never hand-hashed. */
+    role: Hex;
+    /** The account receiving the role. Distinct from `account`, which is who sends the transaction. */
+    holder: Address;
+}
+/**
+ * Grant one factory role.
+ *
+ * Requires `DEFAULT_ADMIN_ROLE`: the factory administers all five of its roles
+ * through the root role and never calls `_setRoleAdmin`, so unlike an airdrop
+ * instance there is no self-administered role here - one admin key can grant
+ * every one of them.
+ *
+ * **Invalidates:** this factory's {@link useFactoryHasRole} entry for exactly
+ * `(role, holder)` and its {@link useFactoryRoleMembers} entry for `role` (the
+ * list and the count both move). Keyed off `variables.holder`, never the
+ * sending `account` - the submitter is an admin whose own membership does not
+ * change here.
+ *
+ * @example
+ * const grant = useFactoryGrantRole();
+ * await grant.mutateAsync({ role: roles.FEE_MANAGER_ROLE, holder: opsAddress });
+ *
+ * @alpha
+ */
+export declare function useFactoryGrantRole(options?: AirdropClientOptions): UseMutationResult<Hex, Error, FactoryGrantRoleArgs>;

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

@@ -0,0 +1,27 @@
+import { type UseQueryResult } from "@tanstack/react-query";
+import type { Address, Hex } from "viem";
+import { type AirdropHookOptions } from "../../react/_shared.js";
+/** @alpha */
+export interface UseFactoryHasRoleArgs extends AirdropHookOptions<boolean> {
+    /** A `bytes32` role identifier - from {@link useFactoryRoleConstants}, never hand-hashed. */
+    role?: Hex;
+    /** The account to check. */
+    holder?: Address;
+}
+/**
+ * Whether `holder` holds `role` on the factory.
+ *
+ * Stays disabled (no request fired) until both `role` and `holder` are defined,
+ * so a UI can call it unconditionally while a form is still being filled in.
+ *
+ * Named apart from the instance-level `useAirdropHasRole` and the clone-level
+ * `useComplianceHasRole` because these are three different contracts' role
+ * sets; the cache never confuses them either, since the key's address segment
+ * is the factory.
+ *
+ * @example
+ * const { data: isFeeManager } = useFactoryHasRole({ role: roles?.FEE_MANAGER_ROLE, holder });
+ *
+ * @alpha
+ */
+export declare function useFactoryHasRole(args?: UseFactoryHasRoleArgs): UseQueryResult<boolean, Error>;

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

@@ -0,0 +1,33 @@
+import { type UseQueryResult } from "@tanstack/react-query";
+import type { Address } from "viem";
+import { type AirdropHookOptions } from "../../react/_shared.js";
+/**
+ * The three implementation pointers future clones are cut from.
+ *
+ * @alpha
+ */
+export interface FactoryImplementations {
+    /** What `createEcdsaAirdrop*` currently clones. */
+    ecdsa: Address;
+    /** What `createMerkleAirdrop*` currently clones. */
+    merkle: Address;
+    /** What each new compliance-manager clone is cut from. */
+    complianceManager: Address;
+}
+/** @alpha */
+export type UseFactoryImplementationsArgs = AirdropHookOptions<FactoryImplementations>;
+/**
+ * Read all three of the factory's implementation pointers in one round trip -
+ * the row an admin panel shows together, so they are bundled rather than
+ * shipped as three one-line hooks over three parallel `eth_call`s.
+ *
+ * These describe FUTURE creates only. Already-deployed instances and
+ * compliance-manager clones stay pinned to whatever was live when they were
+ * created.
+ *
+ * @example
+ * const { data: impls } = useFactoryImplementations();
+ *
+ * @alpha
+ */
+export declare function useFactoryImplementations(args?: UseFactoryImplementationsArgs): UseQueryResult<FactoryImplementations, Error>;

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

@@ -0,0 +1,36 @@
+import { type UseMutationResult } from "@tanstack/react-query";
+import type { Hex } from "viem";
+import type { WriteAccountOverride } from "../../airdrop-base.js";
+import { type AirdropClientOptions } from "../../react/_shared.js";
+/** @alpha */
+export interface FactoryRenounceRoleArgs extends WriteAccountOverride {
+    /** A `bytes32` role identifier - from {@link useFactoryRoleConstants}, never hand-hashed. */
+    role: Hex;
+}
+/**
+ * Give up a factory role yourself.
+ *
+ * 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 a role from somebody else use
+ * {@link useFactoryRevokeRole}.
+ *
+ * **No floor stops a sole admin renouncing here**, unlike an airdrop instance's
+ * `LastAdmin` guard. A sole `DEFAULT_ADMIN_ROLE` holder renouncing freezes role
+ * administration permanently; grant a successor first.
+ *
+ * **Invalidates:** every {@link useFactoryHasRole} entry for this factory
+ * (prefix, all role/holder pairs), plus its {@link useFactoryRoleMembers} 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.
+ *
+ * @example
+ * const renounce = useFactoryRenounceRole();
+ * await renounce.mutateAsync({ role: roles.UPGRADE_MANAGER_ROLE });
+ *
+ * @alpha
+ */
+export declare function useFactoryRenounceRole(options?: AirdropClientOptions): UseMutationResult<Hex, Error, FactoryRenounceRoleArgs>;

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

@@ -0,0 +1,35 @@
+import { type UseMutationResult } from "@tanstack/react-query";
+import type { Address, Hex } from "viem";
+import type { WriteAccountOverride } from "../../airdrop-base.js";
+import { type AirdropClientOptions } from "../../react/_shared.js";
+/** @alpha */
+export interface FactoryRevokeRoleArgs extends WriteAccountOverride {
+    /** A `bytes32` role identifier - from {@link useFactoryRoleConstants}, never hand-hashed. */
+    role: Hex;
+    /** The account losing the role. Distinct from `account`, which is who sends the transaction. */
+    holder: Address;
+}
+/**
+ * Revoke one factory role from one holder.
+ *
+ * Requires `DEFAULT_ADMIN_ROLE`, which administers all five factory roles.
+ *
+ * **The factory declares no "never empty" floor.** Revoking the last
+ * `DEFAULT_ADMIN_ROLE` holder succeeds and permanently freezes role
+ * administration - no role can ever be granted or revoked again, including
+ * putting an admin back. The four operational roles keep working for whoever
+ * already holds them, with no way to rotate them. On the live deployment all
+ * five roles sit on one key, so show {@link useFactoryRoleMembers}'s `count`
+ * next to the button and grant the successor first.
+ *
+ * **Invalidates:** this factory's {@link useFactoryHasRole} entry for exactly
+ * `(role, holder)` and its {@link useFactoryRoleMembers} entry for `role`.
+ * Keyed off `variables.holder`, never the sending `account`.
+ *
+ * @example
+ * const revoke = useFactoryRevokeRole();
+ * await revoke.mutateAsync({ role: roles.IMPL_MANAGER_ROLE, holder: formerOpsAddress });
+ *
+ * @alpha
+ */
+export declare function useFactoryRevokeRole(options?: AirdropClientOptions): UseMutationResult<Hex, Error, FactoryRevokeRoleArgs>;

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

@@ -0,0 +1,46 @@
+import { type UseQueryResult } from "@tanstack/react-query";
+import type { Hex } from "viem";
+import { type AirdropHookOptions } from "../../react/_shared.js";
+/**
+ * The five `bytes32` role identifiers the factory's admin surface is gated on.
+ *
+ * @alpha
+ */
+export interface FactoryRoleConstants {
+    /** Gates `useSetFeeCollector`, `useSetDefaultGasFee`, `useSetCustomFee`, `useDisableCustomFee`. */
+    FEE_MANAGER_ROLE: Hex;
+    /** Gates `useSetEcdsaImplementation` and `useSetMerkleImplementation`. */
+    IMPL_MANAGER_ROLE: Hex;
+    /** Gates the compliance-wiring setters. */
+    COMPLIANCE_WIRING_ROLE: Hex;
+    /** Gates the upgradeability-policy setters. */
+    UPGRADE_MANAGER_ROLE: Hex;
+    /** OpenZeppelin's root role, read off the factory rather than assumed to be `bytes32(0)`. It administers the other four and itself. */
+    DEFAULT_ADMIN_ROLE: Hex;
+}
+/** @alpha */
+export type UseFactoryRoleConstantsArgs = AirdropHookOptions<FactoryRoleConstants>;
+/**
+ * Read the factory's role identifiers in one fan-out.
+ *
+ * Every value is a bytecode constant, so this defaults to `staleTime: Infinity`
+ * (overridable through `query`). Feed the results into
+ * {@link useFactoryHasRole}, {@link useFactoryRoleMembers} and the three
+ * factory role mutations - hand-hashing `keccak256("FEE_MANAGER_ROLE")`
+ * client-side would turn a constant renamed in a future factory version into a
+ * `grantRole` that silently grants a role nothing checks.
+ *
+ * Bundled rather than shipped as five one-liners: a role panel needs the whole
+ * palette to render at all. Paired with {@link useFactoryRoleMembers} it is
+ * also the live check `FACTORY_ROLE_CONCENTRATION_NOTE` asks for - read the
+ * five roles, list each one's holders, and see for yourself whether they sit on
+ * one key on the chain you are actually connected to, rather than trusting a
+ * fixed string about one deployment at one point in time.
+ *
+ * @example
+ * const { data: roles } = useFactoryRoleConstants();
+ * const { data: feeManagers } = useFactoryRoleMembers({ role: roles?.FEE_MANAGER_ROLE });
+ *
+ * @alpha
+ */
+export declare function useFactoryRoleConstants(args?: UseFactoryRoleConstantsArgs): UseQueryResult<FactoryRoleConstants, Error>;

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

@@ -0,0 +1,47 @@
+import { type UseQueryResult } from "@tanstack/react-query";
+import type { Address, Hex } from "viem";
+import { type AirdropHookOptions } from "../../react/_shared.js";
+/**
+ * One factory role's membership - the set and its size, read together.
+ *
+ * @alpha
+ */
+export interface FactoryRoleMembership {
+    /** Every account currently holding the role, in the contract's `EnumerableSet` order. */
+    members: readonly Address[];
+    /** How many accounts hold it. */
+    count: bigint;
+}
+/** @alpha */
+export interface UseFactoryRoleMembersArgs extends AirdropHookOptions<FactoryRoleMembership> {
+    /** The role whose members to list - from {@link useFactoryRoleConstants}, never hand-hashed. */
+    role?: Hex;
+}
+/**
+ * List who holds `role` on the factory, with the member count.
+ *
+ * This is the live half of the role-concentration check
+ * `FACTORY_ROLE_CONCENTRATION_NOTE` prescribes: run it over the five roles from
+ * {@link useFactoryRoleConstants} and compare the holder sets, instead of
+ * trusting a fixed string that describes one deployment at one moment.
+ *
+ * `count` is bundled with the list rather than split into its own hook because
+ * it is what a UI needs in the same render to decide whether a revoke is safe -
+ * the factory declares no "never empty" floor, so revoking the last
+ * `DEFAULT_ADMIN_ROLE` holder succeeds and permanently freezes all role
+ * administration.
+ *
+ * Unpaginated: factory role sets are operator-sized, not user-sized.
+ *
+ * @remarks
+ * Invalidated by {@link useFactoryGrantRole}, {@link useFactoryRevokeRole} and
+ * {@link useFactoryRenounceRole}. Member order is `EnumerableSet`'s and is not
+ * stable across grants and revokes - treat it as a set, not a list.
+ *
+ * @example
+ * const { data } = useFactoryRoleMembers({ role: roles?.DEFAULT_ADMIN_ROLE });
+ * const lastAdmin = data?.count === 1n;
+ *
+ * @alpha
+ */
+export declare function useFactoryRoleMembers(args?: UseFactoryRoleMembersArgs): UseQueryResult<FactoryRoleMembership, Error>;

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

@@ -0,0 +1,39 @@
+import { type UseQueryResult } from "@tanstack/react-query";
+import type { Address } from "viem";
+import { type AirdropHookOptions } from "../../react/_shared.js";
+/**
+ * The factory default, one creator's override, and the resolved value.
+ *
+ * @alpha
+ */
+export interface FactoryUpgradeabilityPolicy {
+    /** What applies to creators with no override. */
+    defaultUpgradeable: boolean;
+    /** Whether this creator has an override at all. */
+    overridden: boolean;
+    /** The override's value. Meaningless while `overridden` is `false`. */
+    allowed: boolean;
+    /** What the factory actually resolves for this creator, and what a `mode: "uups"` create is checked against. */
+    effective: boolean;
+}
+/** @alpha */
+export interface UseFactoryUpgradeabilityPolicyArgs extends AirdropHookOptions<FactoryUpgradeabilityPolicy> {
+    /** The creator whose policy to inspect. */
+    creator?: Address;
+}
+/**
+ * The admin panel's full upgradeability answer for one creator, in one round
+ * trip: the factory default, the per-creator override, and the resolved
+ * value. Absorbing `defaultUpgradeable()` here is why it needs no hook of its
+ * own.
+ *
+ * Duplicates the creator-facing `useEffectiveUpgradeable`'s single field
+ * rather than replacing it - that hook stays the cheap read a create form
+ * uses to decide whether to offer UUPS.
+ *
+ * @example
+ * const { data: policy } = useFactoryUpgradeabilityPolicy({ creator });
+ *
+ * @alpha
+ */
+export declare function useFactoryUpgradeabilityPolicy(args?: UseFactoryUpgradeabilityPolicyArgs): UseQueryResult<FactoryUpgradeabilityPolicy, Error>;

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

@@ -0,0 +1,24 @@
+import { type UseQueryResult } from "@tanstack/react-query";
+import type { Hex } from "viem";
+import type { DeploymentMode } from "../../constants.js";
+import { type AirdropHookOptions } from "../../react/_shared.js";
+import type { MerkleAirdropParams } from "../../types.js";
+/** @alpha */
+export interface UseMerkleInitCodeHashArgs extends AirdropHookOptions<Hex> {
+    params: MerkleAirdropParams;
+    mode: DeploymentMode;
+}
+/**
+ * Init-code hash of the Merkle proxy the factory would deploy for `mode` -
+ * the Merkle counterpart of {@link useEcdsaInitCodeHash}, with the same
+ * before/after bracketing job and the same `/advanced/react` home.
+ *
+ * `usePlanMerkleCampaign` already brackets its own build with this read, so
+ * reach for the hook only when driving prediction by hand.
+ *
+ * @example
+ * const before = useMerkleInitCodeHash({ params, mode: "clone" });
+ *
+ * @alpha
+ */
+export declare function useMerkleInitCodeHash(args: UseMerkleInitCodeHashArgs): UseQueryResult<Hex, Error>;

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

@@ -0,0 +1,33 @@
+import { type UseQueryResult } from "@tanstack/react-query";
+import type { Address, Hex } from "viem";
+import type { DeploymentMode } from "../../constants.js";
+import type { EcdsaAirdropParams } from "../../types.js";
+import { type AirdropHookOptions } from "../../react/_shared.js";
+/** @alpha */
+export interface UsePredictEcdsaAirdropAddressArgs extends AirdropHookOptions<Address> {
+    params: EcdsaAirdropParams;
+    mode: DeploymentMode;
+    deployer: Address;
+    userSalt: Hex;
+}
+/**
+ * Where an ECDSA `create*` from `deployer` with this `(mode, userSalt)` pair
+ * would land.
+ *
+ * **What a prediction commits to.** Only `(implementation, mode, deployer,
+ * userSalt)` — `params` is required because the ABI declares it, but the
+ * factory ignores it for this variant's oracle. Changing the token, window
+ * or signer does NOT move the predicted address.
+ *
+ * A returned address is not evidence the create will succeed — prediction is
+ * a pure oracle that answers even for a deployer not currently allowed to
+ * deploy the requested `mode`.
+ *
+ * @example
+ * const { data: predicted } = usePredictEcdsaAirdropAddress({
+ *   params, mode: "clone", deployer, userSalt,
+ * });
+ *
+ * @alpha
+ */
+export declare function usePredictEcdsaAirdropAddress(args: UsePredictEcdsaAirdropAddressArgs): UseQueryResult<Address, Error>;

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

@@ -0,0 +1,27 @@
+import { type UseQueryResult } from "@tanstack/react-query";
+import type { Address, Hex } from "viem";
+import type { DeploymentMode } from "../../constants.js";
+import type { MerkleAirdropParams } from "../../types.js";
+import { type AirdropHookOptions } from "../../react/_shared.js";
+/** @alpha */
+export interface UsePredictMerkleAirdropAddressArgs extends AirdropHookOptions<Address> {
+    params: MerkleAirdropParams;
+    mode: DeploymentMode;
+    deployer: Address;
+    userSalt: Hex;
+}
+/**
+ * Where a Merkle `create*` from `deployer` with this `(mode, userSalt)` pair
+ * would land.
+ *
+ * Same "only `(implementation, mode, deployer, userSalt)` matters" contract
+ * as {@link usePredictEcdsaAirdropAddress} — see its TSDoc.
+ *
+ * @example
+ * const { data: predicted } = usePredictMerkleAirdropAddress({
+ *   params, mode: "clone", deployer, userSalt,
+ * });
+ *
+ * @alpha
+ */
+export declare function usePredictMerkleAirdropAddress(args: UsePredictMerkleAirdropAddressArgs): UseQueryResult<Address, Error>;

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

@@ -0,0 +1,33 @@
+import { type UseMutationResult } from "@tanstack/react-query";
+import type { Address, Hex } from "viem";
+import type { WriteAccountOverride } from "../../airdrop-base.js";
+import { type AirdropClientOptions } from "../../react/_shared.js";
+/** @alpha */
+export interface SetComplianceDelegateArgs extends WriteAccountOverride {
+    /** Platform delegate wired into future compliance-manager clones. The zero address reverts `ZeroComplianceDelegate`. */
+    delegate: Address;
+}
+/**
+ * Set the platform-designated compliance delegate that every new
+ * compliance-manager clone wires in. Requires `COMPLIANCE_WIRING_ROLE`.
+ *
+ * **Ordering is load-bearing.** Call this before
+ * {@link useSetDefaultDelegateToCompliance} with `on: true` - turning
+ * delegation on while no delegate is set reverts `ZeroComplianceDelegate`. An
+ * admin panel must sequence the two writes, and read
+ * {@link useFactoryComplianceDelegate} to decide whether the toggle is even
+ * offerable.
+ *
+ * Applies to FUTURE clones only; it cannot retro-wire managers that already
+ * exist.
+ *
+ * **Invalidates:** the factory's `fn "complianceDelegate"` entry
+ * ({@link useFactoryComplianceDelegate}).
+ *
+ * @example
+ * const setDelegate = useSetComplianceDelegate();
+ * await setDelegate.mutateAsync({ delegate: platformDelegate });
+ *
+ * @alpha
+ */
+export declare function useSetComplianceDelegate(options?: AirdropClientOptions): UseMutationResult<Hex, Error, SetComplianceDelegateArgs>;

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

@@ -0,0 +1,27 @@
+import { type UseMutationResult } from "@tanstack/react-query";
+import type { Address, Hex } from "viem";
+import type { WriteAccountOverride } from "../../airdrop-base.js";
+import { type AirdropClientOptions } from "../../react/_shared.js";
+/** @alpha */
+export interface SetComplianceManagerImplArgs extends WriteAccountOverride {
+    /** New compliance-manager implementation. The zero address reverts `ZeroComplianceManagerImpl`. */
+    implementation: Address;
+}
+/**
+ * Point future compliance-manager clones at a new implementation. Requires
+ * `COMPLIANCE_WIRING_ROLE`.
+ *
+ * Only clones created after this lands use the new code — already-deployed
+ * managers keep the implementation they were cloned from, so this is not a
+ * fleet-wide upgrade.
+ *
+ * **Invalidates:** the factory's `fn "implementations"` entry, which carries
+ * `complianceManagerImpl` alongside the ECDSA/Merkle pointers.
+ *
+ * @example
+ * const setImpl = useSetComplianceManagerImpl();
+ * await setImpl.mutateAsync({ implementation: newManagerImpl });
+ *
+ * @alpha
+ */
+export declare function useSetComplianceManagerImpl(options?: AirdropClientOptions): UseMutationResult<Hex, Error, SetComplianceManagerImplArgs>;

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

@@ -0,0 +1,28 @@
+import { type UseMutationResult } from "@tanstack/react-query";
+import type { Address, Hex } from "viem";
+import type { WriteAccountOverride } from "../../airdrop-base.js";
+import { type AirdropClientOptions } from "../../react/_shared.js";
+/** @alpha */
+export interface SetCompliancePolicyArgs extends WriteAccountOverride {
+    /** The creator the override applies to - not the admin sending the transaction. */
+    creator: Address;
+    /** Whether that creator's new instances delegate compliance disclosure to the platform delegate. */
+    delegateToCompliance: boolean;
+}
+/**
+ * Override the factory's default delegate-to-compliance policy for one
+ * creator. Requires `COMPLIANCE_WIRING_ROLE`.
+ *
+ * **Invalidates:** `fn "compliancePolicy"` and
+ * `fn "effectiveDelegateToCompliance"`, both keyed on `args.creator` - the
+ * TARGET creator, never the sending admin. Keying on the sender would leave
+ * the panel's view of the creator it just edited stale while invalidating an
+ * entry nobody rendered.
+ *
+ * @example
+ * const setPolicy = useSetCompliancePolicy();
+ * await setPolicy.mutateAsync({ creator, delegateToCompliance: true });
+ *
+ * @alpha
+ */
+export declare function useSetCompliancePolicy(options?: AirdropClientOptions): UseMutationResult<Hex, Error, SetCompliancePolicyArgs>;