@zama-fhe/react-sdk 1.0.0-alpha.2

package/dist/chunk-463DUSLG.js

@@ -0,0 +1,1005 @@
+"use client";
+import { ZamaSDK, ReadonlyToken, sortByBlockNumber, parseActivityFeed, extractEncryptedHandles, applyDecryptedValues, totalSupplyContract, getWrapFeeContract, getUnwrapFeeContract, getBatchTransferFeeContract, getFeeRecipientContract } from '@zama-fhe/sdk';
+export { ApprovalFailedError, BATCH_SWAP_ABI, CredentialExpiredError, 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, InvalidCredentialsError, 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, 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 { createContext, useMemo, useEffect, 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);
+function ZamaProvider({
+  children,
+  relayer,
+  signer,
+  storage,
+  credentialDurationDays,
+  onEvent
+}) {
+  const sdk = useMemo(
+    () => new ZamaSDK({
+      relayer,
+      signer,
+      storage,
+      credentialDurationDays,
+      onEvent
+    }),
+    [relayer, signer, storage, credentialDurationDays, onEvent]
+  );
+  useEffect(() => {
+    return () => sdk.terminate();
+  }, [sdk]);
+  return /* @__PURE__ */ jsx(ZamaSDKContext.Provider, { value: sdk, children });
+}
+function useZamaSDK() {
+  const context = useContext(ZamaSDKContext);
+  if (!context) {
+    throw new Error("useZamaSDK must be used within a ZamaProvider");
+  }
+  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]
+};
+
+// src/relayer/use-user-decrypt.ts
+function useUserDecrypt() {
+  const sdk = useZamaSDK();
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: (params) => sdk.relayer.userDecrypt(params),
+    onSuccess: (data) => {
+      for (const [handle, value] of Object.entries(data)) {
+        queryClient.setQueryData(decryptionKeys.value(handle), value);
+      }
+    }
+  });
+}
+function usePublicDecrypt() {
+  const sdk = useZamaSDK();
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: (handles) => sdk.relayer.publicDecrypt(handles),
+    onSuccess: (data) => {
+      for (const [handle, value] of Object.entries(data.clearValues)) {
+        queryClient.setQueryData(decryptionKeys.value(handle), value);
+      }
+    }
+  });
+}
+function useGenerateKeypair() {
+  const sdk = useZamaSDK();
+  return useMutation({
+    mutationFn: () => sdk.relayer.generateKeypair()
+  });
+}
+function useCreateEIP712() {
+  const sdk = useZamaSDK();
+  return useMutation({
+    mutationFn: ({ publicKey, contractAddresses, startTimestamp, durationDays }) => sdk.relayer.createEIP712(publicKey, contractAddresses, startTimestamp, durationDays)
+  });
+}
+function useCreateDelegatedUserDecryptEIP712() {
+  const sdk = useZamaSDK();
+  return useMutation({
+    mutationFn: ({
+      publicKey,
+      contractAddresses,
+      delegatorAddress,
+      startTimestamp,
+      durationDays
+    }) => sdk.relayer.createDelegatedUserDecryptEIP712(
+      publicKey,
+      contractAddresses,
+      delegatorAddress,
+      startTimestamp,
+      durationDays
+    )
+  });
+}
+function useDelegatedUserDecrypt() {
+  const sdk = useZamaSDK();
+  return useMutation({
+    mutationFn: (params) => sdk.relayer.delegatedUserDecrypt(params)
+  });
+}
+function useRequestZKProofVerification() {
+  const sdk = useZamaSDK();
+  return useMutation({
+    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
+  };
+}
+function usePublicParams(bits) {
+  const sdk = useZamaSDK();
+  return useQuery(publicParamsQueryOptions(sdk, bits));
+}
+function useUserDecryptedValue(handle) {
+  return useQuery({
+    queryKey: decryptionKeys.value(handle ?? ""),
+    queryFn: () => void 0,
+    enabled: false
+  });
+}
+function useUserDecryptedValues(handles) {
+  const results = useQueries({
+    queries: handles.map((handle) => ({
+      queryKey: decryptionKeys.value(handle),
+      queryFn: () => void 0,
+      enabled: false
+    }))
+  });
+  const data = {};
+  for (let i = 0; i < handles.length; i++) {
+    data[handles[i]] = results[i].data;
+  }
+  return {
+    data,
+    results
+  };
+}
+function useToken(config) {
+  const sdk = useZamaSDK();
+  return useMemo(
+    () => sdk.createToken(config.tokenAddress, config.wrapperAddress),
+    [sdk, config.tokenAddress, config.wrapperAddress]
+  );
+}
+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 useConfidentialBalance(config, options) {
+  const { tokenAddress, handleRefetchInterval } = config;
+  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 handle = handleQuery.data;
+  const balanceQuery = useQuery({
+    queryKey: [...confidentialBalanceQueryKeys.owner(tokenAddress, ownerKey), handle ?? ""],
+    queryFn: () => token.decryptBalance(handle),
+    enabled: !!signerAddress && !!handle,
+    staleTime: Infinity,
+    ...options
+  });
+  return { ...balanceQuery, handleQuery };
+}
+var DEFAULT_HANDLE_REFETCH_INTERVAL2 = 1e4;
+function useConfidentialBalances(config, options) {
+  const { tokenAddresses, handleRefetchInterval, maxConcurrency } = config;
+  const sdk = useZamaSDK();
+  const addressQuery = useQuery({
+    queryKey: ["zama", "signer-address"],
+    queryFn: () => sdk.signer.getAddress()
+  });
+  const signerAddress = addressQuery.data;
+  const ownerKey = signerAddress ?? "";
+  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 handles = handlesQuery.data;
+  const handlesKey = handles?.join(",") ?? "";
+  const balancesQuery = useQuery({
+    queryKey: [...confidentialBalancesQueryKeys.tokens(tokenAddresses, ownerKey), handlesKey],
+    queryFn: async () => {
+      const raw = await ReadonlyToken.batchDecryptBalances(tokens, {
+        handles,
+        maxConcurrency
+      });
+      const remapped = /* @__PURE__ */ new Map();
+      for (let i = 0; i < tokens.length; i++) {
+        const balance = raw.get(tokens[i].address);
+        if (balance !== void 0) remapped.set(tokenAddresses[i], balance);
+      }
+      return remapped;
+    },
+    enabled: tokenAddresses.length > 0 && !!signerAddress && !!handles,
+    staleTime: Infinity,
+    ...options
+  });
+  return { ...balancesQuery, handlesQuery };
+}
+function authorizeAllMutationOptions(sdk) {
+  return {
+    mutationKey: ["authorizeAll"],
+    mutationFn: async (tokenAddresses) => {
+      const tokens = tokenAddresses.map((addr) => sdk.createReadonlyToken(addr));
+      return ReadonlyToken.authorizeAll(tokens);
+    }
+  };
+}
+function useAuthorizeAll() {
+  const sdk = useZamaSDK();
+  return useMutation(authorizeAllMutationOptions(sdk));
+}
+function confidentialTransferMutationOptions(token) {
+  return {
+    mutationKey: ["confidentialTransfer", token.address],
+    mutationFn: ({ to, amount }) => token.confidentialTransfer(to, amount)
+  };
+}
+function useConfidentialTransfer(config, options) {
+  const token = useToken(config);
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationKey: ["confidentialTransfer", config.tokenAddress],
+    mutationFn: ({ to, amount }) => token.confidentialTransfer(to, amount),
+    ...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;
+    } : options?.onMutate,
+    onError: (error, variables, onMutateResult, context) => {
+      if (config.optimistic) {
+        queryClient.invalidateQueries({
+          queryKey: confidentialBalanceQueryKeys.token(config.tokenAddress)
+        });
+      }
+      options?.onError?.(error, variables, onMutateResult, 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
+      });
+      options?.onSuccess?.(data, variables, onMutateResult, context);
+    }
+  });
+}
+function confidentialTransferFromMutationOptions(token) {
+  return {
+    mutationKey: ["confidentialTransferFrom", token.address],
+    mutationFn: ({ from, to, amount }) => token.confidentialTransferFrom(from, to, amount)
+  };
+}
+function useConfidentialTransferFrom(config, options) {
+  const token = useToken(config);
+  return useMutation({
+    mutationKey: ["confidentialTransferFrom", config.tokenAddress],
+    mutationFn: ({ from, to, amount }) => token.confidentialTransferFrom(from, to, amount),
+    ...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);
+    }
+  });
+}
+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) => ["confidentialIsApproved", tokenAddress, spender]
+};
+function confidentialIsApprovedQueryOptions(token, spender) {
+  return {
+    queryKey: confidentialIsApprovedQueryKeys.spender(token.address, spender),
+    queryFn: () => token.isApproved(spender),
+    staleTime: 3e4
+  };
+}
+function useConfidentialIsApproved(config, options) {
+  const { spender, ...tokenConfig } = config;
+  const token = useToken(tokenConfig);
+  return useQuery({
+    ...spender ? confidentialIsApprovedQueryOptions(token, spender) : {
+      queryKey: confidentialIsApprovedQueryKeys.spender(config.tokenAddress, ""),
+      queryFn: skipToken
+    },
+    ...options
+  });
+}
+function useConfidentialIsApprovedSuspense(config) {
+  const { spender, ...tokenConfig } = config;
+  const token = useToken(tokenConfig);
+  return useSuspenseQuery(confidentialIsApprovedQueryOptions(token, spender));
+}
+
+// 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);
+    }
+  });
+}
+function shieldMutationOptions(token) {
+  return {
+    mutationKey: ["shield", token.address],
+    mutationFn: async ({ amount, fees, approvalStrategy }) => token.shield(amount, { fees, approvalStrategy })
+  };
+}
+function useShield(config, options) {
+  const token = useToken(config);
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationKey: ["shield", config.tokenAddress],
+    mutationFn: async ({ amount, fees, approvalStrategy }) => token.shield(amount, { fees, approvalStrategy }),
+    ...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;
+    } : options?.onMutate,
+    onError: (error, variables, onMutateResult, context) => {
+      if (config.optimistic) {
+        queryClient.invalidateQueries({
+          queryKey: confidentialBalanceQueryKeys.token(config.tokenAddress)
+        });
+      }
+      options?.onError?.(error, variables, onMutateResult, 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);
+    }
+  });
+}
+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),
+    ...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);
+    }
+  });
+}
+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),
+    ...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);
+    }
+  });
+}
+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(),
+    ...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);
+    }
+  });
+}
+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),
+    ...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);
+    }
+  });
+}
+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),
+    ...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);
+    }
+  });
+}
+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),
+    ...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);
+    }
+  });
+}
+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),
+    ...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);
+    }
+  });
+}
+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 useWrapperDiscovery(config, options) {
+  const { tokenAddress, coordinatorAddress } = config;
+  const token = useReadonlyToken(tokenAddress);
+  return useQuery({
+    ...coordinatorAddress ? wrapperDiscoveryQueryOptions(token, coordinatorAddress) : {
+      queryKey: wrapperDiscoveryQueryKeys.tokenCoordinator(tokenAddress, ""),
+      queryFn: skipToken
+    },
+    ...options
+  });
+}
+function useWrapperDiscoverySuspense(config) {
+  const { tokenAddress, coordinatorAddress } = config;
+  const token = useReadonlyToken(tokenAddress);
+  return useSuspenseQuery(
+    wrapperDiscoveryQueryOptions(token, coordinatorAddress)
+  );
+}
+var tokenMetadataQueryKeys = {
+  /** Match all token metadata queries. */
+  all: ["tokenMetadata"],
+  /** Match metadata query for a specific token. */
+  token: (tokenAddress) => ["tokenMetadata", tokenAddress]
+};
+function tokenMetadataQueryOptions(token) {
+  return {
+    queryKey: tokenMetadataQueryKeys.token(token.address),
+    queryFn: async () => {
+      const [name, symbol, decimals] = await Promise.all([
+        token.name(),
+        token.symbol(),
+        token.decimals()
+      ]);
+      return { name, symbol, decimals };
+    },
+    staleTime: Infinity
+  };
+}
+function useTokenMetadata(tokenAddress, options) {
+  const token = useReadonlyToken(tokenAddress);
+  return useQuery({
+    ...tokenMetadataQueryOptions(token),
+    ...options
+  });
+}
+function useTokenMetadataSuspense(tokenAddress) {
+  const token = useReadonlyToken(tokenAddress);
+  return useSuspenseQuery(tokenMetadataQueryOptions(token));
+}
+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
+  });
+}
+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),
+    ...options,
+    onSuccess: (data, variables, onMutateResult, context) => {
+      context.client.invalidateQueries({
+        queryKey: underlyingAllowanceQueryKeys.all
+      });
+      options?.onSuccess?.(data, variables, onMutateResult, context);
+    }
+  });
+}
+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),
+    ...options
+  });
+}
+function useIsConfidentialSuspense(tokenAddress) {
+  const token = useReadonlyToken(tokenAddress);
+  return useSuspenseQuery(isConfidentialQueryOptions(token));
+}
+function useIsWrapper(tokenAddress, options) {
+  const token = useReadonlyToken(tokenAddress);
+  return useQuery({
+    ...isWrapperQueryOptions(token),
+    ...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
+  };
+}
+function useTotalSupply(tokenAddress, options) {
+  const token = useReadonlyToken(tokenAddress);
+  return useQuery({
+    ...totalSupplyQueryOptions(token),
+    ...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
+  };
+}
+function useShieldFee(config, options) {
+  const sdk = useZamaSDK();
+  return useQuery({
+    ...shieldFeeQueryOptions(sdk.signer, config),
+    ...options
+  });
+}
+function useUnshieldFee(config, options) {
+  const sdk = useZamaSDK();
+  return useQuery({
+    ...unshieldFeeQueryOptions(sdk.signer, config),
+    ...options
+  });
+}
+function useBatchTransferFee(feeManagerAddress, options) {
+  const sdk = useZamaSDK();
+  return useQuery({
+    ...batchTransferFeeQueryOptions(sdk.signer, feeManagerAddress),
+    ...options
+  });
+}
+function useFeeRecipient(feeManagerAddress, options) {
+  const sdk = useZamaSDK();
+  return useQuery({
+    ...feeRecipientQueryOptions(sdk.signer, feeManagerAddress),
+    ...options
+  });
+}
+
+export { ZamaProvider, activityFeedQueryKeys, approveUnderlyingMutationOptions, authorizeAllMutationOptions, batchTransferFeeQueryOptions, confidentialApproveMutationOptions, confidentialBalanceQueryKeys, confidentialBalancesQueryKeys, confidentialHandleQueryKeys, confidentialHandlesQueryKeys, confidentialIsApprovedQueryKeys, confidentialIsApprovedQueryOptions, confidentialTransferFromMutationOptions, confidentialTransferMutationOptions, decryptionKeys, encryptMutationOptions, feeQueryKeys, feeRecipientQueryOptions, finalizeUnwrapMutationOptions, isConfidentialQueryKeys, isConfidentialQueryOptions, isWrapperQueryKeys, isWrapperQueryOptions, publicKeyQueryKeys, publicKeyQueryOptions, publicParamsQueryKeys, publicParamsQueryOptions, resumeUnshieldMutationOptions, shieldETHMutationOptions, shieldFeeQueryOptions, shieldMutationOptions, tokenMetadataQueryKeys, tokenMetadataQueryOptions, totalSupplyQueryKeys, totalSupplyQueryOptions, underlyingAllowanceQueryKeys, underlyingAllowanceQueryOptions, unshieldAllMutationOptions, unshieldFeeQueryOptions, unshieldMutationOptions, unwrapAllMutationOptions, unwrapMutationOptions, useActivityFeed, useApproveUnderlying, useAuthorizeAll, useBatchTransferFee, useConfidentialApprove, useConfidentialBalance, useConfidentialBalances, useConfidentialIsApproved, useConfidentialIsApprovedSuspense, useConfidentialTransfer, useConfidentialTransferFrom, useCreateDelegatedUserDecryptEIP712, useCreateEIP712, useDelegatedUserDecrypt, useEncrypt, useFeeRecipient, useFinalizeUnwrap, useGenerateKeypair, useIsConfidential, useIsConfidentialSuspense, useIsWrapper, useIsWrapperSuspense, usePublicDecrypt, usePublicKey, usePublicParams, useReadonlyToken, useRequestZKProofVerification, useResumeUnshield, useShield, useShieldETH, useShieldFee, useToken, useTokenMetadata, useTokenMetadataSuspense, useTotalSupply, useTotalSupplySuspense, useUnderlyingAllowance, useUnderlyingAllowanceSuspense, useUnshield, useUnshieldAll, useUnshieldFee, useUnwrap, useUnwrapAll, useUserDecrypt, useUserDecryptedValue, useUserDecryptedValues, useWrapperDiscovery, useWrapperDiscoverySuspense, useZamaSDK, wrapperDiscoveryQueryKeys, wrapperDiscoveryQueryOptions };
+//# sourceMappingURL=chunk-463DUSLG.js.map
+//# sourceMappingURL=chunk-463DUSLG.js.map