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

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

@@ -1,10 +1,10 @@
-import { useMemoAirdropFactoryClient, airdropQueryKey, airdropKeys, airdropQueryKeyPrefix } from '../../../chunk-U3TBQRT7.js';
-import '../../../chunk-BXX5TETM.js';
-import '../../../chunk-LEYYG4RF.js';
+import { useMemoAirdropFactoryClient, airdropKeys, airdropQueryKey } from '../../../chunk-3ZSPRHR3.js';
+import '../../../chunk-67Q6KSVV.js';
+import '../../../chunk-YMWMIWBP.js';
 import '../../../chunk-ZWXJTBZO.js';
-import '../../../chunk-NWFMBLSQ.js';
+import '../../../chunk-7KY4K4PH.js';
 import '../../../chunk-4RAAATVY.js';
-import '../../../chunk-6HCT4QIX.js';
+import '../../../chunk-GHGF65LN.js';
 import '../../../chunk-ZA673I3O.js';
 import '../../../chunk-KWFFIJYX.js';
 import { MissingClientError } from '../../../chunk-QBJ7O2B4.js';
@@ -16,12 +16,12 @@ function usePredictEcdsaAirdropAddress(args) {
   const { client, chainId, resolvedAddress } = useMemoAirdropFactoryClient(base);
   return useQuery({
     ...args.query,
-    queryKey: airdropQueryKey({
-      chainId,
-      address: resolvedAddress,
-      fn: "predictEcdsaAirdropAddress",
-      args: [mode, deployer, userSalt]
-    }),
+    queryKey: airdropKeys.predictEcdsaAddress(
+      { chainId, address: resolvedAddress },
+      mode,
+      deployer,
+      userSalt
+    ),
     queryFn: () => client.predictEcdsaAirdropAddress({ params, mode, deployer, userSalt }),
     enabled: Boolean(client && (args.query?.enabled ?? true))
   });
@@ -31,12 +31,12 @@ function usePredictMerkleAirdropAddress(args) {
   const { client, chainId, resolvedAddress } = useMemoAirdropFactoryClient(base);
   return useQuery({
     ...args.query,
-    queryKey: airdropQueryKey({
-      chainId,
-      address: resolvedAddress,
-      fn: "predictMerkleAirdropAddress",
-      args: [mode, deployer, userSalt]
-    }),
+    queryKey: airdropKeys.predictMerkleAddress(
+      { chainId, address: resolvedAddress },
+      mode,
+      deployer,
+      userSalt
+    ),
     queryFn: () => client.predictMerkleAirdropAddress({ params, mode, deployer, userSalt }),
     enabled: Boolean(client && (args.query?.enabled ?? true))
   });
@@ -57,12 +57,9 @@ function useClearCompliancePolicy(options = {}) {
         queryKey: airdropKeys.compliancePolicy(scope, variables.creator)
       });
       void queryClient.invalidateQueries({
-        queryKey: airdropQueryKey({
-          ...scope,
-          fn: "effectiveDelegateToCompliance",
-          args: [variables.creator]
-        })
+        queryKey: airdropKeys.effectiveDelegateToCompliance(scope, variables.creator)
       });
+      void queryClient.invalidateQueries({ queryKey: airdropKeys.preflightCreateAll(scope) });
     }
   });
 }
