@cofhe/react 0.4.0 → 0.5.1

package/dist/index.d.cts

@@ -5,18 +5,40 @@ import { z } from 'zod';
 import * as _tanstack_react_query from '@tanstack/react-query';
 import { QueryClient, UseQueryOptions, UseQueryResult, UseMutationOptions, UseMutationResult, MutationFunctionContext } from '@tanstack/react-query';
 import * as viem from 'viem';
-import { WalletClient, PublicClient, Address, Hash, Abi, ContractFunctionName, ContractFunctionArgs, Chain, WriteContractParameters, Account, TransactionReceipt } from 'viem';
+import { WalletClient, PublicClient, Address, ContractFunctionName, Hash, Abi as Abi$1, ContractFunctionArgs, Chain, WriteContractParameters, Account, SimulateContractReturnType, SimulateContractParameters, TransactionReceipt } from 'viem';
+import { Abi, CofheReturnType, CofheInputArgsPreTransform, CofheFirstReturnFheType } from '@cofhe/abi';
 import { Permit } from '@cofhe/sdk/permits';
 import BigNumber from 'bignumber.js';
 import * as zustand_middleware from 'zustand/middleware';
 import * as zustand from 'zustand';
-import { Abi as Abi$1, CofheReturnType, CofheInputArgsPreTransform, CofheFirstReturnFheType } from '@cofhe/abi';
 export { createCofheClient } from '@cofhe/sdk/web';
 
