@zama-fhe/react-sdk 1.0.0-alpha.13 → 1.0.0-alpha.15

package/dist/index.js

@@ -1,9 +1,11 @@
 "use client";
-import { ZamaSDK, ReadonlyToken, DecryptionFailedError, sortByBlockNumber, parseActivityFeed, extractEncryptedHandles, applyDecryptedValues, totalSupplyContract, getWrapFeeContract, getUnwrapFeeContract, getBatchTransferFeeContract, getFeeRecipientContract } from '@zama-fhe/sdk';
+import { ZamaSDK } from '@zama-fhe/sdk';
 export { ApprovalFailedError, BATCH_SWAP_ABI, ChromeSessionStorage, CredentialsManager, DEPLOYMENT_COORDINATOR_ABI, DecryptionFailedError, ENCRYPTION_ABI, ERC165_ABI, ERC20_ABI, ERC20_METADATA_ABI, ERC7984_INTERFACE_ID, ERC7984_WRAPPER_INTERFACE_ID, EncryptionFailedError, FEE_MANAGER_ABI, HardhatConfig, IndexedDBStorage, InvalidKeypairError, KeypairExpiredError, MainnetConfig, MemoryStorage, NoCiphertextError, ReadonlyToken, RelayerRequestFailedError, RelayerWeb, SepoliaConfig, SigningFailedError, SigningRejectedError, TOKEN_TOPICS, TRANSFER_BATCHER_ABI, Token, Topics, TransactionRevertedError, WRAPPER_ABI, ZERO_HANDLE, ZamaError, ZamaErrorCode, ZamaSDK, ZamaSDKEvents, allowanceContract, applyDecryptedValues, approveContract, balanceOfContract, chromeSessionStorage, clearPendingUnshield, confidentialBalanceOfContract, confidentialBatchTransferContract, confidentialTotalSupplyContract, confidentialTransferContract, confidentialTransferFromContract, decimalsContract, decodeConfidentialTransfer, decodeOnChainEvent, decodeOnChainEvents, decodeUnwrapRequested, decodeUnwrappedFinalized, decodeUnwrappedStarted, decodeWrapped, deploymentCoordinatorContract, extractEncryptedHandles, finalizeUnwrapContract, findUnwrapRequested, findWrapped, getBatchTransferFeeContract, getFeeRecipientContract, getUnwrapFeeContract, getWrapFeeContract, getWrapperContract, indexedDBStorage, isConfidentialTokenContract, isConfidentialWrapperContract, isFinalizeUnwrapOperatorContract, isOperatorContract, loadPendingUnshield, matchZamaError, nameContract, parseActivityFeed, rateContract, savePendingUnshield, setFinalizeUnwrapOperatorContract, setOperatorContract, sortByBlockNumber, supportsInterfaceContract, symbolContract, totalSupplyContract, underlyingContract, unwrapContract, unwrapFromBalanceContract, wrapContract, wrapETHContract, wrapperExistsContract } from '@zama-fhe/sdk';
+import { invalidateWalletLifecycleQueries, encryptMutationOptions, zamaQueryKeys, hashFn, publicKeyQueryOptions, publicParamsQueryOptions, signerAddressQueryOptions, confidentialHandleQueryOptions, confidentialBalanceQueryOptions, confidentialHandlesQueryOptions, confidentialBalancesQueryOptions, allowMutationOptions, isAllowedQueryOptions, revokeMutationOptions, revokeSessionMutationOptions, invalidateAfterTransfer, confidentialTransferMutationOptions, confidentialTransferFromMutationOptions, invalidateAfterApprove, confidentialApproveMutationOptions, confidentialIsApprovedQueryOptions, invalidateAfterShield, shieldMutationOptions, shieldETHMutationOptions, invalidateAfterUnwrap, unwrapMutationOptions, unwrapAllMutationOptions, invalidateAfterUnshield, finalizeUnwrapMutationOptions, unshieldMutationOptions, unshieldAllMutationOptions, resumeUnshieldMutationOptions, underlyingAllowanceQueryOptions, wrapperDiscoveryQueryOptions, tokenMetadataQueryOptions, activityFeedQueryOptions, invalidateAfterApproveUnderlying, approveUnderlyingMutationOptions, isConfidentialQueryOptions, isWrapperQueryOptions, totalSupplyQueryOptions, shieldFeeQueryOptions, unshieldFeeQueryOptions, batchTransferFeeQueryOptions, feeRecipientQueryOptions } from '@zama-fhe/sdk/query';
+export { activityFeedQueryOptions, allowMutationOptions, approveUnderlyingMutationOptions, batchTransferFeeQueryOptions, confidentialApproveMutationOptions, confidentialBalanceQueryOptions, confidentialBalancesQueryOptions, confidentialHandleQueryOptions, confidentialHandlesQueryOptions, confidentialIsApprovedQueryOptions, confidentialTransferFromMutationOptions, confidentialTransferMutationOptions, encryptMutationOptions, feeRecipientQueryOptions, filterQueryOptions, finalizeUnwrapMutationOptions, hashFn, isAllowedQueryOptions, isConfidentialQueryOptions, isWrapperQueryOptions, publicKeyQueryOptions, publicParamsQueryOptions, resumeUnshieldMutationOptions, revokeMutationOptions, revokeSessionMutationOptions, shieldETHMutationOptions, shieldFeeQueryOptions, shieldMutationOptions, signerAddressQueryOptions, tokenMetadataQueryOptions, totalSupplyQueryOptions, underlyingAllowanceQueryOptions, unshieldAllMutationOptions, unshieldFeeQueryOptions, unshieldMutationOptions, unwrapAllMutationOptions, unwrapMutationOptions, wrapperDiscoveryQueryOptions, zamaQueryKeys } from '@zama-fhe/sdk/query';
+import { useQueryClient, useMutation, useQuery, useQueries, skipToken, useSuspenseQuery as useSuspenseQuery$1 } from '@tanstack/react-query';
 import { createContext, useRef, useEffect, useMemo, useContext } from 'react';
 import { jsx } from 'react/jsx-runtime';
-import { useMutation, useQueryClient, useQuery, useQueries, skipToken, useSuspenseQuery } from '@tanstack/react-query';
 
 // src/provider.tsx
 var ZamaSDKContext = createContext(null);
@@ -17,10 +19,19 @@ function ZamaProvider({
   sessionTTL,
   onEvent
 }) {
+  const queryClient = useQueryClient();
   const onEventRef = useRef(onEvent);
   useEffect(() => {
     onEventRef.current = onEvent;
   });
+  const signerLifecycleCallbacks = useMemo(
+    () => signer?.subscribe ? {
+      onDisconnect: () => invalidateWalletLifecycleQueries(queryClient),
+      onAccountChange: () => invalidateWalletLifecycleQueries(queryClient),
+      onChainChange: () => invalidateWalletLifecycleQueries(queryClient)
+    } : void 0,
+    [queryClient, signer]
+  );
   const sdk = useMemo(
     () => new ZamaSDK({
       relayer,
@@ -29,9 +40,10 @@ function ZamaProvider({
       sessionStorage,
       keypairTTL,
       sessionTTL,
-      onEvent: onEventRef.current
+      onEvent: onEventRef.current,
+      signerLifecycleCallbacks
     }),
-    [relayer, signer, storage, sessionStorage, keypairTTL, sessionTTL]
+    [relayer, signer, storage, sessionStorage, keypairTTL, sessionTTL, signerLifecycleCallbacks]
   );
   useEffect(() => () => sdk.dispose(), [sdk]);
   return /* @__PURE__ */ jsx(ZamaSDKContext.Provider, { value: sdk, children });
@@ -45,20 +57,12 @@ function useZamaSDK() {
   }
   return context;
 }
-function encryptMutationOptions(sdk) {
-  return {
-    mutationKey: ["encrypt"],
-    mutationFn: (params) => sdk.relayer.encrypt(params)
-  };
-}
 function useEncrypt() {
   const sdk = useZamaSDK();
   return useMutation(encryptMutationOptions(sdk));
 }
-
-// src/relayer/decryption-cache.ts
 var decryptionKeys = {
-  value: (handle) => ["decryptedValue", handle]
+  value: (handle, contractAddress) => zamaQueryKeys.decryption.handle(handle, contractAddress)
 };
 
 // src/relayer/use-user-decrypt.ts
@@ -128,37 +132,19 @@ function useRequestZKProofVerification() {
     mutationFn: (zkProof) => sdk.relayer.requestZKProofVerification(zkProof)
   });
 }
