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

package/dist/{chunk-O5676ZWY.js → chunk-LEYYG4RF.js}

@@ -1,11 +1,12 @@
 import { isContractRevert } from './chunk-4RAAATVY.js';
 import { TokenOpsSdkError, InvalidArgumentError, FeatureDisabledError, UnsupportedChainError, FheHandleNotAllowedError, TransferFailedError, InsufficientBalanceError, InsufficientFeeError, PausedError, InvalidSignatureError, isTokenOpsSdkError } from './chunk-QBJ7O2B4.js';
-import { isAddressEqual, zeroAddress, BaseError, ContractFunctionZeroDataError } from 'viem';
+import { isAddressEqual, zeroAddress, isAddress, BaseError, ContractFunctionZeroDataError } from 'viem';
 
 // src/fhe-airdrop/constants.ts
-var AIRDROP_CONTRACTS_COMMIT = "8e5b144bdbcdf35b9f36b62f5257d795bf954e8e";
+var AIRDROP_CONTRACTS_COMMIT = "c5c12c2087f61bcd5bd1daa802563ed3cd68f002";
 var DEPLOYMENT_MODE = { clone: 0, uups: 1 };
 var DEDUP_MODE = { perAddress: 0, perDedupId: 1, both: 2, none: 3 };
+var UINT96_MAX = (1n << 96n) - 1n;
 
 // src/fhe-airdrop/errors.ts
 var MerkleUupsUnsupportedError = class extends TokenOpsSdkError {
@@ -35,6 +36,25 @@ var NonStockWrapperError = class extends TokenOpsSdkError {
     );
   }
 };
+var UnauthorizedRedirectError = class extends TokenOpsSdkError {
+  name = "UnauthorizedRedirectError";
+  constructor(args) {
+    const who = args?.submitter ? ` (submitter: ${args.submitter})` : "";
+    super(
+      `Only the claim identity may redirect its own payout${who}: \`to\` (${args?.to ?? "unknown"}) differs from \`account\` (${args?.account ?? "unknown"}) and the submitter is not that account. Leave \`to\` unset (or equal to \`account\`) when submitting on someone else's behalf.`,
+      {
+        code: "TOKENOPS_UNAUTHORIZED_REDIRECT",
+        cause: args?.cause,
+        context: {
+          constraint: "merkle-third-party-redirect",
+          account: args?.account,
+          to: args?.to,
+          submitter: args?.submitter
+        }
+      }
+    );
+  }
+};
 var SaltCollisionError = class extends TokenOpsSdkError {
   name = "SaltCollisionError";
   constructor(args) {
@@ -184,6 +204,42 @@ var ClaimWindowClosedError = class extends TokenOpsSdkError {
     });
   }
 };
