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

package/dist/index.js

@@ -0,0 +1,1151 @@
+"use client";
+import { ZamaSDK, ReadonlyToken, DecryptionFailedError, sortByBlockNumber, parseActivityFeed, extractEncryptedHandles, applyDecryptedValues, totalSupplyContract, getWrapFeeContract, getUnwrapFeeContract, getBatchTransferFeeContract, getFeeRecipientContract } from '@zama-fhe/sdk';
+export { ApprovalFailedError, BATCH_SWAP_ABI, ChromeSessionStorage, 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, 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 { 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 NO_PROVIDER = /* @__PURE__ */ Symbol("no-provider");
+var ZamaSDKContext = createContext(NO_PROVIDER);
+function ZamaProvider({
+  children,
+  relayer,
+  signer,
+  storage,
+  sessionStorage,
+  credentialDurationDays,
+  onEvent
+}) {
+  const onEventRef = useRef(onEvent);
+  useEffect(() => {
+    onEventRef.current = onEvent;
+  });
+  const sdk = useMemo(
+    () => signer ? new ZamaSDK({
+      relayer,
+      signer,
+      storage,
+      sessionStorage,
+      credentialDurationDays,
+      onEvent: onEventRef.current
+    }) : null,
+    [relayer, signer, storage, sessionStorage, credentialDurationDays]
+  );
+  useEffect(() => () => sdk?.dispose(), [sdk]);
+  return /* @__PURE__ */ jsx(ZamaSDKContext.Provider, { value: sdk, children });
+}
+function useZamaSDK() {
+  const context = useContext(ZamaSDKContext);
+  if (context === NO_PROVIDER) {
+    throw new Error(
+      "useZamaSDK must be used within a <ZamaProvider>. Wrap your component tree in <ZamaProvider relayer={\u2026} signer={\u2026} storage={\u2026}>."
+    );
+  }
+  if (!context) {
+    throw new Error(
+      "useZamaSDK requires a connected signer. Either pass a `signer` prop to <ZamaProvider> or use useReadonlyZamaSDK() for read-only mode."
+    );
+  }
+  return context;
+}
+function useReadonlyZamaSDK() {
+  const context = useContext(ZamaSDKContext);
+  return context === NO_PROVIDER ? null : 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 useUserDecryptFlow(config) {
+  const sdk = useZamaSDK();
+  const queryClient = useQueryClient();
+  const callbacks = config?.callbacks;
+  return useMutation({
+    mutationKey: ["userDecryptFlow"],
+    mutationFn: async ({ handles, durationDays = 1 }) => {
+      const keypair = await sdk.relayer.generateKeypair();
+      callbacks?.onKeypairGenerated?.();
+      const contractAddresses = [...new Set(handles.map((h) => h.contractAddress))];
+      const startTimestamp = Math.floor(Date.now() / 1e3);
+      const eip712 = await sdk.relayer.createEIP712(
+        keypair.publicKey,
+        contractAddresses,
+        startTimestamp,
+        durationDays
+      );
+      callbacks?.onEIP712Created?.();
+      const signature = await sdk.signer.signTypedData(eip712);
+      callbacks?.onSigned?.(signature);
+      const signerAddress = await sdk.signer.getAddress();
+      const allResults = {};
+      const handlesByContract = /* @__PURE__ */ new Map();
+      for (const h of handles) {
+        const list = handlesByContract.get(h.contractAddress) ?? [];
+        list.push(h.handle);
+        handlesByContract.set(h.contractAddress, list);
+      }
+      for (const [contractAddress, contractHandles] of handlesByContract) {
+        const result = await sdk.relayer.userDecrypt({
+          handles: contractHandles,
+          contractAddress,
+          signedContractAddresses: contractAddresses,
+          privateKey: keypair.privateKey,
+          publicKey: keypair.publicKey,
+          signature,
+          signerAddress,
+          startTimestamp,
+          durationDays
+        });
+        Object.assign(allResults, result);
+      }
+      callbacks?.onDecrypted?.(allResults);
+      return allResults;
+    },
+    onSuccess: (data) => {
+      for (const [handle, value] of Object.entries(data)) {
+        queryClient.setQueryData(decryptionKeys.value(handle), value);
+      }
+    }
+  });
+}
+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 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
+  });
+  return { ...balancesQuery, handlesQuery };
+}
+var isAllowedQueryKeys = {
+  all: ["zama", "isAllowed"]
+};
+function isAllowedQueryOptions(sdk) {
+  return {
+    queryKey: isAllowedQueryKeys.all,
+    queryFn: () => sdk.isAllowed()
+  };
+}
+function useIsAllowed() {
+  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 });
+    }
+  });
+}
+function revokeMutationOptions(sdk) {
+  return {
+    mutationKey: ["revoke"],
+    mutationFn: async (tokenAddresses) => {
+      await sdk.revoke(...tokenAddresses);
+    }
+  };
+}
+function useRevoke() {
+  const sdk = useZamaSDK();
+  const queryClient = useQueryClient();
+  return useMutation({
+    ...revokeMutationOptions(sdk),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: isAllowedQueryKeys.all });
+    }
+  });
+}
+function revokeSessionMutationOptions(sdk) {
+  return {
+    mutationKey: ["revokeSession"],
+    mutationFn: async () => {
+      await sdk.revokeSession();
+    }
+  };
+}
+function useRevokeSession() {
+  const sdk = useZamaSDK();
+  const queryClient = useQueryClient();
+  return useMutation({
+    ...revokeSessionMutationOptions(sdk),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: isAllowedQueryKeys.all });
+    }
+  });
+}
+function confidentialTransferMutationOptions(token) {
+  return {
+    mutationKey: ["confidentialTransfer", token.address],
+    mutationFn: ({ to, amount, callbacks }) => token.confidentialTransfer(to, amount, callbacks)
+  };
+}
+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 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, callbacks }) => token.confidentialTransferFrom(from, to, amount, callbacks)
+  };
+}
+function useConfidentialTransferFrom(config, options) {
+  const token = useToken(config);
+  return useMutation({
+    mutationKey: ["confidentialTransferFrom", config.tokenAddress],
+    mutationFn: ({ from, to, amount, callbacks }) => token.confidentialTransferFrom(from, to, 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
+      });
+      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, 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 token = useToken(tokenConfig);
+  return useQuery({
+    ...spender ? confidentialIsApprovedQueryOptions(token, spender, holder) : {
+      queryKey: confidentialIsApprovedQueryKeys.spender(config.tokenAddress, "", holder),
+      queryFn: skipToken
+    },
+    ...options
+  });
+}
+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);
+    }
+  });
+}
+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 }),
+    ...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 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
+  };
+}
+function useMetadata(tokenAddress, options) {
+  const token = useReadonlyToken(tokenAddress);
+  return useQuery({
+    ...metadataQueryOptions(token),
+    ...options
+  });
+}
+function useMetadataSuspense(tokenAddress) {
+  const token = useReadonlyToken(tokenAddress);
+  return useSuspenseQuery(metadataQueryOptions(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, 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, useReadonlyZamaSDK, 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 };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map