@cofhe/react 0.0.0-alpha-20260601105140 → 0.0.0-alpha-20260602122344

package/dist/{chunk-AFU2LVEH.js → chunk-DSFIX7QP.js}

@@ -2754,6 +2754,138 @@ function useCofheWriteContract(options) {
   };
 }
 
+// src/hooks/useTransactionGlobalLifecycle.ts
+import { ContractFunctionExecutionError as ContractFunctionExecutionError2, ContractFunctionRevertedError as ContractFunctionRevertedError2 } from "viem";
+var TOAST_DELAY_MS = 1e4;
+function useTransactionGlobalToastsLifecycle() {
+  const { addToast } = usePortalToasts();
+  return {
+    // 1.tx is submitted
+    onTransactionSubmitted: (transaction) => {
+      cofheLogger.log("____ Transaction submitted:", transaction);
+      addToast(
+        {
+          variant: "info",
+          title: `${transaction.actionType}  Transaction Submitted`,
+          description: `${transaction.actionType} transaction has been submitted.`,
+          transaction: {
+            hash: transaction.hash,
+            chainId: transaction.chainId
+          }
+        },
+        TOAST_DELAY_MS
+      );
+    },
+    onTransactionSubmitError: (error, transactionType) => {
+      let humanReadableError;
+      if (error instanceof ContractFunctionExecutionError2) {
+        if (error.cause instanceof ContractFunctionRevertedError2) {
+          const reasonOfRevert = error.cause.raw;
+          if (typeof reasonOfRevert === "string") {
+            humanReadableError = cofheHumanizeRevertReason(reasonOfRevert);
+          }
+        }
+      }
+      cofheLogger.error("____ Transaction submission failed for type:", transactionType, "with error:", error);
+      addToast(
+        {
+          variant: "error",
+          title: `${transactionType} Transaction Submission Failed`,
+          description: humanReadableError ?? (error instanceof Error ? error.message : "An unknown error occurred during transaction submission.")
+        },
+        TOAST_DELAY_MS
+      );
+    },
+    // 2.a. tx is mined (could be success or fail)
+    onTransactionMined: (transaction, receipt) => {
+      cofheLogger.log("____ Transaction mined:", transaction, "with receipt:", receipt);
+      if (receipt.status === "success") {
+        addToast(
+          {
+            variant: "success",
+            title: `${transaction.actionType} Transaction Mined`,
+            description: `${transaction.actionType} transaction has been mined.`,
+            transaction: {
+              hash: transaction.hash,
+              chainId: transaction.chainId
+            }
+          },
+          TOAST_DELAY_MS
+        );
+      } else {
+        addToast(
+          {
+            variant: "error",
+            title: `${transaction.actionType} Transaction Failed`,
+            description: `${transaction.actionType} transaction has failed.`,
+            transaction: {
+              hash: transaction.hash,
+              chainId: transaction.chainId
+            }
+          },
+          TOAST_DELAY_MS
+        );
+      }
+    },
+    // 2.b. tx receipt fetch failed
+    onWatchReceiptFailure: (error, transaction) => {
+      cofheLogger.error("____ Transaction receipt fetch failed for tx:", transaction, "with error:", error);
+      addToast(
+        {
+          variant: "error",
+          title: `${transaction.actionType} Transaction Fetch Failed`,
+          description: `Fetching ${transaction.actionType} transaction has failed.`,
+          transaction: {
+            hash: transaction.hash,
+            chainId: transaction.chainId
+          }
+        },
+        TOAST_DELAY_MS
+      );
+    }
+  };
+}
+function useTransactionGlobalLifecycle() {
+  const {
+    onTransactionSubmitted: handleToastsOnTransactionSubmitted,
+    onTransactionMined: handleToastsOnTransactionMined,
+    onWatchReceiptFailure: handleToastsOnWatchReceiptFailure,
+    onTransactionSubmitError: handleToastsOnTransactionSubmitError
+  } = useTransactionGlobalToastsLifecycle();
+  return {
+    onTransactionSubmitted: handleToastsOnTransactionSubmitted,
+    onTransactionMined: handleToastsOnTransactionMined,
+    onWatchReceiptFailure: handleToastsOnWatchReceiptFailure,
+    onTransactionSubmitError: handleToastsOnTransactionSubmitError
+  };
+}
+
+// src/hooks/useCofheTokenApprove.ts
+function useCofheTokenApprove(writeMutationOptions) {
+  const { onSuccess: passedOnSuccess, onError: passedOnError, ...restOfOptions } = writeMutationOptions || {};
+  const { onTransactionSubmitError } = useTransactionGlobalLifecycle();
+  return useCofheWriteContract({
+    ...restOfOptions,
+    onError: (error, variables, onMutateResult, context) => {
+      if (passedOnError) passedOnError(error, variables, onMutateResult, context);
+      onTransactionSubmitError(error, "approve" /* Approve */);
+    },
+    onSuccess: (hash, variables, onMutateResult, context) => {
+      if (passedOnSuccess) passedOnSuccess(hash, variables, onMutateResult, context);
+      if (!hasExtras(variables)) return;
+      const { token, tokenAmount, account } = variables.extras;
+      useTransactionStore.getState().addTransaction({
+        hash,
+        token,
+        tokenAmount,
+        chainId: token.chainId,
+        actionType: "approve" /* Approve */,
+        account
+      });
+    }
+  });
+}
+
 // src/hooks/useCofheTokenLists.ts
 import "@tanstack/react-query";
 import { useMemo as useMemo9 } from "react";
