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

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

@@ -1,19 +1,22 @@
-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 { grantInstanceRoles, buildMerkleCampaign, encryptCampaignAmounts, planMerkleCampaign, rotateMerkleRoot } from '../../chunk-GADGBQJO.js';
+export { buildMerkleCampaign, buildMerkleTree, encryptCampaignAmounts, grantInstanceRoles, leafOf, planInstanceRoleSplit, planMerkleCampaign, rotateMerkleRoot, validateCampaignRecipients } from '../../chunk-GADGBQJO.js';
+import { useMemoAirdropBaseClient, airdropQueryKey, useMemoMerkleAirdropClient, useMemoAirdropFactoryClient, airdropKeys, useMemoEcdsaAirdropClient, useMemoComplianceManagerClient, AIRDROP_FN, airdropQueryKeyPrefix } from '../../chunk-EYDA6Q6C.js';
+export { airdropQueryKey, airdropQueryKeyPrefix } from '../../chunk-EYDA6Q6C.js';
+import { resolveEncryptor, signClaimAuthorization } from '../../chunk-X7WBPCEU.js';
+export { encryptUint64, encryptUint64Batch, resolveEncryptor, signClaimAuthorization } from '../../chunk-X7WBPCEU.js';
+import { preflightClaim, preflightCreate } from '../../chunk-VW356KR3.js';
+export { AlreadyClaimedError, ClaimNotStartedError, ClaimWindowClosedError, DedupIdConsumedError, FeeCollectorSelfAdministeredError, MerkleUupsUnsupportedError, NonStockWrapperError, PredictionDriftError, SaltCollisionError, SignatureExpiredError, UnauthorizedRedirectError, UpgradeabilityNotAllowedError, preflightClaim, preflightCreate } from '../../chunk-VW356KR3.js';
 import '../../chunk-ZWXJTBZO.js';
 import '../../chunk-NWFMBLSQ.js';
 import '../../chunk-4RAAATVY.js';
-import '../../chunk-DZHYSUGY.js';
+import '../../chunk-A4DCEE33.js';
 import '../../chunk-ZA673I3O.js';
 import '../../chunk-KWFFIJYX.js';
-import { MissingClientError } from '../../chunk-QBJ7O2B4.js';
+import { MissingClientError, MissingWalletClientError } 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 '../../chunk-Q2GP5UDC.js';
 import { useQuery, useQueryClient, useMutation } from '@tanstack/react-query';
+import { useRef } from 'react';
 
 function useAirdropToken(args) {
   const { client, chainId } = useMemoAirdropBaseClient(args);
@@ -164,6 +167,358 @@ function useEffectiveUpgradeable(args = {}) {
     enabled: Boolean(client && creator && (args.query?.enabled ?? true))
   });
 }