-var publicKeyQueryKeys = {
-  /** Match the public key query. */
-  all: ["publicKey"]
-};
-function publicKeyQueryOptions(sdk) {
-  return {
-    queryKey: publicKeyQueryKeys.all,
-    queryFn: () => sdk.relayer.getPublicKey(),
-    staleTime: Infinity
-  };
-}
 function usePublicKey() {
   const sdk = useZamaSDK();
-  return useQuery(publicKeyQueryOptions(sdk));
-}
-var publicParamsQueryKeys = {
-  /** Match all public params queries. */
-  all: ["publicParams"],
-  /** Match public params query for a specific bit size. */
-  bits: (bits) => ["publicParams", bits]
-};
-function publicParamsQueryOptions(sdk, bits) {
-  return {
-    queryKey: publicParamsQueryKeys.bits(bits),
-    queryFn: () => sdk.relayer.getPublicParams(bits),
-    staleTime: Infinity
-  };
+  return useQuery({
+    ...publicKeyQueryOptions(sdk),
+    queryKeyHashFn: hashFn
+  });
 }
 function usePublicParams(bits) {
   const sdk = useZamaSDK();
-  return useQuery(publicParamsQueryOptions(sdk, bits));
+  return useQuery({
+    ...publicParamsQueryOptions(sdk, bits),
+    queryKeyHashFn: hashFn
+  });
 }
 function useUserDecryptFlow(config) {
   const sdk = useZamaSDK();
@@ -202,8 +188,9 @@ function useUserDecryptFlow(config) {
         });
         Object.assign(allResults, result);
       }
