@tokenops/sdk 1.6.0 → 2.0.0-alpha.2

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

@@ -1,59 +1,599 @@
-import { buildQueryKey } from '../../../chunk-CNP4L3GF.js';
-import '../../../chunk-S2XD75JM.js';
-import { createConfidentialAirdropFactoryAdvancedClient } from '../../../chunk-KSDSXJ34.js';
-import { resolveEncryptor } from '../../../chunk-UE5XK2SY.js';
-import '../../../chunk-YPYCWLYP.js';
-import '../../../chunk-7VELUOMI.js';
-import '../../../chunk-6WSNS3UV.js';
-import { DEPLOYED_ADDRESSES } from '../../../chunk-QKKBBH7I.js';
-import '../../../chunk-46T67CE2.js';
-import '../../../chunk-DRSPMIZ7.js';
+import { useMemoAirdropFactoryClient, airdropQueryKey, airdropKeys, airdropQueryKeyPrefix } from '../../../chunk-EYDA6Q6C.js';
+import '../../../chunk-X7WBPCEU.js';
+import '../../../chunk-VW356KR3.js';
+import '../../../chunk-ZWXJTBZO.js';
+import '../../../chunk-NWFMBLSQ.js';
+import '../../../chunk-4RAAATVY.js';
+import '../../../chunk-A4DCEE33.js';
+import '../../../chunk-ZA673I3O.js';
+import '../../../chunk-KWFFIJYX.js';
+import { MissingClientError } from '../../../chunk-QBJ7O2B4.js';
 import '../../../chunk-Q2GP5UDC.js';
-import { useRef, useMemo } from 'react';
-import { useQuery } from '@tanstack/react-query';
-import { usePublicClient, useWalletClient } from 'wagmi';
+import { useQuery, useQueryClient, useMutation } from '@tanstack/react-query';
 
