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

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

@@ -1,15 +1,15 @@
-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 { grantInstanceRoles, buildMerkleCampaign, encryptCampaignAmounts, planMerkleCampaign, rotateMerkleRoot } from '../../chunk-KJUNBOJQ.js';
+export { MERKLE_BATCH_LIMIT, buildMerkleCampaign, buildMerkleTree, encryptCampaignAmounts, grantInstanceRoles, leafOf, planInstanceRoleSplit, planMerkleCampaign, rotateMerkleRoot, validateCampaignRecipients } from '../../chunk-KJUNBOJQ.js';
+import { useMemoAirdropBaseClient, airdropQueryKey, airdropKeys, useMemoMerkleAirdropClient, useMemoAirdropFactoryClient, AIRDROP_FN, useMemoEcdsaAirdropClient, useMemoComplianceManagerClient, staleUntilNonZeroAddress, invalidateAfterCreate } from '../../chunk-3ZSPRHR3.js';
+export { airdropQueryKey, airdropQueryKeyPrefix } from '../../chunk-3ZSPRHR3.js';
+import { resolveEncryptor, signClaimAuthorization } from '../../chunk-67Q6KSVV.js';
+export { encryptUint64, encryptUint64Batch, resolveEncryptor, signClaimAuthorization } from '../../chunk-67Q6KSVV.js';
+import { preflightClaim, preflightCreate } from '../../chunk-YMWMIWBP.js';
+export { AlreadyClaimedError, ClaimNotStartedError, ClaimWindowClosedError, ClawbackRequiresPauseError, CreateCommitmentMismatchError, DedupIdConsumedError, FeeCollectorSelfAdministeredError, GasFeeNotAcceptedError, MerkleUupsUnsupportedError, NativeRescueRequiresZeroFeeError, NonStockWrapperError, PredictionDriftError, SaltCollisionError, SignatureExpiredError, UINT96_MAX, UnauthorizedRedirectError, UnrecognisedAirdropError, UpgradeabilityNotAllowedError, preflightClaim, preflightCreate } from '../../chunk-YMWMIWBP.js';
 import '../../chunk-ZWXJTBZO.js';
-import '../../chunk-NWFMBLSQ.js';
+import '../../chunk-7KY4K4PH.js';
 import '../../chunk-4RAAATVY.js';
-import '../../chunk-A4DCEE33.js';
+import '../../chunk-GHGF65LN.js';
 import '../../chunk-ZA673I3O.js';
 import '../../chunk-KWFFIJYX.js';
 import { MissingClientError, MissingWalletClientError } from '../../chunk-QBJ7O2B4.js';