-      callbacks?.onDecrypted?.(allResults);
-      return allResults;
+      const results = allResults;
+      callbacks?.onDecrypted?.(results);
+      return results;
     },
     onSuccess: (data) => {
       for (const [handle, value] of Object.entries(data)) {
@@ -214,7 +201,8 @@ function useUserDecryptFlow(config) {
 }
 function useUserDecryptedValue(handle) {
   return useQuery({
-    queryKey: decryptionKeys.value(handle ?? ""),
+    queryKey: decryptionKeys.value(handle ?? "0x"),
+    queryKeyHashFn: hashFn,
     queryFn: () => void 0,
     enabled: false
   });
@@ -223,6 +211,7 @@ function useUserDecryptedValues(handles) {
   const results = useQueries({
     queries: handles.map((handle) => ({
       queryKey: decryptionKeys.value(handle),
+      queryKeyHashFn: hashFn,
       queryFn: () => void 0,
       enabled: false
     }))
@@ -247,659 +236,429 @@ function useReadonlyToken(address) {
   const sdk = useZamaSDK();
   return useMemo(() => sdk.createReadonlyToken(address), [sdk, address]);
 }
-
-// src/token/balance-query-keys.ts
-var confidentialBalanceQueryKeys = {
-  /** Match all single-token balance queries. */
-  all: ["confidentialBalance"],
-  /** Match balance queries for a specific token (any owner). */
-  token: (tokenAddress) => ["confidentialBalance", tokenAddress],
-  /** Match balance query for a specific token + owner. */
-  owner: (tokenAddress, owner) => ["confidentialBalance", tokenAddress, owner]
-};
-var confidentialBalancesQueryKeys = {
-  /** Match all batch balance queries. */
-  all: ["confidentialBalances"],
-  /** Match batch balance query for a specific token set + owner. */
-  tokens: (tokenAddresses, owner) => ["confidentialBalances", tokenAddresses, owner]
-};
-var confidentialHandleQueryKeys = {
-  /** Match all single-token handle queries. */
-  all: ["confidentialHandle"],
-  /** Match handle queries for a specific token (any owner). */
-  token: (tokenAddress) => ["confidentialHandle", tokenAddress],
-  /** Match handle query for a specific token + owner. */
-  owner: (tokenAddress, owner) => ["confidentialHandle", tokenAddress, owner]
-};
-var confidentialHandlesQueryKeys = {
-  /** Match all batch handle queries. */
-  all: ["confidentialHandles"],
-  /** Match batch handle query for a specific token set + owner. */
-  tokens: (tokenAddresses, owner) => ["confidentialHandles", tokenAddresses, owner]
-};
-var wagmiBalancePredicates = {
-  /** Match all wagmi balance queries. */
-  balanceOf: (query) => Array.isArray(query.queryKey) && query.queryKey.some(
-    (key) => typeof key === "object" && key !== null && "functionName" in key && key.functionName === "balanceOf"
-  )};
-
-// src/token/use-confidential-balance.ts
-var DEFAULT_HANDLE_REFETCH_INTERVAL = 1e4;
+function useQuery4(options) {
+  return useQuery({
+    ...options,
+    queryKeyHashFn: hashFn
+  });
+}
+function useSuspenseQuery(options) {
+  return useSuspenseQuery$1({
+    ...options,
+    queryKeyHashFn: hashFn
+  });
+}
 function useConfidentialBalance(config, options) {
   const { tokenAddress, handleRefetchInterval } = config;
+  const userEnabled = options?.enabled;
   const token = useReadonlyToken(tokenAddress);
-  const addressQuery = useQuery({
-    queryKey: ["zama", "signer-address", tokenAddress],
-    queryFn: () => token.signer.getAddress()
-  });
-  const signerAddress = addressQuery.data;
-  const ownerKey = signerAddress ?? "";
-  const handleQuery = useQuery({
-    queryKey: confidentialHandleQueryKeys.owner(tokenAddress, ownerKey),
-    queryFn: () => token.confidentialBalanceOf(),
-    enabled: !!signerAddress,
-    refetchInterval: handleRefetchInterval ?? DEFAULT_HANDLE_REFETCH_INTERVAL
+  const addressQuery = useQuery4({
+    ...signerAddressQueryOptions(token.signer)
+  });
+  const owner = addressQuery.data;
+  const baseHandleQueryOptions = confidentialHandleQueryOptions(token.signer, tokenAddress, {
+    owner,
+    pollingInterval: handleRefetchInterval
+  });
+  const handleFactoryEnabled = baseHandleQueryOptions.enabled ?? true;
+  const handleQuery = useQuery4({
+    ...baseHandleQueryOptions,
+    enabled: handleFactoryEnabled && (userEnabled ?? true)
   });
   const handle = handleQuery.data;
-  const balanceQuery = useQuery({
-    queryKey: [...confidentialBalanceQueryKeys.owner(tokenAddress, ownerKey), handle ?? ""],
-    queryFn: () => token.decryptBalance(handle),
-    enabled: !!signerAddress && !!handle,
-    staleTime: Infinity,
-    ...options
+  const baseBalanceQueryOptions = confidentialBalanceQueryOptions(token, {
+    handle,
+    owner
+  });
+  const factoryEnabled = baseBalanceQueryOptions.enabled ?? true;
+  const balanceQuery = useQuery4({
+    ...baseBalanceQueryOptions,
+    ...options,
+    enabled: factoryEnabled && (userEnabled ?? true)
   });
   return { ...balanceQuery, handleQuery };
 }
-var DEFAULT_HANDLE_REFETCH_INTERVAL2 = 1e4;
 function useConfidentialBalances(config, options) {
   const { tokenAddresses, handleRefetchInterval, maxConcurrency } = config;
+  const userEnabled = options?.enabled;
   const sdk = useZamaSDK();
-  const addressQuery = useQuery({
-    queryKey: ["zama", "signer-address"],
-    queryFn: () => sdk.signer.getAddress()
+  const addressQuery = useQuery4({
+    ...signerAddressQueryOptions(sdk.signer)
   });
-  const signerAddress = addressQuery.data;
-  const ownerKey = signerAddress ?? "";
+  const owner = addressQuery.data;
   const tokens = useMemo(
     () => tokenAddresses.map((addr) => sdk.createReadonlyToken(addr)),
     [sdk, tokenAddresses]
   );
-  const handlesQuery = useQuery({
-    queryKey: confidentialHandlesQueryKeys.tokens(tokenAddresses, ownerKey),
-    queryFn: () => Promise.all(tokens.map((t) => t.confidentialBalanceOf())),
-    enabled: tokenAddresses.length > 0 && !!signerAddress,
-    refetchInterval: handleRefetchInterval ?? DEFAULT_HANDLE_REFETCH_INTERVAL2
+  const baseHandlesQueryOptions = confidentialHandlesQueryOptions(sdk.signer, tokenAddresses, {
+    owner,
+    pollingInterval: handleRefetchInterval
+  });
+  const handlesFactoryEnabled = baseHandlesQueryOptions.enabled ?? true;
+  const handlesQuery = useQuery4({
+    ...baseHandlesQueryOptions,
+    enabled: handlesFactoryEnabled && (userEnabled ?? true)
   });
   const handles = handlesQuery.data;
-  const handlesKey = handles?.join(",") ?? "";
-  const balancesQuery = useQuery({
-    queryKey: [...confidentialBalancesQueryKeys.tokens(tokenAddresses, ownerKey), handlesKey],
-    queryFn: async () => {
-      const perTokenErrors = /* @__PURE__ */ new Map();
-      const raw = await ReadonlyToken.batchDecryptBalances(tokens, {
-        handles,
-        maxConcurrency,
-        onError: (error, address) => {
-          perTokenErrors.set(address, error);
-          return 0n;
-        }
-      });
-      const balances = /* @__PURE__ */ new Map();
-      const errors = /* @__PURE__ */ new Map();
-      for (let i = 0; i < tokens.length; i++) {
-        const tokenAddr = tokens[i].address;
-        const originalAddr = tokenAddresses[i];
-        const tokenError = perTokenErrors.get(tokenAddr);
-        if (tokenError) {
-          errors.set(originalAddr, tokenError);
-        } else {
-          const balance = raw.get(tokenAddr);
-          if (balance !== void 0) balances.set(originalAddr, balance);
-        }
-      }
-      if (errors.size === tokens.length && tokens.length > 0) {
-        throw errors.values().next().value ?? new DecryptionFailedError("All token balance decryptions failed");
-      }
-      return {
-        balances,
-        errors,
-        isPartialError: errors.size > 0
-      };
-    },
-    enabled: tokenAddresses.length > 0 && !!signerAddress && !!handles,
-    staleTime: Infinity,
-    ...options
+  const handlesReady = Array.isArray(handles) && handles.length === tokenAddresses.length;
+  const baseBalancesQueryOptions = confidentialBalancesQueryOptions(tokens, {
+    owner,
+    handles,
+    maxConcurrency,
+    resultAddresses: tokenAddresses
+  });
+  const factoryEnabled = baseBalancesQueryOptions.enabled ?? true;
+  const balancesQuery = useQuery4({
+    ...baseBalancesQueryOptions,
+    ...options,
+    enabled: factoryEnabled && handlesReady && (userEnabled ?? true)
   });
   return { ...balancesQuery, handlesQuery };
 }
-var isAllowedQueryKeys = {
-  all: ["zama", "isAllowed"]
-};
-function isAllowedQueryOptions(sdk) {
-  return {
-    queryKey: isAllowedQueryKeys.all,
-    queryFn: () => sdk.isAllowed()
-  };
-}
-function useIsAllowed() {
+function useAllow(options) {
   const sdk = useZamaSDK();
-  return useQuery(isAllowedQueryOptions(sdk));
-}
-
-// src/token/use-allow.ts
-function allowMutationOptions(sdk) {
-  return {
-    mutationKey: ["allow"],
-    mutationFn: async (tokenAddresses) => {
-      await sdk.allow(...tokenAddresses);
-    }
-  };
-}
-function useAllow() {
-  const sdk = useZamaSDK();
-  const queryClient = useQueryClient();
   return useMutation({
     ...allowMutationOptions(sdk),
-    onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: isAllowedQueryKeys.all });
+    ...options,
+    onSuccess: (data, variables, onMutateResult, context) => {
+      options?.onSuccess?.(data, variables, onMutateResult, context);
+      context.client.invalidateQueries({ queryKey: zamaQueryKeys.isAllowed.all });
     }
   });
 }
-function revokeMutationOptions(sdk) {
-  return {
-    mutationKey: ["revoke"],
-    mutationFn: async (tokenAddresses) => {
-      await sdk.revoke(...tokenAddresses);
-    }
+function useIsAllowed() {
+  const sdk = useZamaSDK();
+  const addressQuery = useQuery4({
+    ...signerAddressQueryOptions(sdk.signer)
+  });
+  const account = addressQuery.data;
+  const baseOpts = account ? isAllowedQueryOptions(sdk, { account }) : {
+    queryKey: zamaQueryKeys.isAllowed.all,
+    queryFn: skipToken
   };
+  const factoryEnabled = "enabled" in baseOpts ? baseOpts.enabled ?? true : true;
+  return useQuery4({
+    ...baseOpts,
+    enabled: factoryEnabled
+  });
 }
-function useRevoke() {
+function useRevoke(options) {
   const sdk = useZamaSDK();
-  const queryClient = useQueryClient();
   return useMutation({
     ...revokeMutationOptions(sdk),
-    onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: isAllowedQueryKeys.all });
+    ...options,
+    onSuccess: (data, variables, onMutateResult, context) => {
+      options?.onSuccess?.(data, variables, onMutateResult, context);
+      context.client.invalidateQueries({ queryKey: zamaQueryKeys.isAllowed.all });
     }
   });
 }
-function revokeSessionMutationOptions(sdk) {
-  return {
-    mutationKey: ["revokeSession"],
-    mutationFn: async () => {
-      await sdk.revokeSession();
-    }
-  };
-}
-function useRevokeSession() {
+function useRevokeSession(options) {
   const sdk = useZamaSDK();
-  const queryClient = useQueryClient();
   return useMutation({
     ...revokeSessionMutationOptions(sdk),
-    onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: isAllowedQueryKeys.all });
+    ...options,
+    onSuccess: (data, variables, onMutateResult, context) => {
+      options?.onSuccess?.(data, variables, onMutateResult, context);
+      context.client.invalidateQueries({ queryKey: zamaQueryKeys.isAllowed.all });
     }
   });
 }
-function confidentialTransferMutationOptions(token) {
-  return {
-    mutationKey: ["confidentialTransfer", token.address],
-    mutationFn: ({ to, amount, callbacks }) => token.confidentialTransfer(to, amount, callbacks)
-  };
+function unwrapOptimisticCallerContext(optimistic, rawContext) {
+  const wrappedContext = optimistic ? rawContext : void 0;
+  const callerContext = optimistic ? wrappedContext?.callerContext : rawContext;
+  return { wrappedContext, callerContext };
+}
+async function applyOptimisticBalanceDelta(queryClient, tokenAddress, amount, mode) {
+  const balanceKey = zamaQueryKeys.confidentialBalance.token(tokenAddress);
+  await queryClient.cancelQueries({ queryKey: balanceKey });
+  const previous = queryClient.getQueriesData({ queryKey: balanceKey });
+  for (const [key, value] of previous) {
+    if (value === void 0) continue;
+    queryClient.setQueryData(key, mode === "add" ? value + amount : value - amount);
+  }
+  return previous;
 }
+function rollbackOptimisticBalanceDelta(queryClient, snapshot) {
+  for (const [key, value] of snapshot) {
+    queryClient.setQueryData(key, value);
+  }
+}
+
+// src/token/use-confidential-transfer.ts
 function useConfidentialTransfer(config, options) {
   const token = useToken(config);
   const queryClient = useQueryClient();
-  return useMutation({
-    mutationKey: ["confidentialTransfer", config.tokenAddress],
-    mutationFn: ({ to, amount, callbacks }) => token.confidentialTransfer(to, amount, callbacks),
-    ...options,
-    onMutate: config.optimistic ? async (variables, mutationContext) => {
-      const balanceKey = confidentialBalanceQueryKeys.token(config.tokenAddress);
-      await queryClient.cancelQueries({ queryKey: balanceKey });
-      const previous = queryClient.getQueriesData({ queryKey: balanceKey });
-      for (const [key, value] of previous) {
-        if (value !== void 0) {
-          queryClient.setQueryData(key, value - variables.amount);
+  return useMutation(
+    {
+      ...confidentialTransferMutationOptions(token),
+      ...options,
+      onMutate: config.optimistic ? async (variables, mutationContext) => {
+        const snapshot = await applyOptimisticBalanceDelta(
+          queryClient,
+          config.tokenAddress,
+          variables.amount,
+          "subtract"
+        );
+        const callerContext = await options?.onMutate?.(variables, mutationContext);
+        return { snapshot, callerContext };
+      } : options?.onMutate,
+      onError: (error, variables, rawContext, context) => {
+        const { wrappedContext, callerContext } = unwrapOptimisticCallerContext(
+          config.optimistic,
+          rawContext
+        );
+        if (wrappedContext) {
+          rollbackOptimisticBalanceDelta(queryClient, wrappedContext.snapshot);
         }
+        options?.onError?.(
+          error,
+          variables,
+          callerContext,
+          context
+        );
+      },
+      onSuccess: (data, variables, rawContext, context) => {
+        const { callerContext } = unwrapOptimisticCallerContext(config.optimistic, rawContext);
+        options?.onSuccess?.(data, variables, callerContext, context);
+        invalidateAfterTransfer(context.client, config.tokenAddress);
+      },
+      onSettled: (data, error, variables, rawContext, context) => {
+        const { callerContext } = unwrapOptimisticCallerContext(config.optimistic, rawContext);
+        options?.onSettled?.(
+          data,
+          error,
+          variables,
+          callerContext,
+          context
+        );
       }
-      return options?.onMutate?.(variables, mutationContext) ?? config.tokenAddress;
-    } : options?.onMutate,
-    onError: (error, variables, onMutateResult, context) => {
-      if (config.optimistic) {
-        queryClient.invalidateQueries({
-          queryKey: confidentialBalanceQueryKeys.token(config.tokenAddress)
-        });
-      }
-      options?.onError?.(error, variables, onMutateResult, context);
-    },
+    }
+  );
+}
+function useConfidentialTransferFrom(config, options) {
+  const token = useToken(config);
+  return useMutation({
+    ...confidentialTransferFromMutationOptions(token),
+    ...options,
     onSuccess: (data, variables, onMutateResult, context) => {
-      context.client.invalidateQueries({
-        queryKey: confidentialHandleQueryKeys.token(config.tokenAddress)
-      });
-      context.client.invalidateQueries({
-        queryKey: confidentialHandlesQueryKeys.all
-      });
-      context.client.resetQueries({
-        queryKey: confidentialBalanceQueryKeys.token(config.tokenAddress)
-      });
-      context.client.invalidateQueries({
-        queryKey: confidentialBalancesQueryKeys.all
-      });
       options?.onSuccess?.(data, variables, onMutateResult, context);
+      invalidateAfterTransfer(context.client, config.tokenAddress);
     }
   });
 }
-function confidentialTransferFromMutationOptions(token) {
-  return {
-    mutationKey: ["confidentialTransferFrom", token.address],
-    mutationFn: ({ from, to, amount, callbacks }) => token.confidentialTransferFrom(from, to, amount, callbacks)
-  };
-}
-function useConfidentialTransferFrom(config, options) {
+function useConfidentialApprove(config, options) {
   const token = useToken(config);
   return useMutation({
-    mutationKey: ["confidentialTransferFrom", config.tokenAddress],
-    mutationFn: ({ from, to, amount, callbacks }) => token.confidentialTransferFrom(from, to, amount, callbacks),
+    ...confidentialApproveMutationOptions(token),
     ...options,
     onSuccess: (data, variables, onMutateResult, context) => {
-      context.client.invalidateQueries({
-        queryKey: confidentialHandleQueryKeys.token(config.tokenAddress)
-      });
-      context.client.invalidateQueries({
-        queryKey: confidentialHandlesQueryKeys.all
-      });
-      context.client.resetQueries({
-        queryKey: confidentialBalanceQueryKeys.token(config.tokenAddress)
-      });
-      context.client.invalidateQueries({
-        queryKey: confidentialBalancesQueryKeys.all
-      });
       options?.onSuccess?.(data, variables, onMutateResult, context);
+      invalidateAfterApprove(context.client, config.tokenAddress);
     }
   });
 }
-var confidentialIsApprovedQueryKeys = {
-  /** Match all approval queries. */
-  all: ["confidentialIsApproved"],
-  /** Match approval queries for a specific token. */
-  token: (tokenAddress) => ["confidentialIsApproved", tokenAddress],
-  /** Match approval queries for a specific token + spender pair. */
-  spender: (tokenAddress, spender, holder) => ["confidentialIsApproved", tokenAddress, spender, holder ?? ""]
-};
-function confidentialIsApprovedQueryOptions(token, spender, holder) {
-  return {
-    queryKey: confidentialIsApprovedQueryKeys.spender(token.address, spender, holder),
-    queryFn: () => token.isApproved(spender, holder),
-    staleTime: 3e4
-  };
-}
 function useConfidentialIsApproved(config, options) {
   const { spender, holder, ...tokenConfig } = config;
+  const userEnabled = options?.enabled;
   const token = useToken(tokenConfig);
-  return useQuery({
-    ...spender ? confidentialIsApprovedQueryOptions(token, spender, holder) : {
-      queryKey: confidentialIsApprovedQueryKeys.spender(config.tokenAddress, "", holder),
-      queryFn: skipToken
-    },
-    ...options
+  const holderQuery = useQuery4({
+    ...signerAddressQueryOptions(token.signer),
+    enabled: holder === void 0
+  });
+  const resolvedHolder = holder ?? holderQuery.data;
+  const baseOpts = spender && resolvedHolder ? confidentialIsApprovedQueryOptions(token.signer, token.address, {
+    holder: resolvedHolder,
+    spender
+  }) : {
+    queryKey: zamaQueryKeys.confidentialIsApproved.token(config.tokenAddress),
+    queryFn: skipToken
+  };
+  const factoryEnabled = "enabled" in baseOpts ? baseOpts.enabled ?? true : true;
+  return useQuery4({
+    ...baseOpts,
+    ...options,
+    enabled: factoryEnabled && (userEnabled ?? true)
   });
 }
 function useConfidentialIsApprovedSuspense(config) {
   const { spender, holder, ...tokenConfig } = config;
   const token = useToken(tokenConfig);
-  return useSuspenseQuery(
-    confidentialIsApprovedQueryOptions(token, spender, holder)
-  );
-}
-
-// src/token/use-confidential-approve.ts
-function confidentialApproveMutationOptions(token) {
-  return {
-    mutationKey: ["confidentialApprove", token.address],
-    mutationFn: ({ spender, until }) => token.approve(spender, until)
-  };
-}
-function useConfidentialApprove(config, options) {
-  const token = useToken(config);
-  return useMutation({
-    mutationKey: ["confidentialApprove", config.tokenAddress],
-    mutationFn: ({ spender, until }) => token.approve(spender, until),
-    ...options,
-    onSuccess: (data, variables, onMutateResult, context) => {
-      context.client.invalidateQueries({
-        queryKey: confidentialIsApprovedQueryKeys.token(config.tokenAddress)
-      });
-      options?.onSuccess?.(data, variables, onMutateResult, context);
-    }
+  const addressQuery = useSuspenseQuery({
+    ...signerAddressQueryOptions(token.signer)
+  });
+  const resolvedHolder = holder ?? addressQuery.data;
+  return useSuspenseQuery({
+    ...confidentialIsApprovedQueryOptions(token.signer, token.address, {
+      holder: resolvedHolder,
+      spender
+    })
   });
-}
-function shieldMutationOptions(token) {
-  return {
-    mutationKey: ["shield", token.address],
-    mutationFn: async ({ amount, fees, approvalStrategy, to, callbacks }) => token.shield(amount, { fees, approvalStrategy, to, callbacks })
-  };
 }
 function useShield(config, options) {
   const token = useToken(config);
   const queryClient = useQueryClient();
   return useMutation({
-    mutationKey: ["shield", config.tokenAddress],
-    mutationFn: async ({ amount, fees, approvalStrategy, to, callbacks }) => token.shield(amount, { fees, approvalStrategy, to, callbacks }),
+    ...shieldMutationOptions(token),
     ...options,
     onMutate: config.optimistic ? async (variables, mutationContext) => {
-      const balanceKey = confidentialBalanceQueryKeys.token(config.tokenAddress);
-      await queryClient.cancelQueries({ queryKey: balanceKey });
-      const previous = queryClient.getQueriesData({ queryKey: balanceKey });
-      for (const [key, value] of previous) {
-        if (value !== void 0) {
-          queryClient.setQueryData(key, value + variables.amount);
-        }
-      }
-      return options?.onMutate?.(variables, mutationContext) ?? config.tokenAddress;
+      const snapshot = await applyOptimisticBalanceDelta(
+        queryClient,
+        config.tokenAddress,
+        variables.amount,
+        "add"
+      );
+      const callerContext = await options?.onMutate?.(variables, mutationContext);
+      return { snapshot, callerContext };
     } : options?.onMutate,
-    onError: (error, variables, onMutateResult, context) => {
-      if (config.optimistic) {
-        queryClient.invalidateQueries({
-          queryKey: confidentialBalanceQueryKeys.token(config.tokenAddress)
-        });
+    onError: (error, variables, rawContext, context) => {
+      const { wrappedContext, callerContext } = unwrapOptimisticCallerContext(
+        config.optimistic,
+        rawContext
+      );
+      if (wrappedContext) {
+        rollbackOptimisticBalanceDelta(queryClient, wrappedContext.snapshot);
       }
-      options?.onError?.(error, variables, onMutateResult, context);
+      options?.onError?.(
+        error,
+        variables,
+        callerContext,
+        context
+      );
     },
-    onSuccess: (data, variables, onMutateResult, context) => {
-      context.client.invalidateQueries({
-        queryKey: confidentialHandleQueryKeys.token(config.tokenAddress)
-      });
-      context.client.invalidateQueries({
-        queryKey: confidentialHandlesQueryKeys.all
-      });
-      context.client.resetQueries({
-        queryKey: confidentialBalanceQueryKeys.token(config.tokenAddress)
-      });
-      context.client.invalidateQueries({
-        queryKey: confidentialBalancesQueryKeys.all
-      });
-      context.client.invalidateQueries({
-        predicate: wagmiBalancePredicates.balanceOf
-      });
-      options?.onSuccess?.(data, variables, onMutateResult, context);
+    onSuccess: (data, variables, rawContext, context) => {
+      const { callerContext } = unwrapOptimisticCallerContext(config.optimistic, rawContext);
+      options?.onSuccess?.(data, variables, callerContext, context);
+      invalidateAfterShield(context.client, config.tokenAddress);
+    },
+    onSettled: (data, error, variables, rawContext, context) => {
+      const { callerContext } = unwrapOptimisticCallerContext(config.optimistic, rawContext);
+      options?.onSettled?.(
+        data,
+        error,
+        variables,
+        callerContext,
+        context
+      );
     }
   });
 }
-function shieldETHMutationOptions(token) {
-  return {
-    mutationKey: ["shieldETH", token.address],
-    mutationFn: ({ amount, value }) => token.shieldETH(amount, value)
-  };
-}
 function useShieldETH(config, options) {
   const token = useToken(config);
   return useMutation({
-    mutationKey: ["shieldETH", config.tokenAddress],
-    mutationFn: ({ amount, value }) => token.shieldETH(amount, value),
+    ...shieldETHMutationOptions(token),
     ...options,
     onSuccess: (data, variables, onMutateResult, context) => {
-      context.client.invalidateQueries({
-        queryKey: confidentialHandleQueryKeys.token(config.tokenAddress)
-      });
-      context.client.invalidateQueries({
-        queryKey: confidentialHandlesQueryKeys.all
-      });
-      context.client.resetQueries({
-        queryKey: confidentialBalanceQueryKeys.token(config.tokenAddress)
-      });
-      context.client.invalidateQueries({
-        queryKey: confidentialBalancesQueryKeys.all
-      });
       options?.onSuccess?.(data, variables, onMutateResult, context);
+      invalidateAfterShield(context.client, config.tokenAddress);
     }
   });
 }
-function unwrapMutationOptions(token) {
-  return {
-    mutationKey: ["unwrap", token.address],
-    mutationFn: ({ amount }) => token.unwrap(amount)
-  };
-}
 function useUnwrap(config, options) {
   const token = useToken(config);
   return useMutation({
-    mutationKey: ["unwrap", config.tokenAddress],
-    mutationFn: ({ amount }) => token.unwrap(amount),
+    ...unwrapMutationOptions(token),
     ...options,
     onSuccess: (data, variables, onMutateResult, context) => {
-      context.client.invalidateQueries({
-        queryKey: confidentialHandleQueryKeys.token(config.tokenAddress)
-      });
-      context.client.invalidateQueries({
-        queryKey: confidentialHandlesQueryKeys.all
-      });
-      context.client.resetQueries({
-        queryKey: confidentialBalanceQueryKeys.token(config.tokenAddress)
-      });
-      context.client.invalidateQueries({
-        queryKey: confidentialBalancesQueryKeys.all
-      });
       options?.onSuccess?.(data, variables, onMutateResult, context);
+      invalidateAfterUnwrap(context.client, config.tokenAddress);
     }
   });
 }
-function unwrapAllMutationOptions(token) {
-  return {
-    mutationKey: ["unwrapAll", token.address],
-    mutationFn: () => token.unwrapAll()
-  };
-}
 function useUnwrapAll(config, options) {
   const token = useToken(config);
   return useMutation({
-    mutationKey: ["unwrapAll", config.tokenAddress],
-    mutationFn: () => token.unwrapAll(),
+    ...unwrapAllMutationOptions(token),
     ...options,
     onSuccess: (data, variables, onMutateResult, context) => {
-      context.client.invalidateQueries({
-        queryKey: confidentialHandleQueryKeys.token(config.tokenAddress)
-      });
-      context.client.invalidateQueries({
-        queryKey: confidentialHandlesQueryKeys.all
-      });
-      context.client.resetQueries({
-        queryKey: confidentialBalanceQueryKeys.token(config.tokenAddress)
-      });
-      context.client.invalidateQueries({
-        queryKey: confidentialBalancesQueryKeys.all
-      });
       options?.onSuccess?.(data, variables, onMutateResult, context);
+      invalidateAfterUnwrap(context.client, config.tokenAddress);
     }
   });
 }
-var underlyingAllowanceQueryKeys = {
-  /** Match all underlying allowance queries. */
-  all: ["underlyingAllowance"],
-  /** Match allowance query for a specific token + wrapper pair. */
-  token: (tokenAddress, wrapper) => ["underlyingAllowance", tokenAddress, wrapper]
-};
-function underlyingAllowanceQueryOptions(token, wrapperAddress) {
-  return {
-    queryKey: underlyingAllowanceQueryKeys.token(token.address, wrapperAddress),
-    queryFn: () => token.allowance(wrapperAddress),
-    staleTime: 3e4
-  };
-}
-function useUnderlyingAllowance(config, options) {
-  const { tokenAddress, wrapperAddress } = config;
-  const token = useReadonlyToken(tokenAddress);
-  return useQuery({
-    ...underlyingAllowanceQueryOptions(token, wrapperAddress),
-    ...options
-  });
-}
-function useUnderlyingAllowanceSuspense(config) {
-  const { tokenAddress, wrapperAddress } = config;
-  const token = useReadonlyToken(tokenAddress);
-  return useSuspenseQuery(underlyingAllowanceQueryOptions(token, wrapperAddress));
-}
-
-// src/token/use-finalize-unwrap.ts
-function finalizeUnwrapMutationOptions(token) {
-  return {
-    mutationKey: ["finalizeUnwrap", token.address],
-    mutationFn: ({ burnAmountHandle }) => token.finalizeUnwrap(burnAmountHandle)
-  };
-}
 function useFinalizeUnwrap(config, options) {
   const token = useToken(config);
   return useMutation({
-    mutationKey: ["finalizeUnwrap", config.tokenAddress],
-    mutationFn: ({ burnAmountHandle }) => token.finalizeUnwrap(burnAmountHandle),
+    ...finalizeUnwrapMutationOptions(token),
     ...options,
     onSuccess: (data, variables, onMutateResult, context) => {
-      context.client.invalidateQueries({
-        queryKey: confidentialHandleQueryKeys.token(config.tokenAddress)
-      });
-      context.client.invalidateQueries({
-        queryKey: confidentialHandlesQueryKeys.all
-      });
-      context.client.resetQueries({
-        queryKey: confidentialBalanceQueryKeys.token(config.tokenAddress)
-      });
-      context.client.invalidateQueries({
-        queryKey: confidentialBalancesQueryKeys.all
-      });
-      context.client.invalidateQueries({
-        queryKey: underlyingAllowanceQueryKeys.all
-      });
-      context.client.invalidateQueries({ predicate: wagmiBalancePredicates.balanceOf });
       options?.onSuccess?.(data, variables, onMutateResult, context);
+      invalidateAfterUnshield(context.client, config.tokenAddress);
     }
   });
 }
-function unshieldMutationOptions(token) {
-  return {
-    mutationKey: ["unshield", token.address],
-    mutationFn: ({ amount, callbacks }) => token.unshield(amount, callbacks)
-  };
-}
 function useUnshield(config, options) {
   const token = useToken(config);
   return useMutation({
-    mutationKey: ["unshield", config.tokenAddress],
-    mutationFn: ({ amount, callbacks }) => token.unshield(amount, callbacks),
+    ...unshieldMutationOptions(token),
     ...options,
     onSuccess: (data, variables, onMutateResult, context) => {
-      context.client.invalidateQueries({
-        queryKey: confidentialHandleQueryKeys.token(config.tokenAddress)
-      });
-      context.client.invalidateQueries({
-        queryKey: confidentialHandlesQueryKeys.all
-      });
-      context.client.resetQueries({
-        queryKey: confidentialBalanceQueryKeys.token(config.tokenAddress)
-      });
-      context.client.invalidateQueries({
-        queryKey: confidentialBalancesQueryKeys.all
-      });
-      context.client.invalidateQueries({
-        queryKey: underlyingAllowanceQueryKeys.all
-      });
-      context.client.invalidateQueries({
-        predicate: wagmiBalancePredicates.balanceOf
-      });
       options?.onSuccess?.(data, variables, onMutateResult, context);
+      invalidateAfterUnshield(context.client, config.tokenAddress);
     }
   });
 }
-function unshieldAllMutationOptions(token) {
-  return {
-    mutationKey: ["unshieldAll", token.address],
-    mutationFn: (params) => token.unshieldAll(params?.callbacks)
-  };
-}
 function useUnshieldAll(config, options) {
   const token = useToken(config);
   return useMutation({
-    mutationKey: ["unshieldAll", config.tokenAddress],
-    mutationFn: (params) => token.unshieldAll(params?.callbacks),
+    ...unshieldAllMutationOptions(token),
     ...options,
     onSuccess: (data, variables, onMutateResult, context) => {
-      context.client.invalidateQueries({
-        queryKey: confidentialHandleQueryKeys.token(config.tokenAddress)
-      });
-      context.client.invalidateQueries({
-        queryKey: confidentialHandlesQueryKeys.all
-      });
-      context.client.resetQueries({
-        queryKey: confidentialBalanceQueryKeys.token(config.tokenAddress)
-      });
-      context.client.invalidateQueries({
-        queryKey: confidentialBalancesQueryKeys.all
-      });
-      context.client.invalidateQueries({
-        queryKey: underlyingAllowanceQueryKeys.all
-      });
-      context.client.invalidateQueries({
-        predicate: wagmiBalancePredicates.balanceOf
-      });
       options?.onSuccess?.(data, variables, onMutateResult, context);
+      invalidateAfterUnshield(context.client, config.tokenAddress);
     }
   });
 }
-function resumeUnshieldMutationOptions(token) {
-  return {
-    mutationKey: ["resumeUnshield", token.address],
-    mutationFn: ({ unwrapTxHash, callbacks }) => token.resumeUnshield(unwrapTxHash, callbacks)
-  };
-}
 function useResumeUnshield(config, options) {
   const token = useToken(config);
   return useMutation({
-    mutationKey: ["resumeUnshield", config.tokenAddress],
-    mutationFn: ({ unwrapTxHash, callbacks }) => token.resumeUnshield(unwrapTxHash, callbacks),
+    ...resumeUnshieldMutationOptions(token),
     ...options,
     onSuccess: (data, variables, onMutateResult, context) => {
-      context.client.invalidateQueries({
-        queryKey: confidentialHandleQueryKeys.token(config.tokenAddress)
-      });
-      context.client.invalidateQueries({
-        queryKey: confidentialHandlesQueryKeys.all
-      });
-      context.client.resetQueries({
-        queryKey: confidentialBalanceQueryKeys.token(config.tokenAddress)
-      });
-      context.client.invalidateQueries({
-        queryKey: confidentialBalancesQueryKeys.all
-      });
-      context.client.invalidateQueries({
-        queryKey: underlyingAllowanceQueryKeys.all
-      });
-      context.client.invalidateQueries({
-        predicate: wagmiBalancePredicates.balanceOf
-      });
       options?.onSuccess?.(data, variables, onMutateResult, context);
+      invalidateAfterUnshield(context.client, config.tokenAddress);
     }
   });
 }
-var wrapperDiscoveryQueryKeys = {
-  /** Match all wrapper discovery queries. */
-  all: ["wrapperDiscovery"],
-  /** Match wrapper discovery queries for a specific token. */
-  token: (tokenAddress) => ["wrapperDiscovery", tokenAddress],
-  /** Match wrapper discovery query for a specific token + coordinator pair. */
-  tokenCoordinator: (tokenAddress, coordinatorAddress) => ["wrapperDiscovery", tokenAddress, coordinatorAddress]
-};
-function wrapperDiscoveryQueryOptions(token, coordinatorAddress) {
-  return {
-    queryKey: wrapperDiscoveryQueryKeys.tokenCoordinator(token.address, coordinatorAddress),
-    queryFn: () => token.discoverWrapper(coordinatorAddress),
-    staleTime: Infinity
-  };
+function useUnderlyingAllowance(config, options) {
+  const { tokenAddress, wrapperAddress } = config;
+  const userEnabled = options?.enabled;
+  const token = useReadonlyToken(tokenAddress);
+  const addressQuery = useQuery4({
+    ...signerAddressQueryOptions(token.signer)
+  });
+  const owner = addressQuery.data;
+  const baseOpts = underlyingAllowanceQueryOptions(token.signer, tokenAddress, {
+    owner,
+    wrapperAddress
+  });
+  const factoryEnabled = baseOpts.enabled ?? true;
+  return useQuery4({
+    ...baseOpts,
+    ...options,
+    enabled: factoryEnabled && (userEnabled ?? true)
+  });
+}
+function useUnderlyingAllowanceSuspense(config) {
+  const { tokenAddress, wrapperAddress } = config;
+  const token = useReadonlyToken(tokenAddress);
+  const addressQuery = useSuspenseQuery({
+    ...signerAddressQueryOptions(token.signer)
+  });
+  const owner = addressQuery.data;
+  return useSuspenseQuery({
+    ...underlyingAllowanceQueryOptions(token.signer, tokenAddress, {
+      owner,
+      wrapperAddress
+    })
+  });
 }
 function useWrapperDiscovery(config, options) {
   const { tokenAddress, coordinatorAddress } = config;
   const token = useReadonlyToken(tokenAddress);
-  return useQuery({
-    ...coordinatorAddress ? wrapperDiscoveryQueryOptions(token, coordinatorAddress) : {
-      queryKey: wrapperDiscoveryQueryKeys.tokenCoordinator(tokenAddress, ""),
+  return useQuery4({
+    ...coordinatorAddress ? wrapperDiscoveryQueryOptions(token.signer, tokenAddress, { coordinatorAddress }) : {
+      queryKey: zamaQueryKeys.wrapperDiscovery.all,
       queryFn: skipToken
     },
     ...options
@@ -908,236 +667,116 @@ function useWrapperDiscovery(config, options) {
 function useWrapperDiscoverySuspense(config) {
   const { tokenAddress, coordinatorAddress } = config;
   const token = useReadonlyToken(tokenAddress);
-  return useSuspenseQuery(
-    wrapperDiscoveryQueryOptions(token, coordinatorAddress)
-  );
-}
-var metadataQueryKeys = {
-  /** Match all token metadata queries. */
-  all: ["tokenMetadata"],
-  /** Match metadata query for a specific token. */
-  token: (tokenAddress) => ["tokenMetadata", tokenAddress]
-};
-function metadataQueryOptions(token) {
-  return {
-    queryKey: metadataQueryKeys.token(token.address),
-    queryFn: async () => {
-      const [name, symbol, decimals] = await Promise.all([
-        token.name(),
-        token.symbol(),
-        token.decimals()
-      ]);
-      return { name, symbol, decimals };
-    },
-    staleTime: Infinity
-  };
+  return useSuspenseQuery({
+    ...wrapperDiscoveryQueryOptions(token.signer, tokenAddress, { coordinatorAddress })
+  });
 }
 function useMetadata(tokenAddress, options) {
   const token = useReadonlyToken(tokenAddress);
-  return useQuery({
-    ...metadataQueryOptions(token),
+  return useQuery4({
+    ...tokenMetadataQueryOptions(token.signer, tokenAddress),
     ...options
   });
 }
 function useMetadataSuspense(tokenAddress) {
   const token = useReadonlyToken(tokenAddress);
-  return useSuspenseQuery(metadataQueryOptions(token));
+  return useSuspenseQuery({
+    ...tokenMetadataQueryOptions(token.signer, tokenAddress)
+  });
 }
-var activityFeedQueryKeys = {
-  /** Match all activity feed queries. */
-  all: ["activityFeed"],
-  /** Match activity feed queries for a specific token. */
-  token: (tokenAddress) => ["activityFeed", tokenAddress]
-};
 function useActivityFeed(config) {
   const { tokenAddress, userAddress, logs, decrypt: decryptOpt } = config;
   const token = useReadonlyToken(tokenAddress);
   const decrypt = decryptOpt ?? true;
-  const enabled = logs !== void 0 && userAddress !== void 0;
-  return useQuery({
-    queryKey: [
-      ...activityFeedQueryKeys.token(tokenAddress),
-      userAddress ?? "",
-      logs?.map((l) => `${l.transactionHash ?? ""}:${l.logIndex ?? ""}`).join(",") ?? ""
-    ],
-    queryFn: async () => {
-      if (!logs || !userAddress) return [];
-      const items = sortByBlockNumber(parseActivityFeed(logs, userAddress));
-      if (!decrypt) return items;
-      const handles = extractEncryptedHandles(items);
-      if (handles.length === 0) return items;
-      const decryptedMap = await token.decryptHandles(handles, userAddress);
-      return applyDecryptedValues(items, decryptedMap);
-    },
-    enabled,
-    staleTime: Infinity
+  const logsKey = logs?.map((log) => `${log.transactionHash ?? ""}:${log.logIndex ?? ""}`).join(",") ?? "";
+  return useQuery4({
+    ...activityFeedQueryOptions(token, {
+      userAddress,
+      logs,
+      decrypt,
+      logsKey
+    })
   });
 }
-function approveUnderlyingMutationOptions(token) {
-  return {
-    mutationKey: ["approveUnderlying", token.address],
-    mutationFn: ({ amount }) => token.approveUnderlying(amount)
-  };
-}
 function useApproveUnderlying(config, options) {
   const token = useToken(config);
   return useMutation({
-    mutationKey: ["approveUnderlying", config.tokenAddress],
-    mutationFn: ({ amount }) => token.approveUnderlying(amount),
+    ...approveUnderlyingMutationOptions(token),
     ...options,
     onSuccess: (data, variables, onMutateResult, context) => {
-      context.client.invalidateQueries({
-        queryKey: underlyingAllowanceQueryKeys.all
-      });
       options?.onSuccess?.(data, variables, onMutateResult, context);
+      invalidateAfterApproveUnderlying(context.client, config.tokenAddress);
     }
   });
 }
-var isConfidentialQueryKeys = {
-  /** Match all confidential interface queries. */
-  all: ["isConfidential"],
-  /** Match confidential interface query for a specific token. */
-  token: (tokenAddress) => ["isConfidential", tokenAddress]
-};
-var isWrapperQueryKeys = {
-  /** Match all wrapper interface queries. */
-  all: ["isWrapper"],
-  /** Match wrapper interface query for a specific token. */
-  token: (tokenAddress) => ["isWrapper", tokenAddress]
-};
-function isConfidentialQueryOptions(token) {
-  return {
-    queryKey: isConfidentialQueryKeys.token(token.address),
-    queryFn: () => token.isConfidential(),
-    staleTime: Infinity
-  };
-}
-function isWrapperQueryOptions(token) {
-  return {
-    queryKey: isWrapperQueryKeys.token(token.address),
-    queryFn: () => token.isWrapper(),
-    staleTime: Infinity
-  };
-}
 function useIsConfidential(tokenAddress, options) {
   const token = useReadonlyToken(tokenAddress);
-  return useQuery({
-    ...isConfidentialQueryOptions(token),
+  return useQuery4({
+    ...isConfidentialQueryOptions(token.signer, tokenAddress),
     ...options
   });
 }
 function useIsConfidentialSuspense(tokenAddress) {
   const token = useReadonlyToken(tokenAddress);
-  return useSuspenseQuery(isConfidentialQueryOptions(token));
+  return useSuspenseQuery({
+    ...isConfidentialQueryOptions(token.signer, tokenAddress)
+  });
 }
 function useIsWrapper(tokenAddress, options) {
   const token = useReadonlyToken(tokenAddress);
-  return useQuery({
-    ...isWrapperQueryOptions(token),
+  return useQuery4({
+    ...isWrapperQueryOptions(token.signer, tokenAddress),
     ...options
   });
 }
 function useIsWrapperSuspense(tokenAddress) {
   const token = useReadonlyToken(tokenAddress);
-  return useSuspenseQuery(isWrapperQueryOptions(token));
-}
-var totalSupplyQueryKeys = {
-  /** Match all total supply queries. */
-  all: ["totalSupply"],
-  /** Match total supply query for a specific token. */
-  token: (tokenAddress) => ["totalSupply", tokenAddress]
-};
-function totalSupplyQueryOptions(token) {
-  return {
-    queryKey: totalSupplyQueryKeys.token(token.address),
-    queryFn: () => token.signer.readContract(totalSupplyContract(token.address)),
-    staleTime: 3e4
-  };
+  return useSuspenseQuery({
+    ...isWrapperQueryOptions(token.signer, tokenAddress)
+  });
 }
 function useTotalSupply(tokenAddress, options) {
   const token = useReadonlyToken(tokenAddress);
-  return useQuery({
-    ...totalSupplyQueryOptions(token),
+  return useQuery4({
+    ...totalSupplyQueryOptions(token.signer, tokenAddress),
     ...options
   });
 }
 function useTotalSupplySuspense(tokenAddress) {
   const token = useReadonlyToken(tokenAddress);
-  return useSuspenseQuery(totalSupplyQueryOptions(token));
-}
-var feeQueryKeys = {
-  /** Match shield fee query for given parameters. */
-  shieldFee: (feeManagerAddress, amount, from, to) => ["shieldFee", feeManagerAddress, ...amount !== void 0 ? [amount, from, to] : []],
-  /** Match unshield fee query for given parameters. */
-  unshieldFee: (feeManagerAddress, amount, from, to) => [
-    "unshieldFee",
-    feeManagerAddress,
-    ...amount !== void 0 ? [amount, from, to] : []
-  ],
-  /** Match batch transfer fee query for a specific fee manager. */
-  batchTransferFee: (feeManagerAddress) => ["batchTransferFee", feeManagerAddress],
-  /** Match fee recipient query for a specific fee manager. */
-  feeRecipient: (feeManagerAddress) => ["feeRecipient", feeManagerAddress]
-};
-function shieldFeeQueryOptions(signer, config) {
-  const { feeManagerAddress, amount, from, to } = config;
-  return {
-    queryKey: feeQueryKeys.shieldFee(feeManagerAddress, amount.toString(), from, to),
-    queryFn: () => signer.readContract(getWrapFeeContract(feeManagerAddress, amount, from, to)),
-    staleTime: 3e4
-  };
-}
-function unshieldFeeQueryOptions(signer, config) {
-  const { feeManagerAddress, amount, from, to } = config;
-  return {
-    queryKey: feeQueryKeys.unshieldFee(feeManagerAddress, amount.toString(), from, to),
-    queryFn: () => signer.readContract(getUnwrapFeeContract(feeManagerAddress, amount, from, to)),
-    staleTime: 3e4
-  };
-}
-function batchTransferFeeQueryOptions(signer, feeManagerAddress) {
-  return {
-    queryKey: feeQueryKeys.batchTransferFee(feeManagerAddress),
-    queryFn: () => signer.readContract(getBatchTransferFeeContract(feeManagerAddress)),
-    staleTime: 3e4
-  };
-}
-function feeRecipientQueryOptions(signer, feeManagerAddress) {
-  return {
-    queryKey: feeQueryKeys.feeRecipient(feeManagerAddress),
-    queryFn: () => signer.readContract(getFeeRecipientContract(feeManagerAddress)),
-    staleTime: 3e4
-  };
+  return useSuspenseQuery({
+    ...totalSupplyQueryOptions(token.signer, tokenAddress)
+  });
 }
 function useShieldFee(config, options) {
   const sdk = useZamaSDK();
-  return useQuery({
+  return useQuery4({
     ...shieldFeeQueryOptions(sdk.signer, config),
     ...options
   });
 }
 function useUnshieldFee(config, options) {
   const sdk = useZamaSDK();
-  return useQuery({
+  return useQuery4({
     ...unshieldFeeQueryOptions(sdk.signer, config),
     ...options
   });
 }
 function useBatchTransferFee(feeManagerAddress, options) {
   const sdk = useZamaSDK();
-  return useQuery({
+  return useQuery4({
     ...batchTransferFeeQueryOptions(sdk.signer, feeManagerAddress),
     ...options
   });
 }
 function useFeeRecipient(feeManagerAddress, options) {
   const sdk = useZamaSDK();
-  return useQuery({
+  return useQuery4({
     ...feeRecipientQueryOptions(sdk.signer, feeManagerAddress),
     ...options
   });
 }
 
-export { ZamaProvider, activityFeedQueryKeys, allowMutationOptions, approveUnderlyingMutationOptions, batchTransferFeeQueryOptions, confidentialApproveMutationOptions, confidentialBalanceQueryKeys, confidentialBalancesQueryKeys, confidentialHandleQueryKeys, confidentialHandlesQueryKeys, confidentialIsApprovedQueryKeys, confidentialIsApprovedQueryOptions, confidentialTransferFromMutationOptions, confidentialTransferMutationOptions, decryptionKeys, encryptMutationOptions, feeQueryKeys, feeRecipientQueryOptions, finalizeUnwrapMutationOptions, isAllowedQueryKeys, isAllowedQueryOptions, isConfidentialQueryKeys, isConfidentialQueryOptions, isWrapperQueryKeys, isWrapperQueryOptions, metadataQueryKeys, metadataQueryOptions, publicKeyQueryKeys, publicKeyQueryOptions, publicParamsQueryKeys, publicParamsQueryOptions, resumeUnshieldMutationOptions, revokeMutationOptions, revokeSessionMutationOptions, shieldETHMutationOptions, shieldFeeQueryOptions, shieldMutationOptions, totalSupplyQueryKeys, totalSupplyQueryOptions, underlyingAllowanceQueryKeys, underlyingAllowanceQueryOptions, unshieldAllMutationOptions, unshieldFeeQueryOptions, unshieldMutationOptions, unwrapAllMutationOptions, unwrapMutationOptions, useActivityFeed, useAllow, useApproveUnderlying, useBatchTransferFee, useConfidentialApprove, useConfidentialBalance, useConfidentialBalances, useConfidentialIsApproved, useConfidentialIsApprovedSuspense, useConfidentialTransfer, useConfidentialTransferFrom, useCreateDelegatedUserDecryptEIP712, useCreateEIP712, useDelegatedUserDecrypt, useEncrypt, useFeeRecipient, useFinalizeUnwrap, useGenerateKeypair, useIsAllowed, useIsConfidential, useIsConfidentialSuspense, useIsWrapper, useIsWrapperSuspense, useMetadata, useMetadataSuspense, usePublicDecrypt, usePublicKey, usePublicParams, useReadonlyToken, useRequestZKProofVerification, useResumeUnshield, useRevoke, useRevokeSession, useShield, useShieldETH, useShieldFee, useToken, useTotalSupply, useTotalSupplySuspense, useUnderlyingAllowance, useUnderlyingAllowanceSuspense, useUnshield, useUnshieldAll, useUnshieldFee, useUnwrap, useUnwrapAll, useUserDecrypt, useUserDecryptFlow, useUserDecryptedValue, useUserDecryptedValues, useWrapperDiscovery, useWrapperDiscoverySuspense, useZamaSDK, wrapperDiscoveryQueryKeys, wrapperDiscoveryQueryOptions };
+export { ZamaProvider, decryptionKeys, useActivityFeed, useAllow, useApproveUnderlying, useBatchTransferFee, useConfidentialApprove, useConfidentialBalance, useConfidentialBalances, useConfidentialIsApproved, useConfidentialIsApprovedSuspense, useConfidentialTransfer, useConfidentialTransferFrom, useCreateDelegatedUserDecryptEIP712, useCreateEIP712, useDelegatedUserDecrypt, useEncrypt, useFeeRecipient, useFinalizeUnwrap, useGenerateKeypair, useIsAllowed, useIsConfidential, useIsConfidentialSuspense, useIsWrapper, useIsWrapperSuspense, useMetadata, useMetadataSuspense, usePublicDecrypt, usePublicKey, usePublicParams, useReadonlyToken, useRequestZKProofVerification, useResumeUnshield, useRevoke, useRevokeSession, useShield, useShieldETH, useShieldFee, useToken, useTotalSupply, useTotalSupplySuspense, useUnderlyingAllowance, useUnderlyingAllowanceSuspense, useUnshield, useUnshieldAll, useUnshieldFee, useUnwrap, useUnwrapAll, useUserDecrypt, useUserDecryptFlow, useUserDecryptedValue, useUserDecryptedValues, useWrapperDiscovery, useWrapperDiscoverySuspense, useZamaSDK };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map