+type CofheReactLoggerMethod = ((...args: unknown[]) => void) | null;
+/**
+ * Logger used by @cofhe/react internal debug logs.
+ *
+ * - Omitted/undefined: disables internal logging
+ * - Object: enables logging and calls only the provided methods
+ * - Method set to null: disables that method
+ */
+type CofheReactLogger = {
+    log?: CofheReactLoggerMethod;
+    warn?: CofheReactLoggerMethod;
+    debug?: CofheReactLoggerMethod;
+    error?: CofheReactLoggerMethod;
+};
+type CofheReactLoggerResolved = {
+    log: (...args: unknown[]) => void;
+    warn: (...args: unknown[]) => void;
+    debug: (...args: unknown[]) => void;
+    error: (...args: unknown[]) => void;
+};
 declare const CofheReactConfigSchema: z.ZodObject<{
     shareablePermits: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
     enableShieldUnshield: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
     autogeneratePermits: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    projectName: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    logger: z.ZodPipe<z.ZodDefault<z.ZodOptional<z.ZodCustom<CofheReactLogger | null, CofheReactLogger | null>>>, z.ZodTransform<CofheReactLoggerResolved, CofheReactLogger | null>>;
     permitExpirationOptions: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodObject<{
         label: z.ZodString;
         intervalSeconds: z.ZodNumber;
@@ -105,7 +127,7 @@ type PageState<K extends keyof FloatingButtonPagePropsMap = FloatingButtonPage$1
 
 type FloatingButtonPosition = 'top-left' | 'top-right' | 'bottom-left' | 'bottom-right';
 type FloatingButtonPositionType = 'fixed' | 'absolute';
-interface FnxFloatingButtonProps extends BaseProps {
+interface CofheFloatingButtonProps extends BaseProps {
     children?: React.ReactNode;
     /** Position of the floating button */
     position?: FloatingButtonPosition;
@@ -177,6 +199,7 @@ declare const useCofhePublicClient: () => {
         number: blockTag extends "pending" ? null : bigint;
         nonce: blockTag extends "pending" ? null : `0x${string}`;
         hash: blockTag extends "pending" ? null : `0x${string}`;
+        size: bigint;
         timestamp: bigint;
         logsBloom: blockTag extends "pending" ? null : `0x${string}`;
         baseFeePerGas: bigint | null;
@@ -193,7 +216,6 @@ declare const useCofhePublicClient: () => {
         receiptsRoot: viem.Hex;
         sealFields: viem.Hex[];
         sha3Uncles: viem.Hash;
-        size: bigint;
         stateRoot: viem.Hash;
         totalDifficulty: bigint | null;
         transactionsRoot: viem.Hash;
@@ -13566,6 +13588,7 @@ declare const useCofheWalletClient: () => {
         id: string;
     }>;
     sendCallsSync: <const calls extends readonly unknown[], chainOverride extends viem.Chain | undefined = undefined>(parameters: viem.SendCallsSyncParameters<viem.Chain | undefined, viem.Account | undefined, chainOverride, calls>) => Promise<{
+        version: string;
         atomic: boolean;
         capabilities?: {
             [key: string]: any;
@@ -13575,7 +13598,6 @@ declare const useCofheWalletClient: () => {
         chainId: number;
         id: string;
         receipts?: viem.WalletCallReceipt<bigint, "success" | "reverted">[] | undefined;
-        version: string;
         statusCode: number;
         status: "pending" | "success" | "failure" | undefined;
     }>;
@@ -14709,20 +14731,6 @@ declare const useCofheWalletClient: () => {
     } & viem.ExactPartial<Pick<viem.PublicActions<viem.Transport, viem.Chain | undefined, viem.Account | undefined>, "getChainId" | "prepareTransactionRequest" | "sendRawTransaction" | "call" | "createContractEventFilter" | "createEventFilter" | "estimateContractGas" | "estimateGas" | "getBlock" | "getBlockNumber" | "getContractEvents" | "getEnsText" | "getFilterChanges" | "getGasPrice" | "getLogs" | "getTransaction" | "getTransactionCount" | "getTransactionReceipt" | "readContract" | "simulateContract" | "uninstallFilter" | "watchBlockNumber" | "watchContractEvent"> & Pick<viem.WalletActions<viem.Chain | undefined, viem.Account | undefined>, "sendTransaction" | "writeContract">>>(fn: (client: viem.Client<viem.Transport, viem.Chain | undefined, viem.Account | undefined, viem.WalletRpcSchema, viem.WalletActions<viem.Chain | undefined, viem.Account | undefined>>) => client) => viem.Client<viem.Transport, viem.Chain | undefined, viem.Account | undefined, viem.WalletRpcSchema, { [K in keyof client]: client[K]; } & viem.WalletActions<viem.Chain | undefined, viem.Account | undefined>>;
 } | undefined;
 
-declare const useCofheActivePermit: () => {
-    permit: Permit;
-    isValid: boolean;
-} | undefined;
-declare const useCofheAllPermits: () => Permit[];
-type Callbacks = {
-    onSuccess?: () => void;
-    onError?: (error: Error) => void;
-};
-declare const useCofheRemovePermit: ({ onSuccess, onError }?: Callbacks) => (hashToRemove: string) => Promise<void>;
-declare const useCofheSelectPermit: ({ onSuccess, onError }?: Callbacks) => (hashToSet: string) => void;
-
-declare const useCofheClient: () => CofheClient<CofheConfigWithReact>;
-
 /**
  * Token types shared across hooks/components/utils.
  *
@@ -14744,6 +14752,54 @@ type Erc20Pair = {
     decimals: number;
     logoURI?: string;
 };
+declare const TOKEN_CONFIDENTIALITY_SUPPORT: {
+    readonly wrapped: {
+        readonly enabled: true;
+        readonly label: "Wrapped confidential token";
+        readonly confidentialValueType: "uint128";
+        readonly publicBalanceSource: "erc20Pair";
+        readonly operations: {
+            readonly confidentialBalance: true;
+            readonly transfer: true;
+            readonly publicBalance: true;
+            readonly shield: true;
+            readonly unshield: true;
+            readonly claim: true;
+            readonly claimable: true;
+        };
+    };
+    readonly pure: {
+        readonly enabled: false;
+        readonly label: "Pure confidential token";
+        readonly confidentialValueType: "uint64";
+        readonly publicBalanceSource: null;
+        readonly operations: {
+            readonly confidentialBalance: false;
+            readonly transfer: false;
+            readonly publicBalance: false;
+            readonly shield: false;
+            readonly unshield: false;
+            readonly claim: false;
+            readonly claimable: false;
+        };
+    };
+    readonly dual: {
+        readonly enabled: false;
+        readonly label: "Dual-balance confidential token";
+        readonly confidentialValueType: "uint64";
+        readonly publicBalanceSource: "token";
+        readonly operations: {
+            readonly confidentialBalance: false;
+            readonly transfer: false;
+            readonly publicBalance: false;
+            readonly shield: false;
+            readonly unshield: false;
+            readonly claim: false;
+            readonly claimable: false;
+        };
+    };
+};
+type TokenConfidentialityType = keyof typeof TOKEN_CONFIDENTIALITY_SUPPORT;
 type Token = {
     chainId: number;
     address: `0x${string}`;
@@ -14753,7 +14809,7 @@ type Token = {
     logoURI?: string;
     extensions: Record<string, unknown> & {
         fhenix: {
-            confidentialityType: 'wrapped' | 'pure' | 'dual';
+            confidentialityType: TokenConfidentialityType;
             confidentialValueType: 'uint64' | 'uint128';
             /** ERC20 pair for wrapped tokens - contains underlying token info */
             erc20Pair?: Erc20Pair;
@@ -14761,6 +14817,49 @@ type Token = {
     };
 };
 
+type UseCofheReadContractQueryOptions<TAbi extends Abi, TfunctionName extends ContractFunctionName<TAbi, 'pure' | 'view'>> = Omit<UseQueryOptions<CofheReturnType<TAbi, TfunctionName>, Error>, 'queryKey' | 'queryFn'> & {
+    enabled?: boolean;
+};
+/**
+ * Generic hook: read a contract and return the result (with permit/error gating support).
+ * is Cofhe-ABI aware: returns CofheReturnType (but doesn't support TArgs typing yet).
+ */
+type UseCofheReadContractResult<TAbi extends Abi, TfunctionName extends ContractFunctionName<TAbi, 'pure' | 'view'>> = UseQueryResult<CofheReturnType<TAbi, TfunctionName>, Error> & {
+    disabledDueToMissingValidPermit: boolean;
+};
+
+declare const TASK_MANAGER_IS_ENABLED_ABI: readonly [{
+    readonly type: "function";
+    readonly name: "isEnabled";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "enabled";
+        readonly type: "bool";
+        readonly internalType: "bool";
+    }];
+    readonly stateMutability: "view";
+}];
+type UseCofheEnabledOptions = UseCofheReadContractQueryOptions<typeof TASK_MANAGER_IS_ENABLED_ABI, 'isEnabled'>;
+type UseCofheEnabledResult = UseCofheReadContractResult<typeof TASK_MANAGER_IS_ENABLED_ABI, 'isEnabled'>;
+/**
+ * Reads `TaskManager.isEnabled()` to determine whether Cofhe is enabled on the connected chain.
+ */
+declare function useCofheEnabled(options?: UseCofheEnabledOptions): UseCofheEnabledResult;
+
+declare const useCofheActivePermit: () => {
+    permit: Permit;
+    isValid: boolean;
+} | undefined;
+declare const useCofheAllPermits: () => Permit[];
+type Callbacks = {
+    onSuccess?: () => void;
+    onError?: (error: Error) => void;
+};
+declare const useCofheRemovePermit: ({ onSuccess, onError }?: Callbacks) => (hashToRemove: string) => Promise<void>;
+declare const useCofheSelectPermit: ({ onSuccess, onError }?: Callbacks) => (hashToSet: string) => void;
+
+declare const useCofheClient: () => CofheClient<CofheConfigWithReact>;
+
 type TokenList = {
     name: string;
     timestamp: string;
@@ -14806,7 +14905,7 @@ type UseConfidentialTokenBalanceResult = {
     isFetching: boolean;
     /** Refetch function */
     refetch: () => Promise<unknown>;
-    disabledDueToMissingPermit: boolean;
+    disabledDueToMissingValidPermit: boolean;
 };
 /**
  * Hook to get confidential (encrypted) balance for a token with convenient formatting.
@@ -14823,7 +14922,7 @@ type WalletWriteContractInputWithExtras<TExtras> = {
     extras: TExtras;
 };
 type WalletWriteContractMutationVariables<TExtras> = WalletWriteContractParamsAny | WalletWriteContractInputWithExtras<TExtras>;
-type WalletWriteContractParams<TAbi extends Abi | readonly unknown[], TFunctionName extends ContractFunctionName<TAbi, 'payable' | 'nonpayable'>, TArgs extends ContractFunctionArgs<TAbi, 'payable' | 'nonpayable', TFunctionName>, TChainOverride extends Chain | undefined = undefined> = WriteContractParameters<TAbi, TFunctionName, TArgs, Chain | undefined, Account | undefined, TChainOverride>;
+type WalletWriteContractParams<TAbi extends Abi$1 | readonly unknown[], TFunctionName extends ContractFunctionName<TAbi, 'payable' | 'nonpayable'>, TArgs extends ContractFunctionArgs<TAbi, 'payable' | 'nonpayable', TFunctionName>, TChainOverride extends Chain | undefined = undefined> = WriteContractParameters<TAbi, TFunctionName, TArgs, Chain | undefined, Account | undefined, TChainOverride>;
 type useCofheWriteContractOptions<TExtras = unknown> = Omit<UseMutationOptions<Hash, Error, WalletWriteContractMutationVariables<TExtras>, unknown>, 'mutationFn'>;
 /**
  * Low-level mutation hook: call `walletClient.writeContract`.
@@ -14831,11 +14930,11 @@ type useCofheWriteContractOptions<TExtras = unknown> = Omit<UseMutationOptions<H
  * Unlike `useCofheWriteContract`, this accepts viem's full `writeContract` parameter type.
  */
 declare function useCofheWriteContract<TExtras = unknown>(options?: useCofheWriteContractOptions<TExtras>): UseMutationResult<Hash, Error, WalletWriteContractMutationVariables<TExtras>, unknown> & {
-    writeContractAsync: <TAbi extends Abi | readonly unknown[], TFunctionName extends ContractFunctionName<TAbi, 'payable' | 'nonpayable'>, TArgs extends ContractFunctionArgs<TAbi, 'payable' | 'nonpayable', TFunctionName>, TChainOverride extends Chain | undefined = undefined>(params: WalletWriteContractParams<TAbi, TFunctionName, TArgs, TChainOverride> | {
+    writeContractAsync: <TAbi extends Abi$1 | readonly unknown[], TFunctionName extends ContractFunctionName<TAbi, 'payable' | 'nonpayable'>, TArgs extends ContractFunctionArgs<TAbi, 'payable' | 'nonpayable', TFunctionName>, TChainOverride extends Chain | undefined = undefined>(params: WalletWriteContractParams<TAbi, TFunctionName, TArgs, TChainOverride> | {
         writeContractInput: WalletWriteContractParams<TAbi, TFunctionName, TArgs, TChainOverride>;
         extras: TExtras;
     }) => Promise<Hash>;
-    writeContract: <TAbi extends Abi | readonly unknown[], TFunctionName extends ContractFunctionName<TAbi, 'payable' | 'nonpayable'>, TArgs extends ContractFunctionArgs<TAbi, 'payable' | 'nonpayable', TFunctionName>, TChainOverride extends Chain | undefined = undefined>(params: WalletWriteContractParams<TAbi, TFunctionName, TArgs, TChainOverride> | {
+    writeContract: <TAbi extends Abi$1 | readonly unknown[], TFunctionName extends ContractFunctionName<TAbi, 'payable' | 'nonpayable'>, TArgs extends ContractFunctionArgs<TAbi, 'payable' | 'nonpayable', TFunctionName>, TChainOverride extends Chain | undefined = undefined>(params: WalletWriteContractParams<TAbi, TFunctionName, TArgs, TChainOverride> | {
         writeContractInput: WalletWriteContractParams<TAbi, TFunctionName, TArgs, TChainOverride>;
         extras: TExtras;
     }) => void;
@@ -14921,6 +15020,21 @@ declare function useCofheTokenTransfer(writeMutationOptions?: UseCofheTokenTrans
     encryptAmountAndSendToken: ({ input, encryptionOptions }: EncryptAndSendInput) => Promise<`0x${string}`>;
 };
 
+type CofheSimulateWriteContractCallArgs<TAbi extends Abi$1 | readonly unknown[] = Abi$1, TFunctionName extends ContractFunctionName<TAbi, 'nonpayable' | 'payable'> = ContractFunctionName<TAbi, 'nonpayable' | 'payable'>, TArgs extends ContractFunctionArgs<TAbi, 'nonpayable' | 'payable', TFunctionName> = ContractFunctionArgs<TAbi, 'nonpayable' | 'payable', TFunctionName>, TChainOverride extends Chain | undefined = Chain | undefined> = SimulateContractParameters<TAbi, TFunctionName, TArgs, Chain | undefined, TChainOverride, Account | Address | undefined>;
+type CofheSimulateWriteContractData<TAbi extends Abi$1 | readonly unknown[], TFunctionName extends ContractFunctionName<TAbi, 'nonpayable' | 'payable'>, TArgs extends ContractFunctionArgs<TAbi, 'nonpayable' | 'payable', TFunctionName>, TChainOverride extends Chain | undefined> = SimulateContractReturnType<TAbi, TFunctionName, TArgs, Chain | undefined, Account | undefined, TChainOverride, Account | Address | undefined>;
+type UseCofheSimulateWriteContractQueryOptions<TData, TSelectedData> = Omit<UseQueryOptions<TData, Error, TSelectedData>, 'queryKey' | 'queryFn'> & {
+    enabled?: boolean;
+};
+declare function useCofheSimulateWriteContract<TAbi extends Abi$1 | readonly unknown[] = Abi$1, TFunctionName extends ContractFunctionName<TAbi, 'nonpayable' | 'payable'> = ContractFunctionName<TAbi, 'nonpayable' | 'payable'>, TArgs extends ContractFunctionArgs<TAbi, 'nonpayable' | 'payable', TFunctionName> = ContractFunctionArgs<TAbi, 'nonpayable' | 'payable', TFunctionName>, TChainOverride extends Chain | undefined = Chain | undefined, TSelectedData = CofheSimulateWriteContractData<TAbi, TFunctionName, TArgs, TChainOverride>>(callArgs?: CofheSimulateWriteContractCallArgs<TAbi, TFunctionName, TArgs, TChainOverride>, queryOptions?: UseCofheSimulateWriteContractQueryOptions<CofheSimulateWriteContractData<TAbi, TFunctionName, TArgs, TChainOverride>, TSelectedData>): UseQueryResult<TSelectedData, Error>;
+
+declare function getCofheTokenShieldCallArgs(params: {
+    token: Token;
+    amount: bigint;
+    account: Address;
+}): {
+    main: CofheSimulateWriteContractCallArgs;
+    approval?: CofheSimulateWriteContractCallArgs;
+};
 type UnshieldClaim = {
     ctHash: bigint;
     requestedAmount: bigint;
@@ -14939,8 +15053,7 @@ type UseTokenShieldInput = {
 type UseTokenShieldOptions = Omit<UseMutationOptions<`0x${string}`, Error, UseTokenShieldInput>, 'mutationFn'>;
 /**
  * Hook to shield tokens (convert regular balance to confidential)
- * - Dual tokens: calls `shield(uint256 amount)`
- * - Wrapped tokens: TBD (needs approval flow)
+ * Wrapped tokens call `encrypt` or `encryptETH`, depending on the paired asset.
  * @param options - Optional React Query mutation options
  * @returns Mutation result with transaction hash
  */
@@ -14959,9 +15072,10 @@ declare enum TransactionActionType {
     ShieldSend = "shieldSend",
     Shield = "shield",
     Unshield = "unshield",
-    Claim = "claim"
+    Claim = "claim",
+    Approve = "approve"
 }
-type TransactionActionString = 'Shielded Transfer' | 'Shield' | 'Unshield' | 'Claim';
+type TransactionActionString = 'Shielded Transfer' | 'Shield' | 'Unshield' | 'Claim' | 'Approve';
 type BaseTransaction = {
     hash: `0x${string}`;
     status: TransactionStatus;
@@ -14981,10 +15095,13 @@ type SendingTransaction = BaseTransaction & {
 type ClaimingTransaction = BaseTransaction & {
     actionType: TransactionActionType.Claim;
 };
+type ApprovingTransaction = BaseTransaction & {
+    actionType: TransactionActionType.Approve;
+};
 type UnshieldingTransaction = BaseTransaction & {
     actionType: TransactionActionType.Unshield;
 };
-type Transaction = UnshieldingTransaction | ShieldingTransaction | SendingTransaction | ClaimingTransaction;
+type Transaction = UnshieldingTransaction | ShieldingTransaction | SendingTransaction | ClaimingTransaction | ApprovingTransaction;
 type NewTransaction = DistributiveOmit<Transaction, 'status' | 'timestamp'>;
 interface TransactionStore {
     transactions: ChainRecord<HashRecord<Transaction>>;
@@ -15012,10 +15129,15 @@ declare const useTransactionStore: zustand.UseBoundStore<Omit<zustand.StoreApi<T
     };
 }>;
 
+declare function getCofheTokenUnshieldCallArgs(params: {
+    token: Token;
+    amount: bigint;
+    account: Address;
+}): CofheSimulateWriteContractCallArgs;
 type UseTokenUnshieldMutationInput = {
     /** Token object with confidentialityType */
     token: Token;
-    /** Amount to unshield (in token's smallest unit, uint64 max for dual) */
+    /** Amount to unshield (in token's smallest unit) */
     amount: bigint;
     /** Optional callback for status updates during the operation */
     onStatusChange?: (message: string) => void;
@@ -15108,6 +15230,10 @@ declare function useCofheTokenUnshield(input: UseCofheTokenUnshieldInput): {
     mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<`0x${string}`, Error, UseTokenUnshieldMutationInput, unknown>;
 };
 
+declare function getCofheTokenClaimUnshieldedCallArgs(params: {
+    token: Token;
+    account: Address;
+}): CofheSimulateWriteContractCallArgs;
 type UseClaimUnshieldInput = {
     /** Token object with confidentialityType */
     token: Token;
@@ -15117,8 +15243,7 @@ type UseClaimUnshieldInput = {
 type UseClaimUnshieldOptions = Omit<UseMutationOptions<`0x${string}`, Error, UseClaimUnshieldInput>, 'mutationFn'>;
 /**
  * Hook to claim unshielded tokens after decryption completes
- * - Dual tokens: calls `claimUnshielded()`
- * - Wrapped tokens: calls `claimAllDecrypted()`
+ * Wrapped tokens call `claimAllDecrypted()`.
  * @param options - Optional React Query mutation options
  * @returns Mutation result with transaction hash
  */
@@ -15131,7 +15256,7 @@ declare function constructUnshieldClaimsQueryKey({ chainId, tokenAddress, confid
     accountAddress: Address | undefined;
 }): (string | number | undefined)[];
 /**
- * Unified unshield claims summary - works for both dual and wrapped tokens
+ * Unshield claims summary for wrapped tokens.
  */
 type UnshieldClaimsSummary = {
     /** Total amount that can be claimed now (decrypted and not claimed) */
@@ -15151,7 +15276,7 @@ type UseUnshieldClaimsInput = {
 };
 type UseUnshieldClaimsOptions = Omit<UseQueryOptions<UnshieldClaimsSummary, Error>, 'queryKey' | 'queryFn'>;
 /**
- * Unified hook to fetch unshield claims for any token type (dual or wrapped)
+ * Hook to fetch wrapped-token unshield claims.
  * @param input - Token object and optional account address
  * @param queryOptions - Optional React Query options
  * @returns Query result with UnshieldClaimsSummary
@@ -15234,24 +15359,11 @@ type UseTokensWithPublicBalancesResult = {
  *
  * Public balance source:
  * - `wrapped`: underlying `erc20Pair` (or native ETH)
- * - `dual`: token contract `balanceOf` (ERC20)
- * - `pure`: skipped (no public balance)
  */
 declare function useTokensWithPublicBalances({ chainId: _chainId, accountAddress, displayDecimals }?: UseTokensWithPublicBalancesInput, options?: {
     enabled?: boolean;
 } & Omit<UseTokenBalanceOptions, 'select'>): UseTokensWithPublicBalancesResult;
 
-type UseCofheReadContractQueryOptions<TAbi extends Abi$1, TfunctionName extends ContractFunctionName<TAbi, 'pure' | 'view'>> = Omit<UseQueryOptions<CofheReturnType<TAbi, TfunctionName>, Error>, 'queryKey' | 'queryFn'> & {
-    enabled?: boolean;
-};
-/**
- * Generic hook: read a contract and return the result (with permit/error gating support).
- * is Cofhe-ABI aware: returns CofheReturnType (but doesn't support TArgs typing yet).
- */
-type UseCofheReadContractResult<TAbi extends Abi$1, TfunctionName extends ContractFunctionName<TAbi, 'pure' | 'view'>> = UseQueryResult<CofheReturnType<TAbi, TfunctionName>, Error> & {
-    disabledDueToMissingPermit: boolean;
-};
-
 type Input$1 = {
     publicClient?: PublicClient;
     walletClient?: WalletClient;
@@ -15328,13 +15440,29 @@ type UseCoingeckoContractMarketChartRangeOptions = Omit<UseQueryOptions<Coingeck
  */
 declare function useCoingeckoContractMarketChartRange({ chainId, contractAddress, enabled: enabledInput, apiBaseUrl, platformIdOverride, vsCurrency, rangeMs, }: UseCoingeckoContractMarketChartRangeInput, queryOptions?: UseCoingeckoContractMarketChartRangeOptions): UseQueryResult<CoingeckoMarketChartPoint[] | null, Error>;
 
+type UseTokenAllowanceInput = {
+    /** ERC20 token contract address */
+    tokenAddress?: Address;
+    /** Allowance owner */
+    ownerAddress?: Address;
+    /** Allowance spender */
+    spenderAddress?: Address;
+};
+type UseTokenAllowanceOptions<TSelectedData = bigint> = Omit<UseQueryOptions<bigint, Error, TSelectedData>, 'queryKey' | 'queryFn'>;
+type UseTokenAllowanceResult = {
+    data?: bigint;
+    isFetching: boolean;
+    refetch: () => Promise<unknown>;
+};
+declare function useTokenAllowance({ tokenAddress, ownerAddress, spenderAddress }: UseTokenAllowanceInput, options?: UseTokenAllowanceOptions): UseTokenAllowanceResult;
+
 type NoInferLocal<T> = [T][T extends any ? 0 : never];
-type ConfidentialityAwareAbiArgs<TAbi extends Abi | readonly unknown[], TFunctionName extends string> = NoInferLocal<Exclude<CofheInputArgsPreTransform<TAbi, TFunctionName>, undefined>>;
+type ConfidentialityAwareAbiArgs<TAbi extends Abi$1 | readonly unknown[], TFunctionName extends string> = NoInferLocal<Exclude<CofheInputArgsPreTransform<TAbi, TFunctionName>, undefined>>;
 declare function useCofheEncryptAndWriteContract<TExtraVars = unknown>({ encrypingMutationOptions, writingMutationOptions, }?: {
     encrypingMutationOptions?: UseCofheEncryptOptions;
     writingMutationOptions?: useCofheWriteContractOptions<TExtraVars>;
 }): {
-    encryptAndWrite: <const TAbi extends Abi, TFunctionName extends ContractFunctionName<TAbi, "payable" | "nonpayable">, TChainOverride extends Chain | undefined = undefined>(args: {
+    encryptAndWrite: <const TAbi extends Abi$1, TFunctionName extends ContractFunctionName<TAbi, "payable" | "nonpayable">, TChainOverride extends Chain | undefined = undefined>(args: {
         params: Omit<WriteContractParameters<TAbi, TFunctionName, ContractFunctionArgs<TAbi, "payable" | "nonpayable", TFunctionName>, Chain | undefined, Account | undefined, TChainOverride>, "args" | "functionName"> & {
             functionName: TFunctionName;
         };
@@ -15348,23 +15476,23 @@ declare function useCofheEncryptAndWriteContract<TExtraVars = unknown>({ encrypi
         isEncrypting: boolean;
         stepsState: StepsState;
     };
-    write: _tanstack_react_query.UseMutationResult<`0x${string}`, Error, WriteContractParameters<Abi | readonly unknown[], string, readonly unknown[], Chain | undefined, Account | undefined, Chain | undefined> | WalletWriteContractInputWithExtras<TExtraVars>, unknown> & {
-        writeContractAsync: <TAbi extends Abi | readonly unknown[], TFunctionName extends ContractFunctionName<TAbi, "nonpayable" | "payable">, TArgs extends ContractFunctionArgs<TAbi, "nonpayable" | "payable", TFunctionName>, TChainOverride extends Chain | undefined = undefined>(params: WalletWriteContractParams<TAbi, TFunctionName, TArgs, TChainOverride> | {
+    write: _tanstack_react_query.UseMutationResult<`0x${string}`, Error, WriteContractParameters<Abi$1 | readonly unknown[], string, readonly unknown[], Chain | undefined, Account | undefined, Chain | undefined> | WalletWriteContractInputWithExtras<TExtraVars>, unknown> & {
+        writeContractAsync: <TAbi extends Abi$1 | readonly unknown[], TFunctionName extends ContractFunctionName<TAbi, "nonpayable" | "payable">, TArgs extends ContractFunctionArgs<TAbi, "nonpayable" | "payable", TFunctionName>, TChainOverride extends Chain | undefined = undefined>(params: WalletWriteContractParams<TAbi, TFunctionName, TArgs, TChainOverride> | {
             writeContractInput: WalletWriteContractParams<TAbi, TFunctionName, TArgs, TChainOverride>;
             extras: TExtraVars;
         }) => Promise<viem.Hash>;
-        writeContract: <TAbi extends Abi | readonly unknown[], TFunctionName extends ContractFunctionName<TAbi, "nonpayable" | "payable">, TArgs extends ContractFunctionArgs<TAbi, "nonpayable" | "payable", TFunctionName>, TChainOverride extends Chain | undefined = undefined>(params: WalletWriteContractParams<TAbi, TFunctionName, TArgs, TChainOverride> | {
+        writeContract: <TAbi extends Abi$1 | readonly unknown[], TFunctionName extends ContractFunctionName<TAbi, "nonpayable" | "payable">, TArgs extends ContractFunctionArgs<TAbi, "nonpayable" | "payable", TFunctionName>, TChainOverride extends Chain | undefined = undefined>(params: WalletWriteContractParams<TAbi, TFunctionName, TArgs, TChainOverride> | {
             writeContractInput: WalletWriteContractParams<TAbi, TFunctionName, TArgs, TChainOverride>;
             extras: TExtraVars;
         }) => void;
     };
 };
 
-type SupportedFheTypeFromReturn<TAbi extends Abi, TfunctionName extends ContractFunctionName<TAbi, 'pure' | 'view'>> = CofheFirstReturnFheType<TAbi, TfunctionName> extends FheTypes ? CofheFirstReturnFheType<TAbi, TfunctionName> : FheTypes;
+type SupportedFheTypeFromReturn<TAbi extends Abi$1, TfunctionName extends ContractFunctionName<TAbi, 'pure' | 'view'>> = CofheFirstReturnFheType<TAbi, TfunctionName> extends FheTypes ? CofheFirstReturnFheType<TAbi, TfunctionName> : FheTypes;
 /**
  * Generic hook: read a confidential contract value and decrypt it.
  */
-declare function useCofheReadContractAndDecrypt<TAbi extends Abi, TfunctionName extends ContractFunctionName<TAbi, 'pure' | 'view'>, TFheType extends FheTypes = SupportedFheTypeFromReturn<TAbi, TfunctionName>, TDecryptedSelectedData = UnsealedItem<TFheType>>(params: {
+declare function useCofheReadContractAndDecrypt<TAbi extends Abi$1, TfunctionName extends ContractFunctionName<TAbi, 'pure' | 'view'>, TFheType extends FheTypes = SupportedFheTypeFromReturn<TAbi, TfunctionName>, TDecryptedSelectedData = UnsealedItem<TFheType>>(params: {
     address?: Address;
     abi?: TAbi;
     functionName?: TfunctionName;
@@ -15376,10 +15504,10 @@ declare function useCofheReadContractAndDecrypt<TAbi extends Abi, TfunctionName
 }): {
     encrypted: UseCofheReadContractResult<TAbi, TfunctionName>;
     decrypted: UseQueryResult<TDecryptedSelectedData, Error>;
-    disabledDueToMissingPermit: boolean;
+    disabledDueToMissingValidPermit: boolean;
 };
 
-declare const FnxFloatingButtonWithProvider: React.FC<FnxFloatingButtonProps>;
+declare const CofheFloatingButtonWithProvider: React.FC<CofheFloatingButtonProps>;
 
 declare const MainPage: React.FC;
 
@@ -15437,7 +15565,7 @@ declare module '../pagesConfig/types' {
     }
 }
 
-interface FnxEncryptInputProps extends BaseProps {
+interface CofheEncryptInputProps extends BaseProps {
     /** Placeholder text for the text field */
     placeholder?: string;
     /** Initial value for the text field */
@@ -15469,7 +15597,7 @@ interface FnxEncryptInputProps extends BaseProps {
     /** Callback when encryption fails */
     onEncryptError?: (_error: string) => void;
 }
-declare const FnxEncryptInput: React.FC<FnxEncryptInputProps>;
+declare const CofheEncryptInput: React.FC<CofheEncryptInputProps>;
 
 /**
  * Gets the block explorer URL for a given chain ID
@@ -15536,12 +15664,9 @@ declare const truncateHash: (value: string, start?: number, end?: number) => str
  */
 declare const formatRelativeTime: (timestamp: number) => string;
 
-declare const fheTypeToString: (fheType: FheTypeValue) => "unknown" | "ebool" | "euint8" | "euint16" | "euint32" | "euint64" | "euint128" | "eaddress";
-declare const encryptedValueToString: (fheType: FheTypeValue, handle: bigint) => string;
-
 type Input = {
     cause?: GeneratePermitPageProps['cause'];
 };
 declare const useCofheNavigateToCreatePermit: () => ({ cause }?: Input) => void;
 
-export { type ClaimableAmountByTokenAddress, type CofheClientConfig, type CofheContextValue, CofheProvider, type CofheProviderProps, type CofheConfigWithReact as CofhesdkConfigWithReact, type CoingeckoMarketChartPoint, ETH_ADDRESS_LOWERCASE, type Erc20Pair, FheTypesList, type FloatingButtonPosition, FnxEncryptInput, type FnxFloatingButtonProps, FnxFloatingButtonWithProvider, MainPage, SettingsPage, type Token, type Transaction, type TransactionActionString, TransactionActionType, TransactionStatus, type TransactionStatusString, type TransactionStore, type UnshieldClaim, type UnshieldClaimsSummary, type UnshieldClaimsSummaryByTokenAddress, type UseCoingeckoContractMarketChartRangeInput, type UseCoingeckoContractMarketChartRangeOptions, type UseCoingeckoUsdPriceInput, type UseCoingeckoUsdPriceOptions, type UseTransactionReceiptsByHashInput, actionToString, createCofheConfig, encryptedValueToString, fheTypeToString, formatRelativeTime, getBlockExplorerAddressUrl, getBlockExplorerTokenUrl, getBlockExplorerTxUrl, getBlockExplorerUrl, isEthPair, isWrappedEthToken, statusToString, truncateHash, useCofheActivePermit, useCofheAllPermits, useCofheAutoConnect, useCofheClient, useCofheConnection, useCofheContext, useCofheEncrypt, useCofheEncryptAndWriteContract, useCofheNavigateToCreatePermit, useCofhePublicClient, useCofheReadContractAndDecrypt, useCofheRemovePermit, useCofheSelectPermit, useCofheTokenClaimUnshielded, useCofheTokenClaimable, useCofheTokenDecryptedBalance, useCofheTokenLists, useCofheTokenShield, useCofheTokenTransfer, useCofheTokenUnshield, useCofheTokens, useCofheTokensClaimable, useCofheTokensWithExistingEncryptedBalances, useCofheWalletClient, useCofheWriteContract, useCoingeckoContractMarketChartRange, useCoingeckoUsdPrice, useInternalQueryClient, useTokensWithPublicBalances, useTransactionReceiptsByHash, useTransactionStore };
+export { type ClaimableAmountByTokenAddress, type CofheClientConfig, type CofheContextValue, CofheEncryptInput, type CofheFloatingButtonProps, CofheFloatingButtonWithProvider, CofheProvider, type CofheProviderProps, type CofheReactLogger, type CofheReactLoggerMethod, type CofheConfigWithReact as CofhesdkConfigWithReact, type CoingeckoMarketChartPoint, ETH_ADDRESS_LOWERCASE, type Erc20Pair, FheTypesList, type FloatingButtonPosition, MainPage, SettingsPage, type Token, type Transaction, type TransactionActionString, TransactionActionType, TransactionStatus, type TransactionStatusString, type TransactionStore, type UnshieldClaim, type UnshieldClaimsSummary, type UnshieldClaimsSummaryByTokenAddress, type UseCoingeckoContractMarketChartRangeInput, type UseCoingeckoContractMarketChartRangeOptions, type UseCoingeckoUsdPriceInput, type UseCoingeckoUsdPriceOptions, type UseTransactionReceiptsByHashInput, actionToString, createCofheConfig, formatRelativeTime, getBlockExplorerAddressUrl, getBlockExplorerTokenUrl, getBlockExplorerTxUrl, getBlockExplorerUrl, getCofheTokenClaimUnshieldedCallArgs, getCofheTokenShieldCallArgs, getCofheTokenUnshieldCallArgs, isEthPair, isWrappedEthToken, statusToString, truncateHash, useCofheActivePermit, useCofheAllPermits, useCofheAutoConnect, useCofheClient, useCofheConnection, useCofheContext, useCofheEnabled, useCofheEncrypt, useCofheEncryptAndWriteContract, useCofheNavigateToCreatePermit, useCofhePublicClient, useCofheReadContractAndDecrypt, useCofheRemovePermit, useCofheSelectPermit, useCofheSimulateWriteContract, useCofheTokenClaimUnshielded, useCofheTokenClaimable, useCofheTokenDecryptedBalance, useCofheTokenLists, useCofheTokenShield, useCofheTokenTransfer, useCofheTokenUnshield, useCofheTokens, useCofheTokensClaimable, useCofheTokensWithExistingEncryptedBalances, useCofheWalletClient, useCofheWriteContract, useCoingeckoContractMarketChartRange, useCoingeckoUsdPrice, useInternalQueryClient, useTokenAllowance, useTokensWithPublicBalances, useTransactionReceiptsByHash, useTransactionStore };