-function usePredictAirdropAddress(args = {}) {
-  const { params, userSalt, deployer, gasFee, address, chainId, publicClient, encryptor } = args;
-  const wagmiPublicClient = usePublicClient({ ...chainId !== void 0 ? { chainId } : {} });
-  const resolvedPublicClient = publicClient ?? wagmiPublicClient;
-  const { data: walletClient } = useWalletClient({
-    ...chainId !== void 0 ? { chainId } : {}
-  });
-  const resolvedChainId = chainId ?? resolvedPublicClient?.chain?.id;
-  const resolvedAddress = address ?? (resolvedChainId === void 0 ? void 0 : DEPLOYED_ADDRESSES.fheAirdrop?.confidentialAirdropFactory?.[resolvedChainId] ?? void 0);
-  const encryptorSourceRef = useRef(encryptor);
-  encryptorSourceRef.current = encryptor;
-  const client = useMemo(() => {
-    if (!resolvedPublicClient) return void 0;
-    if (!resolvedAddress) return void 0;
-    return createConfidentialAirdropFactoryAdvancedClient({
-      publicClient: resolvedPublicClient,
-      ...walletClient ? { walletClient } : {},
+function usePredictEcdsaAirdropAddress(args) {
+  const { params, mode, deployer, userSalt, ...base } = args;
+  const { client, chainId, resolvedAddress } = useMemoAirdropFactoryClient(base);
+  return useQuery({
+    ...args.query,
+    queryKey: airdropQueryKey({
+      chainId,
+      address: resolvedAddress,
+      fn: "predictEcdsaAirdropAddress",
+      args: [mode, deployer, userSalt]
+    }),
+    queryFn: () => client.predictEcdsaAirdropAddress({ params, mode, deployer, userSalt }),
+    enabled: Boolean(client && (args.query?.enabled ?? true))
+  });
+}
+function usePredictMerkleAirdropAddress(args) {
+  const { params, mode, deployer, userSalt, ...base } = args;
+  const { client, chainId, resolvedAddress } = useMemoAirdropFactoryClient(base);
+  return useQuery({
+    ...args.query,
+    queryKey: airdropQueryKey({
+      chainId,
+      address: resolvedAddress,
+      fn: "predictMerkleAirdropAddress",
+      args: [mode, deployer, userSalt]
+    }),
+    queryFn: () => client.predictMerkleAirdropAddress({ params, mode, deployer, userSalt }),
+    enabled: Boolean(client && (args.query?.enabled ?? true))
+  });
+}
+function useClearCompliancePolicy(options = {}) {
+  const { client, resolutionError, chainId, resolvedAddress } = useMemoAirdropFactoryClient(options);
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: async (args) => {
+      if (!client) {
+        throw resolutionError ?? new MissingClientError("useClearCompliancePolicy", "factory");
+      }
+      return client.clearCompliancePolicy(args.creator, args.account);
+    },
+    onSuccess: (_hash, variables) => {
+      const scope = { chainId, address: resolvedAddress };
+      void queryClient.invalidateQueries({
+        queryKey: airdropKeys.compliancePolicy(scope, variables.creator)
+      });
+      void queryClient.invalidateQueries({
+        queryKey: airdropQueryKey({
+          ...scope,
+          fn: "effectiveDelegateToCompliance",
+          args: [variables.creator]
+        })
+      });
+    }
+  });
+}
+function useClearUpgradeabilityPolicy(options = {}) {
+  const { client, resolutionError, chainId, resolvedAddress } = useMemoAirdropFactoryClient(options);
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: async (args) => {
+      if (!client) {
+        throw resolutionError ?? new MissingClientError("useClearUpgradeabilityPolicy", "factory");
+      }
+      return client.clearUpgradeabilityPolicy(args.creator, args.account);
+    },
+    onSuccess: (_hash, variables) => {
+      const scope = { chainId, address: resolvedAddress };
+      void queryClient.invalidateQueries({
+        queryKey: airdropQueryKey({
+          ...scope,
+          fn: "effectiveUpgradeable",
+          args: [variables.creator]
+        })
+      });
+      void queryClient.invalidateQueries({
+        queryKey: airdropKeys.upgradeabilityPolicy(scope, variables.creator)
+      });
+      void queryClient.invalidateQueries({
+        queryKey: airdropKeys.preflightCreateAll(scope)
+      });
+    }
+  });
+}
+function useDisableCustomFee(options = {}) {
+  const { client, resolutionError, chainId, resolvedAddress } = useMemoAirdropFactoryClient(options);
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: async ({ creator, account }) => {
+      if (!client) {
+        throw resolutionError ?? new MissingClientError("useDisableCustomFee", "factory");
+      }
+      return client.disableCustomFee(creator, account);
+    },
+    onSuccess: (_hash, variables) => {
+      void queryClient.invalidateQueries({
+        queryKey: airdropKeys.customFee({ chainId, address: resolvedAddress }, variables.creator)
+      });
+    }
+  });
+}
+function useEcdsaInitCodeHash(args) {
+  const { params, mode, ...base } = args;
+  const { client, chainId, resolvedAddress } = useMemoAirdropFactoryClient(base);
+  return useQuery({
+    ...args.query,
+    // `params` is omitted for the same reason the predict hooks omit it: the
+    // ABI demands it but the factory ignores it, so only `mode` (plus the
+    // implementation pointer, which is what this read reports) moves the
+    // result. If a future factory version makes params hash-affecting, this
+    // key has to grow with it.
+    queryKey: airdropQueryKey({
+      chainId,
+      address: resolvedAddress,
+      fn: "getEcdsaInitCodeHash",
+      args: [mode]
+    }),
+    queryFn: () => client.getEcdsaInitCodeHash({ params, mode }),
+    enabled: Boolean(client && (args.query?.enabled ?? true))
+  });
+}
+function useFactoryComplianceDelegate(args = {}) {
+  const { client, chainId, resolvedAddress } = useMemoAirdropFactoryClient(args);
+  return useQuery({
+    ...args.query,
+    queryKey: airdropQueryKey({
+      chainId,
+      address: resolvedAddress,
+      fn: "complianceDelegate",
+      args: []
+    }),
+    queryFn: () => client.complianceDelegate(),
+    enabled: Boolean(client && (args.query?.enabled ?? true))
+  });
+}
+function useFactoryCompliancePolicy(args = {}) {
+  const { creator, ...base } = args;
+  const { client, chainId, resolvedAddress } = useMemoAirdropFactoryClient(base);
+  return useQuery({
+    ...args.query,
+    queryKey: airdropKeys.compliancePolicy({ chainId, address: resolvedAddress }, creator),
+    queryFn: async () => {
+      const [policy, effective] = await Promise.all([
+        client.getCompliancePolicy(creator),
+        client.effectiveDelegateToCompliance(creator)
+      ]);
+      return {
+        overridden: policy.overridden,
+        delegateToCompliance: policy.delegateToCompliance,
+        effective
+      };
+    },
+    enabled: Boolean(client && creator && (args.query?.enabled ?? true))
+  });
+}
+function useFactoryCustomFee(args = {}) {
+  const { creator, ...base } = args;
+  const { client, chainId, resolvedAddress } = useMemoAirdropFactoryClient(base);
+  return useQuery({
+    ...args.query,
+    queryKey: airdropKeys.customFee({ chainId, address: resolvedAddress }, creator),
+    queryFn: () => client.getCustomFee(creator),
+    enabled: Boolean(client && creator && (args.query?.enabled ?? true))
+  });
+}
+function useFactoryGrantRole(options = {}) {
+  const { client, resolutionError, chainId, resolvedAddress } = useMemoAirdropFactoryClient(options);
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: async (args) => {
+      if (!client) {
+        throw resolutionError ?? new MissingClientError("useFactoryGrantRole", "factory");
+      }
+      return client.grantRole(args);
+    },
+    onSuccess: (_hash, variables) => {
+      const scope = { chainId, address: resolvedAddress };
+      void queryClient.invalidateQueries({
+        queryKey: airdropKeys.factoryHasRole(scope, variables.role, variables.holder)
+      });
+      void queryClient.invalidateQueries({
+        queryKey: airdropKeys.factoryRoleMembers(scope, variables.role)
+      });
+    }
+  });
+}
+function useFactoryHasRole(args = {}) {
+  const { role, holder, ...base } = args;
+  const { client, chainId, resolvedAddress } = useMemoAirdropFactoryClient(base);
+  return useQuery({
+    ...args.query,
+    queryKey: airdropKeys.factoryHasRole({ chainId, address: resolvedAddress }, role, holder),
+    queryFn: () => client.hasRole({ role, holder }),
+    enabled: Boolean(client && role && holder && (args.query?.enabled ?? true))
+  });
+}
+function useFactoryImplementations(args = {}) {
+  const { client, chainId, resolvedAddress } = useMemoAirdropFactoryClient(args);
+  return useQuery({
+    ...args.query,
+    queryKey: airdropKeys.implementations({ chainId, address: resolvedAddress }),
+    queryFn: async () => {
+      const [ecdsa, merkle, complianceManager] = await Promise.all([
+        client.ecdsaImplementation(),
+        client.merkleImplementation(),
+        client.complianceManagerImpl()
+      ]);
+      return { ecdsa, merkle, complianceManager };
+    },
+    enabled: Boolean(client && (args.query?.enabled ?? true))
+  });
+}
+function useFactoryRenounceRole(options = {}) {
+  const { client, resolutionError, chainId, resolvedAddress } = useMemoAirdropFactoryClient(options);
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: async (args) => {
+      if (!client) {
+        throw resolutionError ?? new MissingClientError("useFactoryRenounceRole", "factory");
+      }
+      return client.renounceRole(args);
+    },
+    onSuccess: (_hash, variables) => {
+      const scope = { chainId, address: resolvedAddress };
+      void queryClient.invalidateQueries({ queryKey: airdropKeys.factoryHasRoleAll(scope) });
+      void queryClient.invalidateQueries({
+        queryKey: airdropKeys.factoryRoleMembers(scope, variables.role)
+      });
+    }
+  });
+}
+function useFactoryRevokeRole(options = {}) {
+  const { client, resolutionError, chainId, resolvedAddress } = useMemoAirdropFactoryClient(options);
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: async (args) => {
+      if (!client) {
+        throw resolutionError ?? new MissingClientError("useFactoryRevokeRole", "factory");
+      }
+      return client.revokeRole(args);
+    },
+    onSuccess: (_hash, variables) => {
+      const scope = { chainId, address: resolvedAddress };
+      void queryClient.invalidateQueries({
+        queryKey: airdropKeys.factoryHasRole(scope, variables.role, variables.holder)
+      });
+      void queryClient.invalidateQueries({
+        queryKey: airdropKeys.factoryRoleMembers(scope, variables.role)
+      });
+    }
+  });
+}
+function useFactoryRoleConstants(args = {}) {
+  const { client, chainId, resolvedAddress } = useMemoAirdropFactoryClient(args);
+  return useQuery({
+    // A default, not a lock: `query.staleTime` still wins if a consumer wants refetching.
+    staleTime: Infinity,
+    ...args.query,
+    // `fn` label is unique to this hook, so it stays inline rather than in keys.ts.
+    queryKey: airdropQueryKey({
+      chainId,
+      address: resolvedAddress,
+      fn: "factoryRoleConstants",
+      args: []
+    }),
+    queryFn: async () => {
+      const [
+        FEE_MANAGER_ROLE,
+        IMPL_MANAGER_ROLE,
+        COMPLIANCE_WIRING_ROLE,
+        UPGRADE_MANAGER_ROLE,
+        DEFAULT_ADMIN_ROLE
+      ] = await Promise.all([
+        client.FEE_MANAGER_ROLE(),
+        client.IMPL_MANAGER_ROLE(),
+        client.COMPLIANCE_WIRING_ROLE(),
+        client.UPGRADE_MANAGER_ROLE(),
+        client.DEFAULT_ADMIN_ROLE()
+      ]);
+      return {
+        FEE_MANAGER_ROLE,
+        IMPL_MANAGER_ROLE,
+        COMPLIANCE_WIRING_ROLE,
+        UPGRADE_MANAGER_ROLE,
+        DEFAULT_ADMIN_ROLE
+      };
+    },
+    enabled: Boolean(client && (args.query?.enabled ?? true))
+  });
+}
+function useFactoryRoleMembers(args = {}) {
+  const { role, ...base } = args;
+  const { client, chainId, resolvedAddress } = useMemoAirdropFactoryClient(base);
+  return useQuery({
+    ...args.query,
+    queryKey: airdropKeys.factoryRoleMembers({ chainId, address: resolvedAddress }, 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 useFactoryUpgradeabilityPolicy(args = {}) {
+  const { creator, ...base } = args;
+  const { client, chainId, resolvedAddress } = useMemoAirdropFactoryClient(base);
+  return useQuery({
+    ...args.query,
+    queryKey: airdropKeys.upgradeabilityPolicy({ chainId, address: resolvedAddress }, creator),
+    queryFn: async () => {
+      const [defaultUpgradeable, policy, effective] = await Promise.all([
+        client.defaultUpgradeable(),
+        client.getUpgradeabilityPolicy(creator),
+        client.effectiveUpgradeable(creator)
+      ]);
+      return {
+        defaultUpgradeable,
+        overridden: policy.overridden,
+        allowed: policy.allowed,
+        effective
+      };
+    },
+    enabled: Boolean(client && creator && (args.query?.enabled ?? true))
+  });
+}
+function useMerkleInitCodeHash(args) {
+  const { params, mode, ...base } = args;
+  const { client, chainId, resolvedAddress } = useMemoAirdropFactoryClient(base);
+  return useQuery({
+    ...args.query,
+    // `params` omitted deliberately — see useEcdsaInitCodeHash for why.
+    queryKey: airdropQueryKey({
+      chainId,
       address: resolvedAddress,
-      ...resolvedChainId !== void 0 ? { chainId: resolvedChainId } : {},
-      encryptor: () => resolveEncryptor(encryptorSourceRef.current)
-    });
-  }, [resolvedPublicClient, walletClient, resolvedAddress, resolvedChainId]);
-  return useQuery({
-    queryKey: buildQueryKey(
-      "factory:predictAirdropAddress",
-      resolvedChainId,
-      resolvedAddress,
-      params,
-      userSalt,
-      deployer,
-      gasFee
-    ),
-    queryFn: () => client.predictAirdropAddress({
-      params,
-      userSalt,
-      deployer,
-      gasFee
+      fn: "getMerkleInitCodeHash",
+      args: [mode]
     }),
-    enabled: !!client && !!params && !!userSalt && !!deployer && gasFee !== void 0,
-    staleTime: 0
+    queryFn: () => client.getMerkleInitCodeHash({ params, mode }),
+    enabled: Boolean(client && (args.query?.enabled ?? true))
+  });
+}
+function useSetComplianceDelegate(options = {}) {
+  const { client, resolutionError, chainId, resolvedAddress } = useMemoAirdropFactoryClient(options);
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: async (args) => {
+      if (!client) {
+        throw resolutionError ?? new MissingClientError("useSetComplianceDelegate", "factory");
+      }
+      return client.setComplianceDelegate(args.delegate, args.account);
+    },
+    onSuccess: () => {
+      void queryClient.invalidateQueries({
+        queryKey: airdropQueryKey({
+          chainId,
+          address: resolvedAddress,
+          fn: "complianceDelegate",
+          args: []
+        })
+      });
+    }
+  });
+}
+function useSetComplianceManagerImpl(options = {}) {
+  const { client, resolutionError, chainId, resolvedAddress } = useMemoAirdropFactoryClient(options);
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: async (args) => {
+      if (!client) {
+        throw resolutionError ?? new MissingClientError("useSetComplianceManagerImpl", "factory");
+      }
+      return client.setComplianceManagerImpl(args.implementation, args.account);
+    },
+    onSuccess: () => {
+      void queryClient.invalidateQueries({
+        queryKey: airdropKeys.implementations({ chainId, address: resolvedAddress })
+      });
+    }
+  });
+}
+function useSetCompliancePolicy(options = {}) {
+  const { client, resolutionError, chainId, resolvedAddress } = useMemoAirdropFactoryClient(options);
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: async (args) => {
+      if (!client) {
+        throw resolutionError ?? new MissingClientError("useSetCompliancePolicy", "factory");
+      }
+      return client.setCompliancePolicy(args.creator, args.delegateToCompliance, args.account);
+    },
+    onSuccess: (_hash, variables) => {
+      const scope = { chainId, address: resolvedAddress };
+      void queryClient.invalidateQueries({
+        queryKey: airdropKeys.compliancePolicy(scope, variables.creator)
+      });
+      void queryClient.invalidateQueries({
+        queryKey: airdropQueryKey({
+          ...scope,
+          fn: "effectiveDelegateToCompliance",
+          args: [variables.creator]
+        })
+      });
+    }
+  });
+}
+function useSetCustomFee(options = {}) {
+  const { client, resolutionError, chainId, resolvedAddress } = useMemoAirdropFactoryClient(options);
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: async ({ creator, gasFee, account }) => {
+      if (!client) {
+        throw resolutionError ?? new MissingClientError("useSetCustomFee", "factory");
+      }
+      return client.setCustomFee(creator, gasFee, account);
+    },
+    onSuccess: (_hash, variables) => {
+      void queryClient.invalidateQueries({
+        queryKey: airdropKeys.customFee({ chainId, address: resolvedAddress }, variables.creator)
+      });
+    }
+  });
+}
+function useSetDefaultDelegateToCompliance(options = {}) {
+  const { client, resolutionError, chainId, resolvedAddress } = useMemoAirdropFactoryClient(options);
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: async (args) => {
+      if (!client) {
+        throw resolutionError ?? new MissingClientError("useSetDefaultDelegateToCompliance", "factory");
+      }
+      return client.setDefaultDelegateToCompliance(args.on, args.account);
+    },
+    onSuccess: () => {
+      void queryClient.invalidateQueries({
+        queryKey: airdropQueryKeyPrefix({
+          chainId,
+          address: resolvedAddress,
+          fn: "effectiveDelegateToCompliance"
+        })
+      });
+      void queryClient.invalidateQueries({
+        queryKey: airdropKeys.compliancePolicyAll({ chainId, address: resolvedAddress })
+      });
+    }
+  });
+}
+function useSetDefaultGasFee(options = {}) {
+  const { client, resolutionError, chainId, resolvedAddress } = useMemoAirdropFactoryClient(options);
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: async ({ gasFee, account }) => {
+      if (!client) {
+        throw resolutionError ?? new MissingClientError("useSetDefaultGasFee", "factory");
+      }
+      return client.setDefaultGasFee(gasFee, account);
+    },
+    onSuccess: () => {
+      void queryClient.invalidateQueries({
+        queryKey: airdropKeys.fees({ chainId, address: resolvedAddress })
+      });
+    }
+  });
+}
+function useSetDefaultUpgradeable(options = {}) {
+  const { client, resolutionError, chainId, resolvedAddress } = useMemoAirdropFactoryClient(options);
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: async (args) => {
+      if (!client) {
+        throw resolutionError ?? new MissingClientError("useSetDefaultUpgradeable", "factory");
+      }
+      return client.setDefaultUpgradeable(args.allowed, args.account);
+    },
+    onSuccess: () => {
+      const scope = { chainId, address: resolvedAddress };
+      void queryClient.invalidateQueries({
+        queryKey: airdropQueryKeyPrefix({ ...scope, fn: "effectiveUpgradeable" })
+      });
+      void queryClient.invalidateQueries({
+        queryKey: airdropKeys.upgradeabilityPolicyAll(scope)
+      });
+      void queryClient.invalidateQueries({
+        queryKey: airdropKeys.preflightCreateAll(scope)
+      });
+    }
+  });
+}
+function useSetEcdsaImplementation(options = {}) {
+  const { client, resolutionError, chainId, resolvedAddress } = useMemoAirdropFactoryClient(options);
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: async ({ implementation, account }) => {
+      if (!client) {
+        throw resolutionError ?? new MissingClientError("useSetEcdsaImplementation", "factory");
+      }
+      return client.setEcdsaImplementation(implementation, account);
+    },
+    onSuccess: () => {
+      const scope = { chainId, address: resolvedAddress };
+      void queryClient.invalidateQueries({ queryKey: airdropKeys.implementations(scope) });
+      void queryClient.invalidateQueries({
+        queryKey: airdropQueryKeyPrefix({ ...scope, fn: "getEcdsaInitCodeHash" })
+      });
+      void queryClient.invalidateQueries({
+        queryKey: airdropQueryKeyPrefix({ ...scope, fn: "predictEcdsaAirdropAddress" })
+      });
+      void queryClient.invalidateQueries({
+        queryKey: airdropKeys.preflightCreateAll(scope)
+      });
+    }
+  });
+}
+function useSetFeeCollector(options = {}) {
+  const { client, resolutionError, chainId, resolvedAddress } = useMemoAirdropFactoryClient(options);
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: async ({ feeCollector, account }) => {
+      if (!client) {
+        throw resolutionError ?? new MissingClientError("useSetFeeCollector", "factory");
+      }
+      return client.setFeeCollector(feeCollector, account);
+    },
+    onSuccess: () => {
+      void queryClient.invalidateQueries({
+        queryKey: airdropKeys.fees({ chainId, address: resolvedAddress })
+      });
+    }
+  });
+}
+function useSetMerkleImplementation(options = {}) {
+  const { client, resolutionError, chainId, resolvedAddress } = useMemoAirdropFactoryClient(options);
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: async ({ implementation, account }) => {
+      if (!client) {
+        throw resolutionError ?? new MissingClientError("useSetMerkleImplementation", "factory");
+      }
+      return client.setMerkleImplementation(implementation, account);
+    },
+    onSuccess: () => {
+      const scope = { chainId, address: resolvedAddress };
+      void queryClient.invalidateQueries({ queryKey: airdropKeys.implementations(scope) });
+      void queryClient.invalidateQueries({
+        queryKey: airdropQueryKeyPrefix({ ...scope, fn: "getMerkleInitCodeHash" })
+      });
+      void queryClient.invalidateQueries({
+        queryKey: airdropQueryKeyPrefix({ ...scope, fn: "predictMerkleAirdropAddress" })
+      });
+      void queryClient.invalidateQueries({
+        queryKey: airdropKeys.preflightCreateAll(scope)
+      });
+    }
+  });
+}
+function useSetUpgradeabilityPolicy(options = {}) {
+  const { client, resolutionError, chainId, resolvedAddress } = useMemoAirdropFactoryClient(options);
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: async (args) => {
+      if (!client) {
+        throw resolutionError ?? new MissingClientError("useSetUpgradeabilityPolicy", "factory");
+      }
+      return client.setUpgradeabilityPolicy(args.creator, args.allowed, args.account);
+    },
+    onSuccess: (_hash, variables) => {
+      const scope = { chainId, address: resolvedAddress };
+      void queryClient.invalidateQueries({
+        queryKey: airdropQueryKey({
+          ...scope,
+          fn: "effectiveUpgradeable",
+          args: [variables.creator]
+        })
+      });
+      void queryClient.invalidateQueries({
+        queryKey: airdropKeys.upgradeabilityPolicy(scope, variables.creator)
+      });
+      void queryClient.invalidateQueries({
+        queryKey: airdropKeys.preflightCreateAll(scope)
+      });
+    }
   });
 }
 
