@zama-fhe/react-sdk 2.3.0-alpha.3 → 2.3.0

package/README.md

@@ -425,9 +425,9 @@ function useUnshield(
   options?: UseMutationOptions<Address, Error, UnshieldParams>,
 ): UseMutationResult<Address, Error, UnshieldParams>;
 
-interface UnshieldParams {
+interface UnshieldParams extends UnshieldCallbacks {
   amount: bigint;
-  callbacks?: UnshieldCallbacks;
+  skipBalanceCheck?: boolean;
 }
 ```
 
@@ -438,11 +438,9 @@ const { mutateAsync: unshield, isPending } = useUnshield({
 
 const finalizeTxHash = await unshield({
   amount: 500n,
-  callbacks: {
-    onUnwrapSubmitted: (txHash) => console.log("Unwrap tx:", txHash),
-    onFinalizing: () => console.log("Finalizing..."),
-    onFinalizeSubmitted: (txHash) => console.log("Finalize tx:", txHash),
-  },
+  onUnwrapSubmitted: (txHash) => console.log("Unwrap tx:", txHash),
+  onFinalizing: () => console.log("Finalizing..."),
+  onFinalizeSubmitted: (txHash) => console.log("Finalize tx:", txHash),
 });
 ```
 
@@ -456,9 +454,7 @@ function useUnshieldAll(
   options?: UseMutationOptions<Address, Error, UnshieldAllParams | void>,
 ): UseMutationResult<Address, Error, UnshieldAllParams | void>;
 
-interface UnshieldAllParams {
-  callbacks?: UnshieldCallbacks;
-}
+interface UnshieldAllParams extends UnshieldCallbacks {}
 ```
 
 ```tsx
@@ -479,9 +475,8 @@ function useResumeUnshield(
   options?: UseMutationOptions<Address, Error, ResumeUnshieldParams>,
 ): UseMutationResult<Address, Error, ResumeUnshieldParams>;
 
-interface ResumeUnshieldParams {
+interface ResumeUnshieldParams extends UnshieldCallbacks {
   unwrapTxHash: Hex;
-  callbacks?: UnshieldCallbacks;
 }
 ```
 

package/dist/index.d.ts

@@ -1,7 +1,7 @@
 "use client";
 
 import * as _$_zama_fhe_sdk0 from "@zama-fhe/sdk";
-import { ACL_TOPICS, AclEvent, AclPausedError, ActivityAmount, ActivityDirection, ActivityItem, ActivityItem as ActivityItem$1, ActivityLogMetadata, ActivityLogMetadata as ActivityLogMetadata$1, ActivityType, Address, Address as Address$1, ApprovalFailedError, ApproveSubmittedEvent, ApproveUnderlyingSubmittedEvent, BaseEvent, BatchDecryptAsOptions, BatchDecryptAsOptions as BatchDecryptAsOptions$1, BatchDecryptOptions, BatchTransferData, ChromeSessionStorage, ClearValueType, ClearValueType as ClearValueType$1, ConfidentialTransferEvent, ConfigurationError, ContractAbi, CredentialsAllowedEvent, CredentialsCachedEvent, CredentialsCreatedEvent, CredentialsCreatingEvent, CredentialsExpiredEvent, CredentialsLoadingEvent, CredentialsManager, CredentialsManagerConfig, CredentialsRevokedEvent, DecryptEndEvent, DecryptErrorEvent, DecryptStartEvent, DecryptionFailedError, DefaultRegistryAddresses, DelegatedCredentialsManager, DelegatedCredentialsManagerConfig, DelegatedForUserDecryptionEvent, DelegatedStoredCredentials, DelegatedUserDecryptParams, DelegatedUserDecryptParams as DelegatedUserDecryptParams$1, DelegationContractIsSelfError, DelegationCooldownError, DelegationDelegateEqualsContractError, DelegationExpirationTooSoonError, DelegationExpiredError, DelegationExpiryUnchangedError, DelegationNotFoundError, DelegationNotPropagatedError, DelegationSelfNotAllowedError, EIP712TypedData, EIP712TypedData as EIP712TypedData$1, ERC7984_INTERFACE_ID, ERC7984_WRAPPER_INTERFACE_ID, EncryptEndEvent, EncryptErrorEvent, EncryptInput, EncryptParams, EncryptParams as EncryptParams$1, EncryptResult, EncryptResult as EncryptResult$1, EncryptStartEvent, EncryptionFailedError, FheTypeName, FhevmInstanceConfig, FinalizeUnwrapSubmittedEvent, GenericSigner, GenericSigner as GenericSigner$1, GenericStorage, GenericStorage as GenericStorage$1, Handle, Handle as Handle$1, HardhatConfig, Hex, IndexedDBStorage, InputProofBytesType, InvalidKeypairError, KeypairExpiredError, KeypairType, KmsDelegatedUserDecryptEIP712Type, ListPairsOptions, MainnetConfig, MemoryStorage, NetworkType, NoCiphertextError, OnChainEvent, PaginatedResult, PaginatedResult as PaginatedResult$1, PublicDecryptResult, PublicDecryptResult as PublicDecryptResult$1, RawLog, RawLog as RawLog$1, ReadContractArgs, ReadContractConfig, ReadContractReturnType, ReadFunctionName, ReadonlyToken, ReadonlyToken as ReadonlyToken$1, ReadonlyTokenConfig, RelayerRequestFailedError, RelayerSDK, RelayerSDK as RelayerSDK$1, RelayerSDKStatus, RelayerWeb, RelayerWebConfig, RelayerWebSecurityConfig, RevokedDelegationForUserDecryptionEvent, SepoliaConfig, SessionExpiredEvent, ShieldCallbacks, ShieldSubmittedEvent, SigningFailedError, SigningRejectedError, StoredCredentials, TOKEN_TOPICS, Token, TokenConfig, TokenWrapperPair, TokenWrapperPair as TokenWrapperPair$1, TokenWrapperPairWithMetadata, TokenWrapperPairWithMetadata as TokenWrapperPairWithMetadata$1, Topics, TransactionErrorEvent, TransactionReceipt, TransactionResult, TransactionResult as TransactionResult$1, TransactionRevertedError, TransferCallbacks, TransferFromSubmittedEvent, TransferSubmittedEvent, UnshieldCallbacks, UnshieldPhase1SubmittedEvent, UnshieldPhase2StartedEvent, UnshieldPhase2SubmittedEvent, UnwrapRequestedEvent, UnwrapSubmittedEvent, UnwrappedFinalizedEvent, UnwrappedStartedEvent, UserDecryptParams, WrappedEvent, WrappersRegistry, WrappersRegistryConfig, WriteContractArgs, WriteContractConfig, WriteFunctionName, ZERO_HANDLE, ZKProofLike, ZKProofLike as ZKProofLike$1, ZamaError, ZamaErrorCode, ZamaSDK, ZamaSDK as ZamaSDK$1, ZamaSDKConfig, ZamaSDKEvent, ZamaSDKEventInput, ZamaSDKEventListener, ZamaSDKEventListener as ZamaSDKEventListener$1, ZamaSDKEventType, ZamaSDKEvents, allowanceContract, applyDecryptedValues, approveContract, balanceOfContract, chromeSessionStorage, clearPendingUnshield, confidentialBalanceOfContract, confidentialBatchTransferContract, confidentialTotalSupplyContract, confidentialTransferContract, confidentialTransferFromContract, decimalsContract, decodeAclEvent, decodeAclEvents, decodeConfidentialTransfer, decodeDelegatedForUserDecryption, decodeOnChainEvent, decodeOnChainEvents, decodeRevokedDelegationForUserDecryption, decodeUnwrapRequested, decodeUnwrappedFinalized, decodeUnwrappedStarted, decodeWrapped, delegateForUserDecryptionContract, deploymentCoordinatorContract, extractEncryptedHandles, finalizeUnwrapContract, findDelegatedForUserDecryption, findRevokedDelegationForUserDecryption, findUnwrapRequested, findWrapped, getBatchTransferFeeContract, getDelegationExpiryContract, getFeeRecipientContract, getUnwrapFeeContract, getWrapFeeContract, getWrapperContract, indexedDBStorage, isConfidentialTokenContract, isConfidentialWrapperContract, isFinalizeUnwrapOperatorContract, isHandleDelegatedContract, isOperatorContract, loadPendingUnshield, matchZamaError, memoryStorage, nameContract, parseActivityFeed, rateContract, revokeDelegationContract, savePendingUnshield, setFinalizeUnwrapOperatorContract, setOperatorContract, sortByBlockNumber, supportsInterfaceContract, symbolContract, totalSupplyContract, underlyingContract, unwrapContract, unwrapFromBalanceContract, wrapContract, wrapETHContract, wrapperExistsContract } from "@zama-fhe/sdk";
+import { ACL_TOPICS, AclEvent, AclPausedError, ActivityAmount, ActivityDirection, ActivityItem, ActivityItem as ActivityItem$1, ActivityLogMetadata, ActivityLogMetadata as ActivityLogMetadata$1, ActivityType, Address, Address as Address$1, ApprovalFailedError, ApproveSubmittedEvent, ApproveUnderlyingSubmittedEvent, BalanceCheckUnavailableError, BaseEvent, BatchDecryptAsOptions, BatchDecryptAsOptions as BatchDecryptAsOptions$1, BatchDecryptOptions, BatchTransferData, ChromeSessionStorage, ClearValueType, ClearValueType as ClearValueType$1, ConfidentialTransferEvent, ConfigurationError, ContractAbi, CredentialsAllowedEvent, CredentialsCachedEvent, CredentialsCreatedEvent, CredentialsCreatingEvent, CredentialsExpiredEvent, CredentialsLoadingEvent, CredentialsManager, CredentialsManagerConfig, CredentialsRevokedEvent, DecryptEndEvent, DecryptErrorEvent, DecryptStartEvent, DecryptionFailedError, DefaultRegistryAddresses, DelegatedCredentialsManager, DelegatedCredentialsManagerConfig, DelegatedForUserDecryptionEvent, DelegatedStoredCredentials, DelegatedUserDecryptParams, DelegatedUserDecryptParams as DelegatedUserDecryptParams$1, DelegationContractIsSelfError, DelegationCooldownError, DelegationDelegateEqualsContractError, DelegationExpirationTooSoonError, DelegationExpiredError, DelegationExpiryUnchangedError, DelegationNotFoundError, DelegationNotPropagatedError, DelegationSelfNotAllowedError, EIP712TypedData, EIP712TypedData as EIP712TypedData$1, ERC20ReadFailedError, ERC7984_INTERFACE_ID, ERC7984_WRAPPER_INTERFACE_ID, EncryptEndEvent, EncryptErrorEvent, EncryptInput, EncryptParams, EncryptParams as EncryptParams$1, EncryptResult, EncryptResult as EncryptResult$1, EncryptStartEvent, EncryptionFailedError, FheTypeName, FhevmInstanceConfig, FinalizeUnwrapSubmittedEvent, GenericSigner, GenericSigner as GenericSigner$1, GenericStorage, GenericStorage as GenericStorage$1, Handle, Handle as Handle$1, HardhatConfig, Hex, IndexedDBStorage, InputProofBytesType, InsufficientConfidentialBalanceError, InsufficientERC20BalanceError, InvalidKeypairError, KeypairExpiredError, KeypairType, KmsDelegatedUserDecryptEIP712Type, ListPairsOptions, MainnetConfig, MemoryStorage, NetworkType, NoCiphertextError, OnChainEvent, PaginatedResult, PaginatedResult as PaginatedResult$1, PublicDecryptResult, PublicDecryptResult as PublicDecryptResult$1, RawLog, RawLog as RawLog$1, ReadContractArgs, ReadContractConfig, ReadContractReturnType, ReadFunctionName, ReadonlyToken, ReadonlyToken as ReadonlyToken$1, ReadonlyTokenConfig, RelayerRequestFailedError, RelayerSDK, RelayerSDK as RelayerSDK$1, RelayerSDKStatus, RelayerWeb, RelayerWebConfig, RelayerWebSecurityConfig, RevokedDelegationForUserDecryptionEvent, SepoliaConfig, SessionExpiredEvent, ShieldCallbacks, ShieldSubmittedEvent, SigningFailedError, SigningRejectedError, StoredCredentials, TOKEN_TOPICS, Token, TokenConfig, TokenWrapperPair, TokenWrapperPair as TokenWrapperPair$1, TokenWrapperPairWithMetadata, TokenWrapperPairWithMetadata as TokenWrapperPairWithMetadata$1, Topics, TransactionErrorEvent, TransactionReceipt, TransactionResult, TransactionResult as TransactionResult$1, TransactionRevertedError, TransferCallbacks, TransferFromSubmittedEvent, TransferSubmittedEvent, UnshieldCallbacks, UnshieldPhase1SubmittedEvent, UnshieldPhase2StartedEvent, UnshieldPhase2SubmittedEvent, UnwrapRequestedEvent, UnwrapSubmittedEvent, UnwrappedFinalizedEvent, UnwrappedStartedEvent, UserDecryptParams, WrappedEvent, WrappersRegistry, WrappersRegistryConfig, WriteContractArgs, WriteContractConfig, WriteFunctionName, ZERO_HANDLE, ZKProofLike, ZKProofLike as ZKProofLike$1, ZamaError, ZamaErrorCode, ZamaSDK, ZamaSDK as ZamaSDK$1, ZamaSDKConfig, ZamaSDKEvent, ZamaSDKEventInput, ZamaSDKEventListener, ZamaSDKEventListener as ZamaSDKEventListener$1, ZamaSDKEventType, ZamaSDKEvents, allowanceContract, applyDecryptedValues, approveContract, balanceOfContract, chromeSessionStorage, clearPendingUnshield, confidentialBalanceOfContract, confidentialBatchTransferContract, confidentialTotalSupplyContract, confidentialTransferContract, confidentialTransferFromContract, decimalsContract, decodeAclEvent, decodeAclEvents, decodeConfidentialTransfer, decodeDelegatedForUserDecryption, decodeOnChainEvent, decodeOnChainEvents, decodeRevokedDelegationForUserDecryption, decodeUnwrapRequested, decodeUnwrappedFinalized, decodeUnwrappedStarted, decodeWrapped, delegateForUserDecryptionContract, deploymentCoordinatorContract, extractEncryptedHandles, finalizeUnwrapContract, findDelegatedForUserDecryption, findRevokedDelegationForUserDecryption, findUnwrapRequested, findWrapped, getBatchTransferFeeContract, getDelegationExpiryContract, getFeeRecipientContract, getUnwrapFeeContract, getWrapFeeContract, getWrapperContract, indexedDBStorage, isConfidentialTokenContract, isConfidentialWrapperContract, isFinalizeUnwrapOperatorContract, isHandleDelegatedContract, isOperatorContract, loadPendingUnshield, matchZamaError, memoryStorage, nameContract, parseActivityFeed, rateContract, revokeDelegationContract, savePendingUnshield, setFinalizeUnwrapOperatorContract, setOperatorContract, sortByBlockNumber, supportsInterfaceContract, symbolContract, totalSupplyContract, underlyingContract, unwrapContract, unwrapFromBalanceContract, wrapContract, wrapETHContract, wrapperExistsContract } from "@zama-fhe/sdk";
 import { ApproveUnderlyingParams, ApproveUnderlyingParams as ApproveUnderlyingParams$1, BatchDecryptBalancesAsParams, ConfidentialApproveParams, ConfidentialApproveParams as ConfidentialApproveParams$1, ConfidentialBalancesData, ConfidentialBalancesData as ConfidentialBalancesData$1, ConfidentialTransferFromParams, ConfidentialTransferFromParams as ConfidentialTransferFromParams$1, ConfidentialTransferParams, ConfidentialTransferParams as ConfidentialTransferParams$1, CreateDelegatedUserDecryptEIP712Params, CreateEIP712Params, DecryptBalanceAsParams, DecryptBalanceAsParams as DecryptBalanceAsParams$1, DecryptHandle, DelegateDecryptionParams, DelegateDecryptionParams as DelegateDecryptionParams$1, DelegationStatusData, DelegationStatusData as DelegationStatusData$1, DelegationStatusQueryConfig, FinalizeUnwrapParams, FinalizeUnwrapParams as FinalizeUnwrapParams$1, ListPairsQueryConfig, ResumeUnshieldParams, ResumeUnshieldParams as ResumeUnshieldParams$1, RevokeDelegationParams, RevokeDelegationParams as RevokeDelegationParams$1, ShieldETHParams, ShieldETHParams as ShieldETHParams$1, ShieldParams, ShieldParams as ShieldParams$1, TokenMetadata, UnshieldAllParams, UnshieldAllParams as UnshieldAllParams$1, UnshieldParams, UnshieldParams as UnshieldParams$1, UnwrapParams, UnwrapParams as UnwrapParams$1, UserDecryptCallbacks, UserDecryptCallbacks as UserDecryptCallbacks$1, UserDecryptMutationParams, UserDecryptMutationParams as UserDecryptMutationParams$1, activityFeedQueryOptions, allowMutationOptions, approveUnderlyingMutationOptions, batchDecryptBalancesAsMutationOptions, batchTransferFeeQueryOptions, confidentialApproveMutationOptions, confidentialBalanceQueryOptions, confidentialBalancesQueryOptions, confidentialHandleQueryOptions, confidentialHandlesQueryOptions, confidentialIsApprovedQueryOptions, confidentialTransferFromMutationOptions, confidentialTransferMutationOptions, createDelegatedUserDecryptEIP712MutationOptions, createEIP712MutationOptions, decryptBalanceAsMutationOptions, delegateDecryptionMutationOptions, delegatedUserDecryptMutationOptions, delegationStatusQueryOptions, encryptMutationOptions, feeRecipientQueryOptions, filterQueryOptions, finalizeUnwrapMutationOptions, generateKeypairMutationOptions, hashFn, isAllowedQueryOptions, isConfidentialQueryOptions, isWrapperQueryOptions, listPairsQueryOptions, publicDecryptMutationOptions, publicKeyQueryOptions, publicParamsQueryOptions, requestZKProofVerificationMutationOptions, resumeUnshieldMutationOptions, revokeDelegationMutationOptions, revokeMutationOptions, revokeSessionMutationOptions, shieldETHMutationOptions, shieldFeeQueryOptions, shieldMutationOptions, signerAddressQueryOptions, tokenMetadataQueryOptions, totalSupplyQueryOptions, underlyingAllowanceQueryOptions, unshieldAllMutationOptions, unshieldFeeQueryOptions, unshieldMutationOptions, unwrapAllMutationOptions, unwrapMutationOptions, userDecryptMutationOptions, wrapperDiscoveryQueryOptions, zamaQueryKeys } from "@zama-fhe/sdk/query";
 import * as _$_tanstack_react_query0 from "@tanstack/react-query";
 import { QueryKey, UseMutationOptions, UseMutationResult, UseQueryOptions } from "@tanstack/react-query";
@@ -1699,5 +1699,5 @@ interface OptimisticMutateContext {
   callerContext?: unknown;
 }
 //#endregion
-export { ACL_TOPICS, type AclEvent, AclPausedError, type ActivityAmount, type ActivityDirection, type ActivityItem, type ActivityLogMetadata, type ActivityType, type Address, ApprovalFailedError, type ApproveSubmittedEvent, type ApproveUnderlyingParams, type ApproveUnderlyingSubmittedEvent, type BaseEvent, type BatchDecryptAsOptions, type BatchDecryptBalancesAsParams, type BatchDecryptOptions, type BatchTransferData, ChromeSessionStorage, type ClearValueType, type ConfidentialApproveParams, type ConfidentialBalancesData, type ConfidentialTransferEvent, type ConfidentialTransferFromParams, type ConfidentialTransferParams, ConfigurationError, type ContractAbi, type CreateDelegatedUserDecryptEIP712Params, type CreateEIP712Params, type CredentialsAllowedEvent, type CredentialsCachedEvent, type CredentialsCreatedEvent, type CredentialsCreatingEvent, type CredentialsExpiredEvent, type CredentialsLoadingEvent, CredentialsManager, type CredentialsManagerConfig, type CredentialsRevokedEvent, type DecryptBalanceAsParams, type UserDecryptCallbacks as DecryptCallbacks, type DecryptEndEvent, type DecryptErrorEvent, type DecryptHandle, type UserDecryptMutationParams as DecryptParams, type DecryptStartEvent, DecryptionFailedError, DefaultRegistryAddresses, type DelegateDecryptionParams, DelegatedCredentialsManager, type DelegatedCredentialsManagerConfig, type DelegatedForUserDecryptionEvent, type DelegatedStoredCredentials, type DelegatedUserDecryptParams, DelegationContractIsSelfError, DelegationCooldownError, DelegationDelegateEqualsContractError, DelegationExpirationTooSoonError, DelegationExpiredError, DelegationExpiryUnchangedError, DelegationNotFoundError, DelegationNotPropagatedError, DelegationSelfNotAllowedError, type DelegationStatusData, type DelegationStatusQueryConfig, type EIP712TypedData, ERC7984_INTERFACE_ID, ERC7984_WRAPPER_INTERFACE_ID, type EncryptEndEvent, type EncryptErrorEvent, type EncryptInput, type EncryptParams, type EncryptResult, type EncryptStartEvent, EncryptionFailedError, type FheTypeName, type FhevmInstanceConfig, type FinalizeUnwrapParams, type FinalizeUnwrapSubmittedEvent, type GenericSigner, type GenericStorage, type Handle, HardhatConfig, type Hex, IndexedDBStorage, type InputProofBytesType, InvalidKeypairError, KeypairExpiredError, type KeypairType, type KmsDelegatedUserDecryptEIP712Type, type ListPairsOptions, type ListPairsQueryConfig, MainnetConfig, MemoryStorage, type NetworkType, NoCiphertextError, type OnChainEvent, type OptimisticBalanceSnapshot, type OptimisticMutateContext, type PaginatedResult, type PublicDecryptResult, type PublicKeyData, type PublicParamsData, type RawLog, type ReadContractArgs, type ReadContractConfig, type ReadContractReturnType, type ReadFunctionName, ReadonlyToken, type ReadonlyTokenConfig, RelayerRequestFailedError, type RelayerSDK, type RelayerSDKStatus, RelayerWeb, type RelayerWebConfig, type RelayerWebSecurityConfig, type ResumeUnshieldParams, type RevokeDelegationParams, type RevokedDelegationForUserDecryptionEvent, SepoliaConfig, type SessionExpiredEvent, type ShieldCallbacks, type ShieldETHParams, type ShieldParams, type ShieldSubmittedEvent, SigningFailedError, SigningRejectedError, type StoredCredentials, TOKEN_TOPICS, Token, type TokenConfig, type TokenMetadata, type TokenWrapperPair, type TokenWrapperPairWithMetadata, Topics, type TransactionErrorEvent, type TransactionReceipt, type TransactionResult, TransactionRevertedError, type TransferCallbacks, type TransferFromSubmittedEvent, type TransferSubmittedEvent, type UnshieldAllParams, type UnshieldCallbacks, type UnshieldParams, type UnshieldPhase1SubmittedEvent, type UnshieldPhase2StartedEvent, type UnshieldPhase2SubmittedEvent, type UnwrapParams, type UnwrapRequestedEvent, type UnwrapSubmittedEvent, type UnwrappedFinalizedEvent, type UnwrappedStartedEvent, type UseActivityFeedConfig, type UseConfidentialBalanceConfig, type UseConfidentialBalanceOptions, type UseConfidentialBalancesConfig, type UseConfidentialBalancesOptions, type UseConfidentialIsApprovedConfig, type UseConfidentialIsApprovedSuspenseConfig, type UseConfidentialTransferConfig, type UseDelegationStatusConfig, type UseFeeConfig, type UseShieldConfig, type UseShieldETHConfig, type UseUnderlyingAllowanceConfig, type UseUserDecryptConfig, type UseWrapperDiscoveryConfig, type UseWrapperDiscoverySuspenseConfig, type UseZamaConfig, type UserDecryptCallbacks$1 as UserDecryptCallbacks, type UserDecryptMutationParams$1 as UserDecryptMutationParams, type UserDecryptParams, type WrappedEvent, WrappersRegistry, type WrappersRegistryConfig, type WriteContractArgs, type WriteContractConfig, type WriteFunctionName, ZERO_HANDLE, type ZKProofLike, ZamaError, ZamaErrorCode, ZamaProvider, type ZamaProviderProps, ZamaSDK, type ZamaSDKConfig, type ZamaSDKEvent, type ZamaSDKEventInput, type ZamaSDKEventListener, type ZamaSDKEventType, ZamaSDKEvents, activityFeedQueryOptions, allowMutationOptions, allowanceContract, applyDecryptedValues, approveContract, approveUnderlyingMutationOptions, balanceOfContract, batchDecryptBalancesAsMutationOptions, batchTransferFeeQueryOptions, chromeSessionStorage, clearPendingUnshield, confidentialApproveMutationOptions, confidentialBalanceOfContract, confidentialBalanceQueryOptions, confidentialBalancesQueryOptions, confidentialBatchTransferContract, confidentialHandleQueryOptions, confidentialHandlesQueryOptions, confidentialIsApprovedQueryOptions, confidentialTotalSupplyContract, confidentialTransferContract, confidentialTransferFromContract, confidentialTransferFromMutationOptions, confidentialTransferMutationOptions, createDelegatedUserDecryptEIP712MutationOptions, createEIP712MutationOptions, decimalsContract, decodeAclEvent, decodeAclEvents, decodeConfidentialTransfer, decodeDelegatedForUserDecryption, decodeOnChainEvent, decodeOnChainEvents, decodeRevokedDelegationForUserDecryption, decodeUnwrapRequested, decodeUnwrappedFinalized, decodeUnwrappedStarted, decodeWrapped, decryptBalanceAsMutationOptions, delegateDecryptionMutationOptions, delegateForUserDecryptionContract, delegatedUserDecryptMutationOptions, delegationStatusQueryOptions, deploymentCoordinatorContract, encryptMutationOptions, extractEncryptedHandles, feeRecipientQueryOptions, filterQueryOptions, finalizeUnwrapContract, finalizeUnwrapMutationOptions, findDelegatedForUserDecryption, findRevokedDelegationForUserDecryption, findUnwrapRequested, findWrapped, generateKeypairMutationOptions, getBatchTransferFeeContract, getDelegationExpiryContract, getFeeRecipientContract, getUnwrapFeeContract, getWrapFeeContract, getWrapperContract, hashFn, indexedDBStorage, isAllowedQueryOptions, isConfidentialQueryOptions, isConfidentialTokenContract, isConfidentialWrapperContract, isFinalizeUnwrapOperatorContract, isHandleDelegatedContract, isOperatorContract, isWrapperQueryOptions, listPairsQueryOptions, loadPendingUnshield, matchZamaError, memoryStorage, nameContract, parseActivityFeed, publicDecryptMutationOptions, publicKeyQueryOptions, publicParamsQueryOptions, rateContract, requestZKProofVerificationMutationOptions, resumeUnshieldMutationOptions, revokeDelegationContract, revokeDelegationMutationOptions, revokeMutationOptions, revokeSessionMutationOptions, savePendingUnshield, setFinalizeUnwrapOperatorContract, setOperatorContract, shieldETHMutationOptions, shieldFeeQueryOptions, shieldMutationOptions, signerAddressQueryOptions, sortByBlockNumber, supportsInterfaceContract, symbolContract, tokenMetadataQueryOptions, totalSupplyContract, totalSupplyQueryOptions, underlyingAllowanceQueryOptions, underlyingContract, unshieldAllMutationOptions, unshieldFeeQueryOptions, unshieldMutationOptions, unwrapAllMutationOptions, unwrapContract, unwrapFromBalanceContract, unwrapMutationOptions, useActivityFeed, useAllow, useApproveUnderlying, useBatchDecryptBalancesAs, useBatchTransferFee, useConfidentialApprove, useConfidentialBalance, useConfidentialBalances, useConfidentialIsApproved, useConfidentialIsApprovedSuspense, useConfidentialTokenAddress, useConfidentialTransfer, useConfidentialTransferFrom, useCreateDelegatedUserDecryptEIP712, useCreateEIP712, useDecryptBalanceAs, useDelegateDecryption, useDelegatedUserDecrypt, useDelegationStatus, useEncrypt, useFeeRecipient, useFinalizeUnwrap, useGenerateKeypair, useIsAllowed, useIsConfidential, useIsConfidentialSuspense, useIsConfidentialTokenValid, useIsWrapper, useIsWrapperSuspense, useListPairs, useMetadata, useMetadataSuspense, usePublicDecrypt, usePublicKey, usePublicParams, useReadonlyToken, useRequestZKProofVerification, useResumeUnshield, useRevoke, useRevokeDelegation, useRevokeSession, useShield, useShieldETH, useShieldFee, useToken, useTokenAddress, useTokenPair, useTokenPairsLength, useTokenPairsRegistry, useTokenPairsSlice, useTotalSupply, useTotalSupplySuspense, useUnderlyingAllowance, useUnderlyingAllowanceSuspense, useUnshield, useUnshieldAll, useUnshieldFee, useUnwrap, useUnwrapAll, useUserDecrypt, useUserDecryptedValue, useUserDecryptedValues, useWrapperDiscovery, useWrapperDiscoverySuspense, useWrappersRegistryAddress, useZamaSDK, userDecryptMutationOptions, wrapContract, wrapETHContract, wrapperDiscoveryQueryOptions, wrapperExistsContract, zamaQueryKeys };
+export { ACL_TOPICS, type AclEvent, AclPausedError, type ActivityAmount, type ActivityDirection, type ActivityItem, type ActivityLogMetadata, type ActivityType, type Address, ApprovalFailedError, type ApproveSubmittedEvent, type ApproveUnderlyingParams, type ApproveUnderlyingSubmittedEvent, BalanceCheckUnavailableError, type BaseEvent, type BatchDecryptAsOptions, type BatchDecryptBalancesAsParams, type BatchDecryptOptions, type BatchTransferData, ChromeSessionStorage, type ClearValueType, type ConfidentialApproveParams, type ConfidentialBalancesData, type ConfidentialTransferEvent, type ConfidentialTransferFromParams, type ConfidentialTransferParams, ConfigurationError, type ContractAbi, type CreateDelegatedUserDecryptEIP712Params, type CreateEIP712Params, type CredentialsAllowedEvent, type CredentialsCachedEvent, type CredentialsCreatedEvent, type CredentialsCreatingEvent, type CredentialsExpiredEvent, type CredentialsLoadingEvent, CredentialsManager, type CredentialsManagerConfig, type CredentialsRevokedEvent, type DecryptBalanceAsParams, type UserDecryptCallbacks as DecryptCallbacks, type DecryptEndEvent, type DecryptErrorEvent, type DecryptHandle, type UserDecryptMutationParams as DecryptParams, type DecryptStartEvent, DecryptionFailedError, DefaultRegistryAddresses, type DelegateDecryptionParams, DelegatedCredentialsManager, type DelegatedCredentialsManagerConfig, type DelegatedForUserDecryptionEvent, type DelegatedStoredCredentials, type DelegatedUserDecryptParams, DelegationContractIsSelfError, DelegationCooldownError, DelegationDelegateEqualsContractError, DelegationExpirationTooSoonError, DelegationExpiredError, DelegationExpiryUnchangedError, DelegationNotFoundError, DelegationNotPropagatedError, DelegationSelfNotAllowedError, type DelegationStatusData, type DelegationStatusQueryConfig, type EIP712TypedData, ERC20ReadFailedError, ERC7984_INTERFACE_ID, ERC7984_WRAPPER_INTERFACE_ID, type EncryptEndEvent, type EncryptErrorEvent, type EncryptInput, type EncryptParams, type EncryptResult, type EncryptStartEvent, EncryptionFailedError, type FheTypeName, type FhevmInstanceConfig, type FinalizeUnwrapParams, type FinalizeUnwrapSubmittedEvent, type GenericSigner, type GenericStorage, type Handle, HardhatConfig, type Hex, IndexedDBStorage, type InputProofBytesType, InsufficientConfidentialBalanceError, InsufficientERC20BalanceError, InvalidKeypairError, KeypairExpiredError, type KeypairType, type KmsDelegatedUserDecryptEIP712Type, type ListPairsOptions, type ListPairsQueryConfig, MainnetConfig, MemoryStorage, type NetworkType, NoCiphertextError, type OnChainEvent, type OptimisticBalanceSnapshot, type OptimisticMutateContext, type PaginatedResult, type PublicDecryptResult, type PublicKeyData, type PublicParamsData, type RawLog, type ReadContractArgs, type ReadContractConfig, type ReadContractReturnType, type ReadFunctionName, ReadonlyToken, type ReadonlyTokenConfig, RelayerRequestFailedError, type RelayerSDK, type RelayerSDKStatus, RelayerWeb, type RelayerWebConfig, type RelayerWebSecurityConfig, type ResumeUnshieldParams, type RevokeDelegationParams, type RevokedDelegationForUserDecryptionEvent, SepoliaConfig, type SessionExpiredEvent, type ShieldCallbacks, type ShieldETHParams, type ShieldParams, type ShieldSubmittedEvent, SigningFailedError, SigningRejectedError, type StoredCredentials, TOKEN_TOPICS, Token, type TokenConfig, type TokenMetadata, type TokenWrapperPair, type TokenWrapperPairWithMetadata, Topics, type TransactionErrorEvent, type TransactionReceipt, type TransactionResult, TransactionRevertedError, type TransferCallbacks, type TransferFromSubmittedEvent, type TransferSubmittedEvent, type UnshieldAllParams, type UnshieldCallbacks, type UnshieldParams, type UnshieldPhase1SubmittedEvent, type UnshieldPhase2StartedEvent, type UnshieldPhase2SubmittedEvent, type UnwrapParams, type UnwrapRequestedEvent, type UnwrapSubmittedEvent, type UnwrappedFinalizedEvent, type UnwrappedStartedEvent, type UseActivityFeedConfig, type UseConfidentialBalanceConfig, type UseConfidentialBalanceOptions, type UseConfidentialBalancesConfig, type UseConfidentialBalancesOptions, type UseConfidentialIsApprovedConfig, type UseConfidentialIsApprovedSuspenseConfig, type UseConfidentialTransferConfig, type UseDelegationStatusConfig, type UseFeeConfig, type UseShieldConfig, type UseShieldETHConfig, type UseUnderlyingAllowanceConfig, type UseUserDecryptConfig, type UseWrapperDiscoveryConfig, type UseWrapperDiscoverySuspenseConfig, type UseZamaConfig, type UserDecryptCallbacks$1 as UserDecryptCallbacks, type UserDecryptMutationParams$1 as UserDecryptMutationParams, type UserDecryptParams, type WrappedEvent, WrappersRegistry, type WrappersRegistryConfig, type WriteContractArgs, type WriteContractConfig, type WriteFunctionName, ZERO_HANDLE, type ZKProofLike, ZamaError, ZamaErrorCode, ZamaProvider, type ZamaProviderProps, ZamaSDK, type ZamaSDKConfig, type ZamaSDKEvent, type ZamaSDKEventInput, type ZamaSDKEventListener, type ZamaSDKEventType, ZamaSDKEvents, activityFeedQueryOptions, allowMutationOptions, allowanceContract, applyDecryptedValues, approveContract, approveUnderlyingMutationOptions, balanceOfContract, batchDecryptBalancesAsMutationOptions, batchTransferFeeQueryOptions, chromeSessionStorage, clearPendingUnshield, confidentialApproveMutationOptions, confidentialBalanceOfContract, confidentialBalanceQueryOptions, confidentialBalancesQueryOptions, confidentialBatchTransferContract, confidentialHandleQueryOptions, confidentialHandlesQueryOptions, confidentialIsApprovedQueryOptions, confidentialTotalSupplyContract, confidentialTransferContract, confidentialTransferFromContract, confidentialTransferFromMutationOptions, confidentialTransferMutationOptions, createDelegatedUserDecryptEIP712MutationOptions, createEIP712MutationOptions, decimalsContract, decodeAclEvent, decodeAclEvents, decodeConfidentialTransfer, decodeDelegatedForUserDecryption, decodeOnChainEvent, decodeOnChainEvents, decodeRevokedDelegationForUserDecryption, decodeUnwrapRequested, decodeUnwrappedFinalized, decodeUnwrappedStarted, decodeWrapped, decryptBalanceAsMutationOptions, delegateDecryptionMutationOptions, delegateForUserDecryptionContract, delegatedUserDecryptMutationOptions, delegationStatusQueryOptions, deploymentCoordinatorContract, encryptMutationOptions, extractEncryptedHandles, feeRecipientQueryOptions, filterQueryOptions, finalizeUnwrapContract, finalizeUnwrapMutationOptions, findDelegatedForUserDecryption, findRevokedDelegationForUserDecryption, findUnwrapRequested, findWrapped, generateKeypairMutationOptions, getBatchTransferFeeContract, getDelegationExpiryContract, getFeeRecipientContract, getUnwrapFeeContract, getWrapFeeContract, getWrapperContract, hashFn, indexedDBStorage, isAllowedQueryOptions, isConfidentialQueryOptions, isConfidentialTokenContract, isConfidentialWrapperContract, isFinalizeUnwrapOperatorContract, isHandleDelegatedContract, isOperatorContract, isWrapperQueryOptions, listPairsQueryOptions, loadPendingUnshield, matchZamaError, memoryStorage, nameContract, parseActivityFeed, publicDecryptMutationOptions, publicKeyQueryOptions, publicParamsQueryOptions, rateContract, requestZKProofVerificationMutationOptions, resumeUnshieldMutationOptions, revokeDelegationContract, revokeDelegationMutationOptions, revokeMutationOptions, revokeSessionMutationOptions, savePendingUnshield, setFinalizeUnwrapOperatorContract, setOperatorContract, shieldETHMutationOptions, shieldFeeQueryOptions, shieldMutationOptions, signerAddressQueryOptions, sortByBlockNumber, supportsInterfaceContract, symbolContract, tokenMetadataQueryOptions, totalSupplyContract, totalSupplyQueryOptions, underlyingAllowanceQueryOptions, underlyingContract, unshieldAllMutationOptions, unshieldFeeQueryOptions, unshieldMutationOptions, unwrapAllMutationOptions, unwrapContract, unwrapFromBalanceContract, unwrapMutationOptions, useActivityFeed, useAllow, useApproveUnderlying, useBatchDecryptBalancesAs, useBatchTransferFee, useConfidentialApprove, useConfidentialBalance, useConfidentialBalances, useConfidentialIsApproved, useConfidentialIsApprovedSuspense, useConfidentialTokenAddress, useConfidentialTransfer, useConfidentialTransferFrom, useCreateDelegatedUserDecryptEIP712, useCreateEIP712, useDecryptBalanceAs, useDelegateDecryption, useDelegatedUserDecrypt, useDelegationStatus, useEncrypt, useFeeRecipient, useFinalizeUnwrap, useGenerateKeypair, useIsAllowed, useIsConfidential, useIsConfidentialSuspense, useIsConfidentialTokenValid, useIsWrapper, useIsWrapperSuspense, useListPairs, useMetadata, useMetadataSuspense, usePublicDecrypt, usePublicKey, usePublicParams, useReadonlyToken, useRequestZKProofVerification, useResumeUnshield, useRevoke, useRevokeDelegation, useRevokeSession, useShield, useShieldETH, useShieldFee, useToken, useTokenAddress, useTokenPair, useTokenPairsLength, useTokenPairsRegistry, useTokenPairsSlice, useTotalSupply, useTotalSupplySuspense, useUnderlyingAllowance, useUnderlyingAllowanceSuspense, useUnshield, useUnshieldAll, useUnshieldFee, useUnwrap, useUnwrapAll, useUserDecrypt, useUserDecryptedValue, useUserDecryptedValues, useWrapperDiscovery, useWrapperDiscoverySuspense, useWrappersRegistryAddress, useZamaSDK, userDecryptMutationOptions, wrapContract, wrapETHContract, wrapperDiscoveryQueryOptions, wrapperExistsContract, zamaQueryKeys };
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -1,2 +1,2 @@
-"use client";import{ACL_TOPICS as e,AclPausedError as t,ApprovalFailedError as n,ChromeSessionStorage as r,ConfigurationError as i,CredentialsManager as a,DecryptionFailedError as o,DefaultRegistryAddresses as s,DelegatedCredentialsManager as c,DelegationContractIsSelfError as l,DelegationCooldownError as u,DelegationDelegateEqualsContractError as d,DelegationExpirationTooSoonError as f,DelegationExpiredError as p,DelegationExpiryUnchangedError as m,DelegationNotFoundError as ee,DelegationNotPropagatedError as te,DelegationSelfNotAllowedError as ne,ERC7984_INTERFACE_ID as re,ERC7984_WRAPPER_INTERFACE_ID as ie,EncryptionFailedError as ae,HardhatConfig as oe,IndexedDBStorage as se,InvalidKeypairError as ce,KeypairExpiredError as le,MainnetConfig as ue,MemoryStorage as de,NoCiphertextError as fe,ReadonlyToken as pe,ReadonlyToken as me,RelayerRequestFailedError as he,RelayerWeb as ge,SepoliaConfig as _e,SigningFailedError as ve,SigningRejectedError as ye,TOKEN_TOPICS as be,Token as xe,Topics as Se,TransactionRevertedError as Ce,WrappersRegistry as we,ZERO_HANDLE as Te,ZamaError as Ee,ZamaErrorCode as De,ZamaSDK as Oe,ZamaSDK as ke,ZamaSDKEvents as Ae,allowanceContract as je,applyDecryptedValues as h,approveContract as g,balanceOfContract as _,chromeSessionStorage as v,clearPendingUnshield as y,confidentialBalanceOfContract as b,confidentialBatchTransferContract as x,confidentialTotalSupplyContract as S,confidentialTransferContract as Me,confidentialTransferFromContract as Ne,decimalsContract as Pe,decodeAclEvent as Fe,decodeAclEvents as Ie,decodeConfidentialTransfer as Le,decodeDelegatedForUserDecryption as Re,decodeOnChainEvent as ze,decodeOnChainEvents as Be,decodeRevokedDelegationForUserDecryption as Ve,decodeUnwrapRequested as He,decodeUnwrappedFinalized as Ue,decodeUnwrappedStarted as We,decodeWrapped as Ge,delegateForUserDecryptionContract as Ke,deploymentCoordinatorContract as qe,extractEncryptedHandles as Je,finalizeUnwrapContract as Ye,findDelegatedForUserDecryption as Xe,findRevokedDelegationForUserDecryption as Ze,findUnwrapRequested as Qe,findWrapped as $e,getBatchTransferFeeContract as et,getDelegationExpiryContract as tt,getFeeRecipientContract as nt,getUnwrapFeeContract as rt,getWrapFeeContract as it,getWrapperContract as at,indexedDBStorage as ot,isConfidentialTokenContract as st,isConfidentialWrapperContract as ct,isFinalizeUnwrapOperatorContract as lt,isHandleDelegatedContract as ut,isOperatorContract as dt,loadPendingUnshield as ft,matchZamaError as pt,memoryStorage as mt,nameContract as ht,parseActivityFeed as gt,rateContract as _t,revokeDelegationContract as vt,savePendingUnshield as yt,setFinalizeUnwrapOperatorContract as bt,setOperatorContract as xt,sortByBlockNumber as St,supportsInterfaceContract as Ct,symbolContract as wt,totalSupplyContract as Tt,underlyingContract as Et,unwrapContract as Dt,unwrapFromBalanceContract as Ot,wrapContract as kt,wrapETHContract as At,wrapperExistsContract as jt}from"@zama-fhe/sdk";import{activityFeedQueryOptions as Mt,activityFeedQueryOptions as Nt,allowMutationOptions as Pt,allowMutationOptions as Ft,approveUnderlyingMutationOptions as It,approveUnderlyingMutationOptions as Lt,batchDecryptBalancesAsMutationOptions as Rt,batchTransferFeeQueryOptions as zt,batchTransferFeeQueryOptions as Bt,confidentialApproveMutationOptions as Vt,confidentialApproveMutationOptions as Ht,confidentialBalanceQueryOptions as Ut,confidentialBalanceQueryOptions as Wt,confidentialBalancesQueryOptions as Gt,confidentialBalancesQueryOptions as Kt,confidentialHandleQueryOptions as qt,confidentialHandleQueryOptions as Jt,confidentialHandlesQueryOptions as Yt,confidentialHandlesQueryOptions as Xt,confidentialIsApprovedQueryOptions as Zt,confidentialIsApprovedQueryOptions as C,confidentialTokenAddressQueryOptions as Qt,confidentialTransferFromMutationOptions as $t,confidentialTransferFromMutationOptions as en,confidentialTransferMutationOptions as tn,confidentialTransferMutationOptions as nn,createDelegatedUserDecryptEIP712MutationOptions as rn,createDelegatedUserDecryptEIP712MutationOptions as an,createEIP712MutationOptions as on,createEIP712MutationOptions as sn,decryptBalanceAsMutationOptions as cn,decryptBalanceAsMutationOptions as ln,delegateDecryptionMutationOptions as un,delegateDecryptionMutationOptions as dn,delegatedUserDecryptMutationOptions as fn,delegatedUserDecryptMutationOptions as pn,delegationStatusQueryOptions as mn,delegationStatusQueryOptions as hn,deriveActivityFeedLogsKey as gn,encryptMutationOptions as _n,encryptMutationOptions as vn,feeRecipientQueryOptions as yn,feeRecipientQueryOptions as bn,filterQueryOptions as xn,finalizeUnwrapMutationOptions as Sn,finalizeUnwrapMutationOptions as Cn,generateKeypairMutationOptions as wn,generateKeypairMutationOptions as Tn,hashFn as En,hashFn as w,invalidateAfterApprove as Dn,invalidateAfterApproveUnderlying as On,invalidateAfterShield as kn,invalidateAfterTransfer as T,invalidateAfterUnshield as E,invalidateAfterUnwrap as D,invalidateWalletLifecycleQueries as O,isAllowedQueryOptions as An,isAllowedQueryOptions as jn,isConfidentialQueryOptions as Mn,isConfidentialQueryOptions as k,isConfidentialTokenValidQueryOptions as Nn,isWrapperQueryOptions as Pn,isWrapperQueryOptions as A,listPairsQueryOptions as Fn,listPairsQueryOptions as In,publicDecryptMutationOptions as Ln,publicDecryptMutationOptions as Rn,publicKeyQueryOptions as zn,publicKeyQueryOptions as Bn,publicParamsQueryOptions as Vn,publicParamsQueryOptions as Hn,requestZKProofVerificationMutationOptions as Un,requestZKProofVerificationMutationOptions as Wn,resumeUnshieldMutationOptions as Gn,resumeUnshieldMutationOptions as j,revokeDelegationMutationOptions as Kn,revokeDelegationMutationOptions as qn,revokeMutationOptions as Jn,revokeMutationOptions as Yn,revokeSessionMutationOptions as Xn,revokeSessionMutationOptions as Zn,shieldETHMutationOptions as Qn,shieldETHMutationOptions as $n,shieldFeeQueryOptions as er,shieldFeeQueryOptions as tr,shieldMutationOptions as nr,shieldMutationOptions as rr,signerAddressQueryOptions as ir,signerAddressQueryOptions as M,tokenAddressQueryOptions as ar,tokenMetadataQueryOptions as or,tokenMetadataQueryOptions as N,tokenPairQueryOptions as sr,tokenPairsLengthQueryOptions as cr,tokenPairsQueryOptions as lr,tokenPairsSliceQueryOptions as ur,totalSupplyQueryOptions as dr,totalSupplyQueryOptions as P,underlyingAllowanceQueryOptions as fr,underlyingAllowanceQueryOptions as F,unshieldAllMutationOptions as pr,unshieldAllMutationOptions as mr,unshieldFeeQueryOptions as hr,unshieldFeeQueryOptions as gr,unshieldMutationOptions as _r,unshieldMutationOptions as vr,unwrapAllMutationOptions as yr,unwrapAllMutationOptions as br,unwrapMutationOptions as xr,unwrapMutationOptions as Sr,userDecryptMutationOptions as Cr,userDecryptMutationOptions as wr,wrapperDiscoveryQueryOptions as Tr,wrapperDiscoveryQueryOptions as I,zamaQueryKeys as Er,zamaQueryKeys as L}from"@zama-fhe/sdk/query";import{skipToken as Dr,useMutation as R,useQueries as Or,useQuery as kr,useQueryClient as z,useSuspenseQuery as Ar}from"@tanstack/react-query";import{createContext as jr,useContext as Mr,useEffect as B,useMemo as V,useRef as H}from"react";import{jsx as Nr}from"react/jsx-runtime";const U=jr(null);function Pr({children:e,relayer:t,signer:n,storage:r,sessionStorage:i,keypairTTL:a,sessionTTL:o,registryAddresses:s,registryTTL:c,onEvent:l}){let u=z(),d=H(l),f=H(s);B(()=>{d.current=l,f.current=s});let p=V(()=>n?.subscribe?{onDisconnect:()=>O(u),onAccountChange:()=>O(u),onChainChange:()=>O(u)}:void 0,[u,n]),m=V(()=>new ke({relayer:t,signer:n,storage:r,sessionStorage:i,keypairTTL:a,sessionTTL:o,registryAddresses:f.current,registryTTL:c,onEvent:d.current,signerLifecycleCallbacks:p}),[t,n,r,i,a,o,c,p]);return B(()=>()=>m.dispose(),[m]),Nr(U.Provider,{value:m,children:e})}function W(){let e=Mr(U);if(!e)throw Error(`useZamaSDK must be used within a <ZamaProvider>. Wrap your component tree in <ZamaProvider relayer={…} signer={…} storage={…}>.`);return e}function Fr(){return R(vn(W()))}function Ir(e){return R(wr(W(),e))}function Lr(){return R(Rn(W()))}function Rr(){return R(Tn(W()))}function zr(){return R(sn(W()))}function Br(){return R(an(W()))}function Vr(){return R(pn(W()))}function Hr(){return R(Wn(W()))}function G(e){return kr({...e,queryKeyHashFn:w})}function K(e){return Ar({...e,queryKeyHashFn:w})}function Ur({queries:e,...t}){return Or({...t,queries:e.map(e=>({...e,queryKeyHashFn:w}))})}function Wr(){return G({...Bn(W())})}function Gr(e){return G({...Hn(W(),e)})}function Kr(e){return G({queryKey:L.decryption.handle(e??`0x`),queryFn:()=>void 0,enabled:!1})}function qr(e){let t=Ur({queries:e.map(e=>({queryKey:L.decryption.handle(e),queryFn:()=>void 0,enabled:!1}))}),n={};for(let r=0;r<e.length;r++)n[e[r]]=t[r].data;return{data:n,results:t}}function Jr(e){return R({...Ft(W()),...e,onSuccess:(t,n,r,i)=>{e?.onSuccess?.(t,n,r,i),i.client.invalidateQueries({queryKey:L.isAllowed.all})}})}function Yr(){let e=W(),t=G({...M(e.signer)}).data;return G(t?jn(e,{account:t}):{queryKey:L.isAllowed.all,queryFn:Dr,enabled:!1})}function Xr(e){return R({...Yn(W()),...e,onSuccess:(t,n,r,i)=>{e?.onSuccess?.(t,n,r,i),i.client.invalidateQueries({queryKey:L.isAllowed.all})}})}function Zr(e){return R({...Zn(W()),...e,onSuccess:(t,n,r,i)=>{e?.onSuccess?.(t,n,r,i),i.client.invalidateQueries({queryKey:L.isAllowed.all})}})}function q(e){let t=W();return V(()=>t.createToken(e.tokenAddress,e.wrapperAddress),[t,e.tokenAddress,e.wrapperAddress])}function J(e){let t=W();return V(()=>t.createReadonlyToken(e),[t,e])}function Qr(e,t){let{tokenAddress:n,handleRefetchInterval:r}=e,{enabled:i=!0}=t??{},a=J(n),o=G({...M(a.signer)}).data,s=Jt(a.signer,n,{owner:o,pollingInterval:r}),c=G({...s,enabled:s.enabled&&i}),l=c.data,u=Wt(a,{handle:l,owner:o});return{...G({...u,...t,enabled:u.enabled&&i}),handleQuery:c}}function $r(e,t){let{tokenAddresses:n,handleRefetchInterval:r,maxConcurrency:i}=e,{enabled:a=!0}=t??{},o=W(),s=G({...M(o.signer)}).data,c=V(()=>n.map(e=>o.createReadonlyToken(e)),[o,n]),l=Xt(o.signer,n,{owner:s,pollingInterval:r}),u=G({...l,enabled:l.enabled&&a}),d=u.data,f=Array.isArray(d)&&d.length===n.length,p=Kt(c,{owner:s,handles:d,maxConcurrency:i,resultAddresses:n}),m=p.enabled??!0;return{...G({...p,...t,enabled:m&&f&&a}),handlesQuery:u}}function Y(e,t){let n=e?t:void 0;return{wrappedContext:n,callerContext:e?n?.callerContext:t}}async function X({queryClient:e,tokenAddress:t,amount:n,mode:r}){let i=L.confidentialBalance.token(t);await e.cancelQueries({queryKey:i});let a=e.getQueriesData({queryKey:i});for(let[t,i]of a)i!==void 0&&e.setQueryData(t,r===`add`?i+n:i-n);return a}function Z(e,t){for(let[n,r]of t)e.setQueryData(n,r)}function Q({optimistic:e,tokenAddress:t,queryClient:n,options:r}){return{onMutate:e?async(e,i)=>({snapshot:await X({queryClient:n,tokenAddress:t,amount:e.amount,mode:`add`}),callerContext:await r?.onMutate?.(e,i)}):r?.onMutate,onError:(t,i,a,o)=>{let{wrappedContext:s,callerContext:c}=Y(e,a);try{s&&Z(n,s.snapshot)}finally{r?.onError?.(t,i,c,o)}},onSuccess:(n,i,a,o)=>{let{callerContext:s}=Y(e,a);r?.onSuccess?.(n,i,s,o),kn(o.client,t)},onSettled:(t,n,i,a,o)=>{let{callerContext:s}=Y(e,a);r?.onSettled?.(t,n,i,s,o)}}}function ei(e,t){let n=q(e),r=z();return R({...nn(n),...t,onMutate:e.optimistic?async(n,i)=>({snapshot:await X({queryClient:r,tokenAddress:e.tokenAddress,amount:n.amount,mode:`subtract`}),callerContext:await t?.onMutate?.(n,i)}):t?.onMutate,onError:(n,i,a,o)=>{let{wrappedContext:s,callerContext:c}=Y(e.optimistic,a);try{s&&Z(r,s.snapshot)}finally{t?.onError?.(n,i,c,o)}},onSuccess:(n,r,i,a)=>{let{callerContext:o}=Y(e.optimistic,i);t?.onSuccess?.(n,r,o,a),T(a.client,e.tokenAddress)},onSettled:(n,r,i,a,o)=>{let{callerContext:s}=Y(e.optimistic,a);t?.onSettled?.(n,r,i,s,o)}})}function ti(e,t){return R({...en(q(e)),...t,onSuccess:(n,r,i,a)=>{t?.onSuccess?.(n,r,i,a),T(a.client,e.tokenAddress)}})}function ni(e,t){return R({...Ht(q(e)),...t,onSuccess:(n,r,i,a)=>{t?.onSuccess?.(n,r,i,a),Dn(a.client,e.tokenAddress)}})}function ri(e,t){let{tokenAddress:n,spender:r,holder:i}=e,a=W(),o=G({...M(a.signer),enabled:n!==void 0&&r!==void 0&&i===void 0}),s=i??o.data,c=C(a.signer,n,{holder:s,spender:r});return G({...c,...t,enabled:(c.enabled??!0)&&(t?.enabled??!0)})}function ii(e){let{spender:t,holder:n,...r}=e,i=q(r),a=K({...M(i.signer)}),o=n??a.data;return K({...C(i.signer,i.address,{holder:o,spender:t})})}function ai(e,t){let n=q(e),r=z();return R({...rr(n),...t,...Q({optimistic:e.optimistic,tokenAddress:e.tokenAddress,queryClient:r,options:t})})}function oi(e,t){let n=q(e),r=z();return R({...$n(n),...t,...Q({optimistic:e.optimistic,tokenAddress:e.tokenAddress,queryClient:r,options:t})})}function si(e,t){return R({...Sr(q(e)),...t,onSuccess:(n,r,i,a)=>{t?.onSuccess?.(n,r,i,a),D(a.client,e.tokenAddress)}})}function ci(e,t){return R({...br(q(e)),...t,onSuccess:(n,r,i,a)=>{t?.onSuccess?.(n,r,i,a),D(a.client,e.tokenAddress)}})}function li(e,t){return R({...Cn(q(e)),...t,onSuccess:(n,r,i,a)=>{t?.onSuccess?.(n,r,i,a),E(a.client,e.tokenAddress)}})}function ui(e,t){return R({...vr(q(e)),...t,onSuccess:(n,r,i,a)=>{t?.onSuccess?.(n,r,i,a),E(a.client,e.tokenAddress)}})}function di(e,t){return R({...mr(q(e)),...t,onSuccess:(n,r,i,a)=>{t?.onSuccess?.(n,r,i,a),E(a.client,e.tokenAddress)}})}function fi(e,t){return R({...j(q(e)),...t,onSuccess:(n,r,i,a)=>{t?.onSuccess?.(n,r,i,a),E(a.client,e.tokenAddress)}})}function pi(e,t){let{tokenAddress:n,wrapperAddress:r}=e,i=J(n),a=G({...M(i.signer)}).data,o=F(i.signer,n,{owner:a,wrapperAddress:r});return G({...o,...t,enabled:(o.enabled??!0)&&(t?.enabled??!0)})}function mi(e){let{tokenAddress:t,wrapperAddress:n}=e,r=J(t),i=K({...M(r.signer)}).data;return K({...F(r.signer,t,{owner:i,wrapperAddress:n})})}function $(){let e=W(),{data:t}=G({queryKey:L.wrappersRegistry.chainId(),queryFn:()=>e.signer.getChainId(),staleTime:3e4});return t===void 0?void 0:e.registry.getAddress(t)}function hi(e,t){let{tokenAddress:n,erc20Address:r}=e,i=W(),a=$(),o=I(i.registry,{tokenAddress:n,erc20Address:r,registryAddress:a});return G({...o,...t,enabled:(o.enabled??!0)&&(t?.enabled??!0)})}function gi(e){let{tokenAddress:t,erc20Address:n}=e,r=W(),i=$();return K({...I(r.registry,{tokenAddress:t,erc20Address:n,registryAddress:i})})}function _i(e,t){return G({...N(J(e).signer,e),...t})}function vi(e){return K({...N(J(e).signer,e)})}function yi(e){let{tokenAddress:t,userAddress:n,logs:r,decrypt:i}=e;return G({...Nt(J(t),{userAddress:n,logs:r,decrypt:i??!0,logsKey:gn(r)})})}function bi(e,t){return R({...dn(q(e)),...t,onSuccess:(e,n,r,i)=>{try{t?.onSuccess?.(e,n,r,i)}finally{i.client.invalidateQueries({queryKey:L.delegationStatus.all})}}})}function xi(e,t){return R({...qn(q(e)),...t,onSuccess:(e,n,r,i)=>{try{t?.onSuccess?.(e,n,r,i)}finally{i.client.invalidateQueries({queryKey:L.delegationStatus.all})}}})}function Si(e,t){let n=hn(W(),{tokenAddress:e.tokenAddress,delegatorAddress:e.delegatorAddress,delegateAddress:e.delegateAddress});return G({...n,...t,enabled:(n.enabled??!0)&&(t?.enabled??!0)})}function Ci(e,t){return R({...ln(J(e)),...t})}function wi(e,t){return R({mutationKey:[`zama.batchDecryptBalancesAs`,...e.map(e=>e.address)],mutationFn:async t=>me.batchDecryptBalancesAs(e,t),...t})}function Ti(e,t){return R({...Lt(q(e)),...t,onSuccess:(n,r,i,a)=>{t?.onSuccess?.(n,r,i,a),On(a.client,e.tokenAddress)}})}function Ei(e,t){return G({...k(J(e).signer,e),...t})}function Di(e){return K({...k(J(e).signer,e)})}function Oi(e,t){return G({...A(J(e).signer,e),...t})}function ki(e){return K({...A(J(e).signer,e)})}function Ai(e,t){return G({...P(J(e).signer,e),...t})}function ji(e){return K({...P(J(e).signer,e)})}function Mi(e,t){let n=tr(W().signer,e);return G({...n,...t,enabled:(n.enabled??!0)&&(t?.enabled??!0)})}function Ni(e,t){let n=gr(W().signer,e);return G({...n,...t,enabled:(n.enabled??!0)&&(t?.enabled??!0)})}function Pi(e,t){let n=Bt(W().signer,e);return G({...n,...t,enabled:(n.enabled??!0)&&(t?.enabled??!0)})}function Fi(e,t){let n=bn(W().signer,e);return G({...n,...t,enabled:(n.enabled??!0)&&(t?.enabled??!0)})}function Ii(){let e=W(),t=$();return G(lr(e.signer,{registryAddress:t}))}function Li(){let e=W(),t=$();return G(cr(e.signer,{registryAddress:t}))}function Ri({fromIndex:e,toIndex:t}){let n=W(),r=$();return G(ur(n.signer,{registryAddress:r,fromIndex:e,toIndex:t}))}function zi({index:e}){let t=W(),n=$();return G(sr(t.signer,{registryAddress:n,index:e}))}function Bi({tokenAddress:e}){let t=W(),n=$();return G(Qt(t.signer,{registryAddress:n,tokenAddress:e}))}function Vi({confidentialTokenAddress:e}){let t=W(),n=$();return G(ar(t.signer,{registryAddress:n,confidentialTokenAddress:e}))}function Hi({confidentialTokenAddress:e}){let t=W(),n=$();return G(Nn(t.signer,{registryAddress:n,confidentialTokenAddress:e}))}function Ui({page:e=1,pageSize:t=100,metadata:n=!1}={}){let r=W(),i=$();return G(In(r.registry,{registryAddress:i,page:e,pageSize:t,metadata:n}))}export{e as ACL_TOPICS,t as AclPausedError,n as ApprovalFailedError,r as ChromeSessionStorage,i as ConfigurationError,a as CredentialsManager,o as DecryptionFailedError,s as DefaultRegistryAddresses,c as DelegatedCredentialsManager,l as DelegationContractIsSelfError,u as DelegationCooldownError,d as DelegationDelegateEqualsContractError,f as DelegationExpirationTooSoonError,p as DelegationExpiredError,m as DelegationExpiryUnchangedError,ee as DelegationNotFoundError,te as DelegationNotPropagatedError,ne as DelegationSelfNotAllowedError,re as ERC7984_INTERFACE_ID,ie as ERC7984_WRAPPER_INTERFACE_ID,ae as EncryptionFailedError,oe as HardhatConfig,se as IndexedDBStorage,ce as InvalidKeypairError,le as KeypairExpiredError,ue as MainnetConfig,de as MemoryStorage,fe as NoCiphertextError,pe as ReadonlyToken,he as RelayerRequestFailedError,ge as RelayerWeb,_e as SepoliaConfig,ve as SigningFailedError,ye as SigningRejectedError,be as TOKEN_TOPICS,xe as Token,Se as Topics,Ce as TransactionRevertedError,we as WrappersRegistry,Te as ZERO_HANDLE,Ee as ZamaError,De as ZamaErrorCode,Pr as ZamaProvider,Oe as ZamaSDK,Ae as ZamaSDKEvents,Mt as activityFeedQueryOptions,Pt as allowMutationOptions,je as allowanceContract,h as applyDecryptedValues,g as approveContract,It as approveUnderlyingMutationOptions,_ as balanceOfContract,Rt as batchDecryptBalancesAsMutationOptions,zt as batchTransferFeeQueryOptions,v as chromeSessionStorage,y as clearPendingUnshield,Vt as confidentialApproveMutationOptions,b as confidentialBalanceOfContract,Ut as confidentialBalanceQueryOptions,Gt as confidentialBalancesQueryOptions,x as confidentialBatchTransferContract,qt as confidentialHandleQueryOptions,Yt as confidentialHandlesQueryOptions,Zt as confidentialIsApprovedQueryOptions,S as confidentialTotalSupplyContract,Me as confidentialTransferContract,Ne as confidentialTransferFromContract,$t as confidentialTransferFromMutationOptions,tn as confidentialTransferMutationOptions,rn as createDelegatedUserDecryptEIP712MutationOptions,on as createEIP712MutationOptions,Pe as decimalsContract,Fe as decodeAclEvent,Ie as decodeAclEvents,Le as decodeConfidentialTransfer,Re as decodeDelegatedForUserDecryption,ze as decodeOnChainEvent,Be as decodeOnChainEvents,Ve as decodeRevokedDelegationForUserDecryption,He as decodeUnwrapRequested,Ue as decodeUnwrappedFinalized,We as decodeUnwrappedStarted,Ge as decodeWrapped,cn as decryptBalanceAsMutationOptions,un as delegateDecryptionMutationOptions,Ke as delegateForUserDecryptionContract,fn as delegatedUserDecryptMutationOptions,mn as delegationStatusQueryOptions,qe as deploymentCoordinatorContract,_n as encryptMutationOptions,Je as extractEncryptedHandles,yn as feeRecipientQueryOptions,xn as filterQueryOptions,Ye as finalizeUnwrapContract,Sn as finalizeUnwrapMutationOptions,Xe as findDelegatedForUserDecryption,Ze as findRevokedDelegationForUserDecryption,Qe as findUnwrapRequested,$e as findWrapped,wn as generateKeypairMutationOptions,et as getBatchTransferFeeContract,tt as getDelegationExpiryContract,nt as getFeeRecipientContract,rt as getUnwrapFeeContract,it as getWrapFeeContract,at as getWrapperContract,En as hashFn,ot as indexedDBStorage,An as isAllowedQueryOptions,Mn as isConfidentialQueryOptions,st as isConfidentialTokenContract,ct as isConfidentialWrapperContract,lt as isFinalizeUnwrapOperatorContract,ut as isHandleDelegatedContract,dt as isOperatorContract,Pn as isWrapperQueryOptions,Fn as listPairsQueryOptions,ft as loadPendingUnshield,pt as matchZamaError,mt as memoryStorage,ht as nameContract,gt as parseActivityFeed,Ln as publicDecryptMutationOptions,zn as publicKeyQueryOptions,Vn as publicParamsQueryOptions,_t as rateContract,Un as requestZKProofVerificationMutationOptions,Gn as resumeUnshieldMutationOptions,vt as revokeDelegationContract,Kn as revokeDelegationMutationOptions,Jn as revokeMutationOptions,Xn as revokeSessionMutationOptions,yt as savePendingUnshield,bt as setFinalizeUnwrapOperatorContract,xt as setOperatorContract,Qn as shieldETHMutationOptions,er as shieldFeeQueryOptions,nr as shieldMutationOptions,ir as signerAddressQueryOptions,St as sortByBlockNumber,Ct as supportsInterfaceContract,wt as symbolContract,or as tokenMetadataQueryOptions,Tt as totalSupplyContract,dr as totalSupplyQueryOptions,fr as underlyingAllowanceQueryOptions,Et as underlyingContract,pr as unshieldAllMutationOptions,hr as unshieldFeeQueryOptions,_r as unshieldMutationOptions,yr as unwrapAllMutationOptions,Dt as unwrapContract,Ot as unwrapFromBalanceContract,xr as unwrapMutationOptions,yi as useActivityFeed,Jr as useAllow,Ti as useApproveUnderlying,wi as useBatchDecryptBalancesAs,Pi as useBatchTransferFee,ni as useConfidentialApprove,Qr as useConfidentialBalance,$r as useConfidentialBalances,ri as useConfidentialIsApproved,ii as useConfidentialIsApprovedSuspense,Bi as useConfidentialTokenAddress,ei as useConfidentialTransfer,ti as useConfidentialTransferFrom,Br as useCreateDelegatedUserDecryptEIP712,zr as useCreateEIP712,Ci as useDecryptBalanceAs,bi as useDelegateDecryption,Vr as useDelegatedUserDecrypt,Si as useDelegationStatus,Fr as useEncrypt,Fi as useFeeRecipient,li as useFinalizeUnwrap,Rr as useGenerateKeypair,Yr as useIsAllowed,Ei as useIsConfidential,Di as useIsConfidentialSuspense,Hi as useIsConfidentialTokenValid,Oi as useIsWrapper,ki as useIsWrapperSuspense,Ui as useListPairs,_i as useMetadata,vi as useMetadataSuspense,Lr as usePublicDecrypt,Wr as usePublicKey,Gr as usePublicParams,J as useReadonlyToken,Hr as useRequestZKProofVerification,fi as useResumeUnshield,Xr as useRevoke,xi as useRevokeDelegation,Zr as useRevokeSession,ai as useShield,oi as useShieldETH,Mi as useShieldFee,q as useToken,Vi as useTokenAddress,zi as useTokenPair,Li as useTokenPairsLength,Ii as useTokenPairsRegistry,Ri as useTokenPairsSlice,Ai as useTotalSupply,ji as useTotalSupplySuspense,pi as useUnderlyingAllowance,mi as useUnderlyingAllowanceSuspense,ui as useUnshield,di as useUnshieldAll,Ni as useUnshieldFee,si as useUnwrap,ci as useUnwrapAll,Ir as useUserDecrypt,Kr as useUserDecryptedValue,qr as useUserDecryptedValues,hi as useWrapperDiscovery,gi as useWrapperDiscoverySuspense,$ as useWrappersRegistryAddress,W as useZamaSDK,Cr as userDecryptMutationOptions,kt as wrapContract,At as wrapETHContract,Tr as wrapperDiscoveryQueryOptions,jt as wrapperExistsContract,Er as zamaQueryKeys};
+"use client";import{ACL_TOPICS as e,AclPausedError as t,ApprovalFailedError as n,BalanceCheckUnavailableError as r,ChromeSessionStorage as i,ConfigurationError as a,CredentialsManager as o,DecryptionFailedError as s,DefaultRegistryAddresses as c,DelegatedCredentialsManager as l,DelegationContractIsSelfError as u,DelegationCooldownError as d,DelegationDelegateEqualsContractError as f,DelegationExpirationTooSoonError as p,DelegationExpiredError as m,DelegationExpiryUnchangedError as ee,DelegationNotFoundError as te,DelegationNotPropagatedError as ne,DelegationSelfNotAllowedError as re,ERC20ReadFailedError as ie,ERC7984_INTERFACE_ID as ae,ERC7984_WRAPPER_INTERFACE_ID as oe,EncryptionFailedError as se,HardhatConfig as ce,IndexedDBStorage as le,InsufficientConfidentialBalanceError as ue,InsufficientERC20BalanceError as de,InvalidKeypairError as fe,KeypairExpiredError as pe,MainnetConfig as me,MemoryStorage as he,NoCiphertextError as ge,ReadonlyToken as _e,ReadonlyToken as ve,RelayerRequestFailedError as ye,RelayerWeb as be,SepoliaConfig as xe,SigningFailedError as Se,SigningRejectedError as Ce,TOKEN_TOPICS as we,Token as Te,Topics as Ee,TransactionRevertedError as De,WrappersRegistry as Oe,ZERO_HANDLE as ke,ZamaError as Ae,ZamaErrorCode as h,ZamaSDK as g,ZamaSDK as _,ZamaSDKEvents as v,allowanceContract as y,applyDecryptedValues as b,approveContract as x,balanceOfContract as S,chromeSessionStorage as C,clearPendingUnshield as je,confidentialBalanceOfContract as Me,confidentialBatchTransferContract as Ne,confidentialTotalSupplyContract as Pe,confidentialTransferContract as Fe,confidentialTransferFromContract as Ie,decimalsContract as Le,decodeAclEvent as Re,decodeAclEvents as ze,decodeConfidentialTransfer as Be,decodeDelegatedForUserDecryption as Ve,decodeOnChainEvent as He,decodeOnChainEvents as Ue,decodeRevokedDelegationForUserDecryption as We,decodeUnwrapRequested as Ge,decodeUnwrappedFinalized as Ke,decodeUnwrappedStarted as qe,decodeWrapped as Je,delegateForUserDecryptionContract as Ye,deploymentCoordinatorContract as Xe,extractEncryptedHandles as Ze,finalizeUnwrapContract as Qe,findDelegatedForUserDecryption as $e,findRevokedDelegationForUserDecryption as et,findUnwrapRequested as tt,findWrapped as nt,getBatchTransferFeeContract as rt,getDelegationExpiryContract as it,getFeeRecipientContract as at,getUnwrapFeeContract as ot,getWrapFeeContract as st,getWrapperContract as ct,indexedDBStorage as lt,isConfidentialTokenContract as ut,isConfidentialWrapperContract as dt,isFinalizeUnwrapOperatorContract as ft,isHandleDelegatedContract as pt,isOperatorContract as mt,loadPendingUnshield as ht,matchZamaError as gt,memoryStorage as _t,nameContract as vt,parseActivityFeed as yt,rateContract as bt,revokeDelegationContract as xt,savePendingUnshield as St,setFinalizeUnwrapOperatorContract as Ct,setOperatorContract as wt,sortByBlockNumber as Tt,supportsInterfaceContract as Et,symbolContract as Dt,totalSupplyContract as Ot,underlyingContract as kt,unwrapContract as At,unwrapFromBalanceContract as jt,wrapContract as Mt,wrapETHContract as Nt,wrapperExistsContract as Pt}from"@zama-fhe/sdk";import{activityFeedQueryOptions as Ft,activityFeedQueryOptions as It,allowMutationOptions as Lt,allowMutationOptions as Rt,approveUnderlyingMutationOptions as zt,approveUnderlyingMutationOptions as Bt,batchDecryptBalancesAsMutationOptions as Vt,batchTransferFeeQueryOptions as Ht,batchTransferFeeQueryOptions as Ut,confidentialApproveMutationOptions as Wt,confidentialApproveMutationOptions as Gt,confidentialBalanceQueryOptions as Kt,confidentialBalanceQueryOptions as qt,confidentialBalancesQueryOptions as Jt,confidentialBalancesQueryOptions as Yt,confidentialHandleQueryOptions as Xt,confidentialHandleQueryOptions as Zt,confidentialHandlesQueryOptions as Qt,confidentialHandlesQueryOptions as $t,confidentialIsApprovedQueryOptions as en,confidentialIsApprovedQueryOptions as w,confidentialTokenAddressQueryOptions as tn,confidentialTransferFromMutationOptions as nn,confidentialTransferFromMutationOptions as rn,confidentialTransferMutationOptions as an,confidentialTransferMutationOptions as on,createDelegatedUserDecryptEIP712MutationOptions as sn,createDelegatedUserDecryptEIP712MutationOptions as cn,createEIP712MutationOptions as ln,createEIP712MutationOptions as un,decryptBalanceAsMutationOptions as dn,decryptBalanceAsMutationOptions as fn,delegateDecryptionMutationOptions as pn,delegateDecryptionMutationOptions as mn,delegatedUserDecryptMutationOptions as hn,delegatedUserDecryptMutationOptions as gn,delegationStatusQueryOptions as _n,delegationStatusQueryOptions as vn,deriveActivityFeedLogsKey as yn,encryptMutationOptions as bn,encryptMutationOptions as xn,feeRecipientQueryOptions as Sn,feeRecipientQueryOptions as Cn,filterQueryOptions as wn,finalizeUnwrapMutationOptions as Tn,finalizeUnwrapMutationOptions as En,generateKeypairMutationOptions as Dn,generateKeypairMutationOptions as On,hashFn as kn,hashFn as T,invalidateAfterApprove as An,invalidateAfterApproveUnderlying as jn,invalidateAfterShield as Mn,invalidateAfterTransfer as E,invalidateAfterUnshield as D,invalidateAfterUnwrap as O,invalidateWalletLifecycleQueries as k,isAllowedQueryOptions as Nn,isAllowedQueryOptions as Pn,isConfidentialQueryOptions as A,isConfidentialQueryOptions as j,isConfidentialTokenValidQueryOptions as Fn,isWrapperQueryOptions as In,isWrapperQueryOptions as M,listPairsQueryOptions as Ln,listPairsQueryOptions as Rn,publicDecryptMutationOptions as zn,publicDecryptMutationOptions as Bn,publicKeyQueryOptions as Vn,publicKeyQueryOptions as Hn,publicParamsQueryOptions as Un,publicParamsQueryOptions as Wn,requestZKProofVerificationMutationOptions as Gn,requestZKProofVerificationMutationOptions as Kn,resumeUnshieldMutationOptions as qn,resumeUnshieldMutationOptions as Jn,revokeDelegationMutationOptions as Yn,revokeDelegationMutationOptions as Xn,revokeMutationOptions as Zn,revokeMutationOptions as Qn,revokeSessionMutationOptions as $n,revokeSessionMutationOptions as er,shieldETHMutationOptions as tr,shieldETHMutationOptions as nr,shieldFeeQueryOptions as rr,shieldFeeQueryOptions as ir,shieldMutationOptions as ar,shieldMutationOptions as or,signerAddressQueryOptions as sr,signerAddressQueryOptions as N,tokenAddressQueryOptions as cr,tokenMetadataQueryOptions as lr,tokenMetadataQueryOptions as P,tokenPairQueryOptions as ur,tokenPairsLengthQueryOptions as dr,tokenPairsQueryOptions as fr,tokenPairsSliceQueryOptions as pr,totalSupplyQueryOptions as mr,totalSupplyQueryOptions as F,underlyingAllowanceQueryOptions as hr,underlyingAllowanceQueryOptions as I,unshieldAllMutationOptions as gr,unshieldAllMutationOptions as _r,unshieldFeeQueryOptions as vr,unshieldFeeQueryOptions as yr,unshieldMutationOptions as br,unshieldMutationOptions as xr,unwrapAllMutationOptions as Sr,unwrapAllMutationOptions as Cr,unwrapMutationOptions as wr,unwrapMutationOptions as Tr,userDecryptMutationOptions as Er,userDecryptMutationOptions as Dr,wrapperDiscoveryQueryOptions as Or,wrapperDiscoveryQueryOptions as L,zamaQueryKeys as kr,zamaQueryKeys as R}from"@zama-fhe/sdk/query";import{skipToken as Ar,useMutation as z,useQueries as jr,useQuery as Mr,useQueryClient as B,useSuspenseQuery as Nr}from"@tanstack/react-query";import{createContext as Pr,useContext as Fr,useEffect as V,useMemo as H,useRef as Ir}from"react";import{jsx as Lr}from"react/jsx-runtime";const U=Pr(null);function Rr({children:e,relayer:t,signer:n,storage:r,sessionStorage:i,keypairTTL:a,sessionTTL:o,registryAddresses:s,registryTTL:c,onEvent:l}){let u=B(),d=Ir(l);V(()=>{d.current=l});let f=H(()=>n?.subscribe?{onDisconnect:()=>k(u),onAccountChange:()=>k(u),onChainChange:()=>k(u)}:void 0,[u,n]),p=H(()=>new _({relayer:t,signer:n,storage:r,sessionStorage:i,keypairTTL:a,sessionTTL:o,registryAddresses:s,registryTTL:c,onEvent:d.current,signerLifecycleCallbacks:f}),[t,n,r,i,a,o,s,c,f]);return V(()=>()=>p.dispose(),[p]),Lr(U.Provider,{value:p,children:e})}function W(){let e=Fr(U);if(!e)throw Error(`useZamaSDK must be used within a <ZamaProvider>. Wrap your component tree in <ZamaProvider relayer={…} signer={…} storage={…}>.`);return e}function zr(){return z(xn(W()))}function Br(e){return z(Dr(W(),e))}function Vr(){return z(Bn(W()))}function Hr(){return z(On(W()))}function Ur(){return z(un(W()))}function Wr(){return z(cn(W()))}function Gr(){return z(gn(W()))}function Kr(){return z(Kn(W()))}function G(e){return Mr({...e,queryKeyHashFn:T})}function K(e){return Nr({...e,queryKeyHashFn:T})}function qr({queries:e,...t}){return jr({...t,queries:e.map(e=>({...e,queryKeyHashFn:T}))})}function Jr(){return G({...Hn(W())})}function Yr(e){return G({...Wn(W(),e)})}function Xr(e){return G({queryKey:R.decryption.handle(e??`0x`),queryFn:()=>void 0,enabled:!1})}function Zr(e){let t=qr({queries:e.map(e=>({queryKey:R.decryption.handle(e),queryFn:()=>void 0,enabled:!1}))}),n={};for(let r=0;r<e.length;r++)n[e[r]]=t[r].data;return{data:n,results:t}}function Qr(e){return z({...Rt(W()),...e,onSuccess:(t,n,r,i)=>{e?.onSuccess?.(t,n,r,i),i.client.invalidateQueries({queryKey:R.isAllowed.all})}})}function $r(){let e=W(),t=G({...N(e.signer)}).data;return G(t?Pn(e,{account:t}):{queryKey:R.isAllowed.all,queryFn:Ar,enabled:!1})}function ei(e){return z({...Qn(W()),...e,onSuccess:(t,n,r,i)=>{e?.onSuccess?.(t,n,r,i),i.client.invalidateQueries({queryKey:R.isAllowed.all})}})}function ti(e){return z({...er(W()),...e,onSuccess:(t,n,r,i)=>{e?.onSuccess?.(t,n,r,i),i.client.invalidateQueries({queryKey:R.isAllowed.all})}})}function q(e){let t=W();return H(()=>t.createToken(e.tokenAddress,e.wrapperAddress),[t,e.tokenAddress,e.wrapperAddress])}function J(e){let t=W();return H(()=>t.createReadonlyToken(e),[t,e])}function ni(e,t){let{tokenAddress:n,handleRefetchInterval:r}=e,{enabled:i=!0}=t??{},a=J(n),o=G({...N(a.signer)}).data,s=Zt(a.signer,n,{owner:o,pollingInterval:r}),c=G({...s,enabled:s.enabled&&i}),l=c.data,u=qt(a,{handle:l,owner:o});return{...G({...u,...t,enabled:u.enabled&&i}),handleQuery:c}}function ri(e,t){let{tokenAddresses:n,handleRefetchInterval:r,maxConcurrency:i}=e,{enabled:a=!0}=t??{},o=W(),s=G({...N(o.signer)}).data,c=H(()=>n.map(e=>o.createReadonlyToken(e)),[o,n]),l=$t(o.signer,n,{owner:s,pollingInterval:r}),u=G({...l,enabled:l.enabled&&a}),d=u.data,f=Array.isArray(d)&&d.length===n.length,p=Yt(c,{owner:s,handles:d,maxConcurrency:i,resultAddresses:n}),m=p.enabled??!0;return{...G({...p,...t,enabled:m&&f&&a}),handlesQuery:u}}function Y(e,t){let n=e?t:void 0;return{wrappedContext:n,callerContext:e?n?.callerContext:t}}async function X({queryClient:e,tokenAddress:t,amount:n,mode:r}){let i=R.confidentialBalance.token(t);await e.cancelQueries({queryKey:i});let a=e.getQueriesData({queryKey:i});for(let[t,i]of a)i!==void 0&&e.setQueryData(t,r===`add`?i+n:i-n);return a}function Z(e,t){for(let[n,r]of t)e.setQueryData(n,r)}function Q({optimistic:e,tokenAddress:t,queryClient:n,options:r}){return{onMutate:e?async(e,i)=>({snapshot:await X({queryClient:n,tokenAddress:t,amount:e.amount,mode:`add`}),callerContext:await r?.onMutate?.(e,i)}):r?.onMutate,onError:(t,i,a,o)=>{let{wrappedContext:s,callerContext:c}=Y(e,a);try{s&&Z(n,s.snapshot)}finally{r?.onError?.(t,i,c,o)}},onSuccess:(n,i,a,o)=>{let{callerContext:s}=Y(e,a);r?.onSuccess?.(n,i,s,o),Mn(o.client,t)},onSettled:(t,n,i,a,o)=>{let{callerContext:s}=Y(e,a);r?.onSettled?.(t,n,i,s,o)}}}function ii(e,t){let n=q(e),r=B();return z({...on(n),...t,onMutate:e.optimistic?async(n,i)=>({snapshot:await X({queryClient:r,tokenAddress:e.tokenAddress,amount:n.amount,mode:`subtract`}),callerContext:await t?.onMutate?.(n,i)}):t?.onMutate,onError:(n,i,a,o)=>{let{wrappedContext:s,callerContext:c}=Y(e.optimistic,a);try{s&&Z(r,s.snapshot)}finally{t?.onError?.(n,i,c,o)}},onSuccess:(n,r,i,a)=>{let{callerContext:o}=Y(e.optimistic,i);t?.onSuccess?.(n,r,o,a),E(a.client,e.tokenAddress)},onSettled:(n,r,i,a,o)=>{let{callerContext:s}=Y(e.optimistic,a);t?.onSettled?.(n,r,i,s,o)}})}function ai(e,t){return z({...rn(q(e)),...t,onSuccess:(n,r,i,a)=>{t?.onSuccess?.(n,r,i,a),E(a.client,e.tokenAddress)}})}function oi(e,t){return z({...Gt(q(e)),...t,onSuccess:(n,r,i,a)=>{t?.onSuccess?.(n,r,i,a),An(a.client,e.tokenAddress)}})}function si(e,t){let{tokenAddress:n,spender:r,holder:i}=e,a=W(),o=G({...N(a.signer),enabled:n!==void 0&&r!==void 0&&i===void 0}),s=i??o.data,c=w(a.signer,n,{holder:s,spender:r});return G({...c,...t,enabled:(c.enabled??!0)&&(t?.enabled??!0)})}function ci(e){let{spender:t,holder:n,...r}=e,i=q(r),a=K({...N(i.signer)}),o=n??a.data;return K({...w(i.signer,i.address,{holder:o,spender:t})})}function li(e,t){let n=q(e),r=B();return z({...or(n),...t,...Q({optimistic:e.optimistic,tokenAddress:e.tokenAddress,queryClient:r,options:t})})}function ui(e,t){let n=q(e),r=B();return z({...nr(n),...t,...Q({optimistic:e.optimistic,tokenAddress:e.tokenAddress,queryClient:r,options:t})})}function di(e,t){return z({...Tr(q(e)),...t,onSuccess:(n,r,i,a)=>{t?.onSuccess?.(n,r,i,a),O(a.client,e.tokenAddress)}})}function fi(e,t){return z({...Cr(q(e)),...t,onSuccess:(n,r,i,a)=>{t?.onSuccess?.(n,r,i,a),O(a.client,e.tokenAddress)}})}function pi(e,t){return z({...En(q(e)),...t,onSuccess:(n,r,i,a)=>{t?.onSuccess?.(n,r,i,a),D(a.client,e.tokenAddress)}})}function mi(e,t){return z({...xr(q(e)),...t,onSuccess:(n,r,i,a)=>{t?.onSuccess?.(n,r,i,a),D(a.client,e.tokenAddress)}})}function hi(e,t){return z({..._r(q(e)),...t,onSuccess:(n,r,i,a)=>{t?.onSuccess?.(n,r,i,a),D(a.client,e.tokenAddress)}})}function gi(e,t){return z({...Jn(q(e)),...t,onSuccess:(n,r,i,a)=>{t?.onSuccess?.(n,r,i,a),D(a.client,e.tokenAddress)}})}function _i(e,t){let{tokenAddress:n,wrapperAddress:r}=e,i=J(n),a=G({...N(i.signer)}).data,o=I(i.signer,n,{owner:a,wrapperAddress:r});return G({...o,...t,enabled:(o.enabled??!0)&&(t?.enabled??!0)})}function vi(e){let{tokenAddress:t,wrapperAddress:n}=e,r=J(t),i=K({...N(r.signer)}).data;return K({...I(r.signer,t,{owner:i,wrapperAddress:n})})}function $(){let e=W(),{data:t}=G({queryKey:R.wrappersRegistry.chainId(),queryFn:()=>e.signer.getChainId(),staleTime:3e4});return t===void 0?void 0:e.registry.getAddress(t)}function yi(e,t){let{tokenAddress:n,erc20Address:r}=e,i=W(),a=$(),o=L(i.registry,{tokenAddress:n,erc20Address:r,registryAddress:a});return G({...o,...t,enabled:(o.enabled??!0)&&(t?.enabled??!0)})}function bi(e){let{tokenAddress:t,erc20Address:n}=e,r=W(),i=$();return K({...L(r.registry,{tokenAddress:t,erc20Address:n,registryAddress:i})})}function xi(e,t){return G({...P(J(e).signer,e),...t})}function Si(e){return K({...P(J(e).signer,e)})}function Ci(e){let{tokenAddress:t,userAddress:n,logs:r,decrypt:i}=e;return G({...It(J(t),{userAddress:n,logs:r,decrypt:i??!0,logsKey:yn(r)})})}function wi(e,t){return z({...mn(q(e)),...t,onSuccess:(e,n,r,i)=>{try{t?.onSuccess?.(e,n,r,i)}finally{i.client.invalidateQueries({queryKey:R.delegationStatus.all})}}})}function Ti(e,t){return z({...Xn(q(e)),...t,onSuccess:(e,n,r,i)=>{try{t?.onSuccess?.(e,n,r,i)}finally{i.client.invalidateQueries({queryKey:R.delegationStatus.all})}}})}function Ei(e,t){let n=vn(W(),{tokenAddress:e.tokenAddress,delegatorAddress:e.delegatorAddress,delegateAddress:e.delegateAddress});return G({...n,...t,enabled:(n.enabled??!0)&&(t?.enabled??!0)})}function Di(e,t){return z({...fn(J(e)),...t})}function Oi(e,t){return z({mutationKey:[`zama.batchDecryptBalancesAs`,...e.map(e=>e.address)],mutationFn:async t=>ve.batchDecryptBalancesAs(e,t),...t})}function ki(e,t){return z({...Bt(q(e)),...t,onSuccess:(n,r,i,a)=>{t?.onSuccess?.(n,r,i,a),jn(a.client,e.tokenAddress)}})}function Ai(e,t){return G({...j(J(e).signer,e),...t})}function ji(e){return K({...j(J(e).signer,e)})}function Mi(e,t){return G({...M(J(e).signer,e),...t})}function Ni(e){return K({...M(J(e).signer,e)})}function Pi(e,t){return G({...F(J(e).signer,e),...t})}function Fi(e){return K({...F(J(e).signer,e)})}function Ii(e,t){let n=ir(W().signer,e);return G({...n,...t,enabled:(n.enabled??!0)&&(t?.enabled??!0)})}function Li(e,t){let n=yr(W().signer,e);return G({...n,...t,enabled:(n.enabled??!0)&&(t?.enabled??!0)})}function Ri(e,t){let n=Ut(W().signer,e);return G({...n,...t,enabled:(n.enabled??!0)&&(t?.enabled??!0)})}function zi(e,t){let n=Cn(W().signer,e);return G({...n,...t,enabled:(n.enabled??!0)&&(t?.enabled??!0)})}function Bi(){let e=W(),t=$();return G(fr(e.signer,{registryAddress:t}))}function Vi(){let e=W(),t=$();return G(dr(e.signer,{registryAddress:t}))}function Hi({fromIndex:e,toIndex:t}){let n=W(),r=$();return G(pr(n.signer,{registryAddress:r,fromIndex:e,toIndex:t}))}function Ui({index:e}){let t=W(),n=$();return G(ur(t.signer,{registryAddress:n,index:e}))}function Wi({tokenAddress:e}){let t=W(),n=$();return G(tn(t.signer,{registryAddress:n,tokenAddress:e}))}function Gi({confidentialTokenAddress:e}){let t=W(),n=$();return G(cr(t.signer,{registryAddress:n,confidentialTokenAddress:e}))}function Ki({confidentialTokenAddress:e}){let t=W(),n=$();return G(Fn(t.signer,{registryAddress:n,confidentialTokenAddress:e}))}function qi({page:e=1,pageSize:t=100,metadata:n=!1}={}){let r=W(),i=$();return G(Rn(r.registry,{registryAddress:i,page:e,pageSize:t,metadata:n}))}export{e as ACL_TOPICS,t as AclPausedError,n as ApprovalFailedError,r as BalanceCheckUnavailableError,i as ChromeSessionStorage,a as ConfigurationError,o as CredentialsManager,s as DecryptionFailedError,c as DefaultRegistryAddresses,l as DelegatedCredentialsManager,u as DelegationContractIsSelfError,d as DelegationCooldownError,f as DelegationDelegateEqualsContractError,p as DelegationExpirationTooSoonError,m as DelegationExpiredError,ee as DelegationExpiryUnchangedError,te as DelegationNotFoundError,ne as DelegationNotPropagatedError,re as DelegationSelfNotAllowedError,ie as ERC20ReadFailedError,ae as ERC7984_INTERFACE_ID,oe as ERC7984_WRAPPER_INTERFACE_ID,se as EncryptionFailedError,ce as HardhatConfig,le as IndexedDBStorage,ue as InsufficientConfidentialBalanceError,de as InsufficientERC20BalanceError,fe as InvalidKeypairError,pe as KeypairExpiredError,me as MainnetConfig,he as MemoryStorage,ge as NoCiphertextError,_e as ReadonlyToken,ye as RelayerRequestFailedError,be as RelayerWeb,xe as SepoliaConfig,Se as SigningFailedError,Ce as SigningRejectedError,we as TOKEN_TOPICS,Te as Token,Ee as Topics,De as TransactionRevertedError,Oe as WrappersRegistry,ke as ZERO_HANDLE,Ae as ZamaError,h as ZamaErrorCode,Rr as ZamaProvider,g as ZamaSDK,v as ZamaSDKEvents,Ft as activityFeedQueryOptions,Lt as allowMutationOptions,y as allowanceContract,b as applyDecryptedValues,x as approveContract,zt as approveUnderlyingMutationOptions,S as balanceOfContract,Vt as batchDecryptBalancesAsMutationOptions,Ht as batchTransferFeeQueryOptions,C as chromeSessionStorage,je as clearPendingUnshield,Wt as confidentialApproveMutationOptions,Me as confidentialBalanceOfContract,Kt as confidentialBalanceQueryOptions,Jt as confidentialBalancesQueryOptions,Ne as confidentialBatchTransferContract,Xt as confidentialHandleQueryOptions,Qt as confidentialHandlesQueryOptions,en as confidentialIsApprovedQueryOptions,Pe as confidentialTotalSupplyContract,Fe as confidentialTransferContract,Ie as confidentialTransferFromContract,nn as confidentialTransferFromMutationOptions,an as confidentialTransferMutationOptions,sn as createDelegatedUserDecryptEIP712MutationOptions,ln as createEIP712MutationOptions,Le as decimalsContract,Re as decodeAclEvent,ze as decodeAclEvents,Be as decodeConfidentialTransfer,Ve as decodeDelegatedForUserDecryption,He as decodeOnChainEvent,Ue as decodeOnChainEvents,We as decodeRevokedDelegationForUserDecryption,Ge as decodeUnwrapRequested,Ke as decodeUnwrappedFinalized,qe as decodeUnwrappedStarted,Je as decodeWrapped,dn as decryptBalanceAsMutationOptions,pn as delegateDecryptionMutationOptions,Ye as delegateForUserDecryptionContract,hn as delegatedUserDecryptMutationOptions,_n as delegationStatusQueryOptions,Xe as deploymentCoordinatorContract,bn as encryptMutationOptions,Ze as extractEncryptedHandles,Sn as feeRecipientQueryOptions,wn as filterQueryOptions,Qe as finalizeUnwrapContract,Tn as finalizeUnwrapMutationOptions,$e as findDelegatedForUserDecryption,et as findRevokedDelegationForUserDecryption,tt as findUnwrapRequested,nt as findWrapped,Dn as generateKeypairMutationOptions,rt as getBatchTransferFeeContract,it as getDelegationExpiryContract,at as getFeeRecipientContract,ot as getUnwrapFeeContract,st as getWrapFeeContract,ct as getWrapperContract,kn as hashFn,lt as indexedDBStorage,Nn as isAllowedQueryOptions,A as isConfidentialQueryOptions,ut as isConfidentialTokenContract,dt as isConfidentialWrapperContract,ft as isFinalizeUnwrapOperatorContract,pt as isHandleDelegatedContract,mt as isOperatorContract,In as isWrapperQueryOptions,Ln as listPairsQueryOptions,ht as loadPendingUnshield,gt as matchZamaError,_t as memoryStorage,vt as nameContract,yt as parseActivityFeed,zn as publicDecryptMutationOptions,Vn as publicKeyQueryOptions,Un as publicParamsQueryOptions,bt as rateContract,Gn as requestZKProofVerificationMutationOptions,qn as resumeUnshieldMutationOptions,xt as revokeDelegationContract,Yn as revokeDelegationMutationOptions,Zn as revokeMutationOptions,$n as revokeSessionMutationOptions,St as savePendingUnshield,Ct as setFinalizeUnwrapOperatorContract,wt as setOperatorContract,tr as shieldETHMutationOptions,rr as shieldFeeQueryOptions,ar as shieldMutationOptions,sr as signerAddressQueryOptions,Tt as sortByBlockNumber,Et as supportsInterfaceContract,Dt as symbolContract,lr as tokenMetadataQueryOptions,Ot as totalSupplyContract,mr as totalSupplyQueryOptions,hr as underlyingAllowanceQueryOptions,kt as underlyingContract,gr as unshieldAllMutationOptions,vr as unshieldFeeQueryOptions,br as unshieldMutationOptions,Sr as unwrapAllMutationOptions,At as unwrapContract,jt as unwrapFromBalanceContract,wr as unwrapMutationOptions,Ci as useActivityFeed,Qr as useAllow,ki as useApproveUnderlying,Oi as useBatchDecryptBalancesAs,Ri as useBatchTransferFee,oi as useConfidentialApprove,ni as useConfidentialBalance,ri as useConfidentialBalances,si as useConfidentialIsApproved,ci as useConfidentialIsApprovedSuspense,Wi as useConfidentialTokenAddress,ii as useConfidentialTransfer,ai as useConfidentialTransferFrom,Wr as useCreateDelegatedUserDecryptEIP712,Ur as useCreateEIP712,Di as useDecryptBalanceAs,wi as useDelegateDecryption,Gr as useDelegatedUserDecrypt,Ei as useDelegationStatus,zr as useEncrypt,zi as useFeeRecipient,pi as useFinalizeUnwrap,Hr as useGenerateKeypair,$r as useIsAllowed,Ai as useIsConfidential,ji as useIsConfidentialSuspense,Ki as useIsConfidentialTokenValid,Mi as useIsWrapper,Ni as useIsWrapperSuspense,qi as useListPairs,xi as useMetadata,Si as useMetadataSuspense,Vr as usePublicDecrypt,Jr as usePublicKey,Yr as usePublicParams,J as useReadonlyToken,Kr as useRequestZKProofVerification,gi as useResumeUnshield,ei as useRevoke,Ti as useRevokeDelegation,ti as useRevokeSession,li as useShield,ui as useShieldETH,Ii as useShieldFee,q as useToken,Gi as useTokenAddress,Ui as useTokenPair,Vi as useTokenPairsLength,Bi as useTokenPairsRegistry,Hi as useTokenPairsSlice,Pi as useTotalSupply,Fi as useTotalSupplySuspense,_i as useUnderlyingAllowance,vi as useUnderlyingAllowanceSuspense,mi as useUnshield,hi as useUnshieldAll,Li as useUnshieldFee,di as useUnwrap,fi as useUnwrapAll,Br as useUserDecrypt,Xr as useUserDecryptedValue,Zr as useUserDecryptedValues,yi as useWrapperDiscovery,bi as useWrapperDiscoverySuspense,$ as useWrappersRegistryAddress,W as useZamaSDK,Er as userDecryptMutationOptions,Mt as wrapContract,Nt as wrapETHContract,Or as wrapperDiscoveryQueryOptions,Pt as wrapperExistsContract,kr as zamaQueryKeys};
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":["ZamaSDK","encryptMutationOptions","userDecryptMutationOptions","publicDecryptMutationOptions","generateKeypairMutationOptions","createEIP712MutationOptions","createDelegatedUserDecryptEIP712MutationOptions","delegatedUserDecryptMutationOptions","requestZKProofVerificationMutationOptions","useQuery","tanstack_useQuery","hashFn","useSuspenseQuery","tanstack_useSuspenseQuery","useQueries","tanstack_useQueries","useQuery","publicKeyQueryOptions","useQuery","publicParamsQueryOptions","useQuery","zamaQueryKeys","useQueries","zamaQueryKeys","allowMutationOptions","zamaQueryKeys","useQuery","signerAddressQueryOptions","isAllowedQueryOptions","zamaQueryKeys","revokeMutationOptions","zamaQueryKeys","revokeSessionMutationOptions","zamaQueryKeys","useQuery","signerAddressQueryOptions","confidentialHandleQueryOptions","confidentialBalanceQueryOptions","useQuery","signerAddressQueryOptions","confidentialHandlesQueryOptions","confidentialBalancesQueryOptions","zamaQueryKeys","confidentialTransferMutationOptions","confidentialTransferFromMutationOptions","confidentialApproveMutationOptions","useQuery","signerAddressQueryOptions","confidentialIsApprovedQueryOptions","useSuspenseQuery","shieldMutationOptions","shieldETHMutationOptions","unwrapMutationOptions","unwrapAllMutationOptions","finalizeUnwrapMutationOptions","unshieldMutationOptions","unshieldAllMutationOptions","resumeUnshieldMutationOptions","useQuery","signerAddressQueryOptions","underlyingAllowanceQueryOptions","useSuspenseQuery","useQuery","zamaQueryKeys","wrapperDiscoveryQueryOptions","useQuery","useSuspenseQuery","useQuery","tokenMetadataQueryOptions","useSuspenseQuery","useQuery","activityFeedQueryOptions","delegateDecryptionMutationOptions","zamaQueryKeys","revokeDelegationMutationOptions","zamaQueryKeys","delegationStatusQueryOptions","useQuery","decryptBalanceAsMutationOptions","ReadonlyToken","approveUnderlyingMutationOptions","useQuery","isConfidentialQueryOptions","useSuspenseQuery","isWrapperQueryOptions","useQuery","totalSupplyQueryOptions","useSuspenseQuery","shieldFeeQueryOptions","useQuery","unshieldFeeQueryOptions","batchTransferFeeQueryOptions","feeRecipientQueryOptions","useQuery","useQuery","useQuery","useQuery","useQuery","useQuery","useQuery","useQuery","listPairsQueryOptions"],"sources":["../src/provider.tsx","../src/relayer/use-encrypt.ts","../src/relayer/use-user-decrypt.ts","../src/relayer/use-public-decrypt.ts","../src/relayer/use-generate-keypair.ts","../src/relayer/use-create-eip712.ts","../src/relayer/use-create-delegated-user-decrypt-eip712.ts","../src/relayer/use-delegated-user-decrypt.ts","../src/relayer/use-request-zk-proof-verification.ts","../src/utils/query.ts","../src/relayer/use-public-key.ts","../src/relayer/use-public-params.ts","../src/relayer/use-user-decrypted-value.ts","../src/relayer/use-user-decrypted-values.ts","../src/authorization/use-allow.ts","../src/authorization/use-is-allowed.ts","../src/authorization/use-revoke.ts","../src/authorization/use-revoke-session.ts","../src/token/use-token.ts","../src/token/use-readonly-token.ts","../src/balance/use-confidential-balance.ts","../src/balance/use-confidential-balances.ts","../src/balance/optimistic-balance-update.ts","../src/transfer/use-confidential-transfer.ts","../src/transfer/use-confidential-transfer-from.ts","../src/transfer/use-confidential-approve.ts","../src/transfer/use-confidential-is-approved.ts","../src/shield/use-shield.ts","../src/shield/use-shield-eth.ts","../src/unwrap/use-unwrap.ts","../src/unwrap/use-unwrap-all.ts","../src/unwrap/use-finalize-unwrap.ts","../src/unshield/use-unshield.ts","../src/unshield/use-unshield-all.ts","../src/unshield/use-resume-unshield.ts","../src/shield/use-underlying-allowance.ts","../src/wrappers-registry/use-wrappers-registry-address.ts","../src/token/use-wrapper-discovery.ts","../src/token/use-metadata.ts","../src/balance/use-activity-feed.ts","../src/delegation/use-delegate-decryption.ts","../src/delegation/use-revoke-delegation.ts","../src/delegation/use-delegation-status.ts","../src/delegation/use-decrypt-balance-as.ts","../src/delegation/use-batch-decrypt-balances-as.ts","../src/shield/use-approve-underlying.ts","../src/token/use-is-confidential.ts","../src/token/use-total-supply.ts","../src/token/use-fees.ts","../src/wrappers-registry/use-token-pairs-registry.ts","../src/wrappers-registry/use-token-pairs-length.ts","../src/wrappers-registry/use-token-pairs-slice.ts","../src/wrappers-registry/use-token-pair.ts","../src/wrappers-registry/use-confidential-token-address.ts","../src/wrappers-registry/use-token-address.ts","../src/wrappers-registry/use-is-confidential-token-valid.ts","../src/wrappers-registry/use-list-pairs.ts"],"sourcesContent":["\"use client\";\n\nimport type {\n  Address,\n  GenericSigner,\n  GenericStorage,\n  RelayerSDK,\n  ZamaSDKEventListener,\n} from \"@zama-fhe/sdk\";\nimport { ZamaSDK } from \"@zama-fhe/sdk\";\nimport { invalidateWalletLifecycleQueries } from \"@zama-fhe/sdk/query\";\nimport { useQueryClient } from \"@tanstack/react-query\";\nimport {\n  createContext,\n  type PropsWithChildren,\n  useContext,\n  useEffect,\n  useMemo,\n  useRef,\n} from \"react\";\n\n/** Props for {@link ZamaProvider}. */\nexport interface ZamaProviderProps extends PropsWithChildren {\n  /** FHE relayer backend (RelayerWeb for browser, RelayerNode for server). */\n  relayer: RelayerSDK;\n  /** Wallet signer (`ViemSigner`, `EthersSigner`, or custom {@link GenericSigner}). */\n  signer: GenericSigner;\n  /** Credential storage backend (IndexedDBStorage for browser, MemoryStorage for tests). */\n  storage: GenericStorage;\n  /**\n   * Session storage for wallet signatures. Defaults to in-memory (lost on reload).\n   * Pass a `chrome.storage.session`-backed store for web extensions.\n   */\n  sessionStorage?: GenericStorage;\n  /**\n   * How long the ML-KEM re-encryption keypair remains valid, in seconds.\n   * Default: `86400` (1 day). Must be positive — `0` is rejected.\n   */\n  keypairTTL?: number;\n  /**\n   * Controls how long session signatures (EIP-712 wallet signatures) remain valid, in seconds.\n   * Default: `2592000` (30 days).\n   * - `0`: never persist — every operation triggers a signing prompt (high-security mode).\n   * - Positive number: seconds until the session signature expires and requires re-authentication.\n   */\n  sessionTTL?: number;\n  /**\n   * Per-chain wrappers registry address overrides, merged on top of built-in defaults.\n   * Use this for custom or local chains (e.g. Hardhat) where no default registry exists.\n   */\n  registryAddresses?: Record<number, Address>;\n  /**\n   * How long cached registry results remain valid, in seconds.\n   * Default: `86400` (24 hours).\n   */\n  registryTTL?: number;\n  /** Callback invoked on SDK lifecycle events. */\n  onEvent?: ZamaSDKEventListener;\n}\n\nconst ZamaSDKContext = createContext<ZamaSDK | null>(null);\n\n/**\n * Provides a {@link ZamaSDK} instance to all descendant hooks.\n *\n * @example\n * ```tsx\n * <ZamaProvider relayer={relayer} signer={signer} storage={storage}>\n *   <App />\n * </ZamaProvider>\n * ```\n */\nexport function ZamaProvider({\n  children,\n  relayer,\n  signer,\n  storage,\n  sessionStorage,\n  keypairTTL,\n  sessionTTL,\n  registryAddresses,\n  registryTTL,\n  onEvent,\n}: ZamaProviderProps) {\n  const queryClient = useQueryClient();\n\n  // Stabilize onEvent so an inline arrow doesn't recreate the SDK every render.\n  const onEventRef = useRef(onEvent);\n  const registryAddressesRef = useRef(registryAddresses);\n\n  useEffect(() => {\n    onEventRef.current = onEvent;\n    registryAddressesRef.current = registryAddresses;\n  });\n\n  const signerLifecycleCallbacks = useMemo(\n    () =>\n      signer?.subscribe\n        ? {\n            onDisconnect: () => invalidateWalletLifecycleQueries(queryClient),\n            onAccountChange: () => invalidateWalletLifecycleQueries(queryClient),\n            onChainChange: () => invalidateWalletLifecycleQueries(queryClient),\n          }\n        : undefined,\n    [queryClient, signer],\n  );\n\n  const sdk = useMemo(\n    () =>\n      new ZamaSDK({\n        relayer,\n        signer,\n        storage,\n        sessionStorage,\n        keypairTTL,\n        sessionTTL,\n        registryAddresses: registryAddressesRef.current,\n        registryTTL,\n        onEvent: onEventRef.current,\n        signerLifecycleCallbacks,\n      }),\n    [\n      relayer,\n      signer,\n      storage,\n      sessionStorage,\n      keypairTTL,\n      sessionTTL,\n      registryTTL,\n      signerLifecycleCallbacks,\n    ],\n  );\n\n  // Clean up signer subscriptions on unmount without terminating the\n  // caller-owned relayer. dispose() only unsubscribes from wallet events\n  // and is idempotent.\n  useEffect(() => () => sdk.dispose(), [sdk]);\n\n  return <ZamaSDKContext.Provider value={sdk}>{children}</ZamaSDKContext.Provider>;\n}\n\n/**\n * Access the {@link ZamaSDK} instance from context.\n * Throws if called outside a {@link ZamaProvider} or when no signer is provided.\n *\n * @example\n * ```tsx\n * const sdk = useZamaSDK();\n * const token = sdk.createReadonlyToken(\"0x...\");\n * ```\n */\nexport function useZamaSDK(): ZamaSDK {\n  const context = useContext(ZamaSDKContext);\n\n  if (!context) {\n    throw new Error(\n      \"useZamaSDK must be used within a <ZamaProvider>. \" +\n        \"Wrap your component tree in <ZamaProvider relayer={…} signer={…} storage={…}>.\",\n    );\n  }\n\n  return context;\n}\n","\"use client\";\n\nimport type { EncryptParams, EncryptResult } from \"@zama-fhe/sdk\";\nimport { useMutation } from \"@tanstack/react-query\";\nimport { encryptMutationOptions } from \"@zama-fhe/sdk/query\";\nimport { useZamaSDK } from \"../provider\";\n\n/**\n * Encrypt a plaintext value using FHE.\n * Calls the relayer's `encrypt` method via a mutation.\n *\n * Errors are {@link ZamaError} subclasses — use `instanceof` to handle specific failures:\n * - {@link EncryptionFailedError} — FHE encryption failed\n *\n * @returns A mutation whose `mutate` accepts {@link EncryptParams}.\n *\n * @example\n * ```tsx\n * const encrypt = useEncrypt();\n * encrypt.mutate({ values: [{ value: 1000n, type: \"euint64\" }], contractAddress: \"0x...\", userAddress: \"0x...\" });\n * ```\n */\nexport function useEncrypt() {\n  const sdk = useZamaSDK();\n  return useMutation<EncryptResult, Error, EncryptParams>(encryptMutationOptions(sdk));\n}\n","\"use client\";\n\nimport { useMutation } from \"@tanstack/react-query\";\nimport type { ClearValueType, Handle } from \"@zama-fhe/sdk\";\nimport type {\n  DecryptHandle,\n  UserDecryptCallbacks,\n  UserDecryptMutationParams,\n} from \"@zama-fhe/sdk/query\";\nimport { userDecryptMutationOptions } from \"@zama-fhe/sdk/query\";\nimport { useZamaSDK } from \"../provider\";\n\nexport type {\n  UserDecryptCallbacks as DecryptCallbacks,\n  DecryptHandle,\n  UserDecryptMutationParams as DecryptParams,\n};\n\n/** Configuration for {@link useUserDecrypt}. */\nexport type UseUserDecryptConfig = UserDecryptCallbacks;\n\n/**\n * High-level orchestration hook for user decryption.\n *\n * Reuses cached FHE credentials from `sdk.credentials` when available,\n * falling back to generating a fresh keypair + EIP-712 signature only when\n * no valid credentials exist. This avoids redundant wallet signature prompts.\n *\n * On success, populates the decryption cache so `useUserDecryptedValue` / `useUserDecryptedValues`\n * can read the results.\n *\n * @param config - Optional callbacks for step-by-step UX feedback.\n * @returns A mutation whose `mutate` accepts {@link UserDecryptMutationParams}.\n *\n * @example\n * ```tsx\n * const decrypt = useUserDecrypt({\n *   onCredentialsReady: () => setStep(\"decrypting\"),\n *   onDecrypted: (values) => console.log(values),\n * });\n * decrypt.mutate({\n *   handles: [{ handle: \"0xHandle\", contractAddress: \"0xContract\" }],\n * });\n * ```\n */\nexport function useUserDecrypt(config?: UseUserDecryptConfig) {\n  const sdk = useZamaSDK();\n\n  return useMutation<Record<Handle, ClearValueType>, Error, UserDecryptMutationParams>(\n    userDecryptMutationOptions(sdk, config),\n  );\n}\n","\"use client\";\n\nimport { useMutation } from \"@tanstack/react-query\";\nimport type { Handle, PublicDecryptResult } from \"@zama-fhe/sdk\";\nimport { publicDecryptMutationOptions } from \"@zama-fhe/sdk/query\";\nimport { useZamaSDK } from \"../provider\";\n\n/**\n * Decrypt FHE ciphertext handles using the network public key (no credential needed).\n * On success, populates the decryption cache so {@link useUserDecryptedValue} / {@link useUserDecryptedValues}\n * can read the results.\n *\n * @returns A mutation whose `mutate` accepts an array of handle strings.\n *\n * @example\n * ```tsx\n * const publicDecrypt = usePublicDecrypt();\n * publicDecrypt.mutate([\"0xHandle1\", \"0xHandle2\"]);\n * // publicDecrypt.data?.clearValues => { \"0xHandle1\": 500n, ... }\n * ```\n */\nexport function usePublicDecrypt() {\n  const sdk = useZamaSDK();\n  return useMutation<PublicDecryptResult, Error, Handle[]>(publicDecryptMutationOptions(sdk));\n}\n","\"use client\";\n\nimport { useMutation } from \"@tanstack/react-query\";\nimport { generateKeypairMutationOptions } from \"@zama-fhe/sdk/query\";\nimport { useZamaSDK } from \"../provider\";\n\n/**\n * Generate an FHE keypair via the relayer.\n * Returns a public/private key pair for use in decrypt authorization.\n *\n * Errors are {@link ZamaError} subclasses — use `instanceof` to handle specific failures:\n * - {@link RelayerRequestFailedError} — relayer keypair generation request failed\n *\n * @returns A mutation whose `mutate` takes no parameters.\n *\n * @example\n * ```tsx\n * const generateKeypair = useGenerateKeypair();\n * generateKeypair.mutate();\n * // generateKeypair.data?.publicKey, generateKeypair.data?.privateKey\n * ```\n */\nexport function useGenerateKeypair() {\n  const sdk = useZamaSDK();\n  return useMutation(generateKeypairMutationOptions(sdk));\n}\n","\"use client\";\n\nimport type { EIP712TypedData } from \"@zama-fhe/sdk\";\nimport { useMutation } from \"@tanstack/react-query\";\nimport { createEIP712MutationOptions } from \"@zama-fhe/sdk/query\";\nimport type { CreateEIP712Params } from \"@zama-fhe/sdk/query\";\nimport { useZamaSDK } from \"../provider\";\n\nexport type { CreateEIP712Params };\n\n/**\n * Create EIP-712 typed data for signing an FHE decrypt credential.\n * The returned typed data is signed by the wallet to authorize decryption.\n *\n * @returns A mutation whose `mutate` accepts {@link CreateEIP712Params}.\n *\n * @example\n * ```tsx\n * const createEIP712 = useCreateEIP712();\n * createEIP712.mutate({\n *   publicKey: keypair.publicKey,\n *   contractAddresses: [\"0xToken\"],\n *   startTimestamp: Math.floor(Date.now() / 1000),\n * });\n * ```\n */\nexport function useCreateEIP712() {\n  const sdk = useZamaSDK();\n  return useMutation<EIP712TypedData, Error, CreateEIP712Params>(createEIP712MutationOptions(sdk));\n}\n","\"use client\";\n\nimport type { KmsDelegatedUserDecryptEIP712Type } from \"@zama-fhe/sdk\";\nimport { useMutation } from \"@tanstack/react-query\";\nimport { createDelegatedUserDecryptEIP712MutationOptions } from \"@zama-fhe/sdk/query\";\nimport type { CreateDelegatedUserDecryptEIP712Params } from \"@zama-fhe/sdk/query\";\nimport { useZamaSDK } from \"../provider\";\n\nexport type { CreateDelegatedUserDecryptEIP712Params };\n\n/**\n * Create EIP-712 typed data for a delegated user decrypt credential.\n * Used when one wallet authorizes another to decrypt on its behalf.\n *\n * @returns A mutation whose `mutate` accepts {@link CreateDelegatedUserDecryptEIP712Params}.\n *\n * @example\n * ```tsx\n * const createEIP712 = useCreateDelegatedUserDecryptEIP712();\n * createEIP712.mutate({\n *   publicKey: keypair.publicKey,\n *   contractAddresses: [\"0xToken\"],\n *   delegatorAddress: \"0xDelegator\",\n *   startTimestamp: Math.floor(Date.now() / 1000),\n * });\n * ```\n */\nexport function useCreateDelegatedUserDecryptEIP712() {\n  const sdk = useZamaSDK();\n  return useMutation<\n    KmsDelegatedUserDecryptEIP712Type,\n    Error,\n    CreateDelegatedUserDecryptEIP712Params\n  >(createDelegatedUserDecryptEIP712MutationOptions(sdk));\n}\n","\"use client\";\n\nimport type { DelegatedUserDecryptParams, ClearValueType, Handle } from \"@zama-fhe/sdk\";\nimport { useMutation } from \"@tanstack/react-query\";\nimport { delegatedUserDecryptMutationOptions } from \"@zama-fhe/sdk/query\";\nimport { useZamaSDK } from \"../provider\";\n\n/**\n * Decrypt FHE ciphertext handles using delegated user credentials.\n * Returns a map of handle → plaintext bigint.\n *\n * @returns A mutation whose `mutate` accepts {@link DelegatedUserDecryptParams}.\n *\n * @example\n * ```tsx\n * const decrypt = useDelegatedUserDecrypt();\n * decrypt.mutate({ handles: [\"0xHandle1\"], ...credentials });\n * // decrypt.data => { \"0xHandle1\": 1000n }\n * ```\n */\nexport function useDelegatedUserDecrypt() {\n  const sdk = useZamaSDK();\n  return useMutation<Record<Handle, ClearValueType>, Error, DelegatedUserDecryptParams>(\n    delegatedUserDecryptMutationOptions(sdk),\n  );\n}\n","\"use client\";\n\nimport type { InputProofBytesType, ZKProofLike } from \"@zama-fhe/sdk\";\nimport { useMutation } from \"@tanstack/react-query\";\nimport { requestZKProofVerificationMutationOptions } from \"@zama-fhe/sdk/query\";\nimport { useZamaSDK } from \"../provider\";\n\n/**\n * Submit a ZK proof for on-chain verification.\n * Returns the input proof bytes for use in contract calls.\n *\n * @returns A mutation whose `mutate` accepts a {@link ZKProofLike}.\n *\n * @example\n * ```tsx\n * const verify = useRequestZKProofVerification();\n * verify.mutate(zkProof);\n * // verify.data => Uint8Array (input proof bytes)\n * ```\n */\nexport function useRequestZKProofVerification() {\n  const sdk = useZamaSDK();\n  return useMutation<InputProofBytesType, Error, ZKProofLike>(\n    requestZKProofVerificationMutationOptions(sdk),\n  );\n}\n","import {\n  type DefaultError,\n  type QueriesOptions,\n  type QueriesResults,\n  useQueries as tanstack_useQueries,\n  useQuery as tanstack_useQuery,\n  useSuspenseQuery as tanstack_useSuspenseQuery,\n  type UseQueryOptions,\n  type UseQueryResult,\n  type UseSuspenseQueryOptions,\n  type UseSuspenseQueryResult,\n} from \"@tanstack/react-query\";\nimport { hashFn } from \"@zama-fhe/sdk/query\";\n\n/**\n * Thin wrapper around TanStack's useQuery that injects our custom queryKeyHashFn.\n * Mirrors the wagmi pattern — the type safety boundary is at the factory and hook levels.\n *\n * Callers typically specify only `<TData>` (e.g. `useQuery<PublicKeyData>(...)`) while\n * factory options carry specific tuple keys (e.g. `readonly [\"zama.publicKey\"]`).\n * We erase the QueryKey param via `AnyKeyQueryOptions` so callers don't need to\n * spell out the key type — any QueryKey subtype is accepted.\n */\ntype AnyKeyQueryOptions<TData, TError> = UseQueryOptions<\n  TData,\n  TError,\n  TData,\n  // oxlint-disable-next-line typescript/no-explicit-any\n  any\n>;\ntype AnyKeySuspenseOptions<TData, TError> = UseSuspenseQueryOptions<\n  TData,\n  TError,\n  TData,\n  // oxlint-disable-next-line typescript/no-explicit-any\n  any\n>;\n\nexport function useQuery<TData = unknown, TError = DefaultError>(\n  options: AnyKeyQueryOptions<TData, TError>,\n): UseQueryResult<TData, TError> {\n  return tanstack_useQuery({\n    ...options,\n    queryKeyHashFn: hashFn,\n  });\n}\n\nexport function useSuspenseQuery<TData = unknown, TError = DefaultError>(\n  options: AnyKeySuspenseOptions<TData, TError>,\n): UseSuspenseQueryResult<TData, TError> {\n  return tanstack_useSuspenseQuery({\n    ...options,\n    queryKeyHashFn: hashFn,\n  });\n}\n\n/**\n * Thin wrapper around TanStack's useQueries that injects our custom queryKeyHashFn\n * on every query in the array.\n */\nexport function useQueries<\n  // oxlint-disable-next-line typescript/no-explicit-any\n  T extends Array<any>,\n  TCombinedResult = QueriesResults<T>,\n>({\n  queries,\n  ...options\n}: {\n  queries: readonly [...QueriesOptions<T>];\n  combine?: (result: QueriesResults<T>) => TCombinedResult;\n  subscribed?: boolean;\n}): TCombinedResult {\n  return tanstack_useQueries({\n    ...options,\n    queries: queries.map((q) => ({\n      ...q,\n      queryKeyHashFn: hashFn,\n    })) as [...QueriesOptions<T>],\n  });\n}\n","\"use client\";\n\nimport { useQuery } from \"../utils/query\";\nimport { publicKeyQueryOptions } from \"@zama-fhe/sdk/query\";\nimport { useZamaSDK } from \"../provider\";\n\nexport { publicKeyQueryOptions };\n\n/** Shape of the FHE public key data returned by the relayer. */\nexport interface PublicKeyData {\n  /** Unique identifier for this public key version. */\n  publicKeyId: string;\n  /** The raw FHE public key bytes. */\n  publicKey: Uint8Array;\n}\n\n/**\n * Fetch the FHE network public key from the relayer.\n * Cached indefinitely since the key does not change during a session.\n *\n * @returns Query result with `data: PublicKeyData | null`.\n *\n * @example\n * ```tsx\n * const { data: publicKey } = usePublicKey();\n * // publicKey?.publicKeyId, publicKey?.publicKey\n * ```\n */\nexport function usePublicKey() {\n  const sdk = useZamaSDK();\n  return useQuery<PublicKeyData | null>({\n    ...publicKeyQueryOptions(sdk),\n  });\n}\n","\"use client\";\n\nimport { useQuery } from \"../utils/query\";\nimport { publicParamsQueryOptions } from \"@zama-fhe/sdk/query\";\nimport { useZamaSDK } from \"../provider\";\n\nexport { publicParamsQueryOptions };\n\n/** Shape of the FHE public parameters returned by the relayer. */\nexport interface PublicParamsData {\n  /** The raw public parameters bytes (WASM-ready). */\n  publicParams: Uint8Array;\n  /** Unique identifier for this public params version. */\n  publicParamsId: string;\n}\n\n/**\n * Fetch FHE public parameters for a given bit size from the relayer.\n * Cached indefinitely since parameters do not change during a session.\n *\n * @param bits - The FHE bit size to fetch parameters for (e.g. 2048).\n * @returns Query result with `data: PublicParamsData | null`.\n *\n * @example\n * ```tsx\n * const { data: params } = usePublicParams(2048);\n * // params?.publicParams, params?.publicParamsId\n * ```\n */\nexport function usePublicParams(bits: number) {\n  const sdk = useZamaSDK();\n  return useQuery<PublicParamsData | null>({\n    ...publicParamsQueryOptions(sdk, bits),\n  });\n}\n","\"use client\";\n\nimport { useQuery } from \"../utils/query\";\nimport type { ClearValueType, Handle } from \"@zama-fhe/sdk\";\nimport { zamaQueryKeys } from \"@zama-fhe/sdk/query\";\n\n/**\n * Look up a single cached decrypted value by its handle.\n * Values are populated automatically when `useUserDecrypt` or `usePublicDecrypt` succeed.\n * You can also populate manually via queryClient.setQueryData(zamaQueryKeys.decryption.handle(handle), value).\n */\nexport function useUserDecryptedValue(handle: Handle | undefined) {\n  return useQuery<ClearValueType>({\n    queryKey: zamaQueryKeys.decryption.handle(handle ?? \"0x\"),\n    queryFn: () => undefined as never,\n    enabled: false,\n  });\n}\n","\"use client\";\n\nimport type { ClearValueType, Handle } from \"@zama-fhe/sdk\";\nimport { zamaQueryKeys } from \"@zama-fhe/sdk/query\";\nimport { useQueries } from \"../utils/query\";\n\n/**\n * Look up multiple cached decrypted values by their handles.\n * Values are populated automatically when `useUserDecrypt` or `usePublicDecrypt` succeed.\n */\nexport function useUserDecryptedValues(handles: Handle[]) {\n  const results = useQueries({\n    queries: handles.map((handle) => ({\n      queryKey: zamaQueryKeys.decryption.handle(handle),\n      queryFn: () => undefined as never,\n      enabled: false,\n    })),\n  });\n\n  const data: Record<Handle, ClearValueType | undefined> = {};\n  for (let i = 0; i < handles.length; i++) {\n    data[handles[i]!] = results[i]!.data as ClearValueType | undefined;\n  }\n\n  return {\n    data,\n    results,\n  };\n}\n","\"use client\";\n\nimport { useMutation, type UseMutationOptions } from \"@tanstack/react-query\";\nimport type { Address } from \"@zama-fhe/sdk\";\nimport { allowMutationOptions, zamaQueryKeys } from \"@zama-fhe/sdk/query\";\nimport { useZamaSDK } from \"../provider\";\n\n/**\n * Sign an EIP-712 message authorizing decryption of confidential handles\n * for a list of contract addresses. This is not token-specific — any\n * contract that uses FHE-encrypted values (tokens, DeFi vaults, games, etc.)\n * can be authorized in a single wallet signature. Subsequent decrypt\n * operations on any of these contracts reuse cached credentials.\n *\n * Errors are {@link ZamaError} subclasses — use `instanceof` to handle specific failures:\n * - {@link SigningRejectedError} — user rejected the wallet prompt\n * - {@link KeypairExpiredError} — the re-encryption keypair has expired\n *\n * @example\n * ```tsx\n * const { mutateAsync: allow, isPending } = useAllow();\n *\n * // Authorize decryption for any contracts with encrypted state:\n * // confidential tokens, auction contracts, governance contracts, etc.\n * await allow([tokenAddress, auctionAddress, governanceAddress]);\n * ```\n */\nexport function useAllow(options?: UseMutationOptions<void, Error, Address[]>) {\n  const sdk = useZamaSDK();\n\n  return useMutation<void, Error, Address[]>({\n    ...allowMutationOptions(sdk),\n    ...options,\n    onSuccess: (data, variables, onMutateResult, context) => {\n      options?.onSuccess?.(data, variables, onMutateResult, context);\n      void context.client.invalidateQueries({ queryKey: zamaQueryKeys.isAllowed.all });\n    },\n  });\n}\n","\"use client\";\n\nimport { useQuery } from \"../utils/query\";\nimport { skipToken } from \"@tanstack/react-query\";\nimport type { Address } from \"@zama-fhe/sdk\";\nimport {\n  isAllowedQueryOptions,\n  signerAddressQueryOptions,\n  zamaQueryKeys,\n} from \"@zama-fhe/sdk/query\";\nimport { useZamaSDK } from \"../provider\";\n\n/**\n * Check whether a session signature is cached for the connected wallet.\n * Returns `true` if decrypt operations can proceed without a wallet prompt.\n *\n * @example\n * ```tsx\n * const { data: allowed } = useIsAllowed();\n * ```\n */\nexport function useIsAllowed() {\n  const sdk = useZamaSDK();\n  const addressQuery = useQuery<Address>({\n    ...signerAddressQueryOptions(sdk.signer),\n  });\n  const account = addressQuery.data;\n  const baseOpts = account\n    ? isAllowedQueryOptions(sdk, { account })\n    : ({\n        queryKey: zamaQueryKeys.isAllowed.all,\n        queryFn: skipToken,\n        enabled: false,\n      } as const);\n\n  return useQuery<boolean>(baseOpts);\n}\n","\"use client\";\n\nimport { useMutation, type UseMutationOptions } from \"@tanstack/react-query\";\nimport type { Address } from \"@zama-fhe/sdk\";\nimport { revokeMutationOptions, zamaQueryKeys } from \"@zama-fhe/sdk/query\";\nimport { useZamaSDK } from \"../provider\";\n\n/**\n * Revoke stored FHE decrypt credentials for a list of contract addresses.\n * This is not token-specific — it revokes the EIP-712 authorization for\n * any contract that uses FHE-encrypted values. The next decrypt operation\n * on these contracts will require a fresh wallet signature.\n *\n * @example\n * ```tsx\n * const { mutate: revoke } = useRevoke();\n *\n * // Revoke for any contracts: tokens, auctions, governance, etc.\n * revoke([tokenAddress, auctionAddress]);\n * ```\n */\nexport function useRevoke(options?: UseMutationOptions<void, Error, Address[]>) {\n  const sdk = useZamaSDK();\n\n  return useMutation<void, Error, Address[]>({\n    ...revokeMutationOptions(sdk),\n    ...options,\n    onSuccess: (data, variables, onMutateResult, context) => {\n      options?.onSuccess?.(data, variables, onMutateResult, context);\n      void context.client.invalidateQueries({ queryKey: zamaQueryKeys.isAllowed.all });\n    },\n  });\n}\n","\"use client\";\n\nimport { useMutation, type UseMutationOptions } from \"@tanstack/react-query\";\nimport { revokeSessionMutationOptions, zamaQueryKeys } from \"@zama-fhe/sdk/query\";\nimport { useZamaSDK } from \"../provider\";\n\n/**\n * Revoke the session signature for the connected wallet without\n * specifying contract addresses. Useful for wallet disconnect handlers.\n *\n * @example\n * ```tsx\n * const { mutate: revokeSession } = useRevokeSession();\n * revokeSession();\n * ```\n */\nexport function useRevokeSession(options?: UseMutationOptions<void>) {\n  const sdk = useZamaSDK();\n\n  return useMutation<void>({\n    ...revokeSessionMutationOptions(sdk),\n    ...options,\n    onSuccess: (data, variables, onMutateResult, context) => {\n      options?.onSuccess?.(data, variables, onMutateResult, context);\n      void context.client.invalidateQueries({ queryKey: zamaQueryKeys.isAllowed.all });\n    },\n  });\n}\n","\"use client\";\n\nimport { useMemo } from \"react\";\nimport type { Address } from \"@zama-fhe/sdk\";\nimport { useZamaSDK } from \"../provider\";\n\n/** Base configuration shared by all mutation hooks that need a Token instance. */\nexport interface UseZamaConfig {\n  /** Address of the confidential token contract. */\n  tokenAddress: Address;\n  /** Address of the wrapper contract (required for shield/unshield operations). */\n  wrapperAddress?: Address;\n}\n\n/**\n * Get a {@link Token} instance, memoized by address pair.\n * Reads signer and storage from the nearest {@link ZamaProvider}.\n *\n * @param config - Token and optional wrapper addresses.\n * @returns A memoized `Token` instance.\n *\n * @example\n * ```tsx\n * const token = useToken({ tokenAddress: \"0xToken\", wrapperAddress: \"0xWrapper\" });\n * ```\n */\nexport function useToken(config: UseZamaConfig) {\n  const sdk = useZamaSDK();\n\n  return useMemo(\n    () => sdk.createToken(config.tokenAddress, config.wrapperAddress),\n    [sdk, config.tokenAddress, config.wrapperAddress],\n  );\n}\n","\"use client\";\n\nimport { useMemo } from \"react\";\nimport type { Address } from \"@zama-fhe/sdk\";\nimport { useZamaSDK } from \"../provider\";\n\n/**\n * Get a {@link ReadonlyToken} instance, memoized by address.\n * Supports balance queries, ERC-165 checks, and authorization — no wrapper needed.\n * Reads signer and storage from the nearest {@link ZamaProvider}.\n *\n * @param address - Address of the confidential token contract.\n * @returns A memoized `ReadonlyToken` instance.\n *\n * @example\n * ```tsx\n * const token = useReadonlyToken(\"0xToken\");\n * // token.balanceOf(), token.isConfidential(), etc.\n * ```\n */\nexport function useReadonlyToken(address: Address) {\n  const sdk = useZamaSDK();\n\n  return useMemo(() => sdk.createReadonlyToken(address), [sdk, address]);\n}\n","\"use client\";\n\nimport { useQuery } from \"../utils/query\";\nimport type { UseQueryOptions } from \"@tanstack/react-query\";\nimport type { Address, Handle } from \"@zama-fhe/sdk\";\nimport {\n  confidentialBalanceQueryOptions,\n  confidentialHandleQueryOptions,\n  signerAddressQueryOptions,\n} from \"@zama-fhe/sdk/query\";\nimport { useReadonlyToken } from \"../token/use-readonly-token\";\n\n/** Configuration for {@link useConfidentialBalance}. */\nexport interface UseConfidentialBalanceConfig {\n  /** Address of the confidential token contract. */\n  tokenAddress: Address;\n  /** Polling interval (ms) for the encrypted handle. Default: 10 000. */\n  handleRefetchInterval?: number;\n}\n\n/** Query options for the decrypt phase of {@link useConfidentialBalance}. */\nexport interface UseConfidentialBalanceOptions extends Omit<\n  UseQueryOptions<bigint>,\n  \"queryKey\" | \"queryFn\" | \"enabled\"\n> {\n  /** Whether the query is enabled. Callback form is not supported in composite hooks. */\n  enabled?: boolean;\n}\n\n/**\n * Declarative hook to read the connected wallet's confidential token balance.\n * Uses two-phase polling: cheaply polls the encrypted handle, then only\n * decrypts when the handle changes (new balance).\n *\n * @param config - Token address and optional polling interval.\n * @param options - React Query options forwarded to the decrypt query.\n * @returns The decrypt query result plus `handleQuery` for Phase 1 state.\n *\n * @example\n * ```tsx\n * const { data: balance, isLoading, handleQuery } = useConfidentialBalance({\n *   tokenAddress: \"0x...\",\n * });\n * ```\n */\nexport function useConfidentialBalance(\n  config: UseConfidentialBalanceConfig,\n  options?: UseConfidentialBalanceOptions,\n) {\n  const { tokenAddress, handleRefetchInterval } = config;\n  const { enabled = true } = options ?? {};\n  const token = useReadonlyToken(tokenAddress);\n\n  const addressQuery = useQuery<Address>({\n    ...signerAddressQueryOptions(token.signer),\n  });\n\n  const owner = addressQuery.data;\n\n  // Phase 1: Poll the encrypted handle (cheap RPC read, no signing)\n  const baseHandleQueryOptions = confidentialHandleQueryOptions(token.signer, tokenAddress, {\n    owner,\n    pollingInterval: handleRefetchInterval,\n  });\n  const handleQuery = useQuery<Handle>({\n    ...baseHandleQueryOptions,\n    enabled: baseHandleQueryOptions.enabled && enabled,\n  });\n\n  // Phase 2: Decrypt only when handle changes (expensive relayer roundtrip)\n  const handle = handleQuery.data;\n  const baseBalanceQueryOptions = confidentialBalanceQueryOptions(token, {\n    handle,\n    owner,\n  });\n  const balanceQuery = useQuery<bigint>({\n    ...baseBalanceQueryOptions,\n    ...options,\n    enabled: baseBalanceQueryOptions.enabled && enabled,\n  });\n\n  return { ...balanceQuery, handleQuery };\n}\n","\"use client\";\n\nimport { useMemo } from \"react\";\nimport { useQuery } from \"../utils/query\";\nimport type { UseQueryOptions } from \"@tanstack/react-query\";\nimport type { Address, Handle } from \"@zama-fhe/sdk\";\nimport {\n  confidentialBalancesQueryOptions,\n  confidentialHandlesQueryOptions,\n  signerAddressQueryOptions,\n  type ConfidentialBalancesData,\n} from \"@zama-fhe/sdk/query\";\nimport { useZamaSDK } from \"../provider\";\n\n/** Configuration for {@link useConfidentialBalances}. */\nexport interface UseConfidentialBalancesConfig {\n  /** Addresses of the confidential token contracts to batch-query. */\n  tokenAddresses: Address[];\n  /** Polling interval (ms) for the encrypted handles. Default: 10 000. */\n  handleRefetchInterval?: number;\n  /** Maximum number of concurrent decrypt calls. Default: `Infinity` (no limit). */\n  maxConcurrency?: number;\n}\n\nexport type { ConfidentialBalancesData };\n\n/** Query options for the decrypt phase of {@link useConfidentialBalances}. */\nexport interface UseConfidentialBalancesOptions extends Omit<\n  UseQueryOptions<ConfidentialBalancesData>,\n  \"queryKey\" | \"queryFn\" | \"enabled\"\n> {\n  /** Whether the query is enabled. Callback form is not supported in composite hooks. */\n  enabled?: boolean;\n}\n\n/**\n * Declarative hook to read multiple confidential token balances in batch.\n * Uses two-phase polling: cheaply polls encrypted handles, then only\n * decrypts when any handle changes.\n *\n * Returns partial results when some tokens fail — successful balances are\n * always returned alongside per-token error information.\n *\n * @param config - Token addresses and optional polling interval.\n * @param options - React Query options forwarded to the decrypt query.\n * @returns The decrypt query result plus `handlesQuery` for Phase 1 state.\n *\n * @example\n * ```tsx\n * const { data } = useConfidentialBalances({\n *   tokenAddresses: [\"0xTokenA\", \"0xTokenB\"],\n * });\n * const balance = data?.balances.get(\"0xTokenA\");\n * if (data?.isPartialError) {\n *   // some tokens failed — check data.errors\n * }\n * ```\n */\nexport function useConfidentialBalances(\n  config: UseConfidentialBalancesConfig,\n  options?: UseConfidentialBalancesOptions,\n) {\n  const { tokenAddresses, handleRefetchInterval, maxConcurrency } = config;\n  const { enabled = true } = options ?? {};\n  const sdk = useZamaSDK();\n\n  const addressQuery = useQuery<Address>({\n    ...signerAddressQueryOptions(sdk.signer),\n  });\n\n  const owner = addressQuery.data;\n\n  const tokens = useMemo(\n    () => tokenAddresses.map((addr) => sdk.createReadonlyToken(addr)),\n    [sdk, tokenAddresses],\n  );\n\n  // Phase 1: Poll all encrypted handles (cheap RPC reads)\n  const baseHandlesQueryOptions = confidentialHandlesQueryOptions(sdk.signer, tokenAddresses, {\n    owner,\n    pollingInterval: handleRefetchInterval,\n  });\n  const handlesQuery = useQuery<Handle[]>({\n    ...baseHandlesQueryOptions,\n    enabled: baseHandlesQueryOptions.enabled && enabled,\n  });\n\n  // Phase 2: Batch decrypt only when any handle changes\n  const handles = handlesQuery.data;\n  const handlesReady = Array.isArray(handles) && handles.length === tokenAddresses.length;\n  const baseBalancesQueryOptions = confidentialBalancesQueryOptions(tokens, {\n    owner,\n    handles,\n    maxConcurrency,\n    resultAddresses: tokenAddresses,\n  });\n  const factoryEnabled = baseBalancesQueryOptions.enabled ?? true;\n\n  const balancesQuery = useQuery<ConfidentialBalancesData>({\n    ...baseBalancesQueryOptions,\n    ...options,\n    enabled: factoryEnabled && handlesReady && enabled,\n  });\n\n  return { ...balancesQuery, handlesQuery };\n}\n","import type { QueryClient, QueryKey, UseMutationOptions } from \"@tanstack/react-query\";\nimport type { Address, TransactionResult } from \"@zama-fhe/sdk\";\nimport { invalidateAfterShield, zamaQueryKeys } from \"@zama-fhe/sdk/query\";\n\ntype BalanceDeltaMode = \"add\" | \"subtract\";\nexport type OptimisticBalanceSnapshot = [QueryKey, bigint | undefined][];\n\n/** Combined context returned by optimistic `onMutate`. */\nexport interface OptimisticMutateContext {\n  snapshot: OptimisticBalanceSnapshot;\n  callerContext?: unknown;\n}\n\nexport function unwrapOptimisticCallerContext(\n  optimistic: boolean | undefined,\n  rawContext: unknown,\n): {\n  wrappedContext: OptimisticMutateContext | undefined;\n  callerContext: OptimisticMutateContext | undefined;\n} {\n  const typed = rawContext as OptimisticMutateContext | undefined;\n  const wrappedContext = optimistic ? typed : undefined;\n  const callerContext = (optimistic ? wrappedContext?.callerContext : rawContext) as\n    | OptimisticMutateContext\n    | undefined;\n  return { wrappedContext, callerContext };\n}\n\nexport async function applyOptimisticBalanceDelta({\n  queryClient,\n  tokenAddress,\n  amount,\n  mode,\n}: {\n  queryClient: QueryClient;\n  tokenAddress: Address;\n  amount: bigint;\n  mode: BalanceDeltaMode;\n}): Promise<OptimisticBalanceSnapshot> {\n  const balanceKey = zamaQueryKeys.confidentialBalance.token(tokenAddress);\n  await queryClient.cancelQueries({ queryKey: balanceKey });\n  const previous = queryClient.getQueriesData<bigint>({ queryKey: balanceKey });\n  for (const [key, value] of previous) {\n    if (value === undefined) {\n      continue;\n    }\n    // Temporary optimistic underflow (`amount > value`) is acceptable because\n    // settlement invalidates and rewrites this cache entry.\n    queryClient.setQueryData(key, mode === \"add\" ? value + amount : value - amount);\n  }\n  return previous;\n}\n\nexport function rollbackOptimisticBalanceDelta(\n  queryClient: QueryClient,\n  snapshot: OptimisticBalanceSnapshot,\n) {\n  for (const [key, value] of snapshot) {\n    queryClient.setQueryData(key, value);\n  }\n}\n\n/**\n * Build optimistic mutation callbacks for shield operations.\n * Wraps the caller's `onMutate`/`onError`/`onSuccess`/`onSettled` with snapshot/rollback logic\n * and returns overrides ready to spread into `useMutation`.\n */\nexport function optimisticBalanceCallbacks<TParams extends { amount: bigint }>({\n  optimistic,\n  tokenAddress,\n  queryClient,\n  options,\n}: {\n  optimistic: boolean | undefined;\n  tokenAddress: Address;\n  queryClient: QueryClient;\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  options: UseMutationOptions<TransactionResult, Error, TParams, any> | undefined;\n}): Pick<\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  UseMutationOptions<TransactionResult, Error, TParams, any>,\n  \"onMutate\" | \"onError\" | \"onSuccess\" | \"onSettled\"\n> {\n  return {\n    onMutate: optimistic\n      ? async (variables, mutationContext) => {\n          const snapshot = await applyOptimisticBalanceDelta({\n            queryClient,\n            tokenAddress,\n            amount: variables.amount,\n            mode: \"add\",\n          });\n          const callerContext = await options?.onMutate?.(variables, mutationContext);\n          return { snapshot, callerContext };\n        }\n      : options?.onMutate,\n    onError: (error, variables, rawContext, context) => {\n      const { wrappedContext, callerContext } = unwrapOptimisticCallerContext(\n        optimistic,\n        rawContext,\n      );\n      try {\n        if (wrappedContext) {\n          rollbackOptimisticBalanceDelta(queryClient, wrappedContext.snapshot);\n        }\n      } finally {\n        options?.onError?.(error, variables, callerContext, context);\n      }\n    },\n    onSuccess: (data, variables, rawContext, context) => {\n      const { callerContext } = unwrapOptimisticCallerContext(optimistic, rawContext);\n      options?.onSuccess?.(data, variables, callerContext, context);\n      invalidateAfterShield(context.client, tokenAddress);\n    },\n    onSettled: (data, error, variables, rawContext, context) => {\n      const { callerContext } = unwrapOptimisticCallerContext(optimistic, rawContext);\n      options?.onSettled?.(data, error, variables, callerContext, context);\n    },\n  };\n}\n","\"use client\";\n\nimport {\n  useMutation,\n  useQueryClient,\n  type UseMutationOptions,\n  type UseMutationResult,\n} from \"@tanstack/react-query\";\nimport type { TransactionResult } from \"@zama-fhe/sdk\";\nimport {\n  confidentialTransferMutationOptions,\n  invalidateAfterTransfer,\n  type ConfidentialTransferParams,\n} from \"@zama-fhe/sdk/query\";\nimport {\n  applyOptimisticBalanceDelta,\n  rollbackOptimisticBalanceDelta,\n  unwrapOptimisticCallerContext,\n} from \"../balance/optimistic-balance-update\";\nimport { useToken, type UseZamaConfig } from \"../token/use-token\";\n\n/** Configuration for {@link useConfidentialTransfer}. */\nexport interface UseConfidentialTransferConfig extends UseZamaConfig {\n  /**\n   * When `true`, optimistically subtracts the transfer amount from cached balance\n   * before the transaction confirms. Rolls back on error.\n   * @defaultValue false\n   */\n  optimistic?: boolean;\n}\n\n/**\n * Encrypt and send a confidential transfer. Invalidates balance caches on success.\n *\n * Errors are {@link ZamaError} subclasses — use `instanceof` to handle specific failures:\n * - {@link SigningRejectedError} — user rejected the wallet prompt\n * - {@link EncryptionFailedError} — FHE encryption failed\n * - {@link TransactionRevertedError} — on-chain transaction reverted\n *\n * @param config - Token address (and optional wrapper) identifying the token.\n *   Set `optimistic: true` to subtract the amount from the cached balance immediately.\n * @param options - React Query mutation options.\n *\n * @example\n * ```tsx\n * const transfer = useConfidentialTransfer({\n *   tokenAddress: \"0x...\",\n *   optimistic: true,\n * });\n * transfer.mutate(\n *   { to: \"0xRecipient\", amount: 1000n },\n *   {\n *     onError: (error) => {\n *       if (error instanceof SigningRejectedError) {\n *         // user cancelled — no action needed\n *       }\n *     },\n *   },\n * );\n * ```\n */\nexport function useConfidentialTransfer<TContext = unknown>(\n  config: UseConfidentialTransferConfig,\n  options?: UseMutationOptions<TransactionResult, Error, ConfidentialTransferParams, TContext>,\n): UseMutationResult<TransactionResult, Error, ConfidentialTransferParams, TContext> {\n  const token = useToken(config);\n  const queryClient = useQueryClient();\n\n  // Internal mutation uses `any` for TContext because optimistic mode wraps\n  // the caller's context in OptimisticMutateContext; the public return type\n  // is cast back to the caller's TContext.\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  return useMutation<TransactionResult, Error, ConfidentialTransferParams, any>({\n    ...confidentialTransferMutationOptions(token),\n    ...options,\n    onMutate: config.optimistic\n      ? async (variables, mutationContext) => {\n          const snapshot = await applyOptimisticBalanceDelta({\n            queryClient,\n            tokenAddress: config.tokenAddress,\n            amount: variables.amount,\n            mode: \"subtract\",\n          });\n          const callerContext = await options?.onMutate?.(variables, mutationContext);\n          return { snapshot, callerContext };\n        }\n      : options?.onMutate,\n    onError: (error, variables, rawContext, context) => {\n      const { wrappedContext, callerContext } = unwrapOptimisticCallerContext(\n        config.optimistic,\n        rawContext,\n      );\n      try {\n        if (wrappedContext) {\n          rollbackOptimisticBalanceDelta(queryClient, wrappedContext.snapshot);\n        }\n      } finally {\n        options?.onError?.(error, variables, callerContext as TContext, context);\n      }\n    },\n    onSuccess: (data, variables, rawContext, context) => {\n      const { callerContext } = unwrapOptimisticCallerContext(config.optimistic, rawContext);\n      options?.onSuccess?.(data, variables, callerContext as TContext, context);\n      invalidateAfterTransfer(context.client, config.tokenAddress);\n    },\n    onSettled: (data, error, variables, rawContext, context) => {\n      const { callerContext } = unwrapOptimisticCallerContext(config.optimistic, rawContext);\n      options?.onSettled?.(data, error, variables, callerContext as TContext, context);\n    },\n  }) as UseMutationResult<TransactionResult, Error, ConfidentialTransferParams, TContext>;\n}\n","\"use client\";\n\nimport type { UseMutationOptions } from \"@tanstack/react-query\";\nimport { useMutation } from \"@tanstack/react-query\";\nimport type { Address, TransactionResult } from \"@zama-fhe/sdk\";\nimport {\n  confidentialTransferFromMutationOptions,\n  invalidateAfterTransfer,\n  type ConfidentialTransferFromParams,\n} from \"@zama-fhe/sdk/query\";\nimport { useToken, type UseZamaConfig } from \"../token/use-token\";\n\n/**\n * Operator transfer on behalf of another address. Caller must be an approved operator.\n * Invalidates balance caches on success.\n *\n * Errors are {@link ZamaError} subclasses — use `instanceof` to handle specific failures:\n * - {@link SigningRejectedError} — user rejected the wallet prompt\n * - {@link EncryptionFailedError} — FHE encryption of the transfer amount failed\n * - {@link TransactionRevertedError} — on-chain transaction reverted\n *\n * @param config - Token address (and optional wrapper) identifying the token.\n * @param options - React Query mutation options.\n *\n * @example\n * ```tsx\n * const transferFrom = useConfidentialTransferFrom({ tokenAddress: \"0x...\" });\n * transferFrom.mutate({ from: \"0xOwner\", to: \"0xRecipient\", amount: 500n });\n * ```\n */\nexport function useConfidentialTransferFrom(\n  config: UseZamaConfig,\n  options?: UseMutationOptions<TransactionResult, Error, ConfidentialTransferFromParams, Address>,\n) {\n  const token = useToken(config);\n\n  return useMutation<TransactionResult, Error, ConfidentialTransferFromParams, Address>({\n    ...confidentialTransferFromMutationOptions(token),\n    ...options,\n    onSuccess: (data, variables, onMutateResult, context) => {\n      options?.onSuccess?.(data, variables, onMutateResult, context);\n      invalidateAfterTransfer(context.client, config.tokenAddress);\n    },\n  });\n}\n","\"use client\";\n\nimport type { UseMutationOptions } from \"@tanstack/react-query\";\nimport { useMutation } from \"@tanstack/react-query\";\nimport type { Address, TransactionResult } from \"@zama-fhe/sdk\";\nimport {\n  confidentialApproveMutationOptions,\n  invalidateAfterApprove,\n  type ConfidentialApproveParams,\n} from \"@zama-fhe/sdk/query\";\nimport { useToken, type UseZamaConfig } from \"../token/use-token\";\n\n/**\n * Set operator approval for a confidential token. Defaults to 1 hour.\n *\n * Errors are {@link ZamaError} subclasses — use `instanceof` to handle specific failures:\n * - {@link SigningRejectedError} — user rejected the wallet prompt\n * - {@link TransactionRevertedError} — on-chain transaction reverted\n *\n * @param config - Token address (and optional wrapper) identifying the token.\n * @param options - React Query mutation options.\n *\n * @example\n * ```tsx\n * const approve = useConfidentialApprove({ tokenAddress: \"0x...\" });\n * approve.mutate({ spender: \"0xOperator\" });\n * ```\n */\nexport function useConfidentialApprove(\n  config: UseZamaConfig,\n  options?: UseMutationOptions<TransactionResult, Error, ConfidentialApproveParams, Address>,\n) {\n  const token = useToken(config);\n\n  return useMutation<TransactionResult, Error, ConfidentialApproveParams, Address>({\n    ...confidentialApproveMutationOptions(token),\n    ...options,\n    onSuccess: (data, variables, onMutateResult, context) => {\n      options?.onSuccess?.(data, variables, onMutateResult, context);\n      invalidateAfterApprove(context.client, config.tokenAddress);\n    },\n  });\n}\n","\"use client\";\n\nimport { useQuery, useSuspenseQuery } from \"../utils/query\";\nimport type { UseQueryOptions } from \"@tanstack/react-query\";\nimport type { Address } from \"@zama-fhe/sdk\";\nimport { confidentialIsApprovedQueryOptions, signerAddressQueryOptions } from \"@zama-fhe/sdk/query\";\nimport { useZamaSDK } from \"../provider\";\nimport { useToken, type UseZamaConfig } from \"../token/use-token\";\n\nexport { confidentialIsApprovedQueryOptions };\n\n/** Configuration for {@link useConfidentialIsApproved}. */\nexport interface UseConfidentialIsApprovedConfig {\n  /** Address of the confidential token contract. Pass `undefined` to disable the query. */\n  tokenAddress: Address | undefined;\n  /** Address to check approval for. Pass `undefined` to disable the query. */\n  spender: Address | undefined;\n  /** Token holder address. Defaults to the connected wallet. */\n  holder?: Address;\n}\n\n/** Configuration for {@link useConfidentialIsApprovedSuspense}. */\nexport interface UseConfidentialIsApprovedSuspenseConfig extends UseZamaConfig {\n  /** Address to check approval for. */\n  spender: Address;\n  /** Token holder address. Defaults to the connected wallet. */\n  holder?: Address;\n}\n\n/**\n * Check if a spender is an approved operator for a given holder (defaults to connected wallet).\n *\n * @param config - Token address, spender, and optional holder to check.\n * @param options - React Query options (forwarded to `useQuery`).\n * @returns Query result with `data: boolean`.\n *\n * @example\n * ```tsx\n * const { data: isApproved } = useConfidentialIsApproved({\n *   tokenAddress: \"0xToken\",\n *   spender: \"0xSpender\",\n *   holder: \"0xHolder\", // optional\n * });\n * ```\n */\nexport function useConfidentialIsApproved(\n  config: UseConfidentialIsApprovedConfig,\n  options?: Omit<UseQueryOptions<boolean>, \"queryKey\" | \"queryFn\">,\n) {\n  const { tokenAddress, spender, holder } = config;\n  const sdk = useZamaSDK();\n  const holderQuery = useQuery<Address>({\n    ...signerAddressQueryOptions(sdk.signer),\n    enabled: tokenAddress !== undefined && spender !== undefined && holder === undefined,\n  });\n  const resolvedHolder = holder ?? holderQuery.data;\n  const baseOpts = confidentialIsApprovedQueryOptions(sdk.signer, tokenAddress, {\n    holder: resolvedHolder,\n    spender,\n  });\n  return useQuery({\n    ...baseOpts,\n    ...options,\n    enabled: (baseOpts.enabled ?? true) && (options?.enabled ?? true),\n  });\n}\n\n/**\n * Suspense variant of {@link useConfidentialIsApproved}.\n * Suspends rendering until the approval check resolves.\n *\n * @param config - Token address, spender, and optional holder to check.\n * @returns Suspense query result with `data: boolean`.\n *\n * @example\n * ```tsx\n * const { data: isApproved } = useConfidentialIsApprovedSuspense({\n *   tokenAddress: \"0xToken\",\n *   spender: \"0xSpender\",\n *   holder: \"0xHolder\", // optional\n * });\n * ```\n */\nexport function useConfidentialIsApprovedSuspense(config: UseConfidentialIsApprovedSuspenseConfig) {\n  const { spender, holder, ...tokenConfig } = config;\n  const token = useToken(tokenConfig);\n  const addressQuery = useSuspenseQuery<Address>({\n    ...signerAddressQueryOptions(token.signer),\n  });\n  const resolvedHolder = holder ?? addressQuery.data;\n\n  return useSuspenseQuery<boolean>({\n    ...confidentialIsApprovedQueryOptions(token.signer, token.address, {\n      holder: resolvedHolder,\n      spender,\n    }),\n  });\n}\n","\"use client\";\n\nimport {\n  useMutation,\n  useQueryClient,\n  type UseMutationOptions,\n  type UseMutationResult,\n} from \"@tanstack/react-query\";\nimport type { TransactionResult } from \"@zama-fhe/sdk\";\nimport { shieldMutationOptions, type ShieldParams } from \"@zama-fhe/sdk/query\";\nimport { optimisticBalanceCallbacks } from \"../balance/optimistic-balance-update\";\nimport { useToken, type UseZamaConfig } from \"../token/use-token\";\n\n/** Configuration for {@link useShield}. */\nexport interface UseShieldConfig extends UseZamaConfig {\n  /**\n   * When `true`, optimistically adds the wrap amount to the cached confidential balance\n   * before the transaction confirms. Rolls back on error.\n   * @defaultValue false\n   */\n  optimistic?: boolean;\n}\n\n/**\n * Shield public ERC-20 tokens into confidential tokens.\n * Handles ERC-20 approval automatically. Invalidates balance caches on success.\n *\n * Errors are {@link ZamaError} subclasses — use `instanceof` to handle specific failures:\n * - {@link SigningRejectedError} — user rejected the wallet prompt\n * - {@link ApprovalFailedError} — ERC-20 approval transaction failed\n * - {@link TransactionRevertedError} — shield transaction reverted\n *\n * @param config - Token and wrapper addresses.\n *   Set `optimistic: true` to add the amount to the cached balance immediately.\n * @param options - React Query mutation options.\n *\n * @example\n * ```tsx\n * const shield = useShield({ tokenAddress: \"0x...\", wrapperAddress: \"0x...\", optimistic: true });\n * shield.mutate({ amount: 1000n });\n * ```\n */\nexport function useShield<TContext = unknown>(\n  config: UseShieldConfig,\n  options?: UseMutationOptions<TransactionResult, Error, ShieldParams, TContext>,\n): UseMutationResult<TransactionResult, Error, ShieldParams, TContext> {\n  const token = useToken(config);\n  const queryClient = useQueryClient();\n\n  return useMutation({\n    ...shieldMutationOptions(token),\n    ...options,\n    ...optimisticBalanceCallbacks({\n      optimistic: config.optimistic,\n      tokenAddress: config.tokenAddress,\n      queryClient,\n      options,\n    }),\n  }) as UseMutationResult<TransactionResult, Error, ShieldParams, TContext>;\n}\n","\"use client\";\n\nimport {\n  useMutation,\n  useQueryClient,\n  type UseMutationOptions,\n  type UseMutationResult,\n} from \"@tanstack/react-query\";\nimport type { TransactionResult } from \"@zama-fhe/sdk\";\nimport { shieldETHMutationOptions, type ShieldETHParams } from \"@zama-fhe/sdk/query\";\nimport { optimisticBalanceCallbacks } from \"../balance/optimistic-balance-update\";\nimport { useToken, type UseZamaConfig } from \"../token/use-token\";\n\n/** Configuration for {@link useShieldETH}. */\nexport interface UseShieldETHConfig extends UseZamaConfig {\n  /**\n   * When `true`, optimistically adds the wrap amount to the cached confidential balance\n   * before the transaction confirms. Rolls back on error.\n   * @defaultValue false\n   */\n  optimistic?: boolean;\n}\n\n/**\n * Shield native ETH into confidential tokens.\n * Handles wrapping automatically. Invalidates balance caches on success.\n *\n * Errors are {@link ZamaError} subclasses — use `instanceof` to handle specific failures:\n * - {@link SigningRejectedError} — user rejected the wallet prompt\n * - {@link TransactionRevertedError} — shield transaction reverted\n *\n * @param config - Token and wrapper addresses.\n *   Set `optimistic: true` to add the amount to the cached balance immediately.\n * @param options - React Query mutation options.\n *\n * @example\n * ```tsx\n * const shieldETH = useShieldETH({ tokenAddress: \"0x...\", wrapperAddress: \"0x...\", optimistic: true });\n * shieldETH.mutate({ amount: 1000000000000000000n }); // 1 ETH\n * ```\n */\nexport function useShieldETH<TContext = unknown>(\n  config: UseShieldETHConfig,\n  options?: UseMutationOptions<TransactionResult, Error, ShieldETHParams, TContext>,\n): UseMutationResult<TransactionResult, Error, ShieldETHParams, TContext> {\n  const token = useToken(config);\n  const queryClient = useQueryClient();\n\n  return useMutation({\n    ...shieldETHMutationOptions(token),\n    ...options,\n    ...optimisticBalanceCallbacks({\n      optimistic: config.optimistic,\n      tokenAddress: config.tokenAddress,\n      queryClient,\n      options,\n    }),\n  }) as UseMutationResult<TransactionResult, Error, ShieldETHParams, TContext>;\n}\n","\"use client\";\n\nimport type { UseMutationOptions } from \"@tanstack/react-query\";\nimport { useMutation } from \"@tanstack/react-query\";\nimport type { Address, TransactionResult } from \"@zama-fhe/sdk\";\nimport {\n  invalidateAfterUnwrap,\n  type UnwrapParams,\n  unwrapMutationOptions,\n} from \"@zama-fhe/sdk/query\";\nimport { useToken, type UseZamaConfig } from \"../token/use-token\";\n\n/**\n * Request an unwrap for a specific amount. Encrypts the amount first.\n * Call {@link useFinalizeUnwrap} after the request is processed on-chain,\n * or use {@link useUnshield} for a single-call orchestration.\n *\n * Errors are {@link ZamaError} subclasses — use `instanceof` to handle specific failures:\n * - {@link SigningRejectedError} — user rejected the wallet prompt\n * - {@link EncryptionFailedError} — FHE encryption of the unwrap amount failed\n * - {@link TransactionRevertedError} — on-chain transaction reverted\n *\n * @param config - Token address (and optional wrapper) identifying the token.\n * @param options - React Query mutation options.\n *\n * @example\n * ```tsx\n * const unwrap = useUnwrap({ tokenAddress: \"0x...\" });\n * unwrap.mutate({ amount: 500n });\n * ```\n */\nexport function useUnwrap(\n  config: UseZamaConfig,\n  options?: UseMutationOptions<TransactionResult, Error, UnwrapParams, Address>,\n) {\n  const token = useToken(config);\n\n  return useMutation<TransactionResult, Error, UnwrapParams, Address>({\n    ...unwrapMutationOptions(token),\n    ...options,\n    onSuccess: (data, variables, onMutateResult, context) => {\n      options?.onSuccess?.(data, variables, onMutateResult, context);\n      invalidateAfterUnwrap(context.client, config.tokenAddress);\n    },\n  });\n}\n","\"use client\";\n\nimport type { UseMutationOptions } from \"@tanstack/react-query\";\nimport { useMutation } from \"@tanstack/react-query\";\nimport type { Address, TransactionResult } from \"@zama-fhe/sdk\";\nimport { invalidateAfterUnwrap, unwrapAllMutationOptions } from \"@zama-fhe/sdk/query\";\nimport { useToken, type UseZamaConfig } from \"../token/use-token\";\n\n/**\n * Request an unwrap for the entire confidential balance.\n * Uses the on-chain balance handle directly (no encryption needed).\n * Call {@link useFinalizeUnwrap} after processing, or use {@link useUnshieldAll} for single-call orchestration.\n *\n * Errors are {@link ZamaError} subclasses — use `instanceof` to handle specific failures:\n * - {@link SigningRejectedError} — user rejected the wallet prompt\n * - {@link TransactionRevertedError} — on-chain transaction reverted\n *\n * @param config - Token address (and optional wrapper) identifying the token.\n * @param options - React Query mutation options.\n *\n * @example\n * ```tsx\n * const unwrapAll = useUnwrapAll({ tokenAddress: \"0x...\" });\n * unwrapAll.mutate();\n * ```\n */\nexport function useUnwrapAll(\n  config: UseZamaConfig,\n  options?: UseMutationOptions<TransactionResult, Error, void, Address>,\n) {\n  const token = useToken(config);\n\n  return useMutation<TransactionResult, Error, void, Address>({\n    ...unwrapAllMutationOptions(token),\n    ...options,\n    onSuccess: (data, variables, onMutateResult, context) => {\n      options?.onSuccess?.(data, variables, onMutateResult, context);\n      invalidateAfterUnwrap(context.client, config.tokenAddress);\n    },\n  });\n}\n","\"use client\";\n\nimport type { UseMutationOptions } from \"@tanstack/react-query\";\nimport { useMutation } from \"@tanstack/react-query\";\nimport type { Address, TransactionResult } from \"@zama-fhe/sdk\";\nimport {\n  finalizeUnwrapMutationOptions,\n  invalidateAfterUnshield,\n  type FinalizeUnwrapParams,\n} from \"@zama-fhe/sdk/query\";\nimport { useToken, type UseZamaConfig } from \"../token/use-token\";\n\n/**\n * Complete an unwrap by providing the public decryption proof.\n * Call this after an unwrap request has been processed on-chain.\n *\n * Errors are {@link ZamaError} subclasses — use `instanceof` to handle specific failures:\n * - {@link SigningRejectedError} — user rejected the wallet prompt\n * - {@link DecryptionFailedError} — public decryption of the burn amount failed\n * - {@link TransactionRevertedError} — on-chain finalize transaction reverted\n *\n * @param config - Token address (and optional wrapper) identifying the token.\n * @param options - React Query mutation options.\n *\n * @example\n * ```tsx\n * const finalize = useFinalizeUnwrap({ tokenAddress: \"0x...\" });\n * finalize.mutate({ burnAmountHandle: event.encryptedAmount });\n * ```\n */\nexport function useFinalizeUnwrap(\n  config: UseZamaConfig,\n  options?: UseMutationOptions<TransactionResult, Error, FinalizeUnwrapParams, Address>,\n) {\n  const token = useToken(config);\n\n  return useMutation<TransactionResult, Error, FinalizeUnwrapParams, Address>({\n    ...finalizeUnwrapMutationOptions(token),\n    ...options,\n    onSuccess: (data, variables, onMutateResult, context) => {\n      options?.onSuccess?.(data, variables, onMutateResult, context);\n      invalidateAfterUnshield(context.client, config.tokenAddress);\n    },\n  });\n}\n","\"use client\";\n\nimport type { UseMutationOptions } from \"@tanstack/react-query\";\nimport { useMutation } from \"@tanstack/react-query\";\nimport type { Address, TransactionResult } from \"@zama-fhe/sdk\";\nimport {\n  invalidateAfterUnshield,\n  type UnshieldParams,\n  unshieldMutationOptions,\n} from \"@zama-fhe/sdk/query\";\nimport { useToken, type UseZamaConfig } from \"../token/use-token\";\n\n/**\n * Unshield a specific amount and finalize in one call.\n * Orchestrates: unwrap → wait for receipt → parse event → finalize.\n *\n * Errors are {@link ZamaError} subclasses — use `instanceof` to handle specific failures:\n * - {@link SigningRejectedError} — user rejected the wallet prompt\n * - {@link EncryptionFailedError} — FHE encryption failed during unwrap\n * - {@link DecryptionFailedError} — public decryption failed during finalize\n * - {@link TransactionRevertedError} — on-chain transaction reverted\n *\n * @param config - Token and wrapper addresses.\n * @param options - React Query mutation options.\n *\n * @example\n * ```tsx\n * const unshield = useUnshield({ tokenAddress: \"0x...\", wrapperAddress: \"0x...\" });\n * unshield.mutate({ amount: 500n });\n * ```\n */\nexport function useUnshield(\n  config: UseZamaConfig,\n  options?: UseMutationOptions<TransactionResult, Error, UnshieldParams, Address>,\n) {\n  const token = useToken(config);\n\n  return useMutation<TransactionResult, Error, UnshieldParams, Address>({\n    ...unshieldMutationOptions(token),\n    ...options,\n    onSuccess: (data, variables, onMutateResult, context) => {\n      options?.onSuccess?.(data, variables, onMutateResult, context);\n      invalidateAfterUnshield(context.client, config.tokenAddress);\n    },\n  });\n}\n","\"use client\";\n\nimport type { UseMutationOptions } from \"@tanstack/react-query\";\nimport { useMutation } from \"@tanstack/react-query\";\nimport type { Address, TransactionResult } from \"@zama-fhe/sdk\";\nimport {\n  invalidateAfterUnshield,\n  type UnshieldAllParams,\n  unshieldAllMutationOptions,\n} from \"@zama-fhe/sdk/query\";\nimport { useToken, type UseZamaConfig } from \"../token/use-token\";\n\n/**\n * Unshield the entire balance and finalize in one call.\n * Orchestrates: unwrapAll → wait for receipt → parse event → finalize.\n *\n * Errors are {@link ZamaError} subclasses — use `instanceof` to handle specific failures:\n * - {@link SigningRejectedError} — user rejected the wallet prompt\n * - {@link DecryptionFailedError} — public decryption failed during finalize\n * - {@link TransactionRevertedError} — on-chain transaction reverted\n *\n * @param config - Token and wrapper addresses.\n * @param options - React Query mutation options.\n *\n * @example\n * ```tsx\n * const unshieldAll = useUnshieldAll({ tokenAddress: \"0x...\", wrapperAddress: \"0x...\" });\n * unshieldAll.mutate();\n * ```\n */\nexport function useUnshieldAll(\n  config: UseZamaConfig,\n  options?: UseMutationOptions<TransactionResult, Error, UnshieldAllParams | void, Address>,\n) {\n  const token = useToken(config);\n\n  return useMutation<TransactionResult, Error, UnshieldAllParams | void, Address>({\n    ...unshieldAllMutationOptions(token),\n    ...options,\n    onSuccess: (data, variables, onMutateResult, context) => {\n      options?.onSuccess?.(data, variables, onMutateResult, context);\n      invalidateAfterUnshield(context.client, config.tokenAddress);\n    },\n  });\n}\n","\"use client\";\n\nimport type { UseMutationOptions } from \"@tanstack/react-query\";\nimport { useMutation } from \"@tanstack/react-query\";\nimport type { Address, TransactionResult } from \"@zama-fhe/sdk\";\nimport {\n  invalidateAfterUnshield,\n  type ResumeUnshieldParams,\n  resumeUnshieldMutationOptions,\n} from \"@zama-fhe/sdk/query\";\nimport { useToken, type UseZamaConfig } from \"../token/use-token\";\n\n/**\n * Resume an interrupted unshield from an existing unwrap tx hash.\n * Useful when the user submitted the unwrap but the finalize step was\n * interrupted (e.g. page reload, network error).\n *\n * Errors are {@link ZamaError} subclasses — use `instanceof` to handle specific failures:\n * - {@link DecryptionFailedError} — public decryption failed during finalize\n * - {@link TransactionRevertedError} — on-chain transaction reverted\n *\n * @param config - Token and wrapper addresses.\n * @param options - React Query mutation options.\n *\n * @example\n * ```tsx\n * const resumeUnshield = useResumeUnshield({ tokenAddress: \"0x...\", wrapperAddress: \"0x...\" });\n * resumeUnshield.mutate({ unwrapTxHash: \"0xabc...\" });\n * ```\n */\nexport function useResumeUnshield(\n  config: UseZamaConfig,\n  options?: UseMutationOptions<TransactionResult, Error, ResumeUnshieldParams, Address>,\n) {\n  const token = useToken(config);\n\n  return useMutation<TransactionResult, Error, ResumeUnshieldParams, Address>({\n    ...resumeUnshieldMutationOptions(token),\n    ...options,\n    onSuccess: (data, variables, onMutateResult, context) => {\n      options?.onSuccess?.(data, variables, onMutateResult, context);\n      invalidateAfterUnshield(context.client, config.tokenAddress);\n    },\n  });\n}\n","\"use client\";\n\nimport { useQuery, useSuspenseQuery } from \"../utils/query\";\nimport type { UseQueryOptions } from \"@tanstack/react-query\";\nimport type { Address } from \"@zama-fhe/sdk\";\nimport { signerAddressQueryOptions, underlyingAllowanceQueryOptions } from \"@zama-fhe/sdk/query\";\nimport { useReadonlyToken } from \"../token/use-readonly-token\";\n\nexport { underlyingAllowanceQueryOptions };\n\n/** Configuration for {@link useUnderlyingAllowance}. */\nexport interface UseUnderlyingAllowanceConfig {\n  /** Address of the confidential token contract used to scope the query cache. */\n  tokenAddress: Address;\n  /** Address of the wrapper contract whose underlying ERC-20 allowance is checked. */\n  wrapperAddress: Address;\n}\n\n/**\n * Read the underlying ERC-20 allowance granted to the wrapper contract.\n * Useful to check if an approval is needed before shielding.\n *\n * @param config - Token and wrapper addresses.\n * @param options - React Query options (forwarded to `useQuery`).\n * @returns Query result with `data: bigint` (current allowance).\n *\n * @example\n * ```tsx\n * const { data: allowance } = useUnderlyingAllowance({\n *   tokenAddress: \"0xConfidentialToken\",\n *   wrapperAddress: \"0xWrapper\",\n * });\n * ```\n */\nexport function useUnderlyingAllowance(\n  config: UseUnderlyingAllowanceConfig,\n  options?: Omit<UseQueryOptions<bigint>, \"queryKey\" | \"queryFn\">,\n) {\n  const { tokenAddress, wrapperAddress } = config;\n  const token = useReadonlyToken(tokenAddress);\n  const addressQuery = useQuery<Address>({\n    ...signerAddressQueryOptions(token.signer),\n  });\n  const owner = addressQuery.data;\n\n  const baseOpts = underlyingAllowanceQueryOptions(token.signer, tokenAddress, {\n    owner,\n    wrapperAddress,\n  });\n\n  return useQuery<bigint>({\n    ...baseOpts,\n    ...options,\n    enabled: (baseOpts.enabled ?? true) && (options?.enabled ?? true),\n  });\n}\n\n/**\n * Suspense variant of {@link useUnderlyingAllowance}.\n * Suspends rendering until the allowance is loaded.\n *\n * @param config - Token and wrapper addresses.\n * @returns Suspense query result with `data: bigint`.\n *\n * @example\n * ```tsx\n * const { data: allowance } = useUnderlyingAllowanceSuspense({\n *   tokenAddress: \"0xConfidentialToken\",\n *   wrapperAddress: \"0xWrapper\",\n * });\n * ```\n */\nexport function useUnderlyingAllowanceSuspense(config: UseUnderlyingAllowanceConfig) {\n  const { tokenAddress, wrapperAddress } = config;\n  const token = useReadonlyToken(tokenAddress);\n  const addressQuery = useSuspenseQuery<Address>({\n    ...signerAddressQueryOptions(token.signer),\n  });\n  const owner = addressQuery.data;\n\n  return useSuspenseQuery<bigint>({\n    ...underlyingAllowanceQueryOptions(token.signer, tokenAddress, {\n      owner,\n      wrapperAddress,\n    }),\n  });\n}\n","\"use client\";\n\nimport type { Address } from \"@zama-fhe/sdk\";\nimport { zamaQueryKeys } from \"@zama-fhe/sdk/query\";\nimport { useZamaSDK } from \"../provider\";\nimport { useQuery } from \"../utils/query\";\n\n/**\n * Resolves the wrappers registry address for the current chain.\n * Uses the merged registry addresses from `sdk.registry` (built-in defaults\n * plus any `registryAddresses` overrides passed to `ZamaSDKConfig`).\n *\n * Returns `undefined` when the chain ID hasn't been fetched yet\n * or when no registry is configured for the connected chain.\n *\n * The chain ID is cached for 30 seconds (`staleTime`), so chain\n * switches may take up to 30s to reflect.\n */\nexport function useWrappersRegistryAddress(): Address | undefined {\n  const sdk = useZamaSDK();\n\n  const { data: chainId } = useQuery<number>({\n    queryKey: zamaQueryKeys.wrappersRegistry.chainId(),\n    queryFn: () => sdk.signer.getChainId(),\n    staleTime: 30_000,\n  });\n\n  return chainId !== undefined ? sdk.registry.getAddress(chainId) : undefined;\n}\n","\"use client\";\n\nimport type { UseQueryOptions } from \"@tanstack/react-query\";\nimport type { Address } from \"@zama-fhe/sdk\";\nimport { wrapperDiscoveryQueryOptions } from \"@zama-fhe/sdk/query\";\nimport { useZamaSDK } from \"../provider\";\nimport { useQuery, useSuspenseQuery } from \"../utils/query\";\nimport { useWrappersRegistryAddress } from \"../wrappers-registry/use-wrappers-registry-address\";\n\nexport { wrapperDiscoveryQueryOptions };\n\n/** Configuration for {@link useWrapperDiscovery}. */\nexport interface UseWrapperDiscoveryConfig {\n  /**\n   * Address of any confidential token you control.\n   * Used only to derive the signer context and to scope the query cache key —\n   * it does not affect which wrapper the registry returns.\n   */\n  tokenAddress: Address;\n  /** ERC-20 address to discover the wrapper for. Pass `undefined` to disable the query. */\n  erc20Address: Address | undefined;\n}\n\n/** Configuration for {@link useWrapperDiscoverySuspense}. */\nexport interface UseWrapperDiscoverySuspenseConfig {\n  /**\n   * Address of any confidential token you control.\n   * Used only to derive the signer context and to scope the query cache key —\n   * it does not affect which wrapper the registry returns.\n   */\n  tokenAddress: Address;\n  /** ERC-20 address to discover the wrapper for. */\n  erc20Address: Address;\n}\n\n/**\n * Discover the confidential wrapper for an ERC-20 token via the on-chain registry.\n * Returns the wrapper address if one exists, or `null` if not.\n * Cached indefinitely since wrapper mappings are immutable.\n *\n * @param config - Token and ERC-20 addresses.\n * @param options - React Query options (forwarded to `useQuery`).\n * @returns Query result with `data: Address | null`.\n *\n * @example\n * ```tsx\n * const { data: wrapperAddress } = useWrapperDiscovery({\n *   tokenAddress: \"0xConfidentialToken\",\n *   erc20Address: \"0xUSDC\",\n * });\n * ```\n */\nexport function useWrapperDiscovery(\n  config: UseWrapperDiscoveryConfig,\n  options?: Omit<UseQueryOptions<Address | null>, \"queryKey\" | \"queryFn\">,\n) {\n  const { tokenAddress, erc20Address } = config;\n  const sdk = useZamaSDK();\n  const registryAddress = useWrappersRegistryAddress();\n  const baseOpts = wrapperDiscoveryQueryOptions(sdk.registry, {\n    tokenAddress,\n    erc20Address,\n    registryAddress,\n  });\n\n  return useQuery<Address | null>({\n    ...baseOpts,\n    ...options,\n    enabled: (baseOpts.enabled ?? true) && (options?.enabled ?? true),\n  });\n}\n\n/**\n * Suspense variant of {@link useWrapperDiscovery}.\n * Suspends rendering until the wrapper address is resolved.\n *\n * @param config - Token and ERC-20 addresses.\n * @returns Suspense query result with `data: Address | null`.\n *\n * @example\n * ```tsx\n * const { data: wrapperAddress } = useWrapperDiscoverySuspense({\n *   tokenAddress: \"0xConfidentialToken\",\n *   erc20Address: \"0xUSDC\",\n * });\n * ```\n */\nexport function useWrapperDiscoverySuspense(config: UseWrapperDiscoverySuspenseConfig) {\n  const { tokenAddress, erc20Address } = config;\n  const sdk = useZamaSDK();\n  const registryAddress = useWrappersRegistryAddress();\n\n  return useSuspenseQuery<Address | null>({\n    ...wrapperDiscoveryQueryOptions(sdk.registry, {\n      tokenAddress,\n      erc20Address,\n      registryAddress,\n    }),\n  });\n}\n","\"use client\";\n\nimport { useQuery, useSuspenseQuery } from \"../utils/query\";\nimport type { UseQueryOptions } from \"@tanstack/react-query\";\nimport type { Address } from \"@zama-fhe/sdk\";\nimport { tokenMetadataQueryOptions, type TokenMetadata } from \"@zama-fhe/sdk/query\";\nimport { useReadonlyToken } from \"./use-readonly-token\";\n\nexport { type TokenMetadata };\n\n/**\n * Read ERC-20 token metadata (name, symbol, decimals).\n * Fetches all three in parallel. Cached indefinitely since metadata is immutable.\n *\n * @param tokenAddress - Address of the token contract.\n * @param options - React Query options (forwarded to `useQuery`).\n * @returns Query result with `data: TokenMetadata`.\n *\n * @example\n * ```tsx\n * const { data: metadata } = useMetadata(\"0xToken\");\n * // metadata?.name, metadata?.symbol, metadata?.decimals\n * ```\n */\nexport function useMetadata(\n  tokenAddress: Address,\n  options?: Omit<UseQueryOptions<TokenMetadata>, \"queryKey\" | \"queryFn\">,\n) {\n  const token = useReadonlyToken(tokenAddress);\n\n  return useQuery<TokenMetadata>({\n    ...tokenMetadataQueryOptions(token.signer, tokenAddress),\n    ...options,\n  });\n}\n\n/**\n * Suspense variant of {@link useMetadata}.\n * Suspends rendering until metadata is loaded.\n *\n * @param tokenAddress - Address of the token contract.\n * @returns Suspense query result with `data: TokenMetadata`.\n *\n * @example\n * ```tsx\n * const { data: metadata } = useMetadataSuspense(\"0xToken\");\n * ```\n */\nexport function useMetadataSuspense(tokenAddress: Address) {\n  const token = useReadonlyToken(tokenAddress);\n\n  return useSuspenseQuery<TokenMetadata>({\n    ...tokenMetadataQueryOptions(token.signer, tokenAddress),\n  });\n}\n","\"use client\";\n\nimport { useQuery } from \"../utils/query\";\nimport type { Address, RawLog, ActivityLogMetadata, ActivityItem } from \"@zama-fhe/sdk\";\nimport { activityFeedQueryOptions, deriveActivityFeedLogsKey } from \"@zama-fhe/sdk/query\";\nimport { useReadonlyToken } from \"../token/use-readonly-token\";\n\n/** Configuration for {@link useActivityFeed}. */\nexport interface UseActivityFeedConfig {\n  /** Address of the confidential token contract. */\n  tokenAddress: Address;\n  /** Connected wallet address. Pass `undefined` to disable the query. */\n  userAddress: Address | undefined;\n  /** Raw event logs from the provider (viem, ethers, etc.). Pass `undefined` to disable. */\n  logs: readonly (RawLog & Partial<ActivityLogMetadata>)[] | undefined;\n  /** Whether to batch-decrypt encrypted transfer amounts. Default: `true`. */\n  decrypt?: boolean;\n}\n\n/**\n * Two-phase activity feed hook.\n * Phase 1: Instantly parses raw logs into classified {@link ActivityItem}s (sync, cheap).\n * Phase 2: Batch-decrypts encrypted transfer amounts via the relayer (async).\n *\n * The wallet provides logs (from its own provider — viem, ethers, etc.)\n * and this hook normalizes + decrypts them.\n *\n * @param config - Token address, user address, raw logs, and decrypt option.\n * @returns Query result with `data: ActivityItem[]`.\n *\n * @example\n * ```tsx\n * const { data: activity } = useActivityFeed({\n *   tokenAddress: \"0xToken\",\n *   userAddress: \"0xUser\",\n *   logs: rawLogs,\n * });\n * ```\n */\nexport function useActivityFeed(config: UseActivityFeedConfig) {\n  const { tokenAddress, userAddress, logs, decrypt: decryptOpt } = config;\n  const token = useReadonlyToken(tokenAddress);\n  const decrypt = decryptOpt ?? true;\n  const logsKey = deriveActivityFeedLogsKey(logs);\n\n  return useQuery<ActivityItem[]>({\n    ...activityFeedQueryOptions(token, {\n      userAddress,\n      logs,\n      decrypt,\n      logsKey,\n    }),\n  });\n}\n","\"use client\";\n\nimport { useMutation, type UseMutationOptions } from \"@tanstack/react-query\";\nimport type { TransactionResult } from \"@zama-fhe/sdk\";\nimport {\n  delegateDecryptionMutationOptions,\n  zamaQueryKeys,\n  type DelegateDecryptionParams,\n} from \"@zama-fhe/sdk/query\";\nimport { useToken, type UseZamaConfig } from \"../token/use-token\";\n\n/**\n * Delegate FHE decryption rights for a token to another address via the on-chain ACL.\n *\n * @param config - Token address identifying the confidential token.\n * @param options - React Query mutation options.\n *\n * @example\n * ```tsx\n * const delegate = useDelegateDecryption({ tokenAddress: \"0x...\" });\n * delegate.mutate({ delegateAddress: \"0xDelegate\" });\n * ```\n */\nexport function useDelegateDecryption(\n  config: UseZamaConfig,\n  options?: UseMutationOptions<TransactionResult, Error, DelegateDecryptionParams>,\n) {\n  const token = useToken(config);\n\n  return useMutation<TransactionResult, Error, DelegateDecryptionParams>({\n    ...delegateDecryptionMutationOptions(token),\n    ...options,\n    onSuccess: (data, variables, onMutateResult, context) => {\n      try {\n        options?.onSuccess?.(data, variables, onMutateResult, context);\n      } finally {\n        void context.client.invalidateQueries({ queryKey: zamaQueryKeys.delegationStatus.all });\n      }\n    },\n  });\n}\n","\"use client\";\n\nimport { useMutation, type UseMutationOptions } from \"@tanstack/react-query\";\nimport type { TransactionResult } from \"@zama-fhe/sdk\";\nimport {\n  revokeDelegationMutationOptions,\n  zamaQueryKeys,\n  type RevokeDelegationParams,\n} from \"@zama-fhe/sdk/query\";\nimport { useToken, type UseZamaConfig } from \"../token/use-token\";\n\n/**\n * Revoke FHE decryption delegation for a token from a delegate address.\n *\n * @param config - Token address identifying the confidential token.\n * @param options - React Query mutation options.\n *\n * @example\n * ```tsx\n * const revoke = useRevokeDelegation({ tokenAddress: \"0x...\" });\n * revoke.mutate({ delegateAddress: \"0xDelegate\" });\n * ```\n */\nexport function useRevokeDelegation(\n  config: UseZamaConfig,\n  options?: UseMutationOptions<TransactionResult, Error, RevokeDelegationParams>,\n) {\n  const token = useToken(config);\n\n  return useMutation<TransactionResult, Error, RevokeDelegationParams>({\n    ...revokeDelegationMutationOptions(token),\n    ...options,\n    onSuccess: (data, variables, onMutateResult, context) => {\n      try {\n        options?.onSuccess?.(data, variables, onMutateResult, context);\n      } finally {\n        void context.client.invalidateQueries({ queryKey: zamaQueryKeys.delegationStatus.all });\n      }\n    },\n  });\n}\n","\"use client\";\n\nimport type { UseQueryOptions } from \"@tanstack/react-query\";\nimport type { Address } from \"@zama-fhe/sdk\";\nimport { delegationStatusQueryOptions, type DelegationStatusData } from \"@zama-fhe/sdk/query\";\nimport { useQuery } from \"../utils/query\";\nimport { useZamaSDK } from \"../provider\";\n\nexport interface UseDelegationStatusConfig {\n  /** Address of the confidential token contract. Pass `undefined` to disable the query. */\n  tokenAddress: Address | undefined;\n  /** The address that granted the delegation. */\n  delegatorAddress?: Address;\n  /** The address that received delegation rights. */\n  delegateAddress?: Address;\n}\n\n/**\n * Query delegation status between a delegator and delegate for a token.\n *\n * @param config - Token address, delegator, and delegate addresses.\n * @param options - React Query options (forwarded to `useQuery`).\n * @returns `{ isDelegated, expiryTimestamp, isLoading, error }`.\n *\n * @example\n * ```tsx\n * const { data } = useDelegationStatus({\n *   tokenAddress: \"0xToken\",\n *   delegatorAddress: \"0xDelegator\",\n *   delegateAddress: \"0xDelegate\",\n * });\n * // data?.isDelegated, data?.expiryTimestamp\n * ```\n */\nexport function useDelegationStatus(\n  config: UseDelegationStatusConfig,\n  options?: Omit<UseQueryOptions<DelegationStatusData>, \"queryKey\" | \"queryFn\">,\n) {\n  const sdk = useZamaSDK();\n  const baseOpts = delegationStatusQueryOptions(sdk, {\n    tokenAddress: config.tokenAddress,\n    delegatorAddress: config.delegatorAddress,\n    delegateAddress: config.delegateAddress,\n  });\n\n  return useQuery<DelegationStatusData>({\n    ...baseOpts,\n    ...options,\n    enabled: (baseOpts.enabled ?? true) && (options?.enabled ?? true),\n  });\n}\n","\"use client\";\n\nimport { useMutation, type UseMutationOptions } from \"@tanstack/react-query\";\nimport type { Address } from \"@zama-fhe/sdk\";\nimport { decryptBalanceAsMutationOptions, type DecryptBalanceAsParams } from \"@zama-fhe/sdk/query\";\nimport { useReadonlyToken } from \"../token/use-readonly-token\";\n\n/**\n * Decrypt another user's confidential balance as a delegate.\n *\n * @param tokenAddress - Address of the confidential token contract.\n * @param options - React Query mutation options.\n *\n * @example\n * ```tsx\n * const decryptAs = useDecryptBalanceAs(\"0xToken\");\n * decryptAs.mutate({ delegatorAddress: \"0xDelegator\" });\n * // decryptAs.data => 1000n\n * ```\n */\nexport function useDecryptBalanceAs(\n  tokenAddress: Address,\n  options?: UseMutationOptions<bigint, Error, DecryptBalanceAsParams>,\n) {\n  const readonlyToken = useReadonlyToken(tokenAddress);\n\n  return useMutation<bigint, Error, DecryptBalanceAsParams>({\n    ...decryptBalanceAsMutationOptions(readonlyToken),\n    ...options,\n  });\n}\n","\"use client\";\n\nimport { useMutation, type UseMutationOptions } from \"@tanstack/react-query\";\nimport { ReadonlyToken, type Address, type BatchDecryptAsOptions } from \"@zama-fhe/sdk\";\n\n/**\n * Batch decrypt confidential balances as a delegate across multiple tokens.\n *\n * @param tokens - ReadonlyToken instances to decrypt balances for.\n * @param options - React Query mutation options.\n *\n * @example\n * ```tsx\n * const batchDecryptAs = useBatchDecryptBalancesAs(tokens);\n * batchDecryptAs.mutate({\n *   delegatorAddress: \"0xDelegator\",\n * });\n * // batchDecryptAs.data => Map { \"0xTokenA\" => 100n, \"0xTokenB\" => 200n }\n * ```\n */\nexport function useBatchDecryptBalancesAs(\n  tokens: ReadonlyToken[],\n  options?: UseMutationOptions<Map<Address, bigint>, Error, BatchDecryptAsOptions>,\n) {\n  return useMutation<Map<Address, bigint>, Error, BatchDecryptAsOptions>({\n    mutationKey: [\"zama.batchDecryptBalancesAs\", ...tokens.map((t) => t.address)] as const,\n    mutationFn: async (params) => ReadonlyToken.batchDecryptBalancesAs(tokens, params),\n    ...options,\n  });\n}\n","\"use client\";\n\nimport type { UseMutationOptions } from \"@tanstack/react-query\";\nimport { useMutation } from \"@tanstack/react-query\";\nimport type { Address, TransactionResult } from \"@zama-fhe/sdk\";\nimport {\n  approveUnderlyingMutationOptions,\n  invalidateAfterApproveUnderlying,\n  type ApproveUnderlyingParams,\n} from \"@zama-fhe/sdk/query\";\nimport { useToken, type UseZamaConfig } from \"../token/use-token\";\n\n/**\n * Approve the wrapper contract to spend the underlying ERC-20.\n * Defaults to max uint256. Resets to zero first if there's an existing\n * non-zero allowance (required by tokens like USDT).\n *\n * Errors are {@link ZamaError} subclasses — use `instanceof` to handle specific failures:\n * - {@link SigningRejectedError} — user rejected the wallet prompt\n * - {@link TransactionRevertedError} — approval transaction reverted\n *\n * @param config - Token and wrapper addresses.\n * @param options - React Query mutation options.\n *\n * @example\n * ```tsx\n * const approve = useApproveUnderlying({ tokenAddress: \"0x...\", wrapperAddress: \"0x...\" });\n * approve.mutate({}); // max approval\n * approve.mutate({ amount: 1000n }); // exact amount\n * ```\n */\nexport function useApproveUnderlying(\n  config: UseZamaConfig,\n  options?: UseMutationOptions<TransactionResult, Error, ApproveUnderlyingParams, Address>,\n) {\n  const token = useToken(config);\n\n  return useMutation<TransactionResult, Error, ApproveUnderlyingParams, Address>({\n    ...approveUnderlyingMutationOptions(token),\n    ...options,\n    onSuccess: (data, variables, onMutateResult, context) => {\n      options?.onSuccess?.(data, variables, onMutateResult, context);\n      invalidateAfterApproveUnderlying(context.client, config.tokenAddress);\n    },\n  });\n}\n","\"use client\";\n\nimport { useQuery, useSuspenseQuery } from \"../utils/query\";\nimport type { UseQueryOptions } from \"@tanstack/react-query\";\nimport type { Address } from \"@zama-fhe/sdk\";\nimport { isConfidentialQueryOptions, isWrapperQueryOptions } from \"@zama-fhe/sdk/query\";\nimport { useReadonlyToken } from \"./use-readonly-token\";\n\nexport { isConfidentialQueryOptions, isWrapperQueryOptions };\n\n/**\n * Check if a token supports the ERC-7984 confidential interface via ERC-165.\n * Result is cached indefinitely since interface support does not change.\n *\n * @param tokenAddress - Address of the token contract to check.\n * @param options - React Query options (forwarded to `useQuery`).\n * @returns Query result with `data: boolean`.\n *\n * @example\n * ```tsx\n * const { data: isConfidential } = useIsConfidential(\"0xToken\");\n * ```\n */\nexport function useIsConfidential(\n  tokenAddress: Address,\n  options?: Omit<UseQueryOptions<boolean>, \"queryKey\" | \"queryFn\">,\n) {\n  const token = useReadonlyToken(tokenAddress);\n\n  return useQuery<boolean>({\n    ...isConfidentialQueryOptions(token.signer, tokenAddress),\n    ...options,\n  });\n}\n\n/**\n * Suspense variant of {@link useIsConfidential}.\n * Suspends rendering until the ERC-165 check resolves.\n *\n * @param tokenAddress - Address of the token contract to check.\n * @returns Suspense query result with `data: boolean`.\n *\n * @example\n * ```tsx\n * const { data: isConfidential } = useIsConfidentialSuspense(\"0xToken\");\n * ```\n */\nexport function useIsConfidentialSuspense(tokenAddress: Address) {\n  const token = useReadonlyToken(tokenAddress);\n\n  return useSuspenseQuery<boolean>({\n    ...isConfidentialQueryOptions(token.signer, tokenAddress),\n  });\n}\n\n/**\n * Check if a token supports the ERC-7984 wrapper interface via ERC-165.\n * Result is cached indefinitely since interface support does not change.\n *\n * @param tokenAddress - Address of the token contract to check.\n * @param options - React Query options (forwarded to `useQuery`).\n * @returns Query result with `data: boolean`.\n *\n * @example\n * ```tsx\n * const { data: isWrapper } = useIsWrapper(\"0xToken\");\n * ```\n */\nexport function useIsWrapper(\n  tokenAddress: Address,\n  options?: Omit<UseQueryOptions<boolean>, \"queryKey\" | \"queryFn\">,\n) {\n  const token = useReadonlyToken(tokenAddress);\n\n  return useQuery<boolean>({\n    ...isWrapperQueryOptions(token.signer, tokenAddress),\n    ...options,\n  });\n}\n\n/**\n * Suspense variant of {@link useIsWrapper}.\n * Suspends rendering until the ERC-165 check resolves.\n *\n * @param tokenAddress - Address of the token contract to check.\n * @returns Suspense query result with `data: boolean`.\n *\n * @example\n * ```tsx\n * const { data: isWrapper } = useIsWrapperSuspense(\"0xToken\");\n * ```\n */\nexport function useIsWrapperSuspense(tokenAddress: Address) {\n  const token = useReadonlyToken(tokenAddress);\n\n  return useSuspenseQuery<boolean>({\n    ...isWrapperQueryOptions(token.signer, tokenAddress),\n  });\n}\n","\"use client\";\n\nimport { useQuery, useSuspenseQuery } from \"../utils/query\";\nimport type { UseQueryOptions } from \"@tanstack/react-query\";\nimport type { Address } from \"@zama-fhe/sdk\";\nimport { totalSupplyQueryOptions } from \"@zama-fhe/sdk/query\";\nimport { useReadonlyToken } from \"./use-readonly-token\";\n\nexport { totalSupplyQueryOptions };\n\n/**\n * Read the total supply of a token.\n * Stale after 30 seconds to balance freshness and RPC cost.\n *\n * @param tokenAddress - Address of the token contract.\n * @param options - React Query options (forwarded to `useQuery`).\n * @returns Query result with `data: bigint`.\n *\n * @example\n * ```tsx\n * const { data: totalSupply } = useTotalSupply(\"0xToken\");\n * ```\n */\nexport function useTotalSupply(\n  tokenAddress: Address,\n  options?: Omit<UseQueryOptions<bigint>, \"queryKey\" | \"queryFn\">,\n) {\n  const token = useReadonlyToken(tokenAddress);\n\n  return useQuery<bigint>({\n    ...totalSupplyQueryOptions(token.signer, tokenAddress),\n    ...options,\n  });\n}\n\n/**\n * Suspense variant of {@link useTotalSupply}.\n * Suspends rendering until the total supply is loaded.\n *\n * @param tokenAddress - Address of the token contract.\n * @returns Suspense query result with `data: bigint`.\n *\n * @example\n * ```tsx\n * const { data: totalSupply } = useTotalSupplySuspense(\"0xToken\");\n * ```\n */\nexport function useTotalSupplySuspense(tokenAddress: Address) {\n  const token = useReadonlyToken(tokenAddress);\n\n  return useSuspenseQuery<bigint>({\n    ...totalSupplyQueryOptions(token.signer, tokenAddress),\n  });\n}\n","\"use client\";\n\nimport { useQuery } from \"../utils/query\";\nimport type { UseQueryOptions } from \"@tanstack/react-query\";\nimport type { Address } from \"@zama-fhe/sdk\";\nimport {\n  batchTransferFeeQueryOptions,\n  feeRecipientQueryOptions,\n  shieldFeeQueryOptions,\n  unshieldFeeQueryOptions,\n} from \"@zama-fhe/sdk/query\";\nimport { useZamaSDK } from \"../provider\";\n\nexport {\n  batchTransferFeeQueryOptions,\n  feeRecipientQueryOptions,\n  shieldFeeQueryOptions,\n  unshieldFeeQueryOptions,\n};\n\n/** Configuration for {@link useShieldFee} and {@link useUnshieldFee}. */\nexport interface UseFeeConfig {\n  /** Address of the fee manager contract. */\n  feeManagerAddress: Address;\n  /** Amount to calculate the fee for. */\n  amount: bigint;\n  /** Sender address. */\n  from: Address;\n  /** Receiver address. */\n  to: Address;\n}\n\n/**\n * Read the shield fee for a given amount and address pair.\n *\n * @param config - Fee manager address, amount, from, and to.\n * @param options - React Query options (forwarded to `useQuery`).\n * @returns Query result with `data: bigint` (the fee amount).\n *\n * @example\n * ```tsx\n * const { data: fee } = useShieldFee({\n *   feeManagerAddress: \"0xFeeManager\",\n *   amount: 1000n,\n *   from: \"0xSender\",\n *   to: \"0xReceiver\",\n * });\n * ```\n */\nexport function useShieldFee(\n  config: UseFeeConfig,\n  options?: Omit<UseQueryOptions<bigint>, \"queryKey\" | \"queryFn\">,\n) {\n  const sdk = useZamaSDK();\n  const baseOpts = shieldFeeQueryOptions(sdk.signer, config);\n\n  return useQuery<bigint>({\n    ...baseOpts,\n    ...options,\n    enabled: (baseOpts.enabled ?? true) && (options?.enabled ?? true),\n  });\n}\n\n/**\n * Read the unshield fee for a given amount and address pair.\n *\n * @param config - Fee manager address, amount, from, and to.\n * @param options - React Query options (forwarded to `useQuery`).\n * @returns Query result with `data: bigint` (the fee amount).\n *\n * @example\n * ```tsx\n * const { data: fee } = useUnshieldFee({\n *   feeManagerAddress: \"0xFeeManager\",\n *   amount: 1000n,\n *   from: \"0xSender\",\n *   to: \"0xReceiver\",\n * });\n * ```\n */\nexport function useUnshieldFee(\n  config: UseFeeConfig,\n  options?: Omit<UseQueryOptions<bigint>, \"queryKey\" | \"queryFn\">,\n) {\n  const sdk = useZamaSDK();\n  const baseOpts = unshieldFeeQueryOptions(sdk.signer, config);\n\n  return useQuery<bigint>({\n    ...baseOpts,\n    ...options,\n    enabled: (baseOpts.enabled ?? true) && (options?.enabled ?? true),\n  });\n}\n\n/**\n * Read the batch transfer fee from the fee manager.\n *\n * @param feeManagerAddress - Address of the fee manager contract.\n * @param options - React Query options (forwarded to `useQuery`).\n * @returns Query result with `data: bigint` (the fee amount).\n *\n * @example\n * ```tsx\n * const { data: fee } = useBatchTransferFee(\"0xFeeManager\");\n * ```\n */\nexport function useBatchTransferFee(\n  feeManagerAddress: Address,\n  options?: Omit<UseQueryOptions<bigint>, \"queryKey\" | \"queryFn\">,\n) {\n  const sdk = useZamaSDK();\n  const baseOpts = batchTransferFeeQueryOptions(sdk.signer, feeManagerAddress);\n\n  return useQuery<bigint>({\n    ...baseOpts,\n    ...options,\n    enabled: (baseOpts.enabled ?? true) && (options?.enabled ?? true),\n  });\n}\n\n/**\n * Read the fee recipient address from the fee manager.\n *\n * @param feeManagerAddress - Address of the fee manager contract.\n * @param options - React Query options (forwarded to `useQuery`).\n * @returns Query result with `data: Address` (the fee recipient).\n *\n * @example\n * ```tsx\n * const { data: recipient } = useFeeRecipient(\"0xFeeManager\");\n * ```\n */\nexport function useFeeRecipient(\n  feeManagerAddress: Address,\n  options?: Omit<UseQueryOptions<Address>, \"queryKey\" | \"queryFn\">,\n) {\n  const sdk = useZamaSDK();\n  const baseOpts = feeRecipientQueryOptions(sdk.signer, feeManagerAddress);\n\n  return useQuery<Address>({\n    ...baseOpts,\n    ...options,\n    enabled: (baseOpts.enabled ?? true) && (options?.enabled ?? true),\n  });\n}\n","\"use client\";\n\nimport type { TokenWrapperPair } from \"@zama-fhe/sdk\";\nimport { tokenPairsQueryOptions } from \"@zama-fhe/sdk/query\";\nimport { useZamaSDK } from \"../provider\";\nimport { useQuery } from \"../utils/query\";\nimport { useWrappersRegistryAddress } from \"./use-wrappers-registry-address\";\n\n/**\n * Fetches all token wrapper pairs from the ConfidentialTokenWrappersRegistry\n * contract on the current chain.\n */\nexport function useTokenPairsRegistry() {\n  const sdk = useZamaSDK();\n  const registryAddress = useWrappersRegistryAddress();\n\n  return useQuery<readonly TokenWrapperPair[]>(\n    tokenPairsQueryOptions(sdk.signer, {\n      registryAddress,\n    }),\n  );\n}\n","\"use client\";\n\nimport { tokenPairsLengthQueryOptions } from \"@zama-fhe/sdk/query\";\nimport { useZamaSDK } from \"../provider\";\nimport { useQuery } from \"../utils/query\";\nimport { useWrappersRegistryAddress } from \"./use-wrappers-registry-address\";\n\n/**\n * Returns the total number of token wrapper pairs in the registry.\n */\nexport function useTokenPairsLength() {\n  const sdk = useZamaSDK();\n  const registryAddress = useWrappersRegistryAddress();\n\n  return useQuery<bigint>(\n    tokenPairsLengthQueryOptions(sdk.signer, {\n      registryAddress,\n    }),\n  );\n}\n","\"use client\";\n\nimport type { TokenWrapperPair } from \"@zama-fhe/sdk\";\nimport { tokenPairsSliceQueryOptions } from \"@zama-fhe/sdk/query\";\nimport { useZamaSDK } from \"../provider\";\nimport { useQuery } from \"../utils/query\";\nimport { useWrappersRegistryAddress } from \"./use-wrappers-registry-address\";\n\n/**\n * Fetches a range of token wrapper pairs from the registry (paginated).\n *\n * @param fromIndex - Start index (inclusive). Pass `undefined` to disable.\n * @param toIndex - End index (exclusive). Pass `undefined` to disable.\n */\nexport function useTokenPairsSlice({\n  fromIndex,\n  toIndex,\n}: {\n  fromIndex: bigint | undefined;\n  toIndex: bigint | undefined;\n}) {\n  const sdk = useZamaSDK();\n  const registryAddress = useWrappersRegistryAddress();\n\n  return useQuery<readonly TokenWrapperPair[]>(\n    tokenPairsSliceQueryOptions(sdk.signer, {\n      registryAddress,\n      fromIndex,\n      toIndex,\n    }),\n  );\n}\n","\"use client\";\n\nimport type { TokenWrapperPair } from \"@zama-fhe/sdk\";\nimport { tokenPairQueryOptions } from \"@zama-fhe/sdk/query\";\nimport { useZamaSDK } from \"../provider\";\nimport { useQuery } from \"../utils/query\";\nimport { useWrappersRegistryAddress } from \"./use-wrappers-registry-address\";\n\n/**\n * Fetches a single token wrapper pair by index from the registry.\n *\n * @param index - Zero-based pair index. Pass `undefined` to disable.\n */\nexport function useTokenPair({ index }: { index: bigint | undefined }) {\n  const sdk = useZamaSDK();\n  const registryAddress = useWrappersRegistryAddress();\n\n  return useQuery<TokenWrapperPair>(\n    tokenPairQueryOptions(sdk.signer, {\n      registryAddress,\n      index,\n    }),\n  );\n}\n","\"use client\";\n\nimport type { Address } from \"@zama-fhe/sdk\";\nimport { confidentialTokenAddressQueryOptions } from \"@zama-fhe/sdk/query\";\nimport { useZamaSDK } from \"../provider\";\nimport { useQuery } from \"../utils/query\";\nimport { useWrappersRegistryAddress } from \"./use-wrappers-registry-address\";\n\n/**\n * Looks up the confidential token address for a given plain token address.\n */\nexport function useConfidentialTokenAddress({\n  tokenAddress,\n}: {\n  tokenAddress: Address | undefined;\n}) {\n  const sdk = useZamaSDK();\n  const registryAddress = useWrappersRegistryAddress();\n\n  return useQuery<readonly [boolean, Address]>(\n    confidentialTokenAddressQueryOptions(sdk.signer, {\n      registryAddress,\n      tokenAddress,\n    }),\n  );\n}\n","\"use client\";\n\nimport type { Address } from \"@zama-fhe/sdk\";\nimport { tokenAddressQueryOptions } from \"@zama-fhe/sdk/query\";\nimport { useZamaSDK } from \"../provider\";\nimport { useQuery } from \"../utils/query\";\nimport { useWrappersRegistryAddress } from \"./use-wrappers-registry-address\";\n\n/**\n * Looks up the plain token address for a given confidential token address.\n */\nexport function useTokenAddress({\n  confidentialTokenAddress,\n}: {\n  confidentialTokenAddress: Address | undefined;\n}) {\n  const sdk = useZamaSDK();\n  const registryAddress = useWrappersRegistryAddress();\n\n  return useQuery<readonly [boolean, Address]>(\n    tokenAddressQueryOptions(sdk.signer, {\n      registryAddress,\n      confidentialTokenAddress,\n    }),\n  );\n}\n","\"use client\";\n\nimport type { Address } from \"@zama-fhe/sdk\";\nimport { isConfidentialTokenValidQueryOptions } from \"@zama-fhe/sdk/query\";\nimport { useZamaSDK } from \"../provider\";\nimport { useQuery } from \"../utils/query\";\nimport { useWrappersRegistryAddress } from \"./use-wrappers-registry-address\";\n\n/**\n * Checks whether a confidential token is registered and valid in the\n * on-chain wrappers registry.\n *\n * @param confidentialTokenAddress - The confidential token to check. Pass `undefined` to disable.\n */\nexport function useIsConfidentialTokenValid({\n  confidentialTokenAddress,\n}: {\n  confidentialTokenAddress: Address | undefined;\n}) {\n  const sdk = useZamaSDK();\n  const registryAddress = useWrappersRegistryAddress();\n\n  return useQuery<boolean>(\n    isConfidentialTokenValidQueryOptions(sdk.signer, {\n      registryAddress,\n      confidentialTokenAddress,\n    }),\n  );\n}\n","\"use client\";\n\nimport type {\n  TokenWrapperPair,\n  TokenWrapperPairWithMetadata,\n  PaginatedResult,\n} from \"@zama-fhe/sdk\";\nimport { listPairsQueryOptions } from \"@zama-fhe/sdk/query\";\nimport { useZamaSDK } from \"../provider\";\nimport { useQuery } from \"../utils/query\";\nimport { useWrappersRegistryAddress } from \"./use-wrappers-registry-address\";\n\n/**\n * Fetches paginated token wrapper pairs from the registry.\n *\n * @param options - Query options: `page` (1-indexed, default `1`), `pageSize` (default `100`), `metadata` (fetch on-chain metadata for both tokens, default `false`).\n *\n * @example\n * ```tsx\n * const { data, isLoading } = useListPairs({ page: 1, pageSize: 20 });\n * if (data) {\n *   console.log(`${data.total} pairs, showing page ${data.page}`);\n * }\n * ```\n */\nexport function useListPairs({\n  page = 1,\n  pageSize = 100,\n  metadata = false,\n}: {\n  page?: number;\n  pageSize?: number;\n  metadata?: boolean;\n} = {}) {\n  const sdk = useZamaSDK();\n  const registryAddress = useWrappersRegistryAddress();\n\n  // Pass sdk.registry (a lazy singleton) so the class-level TTL cache is shared\n  // across all queryFn executions — rather than constructing a new instance each time.\n  return useQuery<PaginatedResult<TokenWrapperPair | TokenWrapperPairWithMetadata>>(\n    listPairsQueryOptions(sdk.registry, {\n      registryAddress,\n      page,\n      pageSize,\n      metadata,\n    }),\n  );\n}\n"],"mappings":"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"}
+{"version":3,"file":"index.js","names":["ZamaSDK","encryptMutationOptions","userDecryptMutationOptions","publicDecryptMutationOptions","generateKeypairMutationOptions","createEIP712MutationOptions","createDelegatedUserDecryptEIP712MutationOptions","delegatedUserDecryptMutationOptions","requestZKProofVerificationMutationOptions","useQuery","tanstack_useQuery","hashFn","useSuspenseQuery","tanstack_useSuspenseQuery","useQueries","tanstack_useQueries","useQuery","publicKeyQueryOptions","useQuery","publicParamsQueryOptions","useQuery","zamaQueryKeys","useQueries","zamaQueryKeys","allowMutationOptions","zamaQueryKeys","useQuery","signerAddressQueryOptions","isAllowedQueryOptions","zamaQueryKeys","revokeMutationOptions","zamaQueryKeys","revokeSessionMutationOptions","zamaQueryKeys","useQuery","signerAddressQueryOptions","confidentialHandleQueryOptions","confidentialBalanceQueryOptions","useQuery","signerAddressQueryOptions","confidentialHandlesQueryOptions","confidentialBalancesQueryOptions","zamaQueryKeys","confidentialTransferMutationOptions","confidentialTransferFromMutationOptions","confidentialApproveMutationOptions","useQuery","signerAddressQueryOptions","confidentialIsApprovedQueryOptions","useSuspenseQuery","shieldMutationOptions","shieldETHMutationOptions","unwrapMutationOptions","unwrapAllMutationOptions","finalizeUnwrapMutationOptions","unshieldMutationOptions","unshieldAllMutationOptions","resumeUnshieldMutationOptions","useQuery","signerAddressQueryOptions","underlyingAllowanceQueryOptions","useSuspenseQuery","useQuery","zamaQueryKeys","wrapperDiscoveryQueryOptions","useQuery","useSuspenseQuery","useQuery","tokenMetadataQueryOptions","useSuspenseQuery","useQuery","activityFeedQueryOptions","delegateDecryptionMutationOptions","zamaQueryKeys","revokeDelegationMutationOptions","zamaQueryKeys","delegationStatusQueryOptions","useQuery","decryptBalanceAsMutationOptions","ReadonlyToken","approveUnderlyingMutationOptions","useQuery","isConfidentialQueryOptions","useSuspenseQuery","isWrapperQueryOptions","useQuery","totalSupplyQueryOptions","useSuspenseQuery","shieldFeeQueryOptions","useQuery","unshieldFeeQueryOptions","batchTransferFeeQueryOptions","feeRecipientQueryOptions","useQuery","useQuery","useQuery","useQuery","useQuery","useQuery","useQuery","useQuery","listPairsQueryOptions"],"sources":["../src/provider.tsx","../src/relayer/use-encrypt.ts","../src/relayer/use-user-decrypt.ts","../src/relayer/use-public-decrypt.ts","../src/relayer/use-generate-keypair.ts","../src/relayer/use-create-eip712.ts","../src/relayer/use-create-delegated-user-decrypt-eip712.ts","../src/relayer/use-delegated-user-decrypt.ts","../src/relayer/use-request-zk-proof-verification.ts","../src/utils/query.ts","../src/relayer/use-public-key.ts","../src/relayer/use-public-params.ts","../src/relayer/use-user-decrypted-value.ts","../src/relayer/use-user-decrypted-values.ts","../src/authorization/use-allow.ts","../src/authorization/use-is-allowed.ts","../src/authorization/use-revoke.ts","../src/authorization/use-revoke-session.ts","../src/token/use-token.ts","../src/token/use-readonly-token.ts","../src/balance/use-confidential-balance.ts","../src/balance/use-confidential-balances.ts","../src/balance/optimistic-balance-update.ts","../src/transfer/use-confidential-transfer.ts","../src/transfer/use-confidential-transfer-from.ts","../src/transfer/use-confidential-approve.ts","../src/transfer/use-confidential-is-approved.ts","../src/shield/use-shield.ts","../src/shield/use-shield-eth.ts","../src/unwrap/use-unwrap.ts","../src/unwrap/use-unwrap-all.ts","../src/unwrap/use-finalize-unwrap.ts","../src/unshield/use-unshield.ts","../src/unshield/use-unshield-all.ts","../src/unshield/use-resume-unshield.ts","../src/shield/use-underlying-allowance.ts","../src/wrappers-registry/use-wrappers-registry-address.ts","../src/token/use-wrapper-discovery.ts","../src/token/use-metadata.ts","../src/balance/use-activity-feed.ts","../src/delegation/use-delegate-decryption.ts","../src/delegation/use-revoke-delegation.ts","../src/delegation/use-delegation-status.ts","../src/delegation/use-decrypt-balance-as.ts","../src/delegation/use-batch-decrypt-balances-as.ts","../src/shield/use-approve-underlying.ts","../src/token/use-is-confidential.ts","../src/token/use-total-supply.ts","../src/token/use-fees.ts","../src/wrappers-registry/use-token-pairs-registry.ts","../src/wrappers-registry/use-token-pairs-length.ts","../src/wrappers-registry/use-token-pairs-slice.ts","../src/wrappers-registry/use-token-pair.ts","../src/wrappers-registry/use-confidential-token-address.ts","../src/wrappers-registry/use-token-address.ts","../src/wrappers-registry/use-is-confidential-token-valid.ts","../src/wrappers-registry/use-list-pairs.ts"],"sourcesContent":["\"use client\";\n\nimport type {\n  Address,\n  GenericSigner,\n  GenericStorage,\n  RelayerSDK,\n  ZamaSDKEventListener,\n} from \"@zama-fhe/sdk\";\nimport { ZamaSDK } from \"@zama-fhe/sdk\";\nimport { invalidateWalletLifecycleQueries } from \"@zama-fhe/sdk/query\";\nimport { useQueryClient } from \"@tanstack/react-query\";\nimport {\n  createContext,\n  type PropsWithChildren,\n  useContext,\n  useEffect,\n  useMemo,\n  useRef,\n} from \"react\";\n\n/** Props for {@link ZamaProvider}. */\nexport interface ZamaProviderProps extends PropsWithChildren {\n  /** FHE relayer backend (RelayerWeb for browser, RelayerNode for server). */\n  relayer: RelayerSDK;\n  /** Wallet signer (`ViemSigner`, `EthersSigner`, or custom {@link GenericSigner}). */\n  signer: GenericSigner;\n  /** Credential storage backend (IndexedDBStorage for browser, MemoryStorage for tests). */\n  storage: GenericStorage;\n  /**\n   * Session storage for wallet signatures. Defaults to in-memory (lost on reload).\n   * Pass a `chrome.storage.session`-backed store for web extensions.\n   */\n  sessionStorage?: GenericStorage;\n  /**\n   * How long the ML-KEM re-encryption keypair remains valid, in seconds.\n   * Default: `86400` (1 day). Must be positive — `0` is rejected.\n   */\n  keypairTTL?: number;\n  /**\n   * Controls how long session signatures (EIP-712 wallet signatures) remain valid, in seconds.\n   * Default: `2592000` (30 days).\n   * - `0`: never persist — every operation triggers a signing prompt (high-security mode).\n   * - Positive number: seconds until the session signature expires and requires re-authentication.\n   */\n  sessionTTL?: number;\n  /**\n   * Per-chain wrappers registry address overrides, merged on top of built-in defaults.\n   * Use this for custom or local chains (e.g. Hardhat) where no default registry exists.\n   */\n  registryAddresses?: Record<number, Address>;\n  /**\n   * How long cached registry results remain valid, in seconds.\n   * Default: `86400` (24 hours).\n   */\n  registryTTL?: number;\n  /** Callback invoked on SDK lifecycle events. */\n  onEvent?: ZamaSDKEventListener;\n}\n\nconst ZamaSDKContext = createContext<ZamaSDK | null>(null);\n\n/**\n * Provides a {@link ZamaSDK} instance to all descendant hooks.\n *\n * @example\n * ```tsx\n * <ZamaProvider relayer={relayer} signer={signer} storage={storage}>\n *   <App />\n * </ZamaProvider>\n * ```\n */\nexport function ZamaProvider({\n  children,\n  relayer,\n  signer,\n  storage,\n  sessionStorage,\n  keypairTTL,\n  sessionTTL,\n  registryAddresses,\n  registryTTL,\n  onEvent,\n}: ZamaProviderProps) {\n  const queryClient = useQueryClient();\n\n  // Stabilize onEvent so an inline arrow doesn't recreate the SDK every render.\n  const onEventRef = useRef(onEvent);\n\n  useEffect(() => {\n    onEventRef.current = onEvent;\n  });\n\n  const signerLifecycleCallbacks = useMemo(\n    () =>\n      signer?.subscribe\n        ? {\n            onDisconnect: () => invalidateWalletLifecycleQueries(queryClient),\n            onAccountChange: () => invalidateWalletLifecycleQueries(queryClient),\n            onChainChange: () => invalidateWalletLifecycleQueries(queryClient),\n          }\n        : undefined,\n    [queryClient, signer],\n  );\n\n  const sdk = useMemo(\n    () =>\n      new ZamaSDK({\n        relayer,\n        signer,\n        storage,\n        sessionStorage,\n        keypairTTL,\n        sessionTTL,\n        registryAddresses,\n        registryTTL,\n        onEvent: onEventRef.current,\n        signerLifecycleCallbacks,\n      }),\n    [\n      relayer,\n      signer,\n      storage,\n      sessionStorage,\n      keypairTTL,\n      sessionTTL,\n      registryAddresses,\n      registryTTL,\n      signerLifecycleCallbacks,\n    ],\n  );\n\n  // Clean up signer subscriptions on unmount without terminating the\n  // caller-owned relayer. dispose() only unsubscribes from wallet events\n  // and is idempotent.\n  useEffect(() => () => sdk.dispose(), [sdk]);\n\n  return <ZamaSDKContext.Provider value={sdk}>{children}</ZamaSDKContext.Provider>;\n}\n\n/**\n * Access the {@link ZamaSDK} instance from context.\n * Throws if called outside a {@link ZamaProvider} or when no signer is provided.\n *\n * @example\n * ```tsx\n * const sdk = useZamaSDK();\n * const token = sdk.createReadonlyToken(\"0x...\");\n * ```\n */\nexport function useZamaSDK(): ZamaSDK {\n  const context = useContext(ZamaSDKContext);\n\n  if (!context) {\n    throw new Error(\n      \"useZamaSDK must be used within a <ZamaProvider>. \" +\n        \"Wrap your component tree in <ZamaProvider relayer={…} signer={…} storage={…}>.\",\n    );\n  }\n\n  return context;\n}\n","\"use client\";\n\nimport type { EncryptParams, EncryptResult } from \"@zama-fhe/sdk\";\nimport { useMutation } from \"@tanstack/react-query\";\nimport { encryptMutationOptions } from \"@zama-fhe/sdk/query\";\nimport { useZamaSDK } from \"../provider\";\n\n/**\n * Encrypt a plaintext value using FHE.\n * Calls the relayer's `encrypt` method via a mutation.\n *\n * Errors are {@link ZamaError} subclasses — use `instanceof` to handle specific failures:\n * - {@link EncryptionFailedError} — FHE encryption failed\n *\n * @returns A mutation whose `mutate` accepts {@link EncryptParams}.\n *\n * @example\n * ```tsx\n * const encrypt = useEncrypt();\n * encrypt.mutate({ values: [{ value: 1000n, type: \"euint64\" }], contractAddress: \"0x...\", userAddress: \"0x...\" });\n * ```\n */\nexport function useEncrypt() {\n  const sdk = useZamaSDK();\n  return useMutation<EncryptResult, Error, EncryptParams>(encryptMutationOptions(sdk));\n}\n","\"use client\";\n\nimport { useMutation } from \"@tanstack/react-query\";\nimport type { ClearValueType, Handle } from \"@zama-fhe/sdk\";\nimport type {\n  DecryptHandle,\n  UserDecryptCallbacks,\n  UserDecryptMutationParams,\n} from \"@zama-fhe/sdk/query\";\nimport { userDecryptMutationOptions } from \"@zama-fhe/sdk/query\";\nimport { useZamaSDK } from \"../provider\";\n\nexport type {\n  UserDecryptCallbacks as DecryptCallbacks,\n  DecryptHandle,\n  UserDecryptMutationParams as DecryptParams,\n};\n\n/** Configuration for {@link useUserDecrypt}. */\nexport type UseUserDecryptConfig = UserDecryptCallbacks;\n\n/**\n * High-level orchestration hook for user decryption.\n *\n * Reuses cached FHE credentials from `sdk.credentials` when available,\n * falling back to generating a fresh keypair + EIP-712 signature only when\n * no valid credentials exist. This avoids redundant wallet signature prompts.\n *\n * On success, populates the decryption cache so `useUserDecryptedValue` / `useUserDecryptedValues`\n * can read the results.\n *\n * @param config - Optional callbacks for step-by-step UX feedback.\n * @returns A mutation whose `mutate` accepts {@link UserDecryptMutationParams}.\n *\n * @example\n * ```tsx\n * const decrypt = useUserDecrypt({\n *   onCredentialsReady: () => setStep(\"decrypting\"),\n *   onDecrypted: (values) => console.log(values),\n * });\n * decrypt.mutate({\n *   handles: [{ handle: \"0xHandle\", contractAddress: \"0xContract\" }],\n * });\n * ```\n */\nexport function useUserDecrypt(config?: UseUserDecryptConfig) {\n  const sdk = useZamaSDK();\n\n  return useMutation<Record<Handle, ClearValueType>, Error, UserDecryptMutationParams>(\n    userDecryptMutationOptions(sdk, config),\n  );\n}\n","\"use client\";\n\nimport { useMutation } from \"@tanstack/react-query\";\nimport type { Handle, PublicDecryptResult } from \"@zama-fhe/sdk\";\nimport { publicDecryptMutationOptions } from \"@zama-fhe/sdk/query\";\nimport { useZamaSDK } from \"../provider\";\n\n/**\n * Decrypt FHE ciphertext handles using the network public key (no credential needed).\n * On success, populates the decryption cache so {@link useUserDecryptedValue} / {@link useUserDecryptedValues}\n * can read the results.\n *\n * @returns A mutation whose `mutate` accepts an array of handle strings.\n *\n * @example\n * ```tsx\n * const publicDecrypt = usePublicDecrypt();\n * publicDecrypt.mutate([\"0xHandle1\", \"0xHandle2\"]);\n * // publicDecrypt.data?.clearValues => { \"0xHandle1\": 500n, ... }\n * ```\n */\nexport function usePublicDecrypt() {\n  const sdk = useZamaSDK();\n  return useMutation<PublicDecryptResult, Error, Handle[]>(publicDecryptMutationOptions(sdk));\n}\n","\"use client\";\n\nimport { useMutation } from \"@tanstack/react-query\";\nimport { generateKeypairMutationOptions } from \"@zama-fhe/sdk/query\";\nimport { useZamaSDK } from \"../provider\";\n\n/**\n * Generate an FHE keypair via the relayer.\n * Returns a public/private key pair for use in decrypt authorization.\n *\n * Errors are {@link ZamaError} subclasses — use `instanceof` to handle specific failures:\n * - {@link RelayerRequestFailedError} — relayer keypair generation request failed\n *\n * @returns A mutation whose `mutate` takes no parameters.\n *\n * @example\n * ```tsx\n * const generateKeypair = useGenerateKeypair();\n * generateKeypair.mutate();\n * // generateKeypair.data?.publicKey, generateKeypair.data?.privateKey\n * ```\n */\nexport function useGenerateKeypair() {\n  const sdk = useZamaSDK();\n  return useMutation(generateKeypairMutationOptions(sdk));\n}\n","\"use client\";\n\nimport type { EIP712TypedData } from \"@zama-fhe/sdk\";\nimport { useMutation } from \"@tanstack/react-query\";\nimport { createEIP712MutationOptions } from \"@zama-fhe/sdk/query\";\nimport type { CreateEIP712Params } from \"@zama-fhe/sdk/query\";\nimport { useZamaSDK } from \"../provider\";\n\nexport type { CreateEIP712Params };\n\n/**\n * Create EIP-712 typed data for signing an FHE decrypt credential.\n * The returned typed data is signed by the wallet to authorize decryption.\n *\n * @returns A mutation whose `mutate` accepts {@link CreateEIP712Params}.\n *\n * @example\n * ```tsx\n * const createEIP712 = useCreateEIP712();\n * createEIP712.mutate({\n *   publicKey: keypair.publicKey,\n *   contractAddresses: [\"0xToken\"],\n *   startTimestamp: Math.floor(Date.now() / 1000),\n * });\n * ```\n */\nexport function useCreateEIP712() {\n  const sdk = useZamaSDK();\n  return useMutation<EIP712TypedData, Error, CreateEIP712Params>(createEIP712MutationOptions(sdk));\n}\n","\"use client\";\n\nimport type { KmsDelegatedUserDecryptEIP712Type } from \"@zama-fhe/sdk\";\nimport { useMutation } from \"@tanstack/react-query\";\nimport { createDelegatedUserDecryptEIP712MutationOptions } from \"@zama-fhe/sdk/query\";\nimport type { CreateDelegatedUserDecryptEIP712Params } from \"@zama-fhe/sdk/query\";\nimport { useZamaSDK } from \"../provider\";\n\nexport type { CreateDelegatedUserDecryptEIP712Params };\n\n/**\n * Create EIP-712 typed data for a delegated user decrypt credential.\n * Used when one wallet authorizes another to decrypt on its behalf.\n *\n * @returns A mutation whose `mutate` accepts {@link CreateDelegatedUserDecryptEIP712Params}.\n *\n * @example\n * ```tsx\n * const createEIP712 = useCreateDelegatedUserDecryptEIP712();\n * createEIP712.mutate({\n *   publicKey: keypair.publicKey,\n *   contractAddresses: [\"0xToken\"],\n *   delegatorAddress: \"0xDelegator\",\n *   startTimestamp: Math.floor(Date.now() / 1000),\n * });\n * ```\n */\nexport function useCreateDelegatedUserDecryptEIP712() {\n  const sdk = useZamaSDK();\n  return useMutation<\n    KmsDelegatedUserDecryptEIP712Type,\n    Error,\n    CreateDelegatedUserDecryptEIP712Params\n  >(createDelegatedUserDecryptEIP712MutationOptions(sdk));\n}\n","\"use client\";\n\nimport type { DelegatedUserDecryptParams, ClearValueType, Handle } from \"@zama-fhe/sdk\";\nimport { useMutation } from \"@tanstack/react-query\";\nimport { delegatedUserDecryptMutationOptions } from \"@zama-fhe/sdk/query\";\nimport { useZamaSDK } from \"../provider\";\n\n/**\n * Decrypt FHE ciphertext handles using delegated user credentials.\n * Returns a map of handle → plaintext bigint.\n *\n * @returns A mutation whose `mutate` accepts {@link DelegatedUserDecryptParams}.\n *\n * @example\n * ```tsx\n * const decrypt = useDelegatedUserDecrypt();\n * decrypt.mutate({ handles: [\"0xHandle1\"], ...credentials });\n * // decrypt.data => { \"0xHandle1\": 1000n }\n * ```\n */\nexport function useDelegatedUserDecrypt() {\n  const sdk = useZamaSDK();\n  return useMutation<Record<Handle, ClearValueType>, Error, DelegatedUserDecryptParams>(\n    delegatedUserDecryptMutationOptions(sdk),\n  );\n}\n","\"use client\";\n\nimport type { InputProofBytesType, ZKProofLike } from \"@zama-fhe/sdk\";\nimport { useMutation } from \"@tanstack/react-query\";\nimport { requestZKProofVerificationMutationOptions } from \"@zama-fhe/sdk/query\";\nimport { useZamaSDK } from \"../provider\";\n\n/**\n * Submit a ZK proof for on-chain verification.\n * Returns the input proof bytes for use in contract calls.\n *\n * @returns A mutation whose `mutate` accepts a {@link ZKProofLike}.\n *\n * @example\n * ```tsx\n * const verify = useRequestZKProofVerification();\n * verify.mutate(zkProof);\n * // verify.data => Uint8Array (input proof bytes)\n * ```\n */\nexport function useRequestZKProofVerification() {\n  const sdk = useZamaSDK();\n  return useMutation<InputProofBytesType, Error, ZKProofLike>(\n    requestZKProofVerificationMutationOptions(sdk),\n  );\n}\n","import {\n  type DefaultError,\n  type QueriesOptions,\n  type QueriesResults,\n  useQueries as tanstack_useQueries,\n  useQuery as tanstack_useQuery,\n  useSuspenseQuery as tanstack_useSuspenseQuery,\n  type UseQueryOptions,\n  type UseQueryResult,\n  type UseSuspenseQueryOptions,\n  type UseSuspenseQueryResult,\n} from \"@tanstack/react-query\";\nimport { hashFn } from \"@zama-fhe/sdk/query\";\n\n/**\n * Thin wrapper around TanStack's useQuery that injects our custom queryKeyHashFn.\n * Mirrors the wagmi pattern — the type safety boundary is at the factory and hook levels.\n *\n * Callers typically specify only `<TData>` (e.g. `useQuery<PublicKeyData>(...)`) while\n * factory options carry specific tuple keys (e.g. `readonly [\"zama.publicKey\"]`).\n * We erase the QueryKey param via `AnyKeyQueryOptions` so callers don't need to\n * spell out the key type — any QueryKey subtype is accepted.\n */\ntype AnyKeyQueryOptions<TData, TError> = UseQueryOptions<\n  TData,\n  TError,\n  TData,\n  // oxlint-disable-next-line typescript/no-explicit-any\n  any\n>;\ntype AnyKeySuspenseOptions<TData, TError> = UseSuspenseQueryOptions<\n  TData,\n  TError,\n  TData,\n  // oxlint-disable-next-line typescript/no-explicit-any\n  any\n>;\n\nexport function useQuery<TData = unknown, TError = DefaultError>(\n  options: AnyKeyQueryOptions<TData, TError>,\n): UseQueryResult<TData, TError> {\n  return tanstack_useQuery({\n    ...options,\n    queryKeyHashFn: hashFn,\n  });\n}\n\nexport function useSuspenseQuery<TData = unknown, TError = DefaultError>(\n  options: AnyKeySuspenseOptions<TData, TError>,\n): UseSuspenseQueryResult<TData, TError> {\n  return tanstack_useSuspenseQuery({\n    ...options,\n    queryKeyHashFn: hashFn,\n  });\n}\n\n/**\n * Thin wrapper around TanStack's useQueries that injects our custom queryKeyHashFn\n * on every query in the array.\n */\nexport function useQueries<\n  // oxlint-disable-next-line typescript/no-explicit-any\n  T extends Array<any>,\n  TCombinedResult = QueriesResults<T>,\n>({\n  queries,\n  ...options\n}: {\n  queries: readonly [...QueriesOptions<T>];\n  combine?: (result: QueriesResults<T>) => TCombinedResult;\n  subscribed?: boolean;\n}): TCombinedResult {\n  return tanstack_useQueries({\n    ...options,\n    queries: queries.map((q) => ({\n      ...q,\n      queryKeyHashFn: hashFn,\n    })) as [...QueriesOptions<T>],\n  });\n}\n","\"use client\";\n\nimport { useQuery } from \"../utils/query\";\nimport { publicKeyQueryOptions } from \"@zama-fhe/sdk/query\";\nimport { useZamaSDK } from \"../provider\";\n\nexport { publicKeyQueryOptions };\n\n/** Shape of the FHE public key data returned by the relayer. */\nexport interface PublicKeyData {\n  /** Unique identifier for this public key version. */\n  publicKeyId: string;\n  /** The raw FHE public key bytes. */\n  publicKey: Uint8Array;\n}\n\n/**\n * Fetch the FHE network public key from the relayer.\n * Cached indefinitely since the key does not change during a session.\n *\n * @returns Query result with `data: PublicKeyData | null`.\n *\n * @example\n * ```tsx\n * const { data: publicKey } = usePublicKey();\n * // publicKey?.publicKeyId, publicKey?.publicKey\n * ```\n */\nexport function usePublicKey() {\n  const sdk = useZamaSDK();\n  return useQuery<PublicKeyData | null>({\n    ...publicKeyQueryOptions(sdk),\n  });\n}\n","\"use client\";\n\nimport { useQuery } from \"../utils/query\";\nimport { publicParamsQueryOptions } from \"@zama-fhe/sdk/query\";\nimport { useZamaSDK } from \"../provider\";\n\nexport { publicParamsQueryOptions };\n\n/** Shape of the FHE public parameters returned by the relayer. */\nexport interface PublicParamsData {\n  /** The raw public parameters bytes (WASM-ready). */\n  publicParams: Uint8Array;\n  /** Unique identifier for this public params version. */\n  publicParamsId: string;\n}\n\n/**\n * Fetch FHE public parameters for a given bit size from the relayer.\n * Cached indefinitely since parameters do not change during a session.\n *\n * @param bits - The FHE bit size to fetch parameters for (e.g. 2048).\n * @returns Query result with `data: PublicParamsData | null`.\n *\n * @example\n * ```tsx\n * const { data: params } = usePublicParams(2048);\n * // params?.publicParams, params?.publicParamsId\n * ```\n */\nexport function usePublicParams(bits: number) {\n  const sdk = useZamaSDK();\n  return useQuery<PublicParamsData | null>({\n    ...publicParamsQueryOptions(sdk, bits),\n  });\n}\n","\"use client\";\n\nimport { useQuery } from \"../utils/query\";\nimport type { ClearValueType, Handle } from \"@zama-fhe/sdk\";\nimport { zamaQueryKeys } from \"@zama-fhe/sdk/query\";\n\n/**\n * Look up a single cached decrypted value by its handle.\n * Values are populated automatically when `useUserDecrypt` or `usePublicDecrypt` succeed.\n * You can also populate manually via queryClient.setQueryData(zamaQueryKeys.decryption.handle(handle), value).\n */\nexport function useUserDecryptedValue(handle: Handle | undefined) {\n  return useQuery<ClearValueType>({\n    queryKey: zamaQueryKeys.decryption.handle(handle ?? \"0x\"),\n    queryFn: () => undefined as never,\n    enabled: false,\n  });\n}\n","\"use client\";\n\nimport type { ClearValueType, Handle } from \"@zama-fhe/sdk\";\nimport { zamaQueryKeys } from \"@zama-fhe/sdk/query\";\nimport { useQueries } from \"../utils/query\";\n\n/**\n * Look up multiple cached decrypted values by their handles.\n * Values are populated automatically when `useUserDecrypt` or `usePublicDecrypt` succeed.\n */\nexport function useUserDecryptedValues(handles: Handle[]) {\n  const results = useQueries({\n    queries: handles.map((handle) => ({\n      queryKey: zamaQueryKeys.decryption.handle(handle),\n      queryFn: () => undefined as never,\n      enabled: false,\n    })),\n  });\n\n  const data: Record<Handle, ClearValueType | undefined> = {};\n  for (let i = 0; i < handles.length; i++) {\n    data[handles[i]!] = results[i]!.data as ClearValueType | undefined;\n  }\n\n  return {\n    data,\n    results,\n  };\n}\n","\"use client\";\n\nimport { useMutation, type UseMutationOptions } from \"@tanstack/react-query\";\nimport type { Address } from \"@zama-fhe/sdk\";\nimport { allowMutationOptions, zamaQueryKeys } from \"@zama-fhe/sdk/query\";\nimport { useZamaSDK } from \"../provider\";\n\n/**\n * Sign an EIP-712 message authorizing decryption of confidential handles\n * for a list of contract addresses. This is not token-specific — any\n * contract that uses FHE-encrypted values (tokens, DeFi vaults, games, etc.)\n * can be authorized in a single wallet signature. Subsequent decrypt\n * operations on any of these contracts reuse cached credentials.\n *\n * Errors are {@link ZamaError} subclasses — use `instanceof` to handle specific failures:\n * - {@link SigningRejectedError} — user rejected the wallet prompt\n * - {@link KeypairExpiredError} — the re-encryption keypair has expired\n *\n * @example\n * ```tsx\n * const { mutateAsync: allow, isPending } = useAllow();\n *\n * // Authorize decryption for any contracts with encrypted state:\n * // confidential tokens, auction contracts, governance contracts, etc.\n * await allow([tokenAddress, auctionAddress, governanceAddress]);\n * ```\n */\nexport function useAllow(options?: UseMutationOptions<void, Error, Address[]>) {\n  const sdk = useZamaSDK();\n\n  return useMutation<void, Error, Address[]>({\n    ...allowMutationOptions(sdk),\n    ...options,\n    onSuccess: (data, variables, onMutateResult, context) => {\n      options?.onSuccess?.(data, variables, onMutateResult, context);\n      void context.client.invalidateQueries({ queryKey: zamaQueryKeys.isAllowed.all });\n    },\n  });\n}\n","\"use client\";\n\nimport { useQuery } from \"../utils/query\";\nimport { skipToken } from \"@tanstack/react-query\";\nimport type { Address } from \"@zama-fhe/sdk\";\nimport {\n  isAllowedQueryOptions,\n  signerAddressQueryOptions,\n  zamaQueryKeys,\n} from \"@zama-fhe/sdk/query\";\nimport { useZamaSDK } from \"../provider\";\n\n/**\n * Check whether a session signature is cached for the connected wallet.\n * Returns `true` if decrypt operations can proceed without a wallet prompt.\n *\n * @example\n * ```tsx\n * const { data: allowed } = useIsAllowed();\n * ```\n */\nexport function useIsAllowed() {\n  const sdk = useZamaSDK();\n  const addressQuery = useQuery<Address>({\n    ...signerAddressQueryOptions(sdk.signer),\n  });\n  const account = addressQuery.data;\n  const baseOpts = account\n    ? isAllowedQueryOptions(sdk, { account })\n    : ({\n        queryKey: zamaQueryKeys.isAllowed.all,\n        queryFn: skipToken,\n        enabled: false,\n      } as const);\n\n  return useQuery<boolean>(baseOpts);\n}\n","\"use client\";\n\nimport { useMutation, type UseMutationOptions } from \"@tanstack/react-query\";\nimport type { Address } from \"@zama-fhe/sdk\";\nimport { revokeMutationOptions, zamaQueryKeys } from \"@zama-fhe/sdk/query\";\nimport { useZamaSDK } from \"../provider\";\n\n/**\n * Revoke stored FHE decrypt credentials for a list of contract addresses.\n * This is not token-specific — it revokes the EIP-712 authorization for\n * any contract that uses FHE-encrypted values. The next decrypt operation\n * on these contracts will require a fresh wallet signature.\n *\n * @example\n * ```tsx\n * const { mutate: revoke } = useRevoke();\n *\n * // Revoke for any contracts: tokens, auctions, governance, etc.\n * revoke([tokenAddress, auctionAddress]);\n * ```\n */\nexport function useRevoke(options?: UseMutationOptions<void, Error, Address[]>) {\n  const sdk = useZamaSDK();\n\n  return useMutation<void, Error, Address[]>({\n    ...revokeMutationOptions(sdk),\n    ...options,\n    onSuccess: (data, variables, onMutateResult, context) => {\n      options?.onSuccess?.(data, variables, onMutateResult, context);\n      void context.client.invalidateQueries({ queryKey: zamaQueryKeys.isAllowed.all });\n    },\n  });\n}\n","\"use client\";\n\nimport { useMutation, type UseMutationOptions } from \"@tanstack/react-query\";\nimport { revokeSessionMutationOptions, zamaQueryKeys } from \"@zama-fhe/sdk/query\";\nimport { useZamaSDK } from \"../provider\";\n\n/**\n * Revoke the session signature for the connected wallet without\n * specifying contract addresses. Useful for wallet disconnect handlers.\n *\n * @example\n * ```tsx\n * const { mutate: revokeSession } = useRevokeSession();\n * revokeSession();\n * ```\n */\nexport function useRevokeSession(options?: UseMutationOptions<void>) {\n  const sdk = useZamaSDK();\n\n  return useMutation<void>({\n    ...revokeSessionMutationOptions(sdk),\n    ...options,\n    onSuccess: (data, variables, onMutateResult, context) => {\n      options?.onSuccess?.(data, variables, onMutateResult, context);\n      void context.client.invalidateQueries({ queryKey: zamaQueryKeys.isAllowed.all });\n    },\n  });\n}\n","\"use client\";\n\nimport { useMemo } from \"react\";\nimport type { Address } from \"@zama-fhe/sdk\";\nimport { useZamaSDK } from \"../provider\";\n\n/** Base configuration shared by all mutation hooks that need a Token instance. */\nexport interface UseZamaConfig {\n  /** Address of the confidential token contract. */\n  tokenAddress: Address;\n  /** Address of the wrapper contract (required for shield/unshield operations). */\n  wrapperAddress?: Address;\n}\n\n/**\n * Get a {@link Token} instance, memoized by address pair.\n * Reads signer and storage from the nearest {@link ZamaProvider}.\n *\n * @param config - Token and optional wrapper addresses.\n * @returns A memoized `Token` instance.\n *\n * @example\n * ```tsx\n * const token = useToken({ tokenAddress: \"0xToken\", wrapperAddress: \"0xWrapper\" });\n * ```\n */\nexport function useToken(config: UseZamaConfig) {\n  const sdk = useZamaSDK();\n\n  return useMemo(\n    () => sdk.createToken(config.tokenAddress, config.wrapperAddress),\n    [sdk, config.tokenAddress, config.wrapperAddress],\n  );\n}\n","\"use client\";\n\nimport { useMemo } from \"react\";\nimport type { Address } from \"@zama-fhe/sdk\";\nimport { useZamaSDK } from \"../provider\";\n\n/**\n * Get a {@link ReadonlyToken} instance, memoized by address.\n * Supports balance queries, ERC-165 checks, and authorization — no wrapper needed.\n * Reads signer and storage from the nearest {@link ZamaProvider}.\n *\n * @param address - Address of the confidential token contract.\n * @returns A memoized `ReadonlyToken` instance.\n *\n * @example\n * ```tsx\n * const token = useReadonlyToken(\"0xToken\");\n * // token.balanceOf(), token.isConfidential(), etc.\n * ```\n */\nexport function useReadonlyToken(address: Address) {\n  const sdk = useZamaSDK();\n\n  return useMemo(() => sdk.createReadonlyToken(address), [sdk, address]);\n}\n","\"use client\";\n\nimport { useQuery } from \"../utils/query\";\nimport type { UseQueryOptions } from \"@tanstack/react-query\";\nimport type { Address, Handle } from \"@zama-fhe/sdk\";\nimport {\n  confidentialBalanceQueryOptions,\n  confidentialHandleQueryOptions,\n  signerAddressQueryOptions,\n} from \"@zama-fhe/sdk/query\";\nimport { useReadonlyToken } from \"../token/use-readonly-token\";\n\n/** Configuration for {@link useConfidentialBalance}. */\nexport interface UseConfidentialBalanceConfig {\n  /** Address of the confidential token contract. */\n  tokenAddress: Address;\n  /** Polling interval (ms) for the encrypted handle. Default: 10 000. */\n  handleRefetchInterval?: number;\n}\n\n/** Query options for the decrypt phase of {@link useConfidentialBalance}. */\nexport interface UseConfidentialBalanceOptions extends Omit<\n  UseQueryOptions<bigint>,\n  \"queryKey\" | \"queryFn\" | \"enabled\"\n> {\n  /** Whether the query is enabled. Callback form is not supported in composite hooks. */\n  enabled?: boolean;\n}\n\n/**\n * Declarative hook to read the connected wallet's confidential token balance.\n * Uses two-phase polling: cheaply polls the encrypted handle, then only\n * decrypts when the handle changes (new balance).\n *\n * @param config - Token address and optional polling interval.\n * @param options - React Query options forwarded to the decrypt query.\n * @returns The decrypt query result plus `handleQuery` for Phase 1 state.\n *\n * @example\n * ```tsx\n * const { data: balance, isLoading, handleQuery } = useConfidentialBalance({\n *   tokenAddress: \"0x...\",\n * });\n * ```\n */\nexport function useConfidentialBalance(\n  config: UseConfidentialBalanceConfig,\n  options?: UseConfidentialBalanceOptions,\n) {\n  const { tokenAddress, handleRefetchInterval } = config;\n  const { enabled = true } = options ?? {};\n  const token = useReadonlyToken(tokenAddress);\n\n  const addressQuery = useQuery<Address>({\n    ...signerAddressQueryOptions(token.signer),\n  });\n\n  const owner = addressQuery.data;\n\n  // Phase 1: Poll the encrypted handle (cheap RPC read, no signing)\n  const baseHandleQueryOptions = confidentialHandleQueryOptions(token.signer, tokenAddress, {\n    owner,\n    pollingInterval: handleRefetchInterval,\n  });\n  const handleQuery = useQuery<Handle>({\n    ...baseHandleQueryOptions,\n    enabled: baseHandleQueryOptions.enabled && enabled,\n  });\n\n  // Phase 2: Decrypt only when handle changes (expensive relayer roundtrip)\n  const handle = handleQuery.data;\n  const baseBalanceQueryOptions = confidentialBalanceQueryOptions(token, {\n    handle,\n    owner,\n  });\n  const balanceQuery = useQuery<bigint>({\n    ...baseBalanceQueryOptions,\n    ...options,\n    enabled: baseBalanceQueryOptions.enabled && enabled,\n  });\n\n  return { ...balanceQuery, handleQuery };\n}\n","\"use client\";\n\nimport { useMemo } from \"react\";\nimport { useQuery } from \"../utils/query\";\nimport type { UseQueryOptions } from \"@tanstack/react-query\";\nimport type { Address, Handle } from \"@zama-fhe/sdk\";\nimport {\n  confidentialBalancesQueryOptions,\n  confidentialHandlesQueryOptions,\n  signerAddressQueryOptions,\n  type ConfidentialBalancesData,\n} from \"@zama-fhe/sdk/query\";\nimport { useZamaSDK } from \"../provider\";\n\n/** Configuration for {@link useConfidentialBalances}. */\nexport interface UseConfidentialBalancesConfig {\n  /** Addresses of the confidential token contracts to batch-query. */\n  tokenAddresses: Address[];\n  /** Polling interval (ms) for the encrypted handles. Default: 10 000. */\n  handleRefetchInterval?: number;\n  /** Maximum number of concurrent decrypt calls. Default: `Infinity` (no limit). */\n  maxConcurrency?: number;\n}\n\nexport type { ConfidentialBalancesData };\n\n/** Query options for the decrypt phase of {@link useConfidentialBalances}. */\nexport interface UseConfidentialBalancesOptions extends Omit<\n  UseQueryOptions<ConfidentialBalancesData>,\n  \"queryKey\" | \"queryFn\" | \"enabled\"\n> {\n  /** Whether the query is enabled. Callback form is not supported in composite hooks. */\n  enabled?: boolean;\n}\n\n/**\n * Declarative hook to read multiple confidential token balances in batch.\n * Uses two-phase polling: cheaply polls encrypted handles, then only\n * decrypts when any handle changes.\n *\n * Returns partial results when some tokens fail — successful balances are\n * always returned alongside per-token error information.\n *\n * @param config - Token addresses and optional polling interval.\n * @param options - React Query options forwarded to the decrypt query.\n * @returns The decrypt query result plus `handlesQuery` for Phase 1 state.\n *\n * @example\n * ```tsx\n * const { data } = useConfidentialBalances({\n *   tokenAddresses: [\"0xTokenA\", \"0xTokenB\"],\n * });\n * const balance = data?.balances.get(\"0xTokenA\");\n * if (data?.isPartialError) {\n *   // some tokens failed — check data.errors\n * }\n * ```\n */\nexport function useConfidentialBalances(\n  config: UseConfidentialBalancesConfig,\n  options?: UseConfidentialBalancesOptions,\n) {\n  const { tokenAddresses, handleRefetchInterval, maxConcurrency } = config;\n  const { enabled = true } = options ?? {};\n  const sdk = useZamaSDK();\n\n  const addressQuery = useQuery<Address>({\n    ...signerAddressQueryOptions(sdk.signer),\n  });\n\n  const owner = addressQuery.data;\n\n  const tokens = useMemo(\n    () => tokenAddresses.map((addr) => sdk.createReadonlyToken(addr)),\n    [sdk, tokenAddresses],\n  );\n\n  // Phase 1: Poll all encrypted handles (cheap RPC reads)\n  const baseHandlesQueryOptions = confidentialHandlesQueryOptions(sdk.signer, tokenAddresses, {\n    owner,\n    pollingInterval: handleRefetchInterval,\n  });\n  const handlesQuery = useQuery<Handle[]>({\n    ...baseHandlesQueryOptions,\n    enabled: baseHandlesQueryOptions.enabled && enabled,\n  });\n\n  // Phase 2: Batch decrypt only when any handle changes\n  const handles = handlesQuery.data;\n  const handlesReady = Array.isArray(handles) && handles.length === tokenAddresses.length;\n  const baseBalancesQueryOptions = confidentialBalancesQueryOptions(tokens, {\n    owner,\n    handles,\n    maxConcurrency,\n    resultAddresses: tokenAddresses,\n  });\n  const factoryEnabled = baseBalancesQueryOptions.enabled ?? true;\n\n  const balancesQuery = useQuery<ConfidentialBalancesData>({\n    ...baseBalancesQueryOptions,\n    ...options,\n    enabled: factoryEnabled && handlesReady && enabled,\n  });\n\n  return { ...balancesQuery, handlesQuery };\n}\n","import type { QueryClient, QueryKey, UseMutationOptions } from \"@tanstack/react-query\";\nimport type { Address, TransactionResult } from \"@zama-fhe/sdk\";\nimport { invalidateAfterShield, zamaQueryKeys } from \"@zama-fhe/sdk/query\";\n\ntype BalanceDeltaMode = \"add\" | \"subtract\";\nexport type OptimisticBalanceSnapshot = [QueryKey, bigint | undefined][];\n\n/** Combined context returned by optimistic `onMutate`. */\nexport interface OptimisticMutateContext {\n  snapshot: OptimisticBalanceSnapshot;\n  callerContext?: unknown;\n}\n\nexport function unwrapOptimisticCallerContext(\n  optimistic: boolean | undefined,\n  rawContext: unknown,\n): {\n  wrappedContext: OptimisticMutateContext | undefined;\n  callerContext: OptimisticMutateContext | undefined;\n} {\n  const typed = rawContext as OptimisticMutateContext | undefined;\n  const wrappedContext = optimistic ? typed : undefined;\n  const callerContext = (optimistic ? wrappedContext?.callerContext : rawContext) as\n    | OptimisticMutateContext\n    | undefined;\n  return { wrappedContext, callerContext };\n}\n\nexport async function applyOptimisticBalanceDelta({\n  queryClient,\n  tokenAddress,\n  amount,\n  mode,\n}: {\n  queryClient: QueryClient;\n  tokenAddress: Address;\n  amount: bigint;\n  mode: BalanceDeltaMode;\n}): Promise<OptimisticBalanceSnapshot> {\n  const balanceKey = zamaQueryKeys.confidentialBalance.token(tokenAddress);\n  await queryClient.cancelQueries({ queryKey: balanceKey });\n  const previous = queryClient.getQueriesData<bigint>({ queryKey: balanceKey });\n  for (const [key, value] of previous) {\n    if (value === undefined) {\n      continue;\n    }\n    // Temporary optimistic underflow (`amount > value`) is acceptable because\n    // settlement invalidates and rewrites this cache entry.\n    queryClient.setQueryData(key, mode === \"add\" ? value + amount : value - amount);\n  }\n  return previous;\n}\n\nexport function rollbackOptimisticBalanceDelta(\n  queryClient: QueryClient,\n  snapshot: OptimisticBalanceSnapshot,\n) {\n  for (const [key, value] of snapshot) {\n    queryClient.setQueryData(key, value);\n  }\n}\n\n/**\n * Build optimistic mutation callbacks for shield operations.\n * Wraps the caller's `onMutate`/`onError`/`onSuccess`/`onSettled` with snapshot/rollback logic\n * and returns overrides ready to spread into `useMutation`.\n */\nexport function optimisticBalanceCallbacks<TParams extends { amount: bigint }>({\n  optimistic,\n  tokenAddress,\n  queryClient,\n  options,\n}: {\n  optimistic: boolean | undefined;\n  tokenAddress: Address;\n  queryClient: QueryClient;\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  options: UseMutationOptions<TransactionResult, Error, TParams, any> | undefined;\n}): Pick<\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  UseMutationOptions<TransactionResult, Error, TParams, any>,\n  \"onMutate\" | \"onError\" | \"onSuccess\" | \"onSettled\"\n> {\n  return {\n    onMutate: optimistic\n      ? async (variables, mutationContext) => {\n          const snapshot = await applyOptimisticBalanceDelta({\n            queryClient,\n            tokenAddress,\n            amount: variables.amount,\n            mode: \"add\",\n          });\n          const callerContext = await options?.onMutate?.(variables, mutationContext);\n          return { snapshot, callerContext };\n        }\n      : options?.onMutate,\n    onError: (error, variables, rawContext, context) => {\n      const { wrappedContext, callerContext } = unwrapOptimisticCallerContext(\n        optimistic,\n        rawContext,\n      );\n      try {\n        if (wrappedContext) {\n          rollbackOptimisticBalanceDelta(queryClient, wrappedContext.snapshot);\n        }\n      } finally {\n        options?.onError?.(error, variables, callerContext, context);\n      }\n    },\n    onSuccess: (data, variables, rawContext, context) => {\n      const { callerContext } = unwrapOptimisticCallerContext(optimistic, rawContext);\n      options?.onSuccess?.(data, variables, callerContext, context);\n      invalidateAfterShield(context.client, tokenAddress);\n    },\n    onSettled: (data, error, variables, rawContext, context) => {\n      const { callerContext } = unwrapOptimisticCallerContext(optimistic, rawContext);\n      options?.onSettled?.(data, error, variables, callerContext, context);\n    },\n  };\n}\n","\"use client\";\n\nimport {\n  useMutation,\n  useQueryClient,\n  type UseMutationOptions,\n  type UseMutationResult,\n} from \"@tanstack/react-query\";\nimport type { TransactionResult } from \"@zama-fhe/sdk\";\nimport {\n  confidentialTransferMutationOptions,\n  invalidateAfterTransfer,\n  type ConfidentialTransferParams,\n} from \"@zama-fhe/sdk/query\";\nimport {\n  applyOptimisticBalanceDelta,\n  rollbackOptimisticBalanceDelta,\n  unwrapOptimisticCallerContext,\n} from \"../balance/optimistic-balance-update\";\nimport { useToken, type UseZamaConfig } from \"../token/use-token\";\n\n/** Configuration for {@link useConfidentialTransfer}. */\nexport interface UseConfidentialTransferConfig extends UseZamaConfig {\n  /**\n   * When `true`, optimistically subtracts the transfer amount from cached balance\n   * before the transaction confirms. Rolls back on error.\n   * @defaultValue false\n   */\n  optimistic?: boolean;\n}\n\n/**\n * Encrypt and send a confidential transfer. Invalidates balance caches on success.\n *\n * Errors are {@link ZamaError} subclasses — use `instanceof` to handle specific failures:\n * - {@link SigningRejectedError} — user rejected the wallet prompt\n * - {@link EncryptionFailedError} — FHE encryption failed\n * - {@link TransactionRevertedError} — on-chain transaction reverted\n *\n * @param config - Token address (and optional wrapper) identifying the token.\n *   Set `optimistic: true` to subtract the amount from the cached balance immediately.\n * @param options - React Query mutation options.\n *\n * @example\n * ```tsx\n * const transfer = useConfidentialTransfer({\n *   tokenAddress: \"0x...\",\n *   optimistic: true,\n * });\n * transfer.mutate(\n *   { to: \"0xRecipient\", amount: 1000n },\n *   {\n *     onError: (error) => {\n *       if (error instanceof SigningRejectedError) {\n *         // user cancelled — no action needed\n *       }\n *     },\n *   },\n * );\n * ```\n */\nexport function useConfidentialTransfer<TContext = unknown>(\n  config: UseConfidentialTransferConfig,\n  options?: UseMutationOptions<TransactionResult, Error, ConfidentialTransferParams, TContext>,\n): UseMutationResult<TransactionResult, Error, ConfidentialTransferParams, TContext> {\n  const token = useToken(config);\n  const queryClient = useQueryClient();\n\n  // Internal mutation uses `any` for TContext because optimistic mode wraps\n  // the caller's context in OptimisticMutateContext; the public return type\n  // is cast back to the caller's TContext.\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  return useMutation<TransactionResult, Error, ConfidentialTransferParams, any>({\n    ...confidentialTransferMutationOptions(token),\n    ...options,\n    onMutate: config.optimistic\n      ? async (variables, mutationContext) => {\n          const snapshot = await applyOptimisticBalanceDelta({\n            queryClient,\n            tokenAddress: config.tokenAddress,\n            amount: variables.amount,\n            mode: \"subtract\",\n          });\n          const callerContext = await options?.onMutate?.(variables, mutationContext);\n          return { snapshot, callerContext };\n        }\n      : options?.onMutate,\n    onError: (error, variables, rawContext, context) => {\n      const { wrappedContext, callerContext } = unwrapOptimisticCallerContext(\n        config.optimistic,\n        rawContext,\n      );\n      try {\n        if (wrappedContext) {\n          rollbackOptimisticBalanceDelta(queryClient, wrappedContext.snapshot);\n        }\n      } finally {\n        options?.onError?.(error, variables, callerContext as TContext, context);\n      }\n    },\n    onSuccess: (data, variables, rawContext, context) => {\n      const { callerContext } = unwrapOptimisticCallerContext(config.optimistic, rawContext);\n      options?.onSuccess?.(data, variables, callerContext as TContext, context);\n      invalidateAfterTransfer(context.client, config.tokenAddress);\n    },\n    onSettled: (data, error, variables, rawContext, context) => {\n      const { callerContext } = unwrapOptimisticCallerContext(config.optimistic, rawContext);\n      options?.onSettled?.(data, error, variables, callerContext as TContext, context);\n    },\n  }) as UseMutationResult<TransactionResult, Error, ConfidentialTransferParams, TContext>;\n}\n","\"use client\";\n\nimport type { UseMutationOptions } from \"@tanstack/react-query\";\nimport { useMutation } from \"@tanstack/react-query\";\nimport type { Address, TransactionResult } from \"@zama-fhe/sdk\";\nimport {\n  confidentialTransferFromMutationOptions,\n  invalidateAfterTransfer,\n  type ConfidentialTransferFromParams,\n} from \"@zama-fhe/sdk/query\";\nimport { useToken, type UseZamaConfig } from \"../token/use-token\";\n\n/**\n * Operator transfer on behalf of another address. Caller must be an approved operator.\n * Invalidates balance caches on success.\n *\n * Errors are {@link ZamaError} subclasses — use `instanceof` to handle specific failures:\n * - {@link SigningRejectedError} — user rejected the wallet prompt\n * - {@link EncryptionFailedError} — FHE encryption of the transfer amount failed\n * - {@link TransactionRevertedError} — on-chain transaction reverted\n *\n * @param config - Token address (and optional wrapper) identifying the token.\n * @param options - React Query mutation options.\n *\n * @example\n * ```tsx\n * const transferFrom = useConfidentialTransferFrom({ tokenAddress: \"0x...\" });\n * transferFrom.mutate({ from: \"0xOwner\", to: \"0xRecipient\", amount: 500n });\n * ```\n */\nexport function useConfidentialTransferFrom(\n  config: UseZamaConfig,\n  options?: UseMutationOptions<TransactionResult, Error, ConfidentialTransferFromParams, Address>,\n) {\n  const token = useToken(config);\n\n  return useMutation<TransactionResult, Error, ConfidentialTransferFromParams, Address>({\n    ...confidentialTransferFromMutationOptions(token),\n    ...options,\n    onSuccess: (data, variables, onMutateResult, context) => {\n      options?.onSuccess?.(data, variables, onMutateResult, context);\n      invalidateAfterTransfer(context.client, config.tokenAddress);\n    },\n  });\n}\n","\"use client\";\n\nimport type { UseMutationOptions } from \"@tanstack/react-query\";\nimport { useMutation } from \"@tanstack/react-query\";\nimport type { Address, TransactionResult } from \"@zama-fhe/sdk\";\nimport {\n  confidentialApproveMutationOptions,\n  invalidateAfterApprove,\n  type ConfidentialApproveParams,\n} from \"@zama-fhe/sdk/query\";\nimport { useToken, type UseZamaConfig } from \"../token/use-token\";\n\n/**\n * Set operator approval for a confidential token. Defaults to 1 hour.\n *\n * Errors are {@link ZamaError} subclasses — use `instanceof` to handle specific failures:\n * - {@link SigningRejectedError} — user rejected the wallet prompt\n * - {@link TransactionRevertedError} — on-chain transaction reverted\n *\n * @param config - Token address (and optional wrapper) identifying the token.\n * @param options - React Query mutation options.\n *\n * @example\n * ```tsx\n * const approve = useConfidentialApprove({ tokenAddress: \"0x...\" });\n * approve.mutate({ spender: \"0xOperator\" });\n * ```\n */\nexport function useConfidentialApprove(\n  config: UseZamaConfig,\n  options?: UseMutationOptions<TransactionResult, Error, ConfidentialApproveParams, Address>,\n) {\n  const token = useToken(config);\n\n  return useMutation<TransactionResult, Error, ConfidentialApproveParams, Address>({\n    ...confidentialApproveMutationOptions(token),\n    ...options,\n    onSuccess: (data, variables, onMutateResult, context) => {\n      options?.onSuccess?.(data, variables, onMutateResult, context);\n      invalidateAfterApprove(context.client, config.tokenAddress);\n    },\n  });\n}\n","\"use client\";\n\nimport { useQuery, useSuspenseQuery } from \"../utils/query\";\nimport type { UseQueryOptions } from \"@tanstack/react-query\";\nimport type { Address } from \"@zama-fhe/sdk\";\nimport { confidentialIsApprovedQueryOptions, signerAddressQueryOptions } from \"@zama-fhe/sdk/query\";\nimport { useZamaSDK } from \"../provider\";\nimport { useToken, type UseZamaConfig } from \"../token/use-token\";\n\nexport { confidentialIsApprovedQueryOptions };\n\n/** Configuration for {@link useConfidentialIsApproved}. */\nexport interface UseConfidentialIsApprovedConfig {\n  /** Address of the confidential token contract. Pass `undefined` to disable the query. */\n  tokenAddress: Address | undefined;\n  /** Address to check approval for. Pass `undefined` to disable the query. */\n  spender: Address | undefined;\n  /** Token holder address. Defaults to the connected wallet. */\n  holder?: Address;\n}\n\n/** Configuration for {@link useConfidentialIsApprovedSuspense}. */\nexport interface UseConfidentialIsApprovedSuspenseConfig extends UseZamaConfig {\n  /** Address to check approval for. */\n  spender: Address;\n  /** Token holder address. Defaults to the connected wallet. */\n  holder?: Address;\n}\n\n/**\n * Check if a spender is an approved operator for a given holder (defaults to connected wallet).\n *\n * @param config - Token address, spender, and optional holder to check.\n * @param options - React Query options (forwarded to `useQuery`).\n * @returns Query result with `data: boolean`.\n *\n * @example\n * ```tsx\n * const { data: isApproved } = useConfidentialIsApproved({\n *   tokenAddress: \"0xToken\",\n *   spender: \"0xSpender\",\n *   holder: \"0xHolder\", // optional\n * });\n * ```\n */\nexport function useConfidentialIsApproved(\n  config: UseConfidentialIsApprovedConfig,\n  options?: Omit<UseQueryOptions<boolean>, \"queryKey\" | \"queryFn\">,\n) {\n  const { tokenAddress, spender, holder } = config;\n  const sdk = useZamaSDK();\n  const holderQuery = useQuery<Address>({\n    ...signerAddressQueryOptions(sdk.signer),\n    enabled: tokenAddress !== undefined && spender !== undefined && holder === undefined,\n  });\n  const resolvedHolder = holder ?? holderQuery.data;\n  const baseOpts = confidentialIsApprovedQueryOptions(sdk.signer, tokenAddress, {\n    holder: resolvedHolder,\n    spender,\n  });\n  return useQuery({\n    ...baseOpts,\n    ...options,\n    enabled: (baseOpts.enabled ?? true) && (options?.enabled ?? true),\n  });\n}\n\n/**\n * Suspense variant of {@link useConfidentialIsApproved}.\n * Suspends rendering until the approval check resolves.\n *\n * @param config - Token address, spender, and optional holder to check.\n * @returns Suspense query result with `data: boolean`.\n *\n * @example\n * ```tsx\n * const { data: isApproved } = useConfidentialIsApprovedSuspense({\n *   tokenAddress: \"0xToken\",\n *   spender: \"0xSpender\",\n *   holder: \"0xHolder\", // optional\n * });\n * ```\n */\nexport function useConfidentialIsApprovedSuspense(config: UseConfidentialIsApprovedSuspenseConfig) {\n  const { spender, holder, ...tokenConfig } = config;\n  const token = useToken(tokenConfig);\n  const addressQuery = useSuspenseQuery<Address>({\n    ...signerAddressQueryOptions(token.signer),\n  });\n  const resolvedHolder = holder ?? addressQuery.data;\n\n  return useSuspenseQuery<boolean>({\n    ...confidentialIsApprovedQueryOptions(token.signer, token.address, {\n      holder: resolvedHolder,\n      spender,\n    }),\n  });\n}\n","\"use client\";\n\nimport {\n  useMutation,\n  useQueryClient,\n  type UseMutationOptions,\n  type UseMutationResult,\n} from \"@tanstack/react-query\";\nimport type { TransactionResult } from \"@zama-fhe/sdk\";\nimport { shieldMutationOptions, type ShieldParams } from \"@zama-fhe/sdk/query\";\nimport { optimisticBalanceCallbacks } from \"../balance/optimistic-balance-update\";\nimport { useToken, type UseZamaConfig } from \"../token/use-token\";\n\n/** Configuration for {@link useShield}. */\nexport interface UseShieldConfig extends UseZamaConfig {\n  /**\n   * When `true`, optimistically adds the wrap amount to the cached confidential balance\n   * before the transaction confirms. Rolls back on error.\n   * @defaultValue false\n   */\n  optimistic?: boolean;\n}\n\n/**\n * Shield public ERC-20 tokens into confidential tokens.\n * Handles ERC-20 approval automatically. Invalidates balance caches on success.\n *\n * Errors are {@link ZamaError} subclasses — use `instanceof` to handle specific failures:\n * - {@link SigningRejectedError} — user rejected the wallet prompt\n * - {@link ApprovalFailedError} — ERC-20 approval transaction failed\n * - {@link TransactionRevertedError} — shield transaction reverted\n *\n * @param config - Token and wrapper addresses.\n *   Set `optimistic: true` to add the amount to the cached balance immediately.\n * @param options - React Query mutation options.\n *\n * @example\n * ```tsx\n * const shield = useShield({ tokenAddress: \"0x...\", wrapperAddress: \"0x...\", optimistic: true });\n * shield.mutate({ amount: 1000n });\n * ```\n */\nexport function useShield<TContext = unknown>(\n  config: UseShieldConfig,\n  options?: UseMutationOptions<TransactionResult, Error, ShieldParams, TContext>,\n): UseMutationResult<TransactionResult, Error, ShieldParams, TContext> {\n  const token = useToken(config);\n  const queryClient = useQueryClient();\n\n  return useMutation({\n    ...shieldMutationOptions(token),\n    ...options,\n    ...optimisticBalanceCallbacks({\n      optimistic: config.optimistic,\n      tokenAddress: config.tokenAddress,\n      queryClient,\n      options,\n    }),\n  }) as UseMutationResult<TransactionResult, Error, ShieldParams, TContext>;\n}\n","\"use client\";\n\nimport {\n  useMutation,\n  useQueryClient,\n  type UseMutationOptions,\n  type UseMutationResult,\n} from \"@tanstack/react-query\";\nimport type { TransactionResult } from \"@zama-fhe/sdk\";\nimport { shieldETHMutationOptions, type ShieldETHParams } from \"@zama-fhe/sdk/query\";\nimport { optimisticBalanceCallbacks } from \"../balance/optimistic-balance-update\";\nimport { useToken, type UseZamaConfig } from \"../token/use-token\";\n\n/** Configuration for {@link useShieldETH}. */\nexport interface UseShieldETHConfig extends UseZamaConfig {\n  /**\n   * When `true`, optimistically adds the wrap amount to the cached confidential balance\n   * before the transaction confirms. Rolls back on error.\n   * @defaultValue false\n   */\n  optimistic?: boolean;\n}\n\n/**\n * Shield native ETH into confidential tokens.\n * Handles wrapping automatically. Invalidates balance caches on success.\n *\n * Errors are {@link ZamaError} subclasses — use `instanceof` to handle specific failures:\n * - {@link SigningRejectedError} — user rejected the wallet prompt\n * - {@link TransactionRevertedError} — shield transaction reverted\n *\n * @param config - Token and wrapper addresses.\n *   Set `optimistic: true` to add the amount to the cached balance immediately.\n * @param options - React Query mutation options.\n *\n * @example\n * ```tsx\n * const shieldETH = useShieldETH({ tokenAddress: \"0x...\", wrapperAddress: \"0x...\", optimistic: true });\n * shieldETH.mutate({ amount: 1000000000000000000n }); // 1 ETH\n * ```\n */\nexport function useShieldETH<TContext = unknown>(\n  config: UseShieldETHConfig,\n  options?: UseMutationOptions<TransactionResult, Error, ShieldETHParams, TContext>,\n): UseMutationResult<TransactionResult, Error, ShieldETHParams, TContext> {\n  const token = useToken(config);\n  const queryClient = useQueryClient();\n\n  return useMutation({\n    ...shieldETHMutationOptions(token),\n    ...options,\n    ...optimisticBalanceCallbacks({\n      optimistic: config.optimistic,\n      tokenAddress: config.tokenAddress,\n      queryClient,\n      options,\n    }),\n  }) as UseMutationResult<TransactionResult, Error, ShieldETHParams, TContext>;\n}\n","\"use client\";\n\nimport type { UseMutationOptions } from \"@tanstack/react-query\";\nimport { useMutation } from \"@tanstack/react-query\";\nimport type { Address, TransactionResult } from \"@zama-fhe/sdk\";\nimport {\n  invalidateAfterUnwrap,\n  type UnwrapParams,\n  unwrapMutationOptions,\n} from \"@zama-fhe/sdk/query\";\nimport { useToken, type UseZamaConfig } from \"../token/use-token\";\n\n/**\n * Request an unwrap for a specific amount. Encrypts the amount first.\n * Call {@link useFinalizeUnwrap} after the request is processed on-chain,\n * or use {@link useUnshield} for a single-call orchestration.\n *\n * Errors are {@link ZamaError} subclasses — use `instanceof` to handle specific failures:\n * - {@link SigningRejectedError} — user rejected the wallet prompt\n * - {@link EncryptionFailedError} — FHE encryption of the unwrap amount failed\n * - {@link TransactionRevertedError} — on-chain transaction reverted\n *\n * @param config - Token address (and optional wrapper) identifying the token.\n * @param options - React Query mutation options.\n *\n * @example\n * ```tsx\n * const unwrap = useUnwrap({ tokenAddress: \"0x...\" });\n * unwrap.mutate({ amount: 500n });\n * ```\n */\nexport function useUnwrap(\n  config: UseZamaConfig,\n  options?: UseMutationOptions<TransactionResult, Error, UnwrapParams, Address>,\n) {\n  const token = useToken(config);\n\n  return useMutation<TransactionResult, Error, UnwrapParams, Address>({\n    ...unwrapMutationOptions(token),\n    ...options,\n    onSuccess: (data, variables, onMutateResult, context) => {\n      options?.onSuccess?.(data, variables, onMutateResult, context);\n      invalidateAfterUnwrap(context.client, config.tokenAddress);\n    },\n  });\n}\n","\"use client\";\n\nimport type { UseMutationOptions } from \"@tanstack/react-query\";\nimport { useMutation } from \"@tanstack/react-query\";\nimport type { Address, TransactionResult } from \"@zama-fhe/sdk\";\nimport { invalidateAfterUnwrap, unwrapAllMutationOptions } from \"@zama-fhe/sdk/query\";\nimport { useToken, type UseZamaConfig } from \"../token/use-token\";\n\n/**\n * Request an unwrap for the entire confidential balance.\n * Uses the on-chain balance handle directly (no encryption needed).\n * Call {@link useFinalizeUnwrap} after processing, or use {@link useUnshieldAll} for single-call orchestration.\n *\n * Errors are {@link ZamaError} subclasses — use `instanceof` to handle specific failures:\n * - {@link SigningRejectedError} — user rejected the wallet prompt\n * - {@link TransactionRevertedError} — on-chain transaction reverted\n *\n * @param config - Token address (and optional wrapper) identifying the token.\n * @param options - React Query mutation options.\n *\n * @example\n * ```tsx\n * const unwrapAll = useUnwrapAll({ tokenAddress: \"0x...\" });\n * unwrapAll.mutate();\n * ```\n */\nexport function useUnwrapAll(\n  config: UseZamaConfig,\n  options?: UseMutationOptions<TransactionResult, Error, void, Address>,\n) {\n  const token = useToken(config);\n\n  return useMutation<TransactionResult, Error, void, Address>({\n    ...unwrapAllMutationOptions(token),\n    ...options,\n    onSuccess: (data, variables, onMutateResult, context) => {\n      options?.onSuccess?.(data, variables, onMutateResult, context);\n      invalidateAfterUnwrap(context.client, config.tokenAddress);\n    },\n  });\n}\n","\"use client\";\n\nimport type { UseMutationOptions } from \"@tanstack/react-query\";\nimport { useMutation } from \"@tanstack/react-query\";\nimport type { Address, TransactionResult } from \"@zama-fhe/sdk\";\nimport {\n  finalizeUnwrapMutationOptions,\n  invalidateAfterUnshield,\n  type FinalizeUnwrapParams,\n} from \"@zama-fhe/sdk/query\";\nimport { useToken, type UseZamaConfig } from \"../token/use-token\";\n\n/**\n * Complete an unwrap by providing the public decryption proof.\n * Call this after an unwrap request has been processed on-chain.\n *\n * Errors are {@link ZamaError} subclasses — use `instanceof` to handle specific failures:\n * - {@link SigningRejectedError} — user rejected the wallet prompt\n * - {@link DecryptionFailedError} — public decryption of the burn amount failed\n * - {@link TransactionRevertedError} — on-chain finalize transaction reverted\n *\n * @param config - Token address (and optional wrapper) identifying the token.\n * @param options - React Query mutation options.\n *\n * @example\n * ```tsx\n * const finalize = useFinalizeUnwrap({ tokenAddress: \"0x...\" });\n * finalize.mutate({ burnAmountHandle: event.encryptedAmount });\n * ```\n */\nexport function useFinalizeUnwrap(\n  config: UseZamaConfig,\n  options?: UseMutationOptions<TransactionResult, Error, FinalizeUnwrapParams, Address>,\n) {\n  const token = useToken(config);\n\n  return useMutation<TransactionResult, Error, FinalizeUnwrapParams, Address>({\n    ...finalizeUnwrapMutationOptions(token),\n    ...options,\n    onSuccess: (data, variables, onMutateResult, context) => {\n      options?.onSuccess?.(data, variables, onMutateResult, context);\n      invalidateAfterUnshield(context.client, config.tokenAddress);\n    },\n  });\n}\n","\"use client\";\n\nimport type { UseMutationOptions } from \"@tanstack/react-query\";\nimport { useMutation } from \"@tanstack/react-query\";\nimport type { Address, TransactionResult } from \"@zama-fhe/sdk\";\nimport {\n  invalidateAfterUnshield,\n  type UnshieldParams,\n  unshieldMutationOptions,\n} from \"@zama-fhe/sdk/query\";\nimport { useToken, type UseZamaConfig } from \"../token/use-token\";\n\n/**\n * Unshield a specific amount and finalize in one call.\n * Orchestrates: unwrap → wait for receipt → parse event → finalize.\n *\n * Errors are {@link ZamaError} subclasses — use `instanceof` to handle specific failures:\n * - {@link SigningRejectedError} — user rejected the wallet prompt\n * - {@link EncryptionFailedError} — FHE encryption failed during unwrap\n * - {@link DecryptionFailedError} — public decryption failed during finalize\n * - {@link TransactionRevertedError} — on-chain transaction reverted\n *\n * @param config - Token and wrapper addresses.\n * @param options - React Query mutation options.\n *\n * @example\n * ```tsx\n * const unshield = useUnshield({ tokenAddress: \"0x...\", wrapperAddress: \"0x...\" });\n * unshield.mutate({ amount: 500n });\n * ```\n */\nexport function useUnshield(\n  config: UseZamaConfig,\n  options?: UseMutationOptions<TransactionResult, Error, UnshieldParams, Address>,\n) {\n  const token = useToken(config);\n\n  return useMutation<TransactionResult, Error, UnshieldParams, Address>({\n    ...unshieldMutationOptions(token),\n    ...options,\n    onSuccess: (data, variables, onMutateResult, context) => {\n      options?.onSuccess?.(data, variables, onMutateResult, context);\n      invalidateAfterUnshield(context.client, config.tokenAddress);\n    },\n  });\n}\n","\"use client\";\n\nimport type { UseMutationOptions } from \"@tanstack/react-query\";\nimport { useMutation } from \"@tanstack/react-query\";\nimport type { Address, TransactionResult } from \"@zama-fhe/sdk\";\nimport {\n  invalidateAfterUnshield,\n  type UnshieldAllParams,\n  unshieldAllMutationOptions,\n} from \"@zama-fhe/sdk/query\";\nimport { useToken, type UseZamaConfig } from \"../token/use-token\";\n\n/**\n * Unshield the entire balance and finalize in one call.\n * Orchestrates: unwrapAll → wait for receipt → parse event → finalize.\n *\n * Errors are {@link ZamaError} subclasses — use `instanceof` to handle specific failures:\n * - {@link SigningRejectedError} — user rejected the wallet prompt\n * - {@link DecryptionFailedError} — public decryption failed during finalize\n * - {@link TransactionRevertedError} — on-chain transaction reverted\n *\n * @param config - Token and wrapper addresses.\n * @param options - React Query mutation options.\n *\n * @example\n * ```tsx\n * const unshieldAll = useUnshieldAll({ tokenAddress: \"0x...\", wrapperAddress: \"0x...\" });\n * unshieldAll.mutate();\n * ```\n */\nexport function useUnshieldAll(\n  config: UseZamaConfig,\n  options?: UseMutationOptions<TransactionResult, Error, UnshieldAllParams | void, Address>,\n) {\n  const token = useToken(config);\n\n  return useMutation<TransactionResult, Error, UnshieldAllParams | void, Address>({\n    ...unshieldAllMutationOptions(token),\n    ...options,\n    onSuccess: (data, variables, onMutateResult, context) => {\n      options?.onSuccess?.(data, variables, onMutateResult, context);\n      invalidateAfterUnshield(context.client, config.tokenAddress);\n    },\n  });\n}\n","\"use client\";\n\nimport type { UseMutationOptions } from \"@tanstack/react-query\";\nimport { useMutation } from \"@tanstack/react-query\";\nimport type { Address, TransactionResult } from \"@zama-fhe/sdk\";\nimport {\n  invalidateAfterUnshield,\n  type ResumeUnshieldParams,\n  resumeUnshieldMutationOptions,\n} from \"@zama-fhe/sdk/query\";\nimport { useToken, type UseZamaConfig } from \"../token/use-token\";\n\n/**\n * Resume an interrupted unshield from an existing unwrap tx hash.\n * Useful when the user submitted the unwrap but the finalize step was\n * interrupted (e.g. page reload, network error).\n *\n * Errors are {@link ZamaError} subclasses — use `instanceof` to handle specific failures:\n * - {@link DecryptionFailedError} — public decryption failed during finalize\n * - {@link TransactionRevertedError} — on-chain transaction reverted\n *\n * @param config - Token and wrapper addresses.\n * @param options - React Query mutation options.\n *\n * @example\n * ```tsx\n * const resumeUnshield = useResumeUnshield({ tokenAddress: \"0x...\", wrapperAddress: \"0x...\" });\n * resumeUnshield.mutate({ unwrapTxHash: \"0xabc...\" });\n * ```\n */\nexport function useResumeUnshield(\n  config: UseZamaConfig,\n  options?: UseMutationOptions<TransactionResult, Error, ResumeUnshieldParams, Address>,\n) {\n  const token = useToken(config);\n\n  return useMutation<TransactionResult, Error, ResumeUnshieldParams, Address>({\n    ...resumeUnshieldMutationOptions(token),\n    ...options,\n    onSuccess: (data, variables, onMutateResult, context) => {\n      options?.onSuccess?.(data, variables, onMutateResult, context);\n      invalidateAfterUnshield(context.client, config.tokenAddress);\n    },\n  });\n}\n","\"use client\";\n\nimport { useQuery, useSuspenseQuery } from \"../utils/query\";\nimport type { UseQueryOptions } from \"@tanstack/react-query\";\nimport type { Address } from \"@zama-fhe/sdk\";\nimport { signerAddressQueryOptions, underlyingAllowanceQueryOptions } from \"@zama-fhe/sdk/query\";\nimport { useReadonlyToken } from \"../token/use-readonly-token\";\n\nexport { underlyingAllowanceQueryOptions };\n\n/** Configuration for {@link useUnderlyingAllowance}. */\nexport interface UseUnderlyingAllowanceConfig {\n  /** Address of the confidential token contract used to scope the query cache. */\n  tokenAddress: Address;\n  /** Address of the wrapper contract whose underlying ERC-20 allowance is checked. */\n  wrapperAddress: Address;\n}\n\n/**\n * Read the underlying ERC-20 allowance granted to the wrapper contract.\n * Useful to check if an approval is needed before shielding.\n *\n * @param config - Token and wrapper addresses.\n * @param options - React Query options (forwarded to `useQuery`).\n * @returns Query result with `data: bigint` (current allowance).\n *\n * @example\n * ```tsx\n * const { data: allowance } = useUnderlyingAllowance({\n *   tokenAddress: \"0xConfidentialToken\",\n *   wrapperAddress: \"0xWrapper\",\n * });\n * ```\n */\nexport function useUnderlyingAllowance(\n  config: UseUnderlyingAllowanceConfig,\n  options?: Omit<UseQueryOptions<bigint>, \"queryKey\" | \"queryFn\">,\n) {\n  const { tokenAddress, wrapperAddress } = config;\n  const token = useReadonlyToken(tokenAddress);\n  const addressQuery = useQuery<Address>({\n    ...signerAddressQueryOptions(token.signer),\n  });\n  const owner = addressQuery.data;\n\n  const baseOpts = underlyingAllowanceQueryOptions(token.signer, tokenAddress, {\n    owner,\n    wrapperAddress,\n  });\n\n  return useQuery<bigint>({\n    ...baseOpts,\n    ...options,\n    enabled: (baseOpts.enabled ?? true) && (options?.enabled ?? true),\n  });\n}\n\n/**\n * Suspense variant of {@link useUnderlyingAllowance}.\n * Suspends rendering until the allowance is loaded.\n *\n * @param config - Token and wrapper addresses.\n * @returns Suspense query result with `data: bigint`.\n *\n * @example\n * ```tsx\n * const { data: allowance } = useUnderlyingAllowanceSuspense({\n *   tokenAddress: \"0xConfidentialToken\",\n *   wrapperAddress: \"0xWrapper\",\n * });\n * ```\n */\nexport function useUnderlyingAllowanceSuspense(config: UseUnderlyingAllowanceConfig) {\n  const { tokenAddress, wrapperAddress } = config;\n  const token = useReadonlyToken(tokenAddress);\n  const addressQuery = useSuspenseQuery<Address>({\n    ...signerAddressQueryOptions(token.signer),\n  });\n  const owner = addressQuery.data;\n\n  return useSuspenseQuery<bigint>({\n    ...underlyingAllowanceQueryOptions(token.signer, tokenAddress, {\n      owner,\n      wrapperAddress,\n    }),\n  });\n}\n","\"use client\";\n\nimport type { Address } from \"@zama-fhe/sdk\";\nimport { zamaQueryKeys } from \"@zama-fhe/sdk/query\";\nimport { useZamaSDK } from \"../provider\";\nimport { useQuery } from \"../utils/query\";\n\n/**\n * Resolves the wrappers registry address for the current chain.\n * Uses the merged registry addresses from `sdk.registry` (built-in defaults\n * plus any `registryAddresses` overrides passed to `ZamaSDKConfig`).\n *\n * Returns `undefined` when the chain ID hasn't been fetched yet\n * or when no registry is configured for the connected chain.\n *\n * The chain ID is cached for 30 seconds (`staleTime`), so chain\n * switches may take up to 30s to reflect.\n */\nexport function useWrappersRegistryAddress(): Address | undefined {\n  const sdk = useZamaSDK();\n\n  const { data: chainId } = useQuery<number>({\n    queryKey: zamaQueryKeys.wrappersRegistry.chainId(),\n    queryFn: () => sdk.signer.getChainId(),\n    staleTime: 30_000,\n  });\n\n  return chainId !== undefined ? sdk.registry.getAddress(chainId) : undefined;\n}\n","\"use client\";\n\nimport type { UseQueryOptions } from \"@tanstack/react-query\";\nimport type { Address } from \"@zama-fhe/sdk\";\nimport { wrapperDiscoveryQueryOptions } from \"@zama-fhe/sdk/query\";\nimport { useZamaSDK } from \"../provider\";\nimport { useQuery, useSuspenseQuery } from \"../utils/query\";\nimport { useWrappersRegistryAddress } from \"../wrappers-registry/use-wrappers-registry-address\";\n\nexport { wrapperDiscoveryQueryOptions };\n\n/** Configuration for {@link useWrapperDiscovery}. */\nexport interface UseWrapperDiscoveryConfig {\n  /**\n   * Address of any confidential token you control.\n   * Used only to derive the signer context and to scope the query cache key —\n   * it does not affect which wrapper the registry returns.\n   */\n  tokenAddress: Address;\n  /** ERC-20 address to discover the wrapper for. Pass `undefined` to disable the query. */\n  erc20Address: Address | undefined;\n}\n\n/** Configuration for {@link useWrapperDiscoverySuspense}. */\nexport interface UseWrapperDiscoverySuspenseConfig {\n  /**\n   * Address of any confidential token you control.\n   * Used only to derive the signer context and to scope the query cache key —\n   * it does not affect which wrapper the registry returns.\n   */\n  tokenAddress: Address;\n  /** ERC-20 address to discover the wrapper for. */\n  erc20Address: Address;\n}\n\n/**\n * Discover the confidential wrapper for an ERC-20 token via the on-chain registry.\n * Returns the wrapper address if one exists, or `null` if not.\n * Cached indefinitely since wrapper mappings are immutable.\n *\n * @param config - Token and ERC-20 addresses.\n * @param options - React Query options (forwarded to `useQuery`).\n * @returns Query result with `data: Address | null`.\n *\n * @example\n * ```tsx\n * const { data: wrapperAddress } = useWrapperDiscovery({\n *   tokenAddress: \"0xConfidentialToken\",\n *   erc20Address: \"0xUSDC\",\n * });\n * ```\n */\nexport function useWrapperDiscovery(\n  config: UseWrapperDiscoveryConfig,\n  options?: Omit<UseQueryOptions<Address | null>, \"queryKey\" | \"queryFn\">,\n) {\n  const { tokenAddress, erc20Address } = config;\n  const sdk = useZamaSDK();\n  const registryAddress = useWrappersRegistryAddress();\n  const baseOpts = wrapperDiscoveryQueryOptions(sdk.registry, {\n    tokenAddress,\n    erc20Address,\n    registryAddress,\n  });\n\n  return useQuery<Address | null>({\n    ...baseOpts,\n    ...options,\n    enabled: (baseOpts.enabled ?? true) && (options?.enabled ?? true),\n  });\n}\n\n/**\n * Suspense variant of {@link useWrapperDiscovery}.\n * Suspends rendering until the wrapper address is resolved.\n *\n * @param config - Token and ERC-20 addresses.\n * @returns Suspense query result with `data: Address | null`.\n *\n * @example\n * ```tsx\n * const { data: wrapperAddress } = useWrapperDiscoverySuspense({\n *   tokenAddress: \"0xConfidentialToken\",\n *   erc20Address: \"0xUSDC\",\n * });\n * ```\n */\nexport function useWrapperDiscoverySuspense(config: UseWrapperDiscoverySuspenseConfig) {\n  const { tokenAddress, erc20Address } = config;\n  const sdk = useZamaSDK();\n  const registryAddress = useWrappersRegistryAddress();\n\n  return useSuspenseQuery<Address | null>({\n    ...wrapperDiscoveryQueryOptions(sdk.registry, {\n      tokenAddress,\n      erc20Address,\n      registryAddress,\n    }),\n  });\n}\n","\"use client\";\n\nimport { useQuery, useSuspenseQuery } from \"../utils/query\";\nimport type { UseQueryOptions } from \"@tanstack/react-query\";\nimport type { Address } from \"@zama-fhe/sdk\";\nimport { tokenMetadataQueryOptions, type TokenMetadata } from \"@zama-fhe/sdk/query\";\nimport { useReadonlyToken } from \"./use-readonly-token\";\n\nexport { type TokenMetadata };\n\n/**\n * Read ERC-20 token metadata (name, symbol, decimals).\n * Fetches all three in parallel. Cached indefinitely since metadata is immutable.\n *\n * @param tokenAddress - Address of the token contract.\n * @param options - React Query options (forwarded to `useQuery`).\n * @returns Query result with `data: TokenMetadata`.\n *\n * @example\n * ```tsx\n * const { data: metadata } = useMetadata(\"0xToken\");\n * // metadata?.name, metadata?.symbol, metadata?.decimals\n * ```\n */\nexport function useMetadata(\n  tokenAddress: Address,\n  options?: Omit<UseQueryOptions<TokenMetadata>, \"queryKey\" | \"queryFn\">,\n) {\n  const token = useReadonlyToken(tokenAddress);\n\n  return useQuery<TokenMetadata>({\n    ...tokenMetadataQueryOptions(token.signer, tokenAddress),\n    ...options,\n  });\n}\n\n/**\n * Suspense variant of {@link useMetadata}.\n * Suspends rendering until metadata is loaded.\n *\n * @param tokenAddress - Address of the token contract.\n * @returns Suspense query result with `data: TokenMetadata`.\n *\n * @example\n * ```tsx\n * const { data: metadata } = useMetadataSuspense(\"0xToken\");\n * ```\n */\nexport function useMetadataSuspense(tokenAddress: Address) {\n  const token = useReadonlyToken(tokenAddress);\n\n  return useSuspenseQuery<TokenMetadata>({\n    ...tokenMetadataQueryOptions(token.signer, tokenAddress),\n  });\n}\n","\"use client\";\n\nimport { useQuery } from \"../utils/query\";\nimport type { Address, RawLog, ActivityLogMetadata, ActivityItem } from \"@zama-fhe/sdk\";\nimport { activityFeedQueryOptions, deriveActivityFeedLogsKey } from \"@zama-fhe/sdk/query\";\nimport { useReadonlyToken } from \"../token/use-readonly-token\";\n\n/** Configuration for {@link useActivityFeed}. */\nexport interface UseActivityFeedConfig {\n  /** Address of the confidential token contract. */\n  tokenAddress: Address;\n  /** Connected wallet address. Pass `undefined` to disable the query. */\n  userAddress: Address | undefined;\n  /** Raw event logs from the provider (viem, ethers, etc.). Pass `undefined` to disable. */\n  logs: readonly (RawLog & Partial<ActivityLogMetadata>)[] | undefined;\n  /** Whether to batch-decrypt encrypted transfer amounts. Default: `true`. */\n  decrypt?: boolean;\n}\n\n/**\n * Two-phase activity feed hook.\n * Phase 1: Instantly parses raw logs into classified {@link ActivityItem}s (sync, cheap).\n * Phase 2: Batch-decrypts encrypted transfer amounts via the relayer (async).\n *\n * The wallet provides logs (from its own provider — viem, ethers, etc.)\n * and this hook normalizes + decrypts them.\n *\n * @param config - Token address, user address, raw logs, and decrypt option.\n * @returns Query result with `data: ActivityItem[]`.\n *\n * @example\n * ```tsx\n * const { data: activity } = useActivityFeed({\n *   tokenAddress: \"0xToken\",\n *   userAddress: \"0xUser\",\n *   logs: rawLogs,\n * });\n * ```\n */\nexport function useActivityFeed(config: UseActivityFeedConfig) {\n  const { tokenAddress, userAddress, logs, decrypt: decryptOpt } = config;\n  const token = useReadonlyToken(tokenAddress);\n  const decrypt = decryptOpt ?? true;\n  const logsKey = deriveActivityFeedLogsKey(logs);\n\n  return useQuery<ActivityItem[]>({\n    ...activityFeedQueryOptions(token, {\n      userAddress,\n      logs,\n      decrypt,\n      logsKey,\n    }),\n  });\n}\n","\"use client\";\n\nimport { useMutation, type UseMutationOptions } from \"@tanstack/react-query\";\nimport type { TransactionResult } from \"@zama-fhe/sdk\";\nimport {\n  delegateDecryptionMutationOptions,\n  zamaQueryKeys,\n  type DelegateDecryptionParams,\n} from \"@zama-fhe/sdk/query\";\nimport { useToken, type UseZamaConfig } from \"../token/use-token\";\n\n/**\n * Delegate FHE decryption rights for a token to another address via the on-chain ACL.\n *\n * @param config - Token address identifying the confidential token.\n * @param options - React Query mutation options.\n *\n * @example\n * ```tsx\n * const delegate = useDelegateDecryption({ tokenAddress: \"0x...\" });\n * delegate.mutate({ delegateAddress: \"0xDelegate\" });\n * ```\n */\nexport function useDelegateDecryption(\n  config: UseZamaConfig,\n  options?: UseMutationOptions<TransactionResult, Error, DelegateDecryptionParams>,\n) {\n  const token = useToken(config);\n\n  return useMutation<TransactionResult, Error, DelegateDecryptionParams>({\n    ...delegateDecryptionMutationOptions(token),\n    ...options,\n    onSuccess: (data, variables, onMutateResult, context) => {\n      try {\n        options?.onSuccess?.(data, variables, onMutateResult, context);\n      } finally {\n        void context.client.invalidateQueries({ queryKey: zamaQueryKeys.delegationStatus.all });\n      }\n    },\n  });\n}\n","\"use client\";\n\nimport { useMutation, type UseMutationOptions } from \"@tanstack/react-query\";\nimport type { TransactionResult } from \"@zama-fhe/sdk\";\nimport {\n  revokeDelegationMutationOptions,\n  zamaQueryKeys,\n  type RevokeDelegationParams,\n} from \"@zama-fhe/sdk/query\";\nimport { useToken, type UseZamaConfig } from \"../token/use-token\";\n\n/**\n * Revoke FHE decryption delegation for a token from a delegate address.\n *\n * @param config - Token address identifying the confidential token.\n * @param options - React Query mutation options.\n *\n * @example\n * ```tsx\n * const revoke = useRevokeDelegation({ tokenAddress: \"0x...\" });\n * revoke.mutate({ delegateAddress: \"0xDelegate\" });\n * ```\n */\nexport function useRevokeDelegation(\n  config: UseZamaConfig,\n  options?: UseMutationOptions<TransactionResult, Error, RevokeDelegationParams>,\n) {\n  const token = useToken(config);\n\n  return useMutation<TransactionResult, Error, RevokeDelegationParams>({\n    ...revokeDelegationMutationOptions(token),\n    ...options,\n    onSuccess: (data, variables, onMutateResult, context) => {\n      try {\n        options?.onSuccess?.(data, variables, onMutateResult, context);\n      } finally {\n        void context.client.invalidateQueries({ queryKey: zamaQueryKeys.delegationStatus.all });\n      }\n    },\n  });\n}\n","\"use client\";\n\nimport type { UseQueryOptions } from \"@tanstack/react-query\";\nimport type { Address } from \"@zama-fhe/sdk\";\nimport { delegationStatusQueryOptions, type DelegationStatusData } from \"@zama-fhe/sdk/query\";\nimport { useQuery } from \"../utils/query\";\nimport { useZamaSDK } from \"../provider\";\n\nexport interface UseDelegationStatusConfig {\n  /** Address of the confidential token contract. Pass `undefined` to disable the query. */\n  tokenAddress: Address | undefined;\n  /** The address that granted the delegation. */\n  delegatorAddress?: Address;\n  /** The address that received delegation rights. */\n  delegateAddress?: Address;\n}\n\n/**\n * Query delegation status between a delegator and delegate for a token.\n *\n * @param config - Token address, delegator, and delegate addresses.\n * @param options - React Query options (forwarded to `useQuery`).\n * @returns `{ isDelegated, expiryTimestamp, isLoading, error }`.\n *\n * @example\n * ```tsx\n * const { data } = useDelegationStatus({\n *   tokenAddress: \"0xToken\",\n *   delegatorAddress: \"0xDelegator\",\n *   delegateAddress: \"0xDelegate\",\n * });\n * // data?.isDelegated, data?.expiryTimestamp\n * ```\n */\nexport function useDelegationStatus(\n  config: UseDelegationStatusConfig,\n  options?: Omit<UseQueryOptions<DelegationStatusData>, \"queryKey\" | \"queryFn\">,\n) {\n  const sdk = useZamaSDK();\n  const baseOpts = delegationStatusQueryOptions(sdk, {\n    tokenAddress: config.tokenAddress,\n    delegatorAddress: config.delegatorAddress,\n    delegateAddress: config.delegateAddress,\n  });\n\n  return useQuery<DelegationStatusData>({\n    ...baseOpts,\n    ...options,\n    enabled: (baseOpts.enabled ?? true) && (options?.enabled ?? true),\n  });\n}\n","\"use client\";\n\nimport { useMutation, type UseMutationOptions } from \"@tanstack/react-query\";\nimport type { Address } from \"@zama-fhe/sdk\";\nimport { decryptBalanceAsMutationOptions, type DecryptBalanceAsParams } from \"@zama-fhe/sdk/query\";\nimport { useReadonlyToken } from \"../token/use-readonly-token\";\n\n/**\n * Decrypt another user's confidential balance as a delegate.\n *\n * @param tokenAddress - Address of the confidential token contract.\n * @param options - React Query mutation options.\n *\n * @example\n * ```tsx\n * const decryptAs = useDecryptBalanceAs(\"0xToken\");\n * decryptAs.mutate({ delegatorAddress: \"0xDelegator\" });\n * // decryptAs.data => 1000n\n * ```\n */\nexport function useDecryptBalanceAs(\n  tokenAddress: Address,\n  options?: UseMutationOptions<bigint, Error, DecryptBalanceAsParams>,\n) {\n  const readonlyToken = useReadonlyToken(tokenAddress);\n\n  return useMutation<bigint, Error, DecryptBalanceAsParams>({\n    ...decryptBalanceAsMutationOptions(readonlyToken),\n    ...options,\n  });\n}\n","\"use client\";\n\nimport { useMutation, type UseMutationOptions } from \"@tanstack/react-query\";\nimport { ReadonlyToken, type Address, type BatchDecryptAsOptions } from \"@zama-fhe/sdk\";\n\n/**\n * Batch decrypt confidential balances as a delegate across multiple tokens.\n *\n * @param tokens - ReadonlyToken instances to decrypt balances for.\n * @param options - React Query mutation options.\n *\n * @example\n * ```tsx\n * const batchDecryptAs = useBatchDecryptBalancesAs(tokens);\n * batchDecryptAs.mutate({\n *   delegatorAddress: \"0xDelegator\",\n * });\n * // batchDecryptAs.data => Map { \"0xTokenA\" => 100n, \"0xTokenB\" => 200n }\n * ```\n */\nexport function useBatchDecryptBalancesAs(\n  tokens: ReadonlyToken[],\n  options?: UseMutationOptions<Map<Address, bigint>, Error, BatchDecryptAsOptions>,\n) {\n  return useMutation<Map<Address, bigint>, Error, BatchDecryptAsOptions>({\n    mutationKey: [\"zama.batchDecryptBalancesAs\", ...tokens.map((t) => t.address)] as const,\n    mutationFn: async (params) => ReadonlyToken.batchDecryptBalancesAs(tokens, params),\n    ...options,\n  });\n}\n","\"use client\";\n\nimport type { UseMutationOptions } from \"@tanstack/react-query\";\nimport { useMutation } from \"@tanstack/react-query\";\nimport type { Address, TransactionResult } from \"@zama-fhe/sdk\";\nimport {\n  approveUnderlyingMutationOptions,\n  invalidateAfterApproveUnderlying,\n  type ApproveUnderlyingParams,\n} from \"@zama-fhe/sdk/query\";\nimport { useToken, type UseZamaConfig } from \"../token/use-token\";\n\n/**\n * Approve the wrapper contract to spend the underlying ERC-20.\n * Defaults to max uint256. Resets to zero first if there's an existing\n * non-zero allowance (required by tokens like USDT).\n *\n * Errors are {@link ZamaError} subclasses — use `instanceof` to handle specific failures:\n * - {@link SigningRejectedError} — user rejected the wallet prompt\n * - {@link TransactionRevertedError} — approval transaction reverted\n *\n * @param config - Token and wrapper addresses.\n * @param options - React Query mutation options.\n *\n * @example\n * ```tsx\n * const approve = useApproveUnderlying({ tokenAddress: \"0x...\", wrapperAddress: \"0x...\" });\n * approve.mutate({}); // max approval\n * approve.mutate({ amount: 1000n }); // exact amount\n * ```\n */\nexport function useApproveUnderlying(\n  config: UseZamaConfig,\n  options?: UseMutationOptions<TransactionResult, Error, ApproveUnderlyingParams, Address>,\n) {\n  const token = useToken(config);\n\n  return useMutation<TransactionResult, Error, ApproveUnderlyingParams, Address>({\n    ...approveUnderlyingMutationOptions(token),\n    ...options,\n    onSuccess: (data, variables, onMutateResult, context) => {\n      options?.onSuccess?.(data, variables, onMutateResult, context);\n      invalidateAfterApproveUnderlying(context.client, config.tokenAddress);\n    },\n  });\n}\n","\"use client\";\n\nimport { useQuery, useSuspenseQuery } from \"../utils/query\";\nimport type { UseQueryOptions } from \"@tanstack/react-query\";\nimport type { Address } from \"@zama-fhe/sdk\";\nimport { isConfidentialQueryOptions, isWrapperQueryOptions } from \"@zama-fhe/sdk/query\";\nimport { useReadonlyToken } from \"./use-readonly-token\";\n\nexport { isConfidentialQueryOptions, isWrapperQueryOptions };\n\n/**\n * Check if a token supports the ERC-7984 confidential interface via ERC-165.\n * Result is cached indefinitely since interface support does not change.\n *\n * @param tokenAddress - Address of the token contract to check.\n * @param options - React Query options (forwarded to `useQuery`).\n * @returns Query result with `data: boolean`.\n *\n * @example\n * ```tsx\n * const { data: isConfidential } = useIsConfidential(\"0xToken\");\n * ```\n */\nexport function useIsConfidential(\n  tokenAddress: Address,\n  options?: Omit<UseQueryOptions<boolean>, \"queryKey\" | \"queryFn\">,\n) {\n  const token = useReadonlyToken(tokenAddress);\n\n  return useQuery<boolean>({\n    ...isConfidentialQueryOptions(token.signer, tokenAddress),\n    ...options,\n  });\n}\n\n/**\n * Suspense variant of {@link useIsConfidential}.\n * Suspends rendering until the ERC-165 check resolves.\n *\n * @param tokenAddress - Address of the token contract to check.\n * @returns Suspense query result with `data: boolean`.\n *\n * @example\n * ```tsx\n * const { data: isConfidential } = useIsConfidentialSuspense(\"0xToken\");\n * ```\n */\nexport function useIsConfidentialSuspense(tokenAddress: Address) {\n  const token = useReadonlyToken(tokenAddress);\n\n  return useSuspenseQuery<boolean>({\n    ...isConfidentialQueryOptions(token.signer, tokenAddress),\n  });\n}\n\n/**\n * Check if a token supports the ERC-7984 wrapper interface via ERC-165.\n * Result is cached indefinitely since interface support does not change.\n *\n * @param tokenAddress - Address of the token contract to check.\n * @param options - React Query options (forwarded to `useQuery`).\n * @returns Query result with `data: boolean`.\n *\n * @example\n * ```tsx\n * const { data: isWrapper } = useIsWrapper(\"0xToken\");\n * ```\n */\nexport function useIsWrapper(\n  tokenAddress: Address,\n  options?: Omit<UseQueryOptions<boolean>, \"queryKey\" | \"queryFn\">,\n) {\n  const token = useReadonlyToken(tokenAddress);\n\n  return useQuery<boolean>({\n    ...isWrapperQueryOptions(token.signer, tokenAddress),\n    ...options,\n  });\n}\n\n/**\n * Suspense variant of {@link useIsWrapper}.\n * Suspends rendering until the ERC-165 check resolves.\n *\n * @param tokenAddress - Address of the token contract to check.\n * @returns Suspense query result with `data: boolean`.\n *\n * @example\n * ```tsx\n * const { data: isWrapper } = useIsWrapperSuspense(\"0xToken\");\n * ```\n */\nexport function useIsWrapperSuspense(tokenAddress: Address) {\n  const token = useReadonlyToken(tokenAddress);\n\n  return useSuspenseQuery<boolean>({\n    ...isWrapperQueryOptions(token.signer, tokenAddress),\n  });\n}\n","\"use client\";\n\nimport { useQuery, useSuspenseQuery } from \"../utils/query\";\nimport type { UseQueryOptions } from \"@tanstack/react-query\";\nimport type { Address } from \"@zama-fhe/sdk\";\nimport { totalSupplyQueryOptions } from \"@zama-fhe/sdk/query\";\nimport { useReadonlyToken } from \"./use-readonly-token\";\n\nexport { totalSupplyQueryOptions };\n\n/**\n * Read the total supply of a token.\n * Stale after 30 seconds to balance freshness and RPC cost.\n *\n * @param tokenAddress - Address of the token contract.\n * @param options - React Query options (forwarded to `useQuery`).\n * @returns Query result with `data: bigint`.\n *\n * @example\n * ```tsx\n * const { data: totalSupply } = useTotalSupply(\"0xToken\");\n * ```\n */\nexport function useTotalSupply(\n  tokenAddress: Address,\n  options?: Omit<UseQueryOptions<bigint>, \"queryKey\" | \"queryFn\">,\n) {\n  const token = useReadonlyToken(tokenAddress);\n\n  return useQuery<bigint>({\n    ...totalSupplyQueryOptions(token.signer, tokenAddress),\n    ...options,\n  });\n}\n\n/**\n * Suspense variant of {@link useTotalSupply}.\n * Suspends rendering until the total supply is loaded.\n *\n * @param tokenAddress - Address of the token contract.\n * @returns Suspense query result with `data: bigint`.\n *\n * @example\n * ```tsx\n * const { data: totalSupply } = useTotalSupplySuspense(\"0xToken\");\n * ```\n */\nexport function useTotalSupplySuspense(tokenAddress: Address) {\n  const token = useReadonlyToken(tokenAddress);\n\n  return useSuspenseQuery<bigint>({\n    ...totalSupplyQueryOptions(token.signer, tokenAddress),\n  });\n}\n","\"use client\";\n\nimport { useQuery } from \"../utils/query\";\nimport type { UseQueryOptions } from \"@tanstack/react-query\";\nimport type { Address } from \"@zama-fhe/sdk\";\nimport {\n  batchTransferFeeQueryOptions,\n  feeRecipientQueryOptions,\n  shieldFeeQueryOptions,\n  unshieldFeeQueryOptions,\n} from \"@zama-fhe/sdk/query\";\nimport { useZamaSDK } from \"../provider\";\n\nexport {\n  batchTransferFeeQueryOptions,\n  feeRecipientQueryOptions,\n  shieldFeeQueryOptions,\n  unshieldFeeQueryOptions,\n};\n\n/** Configuration for {@link useShieldFee} and {@link useUnshieldFee}. */\nexport interface UseFeeConfig {\n  /** Address of the fee manager contract. */\n  feeManagerAddress: Address;\n  /** Amount to calculate the fee for. */\n  amount: bigint;\n  /** Sender address. */\n  from: Address;\n  /** Receiver address. */\n  to: Address;\n}\n\n/**\n * Read the shield fee for a given amount and address pair.\n *\n * @param config - Fee manager address, amount, from, and to.\n * @param options - React Query options (forwarded to `useQuery`).\n * @returns Query result with `data: bigint` (the fee amount).\n *\n * @example\n * ```tsx\n * const { data: fee } = useShieldFee({\n *   feeManagerAddress: \"0xFeeManager\",\n *   amount: 1000n,\n *   from: \"0xSender\",\n *   to: \"0xReceiver\",\n * });\n * ```\n */\nexport function useShieldFee(\n  config: UseFeeConfig,\n  options?: Omit<UseQueryOptions<bigint>, \"queryKey\" | \"queryFn\">,\n) {\n  const sdk = useZamaSDK();\n  const baseOpts = shieldFeeQueryOptions(sdk.signer, config);\n\n  return useQuery<bigint>({\n    ...baseOpts,\n    ...options,\n    enabled: (baseOpts.enabled ?? true) && (options?.enabled ?? true),\n  });\n}\n\n/**\n * Read the unshield fee for a given amount and address pair.\n *\n * @param config - Fee manager address, amount, from, and to.\n * @param options - React Query options (forwarded to `useQuery`).\n * @returns Query result with `data: bigint` (the fee amount).\n *\n * @example\n * ```tsx\n * const { data: fee } = useUnshieldFee({\n *   feeManagerAddress: \"0xFeeManager\",\n *   amount: 1000n,\n *   from: \"0xSender\",\n *   to: \"0xReceiver\",\n * });\n * ```\n */\nexport function useUnshieldFee(\n  config: UseFeeConfig,\n  options?: Omit<UseQueryOptions<bigint>, \"queryKey\" | \"queryFn\">,\n) {\n  const sdk = useZamaSDK();\n  const baseOpts = unshieldFeeQueryOptions(sdk.signer, config);\n\n  return useQuery<bigint>({\n    ...baseOpts,\n    ...options,\n    enabled: (baseOpts.enabled ?? true) && (options?.enabled ?? true),\n  });\n}\n\n/**\n * Read the batch transfer fee from the fee manager.\n *\n * @param feeManagerAddress - Address of the fee manager contract.\n * @param options - React Query options (forwarded to `useQuery`).\n * @returns Query result with `data: bigint` (the fee amount).\n *\n * @example\n * ```tsx\n * const { data: fee } = useBatchTransferFee(\"0xFeeManager\");\n * ```\n */\nexport function useBatchTransferFee(\n  feeManagerAddress: Address,\n  options?: Omit<UseQueryOptions<bigint>, \"queryKey\" | \"queryFn\">,\n) {\n  const sdk = useZamaSDK();\n  const baseOpts = batchTransferFeeQueryOptions(sdk.signer, feeManagerAddress);\n\n  return useQuery<bigint>({\n    ...baseOpts,\n    ...options,\n    enabled: (baseOpts.enabled ?? true) && (options?.enabled ?? true),\n  });\n}\n\n/**\n * Read the fee recipient address from the fee manager.\n *\n * @param feeManagerAddress - Address of the fee manager contract.\n * @param options - React Query options (forwarded to `useQuery`).\n * @returns Query result with `data: Address` (the fee recipient).\n *\n * @example\n * ```tsx\n * const { data: recipient } = useFeeRecipient(\"0xFeeManager\");\n * ```\n */\nexport function useFeeRecipient(\n  feeManagerAddress: Address,\n  options?: Omit<UseQueryOptions<Address>, \"queryKey\" | \"queryFn\">,\n) {\n  const sdk = useZamaSDK();\n  const baseOpts = feeRecipientQueryOptions(sdk.signer, feeManagerAddress);\n\n  return useQuery<Address>({\n    ...baseOpts,\n    ...options,\n    enabled: (baseOpts.enabled ?? true) && (options?.enabled ?? true),\n  });\n}\n","\"use client\";\n\nimport type { TokenWrapperPair } from \"@zama-fhe/sdk\";\nimport { tokenPairsQueryOptions } from \"@zama-fhe/sdk/query\";\nimport { useZamaSDK } from \"../provider\";\nimport { useQuery } from \"../utils/query\";\nimport { useWrappersRegistryAddress } from \"./use-wrappers-registry-address\";\n\n/**\n * Fetches all token wrapper pairs from the ConfidentialTokenWrappersRegistry\n * contract on the current chain.\n */\nexport function useTokenPairsRegistry() {\n  const sdk = useZamaSDK();\n  const registryAddress = useWrappersRegistryAddress();\n\n  return useQuery<readonly TokenWrapperPair[]>(\n    tokenPairsQueryOptions(sdk.signer, {\n      registryAddress,\n    }),\n  );\n}\n","\"use client\";\n\nimport { tokenPairsLengthQueryOptions } from \"@zama-fhe/sdk/query\";\nimport { useZamaSDK } from \"../provider\";\nimport { useQuery } from \"../utils/query\";\nimport { useWrappersRegistryAddress } from \"./use-wrappers-registry-address\";\n\n/**\n * Returns the total number of token wrapper pairs in the registry.\n */\nexport function useTokenPairsLength() {\n  const sdk = useZamaSDK();\n  const registryAddress = useWrappersRegistryAddress();\n\n  return useQuery<bigint>(\n    tokenPairsLengthQueryOptions(sdk.signer, {\n      registryAddress,\n    }),\n  );\n}\n","\"use client\";\n\nimport type { TokenWrapperPair } from \"@zama-fhe/sdk\";\nimport { tokenPairsSliceQueryOptions } from \"@zama-fhe/sdk/query\";\nimport { useZamaSDK } from \"../provider\";\nimport { useQuery } from \"../utils/query\";\nimport { useWrappersRegistryAddress } from \"./use-wrappers-registry-address\";\n\n/**\n * Fetches a range of token wrapper pairs from the registry (paginated).\n *\n * @param fromIndex - Start index (inclusive). Pass `undefined` to disable.\n * @param toIndex - End index (exclusive). Pass `undefined` to disable.\n */\nexport function useTokenPairsSlice({\n  fromIndex,\n  toIndex,\n}: {\n  fromIndex: bigint | undefined;\n  toIndex: bigint | undefined;\n}) {\n  const sdk = useZamaSDK();\n  const registryAddress = useWrappersRegistryAddress();\n\n  return useQuery<readonly TokenWrapperPair[]>(\n    tokenPairsSliceQueryOptions(sdk.signer, {\n      registryAddress,\n      fromIndex,\n      toIndex,\n    }),\n  );\n}\n","\"use client\";\n\nimport type { TokenWrapperPair } from \"@zama-fhe/sdk\";\nimport { tokenPairQueryOptions } from \"@zama-fhe/sdk/query\";\nimport { useZamaSDK } from \"../provider\";\nimport { useQuery } from \"../utils/query\";\nimport { useWrappersRegistryAddress } from \"./use-wrappers-registry-address\";\n\n/**\n * Fetches a single token wrapper pair by index from the registry.\n *\n * @param index - Zero-based pair index. Pass `undefined` to disable.\n */\nexport function useTokenPair({ index }: { index: bigint | undefined }) {\n  const sdk = useZamaSDK();\n  const registryAddress = useWrappersRegistryAddress();\n\n  return useQuery<TokenWrapperPair>(\n    tokenPairQueryOptions(sdk.signer, {\n      registryAddress,\n      index,\n    }),\n  );\n}\n","\"use client\";\n\nimport type { Address } from \"@zama-fhe/sdk\";\nimport { confidentialTokenAddressQueryOptions } from \"@zama-fhe/sdk/query\";\nimport { useZamaSDK } from \"../provider\";\nimport { useQuery } from \"../utils/query\";\nimport { useWrappersRegistryAddress } from \"./use-wrappers-registry-address\";\n\n/**\n * Looks up the confidential token address for a given plain token address.\n */\nexport function useConfidentialTokenAddress({\n  tokenAddress,\n}: {\n  tokenAddress: Address | undefined;\n}) {\n  const sdk = useZamaSDK();\n  const registryAddress = useWrappersRegistryAddress();\n\n  return useQuery<readonly [boolean, Address]>(\n    confidentialTokenAddressQueryOptions(sdk.signer, {\n      registryAddress,\n      tokenAddress,\n    }),\n  );\n}\n","\"use client\";\n\nimport type { Address } from \"@zama-fhe/sdk\";\nimport { tokenAddressQueryOptions } from \"@zama-fhe/sdk/query\";\nimport { useZamaSDK } from \"../provider\";\nimport { useQuery } from \"../utils/query\";\nimport { useWrappersRegistryAddress } from \"./use-wrappers-registry-address\";\n\n/**\n * Looks up the plain token address for a given confidential token address.\n */\nexport function useTokenAddress({\n  confidentialTokenAddress,\n}: {\n  confidentialTokenAddress: Address | undefined;\n}) {\n  const sdk = useZamaSDK();\n  const registryAddress = useWrappersRegistryAddress();\n\n  return useQuery<readonly [boolean, Address]>(\n    tokenAddressQueryOptions(sdk.signer, {\n      registryAddress,\n      confidentialTokenAddress,\n    }),\n  );\n}\n","\"use client\";\n\nimport type { Address } from \"@zama-fhe/sdk\";\nimport { isConfidentialTokenValidQueryOptions } from \"@zama-fhe/sdk/query\";\nimport { useZamaSDK } from \"../provider\";\nimport { useQuery } from \"../utils/query\";\nimport { useWrappersRegistryAddress } from \"./use-wrappers-registry-address\";\n\n/**\n * Checks whether a confidential token is registered and valid in the\n * on-chain wrappers registry.\n *\n * @param confidentialTokenAddress - The confidential token to check. Pass `undefined` to disable.\n */\nexport function useIsConfidentialTokenValid({\n  confidentialTokenAddress,\n}: {\n  confidentialTokenAddress: Address | undefined;\n}) {\n  const sdk = useZamaSDK();\n  const registryAddress = useWrappersRegistryAddress();\n\n  return useQuery<boolean>(\n    isConfidentialTokenValidQueryOptions(sdk.signer, {\n      registryAddress,\n      confidentialTokenAddress,\n    }),\n  );\n}\n","\"use client\";\n\nimport type {\n  TokenWrapperPair,\n  TokenWrapperPairWithMetadata,\n  PaginatedResult,\n} from \"@zama-fhe/sdk\";\nimport { listPairsQueryOptions } from \"@zama-fhe/sdk/query\";\nimport { useZamaSDK } from \"../provider\";\nimport { useQuery } from \"../utils/query\";\nimport { useWrappersRegistryAddress } from \"./use-wrappers-registry-address\";\n\n/**\n * Fetches paginated token wrapper pairs from the registry.\n *\n * @param options - Query options: `page` (1-indexed, default `1`), `pageSize` (default `100`), `metadata` (fetch on-chain metadata for both tokens, default `false`).\n *\n * @example\n * ```tsx\n * const { data, isLoading } = useListPairs({ page: 1, pageSize: 20 });\n * if (data) {\n *   console.log(`${data.total} pairs, showing page ${data.page}`);\n * }\n * ```\n */\nexport function useListPairs({\n  page = 1,\n  pageSize = 100,\n  metadata = false,\n}: {\n  page?: number;\n  pageSize?: number;\n  metadata?: boolean;\n} = {}) {\n  const sdk = useZamaSDK();\n  const registryAddress = useWrappersRegistryAddress();\n\n  // Pass sdk.registry (a lazy singleton) so the class-level TTL cache is shared\n  // across all queryFn executions — rather than constructing a new instance each time.\n  return useQuery<PaginatedResult<TokenWrapperPair | TokenWrapperPairWithMetadata>>(\n    listPairsQueryOptions(sdk.registry, {\n      registryAddress,\n      page,\n      pageSize,\n      metadata,\n    }),\n  );\n}\n"],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zama-fhe/react-sdk",
-  "version": "2.3.0-alpha.3",
+  "version": "2.3.0",
   "description": "React hooks for Zama SDK",
   "license": "BSD-3-Clause-Clear",
   "author": "Zama",
@@ -59,7 +59,7 @@
   },
   "peerDependencies": {
     "@tanstack/react-query": ">=5",
-    "@zama-fhe/sdk": "^2.3.0-alpha.3",
+    "@zama-fhe/sdk": "^2.3.0",
     "react": ">=18",
     "viem": "^2.47.0",
     "wagmi": ">=2"