+function useAirdropConfig(args) {
+  const { client, chainId } = useMemoAirdropBaseClient(args);
+  return useQuery({
+    staleTime: Infinity,
+    ...args.query,
+    queryKey: 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 useAirdropDeploymentMode(args) {
+  const { client, chainId } = useMemoAirdropBaseClient(args);
+  return useQuery({
+    staleTime: Infinity,
+    ...args.query,
+    queryKey: 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 } = useMemoAirdropBaseClient(base);
+  return useQuery({
+    // A default, not a lock: `query.staleTime` still wins.
+    staleTime: Infinity,
+    ...args.query,
+    queryKey: 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 } = useMemoAirdropBaseClient(base);
+  const { client: merkleClient } = useMemoMerkleAirdropClient(base);
+  const { client: ecdsaClient } = useMemoEcdsaAirdropClient({
+    ...base,
+    dedupMode: dedupMode ?? "none"
+  });
+  return 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: 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 } = useMemoAirdropBaseClient(base);
+  return useQuery({
+    ...args.query,
+    queryKey: 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 } = useMemoComplianceManagerClient(base);
+  return useQuery({
+    ...args.query,
+    queryKey: 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 } = useMemoComplianceManagerClient(args);
+  return useQuery({
+    ...args.query,
+    queryKey: 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 useComplianceManagerOf(args = {}) {
+  const { airdrop, ...base } = args;
+  const { client, chainId, resolvedAddress } = useMemoAirdropFactoryClient(base);
+  return useQuery({
+    staleTime: Infinity,
+    ...args.query,
+    queryKey: 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 } = useMemoComplianceManagerClient(args);
+  return useQuery({
+    // A default, not a lock: `query.staleTime` still wins.
+    staleTime: Infinity,
+    ...args.query,
+    queryKey: 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 } = useMemoComplianceManagerClient(base);
+  return useQuery({
+    ...args.query,
+    queryKey: 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 } = useMemoEcdsaAirdropClient(args);
+  return 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: 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 } = useMemoAirdropFactoryClient(base);
+  return useQuery({
+    ...args.query,
+    queryKey: airdropQueryKey({
+      chainId,
+      address: resolvedAddress,
+      fn: "effectiveDelegateToCompliance",
+      args: [creator]
+    }),
+    queryFn: () => client.effectiveDelegateToCompliance(creator),
+    enabled: Boolean(client && creator && (args.query?.enabled ?? true))
+  });
+}
+function useIsActiveDelegate(args) {
+  const { delegate, ...base } = args;
+  const { client, chainId } = useMemoComplianceManagerClient(base);
+  return useQuery({
+    ...args.query,
+    queryKey: 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 } = useMemoMerkleAirdropClient(args);
+  return useQuery({
+    // Before the spread so a consumer can still opt into refetching.
+    staleTime: Infinity,
+    ...args.query,
+    queryKey: 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 } = useMemoEcdsaAirdropClient(base);
+  return useQuery({
+    ...args.query,
+    queryKey: airdropQueryKey({
+      chainId,
+      address: args.address,
+      fn: 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 } = useMemoMerkleAirdropClient(base);
+  const { client: ecdsaClient } = useMemoEcdsaAirdropClient({
+    ...base,
+    dedupMode: dedupMode ?? "none"
+  });
+  const client = variant === "ecdsa" ? ecdsaClient : merkleClient;
+  return useQuery({
+    ...args.query,
+    queryKey: airdropQueryKey({
+      chainId,
+      address: args.address,
+      fn: "preflightClaim",
+      args: [variant, claimant, account, to, entrypoint, signature]
+    }),
+    queryFn: () => preflightClaim({
+      airdrop: client,
+      claimant,
+      account,
+      to,
+      entrypoint,
+      signature
+    }),
+    enabled: Boolean(client && claimant && (args.query?.enabled ?? true))
+  });
+}
+function usePreflightCreateAirdrop(args = {}) {
+  const { client, chainId, resolvedAddress } = useMemoAirdropFactoryClient(args);
+  return useQuery({
+    ...args.query,
+    queryKey: airdropQueryKey({
+      chainId,
+      address: resolvedAddress,
+      fn: 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
+      ]
+    }),
+    queryFn: () => {
+      const common = {
+        factory: client,
+        mode: args.mode,
+        creator: args.creator,
+        userSalt: args.userSalt,
+        expectedInitCodeHash: args.expectedInitCodeHash
+      };
+      return args.variant === "merkle" ? preflightCreate({ ...common, variant: "merkle", params: args.params }) : 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 useCreateEcdsaAirdrop(options = {}) {
   const { client, resolutionError, chainId, resolvedAddress } = useMemoAirdropFactoryClient(options);
   const queryClient = useQueryClient();
@@ -210,18 +565,24 @@ function useFundAirdrop(options = {}) {
   });
 }
 function useEcdsaClaim(options) {
-  const { client } = useMemoEcdsaAirdropClient(options);
+  const { client, chainId } = useMemoEcdsaAirdropClient(options);
+  const queryClient = useQueryClient();
   return useMutation({
     mutationFn: async (args) => {
       if (!client) {
         throw new MissingClientError("useEcdsaClaim", "ecdsa-airdrop");
       }
       return client.claim(args);
+    },
+    onSuccess: () => {
+      void queryClient.invalidateQueries({
+        queryKey: airdropKeys.isSignatureValidAll({ chainId, address: options.address })
+      });
     }
   });
 }
 function useMerkleClaim(options) {
-  const { client, chainId, walletClient } = useMemoMerkleAirdropClient(options);
+  const { client, chainId } = useMemoMerkleAirdropClient(options);
   const queryClient = useQueryClient();
   return useMutation({
     mutationFn: async (args) => {
@@ -230,20 +591,15 @@ function useMerkleClaim(options) {
       }
       return client.claim(args);
     },
-    onMutate: (variables) => {
-      const account = variables.account ?? walletClient?.account;
-      return {
-        claimant: account ? typeof account === "string" ? account : account.address : void 0
-      };
-    },
+    onMutate: (variables) => ({ account: variables.entry.account }),
     onSuccess: (_hash, _variables, context) => {
-      if (!context?.claimant) return;
+      if (!context?.account) return;
       void queryClient.invalidateQueries({
         queryKey: airdropQueryKey({
           chainId,
           address: options.address,
           fn: "getClaimedAmount",
-          args: [context.claimant]
+          args: [context.account]
         })
       });
     }
@@ -286,9 +642,9 @@ function useGrantInstanceRoles(options) {
       });
     },
     onSuccess: () => {
-      void queryClient.invalidateQueries({
-        queryKey: airdropQueryKeyPrefix({ chainId, address: options.address, fn: "hasRole" })
-      });
+      const scope = { chainId, address: options.address };
+      void queryClient.invalidateQueries({ queryKey: airdropKeys.hasRoleAll(scope) });
+      void queryClient.invalidateQueries({ queryKey: airdropKeys.roleMembersAll(scope) });
     }
   });
 }
@@ -340,5 +696,452 @@ function useWithdrawConfidential(options) {
     }
   });
 }
+function useAddComplianceDelegate(options) {
+  const { client, chainId } = useMemoComplianceManagerClient(options);
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: async (args) => {
+      if (!client) {
+        throw new MissingClientError("useAddComplianceDelegate", "compliance-manager");
+      }
+      return client.addDelegate(args);
+    },
+    onSuccess: (_hash, variables) => {
+      const scope = { chainId, address: options.address };
+      void queryClient.invalidateQueries({ queryKey: airdropKeys.complianceInfo(scope) });
+      void queryClient.invalidateQueries({
+        queryKey: airdropKeys.activeDelegate(scope, variables.delegate)
+      });
+    }
+  });
+}
+function useAirdropGrantRole(options) {
+  const { client, chainId } = useMemoAirdropBaseClient(options);
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: async (args) => {
+      if (!client) {
+        throw new MissingClientError("useAirdropGrantRole", "airdrop-base");
+      }
+      return client.grantRole(args);
+    },
+    onSuccess: (_hash, variables) => {
+      const scope = { chainId, address: options.address };
+      void queryClient.invalidateQueries({
+        queryKey: airdropKeys.hasRole(scope, variables.role, variables.holder)
+      });
+      void queryClient.invalidateQueries({
+        queryKey: airdropKeys.roleMembers(scope, variables.role)
+      });
+    }
+  });
+}
+function useAirdropRenounceRole(options) {
+  const { client, chainId } = useMemoAirdropBaseClient(options);
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: async (args) => {
+      if (!client) {
+        throw new MissingClientError("useAirdropRenounceRole", "airdrop-base");
+      }
+      return client.renounceRole(args);
+    },
+    onSuccess: (_hash, variables) => {
+      const scope = { chainId, address: options.address };
+      void queryClient.invalidateQueries({ queryKey: airdropKeys.hasRoleAll(scope) });
+      void queryClient.invalidateQueries({
+        queryKey: airdropKeys.roleMembers(scope, variables.role)
+      });
+    }
+  });
+}
+function useAirdropRevokeRole(options) {
+  const { client, chainId } = useMemoAirdropBaseClient(options);
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: async (args) => {
+      if (!client) {
+        throw new MissingClientError("useAirdropRevokeRole", "airdrop-base");
+      }
+      return client.revokeRole(args);
+    },
+    onSuccess: (_hash, variables) => {
+      const scope = { chainId, address: options.address };
+      void queryClient.invalidateQueries({
+        queryKey: airdropKeys.hasRole(scope, variables.role, variables.holder)
+      });
+      void queryClient.invalidateQueries({
+        queryKey: airdropKeys.roleMembers(scope, variables.role)
+      });
+    }
+  });
+}
+function useAirdropUpgradeToAndCall(options) {
+  const { client } = useMemoAirdropBaseClient(options);
+  return useMutation({
+    mutationFn: async (args) => {
+      if (!client) {
+        throw new MissingClientError("useAirdropUpgradeToAndCall", "airdrop-base");
+      }
+      return client.upgradeToAndCall(args);
+    }
+  });
+}
+function useBatchDiscloseHandlesToParty(options) {
+  const { client } = useMemoAirdropBaseClient(options);
+  return useMutation({
+    mutationFn: async (args) => {
+      if (!client) {
+        throw new MissingClientError("useBatchDiscloseHandlesToParty", "airdrop-base");
+      }
+      return client.batchDiscloseHandlesToParty(args);
+    }
+  });
+}
+function useBuildMerkleCampaign(options = {}) {
+  const encryptorSourceRef = useRef(options.encryptor);
+  encryptorSourceRef.current = options.encryptor;
+  return useMutation({
+    mutationFn: async (args) => buildMerkleCampaign({
+      instance: args.instance,
+      recipients: args.recipients,
+      encryptor: () => resolveEncryptor(encryptorSourceRef.current),
+      ...args.submitter !== void 0 ? { submitter: args.submitter } : {}
+    })
+  });
+}
+function useComplianceGrantRole(options) {
+  const { client, chainId } = useMemoComplianceManagerClient(options);
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: async (args) => {
+      if (!client) {
+        throw new MissingClientError("useComplianceGrantRole", "compliance-manager");
+      }
+      return client.grantRole(args);
+    },
+    onSuccess: (_hash, variables) => {
+      const scope = { chainId, address: options.address };
+      void queryClient.invalidateQueries({
+        queryKey: airdropKeys.complianceHasRole(scope, variables.role, variables.holder)
+      });
+      void queryClient.invalidateQueries({
+        queryKey: airdropKeys.complianceRoleMembers(scope, variables.role)
+      });
+    }
+  });
+}
+function useComplianceRenounceRole(options) {
+  const { client, chainId } = useMemoComplianceManagerClient(options);
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: async (args) => {
+      if (!client) {
+        throw new MissingClientError("useComplianceRenounceRole", "compliance-manager");
+      }
+      return client.renounceRole(args);
+    },
+    onSuccess: (_hash, variables) => {
+      const scope = { chainId, address: options.address };
+      void queryClient.invalidateQueries({ queryKey: airdropKeys.complianceHasRoleAll(scope) });
+      void queryClient.invalidateQueries({
+        queryKey: airdropKeys.complianceRoleMembers(scope, variables.role)
+      });
+    }
+  });
+}
+function useComplianceRevokeRole(options) {
+  const { client, chainId } = useMemoComplianceManagerClient(options);
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: async (args) => {
+      if (!client) {
+        throw new MissingClientError("useComplianceRevokeRole", "compliance-manager");
+      }
+      return client.revokeRole(args);
+    },
+    onSuccess: (_hash, variables) => {
+      const scope = { chainId, address: options.address };
+      void queryClient.invalidateQueries({
+        queryKey: airdropKeys.complianceHasRole(scope, variables.role, variables.holder)
+      });
+      void queryClient.invalidateQueries({
+        queryKey: airdropKeys.complianceRoleMembers(scope, variables.role)
+      });
+    }
+  });
+}
+function useCreateAndFundEcdsaAirdrop(options = {}) {
+  const { client, resolutionError, chainId, resolvedAddress } = useMemoAirdropFactoryClient(options);
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: async (args) => {
+      if (!client) {
+        throw resolutionError ?? new MissingClientError("useCreateAndFundEcdsaAirdrop", "factory");
+      }
+      return client.createAndFundEcdsaAirdrop(args);
+    },
+    onSuccess: () => {
+      void queryClient.invalidateQueries({
+        queryKey: airdropKeys.registryAll({ chainId, address: resolvedAddress })
+      });
+    }
+  });
+}
+function useCreateAndFundMerkleAirdrop(options = {}) {
+  const { client, resolutionError, chainId, resolvedAddress } = useMemoAirdropFactoryClient(options);
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: async (args) => {
+      if (!client) {
+        throw resolutionError ?? new MissingClientError("useCreateAndFundMerkleAirdrop", "factory");
+      }
+      return client.createAndFundMerkleAirdrop(args);
+    },
+    onSuccess: () => {
+      void queryClient.invalidateQueries({
+        queryKey: airdropKeys.registryAll({ chainId, address: resolvedAddress })
+      });
+    }
+  });
+}
+function useDiscloseHandleToParty(options) {
+  const { client } = useMemoAirdropBaseClient(options);
+  return useMutation({
+    mutationFn: async (args) => {
+      if (!client) {
+        throw new MissingClientError("useDiscloseHandleToParty", "airdrop-base");
+      }
+      return client.discloseHandleToParty(args);
+    }
+  });
+}
+function useEcdsaClaimAndUnwrap(options) {
+  const { client, chainId } = useMemoEcdsaAirdropClient(options);
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: async (args) => {
+      if (!client) {
+        throw new MissingClientError("useEcdsaClaimAndUnwrap", "ecdsa-airdrop");
+      }
+      return client.claimAndUnwrap(args);
+    },
+    onSuccess: () => {
+      void queryClient.invalidateQueries({
+        queryKey: airdropKeys.isSignatureValidAll({ chainId, address: options.address })
+      });
+    }
+  });
+}
+function useEncryptCampaignAmounts(options = {}) {
+  const encryptorSourceRef = useRef(options.encryptor);
+  encryptorSourceRef.current = options.encryptor;
+  return useMutation({
+    mutationFn: async (args) => encryptCampaignAmounts({
+      instance: args.instance,
+      recipients: args.recipients,
+      encryptor: () => resolveEncryptor(encryptorSourceRef.current),
+      ...args.submitter !== void 0 ? { submitter: args.submitter } : {}
+    })
+  });
+}
+function useMerkleClaimAndUnwrap(options) {
+  const { client, walletClient, chainId } = useMemoMerkleAirdropClient(options);
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: async (args) => {
+      if (!client) {
+        throw new 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: airdropKeys.claimedAmount({ chainId, address: options.address }, context.sender)
+      });
+    }
+  });
+}
+function usePlanMerkleCampaign(options = {}) {
+  const { client, resolutionError } = useMemoAirdropFactoryClient(options);
+  const encryptorSourceRef = useRef(options.encryptor);
+  encryptorSourceRef.current = options.encryptor;
+  return useMutation({
+    mutationFn: async (args) => {
+      if (!client) {
+        throw resolutionError ?? new MissingClientError("usePlanMerkleCampaign", "factory");
+      }
+      return planMerkleCampaign({
+        factory: client,
+        ...args,
+        encryptor: () => resolveEncryptor(encryptorSourceRef.current)
+      });
+    }
+  });
+}
+function useRescueERC20(options) {
+  const { client } = useMemoAirdropBaseClient(options);
+  return useMutation({
+    mutationFn: async (args) => {
+      if (!client) {
+        throw new MissingClientError("useRescueERC20", "airdrop-base");
+      }
+      return client.rescueERC20(args);
+    }
+  });
+}
+function useRescueOtherConfidentialToken(options) {
+  const { client } = useMemoAirdropBaseClient(options);
+  return useMutation({
+    mutationFn: async (args) => {
+      if (!client) {
+        throw new MissingClientError("useRescueOtherConfidentialToken", "airdrop-base");
+      }
+      return client.rescueOtherConfidentialToken(args);
+    }
+  });
+}
+function useRevokeComplianceDelegate(options) {
+  const { client, chainId } = useMemoComplianceManagerClient(options);
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: async (args) => {
+      if (!client) {
+        throw new MissingClientError("useRevokeComplianceDelegate", "compliance-manager");
+      }
+      return client.revokeDelegate(args);
+    },
+    onSuccess: (_hash, variables) => {
+      const scope = { chainId, address: options.address };
+      void queryClient.invalidateQueries({ queryKey: airdropKeys.complianceInfo(scope) });
+      void queryClient.invalidateQueries({
+        queryKey: airdropKeys.activeDelegate(scope, variables.delegate)
+      });
+    }
+  });
+}
+function useRotateMerkleRoot(options) {
+  const { client, chainId } = useMemoMerkleAirdropClient(options);
+  const encryptorSourceRef = useRef(options.encryptor);
+  encryptorSourceRef.current = options.encryptor;
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: async (args) => {
+      if (!client) {
+        throw new MissingClientError("useRotateMerkleRoot", "merkle-airdrop");
+      }
+      return rotateMerkleRoot({
+        airdrop: client,
+        recipients: args.recipients,
+        encryptor: () => resolveEncryptor(encryptorSourceRef.current),
+        ...args.submitter !== void 0 ? { submitter: args.submitter } : {},
+        ...args.account !== void 0 ? { account: args.account } : {}
+      });
+    },
+    onSuccess: () => {
+      void queryClient.invalidateQueries({
+        queryKey: airdropKeys.merkleRoot({ chainId, address: options.address })
+      });
+    }
+  });
+}
+function useSignClaimAuthorization(options) {
+  const { walletClient, chainId } = useMemoAirdropBaseClient(options);
+  return useMutation({
+    mutationFn: async (args) => {
+      if (!walletClient) {
+        throw new MissingWalletClientError("useSignClaimAuthorization");
+      }
+      if (chainId === void 0) {
+        throw new MissingClientError("useSignClaimAuthorization", "airdrop-base");
+      }
+      return signClaimAuthorization({
+        walletClient,
+        airdrop: options.address,
+        chainId,
+        recipient: args.recipient,
+        encryptedAmountHandle: args.encryptedAmountHandle,
+        dedupId: args.dedupId,
+        deadline: args.deadline,
+        account: args.account
+      });
+    }
+  });
+}
+function useWithdrawGasFee(options) {
+  const { client } = useMemoAirdropBaseClient(options);
+  return useMutation({
+    mutationFn: async (args) => {
+      if (!client) {
+        throw new MissingClientError("useWithdrawGasFee", "airdrop-base");
+      }
+      return client.withdrawGasFee(args);
+    }
+  });
+}
+function useAdminBatchDiscloseBalanceToParties(options) {
+  const { client } = useMemoAirdropBaseClient(options);
+  return useMutation({
+    mutationFn: async (args) => {
+      if (!client) {
+        throw new MissingClientError("useAdminBatchDiscloseBalanceToParties", "airdrop-base");
+      }
+      return client.adminBatchDiscloseBalanceToParties(args);
+    }
+  });
+}
+function useAdminDiscloseBalanceToParty(options) {
+  const { client } = useMemoAirdropBaseClient(options);
+  return useMutation({
+    mutationFn: async (args) => {
+      if (!client) {
+        throw new MissingClientError("useAdminDiscloseBalanceToParty", "airdrop-base");
+      }
+      return client.adminDiscloseBalanceToParty(args);
+    }
+  });
+}
+function useAdminGetCurrentBalance(options) {
+  const { client } = useMemoAirdropBaseClient(options);
+  return useMutation({
+    mutationFn: async (args) => {
+      if (!client) {
+        throw new MissingClientError("useAdminGetCurrentBalance", "airdrop-base");
+      }
+      return client.adminGetCurrentBalance(args ?? {});
+    }
+  });
+}
+function useAccessEcdsaClaimAmount(options) {
+  const { client } = useMemoEcdsaAirdropClient(options);
+  return useMutation({
+    mutationFn: async (args) => {
+      if (!client) {
+        throw new MissingClientError("useAccessEcdsaClaimAmount", "ecdsa-airdrop");
+      }
+      return client.getClaimAmount(args);
+    }
+  });
+}
+function useAccessMerkleClaimAmount(options) {
+  const { client } = useMemoMerkleAirdropClient(options);
+  return useMutation({
+    mutationFn: async (args) => {
+      if (!client) {
+        throw new MissingClientError("useAccessMerkleClaimAmount", "merkle-airdrop");
+      }
+      return client.getClaimAmount(args);
+    }
+  });
+}
 
