@cofhe/react 0.0.0-beta-20260417095940 → 0.0.0-beta-20260420143138

package/dist/index.js

@@ -767,6 +767,65 @@ import * as viemChains from "viem/chains";
 // src/types/token.ts
 import { baseSepolia, sepolia } from "@cofhe/sdk/chains";
 var ETH_ADDRESS_LOWERCASE = "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee";
+var TOKEN_CONFIDENTIALITY_SUPPORT = {
+  wrapped: {
+    enabled: true,
+    publicBalanceSource: "erc20Pair",
+    operations: {
+      confidentialBalance: true,
+      transfer: true,
+      publicBalance: true,
+      shield: true,
+      unshield: true,
+      claim: true,
+      claimable: true
+    }
+  },
+  pure: {
+    enabled: false,
+    publicBalanceSource: null,
+    operations: {
+      confidentialBalance: false,
+      transfer: false,
+      publicBalance: false,
+      shield: false,
+      unshield: false,
+      claim: false,
+      claimable: false
+    }
+  },
+  dual: {
+    enabled: false,
+    publicBalanceSource: "token",
+    operations: {
+      confidentialBalance: false,
+      transfer: false,
+      publicBalance: false,
+      shield: false,
+      unshield: false,
+      claim: false,
+      claimable: false
+    }
+  }
+};
+var TOKEN_CONFIDENTIALITY_TYPES = Object.keys(TOKEN_CONFIDENTIALITY_SUPPORT);
+function isTokenConfidentialityType(value) {
+  return typeof value === "string" && value in TOKEN_CONFIDENTIALITY_SUPPORT;
+}
+function isSupportedTokenConfidentialityType(value) {
+  return isTokenConfidentialityType(value) && TOKEN_CONFIDENTIALITY_SUPPORT[value].enabled;
+}
+function isTokenOperationSupported(type, operation) {
+  return isTokenConfidentialityType(type) && TOKEN_CONFIDENTIALITY_SUPPORT[type].operations[operation];
+}
+function getPublicBalanceSourceType(type) {
+  if (!isTokenConfidentialityType(type)) return null;
+  return TOKEN_CONFIDENTIALITY_SUPPORT[type].publicBalanceSource;
+}
+function assertTokenOperationSupported(type, operation) {
+  if (isTokenOperationSupported(type, operation)) return;
+  throw new Error(`${operation} not supported for confidentialityType: ${type ?? "undefined"}`);
+}
 var WETH_SEPOLIA_TOKEN = {
   chainId: 11155111,
   address: "0x87A3effB84CBE1E4caB6Ab430139eC41d156D55A",
@@ -845,7 +904,7 @@ var isEthPair = (erc20Pair) => {
   return erc20Pair.address.toLowerCase() === ETH_ADDRESS_LOWERCASE;
 };
 var isWrappedEthToken = (token) => {
-  if (token.extensions.fhenix.confidentialityType !== "wrapped") return false;
+  if (!isSupportedTokenConfidentialityType(token.extensions.fhenix.confidentialityType)) return false;
   return isEthPair(token.extensions.fhenix.erc20Pair);
 };
 var FheTypesList = [
@@ -1606,249 +1665,222 @@ function useCofheReadContract(params, queryOptions) {
 // src/hooks/useTrackPendingTransactions.ts
 import "@tanstack/react-query";
 
-// src/constants/confidentialTokenABIs.ts
+// src/constants/confidentialTokenWrapped.ts
 import { parseAbi } from "viem";
-var ERC20_ALLOWANCE_ABI = parseAbi([
-  "function allowance(address owner, address spender) view returns (uint256)"
-]);
-var ERC20_APPROVE_ABI = parseAbi(["function approve(address spender, uint256 amount) returns (bool)"]);
-var CONFIDENTIAL_TYPE_WRAPPED_ABI = [
-  {
-    inputs: [
-      {
-        internalType: "address",
-        name: "account",
-        type: "address"
-      }
-    ],
-    name: "encBalanceOf",
-    outputs: [
-      {
-        internalType: "euint128",
-        name: "",
-        type: "uint256"
-      }
-    ],
-    stateMutability: "view",
-    type: "function"
-  }
-];
-var CONFIDENTIAL_TYPE_PURE_ABI = parseAbi([
-  "function confidentialBalanceOf(address account) view returns (uint256)"
-]);
-var CONFIDENTIAL_TYPE_DUAL_ABI = parseAbi([
-  "function confidentialBalanceOf(address account) view returns (uint256)"
-]);
-var CONFIDENTIAL_ABIS = {
-  wrapped: {
-    abi: CONFIDENTIAL_TYPE_WRAPPED_ABI,
-    functionName: "encBalanceOf"
-  },
-  pure: {
-    abi: CONFIDENTIAL_TYPE_PURE_ABI,
-    functionName: "confidentialBalanceOf"
+var wrappedErc20ApprovalContracts = {
+  allowance: {
+    abi: parseAbi(["function allowance(address owner, address spender) view returns (uint256)"]),
+    functionName: "allowance"
   },
-  dual: {
-    abi: CONFIDENTIAL_TYPE_DUAL_ABI,
-    functionName: "confidentialBalanceOf"
+  approve: {
+    abi: parseAbi(["function approve(address spender, uint256 amount) returns (bool)"]),
+    functionName: "approve"
   }
 };
-var WRAPPED_TRANSFER_ABI = [
-  {
-    inputs: [
-      {
-        internalType: "address",
-        name: "to",
-        type: "address"
-      },
+var WRAPPED_TOKEN_CONTRACTS = {
+  confidentialBalance: {
+    abi: [
       {
-        components: [
+        inputs: [
+          {
+            internalType: "address",
+            name: "account",
+            type: "address"
+          }
+        ],
+        name: "encBalanceOf",
+        outputs: [
           {
-            internalType: "uint256",
-            name: "ctHash",
+            internalType: "euint128",
+            name: "",
             type: "uint256"
-          },
+          }
+        ],
+        stateMutability: "view",
+        type: "function"
+      }
+    ],
+    functionName: "encBalanceOf"
+  },
+  confidentialTransfer: {
+    abi: [
+      {
+        inputs: [
           {
-            internalType: "uint8",
-            name: "securityZone",
-            type: "uint8"
+            internalType: "address",
+            name: "to",
+            type: "address"
           },
           {
-            internalType: "uint8",
-            name: "utype",
-            type: "uint8"
-          },
+            components: [
+              {
+                internalType: "uint256",
+                name: "ctHash",
+                type: "uint256"
+              },
+              {
+                internalType: "uint8",
+                name: "securityZone",
+                type: "uint8"
+              },
+              {
+                internalType: "uint8",
+                name: "utype",
+                type: "uint8"
+              },
+              {
+                internalType: "bytes",
+                name: "signature",
+                type: "bytes"
+              }
+            ],
+            internalType: "struct InEuint128",
+            name: "inValue",
+            type: "tuple"
+          }
+        ],
+        name: "encTransfer",
+        outputs: [
           {
-            internalType: "bytes",
-            name: "signature",
-            type: "bytes"
+            internalType: "euint128",
+            name: "transferred",
+            type: "uint256"
           }
         ],
-        internalType: "struct InEuint128",
-        name: "inValue",
-        type: "tuple"
-      }
-    ],
-    name: "encTransfer",
-    outputs: [
-      {
-        internalType: "euint128",
-        name: "transferred",
-        type: "uint256"
-      }
-    ],
-    stateMutability: "nonpayable",
-    type: "function"
-  }
-];
-var PURE_TRANSFER_ABI = [
-  {
-    name: "confidentialTransfer",
-    type: "function",
-    stateMutability: "nonpayable",
-    inputs: [
-      { name: "to", type: "address" },
-      {
-        name: "inValue",
-        type: "tuple",
-        components: [
-          { name: "ctHash", type: "uint256" },
-          { name: "securityZone", type: "uint8" },
-          { name: "utype", type: "uint8" },
-          { name: "signature", type: "bytes" }
-        ]
+        stateMutability: "nonpayable",
+        type: "function"
       }
     ],
-    outputs: [{ name: "transferred", type: "uint256" }]
-  }
-];
-var DUAL_TRANSFER_ABI = [
-  {
-    name: "TBD_DUAL_FUNCTION_NAME",
-    type: "function",
-    stateMutability: "nonpayable",
-    inputs: [
-      { name: "to", type: "address" },
-      {
-        name: "inValue",
-        type: "tuple",
-        components: [
-          { name: "ctHash", type: "uint256" },
-          { name: "securityZone", type: "uint8" },
-          { name: "utype", type: "uint8" },
-          { name: "signature", type: "bytes" }
-        ]
-      }
-    ],
-    outputs: [{ name: "transferred", type: "uint256" }]
-  }
-];
-var TRANSFER_ABIS = {
-  wrapped: {
-    abi: WRAPPED_TRANSFER_ABI,
     functionName: "encTransfer"
   },
-  pure: {
-    abi: PURE_TRANSFER_ABI,
-    functionName: "confidentialTransfer"
+  shield: {
+    approval: wrappedErc20ApprovalContracts,
+    erc20: {
+      abi: parseAbi(["function encrypt(address to, uint128 value) public"]),
+      functionName: "encrypt"
+    },
+    native: {
+      abi: parseAbi(["function encryptETH(address to) public payable"]),
+      functionName: "encryptETH"
+    },
+    wrappedPair: {
+      abi: parseAbi(["function encryptWETH(address to, uint128 value) public"]),
+      functionName: "encryptWETH"
+    }
   },
-  dual: {
-    // Placeholder for dual type
-    abi: DUAL_TRANSFER_ABI,
-    functionName: "TBD_DUAL_FUNCTION_NAME"
+  unshield: {
+    abi: parseAbi(["function decrypt(address to, uint128 value) public"]),
+    functionName: "decrypt"
+  },
+  claims: {
+    single: {
+      abi: parseAbi(["function claimDecrypted(uint256 ctHash) public"]),
+      functionName: "claimDecrypted"
+    },
+    all: {
+      abi: parseAbi(["function claimAllDecrypted() public"]),
+      functionName: "claimAllDecrypted"
+    },
+    query: {
+      abi: [
+        {
+          inputs: [{ name: "user", type: "address" }],
+          name: "getUserClaims",
+          outputs: [
+            {
+              components: [
+                { name: "ctHash", type: "uint256" },
+                { name: "requestedAmount", type: "uint128" },
+                { name: "decryptedAmount", type: "uint128" },
+                { name: "decrypted", type: "bool" },
+                { name: "to", type: "address" },
+                { name: "claimed", type: "bool" }
+              ],
+              name: "",
+              type: "tuple[]"
+            }
+          ],
+          stateMutability: "view",
+          type: "function"
+        }
+      ],
+      functionName: "getUserClaims"
+    }
   }
 };
-var DUAL_SHIELD_ABI = parseAbi(["function shield(uint256 amount) public"]);
-var DUAL_UNSHIELD_ABI = parseAbi(["function unshield(uint64 amount) public"]);
-var DUAL_CLAIM_UNSHIELD_ABI = parseAbi(["function claimUnshielded() public"]);
-var DUAL_GET_UNSHIELD_CLAIM_ABI = [
-  {
-    name: "getUserUnshieldClaim",
-    type: "function",
-    stateMutability: "view",
-    inputs: [{ name: "user", type: "address" }],
-    outputs: [
-      {
-        name: "",
-        type: "tuple",
-        components: [
-          { name: "ctHash", type: "uint256" },
-          { name: "requestedAmount", type: "uint64" },
-          { name: "decryptedAmount", type: "uint64" },
-          { name: "decrypted", type: "bool" },
-          { name: "claimed", type: "bool" }
-        ]
-      }
-    ]
+
+// src/constants/confidentialTokenABIs.ts
+function getRequiredContractConfig(configs, confidentialityType, operation) {
+  const config = configs[confidentialityType];
+  if (!config) {
+    throw new Error(`${operation} config is not defined for confidentialityType: ${confidentialityType}`);
   }
-];
-var WRAPPED_ENCRYPT_ABI = parseAbi(["function encrypt(address to, uint128 value) public"]);
-var WRAPPED_DECRYPT_ABI = parseAbi(["function decrypt(address to, uint128 value) public"]);
-var WRAPPED_CLAIM_DECRYPTED_ABI = parseAbi(["function claimDecrypted(uint256 ctHash) public"]);
-var WRAPPED_CLAIM_ALL_DECRYPTED_ABI = parseAbi(["function claimAllDecrypted() public"]);
-var WRAPPED_GET_USER_CLAIMS_ABI = [
-  {
-    inputs: [{ name: "user", type: "address" }],
-    name: "getUserClaims",
-    outputs: [
-      {
-        components: [
-          { name: "ctHash", type: "uint256" },
-          { name: "requestedAmount", type: "uint128" },
-          { name: "decryptedAmount", type: "uint128" },
-          { name: "decrypted", type: "bool" },
-          { name: "to", type: "address" },
-          { name: "claimed", type: "bool" }
-        ],
-        name: "",
-        type: "tuple[]"
-      }
-    ],
-    stateMutability: "view",
-    type: "function"
+  return config;
+}
+var TOKEN_CONFIDENTIALITY_CONTRACTS = {
+  wrapped: WRAPPED_TOKEN_CONTRACTS
+};
+function getDefaultShieldApprovalContracts() {
+  return WRAPPED_TOKEN_CONTRACTS.shield.approval;
+}
+function getContractsForType(confidentialityType) {
+  return getRequiredContractConfig(TOKEN_CONFIDENTIALITY_CONTRACTS, confidentialityType, "token contracts");
+}
+function getTokenContractConfig(confidentialityType) {
+  return getContractsForType(confidentialityType).confidentialBalance;
+}
+function getTransferContractConfig(confidentialityType) {
+  return getContractsForType(confidentialityType).confidentialTransfer;
+}
+function getShieldContractConfig(confidentialityType) {
+  const contracts = getContractsForType(confidentialityType).shield;
+  if (!contracts) {
+    throw new Error(`shield config is not defined for confidentialityType: ${confidentialityType}`);
   }
-];
-var WRAPPED_ETH_ENCRYPT_ETH_ABI = parseAbi(["function encryptETH(address to) public payable"]);
-var WRAPPED_ETH_ENCRYPT_WETH_ABI = parseAbi(["function encryptWETH(address to, uint128 value) public"]);
-var SHIELD_ABIS = {
-  dual: {
-    abi: DUAL_SHIELD_ABI,
-    functionName: "shield"
-  },
-  wrapped: {
-    // TBD - needs approval flow and underlying token reference
-    abi: WRAPPED_ENCRYPT_ABI,
-    functionName: "encrypt"
+  return contracts.erc20;
+}
+function getShieldAllowanceContractConfig() {
+  return getDefaultShieldApprovalContracts().allowance;
+}
+function getShieldApproveContractConfig() {
+  return getDefaultShieldApprovalContracts().approve;
+}
+function getShieldEthContractConfig(confidentialityType) {
+  const contracts = getContractsForType(confidentialityType).shield;
+  if (!contracts) {
+    throw new Error(`shield ETH config is not defined for confidentialityType: ${confidentialityType}`);
   }
-};
-var UNSHIELD_ABIS = {
-  dual: {
-    abi: DUAL_UNSHIELD_ABI,
-    functionName: "unshield"
-  },
-  wrapped: {
-    // TBD - needs claim flow
-    abi: WRAPPED_DECRYPT_ABI,
-    functionName: "decrypt"
+  return contracts.native;
+}
+function getUnshieldContractConfig(confidentialityType) {
+  const contracts = getContractsForType(confidentialityType).unshield;
+  if (!contracts) {
+    throw new Error(`unshield config is not defined for confidentialityType: ${confidentialityType}`);
   }
-};
-var CLAIM_ABIS = {
-  dual: {
-    abi: DUAL_CLAIM_UNSHIELD_ABI,
-    functionName: "claimUnshielded"
-  },
-  wrapped: {
-    abi: WRAPPED_CLAIM_ALL_DECRYPTED_ABI,
-    functionName: "claimAllDecrypted"
+  return contracts;
+}
+function getClaimContractConfig(confidentialityType) {
+  const contracts = getContractsForType(confidentialityType).claims;
+  if (!contracts) {
+    throw new Error(`claim config is not defined for confidentialityType: ${confidentialityType}`);
   }
-};
-function getTokenContractConfig(confidentialityType) {
-  return CONFIDENTIAL_ABIS[confidentialityType];
+  return contracts.all;
+}
+function getClaimableContractConfig(confidentialityType) {
+  const contracts = getContractsForType(confidentialityType).claims;
+  if (!contracts) {
+    throw new Error(`claimable config is not defined for confidentialityType: ${confidentialityType}`);
+  }
+  return contracts.query;
 }
 
 // src/hooks/useCofheTokenLists.ts
 import "@tanstack/react-query";
 import { useMemo as useMemo4 } from "react";
+function isSupportedToken(token) {
+  const confidentialityType = token.extensions?.fhenix?.confidentialityType;
+  return isSupportedTokenConfidentialityType(confidentialityType);
+}
 function useCofheTokenLists({ chainId }, queryOptions) {
   const widgetConfig = useCofheContext().client.config.react;
   const tokensListsUrls = chainId ? widgetConfig.tokenLists?.[chainId] : [];
@@ -1870,7 +1902,7 @@ function useCofheTokenLists({ chainId }, queryOptions) {
     select: (data) => {
       return {
         ...data,
-        tokens: data.tokens.filter((token) => token.chainId === chainId)
+        tokens: data.tokens.filter((token) => token.chainId === chainId && isSupportedToken(token))
       };
     },
     ...queryOptions
@@ -1962,7 +1994,8 @@ function constructPublicTokenBalanceQueryKeyForInvalidation({
 function getPublicTokenBalanceSource(token) {
   const confidentialityType = token?.extensions.fhenix.confidentialityType;
   const underlyingErc20 = token?.extensions.fhenix.erc20Pair;
-  const tokenToFetchBalanceFrom = confidentialityType === "wrapped" ? underlyingErc20 : confidentialityType === "dual" ? token : void 0;
+  const publicBalanceSourceType = getPublicBalanceSourceType(confidentialityType);
+  const tokenToFetchBalanceFrom = publicBalanceSourceType === "erc20Pair" ? underlyingErc20 : publicBalanceSourceType === "token" ? token : void 0;
   if (!tokenToFetchBalanceFrom) return void 0;
   return {
     address: tokenToFetchBalanceFrom.address,
@@ -2220,7 +2253,7 @@ var DEFAULT_UNSHIELD_CLAIM_SUMMARY = {
   hasPending: false
 };
 function isTokenConfidentialityTypeClaimable(type) {
-  return type === "dual" || type === "wrapped";
+  return isTokenOperationSupported(type, "claimable");
 }
 async function fetchUnshieldClaimsSummary({
   publicClient,
@@ -2230,58 +2263,36 @@ async function fetchUnshieldClaimsSummary({
   queryKey,
   signal
 }) {
-  if (confidentialityType === "dual") {
-    const claim = await decryptionAwareReadContract({
-      publicClient,
-      queryKey,
-      signal,
-      readContractParams: {
-        address: token.address,
-        abi: DUAL_GET_UNSHIELD_CLAIM_ABI,
-        functionName: "getUserUnshieldClaim",
-        args: [accountAddress]
-      }
-    });
-    if (claim.ctHash === 0n || claim.claimed) return DEFAULT_UNSHIELD_CLAIM_SUMMARY;
-    return {
-      claimableAmount: claim.decrypted ? claim.decryptedAmount : 0n,
-      pendingAmount: claim.decrypted ? 0n : claim.requestedAmount,
-      hasClaimable: claim.decrypted && claim.decryptedAmount > 0n,
-      hasPending: !claim.decrypted
-    };
-  }
-  if (confidentialityType === "wrapped") {
-    const result = await decryptionAwareReadContract({
-      publicClient,
-      queryKey,
-      signal,
-      readContractParams: {
-        address: token.address,
-        abi: WRAPPED_GET_USER_CLAIMS_ABI,
-        functionName: "getUserClaims",
-        args: [accountAddress]
+  const contractConfig = getClaimableContractConfig(confidentialityType);
+  const result = await decryptionAwareReadContract({
+    publicClient,
+    queryKey,
+    signal,
+    readContractParams: {
+      address: token.address,
+      abi: contractConfig.abi,
+      functionName: contractConfig.functionName,
+      args: [accountAddress]
+    }
+  });
+  const claims = result.filter((c) => !c.claimed);
+  const { claimableAmount, pendingAmount } = claims.reduce(
+    (acc, claim) => {
+      if (claim.decrypted) {
+        acc.claimableAmount += claim.decryptedAmount;
+      } else {
+        acc.pendingAmount += claim.requestedAmount;
       }
-    });
-    const claims = result.filter((c) => !c.claimed);
-    const { claimableAmount, pendingAmount } = claims.reduce(
-      (acc, claim) => {
-        if (claim.decrypted) {
-          acc.claimableAmount += claim.decryptedAmount;
-        } else {
-          acc.pendingAmount += claim.requestedAmount;
-        }
-        return acc;
-      },
-      { claimableAmount: 0n, pendingAmount: 0n }
-    );
-    return {
-      claimableAmount,
-      pendingAmount,
-      hasClaimable: claimableAmount > 0n,
-      hasPending: pendingAmount > 0n
-    };
-  }
-  return DEFAULT_UNSHIELD_CLAIM_SUMMARY;
+      return acc;
+    },
+    { claimableAmount: 0n, pendingAmount: 0n }
+  );
+  return {
+    claimableAmount,
+    pendingAmount,
+    hasClaimable: claimableAmount > 0n,
+    hasPending: pendingAmount > 0n
+  };
 }
 function useCofheTokenClaimable({ accountAddress: account, token }, queryOptions) {
   const publicClient = useCofhePublicClient();
@@ -2372,12 +2383,15 @@ function createTokenAllowanceQueryOptions(params) {
       (0, import_ts_essentials4.assert)(tokenAddress, "Token address is required to fetch token allowance");
       (0, import_ts_essentials4.assert)(ownerAddress, "Owner address is required to fetch token allowance");
       (0, import_ts_essentials4.assert)(spenderAddress, "Spender address is required to fetch token allowance");
-      return publicClient.readContract({
+      const allowanceContract = getShieldAllowanceContractConfig();
+      const allowance = await publicClient.readContract({
         address: tokenAddress,
-        abi: ERC20_ALLOWANCE_ABI,
-        functionName: "allowance",
+        abi: allowanceContract.abi,
+        functionName: allowanceContract.functionName,
         args: [ownerAddress, spenderAddress]
       });
+      (0, import_ts_essentials4.assert)(typeof allowance === "bigint", "Token allowance must resolve to bigint");
+      return allowance;
     },
     enabled,
     refetchOnMount: false,
@@ -2701,7 +2715,7 @@ var CopyButton = ({ text, size = 14, className }) => {
       setCopied(true);
       setTimeout(() => setCopied(false), 800);
     } catch (err) {
-      console.error("Failed to copy address:", err);
+      cofheLogger.error("Failed to copy address:", err);
     }
   };
   return /* @__PURE__ */ jsx3(
@@ -2884,7 +2898,7 @@ function useTransactionGlobalToastsLifecycle() {
           }
         }
       }
-      console.error("____ Transaction submission failed for type:", transactionType, "with error:", error);
+      cofheLogger.error("____ Transaction submission failed for type:", transactionType, "with error:", error);
       addToast(
         {
           variant: "error",
@@ -2929,7 +2943,7 @@ function useTransactionGlobalToastsLifecycle() {
     },
     // 2.b. tx receipt fetch failed
     onWatchReceiptFailure: (error, transaction) => {
-      console.error("____ Transaction receipt fetch failed for tx:", transaction, "with error:", error);
+      cofheLogger.error("____ Transaction receipt fetch failed for tx:", transaction, "with error:", error);
       addToast(
         {
           variant: "error",
@@ -3134,7 +3148,7 @@ function useHandleInvalidations() {
         );
       }
     } else {
-      console.warn("No invalidation logic for transaction action type:", tx.actionType);
+      cofheLogger.warn("No invalidation logic for transaction action type:", tx.actionType);
     }
   };
   return handleInvalidations;
@@ -3883,7 +3897,8 @@ function useCofheTokenTransfer(writeMutationOptions) {
     encryptAmountAndSendToken: ({ input, encryptionOptions }) => {
       const { token, to, amount, userAddress } = input;
       const { input: _ignoredInput, ...encryptionOpts } = encryptionOptions ?? {};
-      const contractConfig = TRANSFER_ABIS[token.extensions.fhenix.confidentialityType];
+      assertTokenOperationSupported(token.extensions.fhenix.confidentialityType, "transfer");
+      const contractConfig = getTransferContractConfig(token.extensions.fhenix.confidentialityType);
       return encryptAndWrite({
         params: {
           address: token.address,
@@ -3942,30 +3957,16 @@ function getCofheTokenShieldCallArgs(params) {
   if (!confidentialityType) {
     throw new Error("confidentialityType is required in token extensions");
   }
-  if (confidentialityType !== "dual" && confidentialityType !== "wrapped") {
-    throw new Error(`Shield not supported for confidentialityType: ${confidentialityType}`);
-  }
-  if (confidentialityType === "dual") {
-    const contractConfig = SHIELD_ABIS.dual;
-    return {
-      main: {
-        address: tokenAddress,
-        abi: contractConfig.abi,
-        functionName: contractConfig.functionName,
-        args: [amount],
-        account,
-        chain: void 0
-      }
-    };
-  }
+  assertTokenOperationSupported(confidentialityType, "shield");
   const erc20PairAddress = token.extensions.fhenix.erc20Pair?.address;
   const isEth = erc20PairAddress?.toLowerCase() === ETH_ADDRESS_LOWERCASE;
   if (isEth) {
+    const contractConfig = getShieldEthContractConfig(confidentialityType);
     return {
       main: {
         address: tokenAddress,
-        abi: WRAPPED_ETH_ENCRYPT_ETH_ABI,
-        functionName: "encryptETH",
+        abi: contractConfig.abi,
+        functionName: contractConfig.functionName,
         args: [account],
         value: amount,
         account,
@@ -3979,16 +3980,14 @@ function getCofheTokenShieldCallArgs(params) {
   return {
     approval: {
       address: erc20PairAddress,
-      abi: ERC20_APPROVE_ABI,
-      functionName: "approve",
+      ...getShieldApproveContractConfig(),
       args: [tokenAddress, amount],
       account,
       chain: void 0
     },
     main: {
+      ...getShieldContractConfig(confidentialityType),
       address: tokenAddress,
-      abi: WRAPPED_ENCRYPT_ABI,
-      functionName: "encrypt",
       args: [account, amount],
       account,
       chain: void 0
@@ -4018,47 +4017,35 @@ function useCofheTokenShield(options) {
       if (!walletClient.account) {
         throw new Error("Wallet account is required for token shield");
       }
-      if (confidentialityType !== "dual" && confidentialityType !== "wrapped") {
-        throw new Error(`Shield not supported for confidentialityType: ${confidentialityType}`);
-      }
+      assertTokenOperationSupported(confidentialityType, "shield");
       let hash;
-      if (confidentialityType === "wrapped") {
-        const erc20PairAddress = input.token.extensions.fhenix.erc20Pair?.address;
-        const isEth = erc20PairAddress?.toLowerCase() === ETH_ADDRESS_LOWERCASE;
-        if (isEth) {
-          const { request } = await publicClient.simulateContract({
-            address: tokenAddress,
-            abi: WRAPPED_ETH_ENCRYPT_ETH_ABI,
-            functionName: "encryptETH",
-            args: [walletClient.account.address],
-            value: input.amount,
-            account: walletClient.account
-          });
-          hash = await walletClient.writeContract({ ...request, chain: void 0 });
-        } else {
-          if (!erc20PairAddress) {
-            throw new Error("erc20Pair address is required for wrapped ERC20 tokens");
-          }
-          input.onStatusChange?.("Please confirm shield in wallet...");
-          const { request: encryptRequest } = await publicClient.simulateContract({
-            address: tokenAddress,
-            abi: WRAPPED_ENCRYPT_ABI,
-            functionName: "encrypt",
-            args: [walletClient.account.address, input.amount],
-            account: walletClient.account
-          });
-          hash = await walletClient.writeContract({ ...encryptRequest, chain: void 0 });
-        }
-      } else {
-        const contractConfig = SHIELD_ABIS.dual;
+      const erc20PairAddress = input.token.extensions.fhenix.erc20Pair?.address;
+      const isEth = erc20PairAddress?.toLowerCase() === ETH_ADDRESS_LOWERCASE;
+      if (isEth) {
+        const contractConfig = getShieldEthContractConfig(confidentialityType);
         const { request } = await publicClient.simulateContract({
           address: tokenAddress,
           abi: contractConfig.abi,
           functionName: contractConfig.functionName,
-          args: [input.amount],
+          args: [walletClient.account.address],
+          value: input.amount,
           account: walletClient.account
         });
         hash = await walletClient.writeContract({ ...request, chain: void 0 });
+      } else {
+        if (!erc20PairAddress) {
+          throw new Error("erc20Pair address is required for wrapped ERC20 tokens");
+        }
+        input.onStatusChange?.("Please confirm shield in wallet...");
+        const contractConfig = getShieldContractConfig(confidentialityType);
+        const { request: encryptRequest } = await publicClient.simulateContract({
+          address: tokenAddress,
+          abi: contractConfig.abi,
+          functionName: contractConfig.functionName,
+          args: [walletClient.account.address, input.amount],
+          account: walletClient.account
+        });
+        hash = await walletClient.writeContract({ ...encryptRequest, chain: void 0 });
       }
       return hash;
     },
@@ -4188,29 +4175,13 @@ function getCofheTokenUnshieldCallArgs(params) {
   if (!confidentialityType) {
     throw new Error("confidentialityType is required in token extensions");
   }
-  if (confidentialityType !== "dual" && confidentialityType !== "wrapped") {
-    throw new Error(`Unshield not supported for confidentialityType: ${confidentialityType}`);
-  }
-  const contractConfig = UNSHIELD_ABIS[confidentialityType];
-  if (!contractConfig) {
-    throw new Error(`Unsupported confidentialityType for unshield: ${confidentialityType}`);
-  }
-  if (confidentialityType === "wrapped") {
-    return {
-      address: tokenAddress,
-      abi: contractConfig.abi,
-      functionName: contractConfig.functionName,
-      args: [account, rawAmount],
-      account,
-      chain: void 0
-    };
-  }
-  const amount = BigInt.asUintN(64, rawAmount);
+  assertTokenOperationSupported(confidentialityType, "unshield");
+  const contractConfig = getUnshieldContractConfig(confidentialityType);
   return {
     address: tokenAddress,
     abi: contractConfig.abi,
     functionName: contractConfig.functionName,
-    args: [amount],
+    args: [account, rawAmount],
     account,
     chain: void 0
   };
@@ -4238,35 +4209,18 @@ function useCofheTokenUnshieldMutation(options) {
       if (!walletClient.account) {
         throw new Error("Wallet account is required for token unshield");
       }
-      if (confidentialityType !== "dual" && confidentialityType !== "wrapped") {
-        throw new Error(`Unshield not supported for confidentialityType: ${confidentialityType}`);
-      }
-      const contractConfig = UNSHIELD_ABIS[confidentialityType];
-      if (!contractConfig) {
-        throw new Error(`Unsupported confidentialityType for unshield: ${confidentialityType}`);
-      }
+      assertTokenOperationSupported(confidentialityType, "unshield");
+      const contractConfig = getUnshieldContractConfig(confidentialityType);
       let hash;
       input.onStatusChange?.("Please confirm in wallet...");
-      if (confidentialityType === "wrapped") {
-        const { request } = await publicClient.simulateContract({
-          address: tokenAddress,
-          abi: contractConfig.abi,
-          functionName: contractConfig.functionName,
-          args: [walletClient.account.address, input.amount],
-          account: walletClient.account
-        });
-        hash = await walletClient.writeContract({ ...request, chain: void 0 });
-      } else {
-        const amount = BigInt.asUintN(64, input.amount);
-        const { request } = await publicClient.simulateContract({
-          address: tokenAddress,
-          abi: contractConfig.abi,
-          functionName: contractConfig.functionName,
-          args: [amount],
-          account: walletClient.account
-        });
-        hash = await walletClient.writeContract({ ...request, chain: void 0 });
-      }
+      const { request } = await publicClient.simulateContract({
+        address: tokenAddress,
+        abi: contractConfig.abi,
+        functionName: contractConfig.functionName,
+        args: [walletClient.account.address, input.amount],
+        account: walletClient.account
+      });
+      hash = await walletClient.writeContract({ ...request, chain: void 0 });
       return hash;
     },
     onError: (error, variables, onMutateResult, context) => {
@@ -4323,13 +4277,8 @@ function getCofheTokenClaimUnshieldedCallArgs(params) {
   if (!confidentialityType) {
     throw new Error("confidentialityType is required in token extensions");
   }
-  if (confidentialityType !== "dual" && confidentialityType !== "wrapped") {
-    throw new Error(`Claim not supported for confidentialityType: ${confidentialityType}`);
-  }
-  const contractConfig = CLAIM_ABIS[confidentialityType];
-  if (!contractConfig) {
-    throw new Error(`Unsupported confidentialityType for claim: ${confidentialityType}`);
-  }
+  assertTokenOperationSupported(confidentialityType, "claim");
+  const contractConfig = getClaimContractConfig(confidentialityType);
   return {
     address: tokenAddress,
     abi: contractConfig.abi,
@@ -4362,13 +4311,8 @@ function useCofheTokenClaimUnshielded(options) {
       if (!walletClient.account) {
         throw new Error("Wallet account is required for claim");
       }
-      if (confidentialityType !== "dual" && confidentialityType !== "wrapped") {
-        throw new Error(`Claim not supported for confidentialityType: ${confidentialityType}`);
-      }
-      const contractConfig = CLAIM_ABIS[confidentialityType];
-      if (!contractConfig) {
-        throw new Error(`Unsupported confidentialityType for claim: ${confidentialityType}`);
-      }
+      assertTokenOperationSupported(confidentialityType, "claim");
+      const contractConfig = getClaimContractConfig(confidentialityType);
       const { request } = await publicClient.simulateContract({
         address: tokenAddress,
         abi: contractConfig.abi,
@@ -5198,7 +5142,7 @@ function useReceivePermit({ onSuccess, onError } = {}) {
       setImportedPermit(permit);
       setErrorMsg(null);
     } catch (e) {
-      console.error("Error parsing pasted permit data", e);
+      cofheLogger.error("Error parsing pasted permit data", e);
       setImportedPermit(null);
       setErrorMsg(`Invalid permit data. Expected JSON.`);
     }
@@ -6173,7 +6117,7 @@ var AddressButton = ({ address, className, icon, showCopyIcon = true }) => {
       setCopied(true);
       setTimeout(() => setCopied(false), 2e3);
     } catch (err) {
-      console.error("Failed to copy address:", err);
+      cofheLogger.error("Failed to copy address:", err);
     }
   };
   const truncatedAddress = truncateAddress(address) || "Not connected";
@@ -7747,7 +7691,7 @@ var ImportPermitPage = () => {
         title: "Failed to import permit",
         description: error.message
       });
-      console.error("Error importing permit", error);
+      cofheLogger.error("Error importing permit", error);
     }
   });
   return /* @__PURE__ */ jsx45(
@@ -8079,7 +8023,7 @@ var SendPage = ({ token: _token }) => {
     onError: (error2) => {
       const errorMessage = cofheHumanizeViemError(error2) ?? (error2 instanceof Error ? error2.message : "Failed to send tokens");
       setError(errorMessage);
-      console.error("Send tx submit error:", error2);
+      cofheLogger.error("Send tx submit error:", error2);
     },
     onMutate: () => {
       setError(null);
@@ -8350,7 +8294,7 @@ function useClaimUnshieldedWithLifecycle() {
       const errorMessage = cofheHumanizeViemError(error2) ?? (error2 instanceof Error ? error2.message : "Failed to claim unshielded tokens");
       setError(errorMessage);
       setStatus(null);
-      console.error("Claim tx submit error:", error2);
+      cofheLogger.error("Claim tx submit error:", error2);
     }
   });
   const { isMining: isClaimingMining } = useOnceTransactionMined({
@@ -8409,7 +8353,7 @@ function useShieldWithLifecycle(token) {
       const errorMessage = cofheHumanizeViemError(error2) ?? (error2 instanceof Error ? error2.message : "Failed to shield tokens");
       setError(errorMessage);
       setStatus(null);
-      console.error("Shield tx submit error:", error2);
+      cofheLogger.error("Shield tx submit error:", error2);
     }
   });
   const { tokenApprove, isApprovingMining } = useApproveWithLifecycle({
@@ -8558,7 +8502,7 @@ function useUnshieldWithLifecycle(token) {
       const errorMessage = cofheHumanizeViemError(error2) ?? (error2 instanceof Error ? error2.message : "Failed to unshield tokens");
       setError(errorMessage);
       setStatus(null);
-      console.error("Unshield tx submit error:", error2);
+      cofheLogger.error("Unshield tx submit error:", error2);
     },
     onceMined: (transaction) => {
       if (transaction.status === "confirmed") {
@@ -8628,7 +8572,6 @@ function useUnshieldWithLifecycle(token) {
     primaryIcon: /* @__PURE__ */ jsx50(TbShieldMinus2, { className: "w-3 h-3" })
   };
 }
-var shieldableTypes = /* @__PURE__ */ new Set(["dual", "wrapped"]);
 var ShieldPageV2 = ({ token: _token, defaultMode }) => {
   const [mode, setMode] = useState11(defaultMode ?? "shield");
   const [overriddenToken, setOverriddenToken] = useState11(null);
@@ -8754,9 +8697,15 @@ var ShieldAndUnshieldPageView = ({
 }) => {
   const { navigateBack } = usePortalNavigation();
   const { openModal } = usePortalModals();
-  const isShieldableToken = shieldableTypes.has(token.extensions.fhenix.confidentialityType);
+  const isShieldableToken = isTokenOperationSupported(token.extensions.fhenix.confidentialityType, "shield");
   const { tokensWithExistingEncryptedBalance } = useCofheTokensWithExistingEncryptedBalances();
   const { tokensWithPublicBalances } = useTokensWithPublicBalances();
+  const selectableTokens = useMemo31(
+    () => (mode === "unshield" ? tokensWithExistingEncryptedBalance : tokensWithPublicBalances).filter(
+      (candidate) => isTokenOperationSupported(candidate.extensions.fhenix.confidentialityType, mode)
+    ),
+    [mode, tokensWithExistingEncryptedBalance, tokensWithPublicBalances]
+  );
   return /* @__PURE__ */ jsx50(
     PageContainer,
     {
@@ -8777,7 +8726,7 @@ var ShieldAndUnshieldPageView = ({
           {
             onClick: () => openModal("tokenList" /* TokenList */, {
               balanceType: mode === "shield" ? "public" /* Public */ : "confidential" /* Confidential */,
-              tokens: mode === "unshield" ? tokensWithExistingEncryptedBalance : tokensWithPublicBalances,
+              tokens: selectableTokens,
               title: mode === "shield" ? "Select token to shield" : "Select token to unshield",
               onSelectToken: (token2) => setToken(token2)
             }),
@@ -8898,7 +8847,7 @@ function useApproveWithLifecycle({
       const errorMessage = cofheHumanizeViemError(error) ?? (error instanceof Error ? error.message : "Failed to approve tokens");
       setError(errorMessage);
       setStatus(null);
-      console.error("Approve tx submit error:", error);
+      cofheLogger.error("Approve tx submit error:", error);
     }
   });
   const { isMining: isApprovingMining } = useOnceTransactionMined({
@@ -10431,7 +10380,7 @@ var CofheEncryptInput = ({
         setCopySuccess(false);
       }, 2e3);
     } catch (error) {
-      console.error("Failed to copy to clipboard:", error);
+      cofheLogger.error("Failed to copy to clipboard:", error);
     }
   };
   const handleTypeSelect = async (type) => {
@@ -10450,13 +10399,13 @@ var CofheEncryptInput = ({
             onEncryptComplete?.(data);
           } catch (error) {
             const errorMessage2 = error instanceof Error ? error.message : "Encryption failed";
-            console.error("Encryption failed:", error);
+            cofheLogger.error("Encryption failed:", error);
             onEncryptError?.(errorMessage2);
           }
         })();
       } catch (error) {
         const errorMessage2 = error instanceof Error ? error.message : "Encryption setup failed";
-        console.error("Encryption setup failed:", error);
+        cofheLogger.error("Encryption setup failed:", error);
         onEncryptError?.(errorMessage2);
       }
     }