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

package/dist/{chunk-GWNGM2KD.cjs → chunk-4FH4QHHA.cjs}

@@ -1047,6 +1047,7 @@ function CofheProvider(props) {
     {
       value: {
         client: cofheClient,
+        transactionRenderers: props.transactionRenderers,
         state: {
           position,
           setPosition,
@@ -2618,32 +2619,46 @@ var TransactionStatus = /* @__PURE__ */ ((TransactionStatus3) => {
   TransactionStatus3["Confirmed"] = "confirmed";
   return TransactionStatus3;
 })(TransactionStatus || {});
-var TransactionActionType = /* @__PURE__ */ ((TransactionActionType2) => {
-  TransactionActionType2["ShieldSend"] = "shieldSend";
-  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",
-  ["approve" /* Approve */]: "Approve"
+var TransactionActionType = {
+  ShieldSend: "shieldSend",
+  Shield: "shield",
+  Unshield: "unshield",
+  Claim: "claim",
+  Approve: "approve"
 };
-var actionToString = (a) => actionToStringMap[a];
+var actionToStringMap = {
+  [TransactionActionType.ShieldSend]: "Shielded Transfer",
+  [TransactionActionType.Shield]: "Shield",
+  [TransactionActionType.Unshield]: "Unshield",
+  [TransactionActionType.Claim]: "Claim",
+  [TransactionActionType.Approve]: "Approve"
+};
+var actionToString = (a, fallbackTitle) => _nullishCoalesce(_nullishCoalesce(actionToStringMap[a], () => ( fallbackTitle)), () => ( a));
+var isCustomTransactionActionType = (actionType) => actionType.startsWith("custom-");
 var statusToStringMap = {
   ["pending" /* Pending */]: "Pending",
   ["failed" /* Failed */]: "Failed",
   ["confirmed" /* Confirmed */]: "Confirmed"
 };
 var statusToString = (a) => statusToStringMap[a];
+function normalizeAddressList(addresses) {
+  if (!addresses || addresses.length === 0) return void 0;
+  return Array.from(new Set(addresses.map((address) => address.toLowerCase())));
+}
+function transactionMatchesToken(tx, tokenAddress) {
+  const normalizedTokenAddress = tokenAddress.toLowerCase();
+  if ("token" in tx && tx.token.address.toLowerCase() === normalizedTokenAddress) return true;
+  return _nullishCoalesce(_optionalChain([tx, 'access', _88 => _88.tokenTags, 'optionalAccess', _89 => _89.some, 'call', _90 => _90((tag) => tag.toLowerCase() === normalizedTokenAddress)]), () => ( false));
+}
 var bigintStorage = _middleware.createJSONStorage.call(void 0, () => localStorage, bigintJSONStorageOptions);
 function constructNewTx(transaction) {
+  const tokenTags = normalizeAddressList([
+    ..._nullishCoalesce(transaction.tokenTags, () => ( [])),
+    ..."token" in transaction ? [transaction.token.address] : []
+  ]);
   return {
     ...transaction,
+    ...tokenTags ? { tokenTags } : {},
     status: "pending" /* Pending */,
     timestamp: Date.now()
   };
@@ -2679,7 +2694,7 @@ var useTransactionStore = _zustand.create.call(void 0, )(
                 [hash]: {
                   ...chainTxs[hash],
                   status,
-                  receipt: _nullishCoalesce(_optionalChain([minedData, 'optionalAccess', _88 => _88.receipt]), () => ( chainTxs[hash].receipt))
+                  receipt: _nullishCoalesce(_optionalChain([minedData, 'optionalAccess', _91 => _91.receipt]), () => ( chainTxs[hash].receipt))
                 }
               }
             }
@@ -2687,7 +2702,7 @@ var useTransactionStore = _zustand.create.call(void 0, )(
         });
       },
       getTransaction: (chainId, hash) => {
-        return _optionalChain([get, 'call', _89 => _89(), 'access', _90 => _90.transactions, 'access', _91 => _91[chainId], 'optionalAccess', _92 => _92[hash]]);
+        return _optionalChain([get, 'call', _92 => _92(), 'access', _93 => _93.transactions, 'access', _94 => _94[chainId], 'optionalAccess', _95 => _95[hash]]);
       },
       getAllTransactions: (chainId, account) => {
         const chainTxs = get().transactions[chainId];
@@ -2696,7 +2711,8 @@ var useTransactionStore = _zustand.create.call(void 0, )(
       getAllTransactionsByToken: (chainId, tokenAddress, account) => {
         const chainTxs = get().transactions[chainId];
         return chainTxs ? Object.values(chainTxs).filter((tx) => {
-          return tx.account.toLowerCase() === _optionalChain([account, 'optionalAccess', _93 => _93.toLowerCase, 'call', _94 => _94()]);
+          if (!transactionMatchesToken(tx, tokenAddress)) return false;
+          return !account || tx.account.toLowerCase() === account.toLowerCase();
         }).sort((a, b) => b.timestamp - a.timestamp) : [];
       },
       clearTransactions: (chainId) => {
@@ -2730,7 +2746,7 @@ function useCofheWriteContract(options) {
   const publicClient = useCofhePublicClient();
   const mutation = useInternalMutation({
     ...options,
-    mutationKey: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _95 => _95.mutationKey]), () => ( ["cofhe", "walletWriteContract"])),
+    mutationKey: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _96 => _96.mutationKey]), () => ( ["cofhe", "walletWriteContract"])),
     mutationFn: async (variables) => {
       (0, import_ts_essentials5.assert)(walletClient, "WalletClient is required to write to a contract");
       (0, import_ts_essentials5.assert)(publicClient, "PublicClient is required to simulate contract before writing");
@@ -2754,6 +2770,138 @@ function useCofheWriteContract(options) {
   };
 }
 
+// src/hooks/useTransactionGlobalLifecycle.ts
+
+var TOAST_DELAY_MS = 1e4;
+function useTransactionGlobalToastsLifecycle() {
+  const { addToast } = usePortalToasts();
+  return {
+    // 1.tx is submitted
+    onTransactionSubmitted: (transaction) => {
+      cofheLogger.log("____ Transaction submitted:", transaction);
+      addToast(
+        {
+          variant: "info",
+          title: `${transaction.actionType}  Transaction Submitted`,
+          description: `${transaction.actionType} transaction has been submitted.`,
+          transaction: {
+            hash: transaction.hash,
+            chainId: transaction.chainId
+          }
+        },
+        TOAST_DELAY_MS
+      );
+    },
+    onTransactionSubmitError: (error, transactionType) => {
+      let humanReadableError;
+      if (error instanceof _viem.ContractFunctionExecutionError) {
+        if (error.cause instanceof _viem.ContractFunctionRevertedError) {
+          const reasonOfRevert = error.cause.raw;
+          if (typeof reasonOfRevert === "string") {
+            humanReadableError = cofheHumanizeRevertReason(reasonOfRevert);
+          }
+        }
+      }
+      cofheLogger.error("____ Transaction submission failed for type:", transactionType, "with error:", error);
+      addToast(
+        {
+          variant: "error",
+          title: `${transactionType} Transaction Submission Failed`,
+          description: _nullishCoalesce(humanReadableError, () => ( (error instanceof Error ? error.message : "An unknown error occurred during transaction submission.")))
+        },
+        TOAST_DELAY_MS
+      );
+    },
+    // 2.a. tx is mined (could be success or fail)
+    onTransactionMined: (transaction, receipt) => {
+      cofheLogger.log("____ Transaction mined:", transaction, "with receipt:", receipt);
+      if (receipt.status === "success") {
+        addToast(
+          {
+            variant: "success",
+            title: `${transaction.actionType} Transaction Mined`,
+            description: `${transaction.actionType} transaction has been mined.`,
+            transaction: {
+              hash: transaction.hash,
+              chainId: transaction.chainId
+            }
+          },
+          TOAST_DELAY_MS
+        );
+      } else {
+        addToast(
+          {
+            variant: "error",
+            title: `${transaction.actionType} Transaction Failed`,
+            description: `${transaction.actionType} transaction has failed.`,
+            transaction: {
+              hash: transaction.hash,
+              chainId: transaction.chainId
+            }
+          },
+          TOAST_DELAY_MS
+        );
+      }
+    },
+    // 2.b. tx receipt fetch failed
+    onWatchReceiptFailure: (error, transaction) => {
+      cofheLogger.error("____ Transaction receipt fetch failed for tx:", transaction, "with error:", error);
+      addToast(
+        {
+          variant: "error",
+          title: `${transaction.actionType} Transaction Fetch Failed`,
+          description: `Fetching ${transaction.actionType} transaction has failed.`,
+          transaction: {
+            hash: transaction.hash,
+            chainId: transaction.chainId
+          }
+        },
+        TOAST_DELAY_MS
+      );
+    }
+  };
+}
+function useTransactionGlobalLifecycle() {
+  const {
+    onTransactionSubmitted: handleToastsOnTransactionSubmitted,
+    onTransactionMined: handleToastsOnTransactionMined,
+    onWatchReceiptFailure: handleToastsOnWatchReceiptFailure,
+    onTransactionSubmitError: handleToastsOnTransactionSubmitError
+  } = useTransactionGlobalToastsLifecycle();
+  return {
+    onTransactionSubmitted: handleToastsOnTransactionSubmitted,
+    onTransactionMined: handleToastsOnTransactionMined,
+    onWatchReceiptFailure: handleToastsOnWatchReceiptFailure,
+    onTransactionSubmitError: handleToastsOnTransactionSubmitError
+  };
+}
+
+// src/hooks/useCofheTokenApprove.ts
+function useCofheTokenApprove(writeMutationOptions) {
+  const { onSuccess: passedOnSuccess, onError: passedOnError, ...restOfOptions } = writeMutationOptions || {};
+  const { onTransactionSubmitError } = useTransactionGlobalLifecycle();
+  return useCofheWriteContract({
+    ...restOfOptions,
+    onError: (error, variables, onMutateResult, context) => {
+      if (passedOnError) passedOnError(error, variables, onMutateResult, context);
+      onTransactionSubmitError(error, TransactionActionType.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: TransactionActionType.Approve,
+        account
+      });
+    }
+  });
+}
+
 // src/hooks/useCofheTokenLists.ts
 
 
@@ -3209,7 +3357,7 @@ function getShieldApproveContractConfig() {
 }
 function getShieldEthContractConfig(token) {
   const contracts = getShieldContractsForToken(token);
-  if (!_optionalChain([contracts, 'optionalAccess', _96 => _96.native])) {
+  if (!_optionalChain([contracts, 'optionalAccess', _97 => _97.native])) {
     throw new Error(
       `shield ETH config is not defined for confidentialityType: ${token.extensions.fhenix.confidentialityType}`
     );
@@ -3218,7 +3366,7 @@ function getShieldEthContractConfig(token) {
 }
 function getShieldWrappedPairContractConfig(token) {
   const contracts = getShieldContractsForToken(token);
-  if (!_optionalChain([contracts, 'optionalAccess', _97 => _97.wrappedPair])) {
+  if (!_optionalChain([contracts, 'optionalAccess', _98 => _98.wrappedPair])) {
     throw new Error(
       `shield wrapped pair config is not defined for confidentialityType: ${token.extensions.fhenix.confidentialityType}`
     );
@@ -3241,7 +3389,7 @@ function getClaimSingleContractConfig(confidentialityType) {
 }
 function getClaimAllContractConfig(confidentialityType) {
   const contracts = getContractsForType(confidentialityType).claims;
-  if (!_optionalChain([contracts, 'optionalAccess', _98 => _98.all])) {
+  if (!_optionalChain([contracts, 'optionalAccess', _99 => _99.all])) {
     throw new Error(`claim-all config is not defined for confidentialityType: ${confidentialityType}`);
   }
   return contracts.all;
@@ -3292,7 +3440,7 @@ function useResolvedCofheToken({ chainId: _chainId, address }, queryOptions) {
   const cofheChainId = useCofheChainId();
   const chainId = _nullishCoalesce(_chainId, () => ( cofheChainId));
   return useInternalQuery({
-    queryKey: ["resolvedCofheToken", chainId, _optionalChain([address, 'optionalAccess', _99 => _99.toLowerCase, 'call', _100 => _100()])],
+    queryKey: ["resolvedCofheToken", chainId, _optionalChain([address, 'optionalAccess', _100 => _100.toLowerCase, 'call', _101 => _101()])],
     queryFn: async () => {
       if (!publicClient) {
         throw new Error("PublicClient is required to resolve a token");
@@ -3379,8 +3527,8 @@ function useResolvedCofheToken({ chainId: _chainId, address }, queryOptions) {
               ],
               allowFailure: true
             });
-            const pairDecimals = _optionalChain([pairMetadata, 'access', _101 => _101[0], 'optionalAccess', _102 => _102.status]) === "success" ? pairMetadata[0].result : void 0;
-            const pairSymbol = _optionalChain([pairMetadata, 'access', _103 => _103[1], 'optionalAccess', _104 => _104.status]) === "success" ? pairMetadata[1].result : void 0;
+            const pairDecimals = _optionalChain([pairMetadata, 'access', _102 => _102[0], 'optionalAccess', _103 => _103.status]) === "success" ? pairMetadata[0].result : void 0;
+            const pairSymbol = _optionalChain([pairMetadata, 'access', _104 => _104[1], 'optionalAccess', _105 => _105.status]) === "success" ? pairMetadata[1].result : void 0;
             if (pairDecimals != null && pairSymbol != null) {
               erc20Pair = {
                 address: pairAddress,
@@ -3406,7 +3554,7 @@ function useResolvedCofheToken({ chainId: _chainId, address }, queryOptions) {
         erc20Pair
       });
     },
-    enabled: (_nullishCoalesce(_optionalChain([queryOptions, 'optionalAccess', _105 => _105.enabled]), () => ( true))) && !!publicClient && !!chainId && !!address,
+    enabled: (_nullishCoalesce(_optionalChain([queryOptions, 'optionalAccess', _106 => _106.enabled]), () => ( true))) && !!publicClient && !!chainId && !!address,
     staleTime: Infinity,
     ...queryOptions
   });
@@ -3414,7 +3562,7 @@ function useResolvedCofheToken({ chainId: _chainId, address }, queryOptions) {
 
 // src/hooks/useCofheTokenLists.ts
 function isSupportedToken(token) {
-  const confidentialityType = _optionalChain([token, 'access', _106 => _106.extensions, 'optionalAccess', _107 => _107.fhenix, 'optionalAccess', _108 => _108.confidentialityType]);
+  const confidentialityType = _optionalChain([token, 'access', _107 => _107.extensions, 'optionalAccess', _108 => _108.fhenix, 'optionalAccess', _109 => _109.confidentialityType]);
   return isSupportedTokenConfidentialityType(confidentialityType);
 }
 var TokenListFetchError = class extends Error {
@@ -3431,8 +3579,8 @@ function getCustomTokensForChain(customTokensByChainId, chainId) {
 }
 function useCofheTokenLists({ chainId }, queryOptions) {
   const widgetConfig = useCofheContext().client.config.react;
-  const tokensListsUrls = chainId ? _optionalChain([widgetConfig, 'access', _109 => _109.tokenLists, 'optionalAccess', _110 => _110[chainId]]) : [];
-  const queriesOptions = _optionalChain([tokensListsUrls, 'optionalAccess', _111 => _111.map, 'call', _112 => _112((url) => ({
+  const tokensListsUrls = chainId ? _optionalChain([widgetConfig, 'access', _110 => _110.tokenLists, 'optionalAccess', _111 => _111[chainId]]) : [];
+  const queriesOptions = _optionalChain([tokensListsUrls, 'optionalAccess', _112 => _112.map, 'call', _113 => _113((url) => ({
     cacheTime: Infinity,
     staleTime: Infinity,
     refetchOnMount: false,
@@ -3512,7 +3660,7 @@ function useCofheToken({ chainId: _chainId, address }, metdataQueryOptions) {
     },
     {
       ...metdataQueryOptions,
-      enabled: (_nullishCoalesce(_optionalChain([metdataQueryOptions, 'optionalAccess', _113 => _113.enabled]), () => ( true))) && !!address && !!chainId && !tokenFromList
+      enabled: (_nullishCoalesce(_optionalChain([metdataQueryOptions, 'optionalAccess', _114 => _114.enabled]), () => ( true))) && !!address && !!chainId && !tokenFromList
     }
   );
   return _nullishCoalesce(tokenFromList, () => ( resolvedToken.data));
@@ -3620,10 +3768,10 @@ async function fetchUnshieldClaimsSummary({
 }
 function useCofheTokenClaimable({ accountAddress: account, token }, queryOptions) {
   const publicClient = useCofhePublicClient();
-  const confidentialityType = _optionalChain([token, 'optionalAccess', _114 => _114.extensions, 'access', _115 => _115.fhenix, 'access', _116 => _116.confidentialityType]);
+  const confidentialityType = _optionalChain([token, 'optionalAccess', _115 => _115.extensions, 'access', _116 => _116.fhenix, 'access', _117 => _117.confidentialityType]);
   const queryKey = constructUnshieldClaimsQueryKey({
-    chainId: _optionalChain([token, 'optionalAccess', _117 => _117.chainId]),
-    tokenAddress: _optionalChain([token, 'optionalAccess', _118 => _118.address]),
+    chainId: _optionalChain([token, 'optionalAccess', _118 => _118.chainId]),
+    tokenAddress: _optionalChain([token, 'optionalAccess', _119 => _119.address]),
     confidentialityType,
     accountAddress: account
   });
@@ -3644,7 +3792,7 @@ function useCofheTokenClaimable({ accountAddress: account, token }, queryOptions
         accountAddress: account,
         confidentialityType,
         signal,
-        blockHashToBeAwareOf: _optionalChain([invalidationContext, 'optionalAccess', _119 => _119.blockHashToBeAwareOf])
+        blockHashToBeAwareOf: _optionalChain([invalidationContext, 'optionalAccess', _120 => _120.blockHashToBeAwareOf])
       });
     }),
     refetchOnMount: false,
@@ -3661,114 +3809,6 @@ function useCofheTokenClaimable({ accountAddress: account, token }, queryOptions
 var import_ts_essentials7 = __toESM(require_dist(), 1);
 
 
-
-// src/hooks/useTransactionGlobalLifecycle.ts
-
-var TOAST_DELAY_MS = 1e4;
-function useTransactionGlobalToastsLifecycle() {
-  const { addToast } = usePortalToasts();
-  return {
-    // 1.tx is submitted
-    onTransactionSubmitted: (transaction) => {
-      cofheLogger.log("____ Transaction submitted:", transaction);
-      addToast(
-        {
-          variant: "info",
-          title: `${transaction.actionType}  Transaction Submitted`,
-          description: `${transaction.actionType} transaction has been submitted.`,
-          transaction: {
-            hash: transaction.hash,
-            chainId: transaction.chainId
-          }
-        },
-        TOAST_DELAY_MS
-      );
-    },
-    onTransactionSubmitError: (error, transactionType) => {
-      let humanReadableError;
-      if (error instanceof _viem.ContractFunctionExecutionError) {
-        if (error.cause instanceof _viem.ContractFunctionRevertedError) {
-          const reasonOfRevert = error.cause.raw;
-          if (typeof reasonOfRevert === "string") {
-            humanReadableError = cofheHumanizeRevertReason(reasonOfRevert);
-          }
-        }
-      }
-      cofheLogger.error("____ Transaction submission failed for type:", transactionType, "with error:", error);
-      addToast(
-        {
-          variant: "error",
-          title: `${transactionType} Transaction Submission Failed`,
-          description: _nullishCoalesce(humanReadableError, () => ( (error instanceof Error ? error.message : "An unknown error occurred during transaction submission.")))
-        },
-        TOAST_DELAY_MS
-      );
-    },
-    // 2.a. tx is mined (could be success or fail)
-    onTransactionMined: (transaction, receipt) => {
-      cofheLogger.log("____ Transaction mined:", transaction, "with receipt:", receipt);
-      if (receipt.status === "success") {
-        addToast(
-          {
-            variant: "success",
-            title: `${transaction.actionType} Transaction Mined`,
-            description: `${transaction.actionType} transaction has been mined.`,
-            transaction: {
-              hash: transaction.hash,
-              chainId: transaction.chainId
-            }
-          },
-          TOAST_DELAY_MS
-        );
-      } else {
-        addToast(
-          {
-            variant: "error",
-            title: `${transaction.actionType} Transaction Failed`,
-            description: `${transaction.actionType} transaction has failed.`,
-            transaction: {
-              hash: transaction.hash,
-              chainId: transaction.chainId
-            }
-          },
-          TOAST_DELAY_MS
-        );
-      }
-    },
-    // 2.b. tx receipt fetch failed
-    onWatchReceiptFailure: (error, transaction) => {
-      cofheLogger.error("____ Transaction receipt fetch failed for tx:", transaction, "with error:", error);
-      addToast(
-        {
-          variant: "error",
-          title: `${transaction.actionType} Transaction Fetch Failed`,
-          description: `Fetching ${transaction.actionType} transaction has failed.`,
-          transaction: {
-            hash: transaction.hash,
-            chainId: transaction.chainId
-          }
-        },
-        TOAST_DELAY_MS
-      );
-    }
-  };
-}
-function useTransactionGlobalLifecycle() {
-  const {
-    onTransactionSubmitted: handleToastsOnTransactionSubmitted,
-    onTransactionMined: handleToastsOnTransactionMined,
-    onWatchReceiptFailure: handleToastsOnWatchReceiptFailure,
-    onTransactionSubmitError: handleToastsOnTransactionSubmitError
-  } = useTransactionGlobalToastsLifecycle();
-  return {
-    onTransactionSubmitted: handleToastsOnTransactionSubmitted,
-    onTransactionMined: handleToastsOnTransactionMined,
-    onWatchReceiptFailure: handleToastsOnWatchReceiptFailure,
-    onTransactionSubmitError: handleToastsOnTransactionSubmitError
-  };
-}
-
-// src/hooks/useCofheTokenClaimUnshielded.ts
 function getCofheTokenClaimUnshieldedCallArgs(params) {
   const { token, account, claim, claims } = params;
   const tokenAddress = token.address;
@@ -3789,7 +3829,7 @@ function getCofheTokenClaimUnshieldedCallArgs(params) {
       chain: void 0
     };
   }
-  if (!_optionalChain([claims, 'optionalAccess', _120 => _120.length])) {
+  if (!_optionalChain([claims, 'optionalAccess', _121 => _121.length])) {
     return void 0;
   }
   const contractConfig = getClaimAllContractConfig(confidentialityType);
@@ -3868,7 +3908,7 @@ function useCofheTokenClaimUnshielded(options) {
               token: input.token,
               tokenAmount: decryptResult.decryptedValue,
               chainId,
-              actionType: "claim" /* Claim */,
+              actionType: TransactionActionType.Claim,
               account
             });
           } catch (error) {
@@ -3928,7 +3968,7 @@ function useCofheTokenClaimUnshielded(options) {
     },
     onError: (error, variables, onMutateResult, context) => {
       if (onError) onError(error, variables, onMutateResult, context);
-      onTransactionSubmitError(error, "claim" /* Claim */);
+      onTransactionSubmitError(error, TransactionActionType.Claim);
     },
     onSuccess: async (hash, input, onMutateResult, context) => {
       (0, import_ts_essentials7.assert)(chainId, "Chain ID is required for claim");
@@ -3942,7 +3982,7 @@ function useCofheTokenClaimUnshielded(options) {
         token: input.token,
         tokenAmount: input.amount,
         chainId,
-        actionType: "claim" /* Claim */,
+        actionType: TransactionActionType.Claim,
         account
       });
     },
@@ -3967,7 +4007,7 @@ function useCofheDecrypt({
   const enabled = !!input && BigInt(input.ctHash) > 0n && !!client && (_nullishCoalesce(userEnabled, () => ( true)));
   return useInternalQuery({
     enabled,
-    queryKey: ["decryptCiphertext", _optionalChain([input, 'optionalAccess', _121 => _121.ctHash, 'access', _122 => _122.toString, 'call', _123 => _123()]), _optionalChain([input, 'optionalAccess', _124 => _124.utype])],
+    queryKey: ["decryptCiphertext", _optionalChain([input, 'optionalAccess', _122 => _122.ctHash, 'access', _123 => _123.toString, 'call', _124 => _124()]), _optionalChain([input, 'optionalAccess', _125 => _125.utype])],
     queryFn: async () => {
       (0, import_ts_essentials8.assert)(input, "input is guaranteed to be defined by enabled condition");
       const builder = client.decryptForView(input.ctHash, input.utype);
@@ -4026,7 +4066,7 @@ function useCofheReadContractAndDecrypt(params, {
 
 
 
-var import_ts_essentials9 = __toESM(require_dist(), 1);
+var import_ts_essentials9 = __toESM(require_dist());
 
 // src/utils/format.ts
 var _bignumberjs = require('bignumber.js'); var _bignumberjs2 = _interopRequireDefault(_bignumberjs);
@@ -4039,58 +4079,173 @@ function formatTokenAmount(amount, decimals, displayDecimals) {
     // the only precise way, without parseFloat
   };
 }
-function unitToWei(amount, decimals) {
-  return BigInt(new (0, _bignumberjs2.default)(amount).multipliedBy(10 ** decimals).toFixed(0));
-}
-function formatUsdAmount(amount, displayDecimals = 2) {
-  const amountBN = _bignumberjs2.default.isBigNumber(amount) ? amount : new (0, _bignumberjs2.default)(amount);
-  return `$${amountBN.toFormat(displayDecimals)}`;
+function unitToWei(amount, decimals) {
+  return BigInt(new (0, _bignumberjs2.default)(amount).multipliedBy(10 ** decimals).toFixed(0));
+}
+function formatUsdAmount(amount, displayDecimals = 2) {
+  const amountBN = _bignumberjs2.default.isBigNumber(amount) ? amount : new (0, _bignumberjs2.default)(amount);
+  return `$${amountBN.toFormat(displayDecimals)}`;
+}
+
+// src/hooks/useCofheTokenDecryptedBalance.ts
+function useCofheTokenDecryptedBalance({ token, accountAddress, displayDecimals = 5 }, options) {
+  const { enabled: userEnabled = true, ...restOptions } = _nullishCoalesce(options, () => ( {}));
+  const contractConfig = token && getTokenContractConfig(token.extensions.fhenix.confidentialityType);
+  const {
+    decrypted: { data: decryptedData, isFetching: isDecryptionFetching },
+    encrypted: { isFetching: isEncryptedFetching, refetch: refetchCiphertext },
+    disabledDueToMissingValidPermit
+  } = useCofheReadContractAndDecrypt(
+    {
+      address: _optionalChain([token, 'optionalAccess', _126 => _126.address]),
+      abi: _optionalChain([contractConfig, 'optionalAccess', _127 => _127.abi]),
+      functionName: _optionalChain([contractConfig, 'optionalAccess', _128 => _128.functionName]),
+      args: accountAddress ? [accountAddress] : void 0,
+      requiresPermit: true
+    },
+    {
+      readQueryOptions: {
+        refetchOnMount: false,
+        enabled: userEnabled && !!token
+      },
+      decryptingQueryOptions: {
+        refetchOnMount: false,
+        select: (amountWei) => {
+          (0, import_ts_essentials9.assert)(token, "Token must be defined to format confidential balance");
+          if (typeof amountWei !== "bigint") {
+            throw new Error("Expected bigint from confidential decryption");
+          }
+          return formatTokenAmount(amountWei, token.decimals, displayDecimals);
+        }
+      },
+      ...restOptions
+    }
+  );
+  return {
+    disabledDueToMissingValidPermit,
+    data: decryptedData,
+    isFetching: isDecryptionFetching || isEncryptedFetching,
+    refetch: refetchCiphertext
+  };
+}
+
+// src/hooks/useCofheTokenPublicBalance.ts
+var import_ts_essentials10 = __toESM(require_dist(), 1);
+
+
+function constructPublicTokenBalanceQueryKey({
+  chainId,
+  accountAddress,
+  tokenAddress
+}) {
+  return ["tokenBalance", chainId, _optionalChain([accountAddress, 'optionalAccess', _129 => _129.toLowerCase, 'call', _130 => _130()]), _optionalChain([tokenAddress, 'optionalAccess', _131 => _131.toLowerCase, 'call', _132 => _132()])];
+}
+function constructPublicTokenBalanceQueryKeyForInvalidation({
+  chainId,
+  accountAddress,
+  tokenAddress
+}) {
+  return constructPublicTokenBalanceQueryKey({
+    chainId,
+    accountAddress,
+    tokenAddress
+  });
+}
+function getPublicTokenBalanceSource(token) {
+  const confidentialityType = _optionalChain([token, 'optionalAccess', _133 => _133.extensions, 'access', _134 => _134.fhenix, 'access', _135 => _135.confidentialityType]);
+  const underlyingErc20 = _optionalChain([token, 'optionalAccess', _136 => _136.extensions, 'access', _137 => _137.fhenix, 'access', _138 => _138.erc20Pair]);
+  const publicBalanceSourceType = getPublicBalanceSourceType(confidentialityType);
+  const tokenToFetchBalanceFrom = publicBalanceSourceType === "erc20Pair" ? underlyingErc20 : publicBalanceSourceType === "token" ? token : void 0;
+  if (!tokenToFetchBalanceFrom) return void 0;
+  return {
+    address: tokenToFetchBalanceFrom.address,
+    decimals: tokenToFetchBalanceFrom.decimals
+  };
+}
+function createPublicTokenBalanceQueryOptions(params) {
+  const { publicClient, accountAddress, tokenAddress, queryOptions } = params;
+  const { enabled: userEnabled, ...restQueryOptions } = _nullishCoalesce(queryOptions, () => ( {}));
+  const baseEnabled = !!publicClient && !!accountAddress && !!tokenAddress;
+  const enabled = baseEnabled && (_nullishCoalesce(userEnabled, () => ( true)));
+  const queryKey = constructPublicTokenBalanceQueryKey({
+    chainId: _optionalChain([publicClient, 'optionalAccess', _139 => _139.chain, 'optionalAccess', _140 => _140.id]),
+    accountAddress,
+    tokenAddress
+  });
+  return {
+    queryKey,
+    queryFn: withInvalidationContext(
+      async ({ invalidationContext, signal }) => {
+        (0, import_ts_essentials10.assert)(tokenAddress, "Token address is required to fetch token balance");
+        (0, import_ts_essentials10.assert)(publicClient, "PublicClient is required to fetch token balance");
+        (0, import_ts_essentials10.assert)(accountAddress, "Account address is required to fetch token balance");
+        const isNativeToken = tokenAddress.toLowerCase() === ETH_ADDRESS_LOWERCASE;
+        const balance = await maybeWaitUntilRpcAware(
+          publicClient,
+          {
+            blockHashToBeAwareOf: _optionalChain([invalidationContext, 'optionalAccess', _141 => _141.blockHashToBeAwareOf]),
+            readDescription: isNativeToken ? "read native balance" : "read ERC20 balance",
+            read: () => isNativeToken ? publicClient.getBalance({
+              address: accountAddress
+            }) : publicClient.readContract({
+              address: tokenAddress,
+              abi: ERC20_BALANCE_OF_ABI,
+              functionName: "balanceOf",
+              args: [accountAddress]
+            })
+          },
+          { signal }
+        );
+        return balance;
+      }
+    ),
+    enabled,
+    refetchOnMount: false,
+    ...restQueryOptions
+  };
+}
+function useTokenBalance({ tokenAddress, accountAddress }, queryOptions) {
+  const publicClient = useCofhePublicClient();
+  return useInternalQuery(
+    createPublicTokenBalanceQueryOptions({
+      publicClient,
+      accountAddress,
+      tokenAddress,
+      queryOptions
+    })
+  );
 }
-
-// src/hooks/useCofheTokenDecryptedBalance.ts
-function useCofheTokenDecryptedBalance({ token, accountAddress, displayDecimals = 5 }, options) {
+function useCofheTokenPublicBalance({ token, accountAddress, displayDecimals = 5 }, options) {
+  const connectedAccount = useCofheAccount();
+  const account = accountAddress || connectedAccount;
   const { enabled: userEnabled = true, ...restOptions } = _nullishCoalesce(options, () => ( {}));
-  const contractConfig = token && getTokenContractConfig(token.extensions.fhenix.confidentialityType);
-  const {
-    decrypted: { data: decryptedData, isFetching: isDecryptionFetching },
-    encrypted: { isFetching: isEncryptedFetching, refetch: refetchCiphertext },
-    disabledDueToMissingValidPermit
-  } = useCofheReadContractAndDecrypt(
+  const tokenToFetchBalanceFrom = getPublicTokenBalanceSource(token);
+  const { data, isFetching, refetch } = useTokenBalance(
     {
-      address: _optionalChain([token, 'optionalAccess', _125 => _125.address]),
-      abi: _optionalChain([contractConfig, 'optionalAccess', _126 => _126.abi]),
-      functionName: _optionalChain([contractConfig, 'optionalAccess', _127 => _127.functionName]),
-      args: accountAddress ? [accountAddress] : void 0,
-      requiresPermit: true
+      tokenAddress: _optionalChain([tokenToFetchBalanceFrom, 'optionalAccess', _142 => _142.address]),
+      accountAddress: account
     },
     {
-      readQueryOptions: {
-        refetchOnMount: false,
-        enabled: userEnabled && !!token
-      },
-      decryptingQueryOptions: {
-        refetchOnMount: false,
-        select: (amountWei) => {
-          (0, import_ts_essentials9.assert)(token, "Token must be defined to format confidential balance");
-          if (typeof amountWei !== "bigint") {
-            throw new Error("Expected bigint from confidential decryption");
-          }
-          return formatTokenAmount(amountWei, token.decimals, displayDecimals);
-        }
+      enabled: userEnabled,
+      select: (value) => {
+        (0, import_ts_essentials10.assert)(
+          typeof _optionalChain([tokenToFetchBalanceFrom, 'optionalAccess', _143 => _143.decimals]) === "number",
+          "Token decimals must be defined to format public token balance"
+        );
+        return formatTokenAmount(value, tokenToFetchBalanceFrom.decimals, displayDecimals);
       },
       ...restOptions
     }
   );
   return {
-    disabledDueToMissingValidPermit,
-    data: decryptedData,
-    isFetching: isDecryptionFetching || isEncryptedFetching,
-    refetch: refetchCiphertext
+    data,
+    isFetching,
+    refetch
   };
 }
 
 // src/hooks/useCofheTokensClaimable.ts
-var import_ts_essentials11 = __toESM(require_dist(), 1);
+var import_ts_essentials12 = __toESM(require_dist(), 1);
 
 
 
@@ -4100,9 +4255,9 @@ var import_ts_essentials11 = __toESM(require_dist(), 1);
 function useNormalizedList(items, options) {
   return _react.useMemo.call(void 0, () => {
     if (!items || items.length === 0) return [];
-    const filter2 = _optionalChain([options, 'optionalAccess', _128 => _128.filter]);
-    const dedupeKey = _optionalChain([options, 'optionalAccess', _129 => _129.dedupeKey]);
-    const sort = _optionalChain([options, 'optionalAccess', _130 => _130.sort]);
+    const filter2 = _optionalChain([options, 'optionalAccess', _144 => _144.filter]);
+    const dedupeKey = _optionalChain([options, 'optionalAccess', _145 => _145.dedupeKey]);
+    const sort = _optionalChain([options, 'optionalAccess', _146 => _146.sort]);
     const filtered = filter2 ? items.filter(filter2) : items;
     const deduped = (() => {
       if (!dedupeKey) return filtered;
@@ -4118,11 +4273,11 @@ function useNormalizedList(items, options) {
     })();
     if (sort) deduped.sort(sort);
     return deduped;
-  }, [items, _optionalChain([options, 'optionalAccess', _131 => _131.dedupeKey]), _optionalChain([options, 'optionalAccess', _132 => _132.filter]), _optionalChain([options, 'optionalAccess', _133 => _133.sort])]);
+  }, [items, _optionalChain([options, 'optionalAccess', _147 => _147.dedupeKey]), _optionalChain([options, 'optionalAccess', _148 => _148.filter]), _optionalChain([options, 'optionalAccess', _149 => _149.sort])]);
 }
 
 // src/hooks/useStoredTransactions.ts
-var import_ts_essentials10 = __toESM(require_dist());
+var import_ts_essentials11 = __toESM(require_dist());
 
 function useStoredTransactions({
   chainId,
@@ -4152,10 +4307,10 @@ function useStoredTransactions({
     [transactionsAsArray, filter2, account]
   );
   const reduced = _react.useMemo.call(void 0, () => {
-    return _optionalChain([reducer, 'optionalCall', _134 => _134(filtered)]);
+    return _optionalChain([reducer, 'optionalCall', _150 => _150(filtered)]);
   }, [filtered, reducer]);
   const uniqueHashes = new Set(filtered.map((tx) => tx.hash));
-  (0, import_ts_essentials10.assert)(
+  (0, import_ts_essentials11.assert)(
     uniqueHashes.size === filtered.length,
     "There should be no duplicate transactions with the same hash in the result"
   );
@@ -4178,7 +4333,7 @@ function useStoredTransactions({
 
 // src/hooks/useCofheTokensClaimable.ts
 function isClaimableToken(token) {
-  return isTokenConfidentialityTypeClaimable(_optionalChain([token, 'access', _135 => _135.extensions, 'optionalAccess', _136 => _136.fhenix, 'optionalAccess', _137 => _137.confidentialityType]));
+  return isTokenConfidentialityTypeClaimable(_optionalChain([token, 'access', _151 => _151.extensions, 'optionalAccess', _152 => _152.fhenix, 'optionalAccess', _153 => _153.confidentialityType]));
 }
 function claimableDedupeKey(token) {
   const confidentialityType = token.extensions.fhenix.confidentialityType;
@@ -4188,10 +4343,11 @@ function claimableSort(a, b) {
   if (a.chainId !== b.chainId) return a.chainId - b.chainId;
   return a.address.toLowerCase().localeCompare(b.address.toLowerCase());
 }
-var pendingClaimsFilter = (tx) => tx.actionType === "claim" /* Claim */ && tx.status === "pending" /* Pending */;
-var pendingUnshieldsFilter = (tx) => tx.actionType === "unshield" /* Unshield */ && tx.status === "pending" /* Pending */;
+var pendingClaimsFilter = (tx) => tx.actionType === TransactionActionType.Claim && tx.status === "pending" /* Pending */;
+var pendingUnshieldsFilter = (tx) => tx.actionType === TransactionActionType.Unshield && tx.status === "pending" /* Pending */;
 var asBooleanByTokenAddressLowercase = (txs) => {
   return txs.reduce((acc, tx) => {
+    if (!tx.token) return acc;
     const key = tx.token.address.toLowerCase();
     acc[key] = true;
     return acc;
@@ -4230,19 +4386,19 @@ function useCofheTokensClaimable({ tokens, accountAddress: account }, queryOptio
       return {
         queryKey,
         queryFn: withInvalidationContext(async ({ signal, invalidationContext }) => {
-          (0, import_ts_essentials11.assert)(
+          (0, import_ts_essentials12.assert)(
             isTokenConfidentialityTypeClaimable(confidentialityType),
             "confidentialityType narrowed by token guard"
           );
-          (0, import_ts_essentials11.assert)(account, "account is required to fetch unshield claims");
-          (0, import_ts_essentials11.assert)(publicClient, "publicClient is required to fetch unshield claims");
+          (0, import_ts_essentials12.assert)(account, "account is required to fetch unshield claims");
+          (0, import_ts_essentials12.assert)(publicClient, "publicClient is required to fetch unshield claims");
           return fetchUnshieldClaimsSummary({
             publicClient,
             token,
             accountAddress: account,
             confidentialityType,
             signal,
-            blockHashToBeAwareOf: _optionalChain([invalidationContext, 'optionalAccess', _138 => _138.blockHashToBeAwareOf])
+            blockHashToBeAwareOf: _optionalChain([invalidationContext, 'optionalAccess', _154 => _154.blockHashToBeAwareOf])
           });
         }),
         refetchOnMount: false,
@@ -4298,7 +4454,7 @@ function useCofheTokensClaimable({ tokens, accountAddress: account }, queryOptio
 // src/hooks/useCofheTokenShield.ts
 
 
-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;
@@ -4307,8 +4463,8 @@ function getCofheTokenShieldCallArgs(params) {
     throw new Error("confidentialityType is required in token extensions");
   }
   assertTokenOperationSupported(confidentialityType, "shield");
-  const erc20PairAddress = _optionalChain([token, 'access', _139 => _139.extensions, 'access', _140 => _140.fhenix, 'access', _141 => _141.erc20Pair, 'optionalAccess', _142 => _142.address]);
-  const isEth = _optionalChain([erc20PairAddress, 'optionalAccess', _143 => _143.toLowerCase, 'call', _144 => _144()]) === ETH_ADDRESS_LOWERCASE;
+  const erc20PairAddress = _optionalChain([token, 'access', _155 => _155.extensions, 'access', _156 => _156.fhenix, 'access', _157 => _157.erc20Pair, 'optionalAccess', _158 => _158.address]);
+  const isEth = _optionalChain([erc20PairAddress, 'optionalAccess', _159 => _159.toLowerCase, 'call', _160 => _160()]) === ETH_ADDRESS_LOWERCASE;
   if (isEth) {
     const contractConfig2 = getShieldEthContractConfig(token);
     return {
@@ -4380,8 +4536,8 @@ function useCofheTokenShield(options) {
       }
       assertTokenOperationSupported(confidentialityType, "shield");
       let hash;
-      const erc20PairAddress = _optionalChain([input, 'access', _145 => _145.token, 'access', _146 => _146.extensions, 'access', _147 => _147.fhenix, 'access', _148 => _148.erc20Pair, 'optionalAccess', _149 => _149.address]);
-      const isEth = _optionalChain([erc20PairAddress, 'optionalAccess', _150 => _150.toLowerCase, 'call', _151 => _151()]) === ETH_ADDRESS_LOWERCASE;
+      const erc20PairAddress = _optionalChain([input, 'access', _161 => _161.token, 'access', _162 => _162.extensions, 'access', _163 => _163.fhenix, 'access', _164 => _164.erc20Pair, 'optionalAccess', _165 => _165.address]);
+      const isEth = _optionalChain([erc20PairAddress, 'optionalAccess', _166 => _166.toLowerCase, 'call', _167 => _167()]) === ETH_ADDRESS_LOWERCASE;
       const { main: shieldCallArgs } = getCofheTokenShieldCallArgs({
         token: input.token,
         amount: input.amount,
@@ -4394,7 +4550,7 @@ function useCofheTokenShield(options) {
         });
         hash = await walletClient.writeContract({ ...request, chain: void 0 });
       } else {
-        _optionalChain([input, 'access', _152 => _152.onStatusChange, 'optionalCall', _153 => _153("Please confirm shield in wallet...")]);
+        _optionalChain([input, 'access', _168 => _168.onStatusChange, 'optionalCall', _169 => _169("Please confirm shield in wallet...")]);
         const { request: shieldRequest } = await publicClient.simulateContract({
           ...shieldCallArgs,
           account: walletClient.account
@@ -4405,18 +4561,18 @@ function useCofheTokenShield(options) {
     },
     onError: (error, variables, onMutateResult, context) => {
       if (onError) onError(error, variables, onMutateResult, context);
-      onTransactionSubmitError(error, "shield" /* Shield */);
+      onTransactionSubmitError(error, TransactionActionType.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,
         token: input.token,
         tokenAmount: input.amount,
         chainId,
-        actionType: "shield" /* Shield */,
+        actionType: TransactionActionType.Shield,
         account
       });
     },
@@ -4428,7 +4584,7 @@ function useCofheTokenShield(options) {
 
 
 // src/hooks/useCofheReadContracts.ts
-var import_ts_essentials13 = __toESM(require_dist(), 1);
+var import_ts_essentials14 = __toESM(require_dist(), 1);
 
 
 var QUERY_CACHE_PREFIX3 = "cofheReadContracts";
@@ -4462,7 +4618,7 @@ function useCofheReadContracts(params, queryOptions) {
     publicClient,
     cofheChainId,
     contracts,
-    userEnabled: _optionalChain([queryOptions, 'optionalAccess', _154 => _154.enabled])
+    userEnabled: _optionalChain([queryOptions, 'optionalAccess', _170 => _170.enabled])
   });
   const { enabled: _ignoredEnabled, ...restQueryOptions } = queryOptions || {};
   return useInternalQuery({
@@ -4470,11 +4626,11 @@ function useCofheReadContracts(params, queryOptions) {
     queryKey: constructCofheReadContractsQueryKey({
       cofheChainId,
       contracts,
-      allowFailure: _optionalChain([multicallOptions, 'optionalAccess', _155 => _155.allowFailure])
+      allowFailure: _optionalChain([multicallOptions, 'optionalAccess', _171 => _171.allowFailure])
     }),
     queryFn: async () => {
-      (0, import_ts_essentials13.assert)(publicClient, "PublicClient should be guaranteed by enabled check");
-      (0, import_ts_essentials13.assert)(contracts && contracts.length > 0, "Contracts should be guaranteed by enabled check");
+      (0, import_ts_essentials14.assert)(publicClient, "PublicClient should be guaranteed by enabled check");
+      (0, import_ts_essentials14.assert)(contracts && contracts.length > 0, "Contracts should be guaranteed by enabled check");
       const raw = await publicClient.multicall({
         contracts,
         ...multicallOptions || {}
@@ -4546,7 +4702,7 @@ function useCofheTokensWithExistingEncryptedBalances({ chainId: _chainId, accoun
     {
       refetchOnMount: false,
       ...queryOptions,
-      enabled: (_nullishCoalesce(_optionalChain([queryOptions, 'optionalAccess', _156 => _156.enabled]), () => ( true))) && !!account && tokens.length > 0
+      enabled: (_nullishCoalesce(_optionalChain([queryOptions, 'optionalAccess', _172 => _172.enabled]), () => ( true))) && !!account && tokens.length > 0
     }
   );
   const { tokensWithExistingEncryptedBalance, ctHashByTokenAddress, error } = _react.useMemo.call(void 0, () => {
@@ -4651,7 +4807,7 @@ function useCofheTokenTransfer(writeMutationOptions) {
     writingMutationOptions: {
       onError: (error, variables, onMutateResult, context) => {
         if (passedOnError) passedOnError(error, variables, onMutateResult, context);
-        onTransactionSubmitError(error, "shieldSend" /* ShieldSend */);
+        onTransactionSubmitError(error, TransactionActionType.ShieldSend);
       },
       onSuccess: (hash, variables, onMutateResult, context) => {
         if (passedOnSuccess) passedOnSuccess(hash, variables, onMutateResult, context);
@@ -4662,7 +4818,7 @@ function useCofheTokenTransfer(writeMutationOptions) {
           token: extras.token,
           tokenAmount: extras.amount,
           chainId: extras.token.chainId,
-          actionType: "shieldSend" /* ShieldSend */,
+          actionType: TransactionActionType.ShieldSend,
           account: extras.userAddress
         });
       },
@@ -4699,20 +4855,44 @@ function useCofheTokenTransfer(writeMutationOptions) {
   };
 }
 
+// src/hooks/useCofheTransactions.ts
+
+function addCofheTransaction(transaction) {
+  useTransactionStore.getState().addTransaction(transaction);
+}
+function useCofheTransactions() {
+  const transactions = useTransactionStore((state) => state.transactions);
+  const addTransaction = _react.useCallback.call(void 0, (transaction) => {
+    addCofheTransaction(transaction);
+  }, []);
+  const clearTransactions = useTransactionStore((state) => state.clearTransactions);
+  const getTransaction = useTransactionStore((state) => state.getTransaction);
+  const getAllTransactions = useTransactionStore((state) => state.getAllTransactions);
+  const getAllTransactionsByToken = useTransactionStore((state) => state.getAllTransactionsByToken);
+  return {
+    transactions,
+    addTransaction,
+    clearTransactions,
+    getTransaction,
+    getAllTransactions,
+    getAllTransactionsByToken
+  };
+}
+
 // src/hooks/useCofheTokenUnshield.ts
 
 
-var import_ts_essentials15 = __toESM(require_dist(), 1);
+var import_ts_essentials16 = __toESM(require_dist(), 1);
 
 // src/hooks/useStoredTransaction.ts
 
-var import_ts_essentials14 = __toESM(require_dist(), 1);
+var import_ts_essentials15 = __toESM(require_dist(), 1);
 function useStoredTransaction(txHash) {
   const filter2 = _react.useMemo.call(void 0, () => {
     return (tx) => tx.hash === txHash;
   }, [txHash]);
   const { filteredTxs } = useStoredTransactions({ filter: filter2 });
-  (0, import_ts_essentials14.assert)(filteredTxs.length <= 1, "There should be at most one transaction with a given hash");
+  (0, import_ts_essentials15.assert)(filteredTxs.length <= 1, "There should be at most one transaction with a given hash");
   return filteredTxs[0];
 }
 
@@ -4732,7 +4912,7 @@ function useOnceTransactionMined({
   });
   return {
     transaction,
-    isMining: _optionalChain([transaction, 'optionalAccess', _157 => _157.status]) === "pending"
+    isMining: _optionalChain([transaction, 'optionalAccess', _173 => _173.status]) === "pending"
   };
 }
 function useStoredTransactionStatusEffect({
@@ -4743,8 +4923,8 @@ function useStoredTransactionStatusEffect({
   const previousTransactionRef = _react.useRef.call(void 0, void 0);
   _react.useEffect.call(void 0, () => {
     if (!onTransactionStatusChange) return;
-    if (_optionalChain([previousTransactionRef, 'access', _158 => _158.current, 'optionalAccess', _159 => _159.status]) !== _optionalChain([transaction, 'optionalAccess', _160 => _160.status]) && !!transaction) {
-      onTransactionStatusChange(_optionalChain([previousTransactionRef, 'access', _161 => _161.current, 'optionalAccess', _162 => _162.status]), transaction.status, transaction);
+    if (_optionalChain([previousTransactionRef, 'access', _174 => _174.current, 'optionalAccess', _175 => _175.status]) !== _optionalChain([transaction, 'optionalAccess', _176 => _176.status]) && !!transaction) {
+      onTransactionStatusChange(_optionalChain([previousTransactionRef, 'access', _177 => _177.current, 'optionalAccess', _178 => _178.status]), transaction.status, transaction);
       previousTransactionRef.current = transaction;
     }
   }, [onTransactionStatusChange, transaction]);
@@ -4804,7 +4984,7 @@ function useCofheTokenUnshieldMutation(options) {
         amount: input.amount,
         account: walletClient.account.address
       });
-      _optionalChain([input, 'access', _163 => _163.onStatusChange, 'optionalCall', _164 => _164("Please confirm in wallet...")]);
+      _optionalChain([input, 'access', _179 => _179.onStatusChange, 'optionalCall', _180 => _180("Please confirm in wallet...")]);
       const { request } = await publicClient.simulateContract({
         ...unshieldCallArgs,
         account: walletClient.account
@@ -4814,18 +4994,18 @@ function useCofheTokenUnshieldMutation(options) {
     },
     onError: (error, variables, onMutateResult, context) => {
       if (onError) onError(error, variables, onMutateResult, context);
-      onTransactionSubmitError(error, "unshield" /* Unshield */);
+      onTransactionSubmitError(error, TransactionActionType.Unshield);
     },
     onSuccess: async (hash, input, onMutateResult, context) => {
-      (0, import_ts_essentials15.assert)(chainId, "Chain ID is required for token unshield");
-      (0, import_ts_essentials15.assert)(account, "Wallet account is required for token unshield");
+      (0, import_ts_essentials16.assert)(chainId, "Chain ID is required for token unshield");
+      (0, import_ts_essentials16.assert)(account, "Wallet account is required for token unshield");
       if (onSuccess) await onSuccess(hash, input, onMutateResult, context);
       useTransactionStore.getState().addTransaction({
         hash,
         token: input.token,
         tokenAmount: input.amount,
         chainId,
-        actionType: "unshield" /* Unshield */,
+        actionType: TransactionActionType.Unshield,
         account
       });
     },
@@ -4909,7 +5089,7 @@ function parseCoingeckoSimpleTokenPriceUsd({
 }) {
   const key = normalizeCoingeckoContractAddress(contractAddress);
   const obj = responseJson;
-  const usd = _optionalChain([obj, 'optionalAccess', _165 => _165[key], 'optionalAccess', _166 => _166.usd]);
+  const usd = _optionalChain([obj, 'optionalAccess', _181 => _181[key], 'optionalAccess', _182 => _182.usd]);
   if (typeof usd !== "number" || !Number.isFinite(usd)) return null;
   return usd;
 }
@@ -4918,7 +5098,7 @@ function parseCoingeckoSimplePriceUsd({
   coinId
 }) {
   const obj = responseJson;
-  const usd = _optionalChain([obj, 'optionalAccess', _167 => _167[coinId], 'optionalAccess', _168 => _168.usd]);
+  const usd = _optionalChain([obj, 'optionalAccess', _183 => _183[coinId], 'optionalAccess', _184 => _184.usd]);
   if (typeof usd !== "number" || !Number.isFinite(usd)) return null;
   return usd;
 }
@@ -4977,131 +5157,14 @@ function useCoingeckoUsdPrice({
       return parseCoingeckoSimpleTokenPriceUsd({ responseJson: json, contractAddress: tokenAddress });
     },
     // Reasonable defaults; consumer can override via queryOptions.
-    staleTime: _nullishCoalesce(_optionalChain([queryOptions, 'optionalAccess', _169 => _169.staleTime]), () => ( 6e4)),
-    refetchOnWindowFocus: _nullishCoalesce(_optionalChain([queryOptions, 'optionalAccess', _170 => _170.refetchOnWindowFocus]), () => ( false)),
+    staleTime: _nullishCoalesce(_optionalChain([queryOptions, 'optionalAccess', _185 => _185.staleTime]), () => ( 6e4)),
+    refetchOnWindowFocus: _nullishCoalesce(_optionalChain([queryOptions, 'optionalAccess', _186 => _186.refetchOnWindowFocus]), () => ( false)),
     ...queryOptions
   });
 }
 
 // src/hooks/useTokensWithPublicBalances.ts
 
-
-// src/hooks/useCofheTokenPublicBalance.ts
-var import_ts_essentials16 = __toESM(require_dist(), 1);
-
-
-function constructPublicTokenBalanceQueryKey({
-  chainId,
-  accountAddress,
-  tokenAddress
-}) {
-  return ["tokenBalance", chainId, _optionalChain([accountAddress, 'optionalAccess', _171 => _171.toLowerCase, 'call', _172 => _172()]), _optionalChain([tokenAddress, 'optionalAccess', _173 => _173.toLowerCase, 'call', _174 => _174()])];
-}
-function constructPublicTokenBalanceQueryKeyForInvalidation({
-  chainId,
-  accountAddress,
-  tokenAddress
-}) {
-  return constructPublicTokenBalanceQueryKey({
-    chainId,
-    accountAddress,
-    tokenAddress
-  });
-}
-function getPublicTokenBalanceSource(token) {
-  const confidentialityType = _optionalChain([token, 'optionalAccess', _175 => _175.extensions, 'access', _176 => _176.fhenix, 'access', _177 => _177.confidentialityType]);
-  const underlyingErc20 = _optionalChain([token, 'optionalAccess', _178 => _178.extensions, 'access', _179 => _179.fhenix, 'access', _180 => _180.erc20Pair]);
-  const publicBalanceSourceType = getPublicBalanceSourceType(confidentialityType);
-  const tokenToFetchBalanceFrom = publicBalanceSourceType === "erc20Pair" ? underlyingErc20 : publicBalanceSourceType === "token" ? token : void 0;
-  if (!tokenToFetchBalanceFrom) return void 0;
-  return {
-    address: tokenToFetchBalanceFrom.address,
-    decimals: tokenToFetchBalanceFrom.decimals
-  };
-}
-function createPublicTokenBalanceQueryOptions(params) {
-  const { publicClient, accountAddress, tokenAddress, queryOptions } = params;
-  const { enabled: userEnabled, ...restQueryOptions } = _nullishCoalesce(queryOptions, () => ( {}));
-  const baseEnabled = !!publicClient && !!accountAddress && !!tokenAddress;
-  const enabled = baseEnabled && (_nullishCoalesce(userEnabled, () => ( true)));
-  const queryKey = constructPublicTokenBalanceQueryKey({
-    chainId: _optionalChain([publicClient, 'optionalAccess', _181 => _181.chain, 'optionalAccess', _182 => _182.id]),
-    accountAddress,
-    tokenAddress
-  });
-  return {
-    queryKey,
-    queryFn: withInvalidationContext(
-      async ({ invalidationContext, signal }) => {
-        (0, import_ts_essentials16.assert)(tokenAddress, "Token address is required to fetch token balance");
-        (0, import_ts_essentials16.assert)(publicClient, "PublicClient is required to fetch token balance");
-        (0, import_ts_essentials16.assert)(accountAddress, "Account address is required to fetch token balance");
-        const isNativeToken = tokenAddress.toLowerCase() === ETH_ADDRESS_LOWERCASE;
-        const balance = await maybeWaitUntilRpcAware(
-          publicClient,
-          {
-            blockHashToBeAwareOf: _optionalChain([invalidationContext, 'optionalAccess', _183 => _183.blockHashToBeAwareOf]),
-            readDescription: isNativeToken ? "read native balance" : "read ERC20 balance",
-            read: () => isNativeToken ? publicClient.getBalance({
-              address: accountAddress
-            }) : publicClient.readContract({
-              address: tokenAddress,
-              abi: ERC20_BALANCE_OF_ABI,
-              functionName: "balanceOf",
-              args: [accountAddress]
-            })
-          },
-          { signal }
-        );
-        return balance;
-      }
-    ),
-    enabled,
-    refetchOnMount: false,
-    ...restQueryOptions
-  };
-}
-function useTokenBalance({ tokenAddress, accountAddress }, queryOptions) {
-  const publicClient = useCofhePublicClient();
-  return useInternalQuery(
-    createPublicTokenBalanceQueryOptions({
-      publicClient,
-      accountAddress,
-      tokenAddress,
-      queryOptions
-    })
-  );
-}
-function useCofheTokenPublicBalance({ token, accountAddress, displayDecimals = 5 }, options) {
-  const connectedAccount = useCofheAccount();
-  const account = accountAddress || connectedAccount;
-  const { enabled: userEnabled = true, ...restOptions } = _nullishCoalesce(options, () => ( {}));
-  const tokenToFetchBalanceFrom = getPublicTokenBalanceSource(token);
-  const { data, isFetching, refetch } = useTokenBalance(
-    {
-      tokenAddress: _optionalChain([tokenToFetchBalanceFrom, 'optionalAccess', _184 => _184.address]),
-      accountAddress: account
-    },
-    {
-      enabled: userEnabled,
-      select: (value) => {
-        (0, import_ts_essentials16.assert)(
-          typeof _optionalChain([tokenToFetchBalanceFrom, 'optionalAccess', _185 => _185.decimals]) === "number",
-          "Token decimals must be defined to format public token balance"
-        );
-        return formatTokenAmount(value, tokenToFetchBalanceFrom.decimals, displayDecimals);
-      },
-      ...restOptions
-    }
-  );
-  return {
-    data,
-    isFetching,
-    refetch
-  };
-}
-
-// src/hooks/useTokensWithPublicBalances.ts
 function useTokensWithPublicBalances({ chainId: _chainId, accountAddress, displayDecimals = 5 } = {}, options) {
   const connectedAccount = useCofheAccount();
   const account = _nullishCoalesce(accountAddress, () => ( connectedAccount));
@@ -5196,7 +5259,7 @@ function useTransactionReceiptsByHash({ hashes, chainId: chainIdInput, enabled:
   const publicClient = useCofhePublicClient();
   const cofheChainId = useCofheChainId();
   const chainId = _nullishCoalesce(chainIdInput, () => ( cofheChainId));
-  const enabled = !!publicClient && !!chainId && enabledInput && hashes !== void 0 && _optionalChain([hashes, 'optionalAccess', _186 => _186.size]) > 0;
+  const enabled = !!publicClient && !!chainId && enabledInput && hashes !== void 0 && _optionalChain([hashes, 'optionalAccess', _187 => _187.size]) > 0;
   const queries = _react.useMemo.call(void 0, () => {
     if (!hashes) return [];
     return Array.from(hashes).map((hash) => {
@@ -5223,7 +5286,7 @@ function useTransactionReceiptsByHash({ hashes, chainId: chainIdInput, enabled:
     cofheLogger.log("useTransactionReceiptsByHash - receiptsByHash recalculated");
     if (!hashes) return {};
     return Array.from(hashes).reduce((acc, hash, i) => {
-      if (!_optionalChain([queriesResults, 'access', _187 => _187[i], 'optionalAccess', _188 => _188.data])) return acc;
+      if (!_optionalChain([queriesResults, 'access', _188 => _188[i], 'optionalAccess', _189 => _189.data])) return acc;
       acc[hash] = queriesResults[i].data;
       return acc;
     }, {});
@@ -5278,8 +5341,8 @@ function useCoingeckoContractMarketChartRange({
         return null;
       }
     },
-    staleTime: _nullishCoalesce(_optionalChain([queryOptions, 'optionalAccess', _189 => _189.staleTime]), () => ( 6e4)),
-    refetchOnWindowFocus: _nullishCoalesce(_optionalChain([queryOptions, 'optionalAccess', _190 => _190.refetchOnWindowFocus]), () => ( false)),
+    staleTime: _nullishCoalesce(_optionalChain([queryOptions, 'optionalAccess', _190 => _190.staleTime]), () => ( 6e4)),
+    refetchOnWindowFocus: _nullishCoalesce(_optionalChain([queryOptions, 'optionalAccess', _191 => _191.refetchOnWindowFocus]), () => ( false)),
     ...queryOptions
   });
 }
@@ -5297,9 +5360,9 @@ function constructTokenAllowanceQueryKey({
   return [
     "tokenAllowance",
     chainId,
-    _optionalChain([tokenAddress, 'optionalAccess', _191 => _191.toLowerCase, 'call', _192 => _192()]),
-    _optionalChain([ownerAddress, 'optionalAccess', _193 => _193.toLowerCase, 'call', _194 => _194()]),
-    _optionalChain([spenderAddress, 'optionalAccess', _195 => _195.toLowerCase, 'call', _196 => _196()])
+    _optionalChain([tokenAddress, 'optionalAccess', _192 => _192.toLowerCase, 'call', _193 => _193()]),
+    _optionalChain([ownerAddress, 'optionalAccess', _194 => _194.toLowerCase, 'call', _195 => _195()]),
+    _optionalChain([spenderAddress, 'optionalAccess', _196 => _196.toLowerCase, 'call', _197 => _197()])
   ];
 }
 function constructTokenAllowanceQueryKeyForInvalidation({
@@ -5321,7 +5384,7 @@ function createTokenAllowanceQueryOptions(params) {
   const baseEnabled = !!publicClient && !!tokenAddress && !!ownerAddress && !!spenderAddress;
   const enabled = baseEnabled && (_nullishCoalesce(userEnabled, () => ( true)));
   const queryKey = constructTokenAllowanceQueryKey({
-    chainId: _optionalChain([publicClient, 'optionalAccess', _197 => _197.chain, 'optionalAccess', _198 => _198.id]),
+    chainId: _optionalChain([publicClient, 'optionalAccess', _198 => _198.chain, 'optionalAccess', _199 => _199.id]),
     tokenAddress,
     ownerAddress,
     spenderAddress
@@ -5338,7 +5401,7 @@ function createTokenAllowanceQueryOptions(params) {
         const allowance = await maybeWaitUntilRpcAwareAndReadContract(
           publicClient,
           {
-            blockHashToBeAwareOf: _optionalChain([invalidationContext, 'optionalAccess', _199 => _199.blockHashToBeAwareOf]),
+            blockHashToBeAwareOf: _optionalChain([invalidationContext, 'optionalAccess', _200 => _200.blockHashToBeAwareOf]),
             address: tokenAddress,
             abi: allowanceContract.abi,
             functionName: allowanceContract.functionName,
@@ -5484,7 +5547,7 @@ function usePermitForm(options = {}) {
       setNameError(null);
       setReceiverError(null);
     } catch (e) {
-      setError(_nullishCoalesce(_optionalChain([e, 'optionalAccess', _200 => _200.message]), () => ( "Failed to create permit")));
+      setError(_nullishCoalesce(_optionalChain([e, 'optionalAccess', _201 => _201.message]), () => ( "Failed to create permit")));
     }
   }, [isPermitCreationPending, permitName, isDelegate, receiver, durationSeconds, createPermitMutateAsync]);
   const reset = _react.useCallback.call(void 0, () => {
@@ -5524,8 +5587,8 @@ var usePermitsList = () => {
   const { navigateTo } = usePortalNavigation();
   const { openModal } = usePortalModals();
   const activePermitHash = _react.useMemo.call(void 0, () => {
-    return _optionalChain([activePermit, 'optionalAccess', _201 => _201.permit, 'access', _202 => _202.hash]);
-  }, [_optionalChain([activePermit, 'optionalAccess', _203 => _203.permit, 'access', _204 => _204.hash])]);
+    return _optionalChain([activePermit, 'optionalAccess', _202 => _202.permit, 'access', _203 => _203.hash]);
+  }, [_optionalChain([activePermit, 'optionalAccess', _204 => _204.permit, 'access', _205 => _205.hash])]);
   const selfPermits = _react.useMemo.call(void 0, () => {
     return allPermits.filter((permit) => permit.type === "self");
   }, [allPermits]);
@@ -5601,11 +5664,11 @@ function useReceivePermit({ onSuccess, onError } = {}) {
       }
       await client.permits.importShared(importArg);
       setSuccessMsg("Permit received and set active.");
-      _optionalChain([onSuccess, 'optionalCall', _205 => _205()]);
+      _optionalChain([onSuccess, 'optionalCall', _206 => _206()]);
     } catch (err) {
-      const message = _nullishCoalesce(_optionalChain([err, 'optionalAccess', _206 => _206.message]), () => ( "Failed to import permit"));
+      const message = _nullishCoalesce(_optionalChain([err, 'optionalAccess', _207 => _207.message]), () => ( "Failed to import permit"));
       setErrorMsg(message);
-      _optionalChain([onError, 'optionalCall', _207 => _207(new Error(message))]);
+      _optionalChain([onError, 'optionalCall', _208 => _208(new Error(message))]);
     } finally {
       setIsSubmitting(false);
     }
@@ -5729,16 +5792,16 @@ var usePermitDetailsAndActions = (permitHash) => {
       });
     }
   });
-  const isActivePermit = permit != null && _optionalChain([activePermit, 'optionalAccess', _208 => _208.permit, 'access', _209 => _209.hash]) === permitHash;
+  const isActivePermit = permit != null && _optionalChain([activePermit, 'optionalAccess', _209 => _209.permit, 'access', _210 => _210.hash]) === permitHash;
   const expirationDate = permit != null ? new Date(permit.expiration * 1e3).toLocaleString() : void 0;
-  const isShareablePermit = _optionalChain([permit, 'optionalAccess', _210 => _210.type]) === "sharing";
+  const isShareablePermit = _optionalChain([permit, 'optionalAccess', _211 => _211.type]) === "sharing";
   const permitLabel = _react.useMemo.call(void 0, () => {
     if (!permit) return void 0;
-    if (_optionalChain([permit, 'access', _211 => _211.name, 'optionalAccess', _212 => _212.trim, 'call', _213 => _213()])) return permit.name;
+    if (_optionalChain([permit, 'access', _212 => _212.name, 'optionalAccess', _213 => _213.trim, 'call', _214 => _214()])) return permit.name;
     const fallbackAddress = permit.recipient && permit.recipient !== _viem.zeroAddress ? permit.recipient : permit.issuer || _viem.zeroAddress;
     return _nullishCoalesce(truncateAddress(fallbackAddress, 4, 4), () => ( fallbackAddress));
   }, [permit]);
-  const expirationInfo = _react.useMemo.call(void 0, () => formatExpirationLabel(_optionalChain([permit, 'optionalAccess', _214 => _214.expiration])), [_optionalChain([permit, 'optionalAccess', _215 => _215.expiration])]);
+  const expirationInfo = _react.useMemo.call(void 0, () => formatExpirationLabel(_optionalChain([permit, 'optionalAccess', _215 => _215.expiration])), [_optionalChain([permit, 'optionalAccess', _216 => _216.expiration])]);
   const permitJson = _react.useMemo.call(void 0, () => {
     if (!permit) return void 0;
     return _permits.PermitUtils.export(permit);
@@ -5778,32 +5841,6 @@ var usePermitDetailsAndActions = (permitHash) => {
   };
 };
 
-// src/hooks/useCofheTokenApprove.ts
-function useCofheTokenApprove(writeMutationOptions) {
-  const { onSuccess: passedOnSuccess, onError: passedOnError, ...restOfOptions } = writeMutationOptions || {};
-  const { onTransactionSubmitError } = useTransactionGlobalLifecycle();
-  return useCofheWriteContract({
-    ...restOfOptions,
-    onError: (error, variables, onMutateResult, context) => {
-      if (passedOnError) passedOnError(error, variables, onMutateResult, context);
-      onTransactionSubmitError(error, "approve" /* Approve */);
-    },
-    onSuccess: (hash, variables, onMutateResult, context) => {
-      if (passedOnSuccess) passedOnSuccess(hash, variables, onMutateResult, context);
-      if (!hasExtras(variables)) return;
-      const { token, tokenAmount, account } = variables.extras;
-      useTransactionStore.getState().addTransaction({
-        hash,
-        token,
-        tokenAmount,
-        chainId: token.chainId,
-        actionType: "approve" /* Approve */,
-        account
-      });
-    }
-  });
-}
-
 // src/hooks/useReschedulableTimeout.ts
 
 function useReschedulableTimeout(callback, defaultTimeout) {
@@ -5898,7 +5935,7 @@ var CofheEncryptInput = ({
   onEncryptError
 }) => {
   const [textValue, setTextValue] = _react.useState.call(void 0, initialValue);
-  const [selectedType, setSelectedType] = _react.useState.call(void 0, _optionalChain([options, 'access', _216 => _216[0], 'optionalAccess', _217 => _217.value]) || "uint32");
+  const [selectedType, setSelectedType] = _react.useState.call(void 0, _optionalChain([options, 'access', _217 => _217[0], 'optionalAccess', _218 => _218.value]) || "uint32");
   const [isDropdownOpen, setIsDropdownOpen] = _react.useState.call(void 0, false);
   const [showProgress, setShowProgress] = _react.useState.call(void 0, false);
   const [encryptedResult, setEncryptedResult] = _react.useState.call(void 0, null);
@@ -5930,7 +5967,7 @@ var CofheEncryptInput = ({
   }, [showProgressBar, isEncrypting]);
   _react.useEffect.call(void 0, () => {
     if (isEncrypting && lastEncryptionStep && encryptionProgress && encryptionProgressLabel) {
-      _optionalChain([onEncryptProgress, 'optionalCall', _218 => _218({
+      _optionalChain([onEncryptProgress, 'optionalCall', _219 => _219({
         step: lastEncryptionStep.step,
         progress: encryptionProgress,
         label: encryptionProgressLabel
@@ -6021,7 +6058,7 @@ var CofheEncryptInput = ({
   const handleTextChange = (e) => {
     const value = e.target.value;
     setTextValue(value);
-    _optionalChain([onTextChange, 'optionalCall', _219 => _219(value)]);
+    _optionalChain([onTextChange, 'optionalCall', _220 => _220(value)]);
     setEncryptedResult(null);
     setCopySuccess(false);
     debouncedValidation(value);
@@ -6052,27 +6089,27 @@ var CofheEncryptInput = ({
   const handleTypeSelect = async (type) => {
     setSelectedType(type);
     setIsDropdownOpen(false);
-    _optionalChain([onTypeChange, 'optionalCall', _220 => _220(type)]);
+    _optionalChain([onTypeChange, 'optionalCall', _221 => _221(type)]);
     if (textValue.trim() !== "") {
       try {
         cofheLogger.log("Auto-encrypting value:", textValue, "as type:", type);
-        _optionalChain([onEncryptStart, 'optionalCall', _221 => _221({ value: textValue, type })]);
+        _optionalChain([onEncryptStart, 'optionalCall', _222 => _222({ value: textValue, type })]);
         (async () => {
           try {
             const [encryptionResult] = await encrypt([_sdk.Encryptable.create(type, textValue)]);
             setEncryptedResult(encryptionResult);
             const data = { value: textValue, encrypted: encryptionResult };
-            _optionalChain([onEncryptComplete, 'optionalCall', _222 => _222(data)]);
+            _optionalChain([onEncryptComplete, 'optionalCall', _223 => _223(data)]);
           } catch (error) {
             const errorMessage2 = error instanceof Error ? error.message : "Encryption failed";
             cofheLogger.error("Encryption failed:", error);
-            _optionalChain([onEncryptError, 'optionalCall', _223 => _223(errorMessage2)]);
+            _optionalChain([onEncryptError, 'optionalCall', _224 => _224(errorMessage2)]);
           }
         })();
       } catch (error) {
         const errorMessage2 = error instanceof Error ? error.message : "Encryption setup failed";
         cofheLogger.error("Encryption setup failed:", error);
-        _optionalChain([onEncryptError, 'optionalCall', _224 => _224(errorMessage2)]);
+        _optionalChain([onEncryptError, 'optionalCall', _225 => _225(errorMessage2)]);
       }
     }
   };
@@ -6214,7 +6251,7 @@ function abortError2(message = "Aborted") {
 }
 async function sleep2(ms, signal) {
   if (ms <= 0) return;
-  if (_optionalChain([signal, 'optionalAccess', _225 => _225.aborted])) throw abortError2();
+  if (_optionalChain([signal, 'optionalAccess', _226 => _226.aborted])) throw abortError2();
   await new Promise((resolve, reject) => {
     const cleanup = () => {
       if (signal) signal.removeEventListener("abort", onAbort);
@@ -6240,7 +6277,7 @@ async function resolveReceiptBlockHash(receipt, publicClient, signal) {
   });
   let attempt = 0;
   while (true) {
-    if (_optionalChain([signal, 'optionalAccess', _226 => _226.aborted])) throw abortError2();
+    if (_optionalChain([signal, 'optionalAccess', _227 => _227.aborted])) throw abortError2();
     attempt += 1;
     try {
       const block = await publicClient.getBlock({
@@ -6412,10 +6449,10 @@ function useTrackPendingTransactionsBase({
           receipt: normalizedReceipt
         });
         if (status === "confirmed" /* Confirmed */) onReceiptSuccess(tx, normalizedReceipt);
-        else _optionalChain([onReceiptFail, 'optionalCall', _227 => _227(tx, normalizedReceipt)]);
+        else _optionalChain([onReceiptFail, 'optionalCall', _228 => _228(tx, normalizedReceipt)]);
         return normalizedReceipt;
       } catch (e) {
-        _optionalChain([onFetchFailure, 'optionalCall', _228 => _228(e, tx)]);
+        _optionalChain([onFetchFailure, 'optionalCall', _229 => _229(e, tx)]);
         useTransactionStore.getState().updateTransactionStatus(tx.chainId, tx.hash, "failed" /* Failed */);
         throw e;
       }
@@ -6431,7 +6468,7 @@ function useTrackPendingTransactionsBase({
 function useHandleInvalidations() {
   const queryClient = useInternalQueryClient();
   const handleInvalidations = (tx, receipt) => {
-    const blockHashToBeAwareOf = _nullishCoalesce(_optionalChain([receipt, 'optionalAccess', _229 => _229.blockHash]), () => ( _optionalChain([tx, 'access', _230 => _230.receipt, 'optionalAccess', _231 => _231.blockHash])));
+    const blockHashToBeAwareOf = _nullishCoalesce(_optionalChain([receipt, 'optionalAccess', _230 => _230.blockHash]), () => ( _optionalChain([tx, 'access', _231 => _231.receipt, 'optionalAccess', _232 => _232.blockHash])));
     invalidatePublicTokenBalanceQueries(
       {
         tokenAddress: ETH_ADDRESS_LOWERCASE,
@@ -6441,11 +6478,11 @@ function useHandleInvalidations() {
       queryClient,
       blockHashToBeAwareOf
     );
-    if (tx.actionType === "shieldSend" /* ShieldSend */) {
+    if (tx.actionType === TransactionActionType.ShieldSend) {
       invalidateConfidentialTokenBalanceQueries(tx.token, queryClient, blockHashToBeAwareOf);
-    } else if (tx.actionType === "shield" /* Shield */) {
+    } else if (tx.actionType === TransactionActionType.Shield) {
       invalidatePublicAndConfidentialTokenBalanceQueries(tx.token, tx.account, queryClient, blockHashToBeAwareOf);
-    } else if (tx.actionType === "unshield" /* Unshield */) {
+    } else if (tx.actionType === TransactionActionType.Unshield) {
       invalidateConfidentialTokenBalanceQueries(tx.token, queryClient, blockHashToBeAwareOf);
       if (isTokenOperationSupported(tx.token.extensions.fhenix.confidentialityType, "claimable")) {
         invalidateClaimableQueries({
@@ -6455,7 +6492,7 @@ function useHandleInvalidations() {
           blockHashToBeAwareOf
         });
       }
-    } else if (tx.actionType === "claim" /* Claim */) {
+    } else if (tx.actionType === TransactionActionType.Claim) {
       const publicBalanceSource = getPublicTokenBalanceSource(tx.token);
       if (publicBalanceSource) {
         invalidatePublicTokenBalanceQueries(
@@ -6474,7 +6511,7 @@ function useHandleInvalidations() {
         queryClient,
         blockHashToBeAwareOf
       });
-    } else if (tx.actionType === "approve" /* Approve */) {
+    } else if (tx.actionType === TransactionActionType.Approve) {
       const publicBalanceSource = getPublicTokenBalanceSource(tx.token);
       if (publicBalanceSource && publicBalanceSource.address.toLowerCase() !== ETH_ADDRESS_LOWERCASE) {
         invalidateTokenAllowanceQueries(
@@ -6488,6 +6525,7 @@ function useHandleInvalidations() {
           blockHashToBeAwareOf
         );
       }
+    } else if (isCustomTransactionActionType(tx.actionType)) {
     } else {
       cofheLogger.warn("No invalidation logic for transaction action type:", tx.actionType);
     }
@@ -6640,9 +6678,9 @@ var useWatchPermitStatus = () => {
         hidePermitSharedStatus();
       }
     };
-    updateStatuses(_optionalChain([activePermit, 'optionalAccess', _232 => _232.permit]));
+    updateStatuses(_optionalChain([activePermit, 'optionalAccess', _233 => _233.permit]));
     intervalRef.current = setInterval(() => {
-      updateStatuses(_optionalChain([activePermit, 'optionalAccess', _233 => _233.permit]));
+      updateStatuses(_optionalChain([activePermit, 'optionalAccess', _234 => _234.permit]));
     }, 2e3);
     return () => {
       if (intervalRef.current) {
@@ -7006,7 +7044,7 @@ var ChainIcon = ({ chainId, className }) => {
 var ConnectedChainIndicator = () => {
   const chainId = useCofheChainId();
   const chain = chainId ? _chains.getChainById.call(void 0, chainId) : void 0;
-  const currentNetwork = _optionalChain([chain, 'optionalAccess', _234 => _234.name]) || "Eth";
+  const currentNetwork = _optionalChain([chain, 'optionalAccess', _235 => _235.name]) || "Eth";
   return /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, 
     "div",
     {
@@ -7165,7 +7203,7 @@ var CofheTokenConfidentialBalance = ({
       hidden: disabledDueToMissingValidPermit,
       isFetching: isFetchingConfidential,
       formattedBalance: confidentialBalanceFormatted,
-      symbol: showSymbol ? _optionalChain([token, 'optionalAccess', _235 => _235.symbol]) : void 0
+      symbol: showSymbol ? _optionalChain([token, 'optionalAccess', _236 => _236.symbol]) : void 0
     }
   );
 };
@@ -7189,7 +7227,7 @@ var CofheTokenPublicBalance = ({
       size,
       isFetching: isFetchingPublic,
       formattedBalance: publicBalanceFormatted,
-      symbol: showSymbol ? _optionalChain([token, 'optionalAccess', _236 => _236.symbol]) : void 0
+      symbol: showSymbol ? _optionalChain([token, 'optionalAccess', _237 => _237.symbol]) : void 0
     }
   );
 };
@@ -7198,7 +7236,7 @@ var CofheTokenPublicBalance = ({
 function useCofhePinnedTokenAddress() {
   const widgetConfig = useCofheContext().client.config.react;
   const chainId = useCofheChainId();
-  const pinnedTokenAddress = chainId ? _optionalChain([widgetConfig, 'access', _237 => _237.pinnedTokens, 'optionalAccess', _238 => _238[_optionalChain([chainId, 'optionalAccess', _239 => _239.toString, 'call', _240 => _240()])]]) : void 0;
+  const pinnedTokenAddress = chainId ? _optionalChain([widgetConfig, 'access', _238 => _238.pinnedTokens, 'optionalAccess', _239 => _239[_optionalChain([chainId, 'optionalAccess', _240 => _240.toString, 'call', _241 => _241()])]]) : void 0;
   return pinnedTokenAddress;
 }
 
@@ -7265,8 +7303,8 @@ var AssetCard = () => {
       ),
       children: /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, "div", { className: "flex items-center justify-between", children: [
         /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, "div", { className: "flex items-center gap-3 flex-1", children: [
-          /* @__PURE__ */ _jsxruntime.jsx.call(void 0, TokenIcon, { logoURI: _optionalChain([token, 'optionalAccess', _241 => _241.logoURI]), alt: _optionalChain([token, 'optionalAccess', _242 => _242.symbol]), size: "md" }),
-          /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "div", { className: "flex flex-col gap-1", children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "h3", { className: "text-lg font-bold cofhe-text-primary", children: _optionalChain([token, 'optionalAccess', _243 => _243.symbol]) }) })
+          /* @__PURE__ */ _jsxruntime.jsx.call(void 0, TokenIcon, { logoURI: _optionalChain([token, 'optionalAccess', _242 => _242.logoURI]), alt: _optionalChain([token, 'optionalAccess', _243 => _243.symbol]), size: "md" }),
+          /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "div", { className: "flex flex-col gap-1", children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "h3", { className: "text-lg font-bold cofhe-text-primary", children: _optionalChain([token, 'optionalAccess', _244 => _244.symbol]) }) })
         ] }),
         /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, "div", { className: "flex items-center gap-2", children: [
           /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "div", { className: "flex flex-col items-end", children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
@@ -7481,8 +7519,8 @@ var formatUsd = (n) => n.toLocaleString(void 0, {
   maximumFractionDigits: 0
 });
 var CustomTooltip = ({ active, payload, label }) => {
-  if (!active || !_optionalChain([payload, 'optionalAccess', _244 => _244.length])) return null;
-  const v = _optionalChain([payload, 'access', _245 => _245[0], 'optionalAccess', _246 => _246.value]);
+  if (!active || !_optionalChain([payload, 'optionalAccess', _245 => _245.length])) return null;
+  const v = _optionalChain([payload, 'access', _246 => _246[0], 'optionalAccess', _247 => _247.value]);
   if (typeof v !== "number") return null;
   return /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, "div", { className: "rounded-md border cofhe-card-border cofhe-card-bg px-2 py-1 shadow-sm", children: [
     /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "div", { className: "text-xxxs opacity-70", children: typeof label === "number" ? formatTime(label) : "" }),
@@ -7570,40 +7608,66 @@ var PageContainer = ({ isModal, header, content, footer }) => {
 
 
 
+
+var warnedMissingCustomRendererActionTypes = /* @__PURE__ */ new Set();
 var ActionIcon = ({ actionType }) => {
   const iconClassName2 = "w-5 h-5";
   switch (actionType) {
-    case "shieldSend" /* ShieldSend */:
+    case TransactionActionType.ShieldSend:
       return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _go.GoArrowUpRight, { className: iconClassName2 });
-    case "shield" /* Shield */:
+    case TransactionActionType.Shield:
       return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _tb.TbShieldPlus, { className: iconClassName2 });
-    case "unshield" /* Unshield */:
+    case TransactionActionType.Unshield:
       return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _tb.TbShieldMinus, { className: iconClassName2 });
-    case "claim" /* Claim */:
+    case TransactionActionType.Claim:
       return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _tb.TbShieldCheck, { className: iconClassName2 });
-    case "approve" /* Approve */:
+    case TransactionActionType.Approve:
       return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _go.GoArrowUpRight, { className: iconClassName2 });
     default:
       return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _go.GoArrowUpRight, { className: iconClassName2 });
   }
 };
+function stringifyPayload(payload) {
+  try {
+    return JSON.stringify(payload, null, 2);
+  } catch (e6) {
+    return String(payload);
+  }
+}
 var TransactionItem = ({ transaction }) => {
+  const { transactionRenderers } = useCofheContext();
+  const Renderer = _optionalChain([transactionRenderers, 'optionalAccess', _248 => _248[transaction.actionType]]);
+  _react.useEffect.call(void 0, () => {
+    if (Renderer || !isCustomTransactionActionType(transaction.actionType)) return;
+    if (warnedMissingCustomRendererActionTypes.has(transaction.actionType)) return;
+    warnedMissingCustomRendererActionTypes.add(transaction.actionType);
+    cofheLogger.warn(
+      `No custom transaction renderer registered for "${transaction.actionType}". The SDK is using the fallback JSON renderer. Register a renderer by passing transactionRenderers to CofheProvider, for example: `,
+      {
+        transactionRenderers: {
+          [transaction.actionType]: "YourTransactionRenderer"
+        }
+      }
+    );
+  }, [Renderer, transaction.actionType]);
+  if (Renderer) {
+    return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, Renderer, { transaction });
+  }
+  const amountLabel = "token" in transaction ? `${_viem.formatUnits.call(void 0, transaction.tokenAmount, transaction.token.decimals)} ${transaction.token.symbol}` : null;
   const statusColorClass = transaction.status === "pending" /* Pending */ ? "text-yellow-600 dark:text-yellow-400" : transaction.status === "confirmed" /* Confirmed */ ? "text-green-600 dark:text-green-400" : "text-red-600 dark:text-red-400";
   return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "div", { className: "cofhe-card-bg p-3 rounded-lg border cofhe-dropdown-border", children: /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, "div", { className: "flex items-start gap-3", children: [
     /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "div", { className: "w-8 h-8 rounded-full cofhe-icon-bg flex items-center justify-center flex-shrink-0 cofhe-text-primary", children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, ActionIcon, { actionType: transaction.actionType }) }),
     /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, "div", { className: "flex-1 min-w-0", children: [
       /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, "div", { className: "flex items-center justify-between gap-2", children: [
-        /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "span", { className: "text-sm font-semibold cofhe-text-primary", children: actionToString(transaction.actionType) }),
-        /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, "span", { className: "text-sm font-semibold cofhe-text-primary", children: [
-          _viem.formatUnits.call(void 0, transaction.tokenAmount, transaction.token.decimals),
-          " ",
-          transaction.token.symbol
-        ] })
+        /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "span", { className: "text-sm font-semibold cofhe-text-primary", children: actionToString(transaction.actionType, transaction.title) }),
+        amountLabel ? /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "span", { className: "text-sm font-semibold cofhe-text-primary", children: amountLabel }) : null
       ] }),
       /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, "div", { className: "flex items-center justify-between gap-2 mt-1", children: [
         /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "span", { className: cn("text-xs font-medium", statusColorClass), children: statusToString(transaction.status) }),
         /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "span", { className: "text-xs cofhe-text-primary opacity-60", children: formatRelativeTime(transaction.timestamp) })
       ] }),
+      transaction.description ? /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "p", { className: "mt-1 text-xs cofhe-text-primary opacity-70", children: transaction.description }) : null,
+      isCustomTransactionActionType(transaction.actionType) && transaction.payload !== void 0 ? /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "pre", { className: "mt-2 max-h-24 overflow-auto rounded cofhe-card-bg p-2 text-[10px] cofhe-text-primary opacity-80", children: stringifyPayload(transaction.payload) }) : null,
       /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "div", { className: "mt-1", children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, HashLink, { type: "tx", hash: transaction.hash, chainId: transaction.chainId, copyable: true }) })
     ] })
   ] }) });
@@ -7611,7 +7675,7 @@ var TransactionItem = ({ transaction }) => {
 
 // src/utils/isProduction.ts
 var isProduction = () => {
-  if (typeof process !== "undefined" && _optionalChain([process, 'access', _247 => _247.env, 'optionalAccess', _248 => _248.NODE_ENV]) === "development") {
+  if (typeof process !== "undefined" && _optionalChain([process, 'access', _249 => _249.env, 'optionalAccess', _250 => _250.NODE_ENV]) === "development") {
     return false;
   }
   if (typeof import.meta !== "undefined") {
@@ -7885,7 +7949,7 @@ var PermitItem = ({ permit, onClick, activePermitHash }) => {
     {
       variant: "ghost",
       className: "flex flex-row w-full items-centera !justify-start gap-3 p-0.5",
-      onClick: () => _optionalChain([onClick, 'optionalCall', _249 => _249(permit.hash)]),
+      onClick: () => _optionalChain([onClick, 'optionalCall', _251 => _251(permit.hash)]),
       children: [
         /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
           "span",
@@ -8109,7 +8173,7 @@ var permitActions = [
   { id: "import", label: "Import", icon: _fa.FaDownload }
 ];
 function computeDefaultActiveAccordionId({ activePermit }) {
-  if (_optionalChain([activePermit, 'optionalAccess', _250 => _250.type]) === "recipient") {
+  if (_optionalChain([activePermit, 'optionalAccess', _252 => _252.type]) === "recipient") {
     return "received";
   }
   return "self";
@@ -8604,7 +8668,7 @@ var money = (n) => n.toLocaleString(void 0, {
 });
 var TokenInfoBalanceChart = ({ token, chartPoints }) => {
   const account = useCofheAccount();
-  const publicSymbol = _nullishCoalesce(_optionalChain([token, 'access', _251 => _251.extensions, 'access', _252 => _252.fhenix, 'access', _253 => _253.erc20Pair, 'optionalAccess', _254 => _254.symbol]), () => ( token.symbol));
+  const publicSymbol = _nullishCoalesce(_optionalChain([token, 'access', _253 => _253.extensions, 'access', _254 => _254.fhenix, 'access', _255 => _255.erc20Pair, 'optionalAccess', _256 => _256.symbol]), () => ( token.symbol));
   const { data: publicBalance, isFetching: isFetchingPublicBalance } = useCofheTokenPublicBalance({ token });
   const { data: confidentialBalance, isFetching: isFetchingConfidentialBalance } = useCofheTokenDecryptedBalance({
     accountAddress: account,
@@ -8613,9 +8677,9 @@ var TokenInfoBalanceChart = ({ token, chartPoints }) => {
   const isFetchingBalances = isFetchingConfidentialBalance || isFetchingPublicBalance;
   const balancePercents = _react.useMemo.call(void 0, () => {
     if (!confidentialBalance && !publicBalance) return;
-    const confidentialUnit = _nullishCoalesce(_optionalChain([confidentialBalance, 'optionalAccess', _255 => _255.unit]), () => ( null));
-    const publicUnit = _nullishCoalesce(_optionalChain([publicBalance, 'optionalAccess', _256 => _256.unit]), () => ( null));
-    const totalUnit = _nullishCoalesce(_optionalChain([(_nullishCoalesce(_optionalChain([confidentialUnit, 'optionalAccess', _257 => _257.plus, 'call', _258 => _258(_nullishCoalesce(publicUnit, () => ( 0)))]), () => ( publicUnit))), 'optionalAccess', _259 => _259.toNumber, 'call', _260 => _260()]), () => ( 0));
+    const confidentialUnit = _nullishCoalesce(_optionalChain([confidentialBalance, 'optionalAccess', _257 => _257.unit]), () => ( null));
+    const publicUnit = _nullishCoalesce(_optionalChain([publicBalance, 'optionalAccess', _258 => _258.unit]), () => ( null));
+    const totalUnit = _nullishCoalesce(_optionalChain([(_nullishCoalesce(_optionalChain([confidentialUnit, 'optionalAccess', _259 => _259.plus, 'call', _260 => _260(_nullishCoalesce(publicUnit, () => ( 0)))]), () => ( publicUnit))), 'optionalAccess', _261 => _261.toNumber, 'call', _262 => _262()]), () => ( 0));
     const confidentialPct = totalUnit && totalUnit > 0 && confidentialUnit ? parseInt(confidentialUnit.div(totalUnit).times(100).toFixed(2)) : 0;
     const publicPct = 100 - confidentialPct;
     return {
@@ -8624,8 +8688,8 @@ var TokenInfoBalanceChart = ({ token, chartPoints }) => {
     };
   }, [confidentialBalance, publicBalance]);
   const price = _react.useMemo.call(void 0, () => {
-    const lastPoint = _optionalChain([chartPoints, 'optionalAccess', _261 => _261[chartPoints.length - 1]]);
-    const firstPoint = _optionalChain([chartPoints, 'optionalAccess', _262 => _262[0]]);
+    const lastPoint = _optionalChain([chartPoints, 'optionalAccess', _263 => _263[chartPoints.length - 1]]);
+    const firstPoint = _optionalChain([chartPoints, 'optionalAccess', _264 => _264[0]]);
     if (!lastPoint || !firstPoint) return;
     return {
       valueUsd: lastPoint.value,
@@ -8705,7 +8769,7 @@ var TokenInfoTransactionHistoryHeader = ({ token }) => {
   return /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, "div", { className: "flex items-center justify-between", children: [
     /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "h3", { className: "text-sm font-bold cofhe-text-primary", children: "Activity" }),
     /* @__PURE__ */ _jsxruntime.jsx.call(void 0, HashLink, { type: "token", hash: token.address, chainId: token.chainId, extraShort: true }),
-    _optionalChain([token, 'access', _263 => _263.extensions, 'access', _264 => _264.fhenix, 'access', _265 => _265.erc20Pair, 'optionalAccess', _266 => _266.address]) && /* @__PURE__ */ _jsxruntime.jsx.call(void 0, HashLink, { type: "token", hash: token.extensions.fhenix.erc20Pair.address, chainId: token.chainId, extraShort: true })
+    _optionalChain([token, 'access', _265 => _265.extensions, 'access', _266 => _266.fhenix, 'access', _267 => _267.erc20Pair, 'optionalAccess', _268 => _268.address]) && /* @__PURE__ */ _jsxruntime.jsx.call(void 0, HashLink, { type: "token", hash: token.extensions.fhenix.erc20Pair.address, chainId: token.chainId, extraShort: true })
   ] });
 };
 var money2 = (n) => n.toLocaleString(void 0, {
@@ -8719,14 +8783,25 @@ var TokenInfoTransactionHistory = ({ token, priceUsd }) => {
   const { filteredTxs: tokenTxs } = useStoredTransactions({
     chainId: token.chainId,
     account,
-    filter: (tx) => tx.token.address.toLowerCase() === token.address.toLowerCase()
+    filter: (tx) => {
+      const tokenAddress = token.address.toLowerCase();
+      if ("token" in tx && tx.token.address.toLowerCase() === tokenAddress) return true;
+      return _nullishCoalesce(_optionalChain([tx, 'access', _269 => _269.tokenTags, 'optionalAccess', _270 => _270.some, 'call', _271 => _271((tag) => tag.toLowerCase() === tokenAddress)]), () => ( false));
+    }
   });
   const activity = _react.useMemo.call(void 0, () => {
     return tokenTxs.slice().sort((a, b) => b.timestamp - a.timestamp).map((tx) => {
+      if (!("token" in tx)) {
+        return {
+          kind: actionToString(tx.actionType, tx.title),
+          description: tx.description
+        };
+      }
       const amountToken = parseFloat(_viem.formatUnits.call(void 0, tx.tokenAmount, tx.token.decimals));
       const amountUsd = typeof priceUsd === "number" && Number.isFinite(amountToken) ? amountToken * priceUsd : void 0;
       return {
-        kind: actionToString(tx.actionType),
+        kind: actionToString(tx.actionType, tx.title),
+        description: tx.description,
         amountUsd,
         amountToken: Number.isFinite(amountToken) ? amountToken : 0
       };
@@ -8745,16 +8820,19 @@ var TokenInfoTransactionHistory = ({ token, priceUsd }) => {
             )
           }
         ),
-        /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "div", { className: "flex flex-col", children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "p", { className: "text-sm font-bold cofhe-text-primary", children: item.kind }) })
+        /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, "div", { className: "flex flex-col", children: [
+          /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "p", { className: "text-sm font-bold cofhe-text-primary", children: item.kind }),
+          item.description ? /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "p", { className: "text-xs opacity-70", children: item.description }) : null
+        ] })
       ] }),
-      /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, "div", { className: "flex flex-col items-end", children: [
+      "amountToken" in item ? /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, "div", { className: "flex flex-col items-end", children: [
         /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "p", { className: "text-sm font-bold cofhe-text-primary", children: typeof item.amountUsd === "number" ? money2(item.amountUsd) : "--" }),
         /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, "p", { className: "text-xxxs opacity-70", children: [
           item.amountToken,
           " ",
           token.symbol
         ] })
-      ] })
+      ] }) : null
     ] }, idx);
   }) }) }) });
 };
@@ -8769,13 +8847,13 @@ var TokenInfoPage = ({ token }) => {
       contractAddress: TMP_WBTC_ON_MAINNET.address
     } : {
       chainId: token.chainId,
-      contractAddress: _nullishCoalesce(_optionalChain([token, 'access', _267 => _267.extensions, 'access', _268 => _268.fhenix, 'access', _269 => _269.erc20Pair, 'optionalAccess', _270 => _270.address]), () => ( token.address))
+      contractAddress: _nullishCoalesce(_optionalChain([token, 'access', _272 => _272.extensions, 'access', _273 => _273.fhenix, 'access', _274 => _274.erc20Pair, 'optionalAccess', _275 => _275.address]), () => ( token.address))
     },
     rangeMs: 24 * 36e5
   });
   const priceUsd = _react.useMemo.call(void 0, () => {
-    const lastPoint = _optionalChain([chartPoints, 'optionalAccess', _271 => _271[chartPoints.length - 1]]);
-    return _optionalChain([lastPoint, 'optionalAccess', _272 => _272.value]);
+    const lastPoint = _optionalChain([chartPoints, 'optionalAccess', _276 => _276[chartPoints.length - 1]]);
+    return _optionalChain([lastPoint, 'optionalAccess', _277 => _277.value]);
   }, [chartPoints]);
   return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
     PageContainer,
@@ -8876,7 +8954,7 @@ var SendPage = ({ token: _token }) => {
     token,
     accountAddress: account
   });
-  const encryptionProgressLabel = _react.useMemo.call(void 0, () => _optionalChain([lastStep, 'optionalAccess', _273 => _273.step]) && getStepConfig(lastStep).label, [lastStep]);
+  const encryptionProgressLabel = _react.useMemo.call(void 0, () => _optionalChain([lastStep, 'optionalAccess', _278 => _278.step]) && getStepConfig(lastStep).label, [lastStep]);
   const [amount, setAmount] = _react.useState.call(void 0, "");
   const [recipientAddress, setRecipientAddress] = _react.useState.call(void 0, "");
   const [error, setError] = _react.useState.call(void 0, null);
@@ -9037,7 +9115,7 @@ function useIsUnshieldingMining(token) {
   const account = useCofheAccount();
   const filter2 = _react.useCallback.call(void 0, 
     (tx) => {
-      return tx.token.address === token.address && tx.actionType === "unshield" /* Unshield */ && tx.status === "pending" /* Pending */;
+      return "token" in tx && tx.token.address === token.address && tx.actionType === TransactionActionType.Unshield && tx.status === "pending" /* Pending */;
     },
     [token.address]
   );
@@ -9158,7 +9236,7 @@ function useShieldWithLifecycle(token) {
   const account = useCofheAccount();
   const chainId = useCofheChainId();
   const [shieldAmount, setShieldAmount] = _react.useState.call(void 0, "");
-  const shieldSourceDecimals = _nullishCoalesce(_optionalChain([token, 'access', _274 => _274.extensions, 'access', _275 => _275.fhenix, 'access', _276 => _276.erc20Pair, 'optionalAccess', _277 => _277.decimals]), () => ( token.decimals));
+  const shieldSourceDecimals = _nullishCoalesce(_optionalChain([token, 'access', _279 => _279.extensions, 'access', _280 => _280.fhenix, 'access', _281 => _281.erc20Pair, 'optionalAccess', _282 => _282.decimals]), () => ( token.decimals));
   const { setError, setStatus, error, status } = useLifecycleStore();
   const { schedule: scheduleStatusClear } = useReschedulableTimeout(() => setStatus(null), AUTOCLEAR_TX_STATUS_TIMEOUT);
   const tokenShield = useCofheTokenShield({
@@ -9238,12 +9316,12 @@ function useShieldWithLifecycle(token) {
   const handleShieldMax = () => {
     if (publicBalanceUnit) setShieldAmount(publicBalanceUnit.toFixed());
   };
-  const isValidShieldAmount = _nullishCoalesce((shieldAmount.length > 0 && _optionalChain([publicBalanceUnit, 'optionalAccess', _278 => _278.gte, 'call', _279 => _279(shieldAmount)])), () => ( false));
+  const isValidShieldAmount = _nullishCoalesce((shieldAmount.length > 0 && _optionalChain([publicBalanceUnit, 'optionalAccess', _283 => _283.gte, 'call', _284 => _284(shieldAmount)])), () => ( false));
   const shieldAmountWei = _react.useMemo.call(void 0, () => {
     if (!isValidShieldAmount) return void 0;
     try {
       return unitToWei(shieldAmount, shieldSourceDecimals);
-    } catch (e6) {
+    } catch (e7) {
       return void 0;
     }
   }, [isValidShieldAmount, shieldAmount, shieldSourceDecimals]);
@@ -9251,12 +9329,12 @@ function useShieldWithLifecycle(token) {
     if (!account || !shieldAmountWei) return void 0;
     return getCofheTokenShieldCallArgs({ token, amount: shieldAmountWei, account });
   }, [account, shieldAmountWei, token]);
-  const shieldCallArgs = _optionalChain([shieldTxCallArgs, 'optionalAccess', _280 => _280.main]);
-  const approvalCallArgs = _optionalChain([shieldTxCallArgs, 'optionalAccess', _281 => _281.approval]);
-  const approvalSpender = _nullishCoalesce(_optionalChain([approvalCallArgs, 'optionalAccess', _282 => _282.args, 'optionalAccess', _283 => _283[0]]), () => ( void 0));
+  const shieldCallArgs = _optionalChain([shieldTxCallArgs, 'optionalAccess', _285 => _285.main]);
+  const approvalCallArgs = _optionalChain([shieldTxCallArgs, 'optionalAccess', _286 => _286.approval]);
+  const approvalSpender = _nullishCoalesce(_optionalChain([approvalCallArgs, 'optionalAccess', _287 => _287.args, 'optionalAccess', _288 => _288[0]]), () => ( void 0));
   const { data: allowanceWei, isFetching: isFetchingAllowance } = useTokenAllowance(
     {
-      tokenAddress: _optionalChain([approvalCallArgs, 'optionalAccess', _284 => _284.address]),
+      tokenAddress: _optionalChain([approvalCallArgs, 'optionalAccess', _289 => _289.address]),
       ownerAddress: account,
       spenderAddress: approvalSpender
     },
@@ -9293,9 +9371,9 @@ function useShieldWithLifecycle(token) {
     setInputAmount: setShieldAmount,
     onMaxClick: handleShieldMax,
     canWriteContract: canWrite,
-    sourceSymbol: _nullishCoalesce(_optionalChain([token, 'access', _285 => _285.extensions, 'access', _286 => _286.fhenix, 'access', _287 => _287.erc20Pair, 'optionalAccess', _288 => _288.symbol]), () => ( token.symbol)),
+    sourceSymbol: _nullishCoalesce(_optionalChain([token, 'access', _290 => _290.extensions, 'access', _291 => _291.fhenix, 'access', _292 => _292.erc20Pair, 'optionalAccess', _293 => _293.symbol]), () => ( token.symbol)),
     destSymbol: token.symbol,
-    sourceLogoURI: _nullishCoalesce(_optionalChain([token, 'access', _289 => _289.extensions, 'access', _290 => _290.fhenix, 'access', _291 => _291.erc20Pair, 'optionalAccess', _292 => _292.logoURI]), () => ( token.logoURI)),
+    sourceLogoURI: _nullishCoalesce(_optionalChain([token, 'access', _294 => _294.extensions, 'access', _295 => _295.fhenix, 'access', _296 => _296.erc20Pair, 'optionalAccess', _297 => _297.logoURI]), () => ( token.logoURI)),
     destLogoURI: token.logoURI,
     handlePrimaryAction: shouldApprove ? handleApprove : handleShield,
     primaryLabel: shouldApprove ? "Approve" : "Shield",
@@ -9365,7 +9443,7 @@ function useUnshieldWithLifecycle(token) {
   const handleUnshieldMax = () => {
     if (confidentialBalanceUnit) setUnshieldAmount(confidentialBalanceUnit.toFixed());
   };
-  const isValidUnshieldAmount = _nullishCoalesce((unshieldAmount.length > 0 && _optionalChain([confidentialBalanceUnit, 'optionalAccess', _293 => _293.gte, 'call', _294 => _294(unshieldAmount)])), () => ( false));
+  const isValidUnshieldAmount = _nullishCoalesce((unshieldAmount.length > 0 && _optionalChain([confidentialBalanceUnit, 'optionalAccess', _298 => _298.gte, 'call', _299 => _299(unshieldAmount)])), () => ( false));
   const unshieldCallArgs = _react.useMemo.call(void 0, () => {
     if (!account || !isValidUnshieldAmount) return void 0;
     const amountWei = _viem.parseUnits.call(void 0, unshieldAmount, token.decimals);
@@ -9388,9 +9466,9 @@ function useUnshieldWithLifecycle(token) {
     onMaxClick: handleUnshieldMax,
     canWriteContract: canUnshield,
     sourceSymbol: token.symbol,
-    destSymbol: _nullishCoalesce(_optionalChain([token, 'access', _295 => _295.extensions, 'access', _296 => _296.fhenix, 'access', _297 => _297.erc20Pair, 'optionalAccess', _298 => _298.symbol]), () => ( token.symbol)),
+    destSymbol: _nullishCoalesce(_optionalChain([token, 'access', _300 => _300.extensions, 'access', _301 => _301.fhenix, 'access', _302 => _302.erc20Pair, 'optionalAccess', _303 => _303.symbol]), () => ( token.symbol)),
     sourceLogoURI: token.logoURI,
-    destLogoURI: _nullishCoalesce(_optionalChain([token, 'access', _299 => _299.extensions, 'access', _300 => _300.fhenix, 'access', _301 => _301.erc20Pair, 'optionalAccess', _302 => _302.logoURI]), () => ( token.logoURI)),
+    destLogoURI: _nullishCoalesce(_optionalChain([token, 'access', _304 => _304.extensions, 'access', _305 => _305.fhenix, 'access', _306 => _306.erc20Pair, 'optionalAccess', _307 => _307.logoURI]), () => ( token.logoURI)),
     handlePrimaryAction: handleUnshield,
     primaryLabel: "Unshield",
     primaryIcon: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _tb.TbShieldMinus, { className: "w-3 h-3" })
@@ -9433,7 +9511,7 @@ function ClaimingSection({ token }) {
     status: claimingStatus,
     isClaimingMining
   } = useClaimUnshieldedWithLifecycle();
-  const pairedSymbol = _nullishCoalesce(_optionalChain([token, 'access', _303 => _303.extensions, 'access', _304 => _304.fhenix, 'access', _305 => _305.erc20Pair, 'optionalAccess', _306 => _306.symbol]), () => ( token.symbol));
+  const pairedSymbol = _nullishCoalesce(_optionalChain([token, 'access', _308 => _308.extensions, 'access', _309 => _309.fhenix, 'access', _310 => _310.erc20Pair, 'optionalAccess', _311 => _311.symbol]), () => ( token.symbol));
   const handleClaim = async () => {
     (0, import_ts_essentials23.assert)(unshieldedClaims, "Unshield claims data is required to claim unshielded tokens");
     claimUnshield.mutateAsync({
@@ -9443,9 +9521,9 @@ function ClaimingSection({ token }) {
   };
   const isUnshieldingMining = useIsUnshieldingMining(token);
   const claimCallArgs = _react.useMemo.call(void 0, () => {
-    if (isDualToken || !account || !_optionalChain([unshieldedClaims, 'optionalAccess', _307 => _307.hasClaimable])) return void 0;
+    if (isDualToken || !account || !_optionalChain([unshieldedClaims, 'optionalAccess', _312 => _312.hasClaimable])) return void 0;
     return void 0;
-  }, [account, isDualToken, token, _optionalChain([unshieldedClaims, 'optionalAccess', _308 => _308.hasClaimable])]);
+  }, [account, isDualToken, token, _optionalChain([unshieldedClaims, 'optionalAccess', _313 => _313.hasClaimable])]);
   const claimSimulation = useCofheSimulateWriteContract(claimCallArgs, {
     enabled: !!claimCallArgs
   });
@@ -9455,16 +9533,16 @@ function ClaimingSection({ token }) {
   );
   const shouldSimulateClaim = !!claimCallArgs;
   return /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, _jsxruntime.Fragment, { children: [
-    _optionalChain([unshieldedClaims, 'optionalAccess', _309 => _309.hasClaimable]) && /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+    _optionalChain([unshieldedClaims, 'optionalAccess', _314 => _314.hasClaimable]) && /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
       ActionButton,
       {
         onClick: handleClaim,
         disabled: claimUnshield.isPending || isClaimingMining || isFetchingClaims || isUnshieldingMining || shouldSimulateClaim && claimSimulation.isFetching || shouldSimulateClaim && !!claimSimulation.error,
-        label: claimUnshield.isPending ? "Claiming..." : `Claim ${isFetchingClaims ? "..." : formatTokenAmount(_nullishCoalesce(_optionalChain([unshieldedClaims, 'optionalAccess', _310 => _310.claimableAmount]), () => ( 0n)), token.decimals, 5).formatted} ${pairedSymbol}`,
+        label: claimUnshield.isPending ? "Claiming..." : `Claim ${isFetchingClaims ? "..." : formatTokenAmount(_nullishCoalesce(_optionalChain([unshieldedClaims, 'optionalAccess', _315 => _315.claimableAmount]), () => ( 0n)), token.decimals, 5).formatted} ${pairedSymbol}`,
         className: "mt-1"
       }
     ),
-    _optionalChain([unshieldedClaims, 'optionalAccess', _311 => _311.hasPending]) && token && !unshieldedClaims.hasClaimable && !isDualToken && /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, "p", { className: "text-xxs text-yellow-600 dark:text-yellow-400 text-center", children: [
+    _optionalChain([unshieldedClaims, 'optionalAccess', _316 => _316.hasPending]) && token && !unshieldedClaims.hasClaimable && !isDualToken && /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, "p", { className: "text-xxs text-yellow-600 dark:text-yellow-400 text-center", children: [
       "Pending: ",
       formatTokenAmount(unshieldedClaims.pendingAmount, token.decimals).formatted,
       " ",
@@ -10149,7 +10227,7 @@ var FloatingButtonComponent = ({ onClick }) => {
   const { theme } = useCofheFloatingButtonContext();
   const { statuses } = usePortalStatuses();
   const { portalOpen } = usePortalUI();
-  const topStatusVariant = _optionalChain([statuses, 'access', _312 => _312[statuses.length - 1], 'optionalAccess', _313 => _313.variant]);
+  const topStatusVariant = _optionalChain([statuses, 'access', _317 => _317[statuses.length - 1], 'optionalAccess', _318 => _318.variant]);
   return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
     "button",
     {
@@ -10196,7 +10274,7 @@ var StatusBarSection = ({ children }) => {
 
 
 var TokenRow = ({ token, onClick, topLabel, balanceType }) => {
-  const publicSymbol = _nullishCoalesce(_optionalChain([token, 'access', _314 => _314.extensions, 'access', _315 => _315.fhenix, 'access', _316 => _316.erc20Pair, 'optionalAccess', _317 => _317.symbol]), () => ( token.symbol));
+  const publicSymbol = _nullishCoalesce(_optionalChain([token, 'access', _319 => _319.extensions, 'access', _320 => _320.fhenix, 'access', _321 => _321.erc20Pair, 'optionalAccess', _322 => _322.symbol]), () => ( token.symbol));
   const destinationSymbol = token.symbol;
   const showDestination = balanceType === "public" /* Public */ && !!publicSymbol && !!destinationSymbol && publicSymbol !== destinationSymbol;
   const account = useCofheAccount();
@@ -10216,7 +10294,7 @@ var TokenRow = ({ token, onClick, topLabel, balanceType }) => {
       tokenAddress: TMP_WBTC_ON_MAINNET.address
     } : {
       chainId: token.chainId,
-      tokenAddress: _nullishCoalesce(_optionalChain([token, 'access', _318 => _318.extensions, 'access', _319 => _319.fhenix, 'access', _320 => _320.erc20Pair, 'optionalAccess', _321 => _321.address]), () => ( token.address))
+      tokenAddress: _nullishCoalesce(_optionalChain([token, 'access', _323 => _323.extensions, 'access', _324 => _324.fhenix, 'access', _325 => _325.erc20Pair, 'optionalAccess', _326 => _326.address]), () => ( token.address))
     }
   );
   const usdValue = balanceType === "confidential" /* Confidential */ ? confidentialBalance && price && formatUsdAmount(confidentialBalance.unit.multipliedBy(price)) : publicBalance && price && formatUsdAmount(publicBalance.unit.multipliedBy(price));
@@ -10322,7 +10400,7 @@ var TokenListModal = ({
 };
 var TokenListContent = ({ tokens, onSelectToken, balanceType }) => {
   const pinnedTokenAddress = useCofhePinnedTokenAddress();
-  const normalizedPinnedAddress = _optionalChain([pinnedTokenAddress, 'optionalAccess', _322 => _322.toLowerCase, 'call', _323 => _323()]);
+  const normalizedPinnedAddress = _optionalChain([pinnedTokenAddress, 'optionalAccess', _327 => _327.toLowerCase, 'call', _328 => _328()]);
   const pinnedToken = normalizedPinnedAddress ? tokens.find((t) => t.address.toLowerCase() === normalizedPinnedAddress) : void 0;
   const nonPinnedTokens = pinnedToken ? tokens.filter((t) => t.address.toLowerCase() !== normalizedPinnedAddress) : tokens;
   return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "div", { className: "cofhe-token-list-container", children: tokens.length === 0 ? /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "p", { className: "text-xs opacity-70 py-4 text-center", children: "No tokens found" }) : /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, _jsxruntime.Fragment, { children: [
@@ -10459,9 +10537,9 @@ function ClaimableTokens() {
       ] }),
       content: /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, "div", { className: "flex flex-col gap-4 pr-1", children: [
         rows.map(({ token, claimableAmount }) => {
-          const isUnshielding = _nullishCoalesce(_optionalChain([unshieldingInProgressByTokenAddress, 'optionalAccess', _324 => _324[token.address.toLowerCase()]]), () => ( false));
+          const isUnshielding = _nullishCoalesce(_optionalChain([unshieldingInProgressByTokenAddress, 'optionalAccess', _329 => _329[token.address.toLowerCase()]]), () => ( false));
           const formatted = formatTokenAmount(claimableAmount, token.decimals, 5).formatted;
-          const isClaimingThis = _nullishCoalesce(_optionalChain([isClaimingByTokenAddress, 'optionalAccess', _325 => _325[token.address.toLowerCase()]]), () => ( false));
+          const isClaimingThis = _nullishCoalesce(_optionalChain([isClaimingByTokenAddress, 'optionalAccess', _330 => _330[token.address.toLowerCase()]]), () => ( false));
           return /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, "div", { className: "grid grid-cols-[1fr,auto,auto] items-center gap-4", children: [
             /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, "div", { className: "flex items-center gap-3 min-w-0", children: [
               /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
@@ -10871,7 +10949,7 @@ var ImportCustomTokenCard = ({ tokens, onSelectToken, balanceType }) => {
                     chainId: token.chainId,
                     address: token.address
                   });
-                  if (_optionalChain([normalizedAddress, 'optionalAccess', _326 => _326.toLowerCase, 'call', _327 => _327()]) === token.address.toLowerCase()) {
+                  if (_optionalChain([normalizedAddress, 'optionalAccess', _331 => _331.toLowerCase, 'call', _332 => _332()]) === token.address.toLowerCase()) {
                     setAddressInput("");
                   }
                 }
@@ -10937,7 +11015,7 @@ var MeasuredContentRenderer = ({ children, id, isModal, onModalOverlayClick }) =
     if (!contentRef.current) return;
     const observer = new ResizeObserver((entries) => {
       for (const entry of entries) {
-        const height = _nullishCoalesce(_optionalChain([entry, 'access', _328 => _328.borderBoxSize, 'optionalAccess', _329 => _329[0], 'optionalAccess', _330 => _330.blockSize]), () => ( entry.target.getBoundingClientRect().height));
+        const height = _nullishCoalesce(_optionalChain([entry, 'access', _333 => _333.borderBoxSize, 'optionalAccess', _334 => _334[0], 'optionalAccess', _335 => _335.blockSize]), () => ( entry.target.getBoundingClientRect().height));
         setContentHeight(id, height);
       }
     });
@@ -10954,7 +11032,7 @@ var MeasuredContentRenderer = ({ children, id, isModal, onModalOverlayClick }) =
         onClick: (e) => {
           e.preventDefault();
           e.stopPropagation();
-          _optionalChain([onModalOverlayClick, 'optionalCall', _331 => _331()]);
+          _optionalChain([onModalOverlayClick, 'optionalCall', _336 => _336()]);
         },
         className: "absolute flex w-full h-full bg-[#0E2F3F]/30 origin-top translate-y-[-8px] scale-[0.95]"
       }
@@ -11207,5 +11285,10 @@ var CofheFloatingButtonWithProvider = (props) => {
 
 
 
-exports.useInternalQueryClient = useInternalQueryClient; exports.asCofhePublicClient = asCofhePublicClient; exports.asCofheWalletClient = asCofheWalletClient; exports.useCofheClient = useCofheClient; exports.useCofheAutoConnect = useCofheAutoConnect; exports.createCofheConfig = createCofheConfig; exports.CofheProvider = CofheProvider; exports.useCofheContext = useCofheContext; exports.useCofheCreatePermit = useCofheCreatePermit; exports.ETH_ADDRESS_LOWERCASE = ETH_ADDRESS_LOWERCASE; exports.getBlockExplorerUrl = getBlockExplorerUrl; exports.getBlockExplorerTxUrl = getBlockExplorerTxUrl; exports.getBlockExplorerAddressUrl = getBlockExplorerAddressUrl; exports.getBlockExplorerTokenUrl = getBlockExplorerTokenUrl; exports.isEthPair = isEthPair; exports.isWrappedEthToken = isWrappedEthToken; exports.FheTypesList = FheTypesList; exports.truncateHash = truncateHash; exports.formatRelativeTime = formatRelativeTime; exports.useCofheConnection = useCofheConnection; exports.useCofhePublicClient = useCofhePublicClient; exports.useCofheWalletClient = useCofheWalletClient; exports.useCofheActivePermit = useCofheActivePermit; exports.useCofheAllPermits = useCofheAllPermits; exports.useCofheRemovePermit = useCofheRemovePermit; exports.useCofheSelectPermit = useCofheSelectPermit; exports.useCofheNavigateToCreatePermit = useCofheNavigateToCreatePermit; exports.useCofheEnabled = useCofheEnabled; exports.useCofheEncrypt = useCofheEncrypt; exports.useCofheSimulateWriteContract = useCofheSimulateWriteContract; exports.useCofheStatuses = useCofheStatuses; exports.TransactionStatus = TransactionStatus; exports.TransactionActionType = TransactionActionType; exports.actionToString = actionToString; exports.statusToString = statusToString; exports.useTransactionStore = useTransactionStore; exports.useCofheWriteContract = useCofheWriteContract; exports.useCofheTokenLists = useCofheTokenLists; exports.useCofheTokens = useCofheTokens; exports.useCofheTokenClaimable = useCofheTokenClaimable; exports.getCofheTokenClaimUnshieldedCallArgs = getCofheTokenClaimUnshieldedCallArgs; exports.useCofheTokenClaimUnshielded = useCofheTokenClaimUnshielded; exports.useCofheReadContractAndDecrypt = useCofheReadContractAndDecrypt; exports.useCofheTokenDecryptedBalance = useCofheTokenDecryptedBalance; exports.useCofheTokensClaimable = useCofheTokensClaimable; exports.getCofheTokenShieldCallArgs = getCofheTokenShieldCallArgs; exports.useCofheTokenShield = useCofheTokenShield; exports.useCofheTokensWithExistingEncryptedBalances = useCofheTokensWithExistingEncryptedBalances; exports.useCofheEncryptAndWriteContract = useCofheEncryptAndWriteContract; exports.useCofheTokenTransfer = useCofheTokenTransfer; exports.getCofheTokenUnshieldCallArgs = getCofheTokenUnshieldCallArgs; exports.useCofheTokenUnshield = useCofheTokenUnshield; exports.useCoingeckoUsdPrice = useCoingeckoUsdPrice; exports.useTokensWithPublicBalances = useTokensWithPublicBalances; exports.useTransactionReceiptsByHash = useTransactionReceiptsByHash; exports.useCoingeckoContractMarketChartRange = useCoingeckoContractMarketChartRange; exports.useTokenAllowance = useTokenAllowance; exports.CofheEncryptInput = CofheEncryptInput; exports.CofheStatusActionIntents = CofheStatusActionIntents; exports.COFHE_STATUS_IDS = COFHE_STATUS_IDS; exports.CofheFloatingButtonProvider = CofheFloatingButtonProvider; exports.sortCofheStatuses = sortCofheStatuses; exports.MainPage = MainPage; exports.SettingsPage = SettingsPage; exports.CofheFloatingButtonWithProvider = CofheFloatingButtonWithProvider;
-//# sourceMappingURL=chunk-GWNGM2KD.cjs.map
+
+
+
+
+
+exports.useInternalQueryClient = useInternalQueryClient; exports.asCofhePublicClient = asCofhePublicClient; exports.asCofheWalletClient = asCofheWalletClient; exports.useCofheClient = useCofheClient; exports.useCofheAutoConnect = useCofheAutoConnect; exports.createCofheConfig = createCofheConfig; exports.CofheProvider = CofheProvider; exports.useCofheContext = useCofheContext; exports.useCofheCreatePermit = useCofheCreatePermit; exports.ETH_ADDRESS_LOWERCASE = ETH_ADDRESS_LOWERCASE; exports.getBlockExplorerUrl = getBlockExplorerUrl; exports.getBlockExplorerTxUrl = getBlockExplorerTxUrl; exports.getBlockExplorerAddressUrl = getBlockExplorerAddressUrl; exports.getBlockExplorerTokenUrl = getBlockExplorerTokenUrl; exports.isEthPair = isEthPair; exports.isWrappedEthToken = isWrappedEthToken; exports.FheTypesList = FheTypesList; exports.truncateHash = truncateHash; exports.formatRelativeTime = formatRelativeTime; exports.useCofheConnection = useCofheConnection; exports.useCofhePublicClient = useCofhePublicClient; exports.useCofheWalletClient = useCofheWalletClient; exports.useCofheActivePermit = useCofheActivePermit; exports.useCofheAllPermits = useCofheAllPermits; exports.useCofheRemovePermit = useCofheRemovePermit; exports.useCofheSelectPermit = useCofheSelectPermit; exports.useCofheNavigateToCreatePermit = useCofheNavigateToCreatePermit; exports.useCofheEnabled = useCofheEnabled; exports.useCofheEncrypt = useCofheEncrypt; exports.useCofheSimulateWriteContract = useCofheSimulateWriteContract; exports.useCofheStatuses = useCofheStatuses; exports.TransactionStatus = TransactionStatus; exports.TransactionActionType = TransactionActionType; exports.actionToString = actionToString; exports.isCustomTransactionActionType = isCustomTransactionActionType; exports.statusToString = statusToString; exports.useTransactionStore = useTransactionStore; exports.useCofheWriteContract = useCofheWriteContract; exports.useCofheTokenApprove = useCofheTokenApprove; exports.useCofheTokenLists = useCofheTokenLists; exports.useCofheTokens = useCofheTokens; exports.useCofheTokenClaimable = useCofheTokenClaimable; exports.getCofheTokenClaimUnshieldedCallArgs = getCofheTokenClaimUnshieldedCallArgs; exports.useCofheTokenClaimUnshielded = useCofheTokenClaimUnshielded; exports.useCofheReadContractAndDecrypt = useCofheReadContractAndDecrypt; exports.useCofheTokenDecryptedBalance = useCofheTokenDecryptedBalance; exports.useCofheTokenPublicBalance = useCofheTokenPublicBalance; exports.useCofheTokensClaimable = useCofheTokensClaimable; exports.getCofheTokenShieldCallArgs = getCofheTokenShieldCallArgs; exports.useCofheTokenShield = useCofheTokenShield; exports.useCofheTokensWithExistingEncryptedBalances = useCofheTokensWithExistingEncryptedBalances; exports.useCofheEncryptAndWriteContract = useCofheEncryptAndWriteContract; exports.useCofheTokenTransfer = useCofheTokenTransfer; exports.addCofheTransaction = addCofheTransaction; exports.useCofheTransactions = useCofheTransactions; exports.getCofheTokenUnshieldCallArgs = getCofheTokenUnshieldCallArgs; exports.useCofheTokenUnshield = useCofheTokenUnshield; exports.useCoingeckoUsdPrice = useCoingeckoUsdPrice; exports.useTokensWithPublicBalances = useTokensWithPublicBalances; exports.useTransactionReceiptsByHash = useTransactionReceiptsByHash; exports.useCoingeckoContractMarketChartRange = useCoingeckoContractMarketChartRange; exports.useTokenAllowance = useTokenAllowance; exports.CofheEncryptInput = CofheEncryptInput; exports.CofheStatusActionIntents = CofheStatusActionIntents; exports.COFHE_STATUS_IDS = COFHE_STATUS_IDS; exports.CofheFloatingButtonProvider = CofheFloatingButtonProvider; exports.sortCofheStatuses = sortCofheStatuses; exports.MainPage = MainPage; exports.SettingsPage = SettingsPage; exports.CofheFloatingButtonWithProvider = CofheFloatingButtonWithProvider;
+//# sourceMappingURL=chunk-4FH4QHHA.cjs.map