@tokenops/sdk 1.6.0 → 2.0.0-alpha.2

package/dist/fhe-airdrop/react/index.cjs

@@ -1,679 +1,1469 @@
 'use strict';
 
-var chunkWO72UBQD_cjs = require('../../chunk-WO72UBQD.cjs');
-var chunkSPGSO5SO_cjs = require('../../chunk-SPGSO5SO.cjs');
-var chunkLBWRFZR3_cjs = require('../../chunk-LBWRFZR3.cjs');
-var chunkWOEETTH7_cjs = require('../../chunk-WOEETTH7.cjs');
-var chunkZQUE2B3Q_cjs = require('../../chunk-ZQUE2B3Q.cjs');
-require('../../chunk-4ZCXK4VI.cjs');
-require('../../chunk-SYHNZSZZ.cjs');
-require('../../chunk-FWHYQZ5E.cjs');
-require('../../chunk-43RFBQ73.cjs');
-require('../../chunk-WUXUWTFW.cjs');
-require('../../chunk-VR3FREBX.cjs');
-var chunk2RNW4MIJ_cjs = require('../../chunk-2RNW4MIJ.cjs');
+var chunkIUKKNJ2R_cjs = require('../../chunk-IUKKNJ2R.cjs');
+var chunkEBLBPUPI_cjs = require('../../chunk-EBLBPUPI.cjs');
+var chunkPZZK3O3S_cjs = require('../../chunk-PZZK3O3S.cjs');
+var chunkAREQJHKA_cjs = require('../../chunk-AREQJHKA.cjs');
+require('../../chunk-FAXIIH5R.cjs');
+require('../../chunk-UG5RKLU2.cjs');
+require('../../chunk-MVDQMV25.cjs');
+require('../../chunk-FT5H2Q7Y.cjs');
+require('../../chunk-JK4XMMKM.cjs');
+require('../../chunk-66IHPTOK.cjs');
+var chunk67OV5CX2_cjs = require('../../chunk-67OV5CX2.cjs');
 require('../../chunk-VJKZWYYJ.cjs');
 var reactQuery = require('@tanstack/react-query');
-var wagmi = require('wagmi');
+var react = require('react');
 
