@zama-fhe/react-sdk 1.0.0

package/dist/index.js

@@ -0,0 +1,978 @@
+"use client";
+import { TokenSDK, ReadonlyToken, sortByBlockNumber, parseActivityFeed, extractEncryptedHandles, applyDecryptedValues, totalSupplyContract, getWrapFeeContract, getUnwrapFeeContract, getBatchTransferFeeContract, getFeeRecipientContract } from '@zama-fhe/sdk';
+export { BATCH_SWAP_ABI, CredentialsManager, DEPLOYMENT_COORDINATOR_ABI, ENCRYPTION_ABI, ERC165_ABI, ERC20_ABI, ERC20_METADATA_ABI, ERC7984_INTERFACE_ID, ERC7984_WRAPPER_INTERFACE_ID, FEE_MANAGER_ABI, HardhatConfig, IndexedDBStorage, InvalidCredentialsError, MainnetConfig, MemoryStorage, NoCiphertextError, ReadonlyToken, RelayerRequestFailedError, RelayerWeb, SepoliaConfig, TOKEN_TOPICS, TRANSFER_BATCHER_ABI, Token, TokenError, TokenErrorCode, TokenSDK, Topics, WRAPPER_ABI, ZERO_HANDLE, allowanceContract, applyDecryptedValues, approveContract, balanceOfContract, confidentialBalanceOfContract, confidentialBatchTransferContract, confidentialTotalSupplyContract, confidentialTransferContract, confidentialTransferFromContract, decimalsContract, decodeConfidentialTransfer, decodeTokenEvent, decodeTokenEvents, decodeUnwrapRequested, decodeUnwrappedFinalized, decodeUnwrappedStarted, decodeWrapped, deploymentCoordinatorContract, extractEncryptedHandles, finalizeUnwrapContract, findUnwrapRequested, findWrapped, getBatchTransferFeeContract, getFeeRecipientContract, getUnwrapFeeContract, getWrapFeeContract, getWrapperContract, indexedDBStorage, isFinalizeUnwrapOperatorContract, isOperatorContract, nameContract, parseActivityFeed, rateContract, setFinalizeUnwrapOperatorContract, setOperatorContract, sortByBlockNumber, supportsInterfaceContract, symbolContract, totalSupplyContract, underlyingContract, unwrapContract, unwrapFromBalanceContract, wrapContract, wrapETHContract, wrapperExistsContract } from '@zama-fhe/sdk';
+import { createContext, useMemo, useEffect, useContext, useState } from 'react';
+import { jsx } from 'react/jsx-runtime';
+import { useMutation, useQueryClient, useQuery, useQueries, skipToken, useSuspenseQuery } from '@tanstack/react-query';
+
+// src/provider.tsx
+var TokenSDKContext = createContext(null);
+function TokenSDKProvider({ children, relayer, signer, storage }) {
+  const sdk = useMemo(
+    () => new TokenSDK({
+      relayer,
+      signer,
+      storage
+    }),
+    [relayer, signer, storage]
+  );
+  useEffect(() => {
+    return () => sdk.terminate();
+  }, [sdk]);
+  return /* @__PURE__ */ jsx(TokenSDKContext.Provider, { value: sdk, children });
+}
+function useTokenSDK() {
+  const context = useContext(TokenSDKContext);
+  if (!context) {
+    throw new Error("useTokenSDK must be used within a TokenSDKProvider");
+  }
+  return context;
+}
+function encryptMutationOptions(sdk) {
+  return {
+    mutationKey: ["encrypt"],
+    mutationFn: (params) => sdk.relayer.encrypt(params)
+  };
+}
+function useEncrypt() {
+  const sdk = useTokenSDK();
+  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 = useTokenSDK();
+  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 = useTokenSDK();
+  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 = useTokenSDK();
+  return useMutation({
+    mutationFn: () => sdk.relayer.generateKeypair()
+  });
+}
+function useCreateEIP712() {
+  const sdk = useTokenSDK();
+  return useMutation({
+    mutationFn: ({ publicKey, contractAddresses, startTimestamp, durationDays }) => sdk.relayer.createEIP712(publicKey, contractAddresses, startTimestamp, durationDays)
+  });
+}
+function useCreateDelegatedUserDecryptEIP712() {
+  const sdk = useTokenSDK();
+  return useMutation({
+    mutationFn: ({
+      publicKey,
+      contractAddresses,
+      delegatorAddress,
+      startTimestamp,
+      durationDays
+    }) => sdk.relayer.createDelegatedUserDecryptEIP712(
+      publicKey,
+      contractAddresses,
+      delegatorAddress,
+      startTimestamp,
+      durationDays
+    )
+  });
+}
+function useDelegatedUserDecrypt() {
+  const sdk = useTokenSDK();
+  return useMutation({
+    mutationFn: (params) => sdk.relayer.delegatedUserDecrypt(params)
+  });
+}
+function useRequestZKProofVerification() {
+  const sdk = useTokenSDK();
+  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 = useTokenSDK();
+  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 = useTokenSDK();
+  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 = useTokenSDK();
+  return useMemo(
+    () => sdk.createToken(config.tokenAddress, config.wrapperAddress),
+    [sdk, config.tokenAddress, config.wrapperAddress]
+  );
+}
+function useReadonlyToken(address) {
+  const sdk = useTokenSDK();
+  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 [signerAddress, setSignerAddress] = useState();
+  const [signerError, setSignerError] = useState();
+  useEffect(() => {
+    let cancelled = false;
+    setSignerError(void 0);
+    token.signer.getAddress().then((addr) => {
+      if (!cancelled) setSignerAddress(addr);
+    }).catch((error) => {
+      if (!cancelled) {
+        setSignerAddress(void 0);
+        setSignerError(error instanceof Error ? error : new Error(String(error)));
+      }
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, [token.signer]);
+  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, signerError };
+}
+var DEFAULT_HANDLE_REFETCH_INTERVAL2 = 1e4;
+function useConfidentialBalances(config, options) {
+  const { tokenAddresses, handleRefetchInterval } = config;
+  const sdk = useTokenSDK();
+  const [signerAddress, setSignerAddress] = useState();
+  const [signerError, setSignerError] = useState();
+  useEffect(() => {
+    let cancelled = false;
+    setSignerError(void 0);
+    sdk.signer.getAddress().then((addr) => {
+      if (!cancelled) setSignerAddress(addr);
+    }).catch((error) => {
+      if (!cancelled) {
+        setSignerAddress(void 0);
+        setSignerError(error instanceof Error ? error : new Error(String(error)));
+      }
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, [sdk.signer]);
+  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);
+      const result = /* @__PURE__ */ new Map();
+      for (let i = 0; i < tokens.length; i++) {
+        const balance = raw.get(tokens[i].address);
+        if (balance !== void 0) result.set(tokenAddresses[i], balance);
+      }
+      return result;
+    },
+    enabled: tokenAddresses.length > 0 && !!signerAddress && !!handles,
+    staleTime: Infinity,
+    ...options
+  });
+  return { ...balancesQuery, handlesQuery, signerError };
+}
+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 = useTokenSDK();
+  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 wrapMutationOptions(token) {
+  return {
+    mutationKey: ["wrap", token.address],
+    mutationFn: async ({ amount, fees, approvalStrategy }) => token.wrap(amount, { fees, approvalStrategy })
+  };
+}
+function useWrap(config, options) {
+  const token = useToken(config);
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationKey: ["wrap", config.tokenAddress],
+    mutationFn: async ({ amount, fees, approvalStrategy }) => token.wrap(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 wrapETHMutationOptions(token) {
+  return {
+    mutationKey: ["wrapETH", token.address],
+    mutationFn: ({ amount, value }) => token.wrapETH(amount, value)
+  };
+}
+function useWrapETH(config, options) {
+  const token = useToken(config);
+  return useMutation({
+    mutationKey: ["wrapETH", config.tokenAddress],
+    mutationFn: ({ amount, value }) => token.wrapETH(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 }) => token.unshield(amount)
+  };
+}
+function useUnshield(config, options) {
+  const token = useToken(config);
+  return useMutation({
+    mutationKey: ["unshield", config.tokenAddress],
+    mutationFn: ({ amount }) => token.unshield(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
+      });
+      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: () => token.unshieldAll()
+  };
+}
+function useUnshieldAll(config, options) {
+  const token = useToken(config);
+  return useMutation({
+    mutationKey: ["unshieldAll", config.tokenAddress],
+    mutationFn: () => token.unshieldAll(),
+    ...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 wrap fee query for given parameters. */
+  wrapFee: (feeManagerAddress, amount, from, to) => ["wrapFee", feeManagerAddress, ...amount !== void 0 ? [amount, from, to] : []],
+  /** Match unwrap fee query for given parameters. */
+  unwrapFee: (feeManagerAddress, amount, from, to) => ["unwrapFee", 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 wrapFeeQueryOptions(signer, config) {
+  const { feeManagerAddress, amount, from, to } = config;
+  return {
+    queryKey: feeQueryKeys.wrapFee(feeManagerAddress, amount.toString(), from, to),
+    queryFn: () => signer.readContract(getWrapFeeContract(feeManagerAddress, amount, from, to)),
+    staleTime: 3e4
+  };
+}
+function unwrapFeeQueryOptions(signer, config) {
+  const { feeManagerAddress, amount, from, to } = config;
+  return {
+    queryKey: feeQueryKeys.unwrapFee(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 useWrapFee(config, options) {
+  const sdk = useTokenSDK();
+  return useQuery({
+    ...wrapFeeQueryOptions(sdk.signer, config),
+    ...options
+  });
+}
+function useUnwrapFee(config, options) {
+  const sdk = useTokenSDK();
+  return useQuery({
+    ...unwrapFeeQueryOptions(sdk.signer, config),
+    ...options
+  });
+}
+function useBatchTransferFee(feeManagerAddress, options) {
+  const sdk = useTokenSDK();
+  return useQuery({
+    ...batchTransferFeeQueryOptions(sdk.signer, feeManagerAddress),
+    ...options
+  });
+}
+function useFeeRecipient(feeManagerAddress, options) {
+  const sdk = useTokenSDK();
+  return useQuery({
+    ...feeRecipientQueryOptions(sdk.signer, feeManagerAddress),
+    ...options
+  });
+}
+
+export { TokenSDKProvider, 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, tokenMetadataQueryKeys, tokenMetadataQueryOptions, totalSupplyQueryKeys, totalSupplyQueryOptions, underlyingAllowanceQueryKeys, underlyingAllowanceQueryOptions, unshieldAllMutationOptions, unshieldMutationOptions, unwrapAllMutationOptions, unwrapFeeQueryOptions, 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, useWrap as useShield, useWrapETH as useShieldETH, useToken, useTokenMetadata, useTokenMetadataSuspense, useTokenSDK, useTotalSupply, useTotalSupplySuspense, useUnderlyingAllowance, useUnderlyingAllowanceSuspense, useUnshield, useUnshieldAll, useUnwrap, useUnwrapAll, useUnwrapFee, useUserDecrypt, useUserDecryptedValue, useUserDecryptedValues, useWrap, useWrapETH, useWrapFee, useWrapperDiscovery, useWrapperDiscoverySuspense, wrapETHMutationOptions, wrapFeeQueryOptions, wrapMutationOptions, wrapperDiscoveryQueryKeys, wrapperDiscoveryQueryOptions };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map