@tokenops/sdk 1.6.0 → 2.0.0-alpha.2

package/dist/chunk-VW356KR3.js

@@ -0,0 +1,688 @@
+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, isAddress, BaseError, ContractFunctionZeroDataError } from 'viem';
+
+// src/fhe-airdrop/constants.ts
+var AIRDROP_CONTRACTS_COMMIT = "7175ac82f467f0f88c05aba1a4536892999b4251";
+var DEPLOYMENT_MODE = { clone: 0, uups: 1 };
+var DEDUP_MODE = { perAddress: 0, perDedupId: 1, both: 2, none: 3 };
+
+// src/fhe-airdrop/errors.ts
+var MerkleUupsUnsupportedError = class extends TokenOpsSdkError {
+  name = "MerkleUupsUnsupportedError";
+  constructor(options) {
+    super(
+      'Merkle campaigns cannot use `mode: "uups"`: the per-account `claimedAmount` mapping occupies an ERC-7201 namespaced slot that an earlier revision typed differently, so an in-place upgrade across that change reinterprets existing storage and can re-open claims that were already settled. Use `mode: "clone"`.',
+      {
+        code: "TOKENOPS_MERKLE_UUPS_UNSUPPORTED",
+        cause: options?.cause,
+        context: { constraint: "merkle-uups-storage-retype" }
+      }
+    );
+  }
+};
+var NonStockWrapperError = class extends TokenOpsSdkError {
+  name = "NonStockWrapperError";
+  constructor(args) {
+    const detail = args?.token ? ` (token: ${args.token})` : "";
+    super(
+      `\`claimAndUnwrap\` is only exact for a stock ERC7984ERC20Wrapper${detail}: it burns from the airdrop instance's pooled wrapper balance, not from a per-claimant sub-balance, so the delivered amount is bounded by the pool's balance rather than by the claimant's own outstanding amount. A hooked or fee-taking wrapper can throw that accounting off, so a claimant can be credited against tokens that are not theirs.`,
+      {
+        code: "TOKENOPS_NON_STOCK_WRAPPER",
+        cause: args?.cause,
+        context: { constraint: "wrapper-unwrap-pool-bound", token: args?.token }
+      }
+    );
+  }
+};
+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) {
+    super(
+      `${args.method}: the predicted address ${args.predictedAddress} already holds code. A ${args.variant} instance address commits only to (implementation, mode, deployer, userSalt) - the params struct is ignored - so this (mode, deployer, userSalt) tuple has already been deployed. Pick a fresh \`userSalt\` for each campaign.`,
+      {
+        code: "TOKENOPS_SALT_COLLISION",
+        cause: args.cause,
+        context: {
+          method: args.method,
+          variant: args.variant,
+          mode: args.mode,
+          deployer: args.deployer,
+          userSalt: args.userSalt,
+          predictedAddress: args.predictedAddress
+        }
+      }
+    );
+  }
+};
+var PredictionDriftError = class extends TokenOpsSdkError {
+  name = "PredictionDriftError";
+  constructor(args) {
+    const where = args.predictedAddress ? ` ${args.predictedAddress}` : "";
+    super(
+      `${args.method}: the factory's ${args.variant} init-code hash changed from ${args.initCodeHashBefore} to ${args.initCodeHashAfter} mid-flight. An implementation rotation landed while the prediction was in use, so the predicted address${where} is stale and anything bound to it (a Merkle campaign's ciphertexts above all) will not match the instance the create produces. Re-predict and rebuild.`,
+      {
+        code: "TOKENOPS_PREDICTION_DRIFT",
+        cause: args.cause,
+        context: {
+          method: args.method,
+          variant: args.variant,
+          initCodeHashBefore: args.initCodeHashBefore,
+          initCodeHashAfter: args.initCodeHashAfter,
+          predictedAddress: args.predictedAddress
+        }
+      }
+    );
+  }
+};
+var UpgradeabilityNotAllowedError = class extends TokenOpsSdkError {
+  name = "UpgradeabilityNotAllowedError";
+  constructor(args) {
+    const label = args.method ? `${args.method}: ` : "";
+    const who = args.creator ? ` for creator ${args.creator}` : "";
+    super(
+      `${label}\`mode: "uups"\` is not permitted${who} \u2014 call \`setDefaultUpgradeable(true)\` or \`setUpgradeabilityPolicy(creator, true)\` (UPGRADE_MANAGER_ROLE), or use \`mode: "clone"\`.`,
+      {
+        code: "TOKENOPS_UPGRADEABILITY_NOT_ALLOWED",
+        cause: args.cause,
+        context: {
+          method: args.method,
+          contractAddress: args.contractAddress,
+          creator: args.creator
+        }
+      }
+    );
+  }
+};
+var FeeCollectorSelfAdministeredError = class extends TokenOpsSdkError {
+  name = "FeeCollectorSelfAdministeredError";
+  constructor(args) {
+    super(
+      "FEE_COLLECTOR_ROLE is self-administered (its own role admin, not DEFAULT_ADMIN_ROLE) \u2014 grantInstanceRoles cannot grant it from the caller's admin role. Have an existing FEE_COLLECTOR_ROLE holder call `grantRole` directly.",
+      {
+        code: "TOKENOPS_FEE_COLLECTOR_SELF_ADMINISTERED",
+        cause: args?.cause,
+        context: { requestedGrantee: args?.requestedGrantee }
+      }
+    );
+  }
+};
+var DedupIdConsumedError = class extends TokenOpsSdkError {
+  name = "DedupIdConsumedError";
+  constructor(args) {
+    const which = args.dedupId ? ` ${args.dedupId}` : "";
+    super(`${args.method}: dedupId${which} has already been claimed.`, {
+      code: "TOKENOPS_DEDUP_ID_CONSUMED",
+      cause: args.cause,
+      context: {
+        method: args.method,
+        contractAddress: args.contractAddress,
+        dedupId: args.dedupId
+      }
+    });
+  }
+};
+var AlreadyClaimedError = class extends TokenOpsSdkError {
+  name = "AlreadyClaimedError";
+  constructor(args) {
+    super(`${args.method}: already claimed (${args.replayGuard} replay guard).`, {
+      code: "TOKENOPS_ALREADY_CLAIMED",
+      cause: args.cause,
+      context: {
+        method: args.method,
+        contractAddress: args.contractAddress,
+        replayGuard: args.replayGuard
+      }
+    });
+  }
+};
+var ClaimNotStartedError = class extends TokenOpsSdkError {
+  name = "ClaimNotStartedError";
+  constructor(args) {
+    const detail = args.startTime !== void 0 ? ` Opens at unix timestamp ${args.startTime}.` : "";
+    super(`${args.method}: the claim window has not opened yet.${detail}`, {
+      code: "TOKENOPS_CLAIM_NOT_STARTED",
+      cause: args.cause,
+      context: {
+        method: args.method,
+        contractAddress: args.contractAddress,
+        startTime: args.startTime,
+        currentTime: args.currentTime
+      }
+    });
+  }
+};
+var SignatureExpiredError = class extends TokenOpsSdkError {
+  name = "SignatureExpiredError";
+  constructor(args) {
+    const detail = args.deadline !== void 0 && args.currentTime !== void 0 ? ` The signature's deadline (unix timestamp ${args.deadline}) has passed; current time is ${args.currentTime}.` : "";
+    super(`${args.method}: signature has expired.${detail} Re-sign with a later deadline.`, {
+      code: "TOKENOPS_SIGNATURE_EXPIRED",
+      cause: args.cause,
+      context: {
+        method: args.method,
+        contractAddress: args.contractAddress,
+        deadline: args.deadline,
+        currentTime: args.currentTime
+      }
+    });
+  }
+};
+var ClaimWindowClosedError = class extends TokenOpsSdkError {
+  name = "ClaimWindowClosedError";
+  constructor(args) {
+    const detail = args.endTime !== void 0 ? ` Closed at unix timestamp ${args.endTime}.` : "";
+    super(`${args.method}: the claim window has closed.${detail}`, {
+      code: "TOKENOPS_CLAIM_WINDOW_CLOSED",
+      cause: args.cause,
+      context: {
+        method: args.method,
+        contractAddress: args.contractAddress,
+        endTime: args.endTime,
+        currentTime: args.currentTime
+      }
+    });
+  }
+};
+var airdropProductMapper = (name, errArgs, ctx) => {
+  switch (name) {
+    // ---- guarded conditions, caught on-chain instead of pre-flight -------
+    case "TokenNotAWrapper": {
+      const token = ctx.productContext?.["token"];
+      return new NonStockWrapperError({ token });
+    }
+    case "UpgradeabilityNotAllowed": {
+      const creator = ctx.productContext?.["creator"];
+      return new UpgradeabilityNotAllowedError({ ...ctx, creator });
+    }
+    // ---- claim lifecycle --------------------------------------------------
+    case "ClaimNotStarted": {
+      const startTime = numberArg(errArgs?.[0]);
+      const currentTime = numberArg(errArgs?.[1]);
+      return new ClaimNotStartedError({ ...ctx, startTime, currentTime });
+    }
+    case "ClaimWindowFinished": {
+      const endTime = numberArg(errArgs?.[0]);
+      const currentTime = numberArg(errArgs?.[1]);
+      return new ClaimWindowClosedError({ ...ctx, endTime, currentTime });
+    }
+    case "AddressAlreadyClaimed":
+      return new AlreadyClaimedError({ ...ctx, replayGuard: "address" });
+    case "SignatureAlreadyUsed":
+      return new AlreadyClaimedError({ ...ctx, replayGuard: "signature" });
+    case "DedupIdAlreadyClaimed": {
+      const dedupId = ctx.productContext?.["dedupId"];
+      return new DedupIdConsumedError({ ...ctx, dedupId });
+    }
+    case "InsufficientFee": {
+      const provided = errArgs?.[0];
+      const required = errArgs?.[1];
+      return new InsufficientFeeError({ ...ctx, feeKind: "gas", provided, required });
+    }
+    case "InsufficientFeeBalance": {
+      const requested = errArgs?.[0];
+      const available = errArgs?.[1];
+      return new InsufficientBalanceError({ ...ctx, balanceKind: "eth", requested, available });
+    }
+    case "EthTransferFailed":
+      return new TransferFailedError({ ...ctx, asset: "eth" });
+    case "HandleNotAllowed": {
+      const handle = errArgs?.[0];
+      return new FheHandleNotAllowedError({ ...ctx, handle });
+    }
+    // ---- Merkle-specific ----------------------------------------------
+    case "InvalidMerkleProof":
+      return new InvalidArgumentError({
+        method: ctx.method,
+        argument: "merkleProof",
+        reason: "the contract reverted with `InvalidMerkleProof` \u2014 the proof does not verify against the current on-chain root. If the root was recently rotated, rebuild the proof against the new root."
+      });
+    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;
+      return new UnsupportedChainError(chainId);
+    }
+    // ---- ECDSA-specific signature reverts --------------------------------
+    case "SignatureExpired": {
+      const deadline = errArgs?.[0];
+      const currentTime = errArgs?.[1];
+      return new SignatureExpiredError({ ...ctx, deadline, currentTime });
+    }
+    // ---- argument-validation bucket: reverts not already covered by the
+    // cross-product default mapper's `Zero*`/`Invalid*` list ---------------
+    case "ZeroToken":
+      return invalidArg(ctx, "token", name);
+    case "ZeroFeeCollector":
+      return invalidArg(
+        ctx,
+        "feeCollector",
+        name,
+        "validates the factory-injected fee-collector init parameter"
+      );
+    case "ZeroComplianceManager":
+      return invalidArg(ctx, "complianceManager", name);
+    case "ZeroRecipient":
+      return invalidArg(ctx, "recipient", name);
+    case "ZeroAdminGrant":
+      return invalidArg(
+        ctx,
+        "admin",
+        name,
+        "granting DEFAULT_ADMIN_ROLE to the zero address is never valid"
+      );
+    case "ZeroFeeCollectorGrant":
+      return invalidArg(
+        ctx,
+        "feeCollector",
+        name,
+        "granting FEE_COLLECTOR_ROLE to the zero address is never valid on a fee-charging campaign"
+      );
+    case "LastAdmin":
+      return invalidArg(
+        ctx,
+        "admin",
+        name,
+        "revoking or renouncing the sole DEFAULT_ADMIN_ROLE member would leave the instance permanently ungovernable"
+      );
+    case "LastFeeCollector":
+      return invalidArg(
+        ctx,
+        "feeCollector",
+        name,
+        "revoking the sole FEE_COLLECTOR_ROLE member would strand accrued claim-fee ETH on a fee-charging campaign"
+      );
+    case "CannotRescueAirdropToken":
+      return invalidArg(ctx, "token", name, "the rescue target cannot be the airdrop's own token");
+    case "TokenNotUnwrappable":
+      return new FeatureDisabledError({ ...ctx, feature: "claimAndUnwrap" });
+    case "ZeroAdmin":
+      return invalidArg(ctx, "admin", name);
+    case "ZeroImplementation":
+      return invalidArg(ctx, "implementation", name);
+    case "ZeroComplianceManagerImpl":
+      return invalidArg(ctx, "complianceManagerImpl", name);
+    case "ZeroComplianceDelegate":
+      return invalidArg(
+        ctx,
+        "complianceDelegate",
+        name,
+        "required while the default compliance-delegate policy is on"
+      );
+    case "IndexOutOfBounds": {
+      const index = errArgs?.[0];
+      const count = errArgs?.[1];
+      return invalidArg(
+        ctx,
+        "index",
+        name,
+        `requested index ${index?.toString() ?? "?"}, but only ${count?.toString() ?? "?"} airdrops exist`
+      );
+    }
+    case "UnknownAirdrop":
+      return invalidArg(ctx, "airdrop", name, "was not created by this factory");
+    case "SaltAlreadyUsed": {
+      const existingAirdrop = errArgs?.[0];
+      return new InvalidArgumentError({
+        method: ctx.method,
+        argument: "userSalt",
+        reason: `this (creator, mode, userSalt) tuple already predicts an existing instance${existingAirdrop ? ` at ${existingAirdrop}` : ""}.`,
+        value: existingAirdrop
+      });
+    }
+    case "ZeroSigner":
+      return invalidArg(ctx, "signer", name);
+    case "ZeroMerkleRoot":
+      return invalidArg(
+        ctx,
+        "merkleRoot",
+        name,
+        "a zero root is only permitted when `isMerkleRootMutable` is true"
+      );
+    // ---- compliance manager clone (`ComplianceRoleManager`) --------------
+    case "ZeroAirdrop":
+      return invalidArg(ctx, "airdrop", name);
+    case "ZeroClientAdmin":
+      return invalidArg(ctx, "clientAdmin", name);
+    case "ZeroDelegate":
+      return invalidArg(ctx, "delegate", name);
+    case "AirdropAndManagerAreSameAddress":
+      return invalidArg(
+        ctx,
+        "airdrop",
+        name,
+        "cannot equal this compliance manager clone's own address"
+      );
+    case "DelegateAndManagerAreSameAddress":
+      return invalidArg(
+        ctx,
+        "delegate",
+        name,
+        "cannot equal this compliance manager clone's own address"
+      );
+    case "DelegateAndAirdropAreSameAddress":
+      return invalidArg(ctx, "delegate", name, "cannot equal the airdrop instance's address");
+    case "DelegateAlreadyAdded":
+      return invalidArg(ctx, "delegate", name, "already an active client delegate");
+    case "DelegateNotFound":
+      return invalidArg(ctx, "delegate", name, "not an active client delegate");
+    case "CannotManageComplianceDelegate":
+      return invalidArg(
+        ctx,
+        "delegate",
+        name,
+        "targets the factory-designated platform compliance delegate, which cannot be managed this way"
+      );
+    default:
+      return void 0;
+  }
+};
+function invalidArg(ctx, argument, revertName, detail) {
+  const suffix = detail ? ` ${detail}.` : "";
+  return new InvalidArgumentError({
+    method: ctx.method,
+    argument,
+    reason: `the contract reverted with \`${revertName}\`.${suffix}`
+  });
+}
+function numberArg(value) {
+  return typeof value === "bigint" ? Number(value) : void 0;
+}
+var SUPPORTED_CHAIN_IDS = [1, 11155111, 31337];
+function assertSupportedChain(chainId) {
+  if (!SUPPORTED_CHAIN_IDS.includes(chainId)) {
+    throw new UnsupportedChainError(chainId);
+  }
+}
+function assertMerkleModeSupported(mode) {
+  if (mode === "uups") {
+    throw new MerkleUupsUnsupportedError();
+  }
+}
+var WRAPPER_PROBE_ABI = [
+  {
+    inputs: [],
+    name: "underlying",
+    outputs: [{ internalType: "address", name: "", type: "address" }],
+    stateMutability: "view",
+    type: "function"
+  }
+];
+function isProbeAnswer(error) {
+  if (isContractRevert(error)) return true;
+  if (!(error instanceof BaseError)) return false;
+  return error.walk((e) => e instanceof ContractFunctionZeroDataError) !== null;
+}
+async function assertStockWrapper(args) {
+  if (!args.unwrappable) return;
+  let underlying;
+  try {
+    underlying = await args.publicClient.readContract({
+      address: args.token,
+      abi: WRAPPER_PROBE_ABI,
+      functionName: "underlying"
+    });
+  } catch (cause) {
+    if (!isProbeAnswer(cause)) throw cause;
+    throw new NonStockWrapperError({ token: args.token, cause });
+  }
+  if (isAddressEqual(underlying, zeroAddress)) {
+    throw new NonStockWrapperError({ token: args.token });
+  }
+}
+async function assertSaltAvailable(args) {
+  const code = await args.publicClient.getCode({ address: args.predictedAddress });
+  if (code === void 0 || code === "0x") return;
+  throw new SaltCollisionError({
+    method: args.method,
+    variant: args.variant,
+    mode: args.mode,
+    deployer: args.deployer,
+    userSalt: args.userSalt,
+    predictedAddress: args.predictedAddress
+  });
+}
+function assertPredictionFresh(args) {
+  if (args.initCodeHashBefore.toLowerCase() === args.initCodeHashAfter.toLowerCase()) return;
+  throw new PredictionDriftError({
+    method: args.method,
+    variant: args.variant,
+    initCodeHashBefore: args.initCodeHashBefore,
+    initCodeHashAfter: args.initCodeHashAfter,
+    predictedAddress: args.predictedAddress
+  });
+}
+async function preflightCreate(args) {
+  const method = args.variant === "merkle" ? "createMerkleAirdrop" : "createEcdsaAirdrop";
+  const blockers = [];
+  collect(blockers, () => assertSupportedChain(args.factory.chainId));
+  if (args.variant === "merkle") {
+    collect(blockers, () => assertMerkleModeSupported(args.mode));
+  }
+  const predictArgs = {
+    mode: args.mode,
+    deployer: args.creator,
+    userSalt: args.userSalt
+  };
+  const predictedAddress = args.variant === "merkle" ? await args.factory.predictMerkleAirdropAddress({ params: args.params, ...predictArgs }) : await args.factory.predictEcdsaAirdropAddress({ params: args.params, ...predictArgs });
+  const liveInitCodeHash = args.variant === "merkle" ? await args.factory.getMerkleInitCodeHash({ params: args.params, mode: args.mode }) : await args.factory.getEcdsaInitCodeHash({ params: args.params, mode: args.mode });
+  if (args.mode === "uups") {
+    const allowed = await args.factory.effectiveUpgradeable(args.creator);
+    if (!allowed) {
+      blockers.push(
+        new UpgradeabilityNotAllowedError({
+          method,
+          contractAddress: args.factory.address,
+          creator: args.creator
+        })
+      );
+    }
+  }
+  await collectAsync(
+    blockers,
+    () => assertStockWrapper({
+      publicClient: args.factory.publicClient,
+      token: args.params.common.token,
+      unwrappable: args.params.common.unwrappable
+    })
+  );
+  await collectAsync(
+    blockers,
+    () => assertSaltAvailable({
+      publicClient: args.factory.publicClient,
+      predictedAddress,
+      variant: args.variant,
+      mode: args.mode,
+      deployer: args.creator,
+      userSalt: args.userSalt,
+      method
+    })
+  );
+  if (args.expectedInitCodeHash !== void 0) {
+    collect(
+      blockers,
+      () => assertPredictionFresh({
+        variant: args.variant,
+        initCodeHashBefore: args.expectedInitCodeHash,
+        initCodeHashAfter: liveInitCodeHash,
+        predictedAddress,
+        method
+      })
+    );
+  }
+  return { ready: blockers.length === 0, blockers };
+}
+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));
+  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 }),
+    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 }));
+  }
+  if (!started) {
+    blockers.push(
+      new ClaimNotStartedError({
+        method,
+        contractAddress: airdrop.address,
+        startTime: await airdrop.startTime()
+      })
+    );
+  }
+  if (ended) {
+    blockers.push(
+      new ClaimWindowClosedError({
+        method,
+        contractAddress: airdrop.address,
+        endTime: await airdrop.endTime()
+      })
+    );
+  }
+  if (balance < fee) {
+    blockers.push(
+      new InsufficientFeeError({
+        method,
+        contractAddress: airdrop.address,
+        feeKind: "gas",
+        provided: balance,
+        required: fee
+      })
+    );
+  }
+  if (args.signature && airdrop.isSignatureValid) {
+    const valid = await airdrop.isSignatureValid({ recipient: claimant, ...args.signature });
+    if (!valid) {
+      blockers.push(new InvalidSignatureError({ method, contractAddress: airdrop.address }));
+    }
+  }
+  return { ready: blockers.length === 0, blockers };
+}
+function collect(blockers, run) {
+  try {
+    run();
+  } catch (err) {
+    if (!isTokenOpsSdkError(err)) throw err;
+    blockers.push(err);
+  }
+}
+async function collectAsync(blockers, run) {
+  try {
+    await run();
+  } catch (err) {
+    if (!isTokenOpsSdkError(err)) throw err;
+    blockers.push(err);
+  }
+}
+
+export { AIRDROP_CONTRACTS_COMMIT, AlreadyClaimedError, ClaimNotStartedError, ClaimWindowClosedError, DEDUP_MODE, DEPLOYMENT_MODE, DedupIdConsumedError, FeeCollectorSelfAdministeredError, MerkleUupsUnsupportedError, NonStockWrapperError, PredictionDriftError, SaltCollisionError, SignatureExpiredError, UnauthorizedRedirectError, UpgradeabilityNotAllowedError, airdropProductMapper, assertMerkleClaimIdentity, assertMerkleModeSupported, assertPredictionFresh, assertSaltAvailable, assertStockWrapper, assertSupportedChain, preflightClaim, preflightCreate };