@cofhe/react 0.0.0-beta-20260324063313 → 0.0.0-beta-20260324094644

package/dist/index.js

@@ -581,12 +581,12 @@ var require_assert = __commonJS({
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
     exports.assert = void 0;
-    function assert24(condition, message = "no additional info provided") {
+    function assert26(condition, message = "no additional info provided") {
       if (!condition) {
         throw new Error("Assertion Error: " + message);
       }
     }
-    exports.assert = assert24;
+    exports.assert = assert26;
   }
 });
 
@@ -730,7 +730,7 @@ var require_dist = __commonJS({
 });
 
 // src/providers/CofheProvider.tsx
-import { createContext as createContext4, useContext as useContext5, useMemo as useMemo33, useState as useState15 } from "react";
+import { createContext as createContext4, useContext as useContext5, useMemo as useMemo34, useState as useState15 } from "react";
 
 // src/providers/QueryProvider.tsx
 import { QueryClient } from "@tanstack/react-query";
@@ -1066,6 +1066,71 @@ async function maybeWaitUntilRpcAwareAndReadContract(publicClient, params, optio
   throw new Error("Unexpected exit from wait loop");
 }
 
+// src/utils/cofheErrors.ts
+import errorsJson from "@fhenixprotocol/cofhe-errors/errors.json";
+import { ContractFunctionExecutionError, ContractFunctionRevertedError } from "viem";
+function is0xString(value) {
+  return value.startsWith("0x");
+}
+function isStringArray(value) {
+  return Array.isArray(value) && value.every((v) => typeof v === "string");
+}
+function isCofheSolidityError(value) {
+  if (typeof value !== "object" || value === null) return false;
+  if (!("name" in value) || typeof value.name !== "string") return false;
+  if (!("selector" in value) || typeof value.selector !== "string") return false;
+  if (!is0xString(value.selector)) return false;
+  if (!("signature" in value) || typeof value.signature !== "string") return false;
+  if (!("source" in value) || typeof value.source !== "string") return false;
+  if (!("inputs" in value) || !isStringArray(value.inputs)) return false;
+  if (!("inputTypes" in value) || !isStringArray(value.inputTypes)) return false;
+  return true;
+}
+function parseCofheSolidityErrors(value) {
+  if (!Array.isArray(value)) return [];
+  return value.filter(isCofheSolidityError);
+}
+var errorsJsonUnknown = errorsJson;
+var errors = parseCofheSolidityErrors(errorsJsonUnknown);
+function normalizeSelector(selector) {
+  if (typeof selector !== "string") return void 0;
+  const s = selector.trim().toLowerCase();
+  if (!s.startsWith("0x")) return void 0;
+  if (s.length < 10) return void 0;
+  const candidate = s.slice(0, 10);
+  if (!is0xString(candidate)) return void 0;
+  return candidate;
+}
+function decodeCofheErrorSelector(selectorOrRevertData) {
+  const selector = normalizeSelector(selectorOrRevertData);
+  if (!selector) return void 0;
+  return errors.find((e) => e.selector.toLowerCase() === selector);
+}
+function cofheHumanizeRevertReason(reasonOfRevert) {
+  const decoded = decodeCofheErrorSelector(reasonOfRevert);
+  if (!decoded) return void 0;
+  return `${decoded.signature} (${decoded.source})`;
+}
+function extractSelectorFromMessage(message) {
+  const match = message.match(/0x[0-9a-fA-F]{8}/);
+  return match?.[0];
+}
+function cofheHumanizeViemError(error) {
+  if (error instanceof ContractFunctionExecutionError) {
+    if (error.cause instanceof ContractFunctionRevertedError) {
+      const raw = error.cause.raw;
+      if (typeof raw === "string") {
+        return cofheHumanizeRevertReason(raw);
+      }
+    }
+  }
+  if (error instanceof Error) {
+    const selector = extractSelectorFromMessage(error.message);
+    if (selector) return cofheHumanizeRevertReason(selector);
+  }
+  return void 0;
+}
+
 // src/components/FnxFloatingButton/FloatingButtonComponent.tsx
 import CloseIcon from "@mui/icons-material/Close";
 