@@ -79,11 +76,7 @@ function useClearUpgradeabilityPolicy(options = {}) {
     onSuccess: (_hash, variables) => {
       const scope = { chainId, address: resolvedAddress };
       void queryClient.invalidateQueries({
-        queryKey: airdropQueryKey({
-          ...scope,
-          fn: "effectiveUpgradeable",
-          args: [variables.creator]
-        })
+        queryKey: airdropKeys.effectiveUpgradeable(scope, variables.creator)
       });
       void queryClient.invalidateQueries({
         queryKey: airdropKeys.upgradeabilityPolicy(scope, variables.creator)
@@ -111,6 +104,9 @@ function useDisableCustomFee(options = {}) {
       void queryClient.invalidateQueries({
         queryKey: airdropKeys.customFee({ chainId, address: resolvedAddress }, variables.creator)
       });
+      void queryClient.invalidateQueries({
+        queryKey: airdropKeys.preflightCreateAll({ chainId, address: resolvedAddress })
+      });
     }
   });
 }
@@ -124,12 +120,7 @@ function useEcdsaInitCodeHash(args) {
     // implementation pointer, which is what this read reports) moves the
     // result. If a future factory version makes params hash-affecting, this
     // key has to grow with it.
-    queryKey: airdropQueryKey({
-      chainId,
-      address: resolvedAddress,
-      fn: "getEcdsaInitCodeHash",
-      args: [mode]
-    }),
+    queryKey: airdropKeys.ecdsaInitCodeHash({ chainId, address: resolvedAddress }, mode),
     queryFn: () => client.getEcdsaInitCodeHash({ params, mode }),
     enabled: Boolean(client && (args.query?.enabled ?? true))
   });
@@ -138,12 +129,7 @@ function useFactoryComplianceDelegate(args = {}) {
   const { client, chainId, resolvedAddress } = useMemoAirdropFactoryClient(args);
   return useQuery({
     ...args.query,
-    queryKey: airdropQueryKey({
-      chainId,
-      address: resolvedAddress,
-      fn: "complianceDelegate",
-      args: []
-    }),
+    queryKey: airdropKeys.complianceDelegate({ chainId, address: resolvedAddress }),
     queryFn: () => client.complianceDelegate(),
     enabled: Boolean(client && (args.query?.enabled ?? true))
   });
@@ -347,12 +333,7 @@ function useMerkleInitCodeHash(args) {
   return useQuery({
     ...args.query,
     // `params` omitted deliberately — see useEcdsaInitCodeHash for why.
-    queryKey: airdropQueryKey({
-      chainId,
-      address: resolvedAddress,
-      fn: "getMerkleInitCodeHash",
-      args: [mode]
-    }),
+    queryKey: airdropKeys.merkleInitCodeHash({ chainId, address: resolvedAddress }, mode),
     queryFn: () => client.getMerkleInitCodeHash({ params, mode }),
     enabled: Boolean(client && (args.query?.enabled ?? true))
   });
@@ -369,12 +350,10 @@ function useSetComplianceDelegate(options = {}) {
     },
     onSuccess: () => {
       void queryClient.invalidateQueries({
-        queryKey: airdropQueryKey({
-          chainId,
-          address: resolvedAddress,
-          fn: "complianceDelegate",
-          args: []
-        })
+        queryKey: airdropKeys.complianceDelegate({ chainId, address: resolvedAddress })
+      });
+      void queryClient.invalidateQueries({
+        queryKey: airdropKeys.preflightCreateAll({ chainId, address: resolvedAddress })
       });
     }
   });
@@ -393,6 +372,9 @@ function useSetComplianceManagerImpl(options = {}) {
       void queryClient.invalidateQueries({
         queryKey: airdropKeys.implementations({ chainId, address: resolvedAddress })
       });
+      void queryClient.invalidateQueries({
+        queryKey: airdropKeys.preflightCreateAll({ chainId, address: resolvedAddress })
+      });
     }
   });
 }
@@ -412,12 +394,9 @@ function useSetCompliancePolicy(options = {}) {
         queryKey: airdropKeys.compliancePolicy(scope, variables.creator)
       });
       void queryClient.invalidateQueries({
-        queryKey: airdropQueryKey({
-          ...scope,
-          fn: "effectiveDelegateToCompliance",
-          args: [variables.creator]
-        })
+        queryKey: airdropKeys.effectiveDelegateToCompliance(scope, variables.creator)
       });
+      void queryClient.invalidateQueries({ queryKey: airdropKeys.preflightCreateAll(scope) });
     }
   });
 }
@@ -438,6 +417,9 @@ function useSetCustomFee(options = {}) {
       void queryClient.invalidateQueries({
         queryKey: airdropKeys.customFee({ chainId, address: resolvedAddress }, variables.creator)
       });
+      void queryClient.invalidateQueries({
+        queryKey: airdropKeys.preflightCreateAll({ chainId, address: resolvedAddress })
+      });
     }
   });
 }