-function useConfidentialAirdropFactoryImplementation(options = {}) {
-  const { client, chainId, resolvedAddress } = chunkWO72UBQD_cjs.useMemoFactoryClient(options);
+function useAirdropToken(args) {
+  const { client, chainId } = chunkEBLBPUPI_cjs.useMemoAirdropBaseClient(args);
   return reactQuery.useQuery({
-    queryKey: chunkWO72UBQD_cjs.buildQueryKey("factory:implementation", chainId, resolvedAddress),
-    queryFn: () => client.implementation(),
-    enabled: !!client,
-    staleTime: 0
+    ...args.query,
+    queryKey: chunkEBLBPUPI_cjs.airdropQueryKey({ chainId, address: args.address, fn: "token", args: [] }),
+    queryFn: () => client.token(),
+    enabled: Boolean(client && (args.query?.enabled ?? true))
+  });
+}
+function useAirdropWindow(args) {
+  const { client, chainId } = chunkEBLBPUPI_cjs.useMemoAirdropBaseClient(args);
+  return reactQuery.useQuery({
+    ...args.query,
+    queryKey: chunkEBLBPUPI_cjs.airdropQueryKey({ chainId, address: args.address, fn: "window", args: [] }),
+    queryFn: async () => {
+      const [startTime, endTime, hasStarted, hasEnded, isActive] = await Promise.all([
+        client.startTime(),
+        client.endTime(),
+        client.hasClaimStarted(),
+        client.hasClaimEnded(),
+        client.isClaimWindowActive()
+      ]);
+      return { startTime, endTime, hasStarted, hasEnded, isActive };
+    },
+    enabled: Boolean(client && (args.query?.enabled ?? true))
+  });
+}
+function useAirdropPaused(args) {
+  const { client, chainId } = chunkEBLBPUPI_cjs.useMemoAirdropBaseClient(args);
+  return reactQuery.useQuery({
+    ...args.query,
+    queryKey: chunkEBLBPUPI_cjs.airdropQueryKey({ chainId, address: args.address, fn: "paused", args: [] }),
+    queryFn: () => client.paused(),
+    enabled: Boolean(client && (args.query?.enabled ?? true))
+  });
+}
+function useAirdropGasFee(args) {
+  const { client, chainId } = chunkEBLBPUPI_cjs.useMemoAirdropBaseClient(args);
+  return reactQuery.useQuery({
+    ...args.query,
+    queryKey: chunkEBLBPUPI_cjs.airdropQueryKey({ chainId, address: args.address, fn: "gasFee", args: [] }),
+    queryFn: () => client.gasFee(),
+    enabled: Boolean(client && (args.query?.enabled ?? true))
+  });
+}
+function useAirdropHasRole(args) {
+  const { role, holder, ...base } = args;
+  const { client, chainId } = chunkEBLBPUPI_cjs.useMemoAirdropBaseClient(base);
+  return reactQuery.useQuery({
+    ...args.query,
+    queryKey: chunkEBLBPUPI_cjs.airdropQueryKey({
+      chainId,
+      address: args.address,
+      fn: "hasRole",
+      args: [role, holder]
+    }),
+    queryFn: () => client.hasRole({ role, holder }),
+    enabled: Boolean(client && role && holder && (args.query?.enabled ?? true))
+  });
+}
+function useMerkleRoot(args) {
+  const { client, chainId } = chunkEBLBPUPI_cjs.useMemoMerkleAirdropClient(args);
+  return reactQuery.useQuery({
+    ...args.query,
+    queryKey: chunkEBLBPUPI_cjs.airdropQueryKey({ chainId, address: args.address, fn: "merkleRoot", args: [] }),
+    queryFn: () => client.merkleRoot(),
+    enabled: Boolean(client && (args.query?.enabled ?? true))
+  });
+}
+function useClaimedAmount(args) {
+  const { account, ...base } = args;
+  const { client, chainId } = chunkEBLBPUPI_cjs.useMemoMerkleAirdropClient(base);
+  return reactQuery.useQuery({
+    ...args.query,
+    queryKey: chunkEBLBPUPI_cjs.airdropQueryKey({
+      chainId,
+      address: args.address,
+      fn: "getClaimedAmount",
+      args: [account]
+    }),
+    queryFn: () => client.getClaimedAmount(account),
+    enabled: Boolean(client && account && (args.query?.enabled ?? true))
+  });
+}
+function useComplianceManager(args) {
+  const { client, chainId } = chunkEBLBPUPI_cjs.useMemoAirdropBaseClient(args);
+  return reactQuery.useQuery({
+    ...args.query,
+    queryKey: chunkEBLBPUPI_cjs.airdropQueryKey({
+      chainId,
+      address: args.address,
+      fn: "complianceManager",
+      args: []
+    }),
+    queryFn: () => client.complianceManager(),
+    enabled: Boolean(client && (args.query?.enabled ?? true))
+  });
+}
+function useFactoryFees(args = {}) {
+  const { client, chainId, resolvedAddress } = chunkEBLBPUPI_cjs.useMemoAirdropFactoryClient(args);
+  return reactQuery.useQuery({
+    ...args.query,
+    queryKey: chunkEBLBPUPI_cjs.airdropQueryKey({ chainId, address: resolvedAddress, fn: "fees", args: [] }),
+    queryFn: async () => {
+      const [feeCollector, defaultGasFee] = await Promise.all([
+        client.feeCollector(),
+        client.defaultGasFee()
+      ]);
+      return { feeCollector, defaultGasFee };
+    },
+    enabled: Boolean(client && (args.query?.enabled ?? true))
+  });
+}
+function useFactoryRegistry(args = {}) {
+  const { offset = 0n, limit = 50n, ...base } = args;
+  const { client, chainId, resolvedAddress } = chunkEBLBPUPI_cjs.useMemoAirdropFactoryClient(base);
+  return reactQuery.useQuery({
+    ...args.query,
+    queryKey: chunkEBLBPUPI_cjs.airdropQueryKey({
+      chainId,
+      address: resolvedAddress,
+      fn: "registry",
+      args: [offset, limit]
+    }),
+    queryFn: async () => {
+      const [count, items] = await Promise.all([
+        client.airdropCount(),
+        client.airdrops(offset, limit)
+      ]);
+      return { count, items };
+    },
+    enabled: Boolean(client && (args.query?.enabled ?? true))
+  });
+}
+function useEffectiveUpgradeable(args = {}) {
+  const { creator, ...base } = args;
+  const { client, chainId, resolvedAddress } = chunkEBLBPUPI_cjs.useMemoAirdropFactoryClient(base);
+  return reactQuery.useQuery({
+    ...args.query,
+    queryKey: chunkEBLBPUPI_cjs.airdropQueryKey({
+      chainId,
+      address: resolvedAddress,
+      fn: "effectiveUpgradeable",
+      args: [creator]
+    }),
+    queryFn: () => client.effectiveUpgradeable(creator),
+    enabled: Boolean(client && creator && (args.query?.enabled ?? true))
   });
 }
-function useFactoryDefaultGasFee(options = {}) {
-  const { client, chainId, resolvedAddress } = chunkWO72UBQD_cjs.useMemoFactoryClient(options);
+function useAirdropConfig(args) {
+  const { client, chainId } = chunkEBLBPUPI_cjs.useMemoAirdropBaseClient(args);
   return reactQuery.useQuery({
-    queryKey: chunkWO72UBQD_cjs.buildQueryKey("factory:defaultGasFee", chainId, resolvedAddress),
-    queryFn: () => client.defaultGasFee(),
-    enabled: !!client,
-    staleTime: 0
+    staleTime: Infinity,
+    ...args.query,
+    queryKey: chunkEBLBPUPI_cjs.airdropKeys.config({ chainId, address: args.address }),
+    queryFn: async () => {
+      const [token, airdropType, unwrappable, complianceManager, gasFee] = await Promise.all([
+        client.token(),
+        client.airdropType(),
+        client.unwrappable(),
+        client.complianceManager(),
+        client.gasFee()
+      ]);
+      return {
+        token,
+        airdropType,
+        variant: airdropType === 1 ? "merkle" : "ecdsa",
+        unwrappable,
+        complianceManager,
+        gasFee
+      };
+    },
+    enabled: Boolean(client && (args.query?.enabled ?? true))
   });
 }
-function useFactoryFeeCollector(options = {}) {
-  const { client, chainId, resolvedAddress } = chunkWO72UBQD_cjs.useMemoFactoryClient(options);
+function useAirdropDeploymentMode(args) {
+  const { client, chainId } = chunkEBLBPUPI_cjs.useMemoAirdropBaseClient(args);
   return reactQuery.useQuery({
-    queryKey: chunkWO72UBQD_cjs.buildQueryKey("factory:feeCollector", chainId, resolvedAddress),
-    queryFn: () => client.feeCollector(),
-    enabled: !!client,
-    staleTime: 0
+    staleTime: Infinity,
+    ...args.query,
+    queryKey: chunkEBLBPUPI_cjs.airdropQueryKey({
+      chainId,
+      address: args.address,
+      fn: "deploymentMode",
+      args: []
+    }),
+    queryFn: () => client.deploymentMode(),
+    enabled: Boolean(client && (args.query?.enabled ?? true))
+  });
+}
+function useAirdropRoleAdmin(args) {
+  const { role, ...base } = args;
+  const { client, chainId } = chunkEBLBPUPI_cjs.useMemoAirdropBaseClient(base);
+  return reactQuery.useQuery({
+    // A default, not a lock: `query.staleTime` still wins.
+    staleTime: Infinity,
+    ...args.query,
+    queryKey: chunkEBLBPUPI_cjs.airdropQueryKey({
+      chainId,
+      address: args.address,
+      fn: "getRoleAdmin",
+      args: [role]
+    }),
+    queryFn: () => client.getRoleAdmin(role),
+    enabled: Boolean(client && role && (args.query?.enabled ?? true))
+  });
+}
+function useAirdropRoleConstants(args) {
+  const { variant, dedupMode, ...base } = args;
+  const { client, chainId } = chunkEBLBPUPI_cjs.useMemoAirdropBaseClient(base);
+  const { client: merkleClient } = chunkEBLBPUPI_cjs.useMemoMerkleAirdropClient(base);
+  const { client: ecdsaClient } = chunkEBLBPUPI_cjs.useMemoEcdsaAirdropClient({
+    ...base,
+    dedupMode: dedupMode ?? "none"
+  });
+  return reactQuery.useQuery({
+    // A default, not a lock: `query.staleTime` still wins if a consumer wants refetching.
+    staleTime: Infinity,
+    ...args.query,
+    // `variant` is in the key because it changes the SHAPE of the result -
+    // the merkle and ecdsa responses must not share a cache slot.
+    queryKey: chunkEBLBPUPI_cjs.airdropQueryKey({
+      chainId,
+      address: args.address,
+      fn: "roleConstants",
+      args: [variant]
+    }),
+    queryFn: async () => {
+      const [
+        PAUSER_ROLE,
+        WINDOW_ADMIN_ROLE,
+        TREASURY_ROLE,
+        RESCUER_ROLE,
+        FEE_COLLECTOR_ROLE,
+        UPGRADER_ROLE,
+        DISCLOSURE_ADMIN_ROLE,
+        DEFAULT_ADMIN_ROLE,
+        variantRole
+      ] = await Promise.all([
+        client.PAUSER_ROLE(),
+        client.WINDOW_ADMIN_ROLE(),
+        client.TREASURY_ROLE(),
+        client.RESCUER_ROLE(),
+        client.FEE_COLLECTOR_ROLE(),
+        client.UPGRADER_ROLE(),
+        client.DISCLOSURE_ADMIN_ROLE(),
+        client.DEFAULT_ADMIN_ROLE(),
+        variant === "merkle" ? merkleClient.MERKLE_ADMIN_ROLE() : variant === "ecdsa" ? ecdsaClient.SIGNER_ROLE() : Promise.resolve(void 0)
+      ]);
+      return {
+        PAUSER_ROLE,
+        WINDOW_ADMIN_ROLE,
+        TREASURY_ROLE,
+        RESCUER_ROLE,
+        FEE_COLLECTOR_ROLE,
+        UPGRADER_ROLE,
+        DISCLOSURE_ADMIN_ROLE,
+        DEFAULT_ADMIN_ROLE,
+        ...variant === "merkle" && variantRole ? { MERKLE_ADMIN_ROLE: variantRole } : {},
+        ...variant === "ecdsa" && variantRole ? { SIGNER_ROLE: variantRole } : {}
+      };
+    },
+    enabled: Boolean(client && (args.query?.enabled ?? true))
+  });
+}
+function useAirdropRoleMembers(args) {
+  const { role, ...base } = args;
+  const { client, chainId } = chunkEBLBPUPI_cjs.useMemoAirdropBaseClient(base);
+  return reactQuery.useQuery({
+    ...args.query,
+    queryKey: chunkEBLBPUPI_cjs.airdropKeys.roleMembers({ chainId, address: args.address }, role),
+    queryFn: async () => {
+      const [members, count] = await Promise.all([
+        client.getRoleMembers(role),
+        client.getRoleMemberCount(role)
+      ]);
+      return { members, count };
+    },
+    enabled: Boolean(client && role && (args.query?.enabled ?? true))
+  });
+}
+function useComplianceHasRole(args) {
+  const { role, holder, ...base } = args;
+  const { client, chainId } = chunkEBLBPUPI_cjs.useMemoComplianceManagerClient(base);
+  return reactQuery.useQuery({
+    ...args.query,
+    queryKey: chunkEBLBPUPI_cjs.airdropKeys.complianceHasRole({ chainId, address: args.address }, role, holder),
+    queryFn: () => client.hasRole({ role, holder }),
+    enabled: Boolean(client && role && holder && (args.query?.enabled ?? true))
+  });
+}
+function useComplianceInfo(args) {
+  const { client, chainId } = chunkEBLBPUPI_cjs.useMemoComplianceManagerClient(args);
+  return reactQuery.useQuery({
+    ...args.query,
+    queryKey: chunkEBLBPUPI_cjs.airdropKeys.complianceInfo({ chainId, address: args.address }),
+    queryFn: async () => {
+      const [airdrop, platformDelegate, clientDelegates] = await Promise.all([
+        client.airdrop(),
+        client.complianceDelegate(),
+        client.clientDelegates()
+      ]);
+      return { airdrop, platformDelegate, clientDelegates };
+    },
+    enabled: Boolean(client && (args.query?.enabled ?? true))
   });
 }
-function useFactoryCustomFee(args = {}) {
+function useComplianceManagerOf(args = {}) {
+  const { airdrop, ...base } = args;
+  const { client, chainId, resolvedAddress } = chunkEBLBPUPI_cjs.useMemoAirdropFactoryClient(base);
+  return reactQuery.useQuery({
+    staleTime: Infinity,
+    ...args.query,
+    queryKey: chunkEBLBPUPI_cjs.airdropQueryKey({
+      chainId,
+      address: resolvedAddress,
+      fn: "complianceManagerOf",
+      args: [airdrop]
+    }),
+    queryFn: () => client.complianceManagerOf(airdrop),
+    enabled: Boolean(client && airdrop && (args.query?.enabled ?? true))
+  });
+}
+function useComplianceRoleConstants(args) {
+  const { client, chainId } = chunkEBLBPUPI_cjs.useMemoComplianceManagerClient(args);
+  return reactQuery.useQuery({
+    // A default, not a lock: `query.staleTime` still wins.
+    staleTime: Infinity,
+    ...args.query,
+    queryKey: chunkEBLBPUPI_cjs.airdropQueryKey({
+      chainId,
+      address: args.address,
+      fn: "complianceRoleConstants",
+      args: []
+    }),
+    queryFn: async () => {
+      const [DELEGATION_ADMIN_ROLE, DEFAULT_ADMIN_ROLE] = await Promise.all([
+        client.DELEGATION_ADMIN_ROLE(),
+        client.DEFAULT_ADMIN_ROLE()
+      ]);
+      return { DELEGATION_ADMIN_ROLE, DEFAULT_ADMIN_ROLE };
+    },
+    enabled: Boolean(client && (args.query?.enabled ?? true))
+  });
+}
+function useComplianceRoleMembers(args) {
+  const { role, ...base } = args;
+  const { client, chainId } = chunkEBLBPUPI_cjs.useMemoComplianceManagerClient(base);
+  return reactQuery.useQuery({
+    ...args.query,
+    queryKey: chunkEBLBPUPI_cjs.airdropKeys.complianceRoleMembers({ chainId, address: args.address }, role),
+    queryFn: async () => {
+      const [members, count] = await Promise.all([
+        client.getRoleMembers(role),
+        client.getRoleMemberCount(role)
+      ]);
+      return { members, count };
+    },
+    enabled: Boolean(client && role && (args.query?.enabled ?? true))
+  });
+}
+function useEcdsaDomain(args) {
+  const { client, chainId } = chunkEBLBPUPI_cjs.useMemoEcdsaAirdropClient(args);
+  return reactQuery.useQuery({
+    staleTime: Infinity,
+    ...args.query,
+    // `dedupMode` is a client-construction concern only; it moves no value
+    // read here, so it stays out of the key.
+    queryKey: chunkEBLBPUPI_cjs.airdropQueryKey({ chainId, address: args.address, fn: "ecdsaDomain", args: [] }),
+    queryFn: async () => {
+      const [claimTypehash, domainSeparator, domain] = await Promise.all([
+        client.claimTypehash(),
+        client.domainSeparator(),
+        client.eip712Domain()
+      ]);
+      return { claimTypehash, domainSeparator, domain };
+    },
+    enabled: Boolean(client && (args.query?.enabled ?? true))
+  });
+}
+function useEffectiveDelegateToCompliance(args = {}) {
   const { creator, ...base } = args;
-  const { client, chainId, resolvedAddress } = chunkWO72UBQD_cjs.useMemoFactoryClient(base);
+  const { client, chainId, resolvedAddress } = chunkEBLBPUPI_cjs.useMemoAirdropFactoryClient(base);
   return reactQuery.useQuery({
-    queryKey: chunkWO72UBQD_cjs.buildQueryKey("factory:getCustomFee", chainId, resolvedAddress, creator),
-    queryFn: () => client.getCustomFee(creator),
-    enabled: !!client && !!creator,
-    staleTime: 0
+    ...args.query,
+    queryKey: chunkEBLBPUPI_cjs.airdropQueryKey({
+      chainId,
+      address: resolvedAddress,
+      fn: "effectiveDelegateToCompliance",
+      args: [creator]
+    }),
+    queryFn: () => client.effectiveDelegateToCompliance(creator),
+    enabled: Boolean(client && creator && (args.query?.enabled ?? true))
   });
 }
-function useFactoryInitCodeHash(args = {}) {
-  const { params, gasFee, ...base } = args;
-  const { client, chainId, resolvedAddress } = chunkWO72UBQD_cjs.useMemoFactoryClient(base);
+function useIsActiveDelegate(args) {
+  const { delegate, ...base } = args;
+  const { client, chainId } = chunkEBLBPUPI_cjs.useMemoComplianceManagerClient(base);
   return reactQuery.useQuery({
-    queryKey: chunkWO72UBQD_cjs.buildQueryKey("factory:getInitCodeHash", chainId, resolvedAddress, params, gasFee),
-    queryFn: () => client.getInitCodeHash({ params, gasFee }),
-    enabled: !!client && !!params && gasFee !== void 0,
-    staleTime: 0
+    ...args.query,
+    queryKey: chunkEBLBPUPI_cjs.airdropKeys.activeDelegate({ chainId, address: args.address }, delegate),
+    queryFn: () => client.isActiveDelegate(delegate),
+    enabled: Boolean(client && delegate && (args.query?.enabled ?? true))
+  });
+}
+function useIsMerkleRootMutable(args) {
+  const { client, chainId } = chunkEBLBPUPI_cjs.useMemoMerkleAirdropClient(args);
+  return reactQuery.useQuery({
+    // Before the spread so a consumer can still opt into refetching.
+    staleTime: Infinity,
+    ...args.query,
+    queryKey: chunkEBLBPUPI_cjs.airdropKeys.merkleRootMutable({ chainId, address: args.address }),
+    queryFn: () => client.isMerkleRootMutable(),
+    enabled: Boolean(client && (args.query?.enabled ?? true))
+  });
+}
+function useIsSignatureValid(args) {
+  const { recipient, encryptedAmountHandle, dedupId, deadline, signer, signature, ...base } = args;
+  const { client, chainId } = chunkEBLBPUPI_cjs.useMemoEcdsaAirdropClient(base);
+  return reactQuery.useQuery({
+    ...args.query,
+    queryKey: chunkEBLBPUPI_cjs.airdropQueryKey({
+      chainId,
+      address: args.address,
+      fn: chunkEBLBPUPI_cjs.AIRDROP_FN.isSignatureValid,
+      args: [recipient, encryptedAmountHandle, dedupId, deadline, signer, signature]
+    }),
+    queryFn: () => client.isSignatureValid({
+      recipient,
+      encryptedAmountHandle,
+      dedupId,
+      deadline,
+      signer,
+      signature
+    }),
+    enabled: Boolean(
+      client && recipient && encryptedAmountHandle && dedupId && deadline !== void 0 && signer && signature && (args.query?.enabled ?? true)
+    )
+  });
+}
+function usePreflightClaim(args) {
+  const { variant, dedupMode, claimant, account, to, entrypoint, signature, ...base } = args;
+  const { client: merkleClient, chainId } = chunkEBLBPUPI_cjs.useMemoMerkleAirdropClient(base);
+  const { client: ecdsaClient } = chunkEBLBPUPI_cjs.useMemoEcdsaAirdropClient({
+    ...base,
+    dedupMode: dedupMode ?? "none"
+  });
+  const client = variant === "ecdsa" ? ecdsaClient : merkleClient;
+  return reactQuery.useQuery({
+    ...args.query,
+    queryKey: chunkEBLBPUPI_cjs.airdropQueryKey({
+      chainId,
+      address: args.address,
+      fn: "preflightClaim",
+      args: [variant, claimant, account, to, entrypoint, signature]
+    }),
+    queryFn: () => chunkAREQJHKA_cjs.preflightClaim({
+      airdrop: client,
+      claimant,
+      account,
+      to,
+      entrypoint,
+      signature
+    }),
+    enabled: Boolean(client && claimant && (args.query?.enabled ?? true))
   });
 }
 function usePreflightCreateAirdrop(args = {}) {
-  const { params, creator, userSalt, funding, ...base } = args;
-  const { client, chainId, resolvedAddress } = chunkWO72UBQD_cjs.useMemoFactoryClient(base);
+  const { client, chainId, resolvedAddress } = chunkEBLBPUPI_cjs.useMemoAirdropFactoryClient(args);
   return reactQuery.useQuery({
-    queryKey: chunkWO72UBQD_cjs.buildQueryKey(
-      "factory:preflightCreateAirdrop",
+    ...args.query,
+    queryKey: chunkEBLBPUPI_cjs.airdropQueryKey({
       chainId,
-      resolvedAddress,
-      creator,
-      params,
-      userSalt,
-      funding
-    ),
-    queryFn: () => client.preflightCreateAirdrop({
-      params,
-      creator,
-      ...userSalt !== void 0 ? { userSalt } : {},
-      ...funding !== void 0 ? { funding } : {}
+      address: resolvedAddress,
+      fn: chunkEBLBPUPI_cjs.AIRDROP_FN.preflightCreate,
+      args: [
+        args.variant,
+        args.mode,
+        args.creator,
+        args.userSalt,
+        args.expectedInitCodeHash,
+        // `params` IS key-affecting here, unlike in the predict hooks: the
+        // stock-wrapper probe reads `common.token` / `common.unwrappable`.
+        args.params
+      ]
     }),
-    enabled: !!client && !!params && !!creator,
-    staleTime: 0
+    queryFn: () => {
+      const common = {
+        factory: client,
+        mode: args.mode,
+        creator: args.creator,
+        userSalt: args.userSalt,
+        expectedInitCodeHash: args.expectedInitCodeHash
+      };
+      return args.variant === "merkle" ? chunkAREQJHKA_cjs.preflightCreate({ ...common, variant: "merkle", params: args.params }) : chunkAREQJHKA_cjs.preflightCreate({ ...common, variant: "ecdsa", params: args.params });
+    },
+    enabled: Boolean(
+      client && args.variant && args.params && args.mode && args.creator && args.userSalt && (args.query?.enabled ?? true)
+    )
   });
 }
-function useCreateConfidentialAirdropAndGetAddress(options = {}) {
-  const { client, resolutionError } = chunkWO72UBQD_cjs.useMemoFactoryClient(options);
+function useCreateEcdsaAirdrop(options = {}) {
+  const { client, resolutionError, chainId, resolvedAddress } = chunkEBLBPUPI_cjs.useMemoAirdropFactoryClient(options);
+  const queryClient = reactQuery.useQueryClient();
   return reactQuery.useMutation({
     mutationFn: async (args) => {
       if (!client) {
-        throw resolutionError ?? new chunk2RNW4MIJ_cjs.MissingClientError("useCreateConfidentialAirdropAndGetAddress", "factory");
+        throw resolutionError ?? new chunk67OV5CX2_cjs.MissingClientError("useCreateEcdsaAirdrop", "factory");
       }
-      return client.createConfidentialAirdropAndGetAddress(args);
+      return client.createEcdsaAirdrop(args);
+    },
+    onSuccess: () => {
+      void queryClient.invalidateQueries({
+        queryKey: chunkEBLBPUPI_cjs.airdropQueryKeyPrefix({ chainId, address: resolvedAddress, fn: "registry" })
+      });
     }
   });
 }
-function useCreateConfidentialAirdrop(options = {}) {
-  const { client, resolutionError } = chunkWO72UBQD_cjs.useMemoFactoryClient(options);
+function useCreateMerkleAirdrop(options = {}) {
+  const { client, resolutionError, chainId, resolvedAddress } = chunkEBLBPUPI_cjs.useMemoAirdropFactoryClient(options);
+  const queryClient = reactQuery.useQueryClient();
   return reactQuery.useMutation({
     mutationFn: async (args) => {
       if (!client) {
-        throw resolutionError ?? new chunk2RNW4MIJ_cjs.MissingClientError("useCreateConfidentialAirdrop", "factory");
+        throw resolutionError ?? new chunk67OV5CX2_cjs.MissingClientError("useCreateMerkleAirdrop", "factory");
       }
-      return client.createConfidentialAirdrop(args);
+      return client.createMerkleAirdrop(args);
+    },
+    onSuccess: () => {
+      void queryClient.invalidateQueries({
+        queryKey: chunkEBLBPUPI_cjs.airdropQueryKeyPrefix({ chainId, address: resolvedAddress, fn: "registry" })
+      });
     }
   });
 }
-function useCreateAndFundConfidentialAirdrop(options = {}) {
-  const { client, resolutionError } = chunkWO72UBQD_cjs.useMemoFactoryClient(options);
+function useFundAirdrop(options = {}) {
+  const { client, resolutionError } = chunkEBLBPUPI_cjs.useMemoAirdropFactoryClient(options);
   return reactQuery.useMutation({
     mutationFn: async (args) => {
       if (!client) {
-        throw resolutionError ?? new chunk2RNW4MIJ_cjs.MissingClientError("useCreateAndFundConfidentialAirdrop", "factory");
+        throw resolutionError ?? new chunk67OV5CX2_cjs.MissingClientError("useFundAirdrop", "factory");
       }
-      return client.createAndFundConfidentialAirdrop(args);
+      return client.fundAirdrop(args);
     }
   });
 }
-function useCreateAndFundConfidentialAirdropAndGetAddress(options = {}) {
-  const { client, resolutionError } = chunkWO72UBQD_cjs.useMemoFactoryClient(options);
+function useEcdsaClaim(options) {
+  const { client, chainId } = chunkEBLBPUPI_cjs.useMemoEcdsaAirdropClient(options);
+  const queryClient = reactQuery.useQueryClient();
   return reactQuery.useMutation({
     mutationFn: async (args) => {
       if (!client) {
-        throw resolutionError ?? new chunk2RNW4MIJ_cjs.MissingClientError("useCreateAndFundConfidentialAirdropAndGetAddress", "factory");
+        throw new chunk67OV5CX2_cjs.MissingClientError("useEcdsaClaim", "ecdsa-airdrop");
       }
-      return client.createAndFundConfidentialAirdropAndGetAddress(args);
+      return client.claim(args);
+    },
+    onSuccess: () => {
+      void queryClient.invalidateQueries({
+        queryKey: chunkEBLBPUPI_cjs.airdropKeys.isSignatureValidAll({ chainId, address: options.address })
+      });
     }
   });
 }
-function useFundConfidentialAirdrop(options = {}) {
-  const { client, resolutionError } = chunkWO72UBQD_cjs.useMemoFactoryClient(options);
+function useMerkleClaim(options) {
+  const { client, chainId } = chunkEBLBPUPI_cjs.useMemoMerkleAirdropClient(options);
+  const queryClient = reactQuery.useQueryClient();
   return reactQuery.useMutation({
     mutationFn: async (args) => {
       if (!client) {
-        throw resolutionError ?? new chunk2RNW4MIJ_cjs.MissingClientError("useFundConfidentialAirdrop", "factory");
+        throw new chunk67OV5CX2_cjs.MissingClientError("useMerkleClaim", "merkle-airdrop");
       }
-      return client.fundConfidentialAirdrop(args);
+      return client.claim(args);
+    },
+    onMutate: (variables) => ({ account: variables.entry.account }),
+    onSuccess: (_hash, _variables, context) => {
+      if (!context?.account) return;
+      void queryClient.invalidateQueries({
+        queryKey: chunkEBLBPUPI_cjs.airdropQueryKey({
+          chainId,
+          address: options.address,
+          fn: "getClaimedAmount",
+          args: [context.account]
+        })
+      });
     }
   });
 }
-function useSetFeeCollector(options = {}) {
-  const { client, resolutionError } = chunkWO72UBQD_cjs.useMemoFactoryClient(options);
+function useSetMerkleRoot(options) {
+  const { client, chainId } = chunkEBLBPUPI_cjs.useMemoMerkleAirdropClient(options);
+  const queryClient = reactQuery.useQueryClient();
   return reactQuery.useMutation({
-    mutationFn: async ({ newFeeCollector, account }) => {
-      if (!client) throw resolutionError ?? new chunk2RNW4MIJ_cjs.MissingClientError("useSetFeeCollector", "factory");
-      return client.setFeeCollector(newFeeCollector, account);
+    mutationFn: async (args) => {
+      if (!client) {
+        throw new chunk67OV5CX2_cjs.MissingClientError("useSetMerkleRoot", "merkle-airdrop");
+      }
+      return client.setMerkleRoot(args);
+    },
+    onSuccess: () => {
+      void queryClient.invalidateQueries({
+        queryKey: chunkEBLBPUPI_cjs.airdropQueryKey({
+          chainId,
+          address: options.address,
+          fn: "merkleRoot",
+          args: []
+        })
+      });
     }
   });
 }
-function useSetDefaultGasFee(options = {}) {
-  const { client, resolutionError } = chunkWO72UBQD_cjs.useMemoFactoryClient(options);
+function useGrantInstanceRoles(options) {
+  const { client, chainId } = chunkEBLBPUPI_cjs.useMemoAirdropBaseClient(options);
+  const queryClient = reactQuery.useQueryClient();
   return reactQuery.useMutation({
-    mutationFn: async ({ newGasFee, account }) => {
-      if (!client)
-        throw resolutionError ?? new chunk2RNW4MIJ_cjs.MissingClientError("useSetDefaultGasFee", "factory");
-      return client.setDefaultGasFee(newGasFee, account);
+    mutationFn: async (args) => {
+      if (!client) {
+        throw new chunk67OV5CX2_cjs.MissingClientError("useGrantInstanceRoles", "airdrop-base");
+      }
+      return chunkIUKKNJ2R_cjs.grantInstanceRoles({
+        airdrop: client,
+        assignment: args.assignment,
+        ...args.revokeFromCreator !== void 0 ? { revokeFromCreator: args.revokeFromCreator } : {}
+      });
+    },
+    onSuccess: () => {
+      const scope = { chainId, address: options.address };
+      void queryClient.invalidateQueries({ queryKey: chunkEBLBPUPI_cjs.airdropKeys.hasRoleAll(scope) });
+      void queryClient.invalidateQueries({ queryKey: chunkEBLBPUPI_cjs.airdropKeys.roleMembersAll(scope) });
     }
   });
 }
-function useSetCustomFee(options = {}) {
-  const { client, resolutionError } = chunkWO72UBQD_cjs.useMemoFactoryClient(options);
+function useAirdropPause(options) {
+  const { client, chainId } = chunkEBLBPUPI_cjs.useMemoAirdropBaseClient(options);
+  const queryClient = reactQuery.useQueryClient();
   return reactQuery.useMutation({
-    mutationFn: async ({ campaignCreator, gasFee, account }) => {
-      if (!client) throw resolutionError ?? new chunk2RNW4MIJ_cjs.MissingClientError("useSetCustomFee", "factory");
-      return client.setCustomFee(campaignCreator, gasFee, account);
+    mutationFn: async ({ paused, ...rest }) => {
+      if (!client) {
+        throw new chunk67OV5CX2_cjs.MissingClientError("useAirdropPause", "airdrop-base");
+      }
+      return paused ? client.pause(rest) : client.unpause(rest);
+    },
+    onSuccess: () => {
+      void queryClient.invalidateQueries({
+        queryKey: chunkEBLBPUPI_cjs.airdropQueryKey({ chainId, address: options.address, fn: "paused", args: [] })
+      });
+      void queryClient.invalidateQueries({
+        queryKey: chunkEBLBPUPI_cjs.airdropQueryKey({ chainId, address: options.address, fn: "window", args: [] })
+      });
     }
   });
 }
-function useDisableCustomFee(options = {}) {
-  const { client, resolutionError } = chunkWO72UBQD_cjs.useMemoFactoryClient(options);
+function useExtendClaimWindow(options) {
+  const { client, chainId } = chunkEBLBPUPI_cjs.useMemoAirdropBaseClient(options);
+  const queryClient = reactQuery.useQueryClient();
   return reactQuery.useMutation({
-    mutationFn: async ({ campaignCreator, account }) => {
-      if (!client)
-        throw resolutionError ?? new chunk2RNW4MIJ_cjs.MissingClientError("useDisableCustomFee", "factory");
-      return client.disableCustomFee(campaignCreator, account);
+    mutationFn: async (args) => {
+      if (!client) {
+        throw new chunk67OV5CX2_cjs.MissingClientError("useExtendClaimWindow", "airdrop-base");
+      }
+      return client.extendClaimWindow(args);
+    },
+    onSuccess: () => {
+      void queryClient.invalidateQueries({
+        queryKey: chunkEBLBPUPI_cjs.airdropQueryKey({ chainId, address: options.address, fn: "window", args: [] })
+      });
     }
   });
 }
-function useAirdropToken(options) {
-  const { client, chainId } = chunkWO72UBQD_cjs.useMemoAirdropClient(options);
-  return reactQuery.useQuery({
-    queryKey: chunkWO72UBQD_cjs.buildQueryKey("airdrop:TOKEN", chainId, options.address),
-    queryFn: () => client.token(),
-    enabled: !!client,
-    staleTime: 0
+function useWithdrawConfidential(options) {
+  const { client } = chunkEBLBPUPI_cjs.useMemoAirdropBaseClient(options);
+  return reactQuery.useMutation({
+    mutationFn: async (args) => {
+      if (!client) {
+        throw new chunk67OV5CX2_cjs.MissingClientError("useWithdrawConfidential", "airdrop-base");
+      }
+      return client.withdrawConfidential(args);
+    }
   });
 }
-function useAirdropGasFee(options) {
-  const { client, chainId } = chunkWO72UBQD_cjs.useMemoAirdropClient(options);
-  return reactQuery.useQuery({
-    queryKey: chunkWO72UBQD_cjs.buildQueryKey("airdrop:GAS_FEE", chainId, options.address),
-    queryFn: () => client.gasFee(),
-    enabled: !!client,
-    staleTime: 0
+function useAddComplianceDelegate(options) {
+  const { client, chainId } = chunkEBLBPUPI_cjs.useMemoComplianceManagerClient(options);
+  const queryClient = reactQuery.useQueryClient();
+  return reactQuery.useMutation({
+    mutationFn: async (args) => {
+      if (!client) {
+        throw new chunk67OV5CX2_cjs.MissingClientError("useAddComplianceDelegate", "compliance-manager");
+      }
+      return client.addDelegate(args);
+    },
+    onSuccess: (_hash, variables) => {
+      const scope = { chainId, address: options.address };
+      void queryClient.invalidateQueries({ queryKey: chunkEBLBPUPI_cjs.airdropKeys.complianceInfo(scope) });
+      void queryClient.invalidateQueries({
+        queryKey: chunkEBLBPUPI_cjs.airdropKeys.activeDelegate(scope, variables.delegate)
+      });
+    }
   });
 }
-function useAirdropStartTime(options) {
-  const { client, chainId } = chunkWO72UBQD_cjs.useMemoAirdropClient(options);
-  return reactQuery.useQuery({
-    queryKey: chunkWO72UBQD_cjs.buildQueryKey("airdrop:START_TIME", chainId, options.address),
-    queryFn: () => client.startTime(),
-    enabled: !!client,
-    staleTime: 0
+function useAirdropGrantRole(options) {
+  const { client, chainId } = chunkEBLBPUPI_cjs.useMemoAirdropBaseClient(options);
+  const queryClient = reactQuery.useQueryClient();
+  return reactQuery.useMutation({
+    mutationFn: async (args) => {
+      if (!client) {
+        throw new chunk67OV5CX2_cjs.MissingClientError("useAirdropGrantRole", "airdrop-base");
+      }
+      return client.grantRole(args);
+    },
+    onSuccess: (_hash, variables) => {
+      const scope = { chainId, address: options.address };
+      void queryClient.invalidateQueries({
+        queryKey: chunkEBLBPUPI_cjs.airdropKeys.hasRole(scope, variables.role, variables.holder)
+      });
+      void queryClient.invalidateQueries({
+        queryKey: chunkEBLBPUPI_cjs.airdropKeys.roleMembers(scope, variables.role)
+      });
+    }
   });
 }
-function useAirdropCanExtendClaimWindow(options) {
-  const { client, chainId } = chunkWO72UBQD_cjs.useMemoAirdropClient(options);
-  return reactQuery.useQuery({
-    queryKey: chunkWO72UBQD_cjs.buildQueryKey("airdrop:CAN_EXTEND_CLAIM_WINDOW", chainId, options.address),
-    queryFn: () => client.canExtendClaimWindow(),
-    enabled: !!client,
-    staleTime: 0
+function useAirdropRenounceRole(options) {
+  const { client, chainId } = chunkEBLBPUPI_cjs.useMemoAirdropBaseClient(options);
+  const queryClient = reactQuery.useQueryClient();
+  return reactQuery.useMutation({
+    mutationFn: async (args) => {
+      if (!client) {
+        throw new chunk67OV5CX2_cjs.MissingClientError("useAirdropRenounceRole", "airdrop-base");
+      }
+      return client.renounceRole(args);
+    },
+    onSuccess: (_hash, variables) => {
+      const scope = { chainId, address: options.address };
+      void queryClient.invalidateQueries({ queryKey: chunkEBLBPUPI_cjs.airdropKeys.hasRoleAll(scope) });
+      void queryClient.invalidateQueries({
+        queryKey: chunkEBLBPUPI_cjs.airdropKeys.roleMembers(scope, variables.role)
+      });
+    }
   });
 }
-function useAirdropEndTime(options) {
-  const { client, chainId } = chunkWO72UBQD_cjs.useMemoAirdropClient(options);
-  return reactQuery.useQuery({
-    queryKey: chunkWO72UBQD_cjs.buildQueryKey("airdrop:endTime", chainId, options.address),
-    queryFn: () => client.endTime(),
-    enabled: !!client,
-    staleTime: 0
+function useAirdropRevokeRole(options) {
+  const { client, chainId } = chunkEBLBPUPI_cjs.useMemoAirdropBaseClient(options);
+  const queryClient = reactQuery.useQueryClient();
+  return reactQuery.useMutation({
+    mutationFn: async (args) => {
+      if (!client) {
+        throw new chunk67OV5CX2_cjs.MissingClientError("useAirdropRevokeRole", "airdrop-base");
+      }
+      return client.revokeRole(args);
+    },
+    onSuccess: (_hash, variables) => {
+      const scope = { chainId, address: options.address };
+      void queryClient.invalidateQueries({
+        queryKey: chunkEBLBPUPI_cjs.airdropKeys.hasRole(scope, variables.role, variables.holder)
+      });
+      void queryClient.invalidateQueries({
+        queryKey: chunkEBLBPUPI_cjs.airdropKeys.roleMembers(scope, variables.role)
+      });
+    }
   });
 }
-function useAirdropIsPaused(options) {
-  const { client, chainId } = chunkWO72UBQD_cjs.useMemoAirdropClient(options);
-  return reactQuery.useQuery({
-    queryKey: chunkWO72UBQD_cjs.buildQueryKey("airdrop:isPaused", chainId, options.address),
-    queryFn: () => client.isPaused(),
-    enabled: !!client,
-    staleTime: 0
+function useAirdropUpgradeToAndCall(options) {
+  const { client } = chunkEBLBPUPI_cjs.useMemoAirdropBaseClient(options);
+  return reactQuery.useMutation({
+    mutationFn: async (args) => {
+      if (!client) {
+        throw new chunk67OV5CX2_cjs.MissingClientError("useAirdropUpgradeToAndCall", "airdrop-base");
+      }
+      return client.upgradeToAndCall(args);
+    }
   });
 }
-function useAirdropDeploymentBlockNumber(options) {
-  const { client, chainId } = chunkWO72UBQD_cjs.useMemoAirdropClient(options);
-  return reactQuery.useQuery({
-    queryKey: chunkWO72UBQD_cjs.buildQueryKey("airdrop:deploymentBlockNumber", chainId, options.address),
-    queryFn: () => client.deploymentBlockNumber(),
-    enabled: !!client,
-    staleTime: 0
+function useBatchDiscloseHandlesToParty(options) {
+  const { client } = chunkEBLBPUPI_cjs.useMemoAirdropBaseClient(options);
+  return reactQuery.useMutation({
+    mutationFn: async (args) => {
+      if (!client) {
+        throw new chunk67OV5CX2_cjs.MissingClientError("useBatchDiscloseHandlesToParty", "airdrop-base");
+      }
+      return client.batchDiscloseHandlesToParty(args);
+    }
   });
 }
-function useAirdropDomainSeparator(options) {
-  const { client, chainId } = chunkWO72UBQD_cjs.useMemoAirdropClient(options);
-  return reactQuery.useQuery({
-    queryKey: chunkWO72UBQD_cjs.buildQueryKey("airdrop:DOMAIN_SEPARATOR", chainId, options.address),
-    queryFn: () => client.domainSeparator(),
-    enabled: !!client,
-    staleTime: 0
+function useBuildMerkleCampaign(options = {}) {
+  const encryptorSourceRef = react.useRef(options.encryptor);
+  encryptorSourceRef.current = options.encryptor;
+  return reactQuery.useMutation({
+    mutationFn: async (args) => chunkIUKKNJ2R_cjs.buildMerkleCampaign({
+      instance: args.instance,
+      recipients: args.recipients,
+      encryptor: () => chunkPZZK3O3S_cjs.resolveEncryptor(encryptorSourceRef.current),
+      ...args.submitter !== void 0 ? { submitter: args.submitter } : {}
+    })
   });
 }
-function useAirdropClaimTypehash(options) {
-  const { client, chainId } = chunkWO72UBQD_cjs.useMemoAirdropClient(options);
-  return reactQuery.useQuery({
-    queryKey: chunkWO72UBQD_cjs.buildQueryKey("airdrop:CLAIM_TYPEHASH", chainId, options.address),
-    queryFn: () => client.claimTypehash(),
-    enabled: !!client,
-    staleTime: 0
+function useComplianceGrantRole(options) {
+  const { client, chainId } = chunkEBLBPUPI_cjs.useMemoComplianceManagerClient(options);
+  const queryClient = reactQuery.useQueryClient();
+  return reactQuery.useMutation({
+    mutationFn: async (args) => {
+      if (!client) {
+        throw new chunk67OV5CX2_cjs.MissingClientError("useComplianceGrantRole", "compliance-manager");
+      }
+      return client.grantRole(args);
+    },
+    onSuccess: (_hash, variables) => {
+      const scope = { chainId, address: options.address };
+      void queryClient.invalidateQueries({
+        queryKey: chunkEBLBPUPI_cjs.airdropKeys.complianceHasRole(scope, variables.role, variables.holder)
+      });
+      void queryClient.invalidateQueries({
+        queryKey: chunkEBLBPUPI_cjs.airdropKeys.complianceRoleMembers(scope, variables.role)
+      });
+    }
   });
 }
-function useAirdropIsClaimWindowActive(options) {
-  const { client, chainId } = chunkWO72UBQD_cjs.useMemoAirdropClient(options);
-  return reactQuery.useQuery({
-    queryKey: chunkWO72UBQD_cjs.buildQueryKey("airdrop:isClaimWindowActive", chainId, options.address),
-    queryFn: () => client.isClaimWindowActive(),
-    enabled: !!client,
-    staleTime: 0
+function useComplianceRenounceRole(options) {
+  const { client, chainId } = chunkEBLBPUPI_cjs.useMemoComplianceManagerClient(options);
+  const queryClient = reactQuery.useQueryClient();
+  return reactQuery.useMutation({
+    mutationFn: async (args) => {
+      if (!client) {
+        throw new chunk67OV5CX2_cjs.MissingClientError("useComplianceRenounceRole", "compliance-manager");
+      }
+      return client.renounceRole(args);
+    },
+    onSuccess: (_hash, variables) => {
+      const scope = { chainId, address: options.address };
+      void queryClient.invalidateQueries({ queryKey: chunkEBLBPUPI_cjs.airdropKeys.complianceHasRoleAll(scope) });
+      void queryClient.invalidateQueries({
+        queryKey: chunkEBLBPUPI_cjs.airdropKeys.complianceRoleMembers(scope, variables.role)
+      });
+    }
   });
 }
-function useAirdropHasClaimStarted(options) {
-  const { client, chainId } = chunkWO72UBQD_cjs.useMemoAirdropClient(options);
-  return reactQuery.useQuery({
-    queryKey: chunkWO72UBQD_cjs.buildQueryKey("airdrop:hasClaimStarted", chainId, options.address),
-    queryFn: () => client.hasClaimStarted(),
-    enabled: !!client,
-    staleTime: 0
+function useComplianceRevokeRole(options) {
+  const { client, chainId } = chunkEBLBPUPI_cjs.useMemoComplianceManagerClient(options);
+  const queryClient = reactQuery.useQueryClient();
+  return reactQuery.useMutation({
+    mutationFn: async (args) => {
+      if (!client) {
+        throw new chunk67OV5CX2_cjs.MissingClientError("useComplianceRevokeRole", "compliance-manager");
+      }
+      return client.revokeRole(args);
+    },
+    onSuccess: (_hash, variables) => {
+      const scope = { chainId, address: options.address };
+      void queryClient.invalidateQueries({
+        queryKey: chunkEBLBPUPI_cjs.airdropKeys.complianceHasRole(scope, variables.role, variables.holder)
+      });
+      void queryClient.invalidateQueries({
+        queryKey: chunkEBLBPUPI_cjs.airdropKeys.complianceRoleMembers(scope, variables.role)
+      });
+    }
   });
 }
-function useAirdropHasClaimEnded(options) {
-  const { client, chainId } = chunkWO72UBQD_cjs.useMemoAirdropClient(options);
-  return reactQuery.useQuery({
-    queryKey: chunkWO72UBQD_cjs.buildQueryKey("airdrop:hasClaimEnded", chainId, options.address),
-    queryFn: () => client.hasClaimEnded(),
-    enabled: !!client,
-    staleTime: 0
+function useCreateAndFundEcdsaAirdrop(options = {}) {
+  const { client, resolutionError, chainId, resolvedAddress } = chunkEBLBPUPI_cjs.useMemoAirdropFactoryClient(options);
+  const queryClient = reactQuery.useQueryClient();
+  return reactQuery.useMutation({
+    mutationFn: async (args) => {
+      if (!client) {
+        throw resolutionError ?? new chunk67OV5CX2_cjs.MissingClientError("useCreateAndFundEcdsaAirdrop", "factory");
+      }
+      return client.createAndFundEcdsaAirdrop(args);
+    },
+    onSuccess: () => {
+      void queryClient.invalidateQueries({
+        queryKey: chunkEBLBPUPI_cjs.airdropKeys.registryAll({ chainId, address: resolvedAddress })
+      });
+    }
   });
 }
-function useAirdropClaimedSignatures(args) {
-  const { signatureHash, ...base } = args;
-  const { client, chainId } = chunkWO72UBQD_cjs.useMemoAirdropClient(base);
-  return reactQuery.useQuery({
-    queryKey: chunkWO72UBQD_cjs.buildQueryKey("airdrop:claimedSignatures", chainId, base.address, signatureHash),
-    queryFn: () => client.claimedSignatures(signatureHash),
-    enabled: !!client && !!signatureHash,
-    staleTime: 0
+function useCreateAndFundMerkleAirdrop(options = {}) {
+  const { client, resolutionError, chainId, resolvedAddress } = chunkEBLBPUPI_cjs.useMemoAirdropFactoryClient(options);
+  const queryClient = reactQuery.useQueryClient();
+  return reactQuery.useMutation({
+    mutationFn: async (args) => {
+      if (!client) {
+        throw resolutionError ?? new chunk67OV5CX2_cjs.MissingClientError("useCreateAndFundMerkleAirdrop", "factory");
+      }
+      return client.createAndFundMerkleAirdrop(args);
+    },
+    onSuccess: () => {
+      void queryClient.invalidateQueries({
+        queryKey: chunkEBLBPUPI_cjs.airdropKeys.registryAll({ chainId, address: resolvedAddress })
+      });
+    }
   });
 }
-function useAirdropIsSignatureClaimed(args) {
-  const { user, encryptedAmountHandle, ...base } = args;
-  const { client, chainId } = chunkWO72UBQD_cjs.useMemoAirdropClient(base);
-  return reactQuery.useQuery({
-    queryKey: chunkWO72UBQD_cjs.buildQueryKey(
-      "airdrop:isSignatureClaimed",
-      chainId,
-      base.address,
-      user,
-      encryptedAmountHandle
-    ),
-    queryFn: () => client.isSignatureClaimed(user, encryptedAmountHandle),
-    enabled: !!client && !!user && !!encryptedAmountHandle,
-    staleTime: 0
-  });
-}
-function useAirdropIsSignatureValid(args) {
-  const { encryptedAmountHandle, signature, caller, ...base } = args;
-  const { client, chainId } = chunkWO72UBQD_cjs.useMemoAirdropClient(base);
-  const { address: connectedAddress } = chunkZQUE2B3Q_cjs.useWagmiAccount();
-  const resolvedCaller = caller ?? connectedAddress;
-  return reactQuery.useQuery({
-    queryKey: chunkWO72UBQD_cjs.buildQueryKey(
-      "airdrop:isSignatureValid",
-      chainId,
-      base.address,
-      encryptedAmountHandle,
-      signature,
-      resolvedCaller
-    ),
-    queryFn: () => client.isSignatureValid({
-      encryptedAmountHandle,
-      signature,
-      caller: resolvedCaller
-    }),
-    enabled: !!client && !!encryptedAmountHandle && !!signature && !!resolvedCaller,
-    staleTime: 0
+function useDiscloseHandleToParty(options) {
+  const { client } = chunkEBLBPUPI_cjs.useMemoAirdropBaseClient(options);
+  return reactQuery.useMutation({
+    mutationFn: async (args) => {
+      if (!client) {
+        throw new chunk67OV5CX2_cjs.MissingClientError("useDiscloseHandleToParty", "airdrop-base");
+      }
+      return client.discloseHandleToParty(args);
+    }
   });
 }
-function useAirdropHasRole(args) {
-  const { role, account, ...base } = args;
-  const { client, chainId } = chunkWO72UBQD_cjs.useMemoAirdropClient(base);
-  return reactQuery.useQuery({
-    queryKey: chunkWO72UBQD_cjs.buildQueryKey("airdrop:hasRole", chainId, base.address, role, account),
-    queryFn: () => client.hasRole(role, account),
-    enabled: !!client && !!role && !!account,
-    staleTime: 0
+function useEcdsaClaimAndUnwrap(options) {
+  const { client, chainId } = chunkEBLBPUPI_cjs.useMemoEcdsaAirdropClient(options);
+  const queryClient = reactQuery.useQueryClient();
+  return reactQuery.useMutation({
+    mutationFn: async (args) => {
+      if (!client) {
+        throw new chunk67OV5CX2_cjs.MissingClientError("useEcdsaClaimAndUnwrap", "ecdsa-airdrop");
+      }
+      return client.claimAndUnwrap(args);
+    },
+    onSuccess: () => {
+      void queryClient.invalidateQueries({
+        queryKey: chunkEBLBPUPI_cjs.airdropKeys.isSignatureValidAll({ chainId, address: options.address })
+      });
+    }
   });
 }
-function useClaim(options) {
-  const { client } = chunkWO72UBQD_cjs.useMemoAirdropClient(options);
+function useEncryptCampaignAmounts(options = {}) {
+  const encryptorSourceRef = react.useRef(options.encryptor);
+  encryptorSourceRef.current = options.encryptor;
+  return reactQuery.useMutation({
+    mutationFn: async (args) => chunkIUKKNJ2R_cjs.encryptCampaignAmounts({
+      instance: args.instance,
+      recipients: args.recipients,
+      encryptor: () => chunkPZZK3O3S_cjs.resolveEncryptor(encryptorSourceRef.current),
+      ...args.submitter !== void 0 ? { submitter: args.submitter } : {}
+    })
+  });
+}
+function useMerkleClaimAndUnwrap(options) {
+  const { client, walletClient, chainId } = chunkEBLBPUPI_cjs.useMemoMerkleAirdropClient(options);
+  const queryClient = reactQuery.useQueryClient();
   return reactQuery.useMutation({
     mutationFn: async (args) => {
-      if (!client) throw new chunk2RNW4MIJ_cjs.MissingClientError("useClaim", "airdrop");
-      return client.claim(args);
+      if (!client) {
+        throw new chunk67OV5CX2_cjs.MissingClientError("useMerkleClaimAndUnwrap", "merkle-airdrop");
+      }
+      return client.claimAndUnwrap(args);
+    },
+    // Resolved here rather than in `onSuccess`: a mutation outlives several
+    // re-renders of its own component and `useWalletClient().data` can read back
+    // transiently empty across them, which would silently skip the invalidation.
+    onMutate: (variables) => {
+      const account = variables.account ?? walletClient?.account;
+      if (!account) return {};
+      return { sender: typeof account === "string" ? account : account.address };
+    },
+    onSuccess: (_hash, _variables, context) => {
+      if (!context?.sender) return;
+      void queryClient.invalidateQueries({
+        queryKey: chunkEBLBPUPI_cjs.airdropKeys.claimedAmount({ chainId, address: options.address }, context.sender)
+      });
     }
   });
 }
-function useAccessClaimAmount(options) {
-  const { client } = chunkWO72UBQD_cjs.useMemoAirdropClient(options);
+function usePlanMerkleCampaign(options = {}) {
+  const { client, resolutionError } = chunkEBLBPUPI_cjs.useMemoAirdropFactoryClient(options);
+  const encryptorSourceRef = react.useRef(options.encryptor);
+  encryptorSourceRef.current = options.encryptor;
   return reactQuery.useMutation({
     mutationFn: async (args) => {
-      if (!client) throw new chunk2RNW4MIJ_cjs.MissingClientError("useAccessClaimAmount", "airdrop");
-      return client.getClaimAmount(args);
+      if (!client) {
+        throw resolutionError ?? new chunk67OV5CX2_cjs.MissingClientError("usePlanMerkleCampaign", "factory");
+      }
+      return chunkIUKKNJ2R_cjs.planMerkleCampaign({
+        factory: client,
+        ...args,
+        encryptor: () => chunkPZZK3O3S_cjs.resolveEncryptor(encryptorSourceRef.current)
+      });
     }
   });
 }
-var useGetClaimAmount = useAccessClaimAmount;
-function useWithdraw(options) {
-  const { client } = chunkWO72UBQD_cjs.useMemoAirdropClient(options);
+function useRescueERC20(options) {
+  const { client } = chunkEBLBPUPI_cjs.useMemoAirdropBaseClient(options);
   return reactQuery.useMutation({
-    mutationFn: async ({ recipient, account }) => {
-      if (!client) throw new chunk2RNW4MIJ_cjs.MissingClientError("useWithdraw", "airdrop");
-      return client.withdraw(recipient, account);
+    mutationFn: async (args) => {
+      if (!client) {
+        throw new chunk67OV5CX2_cjs.MissingClientError("useRescueERC20", "airdrop-base");
+      }
+      return client.rescueERC20(args);
     }
   });
 }
-function useSetPaused(options) {
-  const { client } = chunkWO72UBQD_cjs.useMemoAirdropClient(options);
+function useRescueOtherConfidentialToken(options) {
+  const { client } = chunkEBLBPUPI_cjs.useMemoAirdropBaseClient(options);
   return reactQuery.useMutation({
-    mutationFn: async ({ paused, account }) => {
-      if (!client) throw new chunk2RNW4MIJ_cjs.MissingClientError("useSetPaused", "airdrop");
-      return client.setPaused(paused, account);
+    mutationFn: async (args) => {
+      if (!client) {
+        throw new chunk67OV5CX2_cjs.MissingClientError("useRescueOtherConfidentialToken", "airdrop-base");
+      }
+      return client.rescueOtherConfidentialToken(args);
     }
   });
 }
-function useExtendClaimWindow(options) {
-  const { client } = chunkWO72UBQD_cjs.useMemoAirdropClient(options);
+function useRevokeComplianceDelegate(options) {
+  const { client, chainId } = chunkEBLBPUPI_cjs.useMemoComplianceManagerClient(options);
+  const queryClient = reactQuery.useQueryClient();
+  return reactQuery.useMutation({
+    mutationFn: async (args) => {
+      if (!client) {
+        throw new chunk67OV5CX2_cjs.MissingClientError("useRevokeComplianceDelegate", "compliance-manager");
+      }
+      return client.revokeDelegate(args);
+    },
+    onSuccess: (_hash, variables) => {
+      const scope = { chainId, address: options.address };
+      void queryClient.invalidateQueries({ queryKey: chunkEBLBPUPI_cjs.airdropKeys.complianceInfo(scope) });
+      void queryClient.invalidateQueries({
+        queryKey: chunkEBLBPUPI_cjs.airdropKeys.activeDelegate(scope, variables.delegate)
+      });
+    }
+  });
+}
+function useRotateMerkleRoot(options) {
+  const { client, chainId } = chunkEBLBPUPI_cjs.useMemoMerkleAirdropClient(options);
+  const encryptorSourceRef = react.useRef(options.encryptor);
+  encryptorSourceRef.current = options.encryptor;
+  const queryClient = reactQuery.useQueryClient();
   return reactQuery.useMutation({
-    mutationFn: async ({ newEndTime, account }) => {
-      if (!client) throw new chunk2RNW4MIJ_cjs.MissingClientError("useExtendClaimWindow", "airdrop");
-      return client.extendClaimWindow(newEndTime, account);
+    mutationFn: async (args) => {
+      if (!client) {
+        throw new chunk67OV5CX2_cjs.MissingClientError("useRotateMerkleRoot", "merkle-airdrop");
+      }
+      return chunkIUKKNJ2R_cjs.rotateMerkleRoot({
+        airdrop: client,
+        recipients: args.recipients,
+        encryptor: () => chunkPZZK3O3S_cjs.resolveEncryptor(encryptorSourceRef.current),
+        ...args.submitter !== void 0 ? { submitter: args.submitter } : {},
+        ...args.account !== void 0 ? { account: args.account } : {}
+      });
+    },
+    onSuccess: () => {
+      void queryClient.invalidateQueries({
+        queryKey: chunkEBLBPUPI_cjs.airdropKeys.merkleRoot({ chainId, address: options.address })
+      });
     }
   });
 }
-function useWithdrawOtherToken(options) {
-  const { client } = chunkWO72UBQD_cjs.useMemoAirdropClient(options);
+function useSignClaimAuthorization(options) {
+  const { walletClient, chainId } = chunkEBLBPUPI_cjs.useMemoAirdropBaseClient(options);
   return reactQuery.useMutation({
-    mutationFn: async ({ tokenAddress, recipient, account }) => {
-      if (!client) throw new chunk2RNW4MIJ_cjs.MissingClientError("useWithdrawOtherToken", "airdrop");
-      return client.withdrawOtherToken(tokenAddress, recipient, account);
+    mutationFn: async (args) => {
+      if (!walletClient) {
+        throw new chunk67OV5CX2_cjs.MissingWalletClientError("useSignClaimAuthorization");
+      }
+      if (chainId === void 0) {
+        throw new chunk67OV5CX2_cjs.MissingClientError("useSignClaimAuthorization", "airdrop-base");
+      }
+      return chunkPZZK3O3S_cjs.signClaimAuthorization({
+        walletClient,
+        airdrop: options.address,
+        chainId,
+        recipient: args.recipient,
+        encryptedAmountHandle: args.encryptedAmountHandle,
+        dedupId: args.dedupId,
+        deadline: args.deadline,
+        account: args.account
+      });
     }
   });
 }
-function useWithdrawOtherConfidentialToken(options) {
-  const { client } = chunkWO72UBQD_cjs.useMemoAirdropClient(options);
+function useWithdrawGasFee(options) {
+  const { client } = chunkEBLBPUPI_cjs.useMemoAirdropBaseClient(options);
   return reactQuery.useMutation({
-    mutationFn: async ({ tokenAddress, recipient, account }) => {
-      if (!client) throw new chunk2RNW4MIJ_cjs.MissingClientError("useWithdrawOtherConfidentialToken", "airdrop");
-      return client.withdrawOtherConfidentialToken(tokenAddress, recipient, account);
+    mutationFn: async (args) => {
+      if (!client) {
+        throw new chunk67OV5CX2_cjs.MissingClientError("useWithdrawGasFee", "airdrop-base");
+      }
+      return client.withdrawGasFee(args);
     }
   });
 }
-function useAirdropWithdrawGasFee(options) {
-  const { client } = chunkWO72UBQD_cjs.useMemoAirdropClient(options);
+function useAdminBatchDiscloseBalanceToParties(options) {
+  const { client } = chunkEBLBPUPI_cjs.useMemoAirdropBaseClient(options);
   return reactQuery.useMutation({
-    mutationFn: async ({ recipient, amount, account }) => {
-      if (!client) throw new chunk2RNW4MIJ_cjs.MissingClientError("useAirdropWithdrawGasFee", "airdrop");
-      return client.withdrawGasFee(recipient, amount, account);
+    mutationFn: async (args) => {
+      if (!client) {
+        throw new chunk67OV5CX2_cjs.MissingClientError("useAdminBatchDiscloseBalanceToParties", "airdrop-base");
+      }
+      return client.adminBatchDiscloseBalanceToParties(args);
     }
   });
 }
-function useAirdropGrantRole(options) {
-  const { client } = chunkWO72UBQD_cjs.useMemoAirdropClient(options);
+function useAdminDiscloseBalanceToParty(options) {
+  const { client } = chunkEBLBPUPI_cjs.useMemoAirdropBaseClient(options);
+  return reactQuery.useMutation({
+    mutationFn: async (args) => {
+      if (!client) {
+        throw new chunk67OV5CX2_cjs.MissingClientError("useAdminDiscloseBalanceToParty", "airdrop-base");
+      }
+      return client.adminDiscloseBalanceToParty(args);
+    }
+  });
+}
+function useAdminGetCurrentBalance(options) {
+  const { client } = chunkEBLBPUPI_cjs.useMemoAirdropBaseClient(options);
   return reactQuery.useMutation({
-    mutationFn: async ({ role, accountTarget, account }) => {
-      if (!client) throw new chunk2RNW4MIJ_cjs.MissingClientError("useAirdropGrantRole", "airdrop");
-      return client.grantRole(role, accountTarget, account);
+    mutationFn: async (args) => {
+      if (!client) {
+        throw new chunk67OV5CX2_cjs.MissingClientError("useAdminGetCurrentBalance", "airdrop-base");
+      }
+      return client.adminGetCurrentBalance(args ?? {});
     }
   });
 }
-function useAirdropRevokeRole(options) {
-  const { client } = chunkWO72UBQD_cjs.useMemoAirdropClient(options);
+function useAccessEcdsaClaimAmount(options) {
+  const { client } = chunkEBLBPUPI_cjs.useMemoEcdsaAirdropClient(options);
   return reactQuery.useMutation({
-    mutationFn: async ({ role, accountTarget, account }) => {
-      if (!client) throw new chunk2RNW4MIJ_cjs.MissingClientError("useAirdropRevokeRole", "airdrop");
-      return client.revokeRole(role, accountTarget, account);
+    mutationFn: async (args) => {
+      if (!client) {
+        throw new chunk67OV5CX2_cjs.MissingClientError("useAccessEcdsaClaimAmount", "ecdsa-airdrop");
+      }
+      return client.getClaimAmount(args);
     }
   });
 }
-function useSignClaimAuthorization(options = {}) {
-  const { data: walletClient } = wagmi.useWalletClient({ chainId: options.chainId });
+function useAccessMerkleClaimAmount(options) {
+  const { client } = chunkEBLBPUPI_cjs.useMemoMerkleAirdropClient(options);
   return reactQuery.useMutation({
     mutationFn: async (args) => {
-      if (!walletClient) {
-        throw new chunk2RNW4MIJ_cjs.MissingWalletClientError("useSignClaimAuthorization");
+      if (!client) {
+        throw new chunk67OV5CX2_cjs.MissingClientError("useAccessMerkleClaimAmount", "merkle-airdrop");
       }
-      return chunkLBWRFZR3_cjs.signClaimAuthorization({
-        walletClient,
-        airdropAddress: args.airdropAddress,
-        recipient: args.recipient,
-        encryptedAmountHandle: args.encryptedAmountHandle
-      });
+      return client.getClaimAmount(args);
     }
   });
 }
 
-Object.defineProperty(exports, "AlreadyClaimedError", {
+Object.defineProperty(exports, "buildMerkleCampaign", {
   enumerable: true,
-  get: function () { return chunkSPGSO5SO_cjs.AlreadyClaimedError; }
+  get: function () { return chunkIUKKNJ2R_cjs.buildMerkleCampaign; }
 });
-Object.defineProperty(exports, "ClaimNotStartedError", {
+Object.defineProperty(exports, "buildMerkleTree", {
   enumerable: true,
-  get: function () { return chunkSPGSO5SO_cjs.ClaimNotStartedError; }
+  get: function () { return chunkIUKKNJ2R_cjs.buildMerkleTree; }
 });
-Object.defineProperty(exports, "ClaimWindowClosedError", {
+Object.defineProperty(exports, "encryptCampaignAmounts", {
   enumerable: true,
-  get: function () { return chunkSPGSO5SO_cjs.ClaimWindowClosedError; }
+  get: function () { return chunkIUKKNJ2R_cjs.encryptCampaignAmounts; }
+});
+Object.defineProperty(exports, "grantInstanceRoles", {
+  enumerable: true,
+  get: function () { return chunkIUKKNJ2R_cjs.grantInstanceRoles; }
+});
+Object.defineProperty(exports, "leafOf", {
+  enumerable: true,
+  get: function () { return chunkIUKKNJ2R_cjs.leafOf; }
+});
+Object.defineProperty(exports, "planInstanceRoleSplit", {
+  enumerable: true,
+  get: function () { return chunkIUKKNJ2R_cjs.planInstanceRoleSplit; }
+});
+Object.defineProperty(exports, "planMerkleCampaign", {
+  enumerable: true,
+  get: function () { return chunkIUKKNJ2R_cjs.planMerkleCampaign; }
+});
+Object.defineProperty(exports, "rotateMerkleRoot", {
+  enumerable: true,
+  get: function () { return chunkIUKKNJ2R_cjs.rotateMerkleRoot; }
+});
+Object.defineProperty(exports, "validateCampaignRecipients", {
+  enumerable: true,
+  get: function () { return chunkIUKKNJ2R_cjs.validateCampaignRecipients; }
+});
+Object.defineProperty(exports, "airdropQueryKey", {
+  enumerable: true,
+  get: function () { return chunkEBLBPUPI_cjs.airdropQueryKey; }
+});
+Object.defineProperty(exports, "airdropQueryKeyPrefix", {
+  enumerable: true,
+  get: function () { return chunkEBLBPUPI_cjs.airdropQueryKeyPrefix; }
 });
 Object.defineProperty(exports, "encryptUint64", {
   enumerable: true,
-  get: function () { return chunkLBWRFZR3_cjs.encryptUint64; }
+  get: function () { return chunkPZZK3O3S_cjs.encryptUint64; }
 });
 Object.defineProperty(exports, "encryptUint64Batch", {
   enumerable: true,
-  get: function () { return chunkLBWRFZR3_cjs.encryptUint64Batch; }
+  get: function () { return chunkPZZK3O3S_cjs.encryptUint64Batch; }
 });
 Object.defineProperty(exports, "resolveEncryptor", {
   enumerable: true,
-  get: function () { return chunkLBWRFZR3_cjs.resolveEncryptor; }
+  get: function () { return chunkPZZK3O3S_cjs.resolveEncryptor; }
 });
 Object.defineProperty(exports, "signClaimAuthorization", {
   enumerable: true,
-  get: function () { return chunkLBWRFZR3_cjs.signClaimAuthorization; }
+  get: function () { return chunkPZZK3O3S_cjs.signClaimAuthorization; }
+});
+Object.defineProperty(exports, "AlreadyClaimedError", {
+  enumerable: true,
+  get: function () { return chunkAREQJHKA_cjs.AlreadyClaimedError; }
+});
+Object.defineProperty(exports, "ClaimNotStartedError", {
+  enumerable: true,
+  get: function () { return chunkAREQJHKA_cjs.ClaimNotStartedError; }
+});
+Object.defineProperty(exports, "ClaimWindowClosedError", {
+  enumerable: true,
+  get: function () { return chunkAREQJHKA_cjs.ClaimWindowClosedError; }
+});
+Object.defineProperty(exports, "DedupIdConsumedError", {
+  enumerable: true,
+  get: function () { return chunkAREQJHKA_cjs.DedupIdConsumedError; }
+});
+Object.defineProperty(exports, "FeeCollectorSelfAdministeredError", {
+  enumerable: true,
+  get: function () { return chunkAREQJHKA_cjs.FeeCollectorSelfAdministeredError; }
+});
+Object.defineProperty(exports, "MerkleUupsUnsupportedError", {
+  enumerable: true,
+  get: function () { return chunkAREQJHKA_cjs.MerkleUupsUnsupportedError; }
+});
+Object.defineProperty(exports, "NonStockWrapperError", {
+  enumerable: true,
+  get: function () { return chunkAREQJHKA_cjs.NonStockWrapperError; }
+});
+Object.defineProperty(exports, "PredictionDriftError", {
+  enumerable: true,
+  get: function () { return chunkAREQJHKA_cjs.PredictionDriftError; }
+});
+Object.defineProperty(exports, "SaltCollisionError", {
+  enumerable: true,
+  get: function () { return chunkAREQJHKA_cjs.SaltCollisionError; }
+});
+Object.defineProperty(exports, "SignatureExpiredError", {
+  enumerable: true,
+  get: function () { return chunkAREQJHKA_cjs.SignatureExpiredError; }
+});
+Object.defineProperty(exports, "UnauthorizedRedirectError", {
+  enumerable: true,
+  get: function () { return chunkAREQJHKA_cjs.UnauthorizedRedirectError; }
+});
+Object.defineProperty(exports, "UpgradeabilityNotAllowedError", {
+  enumerable: true,
+  get: function () { return chunkAREQJHKA_cjs.UpgradeabilityNotAllowedError; }
 });
-Object.defineProperty(exports, "useEnsureOperator", {
+Object.defineProperty(exports, "preflightClaim", {
   enumerable: true,
-  get: function () { return chunkWOEETTH7_cjs.useEnsureOperator; }
+  get: function () { return chunkAREQJHKA_cjs.preflightClaim; }
 });
-Object.defineProperty(exports, "useIsOperator", {
+Object.defineProperty(exports, "preflightCreate", {
   enumerable: true,
-  get: function () { return chunkWOEETTH7_cjs.useIsOperator; }
+  get: function () { return chunkAREQJHKA_cjs.preflightCreate; }
 });
 Object.defineProperty(exports, "AccessDeniedError", {
   enumerable: true,
-  get: function () { return chunk2RNW4MIJ_cjs.AccessDeniedError; }
+  get: function () { return chunk67OV5CX2_cjs.AccessDeniedError; }
 });
 Object.defineProperty(exports, "AlreadyInitializedError", {
   enumerable: true,
-  get: function () { return chunk2RNW4MIJ_cjs.AlreadyInitializedError; }
+  get: function () { return chunk67OV5CX2_cjs.AlreadyInitializedError; }
 });
 Object.defineProperty(exports, "BatchTooLargeError", {
   enumerable: true,
-  get: function () { return chunk2RNW4MIJ_cjs.BatchTooLargeError; }
+  get: function () { return chunk67OV5CX2_cjs.BatchTooLargeError; }
 });
 Object.defineProperty(exports, "ContractRevertError", {
   enumerable: true,
-  get: function () { return chunk2RNW4MIJ_cjs.ContractRevertError; }
+  get: function () { return chunk67OV5CX2_cjs.ContractRevertError; }
 });
 Object.defineProperty(exports, "DecryptionFailedError", {
   enumerable: true,
-  get: function () { return chunk2RNW4MIJ_cjs.DecryptionFailedError; }
+  get: function () { return chunk67OV5CX2_cjs.DecryptionFailedError; }
 });
 Object.defineProperty(exports, "DeploymentAddressUnavailableError", {
   enumerable: true,
-  get: function () { return chunk2RNW4MIJ_cjs.DeploymentAddressUnavailableError; }
+  get: function () { return chunk67OV5CX2_cjs.DeploymentAddressUnavailableError; }
 });
 Object.defineProperty(exports, "EncryptionFailedError", {
   enumerable: true,
-  get: function () { return chunk2RNW4MIJ_cjs.EncryptionFailedError; }
+  get: function () { return chunk67OV5CX2_cjs.EncryptionFailedError; }
 });
 Object.defineProperty(exports, "FeatureDisabledError", {
   enumerable: true,
-  get: function () { return chunk2RNW4MIJ_cjs.FeatureDisabledError; }
+  get: function () { return chunk67OV5CX2_cjs.FeatureDisabledError; }
 });
 Object.defineProperty(exports, "FheHandleNotAllowedError", {
   enumerable: true,
-  get: function () { return chunk2RNW4MIJ_cjs.FheHandleNotAllowedError; }
+  get: function () { return chunk67OV5CX2_cjs.FheHandleNotAllowedError; }
 });
 Object.defineProperty(exports, "InsufficientBalanceError", {
   enumerable: true,
-  get: function () { return chunk2RNW4MIJ_cjs.InsufficientBalanceError; }
+  get: function () { return chunk67OV5CX2_cjs.InsufficientBalanceError; }
 });
 Object.defineProperty(exports, "InsufficientFeeError", {
   enumerable: true,
-  get: function () { return chunk2RNW4MIJ_cjs.InsufficientFeeError; }
+  get: function () { return chunk67OV5CX2_cjs.InsufficientFeeError; }
 });
 Object.defineProperty(exports, "InsufficientGasFundsError", {
   enumerable: true,
-  get: function () { return chunk2RNW4MIJ_cjs.InsufficientGasFundsError; }
+  get: function () { return chunk67OV5CX2_cjs.InsufficientGasFundsError; }
 });
 Object.defineProperty(exports, "InvalidArgumentError", {
   enumerable: true,
-  get: function () { return chunk2RNW4MIJ_cjs.InvalidArgumentError; }
+  get: function () { return chunk67OV5CX2_cjs.InvalidArgumentError; }
 });
 Object.defineProperty(exports, "InvalidSignatureError", {
   enumerable: true,
-  get: function () { return chunk2RNW4MIJ_cjs.InvalidSignatureError; }
+  get: function () { return chunk67OV5CX2_cjs.InvalidSignatureError; }
 });
 Object.defineProperty(exports, "MissingAccountError", {
   enumerable: true,
-  get: function () { return chunk2RNW4MIJ_cjs.MissingAccountError; }
+  get: function () { return chunk67OV5CX2_cjs.MissingAccountError; }
 });
 Object.defineProperty(exports, "MissingClientError", {
   enumerable: true,
-  get: function () { return chunk2RNW4MIJ_cjs.MissingClientError; }
+  get: function () { return chunk67OV5CX2_cjs.MissingClientError; }
 });
 Object.defineProperty(exports, "MissingEncryptorError", {
   enumerable: true,
-  get: function () { return chunk2RNW4MIJ_cjs.MissingEncryptorError; }
+  get: function () { return chunk67OV5CX2_cjs.MissingEncryptorError; }
 });
 Object.defineProperty(exports, "MissingPublicClientError", {
   enumerable: true,
-  get: function () { return chunk2RNW4MIJ_cjs.MissingPublicClientError; }
+  get: function () { return chunk67OV5CX2_cjs.MissingPublicClientError; }
 });
 Object.defineProperty(exports, "MissingWalletClientError", {
   enumerable: true,
-  get: function () { return chunk2RNW4MIJ_cjs.MissingWalletClientError; }
+  get: function () { return chunk67OV5CX2_cjs.MissingWalletClientError; }
 });
 Object.defineProperty(exports, "NetworkError", {
   enumerable: true,
-  get: function () { return chunk2RNW4MIJ_cjs.NetworkError; }
+  get: function () { return chunk67OV5CX2_cjs.NetworkError; }
 });
 Object.defineProperty(exports, "OperatorNotApprovedError", {
   enumerable: true,
-  get: function () { return chunk2RNW4MIJ_cjs.OperatorNotApprovedError; }
+  get: function () { return chunk67OV5CX2_cjs.OperatorNotApprovedError; }
 });
 Object.defineProperty(exports, "PausedError", {
   enumerable: true,
-  get: function () { return chunk2RNW4MIJ_cjs.PausedError; }
+  get: function () { return chunk67OV5CX2_cjs.PausedError; }
 });
 Object.defineProperty(exports, "ReceiptEventAmbiguousError", {
   enumerable: true,
-  get: function () { return chunk2RNW4MIJ_cjs.ReceiptEventAmbiguousError; }
+  get: function () { return chunk67OV5CX2_cjs.ReceiptEventAmbiguousError; }
 });
 Object.defineProperty(exports, "ReceiptEventNotFoundError", {
   enumerable: true,
-  get: function () { return chunk2RNW4MIJ_cjs.ReceiptEventNotFoundError; }
+  get: function () { return chunk67OV5CX2_cjs.ReceiptEventNotFoundError; }
 });
 Object.defineProperty(exports, "ReentrancyError", {
   enumerable: true,
-  get: function () { return chunk2RNW4MIJ_cjs.ReentrancyError; }
+  get: function () { return chunk67OV5CX2_cjs.ReentrancyError; }
 });
 Object.defineProperty(exports, "RelayerUnreachableError", {
   enumerable: true,
-  get: function () { return chunk2RNW4MIJ_cjs.RelayerUnreachableError; }
+  get: function () { return chunk67OV5CX2_cjs.RelayerUnreachableError; }
 });
 Object.defineProperty(exports, "SigningFailedError", {
   enumerable: true,
-  get: function () { return chunk2RNW4MIJ_cjs.SigningFailedError; }
+  get: function () { return chunk67OV5CX2_cjs.SigningFailedError; }
 });
 Object.defineProperty(exports, "TokenOpsSdkError", {
   enumerable: true,
-  get: function () { return chunk2RNW4MIJ_cjs.TokenOpsSdkError; }
+  get: function () { return chunk67OV5CX2_cjs.TokenOpsSdkError; }
 });
 Object.defineProperty(exports, "TransferFailedError", {
   enumerable: true,
-  get: function () { return chunk2RNW4MIJ_cjs.TransferFailedError; }
+  get: function () { return chunk67OV5CX2_cjs.TransferFailedError; }
 });
 Object.defineProperty(exports, "UnknownWriteFailureError", {
   enumerable: true,
-  get: function () { return chunk2RNW4MIJ_cjs.UnknownWriteFailureError; }
+  get: function () { return chunk67OV5CX2_cjs.UnknownWriteFailureError; }
 });
 Object.defineProperty(exports, "UnsupportedChainError", {
   enumerable: true,
-  get: function () { return chunk2RNW4MIJ_cjs.UnsupportedChainError; }
+  get: function () { return chunk67OV5CX2_cjs.UnsupportedChainError; }
 });
 Object.defineProperty(exports, "UserDecryptNotAllowedError", {
   enumerable: true,
-  get: function () { return chunk2RNW4MIJ_cjs.UserDecryptNotAllowedError; }
+  get: function () { return chunk67OV5CX2_cjs.UserDecryptNotAllowedError; }
 });
 Object.defineProperty(exports, "UserRejectedSignatureError", {
   enumerable: true,
-  get: function () { return chunk2RNW4MIJ_cjs.UserRejectedSignatureError; }
+  get: function () { return chunk67OV5CX2_cjs.UserRejectedSignatureError; }
 });
 Object.defineProperty(exports, "WalletChainMismatchError", {
   enumerable: true,
-  get: function () { return chunk2RNW4MIJ_cjs.WalletChainMismatchError; }
+  get: function () { return chunk67OV5CX2_cjs.WalletChainMismatchError; }
 });
 Object.defineProperty(exports, "WalletRejectedError", {
   enumerable: true,
-  get: function () { return chunk2RNW4MIJ_cjs.WalletRejectedError; }
+  get: function () { return chunk67OV5CX2_cjs.WalletRejectedError; }
 });
 Object.defineProperty(exports, "isTokenOpsSdkError", {
   enumerable: true,
-  get: function () { return chunk2RNW4MIJ_cjs.isTokenOpsSdkError; }
+  get: function () { return chunk67OV5CX2_cjs.isTokenOpsSdkError; }
 });
-exports.useAccessClaimAmount = useAccessClaimAmount;
-exports.useAirdropCanExtendClaimWindow = useAirdropCanExtendClaimWindow;
-exports.useAirdropClaimTypehash = useAirdropClaimTypehash;
-exports.useAirdropClaimedSignatures = useAirdropClaimedSignatures;
-exports.useAirdropDeploymentBlockNumber = useAirdropDeploymentBlockNumber;
-exports.useAirdropDomainSeparator = useAirdropDomainSeparator;
-exports.useAirdropEndTime = useAirdropEndTime;
+exports.useAccessEcdsaClaimAmount = useAccessEcdsaClaimAmount;
+exports.useAccessMerkleClaimAmount = useAccessMerkleClaimAmount;
+exports.useAddComplianceDelegate = useAddComplianceDelegate;
+exports.useAdminBatchDiscloseBalanceToParties = useAdminBatchDiscloseBalanceToParties;
+exports.useAdminDiscloseBalanceToParty = useAdminDiscloseBalanceToParty;
+exports.useAdminGetCurrentBalance = useAdminGetCurrentBalance;
+exports.useAirdropConfig = useAirdropConfig;
+exports.useAirdropDeploymentMode = useAirdropDeploymentMode;
 exports.useAirdropGasFee = useAirdropGasFee;
 exports.useAirdropGrantRole = useAirdropGrantRole;
-exports.useAirdropHasClaimEnded = useAirdropHasClaimEnded;
-exports.useAirdropHasClaimStarted = useAirdropHasClaimStarted;
 exports.useAirdropHasRole = useAirdropHasRole;
-exports.useAirdropIsClaimWindowActive = useAirdropIsClaimWindowActive;
-exports.useAirdropIsPaused = useAirdropIsPaused;
-exports.useAirdropIsSignatureClaimed = useAirdropIsSignatureClaimed;
-exports.useAirdropIsSignatureValid = useAirdropIsSignatureValid;
+exports.useAirdropPause = useAirdropPause;
+exports.useAirdropPaused = useAirdropPaused;
+exports.useAirdropRenounceRole = useAirdropRenounceRole;
 exports.useAirdropRevokeRole = useAirdropRevokeRole;
-exports.useAirdropStartTime = useAirdropStartTime;
+exports.useAirdropRoleAdmin = useAirdropRoleAdmin;
+exports.useAirdropRoleConstants = useAirdropRoleConstants;
+exports.useAirdropRoleMembers = useAirdropRoleMembers;
 exports.useAirdropToken = useAirdropToken;
-exports.useAirdropWithdrawGasFee = useAirdropWithdrawGasFee;
-exports.useClaim = useClaim;
-exports.useConfidentialAirdropFactoryImplementation = useConfidentialAirdropFactoryImplementation;
-exports.useCreateAndFundConfidentialAirdrop = useCreateAndFundConfidentialAirdrop;
-exports.useCreateAndFundConfidentialAirdropAndGetAddress = useCreateAndFundConfidentialAirdropAndGetAddress;
-exports.useCreateConfidentialAirdrop = useCreateConfidentialAirdrop;
-exports.useCreateConfidentialAirdropAndGetAddress = useCreateConfidentialAirdropAndGetAddress;
-exports.useDisableCustomFee = useDisableCustomFee;
+exports.useAirdropUpgradeToAndCall = useAirdropUpgradeToAndCall;
+exports.useAirdropWindow = useAirdropWindow;
+exports.useBatchDiscloseHandlesToParty = useBatchDiscloseHandlesToParty;
+exports.useBuildMerkleCampaign = useBuildMerkleCampaign;
+exports.useClaimedAmount = useClaimedAmount;
+exports.useComplianceGrantRole = useComplianceGrantRole;
+exports.useComplianceHasRole = useComplianceHasRole;
+exports.useComplianceInfo = useComplianceInfo;
+exports.useComplianceManager = useComplianceManager;
+exports.useComplianceManagerOf = useComplianceManagerOf;
+exports.useComplianceRenounceRole = useComplianceRenounceRole;
+exports.useComplianceRevokeRole = useComplianceRevokeRole;
+exports.useComplianceRoleConstants = useComplianceRoleConstants;
+exports.useComplianceRoleMembers = useComplianceRoleMembers;
+exports.useCreateAndFundEcdsaAirdrop = useCreateAndFundEcdsaAirdrop;
+exports.useCreateAndFundMerkleAirdrop = useCreateAndFundMerkleAirdrop;
+exports.useCreateEcdsaAirdrop = useCreateEcdsaAirdrop;
+exports.useCreateMerkleAirdrop = useCreateMerkleAirdrop;
+exports.useDiscloseHandleToParty = useDiscloseHandleToParty;
+exports.useEcdsaClaim = useEcdsaClaim;
+exports.useEcdsaClaimAndUnwrap = useEcdsaClaimAndUnwrap;
+exports.useEcdsaDomain = useEcdsaDomain;
+exports.useEffectiveDelegateToCompliance = useEffectiveDelegateToCompliance;
+exports.useEffectiveUpgradeable = useEffectiveUpgradeable;
+exports.useEncryptCampaignAmounts = useEncryptCampaignAmounts;
 exports.useExtendClaimWindow = useExtendClaimWindow;
-exports.useFactoryCustomFee = useFactoryCustomFee;
-exports.useFactoryDefaultGasFee = useFactoryDefaultGasFee;
-exports.useFactoryFeeCollector = useFactoryFeeCollector;
-exports.useFactoryInitCodeHash = useFactoryInitCodeHash;
-exports.useFundConfidentialAirdrop = useFundConfidentialAirdrop;
-exports.useGetClaimAmount = useGetClaimAmount;
+exports.useFactoryFees = useFactoryFees;
+exports.useFactoryRegistry = useFactoryRegistry;
+exports.useFundAirdrop = useFundAirdrop;
+exports.useGrantInstanceRoles = useGrantInstanceRoles;
+exports.useIsActiveDelegate = useIsActiveDelegate;
+exports.useIsMerkleRootMutable = useIsMerkleRootMutable;
+exports.useIsSignatureValid = useIsSignatureValid;
+exports.useMerkleClaim = useMerkleClaim;
+exports.useMerkleClaimAndUnwrap = useMerkleClaimAndUnwrap;
+exports.useMerkleRoot = useMerkleRoot;
+exports.usePlanMerkleCampaign = usePlanMerkleCampaign;
+exports.usePreflightClaim = usePreflightClaim;
 exports.usePreflightCreateAirdrop = usePreflightCreateAirdrop;
-exports.useSetCustomFee = useSetCustomFee;
-exports.useSetDefaultGasFee = useSetDefaultGasFee;
-exports.useSetFeeCollector = useSetFeeCollector;
-exports.useSetPaused = useSetPaused;
+exports.useRescueERC20 = useRescueERC20;
+exports.useRescueOtherConfidentialToken = useRescueOtherConfidentialToken;
+exports.useRevokeComplianceDelegate = useRevokeComplianceDelegate;
+exports.useRotateMerkleRoot = useRotateMerkleRoot;
+exports.useSetMerkleRoot = useSetMerkleRoot;
 exports.useSignClaimAuthorization = useSignClaimAuthorization;
-exports.useWithdraw = useWithdraw;
-exports.useWithdrawOtherConfidentialToken = useWithdrawOtherConfidentialToken;
-exports.useWithdrawOtherToken = useWithdrawOtherToken;
+exports.useWithdrawConfidential = useWithdrawConfidential;
+exports.useWithdrawGasFee = useWithdrawGasFee;