@@ -3661,114 +3793,6 @@ function useCofheTokenClaimable({ accountAddress: account, token }, queryOptions
 var import_ts_essentials7 = __toESM(require_dist(), 1);
 import "@tanstack/react-query";
 import "viem";
-
-// src/hooks/useTransactionGlobalLifecycle.ts
-import { ContractFunctionExecutionError as ContractFunctionExecutionError2, ContractFunctionRevertedError as ContractFunctionRevertedError2 } from "viem";
-var TOAST_DELAY_MS = 1e4;
-function useTransactionGlobalToastsLifecycle() {
-  const { addToast } = usePortalToasts();
-  return {
-    // 1.tx is submitted
-    onTransactionSubmitted: (transaction) => {
-      cofheLogger.log("____ Transaction submitted:", transaction);
-      addToast(
-        {
-          variant: "info",
-          title: `${transaction.actionType}  Transaction Submitted`,
-          description: `${transaction.actionType} transaction has been submitted.`,
-          transaction: {
-            hash: transaction.hash,
-            chainId: transaction.chainId
-          }
-        },
-        TOAST_DELAY_MS
-      );
-    },
-    onTransactionSubmitError: (error, transactionType) => {
-      let humanReadableError;
-      if (error instanceof ContractFunctionExecutionError2) {
-        if (error.cause instanceof ContractFunctionRevertedError2) {
-          const reasonOfRevert = error.cause.raw;
-          if (typeof reasonOfRevert === "string") {
-            humanReadableError = cofheHumanizeRevertReason(reasonOfRevert);
-          }
-        }
-      }
-      cofheLogger.error("____ Transaction submission failed for type:", transactionType, "with error:", error);
-      addToast(
-        {
-          variant: "error",
-          title: `${transactionType} Transaction Submission Failed`,
-          description: humanReadableError ?? (error instanceof Error ? error.message : "An unknown error occurred during transaction submission.")
-        },
-        TOAST_DELAY_MS
-      );
-    },
-    // 2.a. tx is mined (could be success or fail)
-    onTransactionMined: (transaction, receipt) => {
-      cofheLogger.log("____ Transaction mined:", transaction, "with receipt:", receipt);
-      if (receipt.status === "success") {
-        addToast(
-          {
-            variant: "success",
-            title: `${transaction.actionType} Transaction Mined`,
-            description: `${transaction.actionType} transaction has been mined.`,
-            transaction: {
-              hash: transaction.hash,
-              chainId: transaction.chainId
-            }
-          },
-          TOAST_DELAY_MS
-        );
-      } else {
-        addToast(
-          {
-            variant: "error",
-            title: `${transaction.actionType} Transaction Failed`,
-            description: `${transaction.actionType} transaction has failed.`,
-            transaction: {
-              hash: transaction.hash,
-              chainId: transaction.chainId
-            }
-          },
-          TOAST_DELAY_MS
-        );
-      }
-    },
-    // 2.b. tx receipt fetch failed
-    onWatchReceiptFailure: (error, transaction) => {
-      cofheLogger.error("____ Transaction receipt fetch failed for tx:", transaction, "with error:", error);
-      addToast(
-        {
-          variant: "error",
-          title: `${transaction.actionType} Transaction Fetch Failed`,
-          description: `Fetching ${transaction.actionType} transaction has failed.`,
-          transaction: {
-            hash: transaction.hash,
-            chainId: transaction.chainId
-          }
-        },
-        TOAST_DELAY_MS
-      );
-    }
-  };
-}
-function useTransactionGlobalLifecycle() {
-  const {
-    onTransactionSubmitted: handleToastsOnTransactionSubmitted,
-    onTransactionMined: handleToastsOnTransactionMined,
-    onWatchReceiptFailure: handleToastsOnWatchReceiptFailure,
-    onTransactionSubmitError: handleToastsOnTransactionSubmitError
-  } = useTransactionGlobalToastsLifecycle();
-  return {
-    onTransactionSubmitted: handleToastsOnTransactionSubmitted,
-    onTransactionMined: handleToastsOnTransactionMined,
-    onWatchReceiptFailure: handleToastsOnWatchReceiptFailure,
-    onTransactionSubmitError: handleToastsOnTransactionSubmitError
-  };
-}
-
-// src/hooks/useCofheTokenClaimUnshielded.ts
 function getCofheTokenClaimUnshieldedCallArgs(params) {
   const { token, account, claim, claims } = params;
   const tokenAddress = token.address;
@@ -4089,8 +4113,123 @@ function useCofheTokenDecryptedBalance({ token, accountAddress, displayDecimals
   };
 }
 
+// src/hooks/useCofheTokenPublicBalance.ts
+var import_ts_essentials10 = __toESM(require_dist(), 1);
+import "@tanstack/react-query";
+import "viem";
+function constructPublicTokenBalanceQueryKey({
+  chainId,
+  accountAddress,
+  tokenAddress
+}) {
+  return ["tokenBalance", chainId, accountAddress?.toLowerCase(), tokenAddress?.toLowerCase()];
+}
+function constructPublicTokenBalanceQueryKeyForInvalidation({
+  chainId,
+  accountAddress,
+  tokenAddress
+}) {
+  return constructPublicTokenBalanceQueryKey({
+    chainId,
+    accountAddress,
+    tokenAddress
+  });
+}
+function getPublicTokenBalanceSource(token) {
+  const confidentialityType = token?.extensions.fhenix.confidentialityType;
+  const underlyingErc20 = token?.extensions.fhenix.erc20Pair;
+  const publicBalanceSourceType = getPublicBalanceSourceType(confidentialityType);
+  const tokenToFetchBalanceFrom = publicBalanceSourceType === "erc20Pair" ? underlyingErc20 : publicBalanceSourceType === "token" ? token : void 0;
+  if (!tokenToFetchBalanceFrom) return void 0;
+  return {
+    address: tokenToFetchBalanceFrom.address,
+    decimals: tokenToFetchBalanceFrom.decimals
+  };
+}
+function createPublicTokenBalanceQueryOptions(params) {
+  const { publicClient, accountAddress, tokenAddress, queryOptions } = params;
+  const { enabled: userEnabled, ...restQueryOptions } = queryOptions ?? {};
+  const baseEnabled = !!publicClient && !!accountAddress && !!tokenAddress;
+  const enabled = baseEnabled && (userEnabled ?? true);
+  const queryKey = constructPublicTokenBalanceQueryKey({
+    chainId: publicClient?.chain?.id,
+    accountAddress,
+    tokenAddress
+  });
+  return {
+    queryKey,
+    queryFn: withInvalidationContext(
+      async ({ invalidationContext, signal }) => {
+        (0, import_ts_essentials10.assert)(tokenAddress, "Token address is required to fetch token balance");
+        (0, import_ts_essentials10.assert)(publicClient, "PublicClient is required to fetch token balance");
+        (0, import_ts_essentials10.assert)(accountAddress, "Account address is required to fetch token balance");
+        const isNativeToken = tokenAddress.toLowerCase() === ETH_ADDRESS_LOWERCASE;
+        const balance = await maybeWaitUntilRpcAware(
+          publicClient,
+          {
+            blockHashToBeAwareOf: invalidationContext?.blockHashToBeAwareOf,
+            readDescription: isNativeToken ? "read native balance" : "read ERC20 balance",
+            read: () => isNativeToken ? publicClient.getBalance({
+              address: accountAddress
+            }) : publicClient.readContract({
+              address: tokenAddress,
+              abi: ERC20_BALANCE_OF_ABI,
+              functionName: "balanceOf",
+              args: [accountAddress]
+            })
+          },
+          { signal }
+        );
+        return balance;
+      }
+    ),
+    enabled,
+    refetchOnMount: false,
+    ...restQueryOptions
+  };
+}
+function useTokenBalance({ tokenAddress, accountAddress }, queryOptions) {
+  const publicClient = useCofhePublicClient();
+  return useInternalQuery(
+    createPublicTokenBalanceQueryOptions({
+      publicClient,
+      accountAddress,
+      tokenAddress,
+      queryOptions
+    })
+  );
+}
+function useCofheTokenPublicBalance({ token, accountAddress, displayDecimals = 5 }, options) {
+  const connectedAccount = useCofheAccount();
+  const account = accountAddress || connectedAccount;
+  const { enabled: userEnabled = true, ...restOptions } = options ?? {};
+  const tokenToFetchBalanceFrom = getPublicTokenBalanceSource(token);
+  const { data, isFetching, refetch } = useTokenBalance(
+    {
+      tokenAddress: tokenToFetchBalanceFrom?.address,
+      accountAddress: account
+    },
+    {
+      enabled: userEnabled,
+      select: (value) => {
+        (0, import_ts_essentials10.assert)(
+          typeof tokenToFetchBalanceFrom?.decimals === "number",
+          "Token decimals must be defined to format public token balance"
+        );
+        return formatTokenAmount(value, tokenToFetchBalanceFrom.decimals, displayDecimals);
+      },
+      ...restOptions
+    }
+  );
+  return {
+    data,
+    isFetching,
+    refetch
+  };
+}
+
 // src/hooks/useCofheTokensClaimable.ts
-var import_ts_essentials11 = __toESM(require_dist(), 1);
+var import_ts_essentials12 = __toESM(require_dist(), 1);
 import "@tanstack/react-query";
 import "react";
 import "viem";
@@ -4122,7 +4261,7 @@ function useNormalizedList(items, options) {
 }
 
 // src/hooks/useStoredTransactions.ts
-var import_ts_essentials10 = __toESM(require_dist());
+var import_ts_essentials11 = __toESM(require_dist());
 import { useMemo as useMemo11 } from "react";
 function useStoredTransactions({
   chainId,
@@ -4155,7 +4294,7 @@ function useStoredTransactions({
     return reducer?.(filtered);
   }, [filtered, reducer]);
   const uniqueHashes = new Set(filtered.map((tx) => tx.hash));
-  (0, import_ts_essentials10.assert)(
+  (0, import_ts_essentials11.assert)(
     uniqueHashes.size === filtered.length,
     "There should be no duplicate transactions with the same hash in the result"
   );
@@ -4230,12 +4369,12 @@ function useCofheTokensClaimable({ tokens, accountAddress: account }, queryOptio
       return {
         queryKey,
         queryFn: withInvalidationContext(async ({ signal, invalidationContext }) => {
-          (0, import_ts_essentials11.assert)(
+          (0, import_ts_essentials12.assert)(
             isTokenConfidentialityTypeClaimable(confidentialityType),
             "confidentialityType narrowed by token guard"
           );
-          (0, import_ts_essentials11.assert)(account, "account is required to fetch unshield claims");
-          (0, import_ts_essentials11.assert)(publicClient, "publicClient is required to fetch unshield claims");
+          (0, import_ts_essentials12.assert)(account, "account is required to fetch unshield claims");
+          (0, import_ts_essentials12.assert)(publicClient, "publicClient is required to fetch unshield claims");
           return fetchUnshieldClaimsSummary({
             publicClient,
             token,
@@ -4298,7 +4437,7 @@ function useCofheTokensClaimable({ tokens, accountAddress: account }, queryOptio
 // src/hooks/useCofheTokenShield.ts
 import "@tanstack/react-query";
 import "viem";
-var import_ts_essentials12 = __toESM(require_dist(), 1);
+var import_ts_essentials13 = __toESM(require_dist(), 1);
 function getCofheTokenShieldCallArgs(params) {
   const { token, amount, account } = params;
   const tokenAddress = token.address;
@@ -4408,8 +4547,8 @@ function useCofheTokenShield(options) {
       onTransactionSubmitError(error, "shield" /* Shield */);
     },
     onSuccess: async (hash, input, onMutateResult, context) => {
-      (0, import_ts_essentials12.assert)(chainId, "Chain ID is required for token shield");
-      (0, import_ts_essentials12.assert)(account, "Wallet account is required for token shield");
+      (0, import_ts_essentials13.assert)(chainId, "Chain ID is required for token shield");
+      (0, import_ts_essentials13.assert)(account, "Wallet account is required for token shield");
       if (onSuccess) await onSuccess(hash, input, onMutateResult, context);
       useTransactionStore.getState().addTransaction({
         hash,
@@ -4428,7 +4567,7 @@ function useCofheTokenShield(options) {
 import { useMemo as useMemo13 } from "react";
 
 // src/hooks/useCofheReadContracts.ts
-var import_ts_essentials13 = __toESM(require_dist(), 1);
+var import_ts_essentials14 = __toESM(require_dist(), 1);
 import "@tanstack/react-query";
 import { transformEncryptedReturnTypes as transformEncryptedReturnTypes2 } from "@cofhe/abi";
 var QUERY_CACHE_PREFIX3 = "cofheReadContracts";
@@ -4473,8 +4612,8 @@ function useCofheReadContracts(params, queryOptions) {
       allowFailure: multicallOptions?.allowFailure
     }),
     queryFn: async () => {
-      (0, import_ts_essentials13.assert)(publicClient, "PublicClient should be guaranteed by enabled check");
-      (0, import_ts_essentials13.assert)(contracts && contracts.length > 0, "Contracts should be guaranteed by enabled check");
+      (0, import_ts_essentials14.assert)(publicClient, "PublicClient should be guaranteed by enabled check");
+      (0, import_ts_essentials14.assert)(contracts && contracts.length > 0, "Contracts should be guaranteed by enabled check");
       const raw = await publicClient.multicall({
         contracts,
         ...multicallOptions || {}
@@ -4702,17 +4841,17 @@ function useCofheTokenTransfer(writeMutationOptions) {
 // src/hooks/useCofheTokenUnshield.ts
 import "@tanstack/react-query";
 import "viem";
-var import_ts_essentials15 = __toESM(require_dist(), 1);
+var import_ts_essentials16 = __toESM(require_dist(), 1);
 
 // src/hooks/useStoredTransaction.ts
 import { useMemo as useMemo14 } from "react";
-var import_ts_essentials14 = __toESM(require_dist(), 1);
+var import_ts_essentials15 = __toESM(require_dist(), 1);
 function useStoredTransaction(txHash) {
   const filter2 = useMemo14(() => {
     return (tx) => tx.hash === txHash;
   }, [txHash]);
   const { filteredTxs } = useStoredTransactions({ filter: filter2 });
-  (0, import_ts_essentials14.assert)(filteredTxs.length <= 1, "There should be at most one transaction with a given hash");
+  (0, import_ts_essentials15.assert)(filteredTxs.length <= 1, "There should be at most one transaction with a given hash");
   return filteredTxs[0];
 }
 
@@ -4817,8 +4956,8 @@ function useCofheTokenUnshieldMutation(options) {
       onTransactionSubmitError(error, "unshield" /* Unshield */);
     },
     onSuccess: async (hash, input, onMutateResult, context) => {
-      (0, import_ts_essentials15.assert)(chainId, "Chain ID is required for token unshield");
-      (0, import_ts_essentials15.assert)(account, "Wallet account is required for token unshield");
+      (0, import_ts_essentials16.assert)(chainId, "Chain ID is required for token unshield");
+      (0, import_ts_essentials16.assert)(account, "Wallet account is required for token unshield");
       if (onSuccess) await onSuccess(hash, input, onMutateResult, context);
       useTransactionStore.getState().addTransaction({
         hash,
@@ -4985,123 +5124,6 @@ function useCoingeckoUsdPrice({
 
 // src/hooks/useTokensWithPublicBalances.ts
 import { useMemo as useMemo15 } from "react";
-
-// src/hooks/useCofheTokenPublicBalance.ts
-var import_ts_essentials16 = __toESM(require_dist(), 1);
-import "@tanstack/react-query";
-import "viem";
-function constructPublicTokenBalanceQueryKey({
-  chainId,
-  accountAddress,
-  tokenAddress
-}) {
-  return ["tokenBalance", chainId, accountAddress?.toLowerCase(), tokenAddress?.toLowerCase()];
-}
-function constructPublicTokenBalanceQueryKeyForInvalidation({
-  chainId,
-  accountAddress,
-  tokenAddress
-}) {
-  return constructPublicTokenBalanceQueryKey({
-    chainId,
-    accountAddress,
-    tokenAddress
-  });
-}
-function getPublicTokenBalanceSource(token) {
-  const confidentialityType = token?.extensions.fhenix.confidentialityType;
-  const underlyingErc20 = token?.extensions.fhenix.erc20Pair;
-  const publicBalanceSourceType = getPublicBalanceSourceType(confidentialityType);
-  const tokenToFetchBalanceFrom = publicBalanceSourceType === "erc20Pair" ? underlyingErc20 : publicBalanceSourceType === "token" ? token : void 0;
-  if (!tokenToFetchBalanceFrom) return void 0;
-  return {
-    address: tokenToFetchBalanceFrom.address,
-    decimals: tokenToFetchBalanceFrom.decimals
-  };
-}
-function createPublicTokenBalanceQueryOptions(params) {
-  const { publicClient, accountAddress, tokenAddress, queryOptions } = params;
-  const { enabled: userEnabled, ...restQueryOptions } = queryOptions ?? {};
-  const baseEnabled = !!publicClient && !!accountAddress && !!tokenAddress;
-  const enabled = baseEnabled && (userEnabled ?? true);
-  const queryKey = constructPublicTokenBalanceQueryKey({
-    chainId: publicClient?.chain?.id,
-    accountAddress,
-    tokenAddress
-  });
-  return {
-    queryKey,
-    queryFn: withInvalidationContext(
-      async ({ invalidationContext, signal }) => {
-        (0, import_ts_essentials16.assert)(tokenAddress, "Token address is required to fetch token balance");
-        (0, import_ts_essentials16.assert)(publicClient, "PublicClient is required to fetch token balance");
-        (0, import_ts_essentials16.assert)(accountAddress, "Account address is required to fetch token balance");
-        const isNativeToken = tokenAddress.toLowerCase() === ETH_ADDRESS_LOWERCASE;
-        const balance = await maybeWaitUntilRpcAware(
-          publicClient,
-          {
-            blockHashToBeAwareOf: invalidationContext?.blockHashToBeAwareOf,
-            readDescription: isNativeToken ? "read native balance" : "read ERC20 balance",
-            read: () => isNativeToken ? publicClient.getBalance({
-              address: accountAddress
-            }) : publicClient.readContract({
-              address: tokenAddress,
-              abi: ERC20_BALANCE_OF_ABI,
-              functionName: "balanceOf",
-              args: [accountAddress]
-            })
-          },
-          { signal }
-        );
-        return balance;
-      }
-    ),
-    enabled,
-    refetchOnMount: false,
-    ...restQueryOptions
-  };
-}
-function useTokenBalance({ tokenAddress, accountAddress }, queryOptions) {
-  const publicClient = useCofhePublicClient();
-  return useInternalQuery(
-    createPublicTokenBalanceQueryOptions({
-      publicClient,
-      accountAddress,
-      tokenAddress,
-      queryOptions
-    })
-  );
-}
-function useCofheTokenPublicBalance({ token, accountAddress, displayDecimals = 5 }, options) {
-  const connectedAccount = useCofheAccount();
-  const account = accountAddress || connectedAccount;
-  const { enabled: userEnabled = true, ...restOptions } = options ?? {};
-  const tokenToFetchBalanceFrom = getPublicTokenBalanceSource(token);
-  const { data, isFetching, refetch } = useTokenBalance(
-    {
-      tokenAddress: tokenToFetchBalanceFrom?.address,
-      accountAddress: account
-    },
-    {
-      enabled: userEnabled,
-      select: (value) => {
-        (0, import_ts_essentials16.assert)(
-          typeof tokenToFetchBalanceFrom?.decimals === "number",
-          "Token decimals must be defined to format public token balance"
-        );
-        return formatTokenAmount(value, tokenToFetchBalanceFrom.decimals, displayDecimals);
-      },
-      ...restOptions
-    }
-  );
-  return {
-    data,
-    isFetching,
-    refetch
-  };
-}
-
-// src/hooks/useTokensWithPublicBalances.ts
 function useTokensWithPublicBalances({ chainId: _chainId, accountAddress, displayDecimals = 5 } = {}, options) {
   const connectedAccount = useCofheAccount();
   const account = accountAddress ?? connectedAccount;
@@ -5778,32 +5800,6 @@ var usePermitDetailsAndActions = (permitHash) => {
   };
 };
 
-// src/hooks/useCofheTokenApprove.ts
-function useCofheTokenApprove(writeMutationOptions) {
-  const { onSuccess: passedOnSuccess, onError: passedOnError, ...restOfOptions } = writeMutationOptions || {};
-  const { onTransactionSubmitError } = useTransactionGlobalLifecycle();
-  return useCofheWriteContract({
-    ...restOfOptions,
-    onError: (error, variables, onMutateResult, context) => {
-      if (passedOnError) passedOnError(error, variables, onMutateResult, context);
-      onTransactionSubmitError(error, "approve" /* Approve */);
-    },
-    onSuccess: (hash, variables, onMutateResult, context) => {
-      if (passedOnSuccess) passedOnSuccess(hash, variables, onMutateResult, context);
-      if (!hasExtras(variables)) return;
-      const { token, tokenAmount, account } = variables.extras;
-      useTransactionStore.getState().addTransaction({
-        hash,
-        token,
-        tokenAmount,
-        chainId: token.chainId,
-        actionType: "approve" /* Approve */,
-        account
-      });
-    }
-  });
-}
-
 // src/hooks/useReschedulableTimeout.ts
 import { useEffect as useEffect5, useRef as useRef3 } from "react";
 function useReschedulableTimeout(callback, defaultTimeout) {
@@ -11179,6 +11175,7 @@ export {
   statusToString,
   useTransactionStore,
   useCofheWriteContract,
+  useCofheTokenApprove,
   useCofheTokenLists,
   useCofheTokens,
   useCofheTokenClaimable,
@@ -11186,6 +11183,7 @@ export {
   useCofheTokenClaimUnshielded,
   useCofheReadContractAndDecrypt,
   useCofheTokenDecryptedBalance,
+  useCofheTokenPublicBalance,
   useCofheTokensClaimable,
   getCofheTokenShieldCallArgs,
   useCofheTokenShield,
@@ -11208,4 +11206,4 @@ export {
   SettingsPage,
   CofheFloatingButtonWithProvider
 };
-//# sourceMappingURL=chunk-AFU2LVEH.js.map
+//# sourceMappingURL=chunk-DSFIX7QP.js.map