@tokenops/sdk 1.5.1 → 2.0.0-alpha.1

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

@@ -1,455 +1,344 @@
-import { useMemoFactoryClient, buildQueryKey, useMemoAirdropClient } from '../../chunk-ORFTDNFZ.js';
-export { AlreadyClaimedError, ClaimNotStartedError, ClaimWindowClosedError } from '../../chunk-6R4KNAPK.js';
-import { signClaimAuthorization } from '../../chunk-DUZIIRPF.js';
-export { encryptUint64, encryptUint64Batch, resolveEncryptor, signClaimAuthorization } from '../../chunk-DUZIIRPF.js';
-import { useWagmiAccount } from '../../chunk-FT4LNBOS.js';
+import { grantInstanceRoles } from '../../chunk-456VDDA3.js';
+export { buildMerkleCampaign, buildMerkleTree, encryptCampaignAmounts, grantInstanceRoles, leafOf, planInstanceRoleSplit, planMerkleCampaign, rotateMerkleRoot, validateCampaignRecipients } from '../../chunk-456VDDA3.js';
+import { useMemoAirdropBaseClient, airdropQueryKey, useMemoMerkleAirdropClient, useMemoAirdropFactoryClient, airdropQueryKeyPrefix, useMemoEcdsaAirdropClient } from '../../chunk-VP2B4WM2.js';
+export { airdropQueryKey, airdropQueryKeyPrefix } from '../../chunk-VP2B4WM2.js';
+export { encryptUint64, encryptUint64Batch, resolveEncryptor, signClaimAuthorization } from '../../chunk-GKKDAW44.js';
+export { AlreadyClaimedError, ClaimNotStartedError, ClaimWindowClosedError, DedupIdConsumedError, FeeCollectorSelfAdministeredError, MerkleUupsUnsupportedError, NonStockWrapperError, PredictionDriftError, SaltCollisionError, SignatureExpiredError, UpgradeabilityNotAllowedError, preflightClaim, preflightCreate } from '../../chunk-O5676ZWY.js';
 import '../../chunk-ZWXJTBZO.js';
-import '../../chunk-7VELUOMI.js';
-import '../../chunk-SG65XWH7.js';
-import '../../chunk-XGGTQQFH.js';
+import '../../chunk-NWFMBLSQ.js';
+import '../../chunk-4RAAATVY.js';
+import '../../chunk-DZHYSUGY.js';
 import '../../chunk-ZA673I3O.js';
-import '../../chunk-Q2GP5UDC.js';
 import '../../chunk-KWFFIJYX.js';
-import { MissingClientError, MissingWalletClientError } from '../../chunk-QBJ7O2B4.js';
+import { MissingClientError } from '../../chunk-QBJ7O2B4.js';
 export { AccessDeniedError, AlreadyInitializedError, BatchTooLargeError, ContractRevertError, DecryptionFailedError, DeploymentAddressUnavailableError, EncryptionFailedError, FeatureDisabledError, FheHandleNotAllowedError, InsufficientBalanceError, InsufficientFeeError, InsufficientGasFundsError, InvalidArgumentError, InvalidSignatureError, MissingAccountError, MissingClientError, MissingEncryptorError, MissingPublicClientError, MissingWalletClientError, NetworkError, OperatorNotApprovedError, PausedError, ReceiptEventAmbiguousError, ReceiptEventNotFoundError, ReentrancyError, RelayerUnreachableError, SigningFailedError, TokenOpsSdkError, TransferFailedError, UnknownWriteFailureError, UnsupportedChainError, UserDecryptNotAllowedError, UserRejectedSignatureError, WalletChainMismatchError, WalletRejectedError, isTokenOpsSdkError } from '../../chunk-QBJ7O2B4.js';
-import { useQuery, useMutation } from '@tanstack/react-query';
-import { useWalletClient } from 'wagmi';
+import '../../chunk-Q2GP5UDC.js';
+import { useQuery, useQueryClient, useMutation } from '@tanstack/react-query';
 
