@tokenops/sdk 2.0.0-alpha.2 → 2.0.0-alpha.4

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

@@ -49,17 +49,15 @@ export interface ExtractGrantedHandleArgs {
  * `Allowed` event survives the `account` filter, so the choice between first
  * and last is moot today:
  *
- * - `adminGetCurrentBalance` — a single `FHE.allow(balance, msg.sender)`
- *   (`ConfidentialAirdropBase.sol:358`).
- * - `adminDiscloseBalanceToParty` — a single `FHE.allow(balance, party)` (`:367`).
+ * - `adminGetCurrentBalance` - a single `FHE.allow(balance, msg.sender)`.
+ * - `adminDiscloseBalanceToParty` - a single `FHE.allow(balance, party)`.
  * - `adminBatchDiscloseBalanceToParties` — N grants, but the balance is read
- *   once (`:377`) and the *same* handle is fanned out (`:379`), so every
- *   candidate carries an identical value and ordering cannot matter.
+ *   once and the *same* handle is fanned out, so every candidate carries an
+ *   identical value and ordering cannot matter.
  * - `getClaimAmount` on both variants — the sibling grants target other
  *   addresses: `FHE.allowThis` grants `address(this)` and `_grantCompliance`
- *   grants the manager clone (`ConfidentialAirdropBase.sol:431`), leaving one
- *   grant to the caller (`ECDSAConfidentialAirdrop.sol:166-167`,
- *   `MerkleConfidentialAirdrop.sol:264-266`).
+ *   grants the manager clone, leaving one grant to the preview's grantee: the
+ *   caller on ECDSA (`getClaimAmount`), `account` on Merkle (`_outstandingOf`).
  *
  * Last-wins is therefore chosen for entrypoints that do not exist yet, over
  * `fhe-vesting`'s throw-on-ambiguous: a future compound view that grants twice
@@ -68,12 +66,50 @@ export interface ExtractGrantedHandleArgs {
  *
  * Note what is NOT a motivating case: the Merkle `claim` path does grant an
  * intermediate handle before the outstanding one, but `claim` /
- * `claimAndUnwrap` return void (`IMerkleConfidentialAirdrop.sol:51-70`), so
+ * `claimAndUnwrap` return void (`IMerkleConfidentialAirdrop`), so
  * they run as plain writes and their receipts never reach this function.
  *
  * @throws {@link ReceiptEventNotFoundError} when no `Allowed` event names `account`.
  */
 export declare function extractGrantedHandle(args: ExtractGrantedHandleArgs): Hex;
+/**
+ * The unwrap a `claimAndUnwrap` started, decoded from the instance's
+ * `ClaimedAndUnwrapInitiated` event.
+ *
+ * @alpha
+ */
+export interface UnwrapRequest {
+    /** The claim identity, which is always the claim transaction's sender. */
+    claimant: Address;
+    /** The underlying ERC-20 recipient that `finalizeUnwrap` pays. */
+    beneficiary: Address;
+    /** The ECDSA dedup key (claimant address or `dedupId`) or the Merkle leaf. */
+    claimKey: Hex;
+    /**
+     * The wrapper's unwrap request id, the input to its `finalizeUnwrap`. With the stock
+     * `ERC7984ERC20Wrapper` it is also the burned amount's handle, which the wrapper makes
+     * publicly decryptable in the claim transaction.
+     */
+    unwrapRequestId: Hex;
+}
+/**
+ * What {@link AirdropBaseClient.parseUnwrapRequest} reads: a viem receipt, or its logs.
+ *
+ * @alpha
+ */
+export type UnwrapRequestSource = readonly {
+    address: Address;
+    topics: readonly Hex[];
+    data: Hex;
+}[] | {
+    logs: readonly {
+        address: Address;
+        topics: readonly Hex[];
+        data: Hex;
+    }[];
+    transactionHash?: Hex | undefined;
+    status?: "success" | "reverted" | undefined;
+};
 /** @alpha */
 export interface AirdropBaseClientConfig {
     publicClient: PublicClient;
@@ -137,11 +173,16 @@ export interface WriteAccountOverride {
  * do not care about (an admin panel listing campaigns, say). The ECDSA and
  * Merkle clients extend it and add their own claim path.
  *
- * What it encapsulates beyond the raw ABI is the encrypted-view protocol: five
+ * What it encapsulates beyond the raw ABI is the encrypted-view protocol: six
  * of the contract's disclosure entrypoints look like getters and are not —
  * they mutate ACL state, so they are transactions, and their result must be
  * recovered from the receipt. See {@link extractGrantedHandle}.
  *
+ * Those encrypted views and disclosures have no `waitForReceipt: false` option
+ * for Safe / multisig signers: the handle is only useful to an account that
+ * can user-decrypt in-session, so run them from an EOA or a delegate. The other
+ * writes here return a bare hash and never wait on a receipt.
+ *
  * @example
  * const airdrop = new AirdropBaseClient({ publicClient, walletClient, address });
  * const { handle } = await airdrop.adminGetCurrentBalance();
@@ -197,6 +238,10 @@ export declare class AirdropBaseClient {
      * The amount is not a parameter and never appears in plaintext anywhere:
      * the contract reads its own encrypted balance and moves all of it.
      *
+     * Refused while the campaign is unpaused inside its claim window (`ClawbackRequiresPause`,
+     * surfaced as {@link ClawbackRequiresPauseError}): pause first, or run it outside the window
+     * (before `startTime` or after `endTime`).
+     *
      * @returns The transaction hash.
      */
     withdrawConfidential(args: {
@@ -213,12 +258,29 @@ export declare class AirdropBaseClient {
         recipient: Address;
         amount: bigint;
     } & WriteAccountOverride): Promise<Hex>;
+    /**
+     * Sweep ETH that landed on a ZERO-FEE instance without running its code (a forced send,
+     * a transfer to the predicted address before deploy). Requires `RESCUER_ROLE`.
+     *
+     * Refused while `gasFee() > 0` (`NativeRescueRequiresZeroFee`, surfaced as
+     * {@link NativeRescueRequiresZeroFeeError}): on a fee-charging campaign the ETH is fee
+     * revenue and belongs to `withdrawGasFee`. Reverts `ZeroBalance` with nothing to sweep.
+     *
+     * @returns The transaction hash.
+     */
+    rescueNativeToken(args: {
+        recipient: Address;
+    } & WriteAccountOverride): Promise<Hex>;
     /**
      * Sweep a plain ERC-20 that was sent to the instance by mistake. Requires
      * `RESCUER_ROLE`.
      *
-     * The campaign's own token is ERC-7984, not ERC-20, so it cannot be reached
-     * through this path — use {@link withdrawConfidential} for the pool.
+     * Passing the campaign's own token reverts `CannotRescueAirdropToken`
+     * (audit-05), matching {@link rescueOtherConfidentialToken}. ERC-7984 and
+     * ERC-20 are not disjoint in practice - a wrapper token answers both
+     * interfaces - so "the pool token is confidential, therefore out of reach
+     * here" was never a guarantee, only an assumption. Use
+     * {@link withdrawConfidential} for the pool.
      *
      * @returns The transaction hash.
      */
@@ -253,6 +315,10 @@ export declare class AirdropBaseClient {
     endTime(): Promise<number>;
     /** Whether claimants may unwrap to the underlying ERC-20 as part of a claim. */
     unwrappable(): Promise<boolean>;
+    /** Whether `extendClaimWindow` is permitted on this instance; frozen at create. */
+    canExtendClaimWindow(): Promise<boolean>;
+    /** The block this instance was initialized in (L2 block on Arbitrum). */
+    deploymentBlockNumber(): Promise<bigint>;
     /** The instance's own compliance-manager clone — the only contract granted ACL on campaign handles. */
     complianceManager(): Promise<Address>;
     /** Per-claim ETH fee in wei; `0` on a fee-free campaign. */
@@ -279,7 +345,7 @@ export declare class AirdropBaseClient {
     WINDOW_ADMIN_ROLE(): Promise<Hex>;
     /** Gates {@link withdrawConfidential}. */
     TREASURY_ROLE(): Promise<Hex>;
-    /** Gates {@link rescueERC20} / {@link rescueOtherConfidentialToken}. */
+    /** Gates {@link rescueERC20} / {@link rescueOtherConfidentialToken} / {@link rescueNativeToken}. */
     RESCUER_ROLE(): Promise<Hex>;
     /** Gates {@link withdrawGasFee}. The contract refuses to leave it empty on a fee-charging campaign. */
     FEE_COLLECTOR_ROLE(): Promise<Hex>;
@@ -469,10 +535,38 @@ export declare class AirdropBaseClient {
      * @alpha
      */
     deploymentMode(): Promise<DeploymentMode>;
+    /**
+     * Re-grant the compliance-manager clone on the instance's current pool
+     * balance, and return the handle it was granted on.
+     *
+     * **Permissionless, and deliberately so** (audit-04). The token rotates the
+     * instance's balance handle on every incoming transfer, including one no
+     * airdrop code observes - a third party transferring in directly - and
+     * grants the fresh handle to the token and the holder only. Without this the
+     * compliance clone's grant can be stranded on a handle the token has already
+     * replaced, with no admin necessarily around to restore it. There is no
+     * argument to abuse: the only handle read is `address(this)`'s own balance,
+     * and the only grantee is the clone wired at initialization.
+     *
+     * This is therefore the normative way to obtain a readable live-balance
+     * handle - and it is a **snapshot, not a subscription**. Grants are
+     * append-only, so the handle this returns stays readable forever; but the
+     * next incoming transfer rotates the instance to a NEW handle the clone was
+     * never granted on. A compliance reader that refreshes once and stops is
+     * reading a stale balance, not a live one. Call it again after any transfer
+     * in, or before each read.
+     *
+     * @returns `{ handle, hash }` - the handle the compliance clone may now decrypt.
+     * @throws {@link ReceiptEventNotFoundError} when the transaction granted no ACL to the clone.
+     */
+    refreshComplianceBalance(args?: WriteAccountOverride): Promise<EncryptedViewResult>;
     /**
      * Read the instance's own remaining pool balance as a handle the **caller**
      * can decrypt. Requires `DISCLOSURE_ADMIN_ROLE`.
      *
+     * Also re-grants the compliance-manager clone on the same handle (audit-04),
+     * so an admin read doubles as a {@link refreshComplianceBalance}.
+     *
      * @returns `{ handle, hash }` — pass `handle` to the Zama relayer's `userDecrypt`.
      * @throws {@link ReceiptEventNotFoundError} when the transaction granted no ACL to the caller.
      */
@@ -515,11 +609,18 @@ export declare class AirdropBaseClient {
     /**
      * Grant `party` decrypt access to a handle you already hold.
      *
-     * Two gates apply on-chain: the caller must itself be allowed on the handle
-     * (bypassed by `DISCLOSURE_ADMIN_ROLE`), and the *instance* must be allowed
-     * on it — so an arbitrary handle from another contract cannot be laundered
-     * through this campaign. A failure of the first surfaces as
-     * `FheHandleNotAllowedError`.
+     * Two gates apply on-chain. Gate #1: the handle must be **persistently**
+     * user-decryptable in the `(caller, instance)` context - BOTH legs, and a
+     * transient allowance does not satisfy either (audit-06). `DISCLOSURE_ADMIN_ROLE`
+     * bypasses gate #1 only. Gate #2: the instance must be allowed on the handle,
+     * so an arbitrary handle from another contract cannot be laundered through
+     * this campaign.
+     *
+     * **The transient case is the trap.** An `euint64` that just came back from
+     * an FHE op carries a transient allowance, which used to be enough here and
+     * no longer is. Handles worth disclosing come from the encrypted views on
+     * this client, whose grants are persistent. A gate #1 failure surfaces as
+     * `FheHandleNotAllowedError` carrying the offending handle.
      *
      * @param args.handle An existing `euint64` handle — a public pointer, not a value.
      * @returns The transaction hash. No new handle is produced.
@@ -539,6 +640,29 @@ export declare class AirdropBaseClient {
         handles: readonly Hex[];
         party: Address;
     } & WriteAccountOverride): Promise<Hex>;
+    /**
+     * Decode the unwrap request a `claimAndUnwrap` started, from its receipt or logs.
+     *
+     * Pure: no RPC. Only this instance's `ClaimedAndUnwrapInitiated` counts, so a
+     * receipt that also carries another instance's event (a batched transaction) still
+     * resolves to this one. Pass the result's `unwrapRequestId` to the wrapper's
+     * `finalizeUnwrap`; with Zama's SDK that is
+     * `sdk.createToken(wrapper).finalizeUnwrap(unwrapRequestId)`, which fetches the
+     * public-decryption proof itself.
+     *
+     * @throws {@link ReceiptEventNotFoundError} when no such event from this instance is present.
+     * @throws {@link ReceiptEventAmbiguousError} when the transaction started more than one.
+     */
+    parseUnwrapRequest(source: UnwrapRequestSource): UnwrapRequest;
+    /**
+     * Wait for the `claimAndUnwrap` transaction `hash` to be mined and decode the unwrap
+     * request it started; see {@link parseUnwrapRequest}.
+     *
+     * `hash` must be the on-chain transaction hash. A Safe returns a `safeTxHash`, which
+     * no node can wait on: resolve the executed transaction first, or pass its receipt to
+     * {@link parseUnwrapRequest}.
+     */
+    readUnwrapRequest(hash: Hex): Promise<UnwrapRequest>;
     /**
      * Submit a transaction for a function that returns an encrypted handle via
      * `FHE.allow`, and recover that handle from the receipt.

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

@@ -5,8 +5,19 @@ import type { ConfidentialAirdropFactoryClient } from "./factory.js";
 import type { MerkleAirdropClient } from "./merkle.js";
 import { type MerkleLeafInput } from "./merkle-tree.js";
 import type { DeploymentMode } from "./constants.js";
-import type { BuiltCampaign, CampaignRecipient, MerkleAirdropParams } from "./types.js";
-export type { BuiltCampaign, CampaignEntry, CampaignRecipient } from "./types.js";
+import type { BuiltCampaign, CampaignRecipient, MerkleAirdropParams, PlannedCampaign } from "./types.js";
+export type { BuiltCampaign, CampaignEntry, CampaignRecipient, PlannedCampaign } from "./types.js";
+/**
+ * Recipients per relayer request: an input ciphertext packs at most 2048 bits, so 2048 / 64
+ * euint64 values share one proof.
+ *
+ * `@zama-fhe/sdk` does not check this client-side, so the campaign builders chunk every
+ * roster to this size. Each entry carries its own chunk's proof, so a claim is identical
+ * whichever chunk its leaf came from.
+ *
+ * @alpha
+ */
+export declare const MERKLE_BATCH_LIMIT: number;
 /**
  * Reject the campaign shapes that produce an unusable or misleading tree,
  * before any encryption work is done.
@@ -46,45 +57,12 @@ export declare function validateCampaignRecipients(recipients: readonly Campaign
  * pattern as `buildMerkleTreeInternal` in `./merkle-tree.js`.
  */
 export declare function validateCampaignRecipientsInternal(recipients: readonly CampaignRecipient[], method: string): void;
-/**
- * Who will submit the claims, for every builder that encrypts a roster.
- *
- * Follows the same shared-option pattern as `WriteAccountOverride`, because the choice
- * applies identically to all four builders and is frozen once the root is published.
- *
- * @alpha
- */
-export interface CampaignSubmitterOption {
-    /**
-     * The single address that will send every `claim` in this campaign.
-     *
-     * Omit for a **self-claim** campaign: each recipient's input is bound to that
-     * recipient, one relayer request each, and only they can claim.
-     *
-     * Set it for a **relayed** campaign: the whole roster is bound to this one address and
-     * batched, so a single `inputProof` covers up to 32 recipients and only this address
-     * can submit. That batching is the point — one proof cannot be bound to many
-     * addresses, so per-recipient binding and batching are mutually exclusive.
-     *
-     * An input ciphertext packs at most 2048 bits, so a `euint64` roster is chunked at 32
-     * recipients per request; a longer roster simply issues more requests. Nothing about a
-     * claim changes, since every chunk's proof is bound to the same submitter.
-     *
-     * Either way the leaf still commits each recipient's own `account`, so payout and
-     * accounting are unaffected by who submits.
-     *
-     * **Frozen at publication.** An FHEVM handle encodes its `(instance, userAddress)`
-     * binding, so re-pointing a leaf at a different submitter means re-encrypting, which
-     * changes the handle and therefore the root. Choose before publishing, not after.
-     */
-    submitter?: Address;
-}
 /**
  * Inputs for {@link buildMerkleCampaign}.
  *
  * @alpha
  */
-export interface BuildMerkleCampaignArgs extends CampaignSubmitterOption {
+export interface BuildMerkleCampaignArgs {
     /** The LIVE `MerkleConfidentialAirdrop` instance every input is bound to. Not the factory, not the implementation. */
     instance: Address;
     recipients: readonly CampaignRecipient[];
@@ -96,9 +74,7 @@ export interface BuildMerkleCampaignArgs extends CampaignSubmitterOption {
  * @alpha
  */
 export interface EncryptedCampaignLeaf extends MerkleLeafInput {
-    /** The only address that can submit this leaf — what `handle`/`inputProof` are bound to. */
-    boundTo: Address;
-    /** The KMS input proof binding `handle` to `(instance, boundTo)`. Required at claim time, unused by the tree. */
+    /** The KMS input proof binding `handle` to `(instance, instance)`. Required at claim time, unused by the tree. */
     inputProof: Hex;
 }
 /**
@@ -106,7 +82,7 @@ export interface EncryptedCampaignLeaf extends MerkleLeafInput {
  *
  * @alpha
  */
-export interface EncryptCampaignAmountsArgs extends CampaignSubmitterOption {
+export interface EncryptCampaignAmountsArgs {
     /** The LIVE `MerkleConfidentialAirdrop` instance every input is bound to. Not the factory, not the implementation. */
     instance: Address;
     recipients: readonly CampaignRecipient[];
@@ -119,17 +95,15 @@ export interface EncryptCampaignAmountsArgs extends CampaignSubmitterOption {
  * publishing a root, or to hand them to something else that builds the tree.
  * If you just want a campaign, {@link buildMerkleCampaign} does both.
  *
- * **Request count follows `submitter`.** Omitted: one relayer request per recipient,
- * issued concurrently, each bound to that recipient. Set: one batched request per 32
- * recipients (the 2048-bit input-ciphertext limit), every leaf claimable only by that
- * submitter.
+ * One relayer request per 32 recipients, issued concurrently; every leaf is submittable
+ * by any address.
  *
  * **The output is not reproducible.** Encryption is randomised, so calling this
  * twice with the same roster yields different handles and therefore a different
  * root. Persist what you get back; you cannot regenerate it.
  *
  * @param args The live instance, the roster, and an eager or lazy encryptor.
- * @returns One `{ account, boundTo, handle, inputProof }` per roster entry, in roster order.
+ * @returns One `{ account, handle, inputProof }` per roster entry, in roster order.
  * @throws {@link InvalidArgumentError} on any roster problem {@link validateCampaignRecipients} rejects, or a zero `instance`.
  * @throws {@link MissingEncryptorError} when `encryptor` resolves to `undefined`.
  *
@@ -142,8 +116,7 @@ export interface EncryptCampaignAmountsArgs extends CampaignSubmitterOption {
 export declare function encryptCampaignAmounts(args: EncryptCampaignAmountsArgs): Promise<readonly EncryptedCampaignLeaf[]>;
 /**
  * Encrypt every recipient's cumulative total, then build the tree those ciphertexts
- * belong to. Binding follows `submitter`: omitted, each input is bound to its own
- * recipient; set, the whole roster is bound to that one submitter.
+ * belong to. Every input is bound to `(instance, instance)`.
  *
  * Use this on the **mutable-root** path: the instance already exists, so its
  * address is known and encryption can bind to it directly. Publish the returned
@@ -160,9 +133,8 @@ export declare function encryptCampaignAmounts(args: EncryptCampaignAmountsArgs)
  * claim, and no amount of on-chain data will reconstruct it. Persist the
  * entries when this resolves and serve each recipient theirs.
  *
- * **Relayer load follows `submitter`.** A self-claim roster fans out one request per
- * recipient; a relayed roster issues one per 32. Either way, split the roster across
- * calls yourself if your relayer rate-limits.
+ * One relayer request per 32 recipients, issued concurrently; every leaf is submittable
+ * by any address. Split the roster across calls yourself if your relayer rate-limits.
  *
  * **Already hold the handles?** This function encrypts unconditionally, and
  * encryption is randomised — so re-encrypting handles that exist elsewhere
@@ -185,13 +157,13 @@ export declare function encryptCampaignAmounts(args: EncryptCampaignAmountsArgs)
  *
  * @alpha
  */
-export declare function buildMerkleCampaign({ instance, recipients, encryptor, submitter, }: BuildMerkleCampaignArgs): Promise<BuiltCampaign>;
+export declare function buildMerkleCampaign({ instance, recipients, encryptor, }: BuildMerkleCampaignArgs): Promise<BuiltCampaign>;
 /**
  * Inputs for {@link planMerkleCampaign}.
  *
  * @alpha
  */
-export interface PlanMerkleCampaignArgs extends CampaignSubmitterOption {
+export interface PlanMerkleCampaignArgs {
     factory: ConfidentialAirdropFactoryClient;
     /** The exact params the subsequent `createMerkleAirdrop` will use, except `merkleRoot` — supply the planned root there. */
     params: MerkleAirdropParams;
@@ -202,19 +174,6 @@ export interface PlanMerkleCampaignArgs extends CampaignSubmitterOption {
     recipients: readonly CampaignRecipient[];
     encryptor: EncryptorSource;
 }
-/**
- * A campaign built against a not-yet-deployed instance, plus the evidence needed to trust the prediction.
- *
- * @alpha
- */
-export interface PlannedCampaign extends BuiltCampaign {
-    /** Where `createMerkleAirdrop({ mode, userSalt })` from `creator` will land. Every entry is bound to this address. */
-    predictedAddress: Address;
-    /** The factory's Merkle init-code hash read BEFORE the address was predicted. */
-    initCodeHashBefore: Hex;
-    /** The same hash read AFTER. Always equal to `initCodeHashBefore` on a returned plan - a difference throws instead. */
-    initCodeHashAfter: Hex;
-}
 /**
  * Build a campaign for an instance that does not exist yet, so its root can be
  * baked in at create time.
@@ -249,6 +208,13 @@ export interface PlannedCampaign extends BuiltCampaign {
  * `preflightCreate` (`./guards.js`) for those, or let `createMerkleAirdrop`
  * enforce them at send time.
  *
+ * **Create from the plan.** Pass the returned plan as `plan` to
+ * `createMerkleAirdrop` / `createAndFundMerkleAirdrop` (and to
+ * `preflightCreate`). That pins `predictedAddress`, checks the root, and
+ * re-judges drift against `initCodeHashAfter` just before the send, so an
+ * implementation rotation after planning is refused rather than deployed at an
+ * address the entries are not bound to.
+ *
  * **Distribution is yours** — same as {@link buildMerkleCampaign}: the chain
  * keeps only the root, so each recipient must be handed their own
  * `(handle, inputProof, merkleProof)` out of band or they cannot claim.
@@ -267,17 +233,18 @@ export interface PlannedCampaign extends BuiltCampaign {
  *   params: { ...params, merkleRoot: plan.root, isMerkleRootMutable: false },
  *   mode: "clone",
  *   userSalt,
+ *   plan,
  * });
  *
  * @alpha
  */
-export declare function planMerkleCampaign({ factory, params, mode, creator, userSalt, recipients, encryptor, submitter, }: PlanMerkleCampaignArgs): Promise<PlannedCampaign>;
+export declare function planMerkleCampaign({ factory, params, mode, creator, userSalt, recipients, encryptor, }: PlanMerkleCampaignArgs): Promise<PlannedCampaign>;
 /**
  * Inputs for {@link rotateMerkleRoot}.
  *
  * @alpha
  */
-export interface RotateMerkleRootArgs extends WriteAccountOverride, CampaignSubmitterOption {
+export interface RotateMerkleRootArgs extends WriteAccountOverride {
     /** The live instance. Its `address` is read off the client — nothing is predicted here. */
     airdrop: MerkleAirdropClient;
     /** The FULL updated roster: cumulative totals, not the deltas since the last root. */
@@ -311,11 +278,8 @@ export interface RotatedCampaign extends BuiltCampaign {
  * entries to every recipient**, including the ones whose total was unchanged —
  * the chain stores only the root, so an un-updated recipient is simply stuck.
  *
- * **`submitter` is not remembered across rotations.** It is read from THIS call, not from
- * the campaign being replaced, so omitting it on a rotation rebuilds a relayed campaign as
- * a self-claim one - every new entry becomes claimable only by its own recipient, and the
- * relayer that was settling for them can no longer submit anything. Pass the same
- * `submitter` again to keep a relayed campaign relayed.
+ * One relayer request per 32 recipients, issued concurrently; every leaf is submittable
+ * by any address.
  *
  * Requires `MERKLE_ADMIN_ROLE` on the instance and an instance created with
  * `isMerkleRootMutable: true`.
@@ -335,4 +299,4 @@ export interface RotatedCampaign extends BuiltCampaign {
  *
  * @alpha
  */
-export declare function rotateMerkleRoot({ airdrop, recipients, encryptor, submitter, account, }: RotateMerkleRootArgs): Promise<RotatedCampaign>;
+export declare function rotateMerkleRoot({ airdrop, recipients, encryptor, account, }: RotateMerkleRootArgs): Promise<RotatedCampaign>;

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

@@ -0,0 +1,21 @@
+import type { Address } from "viem";
+/**
+ * Predict the compliance-manager clone the factory deploys for an instance.
+ *
+ * Mirrors `AirdropFactory`: `Clones.cloneDeterministic(managerImpl,
+ * keccak256(abi.encode(predictedInstance, "compliance")))`, sent from the
+ * factory. The salt derives from the instance address, so the clone moves in
+ * lockstep with it.
+ *
+ * @param args.factory The factory that performs the create (the CREATE2 deployer).
+ * @param args.managerImplementation The implementation the clone is made from.
+ * @param args.airdrop The instance address the create lands at.
+ * @returns The checksummed clone address.
+ *
+ * @alpha
+ */
+export declare function predictComplianceManagerClone(args: {
+    factory: Address;
+    managerImplementation: Address;
+    airdrop: Address;
+}): Address;

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

@@ -3,7 +3,7 @@
  *
  * @alpha
  */
-export declare const AIRDROP_CONTRACTS_COMMIT = "7175ac82f467f0f88c05aba1a4536892999b4251";
+export declare const AIRDROP_CONTRACTS_COMMIT = "005980df194e0dc66053bd517e9759bd4d580047";
 /**
  * Deployment shell selected at create time. Mirrors the contract's `DeploymentMode` enum
  * (`IConfidentialAirdropTypes.sol`): `enum DeploymentMode { Clone, UUPS }`.
@@ -31,3 +31,13 @@ export declare const DEDUP_MODE: {
 };
 /** @alpha */
 export type DedupMode = keyof typeof DEDUP_MODE;
+/** {@link DEDUP_MODE} inverted: the contract's ordinal to the SDK's name. */
+export declare const DEDUP_MODE_BY_ORDINAL: ReadonlyMap<number, DedupMode>;
+/**
+ * The largest value `CommonAirdropParams.maxAcceptedGasFee` can carry - the
+ * `uint96` ceiling. Passing it accepts whatever fee the factory resolves, which
+ * is the opt-out, not the default.
+ *
+ * @alpha
+ */
+export declare const UINT96_MAX: bigint;