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

package/dist/chunk-U3TBQRT7.js

@@ -0,0 +1,253 @@
+import { createConfidentialAirdropFactoryClient, resolveEncryptor, createAirdropBaseClient, createMerkleAirdropClient, createComplianceManagerClient, createEcdsaAirdropClient } from './chunk-BXX5TETM.js';
+import { getFheAirdropFactoryAddress } from './chunk-6HCT4QIX.js';
+import { DeploymentAddressUnavailableError } from './chunk-QBJ7O2B4.js';
+import { useRef, useMemo } from 'react';
+import { usePublicClient, useWalletClient } from '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 getFheAirdropFactoryAddress(chainId);
+}
+function computeAirdropFactoryResolutionError(override, chainId) {
+  if (override) return void 0;
+  if (chainId === void 0) {
+    return new DeploymentAddressUnavailableError({
+      reason: "chain-id-missing",
+      product: "fheAirdrop",
+      contract: "airdropFactory",
+      clientLabel: "ConfidentialAirdropFactoryClient"
+    });
+  }
+  const resolved = getFheAirdropFactoryAddress(chainId);
+  if (!resolved) {
+    return new DeploymentAddressUnavailableError({
+      reason: "registry-not-deployed",
+      product: "fheAirdrop",
+      contract: "airdropFactory",
+      chainId,
+      clientLabel: "ConfidentialAirdropFactoryClient"
+    });
+  }
+  return void 0;
+}
+function useMemoAirdropFactoryClient(opts = {}) {
+  const publicClient = usePublicClient({ chainId: opts.chainId });
+  const { data: walletClient } = 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 = useRef(opts.encryptor);
+  encryptorSourceRef.current = opts.encryptor;
+  const telemetry = opts.telemetry;
+  const client = useMemo(() => {
+    if (!publicClient) return void 0;
+    if (!resolvedAddress) return void 0;
+    return createConfidentialAirdropFactoryClient({
+      publicClient,
+      ...walletClient ? { walletClient } : {},
+      address: resolvedAddress,
+      ...chainId !== void 0 ? { chainId } : {},
+      // Lazy — invoked per-encryption inside the headless client.
+      encryptor: () => 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 = usePublicClient({ chainId: opts.chainId });
+  const { data: walletClient } = useWalletClient({ chainId: opts.chainId });
+  const chainId = opts.chainId ?? publicClient?.chain?.id;
+  const telemetry = opts.telemetry;
+  const client = useMemo(() => {
+    if (!publicClient) return void 0;
+    if (!opts.address) return void 0;
+    return 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 = usePublicClient({ chainId: opts.chainId });
+  const { data: walletClient } = useWalletClient({ chainId: opts.chainId });
+  const chainId = opts.chainId ?? publicClient?.chain?.id;
+  const telemetry = opts.telemetry;
+  const client = useMemo(() => {
+    if (!publicClient) return void 0;
+    if (!opts.address) return void 0;
+    return 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 = usePublicClient({ chainId: opts.chainId });
+  const { data: walletClient } = useWalletClient({ chainId: opts.chainId });
+  const chainId = opts.chainId ?? publicClient?.chain?.id;
+  const telemetry = opts.telemetry;
+  const client = useMemo(() => {
+    if (!publicClient) return void 0;
+    if (!opts.address) return void 0;
+    return 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 = usePublicClient({ chainId: opts.chainId });
+  const { data: walletClient } = useWalletClient({ chainId: opts.chainId });
+  const chainId = opts.chainId ?? publicClient?.chain?.id;
+  const telemetry = opts.telemetry;
+  const client = useMemo(() => {
+    if (!publicClient) return void 0;
+    if (!opts.address) return void 0;
+    return 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 })
+};
+
+export { AIRDROP_FN, airdropKeys, airdropQueryKey, airdropQueryKeyPrefix, useMemoAirdropBaseClient, useMemoAirdropFactoryClient, useMemoComplianceManagerClient, useMemoEcdsaAirdropClient, useMemoMerkleAirdropClient };

package/dist/{chunk-EAJ7SYHE.js → chunk-WRWRA4TN.js}

@@ -1,6 +1,6 @@
 import { SDK_VERSION } from './chunk-NWFMBLSQ.js';
 import { mapContractRevert, isContractRevert } from './chunk-4RAAATVY.js';
-import { getFheVestingFactoryAddress } from './chunk-DZHYSUGY.js';
+import { getFheVestingFactoryAddress } from './chunk-6HCT4QIX.js';
 import { normaliseAddress } from './chunk-ZA673I3O.js';
 import { asTxHash } from './chunk-KWFFIJYX.js';
 import { DeploymentAddressUnavailableError, TokenOpsSdkError, MissingWalletClientError, MissingAccountError } from './chunk-QBJ7O2B4.js';

package/dist/{chunk-JQYC66TO.cjs → chunk-YABHXJNH.cjs}

@@ -2,8 +2,8 @@
 
 var chunkWJLECC22_cjs = require('./chunk-WJLECC22.cjs');
 var chunk3QHNYEQD_cjs = require('./chunk-3QHNYEQD.cjs');
-var chunk6PXXGACR_cjs = require('./chunk-6PXXGACR.cjs');
-var chunk5576FRT3_cjs = require('./chunk-5576FRT3.cjs');
+var chunkJVNJSDQ4_cjs = require('./chunk-JVNJSDQ4.cjs');
+var chunkPG3WXT3K_cjs = require('./chunk-PG3WXT3K.cjs');
 var chunk67OV5CX2_cjs = require('./chunk-67OV5CX2.cjs');
 var react = require('react');
 var wagmi = require('wagmi');
@@ -26,7 +26,7 @@ function useHookFiredEvent(hookName, telemetry, hasWallet, chainId) {
 function tryResolveFactoryAddress(override, chainId) {
   if (override) return override;
   if (chainId === void 0) return void 0;
-  return chunk5576FRT3_cjs.getFheVestingFactoryAddress(chainId);
+  return chunkPG3WXT3K_cjs.getFheVestingFactoryAddress(chainId);
 }
 function useMemoFactoryClient(opts = {}) {
   const publicClient = wagmi.usePublicClient({ chainId: opts.chainId });
@@ -39,7 +39,7 @@ function useMemoFactoryClient(opts = {}) {
   const client = react.useMemo(() => {
     if (!publicClient) return void 0;
     if (!resolvedAddress) return void 0;
-    return chunk6PXXGACR_cjs.createConfidentialVestingFactoryClient({
+    return chunkJVNJSDQ4_cjs.createConfidentialVestingFactoryClient({
       publicClient,
       ...walletClient ? { walletClient } : {},
       address: resolvedAddress,
@@ -66,7 +66,7 @@ function computeFactoryResolutionError(override, chainId) {
       clientLabel: "ConfidentialVestingFactoryClient"
     });
   }
-  const resolved = chunk5576FRT3_cjs.getFheVestingFactoryAddress(chainId);
+  const resolved = chunkPG3WXT3K_cjs.getFheVestingFactoryAddress(chainId);
   if (!resolved) {
     return new chunk67OV5CX2_cjs.DeploymentAddressUnavailableError({
       reason: "registry-not-deployed",

package/dist/{chunk-M4IT6DNJ.cjs → chunk-YTIYTV4K.cjs}

@@ -5,9 +5,10 @@ var chunk67OV5CX2_cjs = require('./chunk-67OV5CX2.cjs');
 var viem = require('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 chunk67OV5CX2_cjs.TokenOpsSdkError {
@@ -37,6 +38,25 @@ var NonStockWrapperError = class extends chunk67OV5CX2_cjs.TokenOpsSdkError {
     );
   }
 };
+var UnauthorizedRedirectError = class extends chunk67OV5CX2_cjs.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 chunk67OV5CX2_cjs.TokenOpsSdkError {
   name = "SaltCollisionError";
   constructor(args) {
@@ -186,6 +206,42 @@ var ClaimWindowClosedError = class extends chunk67OV5CX2_cjs.TokenOpsSdkError {
     });
   }
 };
+var GasFeeNotAcceptedError = class extends chunk67OV5CX2_cjs.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 chunk67OV5CX2_cjs.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 -------
@@ -241,6 +297,22 @@ var airdropProductMapper = (name, errArgs, ctx) => {
       });
     case "RootImmutable":
       return new chunk67OV5CX2_cjs.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;
@@ -254,6 +326,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 chunk67OV5CX2_cjs.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":
@@ -286,7 +380,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(
@@ -445,6 +539,27 @@ async function assertSaltAvailable(args) {
     predictedAddress: args.predictedAddress
   });
 }
+function assertMaxAcceptedGasFeeRange(value, method) {
+  if (value < 0n || value > UINT96_MAX) {
+    throw new chunk67OV5CX2_cjs.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({
@@ -462,6 +577,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,
@@ -515,18 +644,113 @@ async function preflightCreate(args) {
   }
   return { ready: blockers.length === 0, blockers };
 }
+async function assertKnownAirdrop(args) {
+  if (args.factory.chainId !== args.chainId) {
+    throw new chunk67OV5CX2_cjs.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 && !viem.isAddress(value, { strict: false })) {
+      throw new chunk67OV5CX2_cjs.InvalidArgumentError({
+        method,
+        argument,
+        reason: "is not a 20-byte hex address",
+        value
+      });
+    }
+  }
+  if (viem.isAddressEqual(account, viem.zeroAddress)) {
+    throw new chunk67OV5CX2_cjs.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 && !viem.isAddressEqual(boundTo, submitter)) {
+    throw new chunk67OV5CX2_cjs.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 (!viem.isAddressEqual(account, submitter)) {
+      throw new chunk67OV5CX2_cjs.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 || viem.isAddressEqual(to, viem.zeroAddress) ? account : to;
+  if (!viem.isAddressEqual(beneficiary, account) && !viem.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 chunk67OV5CX2_cjs.FeatureDisabledError({
+        method,
+        contractAddress: airdrop.address,
+        feature: "claimAndUnwrap"
+      })
+    );
+  }
   if (paused) {
     blockers.push(new chunk67OV5CX2_cjs.PausedError({ method, contractAddress: airdrop.address }));
   }
@@ -570,9 +794,11 @@ async function preflightClaim(args) {
 function collect(blockers, run) {
   try {
     run();
+    return true;
   } catch (err) {
     if (!chunk67OV5CX2_cjs.isTokenOpsSdkError(err)) throw err;
     blockers.push(err);
+    return false;
   }
 }
 async function collectAsync(blockers, run) {
@@ -592,13 +818,19 @@ exports.DEDUP_MODE = DEDUP_MODE;
 exports.DEPLOYMENT_MODE = DEPLOYMENT_MODE;
 exports.DedupIdConsumedError = DedupIdConsumedError;
 exports.FeeCollectorSelfAdministeredError = FeeCollectorSelfAdministeredError;
+exports.GasFeeNotAcceptedError = GasFeeNotAcceptedError;
 exports.MerkleUupsUnsupportedError = MerkleUupsUnsupportedError;
 exports.NonStockWrapperError = NonStockWrapperError;
 exports.PredictionDriftError = PredictionDriftError;
 exports.SaltCollisionError = SaltCollisionError;
 exports.SignatureExpiredError = SignatureExpiredError;
+exports.UINT96_MAX = UINT96_MAX;
+exports.UnauthorizedRedirectError = UnauthorizedRedirectError;
+exports.UnrecognisedAirdropError = UnrecognisedAirdropError;
 exports.UpgradeabilityNotAllowedError = UpgradeabilityNotAllowedError;
 exports.airdropProductMapper = airdropProductMapper;
+exports.assertGasFeeAccepted = assertGasFeeAccepted;
+exports.assertMerkleClaimIdentity = assertMerkleClaimIdentity;
 exports.assertMerkleModeSupported = assertMerkleModeSupported;
 exports.assertPredictionFresh = assertPredictionFresh;
 exports.assertSaltAvailable = assertSaltAvailable;

package/dist/core/addresses.d.ts

@@ -15,16 +15,16 @@ export declare const DEPLOYED_ADDRESSES: {
     };
     readonly fheAirdrop: {
         readonly airdropFactory: {
-            readonly 11155111: "0x383083B6f13a0ee513596A6750B511c5E482d2d1";
+            readonly 11155111: "0xA10ff713cfeE5348313Cda0B2CA1b190A1194cab";
         };
         readonly ecdsaImplementation: {
-            readonly 11155111: "0xefE40570C1837210f8E4Ae938635e11bd1ae788E";
+            readonly 11155111: "0x8d4E8F379f73D5488a76B6C3CC8a2fD489936BDe";
         };
         readonly merkleImplementation: {
-            readonly 11155111: "0x9f3156546744F3ceE98Dc44bed817d98A8b8ae74";
+            readonly 11155111: "0x4B4F43Ed9aB3F9D10468b59C03d14f55A9d4E82F";
         };
         readonly complianceManagerImplementation: {
-            readonly 11155111: "0x6adA841250C048364d1d3027958C662Dd4E62136";
+            readonly 11155111: "0x14bdE71e6b32b50dF1a5Dca1bccD150a319168e2";
         };
     };
     readonly fheDisperse: {

package/dist/core/errors.d.ts

@@ -13,7 +13,7 @@ declare const TOKENOPS_SDK_ERROR_BRAND: unique symbol;
  * human-readable and may evolve between versions.
  * @public
  */
-export type TokenOpsSdkErrorCode = "TOKENOPS_UNSUPPORTED_CHAIN" | "TOKENOPS_DEPLOYMENT_ADDRESS_UNAVAILABLE" | "TOKENOPS_MISSING_PUBLIC_CLIENT" | "TOKENOPS_MISSING_WALLET_CLIENT" | "TOKENOPS_MISSING_ACCOUNT" | "TOKENOPS_MISSING_ENCRYPTOR" | "TOKENOPS_MISSING_CLIENT" | "TOKENOPS_INVALID_ARGUMENT" | "TOKENOPS_RECEIPT_EVENT_NOT_FOUND" | "TOKENOPS_RECEIPT_EVENT_AMBIGUOUS" | "TOKENOPS_CONTRACT_REVERT" | "TOKENOPS_PAUSED" | "TOKENOPS_ACCESS_DENIED" | "TOKENOPS_OPERATOR_NOT_APPROVED" | "TOKENOPS_INSUFFICIENT_FEE" | "TOKENOPS_INSUFFICIENT_BALANCE" | "TOKENOPS_BATCH_TOO_LARGE" | "TOKENOPS_FEATURE_DISABLED" | "TOKENOPS_TRANSFER_FAILED" | "TOKENOPS_FHE_HANDLE_NOT_ALLOWED" | "TOKENOPS_ALREADY_INITIALIZED" | "TOKENOPS_REENTRANCY" | "TOKENOPS_INVALID_SIGNATURE" | "TOKENOPS_WALLET_REJECTED" | "TOKENOPS_WALLET_CHAIN_MISMATCH" | "TOKENOPS_NETWORK_ERROR" | "TOKENOPS_INSUFFICIENT_GAS_FUNDS" | "TOKENOPS_UNKNOWN_WRITE_FAILURE" | "TOKENOPS_USER_REJECTED" | "TOKENOPS_SIGNING_FAILED" | "TOKENOPS_RELAYER_UNREACHABLE" | "TOKENOPS_ENCRYPTION_FAILED" | "TOKENOPS_DECRYPTION_FAILED" | "TOKENOPS_USER_DECRYPT_NOT_ALLOWED" | "TOKENOPS_VESTING_NOT_FOUND" | "TOKENOPS_NOT_RECIPIENT" | "TOKENOPS_CLAIM_LOCKED" | "TOKENOPS_VESTING_REVOKED" | "TOKENOPS_NOT_REVOCABLE" | "TOKENOPS_VESTING_EXPIRED" | "TOKENOPS_TRANSFER_ALREADY_PENDING" | "TOKENOPS_NO_PENDING_TRANSFER" | "TOKENOPS_NOT_PENDING_RECIPIENT" | "TOKENOPS_TRANSFER_EXPIRED" | "TOKENOPS_ALREADY_CLAIMED" | "TOKENOPS_CLAIM_NOT_STARTED" | "TOKENOPS_CLAIM_WINDOW_CLOSED" | "TOKENOPS_NOT_REGISTERED" | "TOKENOPS_ALREADY_REGISTERED" | "TOKENOPS_SUBWALLETS_NOT_APPROVED" | "TOKENOPS_SINGLETON_NOT_APPROVED" | "TOKENOPS_FAUCET_SUPPLY_EXHAUSTED" | "TOKENOPS_MERKLE_UUPS_UNSUPPORTED" | "TOKENOPS_NON_STOCK_WRAPPER" | "TOKENOPS_UPGRADEABILITY_NOT_ALLOWED" | "TOKENOPS_FEE_COLLECTOR_SELF_ADMINISTERED" | "TOKENOPS_DEDUP_ID_CONSUMED" | "TOKENOPS_SIGNATURE_EXPIRED" | "TOKENOPS_SALT_COLLISION" | "TOKENOPS_PREDICTION_DRIFT";
+export type TokenOpsSdkErrorCode = "TOKENOPS_UNSUPPORTED_CHAIN" | "TOKENOPS_DEPLOYMENT_ADDRESS_UNAVAILABLE" | "TOKENOPS_MISSING_PUBLIC_CLIENT" | "TOKENOPS_MISSING_WALLET_CLIENT" | "TOKENOPS_MISSING_ACCOUNT" | "TOKENOPS_MISSING_ENCRYPTOR" | "TOKENOPS_MISSING_CLIENT" | "TOKENOPS_INVALID_ARGUMENT" | "TOKENOPS_RECEIPT_EVENT_NOT_FOUND" | "TOKENOPS_RECEIPT_EVENT_AMBIGUOUS" | "TOKENOPS_CONTRACT_REVERT" | "TOKENOPS_PAUSED" | "TOKENOPS_ACCESS_DENIED" | "TOKENOPS_OPERATOR_NOT_APPROVED" | "TOKENOPS_INSUFFICIENT_FEE" | "TOKENOPS_INSUFFICIENT_BALANCE" | "TOKENOPS_BATCH_TOO_LARGE" | "TOKENOPS_FEATURE_DISABLED" | "TOKENOPS_TRANSFER_FAILED" | "TOKENOPS_FHE_HANDLE_NOT_ALLOWED" | "TOKENOPS_ALREADY_INITIALIZED" | "TOKENOPS_REENTRANCY" | "TOKENOPS_INVALID_SIGNATURE" | "TOKENOPS_WALLET_REJECTED" | "TOKENOPS_WALLET_CHAIN_MISMATCH" | "TOKENOPS_NETWORK_ERROR" | "TOKENOPS_INSUFFICIENT_GAS_FUNDS" | "TOKENOPS_UNKNOWN_WRITE_FAILURE" | "TOKENOPS_USER_REJECTED" | "TOKENOPS_SIGNING_FAILED" | "TOKENOPS_RELAYER_UNREACHABLE" | "TOKENOPS_ENCRYPTION_FAILED" | "TOKENOPS_DECRYPTION_FAILED" | "TOKENOPS_USER_DECRYPT_NOT_ALLOWED" | "TOKENOPS_VESTING_NOT_FOUND" | "TOKENOPS_NOT_RECIPIENT" | "TOKENOPS_CLAIM_LOCKED" | "TOKENOPS_VESTING_REVOKED" | "TOKENOPS_NOT_REVOCABLE" | "TOKENOPS_VESTING_EXPIRED" | "TOKENOPS_TRANSFER_ALREADY_PENDING" | "TOKENOPS_NO_PENDING_TRANSFER" | "TOKENOPS_NOT_PENDING_RECIPIENT" | "TOKENOPS_TRANSFER_EXPIRED" | "TOKENOPS_ALREADY_CLAIMED" | "TOKENOPS_CLAIM_NOT_STARTED" | "TOKENOPS_CLAIM_WINDOW_CLOSED" | "TOKENOPS_NOT_REGISTERED" | "TOKENOPS_ALREADY_REGISTERED" | "TOKENOPS_SUBWALLETS_NOT_APPROVED" | "TOKENOPS_SINGLETON_NOT_APPROVED" | "TOKENOPS_FAUCET_SUPPLY_EXHAUSTED" | "TOKENOPS_MERKLE_UUPS_UNSUPPORTED" | "TOKENOPS_NON_STOCK_WRAPPER" | "TOKENOPS_UPGRADEABILITY_NOT_ALLOWED" | "TOKENOPS_FEE_COLLECTOR_SELF_ADMINISTERED" | "TOKENOPS_DEDUP_ID_CONSUMED" | "TOKENOPS_SIGNATURE_EXPIRED" | "TOKENOPS_SALT_COLLISION" | "TOKENOPS_PREDICTION_DRIFT" | "TOKENOPS_UNAUTHORIZED_REDIRECT" | "TOKENOPS_GAS_FEE_NOT_ACCEPTED" | "TOKENOPS_UNRECOGNISED_AIRDROP";
 /** @public */
 export interface TokenOpsSdkErrorInit {
     code: TokenOpsSdkErrorCode;