@@ -1105,13 +1170,15 @@ var TransactionActionType = /* @__PURE__ */ ((TransactionActionType2) => {
   TransactionActionType2["Shield"] = "shield";
   TransactionActionType2["Unshield"] = "unshield";
   TransactionActionType2["Claim"] = "claim";
+  TransactionActionType2["Approve"] = "approve";
   return TransactionActionType2;
 })(TransactionActionType || {});
 var actionToStringMap = {
   ["shieldSend" /* ShieldSend */]: "Shielded Transfer",
   ["shield" /* Shield */]: "Shield",
   ["unshield" /* Unshield */]: "Unshield",
-  ["claim" /* Claim */]: "Claim"
+  ["claim" /* Claim */]: "Claim",
+  ["approve" /* Approve */]: "Approve"
 };
 var actionToString = (a) => actionToStringMap[a];
 var statusToStringMap = {
@@ -1260,7 +1327,7 @@ var useCofhePublicClient = () => useCofheConnection().publicClient;
 var useCofheWalletClient = () => useCofheConnection().walletClient;
 
 // src/hooks/useTrackPendingTransactions.ts
-var import_ts_essentials5 = __toESM(require_dist());
+var import_ts_essentials6 = __toESM(require_dist());
 
 // src/hooks/useCofheReadContract.ts
 import "@tanstack/react-query";
@@ -1388,19 +1455,27 @@ function useIsCofheErrorActive() {
 
 // src/hooks/useCofheReadContract.ts
 import { transformEncryptedReturnTypes } from "@cofhe/abi";
-var QUERY_CACHE_PREFIX = "cofheReadContract";
+
+// src/utils/serializeBigint.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
 function serializeIfBigint(value) {
-  if (typeof value === "bigint") {
-    return value.toString();
-  }
+  if (typeof value === "bigint") return value.toString();
+  return value;
 }
 function serializeBigintRecursively(value) {
-  if (Array.isArray(value)) {
-    return value.map(serializeBigintRecursively);
-  } else {
-    return serializeIfBigint(value);
+  if (Array.isArray(value)) return value.map(serializeBigintRecursively);
+  if (isRecord(value)) {
+    const out = {};
+    for (const [key, nested] of Object.entries(value)) out[key] = serializeBigintRecursively(nested);
+    return out;
   }
+  return serializeIfBigint(value);
 }
+
+// src/hooks/useCofheReadContract.ts
+var QUERY_CACHE_PREFIX = "cofheReadContract";
 function constructCofheReadContractQueryKey({
   cofheChainId,
   address,
@@ -2235,8 +2310,86 @@ function useCofheTokenClaimable({ accountAddress: account, token }, queryOptions
   };
 }
 
+// src/hooks/useTokenAllowance.ts
+var import_ts_essentials4 = __toESM(require_dist(), 1);
+import "@tanstack/react-query";
+import "viem";
+function constructTokenAllowanceQueryKey({
+  chainId,
+  tokenAddress,
+  ownerAddress,
+  spenderAddress
+}) {
+  return [
+    "tokenAllowance",
+    chainId,
+    tokenAddress?.toLowerCase(),
+    ownerAddress?.toLowerCase(),
+    spenderAddress?.toLowerCase()
+  ];
+}
+function constructTokenAllowanceQueryKeyForInvalidation({
+  chainId,
+  tokenAddress,
+  ownerAddress,
+  spenderAddress
+}) {
+  return constructTokenAllowanceQueryKey({
+    chainId,
+    tokenAddress,
+    ownerAddress,
+    spenderAddress
+  });
+}
+function createTokenAllowanceQueryOptions(params) {
+  const { publicClient, tokenAddress, ownerAddress, spenderAddress, queryOptions } = params;
+  const { enabled: userEnabled, ...restQueryOptions } = queryOptions ?? {};
+  const baseEnabled = !!publicClient && !!tokenAddress && !!ownerAddress && !!spenderAddress;
+  const enabled = baseEnabled && (userEnabled ?? true);
+  const queryKey = constructTokenAllowanceQueryKey({
+    chainId: publicClient?.chain?.id,
+    tokenAddress,
+    ownerAddress,
+    spenderAddress
+  });
+  return {
+    queryKey,
+    queryFn: async () => {
+      (0, import_ts_essentials4.assert)(publicClient, "PublicClient is required to fetch token allowance");
+      (0, import_ts_essentials4.assert)(tokenAddress, "Token address is required to fetch token allowance");
+      (0, import_ts_essentials4.assert)(ownerAddress, "Owner address is required to fetch token allowance");
+      (0, import_ts_essentials4.assert)(spenderAddress, "Spender address is required to fetch token allowance");
+      return publicClient.readContract({
+        address: tokenAddress,
+        abi: ERC20_ALLOWANCE_ABI,
+        functionName: "allowance",
+        args: [ownerAddress, spenderAddress]
+      });
+    },
+    enabled,
+    refetchOnMount: false,
+    ...restQueryOptions
+  };
+}
+function useTokenAllowance({ tokenAddress, ownerAddress, spenderAddress }, options) {
+  const publicClient = useCofhePublicClient();
+  const queryOptions = createTokenAllowanceQueryOptions({
+    publicClient,
+    tokenAddress,
+    ownerAddress,
+    spenderAddress,
+    queryOptions: options
+  });
+  const { data, isFetching, refetch } = useInternalQuery(queryOptions);
+  return {
+    data,
+    isFetching,
+    refetch
+  };
+}
+
 // src/hooks/useStoredTransactions.ts
-var import_ts_essentials4 = __toESM(require_dist());
+var import_ts_essentials5 = __toESM(require_dist());
 import { useMemo as useMemo6 } from "react";
 function useStoredTransactions({
   chainId,
@@ -2269,7 +2422,7 @@ function useStoredTransactions({
     return reducer?.(filtered);
   }, [filtered, reducer]);
   const uniqueHashes = new Set(filtered.map((tx) => tx.hash));
-  (0, import_ts_essentials4.assert)(
+  (0, import_ts_essentials5.assert)(
     uniqueHashes.size === filtered.length,
     "There should be no duplicate transactions with the same hash in the result"
   );
@@ -2687,6 +2840,7 @@ var usePortalToasts = create7()((set, get) => ({
 }));
 
 // src/hooks/useTransactionGlobalLifecycle.ts
+import { ContractFunctionExecutionError as ContractFunctionExecutionError2, ContractFunctionRevertedError as ContractFunctionRevertedError2 } from "viem";
 var TOAST_DELAY_MS = 1e4;
 function useTransactionGlobalToastsLifecycle() {
   const { addToast } = usePortalToasts();
@@ -2708,12 +2862,21 @@ function useTransactionGlobalToastsLifecycle() {
       );
     },
     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);
+          }
+        }
+      }
       console.error("____ Transaction submission failed for type:", transactionType, "with error:", error);
       addToast(
         {
           variant: "error",
           title: `${transactionType} Transaction Submission Failed`,
-          description: error instanceof Error ? error.message : "An unknown error occurred during transaction submission."
+          description: humanReadableError ?? (error instanceof Error ? error.message : "An unknown error occurred during transaction submission.")
         },
         TOAST_DELAY_MS
       );
@@ -2835,7 +2998,7 @@ function invalidatePublicTokenBalanceQueries({
 function invalidatePublicAndConfidentialTokenBalanceQueries(token, accountAddress, queryClient) {
   invalidateConfidentialTokenBalanceQueries(token, queryClient);
   const publicPairTokenAddress = token.extensions.fhenix.erc20Pair?.address;
-  (0, import_ts_essentials5.assert)(publicPairTokenAddress, "Public pair token address is required for shield transaction invalidation");
+  (0, import_ts_essentials6.assert)(publicPairTokenAddress, "Public pair token address is required for shield transaction invalidation");
   invalidatePublicTokenBalanceQueries(
     {
       tokenAddress: publicPairTokenAddress,
@@ -2845,6 +3008,20 @@ function invalidatePublicAndConfidentialTokenBalanceQueries(token, accountAddres
     queryClient
   );
 }
+function invalidateTokenAllowanceQueries({
+  chainId,
+  tokenAddress,
+  ownerAddress,
+  spenderAddress
+}, queryClient) {
+  const queryKey = constructTokenAllowanceQueryKeyForInvalidation({
+    chainId,
+    tokenAddress,
+    ownerAddress,
+    spenderAddress
+  });
+  queryClient.invalidateQueries({ queryKey });
+}
 function useTrackPendingTransactionsBase({
   onReceiptSuccess,
   onReceiptFail,
@@ -2855,9 +3032,11 @@ function useTrackPendingTransactionsBase({
   const queries = accountsPendingTxs.map((tx) => ({
     queryKey: ["tx-receipt", tx.chainId, tx.hash],
     queryFn: async () => {
-      (0, import_ts_essentials5.assert)(publicClient, "Public client is guaranteed by enabled condition");
+      (0, import_ts_essentials6.assert)(publicClient, "Public client is guaranteed by enabled condition");
       try {
-        const receipt = await publicClient.waitForTransactionReceipt({ hash: tx.hash });
+        const receipt = await publicClient.waitForTransactionReceipt({
+          hash: tx.hash
+        });
         const status = receipt.status === "success" ? "confirmed" /* Confirmed */ : "failed" /* Failed */;
         if (status === "confirmed" /* Confirmed */) onReceiptSuccess(tx, receipt);
         else onReceiptFail?.(tx, receipt);
@@ -2913,7 +3092,7 @@ function useHandleInvalidations() {
       });
     } else if (tx.actionType === "claim" /* Claim */) {
       const publicTokenAddress = tx.token.extensions.fhenix.erc20Pair?.address;
-      (0, import_ts_essentials5.assert)(publicTokenAddress, "Public pair token address is required for claim transaction invalidation");
+      (0, import_ts_essentials6.assert)(publicTokenAddress, "Public pair token address is required for claim transaction invalidation");
       invalidatePublicTokenBalanceQueries(
         {
           tokenAddress: publicTokenAddress,
@@ -2927,6 +3106,20 @@ function useHandleInvalidations() {
         accountAddress: tx.account,
         queryClient
       });
+    } else if (tx.actionType === "approve" /* Approve */) {
+      const underlying = tx.token.extensions.fhenix.erc20Pair?.address;
+      (0, import_ts_essentials6.assert)(underlying, "erc20Pair is required for approve transaction invalidation");
+      if (underlying.toLowerCase() !== ETH_ADDRESS_LOWERCASE) {
+        invalidateTokenAllowanceQueries(
+          {
+            chainId: tx.token.chainId,
+            tokenAddress: underlying,
+            ownerAddress: tx.account,
+            spenderAddress: tx.token.address
+          },
+          queryClient
+        );
+      }
     } else {
       console.warn("No invalidation logic for transaction action type:", tx.actionType);
     }
@@ -2971,7 +3164,7 @@ function useTrackPendingTransactions() {
 import { useCallback as useCallback2, useEffect as useEffect2, useMemo as useMemo10, useRef as useRef2 } from "react";
 
 // src/hooks/useTransactionReceiptsByHash.ts
-var import_ts_essentials6 = __toESM(require_dist(), 1);
+var import_ts_essentials7 = __toESM(require_dist(), 1);
 import { useMemo as useMemo8 } from "react";
 function useTransactionReceiptsByHash({ hashes, chainId: chainIdInput, enabled: enabledInput = true, queryOptions } = {
   enabled: true
@@ -2988,7 +3181,7 @@ function useTransactionReceiptsByHash({ hashes, chainId: chainIdInput, enabled:
         queryKey,
         enabled,
         queryFn: async () => {
-          (0, import_ts_essentials6.assert)(publicClient, "Public client is guaranteed by enabled condition");
+          (0, import_ts_essentials7.assert)(publicClient, "Public client is guaranteed by enabled condition");
           return await publicClient.getTransactionReceipt({ hash });
         },
         notifyOnChangeProps: ["data"],
@@ -3015,7 +3208,7 @@ function useTransactionReceiptsByHash({ hashes, chainId: chainIdInput, enabled:
 }
 
 // src/hooks/useTrackDecryptingTransactions.ts
-var import_ts_essentials7 = __toESM(require_dist());
+var import_ts_essentials8 = __toESM(require_dist());
 
 // src/hooks/useCofheReadDecryptionResults.ts
 import { useMemo as useMemo9 } from "react";
@@ -3154,7 +3347,7 @@ function useTrackDecryptingTransactionsBase({ onDecryptionResolve }) {
   const minedTxsWithCiphertextsToWatch = useMemo10(() => {
     return Object.entries(minedTxsPendingDecryptionByHash).filter(([, tx]) => receiptsByHash[tx.hash] !== void 0).map(([, tx]) => {
       const ciphertextToWatch = findDecryptRequestLog(tx.account, receiptsByHash[tx.hash].logs)?.ciphertext;
-      (0, import_ts_essentials7.assert)(
+      (0, import_ts_essentials8.assert)(
         ciphertextToWatch,
         "Ciphertext to watch should be found in the transaction logs if a tx that isPendingDecryption and has a receipt"
       );
@@ -3174,7 +3367,7 @@ function useTrackDecryptingTransactionsBase({ onDecryptionResolve }) {
   useEffect2(() => {
     const txsWithDecryptionResults = minedTxsWithCiphertextsToWatch.filter(({ ciphertextToWatch }) => decryptionResults[ciphertextToWatch] !== void 0).map((item) => {
       const decryptionResult = decryptionResults[item.ciphertextToWatch];
-      (0, import_ts_essentials7.assert)(decryptionResult, "decryptionResult must be defined here");
+      (0, import_ts_essentials8.assert)(decryptionResult, "decryptionResult must be defined here");
       return {
         ...item,
         decryptionResult
@@ -3269,7 +3462,7 @@ var useCofheClient = () => {
 import "@tanstack/react-query";
 import "viem";
 import "@cofhe/sdk";
-var import_ts_essentials9 = __toESM(require_dist(), 1);
+var import_ts_essentials10 = __toESM(require_dist(), 1);
 
 // src/hooks/useCofheReadContractAndDecrypt.ts
 import "@tanstack/react-query";
@@ -3278,7 +3471,7 @@ import { FheTypes as FheTypes2 } from "@cofhe/sdk";
 
 // src/hooks/useCofheDecrypt.ts
 import { CofheError as CofheError2 } from "@cofhe/sdk";
-var import_ts_essentials8 = __toESM(require_dist(), 1);
+var import_ts_essentials9 = __toESM(require_dist(), 1);
 function useCofheDecrypt({
   input,
   onPoll: onPoll2
@@ -3291,7 +3484,7 @@ function useCofheDecrypt({
     enabled,
     queryKey: ["decryptCiphertext", input?.ctHash.toString(), input?.utype],
     queryFn: async () => {
-      (0, import_ts_essentials8.assert)(input, "input is guaranteed to be defined by enabled condition");
+      (0, import_ts_essentials9.assert)(input, "input is guaranteed to be defined by enabled condition");
       const builder = client.decryptForView(input.ctHash, input.utype);
       if (onPoll2) builder.onPoll(onPoll2);
       return builder.execute();
@@ -3382,7 +3575,7 @@ function useCofheTokenDecryptedBalance({ token, accountAddress, displayDecimals
       decryptingQueryOptions: {
         refetchOnMount: false,
         select: (amountWei) => {
-          (0, import_ts_essentials9.assert)(token, "Token must be defined to format confidential balance");
+          (0, import_ts_essentials10.assert)(token, "Token must be defined to format confidential balance");
           if (typeof amountWei !== "bigint") {
             throw new Error("Expected bigint from confidential decryption");
           }
@@ -3408,7 +3601,7 @@ import "@cofhe/sdk";
 import { extractEncryptableValues, insertEncryptedValues } from "@cofhe/abi";
 
 // src/hooks/useCofheEncrypt.ts
-var import_ts_essentials10 = __toESM(require_dist(), 1);
+var import_ts_essentials11 = __toESM(require_dist(), 1);
 import {
   assertCorrectEncryptedItemInput,
   isLastEncryptionStep
@@ -3508,7 +3701,7 @@ function useCofheEncrypt(options) {
     ...options,
     mutationKey: options?.mutationKey ?? ["cofhe", "encryptInputs"],
     mutationFn: async (variables) => {
-      (0, import_ts_essentials10.assert)(client, "CoFHE client not initialized");
+      (0, import_ts_essentials11.assert)(client, "CoFHE client not initialized");
       const key = crypto.randomUUID();
       handleStepSetKey(key);
       const items = hasEncryptInputsOptions(variables) ? variables.items : variables;
@@ -3543,19 +3736,28 @@ function useCofheEncrypt(options) {
 }
 
 // src/hooks/useCofheWriteContract.ts
-var import_ts_essentials11 = __toESM(require_dist(), 1);
+var import_ts_essentials12 = __toESM(require_dist(), 1);
 function hasExtras(variables) {
   return typeof variables === "object" && variables !== null && "writeContractInput" in variables && "extras" in variables;
 }
 function useCofheWriteContract(options) {
   const walletClient = useCofheWalletClient();
+  const publicClient = useCofhePublicClient();
   const mutation = useInternalMutation({
     ...options,
     mutationKey: options?.mutationKey ?? ["cofhe", "walletWriteContract"],
     mutationFn: async (variables) => {
-      (0, import_ts_essentials11.assert)(walletClient, "WalletClient is required to write to a contract");
+      (0, import_ts_essentials12.assert)(walletClient, "WalletClient is required to write to a contract");
+      (0, import_ts_essentials12.assert)(publicClient, "PublicClient is required to simulate contract before writing");
       const writeContractInput = hasExtras(variables) ? variables.writeContractInput : variables;
-      return walletClient.writeContract(writeContractInput);
+      const accountForSimulation = writeContractInput.account ?? walletClient.account;
+      (0, import_ts_essentials12.assert)(accountForSimulation, "Wallet account is required to simulate contract before writing");
+      const { chain, ...rest } = writeContractInput;
+      const { request } = await publicClient.simulateContract({
+        ...chain ? { ...rest, chain } : rest,
+        account: accountForSimulation
+      });
+      return walletClient.writeContract({ ...request, chain: void 0 });
     }
   });
   const writeContractAsync = async (params) => mutation.mutateAsync(params);
@@ -3675,10 +3877,97 @@ function useCofheTokenTransfer(writeMutationOptions) {
   };
 }
 
+// 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 */,
+        isPendingDecryption: false,
+        account
+      });
+    }
+  });
+}
+
 // 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;
+  const confidentialityType = token.extensions.fhenix.confidentialityType;
+  if (!confidentialityType) {
+    throw new Error("confidentialityType is required in token extensions");
+  }
+  if (confidentialityType !== "dual" && confidentialityType !== "wrapped") {
+    throw new Error(`Shield not supported for confidentialityType: ${confidentialityType}`);
+  }
+  if (confidentialityType === "dual") {
+    const contractConfig = SHIELD_ABIS.dual;
+    return {
+      main: {
+        address: tokenAddress,
+        abi: contractConfig.abi,
+        functionName: contractConfig.functionName,
+        args: [amount],
+        account,
+        chain: void 0
+      }
+    };
+  }
+  const erc20PairAddress = token.extensions.fhenix.erc20Pair?.address;
+  const isEth = erc20PairAddress?.toLowerCase() === ETH_ADDRESS_LOWERCASE;
+  if (isEth) {
+    return {
+      main: {
+        address: tokenAddress,
+        abi: WRAPPED_ETH_ENCRYPT_ETH_ABI,
+        functionName: "encryptETH",
+        args: [account],
+        value: amount,
+        account,
+        chain: void 0
+      }
+    };
+  }
+  if (!erc20PairAddress) {
+    throw new Error("erc20Pair address is required for wrapped ERC20 tokens");
+  }
+  return {
+    approval: {
+      address: erc20PairAddress,
+      abi: ERC20_APPROVE_ABI,
+      functionName: "approve",
+      args: [tokenAddress, amount],
+      account,
+      chain: void 0
+    },
+    main: {
+      address: tokenAddress,
+      abi: WRAPPED_ENCRYPT_ABI,
+      functionName: "encrypt",
+      args: [account, amount],
+      account,
+      chain: void 0
+    }
+  };
+}
 function useCofheTokenShield(options) {
   const walletClient = useCofheWalletClient();
   const publicClient = useCofhePublicClient();
@@ -3691,6 +3980,9 @@ function useCofheTokenShield(options) {
       if (!walletClient) {
         throw new Error("WalletClient is required for token shield");
       }
+      if (!publicClient) {
+        throw new Error("PublicClient is required to simulate shield before writing");
+      }
       const tokenAddress = input.token.address;
       const confidentialityType = input.token.extensions.fhenix.confidentialityType;
       if (!confidentialityType) {
@@ -3707,66 +3999,39 @@ function useCofheTokenShield(options) {
         const erc20PairAddress = input.token.extensions.fhenix.erc20Pair?.address;
         const isEth = erc20PairAddress?.toLowerCase() === ETH_ADDRESS_LOWERCASE;
         if (isEth) {
-          hash = await walletClient.writeContract({
+          const { request } = await publicClient.simulateContract({
             address: tokenAddress,
             abi: WRAPPED_ETH_ENCRYPT_ETH_ABI,
             functionName: "encryptETH",
             args: [walletClient.account.address],
             value: input.amount,
-            account: walletClient.account,
-            chain: void 0
+            account: walletClient.account
           });
+          hash = await walletClient.writeContract({ ...request, chain: void 0 });
         } else {
           if (!erc20PairAddress) {
             throw new Error("erc20Pair address is required for wrapped ERC20 tokens");
           }
-          if (!publicClient) {
-            throw new Error("PublicClient is required for allowance check");
-          }
-          input.onStatusChange?.("Checking allowance...");
-          const currentAllowance = await publicClient.readContract({
-            address: erc20PairAddress,
-            abi: ERC20_ALLOWANCE_ABI,
-            functionName: "allowance",
-            args: [walletClient.account.address, tokenAddress]
-          });
-          if (currentAllowance < input.amount) {
-            input.onStatusChange?.("Approval required - please confirm in wallet...");
-            const approvalHash = await walletClient.writeContract({
-              address: erc20PairAddress,
-              abi: ERC20_APPROVE_ABI,
-              functionName: "approve",
-              args: [tokenAddress, input.amount],
-              account: walletClient.account,
-              chain: void 0
-            });
-            input.onStatusChange?.("Waiting for approval confirmation...");
-            await publicClient.waitForTransactionReceipt({ hash: approvalHash });
-            input.onStatusChange?.("Approved! Now shielding...");
-          }
           input.onStatusChange?.("Please confirm shield in wallet...");
-          hash = await walletClient.writeContract({
+          const { request: encryptRequest } = await publicClient.simulateContract({
             address: tokenAddress,
             abi: WRAPPED_ENCRYPT_ABI,
             functionName: "encrypt",
             args: [walletClient.account.address, input.amount],
-            account: walletClient.account,
-            chain: void 0
+            account: walletClient.account
           });
+          hash = await walletClient.writeContract({ ...encryptRequest, chain: void 0 });
         }
       } else {
-        const contractConfig = SHIELD_ABIS[confidentialityType];
-        if (!contractConfig) {
-          throw new Error(`Unsupported confidentialityType for shield: ${confidentialityType}`);
-        }
-        hash = await walletClient.writeContract({
+        const contractConfig = SHIELD_ABIS.dual;
+        const { request } = await publicClient.simulateContract({
           address: tokenAddress,
           abi: contractConfig.abi,
           functionName: contractConfig.functionName,
           args: [input.amount],
-          account: walletClient.account,
-          chain: void 0
+          account: walletClient.account
         });
+        hash = await walletClient.writeContract({ ...request, chain: void 0 });
       }
       return hash;
     },
@@ -3775,8 +4040,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,
@@ -3796,17 +4061,17 @@ function useCofheTokenShield(options) {
 // src/hooks/useCofheTokenUnshield.ts
 import "@tanstack/react-query";
 import "viem";
-var import_ts_essentials14 = __toESM(require_dist(), 1);
+var import_ts_essentials15 = __toESM(require_dist(), 1);
 
 // src/hooks/useStoredTransaction.ts
 import { useMemo as useMemo12 } from "react";
-var import_ts_essentials13 = __toESM(require_dist(), 1);
+var import_ts_essentials14 = __toESM(require_dist(), 1);
 function useStoredTransaction(txHash) {
   const filter3 = useMemo12(() => {
     return (tx) => tx.hash === txHash;
   }, [txHash]);
   const { filteredTxs } = useStoredTransactions({ filter: filter3 });
-  (0, import_ts_essentials13.assert)(filteredTxs.length <= 1, "There should be at most one transaction with a given hash");
+  (0, import_ts_essentials14.assert)(filteredTxs.length <= 1, "There should be at most one transaction with a given hash");
   return filteredTxs[0];
 }
 
@@ -3889,8 +4154,43 @@ function useStoredTransactionDecryptionEffect({
 }
 
 // src/hooks/useCofheTokenUnshield.ts
+function getCofheTokenUnshieldCallArgs(params) {
+  const { token, amount: rawAmount, account } = params;
+  const tokenAddress = token.address;
+  const confidentialityType = token.extensions.fhenix.confidentialityType;
+  if (!confidentialityType) {
+    throw new Error("confidentialityType is required in token extensions");
+  }
+  if (confidentialityType !== "dual" && confidentialityType !== "wrapped") {
+    throw new Error(`Unshield not supported for confidentialityType: ${confidentialityType}`);
+  }
+  const contractConfig = UNSHIELD_ABIS[confidentialityType];
+  if (!contractConfig) {
+    throw new Error(`Unsupported confidentialityType for unshield: ${confidentialityType}`);
+  }
+  if (confidentialityType === "wrapped") {
+    return {
+      address: tokenAddress,
+      abi: contractConfig.abi,
+      functionName: contractConfig.functionName,
+      args: [account, rawAmount],
+      account,
+      chain: void 0
+    };
+  }
+  const amount = BigInt.asUintN(64, rawAmount);
+  return {
+    address: tokenAddress,
+    abi: contractConfig.abi,
+    functionName: contractConfig.functionName,
+    args: [amount],
+    account,
+    chain: void 0
+  };
+}
 function useCofheTokenUnshieldMutation(options) {
   const walletClient = useCofheWalletClient();
+  const publicClient = useCofhePublicClient();
   const chainId = useCofheChainId();
   const account = useCofheAccount();
   const { onTransactionSubmitError } = useTransactionGlobalLifecycle();
@@ -3900,6 +4200,9 @@ function useCofheTokenUnshieldMutation(options) {
       if (!walletClient) {
         throw new Error("WalletClient is required for token unshield");
       }
+      if (!publicClient) {
+        throw new Error("PublicClient is required to simulate unshield before writing");
+      }
       const tokenAddress = input.token.address;
       const confidentialityType = input.token.extensions.fhenix.confidentialityType;
       if (!confidentialityType) {
@@ -3918,24 +4221,24 @@ function useCofheTokenUnshieldMutation(options) {
       let hash;
       input.onStatusChange?.("Please confirm in wallet...");
       if (confidentialityType === "wrapped") {
-        hash = await walletClient.writeContract({
+        const { request } = await publicClient.simulateContract({
           address: tokenAddress,
           abi: contractConfig.abi,
           functionName: contractConfig.functionName,
           args: [walletClient.account.address, input.amount],
-          account: walletClient.account,
-          chain: void 0
+          account: walletClient.account
         });
+        hash = await walletClient.writeContract({ ...request, chain: void 0 });
       } else {
         const amount = BigInt.asUintN(64, input.amount);
-        hash = await walletClient.writeContract({
+        const { request } = await publicClient.simulateContract({
           address: tokenAddress,
           abi: contractConfig.abi,
           functionName: contractConfig.functionName,
           args: [amount],
-          account: walletClient.account,
-          chain: void 0
+          account: walletClient.account
         });
+        hash = await walletClient.writeContract({ ...request, chain: void 0 });
       }
       return hash;
     },
@@ -3944,8 +4247,8 @@ function useCofheTokenUnshieldMutation(options) {
       onTransactionSubmitError(error, "unshield" /* Unshield */);
     },
     onSuccess: async (hash, input, onMutateResult, context) => {
-      (0, import_ts_essentials14.assert)(chainId, "Chain ID is required for token unshield");
-      (0, import_ts_essentials14.assert)(account, "Wallet account is required for token unshield");
+      (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");
       if (onSuccess) await onSuccess(hash, input, onMutateResult, context);
       useTransactionStore.getState().addTransaction({
         hash,
@@ -3985,9 +4288,33 @@ function useCofheTokenUnshield(input) {
 // src/hooks/useCofheTokenClaimUnshielded.ts
 import "@tanstack/react-query";
 import "viem";
-var import_ts_essentials15 = __toESM(require_dist(), 1);
+var import_ts_essentials16 = __toESM(require_dist(), 1);
+function getCofheTokenClaimUnshieldedCallArgs(params) {
+  const { token, account } = params;
+  const tokenAddress = token.address;
+  const confidentialityType = token.extensions.fhenix.confidentialityType;
+  if (!confidentialityType) {
+    throw new Error("confidentialityType is required in token extensions");
+  }
+  if (confidentialityType !== "dual" && confidentialityType !== "wrapped") {
+    throw new Error(`Claim not supported for confidentialityType: ${confidentialityType}`);
+  }
+  const contractConfig = CLAIM_ABIS[confidentialityType];
+  if (!contractConfig) {
+    throw new Error(`Unsupported confidentialityType for claim: ${confidentialityType}`);
+  }
+  return {
+    address: tokenAddress,
+    abi: contractConfig.abi,
+    functionName: contractConfig.functionName,
+    args: [],
+    account,
+    chain: void 0
+  };
+}
 function useCofheTokenClaimUnshielded(options) {
   const walletClient = useCofheWalletClient();
+  const publicClient = useCofhePublicClient();
   const chainId = useCofheChainId();
   const account = useCofheAccount();
   const { onSuccess, onError, ...restOfOptions } = options || {};
@@ -3997,6 +4324,9 @@ function useCofheTokenClaimUnshielded(options) {
       if (!walletClient) {
         throw new Error("WalletClient is required for claim");
       }
+      if (!publicClient) {
+        throw new Error("PublicClient is required to simulate claim before writing");
+      }
       const tokenAddress = input.token.address;
       const confidentialityType = input.token.extensions.fhenix.confidentialityType;
       if (!confidentialityType) {
@@ -4012,23 +4342,22 @@ function useCofheTokenClaimUnshielded(options) {
       if (!contractConfig) {
         throw new Error(`Unsupported confidentialityType for claim: ${confidentialityType}`);
       }
-      const hash = await walletClient.writeContract({
+      const { request } = await publicClient.simulateContract({
         address: tokenAddress,
         abi: contractConfig.abi,
         functionName: contractConfig.functionName,
         args: [],
-        account: walletClient.account,
-        chain: void 0
+        account: walletClient.account
       });
-      return hash;
+      return await walletClient.writeContract({ ...request, chain: void 0 });
     },
     onError: (error, variables, onMutateResult, context) => {
       if (onError) onError(error, variables, onMutateResult, context);
       onTransactionSubmitError(error, "claim" /* Claim */);
     },
     onSuccess: async (hash, input, onMutateResult, context) => {
-      (0, import_ts_essentials15.assert)(chainId, "Chain ID is required for claim");
-      (0, import_ts_essentials15.assert)(account, "Wallet account is required for claim");
+      (0, import_ts_essentials16.assert)(chainId, "Chain ID is required for claim");
+      (0, import_ts_essentials16.assert)(account, "Wallet account is required for claim");
       if (onSuccess) await onSuccess(hash, input, onMutateResult, context);
       useTransactionStore.getState().addTransaction({
         hash,
@@ -4046,7 +4375,7 @@ function useCofheTokenClaimUnshielded(options) {
 }
 
 // src/hooks/useCofheTokensClaimable.ts
-var import_ts_essentials17 = __toESM(require_dist(), 1);
+var import_ts_essentials18 = __toESM(require_dist(), 1);
 import "@tanstack/react-query";
 import { useMemo as useMemo15 } from "react";
 import "viem";
@@ -4078,7 +4407,7 @@ function useNormalizedList(items, options) {
 }
 
 // src/hooks/useIsWaitingForDecryptionByAddress.ts
-var import_ts_essentials16 = __toESM(require_dist(), 1);
+var import_ts_essentials17 = __toESM(require_dist(), 1);
 import { useMemo as useMemo14 } from "react";
 import { isAddress } from "viem";
 function useIsWaitingForDecryptionByAddress(entries) {
@@ -4086,7 +4415,7 @@ function useIsWaitingForDecryptionByAddress(entries) {
   return useMemo14(() => {
     const map = {};
     for (const entry of entries) {
-      (0, import_ts_essentials16.assert)(isAddress(entry.address), "address is valid");
+      (0, import_ts_essentials17.assert)(isAddress(entry.address), "address is valid");
       map[entry.address] = awaitingDecryptionKeySet.has(JSON.stringify(entry.queryKey));
     }
     return map;
@@ -4163,12 +4492,12 @@ function useCofheTokensClaimable({ tokens, accountAddress: account }, queryOptio
           signal,
           queryKey: queryKey2
         }) => {
-          (0, import_ts_essentials17.assert)(
+          (0, import_ts_essentials18.assert)(
             isTokenConfidentialityTypeClaimable(confidentialityType),
             "confidentialityType narrowed by token guard"
           );
-          (0, import_ts_essentials17.assert)(account, "account is required to fetch unshield claims");
-          (0, import_ts_essentials17.assert)(publicClient, "publicClient is required to fetch unshield claims");
+          (0, import_ts_essentials18.assert)(account, "account is required to fetch unshield claims");
+          (0, import_ts_essentials18.assert)(publicClient, "publicClient is required to fetch unshield claims");
           return fetchUnshieldClaimsSummary({
             publicClient,
             token,
@@ -4232,29 +4561,17 @@ function useCofheTokensClaimable({ tokens, accountAddress: account }, queryOptio
 import { useMemo as useMemo16 } from "react";
 
 // src/hooks/useCofheReadContracts.ts
-var import_ts_essentials18 = __toESM(require_dist(), 1);
+var import_ts_essentials19 = __toESM(require_dist(), 1);
 import "@tanstack/react-query";
 import { transformEncryptedReturnTypes as transformEncryptedReturnTypes2 } from "@cofhe/abi";
 var QUERY_CACHE_PREFIX2 = "cofheReadContracts";
-function serializeIfBigint2(value) {
-  if (typeof value === "bigint") {
-    return value.toString();
-  }
-}
-function serializeBigintRecursively2(value) {
-  if (Array.isArray(value)) {
-    return value.map(serializeBigintRecursively2);
-  } else {
-    return serializeIfBigint2(value);
-  }
-}
 function constructCofheReadContractsQueryKey(params) {
   const { cofheChainId, contracts, allowFailure, enabled } = params;
   const serializedContracts = (contracts ?? []).map((contract) => {
     return {
       address: contract.address,
       functionName: contract.functionName,
-      args: Array.isArray(contract.args) ? serializeBigintRecursively2(contract.args) : contract.args,
+      args: Array.isArray(contract.args) ? serializeBigintRecursively(contract.args) : contract.args,
       abi: contract.abi
     };
   });
@@ -4293,8 +4610,8 @@ function useCofheReadContracts(params, queryOptions) {
       enabled
     }),
     queryFn: async () => {
-      (0, import_ts_essentials18.assert)(publicClient, "PublicClient should be guaranteed by enabled check");
-      (0, import_ts_essentials18.assert)(contracts && contracts.length > 0, "Contracts should be guaranteed by enabled check");
+      (0, import_ts_essentials19.assert)(publicClient, "PublicClient should be guaranteed by enabled check");
+      (0, import_ts_essentials19.assert)(contracts && contracts.length > 0, "Contracts should be guaranteed by enabled check");
       const raw = await publicClient.multicall({
         contracts,
         ...multicallOptions || {}
@@ -4473,6 +4790,69 @@ function useTokensWithPublicBalances({ chainId: _chainId, accountAddress, displa
   };
 }
 
+// src/hooks/useCofheSimulateWriteContract.ts
+var import_ts_essentials20 = __toESM(require_dist(), 1);
+var QUERY_CACHE_PREFIX3 = "cofheSimulateWriteContract";
+function isRecord2(value) {
+  return typeof value === "object" && value !== null;
+}
+function hasAddress(value) {
+  return "address" in value && typeof value.address === "string";
+}
+function getAccountAddress(account) {
+  if (!account) return void 0;
+  if (typeof account === "string") return account;
+  if (typeof account === "object" && hasAddress(account)) return account.address;
+  return void 0;
+}
+function constructCofheSimulateWriteContractQueryKey(params) {
+  const { cofheChainId, callArgs, resolvedAccountAddress, enabled } = params;
+  const serialized = isRecord2(callArgs) ? {
+    address: typeof callArgs.address === "string" ? callArgs.address : void 0,
+    functionName: typeof callArgs.functionName === "string" ? callArgs.functionName : void 0,
+    args: Array.isArray(callArgs.args) ? serializeBigintRecursively(callArgs.args) : void 0,
+    value: serializeIfBigint(callArgs.value),
+    dataSuffix: typeof callArgs.dataSuffix === "string" ? callArgs.dataSuffix : void 0,
+    account: resolvedAccountAddress
+  } : void 0;
+  return [QUERY_CACHE_PREFIX3, cofheChainId, serialized, enabled];
+}
+function useCofheSimulateWriteContract(callArgs, queryOptions) {
+  const walletClient = useCofheWalletClient();
+  const publicClient = useCofhePublicClient();
+  const cofheChainId = useCofheChainId();
+  const isCofheErrorActive = useIsCofheErrorActive();
+  const { enabled: userEnabled, ...restQueryOptions } = queryOptions || {};
+  const resolvedAccountAddress = getAccountAddress(callArgs?.account ?? walletClient?.account);
+  const enabled = !isCofheErrorActive && !!publicClient && !!walletClient && !!callArgs && !!resolvedAccountAddress && (userEnabled ?? true);
+  return useInternalQuery({
+    enabled,
+    queryKey: constructCofheSimulateWriteContractQueryKey({
+      cofheChainId,
+      callArgs,
+      resolvedAccountAddress,
+      enabled
+    }),
+    retry: false,
+    // no need to retry on error. The whole point of simulation is to check if there's an error
+    queryFn: async () => {
+      (0, import_ts_essentials20.assert)(publicClient, "PublicClient is required to simulate contract");
+      (0, import_ts_essentials20.assert)(walletClient, "WalletClient is required to simulate contract");
+      (0, import_ts_essentials20.assert)(callArgs, "callArgs is guaranteed to be defined by enabled condition");
+      const accountForSimulation = callArgs.account ?? walletClient.account;
+      (0, import_ts_essentials20.assert)(accountForSimulation, "Wallet account is required to simulate contract");
+      const simulateArgs = {
+        ...callArgs,
+        account: accountForSimulation
+      };
+      return publicClient.simulateContract(
+        simulateArgs
+      );
+    },
+    ...restQueryOptions
+  });
+}
+
 // src/hooks/permits/usePermitDuration.ts
 import { useState as useState3, useCallback as useCallback4, useMemo as useMemo18 } from "react";
 function usePermitDuration(options) {
@@ -5744,7 +6124,7 @@ var StatusBarContent = () => {
 };
 
 // src/components/FnxFloatingButton/ContentSection.tsx
-import { useEffect as useEffect12, useMemo as useMemo32, useRef as useRef8 } from "react";
+import { useEffect as useEffect12, useMemo as useMemo33, useRef as useRef8 } from "react";
 
 // src/components/FnxFloatingButton/pages/MainPage/WalletHeader.tsx
 import { MdOutlineAccountBalanceWallet } from "react-icons/md";
@@ -6090,7 +6470,7 @@ import { IoMdKey } from "react-icons/io";
 import { AiOutlinePieChart } from "react-icons/ai";
 import { TbShieldPlus as TbShieldPlus2 } from "react-icons/tb";
 import { FaBug } from "react-icons/fa";
-var import_ts_essentials19 = __toESM(require_dist(), 1);
+var import_ts_essentials21 = __toESM(require_dist(), 1);
 
 // src/components/FnxFloatingButton/components/ActionButton.tsx
 import { jsx as jsx22, jsxs as jsxs12 } from "react/jsx-runtime";
@@ -6379,6 +6759,8 @@ var ActionIcon = ({ actionType }) => {
       return /* @__PURE__ */ jsx27(TbShieldMinus, { className: iconClassName2 });
     case "claim" /* Claim */:
       return /* @__PURE__ */ jsx27(TbShieldCheck, { className: iconClassName2 });
+    case "approve" /* Approve */:
+      return /* @__PURE__ */ jsx27(GoArrowUpRight, { className: iconClassName2 });
     default:
       return /* @__PURE__ */ jsx27(GoArrowUpRight, { className: iconClassName2 });
   }
@@ -6475,12 +6857,12 @@ var BottomNavigation = () => {
       return;
     }
     if (page === "send" /* Send */) {
-      (0, import_ts_essentials19.assert)(defaultToken, "No pinned token available for Send page");
+      (0, import_ts_essentials21.assert)(defaultToken, "No pinned token available for Send page");
       navigateTo("send" /* Send */, { pageProps: { token: defaultToken } });
       return;
     }
     if (page === "shield" /* Shield */) {
-      (0, import_ts_essentials19.assert)(defaultToken, "No pinned token available for Shield page");
+      (0, import_ts_essentials21.assert)(defaultToken, "No pinned token available for Shield page");
       navigateTo("shield" /* Shield */, { pageProps: { token: defaultToken } });
       return;
     }
@@ -7621,7 +8003,7 @@ import { useState as useState10, useMemo as useMemo30 } from "react";
 import ArrowBackIcon7 from "@mui/icons-material/ArrowBack";
 import KeyboardArrowRightIcon2 from "@mui/icons-material/KeyboardArrowRight";
 import { isAddress as isAddress2, maxUint128 } from "viem";
-var import_ts_essentials20 = __toESM(require_dist(), 1);
+var import_ts_essentials22 = __toESM(require_dist(), 1);
 import { Fragment as Fragment9, jsx as jsx48, jsxs as jsxs33 } from "react/jsx-runtime";
 var SendPage = ({ token: _token }) => {
   const [overriddenToken, setOverriddenToken] = useState10(null);
@@ -7640,7 +8022,7 @@ var SendPage = ({ token: _token }) => {
     }
   } = useCofheTokenTransfer({
     onError: (error2) => {
-      const errorMessage = error2 instanceof Error ? error2.message : "Failed to send tokens";
+      const errorMessage = cofheHumanizeViemError(error2) ?? (error2 instanceof Error ? error2.message : "Failed to send tokens");
       setError(errorMessage);
       console.error("Send tx submit error:", error2);
     },
@@ -7676,10 +8058,10 @@ var SendPage = ({ token: _token }) => {
   const isValidAddress2 = isAddress2(recipientAddress);
   const isValidAmount = (amount.length > 0 && confidentialUnitBalance && confidentialUnitBalance.gte(amount)) ?? false;
   const handleSend = async () => {
-    (0, import_ts_essentials20.assert)(isAddress2(recipientAddress), "Recipient address is not valid");
+    (0, import_ts_essentials22.assert)(isAddress2(recipientAddress), "Recipient address is not valid");
     const amountWei = unitToWei(amount, token.decimals);
-    (0, import_ts_essentials20.assert)(amountWei <= maxUint128, "Amount exceeds maximum supported value (uint128 max)");
-    (0, import_ts_essentials20.assert)(account, "Sender account is required");
+    (0, import_ts_essentials22.assert)(amountWei <= maxUint128, "Amount exceeds maximum supported value (uint128 max)");
+    (0, import_ts_essentials22.assert)(account, "Sender account is required");
     await encryptAmountAndSendToken({
       input: {
         token,
@@ -7693,6 +8075,7 @@ var SendPage = ({ token: _token }) => {
     if (confidentialUnitBalance) setAmount(confidentialUnitBalance.toFixed());
   };
   const { tokensWithExistingEncryptedBalance } = useCofheTokensWithExistingEncryptedBalances();
+  const disabled = !isValidAddress2 || !isValidAmount || isSending || isEncryptingInput;
   return /* @__PURE__ */ jsx48(
     PageContainer,
     {
@@ -7799,11 +8182,11 @@ var SendPage = ({ token: _token }) => {
         "button",
         {
           onClick: handleSend,
-          disabled: !isValidAddress2 || !isValidAmount || isSending || isEncryptingInput,
+          disabled,
           className: cn(
             "fnx-send-button w-full py-3 px-4 font-small",
             "flex items-center justify-center gap-2",
-            isValidAddress2 && isValidAmount && !isSending && !isEncryptingInput ? "fnx-send-button-enabled" : "fnx-send-button-disabled"
+            disabled ? "fnx-send-button-disabled" : "fnx-send-button-enabled"
           ),
           children: [
             /* @__PURE__ */ jsx48("span", { children: "Send" }),
@@ -7820,9 +8203,9 @@ import ArrowBackIcon8 from "@mui/icons-material/ArrowBack";
 import KeyboardArrowDownIcon from "@mui/icons-material/KeyboardArrowDown";
 import { TbShieldPlus as TbShieldPlus3, TbShieldMinus as TbShieldMinus2 } from "react-icons/tb";
 import { LuExternalLink as LuExternalLink2 } from "react-icons/lu";
-import { useState as useState11 } from "react";
-import { parseUnits } from "viem";
-var import_ts_essentials21 = __toESM(require_dist(), 1);
+import { useMemo as useMemo31, useState as useState11 } from "react";
+import { ContractFunctionExecutionError as ContractFunctionExecutionError3, parseUnits } from "viem";
+var import_ts_essentials23 = __toESM(require_dist(), 1);
 
 // src/hooks/useIsUnshieldingMining.ts
 import { useCallback as useCallback13 } from "react";
@@ -7856,6 +8239,13 @@ function useLifecycleStore() {
     setStatus
   };
 }
+function humanizeSimulationError(error, fallbackMessage) {
+  if (!error) return null;
+  const cofheErrorMessage = cofheHumanizeViemError(error);
+  if (cofheErrorMessage) return cofheErrorMessage;
+  if (error instanceof ContractFunctionExecutionError3) return error.shortMessage;
+  return fallbackMessage;
+}
 function TxHashWithActions({ hash, chainId }) {
   const href = chainId ? getBlockExplorerTxUrl(chainId, hash) : void 0;
   const ellipsed = truncateHash(hash);
@@ -7904,7 +8294,7 @@ function useClaimUnshieldedWithLifecycle() {
       });
     },
     onError: (error2) => {
-      const errorMessage = error2 instanceof Error ? error2.message : "Failed to claim unshielded tokens";
+      const errorMessage = cofheHumanizeViemError(error2) ?? (error2 instanceof Error ? error2.message : "Failed to claim unshielded tokens");
       setError(errorMessage);
       setStatus(null);
       console.error("Claim tx submit error:", error2);
@@ -7963,12 +8353,18 @@ function useShieldWithLifecycle(token) {
       setShieldAmount("");
     },
     onError: (error2) => {
-      const errorMessage = error2 instanceof Error ? error2.message : "Failed to shield tokens";
+      const errorMessage = cofheHumanizeViemError(error2) ?? (error2 instanceof Error ? error2.message : "Failed to shield tokens");
       setError(errorMessage);
       setStatus(null);
       console.error("Shield tx submit error:", error2);
     }
   });
+  const { tokenApprove, isApprovingMining } = useApproveWithLifecycle({
+    chainId,
+    setError,
+    setStatus,
+    scheduleStatusClear
+  });
   const { isMining: isTokenShieldMining } = useOnceTransactionMined({
     txHash: tokenShield.data,
     onceMined: (transaction) => {
@@ -8000,6 +8396,15 @@ function useShieldWithLifecycle(token) {
       onStatusChange: (message) => setStatus({ message, type: "info" })
     });
   };
+  const handleApprove = async () => {
+    (0, import_ts_essentials23.assert)(approvalCallArgs, "Approval call args are required to approve");
+    (0, import_ts_essentials23.assert)(shieldAmountWei, "Shield amount is required to approve");
+    (0, import_ts_essentials23.assert)(account, "Wallet account is required to approve");
+    await tokenApprove.writeContractAsync({
+      writeContractInput: { ...approvalCallArgs, account: account ?? null, chain: void 0 },
+      extras: { token, tokenAmount: shieldAmountWei, account }
+    });
+  };
   const { data: { unit: publicBalanceUnit } = {}, isFetching: isFetchingPublic } = useCofheTokenPublicBalance({
     token,
     accountAddress: account
@@ -8009,20 +8414,66 @@ function useShieldWithLifecycle(token) {
     if (publicBalanceUnit) setShieldAmount(publicBalanceUnit.toFixed());
   };
   const isValidShieldAmount = (shieldAmount.length > 0 && publicBalanceUnit?.gte(shieldAmount)) ?? false;
+  const shieldAmountWei = useMemo31(() => {
+    if (!isValidShieldAmount) return void 0;
+    try {
+      return unitToWei(shieldAmount, token.decimals);
+    } catch {
+      return void 0;
+    }
+  }, [isValidShieldAmount, shieldAmount, token.decimals]);
+  const shieldTxCallArgs = useMemo31(() => {
+    if (!account || !shieldAmountWei) return void 0;
+    return getCofheTokenShieldCallArgs({ token, amount: shieldAmountWei, account });
+  }, [account, shieldAmountWei, token]);
+  const shieldCallArgs = shieldTxCallArgs?.main;
+  const approvalCallArgs = shieldTxCallArgs?.approval;
+  const approvalSpender = approvalCallArgs?.args?.[0] ?? void 0;
+  const { data: allowanceWei, isFetching: isFetchingAllowance } = useTokenAllowance(
+    {
+      tokenAddress: approvalCallArgs?.address,
+      ownerAddress: account,
+      spenderAddress: approvalSpender
+    },
+    {
+      enabled: !!approvalCallArgs && !!account && !!approvalSpender && !!shieldAmountWei
+    }
+  );
+  const requiresApproval = !!approvalCallArgs;
+  const isAllowanceKnown = !requiresApproval || typeof allowanceWei === "bigint";
+  const hasSufficientAllowance = !requiresApproval || typeof allowanceWei === "bigint" && typeof shieldAmountWei === "bigint" && allowanceWei >= shieldAmountWei;
+  const shouldApprove = requiresApproval && typeof allowanceWei === "bigint" && typeof shieldAmountWei === "bigint" && allowanceWei < shieldAmountWei;
+  const approvalSimulation = useCofheSimulateWriteContract(approvalCallArgs, {
+    enabled: shouldApprove
+  });
+  const shieldSimulation = useCofheSimulateWriteContract(shieldCallArgs, {
+    enabled: !!shieldCallArgs && !shouldApprove
+  });
+  const simulationError = useMemo31(() => {
+    const relevantError = shouldApprove ? approvalSimulation.error : shieldSimulation.error;
+    if (!relevantError) return null;
+    const cofheErrorMessage = cofheHumanizeViemError(relevantError);
+    if (cofheErrorMessage) return cofheErrorMessage;
+    if (relevantError instanceof ContractFunctionExecutionError3) return relevantError.shortMessage;
+    return shouldApprove ? "Failed to simulate approval transaction" : "Failed to simulate shield transaction";
+  }, [approvalSimulation.error, shieldSimulation.error, shouldApprove]);
+  const canShield = isValidShieldAmount && !!shieldCallArgs && isAllowanceKnown && hasSufficientAllowance && !shieldSimulation.isFetching && !shieldSimulation.error;
+  const canApprove = isValidShieldAmount && shouldApprove && !isFetchingAllowance && !approvalSimulation.isFetching && !approvalSimulation.error;
+  const canWrite = shouldApprove ? canApprove : canShield;
   return {
     status,
-    error,
-    isProcessing: tokenShield.isPending || isTokenShieldMining,
+    error: error ?? simulationError,
+    isProcessing: tokenShield.isPending || isTokenShieldMining || tokenApprove.isPending || isApprovingMining,
     inputAmount: shieldAmount,
     setInputAmount: setShieldAmount,
     onMaxClick: handleShieldMax,
-    isValidAmount: isValidShieldAmount,
+    canWriteContract: canWrite,
     sourceSymbol: token.extensions.fhenix.erc20Pair?.symbol,
     destSymbol: token.symbol,
     sourceLogoURI: token.extensions.fhenix.erc20Pair?.logoURI,
     destLogoURI: token.logoURI,
-    handlePrimaryAction: handleShield,
-    primaryLabel: "Shield",
+    handlePrimaryAction: shouldApprove ? handleApprove : handleShield,
+    primaryLabel: shouldApprove ? "Approve" : "Shield",
     primaryIcon: /* @__PURE__ */ jsx49(TbShieldPlus3, { className: "w-3 h-3" })
   };
 }
@@ -8051,7 +8502,7 @@ function useUnshieldWithLifecycle(token) {
       setUnshieldAmount("");
     },
     onTransactionSubmitError: (error2) => {
-      const errorMessage = error2 instanceof Error ? error2.message : "Failed to unshield tokens";
+      const errorMessage = cofheHumanizeViemError(error2) ?? (error2 instanceof Error ? error2.message : "Failed to unshield tokens");
       setError(errorMessage);
       setStatus(null);
       console.error("Unshield tx submit error:", error2);
@@ -8082,10 +8533,10 @@ function useUnshieldWithLifecycle(token) {
     }
   });
   const handleUnshield = async () => {
-    const amountInSmallestUnit = parseUnits(unshieldAmount, token.decimals);
+    const amountWei = parseUnits(unshieldAmount, token.decimals);
     tokenUnshield.mutateAsync({
       token,
-      amount: amountInSmallestUnit,
+      amount: amountWei,
       onStatusChange: (message) => setStatus({ message, type: "info" })
     });
   };
@@ -8094,14 +8545,27 @@ function useUnshieldWithLifecycle(token) {
     if (confidentialBalanceUnit) setUnshieldAmount(confidentialBalanceUnit.toFixed());
   };
   const isValidUnshieldAmount = (unshieldAmount.length > 0 && confidentialBalanceUnit?.gte(unshieldAmount)) ?? false;
+  const unshieldCallArgs = useMemo31(() => {
+    if (!account || !isValidUnshieldAmount) return void 0;
+    const amountWei = parseUnits(unshieldAmount, token.decimals);
+    return getCofheTokenUnshieldCallArgs({ token, amount: amountWei, account });
+  }, [account, isValidUnshieldAmount, token, unshieldAmount]);
+  const unshieldSimulation = useCofheSimulateWriteContract(unshieldCallArgs, {
+    enabled: !!unshieldCallArgs
+  });
+  const simulationError = useMemo31(
+    () => humanizeSimulationError(unshieldSimulation.error, "Failed to simulate unshield transaction"),
+    [unshieldSimulation.error]
+  );
+  const canUnshield = isValidUnshieldAmount && !!unshieldCallArgs && !unshieldSimulation.isFetching && !unshieldSimulation.error;
   return {
     status,
-    error,
+    error: error ?? simulationError,
     isProcessing: tokenUnshield.isPending || tokenUnshield.isTokenUnshieldMining || tokenUnshield.isPendingDecryption,
     inputAmount: unshieldAmount,
     setInputAmount: setUnshieldAmount,
     onMaxClick: handleUnshieldMax,
-    isValidAmount: isValidUnshieldAmount ?? false,
+    canWriteContract: canUnshield,
     sourceSymbol: token.symbol,
     destSymbol: token.extensions.fhenix.erc20Pair?.symbol,
     sourceLogoURI: token.logoURI,
@@ -8154,19 +8618,30 @@ function ClaimingSection({ token }) {
   } = useClaimUnshieldedWithLifecycle();
   const pairedSymbol = token.extensions.fhenix.erc20Pair?.symbol;
   const handleClaim = async () => {
-    (0, import_ts_essentials21.assert)(unshieldedClaims, "Unshield claims data is required to claim unshielded tokens");
+    (0, import_ts_essentials23.assert)(unshieldedClaims, "Unshield claims data is required to claim unshielded tokens");
     claimUnshield.mutateAsync({
       token,
       amount: unshieldedClaims.claimableAmount
     });
   };
   const isUnshieldingMining = useIsUnshieldingMining(token);
+  const claimCallArgs = useMemo31(() => {
+    if (!account || !unshieldedClaims?.hasClaimable) return void 0;
+    return getCofheTokenClaimUnshieldedCallArgs({ token, account });
+  }, [account, token, unshieldedClaims?.hasClaimable]);
+  const claimSimulation = useCofheSimulateWriteContract(claimCallArgs, {
+    enabled: !!claimCallArgs
+  });
+  const claimSimulationError = useMemo31(
+    () => humanizeSimulationError(claimSimulation.error, "Failed to simulate claim transaction"),
+    [claimSimulation.error]
+  );
   return /* @__PURE__ */ jsxs34(Fragment10, { children: [
     unshieldedClaims?.hasClaimable && /* @__PURE__ */ jsx49(
       ActionButton,
       {
         onClick: handleClaim,
-        disabled: claimUnshield.isPending || isClaimingMining || isFetchingClaims || isWaitingForNewClaimsDecryption || isUnshieldingMining,
+        disabled: claimUnshield.isPending || isClaimingMining || isFetchingClaims || isWaitingForNewClaimsDecryption || isUnshieldingMining || !claimCallArgs || claimSimulation.isFetching || !!claimSimulation.error,
         label: claimUnshield.isPending ? "Claiming..." : `Claim ${isFetchingClaims || isWaitingForNewClaimsDecryption ? "..." : formatTokenAmount(unshieldedClaims.claimableAmount, token.decimals, 5).formatted} ${pairedSymbol}`,
         className: "mt-1"
       }
@@ -8177,7 +8652,7 @@ function ClaimingSection({ token }) {
       " ",
       pairedSymbol
     ] }),
-    /* @__PURE__ */ jsx49(StatusAndError, { status: claimingStatus, error: claimingError })
+    /* @__PURE__ */ jsx49(StatusAndError, { status: claimingStatus, error: claimingError ?? claimSimulationError })
   ] });
 }
 function StatusAndError({ status, error }) {
@@ -8215,7 +8690,7 @@ var ShieldAndUnshieldPageView = ({
   inputAmount,
   setInputAmount,
   onMaxClick,
-  isValidAmount,
+  canWriteContract,
   sourceSymbol,
   destSymbol,
   sourceLogoURI,
@@ -8332,7 +8807,7 @@ var ShieldAndUnshieldPageView = ({
           ActionButton,
           {
             onClick: handlePrimaryAction,
-            disabled: !isValidAmount || isProcessing || !isShieldableToken,
+            disabled: !canWriteContract || isProcessing || !isShieldableToken,
             icon: primaryIcon,
             label: primaryLabel,
             className: "py-2"
@@ -8345,6 +8820,62 @@ var ShieldAndUnshieldPageView = ({
     }
   );
 };
+function useApproveWithLifecycle({
+  chainId,
+  setError,
+  setStatus,
+  scheduleStatusClear
+}) {
+  const tokenApprove = useCofheTokenApprove({
+    onMutate: () => {
+      setError(null);
+      setStatus({ message: "Preparing approval transaction...", type: "info" });
+    },
+    onSuccess: (hash, variables) => {
+      setStatus({
+        message: /* @__PURE__ */ jsxs34(Fragment10, { children: [
+          "Approval transaction sent! Hash: ",
+          /* @__PURE__ */ jsx49(TxHashWithActions, { hash, chainId }),
+          " Waiting for confirmation..."
+        ] }),
+        type: "info"
+      });
+    },
+    onError: (error) => {
+      const errorMessage = cofheHumanizeViemError(error) ?? (error instanceof Error ? error.message : "Failed to approve tokens");
+      setError(errorMessage);
+      setStatus(null);
+      console.error("Approve tx submit error:", error);
+    }
+  });
+  const { isMining: isApprovingMining } = useOnceTransactionMined({
+    txHash: tokenApprove.data,
+    onceMined: async (transaction) => {
+      if (transaction.status === "confirmed") {
+        setStatus({
+          message: /* @__PURE__ */ jsxs34(Fragment10, { children: [
+            "Approval transaction confirmed! Hash: ",
+            /* @__PURE__ */ jsx49(TxHashWithActions, { hash: transaction.hash, chainId })
+          ] }),
+          type: "success"
+        });
+      } else if (transaction.status === "failed") {
+        setError(
+          /* @__PURE__ */ jsxs34(Fragment10, { children: [
+            "Approval transaction failed! Hash: ",
+            /* @__PURE__ */ jsx49(TxHashWithActions, { hash: transaction.hash, chainId })
+          ] })
+        );
+        setStatus(null);
+      }
+      scheduleStatusClear();
+    }
+  });
+  return {
+    tokenApprove,
+    isApprovingMining
+  };
+}
 
 // src/components/FnxFloatingButton/pages/ActivityPage.tsx
 import ArrowBackIcon9 from "@mui/icons-material/ArrowBack";
@@ -8969,8 +9500,8 @@ var PortfolioPage = () => {
 
 // src/components/FnxFloatingButton/pages/ClaimableTokens.tsx
 import ArrowBackIcon13 from "@mui/icons-material/ArrowBack";
-import { useMemo as useMemo31 } from "react";
-var import_ts_essentials22 = __toESM(require_dist(), 1);
+import { useMemo as useMemo32 } from "react";
+var import_ts_essentials24 = __toESM(require_dist(), 1);
 import { jsx as jsx55, jsxs as jsxs40 } from "react/jsx-runtime";
 function ClaimableTokens() {
   const chainsClaimableTokens = useCofheClaimableTokens();
@@ -8982,7 +9513,7 @@ function ClaimableTokens() {
   const chainId = useCofheChainId();
   const allTokens = useCofheTokens(chainId);
   const claimMutation = useCofheTokenClaimUnshielded();
-  const rows = useMemo31(() => {
+  const rows = useMemo32(() => {
     const byLower = new Map(allTokens.map((t) => [t.address.toLowerCase(), t]));
     return Object.entries(claimableByTokenAddress).filter(([_t, amount]) => amount > 0n).map(([tokenAddress, claimableAmount]) => {
       const token = byLower.get(tokenAddress.toLowerCase());
@@ -8991,7 +9522,7 @@ function ClaimableTokens() {
   }, [allTokens, claimableByTokenAddress]);
   const handleClaim = async (tokenAddress) => {
     const row = rows.find((r) => r.token.address.toLowerCase() === tokenAddress.toLowerCase());
-    (0, import_ts_essentials22.assert)(row, "token not found for claim");
+    (0, import_ts_essentials24.assert)(row, "token not found for claim");
     await claimMutation.mutateAsync({ token: row.token, amount: row.claimableAmount });
   };
   return /* @__PURE__ */ jsx55(
@@ -9376,7 +9907,7 @@ var MeasuredContentRenderer = ({ children, id, isModal, onModalOverlayClick }) =
   ] });
 };
 var ContentRenderer = ({ page }) => {
-  const content = useMemo32(() => {
+  const content = useMemo33(() => {
     const PageComp = pages[page.page];
     const props = page.props ?? {};
     return /* @__PURE__ */ jsx62(PageComp, { ...props });
@@ -9384,7 +9915,7 @@ var ContentRenderer = ({ page }) => {
   return /* @__PURE__ */ jsx62(MeasuredContentRenderer, { id: "content", children: content });
 };
 var ModalRenderer = ({ modal }) => {
-  const content = useMemo32(() => {
+  const content = useMemo33(() => {
     const ModalComp = modals[modal.modal];
     return /* @__PURE__ */ jsx62(ModalComp, { ...modal });
   }, [modal]);
@@ -9597,21 +10128,21 @@ function createCofheConfig(config) {
 }
 
 // src/providers/CofheProvider.tsx
-var import_ts_essentials23 = __toESM(require_dist(), 1);
+var import_ts_essentials25 = __toESM(require_dist(), 1);
 import { chains } from "@cofhe/sdk/chains";
 import { jsx as jsx66, jsxs as jsxs51 } from "react/jsx-runtime";
 var CofheContext = createContext4(void 0);
 function CofheProvider(props) {
   const { children, queryClient, publicClient, walletClient } = props;
-  const config = useMemo33(() => {
+  const config = useMemo34(() => {
     if (props.config) return props.config;
     if (props.cofheClient) {
-      (0, import_ts_essentials23.assert)(config.environment === "react", "Provided cofheClient must have react config");
+      (0, import_ts_essentials25.assert)(config.environment === "react", "Provided cofheClient must have react config");
       return props.cofheClient.config;
     }
     return createCofheConfig({ supportedChains: Object.values(chains) });
   }, [props.config, props.cofheClient]);
-  const cofheClient = useMemo33(() => props.cofheClient ?? createCofheClient(config), [props.cofheClient, config]);
+  const cofheClient = useMemo34(() => props.cofheClient ?? createCofheClient(config), [props.cofheClient, config]);
   const [position, setPosition] = useState15(config.react.position);
   const [theme, setTheme] = useState15(config.react.initialTheme);
   return /* @__PURE__ */ jsx66(
@@ -9646,7 +10177,7 @@ function useCofheContext() {
 }
 
 // src/components/FnxEncryptInput.tsx
-import { useState as useState16, useRef as useRef10, useEffect as useEffect14, useMemo as useMemo34 } from "react";
+import { useState as useState16, useRef as useRef10, useEffect as useEffect14, useMemo as useMemo35 } from "react";
 import SecurityIcon from "@mui/icons-material/Security";
 import KeyboardArrowDownIcon2 from "@mui/icons-material/KeyboardArrowDown";
 import ContentCopyIcon from "@mui/icons-material/ContentCopy";
@@ -9684,7 +10215,7 @@ var FnxEncryptInput = ({
     isEncrypting,
     stepsState: { lastStep: lastEncryptionStep }
   } = useCofheEncrypt();
-  const { progress: encryptionProgress, label: encryptionProgressLabel } = useMemo34(() => {
+  const { progress: encryptionProgress, label: encryptionProgressLabel } = useMemo35(() => {
     return lastEncryptionStep ? getStepConfig(lastEncryptionStep) : {
       progress: void 0,
       label: void 0
@@ -9982,6 +10513,9 @@ export {
   getBlockExplorerTokenUrl,
   getBlockExplorerTxUrl,
   getBlockExplorerUrl,
+  getCofheTokenClaimUnshieldedCallArgs,
+  getCofheTokenShieldCallArgs,
+  getCofheTokenUnshieldCallArgs,
   isEthPair,
   isWrappedEthToken,
   statusToString,
@@ -9999,6 +10533,7 @@ export {
   useCofheReadContractAndDecrypt,
   useCofheRemovePermit,
   useCofheSelectPermit,
+  useCofheSimulateWriteContract,
   useCofheTokenClaimUnshielded,
   useCofheTokenClaimable,
   useCofheTokenDecryptedBalance,
@@ -10014,6 +10549,7 @@ export {
   useCoingeckoContractMarketChartRange,
   useCoingeckoUsdPrice,
   useInternalQueryClient,
+  useTokenAllowance,
   useTokensWithPublicBalances,
   useTransactionReceiptsByHash,
   useTransactionStore