@@ -31,7 +31,7 @@ function useAirdropWindow(args) {
   const { client, chainId } = useMemoAirdropBaseClient(args);
   return useQuery({
     ...args.query,
-    queryKey: airdropQueryKey({ chainId, address: args.address, fn: "window", args: [] }),
+    queryKey: airdropKeys.window({ chainId, address: args.address }),
     queryFn: async () => {
       const [startTime, endTime, hasStarted, hasEnded, isActive] = await Promise.all([
         client.startTime(),
@@ -49,7 +49,7 @@ function useAirdropPaused(args) {
   const { client, chainId } = useMemoAirdropBaseClient(args);
   return useQuery({
     ...args.query,
-    queryKey: airdropQueryKey({ chainId, address: args.address, fn: "paused", args: [] }),
+    queryKey: airdropKeys.paused({ chainId, address: args.address }),
     queryFn: () => client.paused(),
     enabled: Boolean(client && (args.query?.enabled ?? true))
   });
@@ -58,7 +58,7 @@ function useAirdropGasFee(args) {
   const { client, chainId } = useMemoAirdropBaseClient(args);
   return useQuery({
     ...args.query,
-    queryKey: airdropQueryKey({ chainId, address: args.address, fn: "gasFee", args: [] }),
+    queryKey: airdropKeys.gasFee({ chainId, address: args.address }),
     queryFn: () => client.gasFee(),
     enabled: Boolean(client && (args.query?.enabled ?? true))
   });
@@ -68,12 +68,7 @@ function useAirdropHasRole(args) {
   const { client, chainId } = useMemoAirdropBaseClient(base);
   return useQuery({
     ...args.query,
-    queryKey: airdropQueryKey({
-      chainId,
-      address: args.address,
-      fn: "hasRole",
-      args: [role, holder]
-    }),
+    queryKey: airdropKeys.hasRole({ chainId, address: args.address }, role, holder),
     queryFn: () => client.hasRole({ role, holder }),
     enabled: Boolean(client && role && holder && (args.query?.enabled ?? true))
   });
@@ -82,7 +77,7 @@ function useMerkleRoot(args) {
   const { client, chainId } = useMemoMerkleAirdropClient(args);
   return useQuery({
     ...args.query,
-    queryKey: airdropQueryKey({ chainId, address: args.address, fn: "merkleRoot", args: [] }),
+    queryKey: airdropKeys.merkleRoot({ chainId, address: args.address }),
     queryFn: () => client.merkleRoot(),
     enabled: Boolean(client && (args.query?.enabled ?? true))
   });
@@ -92,12 +87,7 @@ function useClaimedAmount(args) {
   const { client, chainId } = useMemoMerkleAirdropClient(base);
   return useQuery({
     ...args.query,
-    queryKey: airdropQueryKey({
-      chainId,
-      address: args.address,
-      fn: "getClaimedAmount",
-      args: [account]
-    }),
+    queryKey: airdropKeys.claimedAmount({ chainId, address: args.address }, account),
     queryFn: () => client.getClaimedAmount(account),
     enabled: Boolean(client && account && (args.query?.enabled ?? true))
   });
@@ -120,28 +110,39 @@ function useFactoryFees(args = {}) {
   const { client, chainId, resolvedAddress } = useMemoAirdropFactoryClient(args);
   return useQuery({
     ...args.query,
-    queryKey: airdropQueryKey({ chainId, address: resolvedAddress, fn: "fees", args: [] }),
+    queryKey: airdropKeys.fees({ chainId, address: resolvedAddress }),
     queryFn: async () => {
-      const [feeCollector, defaultGasFee] = await Promise.all([
+      const [feeCollector, defaultGasFee, maxGasFee] = await Promise.all([
         client.feeCollector(),
-        client.defaultGasFee()
+        client.defaultGasFee(),
+        client.maxGasFee()
       ]);
-      return { feeCollector, defaultGasFee };
+      return { feeCollector, defaultGasFee, maxGasFee };
     },
     enabled: Boolean(client && (args.query?.enabled ?? true))
   });
 }
-function useFactoryRegistry(args = {}) {
-  const { offset = 0n, limit = 50n, ...base } = args;
+function useResolveGasFee(args = {}) {
+  const { creator, ...base } = args;
   const { client, chainId, resolvedAddress } = useMemoAirdropFactoryClient(base);
   return useQuery({
     ...args.query,
     queryKey: airdropQueryKey({
       chainId,
       address: resolvedAddress,
-      fn: "registry",
-      args: [offset, limit]
+      fn: AIRDROP_FN.resolvedGasFee,
+      args: [creator]
     }),
+    queryFn: () => client.resolveGasFee(creator),
+    enabled: Boolean(client && creator && (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: airdropKeys.registry({ chainId, address: resolvedAddress }, offset, limit),
     queryFn: async () => {
       const [count, items] = await Promise.all([
         client.airdropCount(),
@@ -152,17 +153,30 @@ function useFactoryRegistry(args = {}) {
     enabled: Boolean(client && (args.query?.enabled ?? true))
   });
 }
-function useEffectiveUpgradeable(args = {}) {
-  const { creator, ...base } = args;
+function useIsAirdrop(args = {}) {
+  const { candidate, ...base } = args;
   const { client, chainId, resolvedAddress } = useMemoAirdropFactoryClient(base);
   return useQuery({
+    // Per-result, not blanket: `true` is immutable (append-only registry),
+    // `false` is not. See the TSDoc above.
+    staleTime: (query) => query.state.data === true ? Infinity : 0,
     ...args.query,
     queryKey: airdropQueryKey({
       chainId,
       address: resolvedAddress,
-      fn: "effectiveUpgradeable",
-      args: [creator]
+      fn: AIRDROP_FN.isAirdrop,
+      args: [candidate]
     }),
+    queryFn: () => client.isAirdrop(candidate),
+    enabled: Boolean(client && candidate && (args.query?.enabled ?? true))
+  });
+}
+function useEffectiveUpgradeable(args = {}) {
+  const { creator, ...base } = args;
+  const { client, chainId, resolvedAddress } = useMemoAirdropFactoryClient(base);
+  return useQuery({
+    ...args.query,
+    queryKey: airdropKeys.effectiveUpgradeable({ chainId, address: resolvedAddress }, creator),
     queryFn: () => client.effectiveUpgradeable(creator),
     enabled: Boolean(client && creator && (args.query?.enabled ?? true))
   });
@@ -174,12 +188,22 @@ function useAirdropConfig(args) {
     ...args.query,
     queryKey: airdropKeys.config({ chainId, address: args.address }),
     queryFn: async () => {
-      const [token, airdropType, unwrappable, complianceManager, gasFee] = await Promise.all([
+      const [
+        token,
+        airdropType,
+        unwrappable,
+        complianceManager,
+        gasFee,
+        canExtendClaimWindow,
+        deploymentBlockNumber
+      ] = await Promise.all([
         client.token(),
         client.airdropType(),
         client.unwrappable(),
         client.complianceManager(),
-        client.gasFee()
+        client.gasFee(),
+        client.canExtendClaimWindow(),
+        client.deploymentBlockNumber()
       ]);
       return {
         token,
@@ -187,7 +211,9 @@ function useAirdropConfig(args) {
         variant: airdropType === 1 ? "merkle" : "ecdsa",
         unwrappable,
         complianceManager,
-        gasFee
+        gasFee,
+        canExtendClaimWindow,
+        deploymentBlockNumber
       };
     },
     enabled: Boolean(client && (args.query?.enabled ?? true))
@@ -329,14 +355,9 @@ function useComplianceManagerOf(args = {}) {
   const { airdrop, ...base } = args;
   const { client, chainId, resolvedAddress } = useMemoAirdropFactoryClient(base);
   return useQuery({
-    staleTime: Infinity,
+    staleTime: staleUntilNonZeroAddress,
     ...args.query,
-    queryKey: airdropQueryKey({
-      chainId,
-      address: resolvedAddress,
-      fn: "complianceManagerOf",
-      args: [airdrop]
-    }),
+    queryKey: airdropKeys.complianceManagerOf({ chainId, address: resolvedAddress }, airdrop),
     queryFn: () => client.complianceManagerOf(airdrop),
     enabled: Boolean(client && airdrop && (args.query?.enabled ?? true))
   });
@@ -379,6 +400,16 @@ function useComplianceRoleMembers(args) {
     enabled: Boolean(client && role && (args.query?.enabled ?? true))
   });
 }
+function useDedupMode(args) {
+  const { client, chainId } = useMemoEcdsaAirdropClient(args);
+  return useQuery({
+    staleTime: Infinity,
+    ...args.query,
+    queryKey: airdropKeys.dedupMode({ chainId, address: args.address }),
+    queryFn: () => client.readDedupMode(),
+    enabled: Boolean(client && (args.query?.enabled ?? true))
+  });
+}
 function useEcdsaDomain(args) {
   const { client, chainId } = useMemoEcdsaAirdropClient(args);
   return useQuery({
@@ -403,12 +434,10 @@ function useEffectiveDelegateToCompliance(args = {}) {
   const { client, chainId, resolvedAddress } = useMemoAirdropFactoryClient(base);
   return useQuery({
     ...args.query,
-    queryKey: airdropQueryKey({
-      chainId,
-      address: resolvedAddress,
-      fn: "effectiveDelegateToCompliance",
-      args: [creator]
-    }),
+    queryKey: airdropKeys.effectiveDelegateToCompliance(
+      { chainId, address: resolvedAddress },
+      creator
+    ),
     queryFn: () => client.effectiveDelegateToCompliance(creator),
     enabled: Boolean(client && creator && (args.query?.enabled ?? true))
   });
@@ -499,6 +528,13 @@ function usePreflightCreateAirdrop(args = {}) {
         args.creator,
         args.userSalt,
         args.expectedInitCodeHash,
+        // Pinned commitments change the reported quote.
+        args.expected,
+        // A plan pins three scalars; `entries` never changes the verdict, and
+        // keying on it would hash every ciphertext on each render.
+        args.variant === "merkle" ? args.plan?.predictedAddress : void 0,
+        args.variant === "merkle" ? args.plan?.root : void 0,
+        args.variant === "merkle" ? args.plan?.initCodeHashAfter : void 0,
         // `params` IS key-affecting here, unlike in the predict hooks: the
         // stock-wrapper probe reads `common.token` / `common.unwrappable`.
         args.params
@@ -510,15 +546,27 @@ function usePreflightCreateAirdrop(args = {}) {
         mode: args.mode,
         creator: args.creator,
         userSalt: args.userSalt,
-        expectedInitCodeHash: args.expectedInitCodeHash
+        expectedInitCodeHash: args.expectedInitCodeHash,
+        expected: args.expected
       };
-      return args.variant === "merkle" ? preflightCreate({ ...common, variant: "merkle", params: args.params }) : preflightCreate({ ...common, variant: "ecdsa", params: args.params });
+      return args.variant === "merkle" ? preflightCreate({ ...common, variant: "merkle", params: args.params, plan: args.plan }) : 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 useTokenOf(args = {}) {
+  const { airdrop, ...base } = args;
+  const { client, chainId, resolvedAddress } = useMemoAirdropFactoryClient(base);
+  return useQuery({
+    staleTime: staleUntilNonZeroAddress,
+    ...args.query,
+    queryKey: airdropKeys.tokenOf({ chainId, address: resolvedAddress }, airdrop),
+    queryFn: () => client.tokenOf(airdrop),
+    enabled: Boolean(client && airdrop && (args.query?.enabled ?? true))
+  });
+}
 function useCreateEcdsaAirdrop(options = {}) {
   const { client, resolutionError, chainId, resolvedAddress } = useMemoAirdropFactoryClient(options);
   const queryClient = useQueryClient();
@@ -529,10 +577,8 @@ function useCreateEcdsaAirdrop(options = {}) {
       }
       return client.createEcdsaAirdrop(args);
     },
-    onSuccess: () => {
-      void queryClient.invalidateQueries({
-        queryKey: airdropQueryKeyPrefix({ chainId, address: resolvedAddress, fn: "registry" })
-      });
+    onSuccess: (result) => {
+      invalidateAfterCreate(queryClient, { chainId, address: resolvedAddress }, result.airdrop);
     }
   });
 }
@@ -546,10 +592,8 @@ function useCreateMerkleAirdrop(options = {}) {
       }
       return client.createMerkleAirdrop(args);
     },
-    onSuccess: () => {
-      void queryClient.invalidateQueries({
-        queryKey: airdropQueryKeyPrefix({ chainId, address: resolvedAddress, fn: "registry" })
-      });
+    onSuccess: (result) => {
+      invalidateAfterCreate(queryClient, { chainId, address: resolvedAddress }, result.airdrop);
     }
   });
 }
@@ -595,12 +639,7 @@ function useMerkleClaim(options) {
     onSuccess: (_hash, _variables, context) => {
       if (!context?.account) return;
       void queryClient.invalidateQueries({
-        queryKey: airdropQueryKey({
-          chainId,
-          address: options.address,
-          fn: "getClaimedAmount",
-          args: [context.account]
-        })
+        queryKey: airdropKeys.claimedAmount({ chainId, address: options.address }, context.account)
       });
     }
   });
@@ -617,12 +656,7 @@ function useSetMerkleRoot(options) {
     },
     onSuccess: () => {
       void queryClient.invalidateQueries({
-        queryKey: airdropQueryKey({
-          chainId,
-          address: options.address,
-          fn: "merkleRoot",
-          args: []
-        })
+        queryKey: airdropKeys.merkleRoot({ chainId, address: options.address })
       });
     }
   });
@@ -659,12 +693,9 @@ function useAirdropPause(options) {
       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: [] })
-      });
+      const scope = { chainId, address: options.address };
+      void queryClient.invalidateQueries({ queryKey: airdropKeys.paused(scope) });
+      void queryClient.invalidateQueries({ queryKey: airdropKeys.window(scope) });
     }
   });
 }
@@ -680,7 +711,7 @@ function useExtendClaimWindow(options) {
     },
     onSuccess: () => {
       void queryClient.invalidateQueries({
-        queryKey: airdropQueryKey({ chainId, address: options.address, fn: "window", args: [] })
+        queryKey: airdropKeys.window({ chainId, address: options.address })
       });
     }
   });
@@ -696,6 +727,17 @@ function useWithdrawConfidential(options) {
     }
   });
 }
+function useRescueNativeToken(options) {
+  const { client } = useMemoAirdropBaseClient(options);
+  return useMutation({
+    mutationFn: async (args) => {
+      if (!client) {
+        throw new MissingClientError("useRescueNativeToken", "airdrop-base");
+      }
+      return client.rescueNativeToken(args);
+    }
+  });
+}
 function useAddComplianceDelegate(options) {
   const { client, chainId } = useMemoComplianceManagerClient(options);
   const queryClient = useQueryClient();
@@ -805,8 +847,7 @@ function useBuildMerkleCampaign(options = {}) {
     mutationFn: async (args) => buildMerkleCampaign({
       instance: args.instance,
       recipients: args.recipients,
-      encryptor: () => resolveEncryptor(encryptorSourceRef.current),
-      ...args.submitter !== void 0 ? { submitter: args.submitter } : {}
+      encryptor: () => resolveEncryptor(encryptorSourceRef.current)
     })
   });
 }
@@ -881,10 +922,8 @@ function useCreateAndFundEcdsaAirdrop(options = {}) {
       }
       return client.createAndFundEcdsaAirdrop(args);
     },
-    onSuccess: () => {
-      void queryClient.invalidateQueries({
-        queryKey: airdropKeys.registryAll({ chainId, address: resolvedAddress })
-      });
+    onSuccess: (result) => {
+      invalidateAfterCreate(queryClient, { chainId, address: resolvedAddress }, result.airdrop);
     }
   });
 }
@@ -898,10 +937,8 @@ function useCreateAndFundMerkleAirdrop(options = {}) {
       }
       return client.createAndFundMerkleAirdrop(args);
     },
-    onSuccess: () => {
-      void queryClient.invalidateQueries({
-        queryKey: airdropKeys.registryAll({ chainId, address: resolvedAddress })
-      });
+    onSuccess: (result) => {
+      invalidateAfterCreate(queryClient, { chainId, address: resolvedAddress }, result.airdrop);
     }
   });
 }
@@ -940,8 +977,7 @@ function useEncryptCampaignAmounts(options = {}) {
     mutationFn: async (args) => encryptCampaignAmounts({
       instance: args.instance,
       recipients: args.recipients,
-      encryptor: () => resolveEncryptor(encryptorSourceRef.current),
-      ...args.submitter !== void 0 ? { submitter: args.submitter } : {}
+      encryptor: () => resolveEncryptor(encryptorSourceRef.current)
     })
   });
 }
@@ -971,6 +1007,21 @@ function useMerkleClaimAndUnwrap(options) {
     }
   });
 }