-export { usePredictAirdropAddress };
+export { useClearCompliancePolicy, useClearUpgradeabilityPolicy, useDisableCustomFee, useEcdsaInitCodeHash, useFactoryComplianceDelegate, useFactoryCompliancePolicy, useFactoryCustomFee, useFactoryGrantRole, useFactoryHasRole, useFactoryImplementations, useFactoryRenounceRole, useFactoryRevokeRole, useFactoryRoleConstants, useFactoryRoleMembers, useFactoryUpgradeabilityPolicy, useMerkleInitCodeHash, usePredictEcdsaAirdropAddress, usePredictMerkleAirdropAddress, useSetComplianceDelegate, useSetComplianceManagerImpl, useSetCompliancePolicy, useSetCustomFee, useSetDefaultDelegateToCompliance, useSetDefaultGasFee, useSetDefaultUpgradeable, useSetEcdsaImplementation, useSetFeeCollector, useSetMerkleImplementation, useSetUpgradeabilityPolicy };

package/dist/fhe-airdrop/advanced/react/useClearCompliancePolicy.d.ts

@@ -0,0 +1,28 @@
+import { type UseMutationResult } from "@tanstack/react-query";
+import type { Address, Hex } from "viem";
+import type { WriteAccountOverride } from "../../airdrop-base.js";
+import { type AirdropClientOptions } from "../../react/_shared.js";
+/** @alpha */
+export interface ClearCompliancePolicyArgs extends WriteAccountOverride {
+    /** The creator whose override is dropped - not the admin sending the transaction. */
+    creator: Address;
+}
+/**
+ * Drop a creator's {@link useSetCompliancePolicy} override, reverting them to
+ * the factory default. Requires `COMPLIANCE_WIRING_ROLE`.
+ *
+ * The cleared state is `overridden: false, delegateToCompliance: false`, so
+ * `effectiveDelegateToCompliance` then follows the factory default set by
+ * {@link useSetDefaultDelegateToCompliance} rather than staying at whatever
+ * the override had been.
+ *
+ * **Invalidates:** `fn "compliancePolicy"` and
+ * `fn "effectiveDelegateToCompliance"`, both keyed on `args.creator`.
+ *
+ * @example
+ * const clearPolicy = useClearCompliancePolicy();
+ * await clearPolicy.mutateAsync({ creator });
+ *
+ * @alpha
+ */
+export declare function useClearCompliancePolicy(options?: AirdropClientOptions): UseMutationResult<Hex, Error, ClearCompliancePolicyArgs>;