@@ -453,15 +435,17 @@ function useSetDefaultDelegateToCompliance(options = {}) {
     },
     onSuccess: () => {
       void queryClient.invalidateQueries({
-        queryKey: airdropQueryKeyPrefix({
+        queryKey: airdropKeys.effectiveDelegateToComplianceAll({
           chainId,
-          address: resolvedAddress,
-          fn: "effectiveDelegateToCompliance"
+          address: resolvedAddress
         })
       });
       void queryClient.invalidateQueries({
         queryKey: airdropKeys.compliancePolicyAll({ chainId, address: resolvedAddress })
       });
+      void queryClient.invalidateQueries({
+        queryKey: airdropKeys.preflightCreateAll({ chainId, address: resolvedAddress })
+      });
     }
   });
 }
@@ -482,6 +466,9 @@ function useSetDefaultGasFee(options = {}) {
       void queryClient.invalidateQueries({
         queryKey: airdropKeys.fees({ chainId, address: resolvedAddress })
       });
+      void queryClient.invalidateQueries({
+        queryKey: airdropKeys.preflightCreateAll({ chainId, address: resolvedAddress })
+      });
     }
   });
 }
@@ -502,6 +489,9 @@ function useSetMaxGasFee(options = {}) {
       void queryClient.invalidateQueries({
         queryKey: airdropKeys.resolvedGasFeeAll({ chainId, address: resolvedAddress })
       });
+      void queryClient.invalidateQueries({
+        queryKey: airdropKeys.preflightCreateAll({ chainId, address: resolvedAddress })
+      });
     }
   });
 }