+function useUnwrapRequest(args) {
+  const { client, chainId } = useMemoAirdropBaseClient(args);
+  return useQuery({
+    staleTime: Infinity,
+    ...args.query,
+    queryKey: airdropQueryKey({
+      chainId,
+      address: args.address,
+      fn: "unwrapRequest",
+      args: [args.hash]
+    }),
+    queryFn: () => client.readUnwrapRequest(args.hash),
+    enabled: Boolean(client && args.hash && (args.query?.enabled ?? true))
+  });
+}
 function usePlanMerkleCampaign(options = {}) {
   const { client, resolutionError } = useMemoAirdropFactoryClient(options);
   const encryptorSourceRef = useRef(options.encryptor);
@@ -1043,7 +1094,6 @@ function useRotateMerkleRoot(options) {
         airdrop: client,
         recipients: args.recipients,
         encryptor: () => resolveEncryptor(encryptorSourceRef.current),
-        ...args.submitter !== void 0 ? { submitter: args.submitter } : {},
         ...args.account !== void 0 ? { account: args.account } : {}
       });
     },
@@ -1121,6 +1171,17 @@ function useAdminGetCurrentBalance(options) {
     }
   });
 }
+function useRefreshComplianceBalance(options) {
+  const { client } = useMemoAirdropBaseClient(options);
+  return useMutation({
+    mutationFn: async (args) => {
+      if (!client) {
+        throw new MissingClientError("useRefreshComplianceBalance", "airdrop-base");
+      }
+      return client.refreshComplianceBalance(args ?? {});
+    }
+  });
+}
 function useAccessEcdsaClaimAmount(options) {
   const { client } = useMemoEcdsaAirdropClient(options);
   return useMutation({
@@ -1144,4 +1205,4 @@ function useAccessMerkleClaimAmount(options) {
   });
 }
 
-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 };
+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, useDedupMode, useDiscloseHandleToParty, useEcdsaClaim, useEcdsaClaimAndUnwrap, useEcdsaDomain, useEffectiveDelegateToCompliance, useEffectiveUpgradeable, useEncryptCampaignAmounts, useExtendClaimWindow, useFactoryFees, useFactoryRegistry, useFundAirdrop, useGrantInstanceRoles, useIsActiveDelegate, useIsAirdrop, useIsMerkleRootMutable, useIsSignatureValid, useMerkleClaim, useMerkleClaimAndUnwrap, useMerkleRoot, usePlanMerkleCampaign, usePreflightClaim, usePreflightCreateAirdrop, useRefreshComplianceBalance, useRescueERC20, useRescueNativeToken, useRescueOtherConfidentialToken, useResolveGasFee, useRevokeComplianceDelegate, useRotateMerkleRoot, useSetMerkleRoot, useSignClaimAuthorization, useTokenOf, useUnwrapRequest, useWithdrawConfidential, useWithdrawGasFee };