-function useConfidentialAirdropFactoryImplementation(options = {}) {
-  const { client, chainId, resolvedAddress } = useMemoFactoryClient(options);
+function useAirdropToken(args) {
+  const { client, chainId } = useMemoAirdropBaseClient(args);
   return useQuery({
-    queryKey: buildQueryKey("factory:implementation", chainId, resolvedAddress),
-    queryFn: () => client.implementation(),
-    enabled: !!client,
-    staleTime: 0
+    ...args.query,
+    queryKey: airdropQueryKey({ chainId, address: args.address, fn: "token", args: [] }),
+    queryFn: () => client.token(),
+    enabled: Boolean(client && (args.query?.enabled ?? true))
   });
 }
-function useFactoryDefaultGasFee(options = {}) {
-  const { client, chainId, resolvedAddress } = useMemoFactoryClient(options);
+function useAirdropWindow(args) {
+  const { client, chainId } = useMemoAirdropBaseClient(args);
   return useQuery({
-    queryKey: buildQueryKey("factory:defaultGasFee", chainId, resolvedAddress),
-    queryFn: () => client.defaultGasFee(),
-    enabled: !!client,
-    staleTime: 0
+    ...args.query,
+    queryKey: 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 } = useMemoAirdropBaseClient(args);
+  return useQuery({
+    ...args.query,
+    queryKey: airdropQueryKey({ chainId, address: args.address, fn: "paused", args: [] }),
+    queryFn: () => client.paused(),
+    enabled: Boolean(client && (args.query?.enabled ?? true))
   });
 }
-function useFactoryFeeCollector(options = {}) {
-  const { client, chainId, resolvedAddress } = useMemoFactoryClient(options);
+function useAirdropGasFee(args) {
+  const { client, chainId } = useMemoAirdropBaseClient(args);
   return useQuery({
-    queryKey: buildQueryKey("factory:feeCollector", chainId, resolvedAddress),
-    queryFn: () => client.feeCollector(),
-    enabled: !!client,
-    staleTime: 0
+    ...args.query,
+    queryKey: airdropQueryKey({ chainId, address: args.address, fn: "gasFee", args: [] }),
+    queryFn: () => client.gasFee(),
+    enabled: Boolean(client && (args.query?.enabled ?? true))
   });
 }
-function useFactoryCustomFee(args = {}) {
-  const { creator, ...base } = args;
-  const { client, chainId, resolvedAddress } = useMemoFactoryClient(base);
+function useAirdropHasRole(args) {
+  const { role, holder, ...base } = args;
+  const { client, chainId } = useMemoAirdropBaseClient(base);
   return useQuery({
-    queryKey: buildQueryKey("factory:getCustomFee", chainId, resolvedAddress, creator),
-    queryFn: () => client.getCustomFee(creator),
-    enabled: !!client && !!creator,
-    staleTime: 0
+    ...args.query,
+    queryKey: 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 useFactoryInitCodeHash(args = {}) {
-  const { params, gasFee, ...base } = args;
-  const { client, chainId, resolvedAddress } = useMemoFactoryClient(base);
+function useMerkleRoot(args) {
+  const { client, chainId } = useMemoMerkleAirdropClient(args);
   return useQuery({
-    queryKey: buildQueryKey("factory:getInitCodeHash", chainId, resolvedAddress, params, gasFee),
-    queryFn: () => client.getInitCodeHash({ params, gasFee }),
-    enabled: !!client && !!params && gasFee !== void 0,
-    staleTime: 0
+    ...args.query,
+    queryKey: airdropQueryKey({ chainId, address: args.address, fn: "merkleRoot", args: [] }),
+    queryFn: () => client.merkleRoot(),
+    enabled: Boolean(client && (args.query?.enabled ?? true))
   });
 }
-function usePreflightCreateAirdrop(args = {}) {
-  const { params, creator, userSalt, funding, ...base } = args;
-  const { client, chainId, resolvedAddress } = useMemoFactoryClient(base);
+function useClaimedAmount(args) {
+  const { account, ...base } = args;
+  const { client, chainId } = useMemoMerkleAirdropClient(base);
   return useQuery({
-    queryKey: buildQueryKey(
-      "factory:preflightCreateAirdrop",
+    ...args.query,
+    queryKey: airdropQueryKey({
       chainId,
-      resolvedAddress,
-      creator,
-      params,
-      userSalt,
-      funding
-    ),
-    queryFn: () => client.preflightCreateAirdrop({
-      params,
-      creator,
-      ...userSalt !== void 0 ? { userSalt } : {},
-      ...funding !== void 0 ? { funding } : {}
+      address: args.address,
+      fn: "getClaimedAmount",
+      args: [account]
     }),
-    enabled: !!client && !!params && !!creator,
-    staleTime: 0
+    queryFn: () => client.getClaimedAmount(account),
+    enabled: Boolean(client && account && (args.query?.enabled ?? true))
   });
 }
-function useCreateConfidentialAirdropAndGetAddress(options = {}) {
-  const { client, resolutionError } = useMemoFactoryClient(options);
-  return useMutation({
-    mutationFn: async (args) => {
-      if (!client) {
-        throw resolutionError ?? new MissingClientError("useCreateConfidentialAirdropAndGetAddress", "factory");
-      }
-      return client.createConfidentialAirdropAndGetAddress(args);
-    }
+function useComplianceManager(args) {
+  const { client, chainId } = useMemoAirdropBaseClient(args);
+  return useQuery({
+    ...args.query,
+    queryKey: 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 } = useMemoAirdropFactoryClient(args);
+  return useQuery({
+    ...args.query,
+    queryKey: 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 } = useMemoAirdropFactoryClient(base);
+  return useQuery({
+    ...args.query,
+    queryKey: 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 } = useMemoAirdropFactoryClient(base);
+  return useQuery({
+    ...args.query,
+    queryKey: airdropQueryKey({
+      chainId,
+      address: resolvedAddress,
+      fn: "effectiveUpgradeable",
+      args: [creator]
+    }),
+    queryFn: () => client.effectiveUpgradeable(creator),
+    enabled: Boolean(client && creator && (args.query?.enabled ?? true))
   });
 }
-function useCreateConfidentialAirdrop(options = {}) {
-  const { client, resolutionError } = useMemoFactoryClient(options);
+function useCreateEcdsaAirdrop(options = {}) {
+  const { client, resolutionError, chainId, resolvedAddress } = useMemoAirdropFactoryClient(options);
+  const queryClient = useQueryClient();
   return useMutation({
     mutationFn: async (args) => {
       if (!client) {
-        throw resolutionError ?? new MissingClientError("useCreateConfidentialAirdrop", "factory");
+        throw resolutionError ?? new MissingClientError("useCreateEcdsaAirdrop", "factory");
       }
-      return client.createConfidentialAirdrop(args);
+      return client.createEcdsaAirdrop(args);
+    },
+    onSuccess: () => {
+      void queryClient.invalidateQueries({
+        queryKey: airdropQueryKeyPrefix({ chainId, address: resolvedAddress, fn: "registry" })
+      });
     }
   });
 }
-function useCreateAndFundConfidentialAirdrop(options = {}) {
-  const { client, resolutionError } = useMemoFactoryClient(options);
+function useCreateMerkleAirdrop(options = {}) {
+  const { client, resolutionError, chainId, resolvedAddress } = useMemoAirdropFactoryClient(options);
+  const queryClient = useQueryClient();
   return useMutation({
     mutationFn: async (args) => {
       if (!client) {
-        throw resolutionError ?? new MissingClientError("useCreateAndFundConfidentialAirdrop", "factory");
+        throw resolutionError ?? new MissingClientError("useCreateMerkleAirdrop", "factory");
       }
-      return client.createAndFundConfidentialAirdrop(args);
+      return client.createMerkleAirdrop(args);
+    },
+    onSuccess: () => {
+      void queryClient.invalidateQueries({
+        queryKey: airdropQueryKeyPrefix({ chainId, address: resolvedAddress, fn: "registry" })
+      });
     }
   });
 }
-function useCreateAndFundConfidentialAirdropAndGetAddress(options = {}) {
-  const { client, resolutionError } = useMemoFactoryClient(options);
+function useFundAirdrop(options = {}) {
+  const { client, resolutionError } = useMemoAirdropFactoryClient(options);
   return useMutation({
     mutationFn: async (args) => {
       if (!client) {
-        throw resolutionError ?? new MissingClientError("useCreateAndFundConfidentialAirdropAndGetAddress", "factory");
+        throw resolutionError ?? new MissingClientError("useFundAirdrop", "factory");
       }
-      return client.createAndFundConfidentialAirdropAndGetAddress(args);
+      return client.fundAirdrop(args);
     }
   });
 }
-function useFundConfidentialAirdrop(options = {}) {
-  const { client, resolutionError } = useMemoFactoryClient(options);
+function useEcdsaClaim(options) {
+  const { client } = useMemoEcdsaAirdropClient(options);
   return useMutation({
     mutationFn: async (args) => {
       if (!client) {
-        throw resolutionError ?? new MissingClientError("useFundConfidentialAirdrop", "factory");
+        throw new MissingClientError("useEcdsaClaim", "ecdsa-airdrop");
       }
-      return client.fundConfidentialAirdrop(args);
-    }
-  });
-}
-function useSetFeeCollector(options = {}) {
-  const { client, resolutionError } = useMemoFactoryClient(options);
-  return useMutation({
-    mutationFn: async ({ newFeeCollector, account }) => {
-      if (!client) throw resolutionError ?? new MissingClientError("useSetFeeCollector", "factory");
-      return client.setFeeCollector(newFeeCollector, account);
-    }
-  });
-}
-function useSetDefaultGasFee(options = {}) {
-  const { client, resolutionError } = useMemoFactoryClient(options);
-  return useMutation({
-    mutationFn: async ({ newGasFee, account }) => {
-      if (!client)
-        throw resolutionError ?? new MissingClientError("useSetDefaultGasFee", "factory");
-      return client.setDefaultGasFee(newGasFee, account);
-    }
-  });
-}
-function useSetCustomFee(options = {}) {
-  const { client, resolutionError } = useMemoFactoryClient(options);
-  return useMutation({
-    mutationFn: async ({ campaignCreator, gasFee, account }) => {
-      if (!client) throw resolutionError ?? new MissingClientError("useSetCustomFee", "factory");
-      return client.setCustomFee(campaignCreator, gasFee, account);
+      return client.claim(args);
     }
   });
 }
-function useDisableCustomFee(options = {}) {
-  const { client, resolutionError } = useMemoFactoryClient(options);
-  return useMutation({
-    mutationFn: async ({ campaignCreator, account }) => {
-      if (!client)
-        throw resolutionError ?? new MissingClientError("useDisableCustomFee", "factory");
-      return client.disableCustomFee(campaignCreator, account);
-    }
-  });
-}
-function useAirdropToken(options) {
-  const { client, chainId } = useMemoAirdropClient(options);
-  return useQuery({
-    queryKey: buildQueryKey("airdrop:TOKEN", chainId, options.address),
-    queryFn: () => client.token(),
-    enabled: !!client,
-    staleTime: 0
-  });
-}
-function useAirdropGasFee(options) {
-  const { client, chainId } = useMemoAirdropClient(options);
-  return useQuery({
-    queryKey: buildQueryKey("airdrop:GAS_FEE", chainId, options.address),
-    queryFn: () => client.gasFee(),
-    enabled: !!client,
-    staleTime: 0
-  });
-}
-function useAirdropStartTime(options) {
-  const { client, chainId } = useMemoAirdropClient(options);
-  return useQuery({
-    queryKey: buildQueryKey("airdrop:START_TIME", chainId, options.address),
-    queryFn: () => client.startTime(),
-    enabled: !!client,
-    staleTime: 0
-  });
-}
-function useAirdropCanExtendClaimWindow(options) {
-  const { client, chainId } = useMemoAirdropClient(options);
-  return useQuery({
-    queryKey: buildQueryKey("airdrop:CAN_EXTEND_CLAIM_WINDOW", chainId, options.address),
-    queryFn: () => client.canExtendClaimWindow(),
-    enabled: !!client,
-    staleTime: 0
-  });
-}
-function useAirdropEndTime(options) {
-  const { client, chainId } = useMemoAirdropClient(options);
-  return useQuery({
-    queryKey: buildQueryKey("airdrop:endTime", chainId, options.address),
-    queryFn: () => client.endTime(),
-    enabled: !!client,
-    staleTime: 0
-  });
-}
-function useAirdropIsPaused(options) {
-  const { client, chainId } = useMemoAirdropClient(options);
-  return useQuery({
-    queryKey: buildQueryKey("airdrop:isPaused", chainId, options.address),
-    queryFn: () => client.isPaused(),
-    enabled: !!client,
-    staleTime: 0
-  });
-}
-function useAirdropDeploymentBlockNumber(options) {
-  const { client, chainId } = useMemoAirdropClient(options);
-  return useQuery({
-    queryKey: buildQueryKey("airdrop:deploymentBlockNumber", chainId, options.address),
-    queryFn: () => client.deploymentBlockNumber(),
-    enabled: !!client,
-    staleTime: 0
-  });
-}
-function useAirdropDomainSeparator(options) {
-  const { client, chainId } = useMemoAirdropClient(options);
-  return useQuery({
-    queryKey: buildQueryKey("airdrop:DOMAIN_SEPARATOR", chainId, options.address),
-    queryFn: () => client.domainSeparator(),
-    enabled: !!client,
-    staleTime: 0
-  });
-}
-function useAirdropClaimTypehash(options) {
-  const { client, chainId } = useMemoAirdropClient(options);
-  return useQuery({
-    queryKey: buildQueryKey("airdrop:CLAIM_TYPEHASH", chainId, options.address),
-    queryFn: () => client.claimTypehash(),
-    enabled: !!client,
-    staleTime: 0
-  });
-}
-function useAirdropIsClaimWindowActive(options) {
-  const { client, chainId } = useMemoAirdropClient(options);
-  return useQuery({
-    queryKey: buildQueryKey("airdrop:isClaimWindowActive", chainId, options.address),
-    queryFn: () => client.isClaimWindowActive(),
-    enabled: !!client,
-    staleTime: 0
-  });
-}
-function useAirdropHasClaimStarted(options) {
-  const { client, chainId } = useMemoAirdropClient(options);
-  return useQuery({
-    queryKey: buildQueryKey("airdrop:hasClaimStarted", chainId, options.address),
-    queryFn: () => client.hasClaimStarted(),
-    enabled: !!client,
-    staleTime: 0
-  });
-}
-function useAirdropHasClaimEnded(options) {
-  const { client, chainId } = useMemoAirdropClient(options);
-  return useQuery({
-    queryKey: buildQueryKey("airdrop:hasClaimEnded", chainId, options.address),
-    queryFn: () => client.hasClaimEnded(),
-    enabled: !!client,
-    staleTime: 0
-  });
-}
-function useAirdropClaimedSignatures(args) {
-  const { signatureHash, ...base } = args;
-  const { client, chainId } = useMemoAirdropClient(base);
-  return useQuery({
-    queryKey: buildQueryKey("airdrop:claimedSignatures", chainId, base.address, signatureHash),
-    queryFn: () => client.claimedSignatures(signatureHash),
-    enabled: !!client && !!signatureHash,
-    staleTime: 0
-  });
-}
-function useAirdropIsSignatureClaimed(args) {
-  const { user, encryptedAmountHandle, ...base } = args;
-  const { client, chainId } = useMemoAirdropClient(base);
-  return useQuery({
-    queryKey: 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 } = useMemoAirdropClient(base);
-  const { address: connectedAddress } = useWagmiAccount();
-  const resolvedCaller = caller ?? connectedAddress;
-  return useQuery({
-    queryKey: buildQueryKey(
-      "airdrop:isSignatureValid",
-      chainId,
-      base.address,
-      encryptedAmountHandle,
-      signature,
-      resolvedCaller
-    ),
-    queryFn: () => client.isSignatureValid({
-      encryptedAmountHandle,
-      signature,
-      caller: resolvedCaller
-    }),
-    enabled: !!client && !!encryptedAmountHandle && !!signature && !!resolvedCaller,
-    staleTime: 0
-  });
-}
-function useAirdropHasRole(args) {
-  const { role, account, ...base } = args;
-  const { client, chainId } = useMemoAirdropClient(base);
-  return useQuery({
-    queryKey: buildQueryKey("airdrop:hasRole", chainId, base.address, role, account),
-    queryFn: () => client.hasRole(role, account),
-    enabled: !!client && !!role && !!account,
-    staleTime: 0
-  });
-}
-function useClaim(options) {
-  const { client } = useMemoAirdropClient(options);
+function useMerkleClaim(options) {
+  const { client, chainId, walletClient } = useMemoMerkleAirdropClient(options);
+  const queryClient = useQueryClient();
   return useMutation({
     mutationFn: async (args) => {
-      if (!client) throw new MissingClientError("useClaim", "airdrop");
+      if (!client) {
+        throw new MissingClientError("useMerkleClaim", "merkle-airdrop");
+      }
       return client.claim(args);
+    },
+    onMutate: (variables) => {
+      const account = variables.account ?? walletClient?.account;
+      return {
+        claimant: account ? typeof account === "string" ? account : account.address : void 0
+      };
+    },
+    onSuccess: (_hash, _variables, context) => {
+      if (!context?.claimant) return;
+      void queryClient.invalidateQueries({
+        queryKey: airdropQueryKey({
+          chainId,
+          address: options.address,
+          fn: "getClaimedAmount",
+          args: [context.claimant]
+        })
+      });
     }
   });
 }
-function useGetClaimAmount(options) {
-  const { client } = useMemoAirdropClient(options);
+function useSetMerkleRoot(options) {
+  const { client, chainId } = useMemoMerkleAirdropClient(options);
+  const queryClient = useQueryClient();
   return useMutation({
     mutationFn: async (args) => {
-      if (!client) throw new MissingClientError("useGetClaimAmount", "airdrop");
-      return client.getClaimAmount(args);
+      if (!client) {
+        throw new MissingClientError("useSetMerkleRoot", "merkle-airdrop");
+      }
+      return client.setMerkleRoot(args);
+    },
+    onSuccess: () => {
+      void queryClient.invalidateQueries({
+        queryKey: airdropQueryKey({
+          chainId,
+          address: options.address,
+          fn: "merkleRoot",
+          args: []
+        })
+      });
     }
   });
 }
-function useWithdraw(options) {
-  const { client } = useMemoAirdropClient(options);
+function useGrantInstanceRoles(options) {
+  const { client, chainId } = useMemoAirdropBaseClient(options);
+  const queryClient = useQueryClient();
   return useMutation({
-    mutationFn: async ({ recipient, account }) => {
-      if (!client) throw new MissingClientError("useWithdraw", "airdrop");
-      return client.withdraw(recipient, account);
+    mutationFn: async (args) => {
+      if (!client) {
+        throw new MissingClientError("useGrantInstanceRoles", "airdrop-base");
+      }
+      return grantInstanceRoles({
+        airdrop: client,
+        assignment: args.assignment,
+        ...args.revokeFromCreator !== void 0 ? { revokeFromCreator: args.revokeFromCreator } : {}
+      });
+    },
+    onSuccess: () => {
+      void queryClient.invalidateQueries({
+        queryKey: airdropQueryKeyPrefix({ chainId, address: options.address, fn: "hasRole" })
+      });
     }
   });
 }
-function useSetPaused(options) {
-  const { client } = useMemoAirdropClient(options);
+function useAirdropPause(options) {
+  const { client, chainId } = useMemoAirdropBaseClient(options);
+  const queryClient = useQueryClient();
   return useMutation({
-    mutationFn: async ({ paused, account }) => {
-      if (!client) throw new MissingClientError("useSetPaused", "airdrop");
-      return client.setPaused(paused, account);
+    mutationFn: async ({ paused, ...rest }) => {
+      if (!client) {
+        throw new MissingClientError("useAirdropPause", "airdrop-base");
+      }
+      return paused ? client.pause(rest) : client.unpause(rest);
+    },
+    onSuccess: () => {
+      void queryClient.invalidateQueries({
+        queryKey: airdropQueryKey({ chainId, address: options.address, fn: "paused", args: [] })
+      });
+      void queryClient.invalidateQueries({
+        queryKey: airdropQueryKey({ chainId, address: options.address, fn: "window", args: [] })
+      });
     }
   });
 }
 function useExtendClaimWindow(options) {
-  const { client } = useMemoAirdropClient(options);
+  const { client, chainId } = useMemoAirdropBaseClient(options);
+  const queryClient = useQueryClient();
   return useMutation({
-    mutationFn: async ({ newEndTime, account }) => {
-      if (!client) throw new MissingClientError("useExtendClaimWindow", "airdrop");
-      return client.extendClaimWindow(newEndTime, account);
-    }
-  });
-}
-function useWithdrawOtherToken(options) {
-  const { client } = useMemoAirdropClient(options);
-  return useMutation({
-    mutationFn: async ({ tokenAddress, recipient, account }) => {
-      if (!client) throw new MissingClientError("useWithdrawOtherToken", "airdrop");
-      return client.withdrawOtherToken(tokenAddress, recipient, account);
-    }
-  });
-}
-function useWithdrawOtherConfidentialToken(options) {
-  const { client } = useMemoAirdropClient(options);
-  return useMutation({
-    mutationFn: async ({ tokenAddress, recipient, account }) => {
-      if (!client) throw new MissingClientError("useWithdrawOtherConfidentialToken", "airdrop");
-      return client.withdrawOtherConfidentialToken(tokenAddress, recipient, account);
-    }
-  });
-}
-function useAirdropWithdrawGasFee(options) {
-  const { client } = useMemoAirdropClient(options);
-  return useMutation({
-    mutationFn: async ({ recipient, amount, account }) => {
-      if (!client) throw new MissingClientError("useAirdropWithdrawGasFee", "airdrop");
-      return client.withdrawGasFee(recipient, amount, account);
-    }
-  });
-}
-function useAirdropGrantRole(options) {
-  const { client } = useMemoAirdropClient(options);
-  return useMutation({
-    mutationFn: async ({ role, accountTarget, account }) => {
-      if (!client) throw new MissingClientError("useAirdropGrantRole", "airdrop");
-      return client.grantRole(role, accountTarget, account);
-    }
-  });
-}
-function useAirdropRevokeRole(options) {
-  const { client } = useMemoAirdropClient(options);
-  return useMutation({
-    mutationFn: async ({ role, accountTarget, account }) => {
-      if (!client) throw new MissingClientError("useAirdropRevokeRole", "airdrop");
-      return client.revokeRole(role, accountTarget, account);
+    mutationFn: async (args) => {
+      if (!client) {
+        throw new MissingClientError("useExtendClaimWindow", "airdrop-base");
+      }
+      return client.extendClaimWindow(args);
+    },
+    onSuccess: () => {
+      void queryClient.invalidateQueries({
+        queryKey: airdropQueryKey({ chainId, address: options.address, fn: "window", args: [] })
+      });
     }
   });
 }
-function useSignClaimAuthorization(options = {}) {
-  const { data: walletClient } = useWalletClient({ chainId: options.chainId });
+function useWithdrawConfidential(options) {
+  const { client } = useMemoAirdropBaseClient(options);
   return useMutation({
     mutationFn: async (args) => {
-      if (!walletClient) {
-        throw new MissingWalletClientError("useSignClaimAuthorization");
+      if (!client) {
+        throw new MissingClientError("useWithdrawConfidential", "airdrop-base");
       }
-      return signClaimAuthorization({
-        walletClient,
-        airdropAddress: args.airdropAddress,
-        recipient: args.recipient,
-        encryptedAmountHandle: args.encryptedAmountHandle
-      });
+      return client.withdrawConfidential(args);
     }
   });
 }
 
-export { useAirdropCanExtendClaimWindow, useAirdropClaimTypehash, useAirdropClaimedSignatures, useAirdropDeploymentBlockNumber, useAirdropDomainSeparator, useAirdropEndTime, useAirdropGasFee, useAirdropGrantRole, useAirdropHasClaimEnded, useAirdropHasClaimStarted, useAirdropHasRole, useAirdropIsClaimWindowActive, useAirdropIsPaused, useAirdropIsSignatureClaimed, useAirdropIsSignatureValid, useAirdropRevokeRole, useAirdropStartTime, useAirdropToken, useAirdropWithdrawGasFee, useClaim, useConfidentialAirdropFactoryImplementation, useCreateAndFundConfidentialAirdrop, useCreateAndFundConfidentialAirdropAndGetAddress, useCreateConfidentialAirdrop, useCreateConfidentialAirdropAndGetAddress, useDisableCustomFee, useExtendClaimWindow, useFactoryCustomFee, useFactoryDefaultGasFee, useFactoryFeeCollector, useFactoryInitCodeHash, useFundConfidentialAirdrop, useGetClaimAmount, usePreflightCreateAirdrop, useSetCustomFee, useSetDefaultGasFee, useSetFeeCollector, useSetPaused, useSignClaimAuthorization, useWithdraw, useWithdrawOtherConfidentialToken, useWithdrawOtherToken };
+export { useAirdropGasFee, useAirdropHasRole, useAirdropPause, useAirdropPaused, useAirdropToken, useAirdropWindow, useClaimedAmount, useComplianceManager, useCreateEcdsaAirdrop, useCreateMerkleAirdrop, useEcdsaClaim, useEffectiveUpgradeable, useExtendClaimWindow, useFactoryFees, useFactoryRegistry, useFundAirdrop, useGrantInstanceRoles, useMerkleClaim, useMerkleRoot, useSetMerkleRoot, useWithdrawConfidential };