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

package/dist/index.cjs

@@ -587,12 +587,12 @@ var require_assert = __commonJS({
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.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);
       }
     }
-    exports2.assert = assert24;
+    exports2.assert = assert26;
   }
 });
 
@@ -757,6 +757,9 @@ __export(index_exports, {
   getBlockExplorerTokenUrl: () => getBlockExplorerTokenUrl,
   getBlockExplorerTxUrl: () => getBlockExplorerTxUrl,
   getBlockExplorerUrl: () => getBlockExplorerUrl,
+  getCofheTokenClaimUnshieldedCallArgs: () => getCofheTokenClaimUnshieldedCallArgs,
+  getCofheTokenShieldCallArgs: () => getCofheTokenShieldCallArgs,
+  getCofheTokenUnshieldCallArgs: () => getCofheTokenUnshieldCallArgs,
   isEthPair: () => isEthPair,
   isWrappedEthToken: () => isWrappedEthToken,
   statusToString: () => statusToString,
@@ -774,6 +777,7 @@ __export(index_exports, {
   useCofheReadContractAndDecrypt: () => useCofheReadContractAndDecrypt,
   useCofheRemovePermit: () => useCofheRemovePermit,
   useCofheSelectPermit: () => useCofheSelectPermit,
+  useCofheSimulateWriteContract: () => useCofheSimulateWriteContract,
   useCofheTokenClaimUnshielded: () => useCofheTokenClaimUnshielded,
   useCofheTokenClaimable: () => useCofheTokenClaimable,
   useCofheTokenDecryptedBalance: () => useCofheTokenDecryptedBalance,
@@ -789,6 +793,7 @@ __export(index_exports, {
   useCoingeckoContractMarketChartRange: () => useCoingeckoContractMarketChartRange,
   useCoingeckoUsdPrice: () => useCoingeckoUsdPrice,
   useInternalQueryClient: () => useInternalQueryClient,
+  useTokenAllowance: () => useTokenAllowance,
   useTokensWithPublicBalances: () => useTokensWithPublicBalances,
   useTransactionReceiptsByHash: () => useTransactionReceiptsByHash,
   useTransactionStore: () => useTransactionStore
@@ -1132,6 +1137,71 @@ async function maybeWaitUntilRpcAwareAndReadContract(publicClient, params, optio
   throw new Error("Unexpected exit from wait loop");
 }
 
+// src/utils/cofheErrors.ts
+var import_errors = __toESM(require("@fhenixprotocol/cofhe-errors/errors.json"), 1);
+var import_viem2 = require("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 = import_errors.default;
+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 import_viem2.ContractFunctionExecutionError) {
+    if (error.cause instanceof import_viem2.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
 var import_Close = __toESM(require("@mui/icons-material/Close"), 1);
 
@@ -1171,13 +1241,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 = {
@@ -1326,11 +1398,11 @@ 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
 var import_react_query2 = require("@tanstack/react-query");
-var import_viem2 = require("viem");
+var import_viem3 = require("viem");
 
 // src/hooks/useCofhePermits.ts
 var import_react4 = require("react");
@@ -1454,19 +1526,27 @@ function useIsCofheErrorActive() {
 
 // src/hooks/useCofheReadContract.ts
 var import_abi = require("@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,
@@ -1582,14 +1662,14 @@ function useCofheReadContract(params, queryOptions) {
 }
 
 // src/hooks/useTrackPendingTransactions.ts
-var import_react_query7 = require("@tanstack/react-query");
+var import_react_query8 = require("@tanstack/react-query");
 
 // src/constants/confidentialTokenABIs.ts
-var import_viem3 = require("viem");
-var ERC20_ALLOWANCE_ABI = (0, import_viem3.parseAbi)([
+var import_viem4 = require("viem");
+var ERC20_ALLOWANCE_ABI = (0, import_viem4.parseAbi)([
   "function allowance(address owner, address spender) view returns (uint256)"
 ]);
-var ERC20_APPROVE_ABI = (0, import_viem3.parseAbi)(["function approve(address spender, uint256 amount) returns (bool)"]);
+var ERC20_APPROVE_ABI = (0, import_viem4.parseAbi)(["function approve(address spender, uint256 amount) returns (bool)"]);
 var CONFIDENTIAL_TYPE_WRAPPED_ABI = [
   {
     inputs: [
@@ -1611,10 +1691,10 @@ var CONFIDENTIAL_TYPE_WRAPPED_ABI = [
     type: "function"
   }
 ];
-var CONFIDENTIAL_TYPE_PURE_ABI = (0, import_viem3.parseAbi)([
+var CONFIDENTIAL_TYPE_PURE_ABI = (0, import_viem4.parseAbi)([
   "function confidentialBalanceOf(address account) view returns (uint256)"
 ]);
-var CONFIDENTIAL_TYPE_DUAL_ABI = (0, import_viem3.parseAbi)([
+var CONFIDENTIAL_TYPE_DUAL_ABI = (0, import_viem4.parseAbi)([
   "function confidentialBalanceOf(address account) view returns (uint256)"
 ]);
 var CONFIDENTIAL_ABIS = {
@@ -1736,9 +1816,9 @@ var TRANSFER_ABIS = {
     functionName: "TBD_DUAL_FUNCTION_NAME"
   }
 };
-var DUAL_SHIELD_ABI = (0, import_viem3.parseAbi)(["function shield(uint256 amount) public"]);
-var DUAL_UNSHIELD_ABI = (0, import_viem3.parseAbi)(["function unshield(uint64 amount) public"]);
-var DUAL_CLAIM_UNSHIELD_ABI = (0, import_viem3.parseAbi)(["function claimUnshielded() public"]);
+var DUAL_SHIELD_ABI = (0, import_viem4.parseAbi)(["function shield(uint256 amount) public"]);
+var DUAL_UNSHIELD_ABI = (0, import_viem4.parseAbi)(["function unshield(uint64 amount) public"]);
+var DUAL_CLAIM_UNSHIELD_ABI = (0, import_viem4.parseAbi)(["function claimUnshielded() public"]);
 var DUAL_GET_UNSHIELD_CLAIM_ABI = [
   {
     name: "getUserUnshieldClaim",
@@ -1760,10 +1840,10 @@ var DUAL_GET_UNSHIELD_CLAIM_ABI = [
     ]
   }
 ];
-var WRAPPED_ENCRYPT_ABI = (0, import_viem3.parseAbi)(["function encrypt(address to, uint128 value) public"]);
-var WRAPPED_DECRYPT_ABI = (0, import_viem3.parseAbi)(["function decrypt(address to, uint128 value) public"]);
-var WRAPPED_CLAIM_DECRYPTED_ABI = (0, import_viem3.parseAbi)(["function claimDecrypted(uint256 ctHash) public"]);
-var WRAPPED_CLAIM_ALL_DECRYPTED_ABI = (0, import_viem3.parseAbi)(["function claimAllDecrypted() public"]);
+var WRAPPED_ENCRYPT_ABI = (0, import_viem4.parseAbi)(["function encrypt(address to, uint128 value) public"]);
+var WRAPPED_DECRYPT_ABI = (0, import_viem4.parseAbi)(["function decrypt(address to, uint128 value) public"]);
+var WRAPPED_CLAIM_DECRYPTED_ABI = (0, import_viem4.parseAbi)(["function claimDecrypted(uint256 ctHash) public"]);
+var WRAPPED_CLAIM_ALL_DECRYPTED_ABI = (0, import_viem4.parseAbi)(["function claimAllDecrypted() public"]);
 var WRAPPED_GET_USER_CLAIMS_ABI = [
   {
     inputs: [{ name: "user", type: "address" }],
@@ -1786,8 +1866,8 @@ var WRAPPED_GET_USER_CLAIMS_ABI = [
     type: "function"
   }
 ];
-var WRAPPED_ETH_ENCRYPT_ETH_ABI = (0, import_viem3.parseAbi)(["function encryptETH(address to) public payable"]);
-var WRAPPED_ETH_ENCRYPT_WETH_ABI = (0, import_viem3.parseAbi)(["function encryptWETH(address to, uint128 value) public"]);
+var WRAPPED_ETH_ENCRYPT_ETH_ABI = (0, import_viem4.parseAbi)(["function encryptETH(address to) public payable"]);
+var WRAPPED_ETH_ENCRYPT_WETH_ABI = (0, import_viem4.parseAbi)(["function encryptWETH(address to, uint128 value) public"]);
 var SHIELD_ABIS = {
   dual: {
     abi: DUAL_SHIELD_ABI,
@@ -1887,14 +1967,14 @@ function useCofheToken({ chainId: _chainId, address }, metdataQueryOptions) {
 
 // src/hooks/useCofheTokenPublicBalance.ts
 var import_react_query4 = require("@tanstack/react-query");
-var import_viem5 = require("viem");
+var import_viem6 = require("viem");
 
 // src/constants/erc20ABIs.ts
-var import_viem4 = require("viem");
-var ERC20_BALANCE_OF_ABI = (0, import_viem4.parseAbi)(["function balanceOf(address owner) view returns (uint256)"]);
-var ERC20_DECIMALS_ABI = (0, import_viem4.parseAbi)(["function decimals() view returns (uint8)"]);
-var ERC20_SYMBOL_ABI = (0, import_viem4.parseAbi)(["function symbol() view returns (string)"]);
-var ERC20_NAME_ABI = (0, import_viem4.parseAbi)(["function name() view returns (string)"]);
+var import_viem5 = require("viem");
+var ERC20_BALANCE_OF_ABI = (0, import_viem5.parseAbi)(["function balanceOf(address owner) view returns (uint256)"]);
+var ERC20_DECIMALS_ABI = (0, import_viem5.parseAbi)(["function decimals() view returns (uint8)"]);
+var ERC20_SYMBOL_ABI = (0, import_viem5.parseAbi)(["function symbol() view returns (string)"]);
+var ERC20_NAME_ABI = (0, import_viem5.parseAbi)(["function name() view returns (string)"]);
 
 // src/hooks/useCofheTokenPublicBalance.ts
 var import_ts_essentials2 = __toESM(require_dist(), 1);
@@ -2021,11 +2101,11 @@ function useCofheTokenPublicBalance({ token, accountAddress, displayDecimals = 5
 
 // src/hooks/useCofheTokenClaimable.ts
 var import_react_query6 = require("@tanstack/react-query");
-var import_viem7 = require("viem");
+var import_viem8 = require("viem");
 
 // src/utils/decryptionAwareReadContract.ts
 var import_react_query5 = require("@tanstack/react-query");
-var import_viem6 = require("viem");
+var import_viem7 = require("viem");
 
 // src/stores/decryptionWatchingStore.ts
 var import_zustand2 = require("zustand");
@@ -2301,9 +2381,87 @@ function useCofheTokenClaimable({ accountAddress: account, token }, queryOptions
   };
 }
 
+// src/hooks/useTokenAllowance.ts
+var import_react_query7 = require("@tanstack/react-query");
+var import_viem9 = require("viem");
+var import_ts_essentials4 = __toESM(require_dist(), 1);
+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_react8 = require("react");
-var import_ts_essentials4 = __toESM(require_dist());
+var import_ts_essentials5 = __toESM(require_dist());
 function useStoredTransactions({
   chainId,
   account,
@@ -2335,7 +2493,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"
   );
@@ -2753,6 +2911,7 @@ var usePortalToasts = (0, import_zustand7.create)()((set, get) => ({
 }));
 
 // src/hooks/useTransactionGlobalLifecycle.ts
+var import_viem10 = require("viem");
 var TOAST_DELAY_MS = 1e4;
 function useTransactionGlobalToastsLifecycle() {
   const { addToast } = usePortalToasts();
@@ -2774,12 +2933,21 @@ function useTransactionGlobalToastsLifecycle() {
       );
     },
     onTransactionSubmitError: (error, transactionType) => {
+      let humanReadableError;
+      if (error instanceof import_viem10.ContractFunctionExecutionError) {
+        if (error.cause instanceof import_viem10.ContractFunctionRevertedError) {
+          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
       );
@@ -2901,7 +3069,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,
@@ -2911,6 +3079,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,
@@ -2921,9 +3103,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);
@@ -2979,7 +3163,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,
@@ -2993,6 +3177,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);
     }
@@ -3038,7 +3236,7 @@ var import_react15 = require("react");
 
 // src/hooks/useTransactionReceiptsByHash.ts
 var import_react13 = require("react");
-var import_ts_essentials6 = __toESM(require_dist(), 1);
+var import_ts_essentials7 = __toESM(require_dist(), 1);
 function useTransactionReceiptsByHash({ hashes, chainId: chainIdInput, enabled: enabledInput = true, queryOptions } = {
   enabled: true
 }) {
@@ -3054,7 +3252,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"],
@@ -3081,7 +3279,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
 var import_react14 = require("react");
@@ -3220,7 +3418,7 @@ function useTrackDecryptingTransactionsBase({ onDecryptionResolve }) {
   const minedTxsWithCiphertextsToWatch = (0, import_react15.useMemo)(() => {
     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"
       );
@@ -3240,7 +3438,7 @@ function useTrackDecryptingTransactionsBase({ onDecryptionResolve }) {
   (0, import_react15.useEffect)(() => {
     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
@@ -3332,19 +3530,19 @@ var useCofheClient = () => {
 };
 
 // src/hooks/useCofheTokenDecryptedBalance.ts
-var import_react_query9 = require("@tanstack/react-query");
-var import_viem9 = require("viem");
+var import_react_query10 = require("@tanstack/react-query");
+var import_viem12 = require("viem");
 var import_sdk6 = require("@cofhe/sdk");
-var import_ts_essentials9 = __toESM(require_dist(), 1);
+var import_ts_essentials10 = __toESM(require_dist(), 1);
 
 // src/hooks/useCofheReadContractAndDecrypt.ts
-var import_react_query8 = require("@tanstack/react-query");
-var import_viem8 = require("viem");
+var import_react_query9 = require("@tanstack/react-query");
+var import_viem11 = require("viem");
 var import_sdk5 = require("@cofhe/sdk");
 
 // src/hooks/useCofheDecrypt.ts
 var import_sdk4 = require("@cofhe/sdk");
-var import_ts_essentials8 = __toESM(require_dist(), 1);
+var import_ts_essentials9 = __toESM(require_dist(), 1);
 function useCofheDecrypt({
   input,
   onPoll: onPoll2
@@ -3357,7 +3555,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();
@@ -3449,7 +3647,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");
           }
@@ -3468,7 +3666,7 @@ function useCofheTokenDecryptedBalance({ token, accountAddress, displayDecimals
 }
 
 // src/hooks/useCofheTokenTransfer.ts
-var import_viem10 = require("viem");
+var import_viem13 = require("viem");
 var import_sdk9 = require("@cofhe/sdk");
 
 // src/hooks/useCofheEncryptAndWriteContract.ts
@@ -3476,7 +3674,7 @@ var import_abi2 = require("@cofhe/abi");
 
 // src/hooks/useCofheEncrypt.ts
 var import_sdk8 = require("@cofhe/sdk");
-var import_ts_essentials10 = __toESM(require_dist(), 1);
+var import_ts_essentials11 = __toESM(require_dist(), 1);
 
 // src/hooks/internal/useStepsState.ts
 var import_sdk7 = require("@cofhe/sdk");
@@ -3572,7 +3770,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;
@@ -3607,19 +3805,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);
@@ -3739,10 +3946,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
-var import_react_query10 = require("@tanstack/react-query");
-var import_viem11 = require("viem");
-var import_ts_essentials12 = __toESM(require_dist(), 1);
+var import_react_query11 = require("@tanstack/react-query");
+var import_viem14 = require("viem");
+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();
@@ -3755,6 +4049,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) {
@@ -3771,66 +4068,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;
     },
@@ -3839,8 +4109,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,
@@ -3858,19 +4128,19 @@ function useCofheTokenShield(options) {
 }
 
 // src/hooks/useCofheTokenUnshield.ts
-var import_react_query11 = require("@tanstack/react-query");
-var import_viem12 = require("viem");
-var import_ts_essentials14 = __toESM(require_dist(), 1);
+var import_react_query12 = require("@tanstack/react-query");
+var import_viem15 = require("viem");
+var import_ts_essentials15 = __toESM(require_dist(), 1);
 
 // src/hooks/useStoredTransaction.ts
 var import_react17 = require("react");
-var import_ts_essentials13 = __toESM(require_dist(), 1);
+var import_ts_essentials14 = __toESM(require_dist(), 1);
 function useStoredTransaction(txHash) {
   const filter3 = (0, import_react17.useMemo)(() => {
     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];
 }
 
@@ -3953,8 +4223,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();
@@ -3964,6 +4269,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) {
@@ -3982,24 +4290,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;
     },
@@ -4008,8 +4316,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,
@@ -4047,11 +4355,35 @@ function useCofheTokenUnshield(input) {
 }
 
 // src/hooks/useCofheTokenClaimUnshielded.ts
-var import_react_query12 = require("@tanstack/react-query");
-var import_viem13 = require("viem");
-var import_ts_essentials15 = __toESM(require_dist(), 1);
+var import_react_query13 = require("@tanstack/react-query");
+var import_viem16 = require("viem");
+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 || {};
@@ -4061,6 +4393,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) {
@@ -4076,23 +4411,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,
@@ -4110,10 +4444,10 @@ function useCofheTokenClaimUnshielded(options) {
 }
 
 // src/hooks/useCofheTokensClaimable.ts
-var import_react_query13 = require("@tanstack/react-query");
+var import_react_query14 = require("@tanstack/react-query");
 var import_react22 = require("react");
-var import_viem15 = require("viem");
-var import_ts_essentials17 = __toESM(require_dist(), 1);
+var import_viem18 = require("viem");
+var import_ts_essentials18 = __toESM(require_dist(), 1);
 
 // src/hooks/useNormalizedList.ts
 var import_react20 = require("react");
@@ -4143,14 +4477,14 @@ function useNormalizedList(items, options) {
 
 // src/hooks/useIsWaitingForDecryptionByAddress.ts
 var import_react21 = require("react");
-var import_viem14 = require("viem");
-var import_ts_essentials16 = __toESM(require_dist(), 1);
+var import_viem17 = require("viem");
+var import_ts_essentials17 = __toESM(require_dist(), 1);
 function useIsWaitingForDecryptionByAddress(entries) {
   const awaitingDecryptionKeySet = useAwaitingDecryptionQueryKeySet();
   return (0, import_react21.useMemo)(() => {
     const map = {};
     for (const entry of entries) {
-      (0, import_ts_essentials16.assert)((0, import_viem14.isAddress)(entry.address), "address is valid");
+      (0, import_ts_essentials17.assert)((0, import_viem17.isAddress)(entry.address), "address is valid");
       map[entry.address] = awaitingDecryptionKeySet.has(JSON.stringify(entry.queryKey));
     }
     return map;
@@ -4227,12 +4561,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,
@@ -4296,29 +4630,17 @@ function useCofheTokensClaimable({ tokens, accountAddress: account }, queryOptio
 var import_react23 = require("react");
 
 // src/hooks/useCofheReadContracts.ts
-var import_react_query14 = require("@tanstack/react-query");
-var import_ts_essentials18 = __toESM(require_dist(), 1);
+var import_react_query15 = require("@tanstack/react-query");
+var import_ts_essentials19 = __toESM(require_dist(), 1);
 var import_abi3 = require("@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
     };
   });
@@ -4357,8 +4679,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 || {}
@@ -4537,6 +4859,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
 var import_react25 = require("react");
 function usePermitDuration(options) {
@@ -4871,7 +5256,7 @@ function useReceivePermit({ onSuccess, onError } = {}) {
 
 // src/hooks/permits/usePermitDetailsAndActions.ts
 var import_react31 = require("react");
-var import_viem16 = require("viem");
+var import_viem19 = require("viem");
 var import_permits4 = require("@cofhe/sdk/permits");
 
 // src/hooks/useCopyFeedback.ts
@@ -4969,7 +5354,7 @@ var usePermitDetailsAndActions = (permitHash) => {
   const permitLabel = (0, import_react31.useMemo)(() => {
     if (!permit) return void 0;
     if (permit.name?.trim()) return permit.name;
-    const fallbackAddress = permit.recipient && permit.recipient !== import_viem16.zeroAddress ? permit.recipient : permit.issuer || import_viem16.zeroAddress;
+    const fallbackAddress = permit.recipient && permit.recipient !== import_viem19.zeroAddress ? permit.recipient : permit.issuer || import_viem19.zeroAddress;
     return truncateAddress(fallbackAddress, 4, 4) ?? fallbackAddress;
   }, [permit]);
   const expirationInfo = (0, import_react31.useMemo)(() => formatExpirationLabel(permit?.expiration), [permit?.expiration]);
@@ -5016,10 +5401,10 @@ var usePermitDetailsAndActions = (permitHash) => {
 var import_react33 = require("react");
 
 // src/providers/internalQueryHooks.ts
-var import_react_query16 = require("@tanstack/react-query");
+var import_react_query17 = require("@tanstack/react-query");
 
 // src/providers/queryUtils.ts
-var import_react_query15 = require("@tanstack/react-query");
+var import_react_query16 = require("@tanstack/react-query");
 var import_react_query_persist_client = require("@tanstack/react-query-persist-client");
 var import_query_async_storage_persister = require("@tanstack/query-async-storage-persister");
 var import_react32 = require("react");
@@ -5071,17 +5456,17 @@ function applyPersistedDefaults(options) {
 }
 function useInternalQuery(options) {
   const qc = useInternalQueryClient();
-  return (0, import_react_query16.useQuery)(applyPersistedDefaults(options), qc);
+  return (0, import_react_query17.useQuery)(applyPersistedDefaults(options), qc);
 }
 function useInternalMutation(options) {
   const qc = useInternalQueryClient();
-  return (0, import_react_query16.useMutation)(options, qc);
+  return (0, import_react_query17.useMutation)(options, qc);
 }
 var useInternalQueries2 = (options, _ignoredQueryClient) => {
   const qc = useInternalQueryClient();
   if (options && typeof options === "object" && "queries" in options) {
     const typedOptions = options;
-    return (0, import_react_query16.useQueries)(
+    return (0, import_react_query17.useQueries)(
       {
         ...options,
         queries: typedOptions.queries.map((q) => applyPersistedDefaults(q))
@@ -5089,7 +5474,7 @@ var useInternalQueries2 = (options, _ignoredQueryClient) => {
       qc
     );
   }
-  return (0, import_react_query16.useQueries)(options, qc);
+  return (0, import_react_query17.useQueries)(options, qc);
 };
 
 // src/hooks/useCofheConnect.ts
@@ -6150,7 +6535,7 @@ var import_io2 = require("react-icons/io");
 var import_ai = require("react-icons/ai");
 var import_tb3 = require("react-icons/tb");
 var import_fa = require("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
 var import_jsx_runtime22 = require("react/jsx-runtime");
@@ -6416,7 +6801,7 @@ var PageContainer = ({ isModal, header, content, footer }) => {
 };
 
 // src/components/FnxFloatingButton/components/TransactionItem.tsx
-var import_viem17 = require("viem");
+var import_viem20 = require("viem");
 var import_go = require("react-icons/go");
 var import_tb2 = require("react-icons/tb");
 var import_jsx_runtime27 = require("react/jsx-runtime");
@@ -6431,6 +6816,8 @@ var ActionIcon = ({ actionType }) => {
       return /* @__PURE__ */ (0, import_jsx_runtime27.jsx)(import_tb2.TbShieldMinus, { className: iconClassName2 });
     case "claim" /* Claim */:
       return /* @__PURE__ */ (0, import_jsx_runtime27.jsx)(import_tb2.TbShieldCheck, { className: iconClassName2 });
+    case "approve" /* Approve */:
+      return /* @__PURE__ */ (0, import_jsx_runtime27.jsx)(import_go.GoArrowUpRight, { className: iconClassName2 });
     default:
       return /* @__PURE__ */ (0, import_jsx_runtime27.jsx)(import_go.GoArrowUpRight, { className: iconClassName2 });
   }
@@ -6443,7 +6830,7 @@ var TransactionItem = ({ transaction }) => {
       /* @__PURE__ */ (0, import_jsx_runtime27.jsxs)("div", { className: "flex items-center justify-between gap-2", children: [
         /* @__PURE__ */ (0, import_jsx_runtime27.jsx)("span", { className: "text-sm font-semibold fnx-text-primary", children: actionToString(transaction.actionType) }),
         /* @__PURE__ */ (0, import_jsx_runtime27.jsxs)("span", { className: "text-sm font-semibold fnx-text-primary", children: [
-          (0, import_viem17.formatUnits)(transaction.tokenAmount, transaction.token.decimals),
+          (0, import_viem20.formatUnits)(transaction.tokenAmount, transaction.token.decimals),
           " ",
           transaction.token.symbol
         ] })
@@ -6527,12 +6914,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;
     }
@@ -6747,7 +7134,7 @@ var InfoModalButton = ({ onClick }) => {
 
 // src/components/FnxFloatingButton/components/PermitCard.tsx
 var import_fa63 = require("react-icons/fa6");
-var import_viem18 = require("viem");
+var import_viem21 = require("viem");
 var import_permits7 = require("@cofhe/sdk/permits");
 
 // src/components/StripedBackground.tsx
@@ -6867,14 +7254,14 @@ var BasePermitCard = ({
               ] })
             ] }),
             /* @__PURE__ */ (0, import_jsx_runtime35.jsx)("br", {}),
-            permit.recipient != null && permit.recipient !== import_viem18.zeroAddress && /* @__PURE__ */ (0, import_jsx_runtime35.jsxs)(import_jsx_runtime35.Fragment, { children: [
+            permit.recipient != null && permit.recipient !== import_viem21.zeroAddress && /* @__PURE__ */ (0, import_jsx_runtime35.jsxs)(import_jsx_runtime35.Fragment, { children: [
               "Recipient: ",
               /* @__PURE__ */ (0, import_jsx_runtime35.jsx)("b", { children: truncateAddress(permit.recipient, 6, 6) }),
               " ",
               /* @__PURE__ */ (0, import_jsx_runtime35.jsx)(CopyButton2, { hash: permit.recipient }),
               /* @__PURE__ */ (0, import_jsx_runtime35.jsx)("br", {})
             ] }),
-            permit.validatorContract != null && permit.validatorContract !== import_viem18.zeroAddress && /* @__PURE__ */ (0, import_jsx_runtime35.jsxs)(import_jsx_runtime35.Fragment, { children: [
+            permit.validatorContract != null && permit.validatorContract !== import_viem21.zeroAddress && /* @__PURE__ */ (0, import_jsx_runtime35.jsxs)(import_jsx_runtime35.Fragment, { children: [
               "Validator:",
               /* @__PURE__ */ (0, import_jsx_runtime35.jsx)("br", {}),
               "  ",
@@ -7541,7 +7928,7 @@ var TokenInfoBalanceChart = ({ token, chartPoints }) => {
 
 // src/components/FnxFloatingButton/pages/TokenInfoTransactionHistory.tsx
 var import_react52 = require("react");
-var import_viem19 = require("viem");
+var import_viem22 = require("viem");
 var import_jsx_runtime46 = require("react/jsx-runtime");
 var TokenInfoTransactionHistoryHeader = ({ token }) => {
   return /* @__PURE__ */ (0, import_jsx_runtime46.jsxs)("div", { className: "flex items-center justify-between", children: [
@@ -7565,7 +7952,7 @@ var TokenInfoTransactionHistory = ({ token, priceUsd }) => {
   });
   const activity = (0, import_react52.useMemo)(() => {
     return tokenTxs.slice().sort((a, b) => b.timestamp - a.timestamp).map((tx) => {
-      const amountToken = parseFloat((0, import_viem19.formatUnits)(tx.tokenAmount, tx.token.decimals));
+      const amountToken = parseFloat((0, import_viem22.formatUnits)(tx.tokenAmount, tx.token.decimals));
       const amountUsd = typeof priceUsd === "number" && Number.isFinite(amountToken) ? amountToken * priceUsd : void 0;
       return {
         kind: actionToString(tx.actionType),
@@ -7672,8 +8059,8 @@ var TokenInfoPage = ({ token }) => {
 var import_react54 = require("react");
 var import_ArrowBack7 = __toESM(require("@mui/icons-material/ArrowBack"), 1);
 var import_KeyboardArrowRight2 = __toESM(require("@mui/icons-material/KeyboardArrowRight"), 1);
-var import_viem20 = require("viem");
-var import_ts_essentials20 = __toESM(require_dist(), 1);
+var import_viem23 = require("viem");
+var import_ts_essentials22 = __toESM(require_dist(), 1);
 var import_jsx_runtime48 = require("react/jsx-runtime");
 var SendPage = ({ token: _token }) => {
   const [overriddenToken, setOverriddenToken] = (0, import_react54.useState)(null);
@@ -7692,7 +8079,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);
     },
@@ -7725,13 +8112,13 @@ var SendPage = ({ token: _token }) => {
   const [recipientAddress, setRecipientAddress] = (0, import_react54.useState)("");
   const [error, setError] = (0, import_react54.useState)(null);
   const [success, setSuccess] = (0, import_react54.useState)(null);
-  const isValidAddress2 = (0, import_viem20.isAddress)(recipientAddress);
+  const isValidAddress2 = (0, import_viem23.isAddress)(recipientAddress);
   const isValidAmount = (amount.length > 0 && confidentialUnitBalance && confidentialUnitBalance.gte(amount)) ?? false;
   const handleSend = async () => {
-    (0, import_ts_essentials20.assert)((0, import_viem20.isAddress)(recipientAddress), "Recipient address is not valid");
+    (0, import_ts_essentials22.assert)((0, import_viem23.isAddress)(recipientAddress), "Recipient address is not valid");
     const amountWei = unitToWei(amount, token.decimals);
-    (0, import_ts_essentials20.assert)(amountWei <= import_viem20.maxUint128, "Amount exceeds maximum supported value (uint128 max)");
-    (0, import_ts_essentials20.assert)(account, "Sender account is required");
+    (0, import_ts_essentials22.assert)(amountWei <= import_viem23.maxUint128, "Amount exceeds maximum supported value (uint128 max)");
+    (0, import_ts_essentials22.assert)(account, "Sender account is required");
     await encryptAmountAndSendToken({
       input: {
         token,
@@ -7745,6 +8132,7 @@ var SendPage = ({ token: _token }) => {
     if (confidentialUnitBalance) setAmount(confidentialUnitBalance.toFixed());
   };
   const { tokensWithExistingEncryptedBalance } = useCofheTokensWithExistingEncryptedBalances();
+  const disabled = !isValidAddress2 || !isValidAmount || isSending || isEncryptingInput;
   return /* @__PURE__ */ (0, import_jsx_runtime48.jsx)(
     PageContainer,
     {
@@ -7851,11 +8239,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__ */ (0, import_jsx_runtime48.jsx)("span", { children: "Send" }),
@@ -7873,8 +8261,8 @@ var import_KeyboardArrowDown = __toESM(require("@mui/icons-material/KeyboardArro
 var import_tb4 = require("react-icons/tb");
 var import_lu2 = require("react-icons/lu");
 var import_react56 = require("react");
-var import_viem21 = require("viem");
-var import_ts_essentials21 = __toESM(require_dist(), 1);
+var import_viem24 = require("viem");
+var import_ts_essentials23 = __toESM(require_dist(), 1);
 
 // src/hooks/useIsUnshieldingMining.ts
 var import_react55 = require("react");
@@ -7908,6 +8296,13 @@ function useLifecycleStore() {
     setStatus
   };
 }
+function humanizeSimulationError(error, fallbackMessage) {
+  if (!error) return null;
+  const cofheErrorMessage = cofheHumanizeViemError(error);
+  if (cofheErrorMessage) return cofheErrorMessage;
+  if (error instanceof import_viem24.ContractFunctionExecutionError) return error.shortMessage;
+  return fallbackMessage;
+}
 function TxHashWithActions({ hash, chainId }) {
   const href = chainId ? getBlockExplorerTxUrl(chainId, hash) : void 0;
   const ellipsed = truncateHash(hash);
@@ -7956,7 +8351,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);
@@ -8015,12 +8410,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) => {
@@ -8052,6 +8453,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
@@ -8061,20 +8471,66 @@ function useShieldWithLifecycle(token) {
     if (publicBalanceUnit) setShieldAmount(publicBalanceUnit.toFixed());
   };
   const isValidShieldAmount = (shieldAmount.length > 0 && publicBalanceUnit?.gte(shieldAmount)) ?? false;
+  const shieldAmountWei = (0, import_react56.useMemo)(() => {
+    if (!isValidShieldAmount) return void 0;
+    try {
+      return unitToWei(shieldAmount, token.decimals);
+    } catch {
+      return void 0;
+    }
+  }, [isValidShieldAmount, shieldAmount, token.decimals]);
+  const shieldTxCallArgs = (0, import_react56.useMemo)(() => {
+    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 = (0, import_react56.useMemo)(() => {
+    const relevantError = shouldApprove ? approvalSimulation.error : shieldSimulation.error;
+    if (!relevantError) return null;
+    const cofheErrorMessage = cofheHumanizeViemError(relevantError);
+    if (cofheErrorMessage) return cofheErrorMessage;
+    if (relevantError instanceof import_viem24.ContractFunctionExecutionError) 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__ */ (0, import_jsx_runtime49.jsx)(import_tb4.TbShieldPlus, { className: "w-3 h-3" })
   };
 }
@@ -8103,7 +8559,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);
@@ -8134,10 +8590,10 @@ function useUnshieldWithLifecycle(token) {
     }
   });
   const handleUnshield = async () => {
-    const amountInSmallestUnit = (0, import_viem21.parseUnits)(unshieldAmount, token.decimals);
+    const amountWei = (0, import_viem24.parseUnits)(unshieldAmount, token.decimals);
     tokenUnshield.mutateAsync({
       token,
-      amount: amountInSmallestUnit,
+      amount: amountWei,
       onStatusChange: (message) => setStatus({ message, type: "info" })
     });
   };
@@ -8146,14 +8602,27 @@ function useUnshieldWithLifecycle(token) {
     if (confidentialBalanceUnit) setUnshieldAmount(confidentialBalanceUnit.toFixed());
   };
   const isValidUnshieldAmount = (unshieldAmount.length > 0 && confidentialBalanceUnit?.gte(unshieldAmount)) ?? false;
+  const unshieldCallArgs = (0, import_react56.useMemo)(() => {
+    if (!account || !isValidUnshieldAmount) return void 0;
+    const amountWei = (0, import_viem24.parseUnits)(unshieldAmount, token.decimals);
+    return getCofheTokenUnshieldCallArgs({ token, amount: amountWei, account });
+  }, [account, isValidUnshieldAmount, token, unshieldAmount]);
+  const unshieldSimulation = useCofheSimulateWriteContract(unshieldCallArgs, {
+    enabled: !!unshieldCallArgs
+  });
+  const simulationError = (0, import_react56.useMemo)(
+    () => 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,
@@ -8206,19 +8675,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 = (0, import_react56.useMemo)(() => {
+    if (!account || !unshieldedClaims?.hasClaimable) return void 0;
+    return getCofheTokenClaimUnshieldedCallArgs({ token, account });
+  }, [account, token, unshieldedClaims?.hasClaimable]);
+  const claimSimulation = useCofheSimulateWriteContract(claimCallArgs, {
+    enabled: !!claimCallArgs
+  });
+  const claimSimulationError = (0, import_react56.useMemo)(
+    () => humanizeSimulationError(claimSimulation.error, "Failed to simulate claim transaction"),
+    [claimSimulation.error]
+  );
   return /* @__PURE__ */ (0, import_jsx_runtime49.jsxs)(import_jsx_runtime49.Fragment, { children: [
     unshieldedClaims?.hasClaimable && /* @__PURE__ */ (0, import_jsx_runtime49.jsx)(
       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"
       }
@@ -8229,7 +8709,7 @@ function ClaimingSection({ token }) {
       " ",
       pairedSymbol
     ] }),
-    /* @__PURE__ */ (0, import_jsx_runtime49.jsx)(StatusAndError, { status: claimingStatus, error: claimingError })
+    /* @__PURE__ */ (0, import_jsx_runtime49.jsx)(StatusAndError, { status: claimingStatus, error: claimingError ?? claimSimulationError })
   ] });
 }
 function StatusAndError({ status, error }) {
@@ -8267,7 +8747,7 @@ var ShieldAndUnshieldPageView = ({
   inputAmount,
   setInputAmount,
   onMaxClick,
-  isValidAmount,
+  canWriteContract,
   sourceSymbol,
   destSymbol,
   sourceLogoURI,
@@ -8384,7 +8864,7 @@ var ShieldAndUnshieldPageView = ({
           ActionButton,
           {
             onClick: handlePrimaryAction,
-            disabled: !isValidAmount || isProcessing || !isShieldableToken,
+            disabled: !canWriteContract || isProcessing || !isShieldableToken,
             icon: primaryIcon,
             label: primaryLabel,
             className: "py-2"
@@ -8397,6 +8877,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__ */ (0, import_jsx_runtime49.jsxs)(import_jsx_runtime49.Fragment, { children: [
+          "Approval transaction sent! Hash: ",
+          /* @__PURE__ */ (0, import_jsx_runtime49.jsx)(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__ */ (0, import_jsx_runtime49.jsxs)(import_jsx_runtime49.Fragment, { children: [
+            "Approval transaction confirmed! Hash: ",
+            /* @__PURE__ */ (0, import_jsx_runtime49.jsx)(TxHashWithActions, { hash: transaction.hash, chainId })
+          ] }),
+          type: "success"
+        });
+      } else if (transaction.status === "failed") {
+        setError(
+          /* @__PURE__ */ (0, import_jsx_runtime49.jsxs)(import_jsx_runtime49.Fragment, { children: [
+            "Approval transaction failed! Hash: ",
+            /* @__PURE__ */ (0, import_jsx_runtime49.jsx)(TxHashWithActions, { hash: transaction.hash, chainId })
+          ] })
+        );
+        setStatus(null);
+      }
+      scheduleStatusClear();
+    }
+  });
+  return {
+    tokenApprove,
+    isApprovingMining
+  };
+}
 
 // src/components/FnxFloatingButton/pages/ActivityPage.tsx
 var import_ArrowBack9 = __toESM(require("@mui/icons-material/ArrowBack"), 1);
@@ -8433,7 +8969,7 @@ var ActivityPage = () => {
 var import_ArrowBack10 = __toESM(require("@mui/icons-material/ArrowBack"), 1);
 var import_react57 = require("react");
 var import_accounts = require("viem/accounts");
-var import_viem22 = require("viem");
+var import_viem25 = require("viem");
 var import_jsx_runtime51 = require("react/jsx-runtime");
 var DebugPage = () => {
   const { navigateBack } = usePortalNavigation();
@@ -8814,9 +9350,9 @@ var CreateAndUseReceivingPermitButton = () => {
     if (!account) throw new Error("No connected account found");
     if (!publicClient) throw new Error("No public client found");
     const sharingAccount = (0, import_accounts.privateKeyToAccount)("0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80");
-    const sharingWalletClient = (0, import_viem22.createWalletClient)({
+    const sharingWalletClient = (0, import_viem25.createWalletClient)({
       chain: publicClient.chain,
-      transport: (0, import_viem22.http)(),
+      transport: (0, import_viem25.http)(),
       account: sharingAccount
     });
     const sharedPermit = await cofheClient.permits.createSharing(
@@ -9022,7 +9558,7 @@ var PortfolioPage = () => {
 // src/components/FnxFloatingButton/pages/ClaimableTokens.tsx
 var import_ArrowBack13 = __toESM(require("@mui/icons-material/ArrowBack"), 1);
 var import_react58 = require("react");
-var import_ts_essentials22 = __toESM(require_dist(), 1);
+var import_ts_essentials24 = __toESM(require_dist(), 1);
 var import_jsx_runtime55 = require("react/jsx-runtime");
 function ClaimableTokens() {
   const chainsClaimableTokens = useCofheClaimableTokens();
@@ -9043,7 +9579,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__ */ (0, import_jsx_runtime55.jsx)(
@@ -9603,12 +10139,12 @@ var FnxFloatingButtonWithProvider = (props) => {
 var import_zod = require("zod");
 var import_sdk10 = require("@cofhe/sdk");
 var import_web2 = require("@cofhe/sdk/web");
-var import_viem23 = require("viem");
-var addressSchema = import_zod.z.string().refine((val) => (0, import_viem23.isAddress)(val), {
+var import_viem26 = require("viem");
+var addressSchema = import_zod.z.string().refine((val) => (0, import_viem26.isAddress)(val), {
   error: "Invalid address"
-}).refine((val) => val !== import_viem23.zeroAddress, {
+}).refine((val) => val !== import_viem26.zeroAddress, {
   error: "Must not be zeroAddress"
-}).transform((val) => (0, import_viem23.getAddress)(val));
+}).transform((val) => (0, import_viem26.getAddress)(val));
 var CofheReactConfigSchema = import_zod.z.object({
   shareablePermits: import_zod.z.boolean().optional().default(false),
   enableShieldUnshield: import_zod.z.boolean().optional().default(true),
@@ -9650,7 +10186,7 @@ function createCofheConfig(config) {
 
 // src/providers/CofheProvider.tsx
 var import_chains5 = require("@cofhe/sdk/chains");
-var import_ts_essentials23 = __toESM(require_dist(), 1);
+var import_ts_essentials25 = __toESM(require_dist(), 1);
 var import_jsx_runtime66 = require("react/jsx-runtime");
 var CofheContext = (0, import_react64.createContext)(void 0);
 function CofheProvider(props) {
@@ -9658,7 +10194,7 @@ function CofheProvider(props) {
   const config = (0, import_react64.useMemo)(() => {
     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(import_chains5.chains) });
@@ -10035,6 +10571,9 @@ var import_web4 = require("@cofhe/sdk/web");
   getBlockExplorerTokenUrl,
   getBlockExplorerTxUrl,
   getBlockExplorerUrl,
+  getCofheTokenClaimUnshieldedCallArgs,
+  getCofheTokenShieldCallArgs,
+  getCofheTokenUnshieldCallArgs,
   isEthPair,
   isWrappedEthToken,
   statusToString,
@@ -10052,6 +10591,7 @@ var import_web4 = require("@cofhe/sdk/web");
   useCofheReadContractAndDecrypt,
   useCofheRemovePermit,
   useCofheSelectPermit,
+  useCofheSimulateWriteContract,
   useCofheTokenClaimUnshielded,
   useCofheTokenClaimable,
   useCofheTokenDecryptedBalance,
@@ -10067,6 +10607,7 @@ var import_web4 = require("@cofhe/sdk/web");
   useCoingeckoContractMarketChartRange,
   useCoingeckoUsdPrice,
   useInternalQueryClient,
+  useTokenAllowance,
   useTokensWithPublicBalances,
   useTransactionReceiptsByHash,
   useTransactionStore