+var GasFeeNotAcceptedError = class extends TokenOpsSdkError {
+  name = "GasFeeNotAcceptedError";
+  constructor(args) {
+    const detail = args.resolvedFee !== void 0 && args.maxAcceptedGasFee !== void 0 ? ` The factory resolved ${args.resolvedFee} wei; \`maxAcceptedGasFee\` is ${args.maxAcceptedGasFee} wei.` : "";
+    super(
+      `${args.method}: the resolved per-claim gas fee exceeds \`common.maxAcceptedGasFee\`.${detail} The fee is frozen into the instance at create and cannot be changed after. Every claimant pays it on every claim, so raise the bound only if that is a fee you accept charging them.`,
+      {
+        code: "TOKENOPS_GAS_FEE_NOT_ACCEPTED",
+        cause: args.cause,
+        context: {
+          method: args.method,
+          contractAddress: args.contractAddress,
+          resolvedFee: args.resolvedFee,
+          maxAcceptedGasFee: args.maxAcceptedGasFee
+        }
+      }
+    );
+  }
+};
+var UnrecognisedAirdropError = class extends TokenOpsSdkError {
+  name = "UnrecognisedAirdropError";
+  constructor(args) {
+    super(
+      `${args.method}: ${args.contractAddress} was not created by the factory at ${args.factory}, so it is not a TokenOps airdrop. Treat its ABI, its events and its pool as unverified.`,
+      {
+        code: "TOKENOPS_UNRECOGNISED_AIRDROP",
+        cause: args.cause,
+        context: {
+          method: args.method,
+          contractAddress: args.contractAddress,
+          factory: args.factory
+        }
+      }
+    );
+  }
+};
 var airdropProductMapper = (name, errArgs, ctx) => {
   switch (name) {
     // ---- guarded conditions, caught on-chain instead of pre-flight -------
@@ -239,6 +295,22 @@ var airdropProductMapper = (name, errArgs, ctx) => {
       });
     case "RootImmutable":
       return new FeatureDisabledError({ ...ctx, feature: "merkleRootRotation" });
+    case "ZeroAccount":
+      return invalidArg(
+        ctx,
+        "account",
+        name,
+        "the claim identity is mandatory and is never defaulted from the caller"
+      );
+    case "UnauthorizedRedirect": {
+      const account = errArgs?.[0];
+      const to = errArgs?.[1];
+      return new UnauthorizedRedirectError({
+        account,
+        to,
+        submitter: ctx.productContext?.["creator"]
+      });
+    }
     // ---- FHEVM chain config ---------------------------------------------
     case "ZamaProtocolUnsupported": {
       const chainId = ctx.productContext?.["chainId"] ?? 0;
@@ -252,6 +324,28 @@ var airdropProductMapper = (name, errArgs, ctx) => {
     }
     // ---- argument-validation bucket: reverts not already covered by the
     // cross-product default mapper's `Zero*`/`Invalid*` list ---------------
+    case "GasFeeNotAccepted": {
+      const resolvedFee = errArgs?.[0];
+      const maxAcceptedGasFee = errArgs?.[1];
+      return new GasFeeNotAcceptedError({ ...ctx, resolvedFee, maxAcceptedGasFee });
+    }
+    case "GasFeeExceedsMaximum": {
+      const gasFee = errArgs?.[0];
+      const maxGasFee = errArgs?.[1];
+      return new InvalidArgumentError({
+        method: ctx.method,
+        argument: "gasFee",
+        reason: `exceeds the factory's own maximum${gasFee !== void 0 && maxGasFee !== void 0 ? ` (${gasFee} wei > ${maxGasFee} wei)` : ""}; \`setMaxGasFee\` is DEFAULT_ADMIN_ROLE-gated and bounds what FEE_MANAGER_ROLE may configure`,
+        value: gasFee
+      });
+    }
+    case "ZeroUnwrapRequestId":
+      return invalidArg(
+        ctx,
+        "token",
+        name,
+        "the wrapper returned the zero request id, which names no handle to read the delivered amount from; the campaign token is not a conforming ERC7984ERC20Wrapper"
+      );
     case "ZeroToken":
       return invalidArg(ctx, "token", name);
     case "ZeroFeeCollector":
@@ -284,7 +378,7 @@ var airdropProductMapper = (name, errArgs, ctx) => {
         ctx,
         "admin",
         name,
-        "revoking or renouncing the sole DEFAULT_ADMIN_ROLE member would leave the instance permanently ungovernable"
+        "revoking or renouncing the sole DEFAULT_ADMIN_ROLE member would leave the contract permanently ungovernable. Declared once and enforced by BOTH the instances and the factory, each on its own admin set (audit-14) - grant a second admin first, then renounce"
       );
     case "LastFeeCollector":
       return invalidArg(
@@ -443,6 +537,27 @@ async function assertSaltAvailable(args) {
     predictedAddress: args.predictedAddress
   });
 }
+function assertMaxAcceptedGasFeeRange(value, method) {
+  if (value < 0n || value > UINT96_MAX) {
+    throw new InvalidArgumentError({
+      method,
+      argument: "common.maxAcceptedGasFee",
+      reason: `is outside uint96 (0 to ${UINT96_MAX}); the params tuple cannot be ABI-encoded at all`,
+      value
+    });
+  }
+}
+async function assertGasFeeAccepted(args) {
+  assertMaxAcceptedGasFeeRange(args.maxAcceptedGasFee, args.method);
+  const resolvedFee = await args.factory.resolveGasFee(args.creator);
+  if (resolvedFee <= args.maxAcceptedGasFee) return;
+  throw new GasFeeNotAcceptedError({
+    method: args.method,
+    contractAddress: args.factory.address,
+    resolvedFee,
+    maxAcceptedGasFee: args.maxAcceptedGasFee
+  });
+}
 function assertPredictionFresh(args) {
   if (args.initCodeHashBefore.toLowerCase() === args.initCodeHashAfter.toLowerCase()) return;
   throw new PredictionDriftError({
@@ -460,6 +575,20 @@ async function preflightCreate(args) {
   if (args.variant === "merkle") {
     collect(blockers, () => assertMerkleModeSupported(args.mode));
   }
+  const encodable = collect(
+    blockers,
+    () => assertMaxAcceptedGasFeeRange(args.params.common.maxAcceptedGasFee, method)
+  );
+  if (!encodable) return { ready: false, blockers };
+  await collectAsync(
+    blockers,
+    () => assertGasFeeAccepted({
+      factory: args.factory,
+      creator: args.creator,
+      maxAcceptedGasFee: args.params.common.maxAcceptedGasFee,
+      method
+    })
+  );
   const predictArgs = {
     mode: args.mode,
     deployer: args.creator,
@@ -513,18 +642,113 @@ async function preflightCreate(args) {
   }
   return { ready: blockers.length === 0, blockers };
 }
+async function assertKnownAirdrop(args) {
+  if (args.factory.chainId !== args.chainId) {
+    throw new InvalidArgumentError({
+      method: args.method,
+      argument: "factory",
+      reason: `is bound to chain ${args.factory.chainId} but the airdrop is on chain ${args.chainId}; a registry answer from another chain proves nothing about this instance`,
+      value: args.factory.address
+    });
+  }
+  if (await args.factory.isAirdrop(args.airdrop)) return;
+  throw new UnrecognisedAirdropError({
+    method: args.method,
+    contractAddress: args.airdrop,
+    factory: args.factory.address
+  });
+}
+function assertMerkleClaimIdentity(args) {
+  const { method, account, submitter, boundTo, to, entrypoint = "claim" } = args;
+  for (const [argument, value] of [
+    ["account", account],
+    ["entry.boundTo", boundTo],
+    ["to", to],
+    ["submitter", submitter]
+  ]) {
+    if (value !== void 0 && !isAddress(value, { strict: false })) {
+      throw new InvalidArgumentError({
+        method,
+        argument,
+        reason: "is not a 20-byte hex address",
+        value
+      });
+    }
+  }
+  if (isAddressEqual(account, zeroAddress)) {
+    throw new InvalidArgumentError({
+      method,
+      argument: "account",
+      reason: "is the zero address; the claim identity is mandatory and is never defaulted from the caller"
+    });
+  }
+  if (boundTo !== void 0 && !isAddressEqual(boundTo, submitter)) {
+    throw new InvalidArgumentError({
+      method,
+      argument: "entry.boundTo",
+      reason: `is ${boundTo}, but this transaction is sent from ${submitter}; the FHE input proof is bound to the sender, so only ${boundTo} can submit this entry`
+    });
+  }
+  if (entrypoint === "claimAndUnwrap") {
+    if (!isAddressEqual(account, submitter)) {
+      throw new InvalidArgumentError({
+        method,
+        argument: "entry.account",
+        reason: `is ${account}, but \`claimAndUnwrap\` is always submitted for the caller (${submitter}); use \`claim\` to settle on someone else's behalf`
+      });
+    }
+    return;
+  }
+  const beneficiary = to === void 0 || isAddressEqual(to, zeroAddress) ? account : to;
+  if (!isAddressEqual(beneficiary, account) && !isAddressEqual(submitter, account)) {
+    throw new UnauthorizedRedirectError({ account, to: beneficiary, submitter });
+  }
+}
 async function preflightClaim(args) {
   const { airdrop, claimant } = args;
   const method = "preflightClaim";
   const blockers = [];
   collect(blockers, () => assertSupportedChain(airdrop.chainId));
-  const [started, ended, paused, fee, balance] = await Promise.all([
+  if (args.factory) {
+    await collectAsync(
+      blockers,
+      () => assertKnownAirdrop({
+        factory: args.factory,
+        airdrop: airdrop.address,
+        chainId: airdrop.chainId,
+        method
+      })
+    );
+  }
+  if (args.account !== void 0 || args.entrypoint !== void 0) {
+    collect(
+      blockers,
+      () => assertMerkleClaimIdentity({
+        method,
+        account: args.account ?? claimant,
+        submitter: claimant,
+        to: args.to,
+        entrypoint: args.entrypoint
+      })
+    );
+  }
+  const [started, ended, paused, fee, balance, unwrappable] = await Promise.all([
     airdrop.hasClaimStarted(),
     airdrop.hasClaimEnded(),
     airdrop.paused(),
     airdrop.gasFee(),
-    airdrop.publicClient.getBalance({ address: claimant })
+    airdrop.publicClient.getBalance({ address: claimant }),
+    args.entrypoint === "claimAndUnwrap" && airdrop.unwrappable ? airdrop.unwrappable() : Promise.resolve(true)
   ]);
+  if (!unwrappable) {
+    blockers.push(
+      new FeatureDisabledError({
+        method,
+        contractAddress: airdrop.address,
+        feature: "claimAndUnwrap"
+      })
+    );
+  }
   if (paused) {
     blockers.push(new PausedError({ method, contractAddress: airdrop.address }));
   }
@@ -568,9 +792,11 @@ async function preflightClaim(args) {
 function collect(blockers, run) {
   try {
     run();
+    return true;
   } catch (err) {
     if (!isTokenOpsSdkError(err)) throw err;
     blockers.push(err);
+    return false;
   }
 }
 async function collectAsync(blockers, run) {
@@ -582,4 +808,4 @@ async function collectAsync(blockers, run) {
   }
 }
 
-export { AIRDROP_CONTRACTS_COMMIT, AlreadyClaimedError, ClaimNotStartedError, ClaimWindowClosedError, DEDUP_MODE, DEPLOYMENT_MODE, DedupIdConsumedError, FeeCollectorSelfAdministeredError, MerkleUupsUnsupportedError, NonStockWrapperError, PredictionDriftError, SaltCollisionError, SignatureExpiredError, UpgradeabilityNotAllowedError, airdropProductMapper, assertMerkleModeSupported, assertPredictionFresh, assertSaltAvailable, assertStockWrapper, assertSupportedChain, preflightClaim, preflightCreate };
+export { AIRDROP_CONTRACTS_COMMIT, AlreadyClaimedError, ClaimNotStartedError, ClaimWindowClosedError, DEDUP_MODE, DEPLOYMENT_MODE, DedupIdConsumedError, FeeCollectorSelfAdministeredError, GasFeeNotAcceptedError, MerkleUupsUnsupportedError, NonStockWrapperError, PredictionDriftError, SaltCollisionError, SignatureExpiredError, UINT96_MAX, UnauthorizedRedirectError, UnrecognisedAirdropError, UpgradeabilityNotAllowedError, airdropProductMapper, assertGasFeeAccepted, assertMerkleClaimIdentity, assertMerkleModeSupported, assertPredictionFresh, assertSaltAvailable, assertStockWrapper, assertSupportedChain, preflightClaim, preflightCreate };

package/dist/{chunk-335Z2W67.js → chunk-NGU4JYIR.js}

@@ -1,4 +1,4 @@
-import { ConfidentialVestingFactoryClient, confidentialVestingFactoryAbi } from './chunk-EAJ7SYHE.js';
+import { ConfidentialVestingFactoryClient, confidentialVestingFactoryAbi } from './chunk-WRWRA4TN.js';
 
 // src/fhe-vesting/advanced/factory-advanced.ts
 var ConfidentialVestingFactoryAdvancedClient = class extends ConfidentialVestingFactoryClient {

package/dist/{chunk-5576FRT3.cjs → chunk-PG3WXT3K.cjs}

@@ -10,22 +10,29 @@ var DEPLOYED_ADDRESSES = {
       // mainnet omitted — not deployed.
     }
   },
-  // Airdrop v2 (tokenops-fhe-airdrop-v2 @ 8e5b144). The four contracts deploy
+  // Airdrop v2 (tokenops-fhe-airdrop-v2 @ c5c12c2). The four contracts deploy
   // together in one scripted run, so a chain either has all of them or none —
   // which is what `chainsWithDeployment` assumes.
+  //
+  // Every address moved again at c5c12c2. The internal-audit round changed the
+  // factory and all three implementations, and CREATE3 returns a consumed salt's
+  // EXISTING address without comparing codehashes - so the run bumps the canonical
+  // salt version (2.0.0 → 2.0.2) rather than redeploying over itself. A campaign
+  // planned against the previous factory therefore predicts an address the new
+  // factory will never produce; `PredictionDriftError` is what catches that.
   fheAirdrop: {
     airdropFactory: {
-      [chains.sepolia.id]: "0x383083B6f13a0ee513596A6750B511c5E482d2d1"
+      [chains.sepolia.id]: "0xA10ff713cfeE5348313Cda0B2CA1b190A1194cab"
       // mainnet omitted — ZamaConfig-gated, not deployed.
     },
     ecdsaImplementation: {
-      [chains.sepolia.id]: "0xefE40570C1837210f8E4Ae938635e11bd1ae788E"
+      [chains.sepolia.id]: "0x8d4E8F379f73D5488a76B6C3CC8a2fD489936BDe"
     },
     merkleImplementation: {
-      [chains.sepolia.id]: "0x9f3156546744F3ceE98Dc44bed817d98A8b8ae74"
+      [chains.sepolia.id]: "0x4B4F43Ed9aB3F9D10468b59C03d14f55A9d4E82F"
     },
     complianceManagerImplementation: {
-      [chains.sepolia.id]: "0x6adA841250C048364d1d3027958C662Dd4E62136"
+      [chains.sepolia.id]: "0x14bdE71e6b32b50dF1a5Dca1bccD150a319168e2"
     }
   },
   fheDisperse: {

package/dist/{chunk-H5POPGOZ.js → chunk-PK6Q6J5F.js}

@@ -2,7 +2,7 @@ import { mapZamaError } from './chunk-WMACINXO.js';
 import { getFhevmAclAddress, requireFhevmAclAddress, ACL_ALLOWED_EVENT } from './chunk-ZWXJTBZO.js';
 import { SDK_VERSION } from './chunk-NWFMBLSQ.js';
 import { isContractRevert, mapContractRevert } from './chunk-4RAAATVY.js';
-import { getFheDisperseSingletonAddress } from './chunk-DZHYSUGY.js';
+import { getFheDisperseSingletonAddress } from './chunk-6HCT4QIX.js';
 import { normaliseAddress } from './chunk-ZA673I3O.js';
 import { asExternalInputProof, asEncryptedHandle } from './chunk-KWFFIJYX.js';
 import { InvalidArgumentError, TokenOpsSdkError, DeploymentAddressUnavailableError, PausedError, InsufficientFeeError, MissingEncryptorError, ReceiptEventAmbiguousError, MissingWalletClientError, MissingAccountError, BatchTooLargeError } from './chunk-QBJ7O2B4.js';

package/dist/chunk-TND5NDV7.cjs

@@ -0,0 +1,263 @@
+'use strict';
+
+var chunk4AWQJQXY_cjs = require('./chunk-4AWQJQXY.cjs');
+var chunkPG3WXT3K_cjs = require('./chunk-PG3WXT3K.cjs');
+var chunk67OV5CX2_cjs = require('./chunk-67OV5CX2.cjs');
+var react = require('react');
+var wagmi = require('wagmi');
+
+var FHE_AIRDROP_KEY = "tokenops-sdk";
+var FHE_AIRDROP_NAMESPACE = "fhe-airdrop";
+function airdropQueryKey(params) {
+  return [
+    FHE_AIRDROP_KEY,
+    FHE_AIRDROP_NAMESPACE,
+    params.chainId ?? null,
+    params.address ? normalizeKeyArg(params.address) : null,
+    params.fn,
+    params.args.map(normalizeKeyArg)
+  ];
+}
+function airdropQueryKeyPrefix(params) {
+  const prefix = [
+    FHE_AIRDROP_KEY,
+    FHE_AIRDROP_NAMESPACE,
+    params.chainId ?? null,
+    params.address ? normalizeKeyArg(params.address) : null
+  ];
+  if (params.fn !== void 0) prefix.push(params.fn);
+  return prefix;
+}
+function normalizeKeyArg(value) {
+  if (typeof value === "bigint") return value.toString();
+  if (Array.isArray(value)) return value.map(normalizeKeyArg);
+  if (value && typeof value === "object") {
+    return Object.fromEntries(
+      Object.entries(value).map(([k, v]) => [k, normalizeKeyArg(v)])
+    );
+  }
+  if (typeof value === "string" && value.startsWith("0x")) return value.toLowerCase();
+  return value;
+}
+function tryResolveAirdropFactoryAddress(override, chainId) {
+  if (override) return override;
+  if (chainId === void 0) return void 0;
+  return chunkPG3WXT3K_cjs.getFheAirdropFactoryAddress(chainId);
+}
+function computeAirdropFactoryResolutionError(override, chainId) {
+  if (override) return void 0;
+  if (chainId === void 0) {
+    return new chunk67OV5CX2_cjs.DeploymentAddressUnavailableError({
+      reason: "chain-id-missing",
+      product: "fheAirdrop",
+      contract: "airdropFactory",
+      clientLabel: "ConfidentialAirdropFactoryClient"
+    });
+  }
+  const resolved = chunkPG3WXT3K_cjs.getFheAirdropFactoryAddress(chainId);
+  if (!resolved) {
+    return new chunk67OV5CX2_cjs.DeploymentAddressUnavailableError({
+      reason: "registry-not-deployed",
+      product: "fheAirdrop",
+      contract: "airdropFactory",
+      chainId,
+      clientLabel: "ConfidentialAirdropFactoryClient"
+    });
+  }
+  return void 0;
+}
+function useMemoAirdropFactoryClient(opts = {}) {
+  const publicClient = wagmi.usePublicClient({ chainId: opts.chainId });
+  const { data: walletClient } = wagmi.useWalletClient({ chainId: opts.chainId });
+  const chainId = opts.chainId ?? publicClient?.chain?.id;
+  const resolvedAddress = tryResolveAirdropFactoryAddress(opts.address, chainId);
+  const resolutionError = computeAirdropFactoryResolutionError(opts.address, chainId);
+  const encryptorSourceRef = react.useRef(opts.encryptor);
+  encryptorSourceRef.current = opts.encryptor;
+  const telemetry = opts.telemetry;
+  const client = react.useMemo(() => {
+    if (!publicClient) return void 0;
+    if (!resolvedAddress) return void 0;
+    return chunk4AWQJQXY_cjs.createConfidentialAirdropFactoryClient({
+      publicClient,
+      ...walletClient ? { walletClient } : {},
+      address: resolvedAddress,
+      ...chainId !== void 0 ? { chainId } : {},
+      // Lazy — invoked per-encryption inside the headless client.
+      encryptor: () => chunk4AWQJQXY_cjs.resolveEncryptor(encryptorSourceRef.current),
+      ...telemetry ? { telemetry } : {}
+    });
+  }, [publicClient, walletClient, resolvedAddress, chainId, telemetry]);
+  return {
+    client,
+    resolutionError,
+    publicClient,
+    walletClient: walletClient ?? void 0,
+    chainId,
+    resolvedAddress
+  };
+}
+function useMemoAirdropBaseClient(opts) {
+  const publicClient = wagmi.usePublicClient({ chainId: opts.chainId });
+  const { data: walletClient } = wagmi.useWalletClient({ chainId: opts.chainId });
+  const chainId = opts.chainId ?? publicClient?.chain?.id;
+  const telemetry = opts.telemetry;
+  const client = react.useMemo(() => {
+    if (!publicClient) return void 0;
+    if (!opts.address) return void 0;
+    return chunk4AWQJQXY_cjs.createAirdropBaseClient({
+      publicClient,
+      ...walletClient ? { walletClient } : {},
+      address: opts.address,
+      ...chainId !== void 0 ? { chainId } : {},
+      ...telemetry ? { telemetry } : {}
+    });
+  }, [publicClient, walletClient, opts.address, chainId, telemetry]);
+  return { client, publicClient, walletClient: walletClient ?? void 0, chainId };
+}
+function useMemoMerkleAirdropClient(opts) {
+  const publicClient = wagmi.usePublicClient({ chainId: opts.chainId });
+  const { data: walletClient } = wagmi.useWalletClient({ chainId: opts.chainId });
+  const chainId = opts.chainId ?? publicClient?.chain?.id;
+  const telemetry = opts.telemetry;
+  const client = react.useMemo(() => {
+    if (!publicClient) return void 0;
+    if (!opts.address) return void 0;
+    return chunk4AWQJQXY_cjs.createMerkleAirdropClient({
+      publicClient,
+      ...walletClient ? { walletClient } : {},
+      address: opts.address,
+      ...chainId !== void 0 ? { chainId } : {},
+      ...telemetry ? { telemetry } : {}
+    });
+  }, [publicClient, walletClient, opts.address, chainId, telemetry]);
+  return { client, publicClient, walletClient: walletClient ?? void 0, chainId };
+}
+function useMemoComplianceManagerClient(opts) {
+  const publicClient = wagmi.usePublicClient({ chainId: opts.chainId });
+  const { data: walletClient } = wagmi.useWalletClient({ chainId: opts.chainId });
+  const chainId = opts.chainId ?? publicClient?.chain?.id;
+  const telemetry = opts.telemetry;
+  const client = react.useMemo(() => {
+    if (!publicClient) return void 0;
+    if (!opts.address) return void 0;
+    return chunk4AWQJQXY_cjs.createComplianceManagerClient({
+      publicClient,
+      ...walletClient ? { walletClient } : {},
+      address: opts.address,
+      ...chainId !== void 0 ? { chainId } : {},
+      ...telemetry ? { telemetry } : {}
+    });
+  }, [publicClient, walletClient, opts.address, chainId, telemetry]);
+  return { client, publicClient, walletClient: walletClient ?? void 0, chainId };
+}
+function useMemoEcdsaAirdropClient(opts) {
+  const publicClient = wagmi.usePublicClient({ chainId: opts.chainId });
+  const { data: walletClient } = wagmi.useWalletClient({ chainId: opts.chainId });
+  const chainId = opts.chainId ?? publicClient?.chain?.id;
+  const telemetry = opts.telemetry;
+  const client = react.useMemo(() => {
+    if (!publicClient) return void 0;
+    if (!opts.address) return void 0;
+    return chunk4AWQJQXY_cjs.createEcdsaAirdropClient({
+      publicClient,
+      ...walletClient ? { walletClient } : {},
+      address: opts.address,
+      dedupMode: opts.dedupMode,
+      ...chainId !== void 0 ? { chainId } : {},
+      ...telemetry ? { telemetry } : {}
+    });
+  }, [publicClient, walletClient, opts.address, opts.dedupMode, chainId, telemetry]);
+  return { client, publicClient, walletClient: walletClient ?? void 0, chainId };
+}
+
+// src/fhe-airdrop/react/keys.ts
+var AIRDROP_FN = {
+  // instance reads
+  claimedAmount: "getClaimedAmount",
+  paused: "paused",
+  window: "window",
+  config: "config",
+  merkleRoot: "merkleRoot",
+  merkleRootMutable: "isMerkleRootMutable",
+  hasRole: "hasRole",
+  roleMembers: "roleMembers",
+  gasFee: "gasFee",
+  preflightCreate: "preflightCreate",
+  isSignatureValid: "isSignatureValid",
+  // factory reads
+  fees: "fees",
+  registry: "registry",
+  isAirdrop: "isAirdrop",
+  resolvedGasFee: "resolvedGasFee",
+  customFee: "customFee",
+  implementations: "implementations",
+  compliancePolicy: "compliancePolicy",
+  upgradeabilityPolicy: "upgradeabilityPolicy",
+  factoryHasRole: "factoryHasRole",
+  factoryRoleMembers: "factoryRoleMembers",
+  // compliance-manager reads
+  complianceInfo: "complianceInfo",
+  activeDelegate: "isActiveDelegate",
+  clientDelegates: "clientDelegates",
+  complianceHasRole: "complianceHasRole",
+  complianceRoleMembers: "complianceRoleMembers"
+};
+var airdropKeys = {
+  /** One account's cumulative delivered total. Keyed on the CLAIM IDENTITY, never the sender. */
+  claimedAmount: (s, account) => airdropQueryKey({ ...s, fn: AIRDROP_FN.claimedAmount, args: [account] }),
+  paused: (s) => airdropQueryKey({ ...s, fn: AIRDROP_FN.paused, args: [] }),
+  window: (s) => airdropQueryKey({ ...s, fn: AIRDROP_FN.window, args: [] }),
+  config: (s) => airdropQueryKey({ ...s, fn: AIRDROP_FN.config, args: [] }),
+  gasFee: (s) => airdropQueryKey({ ...s, fn: AIRDROP_FN.gasFee, args: [] }),
+  merkleRoot: (s) => airdropQueryKey({ ...s, fn: AIRDROP_FN.merkleRoot, args: [] }),
+  merkleRootMutable: (s) => airdropQueryKey({ ...s, fn: AIRDROP_FN.merkleRootMutable, args: [] }),
+  hasRole: (s, role, holder) => airdropQueryKey({ ...s, fn: AIRDROP_FN.hasRole, args: [role, holder] }),
+  /** Every cached `hasRole` for this instance, whatever role/holder pair was queried. */
+  hasRoleAll: (s) => airdropQueryKeyPrefix({ ...s, fn: AIRDROP_FN.hasRole }),
+  roleMembers: (s, role) => airdropQueryKey({ ...s, fn: AIRDROP_FN.roleMembers, args: [role] }),
+  roleMembersAll: (s) => airdropQueryKeyPrefix({ ...s, fn: AIRDROP_FN.roleMembers }),
+  /** Every cached create-preflight, whatever params/mode/salt combination was queried. */
+  preflightCreateAll: (s) => airdropQueryKeyPrefix({ ...s, fn: AIRDROP_FN.preflightCreate }),
+  /** Every cached signature check on this instance; a claim consumes a digest and flips it. */
+  isSignatureValidAll: (s) => airdropQueryKeyPrefix({ ...s, fn: AIRDROP_FN.isSignatureValid }),
+  fees: (s) => airdropQueryKey({ ...s, fn: AIRDROP_FN.fees, args: [] }),
+  customFee: (s, creator) => airdropQueryKey({ ...s, fn: AIRDROP_FN.customFee, args: [creator] }),
+  customFeeAll: (s) => airdropQueryKeyPrefix({ ...s, fn: AIRDROP_FN.customFee }),
+  resolvedGasFee: (s, creator) => airdropQueryKey({ ...s, fn: AIRDROP_FN.resolvedGasFee, args: [creator] }),
+  /** Every creator's resolved fee; the default and any override both move it. */
+  resolvedGasFeeAll: (s) => airdropQueryKeyPrefix({ ...s, fn: AIRDROP_FN.resolvedGasFee }),
+  /** Every registry page, whatever offset/limit was queried. */
+  registryAll: (s) => airdropQueryKeyPrefix({ ...s, fn: AIRDROP_FN.registry }),
+  isAirdrop: (s, candidate) => airdropQueryKey({ ...s, fn: AIRDROP_FN.isAirdrop, args: [candidate] }),
+  /** Every genuineness answer from this factory; a create adds one address. */
+  isAirdropAll: (s) => airdropQueryKeyPrefix({ ...s, fn: AIRDROP_FN.isAirdrop }),
+  implementations: (s) => airdropQueryKey({ ...s, fn: AIRDROP_FN.implementations, args: [] }),
+  compliancePolicy: (s, creator) => airdropQueryKey({ ...s, fn: AIRDROP_FN.compliancePolicy, args: [creator] }),
+  compliancePolicyAll: (s) => airdropQueryKeyPrefix({ ...s, fn: AIRDROP_FN.compliancePolicy }),
+  upgradeabilityPolicy: (s, creator) => airdropQueryKey({ ...s, fn: AIRDROP_FN.upgradeabilityPolicy, args: [creator] }),
+  upgradeabilityPolicyAll: (s) => airdropQueryKeyPrefix({ ...s, fn: AIRDROP_FN.upgradeabilityPolicy }),
+  factoryHasRole: (s, role, holder) => airdropQueryKey({ ...s, fn: AIRDROP_FN.factoryHasRole, args: [role, holder] }),
+  factoryHasRoleAll: (s) => airdropQueryKeyPrefix({ ...s, fn: AIRDROP_FN.factoryHasRole }),
+  factoryRoleMembers: (s, role) => airdropQueryKey({ ...s, fn: AIRDROP_FN.factoryRoleMembers, args: [role] }),
+  factoryRoleMembersAll: (s) => airdropQueryKeyPrefix({ ...s, fn: AIRDROP_FN.factoryRoleMembers }),
+  complianceInfo: (s) => airdropQueryKey({ ...s, fn: AIRDROP_FN.complianceInfo, args: [] }),
+  activeDelegate: (s, delegate) => airdropQueryKey({ ...s, fn: AIRDROP_FN.activeDelegate, args: [delegate] }),
+  activeDelegateAll: (s) => airdropQueryKeyPrefix({ ...s, fn: AIRDROP_FN.activeDelegate }),
+  clientDelegates: (s, index) => airdropQueryKey({ ...s, fn: AIRDROP_FN.clientDelegates, args: [index] }),
+  clientDelegatesAll: (s) => airdropQueryKeyPrefix({ ...s, fn: AIRDROP_FN.clientDelegates }),
+  complianceHasRole: (s, role, holder) => airdropQueryKey({ ...s, fn: AIRDROP_FN.complianceHasRole, args: [role, holder] }),
+  complianceHasRoleAll: (s) => airdropQueryKeyPrefix({ ...s, fn: AIRDROP_FN.complianceHasRole }),
+  complianceRoleMembers: (s, role) => airdropQueryKey({ ...s, fn: AIRDROP_FN.complianceRoleMembers, args: [role] }),
+  complianceRoleMembersAll: (s) => airdropQueryKeyPrefix({ ...s, fn: AIRDROP_FN.complianceRoleMembers })
+};
+
+exports.AIRDROP_FN = AIRDROP_FN;
+exports.airdropKeys = airdropKeys;
+exports.airdropQueryKey = airdropQueryKey;
+exports.airdropQueryKeyPrefix = airdropQueryKeyPrefix;
+exports.useMemoAirdropBaseClient = useMemoAirdropBaseClient;
+exports.useMemoAirdropFactoryClient = useMemoAirdropFactoryClient;
+exports.useMemoComplianceManagerClient = useMemoComplianceManagerClient;
+exports.useMemoEcdsaAirdropClient = useMemoEcdsaAirdropClient;
+exports.useMemoMerkleAirdropClient = useMemoMerkleAirdropClient;