@@ -518,7 +508,7 @@ function useSetDefaultUpgradeable(options = {}) {
     onSuccess: () => {
       const scope = { chainId, address: resolvedAddress };
       void queryClient.invalidateQueries({
-        queryKey: airdropQueryKeyPrefix({ ...scope, fn: "effectiveUpgradeable" })
+        queryKey: airdropKeys.effectiveUpgradeableAll(scope)
       });
       void queryClient.invalidateQueries({
         queryKey: airdropKeys.upgradeabilityPolicyAll(scope)
@@ -542,12 +532,8 @@ function useSetEcdsaImplementation(options = {}) {
     onSuccess: () => {
       const scope = { chainId, address: resolvedAddress };
       void queryClient.invalidateQueries({ queryKey: airdropKeys.implementations(scope) });
-      void queryClient.invalidateQueries({
-        queryKey: airdropQueryKeyPrefix({ ...scope, fn: "getEcdsaInitCodeHash" })
-      });
-      void queryClient.invalidateQueries({
-        queryKey: airdropQueryKeyPrefix({ ...scope, fn: "predictEcdsaAirdropAddress" })
-      });
+      void queryClient.invalidateQueries({ queryKey: airdropKeys.ecdsaInitCodeHashAll(scope) });
+      void queryClient.invalidateQueries({ queryKey: airdropKeys.predictEcdsaAddressAll(scope) });
       void queryClient.invalidateQueries({
         queryKey: airdropKeys.preflightCreateAll(scope)
       });
@@ -584,12 +570,8 @@ function useSetMerkleImplementation(options = {}) {
     onSuccess: () => {
       const scope = { chainId, address: resolvedAddress };
       void queryClient.invalidateQueries({ queryKey: airdropKeys.implementations(scope) });
-      void queryClient.invalidateQueries({
-        queryKey: airdropQueryKeyPrefix({ ...scope, fn: "getMerkleInitCodeHash" })
-      });
-      void queryClient.invalidateQueries({
-        queryKey: airdropQueryKeyPrefix({ ...scope, fn: "predictMerkleAirdropAddress" })
-      });
+      void queryClient.invalidateQueries({ queryKey: airdropKeys.merkleInitCodeHashAll(scope) });
+      void queryClient.invalidateQueries({ queryKey: airdropKeys.predictMerkleAddressAll(scope) });
       void queryClient.invalidateQueries({
         queryKey: airdropKeys.preflightCreateAll(scope)
       });
@@ -609,11 +591,7 @@ function useSetUpgradeabilityPolicy(options = {}) {
     onSuccess: (_hash, variables) => {
       const scope = { chainId, address: resolvedAddress };
       void queryClient.invalidateQueries({
-        queryKey: airdropQueryKey({
-          ...scope,
-          fn: "effectiveUpgradeable",
-          args: [variables.creator]
-        })
+        queryKey: airdropKeys.effectiveUpgradeable(scope, variables.creator)
       });
       void queryClient.invalidateQueries({
         queryKey: airdropKeys.upgradeabilityPolicy(scope, variables.creator)

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

@@ -17,7 +17,9 @@ export interface ClearCompliancePolicyArgs extends WriteAccountOverride {
  * the override had been.
  *
  * **Invalidates:** `fn "compliancePolicy"` and
- * `fn "effectiveDelegateToCompliance"`, both keyed on `args.creator`.
+ * `fn "effectiveDelegateToCompliance"`, both keyed on `args.creator`, and every
+ * cached {@link usePreflightCreateAirdrop} report on this factory, whose
+ * `commitments.complianceDelegate` this write moves.
  *
  * @example
  * const clearPolicy = useClearCompliancePolicy();

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

@@ -15,7 +15,9 @@ export interface DisableCustomFeeArgs extends WriteAccountOverride {
  *
  * **Invalidates:** `useFactoryCustomFee({ creator })` for the TARGET creator -
  * `variables.creator`, never the sending admin. Also every `useResolveGasFee`
- * entry: dropping the override sends this creator back to the default.
+ * entry: dropping the override sends this creator back to the default. Also every
+ * cached {@link usePreflightCreateAirdrop} report on this factory, whose
+ * fee blockers (the `maxGasFee` ceiling and `GasFeeNotAcceptedError`) this write moves.
  *
  * @example
  * const disableCustomFee = useDisableCustomFee();

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

@@ -7,10 +7,8 @@ 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.
+ * Never zero: the constructor seeds it and `setComplianceDelegate` rejects zero. Read it
+ * to show which platform delegate policy-ON creates will wire.
  *
  * **Not** `ComplianceManagerClient.complianceDelegate()`. That method has the
  * same name on a different contract and returns the delegate one already-

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

@@ -11,18 +11,18 @@ export interface SetComplianceDelegateArgs extends WriteAccountOverride {
  * 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.
+ * The factory's constructor seeded a non-zero delegate with delegation ON, so this only
+ * rotates it: it can never be cleared, and the zero address always reverts
+ * `ZeroComplianceDelegate`. There is no ordering against
+ * {@link useSetDefaultDelegateToCompliance}.
  *
  * Applies to FUTURE clones only; it cannot retro-wire managers that already
  * exist.
  *
  * **Invalidates:** the factory's `fn "complianceDelegate"` entry
- * ({@link useFactoryComplianceDelegate}).
+ * ({@link useFactoryComplianceDelegate}), and every cached
+ * {@link usePreflightCreateAirdrop} report on this factory, whose
+ * `commitments.complianceDelegate` this write moves.
  *
  * @example
  * const setDelegate = useSetComplianceDelegate();

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

@@ -16,7 +16,9 @@ export interface SetComplianceManagerImplArgs extends WriteAccountOverride {
  * fleet-wide upgrade.
  *
  * **Invalidates:** the factory's `fn "implementations"` entry, which carries
- * `complianceManagerImpl` alongside the ECDSA/Merkle pointers.
+ * `complianceManagerImpl` alongside the ECDSA/Merkle pointers, and every cached
+ * {@link usePreflightCreateAirdrop} report on this factory, whose
+ * `commitments.complianceManagerImpl` this write moves.
  *
  * @example
  * const setImpl = useSetComplianceManagerImpl();

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

@@ -17,7 +17,8 @@ export interface SetCompliancePolicyArgs extends WriteAccountOverride {
  * `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.
+ * entry nobody rendered. Also every cached {@link usePreflightCreateAirdrop}
+ * report on this factory, whose `commitments.complianceDelegate` this write moves.
  *
  * @example
  * const setPolicy = useSetCompliancePolicy();

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

@@ -18,7 +18,9 @@ export interface SetCustomFeeArgs extends WriteAccountOverride {
  * `variables.creator`, never the sending admin. `account` is the submitter and
  * has no cache entry of its own here, so keying the invalidation off it would
  * refresh the wrong row and leave the edited one stale. Also every
- * `useResolveGasFee` entry, since an override is what that hook resolves.
+ * `useResolveGasFee` entry, since an override is what that hook resolves, and every
+ * cached {@link usePreflightCreateAirdrop} report on this factory, whose
+ * fee blockers (the `maxGasFee` ceiling and `GasFeeNotAcceptedError`) this write moves.
  *
  * @example
  * const setCustomFee = useSetCustomFee();

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

@@ -11,16 +11,17 @@ export interface SetDefaultDelegateToComplianceArgs extends WriteAccountOverride
  * Set the factory-wide default for whether new instances delegate compliance
  * disclosure to the platform delegate. Requires `COMPLIANCE_WIRING_ROLE`.
  *
- * **Ordering is load-bearing.** `on: true` reverts `ZeroComplianceDelegate`
- * unless {@link useSetComplianceDelegate} has already set a delegate - read
- * {@link useFactoryComplianceDelegate} first and sequence the two writes.
+ * The default starts ON at factory construction; `on: false` is the deliberate
+ * global opt-out. A per-creator {@link useSetCompliancePolicy} override still wins.
  *
  * **Invalidates:** the `fn "effectiveDelegateToCompliance"` PREFIX and the
  * `fn "compliancePolicy"` PREFIX - every cached creator at once, because this
  * write is chain-wide: any creator without an override moves with the
  * default, and {@link useFactoryCompliancePolicy}'s bundle carries the
  * resolved `effective` field. Contrast {@link useSetCompliancePolicy}, which
- * stays keyed on the one creator it targets.
+ * stays keyed on the one creator it targets. Also every cached
+ * {@link usePreflightCreateAirdrop} report on this factory, whose
+ * `commitments.complianceDelegate` this write moves.
  *
  * @example
  * const setDefault = useSetDefaultDelegateToCompliance();

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

@@ -19,7 +19,9 @@ export interface SetDefaultGasFeeArgs extends WriteAccountOverride {
  * `useResolveGasFee` entry - the default is what resolves for every creator
  * without an override, so all of them move at once. Deliberately NOT any
  * instance's fn `"gasFee"` key: those are frozen at create and invalidating
- * them would refetch unchanged values.
+ * them would refetch unchanged values. Also every cached
+ * {@link usePreflightCreateAirdrop} report on this factory, whose
+ * fee blockers (the `maxGasFee` ceiling and `GasFeeNotAcceptedError`) this write moves.
  *
  * @example
  * const setDefaultFee = useSetDefaultGasFee();

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

@@ -20,9 +20,13 @@ export interface SetMaxGasFeeArgs extends WriteAccountOverride {
  * it is lowered too, so a reduction is two steps, not one.
  *
  * **Invalidates:** this factory's `useFactoryFees` entry (fn `"fees"`, which
- * carries `maxGasFee`) and every `useResolveGasFee` entry, since the ceiling
- * bounds what any creator's fee can resolve to. Deliberately NOT any instance's
- * fn `"gasFee"` key - an instance's fee is frozen at create and cannot move.
+ * carries `maxGasFee`) and every `useResolveGasFee` entry. The ceiling is checked
+ * at create time, and lowering it below existing fees is allowed: a create whose
+ * resolved fee is above it then reverts `GasFeeExceedsMaximum`. Deliberately NOT
+ * any instance's fn `"gasFee"` key - an instance's fee is frozen at create and
+ * cannot move. Also every cached {@link usePreflightCreateAirdrop} report on this
+ * factory: the preflight reports a resolved fee above the ceiling as a blocker,
+ * so the new ceiling must reach it.
  *
  * @example
  * const setCeiling = useSetMaxGasFee();

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;
@@ -142,6 +178,11 @@ export interface WriteAccountOverride {
  * 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,6 +258,19 @@ 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`.
@@ -257,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. */
@@ -283,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>;
@@ -578,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.