-export { useAirdropGasFee, useAirdropHasRole, useAirdropPause, useAirdropPaused, useAirdropToken, useAirdropWindow, useClaimedAmount, useComplianceManager, useCreateEcdsaAirdrop, useCreateMerkleAirdrop, useEcdsaClaim, useEffectiveUpgradeable, useExtendClaimWindow, useFactoryFees, useFactoryRegistry, useFundAirdrop, useGrantInstanceRoles, useMerkleClaim, useMerkleRoot, useSetMerkleRoot, useWithdrawConfidential };
+export { useAccessEcdsaClaimAmount, useAccessMerkleClaimAmount, useAddComplianceDelegate, useAdminBatchDiscloseBalanceToParties, useAdminDiscloseBalanceToParty, useAdminGetCurrentBalance, useAirdropConfig, useAirdropDeploymentMode, useAirdropGasFee, useAirdropGrantRole, useAirdropHasRole, useAirdropPause, useAirdropPaused, useAirdropRenounceRole, useAirdropRevokeRole, useAirdropRoleAdmin, useAirdropRoleConstants, useAirdropRoleMembers, useAirdropToken, useAirdropUpgradeToAndCall, useAirdropWindow, useBatchDiscloseHandlesToParty, useBuildMerkleCampaign, useClaimedAmount, useComplianceGrantRole, useComplianceHasRole, useComplianceInfo, useComplianceManager, useComplianceManagerOf, useComplianceRenounceRole, useComplianceRevokeRole, useComplianceRoleConstants, useComplianceRoleMembers, useCreateAndFundEcdsaAirdrop, useCreateAndFundMerkleAirdrop, useCreateEcdsaAirdrop, useCreateMerkleAirdrop, useDiscloseHandleToParty, useEcdsaClaim, useEcdsaClaimAndUnwrap, useEcdsaDomain, useEffectiveDelegateToCompliance, useEffectiveUpgradeable, useEncryptCampaignAmounts, useExtendClaimWindow, useFactoryFees, useFactoryRegistry, useFundAirdrop, useGrantInstanceRoles, useIsActiveDelegate, useIsMerkleRootMutable, useIsSignatureValid, useMerkleClaim, useMerkleClaimAndUnwrap, useMerkleRoot, usePlanMerkleCampaign, usePreflightClaim, usePreflightCreateAirdrop, useRescueERC20, useRescueOtherConfidentialToken, useRevokeComplianceDelegate, useRotateMerkleRoot, useSetMerkleRoot, useSignClaimAuthorization, useWithdrawConfidential, useWithdrawGasFee };