package/dist/fhe-airdrop/react/keys.d.ts

@@ -12,7 +12,9 @@
  *
  * A `fn` label used by exactly one hook stays inline in that hook.
  */
+import type { QueryClient } from "@tanstack/react-query";
 import type { Address, Hex } from "viem";
+import type { DeploymentMode } from "../constants.js";
 /** Chain + contract scope every key below is built against. */
 interface Scope {
     chainId: number | undefined;
@@ -22,6 +24,7 @@ interface Scope {
 export declare const AIRDROP_FN: {
     readonly claimedAmount: "getClaimedAmount";
     readonly paused: "paused";
+    readonly dedupMode: "dedupMode";
     readonly window: "window";
     readonly config: "config";
     readonly merkleRoot: "merkleRoot";
@@ -33,21 +36,32 @@ export declare const AIRDROP_FN: {
     readonly isSignatureValid: "isSignatureValid";
     readonly fees: "fees";
     readonly registry: "registry";
+    readonly isAirdrop: "isAirdrop";
+    readonly resolvedGasFee: "resolvedGasFee";
     readonly customFee: "customFee";
     readonly implementations: "implementations";
+    readonly tokenOf: "tokenOf";
+    readonly complianceManagerOf: "complianceManagerOf";
     readonly compliancePolicy: "compliancePolicy";
     readonly upgradeabilityPolicy: "upgradeabilityPolicy";
     readonly factoryHasRole: "factoryHasRole";
     readonly factoryRoleMembers: "factoryRoleMembers";
+    readonly effectiveDelegateToCompliance: "effectiveDelegateToCompliance";
+    readonly effectiveUpgradeable: "effectiveUpgradeable";
+    readonly complianceDelegate: "complianceDelegate";
+    readonly ecdsaInitCodeHash: "getEcdsaInitCodeHash";
+    readonly predictEcdsaAddress: "predictEcdsaAirdropAddress";
+    readonly merkleInitCodeHash: "getMerkleInitCodeHash";
+    readonly predictMerkleAddress: "predictMerkleAirdropAddress";
     readonly complianceInfo: "complianceInfo";
     readonly activeDelegate: "isActiveDelegate";
-    readonly clientDelegates: "clientDelegates";
     readonly complianceHasRole: "complianceHasRole";
     readonly complianceRoleMembers: "complianceRoleMembers";
 };
 export declare const airdropKeys: {
     /** One account's cumulative delivered total. Keyed on the CLAIM IDENTITY, never the sender. */
     readonly claimedAmount: (s: Scope, account: Address | undefined) => unknown[];
+    readonly dedupMode: (s: Scope) => unknown[];
     readonly paused: (s: Scope) => unknown[];
     readonly window: (s: Scope) => unknown[];
     readonly config: (s: Scope) => unknown[];
@@ -65,9 +79,17 @@ export declare const airdropKeys: {
     readonly isSignatureValidAll: (s: Scope) => unknown[];
     readonly fees: (s: Scope) => unknown[];
     readonly customFee: (s: Scope, creator: Address | undefined) => unknown[];
-    readonly customFeeAll: (s: Scope) => unknown[];
+    readonly resolvedGasFee: (s: Scope, creator: Address | undefined) => unknown[];
+    /** Every creator's resolved fee; the default and any override both move it. */
+    readonly resolvedGasFeeAll: (s: Scope) => unknown[];
+    readonly registry: (s: Scope, offset: bigint | undefined, limit: bigint | undefined) => unknown[];
     /** Every registry page, whatever offset/limit was queried. */
     readonly registryAll: (s: Scope) => unknown[];
+    readonly isAirdrop: (s: Scope, candidate: Address | undefined) => unknown[];
+    /** Every genuineness answer from this factory; a create adds one address. */
+    readonly isAirdropAll: (s: Scope) => unknown[];
+    readonly tokenOf: (s: Scope, airdrop: Address | undefined) => unknown[];
+    readonly complianceManagerOf: (s: Scope, airdrop: Address | undefined) => unknown[];
     readonly implementations: (s: Scope) => unknown[];
     readonly compliancePolicy: (s: Scope, creator: Address | undefined) => unknown[];
     readonly compliancePolicyAll: (s: Scope) => unknown[];
@@ -76,15 +98,40 @@ export declare const airdropKeys: {
     readonly factoryHasRole: (s: Scope, role: Hex | undefined, holder: Address | undefined) => unknown[];
     readonly factoryHasRoleAll: (s: Scope) => unknown[];
     readonly factoryRoleMembers: (s: Scope, role: Hex | undefined) => unknown[];
-    readonly factoryRoleMembersAll: (s: Scope) => unknown[];
+    readonly effectiveDelegateToCompliance: (s: Scope, creator: Address | undefined) => unknown[];
+    /** Every creator's effective compliance default; the factory-wide default moves them all. */
+    readonly effectiveDelegateToComplianceAll: (s: Scope) => unknown[];
+    readonly effectiveUpgradeable: (s: Scope, creator: Address | undefined) => unknown[];
+    /** Every creator's effective upgradeability; the factory-wide default moves them all. */
+    readonly effectiveUpgradeableAll: (s: Scope) => unknown[];
+    readonly complianceDelegate: (s: Scope) => unknown[];
+    /** Keyed on `mode` only: `params` does not affect the hash (see `useEcdsaInitCodeHash`). */
+    readonly ecdsaInitCodeHash: (s: Scope, mode: DeploymentMode) => unknown[];
+    readonly ecdsaInitCodeHashAll: (s: Scope) => unknown[];
+    readonly predictEcdsaAddress: (s: Scope, mode: DeploymentMode, deployer: Address, userSalt: Hex) => unknown[];
+    readonly predictEcdsaAddressAll: (s: Scope) => unknown[];
+    readonly merkleInitCodeHash: (s: Scope, mode: DeploymentMode) => unknown[];
+    readonly merkleInitCodeHashAll: (s: Scope) => unknown[];
+    readonly predictMerkleAddress: (s: Scope, mode: DeploymentMode, deployer: Address, userSalt: Hex) => unknown[];
+    readonly predictMerkleAddressAll: (s: Scope) => unknown[];
     readonly complianceInfo: (s: Scope) => unknown[];
     readonly activeDelegate: (s: Scope, delegate: Address | undefined) => unknown[];
-    readonly activeDelegateAll: (s: Scope) => unknown[];
-    readonly clientDelegates: (s: Scope, index: bigint | undefined) => unknown[];
-    readonly clientDelegatesAll: (s: Scope) => unknown[];
     readonly complianceHasRole: (s: Scope, role: Hex | undefined, holder: Address | undefined) => unknown[];
     readonly complianceHasRoleAll: (s: Scope) => unknown[];
     readonly complianceRoleMembers: (s: Scope, role: Hex | undefined) => unknown[];
-    readonly complianceRoleMembersAll: (s: Scope) => unknown[];
 };
+/**
+ * Invalidate everything a create makes stale, for the four factory create hooks.
+ *
+ * - `registryAll`: the registry gained an instance.
+ * - `isAirdropAll`: `isAirdrop(airdrop)` flipped from false to true.
+ * - `preflightCreateAll`: the create consumed its `(mode, deployer, userSalt)`, so a cached
+ *   `ready: true` for it is now a guaranteed `SaltCollisionError`.
+ * - `tokenOf` / `complianceManagerOf` for `airdrop`: a read of the predicted address taken
+ *   before the create cached a zero.
+ *
+ * A receipt-free create runs this too, before the transaction executes. That is harmless:
+ * the refetch reads the pre-create state and the entries are marked stale again later.
+ */
+export declare function invalidateAfterCreate(queryClient: QueryClient, scope: Scope, airdrop: Address): void;
 export {};

package/dist/fhe-airdrop/react/useAccessEcdsaClaimAmount.d.ts

@@ -10,15 +10,18 @@ import { type EcdsaAirdropInstanceClientOptions } from "./_shared.js";
  * with `FHE.allow(amount, msg.sender)`, unlike {@link useAccessMerkleClaimAmount}, whose
  * grantee is the entry's claim identity rather than the caller.
  *
- * `dedupMode` must be supplied - the contract has no on-chain getter for it; pass the
- * same value used at `createEcdsaAirdrop` time.
+ * An empty `inputProof` is accepted only for a zero handle or one the sender and the
+ * instance already hold ACL on; see `EcdsaClaimArgs.encryptedInput`.
+ *
+ * `dedupMode` is deprecated - no call branches on it. Read the
+ * instance's actual policy with `useDedupMode`.
  *
  * **Invalidates:** nothing. The preview consumes neither replay guard nor the EIP-712
  * digest, so the same input is still claimable for real afterwards and no cached read
  * changes value.
  *
  * @example
- * const preview = useAccessEcdsaClaimAmount({ address: airdropAddress, dedupMode: "perAddress" });
+ * const preview = useAccessEcdsaClaimAmount({ address: airdropAddress });
  * const { handle } = await preview.mutateAsync({ encryptedInput, dedupId, deadline, signer, signature });
  *
  * @alpha

package/dist/fhe-airdrop/react/useAccessMerkleClaimAmount.d.ts

@@ -6,8 +6,8 @@ import { type AirdropInstanceClientOptions } from "./_shared.js";
  * **Submits a transaction.** Previews the outstanding amount for a proof-bearing Merkle
  * entry as an encrypted handle. Pass `data.handle` to the Zama relayer's `userDecrypt`.
  *
- * `entry.boundTo` must be the sending account (the coprocessor verifies the input proof
- * against the literal caller); `entry.account` selects the leaf.
+ * `entry.account` selects the leaf. A leaf someone else already settled previews as an
+ * encrypted zero; see {@link MerkleClaimArgs.entry}.
  *
  * **`entry.account` is the only party that can decrypt the result, not the submitter.**
  * The contract grants the outstanding handle with `_outstandingOf(account, account, …)`,